Expose 'With-Element' information in ICollectionExpressionOperation

[CyrusNajmabadi]

Background and Motivation

C# is adding the with(...) element to a collection expression, like so: List<int> list = [with(capacity: 16), 0]; This information needs to be exposed through the IOperation tree.

Proposed API

namespace Microsoft.CodeAnalysis.Operations
{
    public interface ICollectionExpressionOperation : IOperation
    {
+        /**
+        <summary>
+          Arguments passed to to <see cref="ConstructMethod"/>, if present. Arguments are in evaluation order. This can
+          be an empty array. Will never be <c>default</c>.  If the arguments successfully bound, these will all be
+          <see cref="IArgumentOperation"/>; otherwise, they can be any operation.
+        </summary>
+        <remarks>
+          If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays.
+          Default values are supplied for optional arguments missing in source.
+        </remarks>
+        */
+        ImmutableArray<IOperation> ConstructArguments { get; }
    }

+    /**
+      <summary>
+        Represents the elements of a collection expression as they are passed to some construction method
+        specified by a <c>[CollectionBuilder]</c> attribute.  This is distinct from <see cref="ICollectionExpressionOperation.Elements"/>
+        which contains the elements as they appear in source.  This will appear in <see cref="ICollectionExpressionOperation.ConstructArguments"/>
+        when the construction method is a collection builder method, representing the final <c>ReadOnlySpan</c> passed to that
+        construction method containing the fully evaluated elements of the collection expression.
+      </summary>
+    */
+    public interface ICollectionExpressionElementsPlaceholderOperation : IOperation
+    {
+    }
}

1. Spans/Arrays. As 'with' is an error you get an empty array.
2. normal 'new' types. You get the arguments passed to the constructor on the type being 'new'ed up.
3. CollectionBuilder. You get the first first N-1 args passed to the Construct method
4. IList/ICollection. Only legal constructors that can be accessed are List() and List(int capacity). So the args would map to the parameters on htat.
5. IReadOnlyList/IReadOnlyCollection/IENumerable. The only legal with has no arguments. Anything else is error. So you get an empt list.

[333fred]

API Review

• Will it be odd for the order of evaluation to change? The arguments will always be specified first.
  • We could instead expose a list of arguments, no IInvocationOperation/IObjectCreationOperation to wrap?
• We do want IArgumentOperation as the type, since there can be by-ref parameters.
• On the other hand, having an object creation there could be useful to some analyzers?
• IList will be tricky, since you can set capacity:. IDictionary in the future will also be tricky because of comparer:. What is exposed as the parameter for these?
• Workshopped idea:

  namespace Microsoft.CodeAnalysis.Operations
  {
      public interface ICollectionExpressionOperation : IOperation
      {
  +        ImmutableArray<IArgumentOperation> WithElementArguments { get; }
      }
  }

• Will need more work on designing what to do for array/dictionary interface argument cases.

Conclusion: Needs work on a few design elements before approval.