Remove Regex from analyzers (#81)

Replace using a `Regex` on string-ified type names with the proper
Roslyn API (usually Identifier.Name) and do some 'straightening' of the
code using early-returns and pattern matching to reduce the
triangle-ness.

This is effectively a rewrite of
`AsShouldBeUsedOnlyForInterfaceAnalyzer`. There's a smaller refactor for
`CallbackSignatureShouldMatchMockedMethod*` as that code needs to be
shared between the analyzer and the code fix provider (will be handled
later)

This refactor has a few benefits:

1. It addresses the bug mentioned in #58 (testing with a newer version
is coming in another PR to keep code reviewable)
2. It improves performance a good amount using very basic Visual Studio
tracing (e.g. ~20 fewer string allocations and saves 30% [20 ms] on a
single call to Analyzer.Analyze())
3. It plumbs the `CancellationToken` into more places to be a good IDE
citizen

This PR also starts to break apart the monolithic `Helpers` class into
smaller components. In order to support the `.TryXXX` pattern I needed
to bring in a polyfill for `[NotNullWhen]` for nullability analysis. I'm
using PolySharp because, in addition to being the most popular polyfill,
it uses a source generator to add polyfills to the current assembly,
which avoid assembly loading overhead and the hassle of adding
dependencies to the analyzer.

Directory.Packages.props

@@ -3,6 +3,7 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
   </PropertyGroup>
+  <Import Project="build/targets/compiler/Packages.props" />
   <Import Project="build/targets/reproducible/Packages.props" />
   <Import Project="build/targets/tests/Packages.props" />
   <Import Project="build/targets/codeanalysis/Packages.props" />

Source/Moq.Analyzers/AsShouldBeUsedOnlyForInterfaceAnalyzer.cs

@@ -3,6 +3,8 @@ namespace Moq.Analyzers;
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class AsShouldBeUsedOnlyForInterfaceAnalyzer : DiagnosticAnalyzer
 {
+    private static readonly MoqMethodDescriptorBase MoqAsMethodDescriptor = new MoqAsMethodDescriptor();
+
     private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
         Diagnostics.AsShouldBeUsedOnlyForInterfaceId,
         Diagnostics.AsShouldBeUsedOnlyForInterfaceTitle,
@@ -22,20 +24,37 @@ public override void Initialize(AnalysisContext context)
 
     private static void Analyze(SyntaxNodeAnalysisContext context)
     {
-        InvocationExpressionSyntax? asInvocation = (InvocationExpressionSyntax)context.Node;
+        if (context.Node is not InvocationExpressionSyntax invocationExpression)
+        {
+            return;
+        }
+
+        if (invocationExpression.Expression is not MemberAccessExpressionSyntax memberAccessSyntax)
+        {
+            return;
+        }
+
+        if (!MoqAsMethodDescriptor.IsMatch(context.SemanticModel, memberAccessSyntax, context.CancellationToken))
+        {
+            return;
+        }
+
+        if (!memberAccessSyntax.Name.TryGetGenericArguments(out SeparatedSyntaxList<TypeSyntax> typeArguments))
+        {
+            return;
+        }
+
+        if (typeArguments.Count != 1)
+        {
+            return;
+        }
+
+        TypeSyntax typeArgument = typeArguments[0];
+        SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(typeArgument, context.CancellationToken);
 
-        if (asInvocation.Expression is MemberAccessExpressionSyntax memberAccessExpression
-            && Helpers.IsMoqAsMethod(context.SemanticModel, memberAccessExpression)
-            && memberAccessExpression.Name is GenericNameSyntax genericName
-            && genericName.TypeArgumentList.Arguments.Count == 1)
+        if (symbolInfo.Symbol is ITypeSymbol { TypeKind: not TypeKind.Interface })
         {
-            TypeSyntax? typeArgument = genericName.TypeArgumentList.Arguments[0];
-            SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(typeArgument, context.CancellationToken);
-            if (symbolInfo.Symbol is ITypeSymbol typeSymbol && typeSymbol.TypeKind != TypeKind.Interface)
-            {
-                Diagnostic? diagnostic = Diagnostic.Create(Rule, typeArgument.GetLocation());
-                context.ReportDiagnostic(diagnostic);
-            }
+            context.ReportDiagnostic(Diagnostic.Create(Rule, typeArgument.GetLocation()));
         }
     }
 }

Source/Moq.Analyzers/CallbackSignatureShouldMatchMockedMethodAnalyzer.cs

@@ -43,7 +43,7 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
         SeparatedSyntaxList<ParameterSyntax> lambdaParameters = callbackLambda.ParameterList.Parameters;
         if (lambdaParameters.Count == 0) return;
 
-        InvocationExpressionSyntax? setupInvocation = Helpers.FindSetupMethodFromCallbackInvocation(context.SemanticModel, callbackOrReturnsInvocation);
+        InvocationExpressionSyntax? setupInvocation = Helpers.FindSetupMethodFromCallbackInvocation(context.SemanticModel, callbackOrReturnsInvocation, context.CancellationToken);
         InvocationExpressionSyntax? mockedMethodInvocation = Helpers.FindMockedMethodInvocationFromSetupMethod(setupInvocation);
         if (mockedMethodInvocation == null) return;
 

Source/Moq.Analyzers/CallbackSignatureShouldMatchMockedMethodCodeFix.cs

@@ -64,7 +64,7 @@ private async Task<Document> FixCallbackSignatureAsync(SyntaxNode root, Document
             return document;
         }
 
-        InvocationExpressionSyntax? setupMethodInvocation = Helpers.FindSetupMethodFromCallbackInvocation(semanticModel, callbackInvocation);
+        InvocationExpressionSyntax? setupMethodInvocation = Helpers.FindSetupMethodFromCallbackInvocation(semanticModel, callbackInvocation, cancellationToken);
         Debug.Assert(setupMethodInvocation != null, nameof(setupMethodInvocation) + " != null");
         IMethodSymbol[]? matchingMockedMethods = Helpers.GetAllMatchingMockedMethodSymbolsFromSetupMethodInvocation(semanticModel, setupMethodInvocation).ToArray();
 

Source/Moq.Analyzers/Helpers.cs

@@ -1,22 +1,14 @@
 using System.Diagnostics;
-using System.Text.RegularExpressions;
 
 namespace Moq.Analyzers;
 
 internal static class Helpers
 {
-    private static readonly MoqMethodDescriptor MoqSetupMethodDescriptor = new("Setup", new Regex("^Moq\\.Mock<.*>\\.Setup\\.*"));
+    private static readonly MoqMethodDescriptorBase MoqSetupMethodDescriptor = new MoqSetupMethodDescriptor();
 
-    private static readonly MoqMethodDescriptor MoqAsMethodDescriptor = new("As", new Regex("^Moq\\.Mock\\.As<\\.*"), isGeneric: true);
-
-    internal static bool IsMoqSetupMethod(SemanticModel semanticModel, MemberAccessExpressionSyntax method)
-    {
-        return MoqSetupMethodDescriptor.IsMoqMethod(semanticModel, method);
-    }
-
-    internal static bool IsMoqAsMethod(SemanticModel semanticModel, MemberAccessExpressionSyntax method)
+    internal static bool IsMoqSetupMethod(SemanticModel semanticModel, MemberAccessExpressionSyntax method, CancellationToken cancellationToken)
     {
-        return MoqAsMethodDescriptor.IsMoqMethod(semanticModel, method);
+        return MoqSetupMethodDescriptor.IsMatch(semanticModel, method, cancellationToken);
     }
 
     internal static bool IsCallbackOrReturnInvocation(SemanticModel semanticModel, InvocationExpressionSyntax callbackOrReturnsInvocation)
@@ -48,12 +40,12 @@ internal static bool IsCallbackOrReturnInvocation(SemanticModel semanticModel, I
         };
     }
 
-    internal static InvocationExpressionSyntax? FindSetupMethodFromCallbackInvocation(SemanticModel semanticModel, ExpressionSyntax expression)
+    internal static InvocationExpressionSyntax? FindSetupMethodFromCallbackInvocation(SemanticModel semanticModel, ExpressionSyntax expression, CancellationToken cancellationToken)
     {
         InvocationExpressionSyntax? invocation = expression as InvocationExpressionSyntax;
         if (invocation?.Expression is not MemberAccessExpressionSyntax method) return null;
-        if (IsMoqSetupMethod(semanticModel, method)) return invocation;
-        return FindSetupMethodFromCallbackInvocation(semanticModel, method.Expression);
+        if (IsMoqSetupMethod(semanticModel, method, cancellationToken)) return invocation;
+        return FindSetupMethodFromCallbackInvocation(semanticModel, method.Expression, cancellationToken);
     }
 
     internal static InvocationExpressionSyntax? FindMockedMethodInvocationFromSetupMethod(InvocationExpressionSyntax? setupInvocation)

Source/Moq.Analyzers/MoqAsMethodDescriptor.cs

@@ -0,0 +1,32 @@
+namespace Moq.Analyzers;
+
+/// <summary>
+/// A class that, given a <see cref="SemanticModel"/> and a <see cref="MemberAccessExpressionSyntax"/>, determines if
+/// it is a call to the Moq `Mock.As()` method.
+/// </summary>
+internal class MoqAsMethodDescriptor : MoqMethodDescriptorBase
+{
+    private const string MethodName = "As";
+
+    public override bool IsMatch(SemanticModel semanticModel, MemberAccessExpressionSyntax memberAccessSyntax, CancellationToken cancellationToken)
+    {
+        if (!IsFastMatch(memberAccessSyntax, MethodName.AsSpan()))
+        {
+            return false;
+        }
+
+        ISymbol? symbol = semanticModel.GetSymbolInfo(memberAccessSyntax, cancellationToken).Symbol;
+
+        if (symbol is not IMethodSymbol methodSymbol)
+        {
+            return false;
+        }
+
+        if (!IsContainedInMockType(methodSymbol))
+        {
+            return false;
+        }
+
+        return methodSymbol.Name.AsSpan().SequenceEqual(MethodName.AsSpan()) && methodSymbol.IsGenericMethod;
+    }
+}

Source/Moq.Analyzers/MoqMethodDescriptorBase.cs

@@ -0,0 +1,38 @@
+namespace Moq.Analyzers;
+
+/// <summary>
+/// A base that that provides common functionality for identifying if a given <see cref="SyntaxNode"/>
+/// is a specific Moq method.
+/// </summary>
+/// <remarks>
+/// Currently the <see cref="IsMatch(SemanticModel, MemberAccessExpressionSyntax, CancellationToken)"/> abstract method
+/// is specific to <see cref="MemberAccessExpressionSyntax"/> because that's the only type of syntax in use. I expect we'll need
+/// to loosen this restriction if we start using other types of syntax.
+/// </remarks>
+internal abstract class MoqMethodDescriptorBase
+{
+    private const string ContainingNamespace = "Moq";
+    private const string ContainingType = "Mock";
+
+    public abstract bool IsMatch(SemanticModel semanticModel, MemberAccessExpressionSyntax memberAccessSyntax, CancellationToken cancellationToken);
+
+    protected static bool IsFastMatch(MemberAccessExpressionSyntax memberAccessSyntax, ReadOnlySpan<char> methodName)
+    {
+        return memberAccessSyntax.Name.Identifier.Text.AsSpan().SequenceEqual(methodName);
+    }
+
+    protected static bool IsContainedInMockType(IMethodSymbol methodSymbol)
+    {
+        return IsInMoqNamespace(methodSymbol) && IsInMockType(methodSymbol);
+    }
+
+    private static bool IsInMoqNamespace(ISymbol symbol)
+    {
+        return symbol.ContainingNamespace.Name.AsSpan().SequenceEqual(ContainingNamespace.AsSpan());
+    }
+
+    private static bool IsInMockType(ISymbol symbol)
+    {
+        return symbol.ContainingType.Name.AsSpan().SequenceEqual(ContainingType.AsSpan());
+    }
+}

Source/Moq.Analyzers/MoqSetupMethodDescriptor.cs

@@ -0,0 +1,32 @@
+namespace Moq.Analyzers;
+
+/// <summary>
+/// A class that, given a <see cref="SemanticModel"/> and a <see cref="MemberAccessExpressionSyntax"/>, determines if
+/// it is a call to the Moq `Mock.Setup()` method.
+/// </summary>
+internal class MoqSetupMethodDescriptor : MoqMethodDescriptorBase
+{
+    private const string MethodName = "Setup";
+
+    public override bool IsMatch(SemanticModel semanticModel, MemberAccessExpressionSyntax memberAccessSyntax, CancellationToken cancellationToken)
+    {
+        if (!IsFastMatch(memberAccessSyntax, MethodName.AsSpan()))
+        {
+            return false;
+        }
+
+        ISymbol? symbol = semanticModel.GetSymbolInfo(memberAccessSyntax, cancellationToken).Symbol;
+
+        if (symbol is not IMethodSymbol methodSymbol)
+        {
+            return false;
+        }
+
+        if (!IsContainedInMockType(methodSymbol))
+        {
+            return false;
+        }
+
+        return methodSymbol.Name.AsSpan().SequenceEqual(MethodName.AsSpan()) && methodSymbol.IsGenericMethod;
+    }
+}

Source/Moq.Analyzers/SetupShouldBeUsedOnlyForOverridableMembersAnalyzer.cs

@@ -24,7 +24,7 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
     {
         InvocationExpressionSyntax? setupInvocation = (InvocationExpressionSyntax)context.Node;
 
-        if (setupInvocation.Expression is MemberAccessExpressionSyntax memberAccessExpression && Helpers.IsMoqSetupMethod(context.SemanticModel, memberAccessExpression))
+        if (setupInvocation.Expression is MemberAccessExpressionSyntax memberAccessExpression && Helpers.IsMoqSetupMethod(context.SemanticModel, memberAccessExpression, context.CancellationToken))
         {
             ExpressionSyntax? mockedMemberExpression = Helpers.FindMockedMemberExpressionFromSetupMethod(setupInvocation);
             if (mockedMemberExpression == null)

Source/Moq.Analyzers/SetupShouldNotIncludeAsyncResultAnalyzer.cs

@@ -24,7 +24,7 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
     {
         InvocationExpressionSyntax? setupInvocation = (InvocationExpressionSyntax)context.Node;
 
-        if (setupInvocation.Expression is MemberAccessExpressionSyntax memberAccessExpression && Helpers.IsMoqSetupMethod(context.SemanticModel, memberAccessExpression))
+        if (setupInvocation.Expression is MemberAccessExpressionSyntax memberAccessExpression && Helpers.IsMoqSetupMethod(context.SemanticModel, memberAccessExpression, context.CancellationToken))
         {
             ExpressionSyntax? mockedMemberExpression = Helpers.FindMockedMemberExpressionFromSetupMethod(setupInvocation);
             if (mockedMemberExpression == null)

Source/Moq.Analyzers/SyntaxExtensions.cs

@@ -0,0 +1,33 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Moq.Analyzers;
+
+/// <summary>
+/// Extensions methods for <see cref="SyntaxNode"/>s.
+/// </summary>
+internal static class SyntaxExtensions
+{
+    /// <summary>
+    /// Tries to get the generic arguments of a given <see cref="NameSyntax"/>.
+    /// </summary>
+    /// <param name="syntax">The syntax to inspect.</param>
+    /// <param name="typeArguments">The collection of <see cref="TypeSyntax"/> elements on the <paramref name="syntax"/>.</param>
+    /// <returns><see langword="true"/> if <paramref name="syntax"/> has generic / type parameters; <see langword="false"/> otherwise.</returns>
+    /// <example>
+    /// x.As&lt;ISampleInterface&gt;() returns <see langword="true"/> and <paramref name="typeArguments"/> will contain <c>ISampleInterface</c>.
+    /// </example>
+    /// <example>
+    /// x.As() returns <see langword="false"/> and <paramref name="typeArguments"/> will be empty.
+    /// </example>
+    public static bool TryGetGenericArguments(this NameSyntax syntax, [NotNullWhen(true)] out SeparatedSyntaxList<TypeSyntax> typeArguments)
+    {
+        if (syntax is GenericNameSyntax genericName)
+        {
+            typeArguments = genericName.TypeArgumentList.Arguments;
+            return true;
+        }
+
+        typeArguments = default;
+        return false;
+    }
+}

build/targets/compiler/Compiler.props

@@ -4,4 +4,11 @@
     <LangVersion>12.0</LangVersion>
     <Nullable>enable</Nullable>
   </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="PolySharp">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
 </Project>

build/targets/compiler/Packages.props

@@ -0,0 +1,5 @@
+<Project>
+  <ItemGroup>
+    <PackageVersion Include="PolySharp" Version="1.14.1" />
+</ItemGroup>
+</Project>