[GH-76] - convention test improvements, better WhenSubstituteCallFind…

…er implementation
nsubstitute · Mar 31, 2019 · 43d48ed · 43d48ed
1 parent 7d508b5
commit 43d48ed
Show file tree

Hide file tree

Showing 7 changed files with 40 additions and 38 deletions.
diff --git a/src/NSubstitute.Analyzers.CSharp/DiagnosticAnalyzers/CallInfoDoAnalyzer.cs b/src/NSubstitute.Analyzers.CSharp/DiagnosticAnalyzers/CallInfoDoAnalyzer.cs
@@ -8,6 +8,7 @@
 
 namespace NSubstitute.Analyzers.CSharp.DiagnosticAnalyzers
 {
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
     internal class CallInfoDoAnalyzer : CallInfoAnalyzer
     {
         private readonly Lazy<WhenSubstituteCallFinder> _whenSubstituteCallFinderProxy = new Lazy<WhenSubstituteCallFinder>(() => new WhenSubstituteCallFinder());
@@ -34,16 +35,7 @@ protected override SyntaxNode GetSubstituteCall(SyntaxNodeAnalysisContext syntax
                 return null;
             }
 
-            if (syntaxNodeContext.SemanticModel.GetSymbolInfo(parentInvocationExpression).Symbol is IMethodSymbol parentInvocationSymbol)
-            {
-                var argumentExpression = parentInvocationSymbol.MethodKind == MethodKind.ReducedExtension
-                       ? parentInvocationExpression.ArgumentList.Arguments.First().Expression
-                       : parentInvocationExpression.ArgumentList.Arguments.Skip(1).First().Expression;
-
-                return WhenSubstituteCallFinder.Find(syntaxNodeContext, argumentExpression).FirstOrDefault();
-            }
-
-            return null;
+            return WhenSubstituteCallFinder.Find(syntaxNodeContext, parentInvocationExpression).FirstOrDefault();
         }
     }
 }
diff --git a/src/NSubstitute.Analyzers.CSharp/DiagnosticAnalyzers/NonSubstitutableMemberWhenAnalyzer.cs b/src/NSubstitute.Analyzers.CSharp/DiagnosticAnalyzers/NonSubstitutableMemberWhenAnalyzer.cs
@@ -25,9 +25,7 @@ public NonSubstitutableMemberWhenAnalyzer()
 
         protected override IEnumerable<SyntaxNode> GetExpressionsForAnalysys(SyntaxNodeAnalysisContext syntaxNodeAnalysisContext, IMethodSymbol methodSymbol, InvocationExpressionSyntax invocationExpressionSyntax)
         {
-            var argumentListArguments = invocationExpressionSyntax.ArgumentList.Arguments;
-            var argumentSyntax = methodSymbol.MethodKind == MethodKind.ReducedExtension ? argumentListArguments.First() : argumentListArguments.Skip(1).First();
-            return WhenSubstituteCallFinder.Find(syntaxNodeAnalysisContext, argumentSyntax.Expression);
+            return WhenSubstituteCallFinder.Find(syntaxNodeAnalysisContext, invocationExpressionSyntax, methodSymbol);
         }
     }
 }
diff --git a/src/NSubstitute.Analyzers.CSharp/DiagnosticAnalyzers/WhenSubstituteCallFinder.cs b/src/NSubstitute.Analyzers.CSharp/DiagnosticAnalyzers/WhenSubstituteCallFinder.cs
@@ -12,7 +12,21 @@ namespace NSubstitute.Analyzers.CSharp.DiagnosticAnalyzers
     /// </summary>
     internal class WhenSubstituteCallFinder
     {
-        public IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext, SyntaxNode argumentSyntax)
+        public IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext, InvocationExpressionSyntax whenInvocationExpression, ISymbol whenInvocationSymbol = null)
+        {
+            if ((whenInvocationSymbol ?? syntaxNodeContext.SemanticModel.GetSymbolInfo(whenInvocationExpression).Symbol) is IMethodSymbol parentInvocationSymbol)
+            {
+                var argumentExpression = parentInvocationSymbol.MethodKind == MethodKind.ReducedExtension
+                    ? whenInvocationExpression.ArgumentList.Arguments.First().Expression
+                    : whenInvocationExpression.ArgumentList.Arguments.Skip(1).First().Expression;
+
+                return Find(syntaxNodeContext, argumentExpression);
+            }
+
+            return null;
+        }
+
+        private IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext, SyntaxNode argumentSyntax)
         {
             SyntaxNode body = null;
             switch (argumentSyntax)

diff --git a/src/NSubstitute.Analyzers.VisualBasic/DiagnosticAnalyzers/CallInfoDoAnalyzer.cs b/src/NSubstitute.Analyzers.VisualBasic/DiagnosticAnalyzers/CallInfoDoAnalyzer.cs
@@ -8,6 +8,7 @@
 
 namespace NSubstitute.Analyzers.VisualBasic.DiagnosticAnalyzers
 {
+    [DiagnosticAnalyzer(LanguageNames.VisualBasic)]
     internal class CallInfoDoAnalyzer : CallInfoAnalyzer
     {
         private readonly Lazy<WhenSubstituteCallFinder> _whenSubstituteCallFinderProxy = new Lazy<WhenSubstituteCallFinder>(() => new WhenSubstituteCallFinder());
@@ -34,16 +35,7 @@ protected override SyntaxNode GetSubstituteCall(SyntaxNodeAnalysisContext syntax
                 return null;
             }
 
-            if (syntaxNodeContext.SemanticModel.GetSymbolInfo(parentInvocationExpression).Symbol is IMethodSymbol parentInvocationSymbol)
-            {
-                var argumentExpression = parentInvocationSymbol.MethodKind == MethodKind.ReducedExtension
-                       ? parentInvocationExpression.ArgumentList.Arguments.First().GetExpression()
-                       : parentInvocationExpression.ArgumentList.Arguments.Skip(1).First().GetExpression();
-
-                return WhenSubstituteCallFinder.Find(syntaxNodeContext, argumentExpression).FirstOrDefault();
-            }
-
-            return null;
+            return WhenSubstituteCallFinder.Find(syntaxNodeContext, parentInvocationExpression).FirstOrDefault();
         }
     }
 }
diff --git a/...ubstitute.Analyzers.VisualBasic/DiagnosticAnalyzers/NonSubstitutableMemberWhenAnalyzer.cs b/...ubstitute.Analyzers.VisualBasic/DiagnosticAnalyzers/NonSubstitutableMemberWhenAnalyzer.cs
@@ -25,9 +25,7 @@ public NonSubstitutableMemberWhenAnalyzer()
 
         protected override IEnumerable<SyntaxNode> GetExpressionsForAnalysys(SyntaxNodeAnalysisContext syntaxNodeAnalysisContext, IMethodSymbol methodSymbol, InvocationExpressionSyntax invocationExpressionSyntax)
         {
-            var argumentListArguments = invocationExpressionSyntax.ArgumentList.Arguments;
-            var argumentSyntax = methodSymbol.MethodKind == MethodKind.ReducedExtension ? argumentListArguments.First() : argumentListArguments.Skip(1).First();
-            return WhenSubstituteCallFinder.Find(syntaxNodeAnalysisContext, argumentSyntax.GetExpression());
+            return WhenSubstituteCallFinder.Find(syntaxNodeAnalysisContext, invocationExpressionSyntax, methodSymbol);
         }
     }
 }
diff --git a/src/NSubstitute.Analyzers.VisualBasic/DiagnosticAnalyzers/WhenSubstituteCallFinder.cs b/src/NSubstitute.Analyzers.VisualBasic/DiagnosticAnalyzers/WhenSubstituteCallFinder.cs
@@ -9,7 +9,21 @@ namespace NSubstitute.Analyzers.VisualBasic.DiagnosticAnalyzers
 {
     internal class WhenSubstituteCallFinder
     {
-        public IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext, SyntaxNode argumentSyntax)
+        public IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext, InvocationExpressionSyntax whenInvocationExpression, ISymbol whenInvocationSymbol = null)
+        {
+            if ((whenInvocationSymbol ?? syntaxNodeContext.SemanticModel.GetSymbolInfo(whenInvocationExpression).Symbol) is IMethodSymbol parentInvocationSymbol)
+            {
+                var argumentExpression = parentInvocationSymbol.MethodKind == MethodKind.ReducedExtension
+                    ? whenInvocationExpression.ArgumentList.Arguments.First().GetExpression()
+                    : whenInvocationExpression.ArgumentList.Arguments.Skip(1).First().GetExpression();
+
+                return Find(syntaxNodeContext, argumentExpression);
+            }
+
+            return null;
+        }
+
+        private IEnumerable<SyntaxNode> Find(SyntaxNodeAnalysisContext syntaxNodeContext, SyntaxNode argumentSyntax)
         {
             SyntaxNode body = null;
             switch (argumentSyntax)

diff --git a/tests/NSubstitute.Analyzers.Tests.Shared/Fixtures/AnalyzersConventionFixture.cs b/tests/NSubstitute.Analyzers.Tests.Shared/Fixtures/AnalyzersConventionFixture.cs
@@ -24,8 +24,8 @@ public void AssertExportCodeFixProviderAttributeUsageFromAssemblyContaining(Type
         {
             var types = GetTypesAssignableTo<CodeFixProvider>(type.Assembly).ToList();
 
-            types.Should().OnlyContain(innerType => innerType.GetCustomAttributes<ExportCodeFixProviderAttribute>(true).Count() == 1, "because each code fix provider should be marked with only one attribute ExportCodeFixProviderAttribute");
-            types.SelectMany(innerType => innerType.GetCustomAttributes<ExportCodeFixProviderAttribute>(true)).Should()
+            types.Should().OnlyContain(innerType => innerType.GetCustomAttributes<ExportCodeFixProviderAttribute>(false).Count() == 1, "because each code fix provider should be marked with only one attribute ExportCodeFixProviderAttribute");
+            types.SelectMany(innerType => innerType.GetCustomAttributes<ExportCodeFixProviderAttribute>(false)).Should()
                 .OnlyContain(
                     attr => attr.Languages.Length == 1 && attr.Languages.Count(lang => lang == expectedLanguage) == 1,
                     $"because each code fix provider should support only selected language ${expectedLanguage}");
@@ -35,19 +35,13 @@ public void AssertDiagnosticAnalyzerAttributeUsageFromAssemblyContaining(Type ty
         {
             var types = GetTypesAssignableTo<DiagnosticAnalyzer>(type.Assembly).ToList();
 
-            types.Should().OnlyContain(innerType => innerType.GetCustomAttributes<DiagnosticAnalyzerAttribute>(true).Count() == 1, "because each analyzer should be marked with only one attribute DiagnosticAnalyzerAttribute");
-            types.SelectMany(innerType => innerType.GetCustomAttributes<DiagnosticAnalyzerAttribute>(true)).Should()
+            types.Should().OnlyContain(innerType => innerType.GetCustomAttributes<DiagnosticAnalyzerAttribute>(false).Count() == 1, "because each analyzer should be marked with only one attribute DiagnosticAnalyzerAttribute");
+            types.SelectMany(innerType => innerType.GetCustomAttributes<DiagnosticAnalyzerAttribute>(false)).Should()
                 .OnlyContain(
                     attr => attr.Languages.Length == 1 && attr.Languages.Count(lang => lang == expectedLanguage) == 1,
                     $"because each analyzer should support only selected language ${expectedLanguage}");
         }
 
-        private static T CreateInstance<T>(Type analyzer)
-        {
-            var args = analyzer.GetConstructors().First().GetParameters().Select(parameter => Substitute.For(new[] { parameter.ParameterType }, null)).ToArray();
-            return (T)Activator.CreateInstance(analyzer, args);
-        }
-
         private IEnumerable<Type> GetTypesAssignableTo<T>(Assembly assembly)
         {
             var type = typeof(T);