Auto merge of rust-lang#130483 - matthiaskrgr:rollup-q1r0g0y, r=matth…

…iaskrgr Rollup of 5 pull requests Successful merges: - rust-lang#129477 (Fix fluent diagnostics) - rust-lang#129674 (Add new_cyclic_in for Rc and Arc) - rust-lang#130452 (Update Trusty target maintainers) - rust-lang#130467 (Miri subtree update) - rust-lang#130477 (Revert rust-lang#129749 to fix segfault in LLVM) r? `@ghost` `@rustbot` modify labels: rollup
rust-lang-ci · Sep 17, 2024 · 28e8f01 · 28e8f01
2 parents f609b7e + f8090dd
commit 28e8f01
Show file tree

Hide file tree

Showing 752 changed files with 2,927 additions and 2,691 deletions.
diff --git a/Cargo.lock b/Cargo.lock
@@ -104,15 +104,6 @@ dependencies = [
  "unicode-width",
 ]
 
-[[package]]
-name = "ansi_term"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
-dependencies = [
- "winapi",
-]
-
 [[package]]
 name = "anstream"
 version = "0.6.15"
@@ -714,7 +705,7 @@ dependencies = [
  "miow",
  "miropt-test-tools",
  "regex",
- "rustfix 0.8.1",
+ "rustfix",
  "serde",
  "serde_json",
  "tracing",
@@ -2278,7 +2269,7 @@ dependencies = [
  "rustc_version",
  "smallvec",
  "tempfile",
- "ui_test 0.21.2",
+ "ui_test 0.26.5",
  "windows-sys 0.52.0",
 ]
 
@@ -2807,16 +2798,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 
-[[package]]
-name = "prettydiff"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ff1fec61082821f8236cf6c0c14e8172b62ce8a72a0eedc30d3b247bb68dc11"
-dependencies = [
- "ansi_term",
- "pad",
-]
-
 [[package]]
 name = "prettydiff"
 version = "0.7.0"
@@ -4625,18 +4606,6 @@ dependencies = [
  "rustdoc",
 ]
 
-[[package]]
-name = "rustfix"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd2853d9e26988467753bd9912c3a126f642d05d229a4b53f5752ee36c56481"
-dependencies = [
- "anyhow",
- "log",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "rustfix"
 version = "0.8.1"
@@ -5518,36 +5487,36 @@ checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
 
 [[package]]
 name = "ui_test"
-version = "0.21.2"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaf4bf7c184b8dfc7a4d3b90df789b1eb992ee42811cd115f32a7a1eb781058d"
+checksum = "f7e4f339f62edc873975c47115f9e71c5454ddaa37c1142b42fc0b2672c8dacb"
 dependencies = [
- "annotate-snippets 0.9.2",
+ "annotate-snippets 0.11.4",
  "anyhow",
  "bstr",
  "cargo-platform",
- "cargo_metadata 0.15.4",
+ "cargo_metadata 0.18.1",
  "color-eyre",
  "colored",
  "comma",
  "crossbeam-channel",
  "indicatif",
  "lazy_static",
  "levenshtein",
- "prettydiff 0.6.4",
+ "prettydiff",
  "regex",
  "rustc_version",
- "rustfix 0.6.1",
+ "rustfix",
  "serde",
  "serde_json",
- "tempfile",
+ "spanned",
 ]
 
 [[package]]
 name = "ui_test"
-version = "0.25.0"
+version = "0.26.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7e4f339f62edc873975c47115f9e71c5454ddaa37c1142b42fc0b2672c8dacb"
+checksum = "32ee4c40e5a5f9fa6864ff976473e5d6a6e9884b6ce68b40690d9f87e1994c83"
 dependencies = [
  "annotate-snippets 0.11.4",
  "anyhow",
@@ -5559,12 +5528,11 @@ dependencies = [
  "comma",
  "crossbeam-channel",
  "indicatif",
- "lazy_static",
  "levenshtein",
- "prettydiff 0.7.0",
+ "prettydiff",
  "regex",
  "rustc_version",
- "rustfix 0.8.1",
+ "rustfix",
  "serde",
  "serde_json",
  "spanned",

diff --git a/compiler/rustc_fluent_macro/src/fluent.rs b/compiler/rustc_fluent_macro/src/fluent.rs
@@ -138,25 +138,8 @@ pub(crate) fn fluent_messages(input: proc_macro::TokenStream) -> proc_macro::Tok
  // with a lowercase as rustc errors do.
  err.replace_range(0..1, &err.chars().next().unwrap().to_lowercase().to_string());
 
- let line_starts: Vec<usize> = std::iter::once(0)
- .chain(
- this.source()
- .char_indices()
- .filter_map(|(i, c)| Some(i + 1).filter(|_| c == '\n')),
- )
- .collect();
- let line_start = line_starts
- .iter()
- .enumerate()
- .map(|(line, idx)| (line + 1, idx))
- .filter(|(_, idx)| **idx <= pos.start)
- .last()
- .unwrap()
- .0;
-
  let message = annotate_snippets::Level::Error.title(&err).snippet(
  Snippet::source(this.source())
- .line_start(line_start)
  .origin(&relative_ftl_path)
  .fold(true)
  .annotation(annotate_snippets::Level::Error.span(pos.start..pos.end - 1)),

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -1211,11 +1211,7 @@ struct LLVMRustThinLTOData {
  // Not 100% sure what these are, but they impact what's internalized and
  // what's inlined across modules, I believe.
 #if LLVM_VERSION_GE(18, 0)
-#if LLVM_VERSION_GE(20, 0)
- FunctionImporter::ImportListsTy ImportLists;
-#else
  DenseMap<StringRef, FunctionImporter::ImportMapTy> ImportLists;
-#endif
  DenseMap<StringRef, FunctionImporter::ExportSetTy> ExportLists;
  DenseMap<StringRef, GVSummaryMapTy> ModuleToDefinedGVSummaries;
 #else
@@ -1424,13 +1420,13 @@ LLVMRustPrepareThinLTOInternalize(const LLVMRustThinLTOData *Data,
  return true;
 }
 
-extern "C" bool LLVMRustPrepareThinLTOImport(LLVMRustThinLTOData *Data,
+extern "C" bool LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data,
  LLVMModuleRef M,
  LLVMTargetMachineRef TM) {
  Module &Mod = *unwrap(M);
  TargetMachine &Target = *unwrap(TM);
 
- const auto &ImportList = Data->ImportLists[Mod.getModuleIdentifier()];
+ const auto &ImportList = Data->ImportLists.lookup(Mod.getModuleIdentifier());
  auto Loader = [&](StringRef Identifier) {
  const auto &Memory = Data->ModuleMap.lookup(Identifier);
  auto &Context = Mod.getContext();
@@ -1613,7 +1609,7 @@ extern "C" void LLVMRustComputeLTOCacheKey(RustStringRef KeyOut,
  LLVMRustThinLTOData *Data) {
  SmallString<40> Key;
  llvm::lto::Config conf;
- const auto &ImportList = Data->ImportLists[ModId];
+ const auto &ImportList = Data->ImportLists.lookup(ModId);
  const auto &ExportList = Data->ExportLists.lookup(ModId);
  const auto &ResolvedODR = Data->ResolvedODR.lookup(ModId);
  const auto &DefinedGlobals = Data->ModuleToDefinedGVSummaries.lookup(ModId);

diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
@@ -460,42 +460,7 @@ impl<T> Rc<T> {
  where
  F: FnOnce(&Weak<T>) -> T,
  {
- // Construct the inner in the "uninitialized" state with a single
- // weak reference.
- let uninit_ptr: NonNull<_> = Box::leak(Box::new(RcBox {
- strong: Cell::new(0),
- weak: Cell::new(1),
- value: mem::MaybeUninit::<T>::uninit(),
- }))
- .into();
-
- let init_ptr: NonNull<RcBox<T>> = uninit_ptr.cast();
-
- let weak = Weak { ptr: init_ptr, alloc: Global };
-
- // It's important we don't give up ownership of the weak pointer, or
- // else the memory might be freed by the time `data_fn` returns. If
- // we really wanted to pass ownership, we could create an additional
- // weak pointer for ourselves, but this would result in additional
- // updates to the weak reference count which might not be necessary
- // otherwise.
- let data = data_fn(&weak);
-
- let strong = unsafe {
- let inner = init_ptr.as_ptr();
- ptr::write(ptr::addr_of_mut!((*inner).value), data);
-
- let prev_value = (*inner).strong.get();
- debug_assert_eq!(prev_value, 0, "No prior strong references should exist");
- (*inner).strong.set(1);
-
- Rc::from_inner(init_ptr)
- };
-
- // Strong references should collectively own a shared weak reference,
- // so don't run the destructor for our old weak reference.
- mem::forget(weak);
- strong
+ Self::new_cyclic_in(data_fn, Global)
  }
 
  /// Constructs a new `Rc` with uninitialized contents.
@@ -762,6 +727,84 @@ impl<T, A: Allocator> Rc<T, A> {
  }
  }
 
+ /// Constructs a new `Rc<T, A>` in the given allocator while giving you a `Weak<T, A>` to the allocation,
+ /// to allow you to construct a `T` which holds a weak pointer to itself.
+ ///
+ /// Generally, a structure circularly referencing itself, either directly or
+ /// indirectly, should not hold a strong reference to itself to prevent a memory leak.
+ /// Using this function, you get access to the weak pointer during the
+ /// initialization of `T`, before the `Rc<T, A>` is created, such that you can
+ /// clone and store it inside the `T`.
+ ///
+ /// `new_cyclic_in` first allocates the managed allocation for the `Rc<T, A>`,
+ /// then calls your closure, giving it a `Weak<T, A>` to this allocation,
+ /// and only afterwards completes the construction of the `Rc<T, A>` by placing
+ /// the `T` returned from your closure into the allocation.
+ ///
+ /// Since the new `Rc<T, A>` is not fully-constructed until `Rc<T, A>::new_cyclic_in`
+ /// returns, calling [`upgrade`] on the weak reference inside your closure will
+ /// fail and result in a `None` value.
+ ///
+ /// # Panics
+ ///
+ /// If `data_fn` panics, the panic is propagated to the caller, and the
+ /// temporary [`Weak<T, A>`] is dropped normally.
+ ///
+ /// # Examples
+ ///
+ /// See [`new_cyclic`].
+ ///
+ /// [`new_cyclic`]: Rc::new_cyclic
+ /// [`upgrade`]: Weak::upgrade
+ #[cfg(not(no_global_oom_handling))]
+ #[unstable(feature = "allocator_api", issue = "32838")]
+ pub fn new_cyclic_in<F>(data_fn: F, alloc: A) -> Rc<T, A>
+ where
+ F: FnOnce(&Weak<T, A>) -> T,
+ {
+ // Construct the inner in the "uninitialized" state with a single
+ // weak reference.
+ let (uninit_raw_ptr, alloc) = Box::into_raw_with_allocator(Box::new_in(
+ RcBox {
+ strong: Cell::new(0),
+ weak: Cell::new(1),
+ value: mem::MaybeUninit::<T>::uninit(),
+ },
+ alloc,
+ ));
+ let uninit_ptr: NonNull<_> = (unsafe { &mut *uninit_raw_ptr }).into();
+ let init_ptr: NonNull<RcBox<T>> = uninit_ptr.cast();
+
+ let weak = Weak { ptr: init_ptr, alloc: alloc };
+
+ // It's important we don't give up ownership of the weak pointer, or
+ // else the memory might be freed by the time `data_fn` returns. If
+ // we really wanted to pass ownership, we could create an additional
+ // weak pointer for ourselves, but this would result in additional
+ // updates to the weak reference count which might not be necessary
+ // otherwise.
+ let data = data_fn(&weak);
+
+ let strong = unsafe {
+ let inner = init_ptr.as_ptr();
+ ptr::write(ptr::addr_of_mut!((*inner).value), data);
+
+ let prev_value = (*inner).strong.get();
+ debug_assert_eq!(prev_value, 0, "No prior strong references should exist");
+ (*inner).strong.set(1);
+
+ // Strong references should collectively own a shared weak reference,
+ // so don't run the destructor for our old weak reference.
+ // Calling into_raw_with_allocator has the double effect of giving us back the allocator,
+ // and forgetting the weak reference.
+ let alloc = weak.into_raw_with_allocator().1;
+
+ Rc::from_inner_in(init_ptr, alloc)
+ };
+
+ strong
+ }
+
  /// Constructs a new `Rc<T>` in the provided allocator, returning an error if the allocation
  /// fails
  ///