RFC FS-1336 :: Simplify implementation of interface hierarchies with equally named abstract slots

docs/release-notes/.Language/preview.md

@@ -1,5 +1,6 @@
 ### Added
 
+* Simplify implementation of interface hierarchies with equally named abstract slots: when a derived interface provides a Default Interface Member (DIM) implementation for a base interface slot, F# no longer requires explicit interface declarations for the DIM-covered slot. (RFC FS-1336, [Language suggestion #1430](https://github.com/fsharp/fslang-suggestions/issues/1430), [PR #19241](https://github.com/dotnet/fsharp/pull/19241))
 * Better generic unmanaged structs handling. ([Language suggestion #692](https://github.com/fsharp/fslang-suggestions/issues/692), [PR #12154](https://github.com/dotnet/fsharp/pull/12154))
 * Deprecate places where `seq` can be omitted. ([Language suggestion #1033](https://github.com/fsharp/fslang-suggestions/issues/1033), [PR #17772](https://github.com/dotnet/fsharp/pull/17772))
 * Added type conversions cache, only enabled for compiler runs ([PR#17668](https://github.com/dotnet/fsharp/pull/17668))

src/Compiler/Checking/MethodOverrides.fs

@@ -90,6 +90,13 @@ type RequiredSlot =
         | DefaultInterfaceImplementationSlot(_, _, possiblyNoMostSpecific) -> possiblyNoMostSpecific
         | _ -> false
 
+    /// Checks if this slot has implicit DIM coverage (used when the ImplicitDIMCoverage feature is enabled).
+    /// A slot has DIM coverage when it has a default interface implementation AND is optional (not re-abstracted).
+    member this.HasImplicitDIMCoverage(g: TcGlobals) =
+        g.langVersion.SupportsFeature LanguageFeature.ImplicitDIMCoverage
+        && this.HasDefaultInterfaceImplementation
+        && this.IsOptional
+
     /// Gets the method info.
     member this.MethodInfo =
         match this with
@@ -583,18 +590,19 @@ module DispatchSlotChecking =
             [ (reqdTy, GetClassDispatchSlots infoReader ad m reqdTy) ]
 
     /// Check all implementations implement some dispatch slot.
-    let CheckOverridesAreAllUsedOnce(denv, g, infoReader: InfoReader, isObjExpr, reqdTy,
+    let CheckOverridesAreAllUsedOnce(denv, g: TcGlobals.TcGlobals, infoReader: InfoReader, isObjExpr, reqdTy,
                                      dispatchSlotsKeyed: NameMultiMap<RequiredSlot>,
                                      availPriorOverrides: OverrideInfo list,
                                      overrides: OverrideInfo list) = 
         let amap = infoReader.amap
 
         let availPriorOverridesKeyed = availPriorOverrides |> NameMultiMap.initBy (fun ov -> ov.LogicalName)
+
         for overrideBy in overrides do 
           if not overrideBy.IsFakeEventProperty then
             let m = overrideBy.Range
-            let relevantVirts = NameMultiMap.find overrideBy.LogicalName dispatchSlotsKeyed
-            let relevantVirts = relevantVirts |> List.map (fun reqdSlot -> reqdSlot.MethodInfo)
+            let relevantSlots = NameMultiMap.find overrideBy.LogicalName dispatchSlotsKeyed
+            let relevantVirts = relevantSlots |> List.map (fun reqdSlot -> reqdSlot.MethodInfo)
 
             match relevantVirts |> List.filter (fun dispatchSlot -> OverrideImplementsDispatchSlot g amap m dispatchSlot overrideBy) with
             | [] -> 
@@ -628,7 +636,22 @@ module DispatchSlotChecking =
                 if dispatchSlot.IsFinal && (isObjExpr || not (typeEquiv g reqdTy dispatchSlot.ApparentEnclosingType)) then 
                     errorR(Error(FSComp.SR.typrelMethodIsSealed(NicePrint.stringOfMethInfo infoReader m denv dispatchSlot), m))
             | dispatchSlots -> 
-                match dispatchSlots |> List.filter (fun dispatchSlot ->
+                // Filter out slots that have DIM coverage (when feature is enabled)
+                // by looking up the original RequiredSlot information
+                let slotsWithoutDIMCoverage =
+                    dispatchSlots
+                    |> List.filter (fun dispatchSlot ->
+                        // Find the corresponding RequiredSlot to check for DIM coverage
+                        let correspondingSlot = 
+                            relevantSlots 
+                            |> List.tryFind (fun rs -> 
+                                rs.MethodInfo.LogicalName = dispatchSlot.LogicalName &&
+                                typeEquiv g rs.MethodInfo.ApparentEnclosingType dispatchSlot.ApparentEnclosingType)
+                        match correspondingSlot with
+                        | Some slot -> not (slot.HasImplicitDIMCoverage g)
+                        | None -> true)
+
+                match slotsWithoutDIMCoverage |> List.filter (fun dispatchSlot ->
                               (dispatchSlot.IsInstance = overrideBy.IsInstance) &&
                               isInterfaceTy g dispatchSlot.ApparentEnclosingType || 
                               not (DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed dispatchSlot)) with
@@ -860,24 +883,26 @@ module DispatchSlotChecking =
                           let overrideByInfo = GetTypeMemberOverrideInfo g reqdTy overrideBy
                           let overriddenForThisSlotImplSet = 
                               [ for reqdSlot in NameMultiMap.find overrideByInfo.LogicalName dispatchSlotsKeyed do
-                                    let dispatchSlot = reqdSlot.MethodInfo
-                                    if OverrideImplementsDispatchSlot g amap m dispatchSlot overrideByInfo then 
-                                        if tyconRefEq g overrideByInfo.BoundingTyconRef dispatchSlot.DeclaringTyconRef then 
-                                             match dispatchSlot.ArbitraryValRef with 
-                                             | Some virtMember -> 
-                                                  if virtMember.MemberInfo.Value.IsImplemented then errorR(Error(FSComp.SR.tcDefaultImplementationAlreadyExists(), overrideByInfo.Range))
-                                                  virtMember.MemberInfo.Value.IsImplemented <- true
-                                             | None -> () // not an F# slot
-
-                                        // Get the slotsig of the overridden method 
-                                        let slotsig = dispatchSlot.GetSlotSig(amap, m)
-
-                                        // The slotsig from the overridden method is in terms of the type parameters on the parent type of the overriding method,
-                                        // Modify map the slotsig so it is in terms of the type parameters for the overriding method 
-                                        let slotsig = ReparentSlotSigToUseMethodTypars g m overrideBy slotsig
+                                        // Skip slots that have DIM coverage (they don't need MethodImpl)
+                                        if not (reqdSlot.HasImplicitDIMCoverage g) then
+                                            let dispatchSlot = reqdSlot.MethodInfo
+                                            if OverrideImplementsDispatchSlot g amap m dispatchSlot overrideByInfo then 
+                                                if tyconRefEq g overrideByInfo.BoundingTyconRef dispatchSlot.DeclaringTyconRef then 
+                                                     match dispatchSlot.ArbitraryValRef with 
+                                                     | Some virtMember -> 
+                                                          if virtMember.MemberInfo.Value.IsImplemented then errorR(Error(FSComp.SR.tcDefaultImplementationAlreadyExists(), overrideByInfo.Range))
+                                                          virtMember.MemberInfo.Value.IsImplemented <- true
+                                                     | None -> () // not an F# slot
+
+                                                // Get the slotsig of the overridden method 
+                                                let slotsig = dispatchSlot.GetSlotSig(amap, m)
+
+                                                // The slotsig from the overridden method is in terms of the type parameters on the parent type of the overriding method,
+                                                // Modify map the slotsig so it is in terms of the type parameters for the overriding method 
+                                                let slotsig = ReparentSlotSigToUseMethodTypars g m overrideBy slotsig
 
-                                        // Record the slotsig via mutation
-                                        yield slotsig ]
+                                                // Record the slotsig via mutation
+                                                yield slotsig ]
                           //if mustOverrideSomething reqdTy overrideBy then 
                           //    assert nonNil overriddenForThisSlotImplSet
                           yield! overriddenForThisSlotImplSet ]

src/Compiler/FSComp.txt

@@ -1803,5 +1803,6 @@ featureAllowLetOrUseBangTypeAnnotationWithoutParens,"Allow let! and use! type an
 3878,tcAttributeIsNotValidForUnionCaseWithFields,"This attribute is not valid for use on union cases with fields."
 3879,xmlDocNotFirstOnLine,"XML documentation comments should be the first non-whitespace text on a line."
 featureReturnFromFinal,"Support for ReturnFromFinal/YieldFromFinal in computation expressions to enable tailcall optimization when available on the builder."
+featureImplicitDIMCoverage,"Implicit dispatch slot coverage for default interface member implementations"
 3880,optsLangVersionOutOfSupport,"Language version '%s' is out of support. The last .NET SDK supporting it is available at https://dotnet.microsoft.com/en-us/download/dotnet/%s"
 3881,optsUnrecognizedLanguageFeature,"Unrecognized language feature name: '%s'. Use a valid feature name such as 'NameOf' or 'StringInterpolation'."

src/Compiler/Facilities/LanguageFeatures.fs

@@ -104,6 +104,7 @@ type LanguageFeature =
     | ErrorOnInvalidDeclsInTypeDefinitions
     | AllowTypedLetUseAndBang
     | ReturnFromFinal
+    | ImplicitDIMCoverage
 
 /// LanguageVersion management
 type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) =
@@ -251,6 +252,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
 
                 // F# preview (still preview in 10.0)
                 LanguageFeature.FromEndSlicing, previewVersion // Unfinished features --- needs work
+                LanguageFeature.ImplicitDIMCoverage, previewVersion
             ]
 
     static let defaultLanguageVersion = LanguageVersion("default")
@@ -440,6 +442,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
         | LanguageFeature.ErrorOnInvalidDeclsInTypeDefinitions -> FSComp.SR.featureErrorOnInvalidDeclsInTypeDefinitions ()
         | LanguageFeature.AllowTypedLetUseAndBang -> FSComp.SR.featureAllowLetOrUseBangTypeAnnotationWithoutParens ()
         | LanguageFeature.ReturnFromFinal -> FSComp.SR.featureReturnFromFinal ()
+        | LanguageFeature.ImplicitDIMCoverage -> FSComp.SR.featureImplicitDIMCoverage ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -95,6 +95,7 @@ type LanguageFeature =
     | ErrorOnInvalidDeclsInTypeDefinitions
     | AllowTypedLetUseAndBang
     | ReturnFromFinal
+    | ImplicitDIMCoverage
 
 /// LanguageVersion management
 type LanguageVersion =

tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj

@@ -271,6 +271,7 @@
     <Compile Include="ConstraintSolver\MemberConstraints.fs" />
     <Compile Include="ConstraintSolver\ObjInference.fs" />
     <Compile Include="Interop\DeeplyNestedCSharpClasses.fs" />
+    <Compile Include="Interop\DIMSlotCoverageTests.fs" />
     <Compile Include="Interop\SimpleInteropTests.fs" />
     <Compile Include="Interop\RequiredAndInitOnlyProperties.fs" />
     <Compile Include="Interop\StaticsInInterfaces.fs" />