gccrs: Improve deferred operator overload handling.
Enhances operator overload resolution by deferring finalization until more type information is available.
This commit refactors gccrs to better handle operator overloads, particularly when type inference is involved, as seen in libcore. When operator symbols like + or * are ambiguous due to inference variables, the compiler now defers the final resolution of the specific implementation. This allows type-checking to proceed, deferring the specialization until sufficient type hints are gathered, improving the handling of complex expressions and resolving a new test case.
In Details
The operator overload resolution logic in rust-hir-dot-operator.cc and rust-type-util.cc has been enhanced. The MethodResolver::Select now returns an optional result type, and TypeCheckExpr::ResolveOpOverload includes a defer flag. This allows the type checker to continue processing even when an operator overload is ambiguous, deferring its final unification using mechanisms like compute_ambigious_op_overload in rust-typecheck-context.cc until more context is available.
- operator overload
- The ability to define how standard operators (like +, -, *) behave when applied to user-defined types (structs, enums). Rust achieves this through traits like
AddandMul. - type inference
- The process by which a compiler automatically deduces the data types of expressions, variables, and function return values without explicit type annotations. This is a key feature of Rust.
- inference variables
- Temporary placeholders used during type inference. The compiler works to resolve these variables to concrete types as more information becomes available.
- libcore
- A minimal Rust standard library that provides fundamental types and traits, excluding I/O and other platform-specific features. It's often used in embedded development and as a basis for the full standard library.