Rust: Infer argument types based on trait bounds on parameters

[hvitved]

This PR adds support for inferring argument types based on trait bounds on parameters. Example (thanks to @paldepind):

structGen<T>(T);traitContainer<T>{fnget_input(&self) -> T;}fnmy_get<T:Container<i64>>(c:&T) -> bool{ ...}impl<GT:Copy>Container<GT>forGen<GT>{ ... }fntest(){let v = Default::default();let g = Gen(v);my_get(&g);}

In order to determine that the type of v is i64, we need to link the T: Container<i64> constraint in my_get with the impl block.

A similar thing happens for closures:

fnapply<T,F:Fn(T) -> T>(f:F,a:T) -> T{f(a)}let f = |x| x;apply(f,false);

In order to infer that the type of x in the closure is bool, we need to first match T in apply against bool via the false argument, and then match the closure against the trait bound Fn(bool) -> bool.

The former example above is handled entirely by changes to the shared type inference library, where as the second example requires implicitly typed closure parameters to have the special Unknown type, which allows for type information to flow into the parameter.

Additional changes are required for closures that are invoked directly:

let g = |y| y;g(0i32);

In order to infer that the type of y in the closure is i32, we desugar the call to Fn::call(g, (0i32)) using the Fn trait, which makes it an instance of the apply case above. We then need to assign the argument list, (0i32), the 1-ary tuple type (i32).

DCA looks mostly good: As expected, we resolve more calls and consequently generate more alerts. The Nodes With Type At Length Limit increases significantly; one source of this is documented in the regression5 test case, and instead of postponing this PR further, I suggest we look into fixing that follow-up.

[hvitved]

Note that this example has actually nothing to do with the changes in this PR.

[Copilot]

Pull request overview

Adds Rust type inference support for inferring argument/closure parameter types from trait bounds on parameters by linking function constraints to relevant impl blocks and modeling dynamically-invoked closures via Fn*::call_*-style desugaring.

Changes:

• Extend shared type inference constraint satisfaction to propagate types through matching type parameters in constraints.
• Update Rust type inference to better model closures (including dynamic call expressions and argument-list tuple typing) and allow type flow into implicitly-typed closure params.
• Expand/update Rust type-inference and model-generator tests (including new regression coverage) and regenerate expected outputs.

Reviewed changes

Copilot reviewed 10 out of 10 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
shared/typeinference/codeql/typeinference/internal/TypeInference.qll	Extends constraint satisfaction plumbing used by multiple languages.
rust/ql/lib/codeql/rust/internal/typeinference/TypeInference.qll	Enhances Rust inference for closures/dynamic calls and constraint-driven propagation.
rust/ql/lib/codeql/rust/internal/typeinference/TypeMention.qll	Adjusts associated-type resolution to the updated constraint API.
rust/ql/lib/codeql/rust/internal/typeinference/BlanketImplementation.qll	Updates blanket-impl constraint checks to the renamed constraint predicate.
rust/ql/test/library-tests/type-inference/main.rs	Adds a targeted test for inferring argument types via trait bounds on parameters.
rust/ql/test/library-tests/type-inference/closure.rs	Adds/updates closure inference tests (trait-bound driven and dynamic-call cases).
rust/ql/test/library-tests/type-inference/regressions.rs	Adds regressions documenting known spurious resolutions / sibling-impl limitations.
rust/ql/test/utils-tests/modelgenerator/option.rs	Updates model-generator expectations/documentation around a spurious model.
rust/ql/test/library-tests/type-inference/type-inference.expected	Regenerated expected results for expanded inference output.
rust/ql/test/library-tests/type-inference/CONSISTENCY/PathResolutionConsistency.expected	Regenerated consistency expectations after additional resolution.

Comments suppressed due to low confidence (2)

shared/typeinference/codeql/typeinference/internal/TypeInference.qll:1212

• The dissatisfiesConstraint docstring still refers to satisfiesConstraintType, but that predicate was renamed to satisfiesConstraint above. Update the comment to use the new predicate name so the documentation matches the code.

 * This is an approximation of `not satisfiesConstraintType(term, constraint, _, _)`,
* but defined without a negative occurrence of `satisfiesConstraintType`.
*
* Due to the approximation, both `satisfiesConstraintType` and `dissatisfiesConstraint`
* can hold for the same values. For example, if `term` has two different types `t1`

shared/typeinference/codeql/typeinference/internal/TypeInference.qll:1908

• Typo in the comment: "allows us to to infer" has a duplicated "to". Please correct the wording.

 * That is, it allows us to to infer that the type of `y` is `MyThing<i32>`.

[paldepind]

LGTM!