qodana cleaning

src/sly/lexer/GenericLexer.cs

@@ -43,8 +43,6 @@ public Config()
 
             public IEqualityComparer<string> KeyWordComparer =>
                 KeyWordIgnoreCase ? StringComparer.OrdinalIgnoreCase : null;
-
-            public IList<string> Modes { get; set; }
         }
 
         public LexerPostProcess<IN> LexerPostProcess { get; set; }
@@ -832,7 +830,6 @@ private void AddDoubleWhenDoubleTokenPresent(IN token, DateFormat format, char s
                 match.Result.SpanValue = value;
 
                 match.StringDelimiterChar = stringDelimiterChar;
-                match.IsString = true;
                 if (stringDelimiterChar != escapeStringDelimiterChar)
                 {
                     match.Result.SpanValue = diffCharEscaper(escapeStringDelimiterChar, stringDelimiterChar,

src/sly/lexer/LexerBuilder.cs

@@ -347,7 +347,6 @@ private static bool IsGenericLexer<IN>(Dictionary<IN, (List<LexemeAttribute> lex
             var modesAttribute = typeof(IN).GetCustomAttribute<ModesAttribute>();
             if (modesAttribute != null)
             {
-                config.Modes = modesAttribute.Modes;
             }
 
             var statics = new List<GenericToken>();

src/sly/lexer/attributes/PopAttribute.cs

@@ -5,11 +5,8 @@ namespace sly.lexer
     [AttributeUsage(AttributeTargets.Field)]
     public class PopAttribute : Attribute
     {
-        public string TargetMode { get; }
-
         public PopAttribute(string mode = null)
         {
-            TargetMode = mode;
         }
     }
 }

src/sly/lexer/fsm/FSMLexerBuilder.cs

@@ -22,7 +22,6 @@ public FSMLexerBuilder()
             CurrentState = 0;
             Marks = new Dictionary<string, int>();
             Fsm.AddNode(default(N));
-            Fsm.GetNode(0).IsStart = true;
         }
 
         public FSMLexer<N> Fsm { get; }

src/sly/lexer/fsm/FSMMatch.cs

@@ -7,8 +7,6 @@ public class FSMMatch<N>  where N : struct
     {
         public Dictionary<string, object> Properties { get; }
 
-        public bool IsString { get; set; }
-
         public char StringDelimiterChar { get; set; }
 
         public char DecimalSeparator { get; set; }

src/sly/lexer/fsm/FSMNode.cs

@@ -9,11 +9,10 @@ internal FSMNode(N value)
 
         internal N Value { get; set; }
 
-        internal int Id { get; set; } = 0;
+        internal int Id { get; set; }
 
-        internal bool IsEnd { get; set; } = false;
+        internal bool IsEnd { get; set; }
 
-        internal bool IsStart { get; set; } = false;
         public string Mark { get; internal set; }
         public bool IsLineEnding { get; set; }
 

src/sly/parser/generator/ParserBuilder.cs

@@ -171,7 +171,7 @@ public ParserBuilder() : this(null)
             {
                 var nt = "";
                 var rule = "";
-                var i = ruleString.IndexOf(":");
+                var i = ruleString.IndexOf(":", StringComparison.Ordinal);
                 if (i > 0)
                 {
                     nt = ruleString.Substring(0, i).Trim();
@@ -198,17 +198,15 @@ public ParserBuilder() : this(null)
         protected virtual ParserConfiguration<IN, OUT> ExtractParserConfiguration(Type parserClass)
         {
             var conf = new ParserConfiguration<IN, OUT>();
-            var functions = new Dictionary<string, MethodInfo>();
             var nonTerminals = new Dictionary<string, NonTerminal<IN>>();
-            var methods = parserClass.GetMethods().ToList<MethodInfo>();
-            methods = methods.Where<MethodInfo>(m =>
+            var methods = parserClass.GetMethods().ToList();
+            methods = methods.Where(m =>
             {
-                var attributes = m.GetCustomAttributes().ToList<Attribute>();
+                var attributes = m.GetCustomAttributes().ToList();
                 var attr = attributes.Find(a => a.GetType() == typeof(ProductionAttribute));
                 return attr != null;
-            }).ToList<MethodInfo>();
+            }).ToList();
 
-            parserClass.GetMethods();
             methods.ForEach(m =>
             {
                 var attributes = (ProductionAttribute[])m.GetCustomAttributes(typeof(ProductionAttribute), true);
@@ -222,8 +220,7 @@ public ParserBuilder() : this(null)
                     r.SetVisitor(m);
                     r.NonTerminalName = ntAndRule.Item1;
                     var key = $"{ntAndRule.Item1}__{r.Key}";
-                    functions[key] = m;
-                    NonTerminal<IN> nonT = null;
+                    NonTerminal<IN> nonT ;
                     if (!nonTerminals.ContainsKey(ntAndRule.Item1))
                         nonT = new NonTerminal<IN>(ntAndRule.Item1, new List<Rule<IN>>());
                     else

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

@@ -54,9 +54,9 @@ public bool Equals(IClause<T> clause)
             }
 
             return false;
-        } 
-        
-        protected bool Equals(ChoiceClause<T> other)
+        }
+
+        private bool Equals(ChoiceClause<T> other)
         {
             if (other.Choices.Count != Choices.Count)
             {

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

@@ -41,8 +41,8 @@ public bool Equals(IClause<T> clause)
 
             return false;
         }
-        
-        protected bool Equals(NonTerminalClause<T> other)
+
+        private bool Equals(NonTerminalClause<T> other)
         {
             return NonTerminalName == other.NonTerminalName && IsGroup == other.IsGroup;
         }

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

@@ -39,8 +39,8 @@ public bool Equals(IClause<T> clause)
             }
             return false;
         }
-        
-        protected bool Equals(OptionClause<T> other)
+
+        private bool Equals(OptionClause<T> other)
         {
             return Equals(Clause, other.Clause);
         }