Concatenate 2 IncrementalValuesProvider<T>

[ErikWe]

Hi,

Regarding Incremental Source Generators, as far as I'm aware there is currently no immediate support for a "Concat" transform. The behaviour is illustrated in the diagram at the bottom.

For me, the need for such a transform appears when simplifying separate branches of a pipeline to a common type T. I am then left with two instances of IncrementalValuesProvider<T>, and all subsequent transforms (which are the same in both cases) has to be applied to each individually. This seems like a relatively rare situation, and often appears at the very end of pipelines anyway.

Alternative Solutions

1. Use .Collect() followed by .Combine() - this works, but the ability to cache results is harmed (which is the main benefit of using an incremental SG).
2. Use .Collect() on one instance, then .Combine() followed by .SelectMany() - probably sufficient for most cases, and could manually be added as an extension method if that's the case. Intuitively it seems like an imperfect solution though, as it adds "unnecessary" steps to the pipeline.
3. Implement a separate class that manages a collection of IncrementalValuesProvider, and applies each transform individually.

Behaviour:

     IncrementalValuesProvider<T>
         ┌─────────────────┐
         │                 │
         │        T        ├───────┐
         │                 │       │       IncrementalValuesProvider<T>
         └─────────────────┘       │           ┌─────────────────┐
               x Items             │ Concat<T> │                 │
                                   ├──────────►│        T        │
                                   │           │                 │
     IncrementalValuesProvider<T>  │           └─────────────────┘
          ┌─────────────────┐      │               [x + y] items
          │                 ├──────┘
          │        T        │
          │                 │
          └─────────────────┘
               y Items

[CyrusNajmabadi]

What are the semantics if the lengths are difference?

[jasonmalinowski]

I don't think different lengths matter here? They're not asking for pair-wise combining, but just a list with all the elements together.

[CyrusNajmabadi]

Oh, my bad. I didn't realize the semantics there. Yes, that seems reasonable for values-providers of the same type.

[ErikWe]

Indeed, this proposal would require both providers to be of the same type T, and the resulting provider would also be of the same type T.

[CyrusNajmabadi]

Can you give an example of when you'd want this?

[ErikWe]

It has typically appeared when generating source based on a number of different attributes, each meant for slightly different purposes. I do this by registering multiple SyntaxProviders - which means that I end up with multiple pipelines (and at this stage they can not be concatenated as they are of different types). However, sometimes I'm able to reduce different pipelines to the same type T - and when all remaining transforms are the same for both providers, being able to simply concatenate them would be nice