[GH-1] - reducing amount of constructor types calculation to minimum

src/NSubstitute.Analyzers/DiagnosticAnalyzers/ConstructorContext.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+
+namespace NSubstitute.Analyzers.DiagnosticAnalyzers
+{
+    public readonly struct ConstructorContext
+    {
+        public IList<IMethodSymbol> AccessibleConstructors { get; }
+
+        public IList<IMethodSymbol> PossibleConstructors { get; }
+
+        public IList<ITypeSymbol> InvocationParameters { get; }
+
+        public ITypeSymbol ConstructorType { get; }
+
+        public ConstructorContext(
+            ITypeSymbol constructorType,
+            IList<IMethodSymbol> accessibleConstructors,
+            IList<IMethodSymbol> possibleConstructors,
+            IList<ITypeSymbol> invocationParameters)
+        {
+            ConstructorType = constructorType;
+            InvocationParameters = invocationParameters;
+            AccessibleConstructors = accessibleConstructors;
+            PossibleConstructors = possibleConstructors;
+        }
+    }
+}

src/NSubstitute.Analyzers/DiagnosticAnalyzers/SubstituteAnalysis.cs

@@ -15,7 +15,34 @@ namespace NSubstitute.Analyzers.DiagnosticAnalyzers
     // TODO remove duplication
     public static class SubstituteAnalysis
     {
-        public static IList<TypeInfo> GetInvocationInfo(SubstituteAnalyzer.SubstituteContext substituteContext)
+        public static ConstructorContext CollectConstructorContext(SubstituteContext substituteContext, ITypeSymbol proxyTypeSymbol)
+        {
+            var accessibleConstructors = GetAccessibleConstructors(proxyTypeSymbol);
+            var invocationParameterTypes = GetInvocationInfo(substituteContext);
+            var possibleConstructors = invocationParameterTypes != null && accessibleConstructors != null
+                ? accessibleConstructors.Where(ctor => ctor.Parameters.Length == invocationParameterTypes.Count)
+                    .ToList().AsReadOnly()
+                : null;
+
+            return new ConstructorContext(
+                proxyTypeSymbol,
+                accessibleConstructors,
+                possibleConstructors,
+                invocationParameterTypes);
+        }
+
+        public static bool InternalsVisibleToProxyGenerator(ISymbol typeSymbol)
+        {
+            var internalsVisibleToAttribute = typeSymbol.ContainingAssembly.GetAttributes()
+                .FirstOrDefault(att =>
+                    att.AttributeClass.ToString() == MetadataNames.InternalsVisibleToAttributeFullTypeName);
+
+            return internalsVisibleToAttribute != null &&
+                   internalsVisibleToAttribute.ConstructorArguments.Any(arg =>
+                       arg.Value.ToString() == MetadataNames.CastleDynamicProxyGenAssembly2Name);
+        }
+
+        private static IList<ITypeSymbol> GetInvocationInfo(SubstituteContext substituteContext)
         {
             var infos = substituteContext.MethodSymbol.IsGenericMethod
                 ? GetGenericInvocationArgumentTypes(substituteContext)
@@ -24,7 +51,7 @@ public static IList<TypeInfo> GetInvocationInfo(SubstituteAnalyzer.SubstituteCon
             return infos;
         }
 
-        private static IList<TypeInfo> GetGenericInvocationArgumentTypes(SubstituteAnalyzer.SubstituteContext substituteContext)
+        private static IList<ITypeSymbol> GetGenericInvocationArgumentTypes(SubstituteContext substituteContext)
         {
             if (substituteContext.InvocationExpression.ArgumentList == null)
             {
@@ -35,7 +62,7 @@ private static IList<TypeInfo> GetGenericInvocationArgumentTypes(SubstituteAnaly
 
             if (arguments.Count == 0)
             {
-                return new List<TypeInfo>();
+                return new List<ITypeSymbol>();
             }
 
             var typeInfos = arguments.Select(arg =>
@@ -53,10 +80,10 @@ possibleParamsArgument.ConvertedType is IArrayTypeSymbol arrayTypeSymbol &&
                 return GetArgumentTypeInfo(substituteContext, arguments.First());
             }
 
-            return typeInfos;
+            return typeInfos.Select(type => type.Type).ToList();
         }
 
-        private static IList<TypeInfo> GetNonGenericInvocationArgumentTypes(SubstituteAnalyzer.SubstituteContext substituteContext)
+        private static IList<ITypeSymbol> GetNonGenericInvocationArgumentTypes(SubstituteContext substituteContext)
         {
             // Substitute.For(new [] { typeof(T) }, new object[] { 1, 2, 3}) // actual arguments reside in second arg
             var arrayArgument = substituteContext.InvocationExpression.ArgumentList?.Arguments.Skip(1).FirstOrDefault();
@@ -68,15 +95,15 @@ private static IList<TypeInfo> GetNonGenericInvocationArgumentTypes(SubstituteAn
             return GetArgumentTypeInfo(substituteContext, arrayArgument);
         }
 
-        private static IList<TypeInfo> GetArgumentTypeInfo(SubstituteAnalyzer.SubstituteContext substituteContext, ArgumentSyntax arrayArgument)
+        private static IList<ITypeSymbol> GetArgumentTypeInfo(SubstituteContext substituteContext, ArgumentSyntax arrayArgument)
         {
             var typeInfo = substituteContext.SyntaxNodeAnalysisContext.SemanticModel.GetTypeInfo(arrayArgument.DescendantNodes().First());
 
             if (typeInfo.ConvertedType != null &&
                 typeInfo.ConvertedType.TypeKind == TypeKind.Array &&
                 typeInfo.Type == null)
             {
-                return new List<TypeInfo>();
+                return new List<ITypeSymbol>();
             }
 
             // new object[] { }; // means we dont pass any arguments
@@ -89,13 +116,25 @@ private static IList<TypeInfo> GetArgumentTypeInfo(SubstituteAnalyzer.Substitute
 
             // new object[] { 1, 2, 3}); // means we pass arguments
             var types = parameterExpressionsFromArrayArgument
-                .Select(exp => GetTypeInfo(substituteContext, exp))
+                .Select(exp => GetTypeInfo(substituteContext, exp).Type)
                 .ToList();
 
             return types;
         }
 
-        private static TypeInfo GetTypeInfo(SubstituteAnalyzer.SubstituteContext substituteContext, SyntaxNode syntax)
+        private static IList<IMethodSymbol> GetAccessibleConstructors(ITypeSymbol genericArgument)
+        {
+            var internalsVisibleToProxy = InternalsVisibleToProxyGenerator(genericArgument);
+
+            return genericArgument.GetMembers().OfType<IMethodSymbol>().Where(symbol =>
+                symbol.MethodKind == MethodKind.Constructor &&
+                symbol.IsStatic == false &&
+                (symbol.DeclaredAccessibility == Accessibility.Protected ||
+                 symbol.DeclaredAccessibility == Accessibility.Public ||
+                 (internalsVisibleToProxy && symbol.DeclaredAccessibility == Accessibility.Internal))).ToList();
+        }
+
+        private static TypeInfo GetTypeInfo(SubstituteContext substituteContext, SyntaxNode syntax)
         {
             return substituteContext.SyntaxNodeAnalysisContext.SemanticModel.GetTypeInfo(syntax);
         }

src/NSubstitute.Analyzers/DiagnosticAnalyzers/SubstituteAnalyzer.cs

@@ -12,7 +12,6 @@
 #elif VISUAL_BASIC
 using Microsoft.CodeAnalysis.VisualBasic;
 using Microsoft.CodeAnalysis.VisualBasic.Syntax;
-
 #endif
 
 namespace NSubstitute.Analyzers.DiagnosticAnalyzers
@@ -98,20 +97,8 @@ private void AnalyzeSubstituteForMethod(SubstituteContext substituteContext)
                 return;
             }
 
-            if (AnalyzeConstructorAccessability(substituteContext, proxyType))
-            {
-                return;
-            }
-
-            if (AnalyzeConstructorParametersCount(substituteContext, proxyType))
-            {
-                return;
-            }
-
-            if (AnalyzeConstructorInvocation(substituteContext, proxyType))
-            {
-                return;
-            }
+            var constructorContext = CollectConstructorContext(substituteContext, proxyType);
+            AnalyzeConstructor(substituteContext, constructorContext);
         }
 
         private void AnalyzeSubstituteForPartsOf(SubstituteContext substituteContext)
@@ -138,17 +125,23 @@ private void AnalyzeSubstituteForPartsOf(SubstituteContext substituteContext)
                 return;
             }
 
-            if (AnalyzeConstructorAccessability(substituteContext, proxyType))
+            var constructorContext = CollectConstructorContext(substituteContext, proxyType);
+            AnalyzeConstructor(substituteContext, constructorContext);
+        }
+
+        private void AnalyzeConstructor(SubstituteContext substituteContext, ConstructorContext constructorContext)
+        {
+            if (AnalyzeConstructorAccessability(substituteContext, constructorContext))
             {
                 return;
             }
 
-            if (AnalyzeConstructorParametersCount(substituteContext, proxyType))
+            if (AnalyzeConstructorParametersCount(substituteContext, constructorContext))
             {
                 return;
             }
 
-            if (AnalyzeConstructorInvocation(substituteContext, proxyType))
+            if (AnalyzeConstructorInvocation(substituteContext, constructorContext))
             {
                 return;
             }
@@ -207,36 +200,10 @@ private ImmutableArray<ITypeSymbol> GetProxySymbols(SubstituteContext substitute
             return arrayParameters.Count == proxyTypes.Length ? proxyTypes : ImmutableArray<ITypeSymbol>.Empty;
         }
 
-        private bool AnalyzeConstructorInvocation(SubstituteContext substituteContext, ITypeSymbol typeSymbol)
-        {
-            if (typeSymbol.TypeKind != TypeKind.Class)
-            {
-                return false;
-            }
-
-            var possibleConstructors = GetPossibleConstructors(substituteContext, typeSymbol);
-            var invocationInfo = GetInvocationInfo(substituteContext);
-
-            if (invocationInfo != null && possibleConstructors.All(ctor =>
-                    SubstituteConstructorMatcher.MatchesInvocation(
-                        substituteContext.SyntaxNodeAnalysisContext.SemanticModel.Compilation, ctor, invocationInfo) ==
-                    false))
-            {
-                var diagnostic = Diagnostic.Create(
-                    DiagnosticDescriptors.SubstituteConstructorMismatch,
-                    substituteContext.InvocationExpression.GetLocation());
-
-                substituteContext.SyntaxNodeAnalysisContext.ReportDiagnostic(diagnostic);
-                return true;
-            }
-
-            return false;
-        }
-
-        private bool AnalyzeConstructorParametersCount(SubstituteContext substituteContext, ITypeSymbol typeSymbol)
+        private bool AnalyzeConstructorParametersCount(SubstituteContext substituteContext, ConstructorContext constructorContext)
         {
-            var invocationArgumentTypes = GetInvocationInfo(substituteContext)?.Count;
-            switch (typeSymbol.TypeKind)
+            var invocationArgumentTypes = constructorContext.InvocationParameters?.Count;
+            switch (constructorContext.ConstructorType.TypeKind)
             {
                 case TypeKind.Interface when invocationArgumentTypes > 0:
                     var diagnostic = Diagnostic.Create(
@@ -258,9 +225,7 @@ private bool AnalyzeConstructorParametersCount(SubstituteContext substituteConte
                     return false;
             }
 
-            var possibleConstructors = GetPossibleConstructors(substituteContext, typeSymbol);
-
-            if (possibleConstructors != null && possibleConstructors.Any() == false)
+            if (constructorContext.PossibleConstructors != null && constructorContext.PossibleConstructors.Any() == false)
             {
                 var diagnostic = Diagnostic.Create(
                     DiagnosticDescriptors.SubstituteForConstructorParametersMismatch,
@@ -273,15 +238,6 @@ private bool AnalyzeConstructorParametersCount(SubstituteContext substituteConte
             return false;
         }
 
-        private IEnumerable<IMethodSymbol> GetPossibleConstructors(SubstituteContext substituteContext, ITypeSymbol typeSymbol)
-        {
-            var count = GetInvocationInfo(substituteContext)?.Count;
-
-            return count.HasValue
-                ? GetAccessibleConstructors(typeSymbol).Where(ctor => ctor.Parameters.Length == count)
-                : null;
-        }
-
         private static bool AnalyzeTypeKind(SubstituteContext substituteContext, ITypeSymbol proxyType)
         {
             if (proxyType.TypeKind == TypeKind.Interface || proxyType.TypeKind == TypeKind.Delegate)
@@ -313,18 +269,20 @@ private bool AnalyzeTypeAccessability(SubstituteContext substituteContext, IType
             return false;
         }
 
-        private bool AnalyzeConstructorAccessability(SubstituteContext substituteContext, ITypeSymbol typeSymbol)
+        private bool AnalyzeConstructorInvocation(SubstituteContext substituteContext, ConstructorContext constructorContext)
         {
-            if (typeSymbol.TypeKind != TypeKind.Class)
+            if (constructorContext.ConstructorType.TypeKind != TypeKind.Class || constructorContext.InvocationParameters == null || constructorContext.PossibleConstructors == null)
             {
                 return false;
             }
 
-            var accessibleConstructors = GetAccessibleConstructors(typeSymbol);
-            if (accessibleConstructors.Any() == false)
+            if (constructorContext.PossibleConstructors.All(ctor =>
+                    SubstituteConstructorMatcher.MatchesInvocation(
+                        substituteContext.SyntaxNodeAnalysisContext.SemanticModel.Compilation, ctor, constructorContext.InvocationParameters) ==
+                    false))
             {
                 var diagnostic = Diagnostic.Create(
-                    DiagnosticDescriptors.SubstituteForWithoutAccessibleConstructor,
+                    DiagnosticDescriptors.SubstituteConstructorMismatch,
                     substituteContext.InvocationExpression.GetLocation());
 
                 substituteContext.SyntaxNodeAnalysisContext.ReportDiagnostic(diagnostic);
@@ -334,27 +292,19 @@ private bool AnalyzeConstructorAccessability(SubstituteContext substituteContext
             return false;
         }
 
-        private bool InternalsVisibleToProxyGenerator(ISymbol typeSymbol)
+        private bool AnalyzeConstructorAccessability(SubstituteContext substituteContext, ConstructorContext constructorContext)
         {
-            var internalsVisibleToAttribute = typeSymbol.ContainingAssembly.GetAttributes()
-                .FirstOrDefault(att =>
-                    att.AttributeClass.ToString() == MetadataNames.InternalsVisibleToAttributeFullTypeName);
+            if (constructorContext.ConstructorType.TypeKind == TypeKind.Class && constructorContext.AccessibleConstructors != null && constructorContext.AccessibleConstructors.Any() == false)
+            {
+                var diagnostic = Diagnostic.Create(
+                    DiagnosticDescriptors.SubstituteForWithoutAccessibleConstructor,
+                    substituteContext.InvocationExpression.GetLocation());
 
-            return internalsVisibleToAttribute != null &&
-                   internalsVisibleToAttribute.ConstructorArguments.Any(arg =>
-                       arg.Value.ToString() == MetadataNames.CastleDynamicProxyGenAssembly2Name);
-        }
+                substituteContext.SyntaxNodeAnalysisContext.ReportDiagnostic(diagnostic);
+                return true;
+            }
 
-        private IEnumerable<IMethodSymbol> GetAccessibleConstructors(ITypeSymbol genericArgument)
-        {
-            var internalsVisibleToProxy = InternalsVisibleToProxyGenerator(genericArgument);
-
-            return genericArgument.GetMembers().OfType<IMethodSymbol>().Where(symbol =>
-                symbol.MethodKind == MethodKind.Constructor &&
-                symbol.IsStatic == false &&
-                (symbol.DeclaredAccessibility == Accessibility.Protected ||
-                 symbol.DeclaredAccessibility == Accessibility.Public ||
-                 (internalsVisibleToProxy && symbol.DeclaredAccessibility == Accessibility.Internal)));
+            return false;
         }
 
         private static bool IsSubstituteMethod(SyntaxNodeAnalysisContext syntaxNodeContext, SyntaxNode syntax, string memberName)
@@ -369,21 +319,5 @@ private static bool IsSubstituteMethod(SyntaxNodeAnalysisContext syntaxNodeConte
             return symbol.Symbol?.ContainingAssembly?.Name.Equals(MetadataNames.NSubstituteAssemblyName, StringComparison.Ordinal) == true &&
                    symbol.Symbol?.ContainingType?.ToString().Equals(MetadataNames.NSubstituteSubstituteFullTypeName, StringComparison.Ordinal) == true;
         }
-
-        public readonly struct SubstituteContext
-        {
-            public SyntaxNodeAnalysisContext SyntaxNodeAnalysisContext { get; }
-
-            public InvocationExpressionSyntax InvocationExpression { get; }
-
-            public IMethodSymbol MethodSymbol { get; }
-
-            public SubstituteContext(SyntaxNodeAnalysisContext syntaxNodeAnalysisContext, InvocationExpressionSyntax invocationExpression, IMethodSymbol methodSymbol)
-            {
-                SyntaxNodeAnalysisContext = syntaxNodeAnalysisContext;
-                InvocationExpression = invocationExpression;
-                MethodSymbol = methodSymbol;
-            }
-        }
     }
 }

src/NSubstitute.Analyzers/DiagnosticAnalyzers/SubstituteConstructorMatcher.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 #if CSHARP
@@ -21,14 +22,14 @@ static SubstituteConstructorMatcher()
             IntegerTypes = ((SpecialType[])Enum.GetValues(typeof(SpecialType))).Where(type => (int)type >= 11 && (int)type <= 16).ToArray();
         }
 
-        public static bool MatchesInvocation(Compilation compilation, IMethodSymbol methodSymbol, IList<TypeInfo> argumentTypes)
+        public static bool MatchesInvocation(Compilation compilation, IMethodSymbol methodSymbol, IList<ITypeSymbol> invocationParameters)
         {
-            if (methodSymbol.Parameters.Length != argumentTypes.Count)
+            if (methodSymbol.Parameters.Length != invocationParameters.Count)
             {
                 return false;
             }
 
-            return methodSymbol.Parameters.Length == 0 || methodSymbol.Parameters.Where((symbol, index) => IsConvertible(compilation, argumentTypes[index].Type, symbol.Type)).Any();
+            return methodSymbol.Parameters.Length == 0 || methodSymbol.Parameters.Where((symbol, index) => IsConvertible(compilation, invocationParameters[index], symbol.Type)).Any();
         }
 
         private static bool IsConvertible(Compilation compilation, ITypeSymbol source, ITypeSymbol destination)