[GH-153] - using operation API for NonSubstitutableMemberWhenAnalyzer

nsubstitute · Dec 20, 2020 · 14377f4 · 14377f4
1 parent a4a1cb6
commit 14377f4
Show file tree

Hide file tree

Showing 3 changed files with 12 additions and 15 deletions.
diff --git a/...titute.Analyzers.Shared/DiagnosticAnalyzers/AbstractNonSubstitutableMemberWhenAnalyzer.cs b/...titute.Analyzers.Shared/DiagnosticAnalyzers/AbstractNonSubstitutableMemberWhenAnalyzer.cs
@@ -2,6 +2,7 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
 using NSubstitute.Analyzers.Shared.Extensions;
 
 namespace NSubstitute.Analyzers.Shared.DiagnosticAnalyzers
@@ -41,22 +42,17 @@ protected override void InitializeAnalyzer(AnalysisContext context)
 
         private void AnalyzeInvocation(SyntaxNodeAnalysisContext syntaxNodeContext)
         {
-            var invocationExpression = (TInvocationExpressionSyntax)syntaxNodeContext.Node;
-            var methodSymbolInfo = syntaxNodeContext.SemanticModel.GetSymbolInfo(invocationExpression);
-
-            if (methodSymbolInfo.Symbol == null || methodSymbolInfo.Symbol.Kind != SymbolKind.Method)
+            if (!(syntaxNodeContext.SemanticModel.GetOperation(syntaxNodeContext.Node) is IInvocationOperation invocationOperation))
             {
                 return;
             }
 
-            var methodSymbol = (IMethodSymbol)methodSymbolInfo.Symbol;
-
-            if (methodSymbol.IsWhenLikeMethod() == false)
+            if (invocationOperation.TargetMethod.IsWhenLikeMethod() == false)
             {
                 return;
             }
 
-            var expressionsForAnalysys = _substitutionNodeFinder.FindForWhenExpression(syntaxNodeContext, invocationExpression, methodSymbol);
+            var expressionsForAnalysys = _substitutionNodeFinder.FindForWhenExpression(syntaxNodeContext, invocationOperation);
             foreach (var analysedSyntax in expressionsForAnalysys)
             {
                 var symbolInfo = syntaxNodeContext.SemanticModel.GetSymbolInfo(analysedSyntax);

diff --git a/src/NSubstitute.Analyzers.Shared/DiagnosticAnalyzers/AbstractSubstitutionNodeFinder.cs b/src/NSubstitute.Analyzers.Shared/DiagnosticAnalyzers/AbstractSubstitutionNodeFinder.cs
@@ -28,13 +28,13 @@ public IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext,
             if (invocationExpressionSymbol.Name.Equals(MetadataNames.NSubstituteDoMethod, StringComparison.Ordinal))
             {
                 var parentInvocationExpression = GetParentInvocationExpression((TInvocationExpressionSyntax)invocationExpression);
-                return FindForWhenExpression(syntaxNodeContext, parentInvocationExpression);
+                return FindForWhenExpression(syntaxNodeContext, syntaxNodeContext.SemanticModel.GetOperation(parentInvocationExpression) as IInvocationOperation);
             }
 
             if (invocationExpressionSymbol.Name.Equals(MetadataNames.NSubstituteWhenMethod, StringComparison.Ordinal) ||
                 invocationExpressionSymbol.Name.Equals(MetadataNames.NSubstituteWhenForAnyArgsMethod, StringComparison.Ordinal))
             {
-                return FindForWhenExpression(syntaxNodeContext, (TInvocationExpressionSyntax)invocationExpression, invocationExpressionSymbol);
+                return FindForWhenExpression(syntaxNodeContext, invocationOperation, invocationExpressionSymbol);
             }
 
             if (invocationExpressionSymbol.Name.Equals(MetadataNames.NSubstituteAndDoesMethod, StringComparison.Ordinal))
@@ -48,22 +48,23 @@ public IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext,
             return standardSubstitution != null ? new[] { standardSubstitution } : Enumerable.Empty<SyntaxNode>();
         }
 
-        public IEnumerable<SyntaxNode> FindForWhenExpression(SyntaxNodeAnalysisContext syntaxNodeContext, TInvocationExpressionSyntax whenInvocationExpression, IMethodSymbol whenInvocationSymbol = null)
+        public IEnumerable<SyntaxNode> FindForWhenExpression(SyntaxNodeAnalysisContext syntaxNodeContext, IInvocationOperation invocationOperation, IMethodSymbol whenInvocationSymbol = null)
         {
-            if (whenInvocationExpression == null)
+            if (invocationOperation == null)
             {
                 yield break;
             }
 
-            whenInvocationSymbol = whenInvocationSymbol ?? syntaxNodeContext.SemanticModel.GetSymbolInfo(whenInvocationExpression).Symbol as IMethodSymbol;
+            var invocationExpression = invocationOperation.Syntax;
+            whenInvocationSymbol ??= syntaxNodeContext.SemanticModel.GetSymbolInfo(invocationExpression).Symbol as IMethodSymbol;
 
             if (whenInvocationSymbol == null)
             {
                 yield break;
             }
 
             var typeSymbol = whenInvocationSymbol.TypeArguments.FirstOrDefault() ?? whenInvocationSymbol.ReceiverType;
-            foreach (var syntaxNode in FindForWhenExpressionInternal(syntaxNodeContext, whenInvocationExpression, whenInvocationSymbol))
+            foreach (var syntaxNode in FindForWhenExpressionInternal(syntaxNodeContext, (TInvocationExpressionSyntax)invocationExpression, whenInvocationSymbol))
             {
                 var symbol = syntaxNodeContext.SemanticModel.GetSymbolInfo(syntaxNode).Symbol;
                 if (symbol != null && typeSymbol != null && ContainsSymbol(typeSymbol, symbol))

diff --git a/src/NSubstitute.Analyzers.Shared/DiagnosticAnalyzers/ISubstitutionNodeFinder.cs b/src/NSubstitute.Analyzers.Shared/DiagnosticAnalyzers/ISubstitutionNodeFinder.cs
@@ -9,7 +9,7 @@ internal interface ISubstitutionNodeFinder<in TInvocationExpressionSyntax> where
     {
         IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext, IInvocationOperation invocationOperation, IMethodSymbol invocationExpressionSymbol = null);
 
-        IEnumerable<SyntaxNode> FindForWhenExpression(SyntaxNodeAnalysisContext syntaxNodeContext, TInvocationExpressionSyntax whenInvocationExpression, IMethodSymbol whenInvocationSymbol = null);
+        IEnumerable<SyntaxNode> FindForWhenExpression(SyntaxNodeAnalysisContext syntaxNodeContext, IInvocationOperation invocationOperation, IMethodSymbol whenInvocationSymbol = null);
 
         IEnumerable<SyntaxNode> FindForReceivedInOrderExpression(SyntaxNodeAnalysisContext syntaxNodeContext, TInvocationExpressionSyntax receivedInOrderExpression, IMethodSymbol receivedInOrderInvocationSymbol = null);