[WIP] Correctly implemented reference assignement

antoineatstariongroup · antoineatstariongroup · commit a27b1b411c68 · 2026-03-06T09:37:44.000+01:00
diff --git a/SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreTextualNotationBuilderGeneratorTestFixture.cs b/SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreTextualNotationBuilderGeneratorTestFixture.cs
@@ -30,6 +30,8 @@ namespace SysML2.NET.CodeGenerator.Tests.Generators.UmlHandleBarsGenerators
     using SysML2.NET.CodeGenerator.Grammar;
     using SysML2.NET.CodeGenerator.Grammar.Model;
 
+    using uml4net.CommonStructure;
+
     [TestFixture]
     public class UmlCoreTextualNotationBuilderGeneratorTestFixture
     {
diff --git a/SysML2.NET.CodeGenerator/HandleBarHelpers/RulesHelper.cs b/SysML2.NET.CodeGenerator/HandleBarHelpers/RulesHelper.cs
@@ -69,7 +69,7 @@ public static void RegisterRulesHelper(this IHandlebars handlebars)
 
                 if (namedElement is IClass umlClass)
                 {
-                    var ruleGenerationContext = new RuleGenerationContext();
+                    var ruleGenerationContext = new RuleGenerationContext(namedElement);
                     ruleGenerationContext.AllRules.AddRange(allRules);
                     ProcessAlternatives(writer, umlClass, textualRule.Alternatives, ruleGenerationContext);
                 }
@@ -93,7 +93,7 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas
                 var elements = alternative.Elements;
                 DeclareAllRequiredIterators(writer, umlClass, alternative, ruleGenerationContext);
                 
-                if (ruleGenerationContext.CallerContext?.CallerRule is { IsOptional: true, IsCollection: false })
+                if (ruleGenerationContext.CallerRule is { IsOptional: true, IsCollection: false })
                 {
                     var targetPropertiesName = elements.OfType<AssignmentElement>().Select(x => x.Property).Distinct().ToList();
                     var allProperties = umlClass.QueryAllProperties();
@@ -127,9 +127,9 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas
 
                         foreach (var textualRuleElement in elements)
                         {
-                            var previousCaller = ruleGenerationContext.CallerContext;
+                            var previousCaller = ruleGenerationContext.CallerRule;
                             ProcessRuleElement(writer, umlClass, textualRuleElement, ruleGenerationContext);
-                            ruleGenerationContext.CallerContext = previousCaller;
+                            ruleGenerationContext.CallerRule = previousCaller;
                         }
                     }
                     else
@@ -150,9 +150,9 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas
                 {
                     foreach (var textualRuleElement in elements)
                     {
-                        var previousCaller = ruleGenerationContext.CallerContext;
+                        var previousCaller = ruleGenerationContext.CallerRule;
                         ProcessRuleElement(writer, umlClass, textualRuleElement, ruleGenerationContext);
-                        ruleGenerationContext.CallerContext = previousCaller;
+                        ruleGenerationContext.CallerRule = previousCaller;
                     }    
                 }
             }
@@ -215,18 +215,20 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass
                     writer.WriteSafeString($"stringBuilder.Append(\"{valueToAdd}\");");
                     break;
                 case NonTerminalElement nonTerminalElement:
-                    if (ruleGenerationContext.CallerContext?.CallerRule is NonTerminalElement callerNonTerminalElement && callerNonTerminalElement.Container is AssignmentElement)
+                    if (ruleGenerationContext.CallerRule is NonTerminalElement { Container: AssignmentElement assignmentElementContainer })
                     {
-                        ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", ruleGenerationContext.CallerContext.CallerClassContext, ruleGenerationContext);
+                        var textualBuilderClass = ruleGenerationContext.NamedElementToGenerate as IClass;
+                        var assignedProperty = textualBuilderClass.QueryAllProperties().SingleOrDefault(x => x.Name == assignmentElementContainer.Property);
+                        ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, assignedProperty == null ? "poco" : $"poco.{assignedProperty.QueryPropertyNameBasedOnUmlProperties()}", ruleGenerationContext);
                     }
                     else
                     {
-                        ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", umlClass, ruleGenerationContext);
+                        ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", ruleGenerationContext);
                     }
 
                     break;
                 case GroupElement groupElement:
-                    ruleGenerationContext.CallerContext = new CallerContext(groupElement);
+                    ruleGenerationContext.CallerRule = groupElement ;
                     
                     if (groupElement.IsCollection)
                     {
@@ -270,7 +272,7 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass
                                     writer.WriteSafeString($"{iteratorToUse.IteratorVariableName}.MoveNext();{Environment.NewLine}");
                                 }
 
-                                ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, $"{iteratorToUse.IteratorVariableName}.Current", umlClass, ruleGenerationContext);
+                                ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, $"{iteratorToUse.IteratorVariableName}.Current", ruleGenerationContext);
                             }
                             else
                             {
@@ -311,10 +313,10 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass
                                 {
                                     if (assignmentElement.Value is NonTerminalElement nonTerminalElement)
                                     {
-                                        var previousCaller = ruleGenerationContext.CallerContext;
-                                        ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement);
-                                        ProcessNonTerminalElement(writer, targetProperty.Type as IClass, nonTerminalElement, $"poco.{targetProperty.QueryPropertyNameBasedOnUmlProperties()}", umlClass, ruleGenerationContext);
-                                        ruleGenerationContext.CallerContext = previousCaller;
+                                        var previousCaller = ruleGenerationContext.CallerRule;
+                                        ruleGenerationContext.CallerRule = nonTerminalElement;
+                                        ProcessNonTerminalElement(writer, targetProperty.Type as IClass, nonTerminalElement, $"poco.{targetProperty.QueryPropertyNameBasedOnUmlProperties()}", ruleGenerationContext);
+                                        ruleGenerationContext.CallerRule = previousCaller;
                                     }
                                     else
                                     {
@@ -355,9 +357,8 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass
         /// <param name="umlClass">The related <see cref="IClass"/></param>
         /// <param name="nonTerminalElement">The <see cref="NonTerminalElement"/> to process</param>
         /// <param name="variableName">The name of the variable that should be used to call the non-terminal method</param>
-        /// <param name="callerClass">Gets the <see cref="IClass"/> that initially calls this function</param>
         /// <param name="ruleGenerationContext"></param>
-        private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass umlClass, NonTerminalElement nonTerminalElement, string variableName, IClass callerClass, RuleGenerationContext ruleGenerationContext)
+        private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass umlClass, NonTerminalElement nonTerminalElement, string variableName, RuleGenerationContext ruleGenerationContext)
         {
             var referencedRule = ruleGenerationContext.AllRules.SingleOrDefault(x => x.RuleName == nonTerminalElement.Name);
 
@@ -380,7 +381,7 @@ private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass u
                 writer.WriteSafeString($"{{{Environment.NewLine}");
             }
                             
-            if (typeTarget != callerClass.Name)
+            if (typeTarget != ruleGenerationContext.NamedElementToGenerate.Name)
             {
                 var targetType = umlClass.Cache.Values.OfType<INamedElement>().SingleOrDefault(x => x.Name == typeTarget);
                                 
@@ -392,18 +393,18 @@ private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass u
                     }
                     else
                     {
-                        var previousCaller = ruleGenerationContext.CallerContext;
-                        ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement, targetType as  IClass);
-                        ProcessAlternatives(writer, callerClass, referencedRule?.Alternatives, ruleGenerationContext);
-                        ruleGenerationContext.CallerContext = previousCaller;
+                        var previousCaller = ruleGenerationContext.CallerRule;
+                        ruleGenerationContext.CallerRule = nonTerminalElement;
+                        ProcessAlternatives(writer, umlClass, referencedRule?.Alternatives, ruleGenerationContext);
+                        ruleGenerationContext.CallerRule = previousCaller;
                     }
                 }
                 else
                 {
-                    var previousCaller = ruleGenerationContext.CallerContext;
-                    ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement);
-                    ProcessAlternatives(writer, callerClass, referencedRule?.Alternatives, ruleGenerationContext);
-                    ruleGenerationContext.CallerContext = previousCaller;
+                    var previousCaller = ruleGenerationContext.CallerRule;
+                    ruleGenerationContext.CallerRule = nonTerminalElement;
+                    ProcessAlternatives(writer, umlClass, referencedRule?.Alternatives, ruleGenerationContext);
+                    ruleGenerationContext.CallerRule = previousCaller;
                 }
             }
             else
@@ -559,29 +560,6 @@ public bool IsIteratorValidForProperty(IProperty property, TextualNotationRule t
             }
         }
 
-        /// <summary>
-        /// Provide context about the caller context 
-        /// </summary>
-        private class CallerContext
-        {
-            /// <summary>Initializes a new instance of the <see cref="CallerContext" /> class.</summary>
-            public CallerContext(RuleElement callerRule, IClass callerClassContext = null)
-            {
-                this.CallerRule = callerRule;
-                this.CallerClassContext = callerClassContext;
-            }
-
-            /// <summary>
-            /// Gets or sets the <see cref="RuleElement"/> that called other rule
-            /// </summary>
-            public RuleElement CallerRule { get; }
-
-            /// <summary>
-            /// Gets or sets the <see cref="IClass"/> used during the caller rule
-            /// </summary>
-            public IClass CallerClassContext { get; }
-        }
-
         /// <summary>
         /// Provides context over the rule generation history
         /// </summary>
@@ -598,9 +576,20 @@ private class RuleGenerationContext
             public List<TextualNotationRule> AllRules { get; } = [];
 
             /// <summary>
-            /// Gets or sets the <see cref="CallerContext"/>
+            /// Gets or sets the <see cref="RuleElement"/> that called other rule
+            /// </summary>
+            public RuleElement CallerRule { get; set; }
+
+            /// <summary>Initializes a new instance of the <see cref="T:System.Object" /> class.</summary>
+            public RuleGenerationContext(INamedElement namedElementToGenerate)
+            {
+                this.NamedElementToGenerate = namedElementToGenerate;
+            }
+
+            /// <summary>
+            /// Gets the <see cref="INamedElement"/> that is used in the current generation
             /// </summary>
-            public CallerContext CallerContext { get; set; }
+            public INamedElement NamedElementToGenerate { get; }
         }
     }
 }
diff --git a/SysML2.NET/TextualNotation/AutoGenTextualNotationBuilder/FeatureMembershipTextualNotationBuilder.cs b/SysML2.NET/TextualNotation/AutoGenTextualNotationBuilder/FeatureMembershipTextualNotationBuilder.cs
@@ -379,21 +379,21 @@ public static void BuildMetadataBodyUsageMember(SysML2.NET.Core.POCO.Core.Types.
                 {
                     RedefinitionTextualNotationBuilder.BuildOwnedRedefinition(ownedRelationshipOfRedefinitionIterator.Current, stringBuilder);
                 }
-                throw new System.NotSupportedException("Multiple alternatives not implemented yet");
-                using var ownedRelationshipOfFeatureValueIterator = poco.OwnedRelationship.OfType<SysML2.NET.Core.POCO.Kernel.FeatureValues.FeatureValue>().GetEnumerator();
 
-                if (ownedRelationshipOfFeatureValueIterator.MoveNext())
+                if (poco.ownedMemberFeature != null)
                 {
-                    ownedRelationshipOfFeatureValueIterator.MoveNext();
+                    FeatureTextualNotationBuilder.BuildFeatureSpecializationPart(poco.ownedMemberFeature, stringBuilder);
+                }
 
-                    if (ownedRelationshipOfFeatureValueIterator.Current != null)
-                    {
-                        FeatureValueTextualNotationBuilder.BuildFeatureValue(ownedRelationshipOfFeatureValueIterator.Current, stringBuilder);
-                    }
-                    stringBuilder.Append(' ');
+                if (poco.ownedMemberFeature != null)
+                {
+                    FeatureTextualNotationBuilder.BuildValuePart(poco.ownedMemberFeature, stringBuilder);
                 }
 
-                throw new System.NotSupportedException("Multiple alternatives not implemented yet");
+                if (poco.ownedMemberFeature != null)
+                {
+                    TypeTextualNotationBuilder.BuildMetadataBody(poco.ownedMemberFeature, stringBuilder);
+                }
 
             }
 
@@ -515,25 +515,11 @@ public static void BuildExpressionBodyMember(SysML2.NET.Core.POCO.Core.Types.IFe
             if (poco.ownedMemberFeature != null)
             {
                 stringBuilder.Append("{");
-                using var ownedRelationshipOfReturnParameterMembershipIterator = poco.OwnedRelationship.OfType<SysML2.NET.Core.POCO.Kernel.Functions.ReturnParameterMembership>().GetEnumerator();
-                using var ownedRelationshipOfResultExpressionMembershipIterator = poco.OwnedRelationship.OfType<SysML2.NET.Core.POCO.Kernel.Functions.ResultExpressionMembership>().GetEnumerator();
 
-                while (ownedRelationshipOfReturnParameterMembershipIterator.MoveNext())
+                if (poco.ownedMemberFeature != null)
                 {
-                    throw new System.NotSupportedException("Multiple alternatives not implemented yet");
+                    TypeTextualNotationBuilder.BuildFunctionBodyPart(poco.ownedMemberFeature, stringBuilder);
                 }
-
-                if (ownedRelationshipOfResultExpressionMembershipIterator.MoveNext())
-                {
-
-                    if (ownedRelationshipOfResultExpressionMembershipIterator.Current != null)
-                    {
-                        ResultExpressionMembershipTextualNotationBuilder.BuildResultExpressionMember(ownedRelationshipOfResultExpressionMembershipIterator.Current, stringBuilder);
-                    }
-                    stringBuilder.Append(' ');
-                }
-
-
                 stringBuilder.Append("}");
 
             }

Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,8 @@ namespace SysML2.NET.CodeGenerator.Tests.Generators.UmlHandleBarsGenerators`
`30`	`30`	`using SysML2.NET.CodeGenerator.Grammar;`
`31`	`31`	`using SysML2.NET.CodeGenerator.Grammar.Model;`
`32`	`32`
	`33`	`+ using uml4net.CommonStructure;`
	`34`	`+`
`33`	`35`	`[TestFixture]`
`34`	`36`	`public class UmlCoreTextualNotationBuilderGeneratorTestFixture`
`35`	`37`	`{`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ public static void RegisterRulesHelper(this IHandlebars handlebars)`
`69`	`69`
`70`	`70`	`if (namedElement is IClass umlClass)`
`71`	`71`	`{`
`72`		`- var ruleGenerationContext = new RuleGenerationContext();`
	`72`	`+ var ruleGenerationContext = new RuleGenerationContext(namedElement);`
`73`	`73`	`ruleGenerationContext.AllRules.AddRange(allRules);`
`74`	`74`	`ProcessAlternatives(writer, umlClass, textualRule.Alternatives, ruleGenerationContext);`
`75`	`75`	`}`
`@@ -93,7 +93,7 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas`
`93`	`93`	`var elements = alternative.Elements;`
`94`	`94`	`DeclareAllRequiredIterators(writer, umlClass, alternative, ruleGenerationContext);`
`95`	`95`
`96`		`- if (ruleGenerationContext.CallerContext?.CallerRule is { IsOptional: true, IsCollection: false })`
	`96`	`+ if (ruleGenerationContext.CallerRule is { IsOptional: true, IsCollection: false })`
`97`	`97`	`{`
`98`	`98`	`var targetPropertiesName = elements.OfType<AssignmentElement>().Select(x => x.Property).Distinct().ToList();`
`99`	`99`	`var allProperties = umlClass.QueryAllProperties();`
`@@ -127,9 +127,9 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas`
`127`	`127`
`128`	`128`	`foreach (var textualRuleElement in elements)`
`129`	`129`	`{`
`130`		`- var previousCaller = ruleGenerationContext.CallerContext;`
	`130`	`+ var previousCaller = ruleGenerationContext.CallerRule;`
`131`	`131`	`ProcessRuleElement(writer, umlClass, textualRuleElement, ruleGenerationContext);`
`132`		`- ruleGenerationContext.CallerContext = previousCaller;`
	`132`	`+ ruleGenerationContext.CallerRule = previousCaller;`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`else`
`@@ -150,9 +150,9 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas`
`150`	`150`	`{`
`151`	`151`	`foreach (var textualRuleElement in elements)`
`152`	`152`	`{`
`153`		`- var previousCaller = ruleGenerationContext.CallerContext;`
	`153`	`+ var previousCaller = ruleGenerationContext.CallerRule;`
`154`	`154`	`ProcessRuleElement(writer, umlClass, textualRuleElement, ruleGenerationContext);`
`155`		`- ruleGenerationContext.CallerContext = previousCaller;`
	`155`	`+ ruleGenerationContext.CallerRule = previousCaller;`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`	`}`
`@@ -215,18 +215,20 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass`
`215`	`215`	`writer.WriteSafeString($"stringBuilder.Append(\"{valueToAdd}\");");`
`216`	`216`	`break;`
`217`	`217`	`case NonTerminalElement nonTerminalElement:`
`218`		`- if (ruleGenerationContext.CallerContext?.CallerRule is NonTerminalElement callerNonTerminalElement && callerNonTerminalElement.Container is AssignmentElement)`
	`218`	`+ if (ruleGenerationContext.CallerRule is NonTerminalElement { Container: AssignmentElement assignmentElementContainer })`
`219`	`219`	`{`
`220`		`- ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", ruleGenerationContext.CallerContext.CallerClassContext, ruleGenerationContext);`
	`220`	`+ var textualBuilderClass = ruleGenerationContext.NamedElementToGenerate as IClass;`
	`221`	`+ var assignedProperty = textualBuilderClass.QueryAllProperties().SingleOrDefault(x => x.Name == assignmentElementContainer.Property);`
	`222`	`+ ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, assignedProperty == null ? "poco" : $"poco.{assignedProperty.QueryPropertyNameBasedOnUmlProperties()}", ruleGenerationContext);`
`221`	`223`	`}`
`222`	`224`	`else`
`223`	`225`	`{`
`224`		`- ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", umlClass, ruleGenerationContext);`
	`226`	`+ ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", ruleGenerationContext);`
`225`	`227`	`}`
`226`	`228`
`227`	`229`	`break;`
`228`	`230`	`case GroupElement groupElement:`
`229`		`- ruleGenerationContext.CallerContext = new CallerContext(groupElement);`
	`231`	`+ ruleGenerationContext.CallerRule = groupElement ;`
`230`	`232`
`231`	`233`	`if (groupElement.IsCollection)`
`232`	`234`	`{`
`@@ -270,7 +272,7 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass`
`270`	`272`	`writer.WriteSafeString($"{iteratorToUse.IteratorVariableName}.MoveNext();{Environment.NewLine}");`
`271`	`273`	`}`
`272`	`274`
`273`		`- ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, $"{iteratorToUse.IteratorVariableName}.Current", umlClass, ruleGenerationContext);`
	`275`	`+ ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, $"{iteratorToUse.IteratorVariableName}.Current", ruleGenerationContext);`
`274`	`276`	`}`
`275`	`277`	`else`
`276`	`278`	`{`
`@@ -311,10 +313,10 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass`
`311`	`313`	`{`
`312`	`314`	`if (assignmentElement.Value is NonTerminalElement nonTerminalElement)`
`313`	`315`	`{`
`314`		`- var previousCaller = ruleGenerationContext.CallerContext;`
`315`		`- ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement);`
`316`		`- ProcessNonTerminalElement(writer, targetProperty.Type as IClass, nonTerminalElement, $"poco.{targetProperty.QueryPropertyNameBasedOnUmlProperties()}", umlClass, ruleGenerationContext);`
`317`		`- ruleGenerationContext.CallerContext = previousCaller;`
	`316`	`+ var previousCaller = ruleGenerationContext.CallerRule;`
	`317`	`+ ruleGenerationContext.CallerRule = nonTerminalElement;`
	`318`	`+ ProcessNonTerminalElement(writer, targetProperty.Type as IClass, nonTerminalElement, $"poco.{targetProperty.QueryPropertyNameBasedOnUmlProperties()}", ruleGenerationContext);`
	`319`	`+ ruleGenerationContext.CallerRule = previousCaller;`
`318`	`320`	`}`
`319`	`321`	`else`
`320`	`322`	`{`
`@@ -355,9 +357,8 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass`
`355`	`357`	`/// <param name="umlClass">The related <see cref="IClass"/></param>`
`356`	`358`	`/// <param name="nonTerminalElement">The <see cref="NonTerminalElement"/> to process</param>`
`357`	`359`	`/// <param name="variableName">The name of the variable that should be used to call the non-terminal method</param>`
`358`		`- /// <param name="callerClass">Gets the <see cref="IClass"/> that initially calls this function</param>`
`359`	`360`	`/// <param name="ruleGenerationContext"></param>`
`360`		`- private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass umlClass, NonTerminalElement nonTerminalElement, string variableName, IClass callerClass, RuleGenerationContext ruleGenerationContext)`
	`361`	`+ private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass umlClass, NonTerminalElement nonTerminalElement, string variableName, RuleGenerationContext ruleGenerationContext)`
`361`	`362`	`{`
`362`	`363`	`var referencedRule = ruleGenerationContext.AllRules.SingleOrDefault(x => x.RuleName == nonTerminalElement.Name);`
`363`	`364`
`@@ -380,7 +381,7 @@ private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass u`
`380`	`381`	`writer.WriteSafeString($"{{{Environment.NewLine}");`
`381`	`382`	`}`
`382`	`383`
`383`		`- if (typeTarget != callerClass.Name)`
	`384`	`+ if (typeTarget != ruleGenerationContext.NamedElementToGenerate.Name)`
`384`	`385`	`{`
`385`	`386`	`var targetType = umlClass.Cache.Values.OfType<INamedElement>().SingleOrDefault(x => x.Name == typeTarget);`
`386`	`387`
`@@ -392,18 +393,18 @@ private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass u`
`392`	`393`	`}`
`393`	`394`	`else`
`394`	`395`	`{`
`395`		`- var previousCaller = ruleGenerationContext.CallerContext;`
`396`		`- ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement, targetType as IClass);`
`397`		`- ProcessAlternatives(writer, callerClass, referencedRule?.Alternatives, ruleGenerationContext);`
`398`		`- ruleGenerationContext.CallerContext = previousCaller;`
	`396`	`+ var previousCaller = ruleGenerationContext.CallerRule;`
	`397`	`+ ruleGenerationContext.CallerRule = nonTerminalElement;`
	`398`	`+ ProcessAlternatives(writer, umlClass, referencedRule?.Alternatives, ruleGenerationContext);`
	`399`	`+ ruleGenerationContext.CallerRule = previousCaller;`
`399`	`400`	`}`
`400`	`401`	`}`
`401`	`402`	`else`
`402`	`403`	`{`
`403`		`- var previousCaller = ruleGenerationContext.CallerContext;`
`404`		`- ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement);`
`405`		`- ProcessAlternatives(writer, callerClass, referencedRule?.Alternatives, ruleGenerationContext);`
`406`		`- ruleGenerationContext.CallerContext = previousCaller;`
	`404`	`+ var previousCaller = ruleGenerationContext.CallerRule;`
	`405`	`+ ruleGenerationContext.CallerRule = nonTerminalElement;`
	`406`	`+ ProcessAlternatives(writer, umlClass, referencedRule?.Alternatives, ruleGenerationContext);`
	`407`	`+ ruleGenerationContext.CallerRule = previousCaller;`
`407`	`408`	`}`
`408`	`409`	`}`
`409`	`410`	`else`
`@@ -559,29 +560,6 @@ public bool IsIteratorValidForProperty(IProperty property, TextualNotationRule t`
`559`	`560`	`}`
`560`	`561`	`}`
`561`	`562`
`562`		`- /// <summary>`
`563`		`- /// Provide context about the caller context`
`564`		`- /// </summary>`
`565`		`- private class CallerContext`
`566`		`- {`
`567`		`- /// <summary>Initializes a new instance of the <see cref="CallerContext" /> class.</summary>`
`568`		`- public CallerContext(RuleElement callerRule, IClass callerClassContext = null)`
`569`		`- {`
`570`		`- this.CallerRule = callerRule;`
`571`		`- this.CallerClassContext = callerClassContext;`
`572`		`- }`
`573`		`-`
`574`		`- /// <summary>`
`575`		`- /// Gets or sets the <see cref="RuleElement"/> that called other rule`
`576`		`- /// </summary>`
`577`		`- public RuleElement CallerRule { get; }`
`578`		`-`
`579`		`- /// <summary>`
`580`		`- /// Gets or sets the <see cref="IClass"/> used during the caller rule`
`581`		`- /// </summary>`
`582`		`- public IClass CallerClassContext { get; }`
`583`		`- }`
`584`		`-`
`585`	`563`	`/// <summary>`
`586`	`564`	`/// Provides context over the rule generation history`
`587`	`565`	`/// </summary>`
`@@ -598,9 +576,20 @@ private class RuleGenerationContext`
`598`	`576`	`public List<TextualNotationRule> AllRules { get; } = [];`
`599`	`577`
`600`	`578`	`/// <summary>`
`601`		`- /// Gets or sets the <see cref="CallerContext"/>`
	`579`	`+ /// Gets or sets the <see cref="RuleElement"/> that called other rule`
	`580`	`+ /// </summary>`
	`581`	`+ public RuleElement CallerRule { get; set; }`
	`582`	`+`
	`583`	`+ /// <summary>Initializes a new instance of the <see cref="T:System.Object" /> class.</summary>`
	`584`	`+ public RuleGenerationContext(INamedElement namedElementToGenerate)`
	`585`	`+ {`
	`586`	`+ this.NamedElementToGenerate = namedElementToGenerate;`
	`587`	`+ }`
	`588`	`+`
	`589`	`+ /// <summary>`
	`590`	`+ /// Gets the <see cref="INamedElement"/> that is used in the current generation`
`602`	`591`	`/// </summary>`
`603`		`- public CallerContext CallerContext { get; set; }`
	`592`	`+ public INamedElement NamedElementToGenerate { get; }`
`604`	`593`	`}`
`605`	`594`	`}`
`606`	`595`	`}`