upvote

points

by mitxela7 hours ago |
comments
upvoteby simonask7 hours ago|
[-]
No, Rust does not allow that. The current Rust compiler does, but that’s a bug that is being fixed.

At some point in the future, a fully backwards compatible Rust compiler will report an error when you try to compile cve-rs.

reply
upvoteby nick__m6 hours ago|
parent|
next
[-]
Since we are not at some point in the future where that correct compiler exists and there is only one official compiler, the distinction you make is practically meaningless!
reply
upvoteby simonask4 hours ago|
parent|
[-]
I mean… no? It matters whether something is a part of the language or not, because it matters if you can write code relying on this behavior. Since this is a compiler bug, you cannot - the code will stop compiling the moment the bug is fixed.

There are no known instances of this bug being encountered in the wild, and if you look into it, you will see how extremely unlikely such code is.

reply
upvoteby ghusbands6 hours ago|
parent|
prev|
next
[-]
Isn't one of the bugs around ten years old, now? Isn't ten years enough to call something a feature of the language rather than a bug?

I like Rust, but with this bug existing for so long, I personally no longer think of it as memory-safe.

reply
upvoteby aw16211074 hours ago|
parent|
[-]
> Isn't ten years enough to call something a feature of the language rather than a bug?

I suppose it depends on who is doing the classifying? From the developer's standpoint I'd imagine intent is all that matters: a bug is something that does not match developer intent and that is (eventually) expected to be changed to match the intent, while a feature is something that does match developer intent regardless of how old/new it is. From a user's standpoint I'd imagine it's a combination of developer intent and the user's reliance on said behavior, but IIRC in this particular case there's no known non-demo code that has organically run into this particular bug so there's little weight in favor of calling the bug a feature despite the devs' stance.

Also as GP said I think one needs to be careful to distinguish between the compiler and the language. IIRC the devs have known for basically this entire time exactly in what manner the Rust compiler fail to implement the rules of Rust the language, but a general fix has been blocked on long-running projects that have only recently been approaching the finish line [1].

[0]: https://news.ycombinator.com/item?id=40431444

[1]: https://blog.rust-lang.org/2026/08/21/enabling-next-solver-o...

reply
upvoteby mitxela5 hours ago|
parent|
prev|
next
[-]
I define undefined behaviour as a bug in C++. Now C++ is memory-safe!

btw, it's not actually that hard to write correct code in C++, easier than in C because you have all the container types. The problem is that nothing will tell you when you write incorrect code - there's no guarantee.

reply
upvoteby simonask4 hours ago|
parent|
next
[-]
UB is part of the C++ standard. Surely you can understand the difference between the C++ standard and bugs in compilers implementing the C++ standard. This is that.
reply
upvoteby aw16211074 hours ago|
parent|
prev|
[-]
> I define undefined behaviour as a bug in C++. Now C++ is memory-safe!

I mean, sure, insofar as such a thing would also imply that a) the standard would need quite a bit of cleanup/clarification work to not contradict your definition, and b) the main optimizing C++ compilers are miscompiling code, analogous to how cve-rs is a rustc miscompilation rather than an issue with Rust itself.

(Fil-C might be an interesting exception here, though IIRC its definition of memory safety is slightly different)

reply
upvoteby zephen2 hours ago|
parent|
prev|
[-]
And yet, there's a C compiler (fil-c) that doesn't allow that.
reply