Rollup of 7 pull requests

compiler/rustc_borrowck/src/def_use.rs

@@ -55,7 +55,7 @@ pub fn categorize(context: PlaceContext) -> Option<DefUse> {
  // `PlaceMention` and `AscribeUserType` both evaluate the place, which must not
  // contain dangling references.
  PlaceContext::NonMutatingUse(NonMutatingUseContext::PlaceMention) |
- PlaceContext::NonUse(NonUseContext::AscribeUserTy) |
+ PlaceContext::NonUse(NonUseContext::AscribeUserTy(_)) |
 
  PlaceContext::MutatingUse(MutatingUseContext::AddressOf) |
  PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) |

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -777,7 +777,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
  Inspect | Copy | Move | PlaceMention | SharedBorrow | ShallowBorrow | UniqueBorrow
  | AddressOf | Projection,
  ) => ty::Covariant,
- PlaceContext::NonUse(AscribeUserTy) => ty::Covariant,
+ PlaceContext::NonUse(AscribeUserTy(variance)) => variance,
  }
  }
 

compiler/rustc_codegen_llvm/src/callee.rs

@@ -94,11 +94,11 @@ pub fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) ->
  // LLVM will prefix the name with `__imp_`. Ideally, we'd like the
  // existing logic below to set the Storage Class, but it has an
  // exemption for MinGW for backwards compatability.
- let llfn = cx.declare_fn(&common::i686_decorated_name(&dllimport, common::is_mingw_gnu_toolchain(&tcx.sess.target), true), fn_abi);
+ let llfn = cx.declare_fn(&common::i686_decorated_name(&dllimport, common::is_mingw_gnu_toolchain(&tcx.sess.target), true), fn_abi, Some(instance));
  unsafe { llvm::LLVMSetDLLStorageClass(llfn, llvm::DLLStorageClass::DllImport); }
  llfn
  } else {
- cx.declare_fn(sym, fn_abi)
+ cx.declare_fn(sym, fn_abi, Some(instance))
  };
  debug!("get_fn: not casting pointer!");
 

compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs

@@ -207,6 +207,7 @@ fn declare_unused_fn<'tcx>(cx: &CodegenCx<'_, 'tcx>, def_id: DefId) -> Instance<
  )),
  ty::List::empty(),
  ),
+ None,
  );
 
  llvm::set_linkage(llfn, llvm::Linkage::PrivateLinkage);

compiler/rustc_codegen_llvm/src/declare.rs

@@ -19,8 +19,11 @@ use crate::llvm::AttributePlace::Function;
 use crate::type_::Type;
 use crate::value::Value;
 use rustc_codegen_ssa::traits::TypeMembershipMethods;
-use rustc_middle::ty::Ty;
-use rustc_symbol_mangling::typeid::{kcfi_typeid_for_fnabi, typeid_for_fnabi, TypeIdOptions};
+use rustc_middle::ty::{Instance, Ty};
+use rustc_symbol_mangling::typeid::{
+ kcfi_typeid_for_fnabi, kcfi_typeid_for_instance, typeid_for_fnabi, typeid_for_instance,
+ TypeIdOptions,
+};
 use smallvec::SmallVec;
 
 /// Declare a function.
@@ -116,7 +119,12 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
  ///
  /// If there’s a value with the same name already declared, the function will
  /// update the declaration and return existing Value instead.
- pub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> &'ll Value {
+ pub fn declare_fn(
+ &self,
+ name: &str,
+ fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
+ instance: Option<Instance<'tcx>>,
+ ) -> &'ll Value {
  debug!("declare_rust_fn(name={:?}, fn_abi={:?})", name, fn_abi);
 
  // Function addresses in Rust are never significant, allowing functions to
@@ -132,18 +140,35 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
  fn_abi.apply_attrs_llfn(self, llfn);
 
  if self.tcx.sess.is_sanitizer_cfi_enabled() {
- let typeid = typeid_for_fnabi(self.tcx, fn_abi, TypeIdOptions::empty());
- self.set_type_metadata(llfn, typeid);
- let typeid = typeid_for_fnabi(self.tcx, fn_abi, TypeIdOptions::GENERALIZE_POINTERS);
- self.add_type_metadata(llfn, typeid);
- let typeid = typeid_for_fnabi(self.tcx, fn_abi, TypeIdOptions::NORMALIZE_INTEGERS);
- self.add_type_metadata(llfn, typeid);
- let typeid = typeid_for_fnabi(
- self.tcx,
- fn_abi,
- TypeIdOptions::GENERALIZE_POINTERS | TypeIdOptions::NORMALIZE_INTEGERS,
- );
- self.add_type_metadata(llfn, typeid);
+ if let Some(instance) = instance {
+ let typeid = typeid_for_instance(self.tcx, &instance, TypeIdOptions::empty());
+ self.set_type_metadata(llfn, typeid);
+ let typeid =
+ typeid_for_instance(self.tcx, &instance, TypeIdOptions::GENERALIZE_POINTERS);
+ self.add_type_metadata(llfn, typeid);
+ let typeid =
+ typeid_for_instance(self.tcx, &instance, TypeIdOptions::NORMALIZE_INTEGERS);
+ self.add_type_metadata(llfn, typeid);
+ let typeid = typeid_for_instance(
+ self.tcx,
+ &instance,
+ TypeIdOptions::GENERALIZE_POINTERS | TypeIdOptions::NORMALIZE_INTEGERS,
+ );
+ self.add_type_metadata(llfn, typeid);
+ } else {
+ let typeid = typeid_for_fnabi(self.tcx, fn_abi, TypeIdOptions::empty());
+ self.set_type_metadata(llfn, typeid);
+ let typeid = typeid_for_fnabi(self.tcx, fn_abi, TypeIdOptions::GENERALIZE_POINTERS);
+ self.add_type_metadata(llfn, typeid);
+ let typeid = typeid_for_fnabi(self.tcx, fn_abi, TypeIdOptions::NORMALIZE_INTEGERS);
+ self.add_type_metadata(llfn, typeid);
+ let typeid = typeid_for_fnabi(
+ self.tcx,
+ fn_abi,
+ TypeIdOptions::GENERALIZE_POINTERS | TypeIdOptions::NORMALIZE_INTEGERS,
+ );
+ self.add_type_metadata(llfn, typeid);
+ }
  }
 
  if self.tcx.sess.is_sanitizer_kcfi_enabled() {
@@ -156,8 +181,13 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
  options.insert(TypeIdOptions::NORMALIZE_INTEGERS);
  }
 
- let kcfi_typeid = kcfi_typeid_for_fnabi(self.tcx, fn_abi, options);
- self.set_kcfi_type_metadata(llfn, kcfi_typeid);
+ if let Some(instance) = instance {
+ let kcfi_typeid = kcfi_typeid_for_instance(self.tcx, &instance, options);
+ self.set_kcfi_type_metadata(llfn, kcfi_typeid);
+ } else {
+ let kcfi_typeid = kcfi_typeid_for_fnabi(self.tcx, fn_abi, options);
+ self.set_kcfi_type_metadata(llfn, kcfi_typeid);
+ }
  }
 
  llfn

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -772,7 +772,7 @@ fn gen_fn<'ll, 'tcx>(
 ) -> (&'ll Type, &'ll Value) {
  let fn_abi = cx.fn_abi_of_fn_ptr(rust_fn_sig, ty::List::empty());
  let llty = fn_abi.llvm_type(cx);
- let llfn = cx.declare_fn(name, fn_abi);
+ let llfn = cx.declare_fn(name, fn_abi, None);
  cx.set_frame_pointer_type(llfn);
  cx.apply_target_cpu_attr(llfn);
  // FIXME(eddyb) find a nicer way to do this.

compiler/rustc_codegen_llvm/src/mono_item.rs

@@ -51,7 +51,7 @@ impl<'tcx> PreDefineMethods<'tcx> for CodegenCx<'_, 'tcx> {
  assert!(!instance.substs.has_infer());
 
  let fn_abi = self.fn_abi_of_instance(instance, ty::List::empty());
- let lldecl = self.declare_fn(symbol_name, fn_abi);
+ let lldecl = self.declare_fn(symbol_name, fn_abi, Some(instance));
  unsafe { llvm::LLVMRustSetLinkage(lldecl, base::linkage_to_llvm(linkage)) };
  let attrs = self.tcx.codegen_fn_attrs(instance.def_id());
  base::set_link_section(lldecl, attrs);

compiler/rustc_hir_analysis/src/check/check.rs

@@ -31,6 +31,7 @@ use rustc_target::abi::FieldIdx;
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::traits::error_reporting::on_unimplemented::OnUnimplementedDirective;
 use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
+use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt as _;
 use rustc_trait_selection::traits::{self, ObligationCtxt, TraitEngine, TraitEngineExt as _};
 
 use std::ops::ControlFlow;
@@ -222,7 +223,7 @@ fn check_opaque(tcx: TyCtxt<'_>, id: hir::ItemId) {
  if check_opaque_for_cycles(tcx, item.owner_id.def_id, substs, span, &origin).is_err() {
  return;
  }
- check_opaque_meets_bounds(tcx, item.owner_id.def_id, substs, span, &origin);
+ check_opaque_meets_bounds(tcx, item.owner_id.def_id, span, &origin);
 }
 
 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
@@ -391,7 +392,6 @@ pub(super) fn check_opaque_for_cycles<'tcx>(
 fn check_opaque_meets_bounds<'tcx>(
  tcx: TyCtxt<'tcx>,
  def_id: LocalDefId,
- substs: SubstsRef<'tcx>,
  span: Span,
  origin: &hir::OpaqueTyOrigin,
 ) {
@@ -406,6 +406,8 @@ fn check_opaque_meets_bounds<'tcx>(
  .with_opaque_type_inference(DefiningAnchor::Bind(defining_use_anchor))
  .build();
  let ocx = ObligationCtxt::new(&infcx);
+
+ let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
  let opaque_ty = tcx.mk_opaque(def_id.to_def_id(), substs);
 
  // `ReErased` regions appear in the "parent_substs" of closures/generators.
@@ -448,9 +450,18 @@ fn check_opaque_meets_bounds<'tcx>(
  match origin {
  // Checked when type checking the function containing them.
  hir::OpaqueTyOrigin::FnReturn(..) | hir::OpaqueTyOrigin::AsyncFn(..) => {}
+ // Nested opaque types occur only in associated types:
+ // ` type Opaque<T> = impl Trait<&'static T, AssocTy = impl Nested>; `
+ // They can only be referenced as `<Opaque<T> as Trait<&'static T>>::AssocTy`.
+ // We don't have to check them here because their well-formedness follows from the WF of
+ // the projection input types in the defining- and use-sites.
+ hir::OpaqueTyOrigin::TyAlias
+ if tcx.def_kind(tcx.parent(def_id.to_def_id())) == DefKind::OpaqueTy => {}
  // Can have different predicates to their defining use
  hir::OpaqueTyOrigin::TyAlias => {
- let outlives_env = OutlivesEnvironment::new(param_env);
+ let wf_tys = ocx.assumed_wf_types(param_env, span, def_id);
+ let implied_bounds = infcx.implied_bounds_tys(param_env, def_id, wf_tys);
+ let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
  let _ = ocx.resolve_regions_and_report_errors(defining_use_anchor, &outlives_env);
  }
  }

compiler/rustc_middle/src/mir/visit.rs

@@ -64,7 +64,7 @@
 
 use crate::mir::*;
 use crate::ty::subst::SubstsRef;
-use crate::ty::{CanonicalUserTypeAnnotation, Ty};
+use crate::ty::{self, CanonicalUserTypeAnnotation, Ty};
 use rustc_span::Span;
 
 macro_rules! make_mir_visitor {
@@ -782,12 +782,12 @@ macro_rules! make_mir_visitor {
 
  fn super_ascribe_user_ty(&mut self,
  place: & $($mutability)? Place<'tcx>,
- _variance: $(& $mutability)? ty::Variance,
+ variance: $(& $mutability)? ty::Variance,
  user_ty: & $($mutability)? UserTypeProjection,
  location: Location) {
  self.visit_place(
  place,
- PlaceContext::NonUse(NonUseContext::AscribeUserTy),
+ PlaceContext::NonUse(NonUseContext::AscribeUserTy($(* &$mutability *)? variance)),
  location
  );
  self.visit_user_type_projection(user_ty);
@@ -1320,7 +1320,7 @@ pub enum NonUseContext {
  /// Ending a storage live range.
  StorageDead,
  /// User type annotation assertions for NLL.
- AscribeUserTy,
+ AscribeUserTy(ty::Variance),
  /// The data of a user variable, for debug info.
  VarDebugInfo,
 }

compiler/rustc_middle/src/ty/util.rs

@@ -1253,7 +1253,7 @@ pub enum ExplicitSelf<'tcx> {
 
 impl<'tcx> ExplicitSelf<'tcx> {
  /// Categorizes an explicit self declaration like `self: SomeType`
- /// into either `self`, `&self`, `&mut self`, `Box<self>`, or
+ /// into either `self`, `&self`, `&mut self`, `Box<Self>`, or
  /// `Other`.
  /// This is mainly used to require the arbitrary_self_types feature
  /// in the case of `Other`, to improve error messages in the common cases,

compiler/rustc_resolve/messages.ftl

@@ -199,6 +199,10 @@ resolve_invalid_asm_sym =
  .label = is a local variable
  .help = `sym` operands must refer to either a function or a static
 
+resolve_lowercase_self =
+ attempt to use a non-constant value in a constant
+ .suggestion = try using `Self`
+
 resolve_trait_impl_duplicate =
  duplicate definitions with name `{$name}`:
  .label = duplicate definition

compiler/rustc_resolve/src/diagnostics.rs

@@ -948,6 +948,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  ResolutionError::InvalidAsmSym => {
  self.tcx.sess.create_err(errs::InvalidAsmSym { span })
  }
+ ResolutionError::LowercaseSelf => {
+ self.tcx.sess.create_err(errs::LowercaseSelf { span })
+ }
  }
  }
 

compiler/rustc_resolve/src/errors.rs

@@ -442,6 +442,14 @@ pub(crate) struct InvalidAsmSym {
  pub(crate) span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(resolve_lowercase_self)]
+pub(crate) struct LowercaseSelf {
+ #[primary_span]
+ #[suggestion(code = "Self", applicability = "maybe-incorrect", style = "short")]
+ pub(crate) span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(resolve_trait_impl_duplicate, code = "E0201")]
 pub(crate) struct TraitImplDuplicate {

compiler/rustc_resolve/src/ident.rs

@@ -15,8 +15,7 @@ use std::ptr;
 
 use crate::errors::{ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst};
 use crate::late::{
- ConstantHasGenerics, ConstantItemKind, HasGenericParams, NoConstantGenericsReason, PathSource,
- Rib, RibKind,
+ ConstantHasGenerics, HasGenericParams, NoConstantGenericsReason, PathSource, Rib, RibKind,
 };
 use crate::macros::{sub_namespace_match, MacroRulesScope};
 use crate::{errors, AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, Determinacy, Finalize};
@@ -1127,28 +1126,25 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  RibKind::ConstantItem(_, item) => {
  // Still doesn't deal with upvars
  if let Some(span) = finalize {
- let (span, resolution_error) =
- if let Some((ident, constant_item_kind)) = item {
- let kind_str = match constant_item_kind {
- ConstantItemKind::Const => "const",
- ConstantItemKind::Static => "static",
- };
- (
- span,
- AttemptToUseNonConstantValueInConstant(
- ident, "let", kind_str,
- ),
- )
- } else {
- (
- rib_ident.span,
- AttemptToUseNonConstantValueInConstant(
- original_rib_ident_def,
- "const",
- "let",
- ),
- )
- };
+ let (span, resolution_error) = match item {
+ None if rib_ident.as_str() == "self" => (span, LowercaseSelf),
+ None => (
+ rib_ident.span,
+ AttemptToUseNonConstantValueInConstant(
+ original_rib_ident_def,
+ "const",
+ "let",
+ ),
+ ),
+ Some((ident, kind)) => (
+ span,
+ AttemptToUseNonConstantValueInConstant(
+ ident,
+ "let",
+ kind.as_str(),
+ ),
+ ),
+ };
  self.report_error(span, resolution_error);
  }
  return Res::Err;

compiler/rustc_resolve/src/late.rs

@@ -150,6 +150,15 @@ pub(crate) enum ConstantItemKind {
  Static,
 }
 
+impl ConstantItemKind {
+ pub(crate) fn as_str(&self) -> &'static str {
+ match self {
+ Self::Const => "const",
+ Self::Static => "static",
+ }
+ }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 enum RecordPartialRes {
  Yes,
@@ -1482,7 +1491,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
  if let Some(&(_, res)) = rib.bindings.get(&normalized_ident) {
  self.record_lifetime_res(lifetime.id, res, LifetimeElisionCandidate::Named);
 
- if let LifetimeRes::Param { param, .. } = res {
+ if let LifetimeRes::Param { param, binder } = res {
  match self.lifetime_uses.entry(param) {
  Entry::Vacant(v) => {
  debug!("First use of {:?} at {:?}", res, ident.span);
@@ -1496,10 +1505,16 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
  LifetimeRibKind::Item
  | LifetimeRibKind::AnonymousReportError
  | LifetimeRibKind::ElisionFailure => Some(LifetimeUseSet::Many),
- // An anonymous lifetime is legal here, go ahead.
- LifetimeRibKind::AnonymousCreateParameter { .. } => {
- Some(LifetimeUseSet::One { use_span: ident.span, use_ctxt })
- }
+ // An anonymous lifetime is legal here, and bound to the right
+ // place, go ahead.
+ LifetimeRibKind::AnonymousCreateParameter {
+ binder: anon_binder,
+ ..
+ } => Some(if binder == anon_binder {
+ LifetimeUseSet::One { use_span: ident.span, use_ctxt }
+ } else {
+ LifetimeUseSet::Many
+ }),
  // Only report if eliding the lifetime would have the same
  // semantics.
  LifetimeRibKind::Elided(r) => Some(if res == r {

compiler/rustc_resolve/src/lib.rs

@@ -251,6 +251,8 @@ enum ResolutionError<'a> {
  TraitImplDuplicate { name: Symbol, trait_item_span: Span, old_span: Span },
  /// Inline asm `sym` operand must refer to a `fn` or `static`.
  InvalidAsmSym,
+ /// `self` used instead of `Self` in a generic parameter
+ LowercaseSelf,
 }
 
 enum VisResolutionError<'a> {