Auto merge of rust-lang#127924 - matthiaskrgr:rollup-1gn6afv, r=matth…

…iaskrgr

Rollup of 6 pull requests

Successful merges:

 - rust-lang#124881 (Use ThreadId instead of TLS-address in `ReentrantLock`)
 - rust-lang#127656 (make pub_use_of_private_extern_crate show up in cargo's future breakage reports)
 - rust-lang#127748 (Use Option's discriminant as its size hint)
 - rust-lang#127854 (Add internal lint for detecting non-glob imports of `rustc_type_ir::inherent`)
 - rust-lang#127908 (Update extern linking documentation)
 - rust-lang#127919 (Allow a git command for getting the current branch in bootstrap to fail)

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

compiler/rustc_lint/messages.ftl

@@ -556,6 +556,9 @@ lint_non_fmt_panic_unused =
  }
  .add_fmt_suggestion = or add a "{"{"}{"}"}" format string to use the message literally
 
+lint_non_glob_import_type_ir_inherent = non-glob import of `rustc_type_ir::inherent`
+ .suggestion = try using a glob import instead
+
 lint_non_local_definitions_cargo_update = the {$macro_kind} `{$macro_name}` may come from an old version of the `{$crate_name}` crate, try updating your dependency with `cargo update -p {$crate_name}`
 
 lint_non_local_definitions_deprecation = this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>

compiler/rustc_lint/src/internal.rs

@@ -3,7 +3,8 @@
 
 use crate::lints::{
  BadOptAccessDiag, DefaultHashTypesDiag, DiagOutOfImpl, LintPassByHand, NonExistentDocKeyword,
- QueryInstability, SpanUseEqCtxtDiag, TyQualified, TykindDiag, TykindKind, UntranslatableDiag,
+ NonGlobImportTypeIrInherent, QueryInstability, SpanUseEqCtxtDiag, TyQualified, TykindDiag,
+ TykindKind, UntranslatableDiag,
 };
 use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_ast as ast;
@@ -263,6 +264,49 @@ fn gen_args(segment: &PathSegment<'_>) -> String {
  String::new()
 }
 
+declare_tool_lint! {
+ /// The `non_glob_import_of_type_ir_inherent_item` lint detects
+ /// non-glob imports of module `rustc_type_ir::inherent`.
+ pub rustc::NON_GLOB_IMPORT_OF_TYPE_IR_INHERENT,
+ Allow,
+ "non-glob import of `rustc_type_ir::inherent`",
+ report_in_external_macro: true
+}
+
+declare_lint_pass!(TypeIr => [NON_GLOB_IMPORT_OF_TYPE_IR_INHERENT]);
+
+impl<'tcx> LateLintPass<'tcx> for TypeIr {
+ fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+ let rustc_hir::ItemKind::Use(path, kind) = item.kind else { return };
+
+ let is_mod_inherent = |def_id| cx.tcx.is_diagnostic_item(sym::type_ir_inherent, def_id);
+ let (lo, hi, snippet) = match path.segments {
+ [.., penultimate, segment]
+ if penultimate.res.opt_def_id().is_some_and(is_mod_inherent) =>
+ {
+ (segment.ident.span, item.ident.span, "*")
+ }
+ [.., segment]
+ if path.res.iter().flat_map(Res::opt_def_id).any(is_mod_inherent)
+ && let rustc_hir::UseKind::Single = kind =>
+ {
+ let (lo, snippet) =
+ match cx.tcx.sess.source_map().span_to_snippet(path.span).as_deref() {
+ Ok("self") => (path.span, "*"),
+ _ => (segment.ident.span.shrink_to_hi(), "::*"),
+ };
+ (lo, if segment.ident == item.ident { lo } else { item.ident.span }, snippet)
+ }
+ _ => return,
+ };
+ cx.emit_span_lint(
+ NON_GLOB_IMPORT_OF_TYPE_IR_INHERENT,
+ path.span,
+ NonGlobImportTypeIrInherent { suggestion: lo.eq_ctxt(hi).then(|| lo.to(hi)), snippet },
+ );
+ }
+}
+
 declare_tool_lint! {
  /// The `lint_pass_impl_without_macro` detects manual implementations of a lint
  /// pass, without using [`declare_lint_pass`] or [`impl_lint_pass`].

compiler/rustc_lint/src/lib.rs

@@ -572,6 +572,8 @@ fn register_internals(store: &mut LintStore) {
  store.register_late_mod_pass(|_| Box::new(ExistingDocKeyword));
  store.register_lints(&TyTyKind::get_lints());
  store.register_late_mod_pass(|_| Box::new(TyTyKind));
+ store.register_lints(&TypeIr::get_lints());
+ store.register_late_mod_pass(|_| Box::new(TypeIr));
  store.register_lints(&Diagnostics::get_lints());
  store.register_late_mod_pass(|_| Box::new(Diagnostics));
  store.register_lints(&BadOptAccess::get_lints());
@@ -595,6 +597,7 @@ fn register_internals(store: &mut LintStore) {
  LintId::of(PASS_BY_VALUE),
  LintId::of(LINT_PASS_IMPL_WITHOUT_MACRO),
  LintId::of(USAGE_OF_QUALIFIED_TY),
+ LintId::of(NON_GLOB_IMPORT_OF_TYPE_IR_INHERENT),
  LintId::of(EXISTING_DOC_KEYWORD),
  LintId::of(BAD_OPT_ACCESS),
  LintId::of(SPAN_USE_EQ_CTXT),

compiler/rustc_lint/src/lints.rs

@@ -926,6 +926,14 @@ pub struct TyQualified {
  pub suggestion: Span,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_non_glob_import_type_ir_inherent)]
+pub struct NonGlobImportTypeIrInherent {
+ #[suggestion(code = "{snippet}", applicability = "maybe-incorrect")]
+ pub suggestion: Option<Span>,
+ pub snippet: &'static str,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(lint_lintpass_by_hand)]
 #[help]

compiler/rustc_lint_defs/src/builtin.rs

@@ -1203,16 +1203,16 @@ declare_lint! {
  /// This was historically allowed, but is not the intended behavior
  /// according to the visibility rules. This is a [future-incompatible]
  /// lint to transition this to a hard error in the future. See [issue
- /// #34537] for more details.
+ /// #127909] for more details.
  ///
- /// [issue #34537]: https://github.com/rust-lang/rust/issues/34537
+ /// [issue #127909]: https://github.com/rust-lang/rust/issues/127909
  /// [future-incompatible]: ../index.md#future-incompatible-lints
  pub PUB_USE_OF_PRIVATE_EXTERN_CRATE,
  Deny,
  "detect public re-exports of private extern crates",
  @future_incompatible = FutureIncompatibleInfo {
- reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
- reference: "issue #34537 <https://github.com/rust-lang/rust/issues/34537>",
+ reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
+ reference: "issue #127909 <https://github.com/rust-lang/rust/issues/127909>",
  };
 }
 

compiler/rustc_span/src/symbol.rs

@@ -1926,6 +1926,7 @@ symbols! {
  type_ascription,
  type_changing_struct_update,
  type_id,
+ type_ir_inherent,
  type_length_limit,
  type_macros,
  type_name,

compiler/rustc_type_ir/src/effects.rs

@@ -1,4 +1,4 @@
-use crate::inherent::{AdtDef, IntoKind, Ty};
+use crate::inherent::*;
 use crate::lang_items::TraitSolverLangItem::{EffectsMaybe, EffectsNoRuntime, EffectsRuntime};
 use crate::Interner;
 

compiler/rustc_type_ir/src/lib.rs

@@ -24,6 +24,7 @@ pub mod elaborate;
 pub mod error;
 pub mod fast_reject;
 pub mod fold;
+#[cfg_attr(feature = "nightly", rustc_diagnostic_item = "type_ir_inherent")]
 pub mod inherent;
 pub mod ir_print;
 pub mod lang_items;

library/core/src/option.rs

@@ -770,6 +770,13 @@ impl<T> Option<T> {
  }
  }
 
+ #[inline]
+ const fn len(&self) -> usize {
+ // Using the intrinsic avoids emitting a branch to get the 0 or 1.
+ let discriminant: isize = crate::intrinsics::discriminant_value(self);
+ discriminant as usize
+ }
+
  /// Returns a slice of the contained value, if any. If this is `None`, an
  /// empty slice is returned. This can be useful to have a single type of
  /// iterator over an `Option` or slice.
@@ -812,7 +819,7 @@ impl<T> Option<T> {
  unsafe {
  slice::from_raw_parts(
  (self as *const Self).byte_add(core::mem::offset_of!(Self, Some.0)).cast(),
- self.is_some() as usize,
+ self.len(),
  )
  }
  }
@@ -869,7 +876,7 @@ impl<T> Option<T> {
  unsafe {
  slice::from_raw_parts_mut(
  (self as *mut Self).byte_add(core::mem::offset_of!(Self, Some.0)).cast(),
- self.is_some() as usize,
+ self.len(),
  )
  }
  }
@@ -2242,10 +2249,8 @@ impl<A> Iterator for Item<A> {
 
  #[inline]
  fn size_hint(&self) -> (usize, Option<usize>) {
- match self.opt {
- Some(_) => (1, Some(1)),
- None => (0, Some(0)),
- }
+ let len = self.len();
+ (len, Some(len))
  }
 }
 
@@ -2256,7 +2261,12 @@ impl<A> DoubleEndedIterator for Item<A> {
  }
 }
 
-impl<A> ExactSizeIterator for Item<A> {}
+impl<A> ExactSizeIterator for Item<A> {
+ #[inline]
+ fn len(&self) -> usize {
+ self.opt.len()
+ }
+}
 impl<A> FusedIterator for Item<A> {}
 unsafe impl<A> TrustedLen for Item<A> {}