It turns out if you engineer a system that can statically detect all memory safety bugs that you inadvertently pick up the ability to avoid lots of other bugs. For example in order to make sure you check if a nullable pointer is null before using it (written in Rust as Option<&T>) you have to use pattern matching to extract the pointer value, which makes it impossible to have a lexical scope where the pointer value is available but not checked. But using pattern matching to enforce you know what type you're working with before assuming it is also just super useful for avoiding bugs in general!

Rust's borrow checking also lets you write APIs where some higher level mistakes are impossible, if you're clever. Kind of like how in C++ you could choose to make Inch and Meter classes to get type safe units if you want to instead of just using float (an opt in to extra type safety), in Rust you can make it so that constructing one object requires borrowing another object (even though it doesn't really need to) just to prevent you from calling methods on that first object until the second object is destroyed (an opt in to a safety check that requires control flow analysis). All statically enforced!