MGCA: Support struct expressions without intermediary anon consts #149114

BoxyUwU · 2025-11-19T21:36:30Z

r? oli-obk

tracking issue: #132980

Fixes #127972
Fixes #137888
Fixes #140275

due to delaying a bug instead of ICEing in HIR ty lowering.

High level goal

Under feature(min_generic_const_args) this PR adds another kind of const argument. A struct/variant construction const arg kind. We represent the values of the fields as themselves being const arguments which allows for uses of generic parameters subject to the existing restrictions present in min_generic_const_args:

fn foo<const N: Option<u32>>() {}

trait Trait {
    #[type_const]
    const ASSOC: usize;
}

fn bar<T: Trait, const N: u32>() {
    // the initializer of `_0` is a `N` which is a legal const argument
    // so this is ok.
    foo::<{ Some::<u32> { 0: N } }>();

    // this is allowed as mgca supports uses of assoc consts in the
    // type system. ie `<T as Trait>::ASSOC` is a legal const argument
    foo::<{ Some::<u32> { 0: <T as Trait>::ASSOC } }>();

    // this on the other hand is not allowed as `N + 1` is not a legal
    // const argument
    foo::<{ Some::<u32> { 0: N + 1 } }>();
}

This PR does not support uses of const ctors, e.g. None. And also does not support tuple constructors, e.g. Some(N). I believe that it would not be difficult to add support for such functionality after this PR lands so have left it out deliberately.

We currently require that all generic parameters on the type being constructed be explicitly specified. I haven't really looked into why that is but it doesn't seem desirable to me as it should be legal to write Some { ... } in a const argument inside of a body and have that desugar to Some::<_> { ... }. Regardless this can definitely be a follow-up PR and I assume this is some underlying consistency with the way that elided args are handled with type paths elsewhere.

This PRs implementation of supporting struct expressions is somewhat incomplete. We don't handle Foo { ..expr } at all and aren't handling privacy/stability. The printing of ConstArgKind::Struct HIR nodes doesn't really exist either :')

I've tried to keep the implementation here somewhat deliberately incomplete as I think a number of these issues are actually quite small and self contained after this PR lands and I'm hoping it could be a good set of issues to mentor newer contributors on 🤔 I just wanted the "bare minimum" required to actually demonstrate that the previous changes are "necessary".

`ValTree` now recurse through `ty::Const`

In order to actually represent struct/variant construction in ty::Const without going through an anon const we would need to introduce some new ConstKind variant. Let's say some hypothetical ConstKind::ADT(Ty<'tcx>, List<Const<'tcx>>).

This variant would represent things the same way that ValTree does with the first element representing the VariantIdx of the enum (if its an enum), and then followed by a list of field values in definition order.

This could work but there are a few reasons why it's suboptimal.

First it would mean we have a second kind of Const that can be normalized. Right now we only have ConstKind::Unevaluated which possibly needs normalization. Similarly with TyKind we only have TyKind::Alias. If we introduced ConstKind::ADT it would need to be normalized to a ConstKind::Value eventually. This feels to me like it has the potential to cause bugs in the long run where only ConstKind::Unevaluated is handled by some code paths.

Secondly it would make type equality/inference be kind of... weird... It's desirable for Some { 0: ?x } eq Some { 0: 1_u32 } to result in ?x=1_u32. I can't see a way for this to work with this ConstKind::ADT design under the current architecture for how we represent types/consts and generally do equality operations.

We would need to wholly special case these two variants in type equality and have a custom recursive walker separate from the existing architecture for doing type equality. It would also be somewhat unique in that it's a non-rigid ty::Const (it can be normalized more later on in type inference) while also having somewhat "structural" equality behaviour.

Lastly, it's worth noting that its not actually ConstKind::ADT that we want. It's desirable to extend this setup to also support tuples and arrays, or even references if we wind up supporting those in const generics. Therefore this isn't really ConstKind::ADT but a more general ConstKind::ShallowValue or something to that effect. It represents at least one "layer" of a types value :')

Instead of doing this implementation choice we instead change ValTree::Branch:

enum ValTree<'tcx> {
    Leaf(ScalarInt),
    // Before this PR:
    Branch(Box<[ValTree<'tcx>]>),
    // After this PR
    Branch(Box<[Const<'tcx>]>),
}

The representation for so called "shallow values" is now the same as the representation for the entire full value. The desired inference/type equality behaviour just falls right out of this. We also don't wind up with these shallow values actually being non-rigid. And ValTree already supports references/tuples/arrays so we can handle those just fine.

I think in the future it might be worth considering inlining ValTree into ty::ConstKind. E.g:

enum ConstKind {
    Scalar(Ty<'tcx>, ScalarInt),
    ShallowValue(Ty<'tcx>, List<Const<'tcx>>),
    Unevaluated(UnevaluatedConst<'tcx>),
    ...
}

This would imply that the usage of ValTrees in patterns would now be using ty::Const but they already kind of are anyway and I think that's probably okay in the long run. It also would mean that the set of things we could represent in const patterns is greater which may be desirable in the long run for supporting things such as const patterns of const generic parameters.

Regardless, this PR doesn't actually inline ValTree into ty::ConstKind, it only changes Branch to recurse through Const. This change could be split out of this PR if desired.

I'm not sure if there'll be a perf impact from this change. It's somewhat plausible as now all const pattern values that have nesting will be interning a lot more Tys. We shall see :>

Forbidding generic parameters under mgca

Under mgca we now allow all const arguments to resolve paths to generic parameters. We then later actually validate that the const arg should be allowed to access generic parameters if it did wind up resolving to any.

This winds up just being a lot simpler to implement than trying to make name resolution "keep track" of whether we're inside of a non-anon-const const arg and then encounter a const { ... } indicating we should now stop allowing resolving to generic parameters.

It's also somewhat in line with what we'll need for a feature(generic_const_args) where we'll want to decide whether an anon const should have any generic parameters based off syntactically whether any generic parameters were used. Though that design is entirely hypothetical at this point :)

Followup Work

Make HIR ty lowering check whether lowering generic parameters is supported and if not lower to an error type/const. Should make the code cleaner, fix some other bugs, and maybe(?) recover perf since we'll be accessing less queries which I think is part of the perf regression of this PR
Make the ValTree setup less scuffed. We should find a new name for ConstKind::Value and the Val part of ValTree and ty::Value as they no longer correspond to a fully normalized structure. It may also be worth looking into inlining ValTreeKind into ConstKind or atleast into ty::Value or sth 🤔
Support tuple constructors and const constructors not just struct expressions.
Reduce code duplication between HIR ty lowering's handling of struct expressions, and HIR typeck's handling of struct expressions
Try fix perf MGCA: Support struct expressions without intermediary anon consts #149114 (comment). Maybe this will clear up once we clean up ValTree a bit and stop doing double interning and whatnot

rustbot · 2025-11-19T21:36:34Z

oli-obk is not on the review rotation at the moment.
They may take a while to respond.

BoxyUwU · 2025-11-20T01:16:22Z

@bors try @rust-timer queue

MGCA: Support struct expressions without intermediary anon consts

compiler/rustc_middle/src/arena.rs

compiler/rustc_ast/src/ast.rs

BoxyUwU · 2025-11-20T01:48:27Z

compiler/rustc_ty_utils/src/consts.rs

            let (variant_idx, branches) = if def.is_enum() {
                let (head, rest) = branches.split_first().unwrap();
-                (VariantIdx::from_u32(head.unwrap_leaf().to_u32()), rest)
+                (VariantIdx::from_u32(head.to_value().valtree.unwrap_leaf().to_u32()), rest)


the addition of all the .to_value().valtree everywhere is kind of unfortunate

BoxyUwU · 2025-11-20T01:49:05Z

compiler/rustc_mir_build/src/thir/constant.rs

            // We need a branch for each "level" of the data structure.
            let bytes = ty::ValTree::from_raw_bytes(tcx, byte_sym.as_byte_str());
-            ty::ValTree::from_branches(tcx, [bytes])
+            ty::ValTree::from_branches(tcx, [ty::Const::new_value(tcx, bytes, *inner_ty)])


same with all the extra calls to ty::Const::new_x

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

rust-bors · 2025-11-20T03:33:56Z

☀️ Try build successful (CI)
Build commit: eeb4682 (eeb4682d365158169a665813e65ad6eabb62448b, parent: d2f887349fe3ea079a4f89b020ce6df1993e1e06)

rust-timer · 2025-11-20T04:53:15Z

Finished benchmarking commit (eeb4682): comparison URL.

Overall result: ❌✅ regressions and improvements - please read the text below

Benchmarking this pull request means it may be perf-sensitive – we'll automatically label it not fit for rolling up. You can override this, but we strongly advise not to, due to possible changes in compiler perf.

Next Steps: If you can justify the regressions found in this try perf run, please do so in sufficient writing along with @rustbot label: +perf-regression-triaged. If not, please fix the regressions and do another perf run. If its results are neutral or positive, the label will be automatically removed.

@bors rollup=never
@rustbot label: -S-waiting-on-perf +perf-regression

Instruction count

Our most reliable metric. Used to determine the overall result above. However, even this metric can be noisy.

	mean	range	count
Regressions ❌ (primary)	0.3%	[0.1%, 0.7%]	18
Regressions ❌ (secondary)	0.4%	[0.1%, 0.7%]	8
Improvements ✅ (primary)	-	-	0
Improvements ✅ (secondary)	-0.3%	[-0.5%, -0.1%]	9
All ❌✅ (primary)	0.3%	[0.1%, 0.7%]	18

Max RSS (memory usage)

Results (primary 1.2%, secondary 1.0%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	1.2%	[1.0%, 1.4%]	2
Regressions ❌ (secondary)	1.0%	[1.0%, 1.0%]	1
Improvements ✅ (primary)	-	-	0
Improvements ✅ (secondary)	-	-	0
All ❌✅ (primary)	1.2%	[1.0%, 1.4%]	2

Cycles

Results (secondary -0.1%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	-	-	0
Regressions ❌ (secondary)	3.0%	[3.0%, 3.0%]	1
Improvements ✅ (primary)	-	-	0
Improvements ✅ (secondary)	-3.2%	[-3.2%, -3.2%]	1
All ❌✅ (primary)	-	-	0

Binary size

Results (secondary 0.0%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	-	-	0
Regressions ❌ (secondary)	0.0%	[0.0%, 0.0%]	1
Improvements ✅ (primary)	-	-	0
Improvements ✅ (secondary)	-	-	0
All ❌✅ (primary)	-	-	0

Bootstrap: 474.035s -> 472.627s (-0.30%)
Artifact size: 388.78 MiB -> 388.92 MiB (0.04%)

BoxyUwU · 2025-11-20T06:30:55Z

@bors try @rust-timer queue

rust-bors · 2025-12-21T03:32:19Z

☀️ Try build successful (CI)
Build commit: 1dcb7af (1dcb7af4fb8438f00d3b47ab9a13ab216e579024, parent: cb79c42008b970269f6a06b257e5f04b93f24d03)

rust-timer · 2025-12-21T04:13:26Z

Finished benchmarking commit (1dcb7af): comparison URL.

Overall result: ❌✅ regressions and improvements - please read the text below

Benchmarking this pull request means it may be perf-sensitive – we'll automatically label it not fit for rolling up. You can override this, but we strongly advise not to, due to possible changes in compiler perf.

Next Steps: If you can justify the regressions found in this try perf run, please do so in sufficient writing along with @rustbot label: +perf-regression-triaged. If not, please fix the regressions and do another perf run. If its results are neutral or positive, the label will be automatically removed.

@bors rollup=never
@rustbot label: -S-waiting-on-perf +perf-regression

Instruction count

Our most reliable metric. Used to determine the overall result above. However, even this metric can be noisy.

	mean	range	count
Regressions ❌ (primary)	0.2%	[0.2%, 0.3%]	7
Regressions ❌ (secondary)	0.2%	[0.2%, 0.2%]	2
Improvements ✅ (primary)	-0.1%	[-0.1%, -0.1%]	3
Improvements ✅ (secondary)	-0.3%	[-0.6%, -0.2%]	18
All ❌✅ (primary)	0.1%	[-0.1%, 0.3%]	10

Max RSS (memory usage)

Results (primary -1.9%, secondary 2.3%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	-	-	0
Regressions ❌ (secondary)	2.3%	[1.5%, 3.2%]	2
Improvements ✅ (primary)	-1.9%	[-1.9%, -1.9%]	1
Improvements ✅ (secondary)	-	-	0
All ❌✅ (primary)	-1.9%	[-1.9%, -1.9%]	1

Cycles

Results (secondary -4.5%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	-	-	0
Regressions ❌ (secondary)	-	-	0
Improvements ✅ (primary)	-	-	0
Improvements ✅ (secondary)	-4.5%	[-5.8%, -2.9%]	3
All ❌✅ (primary)	-	-	0

Binary size

This benchmark run did not return any relevant results for this metric.

Bootstrap: 482.897s -> 486.06s (0.66%)
Artifact size: 390.62 MiB -> 390.61 MiB (-0.00%)

lcnr

final nits, then r=me

View changes since this review

compiler/rustc_hir_typeck/src/lib.rs

tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs

rustbot · 2025-12-23T13:55:20Z

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

BoxyUwU · 2025-12-23T14:49:30Z

@bors r=lcnr rollup=never

bors · 2025-12-23T14:49:33Z

📌 Commit 79fd535 has been approved by lcnr

It is now in the queue for this repository.

bors · 2025-12-23T23:53:58Z

⌛ Testing commit 79fd535 with merge 8796b3b...

bors · 2025-12-24T03:01:36Z

☀️ Test successful - checks-actions
Approved by: lcnr
Pushing 8796b3b to main...

github-actions · 2025-12-24T03:04:41Z

What is this?

This is an experimental post-merge analysis report that shows differences in test outcomes between the merged PR and its parent PR.

Comparing 2ca7bcd (parent) -> 8796b3b (this PR)

Test differences

Show 98 test diffs

Stage 1

[crashes] tests/crashes/127972.rs: pass -> [missing] (J0)
[crashes] tests/crashes/137888.rs: pass -> [missing] (J0)
[crashes] tests/crashes/140275.rs: pass -> [missing] (J0)
[ui] tests/ui/const-generics/mgca/adt_expr_arg_simple.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/adt_expr_erroneuous_inits.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/adt_expr_fields_type_check.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/adt_expr_infers_from_value.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-2.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-3.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-4.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-5.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-6.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/struct_expr_with_macros.rs: [missing] -> pass (J0)
[ui] tests/ui/const-generics/mgca/type_const-on-generic_expr-2.rs: [missing] -> pass (J0)
[ui] tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs: pass -> [missing] (J0)

Stage 2

[crashes] tests/crashes/127972.rs: pass -> [missing] (J1)
[crashes] tests/crashes/137888.rs: pass -> [missing] (J1)
[crashes] tests/crashes/140275.rs: pass -> [missing] (J1)
[ui] tests/ui/const-generics/mgca/adt_expr_arg_simple.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/adt_expr_erroneuous_inits.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/adt_expr_fields_type_check.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/adt_expr_infers_from_value.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-2.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-3.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-4.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-5.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/explicit_anon_consts-6.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/struct_expr_with_macros.rs: [missing] -> pass (J2)
[ui] tests/ui/const-generics/mgca/type_const-on-generic_expr-2.rs: [missing] -> pass (J2)
[ui] tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs: pass -> [missing] (J2)

Additionally, 68 doctest diffs were found. These are ignored, as they are noisy.

Job group index

J0: x86_64-gnu-llvm-20-3, x86_64-gnu-llvm-21-3
J1: aarch64-apple, aarch64-gnu, aarch64-gnu-llvm-20-1, aarch64-msvc-1, arm-android, armhf-gnu, dist-i586-gnu-i586-i686-musl, i686-gnu-1, i686-gnu-nopt-1, i686-msvc-1, test-various, x86_64-gnu, x86_64-gnu-gcc, x86_64-gnu-llvm-20-2, x86_64-gnu-llvm-21-2, x86_64-gnu-nopt, x86_64-gnu-stable, x86_64-mingw-1, x86_64-msvc-1
J2: aarch64-apple, aarch64-gnu, aarch64-gnu-llvm-20-1, aarch64-msvc-1, arm-android, armhf-gnu, dist-i586-gnu-i586-i686-musl, i686-gnu-1, i686-gnu-nopt-1, i686-msvc-1, test-various, x86_64-gnu, x86_64-gnu-debug, x86_64-gnu-gcc, x86_64-gnu-llvm-20, x86_64-gnu-llvm-20-2, x86_64-gnu-llvm-21-2, x86_64-gnu-nopt, x86_64-gnu-stable, x86_64-mingw-1, x86_64-msvc-1

Test dashboard

Run

cargo run --manifest-path src/ci/citool/Cargo.toml -- \
    test-dashboard 8796b3b8b4ac6f38a80bf80ce89dd7bd7f92edd7 --output-dir test-dashboard

And then open test-dashboard/index.html in your browser to see an overview of all executed tests.

Job duration changes

dist-x86_64-apple: 7738.5s -> 9315.5s (+20.4%)
aarch64-gnu-llvm-20-1: 3297.3s -> 3814.3s (+15.7%)
x86_64-gnu-tools: 3004.2s -> 3446.2s (+14.7%)
pr-check-1: 1645.3s -> 1883.4s (+14.5%)
aarch64-msvc-2: 5973.8s -> 6766.7s (+13.3%)
i686-gnu-2: 5409.7s -> 6114.4s (+13.0%)
x86_64-gnu-gcc: 3016.0s -> 3403.2s (+12.8%)
x86_64-rust-for-linux: 2669.8s -> 3001.8s (+12.4%)
aarch64-apple: 9626.7s -> 10798.2s (+12.2%)
i686-gnu-nopt-1: 7326.6s -> 8170.6s (+11.5%)

How to interpret the job duration changes?

Job durations can vary a lot, based on the actual runner instance
that executed the job, system noise, invalidated caches, etc. The table above is provided
mostly for t-infra members, for simpler debugging of potential CI slow-downs.

rust-timer · 2025-12-24T03:43:02Z

Finished benchmarking commit (8796b3b): comparison URL.

Overall result: ❌✅ regressions and improvements - please read the text below

Our benchmarks found a performance regression caused by this PR.
This might be an actual regression, but it can also be just noise.

Next Steps:

If the regression was expected or you think it can be justified,
please write a comment with sufficient written justification, and add
@rustbot label: +perf-regression-triaged to it, to mark the regression as triaged.
If you think that you know of a way to resolve the regression, try to create
a new PR with a fix for the regression.
If you do not understand the regression or you think that it is just noise,
you can ask the @rust-lang/wg-compiler-performance working group for help (members of this group
were already notified of this PR).

@rustbot label: +perf-regression
cc @rust-lang/wg-compiler-performance

Instruction count

Our most reliable metric. Used to determine the overall result above. However, even this metric can be noisy.

	mean	range	count
Regressions ❌ (primary)	0.2%	[0.2%, 0.3%]	7
Regressions ❌ (secondary)	-	-	0
Improvements ✅ (primary)	-0.1%	[-0.1%, -0.1%]	1
Improvements ✅ (secondary)	-0.3%	[-0.7%, -0.1%]	19
All ❌✅ (primary)	0.2%	[-0.1%, 0.3%]	8

Max RSS (memory usage)

This benchmark run did not return any relevant results for this metric.

Cycles

Results (primary 2.5%, secondary -2.2%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	2.5%	[2.1%, 3.4%]	3
Regressions ❌ (secondary)	1.7%	[1.7%, 1.7%]	1
Improvements ✅ (primary)	-	-	0
Improvements ✅ (secondary)	-4.2%	[-4.3%, -4.0%]	2
All ❌✅ (primary)	2.5%	[2.1%, 3.4%]	3

Binary size

This benchmark run did not return any relevant results for this metric.

Bootstrap: 481.719s -> 484.054s (0.48%)
Artifact size: 390.35 MiB -> 390.47 MiB (0.03%)

MGCA: Support struct expressions without intermediary anon consts r? oli-obk tracking issue: rust-lang/rust#132980 Fixes rust-lang/rust#127972 Fixes rust-lang/rust#137888 Fixes rust-lang/rust#140275 due to delaying a bug instead of ICEing in HIR ty lowering. ### High level goal Under `feature(min_generic_const_args)` this PR adds another kind of const argument. A struct/variant construction const arg kind. We represent the values of the fields as themselves being const arguments which allows for uses of generic parameters subject to the existing restrictions present in `min_generic_const_args`: ```rust fn foo<const N: Option<u32>>() {} trait Trait { #[type_const] const ASSOC: usize; } fn bar<T: Trait, const N: u32>() { // the initializer of `_0` is a `N` which is a legal const argument // so this is ok. foo::<{ Some::<u32> { 0: N } }>(); // this is allowed as mgca supports uses of assoc consts in the // type system. ie `<T as Trait>::ASSOC` is a legal const argument foo::<{ Some::<u32> { 0: <T as Trait>::ASSOC } }>(); // this on the other hand is not allowed as `N + 1` is not a legal // const argument foo::<{ Some::<u32> { 0: N + 1 } }>(); } ``` This PR does not support uses of const ctors, e.g. `None`. And also does not support tuple constructors, e.g. `Some(N)`. I believe that it would not be difficult to add support for such functionality after this PR lands so have left it out deliberately. We currently require that all generic parameters on the type being constructed be explicitly specified. I haven't really looked into why that is but it doesn't seem desirable to me as it should be legal to write `Some { ... }` in a const argument inside of a body and have that desugar to `Some::<_> { ... }`. Regardless this can definitely be a follow-up PR and I assume this is some underlying consistency with the way that elided args are handled with type paths elsewhere. This PRs implementation of supporting struct expressions is somewhat incomplete. We don't handle `Foo { ..expr }` at all and aren't handling privacy/stability. The printing of `ConstArgKind::Struct` HIR nodes doesn't really exist either :') I've tried to keep the implementation here somewhat deliberately incomplete as I think a number of these issues are actually quite small and self contained after this PR lands and I'm hoping it could be a good set of issues to mentor newer contributors on 🤔 I just wanted the "bare minimum" required to actually demonstrate that the previous changes are "necessary". ### `ValTree` now recurse through `ty::Const` In order to actually represent struct/variant construction in `ty::Const` without going through an anon const we would need to introduce some new `ConstKind` variant. Let's say some hypothetical `ConstKind::ADT(Ty<'tcx>, List<Const<'tcx>>)`. This variant would represent things the same way that `ValTree` does with the first element representing the `VariantIdx` of the enum (if its an enum), and then followed by a list of field values in definition order. This *could* work but there are a few reasons why it's suboptimal. First it would mean we have a second kind of `Const` that can be normalized. Right now we only have `ConstKind::Unevaluated` which possibly needs normalization. Similarly with `TyKind` we *only* have `TyKind::Alias`. If we introduced `ConstKind::ADT` it would need to be normalized to a `ConstKind::Value` eventually. This feels to me like it has the potential to cause bugs in the long run where only `ConstKind::Unevaluated` is handled by some code paths. Secondly it would make type equality/inference be kind of... weird... It's desirable for `Some { 0: ?x } eq Some { 0: 1_u32 }` to result in `?x=1_u32`. I can't see a way for this to work with this `ConstKind::ADT` design under the current architecture for how we represent types/consts and generally do equality operations. We would need to wholly special case these two variants in type equality and have a custom recursive walker separate from the existing architecture for doing type equality. It would also be somewhat unique in that it's a non-rigid `ty::Const` (it can be normalized more later on in type inference) while also having somewhat "structural" equality behaviour. Lastly, it's worth noting that its not *actually* `ConstKind::ADT` that we want. It's desirable to extend this setup to also support tuples and arrays, or even references if we wind up supporting those in const generics. Therefore this isn't really `ConstKind::ADT` but a more general `ConstKind::ShallowValue` or something to that effect. It represents at least one "layer" of a types value :') Instead of doing this implementation choice we instead change `ValTree::Branch`: ```rust enum ValTree<'tcx> { Leaf(ScalarInt), // Before this PR: Branch(Box<[ValTree<'tcx>]>), // After this PR Branch(Box<[Const<'tcx>]>), } ``` The representation for so called "shallow values" is now the same as the representation for the *entire* full value. The desired inference/type equality behaviour just falls right out of this. We also don't wind up with these shallow values actually being non-rigid. And `ValTree` *already* supports references/tuples/arrays so we can handle those just fine. I think in the future it might be worth considering inlining `ValTree` into `ty::ConstKind`. E.g: ```rust enum ConstKind { Scalar(Ty<'tcx>, ScalarInt), ShallowValue(Ty<'tcx>, List<Const<'tcx>>), Unevaluated(UnevaluatedConst<'tcx>), ... } ``` This would imply that the usage of `ValTree`s in patterns would now be using `ty::Const` but they already kind of are anyway and I think that's probably okay in the long run. It also would mean that the set of things we *could* represent in const patterns is greater which may be desirable in the long run for supporting things such as const patterns of const generic parameters. Regardless, this PR doesn't actually inline `ValTree` into `ty::ConstKind`, it only changes `Branch` to recurse through `Const`. This change could be split out of this PR if desired. I'm not sure if there'll be a perf impact from this change. It's somewhat plausible as now all const pattern values that have nesting will be interning a lot more `Ty`s. We shall see :> ### Forbidding generic parameters under mgca Under mgca we now allow all const arguments to resolve paths to generic parameters. We then *later* actually validate that the const arg should be allowed to access generic parameters if it did wind up resolving to any. This winds up just being a lot simpler to implement than trying to make name resolution "keep track" of whether we're inside of a non-anon-const const arg and then encounter a `const { ... }` indicating we should now stop allowing resolving to generic parameters. It's also somewhat in line with what we'll need for a `feature(generic_const_args)` where we'll want to decide whether an anon const should have any generic parameters based off syntactically whether any generic parameters were used. Though that design is entirely hypothetical at this point :) ### Followup Work - Make HIR ty lowering check whether lowering generic parameters is supported and if not lower to an error type/const. Should make the code cleaner, fix some other bugs, and maybe(?) recover perf since we'll be accessing less queries which I think is part of the perf regression of this PR - Make the ValTree setup less scuffed. We should find a new name for `ConstKind::Value` and the `Val` part of `ValTree` and `ty::Value` as they no longer correspond to a fully normalized structure. It may also be worth looking into inlining `ValTreeKind` into `ConstKind` or atleast into `ty::Value` or sth 🤔 - Support tuple constructors and const constructors not just struct expressions. - Reduce code duplication between HIR ty lowering's handling of struct expressions, and HIR typeck's handling of struct expressions - Try fix perf rust-lang/rust#149114 (comment). Maybe this will clear up once we clean up `ValTree` a bit and stop doing double interning and whatnot

rustbot assigned oli-obk Nov 19, 2025

BoxyUwU force-pushed the mgca_adt_exprs branch from 0dbf003 to a019ac7 Compare November 19, 2025 21:45