Unfold choice type slices when no unfolded elements match

src/fhirtypes/StructureDefinition.ts

@@ -216,6 +216,7 @@ export class StructureDefinition {
     const parsedPath = parseFSHPath(path);
 
     let fhirPathString = this.pathType;
+    let previousPathPart = '';
     let matchingElements = this.elements;
     let newMatchingElements: ElementDefinition[] = [];
     // Iterate over the path, filtering out elements that do not match
@@ -241,6 +242,14 @@ export class StructureDefinition {
         if (unfoldedElements.length > 0) {
           // Only get the children that match our path
           newMatchingElements = unfoldedElements.filter(e => e.path.startsWith(fhirPathString));
+          // If none of those matched, try unfolding the choice elements
+          if (
+            newMatchingElements.length === 0 &&
+            matchingElements[0].id.endsWith(`[x]:${previousPathPart}`)
+          ) {
+            unfoldedElements = matchingElements[0].unfoldChoiceElementTypes(fisher);
+            newMatchingElements = unfoldedElements.filter(e => e.path.startsWith(fhirPathString));
+          }
         } else if (matchingElements[0].id.endsWith('[x]')) {
           unfoldedElements = matchingElements[0].unfoldChoiceElementTypes(fisher);
           newMatchingElements = unfoldedElements.filter(e => e.path.startsWith(fhirPathString));
@@ -312,6 +321,7 @@ export class StructureDefinition {
           );
         });
       }
+      previousPathPart = pathPart.base;
     }
 
     // We could still have child elements that are matching, if so filter them out now

test/fhirtypes/StructureDefinition.test.ts

@@ -1127,6 +1127,29 @@ describe('StructureDefinition', () => {
       expect(observation.elements.length).toBe(originalLength + 8);
     });
 
+    it('should make explicit a non-existing choice element that must be unfolded when finding it by a type-specific path to a child element', () => {
+      // NOTE: MedicationStatement-uv-ips profile has some child elements on effective[x]
+      // but not the child elements of the choiceTypes so need to unfold in order to find those
+      const ipsMedicationStatement = fisher.fishForStructureDefinition(
+        'MedicationStatement-uv-ips'
+      );
+      const originalLength = ipsMedicationStatement.elements.length;
+      const effectiveX = ipsMedicationStatement.findElementByPath('effective[x]', fisher);
+      expect(effectiveX.slicing).toBeUndefined();
+      const effectivePeriodStart = ipsMedicationStatement.findElementByPath(
+        'effectivePeriod.start',
+        fisher
+      );
+      expect(effectivePeriodStart).toBeDefined();
+      expect(effectivePeriodStart.id).toBe(
+        'MedicationStatement.effective[x]:effectivePeriod.start'
+      );
+      expect(effectivePeriodStart.path).toBe('MedicationStatement.effective[x].start');
+      expect(effectiveX.slicing).toBeDefined();
+      expect(effectiveX.slicing.discriminator[0]).toEqual({ type: 'type', path: '$this' });
+      expect(ipsMedicationStatement.elements.length).toBe(originalLength + 7); // unfolded effectivePeriod + it's 6 child elements
+    });
+
     it('should find an already existing explicit choice element with slicing syntax', () => {
       const originalLength = respRate.elements.length;
       const valueQuantity = respRate.findElementByPath('value[x][valueQuantity]', fisher);