Auto merge of rust-lang#105365 - matthiaskrgr:rollup-g0mrrt7, r=matth…

…iaskrgr

Rollup of 11 pull requests

Successful merges:

 - rust-lang#104439 (Add prototype to generate `COPYRIGHT` from REUSE metadata)
 - rust-lang#105005 (On E0195 point at where clause lifetime bounds)
 - rust-lang#105098 (propagate the error from parsing enum variant to the parser and emit out)
 - rust-lang#105243 (remove no-op 'let _ = ')
 - rust-lang#105254 (Recurse into nested impl-trait when computing variance.)
 - rust-lang#105287 (Synthesize substitutions for bad auto traits in dyn types)
 - rust-lang#105310 (Be more careful about unresolved exprs in suggestion)
 - rust-lang#105318 (Make `get_impl_future_output_ty` work with AFIT)
 - rust-lang#105339 (support `ConstKind::Expr` in `is_const_evaluatable` and `WfPredicates::compute`)
 - rust-lang#105340 (Avoid ICE by accounting for missing type)
 - rust-lang#105342 (Make `note_obligation_cause_code`  take a `impl ToPredicate` for predicate)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

Cargo.lock

@@ -581,6 +581,7 @@ dependencies = [
  "libc",
  "num-integer",
  "num-traits",
+ "serde",
  "time",
  "winapi",
 ]
@@ -730,6 +731,16 @@ dependencies = [
  "rustc-semver",
 ]
 
+[[package]]
+name = "collect-license-metadata"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "serde",
+ "serde_json",
+ "spdx-rs",
+]
+
 [[package]]
 name = "color-eyre"
 version = "0.6.2"
@@ -1552,6 +1563,15 @@ dependencies = [
  "termcolor",
 ]
 
+[[package]]
+name = "generate-copyright"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.4"
@@ -4864,6 +4884,35 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "spdx-expression"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d7ac03c67c572d85049d6db815e20a4a19b41b3d5cca732ac582342021ad77"
+dependencies = [
+ "nom",
+ "serde",
+ "thiserror",
+ "tracing",
+]
+
+[[package]]
+name = "spdx-rs"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3c02f6eb7e7b4100c272f685a9ccaccaab302324e8c7ec3e2ee72340fb29ff3"
+dependencies = [
+ "chrono",
+ "log",
+ "nom",
+ "serde",
+ "spdx-expression",
+ "strum",
+ "strum_macros",
+ "thiserror",
+ "uuid",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
@@ -4967,6 +5016,25 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
+[[package]]
+name = "strum"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+
+[[package]]
+name = "strum_macros"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.102"
@@ -5596,6 +5664,15 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8772a4ccbb4e89959023bc5b7cb8623a795caa7092d99f3aa9501b9484d4557d"
 
+[[package]]
+name = "uuid"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
+dependencies = [
+ "getrandom 0.2.0",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.0"

Cargo.toml

@@ -39,6 +39,8 @@ members = [
  "src/tools/bump-stage0",
  "src/tools/replace-version-placeholder",
  "src/tools/lld-wrapper",
+ "src/tools/collect-license-metadata",
+ "src/tools/generate-copyright",
 ]
 
 exclude = [

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -121,9 +121,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
  pub(super) fn prove_predicates(
  &mut self,
- predicates: impl IntoIterator<
- Item = impl ToPredicate<'tcx, ty::Predicate<'tcx>> + std::fmt::Debug,
- >,
+ predicates: impl IntoIterator<Item = impl ToPredicate<'tcx> + std::fmt::Debug>,
  locations: Locations,
  category: ConstraintCategory<'tcx>,
  ) {
@@ -135,7 +133,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  #[instrument(skip(self), level = "debug")]
  pub(super) fn prove_predicate(
  &mut self,
- predicate: impl ToPredicate<'tcx, ty::Predicate<'tcx>> + std::fmt::Debug,
+ predicate: impl ToPredicate<'tcx> + std::fmt::Debug,
  locations: Locations,
  category: ConstraintCategory<'tcx>,
  ) {

compiler/rustc_error_messages/locales/en-US/hir_analysis.ftl

@@ -17,6 +17,8 @@ hir_analysis_lifetimes_or_bounds_mismatch_on_trait =
  lifetime parameters or bounds on {$item_kind} `{$ident}` do not match the trait declaration
  .label = lifetimes do not match {$item_kind} in trait
  .generics_label = lifetimes in impl do not match this {$item_kind} in trait
+ .where_label = this `where` clause might not match the one in the trait
+ .bounds_label = this bound might be missing in the impl
 
 hir_analysis_drop_impl_on_wrong_item =
  the `Drop` trait may only be implemented for local structs, enums, and unions

compiler/rustc_hir_analysis/src/check/compare_method.rs

@@ -751,27 +751,56 @@ fn check_region_bounds_on_impl_item<'tcx>(
  .get_generics(impl_m.def_id.expect_local())
  .expect("expected impl item to have generics or else we can't compare them")
  .span;
- let generics_span = if let Some(local_def_id) = trait_m.def_id.as_local() {
- Some(
- tcx.hir()
- .get_generics(local_def_id)
- .expect("expected trait item to have generics or else we can't compare them")
- .span,
- )
- } else {
- None
- };
 
+ let mut generics_span = None;
+ let mut bounds_span = vec![];
+ let mut where_span = None;
+ if let Some(trait_node) = tcx.hir().get_if_local(trait_m.def_id)
+ && let Some(trait_generics) = trait_node.generics()
+ {
+ generics_span = Some(trait_generics.span);
+ // FIXME: we could potentially look at the impl's bounds to not point at bounds that
+ // *are* present in the impl.
+ for p in trait_generics.predicates {
+ if let hir::WherePredicate::BoundPredicate(pred) = p {
+ for b in pred.bounds {
+ if let hir::GenericBound::Outlives(lt) = b {
+ bounds_span.push(lt.ident.span);
+ }
+ }
+ }
+ }
+ if let Some(impl_node) = tcx.hir().get_if_local(impl_m.def_id)
+ && let Some(impl_generics) = impl_node.generics()
+ {
+ let mut impl_bounds = 0;
+ for p in impl_generics.predicates {
+ if let hir::WherePredicate::BoundPredicate(pred) = p {
+ for b in pred.bounds {
+ if let hir::GenericBound::Outlives(_) = b {
+ impl_bounds += 1;
+ }
+ }
+ }
+ }
+ if impl_bounds == bounds_span.len() {
+ bounds_span = vec![];
+ } else if impl_generics.has_where_clause_predicates {
+ where_span = Some(impl_generics.where_clause_span);
+ }
+ }
+ }
  let reported = tcx
  .sess
  .create_err(LifetimesOrBoundsMismatchOnTrait {
  span,
  item_kind: assoc_item_kind_str(impl_m),
  ident: impl_m.ident(tcx),
  generics_span,
+ bounds_span,
+ where_span,
  })
  .emit_unless(delay);
-
  return Err(reported);
  }
 

compiler/rustc_hir_analysis/src/errors.rs

@@ -43,6 +43,10 @@ pub struct LifetimesOrBoundsMismatchOnTrait {
  pub span: Span,
  #[label(generics_label)]
  pub generics_span: Option<Span>,
+ #[label(where_label)]
+ pub where_span: Option<Span>,
+ #[label(bounds_label)]
+ pub bounds_span: Vec<Span>,
  pub item_kind: &'static str,
  pub ident: Ident,
 }

compiler/rustc_hir_analysis/src/variance/mod.rs

@@ -7,7 +7,8 @@ use rustc_arena::DroplessArena;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::ty::query::Providers;
-use rustc_middle::ty::{self, CrateVariancesMap, TyCtxt, TypeSuperVisitable, TypeVisitable};
+use rustc_middle::ty::{self, CrateVariancesMap, SubstsRef, Ty, TyCtxt};
+use rustc_middle::ty::{DefIdTree, TypeSuperVisitable, TypeVisitable};
 use std::ops::ControlFlow;
 
 /// Defines the `TermsContext` basically houses an arena where we can
@@ -75,18 +76,50 @@ fn variance_of_opaque(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Varianc
  // type Foo<'a, 'b, 'c> = impl Trait<'a> + 'b;
  // ```
  // we may not use `'c` in the hidden type.
- struct OpaqueTypeLifetimeCollector {
+ struct OpaqueTypeLifetimeCollector<'tcx> {
+ tcx: TyCtxt<'tcx>,
+ root_def_id: DefId,
  variances: Vec<ty::Variance>,
  }
 
- impl<'tcx> ty::TypeVisitor<'tcx> for OpaqueTypeLifetimeCollector {
+ impl<'tcx> OpaqueTypeLifetimeCollector<'tcx> {
+ #[instrument(level = "trace", skip(self), ret)]
+ fn visit_opaque(&mut self, def_id: DefId, substs: SubstsRef<'tcx>) -> ControlFlow<!> {
+ if def_id != self.root_def_id && self.tcx.is_descendant_of(def_id, self.root_def_id) {
+ let child_variances = self.tcx.variances_of(def_id);
+ for (a, v) in substs.iter().zip(child_variances) {
+ if *v != ty::Bivariant {
+ a.visit_with(self)?;
+ }
+ }
+ ControlFlow::CONTINUE
+ } else {
+ substs.visit_with(self)
+ }
+ }
+ }
+
+ impl<'tcx> ty::TypeVisitor<'tcx> for OpaqueTypeLifetimeCollector<'tcx> {
  #[instrument(level = "trace", skip(self), ret)]
  fn visit_region(&mut self, r: ty::Region<'tcx>) -> ControlFlow<Self::BreakTy> {
  if let ty::RegionKind::ReEarlyBound(ebr) = r.kind() {
  self.variances[ebr.index as usize] = ty::Invariant;
  }
  r.super_visit_with(self)
  }
+
+ #[instrument(level = "trace", skip(self), ret)]
+ fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
+ match t.kind() {
+ ty::Opaque(def_id, substs) => self.visit_opaque(*def_id, substs),
+ ty::Projection(proj)
+ if self.tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder =>
+ {
+ self.visit_opaque(proj.item_def_id, proj.substs)
+ }
+ _ => t.super_visit_with(self),
+ }
+ }
  }
 
  // By default, RPIT are invariant wrt type and const generics, but they are bivariant wrt
@@ -111,7 +144,8 @@ fn variance_of_opaque(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Varianc
  }
  }
 
- let mut collector = OpaqueTypeLifetimeCollector { variances };
+ let mut collector =
+ OpaqueTypeLifetimeCollector { tcx, root_def_id: item_def_id.to_def_id(), variances };
  let id_substs = ty::InternalSubsts::identity_for_item(tcx, item_def_id.to_def_id());
  for pred in tcx.bound_explicit_item_bounds(item_def_id.to_def_id()).transpose_iter() {
  let pred = pred.map_bound(|(pred, _)| *pred).subst(tcx, id_substs);

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1482,25 +1482,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  ident_name: Symbol,
  }
 
+ // FIXME: This really should be taking scoping, etc into account.
  impl<'v> Visitor<'v> for LetVisitor<'v> {
  fn visit_stmt(&mut self, ex: &'v hir::Stmt<'v>) {
- if let hir::StmtKind::Local(hir::Local { pat, init, .. }) = &ex.kind {
- if let Binding(_, _, ident, ..) = pat.kind &&
- ident.name == self.ident_name {
- self.result = *init;
- }
+ if let hir::StmtKind::Local(hir::Local { pat, init, .. }) = &ex.kind
+ && let Binding(_, _, ident, ..) = pat.kind
+ && ident.name == self.ident_name
+ {
+ self.result = *init;
+ } else {
+ hir::intravisit::walk_stmt(self, ex);
  }
- hir::intravisit::walk_stmt(self, ex);
  }
  }
 
  let mut visitor = LetVisitor { result: None, ident_name: seg1.ident.name };
  visitor.visit_body(&body);
 
  let parent = self.tcx.hir().get_parent_node(seg1.hir_id);
- if let Some(Node::Expr(call_expr)) = self.tcx.hir().find(parent) &&
- let Some(expr) = visitor.result {
- let self_ty = self.node_ty(expr.hir_id);
+ if let Some(Node::Expr(call_expr)) = self.tcx.hir().find(parent)
+ && let Some(expr) = visitor.result
+ && let Some(self_ty) = self.node_ty_opt(expr.hir_id)
+ {
  let probe = self.lookup_probe(
  seg2.ident,
  self_ty,
@@ -1513,7 +1516,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  sm.span_extend_while(seg1.ident.span.shrink_to_hi(), |c| c == ':').unwrap(),
  "you may have meant to call an instance method",
  ".".to_string(),
- Applicability::MaybeIncorrect
+ Applicability::MaybeIncorrect,
  );
  }
  }

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

@@ -341,7 +341,15 @@ pub fn unexpected_hidden_region_diagnostic<'tcx>(
 
 impl<'tcx> InferCtxt<'tcx> {
  pub fn get_impl_future_output_ty(&self, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
- let ty::Opaque(def_id, substs) = *ty.kind() else { return None; };
+ let (def_id, substs) = match *ty.kind() {
+ ty::Opaque(def_id, substs) => (def_id, substs),
+ ty::Projection(data)
+ if self.tcx.def_kind(data.item_def_id) == DefKind::ImplTraitPlaceholder =>
+ {
+ (data.item_def_id, data.substs)
+ }
+ _ => return None,
+ };
 
  let future_trait = self.tcx.require_lang_item(LangItem::Future, None);
  let item_def_id = self.tcx.associated_item_def_ids(future_trait)[0];

compiler/rustc_middle/src/ty/generics.rs

@@ -101,6 +101,20 @@ impl GenericParamDef {
  _ => None,
  }
  }
+
+ pub fn to_error<'tcx>(
+ &self,
+ tcx: TyCtxt<'tcx>,
+ preceding_substs: &[ty::GenericArg<'tcx>],
+ ) -> ty::GenericArg<'tcx> {
+ match &self.kind {
+ ty::GenericParamDefKind::Lifetime => tcx.lifetimes.re_static.into(),
+ ty::GenericParamDefKind::Type { .. } => tcx.ty_error().into(),
+ ty::GenericParamDefKind::Const { .. } => {
+ tcx.const_error(tcx.bound_type_of(self.def_id).subst(tcx, preceding_substs)).into()
+ }
+ }
+ }
 }
 
 #[derive(Default)]