Merge pull request #929 from FirelyTeam/copilot/fix-923-2

923 Make original cql operand name accessible through DefinitionInvoker

Author: ewoutkramer

copilot-instructions.md renamed to .github/copilot-instructions.md

@@ -82,6 +82,13 @@ Use this header format with "Firely, NCQA":
 6. **When adding new utility files or functionality that are only used internally, keep those types as `internal`, not `public`** - Only expose public APIs when they are intended for external consumption
 7. **When creating new files or modifying existing ones, always remove unused usings at the top of the file** - Keep using statements clean and only include what is actually used
 8. **Do not add duplicate usings in files where the using is already included globally in `GlobalUsings.cs`** - Check GlobalUsings.cs first to avoid redundant using statements
+9. **Always use the latest C# language features** when appropriate:
+   - Use collection expressions `[]` instead of `new[] { ... }` for arrays and collections
+   - Use target-typed `new()` expressions when the type is clear from context
+   - Use pattern matching and switch expressions where applicable
+   - Use record types for immutable data structures
+   - Use nullable reference types and null-conditional operators
+   - Use string interpolation instead of `string.Format` or concatenation
 
 ### Project References
 - When adding internal access, ensure the requesting project is appropriate for internal API usage

Cql-Sdk-All.sln

@@ -131,7 +131,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		build-elm.ps1 = build-elm.ps1
 		build-local-nuget.ps1 = build-local-nuget.ps1
 		build-publicapi.ps1 = build-publicapi.ps1
-		copilot-instructions.md = copilot-instructions.md
+		.github\copilot-instructions.md = .github\copilot-instructions.md
 		LICENSE = LICENSE
 		NuGet.config = NuGet.config
 		README.md = README.md

Cql/CoreTests/AssertExtensions.cs

@@ -6,6 +6,7 @@
  * available at https://raw.githubusercontent.com/FirelyTeam/firely-cql-sdk/main/LICENSE
  */
 #nullable enable
+using System.Diagnostics;
 using System.Text.RegularExpressions;
 
 namespace CoreTests;
@@ -26,6 +27,7 @@ public static void DoesNotThrow(
         }
     }
 
+    [DebuggerStepThrough]
     public static void MultilinesAreEqual(
         this Assert assert,
         string expected,

Cql/CoreTests/DefinitionSignatureTests.cs

@@ -0,0 +1,204 @@
+/*
+ * 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.Runtime;
+
+namespace CoreTests;
+
+[TestClass]
+public class DefinitionSignatureTests
+{
+    [TestMethod]
+    public void Constructor_WithValidNameAndTypes_ShouldCreateInstance()
+    {
+        // Arrange
+        const string name = "TestFunction";
+        var paramTypes = new[] { typeof(int), typeof(string) };
+
+        // Act
+        var signature = new DefinitionSignature(name, paramTypes);
+
+        // Assert
+        Assert.AreEqual(name, signature.Name);
+        CollectionAssert.AreEqual(paramTypes, signature.ParameterTypes);
+    }
+
+    [TestMethod]
+    public void Constructor_WithValidNameAndNoTypes_ShouldCreateInstance()
+    {
+        // Arrange
+        const string name = "TestFunction";
+
+        // Act
+        var signature = new DefinitionSignature(name);
+
+        // Assert
+        Assert.AreEqual(name, signature.Name);
+        Assert.AreEqual(0, signature.ParameterTypes.Length);
+    }
+
+    [TestMethod]
+    public void Constructor_WithNullName_ShouldThrowArgumentNullException()
+    {
+        // Act & Assert
+        Assert.ThrowsException<ArgumentNullException>(() => new DefinitionSignature(null!, typeof(int)));
+    }
+
+    [TestMethod]
+    public void Constructor_WithNullParameterTypes_ShouldCreateEmptyArray()
+    {
+        // Arrange
+        const string name = "TestFunction";
+
+        // Act
+        var signature = new DefinitionSignature(name, null!);
+
+        // Assert
+        Assert.AreEqual(name, signature.Name);
+        Assert.AreEqual(0, signature.ParameterTypes.Length);
+    }
+
+    [TestMethod]
+    public void Equals_WithSameNameAndTypes_ShouldReturnTrue()
+    {
+        // Arrange
+        var signature1 = new DefinitionSignature("TestFunction", typeof(int), typeof(string));
+        var signature2 = new DefinitionSignature("TestFunction", typeof(int), typeof(string));
+
+        // Act & Assert
+        Assert.IsTrue(signature1.Equals(signature2));
+        Assert.IsTrue(signature1 == signature2);
+        Assert.AreEqual(signature1.GetHashCode(), signature2.GetHashCode());
+    }
+
+    [TestMethod]
+    public void Equals_WithDifferentNames_ShouldReturnFalse()
+    {
+        // Arrange
+        var signature1 = new DefinitionSignature("TestFunction1", typeof(int));
+        var signature2 = new DefinitionSignature("TestFunction2", typeof(int));
+
+        // Act & Assert
+        Assert.IsFalse(signature1.Equals(signature2));
+        Assert.IsFalse(signature1 == signature2);
+    }
+
+    [TestMethod]
+    public void Equals_WithDifferentParameterTypes_ShouldReturnFalse()
+    {
+        // Arrange
+        var signature1 = new DefinitionSignature("TestFunction", typeof(int));
+        var signature2 = new DefinitionSignature("TestFunction", typeof(string));
+
+        // Act & Assert
+        Assert.IsFalse(signature1.Equals(signature2));
+        Assert.IsFalse(signature1 == signature2);
+    }
+
+    [TestMethod]
+    public void Equals_WithDifferentParameterCount_ShouldReturnFalse()
+    {
+        // Arrange
+        var signature1 = new DefinitionSignature("TestFunction", typeof(int));
+        var signature2 = new DefinitionSignature("TestFunction", typeof(int), typeof(string));
+
+        // Act & Assert
+        Assert.IsFalse(signature1.Equals(signature2));
+        Assert.IsFalse(signature1 == signature2);
+    }
+
+    [TestMethod]
+    public void GetHashCode_WithSameContent_ShouldBeSame()
+    {
+        // Arrange
+        var signature1 = new DefinitionSignature("TestFunction", typeof(int), typeof(string));
+        var signature2 = new DefinitionSignature("TestFunction", typeof(int), typeof(string));
+
+        // Act & Assert
+        Assert.AreEqual(signature1.GetHashCode(), signature2.GetHashCode());
+    }
+
+    [TestMethod]
+    public void GetHashCode_WithDifferentContent_ShouldBeDifferent()
+    {
+        // Arrange
+        var signature1 = new DefinitionSignature("TestFunction1", typeof(int));
+        var signature2 = new DefinitionSignature("TestFunction2", typeof(int));
+
+        // Act & Assert
+        Assert.AreNotEqual(signature1.GetHashCode(), signature2.GetHashCode());
+    }
+
+    [TestMethod]
+    public void GetHashCode_ShouldBeCached()
+    {
+        // Arrange
+        var signature = new DefinitionSignature("TestFunction", typeof(int), typeof(string));
+
+        // Act
+        var hash1 = signature.GetHashCode();
+        var hash2 = signature.GetHashCode();
+
+        // Assert
+        Assert.AreEqual(hash1, hash2);
+    }
+
+    [TestMethod]
+    public void ToString_WithNoParameters_ShouldReturnNameOnly()
+    {
+        // Arrange
+        var signature = new DefinitionSignature("TestFunction");
+
+        // Act
+        var result = signature.ToString();
+
+        // Assert
+        Assert.AreEqual("TestFunction()", result);
+    }
+
+    [TestMethod]
+    public void ToString_WithParameters_ShouldIncludeParameterTypes()
+    {
+        // Arrange
+        var signature = new DefinitionSignature("TestFunction", typeof(int), typeof(string));
+
+        // Act
+        var result = signature.ToString();
+
+        // Assert
+        Assert.AreEqual("TestFunction(System.Int32, System.String)", result);
+    }
+
+    [TestMethod]
+    public void ImplicitConversion_FromString_ShouldCreateSignature()
+    {
+        // Arrange
+        const string functionName = "TestFunction";
+
+        // Act
+        DefinitionSignature signature = functionName;
+
+        // Assert
+        Assert.AreEqual(functionName, signature.Name);
+        Assert.AreEqual(0, signature.ParameterTypes.Length);
+    }
+
+    [TestMethod]
+    public void Deconstruct_ShouldProvideNameAndParameterTypes()
+    {
+        // Arrange
+        var signature = new DefinitionSignature("TestFunction", typeof(int), typeof(string));
+
+        // Act
+        var (name, parameterTypes) = signature;
+
+        // Assert
+        Assert.AreEqual("TestFunction", name);
+        CollectionAssert.AreEqual(new[] { typeof(int), typeof(string) }, parameterTypes);
+    }
+}

Cql/CoreTests/LibraryInvokerTestExtensions.cs

@@ -12,10 +12,10 @@
 
 namespace CoreTests;
 
-internal static class LibraryInvokerTestExtensions
+internal static class LibraryInvokerTestExtensions // These are extensions used in other tests
 {
     /// <summary>
-    /// Invokes the delegate <paramref name="define"/> in <paramref name="libraryName"/> with <paramref name="parameters"/>.
+    /// Invokes the delegate <paramref name="define"/> in <paramref name="libraryInvoker"/> with <paramref name="parameters"/>.
     /// </summary>
     /// <typeparam name="T">The expected return type of the delegate.</typeparam>
     /// <param name="libraryInvoker">The delegates containing this definition.</param>
@@ -30,8 +30,14 @@ internal static class LibraryInvokerTestExtensions
         params object[] parameters)
     {
         var parameterTypes = parameters.Select(p => p.GetType()).ToArray();
+
+        // Find the definition that matches the name and parameter types
         var definitionSignature = new DefinitionSignature(define, parameterTypes);
-        var definition = libraryInvoker.Definitions[definitionSignature];
+        var definition = libraryInvoker.Definitions.GetValueOrDefault(definitionSignature);
+
+        if (definition == null)
+            throw new InvalidOperationException($"No definition found with name '{define}' and parameter types [{string.Join(", ", parameterTypes.Select(t => t.Name))}]");
+
         var resultObj = definition.Invoke(rtx, parameters);
         var result = (T?)resultObj;
         return result;