Collection expressions: use inline arrays for collection expressions with span target types

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

@@ -3852,6 +3852,13 @@ internal uint GetValEscape(BoundExpression expr, uint scopeOfTheContainingExpres
                         return GetInterpolatedStringHandlerConversionEscapeScope(conversion.Operand, scopeOfTheContainingExpression);
                     }
 
+                    if (conversion.ConversionKind == ConversionKind.CollectionExpression)
+                    {
+                        return HasLocalScope((BoundCollectionExpression)conversion.Operand)
+                            ? scopeOfTheContainingExpression
+                            : CallingMethodScope;
+                    }
+
                     if (conversion.Conversion.IsInlineArray)
                     {
                         ImmutableArray<BoundExpression> arguments;
@@ -3959,9 +3966,6 @@ internal uint GetValEscape(BoundExpression expr, uint scopeOfTheContainingExpres
                     var switchExpr = (BoundSwitchExpression)expr;
                     return GetValEscape(switchExpr.SwitchArms.SelectAsArray(a => a.Value), scopeOfTheContainingExpression);
 
-                case BoundKind.CollectionExpression:
-                    return CallingMethodScope;
-
                 default:
                     // in error situations some unexpected nodes could make here
                     // returning "scopeOfTheContainingExpression" seems safer than throwing.
@@ -3971,6 +3975,51 @@ internal uint GetValEscape(BoundExpression expr, uint scopeOfTheContainingExpres
             }
         }
 
+#nullable enable
+        private bool HasLocalScope(BoundCollectionExpression expr)
+        {
+            // A non-empty collection expression with span type may be stored
+            // on the stack. In those cases the expression may have local scope.
+            if (expr.Type?.IsRefLikeType == true && expr.Elements.Length > 0)
+            {
+                var collectionTypeKind = ConversionsBase.GetCollectionExpressionTypeKind(_compilation, expr.Type, out var elementType);
+
+                switch (collectionTypeKind)
+                {
+                    case CollectionExpressionTypeKind.ReadOnlySpan:
+                        Debug.Assert(elementType is { });
+                        return !LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, elementType);
+                    case CollectionExpressionTypeKind.Span:
+                        return true;
+                    case CollectionExpressionTypeKind.CollectionBuilder:
+                        // For a ref struct type with a builder method, the scope of the collection
+                        // expression is the scope of an invocation of the builder method with the
+                        // collection expression as the span argument.
+                        var constructMethod = expr.CollectionBuilderMethod;
+                        if (constructMethod is not { Parameters: [{ RefKind: RefKind.None } parameter] })
+                        {
+                            // Unexpected construct method. Restrict the collection to local scope.
+                            return true;
+                        }
+                        Debug.Assert(constructMethod.ReturnType.Equals(expr.Type, TypeCompareKind.AllIgnoreOptions));
+                        Debug.Assert(parameter.Type.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions));
+                        if (parameter.EffectiveScope == ScopedKind.ScopedValue)
+                        {
+                            return false;
+                        }
+                        if (LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, ((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type))
+                        {
+                            return false;
+                        }
+                        return true;
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(collectionTypeKind); // ref struct collection type with unexpected type kind
+                }
+            }
+            return false;
+        }
+#nullable disable
+
         private uint GetTupleValEscape(ImmutableArray<BoundExpression> elements, uint scopeOfTheContainingExpression)
         {
             uint narrowestScope = scopeOfTheContainingExpression;
@@ -4374,6 +4423,16 @@ internal bool CheckValEscape(SyntaxNode node, BoundExpression expr, uint escapeF
                         return CheckInterpolatedStringHandlerConversionEscape(conversion.Operand, escapeFrom, escapeTo, diagnostics);
                     }
 
+                    if (conversion.ConversionKind == ConversionKind.CollectionExpression)
+                    {
+                        if (HasLocalScope((BoundCollectionExpression)conversion.Operand) && escapeTo < _localScopeDepth)
+                        {
+                            Error(diagnostics, ErrorCode.ERR_CollectionExpressionEscape, node, expr.Type);
+                            return false;
+                        }
+                        return true;
+                    }
+
                     if (conversion.Conversion.IsInlineArray)
                     {
                         ImmutableArray<BoundExpression> arguments;
@@ -4488,9 +4547,6 @@ internal bool CheckValEscape(SyntaxNode node, BoundExpression expr, uint escapeF
 
                     return true;
 
-                case BoundKind.CollectionExpression:
-                    return true;
-
                 default:
                     // in error situations some unexpected nodes could make here
                     // returning "false" seems safer than throwing.

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6852,6 +6852,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_CollectionBuilderAttributeInvalidMethodName" xml:space="preserve">
     <value>The CollectionBuilderAttribute method name is invalid.</value>
   </data>
+  <data name="ERR_CollectionExpressionEscape" xml:space="preserve">
+    <value>A collection expression of type '{0}' cannot be used in this context because it may be exposed outside of the current scope.</value>
+  </data>
   <data name="ERR_EqualityContractRequiresGetter" xml:space="preserve">
     <value>Record equality contract property '{0}' must have a get accessor.</value>
   </data>

src/Compilers/CSharp/Portable/CodeGen/EmitArrayInitializer.cs

@@ -693,7 +693,7 @@ private bool TryEmitReadonlySpanAsBlobWrapper(NamedTypeSymbol spanType, BoundExp
         }
 
         /// <summary>Gets whether the element type of an array is appropriate for storing in a blob.</summary>
-        private static bool IsTypeAllowedInBlobWrapper(SpecialType type) => type is
+        internal static bool IsTypeAllowedInBlobWrapper(SpecialType type) => type is
             // 1 byte
             // For primitives that are a single byte in size, a span can point directly to a blob
             // containing the constant data.

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2268,6 +2268,7 @@ internal enum ErrorCode
         WRN_UseDefViolationRefField = 9201,
 
         ERR_FeatureNotAvailableInVersion12 = 9202,
+        ERR_CollectionExpressionEscape = 9203,
 
         #endregion
 

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -2399,6 +2399,7 @@ internal static bool IsBuildOnlyDiagnostic(ErrorCode code)
                 case ErrorCode.WRN_ByValArraySizeConstRequired:
                 case ErrorCode.WRN_UseDefViolationRefField:
                 case ErrorCode.ERR_FeatureNotAvailableInVersion12:
+                case ErrorCode.ERR_CollectionExpressionEscape:
                     return false;
                 default:
                     // NOTE: All error codes must be explicitly handled in this switch statement

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

@@ -31,6 +31,7 @@ internal sealed partial class LocalRewriter : BoundTreeRewriterWithStackGuard
         private readonly int _topLevelMethodOrdinal;
         private DelegateCacheRewriter? _lazyDelegateCacheRewriter;
         private bool _inExpressionLambda;
+        private ArrayBuilder<LocalSymbol>? _additionalLocals;
 
         /// <summary>
         /// The original body of the current lambda or local function body, or null if not currently lowering a lambda.
@@ -618,6 +619,41 @@ public override BoundNode VisitRefTypeOperator(BoundRefTypeOperator node)
             return node.Update(operand, getTypeFromHandle, type);
         }
 
+        private BoundStatement? RewriteFieldOrPropertyInitializer(BoundStatement initializer)
+        {
+            var previousLocals = _additionalLocals;
+            _additionalLocals = ArrayBuilder<LocalSymbol>.GetInstance();
+
+            try
+            {
+                if (initializer.Kind == BoundKind.Block)
+                {
+                    var block = (BoundBlock)initializer;
+
+                    var statement = RewriteExpressionStatement((BoundExpressionStatement)block.Statements.Single(), suppressInstrumentation: true);
+                    Debug.Assert(statement is { });
+                    return block.Update(block.Locals.AddRange(_additionalLocals), block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(statement));
+                }
+                else
+                {
+                    var statement = RewriteExpressionStatement((BoundExpressionStatement)initializer, suppressInstrumentation: true);
+                    if (statement is null || _additionalLocals.Count == 0)
+                    {
+                        return statement;
+                    }
+                    return new BoundBlock(
+                        statement.Syntax,
+                        _additionalLocals.ToImmutable(),
+                        ImmutableArray.Create(statement));
+                }
+            }
+            finally
+            {
+                _additionalLocals.Free();
+                _additionalLocals = previousLocals;
+            }
+        }
+
         public override BoundNode VisitTypeOrInstanceInitializers(BoundTypeOrInstanceInitializers node)
         {
             ImmutableArray<BoundStatement> originalStatements = node.Statements;
@@ -626,18 +662,7 @@ public override BoundNode VisitTypeOrInstanceInitializers(BoundTypeOrInstanceIni
             {
                 if (IsFieldOrPropertyInitializer(initializer))
                 {
-                    if (initializer.Kind == BoundKind.Block)
-                    {
-                        var block = (BoundBlock)initializer;
-
-                        var statement = RewriteExpressionStatement((BoundExpressionStatement)block.Statements.Single(), suppressInstrumentation: true);
-                        Debug.Assert(statement is { });
-                        statements.Add(block.Update(block.Locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(statement)));
-                    }
-                    else
-                    {
-                        statements.Add(RewriteExpressionStatement((BoundExpressionStatement)initializer, suppressInstrumentation: true));
-                    }
+                    statements.Add(RewriteFieldOrPropertyInitializer(initializer));
                 }
                 else
                 {

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

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Diagnostics;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -20,26 +19,37 @@ public override BoundNode VisitBlock(BoundBlock node)
             }
 
             var builder = ArrayBuilder<BoundStatement>.GetInstance();
-            VisitStatementSubList(builder, node.Statements);
+            var previousLocals = _additionalLocals;
+            _additionalLocals = ArrayBuilder<LocalSymbol>.GetInstance();
 
-            var additionalLocals = TemporaryArray<LocalSymbol>.Empty;
-
-            BoundBlockInstrumentation? instrumentation = null;
-            if (Instrument)
+            try
             {
-                Instrumenter.InstrumentBlock(node, this, ref additionalLocals, out var prologue, out var epilogue, out instrumentation);
-                if (prologue != null)
-                {
-                    builder.Insert(0, prologue);
-                }
+                VisitStatementSubList(builder, node.Statements);
+
+                var additionalLocals = TemporaryArray<LocalSymbol>.Empty;
 
-                if (epilogue != null)
+                BoundBlockInstrumentation? instrumentation = null;
+                if (Instrument)
                 {
-                    builder.Add(epilogue);
+                    Instrumenter.InstrumentBlock(node, this, ref additionalLocals, out var prologue, out var epilogue, out instrumentation);
+                    if (prologue != null)
+                    {
+                        builder.Insert(0, prologue);
+                    }
+
+                    if (epilogue != null)
+                    {
+                        builder.Add(epilogue);
+                    }
                 }
-            }
 
-            return new BoundBlock(node.Syntax, node.Locals.AddRange(additionalLocals), node.LocalFunctions, node.HasUnsafeModifier, instrumentation, builder.ToImmutableAndFree(), node.HasErrors);
+                return new BoundBlock(node.Syntax, node.Locals.AddRange(_additionalLocals).AddRange(additionalLocals), node.LocalFunctions, node.HasUnsafeModifier, instrumentation, builder.ToImmutableAndFree(), node.HasErrors);
+            }
+            finally
+            {
+                _additionalLocals.Free();
+                _additionalLocals = previousLocals;
+            }
         }
 
         /// <summary>