Add support for list overload of Union operator.

PiperOrigin-RevId: 767513231

Author: evan-gordon

interpreter/operator_dispatcher.go

@@ -1238,6 +1238,13 @@ func (i *interpreter) binaryOverloads(m model.IBinaryExpression) ([]convert.Over
 				Result:   evalTake,
 			},
 		}, nil
+	case *model.Union:
+		return []convert.Overload[evalBinarySignature]{
+			{
+				Operands: []types.IType{&types.List{ElementType: types.Any}, &types.List{ElementType: types.Any}},
+				Result:   evalUnion,
+			},
+		}, nil
 	case *model.EndsWith:
 		return []convert.Overload[evalBinarySignature]{
 			{

interpreter/operator_list.go

@@ -500,6 +500,42 @@ func (i *interpreter) evalIndexerList(m model.IBinaryExpression, lObj, rObj resu
 	return list[idx], nil
 }
 
+// Union(left List<T>, right List<T>) List<T>
+// https://cql.hl7.org/09-b-cqlreference.html#union-1
+func evalUnion(m model.IBinaryExpression, lObj, rObj result.Value) (result.Value, error) {
+	staticType := &types.List{ElementType: types.Any}
+	var l []result.Value
+	var r []result.Value
+	var err error
+	if !result.IsNull(lObj) {
+		staticType = lObj.GolangValue().(result.List).StaticType
+		l, err = result.ToSlice(lObj)
+		if err != nil {
+			return result.Value{}, err
+		}
+	}
+	if !result.IsNull(rObj) {
+		staticType = rObj.GolangValue().(result.List).StaticType
+		r, err = result.ToSlice(rObj)
+		if err != nil {
+			return result.Value{}, err
+		}
+	}
+	var unionList []result.Value
+	for _, elemObj := range l {
+		unionList = append(unionList, elemObj)
+	}
+	for _, elemObj := range r {
+		if !valueInList(elemObj, l) {
+			unionList = append(unionList, elemObj)
+		}
+	}
+	return result.New(result.List{
+		Value:      unionList,
+		StaticType: staticType,
+	})
+}
+
 // valueInList returns true if the value is in the list using equality scemantics.
 func valueInList(value result.Value, list []result.Value) bool {
 	for _, elemObj := range list {

parser/operators.go

@@ -1949,7 +1949,7 @@ func (p *Parser) loadSystemOperators() error {
 		},
 		{
 			name:     "Union",
-			operands: [][]types.IType{{&types.List{ElementType: types.Any}, &types.List{ElementType: types.Any}}},
+			operands: [][]types.IType{{convert.GenericList, convert.GenericList}},
 			model: func() model.IExpression {
 				return &model.Union{
 					BinaryExpression: &model.BinaryExpression{},

parser/operators_test.go

@@ -1586,14 +1586,14 @@ func TestBuiltInFunctions(t *testing.T) {
 		},
 		{
 			name: "Union",
-			cql:  "Union({1}, {'hi'})",
+			cql:  "Union({1}, {2})",
 			want: &model.Union{
 				BinaryExpression: &model.BinaryExpression{
 					Operands: []model.IExpression{
 						model.NewList([]string{"1"}, types.Integer),
-						model.NewList([]string{"hi"}, types.String),
+						model.NewList([]string{"2"}, types.Integer),
 					},
-					Expression: model.ResultType(&types.List{ElementType: &types.Choice{ChoiceTypes: []types.IType{types.Integer, types.String}}}),
+					Expression: model.ResultType(&types.List{ElementType: types.Integer}),
 				},
 			},
 		},

tests/enginetests/operator_list_test.go

@@ -2078,3 +2078,88 @@ func TestIndexerList(t *testing.T) {
 		})
 	}
 }
+
+func TestUnionList(t *testing.T) {
+	tests := []struct {
+		name       string
+		cql        string
+		wantModel  model.IExpression
+		wantResult result.Value
+	}{
+		{
+			name: "Union on two equal lists",
+			cql:  "{'a', 'b'} union {'a', 'b'}",
+			wantModel: &model.Union{
+				BinaryExpression: &model.BinaryExpression{
+					Expression: model.ResultType(&types.List{ElementType: types.String}),
+					Operands: []model.IExpression{
+						model.NewList([]string{"a", "b"}, types.String),
+						model.NewList([]string{"a", "b"}, types.String),
+					},
+				},
+			},
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{newOrFatal(t, "a"), newOrFatal(t, "b")}, StaticType: &types.List{ElementType: types.String}}),
+		},
+		{
+			name:       "Union where right is a superset of left",
+			cql:        "{1} union {1, 2}",
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{newOrFatal(t, int32(1)), newOrFatal(t, int32(2))}, StaticType: &types.List{ElementType: types.Integer}}),
+		},
+		{
+			name:       "Union where left is a superset of right",
+			cql:        "{1, 2} union {1}",
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{newOrFatal(t, int32(1)), newOrFatal(t, int32(2))}, StaticType: &types.List{ElementType: types.Integer}}),
+		},
+		{
+			name:       "Union with both empty lists",
+			cql:        "{} union {}",
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{}, StaticType: &types.List{ElementType: types.Any}}),
+		},
+		{
+			name:       "Union with right null",
+			cql:        "{1, 2} union null",
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{newOrFatal(t, int32(1)), newOrFatal(t, int32(2))}, StaticType: &types.List{ElementType: types.Integer}}),
+		},
+		{
+			name:       "Union with left null",
+			cql:        "null union {1, 2}",
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{newOrFatal(t, int32(1)), newOrFatal(t, int32(2))}, StaticType: &types.List{ElementType: types.Integer}}),
+		},
+		{
+			name:       "Union with both null",
+			cql:        "null as List<Integer> union null as List<Integer>",
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{}, StaticType: &types.List{ElementType: types.Any}}),
+		},
+		{
+			name:       "Union with symbolic operator",
+			cql:        "{1, 2} | {1}",
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{newOrFatal(t, int32(1)), newOrFatal(t, int32(2))}, StaticType: &types.List{ElementType: types.Integer}}),
+		},
+		{
+			name:       "Union functional form",
+			cql:        "Union({1, 2}, {1})",
+			wantResult: newOrFatal(t, result.List{Value: []result.Value{newOrFatal(t, int32(1)), newOrFatal(t, int32(2))}, StaticType: &types.List{ElementType: types.Integer}}),
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			p := newFHIRParser(t)
+			parsedLibs, err := p.Libraries(context.Background(), wrapInLib(t, tc.cql), parser.Config{})
+			if err != nil {
+				t.Fatalf("Parse returned unexpected error: %v", err)
+			}
+			if diff := cmp.Diff(tc.wantModel, getTESTRESULTModel(t, parsedLibs)); tc.wantModel != nil && diff != "" {
+				t.Errorf("Parse diff (-want +got):\n%s", diff)
+			}
+
+			results, err := interpreter.Eval(context.Background(), parsedLibs, defaultInterpreterConfig(t, p))
+			if err != nil {
+				t.Fatalf("Eval returned unexpected error: %v", err)
+			}
+			if diff := cmp.Diff(tc.wantResult, getTESTRESULT(t, results), protocmp.Transform()); diff != "" {
+				t.Errorf("Eval diff (-want +got)\n%v", diff)
+			}
+
+		})
+	}
+}

tests/spectests/exclusions/exclusions.go

@@ -318,7 +318,6 @@ func XMLTestFileExclusionDefinitions() map[string]XMLTestFileExclusions {
 			GroupExcludes: []string{
 				// TODO: b/342061715 - unsupported operators.
 				"Descendents",
-				"Union",
 			},
 			NamesExcludes: []string{
 				// TODO: b/342061715 - unsupported operator.