Rust: Support blanket implementations

[paldepind]

This PR implements method resolution for blanket implementations that satisfies the criteria: the type parameter that the implementation targets has a trait bound.

For instance, this impl block

impl<R: AsyncRead> AsyncReadExt for R {}

is handled as there is a trait bound AsyncRead on the type parameter R.

On the other hand, this impl block

impl<T, U> Into<U> for T where U: From<T> {

is not handled since there is not trait bound for T.

At a high level, the implementation works as follows:

1. For a method call foo.bar check if there's a blanket implementation that has the method bar.
2. For a trait bound on the blanket implementation's type parameter, check if foo satisfies the trait bound.
3. Given the above, resolve foo.bar to the method from the blanket implementation.

If there are multiple trait bounds on the type parameter, then only one is checked to be satisfied. This could give false results, but from looking at some results in doesn't look too bad after filtering away some trivial traits (Clone, Send, etc.).

The DCA report seems great. A 0.819% point increase in resolved calls with little to no change to performance. Some inconsistencies are up, but a good chunk of that is probably explained by more type information in general.

[Copilot]

Pull Request Overview

This PR implements method resolution for blanket implementations in Rust type inference, specifically targeting blanket implementations where the type parameter has trait bounds. The implementation enables CodeQL to better resolve method calls that depend on blanket trait implementations.

Key changes:

• Added support for blanket implementation method resolution with trait bounds
• Enhanced type inference to handle universally quantified type parameters in constraints
• Updated test cases to reflect improved method resolution capabilities

Reviewed Changes

Copilot reviewed 15 out of 15 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
shared/typeinference/codeql/typeinference/internal/TypeInference.qll	Added useUniversalConditions predicate to control constraint satisfaction for universally quantified type parameters
rust/ql/lib/codeql/rust/internal/TypeInference.qll	Core implementation of blanket implementation support including detection, canonicalization, and method resolution
rust/ql/lib/codeql/rust/internal/PathResolution.qll	Added resolveBound method to resolve type parameter bounds by index
rust/ql/test/library-tests/type-inference/blanket_impl.rs	New test file demonstrating blanket implementation scenarios
Multiple test expected files	Updated to reflect improved method resolution results from blanket implementation support

[Copilot]

The hardcoded list of excluded trait names should be extracted to a constant or configuration to improve maintainability and make it easier to extend.

[Copilot]

The heuristic for selecting the 'canonical' implementation based on greatest file name seems fragile and may not always correspond to the greatest library version. Consider documenting the limitations of this approach or exploring more robust versioning detection.

Suggested change

	* version in the path)
	* version in the path). **Note:** This heuristic is fragile and may not always
	* correspond to the greatest library version, as file names may not reliably
	* encode version information and lexicographical order does not match semantic
	* versioning. Users should be aware of this limitation and consider more robust
	* version detection if precise canonicalization is required.