Support using `string.Concat(ReadOnlySpan<string>)` for string lowering #81788

333fred · 2025-12-22T20:00:36Z

Closes #74538. We now support using string.Concat(ReadOnlySpan<string>), instead of string.Concat(string[]), where available. This allows us to avoid an allocation of an array, and takes advantage of the inline array support already added for collection expressions and params ReadOnlySpan<T>. On runtimes that do not support inline arrays, the new overloads do not light up. Also added is support for interpolated strings to lower to this form, preferring that over DefaultInterpolatedStringHandler when all components are strings for performance.

Closes dotnet#74538. We now support using `string.Concat(ReadOnlySpan<string>)`, instead of `string.Concat(string[])`, where available. This allows us to avoid an allocation of an array, and takes advantage of the inline array support already added for collection expressions and `params ReadOnlySpan<T>`. On runtimes that do not support inline arrays, the new overloads do not light up. Also added is support for interpolated strings to lower to this form, preferring that over `DefaultInterpolatedStringHandler` when all components are strings for performance.

src/Compilers/CSharp/Portable/Binder/Binder_InterpolatedString.cs

333fred · 2025-12-22T21:56:07Z

@dotnet/roslyn-compiler for reviews. /cc @stephentoub

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs

AlekseyTs · 2025-12-23T18:27:11Z

@333fred It looks like there are legitimate test failures

src/Compilers/CSharp/Portable/Binder/Binder_InterpolatedString.cs

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

AlekseyTs · 2025-12-26T18:08:34Z

    private BoundExpression CreateStringConcat(SyntaxNode originalSyntax, ArrayBuilder<BoundExpression> visitedArguments)

It would be good to add a comment that this method mutates visitedArguments #Closed

Refers to: src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs:72 in 3eb40ea. [](commit_id = 3eb40ea, deletion_comment = False)

AlekseyTs · 2025-12-26T18:10:23Z

    private BoundExpression CreateStringConcat(SyntaxNode originalSyntax, ArrayBuilder<BoundExpression> visitedArguments)

It even frees the builder

In reply to: 3693188522

Refers to: src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs:72 in 3eb40ea. [](commit_id = 3eb40ea, deletion_comment = False)

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

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs

AlekseyTs · 2025-12-27T00:13:09Z

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

+                        if (_compilation.Assembly.RuntimeSupportsInlineArrayTypes
+                            && TryGetSpecialTypeMethod(originalSyntax, SpecialMember.System_String__ConcatReadOnlySpanString, out concatMethod, isOptional: true))
+                        {
+                            finalArguments = [CreateAndPopulateSpanFromInlineArray(


CreateAndPopulateSpanFromInlineArray

It looks like there is no guarantee that we are going to get an instance of InternalSpecialType.System_ReadOnlySpan_T back

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs

AlekseyTs · 2025-12-27T00:19:07Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs

+                  .maxstack  4
+                  .locals init (char V_0, //c
+                                char V_1, //d
+                                System.Runtime.CompilerServices.InlineArray6<string> V_2,


System.Runtime.CompilerServices.InlineArray6 V_2

Is it possible to reuse the inline array instance?

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs

AlekseyTs · 2025-12-27T00:22:28Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs


 #nullable disable

+using System.Linq;


Are both added usings used?

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs

AlekseyTs · 2025-12-27T00:26:16Z

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs

+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        verifier = CompileAndVerify(comp, expectedOutput: ExecutionConditionUtil.IsCoreClr ? "abcde" : null, verify: Verification.Fails);


Fails

FailsPEVerify?

Similar for added tests below

No, these all Fail regardless, as InlineArrayAsReadOnlySpan does not pass ILVerify.

AlekseyTs · 2025-12-27T00:30:04Z

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs

+              IL_0040:  ldloca.s   V_1
+              IL_0042:  ldc.i4.5
+              IL_0043:  call       "System.ReadOnlySpan<string> <PrivateImplementationDetails>.InlineArrayAsReadOnlySpan<System.Runtime.CompilerServices.InlineArray5<string>, string>(in System.Runtime.CompilerServices.InlineArray5<string>, int)"
+              IL_0048:  call       "string string.Concat(params System.ReadOnlySpan<string>)"


string string.Concat(params System.ReadOnlySpan)

Should we be clearing content of the inline array on the stack?

AlekseyTs · 2025-12-27T00:32:41Z

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs

+              .locals init (string V_0, //s
+                            System.Runtime.CompilerServices.InlineArray5<string> V_1,
+                            System.Runtime.CompilerServices.InlineArray6<string> V_2,
+                            System.Runtime.CompilerServices.InlineArray7<string> V_3)


System.Runtime.CompilerServices.InlineArray7 V_3

Perhaps we could accomplish the task with just this array allocated on the stack.

AlekseyTs · 2025-12-27T00:35:53Z

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs

+                System.Console.WriteLine(s + s + s + s + s);
+                """;
+
+        var comp = CreateCompilation(source, targetFramework: TargetFramework.Net100);


targetFramework: TargetFramework.Net100

I think this test can target default TargetFramework

No, I'm intentionally testing where string.Concat(params ReadOnlySpan<string>) exists, but the runtime does not have inline array support.

AlekseyTs · 2025-12-27T00:38:48Z

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs

+        var comp = CreateCompilation(source, targetFramework: TargetFramework.Net100);
+        var verifier = CompileAndVerify(comp, expectedOutput: ExecutionConditionUtil.IsCoreClr ? "aaaaa" : null, verify: Verification.FailsPEVerify);
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("<top-level-statements-entry-point>", """


verifier.VerifyIL("", """

Consider dropping IL verification for this scenario and instead asserting the expression tree shape.

AlekseyTs · 2025-12-27T00:39:16Z

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs

 #nullable disable

+using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;


Is this using used?

Assuming you meant the Linq using, yes, Enumerable.Repeat is used below.

AlekseyTs · 2025-12-27T00:41:41Z

src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs

+                123
+                1234
+                12345
+                """ : null, verify: Verification.Skipped);


Skipped

FailsPEVerify?

src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs

AlekseyTs · 2025-12-27T00:46:22Z

src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs

+                System.Console.WriteLine({expression});
+                """;
+
+            var comp = CreateCompilation(code, targetFramework: TargetFramework.Net100);


targetFramework: TargetFramework.Net100

Can this test use default TargetFramework?

No. I'm intentionally testing when params ReadOnlySpan<string> exists, but inline arrays are not supported by the runtime.

AlekseyTs · 2025-12-27T00:49:07Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs

+                  IL_0002:  initobj    "System.Runtime.CompilerServices.InlineArray5<string>"
+                  IL_0008:  ldloca.s   V_0
+                  IL_000a:  ldc.i4.0
+                  IL_000b:  call       "ref string <PrivateImplementationDetails>.InlineArrayElementRef<System.Runtime.CompilerServices.InlineArray5<string>, string>(ref System.Runtime.CompilerServices.InlineArray5<string>, int)"


InlineArrayElementRef

It looks like there are no tests that cover scenarios when helpers used by this method are missing

AlekseyTs · 2025-12-27T00:49:18Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs

+                  IL_004d:  stind.ref
+                  IL_004e:  ldloca.s   V_0
+                  IL_0050:  ldc.i4.5
+                  IL_0051:  call       "System.ReadOnlySpan<string> <PrivateImplementationDetails>.InlineArrayAsReadOnlySpan<System.Runtime.CompilerServices.InlineArray5<string>, string>(in System.Runtime.CompilerServices.InlineArray5<string>, int)"


InlineArrayAsReadOnlySpan

It looks like there are no tests that cover scenarios when helpers used by this method are missing

AlekseyTs · 2025-12-27T00:56:54Z

Are we testing scenarios when Span and/or ReadOnlySpan are missing?

AlekseyTs · 2025-12-27T00:59:13Z

It looks like we are lacking coverage for a scenario when InternalSpecialType.System_ReadOnlySpan_T and WellKnownType.System_ReadOnlySpan_T are different types

AlekseyTs · 2025-12-27T01:02:30Z

We need to decide whether we are comfortable with a possible stack bloating that the current implementation might lead to. Including whether we might want to have a threshold on the length of the inline array that we are willing to put on the stack.

AlekseyTs · 2025-12-27T01:03:06Z

Done with review pass (commit 6)

Based on some comments on dotnet#81788, I wanted to see what an implementation of sharing inline arrays across different calls might look like. This is very much still a prototype, and needs plenty of cleaning up (and extensive testing), but the concept is good enough to be reviewed, I think. The general strategy is that, for by-value and scoped `Span/ReadOnlySpan` parameters that are directly passed a collection expression (either explicitly as a collection expression or implicitly as a params parameter), we know the precise lifetime that span needs to remain valid: from the start of the argument position in code until the end of the method call. We can record this information during local rewriting to know, for every type, what the maximum stack space needed at any given time is (including what might be needed for multiple nested calls with the same element type occurring at the same time). We then substitute in a "replace me with a real inline array ref" node. We can then pre-allocate an inline array of that max size, and slice off bits for each call as necessary, replacing the placeholders with real slicing in a new pass I've called the `TransientInlineArrayRewriter`. Since these arrays might be used later in the method, we do have to clear the arrays after use if the element type could be a reference type so the GC can reclaim their values. As I mentioned, this is not yet ready for an in-depth code review. PROTOTYPE comments still exist, and there are several bugs failing tests that I haven't really looked into yet. But the general concept is ready for comment before I go further.

github-actions bot added the Area-Compilers label Dec 22, 2025

CyrusNajmabadi reviewed Dec 22, 2025

View reviewed changes

src/Compilers/CSharp/Portable/Binder/Binder_InterpolatedString.cs Outdated Show resolved Hide resolved

CyrusNajmabadi reviewed Dec 22, 2025

View reviewed changes

src/Compilers/CSharp/Portable/Binder/Binder_InterpolatedString.cs Show resolved Hide resolved

CyrusNajmabadi reviewed Dec 22, 2025

View reviewed changes

src/Compilers/CSharp/Portable/Binder/Binder_InterpolatedString.cs Show resolved Hide resolved

Failing tests and feedback

4401c66

333fred marked this pull request as ready for review December 22, 2025 21:49

333fred requested a review from a team as a code owner December 22, 2025 21:49

DoctorKrolic reviewed Dec 23, 2025

View reviewed changes

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs Outdated Show resolved Hide resolved

Framework

3eb40ea

AlekseyTs reviewed Dec 26, 2025

View reviewed changes

src/Compilers/CSharp/Portable/Binder/Binder_InterpolatedString.cs Outdated Show resolved Hide resolved

AlekseyTs reviewed Dec 26, 2025

View reviewed changes

src/Compilers/CSharp/Portable/Binder/Binder_InterpolatedString.cs Outdated Show resolved Hide resolved

AlekseyTs reviewed Dec 26, 2025

View reviewed changes

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

AlekseyTs reviewed Dec 26, 2025

View reviewed changes

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

333fred added 3 commits December 26, 2025 11:40

Binding and lowering refactors, add more tests.

8ffb410

Add an additional test for where a local could not be reused.

8e3ac70

Improve test

9715ab7

AlekseyTs reviewed Dec 26, 2025

View reviewed changes

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs Show resolved Hide resolved

AlekseyTs reviewed Dec 27, 2025

View reviewed changes

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs Show resolved Hide resolved

AlekseyTs reviewed Dec 27, 2025

View reviewed changes

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs Show resolved Hide resolved

AlekseyTs reviewed Dec 27, 2025

View reviewed changes

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStringConcat.cs

#nullable disable

using System.Linq;

Copy link

Contributor

AlekseyTs Dec 27, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Are both added usings used?

AlekseyTs reviewed Dec 27, 2025

View reviewed changes

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs Show resolved Hide resolved

AlekseyTs reviewed Dec 27, 2025

View reviewed changes

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs Show resolved Hide resolved

AlekseyTs reviewed Dec 27, 2025

View reviewed changes

src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs Show resolved Hide resolved

AlekseyTs reviewed Dec 27, 2025

View reviewed changes

src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs Show resolved Hide resolved

AlekseyTs reviewed Dec 27, 2025

View reviewed changes

333fred mentioned this pull request Jan 3, 2026

Prototype: sharing transient inline arrays #81840

Closed

333fred mentioned this pull request Jan 3, 2026

Prototype: sharing transient inline arrays #81841

Draft

Support using string.Concat(ReadOnlySpan<string>) for string lowering #81788

Are you sure you want to change the base?

Support using string.Concat(ReadOnlySpan<string>) for string lowering #81788

Conversation

333fred commented Dec 22, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

333fred commented Dec 22, 2025

Uh oh!

Uh oh!

AlekseyTs commented Dec 23, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

AlekseyTs commented Dec 26, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

AlekseyTs commented Dec 26, 2025

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

333fred Dec 29, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs commented Dec 27, 2025

Uh oh!

AlekseyTs commented Dec 27, 2025

Uh oh!

AlekseyTs commented Dec 27, 2025

Uh oh!

AlekseyTs commented Dec 27, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Support using `string.Concat(ReadOnlySpan<string>)` for string lowering #81788

Support using `string.Concat(ReadOnlySpan<string>)` for string lowering #81788

AlekseyTs commented Dec 26, 2025 •

edited

Loading

333fred Dec 29, 2025 •

edited

Loading