Pass data through constructor.

src/Features/CSharp/Portable/ValidateRegexString/CSharpValidateRegexStringDiagnosticAnalyzer.cs

@@ -2,8 +2,6 @@
 
 using Microsoft.CodeAnalysis.CSharp.RegularExpressions;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.LanguageServices;
-using Microsoft.CodeAnalysis.RegularExpressions;
 using Microsoft.CodeAnalysis.ValidateRegexString;
 
 namespace Microsoft.CodeAnalysis.CSharp.ValidateRegexString
@@ -12,17 +10,9 @@ namespace Microsoft.CodeAnalysis.CSharp.ValidateRegexString
     internal class CSharpValidateRegexStringDiagnosticAnalyzer : AbstractValidateRegexStringDiagnosticAnalyzer
     {
         public CSharpValidateRegexStringDiagnosticAnalyzer() 
-            : base((int)SyntaxKind.StringLiteralToken)
+            : base((int)SyntaxKind.StringLiteralToken, 
+                  CSharpSyntaxFactsService.Instance, CSharpSemanticFactsService.Instance, CSharpVirtualCharService.Instance)
         {
         }
-
-        protected override ISyntaxFactsService GetSyntaxFactsService()
-            => CSharpSyntaxFactsService.Instance;
-
-        protected override ISemanticFactsService GetSemanticFactsService()
-            => CSharpSemanticFactsService.Instance;
-
-        protected override IVirtualCharService GetVirtualCharService()
-            => CSharpVirtualCharService.Instance;
     }
 }

src/Features/Core/Portable/ValidateRegexString/AbstractValidateRegexStringDiagnosticAnalyzer.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Text.RegularExpressions;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -12,12 +11,22 @@ namespace Microsoft.CodeAnalysis.ValidateRegexString
     internal abstract class AbstractValidateRegexStringDiagnosticAnalyzer : AbstractCodeStyleDiagnosticAnalyzer
     {
         private readonly int _stringLiteralKind;
+        private readonly ISyntaxFactsService _syntaxFacts;
+        private readonly ISemanticFactsService _semanticFacts;
+        private readonly IVirtualCharService _virtualCharService;
 
-        protected AbstractValidateRegexStringDiagnosticAnalyzer(int stringLiteralKind)
+        protected AbstractValidateRegexStringDiagnosticAnalyzer(
+            int stringLiteralKind,
+            ISyntaxFactsService syntaxFacts,
+            ISemanticFactsService semanticFacts,
+            IVirtualCharService virtualCharService)
             : base(IDEDiagnosticIds.RegexPatternDiagnosticId,
                    new LocalizableResourceString(nameof(FeaturesResources.Regex_issue_0), FeaturesResources.ResourceManager, typeof(FeaturesResources)))
         {
             _stringLiteralKind = stringLiteralKind;
+            _syntaxFacts = syntaxFacts;
+            _semanticFacts = semanticFacts;
+            _virtualCharService = virtualCharService;
         }
 
         public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
@@ -26,10 +35,6 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
         public override bool OpenFileOnly(Workspace workspace)
             => false;
 
-        protected abstract ISyntaxFactsService GetSyntaxFactsService();
-        protected abstract ISemanticFactsService GetSemanticFactsService();
-        protected abstract IVirtualCharService GetVirtualCharService();
-
         protected override void InitializeWorker(AnalysisContext context)
             => context.RegisterSemanticModelAction(AnalyzeSemanticModel);
 
@@ -51,15 +56,14 @@ private void AnalyzeSemanticModel(SemanticModelAnalysisContext context)
                 return;
             }
 
-            var detector = RegexPatternDetector.TryCreate(
-                semanticModel, GetSyntaxFactsService(), GetSemanticFactsService());
+            var detector = RegexPatternDetector.TryCreate(semanticModel, _syntaxFacts, _semanticFacts);
             if (detector == null)
             {
                 return;
             }
 
             var root = syntaxTree.GetRoot(cancellationToken);
-            Analyze(context, detector, GetVirtualCharService(), root, cancellationToken);
+            Analyze(context, detector, _virtualCharService, root, cancellationToken);
         }
 
         private void Analyze(

src/Features/VisualBasic/Portable/ValidateRegexString/VisualBasicValidateRegexStringDiagnosticAnalyzer.vb

 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports Microsoft.CodeAnalysis.VisualBasic.RegularExpressions
 Imports Microsoft.CodeAnalysis.Diagnostics
-Imports Microsoft.CodeAnalysis.LanguageServices
-Imports Microsoft.CodeAnalysis.RegularExpressions
 Imports Microsoft.CodeAnalysis.ValidateRegexString
+Imports Microsoft.CodeAnalysis.VisualBasic.RegularExpressions
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.ValidateRegexString
     <DiagnosticAnalyzer(LanguageNames.VisualBasic)>
@@ -12,19 +10,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ValidateRegexString
         Inherits AbstractValidateRegexStringDiagnosticAnalyzer
 
         Public Sub New()
-            MyBase.New(SyntaxKind.StringLiteralToken)
+            MyBase.New(SyntaxKind.StringLiteralToken,
+                       VisualBasicSyntaxFactsService.Instance,
+                       VisualBasicSemanticFactsService.Instance,
+                       VisualBasicVirtualCharService.Instance)
         End Sub
-
-        Protected Overrides Function GetSyntaxFactsService() As ISyntaxFactsService
-            Return VisualBasicSyntaxFactsService.Instance
-        End Function
-
-        Protected Overrides Function GetSemanticFactsService() As ISemanticFactsService
-            Return VisualBasicSemanticFactsService.Instance
-        End Function
-
-        Protected Overrides Function GetVirtualCharService() As IVirtualCharService
-            Return VisualBasicVirtualCharService.Instance
-        End Function
     End Class
 End Namespace