private static IDisposable WriteMethodDeclarationNoScope()

in src/AutoRest.CSharp/Common/Generation/Writers/CodeWriterExtensions.cs [150:273]
108 lines of code
20 McCabe index (conditional complexity)

        private static IDisposable WriteMethodDeclarationNoScope(this CodeWriter writer, MethodSignatureBase methodBase, params string[] disabledWarnings)
        {
            if (methodBase.Attributes is { } attributes)
            {
                foreach (var attribute in attributes)
                {
                    if (attribute.Arguments.Any())
                    {
                        writer.Append($"[{attribute.Type}(");
                        foreach (var argument in attribute.Arguments)
                        {
                            argument.Write(writer);
                        }
                        writer.RemoveTrailingComma();
                        writer.LineRaw(")]");
                    }
                    else
                    {
                        writer.Line($"[{attribute.Type}]");
                    }
                }
            }

            foreach (var disabledWarning in disabledWarnings)
            {
                writer.Line($"#pragma warning disable {disabledWarning}");
            }

            writer
                .AppendRawIf("public ", methodBase.Modifiers.HasFlag(Public))
                .AppendRawIf("internal ", methodBase.Modifiers.HasFlag(Internal))
                .AppendRawIf("protected ", methodBase.Modifiers.HasFlag(Protected))
                .AppendRawIf("private ", methodBase.Modifiers.HasFlag(Private))
                .AppendRawIf("static ", methodBase.Modifiers.HasFlag(Static));

            if (methodBase is MethodSignature method)
            {
                writer
                    .AppendRawIf("virtual ", methodBase.Modifiers.HasFlag(Virtual))
                    .AppendRawIf("override ", methodBase.Modifiers.HasFlag(Override))
                    .AppendRawIf("new ", methodBase.Modifiers.HasFlag(New))
                    .AppendRawIf("async ", methodBase.Modifiers.HasFlag(Async));

                if (method.ReturnType != null)
                {
                    writer.Append($"{method.ReturnType} ");
                }
                else
                {
                    writer.AppendRaw("void ");
                }

                if (method.ExplicitInterface is not null)
                {
                    writer.Append($"{method.ExplicitInterface}.");
                }

                writer.Append($"{methodBase.Name}");

                if (method?.GenericArguments != null)
                {
                    writer.AppendRaw("<");
                    foreach (var argument in method.GenericArguments)
                    {
                        writer.Append($"{argument:D},");
                    }
                    writer.RemoveTrailingComma();
                    writer.AppendRaw(">");
                }
            }
            else
            {
                writer.Append($"{methodBase.Name}");
            }

            writer
                .AppendRaw("(")
                .AppendRawIf("this ", methodBase.Modifiers.HasFlag(Extension));

            var outerScope = writer.AmbientScope();

            foreach (var parameter in methodBase.Parameters)
            {
                writer.WriteParameter(parameter);
            }

            writer.RemoveTrailingComma();
            writer.Append($")");

            if (methodBase is MethodSignature { GenericParameterConstraints: { } constraints })
            {
                writer.Line();
                foreach (var constraint in constraints)
                {
                    constraint.Write(writer);
                    writer.AppendRaw(" ");
                }
            }

            if (methodBase is ConstructorSignature { Initializer: { } } constructor)
            {
                var (isBase, arguments) = constructor.Initializer;

                if (!isBase || arguments.Any())
                {
                    writer.AppendRaw(isBase ? ": base(" : ": this(");
                    foreach (var argument in arguments)
                    {
                        argument.Write(writer);
                        writer.AppendRaw(", ");
                    }
                    writer.RemoveTrailingComma();
                    writer.AppendRaw(")");
                }
            }

            foreach (var disabledWarning in disabledWarnings)
            {
                writer.Line();
                writer.Append($"#pragma warning restore {disabledWarning}");
            }

            return outerScope;
        }