readonly record struct, update .Net version

RomanSoloweow · RomanSoloweow · commit 5b775431dd13 · 2022-04-23T04:23:00.000+03:00
diff --git a/global.json b/global.json
@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "5.0.0",
+    "version": "6.0.0",
     "rollForward": "latestMinor",
     "allowPrerelease": false
   }
diff --git a/src/SimpleStateMachine.StructuralSearch.Sandbox/SimpleStateMachine.StructuralSearch.Sandbox.csproj b/src/SimpleStateMachine.StructuralSearch.Sandbox/SimpleStateMachine.StructuralSearch.Sandbox.csproj
@@ -5,11 +5,11 @@
         <TargetFramework>net5.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
-        <LangVersion>9</LangVersion>
+        <LangVersion>10</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Pidgin" Version="3.0.1" />
+      <PackageReference Include="Pidgin" Version="3.1.0" />
       <PackageReference Include="YamlDotNet" Version="11.2.1" />
     </ItemGroup>
 
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Examples/TernaryOperator.cs b/src/SimpleStateMachine.StructuralSearch.Tests/Examples/TernaryOperator.cs
@@ -6,44 +6,44 @@ public class TernaryOperator
     {
         public int Test1()
         {
-            var temp = 150;
+            var temp = 1;
             
-            if(temp == 125)
-                return 12;
+            if(temp == 2)
+                return 3;
             else
-                return 15;
+                return 4;
         }
         
         public int Test2()
         {
-            var temp = 150;
+            var temp = 5;
             
-            if(temp == 125)
-                return 12;
+            if(temp == 6)
+                return 7;
             else
-                return 15;
+                return 8;
         }
         
         public int Test3()
         {
-            var temp2 = 150;
+            var temp2 = 1;
             
-            if(temp2 == 125)
-                return 12;
+            if(temp2 == 2)
+                return 3;
             else
-                return 15; 
+                return 4; 
         }
         
         public int Test4()
         {
-            var temp3 = 150;
+            var temp3 = 5;
             
-            if(temp3 == 125)
-                return 12;
-            else if (temp3 == 135)
-                return 15;
+            if(temp3 == 6)
+                return 7;
+            else if (temp3 == 8)
+                return 9;
             else
-                return 0;
+                return 10;
         }
         
         public void Test5()
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs
@@ -34,8 +34,8 @@ public void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, stri
             var result = findParser.Parse(ref parsingContext, input);
             
             Assert.NotNull(findParser);
-            Assert.NotNull(result.Value);
-            Assert.Equal(result.Lenght, source.Length);
+            // Assert.NotNull(result.Value);
+            Assert.Equal(result.Length, source.Length);
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj b/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj
@@ -4,17 +4,17 @@
         <TargetFramework>net5.0</TargetFramework>
         <Nullable>enable</Nullable>
         <IsPackable>false</IsPackable>
-        <LangVersion>9</LangVersion>
+        <LangVersion>10</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
         <PackageReference Include="xunit" Version="2.4.1" />
         <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
-        <PackageReference Include="coverlet.collector" Version="3.0.2">
+        <PackageReference Include="coverlet.collector" Version="3.1.2">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/MatchExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/MatchExtensions.cs
@@ -0,0 +1,9 @@
+﻿namespace SimpleStateMachine.StructuralSearch.Extensions;
+
+public static class MatchExtensions
+{
+    public static bool IsEmpty(this Match<string> match)
+    {
+        return string.IsNullOrEmpty(match.Value);
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs
@@ -49,6 +49,44 @@ public static Parser<TToken, bool> Contains<TToken, T>(this Parser<TToken, T> pa
                 : throw new ArgumentNullException(nameof(parser));
         }
 
+        // public static Parser<char, T> Match<T>(this Parser<char, T> parser, ref ParseState<char> state,
+        //     ref PooledList<Expected<char>> expected, out T result)
+        // {
+        //     Parser<char>.CurrentPos.TryParse(ref state, ref expected, out var oldPos);
+        //     Parser<char>.CurrentOffset.TryParse(ref state, ref expected, out var oldOffset);
+        //     var res = parser.TryParse(ref state, ref expected, out result);
+        //
+        //     if (res)
+        //     {
+        //         Parser<char>.CurrentPos.TryParse(ref state, ref expected, out var newPos);
+        //         Parser<char>.CurrentOffset.TryParse(ref state, ref expected, out var newOffset);
+        //
+        //         var line = new LinePosition(oldPos.Line, newPos.Line);
+        //         var column = new ColumnPosition(oldPos.Col, newPos.Col);
+        //         var offset = new OffsetPosition(oldOffset, newOffset);
+        //         
+        //         return null;
+        //     }
+        // }
+        
+        public static Parser<char, Match<T>> Match<T>(this Parser<char, T> parser)
+        {
+            return Map((oldPos, oldOffset, result, newPos, newOffset) =>
+                {
+                    var line = new LinePosition(oldPos.Line, newPos.Line);
+                    var column = new ColumnPosition(oldPos.Col, newPos.Col);
+                    var offset = new OffsetPosition(oldOffset, newOffset);
+                    var lenght = newOffset - oldOffset;
+                    return new Match<T>(result, lenght, column, line, offset);
+                },
+                Parser<char>.CurrentPos, Parser<char>.CurrentOffset,
+                parser,
+                Parser<char>.CurrentPos, Parser<char>.CurrentOffset);
+        }
+        
+        
+        
+        
         // public static Parser<TToken, TOut> WithResult<TToken, TOut>(this Parser<TToken, TOut> parser, Func<TToken, SourcePos, TOut> transformResult)
         // {
         //     = Parser<TToken>.CurrentSourcePosDelta.Select<SourcePos>((Func<SourcePosDelta, SourcePos>) (d => new SourcePos(1, 1) + d));
diff --git a/src/SimpleStateMachine.StructuralSearch/FindParser.cs b/src/SimpleStateMachine.StructuralSearch/FindParser.cs
@@ -1,5 +1,8 @@
-﻿using System.Collections.Generic;
+﻿using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Text;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using YamlDotNet.Core.Events;
@@ -14,14 +17,23 @@ public FindParser(SeriesParser parser)
             Parser = parser;
         }
 
-        public SourceMatch Parse(ref IParsingContext context, IInput input)
+        public string Parse(ref IParsingContext context, IInput input)
         {
+            StringBuilder res = new StringBuilder();
             Parser.SetContext(ref context);
-            
-            var result = input.Parse(Parser.Select(x => string.Join(string.Empty, x))
-                .AsMatch());
-
-            return result.Success ? result.Value : SourceMatch.Empty;
+            var parser = Parser.Select(x => string.Join(string.Empty, x)).Match().Try();
+            var empty = Pidgin.Parser<char>.Any.Select(x=>
+            {
+                res.Append(x);
+                return string.Empty;
+            }).ThenReturn(Match.EmptyMatchString);
+            var parse = Pidgin.Parser.OneOf(parser, empty)
+                .Many();
+                
+            var result = input.Parse(parse);
+            var t = result.Value.Where(x => !x.IsEmpty());
+            // return result.Success ? result.Value.JoinToString() : string.Empty;
+            return string.Empty;
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/IFindParser.cs b/src/SimpleStateMachine.StructuralSearch/IFindParser.cs
@@ -7,6 +7,6 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public interface IFindParser
     {
-        SourceMatch Parse(ref IParsingContext context, IInput input);
+        string Parse(ref IParsingContext context, IInput input);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/ParserWithLookahead.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/ParserWithLookahead.cs
@@ -1,12 +1,14 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
 
 namespace SimpleStateMachine.StructuralSearch
 {
     public abstract class ParserWithLookahead<TToken, T> : Parser<TToken, T>
     {
-        private Func<Parser<TToken, T>> _parser { get; set; }
+        protected Lazy<Parser<TToken, T>> parser;
 
         public Func<IEnumerable<LookaheadResult<TToken, T>>> OnLookahead { get; set; }
 
@@ -16,13 +18,13 @@ public abstract Parser<TToken, T> BuildParser(Func<Parser<TToken, T>?> next,
         public void Lookahead(Func<Parser<TToken, T>?> next, Func<Parser<TToken, T>?> nextNext)
         {
             // lazy initialization
-            _parser = () => BuildParser(next, nextNext);
+            parser = new Lazy<Parser<TToken, T>>(() => BuildParser(next, nextNext));
         }
 
         public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expected,
             out T result)
         {
-            var res = _parser().TryParse(ref state, ref expected, out result);
+            var res = parser.Value.TryParse(ref state, ref expected, out result);
             return res;
         }
     }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs
@@ -121,5 +121,44 @@ public static Parser<TToken, T> Lookahead<TToken, T>(Parser<TToken, T> parser) =
             parser != null ? (Parser<TToken, T>) 
             new LookaheadParser<TToken, T>(parser) 
             : throw new ArgumentNullException(nameof (parser));
+        
+        public static Parser<char, Match<T>> Match<T>(Parser<char, T> parser)
+        {
+            return Map((oldPos, oldOffset, result, newPos, newOffset) =>
+                {
+                    var line = new LinePosition(oldPos.Line, newPos.Line);
+                    var column = new ColumnPosition(oldPos.Col, newPos.Col);
+                    var offset = new OffsetPosition(oldOffset, newOffset);
+                    var lenght = newOffset - oldOffset;
+                    return new Match<T>(result, lenght, column, line, offset);
+                },
+                Parser<char>.CurrentPos, Parser<char>.CurrentOffset,
+                parser,
+                Parser<char>.CurrentPos, Parser<char>.CurrentOffset);
+        }
+        
+        
+        // public static string Match(Parser<char, string> parser, ref ParseState<char> state,
+        //     ref PooledList<Expected<char>> expected, out string result)
+        // {
+        //     Parser<char>.CurrentPos.Then(Parser<char>.CurrentOffset, (pos, i) => (oldPos, oldOffset))
+        //         .Then()
+        //     .TryParse(ref state, ref expected, out var oldPos);
+        //    .TryParse(ref state, ref expected, out var oldOffset);
+        //     var res = parser.TryParse(ref state, ref expected, out result);
+        //
+        //     if (res)
+        //     {
+        //         Parser<char>.CurrentPos.TryParse(ref state, ref expected, out var newPos);
+        //         Parser<char>.CurrentOffset.TryParse(ref state, ref expected, out var newOffset);
+        //
+        //         var line = new LinePosition(oldPos.Line, newPos.Line);
+        //         var column = new ColumnPosition(oldPos.Col, newPos.Col);
+        //         var offset = new OffsetPosition(oldOffset, newOffset);
+        //         
+        //     }
+        //
+        //     return null;
+        // }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs
@@ -20,7 +20,7 @@ public override Parser<char, string> BuildParser(Func<Parser<char, string>?> nex
             Func<Parser<char, string>?> nextNext)
         {
             var _next = next();
-            var _nextNext = nextNext() ?? Parser.OneOf(CommonParser.WhiteSpaces, Parser<char>.End.ThenReturn(string.Empty));
+            var _nextNext = nextNext() ?? Parser.OneOf(Parser<char>.Any.AsString(), Parser<char>.End.ThenReturn(string.Empty));
             var lookahead = Parsers.Lookahead(_next.Then(_nextNext, (s1, s2) =>
             {
                 OnLookahead = () => new List<LookaheadResult<char, string>>
@@ -66,22 +66,14 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
             }
             else
             {
-                Parser<char>.CurrentPos.TryParse(ref state, ref expected, out var oldPos);
-                Parser<char>.CurrentOffset.TryParse(ref state, ref expected, out var oldOffset);
-                res = base.TryParse(ref state, ref expected, out result);
-
+                res = parser.Value.Match().TryParse(ref state, ref expected, out var match);
+                result = match.Value;
                 if (res)
                 {
-                    Parser<char>.CurrentSourcePosDelta.TryParse(ref state, ref expected, out var posDelta);
-                    Parser<char>.CurrentOffset.TryParse(ref state, ref expected, out var newOffset);
-            
                     _context.AddPlaceholder(new Placeholder(
                         context: _context,
                         name: Name,
-                        value: result,
-                        line: new LineProperty(oldPos.Line, oldPos.Line + posDelta.Lines),
-                        column: new ColumnProperty(oldPos.Col, oldPos.Col + posDelta.Cols),
-                        offset: new OffsetProperty(oldOffset, newOffset)));
+                        match: match));
                 }
             }
             
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/Column.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/Column.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/ColumnPosition.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/ColumnPosition.cs
@@ -0,0 +1,10 @@
+﻿namespace SimpleStateMachine.StructuralSearch
+{
+    public readonly record struct ColumnPosition(int Start, int End)
+    {
+        public readonly int Start = Start;
+        public readonly int End = End;
+
+        public static readonly ColumnPosition Empty = new(0, 0);
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/LinePosition.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/LinePosition.cs
@@ -0,0 +1,10 @@
+﻿namespace SimpleStateMachine.StructuralSearch
+{
+    public readonly record struct LinePosition(int Start, int End)
+    {
+        public readonly int Start = Start;
+        public readonly int End = End;
+
+        public static readonly LinePosition Empty = new(0, 0);
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/LineProperty.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/LineProperty.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/MatchPosition.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/MatchPosition.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/OffsetPosition.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/OffsetPosition.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/OffsetProperty.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/OffsetProperty.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/Placeholder.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/Placeholder.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/SimpleStateMachine.StructuralSearch.csproj b/src/SimpleStateMachine.StructuralSearch/SimpleStateMachine.StructuralSearch.csproj

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"sdk": {`
`3`		`- "version": "5.0.0",`
	`3`	`+ "version": "6.0.0",`
`4`	`4`	`"rollForward": "latestMinor",`
`5`	`5`	`"allowPrerelease": false`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,8 +34,8 @@ public void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, stri`
`34`	`34`	`var result = findParser.Parse(ref parsingContext, input);`
`35`	`35`
`36`	`36`	`Assert.NotNull(findParser);`
`37`		`- Assert.NotNull(result.Value);`
`38`		`- Assert.Equal(result.Lenght, source.Length);`
	`37`	`+ // Assert.NotNull(result.Value);`
	`38`	`+ Assert.Equal(result.Length, source.Length);`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,6 @@ namespace SimpleStateMachine.StructuralSearch`
`7`	`7`	`{`
`8`	`8`	`public interface IFindParser`
`9`	`9`	`{`
`10`		`- SourceMatch Parse(ref IParsingContext context, IInput input);`
	`10`	`+ string Parse(ref IParsingContext context, IInput input);`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,14 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Runtime.CompilerServices;`
`3`	`4`	`using Pidgin;`
	`5`	`+using SimpleStateMachine.StructuralSearch.Extensions;`
`4`	`6`
`5`	`7`	`namespace SimpleStateMachine.StructuralSearch`
`6`	`8`	`{`
`7`	`9`	`public abstract class ParserWithLookahead<TToken, T> : Parser<TToken, T>`
`8`	`10`	`{`
`9`		`- private Func<Parser<TToken, T>> _parser { get; set; }`
	`11`	`+ protected Lazy<Parser<TToken, T>> parser;`
`10`	`12`
`11`	`13`	`public Func<IEnumerable<LookaheadResult<TToken, T>>> OnLookahead { get; set; }`
`12`	`14`
`@@ -16,13 +18,13 @@ public abstract Parser<TToken, T> BuildParser(Func<Parser<TToken, T>?> next,`
`16`	`18`	`public void Lookahead(Func<Parser<TToken, T>?> next, Func<Parser<TToken, T>?> nextNext)`
`17`	`19`	`{`
`18`	`20`	`// lazy initialization`
`19`		`- _parser = () => BuildParser(next, nextNext);`
	`21`	`+ parser = new Lazy<Parser<TToken, T>>(() => BuildParser(next, nextNext));`
`20`	`22`	`}`
`21`	`23`
`22`	`24`	`public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expected,`
`23`	`25`	`out T result)`
`24`	`26`	`{`
`25`		`- var res = _parser().TryParse(ref state, ref expected, out result);`
	`27`	`+ var res = parser.Value.TryParse(ref state, ref expected, out result);`
`26`	`28`	`return res;`
`27`	`29`	`}`
`28`	`30`	`}`