rust184: add a package for rust 1.84.1 (skipping over 1.84.0).

Pkgsrc changes:
 * Adapt patches, one of the patched files were restructured upstream.
 * Checksum changes.

Upstream changes:

Version 1.84.1 (2025-01-30)
==========================

- [Fix ICE 132920 in duplicate-crate diagnostics.]
  (rust-lang/rust#133304)
- [Fix errors for overlapping impls in incremental rebuilds.]
  (rust-lang/rust#133828)
- [Fix slow compilation related to the next-generation trait solver.]
  (rust-lang/rust#135618)
- [Fix debuginfo when LLVM's location discriminator value limit is exceeded.]
  (rust-lang/rust#135643)
- Fixes for building Rust from source:
  - [Only try to distribute `llvm-objcopy` if llvm tools are enabled.]
    (rust-lang/rust#134240)
  - [Add Profile Override for Non-Git Sources.]
    (rust-lang/rust#135433)
  - [Resolve symlinks of LLVM tool binaries before copying them.]
    (rust-lang/rust#135585)
  - [Make it possible to use ci-rustc on tarball sources.]
    (rust-lang/rust#135722)

Version 1.84.0 (2025-01-09)
==========================

Language
--------
- [Allow `#[deny]` inside `#[forbid]` as a no-op]
  (rust-lang/rust#121560)
- [Show a warning when `-Ctarget-feature` is used to toggle features
  that can lead to unsoundness due to ABI mismatches]
  (rust-lang/rust#129884)
- [Use the next-generation trait solver in coherence]
  (rust-lang/rust#130654)
- [Allow coercions to drop the principal of trait objects]
  (rust-lang/rust#131857)
- [Support `/` as the path separator for `include!()` in all cases on Windows]
  (rust-lang/rust#125205)
- [Taking a raw ref (`raw (const|mut)`) of a deref of a pointer
  (`*ptr`) is now safe]
  (rust-lang/rust#129248)
- [Stabilize s390x inline assembly]
  (rust-lang/rust#131258)
- [Stabilize Arm64EC inline assembly]
  (rust-lang/rust#131781)
- [Lint against creating pointers to immediately dropped temporaries]
  (rust-lang/rust#128985)
- [Execute drop glue when unwinding in an `extern "C"` function]
  (rust-lang/rust#129582)

Compiler
--------
- [Add `--print host-tuple` flag to print the host target tuple
  and affirm the "target tuple" terminology over "target triple"]
  (rust-lang/rust#125579)
- [Declaring functions with a calling convention not supported on
  the current target now triggers a hard error]
  (rust-lang/rust#129935)
- [Set up indirect access to external data for
  `loongarch64-unknown-linux-{musl,ohos}`]
  (rust-lang/rust#131583)
- [Enable XRay instrumentation for LoongArch Linux targets]
  (rust-lang/rust#131818)
- [Extend the `unexpected_cfgs` lint to also warn in external macros]
  (rust-lang/rust#132577)
- [Stabilize WebAssembly `multivalue`, `reference-types`, and
  `tail-call` target features]
  (rust-lang/rust#131080)
- [Added Tier 2 support for the `wasm32v1-none` target]
  (rust-lang/rust#131487)

Libraries
---------
- [Implement `From<&mut {slice}>` for `Box/Rc/Arc<{slice}>`]
  (rust-lang/rust#129329)
- [Move `<float>::copysign`, `<float>::abs`, `<float>::signum` to `core`]
  (rust-lang/rust#131304)
- [Add `LowerExp` and `UpperExp` implementations to `NonZero`]
  (rust-lang/rust#131377)
- [Implement `FromStr` for `CString` and `TryFrom<CString>` for `String`]
  (rust-lang/rust#130608)
- [`std::os::darwin` has been made public]
  (rust-lang/rust#130635)

Stabilized APIs
---------------

- [`Ipv6Addr::is_unique_local`]
  (https://doc.rust-lang.org/stable/core/net/struct.Ipv6Addr.html#method.is_unique_local)
- [`Ipv6Addr::is_unicast_link_local`]
  (https://doc.rust-lang.org/stable/core/net/struct.Ipv6Addr.html#method.is_unicast_link_local)
- [`core::ptr::with_exposed_provenance`]
  (https://doc.rust-lang.org/stable/core/ptr/fn.with_exposed_provenance.html)
- [`core::ptr::with_exposed_provenance_mut`]
  (https://doc.rust-lang.org/stable/core/ptr/fn.with_exposed_provenance_mut.html)
- [`<ptr>::addr`]
  (https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.addr)
- [`<ptr>::expose_provenance`]
  (https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.expose_provenance)
- [`<ptr>::with_addr`]
  (https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.with_addr)
- [`<ptr>::map_addr`]
  (https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.map_addr)
- [`<int>::isqrt`]
  (https://doc.rust-lang.org/stable/core/primitive.i32.html#method.isqrt)
- [`<int>::checked_isqrt`]
  (https://doc.rust-lang.org/stable/core/primitive.i32.html#method.checked_isqrt)
- [`<uint>::isqrt`]
  (https://doc.rust-lang.org/stable/core/primitive.u32.html#method.isqrt)
- [`NonZero::isqrt`]
  (https://doc.rust-lang.org/stable/core/num/struct.NonZero.html#impl-NonZero%3Cu128%3E/method.isqrt)
- [`core::ptr::without_provenance`]
  (https://doc.rust-lang.org/stable/core/ptr/fn.without_provenance.html)
- [`core::ptr::without_provenance_mut`]
  (https://doc.rust-lang.org/stable/core/ptr/fn.without_provenance_mut.html)
- [`core::ptr::dangling`]
  (https://doc.rust-lang.org/stable/core/ptr/fn.dangling.html)
- [`core::ptr::dangling_mut`]
  (https://doc.rust-lang.org/stable/core/ptr/fn.dangling_mut.html)

These APIs are now stable in const contexts

- [`AtomicBool::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicBool.html#method.from_ptr)
- [`AtomicPtr::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicPtr.html#method.from_ptr)
- [`AtomicU8::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicU8.html#method.from_ptr)
- [`AtomicU16::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicU16.html#method.from_ptr)
- [`AtomicU32::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicU32.html#method.from_ptr)
- [`AtomicU64::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicU64.html#method.from_ptr)
- [`AtomicUsize::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicUsize.html#method.from_ptr)
- [`AtomicI8::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicI8.html#method.from_ptr)
- [`AtomicI16::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicI16.html#method.from_ptr)
- [`AtomicI32::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicI32.html#method.from_ptr)
- [`AtomicI64::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicI64.html#method.from_ptr)
- [`AtomicIsize::from_ptr`]
  (https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicIsize.html#method.from_ptr)
- [`<ptr>::is_null`]
  (https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.is_null-1)
- [`<ptr>::as_ref`]
  (https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.as_ref-1)
- [`<ptr>::as_mut`]
  (https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.as_mut)
- [`Pin::new`]
  (https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.new)
- [`Pin::new_unchecked`]
  (https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.new_unchecked)
- [`Pin::get_ref`]
  (https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.get_ref)
- [`Pin::into_ref`]
  (https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.into_ref)
- [`Pin::get_mut`]
  (https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.get_mut)
- [`Pin::get_unchecked_mut`]
  (https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.get_unchecked_mut)
- [`Pin::static_ref`]
  (https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.static_ref)
- [`Pin::static_mut`]
  (https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.static_mut)

Cargo
-----
- [Stabilize MSRV-aware resolver config]
  (rust-lang/cargo#14639)
- [Stabilize resolver v3]
  (rust-lang/cargo#14754)

Rustdoc
-------
- [rustdoc-search: improve type-driven search]
  (rust-lang/rust#127589)

Compatibility Notes
-------------------
- [Enable by default the `LSX` target feature for LoongArch Linux targets]
  (rust-lang/rust#132140)
- [The unstable `-Zprofile` flag ("gcov-style" coverage instrumentation)
  has been removed.](rust-lang/rust#131829)
  This does not affect the stable flags for coverage instrumentation
  (`-Cinstrument-coverage`) and profile-guided optimization
  (`-Cprofile-generate`, `-Cprofile-use`), which are unrelated and
  remain available.
- Support for the target named `wasm32-wasi` has been removed as
  the target is now named `wasm32-wasip1`. This completes the [transition]
  (rust-lang/compiler-team#607)
  [plan](rust-lang/compiler-team#695) for
  this target following [the introduction of `wasm32-wasip1`]
  (rust-lang/rust#120468) in Rust 1.78.
  Compiler warnings on [use of `wasm32-wasi`]
  (rust-lang/rust#126662)
  introduced in Rust 1.81 are now gone as well as the target is
  removed.
- [The syntax `&pin (mut|const) T` is now parsed as a type which
  in theory could affect macro expansion results in some edge cases]
  (rust-lang/rust#130635 (comment))
- [Legacy syntax for calling `std::arch` functions is no longer
  permitted to declare items or bodies (such as closures, inline
  consts, or async blocks).]
  (rust-lang/rust#130443 (comment))
- The `wasm32-unknown-emscripten` target's binary release of the
  standard library is now [built with the latest emsdk 3.1.68]
  (rust-lang/rust#131533), which fixes an
  ABI-incompatibility with Emscripten >= 3.1.42. If you are locally
  using a version of emsdk with an incompatible ABI (e.g. before
  3.1.42 or a future one), you should build your code with `-Zbuild-std`
  to ensure that `std` uses the correct ABI.
- [Declaring functions with a calling convention not supported on
  the current target now triggers a hard error]
  (rust-lang/rust#129935)
- [The next-generation trait solver is now enabled for coherence,
  fixing multiple soundness issues]
  (rust-lang/rust#130654)

rust184/DESCR

@@ -0,0 +1,13 @@
+Rust is a systems programming language focused on three goals: safety,
+speed, and concurrency.  It maintains these goals without having a
+garbage collector, making it a useful language for a number of use cases
+other languages aren't good at: embedding in other languages, programs
+with specific space and time requirements, and writing low-level code,
+like device drivers and operating systems.
+
+It improves on current languages targeting this space by having a number
+of compile-time safety checks that produce no runtime overhead, while
+eliminating all data races.  Rust also aims to achieve "zero-cost
+abstractions" even though some of these abstractions feel like those of
+a high-level language.  Even then, Rust still allows precise control
+like a low-level language would.

rust184/HOWTO-BOOTSTRAP

@@ -0,0 +1,85 @@
+How to build a rust bootstrap kit using pkgsrc
+----------------------------------------------
+
+A rust bootstrap kit is simply a pre-compiled binary of rust and
+the rust standard library, and contains the "rust" and "rust-std"
+build results, found in
+
+   work/rustc-<version>/build/dist/
+as
+   rust-<version>-<target>.tar.xz
+and
+   rust-std-<version>-<target>.tar.xz
+
+These result files are produced when the "dist" build target is
+used, ref. BUILD_TARGET.   For a normal native build of the rust
+pkgsrc package, the default BUILD_TARGET is "build", not "dist".
+
+There are two possible ways to produce a bootstrap kit:
+
+1) a native build.  This requires minimum preparation, except
+   possibly for setting rust.BUILD_TARGET to "dist" via e.g.
+   /etc/mk.conf.  Note that on NetBSD, using the "BUILD_TARGET" ==
+   "dist" results in the "rust-cargo-static" option being set, ref.
+   options.mk.  This is so that the resulting bootstrap kits are
+   built with mostly-static linking, reducing the run-time dependencies
+   of the bootstrap kits.
+
+2) a cross-build.  This requires a bit of preparation:
+
+   For each target you want to cross-build rust for, you need
+     - the cross toolchain resulting from "build.sh tools" for
+       the intended target
+     - an OS distribution extracted, including the comp.tgz
+       set so that the target's include files can be used
+     - for 32-bit ports, the "libatomic" package needs to be
+       available.  I'm sure there's a clever and long-winded
+       use of pkg_install which can be used to effect this;
+       I on my hand have always just extracted the tgz file
+       and done the minimal cleanup of the "cruft" files
+       which are part of the package meta-data.
+     - Pick a root directory for the target, e.g. /u/i386.
+       Below this directory place the "tools" containing
+       the cross-compiler in a "tools" sub-directory.
+       Similarly, the extracted OS distribution in the "dest"
+       sub-directory.
+
+   There are two methods available for doing the cross-compile:
+
+   a) Using the "cross.mk" file.  For an i386 build against i586, the
+      following settings should be active:
+
+CROSS_ROOT=            /u/i386
+MAKE_ENV+=             CROSS_ROOT=${CROSS_ROOT}
+GNU_CROSS_TARGET=      i486--netbsdelf
+MAKE_ENV+=             GNU_CROSS_TARGET=${GNU_CROSS_TARGET}
+TARGET=                i586-unknown-netbsd
+SCRIPTS=               ${WRKDIR}/scripts
+CONFIGURE_ARGS+=       --host=${TARGET}
+CONFIGURE_ARGS+=       --target=${TARGET}
+CONFIGURE_ARGS+=       --set=target.${TARGET}.cc=${SCRIPTS}/gcc-wrap
+CONFIGURE_ARGS+=       --set=target.${TARGET}.cxx=${SCRIPTS}/c++-wrap
+CONFIGURE_ARGS+=       --set=target.${TARGET}.linker=${SCRIPTS}/gcc-wrap
+CONFIGURE_ARGS+=       --set=target.${TARGET}.ar=${CROSS_ROOT}/tools/bin/${GNU_CROSS_TARGET}-ar
+
+      Then doing a "make" will cross-build rust, including the LLVM
+      embedded in the rust distribution, ref. the defaulting of that
+      option when TARGET is defined ref. options.mk.
+
+      Note that when TARGET is set, the default build target for
+      the rust makefile becomes "dist", so there's no need to set
+      rust.BUILD_TARGET for cross-builds.
+
+   b) Using the "do-cross.mk" Makefile.  This will attempt to
+      cross-build rust for all the targets listed in the SHORT_TARGETS
+      variable in that file.  Overriding the root directories for
+      the various targets can be done by making your own "local-roots.mk"
+      file, ref. "do-cross.mk".
+
+      This will create a "dist" subdirectory in the rust pkgsrc
+      directory, and the bootstrap kits for each architecture, plus
+      the library source kit will be placed in this directory.
+
+The bootstrap kits can then be placed in /usr/pkgsrc/distfiles, and
+be used by the "next" rust version, where you can use "make makesum"
+to compute the updated checksums for the bootstrap kits.