Rust: Improve handling of trait bounds

[paldepind]

This PR improves type inference for trait bounds on type parameters. For instance

fn call_first_trait_per_bound<T: ATrait<Foo, Bar>>(x: T) {
    x.method(); // <- We can now infer the type of this method call
}

where method is a trait method.

This is done by implementing getABaseTypeMention on type parameter types s.t. their bounds are base type mentions and by a small tweak to baseTypeMentionHasNonTypeParameterAt.

To explain and motivate the change to baseTypeMentionHasNonTypeParameterAt consider the C# example below.
I'm not sure if this can actually happen in C#, but we suppose that T is some type parameter in scope and we have:

forall<T> { // <- `T` is in scope, i.e., a fixed type inside this block
  // ..
  class Sub<S> : Super<T, S, Int> { }
}

Here the meaning of S and T in Super are different. T is a fixed type at the class declaration and S is a type parameter of the class and the subclassing (Rust makes this more clear as the type quantification is explicit). Hence the T should actually be handled just like Int, but baseTypeMentionHasNonTypeParameterAt which gives us the "concrete" types in the type mention, would only produce Int and not S, due to not t instanceof TypeParameter.

The above can maybe not happen in C#, but in Rust it does in the following, if we consider SecondTrait<I> to be a base type mention of T:

trait MyTrait<A> { ... }
fn call_first_trait_per_bound<I: Debug, T: MyTrait<I>>(x: T) { ... }

Here we'd like T and it's mention SecondTrait<I> to have at the path A the type I. We make this possible only excluding type parameters of the "subtype" and not all type parameters.

The PR also adds some comments and some tests for type aliases, that are unrelated to the above.

[Copilot]

Pull Request Overview

This PR improves type inference for trait bounds on type parameters by refining the handling of base type mentions and tweaking the evaluation of type parameters in trait bounds. It also adds new test modules to validate the changes in trait bound resolution and type alias handling.

• Introduces the module "type_parameter_bounds" with various functions to test trait method resolution.
• Adds the module "type_aliases" to test generic and non-generic type alias inference.

Files not reviewed (3)

• rust/ql/lib/codeql/rust/internal/Type.qll: Language not supported
• rust/ql/lib/codeql/rust/internal/TypeInference.qll: Language not supported
• shared/typeinference/codeql/typeinference/internal/TypeInference.qll: Language not supported

Comments suppressed due to low confidence (1)

rust/ql/test/library-tests/type-inference/main.rs:546

• The variable 'p3' is declared twice in the same scope in function 'f'; using distinct names may clarify the test cases.

let p3: AnotherPair<S3> = PairOption::PairNone(); // type for `Snd` missing, spurious `S3` for `Fst`

Tip: Leave feedback on Copilot's review comments with the 👎 and 👍 buttons to help improve review quality. Learn more

[Copilot]

The word 'infered' appears in this comment; it should be spelled 'inferred'.

Suggested change

	// Type can be infered from the constructor
	// Type can be inferred from the constructor

[Copilot]

The word 'infered' appears in this comment; it should be spelled 'inferred'.

Suggested change

	// Type can be only infered from the type alias
	// Type can be only inferred from the type alias

[hvitved]

Very nice! Let's wait for DCA before merging.

[paldepind]

DCA is looking fine.