checks/errors: Fix non-exhaustive pattern matching for literals

[Pasta-coder]

The compiler previously treated literal patterns (like 0, 'a', or true) as
wildcards, causing the exhaustiveness checker to incorrectly accept incomplete
match blocks.

This patch modifies lower_pattern to lower literals into integer ranges
using std::strtoll (for -fno-exceptions compatibility). It updates
split_constructors to handle finite boolean universes and defaults other
scalars to wildcards.

Additionally, WitnessMatrix::apply_constructor and WitnessPat::to_string
are updated to handle INT_RANGE constructors, preventing Internal Compiler
Errors (ICEs). Existing tests were updated to include wildcard arms to
satisfy the correct exhaustiveness checks.

Fixes #4296

gcc/rust/ChangeLog:

* checks/errors/rust-hir-pattern-analysis.h (Constructor::make_int_range):
Add helper to create integer range constructors.
* checks/errors/rust-hir-pattern-analysis.cc (lower_pattern): Lower
literals (int, bool, char) to integer ranges.
(split_constructors): Handle integer, bool, and char types correctly.
(WitnessPat::to_string): Handle INT_RANGE to prevent ICE.
(WitnessMatrix::apply_constructor): Handle INT_RANGE to prevent ICE.

gcc/testsuite/ChangeLog:

* rust/compile/issue-4296.rs: New test.
* rust/compile/issue-3929-2.rs: Add wildcard arm to match block.
* rust/execute/torture/struct-pattern-match.rs: Add wildcard arm.

• GCC development requires copyright assignment or the Developer's Certificate of Origin sign-off, see https://gcc.gnu.org/contribute.html or https://gcc.gnu.org/dco.html
• Read contributing guidlines
• make check-rust passes locally
• Run clang-format
• Added any relevant test cases to gcc/testsuite/rust/

[Pasta-coder]

replaced the wildcard stub in lower_pattern with actual literal lowering using std::strtoll. I then updated split_constructors to handle primitive types correctly—defining Booleans as a finite set {true, false} and Integers as requiring a wildcard. Finally, I patched the Witness functions to handle INT_RANGE constructors to prevent ICEs and updated existing tests that were relying on the previous buggy behavior.

[Pasta-coder]

Sequence of Changes:

Lowering (lower_pattern):

• Replaced the wildcard stub with actual literal parsing.
• Used std::strtoll for integer parsing to satisfy -fno-exceptions.
• Lowered all literals (Int, Bool, Char) into Constructor::INT_RANGE.

Analysis Logic (split_constructors):

• Booleans: Defined universe as finite set {false, true}.
• Integers/Chars: Defined universe as wildcard (_) to force exhaustiveness.
• Safety: Removed aggressive assertions to prevent crashes on non-ADT types (Tuples, Refs).

Crash Prevention (Witness Functions):

• Updated WitnessMatrix::apply_constructor and WitnessPat::to_string to explicitly handle INT_RANGE constructors instead of hitting rust_unreachable() and crashing.

Verification (Tests):

• Added issue-4296.rs to verify the fix.
• Updated issue-3929-2.rs and struct-pattern-match.rs by adding wildcard arms, as they were previously passing only due to the bug.

[Pasta-coder]

final updates

Regression Fix (Integer Parsing):

• The addition of the parse_check_literal static helper correctly handles Rust-specific syntax that strtoll missed.
• Underscores: 1_000 is now correctly sanitized to 1000.
• Suffixes: 10u8 is correctly truncated to 10 before parsing.
• Bases: 0x, 0b, 0o prefixes are correctly detected and handled.

Safety Fix (Unicode/Hex Chars):

The explicit check for \u and \x in the CHAR case prevents the unsafe cast behavior. Returning a Wildcard here is a safe fallback that prevents ICEs (Internal Compiler Errors) while acknowledging (via the FIXME) that full Unicode support is a future task.

Logic Logic:

The split_constructors update correctly distinguishes BOOL (finite) from other types (wildcard required), ensuring standard match blocks behave as expected.