From 97ca741d546bd4da49ca04524886c5d22b1d3ca5 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 18 May 2026 06:32:35 +0000
Subject: [PATCH 1/3] Add async override virtual await coverage

Agent-Logs-Url: https://github.com/dotnet/runtime/sessions/f0cdee65-d4c1-4916-bbd3-9dcb4dcfe398

Co-authored-by: MichalStrehovsky <13110571+MichalStrehovsky@users.noreply.github.com>
---
 src/tests/async/override/override.cs | 62 ++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/src/tests/async/override/override.cs b/src/tests/async/override/override.cs
index d55d961880ad30..c35f4997f90a02 100644
--- a/src/tests/async/override/override.cs
+++ b/src/tests/async/override/override.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Xunit;
@@ -15,6 +16,12 @@ public virtual async Task<int> M1()
             await Task.Yield();
             return 1;
         }
+
+        public virtual async Task<List<T>> M2<T>(T first, T second)
+        {
+            await Task.Yield();
+            return new List<T>();
+        }
     }
 
     class Derived1 : Base
@@ -25,6 +32,12 @@ public override async Task<int> M1()
             await Task.Yield();
             return 2;
         }
+
+        public override async Task<List<T>> M2<T>(T first, T second)
+        {
+            await Task.Yield();
+            return new List<T> { first };
+        }
     }
 
     class Derived2 : Derived1
@@ -34,6 +47,12 @@ public override async Task<int> M1()
             await Task.Yield();
             return 3;
         }
+
+        public override async Task<List<T>> M2<T>(T first, T second)
+        {
+            await Task.Yield();
+            return new List<T> { second };
+        }
     }
 
 
@@ -45,6 +64,12 @@ public virtual async Task<int> M1()
             await Task.Yield();
             return 11;
         }
+
+        public virtual async Task<List<T>> M2<T>(T first, T second)
+        {
+            await Task.Yield();
+            return new List<T>();
+        }
     }
 
     class Derived11 : Base1
@@ -54,6 +79,12 @@ public override async Task<int> M1()
             await Task.Yield();
             return 12;
         }
+
+        public override async Task<List<T>> M2<T>(T first, T second)
+        {
+            await Task.Yield();
+            return new List<T> { first };
+        }
     }
 
     class Derived12 : Derived11
@@ -64,30 +95,61 @@ public override async Task<int> M1()
             await Task.Yield();
             return 13;
         }
+
+        public override async Task<List<T>> M2<T>(T first, T second)
+        {
+            await Task.Yield();
+            return new List<T> { second };
+        }
     }
 
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    static async Task<int> AwaitBaseM1(Base b) => await b.M1();
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    static async Task<int> AwaitBaseM1(Base1 b) => await b.M1();
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    static async Task<List<T>> AwaitBaseM2<T>(Base b, T first, T second) => await b.M2(first, second);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    static async Task<List<T>> AwaitBaseM2<T>(Base1 b, T first, T second) => await b.M2(first, second);
 
     [Fact]
     public static void TestEntryPoint()
     {
         Base b = new Derived1();
         Assert.Equal(2, b.M1().Result);
+        Assert.Equal(2, AwaitBaseM1(b).Result);
+        Assert.Equal(new List<int> { 2 }, b.M2(2, 3).Result);
+        Assert.Equal(new List<int> { 2 }, AwaitBaseM2(b, 2, 3).Result);
 
         b = new Derived2();
         Assert.Equal(3, b.M1().Result);
+        Assert.Equal(3, AwaitBaseM1(b).Result);
+        Assert.Equal(new List<int> { 3 }, b.M2(2, 3).Result);
+        Assert.Equal(new List<int> { 3 }, AwaitBaseM2(b, 2, 3).Result);
 
         Derived1 d = new Derived2();
         Assert.Equal(3, d.M1().Result);
+        Assert.Equal(new List<int> { 3 }, d.M2(2, 3).Result);
 
 
         Base1 b1 = new Derived11();
         Assert.Equal(12, b1.M1().Result);
+        Assert.Equal(12, AwaitBaseM1(b1).Result);
+        Assert.Equal(new List<int> { 12 }, b1.M2(12, 13).Result);
+        Assert.Equal(new List<int> { 12 }, AwaitBaseM2(b1, 12, 13).Result);
 
         b1 = new Derived12();
         Assert.Equal(13, b1.M1().Result);
+        Assert.Equal(13, AwaitBaseM1(b1).Result);
+        Assert.Equal(new List<int> { 13 }, b1.M2(12, 13).Result);
+        Assert.Equal(new List<int> { 13 }, AwaitBaseM2(b1, 12, 13).Result);
 
         Derived11 d1 = new Derived12();
         Assert.Equal(13, d1.M1().Result);
+        Assert.Equal(new List<int> { 13 }, d1.M2(12, 13).Result);
 
     }
 }

From f1ceef11368b34a29679494b9f506fa57b0982a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Thu, 21 May 2026 10:27:37 +0900
Subject: [PATCH 2/3] Simplify, this doesn't involve shared generics anyway

---
 src/tests/async/override/override.cs | 47 ++++++++++++++--------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/src/tests/async/override/override.cs b/src/tests/async/override/override.cs
index c35f4997f90a02..7e9d434fa31bd4 100644
--- a/src/tests/async/override/override.cs
+++ b/src/tests/async/override/override.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Xunit;
@@ -17,10 +16,10 @@ public virtual async Task<int> M1()
             return 1;
         }
 
-        public virtual async Task<List<T>> M2<T>(T first, T second)
+        public virtual async Task<T> M2<T>(T first, T second)
         {
             await Task.Yield();
-            return new List<T>();
+            return default(T);
         }
     }
 
@@ -33,10 +32,10 @@ public override async Task<int> M1()
             return 2;
         }
 
-        public override async Task<List<T>> M2<T>(T first, T second)
+        public override async Task<T> M2<T>(T first, T second)
         {
             await Task.Yield();
-            return new List<T> { first };
+            return first;
         }
     }
 
@@ -48,10 +47,10 @@ public override async Task<int> M1()
             return 3;
         }
 
-        public override async Task<List<T>> M2<T>(T first, T second)
+        public override async Task<T> M2<T>(T first, T second)
         {
             await Task.Yield();
-            return new List<T> { second };
+            return second;
         }
     }
 
@@ -65,10 +64,10 @@ public virtual async Task<int> M1()
             return 11;
         }
 
-        public virtual async Task<List<T>> M2<T>(T first, T second)
+        public virtual async Task<T> M2<T>(T first, T second)
         {
             await Task.Yield();
-            return new List<T>();
+            return default(T);
         }
     }
 
@@ -83,7 +82,7 @@ public override async Task<int> M1()
         public override async Task<List<T>> M2<T>(T first, T second)
         {
             await Task.Yield();
-            return new List<T> { first };
+            return first;
         }
     }
 
@@ -96,10 +95,10 @@ public override async Task<int> M1()
             return 13;
         }
 
-        public override async Task<List<T>> M2<T>(T first, T second)
+        public override async Task<T> M2<T>(T first, T second)
         {
             await Task.Yield();
-            return new List<T> { second };
+            return second;
         }
     }
 
@@ -110,10 +109,10 @@ public override async Task<List<T>> M2<T>(T first, T second)
     static async Task<int> AwaitBaseM1(Base1 b) => await b.M1();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    static async Task<List<T>> AwaitBaseM2<T>(Base b, T first, T second) => await b.M2(first, second);
+    static async Task<T> AwaitBaseM2<T>(Base b, T first, T second) => await b.M2(first, second);
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    static async Task<List<T>> AwaitBaseM2<T>(Base1 b, T first, T second) => await b.M2(first, second);
+    static async Task<T> AwaitBaseM2<T>(Base1 b, T first, T second) => await b.M2(first, second);
 
     [Fact]
     public static void TestEntryPoint()
@@ -121,35 +120,35 @@ public static void TestEntryPoint()
         Base b = new Derived1();
         Assert.Equal(2, b.M1().Result);
         Assert.Equal(2, AwaitBaseM1(b).Result);
-        Assert.Equal(new List<int> { 2 }, b.M2(2, 3).Result);
-        Assert.Equal(new List<int> { 2 }, AwaitBaseM2(b, 2, 3).Result);
+        Assert.Equal(2, b.M2(2, 3).Result);
+        Assert.Equal(2, AwaitBaseM2(b, 2, 3).Result);
 
         b = new Derived2();
         Assert.Equal(3, b.M1().Result);
         Assert.Equal(3, AwaitBaseM1(b).Result);
-        Assert.Equal(new List<int> { 3 }, b.M2(2, 3).Result);
-        Assert.Equal(new List<int> { 3 }, AwaitBaseM2(b, 2, 3).Result);
+        Assert.Equal(3, b.M2(2, 3).Result);
+        Assert.Equal(3, AwaitBaseM2(b, 2, 3).Result);
 
         Derived1 d = new Derived2();
         Assert.Equal(3, d.M1().Result);
-        Assert.Equal(new List<int> { 3 }, d.M2(2, 3).Result);
+        Assert.Equal(3, d.M2(2, 3).Result);
 
 
         Base1 b1 = new Derived11();
         Assert.Equal(12, b1.M1().Result);
         Assert.Equal(12, AwaitBaseM1(b1).Result);
-        Assert.Equal(new List<int> { 12 }, b1.M2(12, 13).Result);
-        Assert.Equal(new List<int> { 12 }, AwaitBaseM2(b1, 12, 13).Result);
+        Assert.Equal(12, b1.M2(12, 13).Result);
+        Assert.Equal(12, AwaitBaseM2(b1, 12, 13).Result);
 
         b1 = new Derived12();
         Assert.Equal(13, b1.M1().Result);
         Assert.Equal(13, AwaitBaseM1(b1).Result);
-        Assert.Equal(new List<int> { 13 }, b1.M2(12, 13).Result);
-        Assert.Equal(new List<int> { 13 }, AwaitBaseM2(b1, 12, 13).Result);
+        Assert.Equal(13, b1.M2(12, 13).Result);
+        Assert.Equal(13, AwaitBaseM2(b1, 12, 13).Result);
 
         Derived11 d1 = new Derived12();
         Assert.Equal(13, d1.M1().Result);
-        Assert.Equal(new List<int> { 13 }, d1.M2(12, 13).Result);
+        Assert.Equal(13, d1.M2(12, 13).Result);
 
     }
 }

From 9f303d48fea1dd31d8cc3ddecfac0532b903ffde Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Thu, 21 May 2026 10:32:01 +0900
Subject: [PATCH 3/3] Update override.cs

---
 src/tests/async/override/override.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tests/async/override/override.cs b/src/tests/async/override/override.cs
index 7e9d434fa31bd4..2d886f01d60d64 100644
--- a/src/tests/async/override/override.cs
+++ b/src/tests/async/override/override.cs
@@ -79,7 +79,7 @@ public override async Task<int> M1()
             return 12;
         }
 
-        public override async Task<List<T>> M2<T>(T first, T second)
+        public override async Task<T> M2<T>(T first, T second)
         {
             await Task.Yield();
             return first;