Refactor some inconsistent code styles

Therena · Therena · commit 584a484fe456 · 2020-12-20T15:05:29.000+01:00
diff --git a/AutoItSyntaxHighlight/AutoItEditorClassifier.cs b/AutoItSyntaxHighlight/AutoItEditorClassifier.cs
@@ -22,7 +22,7 @@ namespace AutoItSyntaxHighlight
 {
     internal class AutoItEditorClassifier : IClassifier
     {
-        private AutoItLexer m_Lexer;
+        private readonly AutoItLexer m_Lexer;
 
         internal AutoItEditorClassifier(IClassificationTypeRegistryService registry)
         {
diff --git a/AutoItSyntaxHighlight/AutoItEditorClassifierClassificationDefinition.cs b/AutoItSyntaxHighlight/AutoItEditorClassifierClassificationDefinition.cs
@@ -26,33 +26,33 @@ internal static class AutoItEditorClassifierClassificationDefinition
 #pragma warning disable CS0414
         [Export(typeof(ClassificationTypeDefinition))]
         [Name("AutoItEditorClassifier")]
-        private static ClassificationTypeDefinition typeDefinition = null;
+        private static ClassificationTypeDefinition m_TypeDefinition = null;
 
         [Export(typeof(ClassificationTypeDefinition))]
         [Name("AutoItEditorCommentClassifier")]
-        private static ClassificationTypeDefinition typeCommentDefinition = null;
+        private static ClassificationTypeDefinition m_TypeCommentDefinition = null;
 
         [Export(typeof(ClassificationTypeDefinition))]
         [Name("AutoItEditorStringClassifier")]
-        private static ClassificationTypeDefinition typeStringDefinition = null;
+        private static ClassificationTypeDefinition m_TypeStringDefinition = null;
 
         [Export(typeof(ClassificationTypeDefinition))]
         [Name("AutoItEditorFunctionsClassifier")]
-        private static ClassificationTypeDefinition typeFunctionDefinition = null;
+        private static ClassificationTypeDefinition m_TypeFunctionDefinition = null;
 
         [Export(typeof(ClassificationTypeDefinition))]
         [Name("AutoItEditorKeywordClassifier")]
-        private static ClassificationTypeDefinition typeKeywordDefinition = null;
+        private static ClassificationTypeDefinition m_TypeKeywordDefinition = null;
 
         [Export]
         [Name("au3")]
         [BaseDefinition("code")]
-        internal static ContentTypeDefinition AutoItContentDefinition = null;
+        internal static ContentTypeDefinition ItContentDefinition = null;
 
         [Export]
         [FileExtension(".au3")]
         [ContentType("au3")]
-        internal static FileExtensionToContentTypeDefinition AutoItFileExtensionDefinition = null;
+        internal static FileExtensionToContentTypeDefinition ItFileExtensionDefinition = null;
 
 #pragma warning restore 169
 #pragma warning restore CS0414
diff --git a/AutoItSyntaxHighlight/AutoItEditorClassifierProvider.cs b/AutoItSyntaxHighlight/AutoItEditorClassifierProvider.cs
@@ -27,14 +27,14 @@ internal class AutoItEditorClassifierProvider : IClassifierProvider
         // Disable "Field is never assigned to..." compiler's warning. Justification: the field is assigned by MEF.
 #pragma warning disable 649
         [Import]
-        private readonly IClassificationTypeRegistryService classificationRegistry;
+        private readonly IClassificationTypeRegistryService m_ClassificationRegistry;
 
 #pragma warning restore 649
 
         #region IClassifierProvider
         public IClassifier GetClassifier(ITextBuffer buffer)
         {
-            return buffer.Properties.GetOrCreateSingletonProperty<AutoItEditorClassifier>(creator: () => new AutoItEditorClassifier(this.classificationRegistry));
+            return buffer.Properties.GetOrCreateSingletonProperty(creator: () => new AutoItEditorClassifier(this.m_ClassificationRegistry));
         }
         #endregion
     }
diff --git a/AutoItSyntaxHighlight/AutoItLexer.cs b/AutoItSyntaxHighlight/AutoItLexer.cs
@@ -25,12 +25,14 @@ namespace AutoItSyntaxHighlight
     internal sealed class AutoItLexer
     {
         private readonly List<IAutoItLexer> m_Lexer;
-        private readonly IClassificationType classificationType;
+
         public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;
+        
+        public IClassificationType ClassificationType { get; }
 
         public AutoItLexer(IClassificationTypeRegistryService registry)
         {
-            this.classificationType = registry.GetClassificationType("AutoItEditorClassifier");
+            this.ClassificationType = registry.GetClassificationType("AutoItEditorClassifier");
 
             m_Lexer = new List<IAutoItLexer>
             {
@@ -55,7 +57,7 @@ public List<ClassificationSpan> FlattenSpanList(List<PrioritiesClassificationSpa
             List<ClassificationSpan> classifications = new List<ClassificationSpan>();
             foreach (var one in spanList)
             {
-                bool hasntHighestPriority = true;
+                bool hasNotHighestPriority = true;
                 foreach (var two in spanList)
                 {
                     if (one == two || one.Span.Span.OverlapsWith(two.Span.Span) == false)
@@ -65,12 +67,12 @@ public List<ClassificationSpan> FlattenSpanList(List<PrioritiesClassificationSpa
 
                     if (one.Priority < two.Priority)
                     {
-                        hasntHighestPriority = false;
+                        hasNotHighestPriority = false;
                         break;
                     }
                 }
 
-                if(hasntHighestPriority)
+                if(hasNotHighestPriority)
                 {
                     classifications.Add(one.Span);
                 }
@@ -80,12 +82,12 @@ public List<ClassificationSpan> FlattenSpanList(List<PrioritiesClassificationSpa
 
         public List<ClassificationSpan> Parse(SnapshotSpan span)
         {
-            List<PrioritiesClassificationSpan> prioClassi = new List<PrioritiesClassificationSpan>();
+            List<PrioritiesClassificationSpan> priorClassification = new List<PrioritiesClassificationSpan>();
             foreach (var lexer in m_Lexer)
             {
-                prioClassi.AddRange(lexer.Parse(span));
+                priorClassification.AddRange(lexer.Parse(span));
             }
-            return FlattenSpanList(prioClassi);
+            return FlattenSpanList(priorClassification);
         }
     }
 }
diff --git a/AutoItSyntaxHighlight/Helper/MultiLineComment.cs b/AutoItSyntaxHighlight/Helper/MultiLineComment.cs
@@ -14,7 +14,6 @@
 // limitations under the License.
 //
 using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Text.Classification;
 
 namespace AutoItSyntaxHighlight.Helper
 {
diff --git a/AutoItSyntaxHighlight/Lexer/AutoItLexerComments.cs b/AutoItSyntaxHighlight/Lexer/AutoItLexerComments.cs
@@ -25,10 +25,10 @@ namespace AutoItSyntaxHighlight.Lexer
 {
     internal sealed class AutoItLexerComments : IAutoItLexer
     {
-        private Regex m_Regex;
+        private readonly Regex m_Regex;
         private readonly IClassificationType m_Type;
-        private List<MultiLineComment> m_MultiLineComments;
-        private IClassificationTypeRegistryService m_Registry;
+        private readonly List<MultiLineComment> m_MultiLineComments;
+        private readonly IClassificationTypeRegistryService m_Registry;
         public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;
 
         public AutoItLexerComments(IClassificationTypeRegistryService registry)
@@ -56,13 +56,13 @@ private List<PrioritiesClassificationSpan> ParseMultiLine(SnapshotSpan span)
 
             try
             {
-                string codeSegement = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();
-                int endPosition = IndexOfCommentEnd(codeSegement);
+                string codeSegment = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();
+                int endPosition = IndexOfCommentEnd(codeSegment);
                 while (endPosition < 0)
                 {
                     ++lineNumber;
-                    codeSegement = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();
-                    endPosition = IndexOfCommentEnd(codeSegement);
+                    codeSegment = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();
+                    endPosition = IndexOfCommentEnd(codeSegment);
                 }
             }
             catch (ArgumentOutOfRangeException)
@@ -80,10 +80,11 @@ private List<PrioritiesClassificationSpan> ParseMultiLine(SnapshotSpan span)
                     new ClassificationChangedEventArgs(new SnapshotSpan(span.End + 1, multiSpan.End)));
             }
 
-            var prioSpan = new PrioritiesClassificationSpan();
-            prioSpan.Span = new ClassificationSpan(multiSpan, m_Type);
-            prioSpan.Priority = 400;
-            classifications.Add(prioSpan);
+            var priorClassification = new PrioritiesClassificationSpan
+            {
+                Span = new ClassificationSpan(multiSpan, m_Type), Priority = 400
+            };
+            classifications.Add(priorClassification);
 
             if (m_MultiLineComments.Any(a => a.Tracking.GetSpan(span.Snapshot).Span == multiSpan.Span) == false)
             {
@@ -120,16 +121,16 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)
                 isInsideOfComment = true;
                 if (span.Snapshot.Version == comment.Version)
                 {
-                    var prioSpan = new PrioritiesClassificationSpan();
-                    prioSpan.Span = new ClassificationSpan(multiSpan, m_Type);
-                    prioSpan.Priority = 400;
-                    classifications.Add(prioSpan);
+                    var priorClassification = new PrioritiesClassificationSpan
+                    {
+                        Span = new ClassificationSpan(multiSpan, m_Type), Priority = 400
+                    };
+                    classifications.Add(priorClassification);
                 }
                 else
                 {
                     m_MultiLineComments.RemoveAt(i);
                     ClassificationChanged?.Invoke(this, new ClassificationChangedEventArgs(multiSpan));
-                    continue;
                 }
             }
 
@@ -157,10 +158,11 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)
                     span.GetText().Length - match.Index);
                 SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);
 
-                var prioSpan = new PrioritiesClassificationSpan();
-                prioSpan.Span = new ClassificationSpan(snapshot, m_Type);
-                prioSpan.Priority = 400;
-                classifications.Add(prioSpan);
+                var priorClassification = new PrioritiesClassificationSpan
+                {
+                    Span = new ClassificationSpan(snapshot, m_Type), Priority = 400
+                };
+                classifications.Add(priorClassification);
             }
             return classifications;
         }
@@ -184,12 +186,12 @@ private int IndexOfCommentStart(string code)
         {
             if (code.Contains("#cs"))
             {
-                return code.IndexOf("#cs");
+                return code.IndexOf("#cs", StringComparison.Ordinal);
             }
 
             if (code.Contains("#comment-start"))
             {
-                return code.IndexOf("#comment-start");
+                return code.IndexOf("#comment-start", StringComparison.Ordinal);
             }
             return -1;
         }
@@ -198,12 +200,12 @@ private int IndexOfCommentEnd(string code)
         {
             if (code.Contains("#ce"))
             {
-                return code.IndexOf("#ce");
+                return code.IndexOf("#ce", StringComparison.Ordinal);
             }
 
             if (code.Contains("#comment-end"))
             {
-                return code.IndexOf("#comment-end");
+                return code.IndexOf("#comment-end", StringComparison.Ordinal);
             }
             return -1;
         }
diff --git a/AutoItSyntaxHighlight/Lexer/AutoItLexerFunctions.cs b/AutoItSyntaxHighlight/Lexer/AutoItLexerFunctions.cs
@@ -24,7 +24,7 @@ namespace AutoItSyntaxHighlight.Lexer
 {
     internal sealed class AutoItLexerFunctions : IAutoItLexer
     {
-        private Regex m_Regex;
+        private readonly Regex m_Regex;
         private readonly IClassificationType m_Type;
 
 #pragma warning disable CS0067
@@ -58,9 +58,9 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)
                 Span spanWord = new Span(span.Start.Position + group.Index, group.Length);
                 SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);
 
-                var prioSpan = new PrioritiesClassificationSpan();
-                prioSpan.Span = new ClassificationSpan(snapshot, m_Type);
-                classifications.Add(prioSpan);
+                var priorClassification = new PrioritiesClassificationSpan();
+                priorClassification.Span = new ClassificationSpan(snapshot, m_Type);
+                classifications.Add(priorClassification);
             }
             return classifications;
         }
diff --git a/AutoItSyntaxHighlight/Lexer/AutoItLexerKeywords.cs b/AutoItSyntaxHighlight/Lexer/AutoItLexerKeywords.cs
@@ -25,7 +25,7 @@ namespace AutoItSyntaxHighlight.Lexer
     internal sealed class AutoItLexerKeywords : IAutoItLexer
     {
         private readonly IClassificationType m_Type;
-        private List<string> m_Keywords;
+        private readonly List<string> m_Keywords;
 
 #pragma warning disable CS0067
         public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;
@@ -36,7 +36,7 @@ public AutoItLexerKeywords(IClassificationTypeRegistryService registry)
             m_Type = registry.GetClassificationType("AutoItEditorKeywordClassifier");
 
             // https://www.autoitscript.com/autoit3/docs/keywords.htm
-            m_Keywords = new List<string>(new string[] { "True", "False",
+            m_Keywords = new List<string>(new[] { "True", "False",
                 "ContinueCase", "ContinueLoop", "#Region", "#EndRegion",
                 "Default", "Dim", "Global", "Local", "Const", "Do", "Until", "Enum",
                 "Exit", "ExitLoop", "For", "To", "Step", "Next", "In", "Next",
@@ -70,9 +70,9 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)
                     Group group = match.Groups[1];
                     if (group.Index > 0)
                     {
-                        Regex regWhitspace = new Regex(@"\s+", RegexOptions.IgnoreCase);
+                        Regex regWhitespace = new Regex(@"\s+", RegexOptions.IgnoreCase);
                         string code = "" + span.GetText()[group.Index - 1];
-                        if (regWhitspace.IsMatch(code) == false)
+                        if (regWhitespace.IsMatch(code) == false)
                         {
                             continue;
                         }
@@ -81,10 +81,10 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)
                     Span spanWord = new Span(span.Start.Position + group.Index, group.Length);
                     SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);
 
-                    var prioSpan = new PrioritiesClassificationSpan();
-                    prioSpan.Span = new ClassificationSpan(snapshot, m_Type);
-                    prioSpan.Priority = 200;
-                    classifications.Add(prioSpan);
+                    var priorClassification = new PrioritiesClassificationSpan();
+                    priorClassification.Span = new ClassificationSpan(snapshot, m_Type);
+                    priorClassification.Priority = 200;
+                    classifications.Add(priorClassification);
                 }
             }
             return classifications;
diff --git a/AutoItSyntaxHighlight/Lexer/AutoItLexerStrings.cs b/AutoItSyntaxHighlight/Lexer/AutoItLexerStrings.cs
@@ -24,7 +24,7 @@ namespace AutoItSyntaxHighlight.Lexer
 {
     internal sealed class AutoItLexerStrings : IAutoItLexer
     {
-        private Regex m_Regex;
+        private readonly Regex m_Regex;
         private readonly IClassificationType m_Type;
 
 #pragma warning disable CS0067
@@ -51,10 +51,11 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)
                 Span spanWord = new Span(span.Start.Position + match.Index, match.Length);
                 SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);
 
-                var prioSpan = new PrioritiesClassificationSpan();
-                prioSpan.Span = new ClassificationSpan(snapshot, m_Type);
-                prioSpan.Priority = 300;
-                classifications.Add(prioSpan);
+                var priorClassification = new PrioritiesClassificationSpan
+                {
+                    Span = new ClassificationSpan(snapshot, m_Type), Priority = 300
+                };
+                classifications.Add(priorClassification);
             }
             return classifications;
         }

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ namespace AutoItSyntaxHighlight`
`22`	`22`	`{`
`23`	`23`	`internal class AutoItEditorClassifier : IClassifier`
`24`	`24`	`{`
`25`		`- private AutoItLexer m_Lexer;`
	`25`	`+ private readonly AutoItLexer m_Lexer;`
`26`	`26`
`27`	`27`	`internal AutoItEditorClassifier(IClassificationTypeRegistryService registry)`
`28`	`28`	`{`
Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,14 @@ internal class AutoItEditorClassifierProvider : IClassifierProvider`
`27`	`27`	`// Disable "Field is never assigned to..." compiler's warning. Justification: the field is assigned by MEF.`
`28`	`28`	`#pragma warning disable 649`
`29`	`29`	`[Import]`
`30`		`- private readonly IClassificationTypeRegistryService classificationRegistry;`
	`30`	`+ private readonly IClassificationTypeRegistryService m_ClassificationRegistry;`
`31`	`31`
`32`	`32`	`#pragma warning restore 649`
`33`	`33`
`34`	`34`	`#region IClassifierProvider`
`35`	`35`	`public IClassifier GetClassifier(ITextBuffer buffer)`
`36`	`36`	`{`
`37`		`- return buffer.Properties.GetOrCreateSingletonProperty<AutoItEditorClassifier>(creator: () => new AutoItEditorClassifier(this.classificationRegistry));`
	`37`	`+ return buffer.Properties.GetOrCreateSingletonProperty(creator: () => new AutoItEditorClassifier(this.m_ClassificationRegistry));`
`38`	`38`	`}`
`39`	`39`	`#endregion`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,12 +25,14 @@ namespace AutoItSyntaxHighlight`
`25`	`25`	`internal sealed class AutoItLexer`
`26`	`26`	`{`
`27`	`27`	`private readonly List<IAutoItLexer> m_Lexer;`
`28`		`- private readonly IClassificationType classificationType;`
	`28`	`+`
`29`	`29`	`public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;`
	`30`	`+`
	`31`	`+ public IClassificationType ClassificationType { get; }`
`30`	`32`
`31`	`33`	`public AutoItLexer(IClassificationTypeRegistryService registry)`
`32`	`34`	`{`
`33`		`- this.classificationType = registry.GetClassificationType("AutoItEditorClassifier");`
	`35`	`+ this.ClassificationType = registry.GetClassificationType("AutoItEditorClassifier");`
`34`	`36`
`35`	`37`	`m_Lexer = new List<IAutoItLexer>`
`36`	`38`	`{`
`@@ -55,7 +57,7 @@ public List<ClassificationSpan> FlattenSpanList(List<PrioritiesClassificationSpa`
`55`	`57`	`List<ClassificationSpan> classifications = new List<ClassificationSpan>();`
`56`	`58`	`foreach (var one in spanList)`
`57`	`59`	`{`
`58`		`- bool hasntHighestPriority = true;`
	`60`	`+ bool hasNotHighestPriority = true;`
`59`	`61`	`foreach (var two in spanList)`
`60`	`62`	`{`
`61`	`63`	`if (one == two \|\| one.Span.Span.OverlapsWith(two.Span.Span) == false)`
`@@ -65,12 +67,12 @@ public List<ClassificationSpan> FlattenSpanList(List<PrioritiesClassificationSpa`
`65`	`67`
`66`	`68`	`if (one.Priority < two.Priority)`
`67`	`69`	`{`
`68`		`- hasntHighestPriority = false;`
	`70`	`+ hasNotHighestPriority = false;`
`69`	`71`	`break;`
`70`	`72`	`}`
`71`	`73`	`}`
`72`	`74`
`73`		`- if(hasntHighestPriority)`
	`75`	`+ if(hasNotHighestPriority)`
`74`	`76`	`{`
`75`	`77`	`classifications.Add(one.Span);`
`76`	`78`	`}`
`@@ -80,12 +82,12 @@ public List<ClassificationSpan> FlattenSpanList(List<PrioritiesClassificationSpa`
`80`	`82`
`81`	`83`	`public List<ClassificationSpan> Parse(SnapshotSpan span)`
`82`	`84`	`{`
`83`		`- List<PrioritiesClassificationSpan> prioClassi = new List<PrioritiesClassificationSpan>();`
	`85`	`+ List<PrioritiesClassificationSpan> priorClassification = new List<PrioritiesClassificationSpan>();`
`84`	`86`	`foreach (var lexer in m_Lexer)`
`85`	`87`	`{`
`86`		`- prioClassi.AddRange(lexer.Parse(span));`
	`88`	`+ priorClassification.AddRange(lexer.Parse(span));`
`87`	`89`	`}`
`88`		`- return FlattenSpanList(prioClassi);`
	`90`	`+ return FlattenSpanList(priorClassification);`
`89`	`91`	`}`
`90`	`92`	`}`
`91`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,6 @@`
`14`	`14`	`// limitations under the License.`
`15`	`15`	`//`
`16`	`16`	`using Microsoft.VisualStudio.Text;`
`17`		`-using Microsoft.VisualStudio.Text.Classification;`
`18`	`17`
`19`	`18`	`namespace AutoItSyntaxHighlight.Helper`
`20`	`19`	`{`
Original file line number	Diff line number	Diff line change
`@@ -25,10 +25,10 @@ namespace AutoItSyntaxHighlight.Lexer`
`25`	`25`	`{`
`26`	`26`	`internal sealed class AutoItLexerComments : IAutoItLexer`
`27`	`27`	`{`
`28`		`- private Regex m_Regex;`
	`28`	`+ private readonly Regex m_Regex;`
`29`	`29`	`private readonly IClassificationType m_Type;`
`30`		`- private List<MultiLineComment> m_MultiLineComments;`
`31`		`- private IClassificationTypeRegistryService m_Registry;`
	`30`	`+ private readonly List<MultiLineComment> m_MultiLineComments;`
	`31`	`+ private readonly IClassificationTypeRegistryService m_Registry;`
`32`	`32`	`public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;`
`33`	`33`
`34`	`34`	`public AutoItLexerComments(IClassificationTypeRegistryService registry)`
`@@ -56,13 +56,13 @@ private List<PrioritiesClassificationSpan> ParseMultiLine(SnapshotSpan span)`
`56`	`56`
`57`	`57`	`try`
`58`	`58`	`{`
`59`		`- string codeSegement = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();`
`60`		`- int endPosition = IndexOfCommentEnd(codeSegement);`
	`59`	`+ string codeSegment = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();`
	`60`	`+ int endPosition = IndexOfCommentEnd(codeSegment);`
`61`	`61`	`while (endPosition < 0)`
`62`	`62`	`{`
`63`	`63`	`++lineNumber;`
`64`		`- codeSegement = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();`
`65`		`- endPosition = IndexOfCommentEnd(codeSegement);`
	`64`	`+ codeSegment = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();`
	`65`	`+ endPosition = IndexOfCommentEnd(codeSegment);`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`	`catch (ArgumentOutOfRangeException)`
`@@ -80,10 +80,11 @@ private List<PrioritiesClassificationSpan> ParseMultiLine(SnapshotSpan span)`
`80`	`80`	`new ClassificationChangedEventArgs(new SnapshotSpan(span.End + 1, multiSpan.End)));`
`81`	`81`	`}`
`82`	`82`
`83`		`- var prioSpan = new PrioritiesClassificationSpan();`
`84`		`- prioSpan.Span = new ClassificationSpan(multiSpan, m_Type);`
`85`		`- prioSpan.Priority = 400;`
`86`		`- classifications.Add(prioSpan);`
	`83`	`+ var priorClassification = new PrioritiesClassificationSpan`
	`84`	`+ {`
	`85`	`+ Span = new ClassificationSpan(multiSpan, m_Type), Priority = 400`
	`86`	`+ };`
	`87`	`+ classifications.Add(priorClassification);`
`87`	`88`
`88`	`89`	`if (m_MultiLineComments.Any(a => a.Tracking.GetSpan(span.Snapshot).Span == multiSpan.Span) == false)`
`89`	`90`	`{`
`@@ -120,16 +121,16 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)`
`120`	`121`	`isInsideOfComment = true;`
`121`	`122`	`if (span.Snapshot.Version == comment.Version)`
`122`	`123`	`{`
`123`		`- var prioSpan = new PrioritiesClassificationSpan();`
`124`		`- prioSpan.Span = new ClassificationSpan(multiSpan, m_Type);`
`125`		`- prioSpan.Priority = 400;`
`126`		`- classifications.Add(prioSpan);`
	`124`	`+ var priorClassification = new PrioritiesClassificationSpan`
	`125`	`+ {`
	`126`	`+ Span = new ClassificationSpan(multiSpan, m_Type), Priority = 400`
	`127`	`+ };`
	`128`	`+ classifications.Add(priorClassification);`
`127`	`129`	`}`
`128`	`130`	`else`
`129`	`131`	`{`
`130`	`132`	`m_MultiLineComments.RemoveAt(i);`
`131`	`133`	`ClassificationChanged?.Invoke(this, new ClassificationChangedEventArgs(multiSpan));`
`132`		`- continue;`
`133`	`134`	`}`
`134`	`135`	`}`
`135`	`136`
`@@ -157,10 +158,11 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)`
`157`	`158`	`span.GetText().Length - match.Index);`
`158`	`159`	`SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);`
`159`	`160`
`160`		`- var prioSpan = new PrioritiesClassificationSpan();`
`161`		`- prioSpan.Span = new ClassificationSpan(snapshot, m_Type);`
`162`		`- prioSpan.Priority = 400;`
`163`		`- classifications.Add(prioSpan);`
	`161`	`+ var priorClassification = new PrioritiesClassificationSpan`
	`162`	`+ {`
	`163`	`+ Span = new ClassificationSpan(snapshot, m_Type), Priority = 400`
	`164`	`+ };`
	`165`	`+ classifications.Add(priorClassification);`
`164`	`166`	`}`
`165`	`167`	`return classifications;`
`166`	`168`	`}`
`@@ -184,12 +186,12 @@ private int IndexOfCommentStart(string code)`
`184`	`186`	`{`
`185`	`187`	`if (code.Contains("#cs"))`
`186`	`188`	`{`
`187`		`- return code.IndexOf("#cs");`
	`189`	`+ return code.IndexOf("#cs", StringComparison.Ordinal);`
`188`	`190`	`}`
`189`	`191`
`190`	`192`	`if (code.Contains("#comment-start"))`
`191`	`193`	`{`
`192`		`- return code.IndexOf("#comment-start");`
	`194`	`+ return code.IndexOf("#comment-start", StringComparison.Ordinal);`
`193`	`195`	`}`
`194`	`196`	`return -1;`
`195`	`197`	`}`
`@@ -198,12 +200,12 @@ private int IndexOfCommentEnd(string code)`
`198`	`200`	`{`
`199`	`201`	`if (code.Contains("#ce"))`
`200`	`202`	`{`
`201`		`- return code.IndexOf("#ce");`
	`203`	`+ return code.IndexOf("#ce", StringComparison.Ordinal);`
`202`	`204`	`}`
`203`	`205`
`204`	`206`	`if (code.Contains("#comment-end"))`
`205`	`207`	`{`
`206`		`- return code.IndexOf("#comment-end");`
	`208`	`+ return code.IndexOf("#comment-end", StringComparison.Ordinal);`
`207`	`209`	`}`
`208`	`210`	`return -1;`
`209`	`211`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ namespace AutoItSyntaxHighlight.Lexer`
`24`	`24`	`{`
`25`	`25`	`internal sealed class AutoItLexerFunctions : IAutoItLexer`
`26`	`26`	`{`
`27`		`- private Regex m_Regex;`
	`27`	`+ private readonly Regex m_Regex;`
`28`	`28`	`private readonly IClassificationType m_Type;`
`29`	`29`
`30`	`30`	`#pragma warning disable CS0067`
`@@ -58,9 +58,9 @@ public List<PrioritiesClassificationSpan> Parse(SnapshotSpan span)`
`58`	`58`	`Span spanWord = new Span(span.Start.Position + group.Index, group.Length);`
`59`	`59`	`SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);`
`60`	`60`
`61`		`- var prioSpan = new PrioritiesClassificationSpan();`
`62`		`- prioSpan.Span = new ClassificationSpan(snapshot, m_Type);`
`63`		`- classifications.Add(prioSpan);`
	`61`	`+ var priorClassification = new PrioritiesClassificationSpan();`
	`62`	`+ priorClassification.Span = new ClassificationSpan(snapshot, m_Type);`
	`63`	`+ classifications.Add(priorClassification);`
`64`	`64`	`}`
`65`	`65`	`return classifications;`
`66`	`66`	`}`