rust188: add a package for rust 1.88.0.

Pkgsrc changes:
 * Adjust patches to adapt to upstream changes and new versions.
 * associated checksums

Upstream changes relative to 1.87.0:

Version 1.88.0 (2025-06-26)
==========================

Language
--------
- [Stabilize `#![feature(let_chains)]` in the 2024 edition.]
  (rust-lang/rust#132833)
  This feature allows `&&`-chaining `let` statements inside `if`
  and `while`, allowing intermixture with boolean expressions. The
  patterns inside the `let` sub-expressions can be irrefutable or
  refutable.
- [Stabilize `#![feature(naked_functions)]`.]
  (rust-lang/rust#134213)
  Naked functions allow writing functions with no compiler-generated
  epilogue and prologue, allowing full control over the generated
  assembly for a particular function.
- [Stabilize `#![feature(cfg_boolean_literals)]`.]
  (rust-lang/rust#138632)
  This allows using boolean literals as `cfg` predicates, e.g.
  `#[cfg(true)]` and `#[cfg(false)]`.
- [Fully de-stabilize the `#[bench]` attribute]
  (rust-lang/rust#134273). Usage of `#[bench]`
  without `#![feature(custom_test_frameworks)]` already triggered
  a deny-by-default future-incompatibility lint since Rust 1.77,
  but will now become a hard error.
- [Add warn-by-default `dangerous_implicit_autorefs` lint against
  implicit autoref of raw pointer dereference.]
  (rust-lang/rust#123239) The
  lint [will be bumped to deny-by-default]
  (rust-lang/rust#141661) in the next
  version of Rust.
- [Add `invalid_null_arguments` lint to prevent invalid usage of
  null pointers.] (rust-lang/rust#119220)
  This lint is uplifted from `clippy::invalid_null_ptr_usage`.
- [Change trait impl candidate preference for builtin impls and
  trivial where-clauses.] (rust-lang/rust#138176)
- [Check types of generic const parameter defaults]
  (rust-lang/rust#139646)

Compiler
--------
- [Stabilize `-Cdwarf-version` for selecting the version of DWARF
  debug information to generate.]
  (rust-lang/rust#136926)

Platform Support
----------------
- [Demote `i686-pc-windows-gnu` to Tier 2.]
  (https://blog.rust-lang.org/2025/05/26/demoting-i686-pc-windows-gnu/)

Refer to Rust's [platform support page][platform-support-doc]
for more information on Rust's tiered platform support.

[platform-support-doc]: https://doc.rust-lang.org/rustc/platform-support.html

Libraries
---------
- [Remove backticks from `#[should_panic]` test failure message.]
  (rust-lang/rust#136160)
- [Guarantee that `[T; N]::from_fn` is generated in order of
  increasing indices.] (rust-lang/rust#139099),
  for those passing it a stateful closure.
- [The libtest flag `--nocapture` is deprecated in favor of the
  more consistent `--no-capture` flag.]
  (rust-lang/rust#139224)
- [Guarantee that `{float}::NAN` is a quiet NaN.]
  (rust-lang/rust#139483)

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

- [`Cell::update`]
  (https://doc.rust-lang.org/stable/std/cell/struct.Cell.html#method.update)
- [`impl Default for *const T`]
  (https://doc.rust-lang.org/nightly/std/primitive.pointer.html#impl-Default-for-*const+T)
- [`impl Default for *mut T`]
  (https://doc.rust-lang.org/nightly/std/primitive.pointer.html#impl-Default-for-*mut+T)
- [`HashMap::extract_if`]
  (https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html#method.extract_if)
- [`HashSet::extract_if`]
  (https://doc.rust-lang.org/stable/std/collections/struct.HashSet.html#method.extract_if)
- [`proc_macro::Span::line`]
  (https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.line)
- [`proc_macro::Span::column`]
  (https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.column)
- [`proc_macro::Span::start`]
  (https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.start)
- [`proc_macro::Span::end`]
  (https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.end)
- [`proc_macro::Span::file`]
  (https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.file)
- [`proc_macro::Span::local_file`]
  (https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.local_file)

These previously stable APIs are now stable in const contexts:

- [`NonNull<T>::replace`]
  (https://doc.rust-lang.org/stable/std/ptr/struct.NonNull.html#method.replace)
- [`<*mut T>::replace`]
  (https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.replace)
- [`std::ptr::swap_nonoverlapping`]
  (rust-lang/rust#137280)
- [`Cell::{replace, get, get_mut, from_mut, as_slice_of_cells}`]
  (rust-lang/rust#137928)

Cargo
-----
- [Stabilize automatic garbage collection.]
  (rust-lang/cargo#14287)
- [use `zlib-rs` for gzip compression in rust code]
  (rust-lang/cargo#15417)

Rustdoc
-----
- [Doctests can be ignored based on target names using `ignore-*` attributes.]
  (rust-lang/rust#137096)
- [Stabilize the `--test-runtool` and `--test-runtool-arg` CLI
  options to specify a program (like qemu) and its arguments to run
  a doctest.] (rust-lang/rust#137096)

Compatibility Notes
-------------------
- [Finish changing the internal representation of pasted tokens]
  (rust-lang/rust#124141). Certain invalid
  declarative macros that were previously accepted in obscure
  circumstances are now correctly rejected by the compiler. Use of
  a `tt` fragment specifier can often fix these macros.
- [Fully de-stabilize the `#[bench]` attribute]
  (rust-lang/rust#134273). Usage of `#[bench]`
  without `#![feature(custom_test_frameworks)]` already triggered
  a deny-by-default future-incompatibility lint since Rust 1.77,
  but will now become a hard error.
- [Fix borrow checking some always-true patterns.]
  (rust-lang/rust#139042) The borrow checker
  was overly permissive in some cases, allowing programs that
  shouldn't have compiled.
- [Update the minimum external LLVM to 19.]
  (rust-lang/rust#139275)
- [Make it a hard error to use a vector type with a non-Rust ABI
  without enabling the required target feature.]
  (rust-lang/rust#139309)

Author: he32

rust188/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.

rust188/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.