Merge pull request #2747 from FirelyTeam/feature/location-itypedelement

ewoutkramer · web-flow · commit 673101089e62 · 2024-03-27T11:05:17.000+01:00
Fixed location property on TypedElementOnSourceNode.cs
diff --git a/src/Hl7.Fhir.Base/ElementModel/SourceNodeExtensions.cs b/src/Hl7.Fhir.Base/ElementModel/SourceNodeExtensions.cs
@@ -170,6 +170,14 @@ public static string GetResourceTypeIndicator(this ISourceNode node) =>
         /// <seealso cref="IAnnotated"/>
         public static IEnumerable<object> Annotations(this ISourceNode node, Type type) =>
             node is IAnnotated ann ? ann.Annotations(type) : Enumerable.Empty<object>();
+        
+        /// <summary>
+        /// Gets specific annotations from the list of annotations on the node.
+        /// </summary>
+        /// <returns>All of the annotations of the given type, or an empty list if none were found.</returns>
+        /// <seealso cref="IAnnotated"/>
+        public static IEnumerable<T> Annotations<T>(this ISourceNode node) =>
+            (node is IAnnotated ann ? ann.Annotations<T>() : []);
 
         /// <summary>
         /// Gets a specific annotation from the list of annotations on the node.
diff --git a/src/Hl7.Fhir.Base/ElementModel/TypedElementOnSourceNode.cs b/src/Hl7.Fhir.Base/ElementModel/TypedElementOnSourceNode.cs
@@ -14,14 +14,16 @@
 using System.Threading;
 using P = Hl7.Fhir.ElementModel.Types;
 
+#nullable enable
+
 namespace Hl7.Fhir.ElementModel
 {
     internal class TypedElementOnSourceNode : ITypedElement, IAnnotated, IExceptionSource, IShortPathGenerator
     {
         private const string XHTML_INSTANCETYPE = "xhtml";
         private const string XHTML_DIV_TAG_NAME = "div";
 
-        public TypedElementOnSourceNode(ISourceNode source, string type, IStructureDefinitionSummaryProvider provider, TypedElementSettings settings = null)
+        public TypedElementOnSourceNode(ISourceNode source, string? type, IStructureDefinitionSummaryProvider provider, TypedElementSettings? settings = null)
         {
             if (source == null) throw Error.ArgumentNull(nameof(source));
 
@@ -31,12 +33,13 @@ public TypedElementOnSourceNode(ISourceNode source, string type, IStructureDefin
             if (source is IExceptionSource ies && ies.ExceptionHandler == null)
                 ies.ExceptionHandler = (o, a) => ExceptionHandler.NotifyOrThrow(o, a);
 
+            Location = source.Name;
             ShortPath = source.Name;
             _source = source;
             (InstanceType, Definition) = buildRootPosition(type);
         }
 
-        private (string instanceType, IElementDefinitionSummary definition) buildRootPosition(string type)
+        private (string instanceType, IElementDefinitionSummary? definition) buildRootPosition(string? type)
         {
             var rootType = type ?? _source.GetResourceTypeIndicator();
             if (rootType == null)
@@ -45,7 +48,7 @@ public TypedElementOnSourceNode(ISourceNode source, string type, IStructureDefin
                     throw Error.Format(nameof(type), $"Cannot determine the type of the root element at '{_source.Location}', " +
                         $"please supply a type argument.");
                 else
-                    return (rootType, null);
+                    return ("Base", null);
             }
 
             var elementType = Provider.Provide(rootType);
@@ -66,7 +69,7 @@ public TypedElementOnSourceNode(ISourceNode source, string type, IStructureDefin
         }
 
 
-        private TypedElementOnSourceNode(TypedElementOnSourceNode parent, ISourceNode source, IElementDefinitionSummary definition, string instanceType, string prettyPath)
+        private TypedElementOnSourceNode(TypedElementOnSourceNode parent, ISourceNode source, IElementDefinitionSummary? definition, string instanceType, string prettyPath, string location)
         {
             _source = source;
             ShortPath = prettyPath;
@@ -75,11 +78,12 @@ private TypedElementOnSourceNode(TypedElementOnSourceNode parent, ISourceNode so
             Definition = definition;
             InstanceType = instanceType;
             _settings = parent._settings;
+            Location = location;
         }
 
-        public ExceptionNotificationHandler ExceptionHandler { get; set; }
+        public ExceptionNotificationHandler? ExceptionHandler { get; set; }
 
-        private void raiseTypeError(string message, object source, bool warning = false, string location = null)
+        private void raiseTypeError(string message, object source, bool warning = false, string? location = null)
         {
             var exMessage = $"Type checking the data: {message}";
             if (!string.IsNullOrEmpty(location))
@@ -101,7 +105,7 @@ private void raiseTypeError(string message, object source, bool warning = false,
 
         private readonly TypedElementSettings _settings;
 
-        public IElementDefinitionSummary Definition { get; private set; }
+        public IElementDefinitionSummary? Definition { get; private set; }
 
         public string Name => Definition?.ElementName ?? _source.Name;
 
@@ -120,7 +124,7 @@ private void raiseTypeError(string message, object source, bool warning = false,
         // R3 and R4, these value (and url and id elements by the way) will indicate which type
         // of system types there are, implicitly specifying the mapping between primitive
         // FHIR types and system types.
-        private static Type tryMapFhirPrimitiveTypeToSystemType(string fhirType)
+        private static Type? tryMapFhirPrimitiveTypeToSystemType(string fhirType)
         {
             switch (fhirType)
             {
@@ -158,7 +162,7 @@ private static Type tryMapFhirPrimitiveTypeToSystemType(string fhirType)
             }
         }
 
-        private object valueFactory()
+        private object? valueFactory()
         {
             string sourceText = _source.Text;
 
@@ -209,7 +213,7 @@ private object valueFactory()
                     if (P.Any.TryParse(sourceText, typeof(P.DateTime), out var dateTimeVal))
                     {
                         // TruncateToDate converts 1991-02-03T11:22:33Z to 1991-02-03+00:00 which is not a valid date! 
-                        var date = (dateTimeVal as P.DateTime).TruncateToDate();
+                        var date = (dateTimeVal as P.DateTime)!.TruncateToDate();
                         // so we cut off timezone by converting it to timeoffset and cast back to date.
                         return P.Date.FromDateTimeOffset(date.ToDateTimeOffset(0, 0, 0, TimeSpan.Zero));
                     }
@@ -220,13 +224,13 @@ private object valueFactory()
             }
         }
 
-        private object _value;
+        private object? _value;
         private bool _valueInitialized = false;
         private static object _initializationLock = new();
 
-        public object Value => LazyInitializer.EnsureInitialized(ref _value, ref _valueInitialized, ref _initializationLock, valueFactory);
+        public object Value => LazyInitializer.EnsureInitialized(ref _value, ref _valueInitialized, ref _initializationLock, valueFactory)!;
 
-        private string deriveInstanceType(ISourceNode current, IElementDefinitionSummary info)
+        private string? deriveInstanceType(ISourceNode current, IElementDefinitionSummary info)
         {
             var resourceTypeIndicator = current.GetResourceTypeIndicator();
 
@@ -338,7 +342,7 @@ private string typeFromLogicalModelCanonical(ITypeSerializationInfo info)
             return pos > -1 ? type.Substring(pos + 1) : type;
         }
 
-        private bool tryGetBySuffixedName(Dictionary<string, IElementDefinitionSummary> dis, string name, out IElementDefinitionSummary info)
+        private bool tryGetBySuffixedName(Dictionary<string, IElementDefinitionSummary> dis, string name, out IElementDefinitionSummary? info)
         {
             // Simplest case, one on one match between name and element name
             if (dis.TryGetValue(name, out info))
@@ -361,7 +365,7 @@ private bool tryGetBySuffixedName(Dictionary<string, IElementDefinitionSummary>
             }
         }
 
-        private IEnumerable<TypedElementOnSourceNode> enumerateElements(Dictionary<string, IElementDefinitionSummary> dis, ISourceNode parent, string name)
+        private IEnumerable<TypedElementOnSourceNode> enumerateElements(Dictionary<string, IElementDefinitionSummary> dis, ISourceNode parent, string? name)
         {
             IEnumerable<ISourceNode> childSet;
 
@@ -372,17 +376,17 @@ private IEnumerable<TypedElementOnSourceNode> enumerateElements(Dictionary<strin
             {
                 var hit = dis.TryGetValue(name, out var info);
                 childSet = hit
-                    ? (info.IsChoiceElement ? parent.Children(name + "*") : parent.Children(name))
+                    ? (info!.IsChoiceElement ? parent.Children(name + "*") : parent.Children(name))
                     : Enumerable.Empty<ISourceNode>();
             }
 
-            string lastName = null;
+            string? lastName = null;
             int _nameIndex = 0;
 
             foreach (var scan in childSet)
             {
                 var hit = tryGetBySuffixedName(dis, scan.Name, out var info);
-                string instanceType = info == null ? null :
+                string? instanceType = info == null ? null :
                     deriveInstanceType(scan, info);
 
                 // If we have definitions for the children, but we didn't find definitions for this 
@@ -406,28 +410,31 @@ private IEnumerable<TypedElementOnSourceNode> enumerateElements(Dictionary<strin
                 }
 
                 var prettyPath =
-                 hit && !info.IsCollection ? $"{ShortPath}.{info.ElementName}" : $"{ShortPath}.{scan.Name}[{_nameIndex}]";
+                 hit && !info!.IsCollection ? $"{ShortPath}.{info.ElementName}" : $"{ShortPath}.{scan.Name}[{_nameIndex}]";
+
+                var location =
+                    hit ? $"{Location}.{info!.ElementName}[{_nameIndex}]" : $"{Location}.{scan.Name}[{_nameIndex}]";
 
                 // Special condition for ccda.
                 // If we encounter a xhtml node in a ccda document we will flatten all childnodes
                 // and use their content to build up the xml.
                 // The xml will be put in this node and children will be ignored.
-                if (instanceType == XHTML_INSTANCETYPE && info.Representation == XmlRepresentation.CdaText)
+                if (instanceType == XHTML_INSTANCETYPE && info!.Representation == XmlRepresentation.CdaText)
                 {
 #pragma warning disable CS0618 // Type or member is obsolete
                     var xmls = scan.Children().Select(c => c.Annotation<ICdaInfoSupplier>()?.XHtmlText);
 #pragma warning restore CS0618 // Type or member is obsolete
 
                     var source = SourceNode.Valued(scan.Name, string.Join(string.Empty, xmls));
-                    yield return new TypedElementOnSourceNode(this, source, info, instanceType, prettyPath);
+                    yield return new TypedElementOnSourceNode(this, source, info, instanceType, prettyPath, location);
                     continue;
                 }
 
-                yield return new TypedElementOnSourceNode(this, scan, info, instanceType, prettyPath);
+                yield return new TypedElementOnSourceNode(this, scan, info, instanceType!, prettyPath, location);
             }
         }
 
-        public IEnumerable<ITypedElement> Children(string name = null)
+        public IEnumerable<ITypedElement> Children(string? name = null)
         {
             // If we have an xhtml typed node and there is not a div tag around the content
             // then we will not enumerate through the children of this node, since there will be no types
@@ -461,13 +468,13 @@ public IEnumerable<ITypedElement> Children(string name = null)
         private IEnumerable<ITypedElement> runAdditionalRules(IEnumerable<ITypedElement> children)
         {
 #pragma warning disable 612, 618
-            var additionalRules = _source.Annotations(typeof(AdditionalStructuralRule));
+            var additionalRules = _source.Annotations<AdditionalStructuralRule>().ToArray();
             var stateBag = new Dictionary<AdditionalStructuralRule, object>();
             foreach (var child in children)
             {
-                foreach (var rule in additionalRules.Cast<AdditionalStructuralRule>())
+                foreach (var rule in additionalRules)
                 {
-                    stateBag.TryGetValue(rule, out object state);
+                    stateBag.TryGetValue(rule, out object? state);
                     state = rule(child, this, state);
                     if (state != null) stateBag[rule] = state;
                 }
@@ -477,25 +484,23 @@ private IEnumerable<ITypedElement> runAdditionalRules(IEnumerable<ITypedElement>
 #pragma warning restore 612, 618
         }
 
-        public string Location => _source.Location;
+        public string Location { get; init; }
 
         public string ShortPath { get; private set; }
 
         public override string ToString() =>
-            $"{(InstanceType != null ? ($"[{InstanceType}] ") : "")}{_source}";
+            $"{(($"[{InstanceType}] "))}{_source}";
 
         public IEnumerable<object> Annotations(Type type)
         {
-#pragma warning disable IDE0046 // Convert to conditional expression
             if (type == typeof(TypedElementOnSourceNode) || type == typeof(ITypedElement) || type == typeof(IShortPathGenerator))
-#pragma warning restore IDE0046 // Convert to conditional expression
                 return new[] { this };
             else
                 return _source.Annotations(type);
         }
     }
 
     [Obsolete("This class is used for internal purposes and is subject to change without notice. Don't use.")]
-    public delegate object AdditionalStructuralRule(ITypedElement node, IExceptionSource ies, object state);
+    public delegate object? AdditionalStructuralRule(ITypedElement node, IExceptionSource ies, object? state);
 }
 
diff --git a/src/Hl7.Fhir.ElementModel.Shared.Tests/ScopedNodeTests.cs b/src/Hl7.Fhir.ElementModel.Shared.Tests/ScopedNodeTests.cs
@@ -267,7 +267,7 @@ static bool CCDATypeNameMapper(string typeName, out string canonical)
             Assert.AreEqual(1, assertXHtml.Count());
             Assert.AreEqual("text", assertXHtml.First().Name);
             Assert.AreEqual("xhtml", assertXHtml.First().InstanceType);
-            Assert.AreEqual("text", assertXHtml.First().Location);
+            Assert.AreEqual("Section.text[0]", assertXHtml.First().Location);
             Assert.IsNotNull(assertXHtml.First().Value);
 
 
diff --git a/src/Hl7.Fhir.ElementModel.Shared.Tests/TypedElementOnSourceNodeTests.cs b/src/Hl7.Fhir.ElementModel.Shared.Tests/TypedElementOnSourceNodeTests.cs
@@ -1,9 +1,11 @@
-﻿using System;
+﻿using Hl7.Fhir.Model;
+using System;
 using System.Linq;
-using System.Threading.Tasks;
 using Hl7.Fhir.Serialization;
 using Hl7.Fhir.Specification;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using Task = System.Threading.Tasks.Task;
 
 namespace Hl7.Fhir.ElementModel.Tests
 {
@@ -22,5 +24,27 @@ public async Task TestExceptionComplexTypeValue()
 
             var _ = typedBundle.Children("entry").First().Value;
         }
+        
+        private SourceNode testPatient => SourceNode.Node("Patient",
+            SourceNode.Resource("contained", "Observation", SourceNode.Valued("valueBoolean", "true")),
+            SourceNode.Valued("active", "true",
+                SourceNode.Valued("id", "myId2"),
+                SourceNode.Node("extension",
+                    SourceNode.Valued("url", "http://example.org/ext"),
+                    SourceNode.Valued("valueString", "world!"))));
+        
+        private TypedElementOnSourceNode getTestPatient => (TypedElementOnSourceNode)testPatient.ToTypedElement(ModelInfo.ModelInspector, "Patient");
+        
+        [TestMethod]
+        public void KnowsPath()
+        {
+            var tp = getTestPatient;
+            Assert.AreEqual("Patient", getTestPatient.Location);
+            Assert.AreEqual("Patient.contained[0].value[0]", getTestPatient.Children("contained").First().Children("value").First().Location);
+            Assert.AreEqual("Patient.active[0]", getTestPatient.Children("active").First().Location);
+            Assert.AreEqual("Patient.active[0].id[0]", getTestPatient.Children("active").First().Children("id").First().Location);
+            Assert.AreEqual("Patient.active[0].extension[0].url[0]", getTestPatient.Children("active").First().Children("extension").First().Children("url").First().Location);
+            Assert.AreEqual("Patient.active[0].extension[0].value[0]", getTestPatient.Children("active").First().Children("extension").First().Children("value").First().Location);
+        }
     }
 }
diff --git a/src/Hl7.Fhir.Serialization.Shared.Tests/RoundtripAllSerializers.cs b/src/Hl7.Fhir.Serialization.Shared.Tests/RoundtripAllSerializers.cs
@@ -28,12 +28,12 @@ public string RoundTripXml(string original) =>
             engine.SerializeToXml(
                 engine.DeserializeFromJson(
                     engine.SerializeToJson(
-                        engine.DeserializeFromXml(original))));
+                        engine.DeserializeFromXml(original)!))!);
         public string RoundTripJson(string original) => 
             engine.SerializeToJson(
                 engine.DeserializeFromXml(
                     engine.SerializeToXml(
-                        engine.DeserializeFromJson(original))));
+                        engine.DeserializeFromJson(original)!))!);
     }
     
     internal class TypedElementBasedRoundtripper(IStructureDefinitionSummaryProvider provider) : IRoundTripper
@@ -249,7 +249,7 @@ public void TestMatchAndExactly(ZipArchiveEntry entry)
                 ? NEW_POCO_ENGINE.DeserializeFromXml(input)
                 : NEW_POCO_ENGINE.DeserializeFromJson(input);
 
-            var r2 = (Resource)resource.DeepCopy();
+            var r2 = (Resource)resource!.DeepCopy();
             Assert.IsTrue(resource.Matches(r2),
                 "Serialization of " + name + " did not match output - Matches test");
             Assert.IsTrue(resource.IsExactly(r2),
diff --git a/src/Hl7.Fhir.Support.Poco.Tests/Rest/TransactionBuilderTests.cs b/src/Hl7.Fhir.Support.Poco.Tests/Rest/TransactionBuilderTests.cs

Original file line number	Diff line number	Diff line change
`@@ -14,14 +14,16 @@`
`14`	`14`	`using System.Threading;`
`15`	`15`	`using P = Hl7.Fhir.ElementModel.Types;`
`16`	`16`
	`17`	`+#nullable enable`
	`18`	`+`
`17`	`19`	`namespace Hl7.Fhir.ElementModel`
`18`	`20`	`{`
`19`	`21`	`internal class TypedElementOnSourceNode : ITypedElement, IAnnotated, IExceptionSource, IShortPathGenerator`
`20`	`22`	`{`
`21`	`23`	`private const string XHTML_INSTANCETYPE = "xhtml";`
`22`	`24`	`private const string XHTML_DIV_TAG_NAME = "div";`
`23`	`25`
`24`		`- public TypedElementOnSourceNode(ISourceNode source, string type, IStructureDefinitionSummaryProvider provider, TypedElementSettings settings = null)`
	`26`	`+ public TypedElementOnSourceNode(ISourceNode source, string? type, IStructureDefinitionSummaryProvider provider, TypedElementSettings? settings = null)`
`25`	`27`	`{`
`26`	`28`	`if (source == null) throw Error.ArgumentNull(nameof(source));`
`27`	`29`
`@@ -31,12 +33,13 @@ public TypedElementOnSourceNode(ISourceNode source, string type, IStructureDefin`
`31`	`33`	`if (source is IExceptionSource ies && ies.ExceptionHandler == null)`
`32`	`34`	`ies.ExceptionHandler = (o, a) => ExceptionHandler.NotifyOrThrow(o, a);`
`33`	`35`
	`36`	`+ Location = source.Name;`
`34`	`37`	`ShortPath = source.Name;`
`35`	`38`	`_source = source;`
`36`	`39`	`(InstanceType, Definition) = buildRootPosition(type);`
`37`	`40`	`}`
`38`	`41`
`39`		`- private (string instanceType, IElementDefinitionSummary definition) buildRootPosition(string type)`
	`42`	`+ private (string instanceType, IElementDefinitionSummary? definition) buildRootPosition(string? type)`
`40`	`43`	`{`
`41`	`44`	`var rootType = type ?? _source.GetResourceTypeIndicator();`
`42`	`45`	`if (rootType == null)`
`@@ -45,7 +48,7 @@ public TypedElementOnSourceNode(ISourceNode source, string type, IStructureDefin`
`45`	`48`	`throw Error.Format(nameof(type), $"Cannot determine the type of the root element at '{_source.Location}', " +`
`46`	`49`	`$"please supply a type argument.");`
`47`	`50`	`else`
`48`		`- return (rootType, null);`
	`51`	`+ return ("Base", null);`
`49`	`52`	`}`
`50`	`53`
`51`	`54`	`var elementType = Provider.Provide(rootType);`
`@@ -66,7 +69,7 @@ public TypedElementOnSourceNode(ISourceNode source, string type, IStructureDefin`
`66`	`69`	`}`
`67`	`70`
`68`	`71`
`69`		`- private TypedElementOnSourceNode(TypedElementOnSourceNode parent, ISourceNode source, IElementDefinitionSummary definition, string instanceType, string prettyPath)`
	`72`	`+ private TypedElementOnSourceNode(TypedElementOnSourceNode parent, ISourceNode source, IElementDefinitionSummary? definition, string instanceType, string prettyPath, string location)`
`70`	`73`	`{`
`71`	`74`	`_source = source;`
`72`	`75`	`ShortPath = prettyPath;`
`@@ -75,11 +78,12 @@ private TypedElementOnSourceNode(TypedElementOnSourceNode parent, ISourceNode so`
`75`	`78`	`Definition = definition;`
`76`	`79`	`InstanceType = instanceType;`
`77`	`80`	`_settings = parent._settings;`
	`81`	`+ Location = location;`
`78`	`82`	`}`
`79`	`83`
`80`		`- public ExceptionNotificationHandler ExceptionHandler { get; set; }`
	`84`	`+ public ExceptionNotificationHandler? ExceptionHandler { get; set; }`
`81`	`85`
`82`		`- private void raiseTypeError(string message, object source, bool warning = false, string location = null)`
	`86`	`+ private void raiseTypeError(string message, object source, bool warning = false, string? location = null)`
`83`	`87`	`{`
`84`	`88`	`var exMessage = $"Type checking the data: {message}";`
`85`	`89`	`if (!string.IsNullOrEmpty(location))`
`@@ -101,7 +105,7 @@ private void raiseTypeError(string message, object source, bool warning = false,`
`101`	`105`
`102`	`106`	`private readonly TypedElementSettings _settings;`
`103`	`107`
`104`		`- public IElementDefinitionSummary Definition { get; private set; }`
	`108`	`+ public IElementDefinitionSummary? Definition { get; private set; }`
`105`	`109`
`106`	`110`	`public string Name => Definition?.ElementName ?? _source.Name;`
`107`	`111`
`@@ -120,7 +124,7 @@ private void raiseTypeError(string message, object source, bool warning = false,`
`120`	`124`	`// R3 and R4, these value (and url and id elements by the way) will indicate which type`
`121`	`125`	`// of system types there are, implicitly specifying the mapping between primitive`
`122`	`126`	`// FHIR types and system types.`
`123`		`- private static Type tryMapFhirPrimitiveTypeToSystemType(string fhirType)`
	`127`	`+ private static Type? tryMapFhirPrimitiveTypeToSystemType(string fhirType)`
`124`	`128`	`{`
`125`	`129`	`switch (fhirType)`
`126`	`130`	`{`
`@@ -158,7 +162,7 @@ private static Type tryMapFhirPrimitiveTypeToSystemType(string fhirType)`
`158`	`162`	`}`
`159`	`163`	`}`
`160`	`164`
`161`		`- private object valueFactory()`
	`165`	`+ private object? valueFactory()`
`162`	`166`	`{`
`163`	`167`	`string sourceText = _source.Text;`
`164`	`168`
`@@ -209,7 +213,7 @@ private object valueFactory()`
`209`	`213`	`if (P.Any.TryParse(sourceText, typeof(P.DateTime), out var dateTimeVal))`
`210`	`214`	`{`
`211`	`215`	`// TruncateToDate converts 1991-02-03T11:22:33Z to 1991-02-03+00:00 which is not a valid date!`
`212`		`- var date = (dateTimeVal as P.DateTime).TruncateToDate();`
	`216`	`+ var date = (dateTimeVal as P.DateTime)!.TruncateToDate();`
`213`	`217`	`// so we cut off timezone by converting it to timeoffset and cast back to date.`
`214`	`218`	`return P.Date.FromDateTimeOffset(date.ToDateTimeOffset(0, 0, 0, TimeSpan.Zero));`
`215`	`219`	`}`
`@@ -220,13 +224,13 @@ private object valueFactory()`
`220`	`224`	`}`
`221`	`225`	`}`
`222`	`226`
`223`		`- private object _value;`
	`227`	`+ private object? _value;`
`224`	`228`	`private bool _valueInitialized = false;`
`225`	`229`	`private static object _initializationLock = new();`
`226`	`230`
`227`		`- public object Value => LazyInitializer.EnsureInitialized(ref _value, ref _valueInitialized, ref _initializationLock, valueFactory);`
	`231`	`+ public object Value => LazyInitializer.EnsureInitialized(ref _value, ref _valueInitialized, ref _initializationLock, valueFactory)!;`
`228`	`232`
`229`		`- private string deriveInstanceType(ISourceNode current, IElementDefinitionSummary info)`
	`233`	`+ private string? deriveInstanceType(ISourceNode current, IElementDefinitionSummary info)`
`230`	`234`	`{`
`231`	`235`	`var resourceTypeIndicator = current.GetResourceTypeIndicator();`
`232`	`236`
`@@ -338,7 +342,7 @@ private string typeFromLogicalModelCanonical(ITypeSerializationInfo info)`
`338`	`342`	`return pos > -1 ? type.Substring(pos + 1) : type;`
`339`	`343`	`}`
`340`	`344`
`341`		`- private bool tryGetBySuffixedName(Dictionary<string, IElementDefinitionSummary> dis, string name, out IElementDefinitionSummary info)`
	`345`	`+ private bool tryGetBySuffixedName(Dictionary<string, IElementDefinitionSummary> dis, string name, out IElementDefinitionSummary? info)`
`342`	`346`	`{`
`343`	`347`	`// Simplest case, one on one match between name and element name`
`344`	`348`	`if (dis.TryGetValue(name, out info))`
`@@ -361,7 +365,7 @@ private bool tryGetBySuffixedName(Dictionary<string, IElementDefinitionSummary>`
`361`	`365`	`}`
`362`	`366`	`}`
`363`	`367`
`364`		`- private IEnumerable<TypedElementOnSourceNode> enumerateElements(Dictionary<string, IElementDefinitionSummary> dis, ISourceNode parent, string name)`
	`368`	`+ private IEnumerable<TypedElementOnSourceNode> enumerateElements(Dictionary<string, IElementDefinitionSummary> dis, ISourceNode parent, string? name)`
`365`	`369`	`{`
`366`	`370`	`IEnumerable<ISourceNode> childSet;`
`367`	`371`
`@@ -372,17 +376,17 @@ private IEnumerable<TypedElementOnSourceNode> enumerateElements(Dictionary<strin`
`372`	`376`	`{`
`373`	`377`	`var hit = dis.TryGetValue(name, out var info);`
`374`	`378`	`childSet = hit`
`375`		`- ? (info.IsChoiceElement ? parent.Children(name + "*") : parent.Children(name))`
	`379`	`+ ? (info!.IsChoiceElement ? parent.Children(name + "*") : parent.Children(name))`
`376`	`380`	`: Enumerable.Empty<ISourceNode>();`
`377`	`381`	`}`
`378`	`382`
`379`		`- string lastName = null;`
	`383`	`+ string? lastName = null;`
`380`	`384`	`int _nameIndex = 0;`
`381`	`385`
`382`	`386`	`foreach (var scan in childSet)`
`383`	`387`	`{`
`384`	`388`	`var hit = tryGetBySuffixedName(dis, scan.Name, out var info);`
`385`		`- string instanceType = info == null ? null :`
	`389`	`+ string? instanceType = info == null ? null :`
`386`	`390`	`deriveInstanceType(scan, info);`
`387`	`391`
`388`	`392`	`// If we have definitions for the children, but we didn't find definitions for this`
`@@ -406,28 +410,31 @@ private IEnumerable<TypedElementOnSourceNode> enumerateElements(Dictionary<strin`
`406`	`410`	`}`
`407`	`411`
`408`	`412`	`var prettyPath =`
`409`		`- hit && !info.IsCollection ? $"{ShortPath}.{info.ElementName}" : $"{ShortPath}.{scan.Name}[{_nameIndex}]";`
	`413`	`+ hit && !info!.IsCollection ? $"{ShortPath}.{info.ElementName}" : $"{ShortPath}.{scan.Name}[{_nameIndex}]";`
	`414`	`+`
	`415`	`+ var location =`
	`416`	`+ hit ? $"{Location}.{info!.ElementName}[{_nameIndex}]" : $"{Location}.{scan.Name}[{_nameIndex}]";`
`410`	`417`
`411`	`418`	`// Special condition for ccda.`
`412`	`419`	`// If we encounter a xhtml node in a ccda document we will flatten all childnodes`
`413`	`420`	`// and use their content to build up the xml.`
`414`	`421`	`// The xml will be put in this node and children will be ignored.`
`415`		`- if (instanceType == XHTML_INSTANCETYPE && info.Representation == XmlRepresentation.CdaText)`
	`422`	`+ if (instanceType == XHTML_INSTANCETYPE && info!.Representation == XmlRepresentation.CdaText)`
`416`	`423`	`{`
`417`	`424`	`#pragma warning disable CS0618 // Type or member is obsolete`
`418`	`425`	`var xmls = scan.Children().Select(c => c.Annotation<ICdaInfoSupplier>()?.XHtmlText);`
`419`	`426`	`#pragma warning restore CS0618 // Type or member is obsolete`
`420`	`427`
`421`	`428`	`var source = SourceNode.Valued(scan.Name, string.Join(string.Empty, xmls));`
`422`		`- yield return new TypedElementOnSourceNode(this, source, info, instanceType, prettyPath);`
	`429`	`+ yield return new TypedElementOnSourceNode(this, source, info, instanceType, prettyPath, location);`
`423`	`430`	`continue;`
`424`	`431`	`}`
`425`	`432`
`426`		`- yield return new TypedElementOnSourceNode(this, scan, info, instanceType, prettyPath);`
	`433`	`+ yield return new TypedElementOnSourceNode(this, scan, info, instanceType!, prettyPath, location);`
`427`	`434`	`}`
`428`	`435`	`}`
`429`	`436`
`430`		`- public IEnumerable<ITypedElement> Children(string name = null)`
	`437`	`+ public IEnumerable<ITypedElement> Children(string? name = null)`
`431`	`438`	`{`
`432`	`439`	`// If we have an xhtml typed node and there is not a div tag around the content`
`433`	`440`	`// then we will not enumerate through the children of this node, since there will be no types`
`@@ -461,13 +468,13 @@ public IEnumerable<ITypedElement> Children(string name = null)`
`461`	`468`	`private IEnumerable<ITypedElement> runAdditionalRules(IEnumerable<ITypedElement> children)`
`462`	`469`	`{`
`463`	`470`	`#pragma warning disable 612, 618`
`464`		`- var additionalRules = _source.Annotations(typeof(AdditionalStructuralRule));`
	`471`	`+ var additionalRules = _source.Annotations<AdditionalStructuralRule>().ToArray();`
`465`	`472`	`var stateBag = new Dictionary<AdditionalStructuralRule, object>();`
`466`	`473`	`foreach (var child in children)`
`467`	`474`	`{`
`468`		`- foreach (var rule in additionalRules.Cast<AdditionalStructuralRule>())`
	`475`	`+ foreach (var rule in additionalRules)`
`469`	`476`	`{`
`470`		`- stateBag.TryGetValue(rule, out object state);`
	`477`	`+ stateBag.TryGetValue(rule, out object? state);`
`471`	`478`	`state = rule(child, this, state);`
`472`	`479`	`if (state != null) stateBag[rule] = state;`
`473`	`480`	`}`
`@@ -477,25 +484,23 @@ private IEnumerable<ITypedElement> runAdditionalRules(IEnumerable<ITypedElement>`
`477`	`484`	`#pragma warning restore 612, 618`
`478`	`485`	`}`
`479`	`486`
`480`		`- public string Location => _source.Location;`
	`487`	`+ public string Location { get; init; }`
`481`	`488`
`482`	`489`	`public string ShortPath { get; private set; }`
`483`	`490`
`484`	`491`	`public override string ToString() =>`
`485`		`- $"{(InstanceType != null ? ($"[{InstanceType}] ") : "")}{_source}";`
	`492`	`+ $"{(($"[{InstanceType}] "))}{_source}";`
`486`	`493`
`487`	`494`	`public IEnumerable<object> Annotations(Type type)`
`488`	`495`	`{`
`489`		`-#pragma warning disable IDE0046 // Convert to conditional expression`
`490`	`496`	`if (type == typeof(TypedElementOnSourceNode) \|\| type == typeof(ITypedElement) \|\| type == typeof(IShortPathGenerator))`
`491`		`-#pragma warning restore IDE0046 // Convert to conditional expression`
`492`	`497`	`return new[] { this };`
`493`	`498`	`else`
`494`	`499`	`return _source.Annotations(type);`
`495`	`500`	`}`
`496`	`501`	`}`
`497`	`502`
`498`	`503`	`[Obsolete("This class is used for internal purposes and is subject to change without notice. Don't use.")]`
`499`		`- public delegate object AdditionalStructuralRule(ITypedElement node, IExceptionSource ies, object state);`
	`504`	`+ public delegate object? AdditionalStructuralRule(ITypedElement node, IExceptionSource ies, object? state);`
`500`	`505`	`}`
`501`	`506`