using System;

using System.Linq;

using Microsoft.CodeAnalysis;

using Microsoft.CodeAnalysis.CSharp;

using Microsoft.CodeAnalysis.CSharp.Syntax;

using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

public static class Extensions{

    public static bool IsNotNull(this TypeInfo info)

    {

        Console.WriteLine(info.Nullability.FlowState);

        if (info.Nullability.FlowState == NullableFlowState.NotNull)

        {

            return true;

        }

        return false;

    }

​

    public  static bool IsNotNull(this ExpressionSyntax expr, SemanticModel model)

    {

        var info = model.GetTypeInfo(expr);

        return IsNotNull(info);

    }   

}

​

public class Program

{

    public static void Main()

    {

        var code = @"using System;

using System.Collections.Generic;

using System.Diagnostics.CodeAnalysis;

using System.Runtime.CompilerServices;

​

public class App

{

    static void Main()

    {

        string Eval (string s)

        {

            Console.WriteLine(s);

            return null;

        }

​

        bool ToTemp<T>(T e, [NotNullIfNotNull(""e"")] out T t)

        {

            t = e;

            return true;

        }

​

        string? temp = default;

        var x = ToTemp(Eval(""A""), out temp) switch

        {

            _ when temp is {} xxx => ""Something"",

            _ => Eval(""B"")

        };

    }

}

";

        var tree = SyntaxTree(ParseCompilationUnit(code));

​

        var compOptions = new CSharpCompilationOptions(

            outputKind: OutputKind.DynamicallyLinkedLibrary,

            allowUnsafe: true,

            nullableContextOptions: NullableContextOptions.Enable

        );

        var refApi = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);

        var com = CSharpCompilation.Create("something", new []{ tree }, new []{refApi}, options: compOptions);

        var model = com.GetSemanticModel(tree);

        var switchExpr =com.SyntaxTrees.First().GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().First()

            .DescendantNodes().OfType<MethodDeclarationSyntax>().First().Body.Statements.Skip(3).First()

            .DescendantNodes().OfType<SwitchExpressionSyntax>().First();

        //temp out var -> MayBeNull (correct)

        var tempOutVar = switchExpr.GoverningExpression.DescendantNodes().OfType<ArgumentSyntax>().Skip(2).First().Expression;

        Console.WriteLine($"eval: {tempOutVar}");

        var isNotNull1 = tempOutVar.IsNotNull(model);

        //temp var in first switch arm (NotNull???)

        var tempVar = switchExpr.Arms.First().DescendantNodes().OfType<IdentifierNameSyntax>().First();

        Console.WriteLine($"eval: {tempVar}");

        var isNotNull2 = tempVar.IsNotNull(model);

    }

}