private static ParameterSyntax DecorateWithQualifiers(this ParameterSyntax @this,
                                                              ITypeSymbol parameterType, IParameterSymbol parameterSymbol, string returnType)
        {
            var parameterTypeKind = parameterType.TypeKind;

            switch (parameterTypeKind)
            {
            case TypeKind.Unknown:
            case TypeKind.Class:
            case TypeKind.Delegate:
            case TypeKind.Dynamic:
            case TypeKind.Enum:
            case TypeKind.Error:
            case TypeKind.Interface:
            case TypeKind.Module:
            case TypeKind.Struct:
            case TypeKind.TypeParameter:
            case TypeKind.Submission:
                @this = @this.WithType(IdentifierName(returnType.ToIdentifier()));
                break;

            case TypeKind.Array:
                var arrayTypeSymbol = (IArrayTypeSymbol)parameterType;
                var elementType     = arrayTypeSymbol.ElementType.SimplifyTypeName();
                if (parameterSymbol.IsParams)
                {
                    @this = @this.DecorateWithArray(elementType);
                }
                else
                {
                    var rank = arrayTypeSymbol.Rank;
                    if (rank >= 2)
                    {
                        var rankTokens = GetRankTokens(rank);
                        @this = @this.WithType(
                            ArrayType(
                                IdentifierName(elementType)
                                )
                            .WithRankSpecifiers(
                                SingletonList(
                                    ArrayRankSpecifier(
                                        SeparatedList <ExpressionSyntax>(
                                            rankTokens
                                            )
                                        )
                                    .WithCloseBracketToken(
                                        SyntaxKind.CloseBracketToken.BuildToken(Array.Empty <SyntaxTrivia>(),
                                                                                new[] { Space }))
                                    )
                                )
                            );
                    }
                    else
                    {
                        @this = @this.DecorateWithArray(elementType);
                    }
                }

                break;

            case TypeKind.Pointer:
                var pointerTypeSymbol = (IPointerTypeSymbol)parameterType;
                var pointedType       = pointerTypeSymbol.PointedAtType.SimplifyTypeName();
                @this = @this.WithType(
                    PointerType(
                        IdentifierName(Identifier(pointedType))
                        )
                    .WithAsteriskToken(SyntaxKind.AsteriskToken.BuildToken(Array.Empty <SyntaxTrivia>(), new[] { Space }))
                    );
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(parameterTypeKind));
            }

            return(@this);
        }