bug fix(semantic): Substitute result of generic const function calls. - #10143

Summary

When a generic const fn returns an aggregate value (struct, tuple, or enum), the returned ConstValue was tagged with the generic types from the function body rather than the concrete types at the call site. This caused type mismatches when using generic const functions that construct and return aggregate types.

The fix applies substitute to the type of each aggregate ConstValue (struct, tuple, and enum variant) during constant evaluation, replacing generic type parameters with the concrete types from the call site.

Type of change

Please check one:

• Bug fix (fixes incorrect behavior)
• New feature
• Performance improvement
• Documentation change with concrete technical impact
• Style, wording, formatting, or typo-only change

Why is this change needed?

Generic const fns that return structs, tuples, or enums were producing ConstValues tagged with the generic type parameters from the function body. At the call site, the expected type is the concrete substituted type, so the mismatch caused incorrect constant evaluation results.

What was the behavior or documentation before?

A generic const fn returning an aggregate (e.g., Pair<T>, (T, T), or Either<T>) would produce a ConstValue whose inner type was still the generic T rather than the concrete type (e.g., felt252) supplied at the call site.

What is the behavior or documentation after?

After evaluating each aggregate expression inside a generic const fn, the type attached to the resulting ConstValue is passed through self.substitute(...) so that structs, tuples, and enum variants are tagged with the concrete types from the call site. Three new tests cover this behavior:

• test_const_generic_struct_ctor — generic const fn returning a struct
• test_const_generic_tuple_return — generic const fn returning a tuple
• test_const_generic_enum_return — generic const fn returning an enum variant

Related issue or discussion (if any)

Additional context

For enum variants, substitute is applied to the entire ConcreteVariant (not just its type) to ensure all generic parameters embedded in the variant descriptor are also resolved to their concrete forms.