Any internal error you encounter should always be reported on the bug tracker..
I know, but I can't report a 10kloc project of code that not 100% belongs to me to the bugtracker. And the funny thing about this is, that as soon as I remove substantial amounts of code this error disappears. It doesn't even matter what parts of the code I remove, to me it seems like it's a problem as soon as the project gets to big
although that is statistically highly unlikely.
Internal errors are written into the code to specify unwanted behavior regarding a specific piece of code and go waaayyyyy beyond exceptions.
You are assuming independence here. Two pieces of unwanted behaviour can still have the same root cause, that just manifested differently. For example if you work on faulty data, a meriad of different errors can occur, even though the cause of the faulty data could always be the same.
Or a concrete example, use after free. This can result in accessing another object of the same kind so you have kindof coherent data with what is expected, it can access a new object at that location, resulting in completely gibberish, it could access the old object which wasn't overridden yet, or it could result in a segfault. These are a bunch of different errors, all stemming from the same root.
An assertion testing for coherent data might not fail in the case of a new object of the same type and accessing the old object, but on a different object it might fail. While a reference check (like checking the name) might fail even on a new object of the same type, but not on accessing the old object.
I would even go so far to say, if you access unknown, random heap objects (which use after free is) pretty much anything can happen. Maybe you override a switch which causes the program to draws a bunch of unicorns all over the screen, who knows, everthing is possible when accessing memory that doesn't belong to you