Fix FS3356 false positive: only check static extension members for duplicate type name conflict

Instance extension members compile with the extended type as the first IL parameter,
so they can never produce duplicate IL method signatures even when the simple type
name matches. Only static extension members lack this distinguishing parameter.

This fixes a regression where libraries like IcedTasks that define instance (inline)
extension members on builder types from different namespaces (e.g.
Microsoft.FSharp.Control.TaskBuilderBase and IcedTasks.TaskBase.TaskBuilderBase)
were incorrectly rejected.

Regression introduced by PR #18821 (commit e948a68).

Author: T-Gro

src/Compiler/Checking/PostInferenceChecks.fs

@@ -2680,21 +2680,27 @@ let CheckEntityDefns cenv env tycons =
 // check modules
 //--------------------------------------------------------------------------
 
-/// Check for duplicate extension member names that would cause IL conflicts.
-/// Extension members for types with the same simple name but different fully qualified names 
-/// will be emitted into the same IL container type, causing a duplicate member error.
+/// Check for duplicate static extension member names that would cause IL conflicts.
+/// Static extension members for types with the same simple name but different fully qualified names
+/// compile to static methods in the same module IL type without a distinguishing first parameter,
+/// so they can produce duplicate IL method signatures.
+/// Instance extension members are safe because they compile with the extended type as the first
+/// parameter, which differentiates the IL signatures.
 let CheckForDuplicateExtensionMemberNames (cenv: cenv) (vals: Val seq) =
     if cenv.reportErrors then
-        let extensionMembers = 
+        let staticExtensionMembers = 
             vals 
-            |> Seq.filter (fun v -> v.IsExtensionMember && v.IsMember)
+            |> Seq.filter (fun v ->
+                v.IsExtensionMember
+                && v.IsMember
+                && not (v.IsInstanceMember))
             |> Seq.toList
 
-        if not extensionMembers.IsEmpty then
+        if not staticExtensionMembers.IsEmpty then
             // Group by LogicalName which includes generic arity suffix (e.g., Expr`1 for Expr<'T>)
             // This matches how types are compiled to IL, so Expr and Expr<'T> are separate groups
             let groupedByLogicalName =
-                extensionMembers
+                staticExtensionMembers
                 |> List.groupBy (fun v -> v.MemberApparentEntity.LogicalName)
 
             for (logicalName, members) in groupedByLogicalName do

tests/FSharp.Compiler.ComponentTests/Language/ExtensionMethodTests.fs

@@ -697,7 +697,9 @@ module CompiledExtensions =
         ]
 
     [<Fact>]
-    let ``Instance extension members for types with same simple name should error`` () =
+    let ``Instance extension members for types with same simple name should succeed`` () =
+        // Instance extension members compile with the extended type as the first IL parameter,
+        // so they can never produce duplicate IL signatures even with same simple type name.
         Fsx
             """
 module Compiled
@@ -712,10 +714,7 @@ module CompiledExtensions =
         member _.InstanceExtension() = ()
             """
         |> compile
-        |> shouldFail
-        |> withDiagnostics [
-            (Error 3356, Line 11, Col 18, Line 11, Col 35, "Extension members extending types with the same simple name 'Task' but different fully qualified names cannot be defined in the same module. Consider defining these extensions in separate modules.")
-        ]
+        |> shouldSucceed
 
     [<Fact>]
     let ``Extension members on generic types with same simple name should error`` () =
@@ -806,3 +805,48 @@ module CompiledExtensions =
             (Error 3356, Line 12, Col 23, Line 12, Col 33, "Extension members extending types with the same simple name 'Task' but different fully qualified names cannot be defined in the same module. Consider defining these extensions in separate modules.")
             (Error 3356, Line 13, Col 23, Line 13, Col 33, "Extension members extending types with the same simple name 'Task' but different fully qualified names cannot be defined in the same module. Consider defining these extensions in separate modules.")
         ]
+
+    [<Fact>]
+    let ``Instance inline extension members on builder types with same simple name should succeed`` () =
+        // Regression test for IcedTasks-like pattern: instance (inline) extension members on
+        // computation expression builder types with the same simple name from different namespaces.
+        // Instance extension members compile with the extended type as the first IL parameter,
+        // so signatures never collide even when the simple type name is the same.
+        Fsx
+            """
+namespace NsA
+type BuilderBase() = class end
+
+namespace NsB
+type BuilderBase() = class end
+
+namespace Extensions
+module M =
+    type NsA.BuilderBase with
+        member inline this.Bind(x: int, f) = f x
+        member inline this.ReturnFrom(x: int) = x
+
+    type NsB.BuilderBase with
+        member inline this.Source(x: int) = x
+        member inline this.Bind(x: string, f) = f x
+            """
+        |> compile
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``Mixed static and instance extension members - only static should error`` () =
+        Fsx
+            """
+module Compiled
+
+type Task = { F: int }
+
+module CompiledExtensions =
+    type System.Threading.Tasks.Task with
+        static member StaticExt() = ()
+
+    type Task with
+        member _.InstanceExt() = ()
+            """
+        |> compile
+        |> shouldSucceed