WIP: Add WithElement syntax

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

@@ -5199,6 +5199,16 @@ private BoundExpression BindCollectionExpression(CollectionExpressionSyntax synt
 
             MessageID.IDS_FeatureCollectionExpressions.CheckFeatureAvailability(diagnostics, syntax, syntax.OpenBracketToken.GetLocation());
 
+            for (int i = 1, n = syntax.Elements.Count - 1; i < n; i++)
+            {
+                var element = syntax.Elements[i];
+                if (element is WithElementSyntax withElement)
+                {
+                    Error(diagnostics, ErrorCode.ERR_WithElementMustBeFirst, withElement.WithKeyword.GetLocation());
+                    break;
+                }
+            }
+
             foreach (var element in syntax.Elements)
             {
                 if (element is KeyValuePairElementSyntax keyValuePairElement)
@@ -5209,6 +5219,14 @@ private BoundExpression BindCollectionExpression(CollectionExpressionSyntax synt
                     Error(diagnostics, ErrorCode.ERR_SyntaxError, keyValuePairElement.ColonToken, ",");
                     return new BoundBadExpression(syntax, LookupResultKind.Empty, symbols: [], childBoundNodes: [], CreateErrorType());
                 }
+                else if (element is WithElementSyntax withElement)
+                {
+                    MessageID.IDS_FeatureCollectionExpressionConstructionArguments.CheckFeatureAvailability(diagnostics, syntax, withElement.WithKeyword.GetLocation());
+
+                    // PROTOTYPE: Error for now.  Flesh this out when we do the binding for `with(...)` arguments.
+                    Error(diagnostics, ErrorCode.ERR_SyntaxError, withElement.WithKeyword, ",");
+                    return new BoundBadExpression(syntax, LookupResultKind.Empty, symbols: [], childBoundNodes: [], CreateErrorType());
+                }
             }
 
             var builder = ArrayBuilder<BoundNode>.GetInstance(syntax.Elements.Count);

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6832,6 +6832,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="IDS_FeatureDictionaryExpressions" xml:space="preserve">
     <value>dictionary expressions</value>
   </data>
+  <data name="IDS_FeatureCollectionExpressionConstructionArguments" xml:space="preserve">
+    <value>collection expression construction arguments</value>
+  </data>
   <data name="ERR_CollectionExpressionTargetTypeNotConstructible" xml:space="preserve">
     <value>Cannot initialize type '{0}' with a collection expression because the type is not constructible.</value>
   </data>
@@ -8020,4 +8023,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_IteratorRefLikeElementType" xml:space="preserve">
     <value>Element type of an iterator may not be a ref struct or a type parameter allowing ref structs</value>
   </data>
+  <data name="ERR_WithElementMustBeFirst" xml:space="preserve">
+    <value>'with(...)' element must be first element in collection expression</value>
+  </data>
 </root>

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

@@ -2350,6 +2350,7 @@ internal enum ErrorCode
         WRN_AccessorDoesNotUseBackingField = 9266,
 
         ERR_IteratorRefLikeElementType = 9267,
+        ERR_WithElementMustBeFirst = 9268,
 
         // Note: you will need to do the following after adding errors:
         //  1) Update ErrorFacts.IsBuildOnlyDiagnostic (src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs)

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

@@ -2467,6 +2467,7 @@ or ErrorCode.WRN_UninitializedNonNullableBackingField
                 or ErrorCode.WRN_UnassignedInternalRefField
                 or ErrorCode.WRN_AccessorDoesNotUseBackingField
                 or ErrorCode.ERR_IteratorRefLikeElementType
+                or ErrorCode.ERR_WithElementMustBeFirst
                     => false,
             };
 #pragma warning restore CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.

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

@@ -295,6 +295,7 @@ internal enum MessageID
 
         IDS_FeatureFirstClassSpan = MessageBase + 12849,
         IDS_FeatureDictionaryExpressions = MessageBase + 12850,
+        IDS_FeatureCollectionExpressionConstructionArguments = MessageBase + 12851,
     }
 
     // Message IDs may refer to strings that need to be localized.

src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Internal.Generated.cs

@@ -6767,6 +6767,82 @@ internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations)
         => new KeyValuePairElementSyntax(this.Kind, this.keyExpression, this.colonToken, this.valueExpression, GetDiagnostics(), annotations);
 }
 
+internal sealed partial class WithElementSyntax : CollectionElementSyntax
+{
+    internal readonly SyntaxToken withKeyword;
+    internal readonly ArgumentListSyntax argumentList;
+
+    internal WithElementSyntax(SyntaxKind kind, SyntaxToken withKeyword, ArgumentListSyntax argumentList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
+      : base(kind, diagnostics, annotations)
+    {
+        this.SlotCount = 2;
+        this.AdjustFlagsAndWidth(withKeyword);
+        this.withKeyword = withKeyword;
+        this.AdjustFlagsAndWidth(argumentList);
+        this.argumentList = argumentList;
+    }
+
+    internal WithElementSyntax(SyntaxKind kind, SyntaxToken withKeyword, ArgumentListSyntax argumentList, SyntaxFactoryContext context)
+      : base(kind)
+    {
+        this.SetFactoryContext(context);
+        this.SlotCount = 2;
+        this.AdjustFlagsAndWidth(withKeyword);
+        this.withKeyword = withKeyword;
+        this.AdjustFlagsAndWidth(argumentList);
+        this.argumentList = argumentList;
+    }
+
+    internal WithElementSyntax(SyntaxKind kind, SyntaxToken withKeyword, ArgumentListSyntax argumentList)
+      : base(kind)
+    {
+        this.SlotCount = 2;
+        this.AdjustFlagsAndWidth(withKeyword);
+        this.withKeyword = withKeyword;
+        this.AdjustFlagsAndWidth(argumentList);
+        this.argumentList = argumentList;
+    }
+
+    public SyntaxToken WithKeyword => this.withKeyword;
+    public ArgumentListSyntax ArgumentList => this.argumentList;
+
+    internal override GreenNode? GetSlot(int index)
+        => index switch
+        {
+            0 => this.withKeyword,
+            1 => this.argumentList,
+            _ => null,
+        };
+
+    internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.WithElementSyntax(this, parent, position);
+
+    public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitWithElement(this);
+    public override TResult Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) => visitor.VisitWithElement(this);
+
+    public WithElementSyntax Update(SyntaxToken withKeyword, ArgumentListSyntax argumentList)
+    {
+        if (withKeyword != this.WithKeyword || argumentList != this.ArgumentList)
+        {
+            var newNode = SyntaxFactory.WithElement(withKeyword, argumentList);
+            var diags = GetDiagnostics();
+            if (diags?.Length > 0)
+                newNode = newNode.WithDiagnosticsGreen(diags);
+            var annotations = GetAnnotations();
+            if (annotations?.Length > 0)
+                newNode = newNode.WithAnnotationsGreen(annotations);
+            return newNode;
+        }
+
+        return this;
+    }
+
+    internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics)
+        => new WithElementSyntax(this.Kind, this.withKeyword, this.argumentList, diagnostics, GetAnnotations());
+
+    internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations)
+        => new WithElementSyntax(this.Kind, this.withKeyword, this.argumentList, GetDiagnostics(), annotations);
+}
+
 internal abstract partial class QueryClauseSyntax : CSharpSyntaxNode
 {
     internal QueryClauseSyntax(SyntaxKind kind, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
@@ -26641,6 +26717,7 @@ internal partial class CSharpSyntaxVisitor<TResult>
     public virtual TResult VisitExpressionElement(ExpressionElementSyntax node) => this.DefaultVisit(node);
     public virtual TResult VisitSpreadElement(SpreadElementSyntax node) => this.DefaultVisit(node);
     public virtual TResult VisitKeyValuePairElement(KeyValuePairElementSyntax node) => this.DefaultVisit(node);
+    public virtual TResult VisitWithElement(WithElementSyntax node) => this.DefaultVisit(node);
     public virtual TResult VisitQueryExpression(QueryExpressionSyntax node) => this.DefaultVisit(node);
     public virtual TResult VisitQueryBody(QueryBodySyntax node) => this.DefaultVisit(node);
     public virtual TResult VisitFromClause(FromClauseSyntax node) => this.DefaultVisit(node);
@@ -26890,6 +26967,7 @@ internal partial class CSharpSyntaxVisitor
     public virtual void VisitExpressionElement(ExpressionElementSyntax node) => this.DefaultVisit(node);
     public virtual void VisitSpreadElement(SpreadElementSyntax node) => this.DefaultVisit(node);
     public virtual void VisitKeyValuePairElement(KeyValuePairElementSyntax node) => this.DefaultVisit(node);
+    public virtual void VisitWithElement(WithElementSyntax node) => this.DefaultVisit(node);
     public virtual void VisitQueryExpression(QueryExpressionSyntax node) => this.DefaultVisit(node);
     public virtual void VisitQueryBody(QueryBodySyntax node) => this.DefaultVisit(node);
     public virtual void VisitFromClause(FromClauseSyntax node) => this.DefaultVisit(node);
@@ -27283,6 +27361,9 @@ public override CSharpSyntaxNode VisitSpreadElement(SpreadElementSyntax node)
     public override CSharpSyntaxNode VisitKeyValuePairElement(KeyValuePairElementSyntax node)
         => node.Update((ExpressionSyntax)Visit(node.KeyExpression), (SyntaxToken)Visit(node.ColonToken), (ExpressionSyntax)Visit(node.ValueExpression));
 
+    public override CSharpSyntaxNode VisitWithElement(WithElementSyntax node)
+        => node.Update((SyntaxToken)Visit(node.WithKeyword), (ArgumentListSyntax)Visit(node.ArgumentList));
+
     public override CSharpSyntaxNode VisitQueryExpression(QueryExpressionSyntax node)
         => node.Update((FromClauseSyntax)Visit(node.FromClause), (QueryBodySyntax)Visit(node.Body));
 
@@ -29435,6 +29516,27 @@ public KeyValuePairElementSyntax KeyValuePairElement(ExpressionSyntax keyExpress
         return result;
     }
 
+    public WithElementSyntax WithElement(SyntaxToken withKeyword, ArgumentListSyntax argumentList)
+    {
+#if DEBUG
+        if (withKeyword == null) throw new ArgumentNullException(nameof(withKeyword));
+        if (withKeyword.Kind != SyntaxKind.WithKeyword) throw new ArgumentException(nameof(withKeyword));
+        if (argumentList == null) throw new ArgumentNullException(nameof(argumentList));
+#endif
+
+        int hash;
+        var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.WithElement, withKeyword, argumentList, this.context, out hash);
+        if (cached != null) return (WithElementSyntax)cached;
+
+        var result = new WithElementSyntax(SyntaxKind.WithElement, withKeyword, argumentList, this.context);
+        if (hash >= 0)
+        {
+            SyntaxNodeCache.AddNode(result, hash);
+        }
+
+        return result;
+    }
+
     public QueryExpressionSyntax QueryExpression(FromClauseSyntax fromClause, QueryBodySyntax body)
     {
 #if DEBUG
@@ -34725,6 +34827,27 @@ public static KeyValuePairElementSyntax KeyValuePairElement(ExpressionSyntax key
         return result;
     }
 
+    public static WithElementSyntax WithElement(SyntaxToken withKeyword, ArgumentListSyntax argumentList)
+    {
+#if DEBUG
+        if (withKeyword == null) throw new ArgumentNullException(nameof(withKeyword));
+        if (withKeyword.Kind != SyntaxKind.WithKeyword) throw new ArgumentException(nameof(withKeyword));
+        if (argumentList == null) throw new ArgumentNullException(nameof(argumentList));
+#endif
+
+        int hash;
+        var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.WithElement, withKeyword, argumentList, out hash);
+        if (cached != null) return (WithElementSyntax)cached;
+
+        var result = new WithElementSyntax(SyntaxKind.WithElement, withKeyword, argumentList);
+        if (hash >= 0)
+        {
+            SyntaxNodeCache.AddNode(result, hash);
+        }
+
+        return result;
+    }
+
     public static QueryExpressionSyntax QueryExpression(FromClauseSyntax fromClause, QueryBodySyntax body)
     {
 #if DEBUG

src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Main.Generated.cs

@@ -231,6 +231,9 @@
     /// <summary>Called when the visitor visits a KeyValuePairElementSyntax node.</summary>
     public virtual TResult? VisitKeyValuePairElement(KeyValuePairElementSyntax node) => this.DefaultVisit(node);
 
+    /// <summary>Called when the visitor visits a WithElementSyntax node.</summary>
+    public virtual TResult? VisitWithElement(WithElementSyntax node) => this.DefaultVisit(node);
+
     /// <summary>Called when the visitor visits a QueryExpressionSyntax node.</summary>
     public virtual TResult? VisitQueryExpression(QueryExpressionSyntax node) => this.DefaultVisit(node);
 
@@ -969,6 +972,9 @@
     /// <summary>Called when the visitor visits a KeyValuePairElementSyntax node.</summary>
     public virtual void VisitKeyValuePairElement(KeyValuePairElementSyntax node) => this.DefaultVisit(node);
 
+    /// <summary>Called when the visitor visits a WithElementSyntax node.</summary>
+    public virtual void VisitWithElement(WithElementSyntax node) => this.DefaultVisit(node);
+
     /// <summary>Called when the visitor visits a QueryExpressionSyntax node.</summary>
     public virtual void VisitQueryExpression(QueryExpressionSyntax node) => this.DefaultVisit(node);
 
@@ -1707,6 +1713,9 @@
     public override SyntaxNode? VisitKeyValuePairElement(KeyValuePairElementSyntax node)
         => node.Update((ExpressionSyntax?)Visit(node.KeyExpression) ?? throw new ArgumentNullException("keyExpression"), VisitToken(node.ColonToken), (ExpressionSyntax?)Visit(node.ValueExpression) ?? throw new ArgumentNullException("valueExpression"));
 
+    public override SyntaxNode? VisitWithElement(WithElementSyntax node)
+        => node.Update(VisitToken(node.WithKeyword), (ArgumentListSyntax?)Visit(node.ArgumentList) ?? throw new ArgumentNullException("argumentList"));
+
     public override SyntaxNode? VisitQueryExpression(QueryExpressionSyntax node)
         => node.Update((FromClauseSyntax?)Visit(node.FromClause) ?? throw new ArgumentNullException("fromClause"), (QueryBodySyntax?)Visit(node.Body) ?? throw new ArgumentNullException("body"));
 
@@ -3439,6 +3448,18 @@
     public static KeyValuePairElementSyntax KeyValuePairElement(ExpressionSyntax keyExpression, ExpressionSyntax valueExpression)
         => SyntaxFactory.KeyValuePairElement(keyExpression, SyntaxFactory.Token(SyntaxKind.ColonToken), valueExpression);
 
+    /// <summary>Creates a new WithElementSyntax instance.</summary>
+    public static WithElementSyntax WithElement(SyntaxToken withKeyword, ArgumentListSyntax argumentList)
+    {
+        if (withKeyword.Kind() != SyntaxKind.WithKeyword) throw new ArgumentException(nameof(withKeyword));
+        if (argumentList == null) throw new ArgumentNullException(nameof(argumentList));
+        return (WithElementSyntax)Syntax.InternalSyntax.SyntaxFactory.WithElement((Syntax.InternalSyntax.SyntaxToken)withKeyword.Node!, (Syntax.InternalSyntax.ArgumentListSyntax)argumentList.Green).CreateRed();
+    }
+
+    /// <summary>Creates a new WithElementSyntax instance.</summary>
+    public static WithElementSyntax WithElement(ArgumentListSyntax? argumentList = default)
+        => SyntaxFactory.WithElement(SyntaxFactory.Token(SyntaxKind.WithKeyword), argumentList ?? SyntaxFactory.ArgumentList());
+
     /// <summary>Creates a new QueryExpressionSyntax instance.</summary>
     public static QueryExpressionSyntax QueryExpression(FromClauseSyntax fromClause, QueryBodySyntax body)
     {

src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Syntax.Generated.cs

@@ -4331,6 +4331,50 @@ public KeyValuePairElementSyntax Update(ExpressionSyntax keyExpression, SyntaxTo
     public KeyValuePairElementSyntax WithValueExpression(ExpressionSyntax valueExpression) => Update(this.KeyExpression, this.ColonToken, valueExpression);
 }
 
+/// <remarks>
+/// <para>This node is associated with the following syntax kinds:</para>
+/// <list type="bullet">
+/// <item><description><see cref="SyntaxKind.WithElement"/></description></item>
+/// </list>
+/// </remarks>
+public sealed partial class WithElementSyntax : CollectionElementSyntax
+{
+    private ArgumentListSyntax? argumentList;
+
+    internal WithElementSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)
+      : base(green, parent, position)
+    {
+    }
+
+    public SyntaxToken WithKeyword => new SyntaxToken(this, ((InternalSyntax.WithElementSyntax)this.Green).withKeyword, Position, 0);
+
+    public ArgumentListSyntax ArgumentList => GetRed(ref this.argumentList, 1)!;
+
+    internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.argumentList, 1)! : null;
+
+    internal override SyntaxNode? GetCachedSlot(int index) => index == 1 ? this.argumentList : null;
+
+    public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitWithElement(this);
+    public override TResult? Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) where TResult : default => visitor.VisitWithElement(this);
+
+    public WithElementSyntax Update(SyntaxToken withKeyword, ArgumentListSyntax argumentList)
+    {
+        if (withKeyword != this.WithKeyword || argumentList != this.ArgumentList)
+        {
+            var newNode = SyntaxFactory.WithElement(withKeyword, argumentList);
+            var annotations = GetAnnotations();
+            return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode;
+        }
+
+        return this;
+    }
+
+    public WithElementSyntax WithWithKeyword(SyntaxToken withKeyword) => Update(withKeyword, this.ArgumentList);
+    public WithElementSyntax WithArgumentList(ArgumentListSyntax argumentList) => Update(this.WithKeyword, argumentList);
+
+    public WithElementSyntax AddArgumentListArguments(params ArgumentSyntax[] items) => WithArgumentList(this.ArgumentList.WithArguments(this.ArgumentList.Arguments.AddRange(items)));
+}
+
 public abstract partial class QueryClauseSyntax : CSharpSyntaxNode
 {
     internal QueryClauseSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -12718,6 +12718,9 @@ private bool IsPossibleCollectionElement()
 
         private CollectionElementSyntax ParseCollectionElement()
         {
+            if (this.CurrentToken.ContextualKind == SyntaxKind.WithKeyword && this.PeekToken(1).Kind == SyntaxKind.OpenParenToken)
+                return _syntaxFactory.WithElement(this.EatContextualToken(SyntaxKind.WithKeyword), this.ParseParenthesizedArgumentList());
+
             if (this.IsAtDotDotToken())
                 return _syntaxFactory.SpreadElement(this.EatDotDotToken(), this.ParseExpressionCore());
 
@@ -12727,10 +12730,9 @@ private CollectionElementSyntax ParseCollectionElement()
                 : this.ParseExpressionCore();
 
             var colonToken = this.TryEatToken(SyntaxKind.ColonToken);
-            if (colonToken != null)
-                return _syntaxFactory.KeyValuePairElement(expression, colonToken, this.ParseExpressionCore());
-
-            return _syntaxFactory.ExpressionElement(expression);
+            return colonToken != null
+                ? _syntaxFactory.KeyValuePairElement(expression, colonToken, this.ParseExpressionCore())
+                : _syntaxFactory.ExpressionElement(expression);
         }
 
         private bool IsAnonymousType()