Out arguments do not contribute val escape

src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs

@@ -2167,7 +2167,7 @@ private void GetEscapeValuesForUpdatedRules(
                     continue;
                 }
 
-                if (parameter.Type.IsRefLikeType && GetParameterValEscapeLevel(parameter) is { } valEscapeLevel)
+                if (parameter.Type.IsRefLikeType && parameter.RefKind != RefKind.Out && GetParameterValEscapeLevel(parameter) is { } valEscapeLevel)
                 {
                     escapeValues.Add(new EscapeValue(parameter, argument, valEscapeLevel, isRefEscape: false));
                 }
@@ -2417,6 +2417,11 @@ private bool CheckInvocationArgMixingWithUpdatedRules(
 
             void inferDeclarationExpressionValEscape()
             {
+                if (argsOpt.IsDefault)
+                {
+                    return;
+                }
+
                 // find the widest scope that arguments could safely escape to.
                 // use this scope as the inferred STE of declaration expressions.
                 var inferredDestinationValEscape = CallingMethodScope;
@@ -2427,9 +2432,9 @@ void inferDeclarationExpressionValEscape()
                         : GetValEscape(fromArg, scopeOfTheContainingExpression));
                 }
 
-                foreach (var (_, fromArg, _, _) in escapeValues)
+                foreach (var argument in argsOpt)
                 {
-                    if (ShouldInferDeclarationExpressionValEscape(fromArg, out var localSymbol))
+                    if (ShouldInferDeclarationExpressionValEscape(argument, out var localSymbol))
                     {
                         localSymbol.SetValEscape(inferredDestinationValEscape);
                     }

src/Compilers/CSharp/Test/Semantic/Semantics/RefEscapingTests.cs

@@ -6416,5 +6416,77 @@ static RS M22(ref RS rs5)
                 Diagnostic(ErrorCode.ERR_EscapeVariable, "rs6").WithArguments("rs6").WithLocation(45, 16)
                 );
         }
+
+        [Fact, WorkItem(64783, "https://github.com/dotnet/roslyn/issues/64783")]
+        public void OutArgumentsDoNotContributeValEscape_01()
+        {
+            var source = """
+                using System;
+
+                class Program
+                {
+                    static Span<byte> M1()
+                    {
+                        Span<byte> a = stackalloc byte[42];
+                        var ret = OneOutSpanReturnsSpan(out a);
+                        return ret;
+                    }
+
+                    static Span<byte> M2()
+                    {
+                        Span<byte> a = stackalloc byte[42];
+                        TwoOutSpans(out a, out Span<byte> b);
+                        return b;
+                    }
+
+                    static Span<byte> OneOutSpanReturnsSpan(out Span<byte> a)
+                    {
+                        // 'return a' is illegal until it is overwritten
+                        a = default;
+                        return default;
+                    }
+
+                    static void TwoOutSpans(out Span<byte> a, out Span<byte> b)
+                    {
+                        // 'a = b' and 'b = a' are illegal until one has already been written
+                        a = b = default;
+                    }
+                }
+
+                """;
+
+            var comp = CreateCompilationWithSpan(source);
+            comp.VerifyDiagnostics();
+        }
+
+        [Fact, WorkItem(56587, "https://github.com/dotnet/roslyn/issues/56587")]
+        public void OutArgumentsDoNotContributeValEscape_02()
+        {
+            // Test that out discard arguments are not treated as inputs.
+            // This means we don't need to take special care to zero-out the variable used for a discard argument between uses.
+            var source = """
+                using System;
+
+                class Program
+                {
+                    static Span<byte> M1()
+                    {
+                        Span<byte> a = stackalloc byte[42];
+                        TwoOutSpans(out a, out _);
+                        TwoOutSpans(out _, out Span<byte> c);
+                        return c;
+                    }
+
+                    static void TwoOutSpans(out Span<byte> a, out Span<byte> b)
+                    {
+                        // 'a = b' and 'b = a' are illegal until one has already been written
+                        a = b = default;
+                    }
+                }
+                """;
+
+            var comp = CreateCompilationWithSpan(source);
+            comp.VerifyDiagnostics();
+        }
     }
 }