Using Flatten on a list of list of literals fails validation

[dschwartznyc]

Steps to Reproduce:

1. Define a Rune function that attempts to concatenate multiple lists using a list literal and the flatten operator:

   func TestListFunction:
       inputs:
           list1 number (1..*)
           list2 number (1..*)
       output:
           result number (1..*)
       set result:
           [list1, list2] flatten
   

2. Generate code passing first through Rune validation

Expected Result:

Validation should succeed. The compiler should recognize that a ListLiteral containing multiple multi-cardinality elements results in a list of lists, which is the required input type for the flatten operator.

Actual Result:

Validation fails with the error:
List flatten only allowed for list of lists.

This occurs because CardinalityProvider.safeIsOutputListOfLists in rune-dsl lacks a specific case for ListLiteral, causing it to return false even when the literal effectively wraps multiple lists.

Environment:

• Project: rune-dsl / rune-python-generator
• OS: Mac
• Runtime: Java 17

Additional Context:

The standard pattern for list concatenation is wrapping inputs in a collection and applying flatten. While the validator allows flatten on a single attribute that is explicitly defined as a list-of-lists, it fails to "see through" a ListLiteral used to group multiple lists for concatenation. This prevents the most common use case for flatten in functional expressions.

[SimonCockx]

The semantics of the list literal [ ... ] are:

• evaluate each expression in the list,
• then create a flat list by concatenating all items together.

List literals allow for mixed cardinality. E.g., given two variables a and b where

• a equals [1, 2],
• b equals 3,
  then the expression [a, b] evaluates to:

[a, b]
-> [[1, 2], 3]
-> [1, 2, 3]

That means the validation error is expected since the result is already flat.

There is a lag of documentation on these semantics, so I will label this issue as such. Thanks for the report.