rust190: add a package for rust 1.90.0.

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

Upstream changes relative to 1.89.0:

Version 1.90 (2025-09-18)
==========================

Language
--------
- [Split up the `unknown_or_malformed_diagnostic_attributes` lint]
  (rust-lang/rust#140717). This lint has
  been split up into four finer-grained lints, with
  `unknown_or_malformed_diagnostic_attributes` now being the lint
  group that contains these lints:
    1. `unknown_diagnostic_attributes`: unknown to the current compiler
    2. `misplaced_diagnostic_attributes`: placed on the wrong item
    3. `malformed_diagnostic_attributes`: malformed attribute syntax or options
    4. `malformed_diagnostic_format_literals`: malformed format string literal
- [Allow constants whose final value has references to mutable/external
  memory, but reject such constants as patterns]
  (rust-lang/rust#140942)
- [Allow volatile access to non-Rust memory, including address 0]
  (rust-lang/rust#141260)

Compiler
--------
- [Use `lld` by default on `x86_64-unknown-linux-gnu`]
  (rust-lang/rust#140525).
- [Tier 3 `musl` targets now link dynamically by default]
  (rust-lang/rust#144410). Affected targets:
    - `mips64-unknown-linux-muslabi64`
    - `powerpc64-unknown-linux-musl`
    - `powerpc-unknown-linux-musl`
    - `powerpc-unknown-linux-muslspe`
    - `riscv32gc-unknown-linux-musl`
    - `s390x-unknown-linux-musl`
    - `thumbv7neon-unknown-linux-musleabihf`

Platform Support
----------------
- [Demote `x86_64-apple-darwin` to Tier 2 with host tools]
  (rust-lang/rust#145252)

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
---------
- [Stabilize `u*::{checked,overflowing,saturating,wrapping}_sub_signed`]
  (rust-lang/rust#126043)
- [Allow comparisons between `CStr`, `CString`, and `Cow<CStr>`]
  (rust-lang/rust#137268)
- [Remove some unsized tuple impls since unsized tuples can't be constructed]
  (rust-lang/rust#138340)
- [Set `MSG_NOSIGNAL` for `UnixStream`]
  (rust-lang/rust#140005)
- [`proc_macro::Ident::new` now supports `$crate`.]
  (rust-lang/rust#141996)
- [Guarantee the pointer returned from `Thread::into_raw` has at
  least 8 bytes of alignment]
  (rust-lang/rust#143859)

Stabilized APIs
---------------
- [`u{n}::checked_sub_signed`]
  (https://doc.rust-lang.org/stable/std/primitive.usize.html#method.checked_sub_signed)
- [`u{n}::overflowing_sub_signed`]
  (https://doc.rust-lang.org/stable/std/primitive.usize.html#method.overflowing_sub_signed)
- [`u{n}::saturating_sub_signed`]
  (https://doc.rust-lang.org/stable/std/primitive.usize.html#method.saturating_sub_signed)
- [`u{n}::wrapping_sub_signed`]
  (https://doc.rust-lang.org/stable/std/primitive.usize.html#method.wrapping_sub_signed)
- [`impl Copy for IntErrorKind`]
  (https://doc.rust-lang.org/stable/std/num/enum.IntErrorKind.html#impl-Copy-for-IntErrorKind)
- [`impl Hash for IntErrorKind`]
  (https://doc.rust-lang.org/stable/std/num/enum.IntErrorKind.html#impl-Hash-for-IntErrorKind)
- [`impl PartialEq<&CStr> for CStr`]
  (https://doc.rust-lang.org/stable/std/ffi/struct.CStr.html#impl-PartialEq%3C%26CStr%3E-for-CStr)
- [`impl PartialEq<CString> for CStr`]
  (https://doc.rust-lang.org/stable/std/ffi/struct.CStr.html#impl-PartialEq%3CCString%3E-for-CStr)
- [`impl PartialEq<Cow<CStr>> for CStr`]
  (https://doc.rust-lang.org/stable/std/ffi/struct.CStr.html#impl-PartialEq%3CCow%3C'_,+CStr%3E%3E-for-CStr)
- [`impl PartialEq<&CStr> for CString`]
  (https://doc.rust-lang.org/stable/std/ffi/struct.CString.html#impl-PartialEq%3C%26CStr%3E-for-CString)
- [`impl PartialEq<CStr> for CString`]
  (https://doc.rust-lang.org/stable/std/ffi/struct.CString.html#impl-PartialEq%3CCStr%3E-for-CString)
- [`impl PartialEq<Cow<CStr>> for CString`]
  (https://doc.rust-lang.org/stable/std/ffi/struct.CString.html#impl-PartialEq%3CCow%3C'_,+CStr%3E%3E-for-CString)
- [`impl PartialEq<&CStr> for Cow<CStr>`]
  (https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html#impl-PartialEq%3C%26CStr%3E-for-Cow%3C'_,+CStr%3E)
- [`impl PartialEq<CStr> for Cow<CStr>`]
  (https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html#impl-PartialEq%3CCStr%3E-for-Cow%3C'_,+CStr%3E)
- [`impl PartialEq<CString> for Cow<CStr>`]
  (https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html#impl-PartialEq%3CCString%3E-for-Cow%3C'_,+CStr%3E)

These previously stable APIs are now stable in const contexts:

- [`<[T]>::reverse`]
  (https://doc.rust-lang.org/stable/std/primitive.slice.html#method.reverse)
- [`f32::floor`]
  (https://doc.rust-lang.org/stable/std/primitive.f32.html#method.floor)
- [`f32::ceil`]
  (https://doc.rust-lang.org/stable/std/primitive.f32.html#method.ceil)
- [`f32::trunc`]
  (https://doc.rust-lang.org/stable/std/primitive.f32.html#method.trunc)
- [`f32::fract`]
  (https://doc.rust-lang.org/stable/std/primitive.f32.html#method.fract)
- [`f32::round`]
  (https://doc.rust-lang.org/stable/std/primitive.f32.html#method.round)
- [`f32::round_ties_even`]
  (https://doc.rust-lang.org/stable/std/primitive.f32.html#method.round_ties_even)
- [`f64::floor`]
  (https://doc.rust-lang.org/stable/std/primitive.f64.html#method.floor)
- [`f64::ceil`]
  (https://doc.rust-lang.org/stable/std/primitive.f64.html#method.ceil)
- [`f64::trunc`]
  (https://doc.rust-lang.org/stable/std/primitive.f64.html#method.trunc)
- [`f64::fract`]
  (https://doc.rust-lang.org/stable/std/primitive.f64.html#method.fract)
- [`f64::round`]
  (https://doc.rust-lang.org/stable/std/primitive.f64.html#method.round)
- [`f64::round_ties_even`]
  (https://doc.rust-lang.org/stable/std/primitive.f64.html#method.round_ties_even)

Cargo
-----
- [Add `http.proxy-cainfo` config for proxy certs]
  (rust-lang/cargo#15374)
- [Use `gix` for `cargo package`]
  (rust-lang/cargo#15534)
- [feat(publish): Stabilize multi-package publishing]
  (rust-lang/cargo#15636)

Rustdoc
-----
- [Add ways to collapse all impl blocks]
  (rust-lang/rust#141663). Previously the
  "Summary" button and "-" keyboard shortcut would never collapse
  `impl` blocks, now they do when shift is held
- [Display unsafe attributes with `unsafe()` wrappers]
  (rust-lang/rust#143662)

Compatibility Notes
-------------------
- [Use `lld` by default on `x86_64-unknown-linux-gnu`]
  (rust-lang/rust#140525).
  See also <https://blog.rust-lang.org/2025/09/01/rust-lld-on-1.90.0-stable/>.
- [Make `core::iter::Fuse`'s `Default` impl construct `I::default()`
  internally as promised in the docs instead of always being empty]
  (rust-lang/rust#140985)
- [Set `MSG_NOSIGNAL` for `UnixStream`]
  (rust-lang/rust#140005) This may change
  program behavior but results in the same behavior as other
  primitives (e.g., stdout, network sockets).  Programs relying on
  signals to terminate them should update handling of sockets to
  handle errors on write by exiting.
- [On Unix `std::env::home_dir` will use the fallback if the `HOME`
  environment variable is empty]
  (rust-lang/rust#141840)
- We now [reject unsupported `extern "{abi}"`s consistently in all
  positions] (rust-lang/rust#142134). This
  primarily affects the use of implementing traits on an `extern
  "{abi}"` function pointer, like `extern "stdcall" fn()`, on a
  platform that doesn't support that, like aarch64-unknown-linux-gnu.
  Direct usage of these unsupported ABI strings by declaring or
  defining functions was already rejected, so this is only a change
  for consistency.
- [const-eval: error when initializing a static writes to that static]
  (rust-lang/rust#143084)
- [Check that the `proc_macro_derive` macro has correct arguments
  when applied to the crate root]
  (rust-lang/rust#143607)

Author: he32

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

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