Detect and error on duplicate static extension member container names in the same module (same name, different namespaces) (#18821)

Author: Copilot

docs/release-notes/.FSharp.Compiler.Service/10.0.200.md

@@ -10,6 +10,7 @@
 
 ### Added
 
+* Detect and error on static extension members extending types with the same simple name but different namespaces in the same module. ([PR #18821](https://github.com/dotnet/fsharp/pull/18821))
 * FSharpDiagnostic: add default severity ([#19152](https://github.com/dotnet/fsharp/pull/19152))
 * Add warning FS3879 for XML documentation comments not positioned as first non-whitespace on line. ([PR #18891](https://github.com/dotnet/fsharp/pull/18891))
 * FsiEvaluationSession.ParseAndCheckInteraction: add keepAssemblyContents optional parameter ([#19155](https://github.com/dotnet/fsharp/pull/19155)) 

src/Compiler/Checking/PostInferenceChecks.fs

@@ -2680,6 +2680,36 @@ 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.
+let CheckForDuplicateExtensionMemberNames (cenv: cenv) (vals: Val seq) =
+    if cenv.reportErrors then
+        let extensionMembers = 
+            vals 
+            |> Seq.filter (fun v -> v.IsExtensionMember && v.IsMember)
+            |> Seq.toList
+
+        if not extensionMembers.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
+                |> List.groupBy (fun v -> v.MemberApparentEntity.LogicalName)
+            
+            for (logicalName, members) in groupedByLogicalName do
+                // Check if members extend types from different namespaces/assemblies
+                let distinctNamespacePaths = 
+                    members 
+                    |> List.map (fun v -> v.MemberApparentEntity.CompilationPath.MangledPath)
+                    |> List.distinct
+                
+                if distinctNamespacePaths.Length > 1 then
+                    // Found extensions for types with same LogicalName but different fully qualified names
+                    // Report error on the second (and subsequent) extensions
+                    for v in members |> List.skip 1 do
+                        errorR(Error(FSComp.SR.tcDuplicateExtensionMemberNames(logicalName), v.Range))
+
 let rec CheckDefnsInModule cenv env mdefs =
     for mdef in mdefs do
         CheckDefnInModule cenv env mdef
@@ -2689,6 +2719,7 @@ and CheckNothingAfterEntryPoint cenv m =
         errorR(Error(FSComp.SR.chkEntryPointUsage(), m))
 
 and CheckDefnInModule cenv env mdef =
+    CheckForDuplicateExtensionMemberNames cenv (allTopLevelValsOfModDef mdef)
     match mdef with
     | TMDefRec(isRec, _opens, tycons, mspecs, m) ->
         CheckNothingAfterEntryPoint cenv m

src/Compiler/FSComp.txt

@@ -1621,6 +1621,7 @@ featureLowerSimpleMappingsInComprehensionsToFastLoops,"Lowers [for x in xs -> f
 3354,tcNotAFunctionButIndexerIndexingNotYetEnabled,"This expression supports indexing, e.g. 'expr.[index]'. The syntax 'expr[index]' requires /langversion:preview. See https://aka.ms/fsharp-index-notation."
 3355,tcNotAnIndexerNamedIndexingNotYetEnabled,"The value '%s' is not a function and does not support index notation."
 3355,tcNotAnIndexerIndexingNotYetEnabled,"This expression is not a function and does not support index notation."
+3356,tcDuplicateExtensionMemberNames,"Extension members extending types with the same simple name '%s' but different fully qualified names cannot be defined in the same module. Consider defining these extensions in separate modules."
 3360,typrelInterfaceWithConcreteAndVariable,"'%s' cannot implement the interface '%s' with the two instantiations '%s' and '%s' because they may unify."
 3361,typrelInterfaceWithConcreteAndVariableObjectExpression,"You cannot implement the interface '%s' with the two instantiations '%s' and '%s' because they may unify."
 featureInterfacesWithMultipleGenericInstantiation,"interfaces with multiple generic instantiation"

src/Compiler/TypedTree/TypedTreeOps.fs

@@ -6446,23 +6446,31 @@ and allEntitiesOfModDef mdef =
                   yield! allEntitiesOfModDef def
     }
 
-and allValsOfModDef mdef = 
+and allValsOfModDefWithOption processNested mdef = 
     seq { match mdef with 
           | TMDefRec(_, _, tycons, mbinds, _) -> 
               yield! abstractSlotValsOfTycons tycons 
               for mbind in mbinds do 
                 match mbind with 
                 | ModuleOrNamespaceBinding.Binding bind -> yield bind.Var
-                | ModuleOrNamespaceBinding.Module(_, def) -> yield! allValsOfModDef def
+                | ModuleOrNamespaceBinding.Module(_, def) -> 
+                    if processNested then
+                        yield! allValsOfModDefWithOption processNested def
           | TMDefLet(bind, _) -> 
               yield bind.Var
           | TMDefDo _ -> ()
           | TMDefOpens _ -> ()
           | TMDefs defs -> 
               for def in defs do 
-                  yield! allValsOfModDef def
+                  yield! allValsOfModDefWithOption processNested def
     }
 
+and allValsOfModDef mdef = 
+    allValsOfModDefWithOption true mdef
+
+and allTopLevelValsOfModDef mdef = 
+    allValsOfModDefWithOption false mdef
+
 and copyAndRemapModDef ctxt compgen tmenv mdef =
     let tycons = allEntitiesOfModDef mdef |> List.ofSeq
     let vs = allValsOfModDef mdef |> List.ofSeq

src/Compiler/TypedTree/TypedTreeOps.fsi

@@ -2758,6 +2758,8 @@ val (|InnerExprPat|): Expr -> Expr
 
 val allValsOfModDef: ModuleOrNamespaceContents -> seq<Val>
 
+val allTopLevelValsOfModDef: ModuleOrNamespaceContents -> seq<Val>
+
 val BindUnitVars: TcGlobals -> Val list * ArgReprInfo list * Expr -> Val list * Expr
 
 val isThreadOrContextStatic: TcGlobals -> Attrib list -> bool