Fix #7776: Detect missing implementations for C# 'abstract override' methods

The IgnoreOverrides filter in InfoReader.fs incorrectly removed abstract
override methods (e.g. C# 'abstract override string ToString()') because
they were signature-equivalent to the base virtual method. This caused
GetClassDispatchSlots to miss these as required dispatch slots.

The fix adds an isAbstract check to the FilterOverrides function so that
abstract methods from derived types are preserved even when they override
an equivalent virtual in a supertype. This ensures the compiler correctly
reports FS0365 when a non-abstract F# class inherits from a C# class with
abstract override members without providing implementations.

Agent-Logs-Url: https://github.com/dotnet/fsharp/sessions/1d6d6e17-b57c-435f-b144-0d3146d9cbd8

Co-authored-by: abonie <20281641+abonie@users.noreply.github.com>

Author: Copilot

src/Compiler/Checking/InfoReader.fs

@@ -571,7 +571,7 @@ type InfoReader(g: TcGlobals, amap: ImportMap) as this =
         FilterItemsInSuperTypesBasedOnItemsInSubTypes nmf (fun item1 items -> not (items |> List.exists (fun item2 -> equivTest item1 item2))) itemLists 
 
     /// Filter the overrides of methods or properties, either keeping the overrides or keeping the dispatch slots.
-    static let FilterOverrides findFlag (isVirt:'a->bool, isNewSlot, isDefiniteOverride, isFinal, equivSigs, nmf:'a->string) items = 
+    static let FilterOverrides findFlag (isVirt:'a->bool, isNewSlot, isDefiniteOverride, isFinal, isAbstract, equivSigs, nmf:'a->string) items = 
         let equivVirts x y = isVirt x && isVirt y && equivSigs x y
         let filterDefiniteOverrides = List.filter(isDefiniteOverride >> not)
 
@@ -610,9 +610,10 @@ type InfoReader(g: TcGlobals, amap: ImportMap) as this =
               //       (a) not virtual
               //       (b) is a new slot or 
               //       (c) not equivalent
+              //       (d) is abstract (e.g. C# 'abstract override' re-abstracting a base virtual method)
               // We keep virtual finals around for error detection later on
               |> FilterItemsInSubTypesBasedOnItemsInSuperTypes nmf (fun newItem priorItem  ->
-                     (isVirt newItem && isFinal newItem) || not (isVirt newItem) || isNewSlot newItem || not (equivVirts newItem priorItem) )
+                     (isVirt newItem && isFinal newItem) || not (isVirt newItem) || isNewSlot newItem || isAbstract newItem || not (equivVirts newItem priorItem) )
 
               // Remove any abstract slots in supertypes that are (a) hidden by another newslot and (b) implemented
               // We leave unimplemented ones around to give errors, e.g. for
@@ -649,6 +650,7 @@ type InfoReader(g: TcGlobals, amap: ImportMap) as this =
              (fun minfo -> minfo.IsNewSlot),
              (fun minfo -> minfo.IsDefiniteFSharpOverride),
              (fun minfo -> minfo.IsFinal),
+             (fun minfo -> minfo.IsAbstract),
              MethInfosEquivByNameAndSig EraseNone true g amap m,
              (fun minfo -> minfo.LogicalName)) 
 
@@ -665,6 +667,7 @@ type InfoReader(g: TcGlobals, amap: ImportMap) as this =
                (fun pinfo -> pinfo.IsNewSlot),
                (fun pinfo -> pinfo.IsDefiniteFSharpOverride),
                (fun _ -> false),
+               (fun _ -> false),
                PropsGetterSetterEquiv (PropInfosEquivByNameAndSig EraseNone g amap m),
                (fun pinfo -> pinfo.PropertyName)) 
 

tests/FSharp.Compiler.ComponentTests/Conformance/ObjectOrientedTypeDefinitions/AbstractMembers/AbstractMembers.fs

@@ -291,3 +291,130 @@ let x4 = new TestLib.B<string>()
         |> compile
         |> shouldFail
         |> withErrorCode 759
+
+    // Regression tests for https://github.com/dotnet/fsharp/issues/7776
+
+    /// C# 'abstract override' re-abstracts a virtual method from a base class.
+    /// F# classes inheriting from such a class must provide an implementation.
+    let private csLibWithAbstractOverride =
+        CSharp """
+namespace CSharpLib
+{
+    public abstract class AbstractClass
+    {
+        public abstract override string ToString();
+    }
+
+    public abstract class AbstractClassWithCustomMethod
+    {
+        public virtual int GetValue() => 42;
+    }
+
+    public abstract class ReAbstractCustomMethod : AbstractClassWithCustomMethod
+    {
+        public abstract override int GetValue();
+    }
+}
+"""
+        |> withName "CSharpAbstractOverrideLib"
+
+    // https://github.com/dotnet/fsharp/issues/7776
+    [<Fact>]
+    let ``Abstract override ToString - missing implementation should error`` () =
+        FSharp """
+module Test
+
+open CSharpLib
+
+type T() =
+    inherit AbstractClass()
+"""
+        |> asLibrary
+        |> withReferences [csLibWithAbstractOverride]
+        |> compile
+        |> shouldFail
+        |> withErrorCode 365
+
+    // https://github.com/dotnet/fsharp/issues/7776
+    [<Fact>]
+    let ``Abstract override ToString - with implementation should succeed`` () =
+        FSharp """
+module Test
+
+open CSharpLib
+
+type T() =
+    inherit AbstractClass()
+    override _.ToString() = "T"
+"""
+        |> asLibrary
+        |> withReferences [csLibWithAbstractOverride]
+        |> compile
+        |> shouldSucceed
+
+    // https://github.com/dotnet/fsharp/issues/7776
+    [<Fact>]
+    let ``Abstract override custom method - missing implementation should error`` () =
+        FSharp """
+module Test
+
+open CSharpLib
+
+type T() =
+    inherit ReAbstractCustomMethod()
+"""
+        |> asLibrary
+        |> withReferences [csLibWithAbstractOverride]
+        |> compile
+        |> shouldFail
+        |> withErrorCode 365
+
+    // https://github.com/dotnet/fsharp/issues/7776
+    [<Fact>]
+    let ``Abstract override custom method - with implementation should succeed`` () =
+        FSharp """
+module Test
+
+open CSharpLib
+
+type T() =
+    inherit ReAbstractCustomMethod()
+    override _.GetValue() = 100
+"""
+        |> asLibrary
+        |> withReferences [csLibWithAbstractOverride]
+        |> compile
+        |> shouldSucceed
+
+    // https://github.com/dotnet/fsharp/issues/7776
+    [<Fact>]
+    let ``Abstract override - F# abstract subclass should be allowed`` () =
+        FSharp """
+module Test
+
+open CSharpLib
+
+[<AbstractClass>]
+type T() =
+    inherit AbstractClass()
+"""
+        |> asLibrary
+        |> withReferences [csLibWithAbstractOverride]
+        |> compile
+        |> shouldSucceed
+
+    // https://github.com/dotnet/fsharp/issues/7776
+    [<Fact>]
+    let ``Abstract override ToString - object expression must implement`` () =
+        FSharp """
+module Test
+
+open CSharpLib
+
+let x = { new AbstractClass() with
+            override _.ToString() = "obj" }
+"""
+        |> asLibrary
+        |> withReferences [csLibWithAbstractOverride]
+        |> compile
+        |> shouldSucceed