File ConstructorArgumentsShouldMatchAnalyzer.cs has 321 lines of code (exceeds 250 allowed). Consider refactoring.

Open

using System.Diagnostics.CodeAnalysis;

namespace Moq.Analyzers;

/// <summary>

Method AnyConstructorsFound has a Cognitive Complexity of 39 (exceeds 20 allowed). Consider refactoring.

Open

    [SuppressMessage("Design", "MA0051:Method is too long", Justification = "This should be refactored; suppressing for now to enable TreatWarningsAsErrors in CI.")]
    private static bool AnyConstructorsFound(
        IMethodSymbol[] constructors,
        ArgumentSyntax[] arguments,
        SyntaxNodeAnalysisContext context)

• Read up
  Read up

Method AnyConstructorsFound has 61 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    [SuppressMessage("Design", "MA0051:Method is too long", Justification = "This should be refactored; suppressing for now to enable TreatWarningsAsErrors in CI.")]
    private static bool AnyConstructorsFound(
        IMethodSymbol[] constructors,
        ArgumentSyntax[] arguments,
        SyntaxNodeAnalysisContext context)

Method Analyze has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    [SuppressMessage("Design", "MA0051:Method is too long", Justification = "Should be fixed. Ignoring for now to avoid additional churn as part of larger refactor.")]
    private static void Analyze(SyntaxNodeAnalysisContext context)
    {
        InvocationExpressionSyntax setupInvocation = (InvocationExpressionSyntax)context.Node;

Method GetAllMatchingSymbols has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static List<T> GetAllMatchingSymbols<T>(this SemanticModel semanticModel, ExpressionSyntax expression)
        where T : class
    {
        List<T> matchingSymbols = new();

Method Analyze has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static void Analyze(SyntaxNodeAnalysisContext context)
    {
        // Check Moq version and skip analysis if the version is 4.16.0 or later
        AssemblyIdentity? moqAssembly = context.Compilation.ReferencedAssemblyNames.FirstOrDefault(a => a.Name.Equals("Moq", StringComparison.OrdinalIgnoreCase));

Method AnalyzeInvocation has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static void AnalyzeInvocation(
        SyntaxNodeAnalysisContext context,
        MoqKnownSymbols knownSymbols,
        InvocationExpressionSyntax invocationExpressionSyntax)
    {

Method FixCallbackSignatureAsync has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static async Task<Document> FixCallbackSignatureAsync(SyntaxNode root, Document document, ParameterListSyntax? oldParameters, CancellationToken cancellationToken)
    {
        SemanticModel? semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

        if (semanticModel is null)

Method RegisterCompilationStartAction has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static void RegisterCompilationStartAction(CompilationStartAnalysisContext context)
    {
        MoqKnownSymbols knownSymbols = new(context.Compilation);

        // Ensure Moq is referenced in the compilation

Method Analyze has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static void Analyze(SyntaxNodeAnalysisContext context)
    {
        ObjectCreationExpressionSyntax objectCreation = (ObjectCreationExpressionSyntax)context.Node;

        // TODO Think how to make this piece more elegant while fast

Method AnalyzeNewObject has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static void AnalyzeNewObject(OperationAnalysisContext context, ImmutableArray<INamedTypeSymbol> mockTypes, INamedTypeSymbol mockBehaviorSymbol)
    {
        if (context.Operation is not IObjectCreationOperation creationOperation)
        {
            return;

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    private static void VerifyDelegateMockAttempt(
    SyntaxNodeAnalysisContext context,
    ArgumentListSyntax? argumentList,
    ArgumentSyntax[] arguments)
    {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    private static void VerifyInterfaceMockAttempt(
        SyntaxNodeAnalysisContext context,
        ArgumentListSyntax? argumentList,
        ArgumentSyntax[] arguments)
    {

• Read up
  Read up

Method CreateDiagnostic has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

        this Location location,
        DiagnosticDescriptor rule,
        IEnumerable<Location>? additionalLocations,
        ImmutableDictionary<string, string?>? properties,
        params object?[]? messageArgs)

Method CreateDiagnostic has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

        this SyntaxNode node,
        DiagnosticDescriptor rule,
        IEnumerable<Location>? additionalLocations,
        ImmutableDictionary<string, string?>? properties,
        params object?[]? messageArgs) => node

Method CreateDiagnostic has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

        this IOperation operation,
        DiagnosticDescriptor rule,
        IEnumerable<Location>? additionalLocations,
        ImmutableDictionary<string, string?>? properties,
        params object?[]? messageArgs) => operation.Syntax.CreateDiagnostic(rule, additionalLocations, properties, messageArgs);

Consider simplifying this complex logical expression.

Open

            if ((arguments.Length < fixedParametersCount
                 || (!hasParams && arguments.Length > fixedParametersCount)
                 || (!hasParams && arguments.Length != fixedParametersCount))
                && requiredParameters != arguments.Length)
            {

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        foreach (IArgumentOperation argument in invocationOperation.Arguments)
        {
            if (argument.Value is IFieldReferenceOperation fieldReferenceOperation)
            {
                ISymbol field = fieldReferenceOperation.Member;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        foreach (IArgumentOperation argument in creationOperation.Arguments)
        {
            if (argument.Value is IFieldReferenceOperation fieldReferenceOperation)
            {
                ISymbol field = fieldReferenceOperation.Member;

• Read up
  Read up

Method CreateDiagnostic has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

        this SyntaxNode node,
        DiagnosticDescriptor rule,
        ImmutableDictionary<string, string?>? properties,
        params object?[]? messageArgs) => node.CreateDiagnostic(rule, additionalLocations: null, properties, messageArgs);