qodana cleaning

src/sly/EnumConverter.cs

@@ -25,7 +25,7 @@ public static IN ConvertIntToEnum<IN>(int intValue)
         public static IN ConvertStringToEnum<IN>(string name)  where IN : struct
         {
             IN token = default(IN);
-            if (!Enum.TryParse<IN>(name, out token))
+            if (!Enum.TryParse(name, out token))
             {
                 throw new ParserConfigurationException($"bad enum name {name} on Operation definition.");
             }
@@ -34,8 +34,7 @@ public static IN ConvertStringToEnum<IN>(string name)  where IN : struct
 
         public static bool IsEnumValue<IN>(string name)  where IN : struct
         {
-
-            return Enum.TryParse<IN>(name, out IN token);
+            return Enum.TryParse(name, out IN token);
         }
     }
 }

src/sly/i18n/I18N.cs

@@ -34,7 +34,7 @@ public string GetText(string lang, I18NMessage key, params string[] args)
         private IDictionary<I18NMessage,string> Load(string lang)
         {
             var translation = new Dictionary<I18NMessage, string>();
-            Assembly assembly = GetType().Assembly;
+            var assembly = GetType().Assembly;
             using (var stream = assembly.GetManifestResourceStream($"sly.i18n.translations.{lang}.txt"))
             {
                 if (stream != null)

src/sly/lexer/CallBacksBuilder.cs

@@ -18,17 +18,17 @@ public static void BuildCallbacks<IN>(GenericLexer<IN> lexer) where IN : struct
 
         public static void ExtractCallBacks<IN>(Type callbackClass, GenericLexer<IN> lexer) where IN : struct
         {
-            var methods = callbackClass.GetMethods().ToList<MethodInfo>();
+            var methods = callbackClass.GetMethods().ToList();
             methods = methods.Where<MethodInfo>(m =>
             {
-                var attributes = m.GetCustomAttributes().ToList<Attribute>();
+                var attributes = m.GetCustomAttributes().ToList();
                 var attr = attributes.Find(a => a.GetType() == typeof(TokenCallbackAttribute));
                 return m.IsStatic && attr != null;
             }).ToList<MethodInfo>();
 
             foreach (var method in methods)
             {
-                var attributes = method.GetCustomAttributes(typeof(TokenCallbackAttribute), false).Cast<TokenCallbackAttribute>().ToList<TokenCallbackAttribute>();
+                var attributes = method.GetCustomAttributes(typeof(TokenCallbackAttribute), false).Cast<TokenCallbackAttribute>().ToList();
                 AddCallback<IN>(lexer, method, EnumConverter.ConvertIntToEnum<IN>(attributes[0].EnumValue));
             }
         }

src/sly/lexer/GenericLexer.cs

@@ -295,11 +295,10 @@ private void ComputePositionWhenIgnoringEOL(FSMMatch<GenericToken> r, List<Token
 
                 if (r.IsLineEnding) // only compute if token is eol
                 {
-                    var eols = tokens.Where<Token<IN>>(t => t.IsLineEnding).ToList<Token<IN>>();
-                    int line = eols.Any<Token<IN>>() ? eols.Count : 0;
+                    var eols = tokens.Where(t => t.IsLineEnding).ToList();
+                    int line = eols.Any() ? eols.Count : 0;
                     int column = 0;
                     int index = newPosition.Index;
-                    // r.Result.Position.Line = line+1;
                     r.NewPosition.Line = line + 1;
                     r.NewPosition.Column = column;
                 }
@@ -323,16 +322,16 @@ private void InitializeStaticLexer(Config config, GenericToken[] staticTokens)
             // start machine definition
             FSMBuilder.Mark(start);
 
-            if (staticTokens.Contains<GenericToken>(GenericToken.Identifier) ||
-                staticTokens.Contains<GenericToken>(GenericToken.KeyWord))
+            if (staticTokens.Contains(GenericToken.Identifier) ||
+                staticTokens.Contains(GenericToken.KeyWord))
             {
                 InitializeIdentifier(config);
             }
 
             // numeric
-            if (staticTokens.Contains<GenericToken>(GenericToken.Int) ||
-                staticTokens.Contains<GenericToken>(GenericToken.Double) || 
-                staticTokens.Contains<GenericToken>(GenericToken.Date)) 
+            if (staticTokens.Contains(GenericToken.Int) ||
+                staticTokens.Contains(GenericToken.Double) || 
+                staticTokens.Contains(GenericToken.Date)) 
             {
                 FSMBuilder = FSMBuilder.GoTo(start)
                     .RangeTransition('0', '9')
@@ -527,8 +526,6 @@ public void AddDouble(IN token, string separator, BuildResult<ILexer<IN>> result
 
             FSMBuilder.GoTo(in_int)
                 .Transition(separatorChar)
-                // .RangeTransition('0','9')
-                // .RangeTransition('0','9')
                 .RangeTransition('0', '9')
                 .Mark(in_double)
                 .RangeTransitionTo('0', '9', in_double)
@@ -572,7 +569,7 @@ private void AddDoubleWhenNoDoubleToken(IN token, DateFormat format, char separa
             };
             NodeCallback<GenericToken> callback = delegate(FSMMatch<GenericToken> match)
             {
-                match.Properties[GenericLexer<IN>.DerivedToken] = token;
+                match.Properties[DerivedToken] = token;
                 var elements = match.Result.Value.Split(separator);
                 DateTime date;
                 if (format == DateFormat.DDMMYYYY)
@@ -633,7 +630,7 @@ private void AddDoubleWhenDoubleTokenPresent(IN token, DateFormat format, char s
             };
             NodeCallback<GenericToken> callback = delegate(FSMMatch<GenericToken> match)
             {
-                match.Properties[GenericLexer<IN>.DerivedToken] = token;
+                match.Properties[DerivedToken] = token;
                 var elements = match.Result.Value.Split(separator);
                 DateTime date;
                 if (format == DateFormat.DDMMYYYY)
@@ -772,7 +769,7 @@ public ReadOnlyMemory<char> sameCharEscaper(char escapeStringDelimiterChar, char
 
             if (substitutionHappened)
             {
-                r += value.At<char>(value.Length - 1);
+                r += value.At(value.Length - 1);
                 value = r.AsMemory();
             }
 
@@ -969,9 +966,9 @@ public void AddSugarLexem(IN token, BuildResult<ILexer<IN>> buildResult, string
                 return match;
             };
 
-            Func<int, TransitionPrecondition> precond = (int i) =>
+            Func<int, TransitionPrecondition> precond = (i) =>
             {
-                return (ReadOnlyMemory<char> value) => { return value.Length == i + 1; };
+                return (value) => { return value.Length == i + 1; };
             };
 
             FSMBuilder.GoTo(start);
@@ -1021,8 +1018,6 @@ public void AddUpTo(IN token, BuildResult<ILexer<IN>> buildResult, string[] exce
                         FSMBuilder.GoTo(startNode);
                         FSMBuilder.SafeTransition(exceptionChar);
                         FSMBuilder.Mark(end);
-                        // FSMBuilder.End(GenericToken.AllExcept)
-                        //     .CallBack(callback);
 
                         startNode = start;
                     }
@@ -1080,7 +1075,6 @@ public LexerPosition ConsumeComment(Token<GenericToken> comment, ReadOnlyMemory<
                     comment.SpanValue = "".ToCharArray();
                 }
                 return new LexerPosition(position, lexerPosition.Line + 1, 0);
-                //LexerFsm.MovePosition(position, LexerFsm.CurrentLine + 1, 0);
             }
             else if (comment.IsMultiLineComment)
             {
@@ -1099,12 +1093,11 @@ public LexerPosition ConsumeComment(Token<GenericToken> comment, ReadOnlyMemory<
                 var newLine = lexerPosition.Line + lines.Count - 1;
                 int newColumn;
                 if (lines.Count > 1)
-                    newColumn = lines.Last<int>() + MultiLineCommentEnd.Length;
+                    newColumn = lines.Last() + MultiLineCommentEnd.Length;
                 else
                     newColumn = lexerPosition.Column + lines[0] + MultiLineCommentEnd.Length;
 
                 return new LexerPosition(newPosition, newLine, newColumn);
-                // LexerFsm.MovePosition(newPosition, newLine, newColumn);
             }
 
             return lexerPosition;

src/sly/lexer/ILexer.cs

@@ -1,7 +1,6 @@
 
 using System;
 using System.Collections.Generic;
-using sly.i18n;
 using sly.lexer.fsm;
 
 namespace sly.lexer

src/sly/lexer/LexerBuilder.cs

@@ -51,7 +51,7 @@ public static class LexerBuilder
             var attributes = new Dictionary<IN, (List<LexemeAttribute>,List<LexemeLabelAttribute>)>();
 
             var values = Enum.GetValues(typeof(IN));
-            var grouped = values.Cast<IN>().GroupBy<IN, IN>(x => x).ToList<IGrouping<IN, IN>>();
+            var grouped = values.Cast<IN>().GroupBy(x => x).ToList();
             foreach (var group in grouped)
             {
                 var v = group.Key;
@@ -606,7 +606,7 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                             fsmBuilder.ConstantTransition(commentAttr.MultiLineCommentStart);
                             fsmBuilder.Mark(GenericLexer<IN>.multi_line_comment_start);
                             fsmBuilder.End(GenericToken.Comment);
-                            fsmBuilder.CallBack(GetCallbackMulti<IN>(comment.Key, commentAttr.DoNotIgnore,
+                            fsmBuilder.CallBack(GetCallbackMulti(comment.Key, commentAttr.DoNotIgnore,
                                 commentAttr.Channel));
                         }
                     }
@@ -682,13 +682,13 @@ private static BuildResult<ILexer<IN>> CheckStringAndCharTokens<IN>(
             var allLexemes = attributes.Values.SelectMany<List<LexemeAttribute>, LexemeAttribute>(a => a);
 
             var allDelimiters = allLexemes
-                .Where<LexemeAttribute>(a => a.IsString || a.IsChar)
-                .Where<LexemeAttribute>(a => a.HasGenericTokenParameters)
-                .Select<LexemeAttribute, string>(a => a.GenericTokenParameters[0]);
+                .Where(a => a.IsString || a.IsChar)
+                .Where(a => a.HasGenericTokenParameters)
+                .Select(a => a.GenericTokenParameters[0]);
 
-            var duplicates = allDelimiters.GroupBy<string, string>(x => x)
-                .Where<IGrouping<string, string>>(g => g.Count<string>() > 1)
-                .Select(y => new { Element = y.Key, Counter = y.Count<string>() });
+            var duplicates = allDelimiters.GroupBy(x => x)
+                .Where(g => g.Count() > 1)
+                .Select(y => new { Element = y.Key, Counter = y.Count() });
 
             foreach (var duplicate in duplicates)
             {
@@ -712,16 +712,16 @@ private static Dictionary<IN, List<CommentAttribute>> GetCommentsAttribute<IN>(B
             {
                 var tokenID = (IN)(object)value;
                 var enumAttributes = value.GetAttributesOfType<CommentAttribute>();
-                if (enumAttributes != null && enumAttributes.Any<CommentAttribute>())
-                    attributes[tokenID] = enumAttributes.ToList<CommentAttribute>();
+                if (enumAttributes != null && enumAttributes.Any())
+                    attributes[tokenID] = enumAttributes.ToList();
             }
 
-            var commentCount = attributes.Values.Select<List<CommentAttribute>, int>(l =>
-                l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(CommentAttribute)) ?? 0).Sum();
-            var multiLineCommentCount = attributes.Values.Select<List<CommentAttribute>, int>(l =>
-                l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(MultiLineCommentAttribute)) ?? 0).Sum();
-            var singleLineCommentCount = attributes.Values.Select<List<CommentAttribute>, int>(l =>
-                l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(SingleLineCommentAttribute)) ?? 0).Sum();
+            var commentCount = attributes.Values.Select(l =>
+                l?.Count(attr => attr.GetType() == typeof(CommentAttribute)) ?? 0).Sum();
+            var multiLineCommentCount = attributes.Values.Select(l =>
+                l?.Count(attr => attr.GetType() == typeof(MultiLineCommentAttribute)) ?? 0).Sum();
+            var singleLineCommentCount = attributes.Values.Select(l =>
+                l?.Count(attr => attr.GetType() == typeof(SingleLineCommentAttribute)) ?? 0).Sum();
 
             if (commentCount > 1)
             {

src/sly/parser/parser/GroupItem.cs

@@ -42,13 +42,13 @@ public X Match<X>(Func<string, Token<IN>, X> fToken, Func<string, OUT, X> fValue
         [ExcludeFromCodeCoverage]
         public static implicit operator OUT(GroupItem<IN, OUT> item)
         {
-            return item.Match<OUT>((name, token) => default(OUT), (name, value) => item.Value);
+            return item.Match((name, token) => default, (name, value) => item.Value);
         }
 
         [ExcludeFromCodeCoverage]
         public static implicit operator Token<IN>(GroupItem<IN, OUT> item)
         {
-            return item.Match<Token<IN>>((name, token) => item.Token, (name, value) => default(Token<IN>));
+            return item.Match((name, token) => item.Token, (name, value) => default);
         }
 
         [ExcludeFromCodeCoverage]

src/sly/parser/parser/Parser.cs

@@ -129,22 +129,22 @@ public ParseResult<IN, OUT> ParseWithContext(IList<Token<IN>> tokens, object par
             else
             {
                 result.Errors = new List<ParseError>();
-                var unexpectedTokens = syntaxResult.Errors.ToList<UnexpectedTokenSyntaxError<IN>>();
-                var byEnding = unexpectedTokens.GroupBy<UnexpectedTokenSyntaxError<IN>, LexerPosition>(x => x.UnexpectedToken.Position).OrderBy<IGrouping<LexerPosition, UnexpectedTokenSyntaxError<IN>>, LexerPosition>(x => x.Key);
+                var unexpectedTokens = syntaxResult.Errors.ToList();
+                var byEnding = unexpectedTokens.GroupBy(x => x.UnexpectedToken.Position).OrderBy(x => x.Key);
                 var errors = new List<ParseError>();  
                 foreach (var expecting in byEnding)
                 {
-                    var expectingTokens = expecting.SelectMany<UnexpectedTokenSyntaxError<IN>, LeadingToken<IN>>(x => x.ExpectedTokens ?? new List<LeadingToken<IN>>()).Distinct();
+                    var expectingTokens = expecting.SelectMany(x => x.ExpectedTokens ?? new List<LeadingToken<IN>>()).Distinct();
                     var expectedTokens =  expectingTokens != null && expectingTokens.Any() ? expectingTokens?.ToArray() : null;
                     if (expectedTokens != null)
                     {
-                        var expected = new UnexpectedTokenSyntaxError<IN>(expecting.First<UnexpectedTokenSyntaxError<IN>>().UnexpectedToken, LexemeLabels, I18n,
+                        var expected = new UnexpectedTokenSyntaxError<IN>(expecting.First().UnexpectedToken, LexemeLabels, I18n,
                             expectedTokens);
                         errors.Add(expected);
                     }
                     else
                     {
-                        var expected = new UnexpectedTokenSyntaxError<IN>(expecting.First<UnexpectedTokenSyntaxError<IN>>().UnexpectedToken, LexemeLabels, I18n,
+                        var expected = new UnexpectedTokenSyntaxError<IN>(expecting.First().UnexpectedToken, LexemeLabels, I18n,
                             new LeadingToken<IN>[]{});
                         errors.Add(expected);
                     }

src/sly/parser/parser/llparser/EBNFRecursiveDescentSyntaxParser.cs

@@ -115,7 +115,7 @@ public override SyntaxParseResult<IN> Parse(IList<Token<IN>> tokens, Rule<IN> ru
                             {
                                 var choiceResult = ParseChoice(tokens, choice, currentPosition, parsingContext);
                                 currentPosition = choiceResult.EndingPosition;
-                                if (choiceResult.IsError && choiceResult.Errors != null && choiceResult.Errors.Any<UnexpectedTokenSyntaxError<IN>>())
+                                if (choiceResult.IsError && choiceResult.Errors != null && choiceResult.Errors.Any())
                                 {
                                     errors.AddRange(choiceResult.Errors);
                                 }

src/sly/parser/parser/llparser/RecursiveDescentSyntaxParser.cs

@@ -101,12 +101,12 @@ public SyntaxParseResult<IN> SafeParse(IList<Token<IN>> tokens, SyntaxParsingCon
                 if (errors.Count > 0)
                 {
                     var lastErrorPosition = errors
-                        .Select<UnexpectedTokenSyntaxError<IN>, int>(e => e.UnexpectedToken.PositionInTokenFlow)
+                        .Select(e => e.UnexpectedToken.PositionInTokenFlow)
                         .Max();
                     var lastErrors = errors
-                        .Where<UnexpectedTokenSyntaxError<IN>>(e =>
+                        .Where(e =>
                             e.UnexpectedToken.PositionInTokenFlow == lastErrorPosition)
-                        .ToList<UnexpectedTokenSyntaxError<IN>>();
+                        .ToList();
                     result.Errors = lastErrors;
                 }
                 else

src/sly/parser/syntax/grammar/ChoiceClause.cs

@@ -8,10 +8,10 @@ public sealed class ChoiceClause<T> : IClause<T> where T : struct
     {
 
         public bool IsDiscarded { get; set; } = false;
-        public bool IsTerminalChoice => Choices.Select<IClause<T>, bool>(c => c is TerminalClause<T>).Aggregate<bool>((x, y) => x && y);
-        public bool IsNonTerminalChoice => Choices.Select<IClause<T>, bool>(c => c is NonTerminalClause<T>).Aggregate<bool>((x, y) => x && y);
+        public bool IsTerminalChoice => Choices.Select(c => c is TerminalClause<T>).Aggregate((x, y) => x && y);
+        public bool IsNonTerminalChoice => Choices.Select(c => c is NonTerminalClause<T>).Aggregate((x, y) => x && y);
 
-        public  List<IClause<T>> Choices { get; set; }
+        public  List<IClause<T>> Choices { get; }
         public ChoiceClause(IClause<T> clause)
         {
             Choices = new List<IClause<T>> {clause};
@@ -31,7 +31,7 @@ public ChoiceClause(IClause<T> choice, List<IClause<T>> choices) : this(choice)
         [ExcludeFromCodeCoverage]
         public override string ToString()
         {
-            var choices = string.Join(" | ", Choices.Select<IClause<T>, string>(c => c.Dump()));
+            var choices = string.Join(" | ", Choices.Select(c => c.Dump()));
             return $"[ {choices} ]";
         }
 

src/sly/parser/syntax/grammar/ClauseSequence.cs

@@ -33,7 +33,7 @@ public void AddRange(ClauseSequence<T> seq)
         [ExcludeFromCodeCoverage]
         public string Dump()
         {
-            return Clauses.Select<IClause<T>, string>(c => c.Dump()).Aggregate<string>((d1, d2) => d1 + " " + d2);
+            return Clauses.Select(c => c.Dump()).Aggregate((d1, d2) => d1 + " " + d2);
         }
 
         public bool Equals(IClause<T> other)

src/sly/parser/syntax/grammar/GroupClause.cs

@@ -37,7 +37,7 @@ public string Dump()
         {
             StringBuilder dump = new StringBuilder();
             dump.Append("( ");
-            dump.Append(Clauses.Select<IClause<T>, string>(c => c.Dump()).Aggregate<string>((d1, d2) => d1 + " " + d2));
+            dump.Append(Clauses.Select(c => c.Dump()).Aggregate((d1, d2) => d1 + " " + d2));
             dump.Append(" )");
             return dump.ToString();
         }