Merge branch 'develop' into AnnotatePopulation-fixes

Author: igajurelNCQA

Cql-Sdk.slnf

@@ -9,11 +9,11 @@
       "Cql\\Cql.CqlToElm\\Cql.CqlToElm.csproj",
       "Cql\\Cql.Firely\\Cql.Firely.csproj",
       "Cql\\Cql.Grammar\\Cql.Grammar.csproj",
+      "Cql\\Cql.Invocation\\Cql.Invocation.csproj",
       "Cql\\Cql.Model\\Cql.Model.csproj",
       "Cql\\Cql.Packaging\\Cql.Packaging.csproj",
       "Cql\\Cql.Runtime\\Cql.Runtime.csproj",
       "Cql\\CqlToElmTests\\CqlToElmTests.csproj",
-      "Cql\\Cql.Invocation\\Cql.Invocation.csproj",
       "Cql\\Cql\\Cql.csproj",
       "Cql\\Elm\\Elm.csproj",
       "Cql\\Iso8601\\Iso8601.csproj",

Cql/Cql.Compiler/CqlOperatorsBinder.Specific.cs

@@ -7,6 +7,7 @@
  */
 
 using Hl7.Cql.Compiler.Expressions;
+using Hl7.Cql.Compiler.Infrastructure;
 using Hl7.Cql.Operators;
 using Hl7.Cql.Primitives;
 using Hl7.Cql.ValueSets;
@@ -72,6 +73,21 @@ private Expression Union(
             }
         }
 
+        // Check if we have compatible list types with different element types
+        var leftListElementType = _typeResolver.GetListElementType(left.Type);
+        var rightListElementType = _typeResolver.GetListElementType(right.Type);
+        if (leftListElementType != null && rightListElementType != null && leftListElementType != rightListElementType)
+        {
+            // Check if the element types are structurally compatible for union
+            if (ElmTupleTypeUtility.AreCompatibleForUnionOperation(leftListElementType, rightListElementType))
+            {
+                // Cast both to IEnumerable<object> to allow union
+                var leftAsObjectEnumerable = left.NewTypeAsExpression<IEnumerable<object>>();
+                var rightAsObjectEnumerable = right.NewTypeAsExpression<IEnumerable<object>>();
+                return BindToBestMethodOverload(nameof(ICqlOperators.Union), [leftAsObjectEnumerable, rightAsObjectEnumerable], [])!;
+            }
+        }
+
         return BindToBestMethodOverload(nameof(ICqlOperators.Union), [left, right], [])!;
     }
 

Cql/Cql.Compiler/CqlOperatorsBinder.cs

@@ -69,6 +69,7 @@ Type[] typeArgs
                 ("Flatten"          ,0 , >=1)  => Flatten(args[0]),
                 ("InList"           ,0 , >=2)  => InList(args[0], args[1]),
                 ("LateBoundProperty",0 , >=3)  => LateBoundProperty(args[0], args[1], args[2]),
+                ("Union"            ,0 , >=2)  => Union(args[0], args[1]),
                 ("ListUnion"        ,0 , >=2)  => Union(args[0], args[1]),
                 ("ResolveValueSet"  ,0 , >=1)  => ResolveValueSet(args[0]),
                 ("Retrieve"         ,0 , >=3)  => Retrieve(args[0], args[1], args[2], args[3]),

Cql/Cql.Compiler/ExpressionBuilderContext.LibraryDefs.cs

@@ -98,6 +98,12 @@ public void ProcessExpressionDef(
                         null);
                 }
 
+                // Pre-process expression to fix missing resultTypeSpecifier on AliasRef elements
+                if (expressionDef.expression != null)
+                {
+                    FixMissingAliasRefTypeSpecifiers(expressionDef.expression);
+                }
+
                 var expressionKey = $"{_libraryContext.LibraryVersionedIdentifier}.{expressionDefName}";
                 Type[] parameterTypes = [];
                 ParameterExpression[] parameters = [CqlExpressions.ParameterExpression];

Cql/Cql.Compiler/ExpressionBuilderContext.TypeFor.cs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024, NCQA and contributors
+ * Copyright (c) 2024, Firely, NCQA and contributors
  * See the file CONTRIBUTORS for details.
  *
  * This file is licensed under the BSD 3-Clause license
@@ -244,7 +244,8 @@ private Type TupleTypeFor((string name, TypeSpecifier elementType)[] elements, F
                     type = changeType(type);
 
                 return (type, el.name);
-            });
+            })
+            .ToList();
 
         return _tupleBuilderCache.CreateOrGetTupleTypeFor(tupleFields);
     }

Cql/Cql.Compiler/ExpressionBuilderContext.cs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NCQA and contributors
+ * Copyright (c) 2023, Firely, NCQA and contributors
  * See the file CONTRIBUTORS for details.
  *
  * This file is licensed under the BSD 3-Clause license
@@ -127,6 +127,20 @@ private Expression TranslateElement(Element element) =>
         {
             using (PushElement(element))
             {
+                /*
+                This code is useful for setting breakpoints to inspect the expression tree at a specific element.
+                The ELM json must be modified to add an annotation tags with a debug counter first.
+
+                var debugCounter = element.annotation
+                                          ?.OfType<Annotation>()
+                                          .FirstOrDefault()?.t.FirstOrDefault(t => t.name == "debug")
+                                          ?.value;
+                if (debugCounter == "42") // Identify the correct debug counter from the ELM file
+                {
+                    ; // Set a breakpoint here
+                }
+                */
+
                 Expression? expression = element switch
                 {
                     //@formatter:off
@@ -325,12 +339,12 @@ Expression ConvertToResultType()
             {
                 if (_typeResolver.GetListElementType(left.Type, throwError: false) is { } leftListElemType
                     && _typeResolver.GetListElementType(right.Type, throwError: false) is { } rightListElemType
-                    && leftListElemType == rightListElemType)
+                    && ElmTupleTypeUtility.AreCompatibleForUnionOperation(leftListElemType, rightListElemType))
                     return [left, right];
 
                 if (left.Type.IsCqlInterval(out var leftPointType)
                     && right.Type.IsCqlInterval(out var rightPointType)
-                    && leftPointType == rightPointType)
+                    && ElmTupleTypeUtility.AreCompatibleForUnionOperation(leftPointType, rightPointType))
                     return [left, right];
             }
 
@@ -442,8 +456,7 @@ protected Expression List(List list)
                 array = Expression.NewArrayBounds(elementType, Expression.Constant(0));
             }
 
-            var asEnumerable = array.NewTypeAsExpression(typeof(IEnumerable<>).MakeGenericType(elementType));
-            return asEnumerable;
+            return array;
         }
 
         throw this.NewExpressionBuildingException($"List is the wrong type");
@@ -1918,7 +1931,7 @@ private void QueryDumpDebugInfoToLog(Query query)
         Type valueTupleType = _typeResolver.GetListElementType(funcResultType, true)!;
         FieldInfo[] valueTupleFields = valueTupleType.GetFields(bfPublicInstance | BindingFlags.GetField);
 
-        Type cqlTupleType = _tupleBuilderCache.CreateOrGetTupleTypeFor(sourceListElementTypes.Zip(aliases));
+        Type cqlTupleType = _tupleBuilderCache.CreateOrGetTupleTypeFor(sourceListElementTypes.Zip(aliases).ToList());
         PropertyInfo[] cqlTupleProperties = cqlTupleType.GetProperties(bfPublicInstance | BindingFlags.SetProperty);
 
         Debug.Assert(valueTupleFields.Length > 0);
@@ -2354,6 +2367,55 @@ void throwCannotCastIfNoMatch(TypeConversion result)
                 throw this.NewExpressionBuildingException($"Cannot convert {input.Type} to {outputType}.");
         }
     }
+
+    /// <summary>
+    /// Pre-processes an expression tree to fix missing resultTypeSpecifier on AliasRef elements
+    /// by copying the type information from the source elements that define the aliases.
+    /// </summary>
+    /// <param name="elmExpression">The root ELM expression to process</param>
+    private void FixMissingAliasRefTypeSpecifiers(Elm.Expression elmExpression)
+    {
+        // First pass: Build dictionary of alias names to their source elements (with resultTypeSpecifier)
+        var aliasSources = new Dictionary<string, (Element sourceElement, TypeSpecifier sourceResultTypeSpecifier)>();
+
+        var aliasCollector = new ElmTreeWalker(node =>
+        {
+            switch (node)
+            {
+                case AliasedQuerySource aqs when !string.IsNullOrEmpty(aqs.alias) && aqs.expression?.resultTypeSpecifier != null:
+                    aliasSources[aqs.alias] = (aqs, aqs.expression.resultTypeSpecifier);
+                    break;
+
+                case LetClause let when !string.IsNullOrEmpty(let.identifier) && let.expression?.resultTypeSpecifier != null:
+                    aliasSources[let.identifier] = (let, let.expression.resultTypeSpecifier);
+                    break;
+            }
+            return true; // Continue walking children
+        });
+
+        aliasCollector.Start(elmExpression);
+
+        // Second pass: Find AliasRef elements without resultTypeSpecifier and copy it from the dictionary
+        var aliasRefFixer = new ElmTreeWalker(node =>
+        {
+            if (node is AliasRef aliasRef
+                && !string.IsNullOrEmpty(aliasRef.name)
+                && aliasRef.resultTypeSpecifier == null
+                && aliasSources.TryGetValue(aliasRef.name, out var source))
+            {
+                _logger.LogDebug(
+                    "Fixing missing resultTypeSpecifier for AliasRef named '{alias}' @ {aliasLocator}, originating from {sourceType} @ {sourceLocator}. {expressionBuilderContext}",
+                    aliasRef.name, aliasRef.locator,
+                    source.sourceElement.GetType().Name,
+                    source.sourceElement.locator,
+                    DebuggerView);
+                aliasRef.resultTypeSpecifier = source.sourceResultTypeSpecifier;
+            }
+            return true; // Continue walking children
+        });
+
+        aliasRefFixer.Start(elmExpression);
+    }
 }
 
 #endregion

Cql/Cql.Compiler/Infrastructure/ElmTupleTypeUtility.cs

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2025, Firely, NCQA and contributors
+ * See the file CONTRIBUTORS for details.
+ *
+ * This file is licensed under the BSD 3-Clause license
+ * available at https://raw.githubusercontent.com/FirelyTeam/firely-cql-sdk/main/LICENSE
+ */
+
+using Hl7.Cql.Primitives;
+using Hl7.Fhir.Model;
+
+namespace Hl7.Cql.Compiler.Infrastructure;
+
+internal static class ElmTupleTypeUtility
+{
+    /// <summary>
+    /// Determines whether two types are compatible for Union operations in ELM to LINQ conversion.
+    /// This includes exact equality, assignability, and structural equivalence for tuple types.
+    /// </summary>
+    /// <param name="leftType">The left operand type.</param>
+    /// <param name="rightType">The right operand type.</param>
+    /// <returns><c>true</c> if the types are compatible for Union operations; otherwise, <c>false</c>.</returns>
+    public static bool AreCompatibleForUnionOperation(Type leftType, Type rightType)
+    {
+        // First check for exact equality
+        if (leftType == rightType)
+            return true;
+
+        // Check if one type is assignable from the other (for polymorphic cases)
+        if (leftType.IsAssignableFrom(rightType) || rightType.IsAssignableFrom(leftType))
+            return true;
+
+        // Check for structural equivalence of tuple types
+        if (AreElmTupleTypesStructurallyEquivalent(leftType, rightType))
+            return true;
+
+        return false;
+    }
+
+    /// <summary>
+    /// Determines whether two types are structurally equivalent ELM tuple types.
+    /// ELM tuple types are considered structurally equivalent if they have the same properties
+    /// in the same order with compatible types.
+    /// </summary>
+    /// <param name="leftType">The left tuple type.</param>
+    /// <param name="rightType">The right tuple type.</param>
+    /// <returns><c>true</c> if both types are ELM tuple types and are structurally equivalent; otherwise, <c>false</c>.</returns>
+    private static bool AreElmTupleTypesStructurallyEquivalent(Type leftType, Type rightType)
+    {
+        // Check if both types are tuple-like (derive from TupleBaseType or have tuple-like properties)
+        if (!leftType.IsTupleBaseType() || !rightType.IsTupleBaseType())
+            return false;
+
+        var leftProps = leftType.GetProperties();
+        var rightProps = rightType.GetProperties();
+
+        // Check if they have the same number of properties
+        if (leftProps.Length != rightProps.Length)
+            return false;
+
+        // Check if each property has the same name and compatible type (order matters for tuples)
+        for (int i = 0; i < leftProps.Length; i++)
+        {
+            var leftProp = leftProps[i];
+            var rightProp = rightProps[i];
+
+            // Property names must match
+            if (leftProp.Name != rightProp.Name)
+                return false;
+
+            // For property types, check if they are the same or convertible
+            if (!AreElmPropertyTypesCompatible(leftProp.PropertyType, rightProp.PropertyType))
+                return false;
+        }
+
+        return true;
+
+        // Determines whether two property types are compatible in the context of ELM tuple operations.
+        // This includes exact matches, assignability, and known CQL/FHIR type conversions.
+        static bool AreElmPropertyTypesCompatible(Type leftPropType, Type rightPropType)
+        {
+            // Exact match
+            if (leftPropType == rightPropType)
+                return true;
+
+            // Check assignability in both directions
+            if (leftPropType.IsAssignableFrom(rightPropType) || rightPropType.IsAssignableFrom(leftPropType))
+                return true;
+
+            // Special cases for known compatible CQL types
+            // CqlDateTime and FhirDateTime are convertible
+            if ((leftPropType == typeof(CqlDateTime) && rightPropType == typeof(FhirDateTime)||
+                (rightPropType == typeof(CqlDateTime) && leftPropType == typeof(FhirDateTime))))
+                return true;
+
+            // Add other known convertible pairs as needed
+
+            return false;
+        }
+    }
+}

Cql/Cql.Compiler/TupleBuilderCache.cs

@@ -33,15 +33,18 @@ public void AddTupleType(Type type)
         }
 
         public bool TryFindTupleType(
-            IEnumerable<(Type propType, string propName, string cqlName)> tupleProps3,
+            IReadOnlyCollection<(Type propType, string propName, string cqlName)> tupleProps3,
             [NotNullWhen(true)]out Type? type)
         {
             type = _tupleTypeList
                 .FirstOrDefault(tupleType =>
                 {
-                    var isMatch = tupleProps3.All(
-                        tf => tupleType.GetProperty(tf.propName) is { PropertyType: { } tuplePropertyType }
-                              && tuplePropertyType == tf.propType);
+                    var isMatch =
+                        tupleProps3.Count == tupleType.GetProperties().Length
+                        &&
+                        tupleProps3.All(tf =>
+                                            tupleType.GetProperty(tf.propName) is { PropertyType: { } tuplePropertyType }
+                                              && tuplePropertyType == tf.propType);
                     return isMatch;
                 });
             return type != null;
@@ -70,7 +73,7 @@ public void Dispose()
     /// </summary>
     /// <param name="tupleProps">A readonly collection of property names with their corresponding types.</param>
     /// <returns>Gets the type that matches the properties.</returns>
-    public Type CreateOrGetTupleTypeFor(IEnumerable<(Type propType, string cqlName)> tupleProps)
+    public Type CreateOrGetTupleTypeFor(IReadOnlyCollection<(Type propType, string cqlName)> tupleProps)
     {
         HashSet<string> propNameDuplicates = new();
         List<(Type propType, string propName, string cqlName)> tupleProps3 =
@@ -83,7 +86,6 @@ public Type CreateOrGetTupleTypeFor(IEnumerable<(Type propType, string cqlName)>
                 return (tupleProp.propType, propName, tupleProp.cqlName);
             })
             .ToList();
-
         if (!_tupleTypeCache.TryFindTupleType(tupleProps3, out var tupleType))
         {
             tupleType = DefineType(tupleProps3);