Re: [gentoo-user] Fragile rust update is wedged.

[Alan Mackenzie <acm@muc.de>]

Hello, Eli.

On Fri, May 02, 2025 at 13:47:02 -0400, Eli Schwartz wrote:
> On 5/2/25 1:07 PM, Alan Mackenzie wrote:
> > Hello, Gentoo.

> > I've just been trying the update for python 3.13.  It went well on my
> > new machine (well, after unmerging app-portage/unsymlink-lib, which was
> > debris from some 2019 update).

> > On my old machine, however, there was a seg fault while merging rust.
> > This is a known problem in certain first generation Ryzen processors.

> > However, this left the build wedged: emerge says that there's a circular
> > dependency from rust to itself.  More precisely, the error message looks
> > like:


> This is clearly not a python update, then.

Well, it was.  ;-)

> > This would appear to be a bug in the rust ebuild - it has set itself as a
> > builtime dependency before it had been built - or something like that.

> > How do I best recover from this?


> It is not a bug in the rust ebuild -- the rust ebuild has always,
> always, always depended on itself. In the past, the rust ebuild silently
> downloaded a temporary copy of dev-lang/rust-bin to work around this.

I disagree.  By attempting this emerging of rust, and failing, some
persistent information indicating this dependency has been created.  This
persistent information, wherever it is, should not have been created, or
it should have been removed on the emerge failure.

> This was changed in November 2024.

Hmmm...  OK.

> The rust compiler is written in the rust programming language, using
> bleeding-edge features of the most recent version of rust. They are
> aware that this is a bootstrap problem and don't consider it a problem,
> because rust is officially installed by downloading prebuilt binaries
> into $HOME.

This sounds bad, but how is it different from C and C++ in GCC?

> Compiling rust officially requires building the pre 1.0 version of rust,
> itself written in ocaml, and then building *every* version of rust since
> then, one by one, in turn, without skipping a single one. That is over
> 80 different versions of rust, you need to compile all of them in order
> to get to the current one.

No thanks!  There's only so much time left before the Sun becomes a red
giant.  But this attitude must limit the portability of rust to different
processors, such as are found in embedded systems.

> On amd64, you can use the unofficial dev-lang/mrustc (third-party
> reimplementation of rust written in C++) which allows you to skip all
> the way to rust 1.74, and from there it is "only" 13 or so versions to
> build.

Doesn't sound much like a solution.

> Or, you may use rust-bin. Alternatively, you may use:

> ```
> emerge --getbinpkg dev-lang/rust
> ```

I think I'll be going for rust-bin.  This is quite new in Gentoo (in the
last few years, at any rate), but I couldn't find the news item about it
I vaguely remember reading.

Hopefully there's nothing tricky about moving from package foo to
foo-bin.

And then I can, hopefully, finish the update of the python stuff.  Though
I would classify it as a design bug that all python programs need to be
rebuilt just because there's a minor version update in python itself.  We
don't need to do this when a new version of GCC comes out.

> -- 
> Eli Schwartz

-- 
Alan Mackenzie (Nuremberg, Germany).