TreatWarningsAsErrors

RomanSoloweow · RomanSoloweow · commit b987a411f3b6 · 2024-03-03T17:18:29.000Z
diff --git a/src/SimpleStateMachine.StructuralSearch/Helper/EnumHelper.cs b/src/SimpleStateMachine.StructuralSearch/Helper/EnumHelper.cs
@@ -40,10 +40,10 @@ public static bool Contains<TEnum>(Type enumType, string value, bool exception =
             return Enum.GetNames<TEnum>();
         }
         
-        public static IEnumerable<string?> GetNamesExcept<TEnum>(params TEnum [] excludedElements)
+        public static IEnumerable<string> GetNamesExcept<TEnum>(params TEnum [] excludedElements)
             where TEnum : struct, Enum
         {
-            return GetValueExcept(excludedElements).Select(x=> x.Name());
+            return GetValueExcept(excludedElements).Select(x=> x.Name()).OfType<string>();
         }
 
         public static IEnumerable<TEnum> GetValues<TEnum>() 
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/DebugParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/DebugParser.cs
@@ -1,4 +1,5 @@
 ﻿using Pidgin;
+#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
 
 namespace SimpleStateMachine.StructuralSearch
 {
@@ -11,9 +12,6 @@ public DebugParser(Parser<TToken, T> parser)
         }
         
         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);
-            return res;
-        }
+            => _parser.TryParse(ref state, ref expected, out result!);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/EmptyStringParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/EmptyStringParser.cs
@@ -1,4 +1,5 @@
 ﻿using Pidgin;
+#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
 
 namespace SimpleStateMachine.StructuralSearch
 {
@@ -11,8 +12,7 @@ public EmptyStringParser(bool value)
             _value = value;
         }
 
-        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,
-            out string result)
+        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out string result)
         {
             result = string.Empty;
             return _value;
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/EnumParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/EnumParser.cs
@@ -3,6 +3,7 @@
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.Helper;
+#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
 
 namespace SimpleStateMachine.StructuralSearch
 {
@@ -18,11 +19,8 @@ public EnumParser(bool ignoreCase, params TEnum [] excluded)
                 .Select(Parser.Try))
                 .AsEnum<TEnum>(ignoreCase);
         }
-
-        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,
-            out TEnum result)
-        {
-            return _parser.TryParse(ref state, ref expected, out result);
-        }
+        
+        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out TEnum result)
+            => _parser.TryParse(ref state, ref expected, out result);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/ParserWithLookahead.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/ParserWithLookahead.cs
@@ -2,28 +2,27 @@
 using System.Collections.Generic;
 using Pidgin;
 
+#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
+
 namespace SimpleStateMachine.StructuralSearch
 {
     public abstract class ParserWithLookahead<TToken, T> : Parser<TToken, T>
     {
-        protected Lazy<Parser<TToken, T>> parser;
-
-        public Func<IEnumerable<LookaheadResult<TToken, T>>> OnLookahead { get; set; }
+        private Lazy<Parser<TToken, T>>? _lookaheadParser;
+        protected Lazy<Parser<TToken, T>> LookaheadParser => _lookaheadParser ?? throw new ArgumentNullException(nameof(Lookahead));
+        
+        public Func<IEnumerable<LookaheadResult<TToken, T>>>? OnLookahead { get; protected set; }
 
-        public abstract Parser<TToken, T> BuildParser(Func<Parser<TToken, T>?> next,
+        protected abstract Parser<TToken, T> BuildParser(Func<Parser<TToken, T>?> next,
             Func<Parser<TToken, T>?> nextNext);
 
         public void Lookahead(Func<Parser<TToken, T>?> next, Func<Parser<TToken, T>?> nextNext)
         {
-            parser = new Lazy<Parser<TToken, T>>(() => BuildParser(next, nextNext));
+            _lookaheadParser = 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.Value.TryParse(ref state, ref expected, out result);
-            return res;
-        }
+        public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expected, out T result)
+            => LookaheadParser.Value.TryParse(ref state, ref expected, out result!);
     }
 
     public class LookaheadResult<TToken, T>
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs
@@ -8,13 +8,15 @@ namespace SimpleStateMachine.StructuralSearch
     public class PlaceholderParser : ParserWithLookahead<char, string>, IContextDependent
     {
         private readonly string _name;
-        private IParsingContext _context;
+        private IParsingContext? _context;
+        private IParsingContext Context => _context ?? throw new ArgumentNullException(nameof(_context));
+        
         public PlaceholderParser(string name)
         {
             _name = name;
         }
 
-        public override Parser<char, string> BuildParser(Func<Parser<char, string>?> next,
+        protected override Parser<char, string> BuildParser(Func<Parser<char, string>?> next,
             Func<Parser<char, string>?> nextNext)
         {
             var nextParser = next();
@@ -58,7 +60,7 @@ public override Parser<char, string> BuildParser(Func<Parser<char, string>?> nex
             Parser<char, string>? term = null;
 
             var parenthesised = Parsers.BetweenOneOfChars(x => Parser.Char(x).AsString(),
-                expr: Parser.Rec(() => term),
+                expr: Parser.Rec(() => term!),
                 Constant.AllParenthesised).JoinToString();
 
             term = Parser.OneOf(parenthesised, token).Many().JoinToString();
@@ -73,24 +75,23 @@ public override Parser<char, string> BuildParser(Func<Parser<char, string>?> nex
             return parser;
         }
 
-        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,
-            out string result)
+        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out string result)
         {
             bool res;
 
             // No use look-ahead if placeholder is already defined
-            if (_context.TryGetPlaceholder(_name, out var placeholder))
+            if (Context.TryGetPlaceholder(_name, out var placeholder))
             {
-                res = Parser.String(placeholder.Value).TryParse(ref state, ref expected, out result);
+                res = Parser.String(placeholder.Value).TryParse(ref state, ref expected, out result!);
             }
             else
             {
-                res = parser.Value.Match().TryParse(ref state, ref expected, out var match);
+                res = LookaheadParser.Value.Match().TryParse(ref state, ref expected, out var match);
                 result = match.Value;
                 if (res)
                 {
-                    _context.AddPlaceholder(new Placeholder(
-                        context: ref _context,
+                    Context.AddPlaceholder(new Placeholder(
+                        context: ref _context!,
                         name: _name,
                         match: match));
                 }
diff --git a/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs
@@ -15,20 +15,16 @@ public ParsingContext(IInput input)
         }
 
         public bool TryGetPlaceholder(string name, out IPlaceholder value)
-        {
-            return _placeholders.TryGetValue(name, out value);
-        }
+            => _placeholders.TryGetValue(name, out value!);
 
         public void AddPlaceholder(IPlaceholder placeholder)
         {
             _placeholders[placeholder.Name] = placeholder;
         }
 
-        public IPlaceholder GetPlaceholder(string name)
-        {
-            return _placeholders[name];
-        }
-        
+        public IPlaceholder GetPlaceholder(string name) 
+            => _placeholders[name];
+
         public void Fill(IReadOnlyDictionary<string, IPlaceholder> placeholders)
         {
             ClearInternal();
diff --git a/src/SimpleStateMachine.StructuralSearch/SeriesParser.cs b/src/SimpleStateMachine.StructuralSearch/SeriesParser.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using Pidgin;
 
+#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
+
 namespace SimpleStateMachine.StructuralSearch
 {
     public class SeriesParser : Parser<char, IEnumerable<string>>, IContextDependent
@@ -55,7 +57,7 @@ void SkipLookedParsers(Parser<char, string> parser, ref ParseState<char> state)
                         lookaheadParser is { OnLookahead: null })
                         return;
 
-                    var lookaheadResults = lookaheadParser.OnLookahead.Invoke();
+                    var lookaheadResults = lookaheadParser.OnLookahead.Invoke().ToArray();
 
                     foreach (var result in lookaheadResults)
                     {
diff --git a/src/SimpleStateMachine.StructuralSearch/SimpleStateMachine.StructuralSearch.csproj b/src/SimpleStateMachine.StructuralSearch/SimpleStateMachine.StructuralSearch.csproj
@@ -4,6 +4,7 @@
     <TargetFramework>net6.0</TargetFramework>
     <LangVersion>10</LangVersion>
     <Nullable>enable</Nullable>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs
@@ -1,4 +1,5 @@
-﻿using System.Collections.Generic;
+﻿using System;
+using System.Collections.Generic;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 
@@ -10,7 +11,7 @@ static FindTemplateParser()
         {
             Parenthesised = Parsers.BetweenOneOfChars(x => ParserToParser.CIChar(x)
                     .Select(x => x.AsString()),
-                Parser.Rec(() => Term),
+                Parser.Rec(() => Term ?? throw new ArgumentNullException(nameof(Term))),
                 Constant.AllParenthesised);
 
             Term = Parser.OneOf(Parenthesised, Token)
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ParametersParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ParametersParser.cs
@@ -13,7 +13,7 @@ static ParametersParser()
         {
             // TODO optimize
             Parenthesised = Parsers.BetweenOneOfChars(x => Parser.Char(x).Try(),
-                    Parser.Rec(() => StringWithParenthesised),
+                    Parser.Rec(() => StringWithParenthesised ?? throw new ArgumentNullException(nameof(StringWithParenthesised))),
                     Constant.AllParenthesised)
                 .Try()
                 .Labelled($"{nameof(ParametersParser)}.{nameof(Parenthesised)}");
@@ -32,7 +32,7 @@ static ParametersParser()
                 .Try()
                 .Labelled($"{nameof(ParametersParser)}.{nameof(StringParameter)}");
 
-            var placeholderOrPropertyRuleParameter = Parser.Rec(() => PlaceholderOrPropertyRuleParameter);
+            var placeholderOrPropertyRuleParameter = Parser.Rec(() => PlaceholderOrPropertyRuleParameter ?? throw new ArgumentNullException(nameof(PlaceholderOrPropertyRuleParameter)));
 
             StringFormatParameter =
                 Parser.OneOf(placeholderOrPropertyRuleParameter, StringParameter)
@@ -120,8 +120,6 @@ static ParametersParser()
 
         public static readonly Parser<char, Func<IRuleParameter, IRuleParameter>> Change;
 
-        public static readonly Parser<char, IRuleParameter> PlaceholderOrProperty;
-
         public static readonly Parser<char, IRuleParameter> PlaceholderOrPropertyRuleParameter;
 
 
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs
@@ -1,4 +1,5 @@
-﻿using System.Collections.Generic;
+﻿using System;
+using System.Collections.Generic;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.Helper;
@@ -14,7 +15,7 @@ static ReplaceTemplateParser()
         {
             ParenthesisedParameter = Parsers.BetweenOneOfChars((c1, c2) =>
                         MatchHelper.GetParenthesisType((c1, c2)),
-                    Parser.Rec(() => Parameter),
+                    Parser.Rec(() => Parameter ?? throw new ArgumentNullException(nameof(Parameter))),
                     Constant.AllParenthesised)
                 .Select(x => new ParenthesisedParameter(x.Item1, new[] { x.Item2 }))
                 .As<char, ParenthesisedParameter, IRuleParameter>()

Original file line number	Diff line number	Diff line change
`@@ -40,10 +40,10 @@ public static bool Contains<TEnum>(Type enumType, string value, bool exception =`
`40`	`40`	`return Enum.GetNames<TEnum>();`
`41`	`41`	`}`
`42`	`42`
`43`		`- public static IEnumerable<string?> GetNamesExcept<TEnum>(params TEnum [] excludedElements)`
	`43`	`+ public static IEnumerable<string> GetNamesExcept<TEnum>(params TEnum [] excludedElements)`
`44`	`44`	`where TEnum : struct, Enum`
`45`	`45`	`{`
`46`		`- return GetValueExcept(excludedElements).Select(x=> x.Name());`
	`46`	`+ return GetValueExcept(excludedElements).Select(x=> x.Name()).OfType<string>();`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public static IEnumerable<TEnum> GetValues<TEnum>()`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using Pidgin;`
	`2`	`+#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.`
`2`	`3`
`3`	`4`	`namespace SimpleStateMachine.StructuralSearch`
`4`	`5`	`{`
`@@ -11,9 +12,6 @@ public DebugParser(Parser<TToken, T> parser)`
`11`	`12`	`}`
`12`	`13`
`13`	`14`	`public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expected, out T result)`
`14`		`- {`
`15`		`- var res = _parser.TryParse(ref state, ref expected, out result);`
`16`		`- return res;`
`17`		`- }`
	`15`	`+ => _parser.TryParse(ref state, ref expected, out result!);`
`18`	`16`	`}`
`19`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using Pidgin;`
`4`	`4`	`using SimpleStateMachine.StructuralSearch.Extensions;`
`5`	`5`	`using SimpleStateMachine.StructuralSearch.Helper;`
	`6`	`+#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.`
`6`	`7`
`7`	`8`	`namespace SimpleStateMachine.StructuralSearch`
`8`	`9`	`{`
`@@ -18,11 +19,8 @@ public EnumParser(bool ignoreCase, params TEnum [] excluded)`
`18`	`19`	`.Select(Parser.Try))`
`19`	`20`	`.AsEnum<TEnum>(ignoreCase);`
`20`	`21`	`}`
`21`		`-`
`22`		`- public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,`
`23`		`- out TEnum result)`
`24`		`- {`
`25`		`- return _parser.TryParse(ref state, ref expected, out result);`
`26`		`- }`
	`22`	`+`
	`23`	`+ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out TEnum result)`
	`24`	`+ => _parser.TryParse(ref state, ref expected, out result);`
`27`	`25`	`}`
`28`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,13 +8,15 @@ namespace SimpleStateMachine.StructuralSearch`
`8`	`8`	`public class PlaceholderParser : ParserWithLookahead<char, string>, IContextDependent`
`9`	`9`	`{`
`10`	`10`	`private readonly string _name;`
`11`		`- private IParsingContext _context;`
	`11`	`+ private IParsingContext? _context;`
	`12`	`+ private IParsingContext Context => _context ?? throw new ArgumentNullException(nameof(_context));`
	`13`	`+`
`12`	`14`	`public PlaceholderParser(string name)`
`13`	`15`	`{`
`14`	`16`	`_name = name;`
`15`	`17`	`}`
`16`	`18`
`17`		`- public override Parser<char, string> BuildParser(Func<Parser<char, string>?> next,`
	`19`	`+ protected override Parser<char, string> BuildParser(Func<Parser<char, string>?> next,`
`18`	`20`	`Func<Parser<char, string>?> nextNext)`
`19`	`21`	`{`
`20`	`22`	`var nextParser = next();`
`@@ -58,7 +60,7 @@ public override Parser<char, string> BuildParser(Func<Parser<char, string>?> nex`
`58`	`60`	`Parser<char, string>? term = null;`
`59`	`61`
`60`	`62`	`var parenthesised = Parsers.BetweenOneOfChars(x => Parser.Char(x).AsString(),`
`61`		`- expr: Parser.Rec(() => term),`
	`63`	`+ expr: Parser.Rec(() => term!),`
`62`	`64`	`Constant.AllParenthesised).JoinToString();`
`63`	`65`
`64`	`66`	`term = Parser.OneOf(parenthesised, token).Many().JoinToString();`
`@@ -73,24 +75,23 @@ public override Parser<char, string> BuildParser(Func<Parser<char, string>?> nex`
`73`	`75`	`return parser;`
`74`	`76`	`}`
`75`	`77`
`76`		`- public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,`
`77`		`- out string result)`
	`78`	`+ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out string result)`
`78`	`79`	`{`
`79`	`80`	`bool res;`
`80`	`81`
`81`	`82`	`// No use look-ahead if placeholder is already defined`
`82`		`- if (_context.TryGetPlaceholder(_name, out var placeholder))`
	`83`	`+ if (Context.TryGetPlaceholder(_name, out var placeholder))`
`83`	`84`	`{`
`84`		`- res = Parser.String(placeholder.Value).TryParse(ref state, ref expected, out result);`
	`85`	`+ res = Parser.String(placeholder.Value).TryParse(ref state, ref expected, out result!);`
`85`	`86`	`}`
`86`	`87`	`else`
`87`	`88`	`{`
`88`		`- res = parser.Value.Match().TryParse(ref state, ref expected, out var match);`
	`89`	`+ res = LookaheadParser.Value.Match().TryParse(ref state, ref expected, out var match);`
`89`	`90`	`result = match.Value;`
`90`	`91`	`if (res)`
`91`	`92`	`{`
`92`		`- _context.AddPlaceholder(new Placeholder(`
`93`		`- context: ref _context,`
	`93`	`+ Context.AddPlaceholder(new Placeholder(`
	`94`	`+ context: ref _context!,`
`94`	`95`	`name: _name,`
`95`	`96`	`match: match));`
`96`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,20 +15,16 @@ public ParsingContext(IInput input)`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public bool TryGetPlaceholder(string name, out IPlaceholder value)`
`18`		`- {`
`19`		`- return _placeholders.TryGetValue(name, out value);`
`20`		`- }`
	`18`	`+ => _placeholders.TryGetValue(name, out value!);`
`21`	`19`
`22`	`20`	`public void AddPlaceholder(IPlaceholder placeholder)`
`23`	`21`	`{`
`24`	`22`	`_placeholders[placeholder.Name] = placeholder;`
`25`	`23`	`}`
`26`	`24`
`27`		`- public IPlaceholder GetPlaceholder(string name)`
`28`		`- {`
`29`		`- return _placeholders[name];`
`30`		`- }`
`31`		`-`
	`25`	`+ public IPlaceholder GetPlaceholder(string name)`
	`26`	`+ => _placeholders[name];`
	`27`	`+`
`32`	`28`	`public void Fill(IReadOnlyDictionary<string, IPlaceholder> placeholders)`
`33`	`29`	`{`
`34`	`30`	`ClearInternal();`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@`
`2`	`2`	`using System.Linq;`
`3`	`3`	`using Pidgin;`
`4`	`4`
	`5`	`+#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.`
	`6`	`+`
`5`	`7`	`namespace SimpleStateMachine.StructuralSearch`
`6`	`8`	`{`
`7`	`9`	`public class SeriesParser : Parser<char, IEnumerable<string>>, IContextDependent`
`@@ -55,7 +57,7 @@ void SkipLookedParsers(Parser<char, string> parser, ref ParseState<char> state)`
`55`	`57`	`lookaheadParser is { OnLookahead: null })`
`56`	`58`	`return;`
`57`	`59`
`58`		`- var lookaheadResults = lookaheadParser.OnLookahead.Invoke();`
	`60`	`+ var lookaheadResults = lookaheadParser.OnLookahead.Invoke().ToArray();`
`59`	`61`
`60`	`62`	`foreach (var result in lookaheadResults)`
`61`	`63`	`{`