private BlockSyntax UpdateMethodBody(BlockSyntax blockSyntax, TypeSyntax returnTypeSyntax, ParameterListSyntax parameterListSyntax)
        {
            if (blockSyntax != null)
            {
                //var specialType = _typeTranslation.FirstOrDefault(tt => ExtractRoslynSymbol(tt.ActualType).ToDisplayString() == returnTypeSyntax.ToFullString().Replace("global::", ""));
                var specialType = _typeTranslation.FirstOrDefault(tt => PrettyTypeName(tt.ActualType) == returnTypeSyntax.ToFullString().Replace("global::", ""));

                if (specialType != null)
                {
                    blockSyntax = SyntaxFactory.Block(
                        blockSyntax.Statements.Select(s => s.IsKind(SyntaxKind.ReturnStatement) ?
                           WrapReturnStatement(s as ReturnStatementSyntax, specialType) :
                           s
                    ).ToArray());
                }

                var parameterIdentifierNodes = blockSyntax.DescendantNodes()
                    .OfType<IdentifierNameSyntax>()
                    .Where(i => parameterListSyntax.Parameters
                        .Any(p => p.Identifier.ToFullString() == i.ToFullString()));
                blockSyntax = blockSyntax.ReplaceNodes(parameterIdentifierNodes, (originalNode, rewrittenNode) => WrapForwardedIdentifier(rewrittenNode, parameterListSyntax));
            }

            return blockSyntax;
        }
        private TypeSyntax UpdateType(TypeSyntax typeSyntax)
        {
            // TODO: figure out a better way to handle global::
            var specialType = _typeTranslation.FirstOrDefault(tt => PrettyTypeName(tt.ActualType) == typeSyntax.ToFullString().Replace("global::", ""));

            if (specialType != null)
            {
                return SyntaxFactory.ParseTypeName(specialType.TranslatedType);
            }

            return typeSyntax;
        }
        private AccessorListSyntax UpdateAccessorList(AccessorListSyntax accessorListSyntax, TypeSyntax type)
        {
            var specialType = _typeTranslation.FirstOrDefault(tt => PrettyTypeName(tt.ActualType) == type.ToFullString().Replace("global::", ""));

            if (specialType != null)
            {
                return accessorListSyntax.WithAccessors(
                    SyntaxFactory.List<AccessorDeclarationSyntax>(
                        accessorListSyntax.Accessors.Select(a =>
                            a.WithBody(UpdateMethodBody(
                                a.Body,
                                type,
                                SyntaxFactory.ParameterList(
                                    SyntaxFactory.SeparatedList<ParameterSyntax>( new [] { SyntaxFactory.Parameter(SyntaxFactory.ParseToken("value")).WithType(type) }))))))
                    );
            }

            return accessorListSyntax;
        }