Extending C # with Roslyn. Secure calls

string text = SomeObject.ToString();

string text = SomeObject?.ToString();

string text = SomeObject != null ? SomeObject.ToString() : null;

int? count = SomeList?.Count;

int? length = SomeObject?.ToString()?.Length;

int? length = SomeObject != null ? SomeObject.ToString() != null ? SomeObject.ToString().Length : null : null;

var temp = SomeObject;
string text = null;
if (temp != null)
    text = temp.ToString();

Project roslyn

1. You can create your own compiler instead of the current csc.exe using the same Roslyn API, and change your build system by replacing csc.exe with your own analogue, including in addition to the default compilation (quite simply programmed, by the way) your preliminary transformations code.
2. You can use your console program as a Pre-Build task that converts source code files and saves the received new sources to the Obj folder. WPF is currently being compiled in a very similar way, when xaml files in the pre-build phase are converted to .g.cs files.

Implementation

public class Example
{
    public const string CODE =
    @"using System;
    using System.Linq;
    using System.Windows;
    namespace HelloWorld
    {
        public class TestClass
        {
            public string TestField;
            public string TestProperty { get; set; }
            public string TestMethod() { return null; }
            public string TestMethod2(int k, string p) { return null; }
            public TestClass ChainTest;
        }
        public class OtherClass
        {
            public void Test()
            {
                TestClass test;
                string testStr1;
                testStr1 = test?.TestField;
                string testStr3 = test?.TestProperty;
                string testStr4 = test?.TestMethod();
                string testStr5 = test?.TestMethod2(100, testStr3);
                var test3 = test?.ChainTest?.TestField;
            }
        }
    }";
}

SyntaxTree tree = SyntaxTree.ParseCompilationUnit(Example.CODE);
SyntaxNode root = tree.Root;

// Находит в синтаксическом дереве операторы безопасного вызова и заменяет их на тернарные операторы
public class SafeCallRewriter : SyntaxRewriter
{
    //Был ли в данный проход заменен хотя бы один оператор ?.
    public bool IsSafeCallRewrited { get; set; }
    protected override SyntaxNode VisitConditionalExpression(ConditionalExpressionSyntax node)
    {
        if (IsSafeCallExpression(node))
        {
            //Строим expression для объекта, проверяемого на null
            string identTxt = node.Condition.GetText();
            ExpressionSyntax ident = Syntax.ParseExpression(identTxt);
            //Строим expression для кода, вызываемого при успешной проверка на != null
            string exprTxt = node.WhenTrue.GetText();
            exprTxt = exprTxt.Substring(1, exprTxt.Length - 1);//убираем точку из записи выражения
            exprTxt = identTxt + '.' + exprTxt;
            ExpressionSyntax expr = Syntax.ParseExpression(exprTxt);
            ExpressionSyntax synt =
                Syntax.ConditionalExpression(//тернарный оператор
                condition: Syntax.BinaryExpression(//проверяемое условие ident != null
                    SyntaxKind.NotEqualsExpression,
                    left: ident, //левый операнд - проверяемый объект
                    right: Syntax.LiteralExpression(SyntaxKind.NullLiteralExpression)), //литерал null
                whenTrue: expr,
                whenFalse: Syntax.LiteralExpression(SyntaxKind.NullLiteralExpression));
            IsSafeCallRewrited = true;
            return synt;
        }
        return base.VisitConditionalExpression(node);
    }
    //Является ли тернарный оператор на самом деле оператором безопасного вызова
    private bool IsSafeCallExpression(ConditionalExpressionSyntax node)
    {
        return node.WhenTrue.GetText()[0] == '.';
    }
}

static void Main(string[] args)
{
    //Строим синтаксическое дерево
    SyntaxTree tree = SyntaxTree.ParseCompilationUnit(Example.CODE);
    SyntaxNode root = tree.Root;
    SafeCallRewriter rewriter = new SafeCallRewriter();
    do
    {
        rewriter.IsSafeCallRewrited = false;
        //Обходим дерево, производя заданные операции в различных типах узлов и переписывая дерево
        root = rewriter.Visit(root);
    } while (rewriter.IsSafeCallRewrited);//за предыдущий проход был найден и преобразован хоть 1 maybe-оператор
    root = root.Format();//программный Ctrl+K, Ctrl+D
    Console.WriteLine(root.ToString());
}

using System;
using System.Linq;
using System.Windows;
namespace HelloWorld
{
    public class TestClass
    {
        public string TestField;
        public string TestProperty
        {
            get;
            set;
        }
        public string TestMethod()
        {
            return null;
        }
        public string TestMethod2(int k, string p)
        {
            return null;
        }
        public TestClass ChainTest;
    }
    public class OtherClass
    {
        public void Test()
        {
            TestClass test;
            string testStr1;
            testStr1 = test != null ? test.TestField : null;
            string testStr3 = test != null ? test.TestProperty : null;
            string testStr4 = test != null ? test.TestMethod() : null;
            string testStr5 = test != null ? test.TestMethod2(100, testStr3) : null;
            var test3 = test != null ? test.ChainTest != null ? test.ChainTest.TestField : null : null;
        }
    }
}