Merge pull request #514 from Handlebars-Net/feature/shared-env

oformaniuk · web-flow · commit e709aa9a3b90 · 2022-03-26T10:26:11.000-07:00
Introduce `SharedEnvironment`
diff --git a/README.md b/README.md
@@ -253,6 +253,56 @@ public void DateTimeFormatter(IHandlebars handlebars)
 #### Notes
 - Formatters are resolved in reverse order according to registration. If multiple providers can provide formatter for a type the last registered would be used.
 
+### Shared environment
+
+By default Handlebars will create standalone copy of environment for each compiled template. This is done in order to eliminate a chance of altering behavior of one template from inside of other one.
+
+Unfortunately, in case runtime has a lot of compiled templates (regardless of the template size) it may have significant memory footprint. This can be solved by using `SharedEnvironment`.
+
+Templates compiled in `SharedEnvironment` will share the same configuration.
+
+#### Limitations
+
+Only runtime configuration properties can be changed after the shared environment has been created. Changes to `Configuration.CompileTimeConfiguration` and other compile-time properties will have no effect. 
+
+#### Example
+
+```c#
+[Fact]
+public void BasicSharedEnvironment()
+{
+    var handlebars = Handlebars.CreateSharedEnvironment();
+    handlebars.RegisterHelper("registerLateHelper", 
+        (in EncodedTextWriter writer, in HelperOptions options, in Context context, in Arguments arguments) =>
+        {
+            var configuration = options.Frame
+                .GetType()
+                .GetProperty("Configuration", BindingFlags.Instance | BindingFlags.NonPublic)?
+                .GetValue(options.Frame) as ICompiledHandlebarsConfiguration;
+            
+            var helpers = configuration?.Helpers;
+
+            const string name = "lateHelper";
+            if (helpers?.TryGetValue(name, out var @ref) ?? false)
+            {
+                @ref.Value = new DelegateReturnHelperDescriptor(name, (c, a) => 42);
+            }
+        });
+    
+    var _0_template = "{{registerLateHelper}}";
+    var _0 = handlebars.Compile(_0_template);
+    var _1_template = "{{lateHelper}}";
+    var _1 = handlebars.Compile(_1_template);
+    
+    var result = _1(null);
+    Assert.Equal("", result); // `lateHelper` is not registered yet
+
+    _0(null);
+    result = _1(null);
+    Assert.Equal("42", result);
+}
+```
+
 ### Compatibility feature toggles
 
 Compatibility feature toggles defines a set of settings responsible for controlling compilation/rendering behavior. Each of those settings would enable certain feature that would break compatibility with canonical Handlebars.
diff --git a/source/Handlebars.Test/BasicIntegrationTests.cs b/source/Handlebars.Test/BasicIntegrationTests.cs
@@ -12,6 +12,7 @@
 using HandlebarsDotNet.Features;
 using HandlebarsDotNet.IO;
 using HandlebarsDotNet.PathStructure;
+using HandlebarsDotNet.Runtime;
 using HandlebarsDotNet.ValueProviders;
 
 namespace HandlebarsDotNet.Test
@@ -56,6 +57,42 @@ public void BasicPath(IHandlebars handlebars)
             var result = template(data);
             Assert.Equal("Hello, Handlebars.Net!", result);
         }
+        
+        [Fact]
+        public void BasicSharedEnvironment()
+        {
+            var handlebars = Handlebars.CreateSharedEnvironment();
+            handlebars.RegisterHelper("registerLateHelper", 
+                (in EncodedTextWriter writer, in HelperOptions options, in Context context, in Arguments arguments) =>
+                {
+                    var configuration = options.Frame
+                        .GetType()
+                        .GetProperty("Configuration", BindingFlags.Instance | BindingFlags.NonPublic)?
+                        .GetValue(options.Frame) as ICompiledHandlebarsConfiguration;
+                    
+                    if(configuration == null) return;
+                    
+                    var helpers = configuration.Helpers;
+
+                    const string name = "lateHelper";
+                    if (helpers.TryGetValue(name, out var @ref))
+                    {
+                        @ref.Value = new DelegateReturnHelperDescriptor(name, (c, a) => 42);
+                    }
+                });
+            
+            var _0_template = "{{registerLateHelper}}";
+            var _0 = handlebars.Compile(_0_template);
+            var _1_template = "{{lateHelper}}";
+            var _1 = handlebars.Compile(_1_template);
+            
+            var result = _1(null);
+            Assert.Equal("", result); // `lateHelper` is not registered yet
+
+            _0(null);
+            result = _1(null);
+            Assert.Equal("42", result);
+        }
 
         [Theory]
         [ClassData(typeof(HandlebarsEnvGenerator))]
@@ -110,7 +147,7 @@ public void PathUnresolvedBindingFormatter(IHandlebars handlebars)
         }
         
         [Theory, ClassData(typeof(HandlebarsEnvGenerator))]
-        public void CustcomDateTimeFormat(IHandlebars handlebars)
+        public void CustomDateTimeFormat(IHandlebars handlebars)
         {
             var source = "{{now}}";
 
@@ -420,6 +457,8 @@ public void BasicPropertyOnArray(IHandlebars handlebars)
         [Theory, ClassData(typeof(HandlebarsEnvGenerator))]
         public void AliasedPropertyOnArray(IHandlebars handlebars)
         {
+            if(handlebars.IsSharedEnvironment) return;
+
             var source = "Array is {{ names.count }} item(s) long";
             handlebars.Configuration.UseCollectionMemberAliasProvider();
             var template = handlebars.Compile(source);
@@ -452,6 +491,8 @@ public void CustomAliasedPropertyOnArray(IHandlebars handlebars)
         [Theory, ClassData(typeof(HandlebarsEnvGenerator))]
         public void AliasedPropertyOnList(IHandlebars handlebars)
         {
+            if(handlebars.IsSharedEnvironment) return;
+            
             var source = "Array is {{ names.Length }} item(s) long";
             handlebars.Configuration.UseCollectionMemberAliasProvider();
             var template = handlebars.Compile(source);
diff --git a/source/Handlebars.Test/Handlebars.Test.csproj b/source/Handlebars.Test/Handlebars.Test.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp2.1;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>netcoreapp3.1</TargetFrameworks>
     <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT'">$(TargetFrameworks);net452;net46;net461;net472</TargetFrameworks>
     <ProjectGuid>6BA232A6-8C4D-4C7D-BD75-1844FE9774AF</ProjectGuid>
     <RootNamespace>HandlebarsDotNet.Test</RootNamespace>
diff --git a/source/Handlebars.Test/HandlebarsEnvGenerator.cs b/source/Handlebars.Test/HandlebarsEnvGenerator.cs
@@ -10,6 +10,7 @@ public class HandlebarsEnvGenerator : IEnumerable<object[]>
         private readonly List<IHandlebars> _data = new()
         {
             Handlebars.Create(),
+            Handlebars.CreateSharedEnvironment(),
             Handlebars.Create(new HandlebarsConfiguration().Configure(o => o.Compatibility.RelaxedHelperNaming = true)),
             Handlebars.Create(new HandlebarsConfiguration().UseWarmUp(types =>
             {
diff --git a/source/Handlebars/Collections/CascadeIndex.cs b/source/Handlebars/Collections/CascadeIndex.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -16,72 +17,84 @@ namespace HandlebarsDotNet.Collections
     public class CascadeIndex<TKey, TValue, TComparer> : IIndexed<TKey, TValue> 
         where TComparer : IEqualityComparer<TKey>
     {
+        private readonly TComparer _comparer;
         public IReadOnlyIndexed<TKey, TValue> Outer { get; set; }
-        private readonly DictionarySlim<TKey, TValue, TComparer> _inner;
+        private DictionarySlim<TKey, TValue, TComparer> _inner;
 
         public CascadeIndex(TComparer comparer)
+            : this(null, comparer)
         {
-            Outer = null;
-            _inner = new DictionarySlim<TKey, TValue, TComparer>(comparer);
         }
         
-        public int Count => _inner.Count + OuterEnumerable().Count();
+        public CascadeIndex(IReadOnlyIndexed<TKey, TValue> outer, TComparer comparer)
+        {
+            _comparer = comparer;
+            Outer = outer;
+        }
+        
+        public int Count => (_inner?.Count ?? 0) + OuterEnumerable().Count();
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void AddOrReplace(in TKey key, in TValue value)
         {
-            _inner.AddOrReplace(key, value);
+            (_inner ??= new DictionarySlim<TKey, TValue, TComparer>(_comparer)).AddOrReplace(key, value);
         }
 
         public void Clear()
         {
             Outer = null;
-            _inner.Clear();
+            _inner?.Clear();
         }
 
         public bool ContainsKey(in TKey key)
         {
-            return _inner.ContainsKey(key) || (Outer?.ContainsKey(key) ?? false);
+            return (_inner?.ContainsKey(key) ?? false) 
+                   || (Outer?.ContainsKey(key) ?? false);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool TryGetValue(in TKey key, out TValue value)
         {
-            if (_inner.TryGetValue(key, out value)) return true;
-            return Outer?.TryGetValue(key, out value) ?? false;
+            value = default;
+            return (_inner?.TryGetValue(key, out value) ?? false) 
+                   || (Outer?.TryGetValue(key, out value) ?? false);
         }
 
         public TValue this[in TKey key]
         {
             get
             {
-                if (_inner.TryGetValue(key, out var value)) return value;
-                if (Outer?.TryGetValue(key, out value) ?? false) return value;
-                throw new KeyNotFoundException($"{key}");
+                if (TryGetValue(key, out var value)) return value;
+                Throw.KeyNotFoundException($"{key}");
+                return default; // will never reach this point
             }
 
-            set => _inner.AddOrReplace(key, value);
+            set => AddOrReplace(key, value);
         }
 
         public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
         {
-            var enumerator = _inner.GetEnumerator();
-            while (enumerator.MoveNext())
-            {
-                yield return enumerator.Current;
-            }
+            foreach (var pair in InnerEnumerable()) yield return pair;
+            foreach (var pair in OuterEnumerable()) yield return pair;
+        }
 
-            foreach (var pair in OuterEnumerable())
+        private IEnumerable<KeyValuePair<TKey, TValue>> InnerEnumerable()
+        {
+            if(_inner == null) yield break; 
+            
+            var outerEnumerator = _inner.GetEnumerator();
+            while (outerEnumerator.MoveNext())
             {
-                yield return pair;
+                if (_inner.ContainsKey(outerEnumerator.Current.Key)) continue;
+                yield return outerEnumerator.Current;
             }
         }
-
+        
         private IEnumerable<KeyValuePair<TKey, TValue>> OuterEnumerable()
         {
-            var outerEnumerator = Outer?.GetEnumerator();
-            if (outerEnumerator == null) yield break;
-
+            if(Outer == null) yield break;
+            
+            using var outerEnumerator = Outer.GetEnumerator();
             while (outerEnumerator.MoveNext())
             {
                 if (_inner.ContainsKey(outerEnumerator.Current.Key)) continue;
@@ -90,5 +103,10 @@ private IEnumerable<KeyValuePair<TKey, TValue>> OuterEnumerable()
         }
 
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        
+        private static class Throw
+        {
+            public static void KeyNotFoundException(string message, Exception exception = null) => throw new KeyNotFoundException(message, exception);
+        }
     }
 }
diff --git a/source/Handlebars/Configuration/HandlebarsConfigurationAdapter.cs b/source/Handlebars/Configuration/HandlebarsConfigurationAdapter.cs
@@ -18,6 +18,7 @@ namespace HandlebarsDotNet
 {
     internal class HandlebarsConfigurationAdapter : ICompiledHandlebarsConfiguration
     {
+        // observers are in WeakCollection, need to keep reference somewhere
         private readonly List<object> _observers = new List<object>();
         
         public HandlebarsConfigurationAdapter(HandlebarsConfiguration configuration)
@@ -33,6 +34,7 @@ public HandlebarsConfigurationAdapter(HandlebarsConfiguration configuration)
                 new CollectionFormatterProvider(),
                 new ReadOnlyCollectionFormatterProvider()
             }.AddMany(configuration.FormatterProviders);
+            configuration.FormatterProviders.Subscribe(FormatterProviders);
             
             ObjectDescriptorProviders = CreateObjectDescriptorProvider(UnderlingConfiguration.ObjectDescriptorProviders);
             ExpressionMiddlewares = new ObservableList<IExpressionMiddleware>(configuration.CompileTimeConfiguration.ExpressionMiddleware)
@@ -78,7 +80,7 @@ public HandlebarsConfigurationAdapter(HandlebarsConfiguration configuration)
         public IAppendOnlyList<IHelperResolver> HelperResolvers { get; }
         public IIndexed<string, HandlebarsTemplate<TextWriter, object, object>> RegisteredTemplates { get; }
         
-        private ObservableIndex<PathInfoLight, Ref<TDescriptor>, IEqualityComparer<PathInfoLight>> CreateHelpersSubscription<TDescriptor, TOptions>(IIndexed<string, TDescriptor> source) 
+        private ObservableIndex<PathInfoLight, Ref<TDescriptor>, PathInfoLight.PathInfoLightEqualityComparer> CreateHelpersSubscription<TDescriptor, TOptions>(IIndexed<string, TDescriptor> source) 
             where TOptions : struct, IOptions
             where TDescriptor : class, IDescriptor<TOptions>
         {
@@ -89,7 +91,7 @@ private ObservableIndex<PathInfoLight, Ref<TDescriptor>, IEqualityComparer<PathI
                 equalityComparer
             );
             
-            var target = new ObservableIndex<PathInfoLight, Ref<TDescriptor>, IEqualityComparer<PathInfoLight>>(equalityComparer, existingHelpers);
+            var target = new ObservableIndex<PathInfoLight, Ref<TDescriptor>, PathInfoLight.PathInfoLightEqualityComparer>(equalityComparer, existingHelpers);
 
             var observer = ObserverBuilder<ObservableEvent<TDescriptor>>.Create(target)
                 .OnEvent<DictionaryAddedObservableEvent<string, TDescriptor>>(
@@ -130,14 +132,8 @@ private ObservableList<IObjectDescriptorProvider> CreateObjectDescriptorProvider
                 }
                 .AddMany(descriptorProviders);
 
-            var observer = ObserverBuilder<ObservableEvent<IObjectDescriptorProvider>>.Create(objectDescriptorProviders)
-                .OnEvent<AddedObservableEvent<IObjectDescriptorProvider>>((@event, state) => { state.Add(@event.Value); })
-                .Build();
+            descriptorProviders.Subscribe(objectDescriptorProviders);
 
-            _observers.Add(observer);
-            
-            descriptorProviders.Subscribe(observer);
-            
             return objectDescriptorProviders;
         }
     }
diff --git a/source/Handlebars/EqualityComparers/PathInfoLight.PathInfoLightEqualityComparer.cs b/source/Handlebars/EqualityComparers/PathInfoLight.PathInfoLightEqualityComparer.cs
@@ -5,7 +5,7 @@ namespace HandlebarsDotNet
 {
     public readonly partial struct PathInfoLight
     {
-        internal sealed class PathInfoLightEqualityComparer : IEqualityComparer<PathInfoLight>
+        internal readonly struct PathInfoLightEqualityComparer : IEqualityComparer<PathInfoLight>
         {
             private readonly PathInfo.TrimmedPathEqualityComparer _comparer;
 
diff --git a/source/Handlebars/Handlebars.cs b/source/Handlebars/Handlebars.cs
@@ -24,8 +24,19 @@ public static IHandlebars Create(HandlebarsConfiguration configuration = null)
             configuration = configuration ?? new HandlebarsConfiguration();
             return new HandlebarsEnvironment(configuration);
         }
-        
-        
+
+        /// <summary>
+        /// Creates shared Handlebars environment that is used to compile templates that share the same configuration
+        /// <para>Runtime only changes can be applied after object creation!</para>
+        /// </summary>
+        /// <param name="configuration"></param>
+        /// <returns></returns>
+        public static IHandlebars CreateSharedEnvironment(HandlebarsConfiguration configuration = null)
+        {
+            configuration ??= new HandlebarsConfiguration();
+            return new HandlebarsEnvironment(new HandlebarsConfigurationAdapter(configuration));
+        }
+
         /// <summary>
         /// Creates standalone instance of <see cref="Handlebars"/> environment
         /// </summary>
diff --git a/source/Handlebars/HandlebarsEnvironment.cs b/source/Handlebars/HandlebarsEnvironment.cs
@@ -4,7 +4,6 @@
 using HandlebarsDotNet.Compiler;
 using HandlebarsDotNet.Decorators;
 using HandlebarsDotNet.Helpers;
-using HandlebarsDotNet.Helpers.BlockHelpers;
 using HandlebarsDotNet.IO;
 using HandlebarsDotNet.ObjectDescriptors;
 using HandlebarsDotNet.Runtime;
@@ -37,8 +36,11 @@ public HandlebarsEnvironment(HandlebarsConfiguration configuration)
         internal HandlebarsEnvironment(ICompiledHandlebarsConfiguration configuration)
         {
             CompiledConfiguration = configuration ?? throw new ArgumentNullException(nameof(configuration));
+            Configuration = CompiledConfiguration.UnderlingConfiguration;
+            IsSharedEnvironment = true;
         }
-        
+
+        public bool IsSharedEnvironment { get; }
         public HandlebarsConfiguration Configuration { get; }
         internal ICompiledHandlebarsConfiguration CompiledConfiguration { get; }
         ICompiledHandlebarsConfiguration ICompiledHandlebars.CompiledConfiguration => CompiledConfiguration;
@@ -115,6 +117,12 @@ private HandlebarsTemplate<TextWriter, object, object> CompileViewInternal(strin
             };
         }
 
+        public IHandlebars CreateSharedEnvironment()
+        {
+            var configuration = CompiledConfiguration ?? new HandlebarsConfigurationAdapter(Configuration);
+            return new HandlebarsEnvironment(configuration);
+        }
+
         public HandlebarsTemplate<TextWriter, object, object> Compile(TextReader template)
         {
             using var container = AmbientContext.Use(_ambientContext);
diff --git a/source/Handlebars/IHandlebars.cs b/source/Handlebars/IHandlebars.cs
diff --git a/source/Handlebars/PathInfoLight.cs b/source/Handlebars/PathInfoLight.cs

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ public class HandlebarsEnvGenerator : IEnumerable<object[]>`
`10`	`10`	`private readonly List<IHandlebars> _data = new()`
`11`	`11`	`{`
`12`	`12`	`Handlebars.Create(),`
	`13`	`+ Handlebars.CreateSharedEnvironment(),`
`13`	`14`	`Handlebars.Create(new HandlebarsConfiguration().Configure(o => o.Compatibility.RelaxedHelperNaming = true)),`
`14`	`15`	`Handlebars.Create(new HandlebarsConfiguration().UseWarmUp(types =>`
`15`	`16`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Collections;`
`2`	`3`	`using System.Collections.Generic;`
`3`	`4`	`using System.Diagnostics;`
`@@ -16,72 +17,84 @@ namespace HandlebarsDotNet.Collections`
`16`	`17`	`public class CascadeIndex<TKey, TValue, TComparer> : IIndexed<TKey, TValue>`
`17`	`18`	`where TComparer : IEqualityComparer<TKey>`
`18`	`19`	`{`
	`20`	`+ private readonly TComparer _comparer;`
`19`	`21`	`public IReadOnlyIndexed<TKey, TValue> Outer { get; set; }`
`20`		`- private readonly DictionarySlim<TKey, TValue, TComparer> _inner;`
	`22`	`+ private DictionarySlim<TKey, TValue, TComparer> _inner;`
`21`	`23`
`22`	`24`	`public CascadeIndex(TComparer comparer)`
	`25`	`+ : this(null, comparer)`
`23`	`26`	`{`
`24`		`- Outer = null;`
`25`		`- _inner = new DictionarySlim<TKey, TValue, TComparer>(comparer);`
`26`	`27`	`}`
`27`	`28`
`28`		`- public int Count => _inner.Count + OuterEnumerable().Count();`
	`29`	`+ public CascadeIndex(IReadOnlyIndexed<TKey, TValue> outer, TComparer comparer)`
	`30`	`+ {`
	`31`	`+ _comparer = comparer;`
	`32`	`+ Outer = outer;`
	`33`	`+ }`
	`34`	`+`
	`35`	`+ public int Count => (_inner?.Count ?? 0) + OuterEnumerable().Count();`
`29`	`36`
`30`	`37`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`31`	`38`	`public void AddOrReplace(in TKey key, in TValue value)`
`32`	`39`	`{`
`33`		`- _inner.AddOrReplace(key, value);`
	`40`	`+ (_inner ??= new DictionarySlim<TKey, TValue, TComparer>(_comparer)).AddOrReplace(key, value);`
`34`	`41`	`}`
`35`	`42`
`36`	`43`	`public void Clear()`
`37`	`44`	`{`
`38`	`45`	`Outer = null;`
`39`		`- _inner.Clear();`
	`46`	`+ _inner?.Clear();`
`40`	`47`	`}`
`41`	`48`
`42`	`49`	`public bool ContainsKey(in TKey key)`
`43`	`50`	`{`
`44`		`- return _inner.ContainsKey(key) \|\| (Outer?.ContainsKey(key) ?? false);`
	`51`	`+ return (_inner?.ContainsKey(key) ?? false)`
	`52`	`+ \|\| (Outer?.ContainsKey(key) ?? false);`
`45`	`53`	`}`
`46`	`54`
`47`	`55`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`48`	`56`	`public bool TryGetValue(in TKey key, out TValue value)`
`49`	`57`	`{`
`50`		`- if (_inner.TryGetValue(key, out value)) return true;`
`51`		`- return Outer?.TryGetValue(key, out value) ?? false;`
	`58`	`+ value = default;`
	`59`	`+ return (_inner?.TryGetValue(key, out value) ?? false)`
	`60`	`+ \|\| (Outer?.TryGetValue(key, out value) ?? false);`
`52`	`61`	`}`
`53`	`62`
`54`	`63`	`public TValue this[in TKey key]`
`55`	`64`	`{`
`56`	`65`	`get`
`57`	`66`	`{`
`58`		`- if (_inner.TryGetValue(key, out var value)) return value;`
`59`		`- if (Outer?.TryGetValue(key, out value) ?? false) return value;`
`60`		`- throw new KeyNotFoundException($"{key}");`
	`67`	`+ if (TryGetValue(key, out var value)) return value;`
	`68`	`+ Throw.KeyNotFoundException($"{key}");`
	`69`	`+ return default; // will never reach this point`
`61`	`70`	`}`
`62`	`71`
`63`		`- set => _inner.AddOrReplace(key, value);`
	`72`	`+ set => AddOrReplace(key, value);`
`64`	`73`	`}`
`65`	`74`
`66`	`75`	`public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()`
`67`	`76`	`{`
`68`		`- var enumerator = _inner.GetEnumerator();`
`69`		`- while (enumerator.MoveNext())`
`70`		`- {`
`71`		`- yield return enumerator.Current;`
`72`		`- }`
	`77`	`+ foreach (var pair in InnerEnumerable()) yield return pair;`
	`78`	`+ foreach (var pair in OuterEnumerable()) yield return pair;`
	`79`	`+ }`
`73`	`80`
`74`		`- foreach (var pair in OuterEnumerable())`
	`81`	`+ private IEnumerable<KeyValuePair<TKey, TValue>> InnerEnumerable()`
	`82`	`+ {`
	`83`	`+ if(_inner == null) yield break;`
	`84`	`+`
	`85`	`+ var outerEnumerator = _inner.GetEnumerator();`
	`86`	`+ while (outerEnumerator.MoveNext())`
`75`	`87`	`{`
`76`		`- yield return pair;`
	`88`	`+ if (_inner.ContainsKey(outerEnumerator.Current.Key)) continue;`
	`89`	`+ yield return outerEnumerator.Current;`
`77`	`90`	`}`
`78`	`91`	`}`
`79`		`-`
	`92`	`+`
`80`	`93`	`private IEnumerable<KeyValuePair<TKey, TValue>> OuterEnumerable()`
`81`	`94`	`{`
`82`		`- var outerEnumerator = Outer?.GetEnumerator();`
`83`		`- if (outerEnumerator == null) yield break;`
`84`		`-`
	`95`	`+ if(Outer == null) yield break;`
	`96`	`+`
	`97`	`+ using var outerEnumerator = Outer.GetEnumerator();`
`85`	`98`	`while (outerEnumerator.MoveNext())`
`86`	`99`	`{`
`87`	`100`	`if (_inner.ContainsKey(outerEnumerator.Current.Key)) continue;`
`@@ -90,5 +103,10 @@ private IEnumerable<KeyValuePair<TKey, TValue>> OuterEnumerable()`
`90`	`103`	`}`
`91`	`104`
`92`	`105`	`IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();`
	`106`	`+`
	`107`	`+ private static class Throw`
	`108`	`+ {`
	`109`	`+ public static void KeyNotFoundException(string message, Exception exception = null) => throw new KeyNotFoundException(message, exception);`
	`110`	`+ }`
`93`	`111`	`}`
`94`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace HandlebarsDotNet`
`5`	`5`	`{`
`6`	`6`	`public readonly partial struct PathInfoLight`
`7`	`7`	`{`
`8`		`- internal sealed class PathInfoLightEqualityComparer : IEqualityComparer<PathInfoLight>`
	`8`	`+ internal readonly struct PathInfoLightEqualityComparer : IEqualityComparer<PathInfoLight>`
`9`	`9`	`{`
`10`	`10`	`private readonly PathInfo.TrimmedPathEqualityComparer _comparer;`
`11`	`11`