Add IOp support for with(...) elements.

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

@@ -1190,6 +1190,7 @@ internal bool CheckValueKind(SyntaxNode node, BoundExpression expr, BindValueKin
                     return CheckSimpleAssignmentValueKind(node, assignment, valueKind, diagnostics);
 
                 case BoundKind.ValuePlaceholder:
+                case BoundKind.CollectionBuilderElementsPlaceholder:
                     // Strict RValue
                     break;
 
@@ -4361,6 +4362,7 @@ internal SafeContext GetValEscape(BoundExpression expr)
                 case BoundKind.InterpolatedStringArgumentPlaceholder:
                 case BoundKind.AwaitableValuePlaceholder:
                 case BoundKind.ValuePlaceholder:
+                case BoundKind.CollectionBuilderElementsPlaceholder:
                     return GetPlaceholderScope((BoundValuePlaceholderBase)expr);
 
                 case BoundKind.Local:
@@ -5002,6 +5004,7 @@ internal bool CheckValEscape(SyntaxNode node, BoundExpression expr, SafeContext
                 case BoundKind.AwaitableValuePlaceholder:
                 case BoundKind.InterpolatedStringArgumentPlaceholder:
                 case BoundKind.ValuePlaceholder:
+                case BoundKind.CollectionBuilderElementsPlaceholder:
                     if (!GetPlaceholderScope((BoundValuePlaceholderBase)expr).IsConvertibleTo(escapeTo))
                     {
                         Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, node, expr.Syntax);

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

@@ -841,7 +841,7 @@ private readonly struct CollectionExpressionConverter(
             private readonly BindingDiagnosticBag _diagnostics = diagnostics;
 
             private BoundCollectionExpression CreateCollectionExpression(
-                CollectionExpressionTypeKind collectionTypeKind, ImmutableArray<BoundNode> elements, BoundObjectOrCollectionValuePlaceholder? placeholder = null, BoundExpression? collectionCreation = null, MethodSymbol? collectionBuilderMethod = null, BoundValuePlaceholder? collectionBuilderElementsPlaceholder = null)
+                CollectionExpressionTypeKind collectionTypeKind, ImmutableArray<BoundNode> elements, BoundObjectOrCollectionValuePlaceholder? placeholder = null, BoundExpression? collectionCreation = null, MethodSymbol? collectionBuilderMethod = null, BoundCollectionBuilderElementsPlaceholder? collectionBuilderElementsPlaceholder = null)
             {
                 return new BoundCollectionExpression(
                     _node.Syntax,
@@ -1153,13 +1153,23 @@ static BoundCollectionExpressionSpreadElement bindSpreadElement(
                         ErrorCode.ERR_CollectionArgumentsNotSupportedForType,
                         _node.WithElement.Syntax.GetFirstToken().GetLocation(),
                         _targetType);
+                    return null;
                 }
 
                 return CreateCollectionExpression(collectionTypeKind, elements);
             }
 
             private readonly BoundCollectionExpression? TryConvertCollectionExpressionArrayInterfaceType(ImmutableArray<BoundNode> elements)
             {
+                if (_node.WithElement?.Arguments.Length > 0 &&
+                    _targetType.IsReadOnlyArrayInterface(out _))
+                {
+                    // For the read-only array interfaces (IEnumerable<E>, IReadOnlyCollection<E>, IReadOnlyList<E>), only
+                    // the parameterless `with()` is allowed.
+                    _diagnostics.Add(ErrorCode.ERR_CollectionArgumentsMustBeEmpty, _node.WithElement.Syntax.GetFirstToken().GetLocation());
+                    return null;
+                }
+
                 return CreateCollectionExpression(
                     CollectionExpressionTypeKind.ArrayInterface,
                     elements,
@@ -1176,13 +1186,6 @@ static BoundCollectionExpressionSpreadElement bindSpreadElement(
                     var withSyntax = withElement.Syntax;
                     if (@this._targetType.IsReadOnlyArrayInterface(out _))
                     {
-                        // For the read-only array interfaces (IEnumerable<E>, IReadOnlyCollection<E>, IReadOnlyList<E>), only
-                        // the parameterless `with()` is allowed.
-                        if (withElement.Arguments.Length > 0)
-                        {
-                            @this._diagnostics.Add(ErrorCode.ERR_CollectionArgumentsMustBeEmpty, withSyntax.GetFirstToken().GetLocation());
-                        }
-
                         // Note: we intentionally report null here.  Even though the code has `with()` in it, we're not actually
                         // going to call a particular constructor.  The lowering phase will properly handle creating a read-only
                         // interface instance.
@@ -1257,7 +1260,7 @@ static BoundCollectionExpressionSpreadElement bindSpreadElement(
                     collectionBuilderMethod: collectionBuilderMethod,
                     collectionBuilderElementsPlaceholder: collectionBuilderElementsPlaceholder);
 
-                static (BoundExpression? collectionCreation, MethodSymbol? collectionBuilderMethod, BoundValuePlaceholder? elementsPlaceholder) bindCollectionBuilderInfo(
+                static (BoundExpression? collectionCreation, MethodSymbol? collectionBuilderMethod, BoundCollectionBuilderElementsPlaceholder? elementsPlaceholder) bindCollectionBuilderInfo(
                     ref readonly CollectionExpressionConverter @this)
                 {
                     var namedType = (NamedTypeSymbol)@this._targetType;
@@ -1340,7 +1343,7 @@ static BoundCollectionExpressionSpreadElement bindSpreadElement(
                     // CollectionBuilder.Create<T1, T2, ..>(a, b, c, <placeholder for [x, y, z]>).
 
                     var readonlySpanParameter = collectionBuilderMethod.Parameters.Last();
-                    var collectionBuilderElementsPlaceholder = new BoundValuePlaceholder(syntax, readonlySpanParameter.Type) { WasCompilerGenerated = true };
+                    var collectionBuilderElementsPlaceholder = new BoundCollectionBuilderElementsPlaceholder(syntax, readonlySpanParameter.Type) { WasCompilerGenerated = true };
 
                     var arguments = projectionCall.Arguments;
                     var argumentNames = projectionCall.ArgumentNamesOpt;
@@ -1371,8 +1374,9 @@ static BoundCollectionExpressionSpreadElement bindSpreadElement(
                         invokedAsExtensionMethod: false,
                         argsToParamsOpt: argsToParams,
                         defaultArguments: projectionCall.DefaultArguments,
-                        resultKind: LookupResultKind.Viable,
-                        type: collectionBuilderMethod.ReturnType)
+                        resultKind: projectionCall.ResultKind,
+                        type: collectionBuilderMethod.ReturnType,
+                        hasErrors: projectionCall.HasErrors)
                     {
                         WasCompilerGenerated = @this._node.WithElement is null,
                     };

src/Compilers/CSharp/Portable/BoundTree/BoundCollectionExpression.cs

@@ -10,6 +10,24 @@ internal partial class BoundCollectionExpression
     {
         private partial void Validate()
         {
+            var collectionCreation = this.CollectionCreation;
+            while (collectionCreation is BoundConversion conversion)
+                collectionCreation = conversion.Operand;
+
+            Debug.Assert(collectionCreation
+                            is null
+                            or BoundObjectCreationExpression
+                            or BoundCall
+                            or BoundNewT
+                            or BoundBadExpression);
+
+            if (collectionCreation is BoundCall boundCall)
+            {
+                Debug.Assert(
+                    boundCall.Arguments is [.., BoundCollectionBuilderElementsPlaceholder placeHolder] &&
+                    placeHolder == this.CollectionBuilderElementsPlaceholder);
+            }
+
             if (this.CollectionTypeKind == CollectionExpressionTypeKind.CollectionBuilder)
             {
                 Debug.Assert(this.CollectionCreation is not null);

src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs

@@ -162,6 +162,11 @@ internal partial class BoundValuePlaceholder
         public sealed override bool IsEquivalentToThisReference => throw ExceptionUtilities.Unreachable();
     }
 
+    internal partial class BoundCollectionBuilderElementsPlaceholder
+    {
+        public sealed override bool IsEquivalentToThisReference => throw ExceptionUtilities.Unreachable();
+    }
+
     internal partial class BoundInterpolatedStringHandlerPlaceholder
     {
         public sealed override bool IsEquivalentToThisReference => false;

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -181,6 +181,10 @@
     <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
   </Node>
 
+  <!-- This node represents the ReadOnlySpan<T> for the elements passed as the last argument to a collection builder
+       method. It does not survive lowering. -->
+  <Node Name="BoundCollectionBuilderElementsPlaceholder" Base="BoundValuePlaceholderBase" />
+
   <!-- only used by codegen -->
   <Node Name="BoundDup" Base="BoundExpression">
     <!-- when duplicating a local or parameter, must remember original ref kind -->
@@ -1942,7 +1946,7 @@
     <Field Name="ArgumentNamesOpt" Type="ImmutableArray&lt;(string Name, Location Location)?&gt;" Null="allow"/>
     <Field Name="ArgumentRefKindsOpt" Type="ImmutableArray&lt;RefKind&gt;" Null="allow"/>
   </Node>
-
+  
   <Node Name="BoundCollectionExpression" Base="BoundCollectionExpressionBase" HasValidate="true">
     <!-- Non-null type is required for this node kind -->
     <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
@@ -1960,9 +1964,8 @@
          expression types.  For example, if the collection is `[with(a, b, c), x, y, z]` initial binding will produce
          `Factory.Create(a, b, c, <placeholder>)`.  The last arg will be replaced in lowering with the ReadOnlySpan for
          and will naturally be visited during all binding phases.  It is just the packaging and movement into the final
-         and will naturally be visited during all binding phases.  It ist just the packaging and movement into the final
          arg that the lowering phase concerns itself with. -->
-    <Field Name="CollectionBuilderElementsPlaceholder" Type="BoundValuePlaceholder?" Null="allow" SkipInVisitor="true"/>
+    <Field Name="CollectionBuilderElementsPlaceholder" Type="BoundCollectionBuilderElementsPlaceholder?" Null="allow" SkipInVisitor="true"/>
     <Field Name="WasTargetTyped" Type="bool" />
     <Field Name="HasWithElement" Type="bool" />
     <Field Name="UnconvertedCollectionExpression" Type="BoundUnconvertedCollectionExpression" Null="disallow" SkipInVisitor="true"/>

src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs

@@ -3708,6 +3708,11 @@ public override BoundNode VisitValuePlaceholder(BoundValuePlaceholder node)
             return null;
         }
 
+        public override BoundNode VisitCollectionBuilderElementsPlaceholder(BoundCollectionBuilderElementsPlaceholder node)
+        {
+            return null;
+        }
+
         public sealed override BoundNode VisitOutVariablePendingInference(OutVariablePendingInference node)
         {
             throw ExceptionUtilities.Unreachable();

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -11622,6 +11622,12 @@ private TypeWithAnnotations GetDeclaredParameterResult(ParameterSymbol parameter
             return null;
         }
 
+        public override BoundNode? VisitCollectionBuilderElementsPlaceholder(BoundCollectionBuilderElementsPlaceholder node)
+        {
+            VisitPlaceholderWithReplacement(node);
+            return null;
+        }
+
         public override BoundNode? VisitEventAccess(BoundEventAccess node)
         {
             var updatedSymbol = VisitMemberAccess(node, node.ReceiverOpt, node.EventSymbol);