Use constant indices when populating Lists and arrays in collection expressions #80999

Copilot · 2025-11-03T20:28:15Z

Collection expressions: use constant indices when populating Lists and arrays

This PR implements the optimization requested in #70656 to use constant indices instead of an incrementing variable when populating Lists and arrays in collection expressions.

Changes completed:

Implementation details:

The optimization applies to both Lists and arrays when:

Collection expression has known length
Collection expression has no spread elements

When spread elements are present (e.g., [1, 2, ..y]), the index variable is used for ALL elements, including those before the spread, as it's needed for the CopyTo optimization.

The code uses the null state of indexTemp to determine behavior:

indexTemp is null: Use constant compile-time indices (0, 1, 2, etc.)
indexTemp is not null: Use runtime-tracked index variable (for spread elements)

Example improvement:

Before:

List<int> list = new List<int>(3);
CollectionsMarshal.SetCount(list, 3);
Span<int> span = CollectionsMarshal.AsSpan(list);
int index = 0;
span[index] = 1; index++;
span[index] = 2; index++;
span[index] = 3;

// Arrays:
int[] array = new int[3];
int index = 0;
array[index] = 1; index++;
array[index] = 2; index++;
array[index] = 3;

After:

List<int> list = new List<int>(3);
CollectionsMarshal.SetCount(list, 3);
Span<int> span = CollectionsMarshal.AsSpan(list);
span[0] = 1;
span[1] = 2;
span[2] = 3;

// Arrays:
int[] array = new int[3];
array[0] = 1;
array[1] = 2;
array[2] = 3;

Benefits:

Smaller IL code size: 13% reduction (78 → 68 bytes for 3 elements)
Constant indices: Enable better JIT optimizations
Better assembly code: Reduction from 9 steps to 6 per element
Potential vectorization: Constant indices make it easier for JIT to vectorize
Simpler IL: Easier to read and understand
Applies to both Lists and arrays

Security Summary:

No security vulnerabilities were introduced or discovered by this change.

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

…essions This change modifies the compiler to emit constant indices (ldc.i4.0, ldc.i4.1, etc.) instead of using an incrementing index variable when populating a List<T> via CollectionsMarshal.AsSpan<T> in collection expressions without spread elements. Benefits: - Smaller IL code size - Constant indices may enable better JIT optimizations - Potential for vectorization in some cases When spread elements are present, the index variable is still used as it's needed for the CopyTo optimization. Co-authored-by: CyrusNajmabadi <[email protected]>

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs

…iter_CollectionExpression.cs

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs

…iter_CollectionExpression.cs

CyrusNajmabadi · 2025-11-03T21:04:34Z

Note: this leads to a genuine improvement in asm, not just IL. Before, the IL for public static IList<int> M() => [1, 2, 8, 4]; produced:

    L006e: mov [ebp-0x1c], eax
    L0071: lea ecx, [ebp-0x18]
    L0074: mov edx, [ebp-0x1c]
    L0077: call dword ptr [0x22b5fae0]
    L007d: mov [ebp-0x2c], eax
    L0080: mov eax, [ebp-0x2c]
    L0083: mov dword ptr [eax], 1
    L0089: mov eax, [ebp-0x1c]
    L008c: inc eax
    L008d: mov [ebp-0x1c], eax
    L0090: lea ecx, [ebp-0x18]
    L0093: mov edx, [ebp-0x1c]
    L0096: call dword ptr [0x22b5fae0]
    L009c: mov [ebp-0x30], eax
    L009f: mov eax, [ebp-0x30]
    L00a2: mov dword ptr [eax], 2
    L00a8: mov eax, [ebp-0x1c]
    L00ab: inc eax
    L00ac: mov [ebp-0x1c], eax
    L00af: lea ecx, [ebp-0x18]
    L00b2: mov edx, [ebp-0x1c]
    L00b5: call dword ptr [0x22b5fae0]
    L00bb: mov [ebp-0x34], eax
    L00be: mov eax, [ebp-0x34]
    L00c1: mov dword ptr [eax], 8
    L00c7: mov eax, [ebp-0x1c]
    L00ca: inc eax
    L00cb: mov [ebp-0x1c], eax
    L00ce: lea ecx, [ebp-0x18]
    L00d1: mov edx, [ebp-0x1c]
    L00d4: call dword ptr [0x22b5fae0]
    L00da: mov [ebp-0x38], eax
    L00dd: mov eax, [ebp-0x38]
    L00e0: mov dword ptr [eax], 4

after, you get:

    L006e: call dword ptr [0x22b5fae0]
    L0074: mov [ebp-0x28], eax
    L0077: mov eax, [ebp-0x28]
    L007a: mov dword ptr [eax], 1
    L0080: lea ecx, [ebp-0x18]
    L0083: mov edx, 1
    L0088: call dword ptr [0x22b5fae0]
    L008e: mov [ebp-0x2c], eax
    L0091: mov eax, [ebp-0x2c]
    L0094: mov dword ptr [eax], 2
    L009a: lea ecx, [ebp-0x18]
    L009d: mov edx, 2
    L00a2: call dword ptr [0x22b5fae0]
    L00a8: mov [ebp-0x30], eax
    L00ab: mov eax, [ebp-0x30]
    L00ae: mov dword ptr [eax], 8
    L00b4: lea ecx, [ebp-0x18]
    L00b7: mov edx, 3
    L00bc: call dword ptr [0x22b5fae0]
    L00c2: mov [ebp-0x34], eax
    L00c5: mov eax, [ebp-0x34]
    L00c8: mov dword ptr [eax], 4

This is a reduction from 9 steps to 6 per element.

CyrusNajmabadi · 2025-11-03T21:37:55Z

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs

+                // When there are no spread elements, we can use constant indices for better codegen.
+                // When there are spread elements, we need a mutable index variable for the CopyTo optimization.
+                bool useConstantIndices = numberIncludingLastSpread == 0;
+                BoundLocal? indexTemp = null;


review with whitespace off.

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs

CyrusNajmabadi · 2025-11-04T17:11:03Z

@copilot please add a test with a couple of fixed elements before a spread. The test should demonstrate that nothing changed and it keeps the existing behavior, namely that we don't use constant indices for anything. In other words, test this case:

List<int> y = new();
List<int> x = [1, 2, .. y];

Added ListConstruction_FixedElementsBeforeSpread test to verify that when there are fixed elements before a spread element (e.g., [1, 2, ..y]), the compiler uses an index variable for ALL elements instead of constant indices. This confirms the existing behavior is maintained - constant indices are only used when there are no spread elements at all. Co-authored-by: CyrusNajmabadi <[email protected]>

Copilot · 2025-11-04T17:24:41Z

@copilot please add a test with a couple of fixed elements before a spread. The test should demonstrate that nothing changed and it keeps the existing behavior, namely that we don't use constant indi...

Added test ListConstruction_FixedElementsBeforeSpread in commit 877b12b. The test verifies that when there are fixed elements before a spread (e.g., [1, 2, ..y]), the compiler uses an index variable for all elements, maintaining the existing behavior. Constant indices are only used when there are no spread elements at all.

CyrusNajmabadi · 2025-11-04T17:29:41Z

src/Compilers/CSharp/Test/Emit3/Semantics/CollectionExpressionTests.cs

            }
        }

+        [Fact]


@copilot add [Fact, WorkItem("...")]

Added WorkItem attribute in commit bd54c95.

Improved the documentation to clarify that indexTemp's null state indicates whether constant compile-time indices or runtime-tracked index is used. Changed the condition from `numberIncludingLastSpread > 0` to `numberIncludingLastSpread != 0` for consistency. Removed unnecessary Debug.Assert calls that are redundant with the null check. Co-authored-by: CyrusNajmabadi <[email protected]>

RikkiGibson · 2025-11-04T20:50:55Z

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs

+            // When there are spread elements, we need a mutable index variable for the CopyTo optimization.
+            BoundLocal? indexTemp = null;
+
+            if (numberIncludingLastSpread > 0)


Ah. Looking at the code from above, I recall now, that this optimization won't ever kick in, until we extend it so that normal elements before the first spread element use constant indices. Preconditions earlier on this code path, make it so the condition on this line will always be true, as currently written.

Sorry for the runaround.

CyrusNajmabadi · 2025-11-05T00:53:15Z

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs

                },
                tryOptimizeSpreadElement: (ArrayBuilder<BoundExpression> sideEffects, BoundExpression arrayTemp, BoundCollectionExpressionSpreadElement spreadElement, BoundExpression rewrittenSpreadOperand) =>
                {
+                    Debug.Assert(indexTemp is not null);


@copilot add a comment mentioning that if we have spreads we expect o always need an index currently.

Added comments in commit 38fdece to clarify that when spreads are present, we always need a runtime-tracked index variable.

CyrusNajmabadi · 2025-11-05T00:53:29Z

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs

                    },
                    tryOptimizeSpreadElement: (ArrayBuilder<BoundExpression> sideEffects, BoundExpression spanTemp, BoundCollectionExpressionSpreadElement spreadElement, BoundExpression rewrittenSpreadOperand) =>
                    {
+                        Debug.Assert(indexTemp is not null);


@copilot have a similar comment here.

The comment was already added in commit 38fdece at line 1270 (same location).

CyrusNajmabadi · 2025-11-05T00:55:00Z

@jjonescz @333fred ptal. tnx.

…ndex Added comments to clarify that when spread elements are present, we always need a runtime-tracked index variable (indexTemp is not null). Co-authored-by: CyrusNajmabadi <[email protected]>

RikkiGibson

Change LGTM. The array element assignment change won't have an effect until later PR when we use const indices for element preceding the first spread, but I'm fine with that

CyrusNajmabadi · 2025-11-05T21:22:14Z

src/Compilers/CSharp/Test/Emit3/Semantics/CollectionExpressionTests.cs


            verifier.VerifyIL("Program.Main", """
                {
-                  // Code size       96 (0x60)


@copilot for all tests that were updated add [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/71183")] to them to mark them as being part of that issue.

Added WorkItem attributes to all 5 updated tests in commit 2fab349: SpreadElement_Dynamic_05, ListConstruction_01, ListConstruction_Dynamic_04_StaticBinding, Spread_TargetSpan, and List_AddRange_IEnumerable_ClassConstraint.

Added [WorkItem("#71183")] to all tests that had their IL expectations updated to use constant indices: - SpreadElement_Dynamic_05 - ListConstruction_01 - ListConstruction_Dynamic_04_StaticBinding - Spread_TargetSpan - List_AddRange_IEnumerable_ClassConstraint Co-authored-by: CyrusNajmabadi <[email protected]>

Initial plan

536a406

Copilot AI assigned Copilot and CyrusNajmabadi Nov 3, 2025

Copilot started work on behalf of CyrusNajmabadi November 3, 2025 20:28 View session

Copilot AI changed the title ~~[WIP] Update collection expressions to use constant indices~~ Use constant indices when populating List span in collection expressions Nov 3, 2025

Copilot AI requested a review from CyrusNajmabadi November 3, 2025 20:54

Copilot finished work on behalf of CyrusNajmabadi November 3, 2025 20:54

CyrusNajmabadi reviewed Nov 3, 2025

View reviewed changes

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs Outdated Show resolved Hide resolved

Update src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewr…

c210cc9

…iter_CollectionExpression.cs

CyrusNajmabadi reviewed Nov 3, 2025

View reviewed changes

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs Outdated Show resolved Hide resolved

Update src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewr…

738dcea

…iter_CollectionExpression.cs

Fix

7aa7cab

CyrusNajmabadi marked this pull request as ready for review November 3, 2025 21:37

CyrusNajmabadi requested a review from a team as a code owner November 3, 2025 21:37

CyrusNajmabadi reviewed Nov 3, 2025

View reviewed changes

CyrusNajmabadi added the Area-Compilers label Nov 4, 2025

RikkiGibson self-requested a review November 4, 2025 06:08

DoctorKrolic reviewed Nov 4, 2025

View reviewed changes

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs Outdated Show resolved Hide resolved

jcouv added the Feature - Collection Expressions label Nov 4, 2025

Copilot started work on behalf of CyrusNajmabadi November 4, 2025 17:00 View session

Copilot AI requested a review from CyrusNajmabadi November 4, 2025 17:02

Copilot finished work on behalf of CyrusNajmabadi November 4, 2025 17:02

Copilot started work on behalf of CyrusNajmabadi November 4, 2025 17:11 View session

Copilot finished work on behalf of CyrusNajmabadi November 4, 2025 17:25

CyrusNajmabadi reviewed Nov 4, 2025

View reviewed changes

Copilot started work on behalf of CyrusNajmabadi November 4, 2025 20:38 View session

Copilot finished work on behalf of CyrusNajmabadi November 4, 2025 20:46

RikkiGibson reviewed Nov 4, 2025

View reviewed changes

CyrusNajmabadi reviewed Nov 5, 2025

View reviewed changes

Copilot started work on behalf of CyrusNajmabadi November 5, 2025 00:53 View session

CyrusNajmabadi requested review from 333fred and jjonescz November 5, 2025 00:54

Add comments explaining that spreads always require runtime-tracked i…

38fdece

…ndex Added comments to clarify that when spread elements are present, we always need a runtime-tracked index variable (indexTemp is not null). Co-authored-by: CyrusNajmabadi <[email protected]>

Copilot AI requested a review from CyrusNajmabadi November 5, 2025 01:00

Copilot finished work on behalf of CyrusNajmabadi November 5, 2025 01:00

Copilot started work on behalf of CyrusNajmabadi November 5, 2025 01:01 View session

Copilot finished work on behalf of CyrusNajmabadi November 5, 2025 01:04

RikkiGibson approved these changes Nov 5, 2025

View reviewed changes

CyrusNajmabadi reviewed Nov 5, 2025

View reviewed changes

Copilot started work on behalf of CyrusNajmabadi November 5, 2025 21:22 View session

Copilot finished work on behalf of CyrusNajmabadi November 5, 2025 21:32

Copilot AI requested a review from CyrusNajmabadi November 5, 2025 21:32

333fred approved these changes Nov 5, 2025

View reviewed changes

CyrusNajmabadi enabled auto-merge (squash) November 5, 2025 22:59

CyrusNajmabadi merged commit 8b3fbe4 into main Nov 5, 2025
24 of 25 checks passed

dotnet-policy-service bot added this to the Next milestone Nov 5, 2025

CyrusNajmabadi deleted the copilot/use-constant-indices-in-span branch November 6, 2025 00:20

dotnet-bot mentioned this pull request Nov 7, 2025

[Automated] PRs inserted in VS build main-11206.22 #81091

Closed

This was referenced Nov 7, 2025

[release/10.0.2xx] Source code updates from dotnet/roslyn dotnet/dotnet#3244

Open

[main] Source code updates from dotnet/roslyn dotnet/dotnet#3147

Open

dotnet-bot mentioned this pull request Nov 7, 2025

[Automated] PRs inserted in VS build feature.debugger.main-11206.224 #81096

Closed

                           }
                       }
+                      [Fact]

Use constant indices when populating Lists and arrays in collection expressions #80999

Use constant indices when populating Lists and arrays in collection expressions #80999

Uh oh!

Conversation

Copilot AI commented Nov 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Collection expressions: use constant indices when populating Lists and arrays

Changes completed:

Implementation details:

Example improvement:

Benefits:

Security Summary:

Uh oh!

Uh oh!

Uh oh!

CyrusNajmabadi commented Nov 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

CyrusNajmabadi Nov 3, 2025

Choose a reason for hiding this comment

Uh oh!

Uh oh!

CyrusNajmabadi commented Nov 4, 2025

Uh oh!

Copilot AI commented Nov 4, 2025

Uh oh!

CyrusNajmabadi Nov 4, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 4, 2025

Choose a reason for hiding this comment

Uh oh!

RikkiGibson Nov 4, 2025

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi commented Nov 5, 2025

Uh oh!

RikkiGibson left a comment

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

6 participants

Copilot AI commented Nov 3, 2025 •

edited

Loading

CyrusNajmabadi commented Nov 3, 2025 •

edited

Loading