Fix 'GetRefEscape' for invocation using old rules (#80261)

Author: RikkiGibson

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

@@ -3056,7 +3056,13 @@ private void GetEscapeValuesForOldRules(
                     escapeValues.Add(new EscapeValue(parameter, argument, EscapeLevel.CallingMethod, isRefEscape: false));
                 }
 
-                if (parameter.RefKind != RefKind.None)
+                // https://github.com/dotnet/csharpstandard/blob/0ad29bf615b18ae463d92ef64f557eeb007b76f1/standard/variables.md#9723-parameter-ref-safe-context
+                // For a parameter `p`:
+                // - If `p` is a reference or input parameter, its ref-safe-context is the caller-context. If `p` is an input parameter, it can’t be returned as a writable `ref` but can be returned as `ref readonly`.
+                // - If `p` is an output parameter, its ref-safe-context is the caller-context.
+                // - Otherwise, if `p` is the `this` parameter of a struct type, its ref-safe-context is the function-member.
+                // - Otherwise, the parameter is a value parameter, and its ref-safe-context is the function-member.
+                if (parameter.RefKind != RefKind.None && !parameter.IsThis)
                 {
                     escapeValues.Add(new EscapeValue(parameter, argument, EscapeLevel.CallingMethod, isRefEscape: true));
                 }

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

@@ -31991,5 +31991,135 @@ static void Test()
                 //         M(GetValue().F);
                 Diagnostic(ErrorCode.ERR_BadArgRef, "GetValue().F").WithArguments("1", "ref").WithLocation(11, 11));
         }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/80244")]
+        public void Repro_80244_NetCoreApp()
+        {
+            var comp = CreateCompilation("""
+                using System;
+                using System.Runtime.CompilerServices;
+                using System.Runtime.InteropServices;
+
+                ref struct SpanReader
+                {
+                    long _spanEndStreamOffset;
+                    ReadOnlySpan<byte> _buffer;
+                    public SpanReader(ReadOnlySpan<byte> buffer, long spanStartStreamOffset)
+                    {
+                        _buffer = buffer;
+                        _spanEndStreamOffset = spanStartStreamOffset + buffer.Length;
+                    }
+
+                    public ref readonly T ReadRef<T>() where T : struct
+                    {
+                        if (_buffer.Length >= Unsafe.SizeOf<T>())
+                        {
+                            ref readonly T ret = ref MemoryMarshal.Cast<byte, T>(_buffer)[0];
+                            _buffer = _buffer.Slice(Unsafe.SizeOf<T>());
+                            return ref ret;
+                        }
+                        else
+                        {
+                            throw new Exception();
+                        }
+                    }
+                }
+                """,
+                targetFramework: TargetFramework.NetCoreApp,
+                parseOptions: TestOptions.Regular14);
+            comp.VerifyEmitDiagnostics();
+        }
+
+        [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/80244")]
+        [InlineData(LanguageVersion.CSharp8), InlineData(LanguageVersion.CSharp14)]
+        public void Repro_80244_NetStandard(LanguageVersion consumerLanguageVersion)
+        {
+            var spanCompilation = CreateCompilation(TestSources.Span, options: TestOptions.UnsafeReleaseDll, parseOptions: TestOptions.Regular8);
+            var spanReference = spanCompilation.EmitToImageReference();
+            var source0 = """
+                namespace System.Runtime.CompilerServices
+                {
+                    public static class Unsafe
+                    {
+                        public static int SizeOf<T>() => throw null!;
+                    }
+                }
+
+                namespace System.Runtime.InteropServices
+                {
+                    public static class MemoryMarshal
+                    {
+                        public static ReadOnlySpan<TTo> Cast<TFrom, TTo>(ReadOnlySpan<TFrom> span)
+                            where TFrom : struct
+                            => throw null!;
+                    }
+                }
+                """;
+            var source1 = """
+                using System;
+                using System.Runtime.CompilerServices;
+                using System.Runtime.InteropServices;
+
+                ref struct SpanReader
+                {
+                    long _spanEndStreamOffset;
+                    ReadOnlySpan<byte> _buffer;
+                    public SpanReader(ReadOnlySpan<byte> buffer, long spanStartStreamOffset)
+                    {
+                        _buffer = buffer;
+                        _spanEndStreamOffset = spanStartStreamOffset + buffer.Length;
+                    }
+
+                    public ref readonly T ReadRef<T>() where T : struct
+                    {
+                        if (_buffer.Length >= Unsafe.SizeOf<T>())
+                        {
+                            ref readonly T ret = ref MemoryMarshal.Cast<byte, T>(_buffer)[0];
+                            _buffer = _buffer.Slice(Unsafe.SizeOf<T>());
+                            return ref ret;
+                        }
+                        else
+                        {
+                            throw new Exception();
+                        }
+                    }
+                }
+                """;
+            var comp = CreateCompilation([source0, source1],
+                references: [spanReference],
+                parseOptions: TestOptions.Regular.WithLanguageVersion(consumerLanguageVersion),
+                targetFramework: TargetFramework.NetStandard20);
+            comp.VerifyEmitDiagnostics();
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/80244")]
+        public void Repro_80244_Simple()
+        {
+            var source0 = """
+                public ref struct RS
+                {
+                    public ref byte this[int i] => throw null!;
+                }
+                """;
+
+            var reference = CreateCompilation(source0, parseOptions: TestOptions.Regular8).EmitToImageReference();
+            var source1 = """
+                class Program
+                {
+                    static ref byte M1(RS rs)
+                    {
+                        ref byte ret = ref rs[1];
+                        return ref ret;
+                    }
+
+                    static ref byte M2(RS rs)
+                    {
+                        return ref rs[1];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source1, references: [reference], parseOptions: TestOptions.Regular8);
+            comp.VerifyEmitDiagnostics();
+        }
     }
 }

src/Compilers/Test/Utilities/CSharp/TestSources.cs

@@ -24,12 +24,14 @@ public readonly ref struct Span<T>
         unsafe public Span(void* pointer, int length)
         {
             this.arr = Helpers.ToArray<T>(pointer, length);
+            this.start = 0;
             this.Length = length;
         }
 
         public Span(T[] arr)
         {
             this.arr = arr;
+            this.start = 0;
             this.Length = arr is null ? 0 : arr.Length;
         }
 
@@ -96,6 +98,8 @@ public ref T Current
         public static implicit operator ReadOnlySpan<T>(Span<T> span) => new ReadOnlySpan<T>(span.arr);
 
         public Span<T> Slice(int offset, int length) => new Span<T>(this.arr, offset, length);
+
+        public Span<T> Slice(int offset) => new Span<T>(this.arr, offset, Length - offset);
     }
 
     public readonly ref struct ReadOnlySpan<T>
@@ -111,12 +115,14 @@ public readonly ref struct ReadOnlySpan<T>
         unsafe public ReadOnlySpan(void* pointer, int length)
         {
             this.arr = Helpers.ToArray<T>(pointer, length);
+            this.start = 0;
             this.Length = length;
         }
 
         public ReadOnlySpan(T[] arr)
         {
             this.arr = arr;
+            this.start = 0;
             this.Length = arr is null ? 0 : arr.Length;
         }
 
@@ -185,6 +191,8 @@ public ref readonly T Current
 
         public ReadOnlySpan<T> Slice(int offset, int length) => new ReadOnlySpan<T>(this.arr, offset, length);
 
+        public ReadOnlySpan<T> Slice(int offset) => new ReadOnlySpan<T>(this.arr, offset, offset - Length);
+
 #nullable enable
         public static ReadOnlySpan<T> CastUp<TDerived>(ReadOnlySpan<TDerived> items) where TDerived : class?, T
         {