decide migration of multi rule applications based on edits (#119)

Author: georghinkel

AnyText/AnyText.Core/ChangeTracker.cs

@@ -0,0 +1,87 @@
+using NMF.AnyText.Rules;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NMF.AnyText
+{
+    internal class ChangeTracker
+    {
+        private TextEdit[] _edits = Array.Empty<TextEdit>();
+
+        public void SetEdits(IEnumerable<TextEdit> edits)
+        {
+            if (edits.TryGetNonEnumeratedCount(out var count) && count <= 1)
+            {
+                _edits = edits as TextEdit[] ?? edits.ToArray();
+            }
+            else
+            {
+                _edits = edits.OrderBy(e => e.Start).ToArray();
+            }
+        }
+
+        public bool IsInsertion(RuleApplication ruleApplication, ParseContext context)
+        {
+            // TODO: implement binary search
+            for (int i = 0; i < _edits.Length; i++)
+            {
+                var edit = _edits[i];
+                if (ruleApplication.CurrentPosition >= edit.Start &&
+                    ruleApplication.CurrentPosition + ruleApplication.Length <= context.Matcher.NextTokenPosition(edit.Start + GetLength(edit)))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private ParsePositionDelta GetLength(TextEdit textEdit)
+        {
+            if (textEdit.NewText.Length == 0)
+            {
+                return default;
+            }
+            var lastLineLength = textEdit.NewText[textEdit.NewText.Length - 1].Length;
+            return new ParsePositionDelta(textEdit.NewText.Length - 1, lastLineLength);
+        }
+
+        public bool IsObsoleted(RuleApplication ruleApplication, ParseContext context)
+        {
+            if (context.Matcher.IsObsoleted(ruleApplication))
+            {
+                return true;
+            }
+            for (int i = 0; i < _edits.Length; i++)
+            {
+                var edit = _edits[i];
+                var pos = ruleApplication.CurrentPosition;
+                if (pos >= edit.Start)
+                {
+                    pos = CompensateMatcherInsertions(pos, edit);
+                    if (pos + ruleApplication.Length <= context.Matcher.NextTokenPosition(edit.End))
+                    {
+                        return true;
+                    }
+                }
+                else
+                {
+                    // edits are sorted, further edits cannot contain rule application
+                    return false;
+                }
+            }
+            return false;
+        }
+
+        private static ParsePosition CompensateMatcherInsertions(ParsePosition pos, TextEdit edit)
+        {
+            var linesDelta = edit.NewText.Length - (edit.End.Line - edit.Start.Line + 1);
+            pos = new ParsePosition(pos.Line - linesDelta, pos.Col);
+            return pos;
+        }
+
+        internal void Reset() => SetEdits(Array.Empty<TextEdit>());
+    }
+}

AnyText/AnyText.Core/Matcher.cs

@@ -41,6 +41,12 @@ public void Reset()
             _trailingComments = null;
         }
 
+        internal RuleApplication GetLiteralAt(ParsePosition position)
+        {
+            var col = GetLine(position.Line)?.GetOrCreateColumn(position.Col);
+            return col?.Applications.Values.FirstOrDefault(r => r.Rule.IsLiteral && r.IsPositive);
+        }
+
         /// <summary>
         /// Gets the position of the next token, starting from the given position
         /// </summary>
@@ -49,7 +55,7 @@ public void Reset()
         public ParsePosition NextTokenPosition(ParsePosition position)
         {
             var line = position.Line;
-            var col = position.Col + 1;
+            var col = position.Col;
             while (line < _memoTable.Count)
             {
                 var memoLine = _memoTable[line];
@@ -398,7 +404,12 @@ public RuleApplication Match(ParseContext context)
         public void Apply(TextEdit edit)
         {
             var refreshLineIndices = false;
-            for (int i = 0; i <= edit.End.Line && i < _memoTable.Count; i++)
+            var lastEffectiveLength = edit.End.Line;
+            if (edit.End.Col == 0 && edit.NewText != null && edit.NewText.Length > 0 && edit.NewText[edit.NewText.Length - 1].Length == 0)
+            {
+                lastEffectiveLength--;
+            }
+            for (int i = 0; i <= lastEffectiveLength && i < _memoTable.Count; i++)
             {
                 var line = GetLine(i);
 
@@ -592,5 +603,17 @@ private static void MoveOverWhitespace(ParseContext context, ref ParsePosition p
             }
             position = new ParsePosition(lineNo, 0);
         }
+
+        /// <summary>
+        /// Determines whether the given rule application is obsoleted
+        /// </summary>
+        /// <param name="ruleApplication">the rule application to check</param>
+        /// <returns>true, if the rule application is on a line that has been obsoleted</returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool IsObsoleted(RuleApplication ruleApplication)
+        {
+            var line = ruleApplication.Line;
+            return line == null || (line.LineNo >= _memoTable.Count || _memoTable[line.LineNo] != line);
+        }
     }
 }

AnyText/AnyText.Core/ParseContext.cs

@@ -28,6 +28,7 @@ public ParseContext(Grammar grammar, Matcher matcher, StringComparison stringCom
             ArgumentNullException.ThrowIfNull(grammar);
             ArgumentNullException.ThrowIfNull(matcher);
 
+            ChangeTracker = new ChangeTracker();
             Grammar = grammar;
             Matcher = matcher;
             StringComparison = stringComparison;
@@ -91,6 +92,8 @@ public void RefreshRoot()
         /// </summary>
         public Matcher Matcher { get; }
 
+        internal ChangeTracker ChangeTracker { get; }
+
         /// <summary>
         /// Indicates whether the last update sent to the parser was successful
         /// </summary>

AnyText/AnyText.Core/Parser.cs

@@ -73,6 +73,7 @@ public object Initialize(string[] input, bool skipValidation = false)
         {
             _context.Input = input;
             _matcher.Reset();
+            _context.ChangeTracker.Reset();
             try
             {
                 _context.IsParsing = true;
@@ -115,7 +116,8 @@ public void Initialize(object semanticObject, bool skipValidation = false)
             {
                 throw new ArgumentException("no parse tree could be created for this object.", nameof(semanticObject));
             }
-            _context.Matcher.Reset();
+            _matcher.Reset();
+            _context.ChangeTracker.Reset();
             var writer = new StringWriter();
             var prettyWriter = new PrettyPrintWriter(writer, "  ");
             ruleApplication.Write(prettyWriter, _context);
@@ -166,7 +168,7 @@ public object Update(TextEdit edit, bool skipValidation)
 
                 input = edit.Apply(input);
                 _matcher.Apply(edit);
-
+                _context.ChangeTracker.SetEdits(new[] { edit });
                 UpdateCore(input, skipValidation);
             }
             finally
@@ -204,6 +206,7 @@ public object Update(IEnumerable<TextEdit> edits, bool skipValidation)
                     input = edit.Apply(input);
                     _matcher.Apply(edit);
                 }
+                _context.ChangeTracker.SetEdits(edits);
                 UpdateCore(input, skipValidation);
                 return _context.Root;
             }
@@ -212,7 +215,6 @@ public object Update(IEnumerable<TextEdit> edits, bool skipValidation)
                 Context.IsParsing = false;
                 Context.IsExecutingModelChanges = false;
             }
-
         }
 
         /// <summary>
@@ -258,6 +260,8 @@ public IReadOnlyList<TextEdit> Update(object updatedElement)
                         }
                     }
                 }
+                // do not pass edits to change tracker because the parse tree already contains everything
+                _context.ChangeTracker.Reset();
 
                 UpdateCore(input, false);
 

AnyText/AnyText.Core/Properties/AssemblyInfo.cs

@@ -1,9 +1,12 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System;
+using System.Runtime.CompilerServices;
 
 [assembly: AssemblyTitle("NMF AnyText Core")]
 [assembly: AssemblyDescription("A library with an incremental packrat parser")]
 [assembly: AssemblyCopyright("Copyright © Georg Hinkel 2025")]
 [assembly: Guid("C4B20D44-F618-40DE-8FF9-8147A958C681")]
 [assembly: CLSCompliant(false)]
+
+[assembly: InternalsVisibleTo("AnyText.Tests")]

AnyText/AnyText.Core/Rules/LiteralRuleApplication.cs

@@ -137,5 +137,20 @@ public override LiteralRuleApplication GetLastInnerLiteral()
         {
             return this;
         }
+
+        internal override RuleApplication MigrateTo(LiteralRuleApplication literal, ParseContext context)
+        {
+            if (literal.Rule != Rule || literal.Literal != Literal)
+            {
+                return base.MigrateTo(literal, context);
+            }
+            var old = Literal;
+            Length = literal.Length;
+            ExaminedTo = literal.ExaminedTo;
+            Comments = literal.Comments;
+            literal.ReplaceWith(this);
+
+            return this;
+        }
     }
 }