Forward merge SDK5 into SDK6

Hl7.Fhir.sln

@@ -369,6 +369,8 @@ Global
 		src\Hl7.Fhir.ElementModel.Shared.Tests\Hl7.Fhir.ElementModel.Shared.Tests.projitems*{37e47f34-d2d5-4d24-8f31-5753000bd439}*SharedItemsImports = 5
 		src\Hl7.Fhir.Shims.R4AndUp\Hl7.Fhir.Shims.R4AndUp.projitems*{3d696d26-c0ff-4c6c-b3b7-cffb4f74079f}*SharedItemsImports = 13
 		src\Hl7.Fhir.Specification.Shared.Tests\Hl7.Fhir.Specification.Shared.Tests.projitems*{3fbbe610-4595-4213-9c0c-2a6af06e5f3c}*SharedItemsImports = 5
+		src\Hl7.Fhir.Shims.R4AndUp\Hl7.Fhir.Shims.R4AndUp.projitems*{41cf5ade-844c-45db-8506-181452a28f4e}*SharedItemsImports = 5
+		src\Hl7.Fhir.Shims.STU3AndUp\Hl7.Fhir.Shims.STU3AndUp.projitems*{41cf5ade-844c-45db-8506-181452a28f4e}*SharedItemsImports = 5
 		src\Hl7.Fhir.Shims.R4AndUp\Hl7.Fhir.Shims.R4AndUp.projitems*{437ec873-7d71-497b-a7e6-7e27c020af9e}*SharedItemsImports = 5
 		src\Hl7.Fhir.Shims.STU3AndUp\Hl7.Fhir.Shims.STU3AndUp.projitems*{437ec873-7d71-497b-a7e6-7e27c020af9e}*SharedItemsImports = 5
 		src\Hl7.Fhir.ElementModel.Shared.Tests\Hl7.Fhir.ElementModel.Shared.Tests.projitems*{52a8cfd0-fc25-42db-b3aa-292f4df8b72f}*SharedItemsImports = 5

src/Benchmarks/Benchmarks.csproj

@@ -10,6 +10,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="BenchmarkDotNet" Version="0.15.2" />
+		<PackageReference Include="BenchmarkDotNet" Version="0.15.4" />
 	</ItemGroup>
 
 	<ItemGroup>

src/Hl7.Fhir.Base/ElementModel/SourceNodeExtensions.Conversions.cs

@@ -125,14 +125,15 @@ public static string ToJson(this ISourceNode source, bool pretty = false)
     [Obsolete("Async support will be removed in the next major release, please use the non-async version instead")]
     public static async Task<string> ToJsonAsync(this ISourceNode source, bool pretty = false)
         => await SerializationUtil.WriteJsonToStringAsync(source.WriteToAsync, pretty).ConfigureAwait(false);
-    
+
     /// <summary>
     /// Serializes an <see cref="ISourceNode"/> instance into a <see cref="JObject"/>.
     /// </summary>
     /// <param name="source">The instance to serialize.</param>
+    /// <param name="preserveWhiteSpaceInValues">Whether to preserve whitespace in string values when serializing</param>
     /// <remarks>Since <see cref="ISourceNode"/> has no type information, this function will throw unless
     /// the <see cref="ISourceNode"/> originated from parsing using <see cref="FhirJsonNode"/>.</remarks>
-    public static JObject ToJObject(this ISourceNode source) => new FhirJsonBuilder().Build(source);
+    public static JObject ToJObject(this ISourceNode source, bool preserveWhiteSpaceInValues = false) => new FhirJsonBuilder(preserveWhiteSpaceInValues).Build(source);
 
     /// <summary>
     /// Serializes an <see cref="ISourceNode"/> instance into FHIR Json.

src/Hl7.Fhir.Base/FhirPath/DiagnosticsDebugTracer.cs

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2015, Firely (info@fire.ly) 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-net-sdk/master/LICENSE
+ */
+
+#nullable enable
+
+using Hl7.Fhir.ElementModel;
+using Hl7.Fhir.Model;
+using Hl7.FhirPath.Expressions;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+
+namespace Hl7.FhirPath
+{
+
+    public class DiagnosticsDebugTracer : IDebugTracer
+    {
+        public void TraceCall(
+            Expression expr,
+            int contextId,
+            IEnumerable<PocoNode>? focus,
+            IEnumerable<PocoNode>? thisValue,
+            PocoNode? index,
+            IEnumerable<PocoNode> totalValue,
+            IEnumerable<PocoNode> result,
+            IEnumerable<KeyValuePair<string, IEnumerable<PocoNode>>> variables)
+        {
+            DiagnosticsDebugTracer.DebugTraceCall(expr, contextId, focus, thisValue, index, totalValue, result, variables);
+        }
+
+        public static void DebugTraceCall(
+            Expression expr,
+            int contextId,
+            IEnumerable<PocoNode>? focus,
+            IEnumerable<PocoNode>? thisValue,
+            PocoNode? index,
+            IEnumerable<PocoNode> totalValue,
+            IEnumerable<PocoNode> result,
+            IEnumerable<KeyValuePair<string, IEnumerable<PocoNode>>> variables)
+        {
+            string exprName;
+
+            switch (expr)
+            {
+                case IdentifierExpression _:
+                    return;
+
+                case ConstantExpression ce:
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},constant (ctx.id: {contextId})");
+                    exprName = "constant";
+                    break;
+
+                case ChildExpression child:
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},{child.ChildName} (ctx.id: {contextId})");
+                    exprName = child.ChildName;
+                    break;
+
+                case IndexerExpression _:
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},[] (ctx.id: {contextId})");
+                    exprName = "[]";
+                    break;
+
+                case UnaryExpression ue:
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},{ue.Op} (ctx.id: {contextId})");
+                    exprName = ue.Op;
+                    break;
+
+                case BinaryExpression be:
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},{be.Op} (ctx.id: {contextId})");
+                    exprName = be.Op;
+                    break;
+
+                case FunctionCallExpression fe:
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},{fe.FunctionName} (ctx.id: {contextId})");
+                    exprName = fe.FunctionName;
+                    break;
+
+                case NewNodeListInitExpression _:
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},{{}} (empty) (ctx.id: {contextId})");
+                    exprName = "{}";
+                    break;
+
+                case AxisExpression ae:
+                    if (ae.AxisName == "that")
+                        return;
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},${ae.AxisName} (ctx.id: {contextId})");
+                    exprName = "$" + ae.AxisName;
+                    break;
+
+                case VariableRefExpression ve:
+                    Trace.WriteLine($"{expr.Location.LineNumber},{expr.Location.LinePosition},%{ve.Name} (ctx.id: {contextId})");
+                    exprName = "%" + ve.Name;
+                    break;
+
+                default:
+                    exprName = expr.GetType().Name;
+#if DEBUG
+                    Debugger.Break();
+#endif
+                    throw new Exception($"Unknown expression type: {expr.GetType().Name} (ctx.id: {contextId})");
+                    // Trace.WriteLine($"Evaluated: {expr} results: {result.Count()}");
+            }
+
+            if (result != null)
+            {
+                foreach (var item in result)
+                {
+                    DebugTraceValue($"{exprName} »", item);
+                }
+            }
+
+            if (focus != null)
+            {
+                foreach (var item in focus)
+                {
+                    DebugTraceValue($"$focus", item);
+                }
+            }
+
+            if (index != null)
+            {
+                DebugTraceValue("$index", index);
+            }
+
+            if (thisValue != null)
+            {
+                foreach (var item in thisValue)
+                {
+                    DebugTraceValue("$this", item);
+                }
+            }
+
+            if (totalValue != null)
+            {
+                foreach (var item in totalValue)
+                {
+                    DebugTraceValue($"{exprName} »", item);
+                }
+            }
+        }
+
+        private static void DebugTraceValue(string exprName, PocoNode? item)
+        {
+            if (item == null)
+                return; // possible with a null focus to kick things off
+            if (item is PrimitiveNode)
+                Trace.WriteLine($"  {exprName}:\t{item.GetValue()}\t({item.Poco.TypeName})");
+            else
+                Trace.WriteLine($"  {exprName}:\t{item.GetValue()}\t({item.Poco.TypeName})\t{item.GetLocation()}");
+        }
+    }
+}

src/Hl7.Fhir.Base/FhirPath/EvaluationContext.cs

@@ -12,7 +12,9 @@ public class EvaluationContext
     [Obsolete("This method does not initialize any members and will be removed in a future version. Use the empty constructor instead.")]
     public static EvaluationContext CreateDefault() => new();
 
-
+    private int ClosuresCreated { get; set; } = 0;
+    internal int IncrementClosuresCreatedCount() => ClosuresCreated++;
+
     public EvaluationContext()
     {
         // no defaults yet
@@ -36,13 +38,13 @@ public EvaluationContext(PocoNode? resource, PocoNode? rootResource)
         Resource = resource;
         RootResource = rootResource ?? resource;
     }
-        
+
     [Obsolete("%resource and %rootResource are inferred from scoped nodes by the evaluator. If you do not have access to a scoped node, or if you wish to explicitly override this behaviour, use the EvaluationContext.WithResourceOverrides() method. Environment can be set explicitly after construction of the base context")]
     public EvaluationContext(PocoNode? resource, PocoNode? rootResource, IDictionary<string, IEnumerable<PocoNode>> environment) : this(resource, rootResource)
     {
         Environment = environment;
     }
-    
+
     /// <summary>
     /// The data represented by <c>%rootResource</c>.
     /// </summary>
@@ -62,6 +64,11 @@ public EvaluationContext(PocoNode? resource, PocoNode? rootResource, IDictionary
     /// A delegate that handles the output for the <c>trace()</c> function.
     /// </summary>
     public Action<string?, IEnumerable<PocoNode>>? Tracer { get; set; }
+
+    /// <summary>
+    /// Gets or sets the tracer used for capturing debug information during evaluation
+    /// </summary>
+    public IDebugTracer? DebugTracer { get; set; }
 }
 
 public static class EvaluationContextExtensions

src/Hl7.Fhir.Base/FhirPath/Expressions/CallSignature.cs

@@ -38,13 +38,14 @@ public bool DynamicMatches(string functionName, IEnumerable<object> arguments)
             return functionName == Name && arguments.Count() == ArgumentTypes.Length &&
                    arguments.Zip(ArgumentTypes, Typecasts.CanCastTo).All(r => r == true);
         }
+
         public bool DynamicExactMatches(string functionName, IEnumerable<object> arguments)
         {
             return functionName == Name && arguments.Count() == ArgumentTypes.Length &&
                    arguments.Zip(ArgumentTypes, Typecasts.IsOfExactType).All(r => r == true);
         }
 
-        public bool Matches(string functionName, int argCount)
+        virtual public bool Matches(string functionName, int argCount)
         {
             return functionName == Name && ArgumentTypes.Length == argCount;
         }

src/Hl7.Fhir.Base/FhirPath/Expressions/Closure.cs

@@ -1,7 +1,7 @@
-/* 
+/*
  * Copyright (c) 2015, Firely (info@fire.ly) 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-net-sdk/master/LICENSE
  */
@@ -17,10 +17,52 @@ namespace Hl7.FhirPath.Expressions
 {
     internal class Closure
     {
-        public Closure()
+        internal int Id { get; private set; }
+
+        public Closure(EvaluationContext ctx)
         {
+            EvaluationContext = ctx;
+            Id = ctx.IncrementClosuresCreatedCount();
+            _debugTracerActive = ctx.DebugTracer != null;
+        }
+
+        public Closure(Closure parent, EvaluationContext ctx)
+        {
+            Parent = parent;
+            EvaluationContext = ctx;
+            Id = ctx.IncrementClosuresCreatedCount();
+            _debugTracerActive = ctx.DebugTracer != null;
+        }
+
+        /// <summary>
+        /// When the debug/trace is enabled this property is used to record the focus of the closure.
+        /// <br/>VALUE IS NOT USED OUTSIDE DEBUG - without debug/tracer, the value is not consistent.
+        /// </summary>
+        /// <remarks>
+        /// It is set in the delegate produced for each node by the evaluator visitor.
+        /// The debug tracer will reset the focus in the closure after calling the delegate it's wrapping.
+        /// ensuring that argument evaluation doesn't impact the focus logged in the debug trace in other
+        /// calls.
+        /// </remarks>
+        public IEnumerable<PocoNode> focus
+        {
+            get
+            {
+                if (!_debugTracerActive)
+                    return [];
+                return _focus;
+            }
+            set
+            {
+                if (!_debugTracerActive)
+                    return;
+                _focus = value;
+            }
         }
 
+        private IEnumerable<PocoNode> _focus;
+        private bool _debugTracerActive = false;
+
         public EvaluationContext EvaluationContext { get; private set; }
 
         public static Closure Root([NotNull] PocoNodeOrList root, EvaluationContext ctx = null)
@@ -32,7 +74,7 @@ public static Closure Root([NotNull] PocoNodeOrList root, EvaluationContext ctx
             // Same thing, but we copy the resource into the root resource if we cannot infer it from the node.
             newContext.RootResource ??= root.GetRootResourceContext();
 
-            var newClosure = new Closure() { EvaluationContext = ctx ?? new EvaluationContext() };
+            var newClosure = new Closure(ctx ?? new EvaluationContext());
 
             foreach (var assignment in newClosure.EvaluationContext.Environment)
             {
@@ -52,6 +94,11 @@ public static Closure Root([NotNull] PocoNodeOrList root, EvaluationContext ctx
 
         private Dictionary<string, IEnumerable<PocoNode>> _namedValues = new ();
 
+        internal IEnumerable<KeyValuePair<string, IEnumerable<PocoNode>>> Variables()
+        {
+            return _namedValues;
+        }
+
         public virtual void SetValue(string name, IEnumerable<PocoNode> value)
         {
             _namedValues.Remove(name);
@@ -63,11 +110,7 @@ public virtual void SetValue(string name, IEnumerable<PocoNode> value)
 
         public virtual Closure Nest()
         {
-            return new Closure()
-            {
-                Parent = this,
-                EvaluationContext = this.EvaluationContext
-            };
+            return new Closure(this, EvaluationContext);
         }
 
 
@@ -89,7 +132,7 @@ public virtual IEnumerable<PocoNode> ResolveValue(string name)
         }
 
         private static ScopedNode getResourceFromNode(ScopedNode node) => node.AtResource ? node : node.ParentResource;
-        
+
         private static ScopedNode getRootResourceFromNode(ScopedNode node)
         {
             var resource = getResourceFromNode(node);