do not check whether rule application is memoized if it is only interesting to see whether the line is obsolete

AnyText/AnyText.Core/ChangeTracker.cs

@@ -265,7 +265,7 @@ public List<RuleApplicationListMigrationEntry> CalculateListMigrations(List<Rule
                         continue;
                     }
                     var migrateIndex = -1;
-                    if (!IsInsertion(target, context, edit) && !IsObsoleted(current, context, edit))
+                    if (!IsInsertion(target.Essential(), context, edit) && !IsObsoleted(current.Essential(), context, edit))
                     {
                         migrateIndex = result.Count;
                         result.Add(new RuleApplicationListMigrationEntry(index, RuleApplicationListMigrationType.Migrate));
@@ -374,7 +374,7 @@ private void InsertInsertions(List<RuleApplication> migrateTo, ParseContext cont
         {
             if (edit.NewText.Length > 1 || (edit.NewText.Length == 1 && edit.NewText[0].Length > 0))
             {
-                while (index < mLen && IsInsertion(migrateTo[index], context, edit))
+                while (index < mLen && IsInsertion(migrateTo[index].Essential(), context, edit))
                 {
                     result.Add(new RuleApplicationListMigrationEntry(index, RuleApplicationListMigrationType.Insert));
                     index++;
@@ -387,7 +387,7 @@ private void RemoveObsoleted(List<RuleApplication> old, ParseContext context, Li
         {
             if (edit.End > edit.Start)
             {
-                while (oldIndex + indexOffset < len && IsObsoleted(old[oldIndex + indexOffset], context, edit))
+                while (oldIndex + indexOffset < len && IsObsoleted(old[oldIndex + indexOffset].Essential(), context, edit))
                 {
                     result.Add(new RuleApplicationListMigrationEntry(oldIndex, RuleApplicationListMigrationType.Remove));
                     indexOffset++;
@@ -435,12 +435,21 @@ private bool IsInsertion(RuleApplication ruleApplication, ParseContext context,
 
         private bool IsObsoleted(RuleApplication ruleApplication, ParseContext context, TextEdit byEdit)
         {
-            if (context.Matcher.IsObsoleted(ruleApplication))
+            if (ruleApplication.CurrentPosition >= byEdit.Start)
             {
-                return true;
+                var afterEdit = byEdit.EndAfterEdit;
+                var isObsoletedWithinAfterEdit = ruleApplication.CurrentPosition + ruleApplication.Length <= afterEdit;
+
+                if (isObsoletedWithinAfterEdit)
+                {
+                    return true;
+                }
+                if (byEdit.End > afterEdit)
+                {
+                    return context.Matcher.IsObsoleted(ruleApplication, afterEdit);
+                }
             }
-            return ruleApplication.CurrentPosition >= byEdit.Start &&
-                ruleApplication.CurrentPosition + ruleApplication.Length <= byEdit.EndAfterEdit;
+            return false;
         }
 
         public void Reset()

AnyText/AnyText.Core/Matcher.cs

@@ -642,7 +642,7 @@ public bool IsObsoleted(RuleApplication ruleApplication)
         {
             var column = ruleApplication.Column;
             var line = column.Line;
-            if (!IsObsoleted(line) && line.HasColumn(column))
+            if (!IsObsoleted(line))
             {
                 return false; 
             }
@@ -653,6 +653,17 @@ public bool IsObsoleted(RuleApplication ruleApplication)
             return ruleApplication.IterateLiterals(IsObsoleted);
         }
 
+        /// <summary>
+        /// Determines whether the given rule application is obsoleted
+        /// </summary>
+        /// <param name="ruleApplication">the rule application to check</param>
+        /// <param name="fromPosition">position from where to start</param>
+        /// <returns>true, if the rule application is on a line that has been obsoleted</returns>
+        public bool IsObsoleted(RuleApplication ruleApplication, ParsePosition fromPosition)
+        {
+            return ruleApplication.IterateLiterals(IsObsoleted, fromPosition);
+        }
+
         /// <summary>
         /// Deteremines whether the given rule application has an up to date position
         /// </summary>
@@ -661,7 +672,7 @@ public bool IsObsoleted(RuleApplication ruleApplication)
         public bool IsFaithfulPosition(RuleApplication ruleApplication)
         {
             var column = ruleApplication.Column;
-            return !IsObsoleted(column.Line) && column.Line.HasColumn(column);
+            return !IsObsoleted(column.Line);
         }
 
         private bool IsObsoleted(MemoLine line)

AnyText/AnyText.Core/Rules/ChoiceRule.cs

@@ -74,6 +74,17 @@ protected internal override bool IsEpsilonAllowed(List<Rule> trace)
             return Array.Exists(Alternatives, r => r.Rule.IsEpsilonAllowed(trace));
         }
 
+
+        /// <inheritdoc />
+        protected internal override RuleApplication GetEssentialInnerRuleApplication(RuleApplication ruleApplication)
+        {
+            if (ruleApplication is SingleRuleApplication single)
+            {
+                return single.Inner.Rule.GetEssentialInnerRuleApplication(single.Inner);
+            }
+            return ruleApplication;
+        }
+
         /// <inheritdoc />
         public override RuleApplication Match(ParseContext context, RecursionContext recursionContext, ref ParsePosition position)
         {

AnyText/AnyText.Core/Rules/FailedChoiceRuleApplication.cs

@@ -120,6 +120,16 @@ public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action,
             return true;
         }
 
+        public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from, bool includeFailures)
+        {
+            if (includeFailures)
+            {
+                var farest = GetRuleApplicationWithFarestExaminationLength();
+                if (farest != null) return farest.IterateLiterals(action, from, true);
+            }
+            return true;
+        }
+
         public override void Write(PrettyPrintWriter writer, ParseContext context)
         {
         }

AnyText/AnyText.Core/Rules/FailedRuleApplication.cs

@@ -85,6 +85,12 @@ public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action,
             return true;
         }
 
+        /// <inheritdoc />
+        public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from, bool includeFailures)
+        {
+            return true;
+        }
+
         /// <inheritdoc />
         public override void Write(PrettyPrintWriter writer, ParseContext context)
         {

AnyText/AnyText.Core/Rules/InheritedFailRuleApplication.cs

@@ -92,6 +92,15 @@ public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action,
             return true;
         }
 
+        public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from, bool includeFailures)
+        {
+            if (includeFailures)
+            {
+                return _innerFail.IterateLiterals(action, from, true);
+            }
+            return true;
+        }
+
         public override void Write(PrettyPrintWriter writer, ParseContext context)
         {
         }

AnyText/AnyText.Core/Rules/LiteralRuleApplication.cs

@@ -121,6 +121,22 @@ public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action,
             return action(this);
         }
 
+        /// <inheritdoc />
+        public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from, bool includeFailures)
+        {
+            if (Comments != null)
+            {
+                foreach (var comment in Comments)
+                {
+                    if (comment.CurrentPosition >= from && !comment.IterateLiterals(action, true))
+                    {
+                        return false;
+                    }
+                }
+            }
+            return action(this);
+        }
+
         /// <inheritdoc />
         public override void Write(PrettyPrintWriter writer, ParseContext context)
         {

AnyText/AnyText.Core/Rules/MultiRuleApplication.cs

@@ -398,6 +398,24 @@ public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action,
             return true;
         }
 
+        /// <inheritdoc />
+        public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from, bool includeFailures)
+        {
+            var index = FindLargestIndexBefore(from);
+            if (index < 0 || Inner[index].CurrentPosition + Inner[index].Length < from)
+            {
+                index++;
+            }
+            for (int i = index; i < Inner.Count; i++)
+            {
+                if (!Inner[i].IterateLiterals(action, includeFailures && i == Inner.Count - 1))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
         private static bool StopsBefore(RuleApplication ruleApplication, ParsePosition to)
         {
             return ruleApplication.CurrentPosition + ruleApplication.Length < to;

AnyText/AnyText.Core/Rules/QuoteRule.cs

@@ -38,6 +38,16 @@ public override RuleApplication Match(ParseContext context, RecursionContext rec
             return new InheritedFailRuleApplication(this, app, app.ExaminedTo);
         }
 
+        /// <inheritdoc />
+        protected internal override RuleApplication GetEssentialInnerRuleApplication(RuleApplication ruleApplication)
+        {
+            if (ruleApplication is SingleRuleApplication single)
+            {
+                return single.Inner.Rule.GetEssentialInnerRuleApplication(single.Inner);
+            }
+            return ruleApplication;
+        }
+
         /// <inheritdoc />
         protected internal override RuleApplication Recover(RuleApplication ruleApplication, RuleApplication failedRuleApplication, RuleApplication currentRoot, ParseContext context, out ParsePosition position)
         {

AnyText/AnyText.Core/Rules/RecoveredSequenceRuleApplication.cs

@@ -108,6 +108,18 @@ public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action,
             return action.Invoke(_stopper);
         }
 
+        public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from, bool includeFailures)
+        {
+            for (int i = 0; i < _successfulApplications.Count; i++)
+            {
+                if (_successfulApplications[i].CurrentPosition >= from && !_successfulApplications[i].IterateLiterals(action, includeFailures))
+                {
+                    return false;
+                }
+            }
+            return action.Invoke(_stopper);
+        }
+
         public override void Write(PrettyPrintWriter writer, ParseContext context)
         {
             var lastPos = CurrentPosition;

AnyText/AnyText.Core/Rules/Rule.cs

@@ -186,6 +186,8 @@
             return false;
         }
 
+        protected internal virtual RuleApplication GetEssentialInnerRuleApplication(RuleApplication ruleApplication) => ruleApplication;
+
         /// <summary>
         /// Indicates whether the rule is recursive
         /// </summary>

AnyText/AnyText.Core/Rules/RuleApplication.cs

@@ -416,6 +416,8 @@ internal void ChangeParent(RuleApplication newParent, ParseContext context)
             }
         }
 
+        internal RuleApplication Essential() => Rule.GetEssentialInnerRuleApplication(this);
+
         /// <summary>
         /// Gets a collection of parse errors represented by this rule application
         /// </summary>
@@ -519,6 +521,21 @@ protected internal virtual void OnContextChange(object oldContext, object newCon
         /// <param name="includeFailures">true, if failed rule applications should be considered, otherwise false</param>
         public abstract bool IterateLiterals(Func<LiteralRuleApplication, bool> action, bool includeFailures);
 
+        /// <summary>
+        /// Iterate over all literals
+        /// </summary>
+        /// <param name="action">the action that should be performed for all literals</param>
+        /// <param name="from">the inclusive position from which the literals should be iterated</param>
+        public bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from) => IterateLiterals(action, from, true);
+
+        /// <summary>
+        /// Iterate over all literals
+        /// </summary>
+        /// <param name="action">the action that should be performed for all literals</param>
+        /// <param name="from">the inclusive position from which the literals should be iterated</param>
+        /// <param name="includeFailures">true, if failed rule applications should be considered, otherwise false</param>
+        public abstract bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from, bool includeFailures);
+
         /// <summary>
         /// Iterate over all literals
         /// </summary>

AnyText/AnyText.Core/Rules/SequenceRule.cs

@@ -118,6 +118,22 @@ protected bool Accept(ref RuleApplication ruleApplication, List<RuleApplication>
             return context.AcceptSequenceAdd(this, ref ruleApplication, ruleApplications, ref examined);
         }
 
+        /// <inheritdoc />
+        protected internal override RuleApplication GetEssentialInnerRuleApplication(RuleApplication ruleApplication)
+        {
+            if (ruleApplication is MultiRuleApplication multiRuleApplication)
+            {
+                for (int i = 0; i < Rules.Length; i++)
+                {
+                    if (!Rules[i].Rule.IsEpsilonAllowed())
+                    {
+                        return multiRuleApplication.Inner[i];
+                    }
+                }
+            }
+            return base.GetEssentialInnerRuleApplication(ruleApplication);
+        }
+
         /// <summary>
         /// The rules that should occur in sequence
         /// </summary>

AnyText/AnyText.Core/Rules/SingleRuleApplication.cs

@@ -225,6 +225,12 @@ public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action,
             return Inner.IterateLiterals(action, includeFailures);
         }
 
+        /// <inheritdoc />
+        public override bool IterateLiterals(Func<LiteralRuleApplication, bool> action, ParsePosition from, bool includeFailures)
+        {
+            return Inner.IterateLiterals(action, from, includeFailures);
+        }
+
         /// <inheritdoc />
         public override void Write(PrettyPrintWriter writer, ParseContext context)
         {

AnyText/AnyText.history

@@ -45,4 +45,5 @@ patch: unification fix
 patch: carry text edits until successful migration
 patch: if a rule application is found, do not increase the deletion index
 patch: improve code lenses for synchronizations
-major: changed extension API for indentation-aware, create API to propagate context changes
+major: changed extension API for indentation-aware, create API to propagate context changes
+patch: do not check whether rule application is memoized if it is only interesting to see whether the line is obsolete