Fix nativeptr type erasure to preserve element type in overload resolution

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

@@ -2,6 +2,7 @@
 
 * Scripts: Fix resolving the dotnet host path when an SDK directory is specified. ([PR #18960](https://github.com/dotnet/fsharp/pull/18960))
 * Fix excessive StackGuard thread jumping ([PR #18971](https://github.com/dotnet/fsharp/pull/18971))
+* Adjust conservative method-overload duplicate detection rules for nativeptr types ([PR #18911](https://github.com/dotnet/fsharp/pull/18911))
 * Fix name is bound multiple times is not reported in 'as' pattern ([PR #18984](https://github.com/dotnet/fsharp/pull/18984))
 * Type relations cache: handle potentially "infinite" types ([PR #19010](https://github.com/dotnet/fsharp/pull/19010))  
 

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

@@ -16,5 +16,6 @@
 
 * Warn on uppercase identifiers in patterns. ([PR #15816](https://github.com/dotnet/fsharp/pull/15816))
 * Error on invalid declarations in type definitions.([Issue #10066](https://github.com/dotnet/fsharp/issues/10066), [PR #18813](https://github.com/dotnet/fsharp/pull/18813))
+* Fix type erasure logic for `nativeptr<'T>` overloads to properly preserve element type differences during duplicate member checking. ([Issue #<ISSUE_NUMBER>](https://github.com/dotnet/fsharp/issues/<ISSUE_NUMBER>), [PR #<PR_NUMBER>](https://github.com/dotnet/fsharp/pull/<PR_NUMBER>))
 
 ### Changed

src/Compiler/TypedTree/TypedTreeOps.fs

@@ -799,7 +799,8 @@ let rec stripTyEqnsAndErase eraseFuncAndTuple (g: TcGlobals) ty =
             let reducedTy2 = addNullnessToTy nullness reducedTy
             stripTyEqnsAndErase eraseFuncAndTuple g reducedTy2
         elif tyconRefEq g tcref g.nativeptr_tcr && eraseFuncAndTuple then 
-            stripTyEqnsAndErase eraseFuncAndTuple g g.nativeint_ty
+            // Regression fix (issue #<ISSUE_NUMBER>): nativeptr<'T> erases to ilsigptr<'T>, not nativeint
+            stripTyEqnsAndErase eraseFuncAndTuple g (TType_app(g.ilsigptr_tcr, args, nullness))
         else
             ty
 

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MemberDefinitions/OverloadingMembers/NativePtrOverloads01.fs

@@ -0,0 +1,9 @@
+module NativePtrOverloads01
+open Microsoft.FSharp.NativeInterop
+#nowarn "9"
+
+type P =
+    static member Do(p: nativeptr<int>) = 1
+    static member Do(p: nativeptr<int64>) = 2
+
+let _invoke (pi: nativeptr<int>) (pl: nativeptr<int64>) = P.Do pi + P.Do pl

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MemberDefinitions/OverloadingMembers/NativePtrOverloads02.fs

@@ -0,0 +1,7 @@
+module NativePtrOverloads02
+open Microsoft.FSharp.NativeInterop
+#nowarn "9"
+
+type Q =
+    static member M(p: nativeptr<int>) = 0
+    static member M(p: nativeptr<int>) = 1  // expect duplicate member error

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MemberDefinitions/OverloadingMembers/NativePtrOverloads03.fs

@@ -0,0 +1,8 @@
+module NativePtrOverloads03
+open Microsoft.FSharp.NativeInterop
+#nowarn "9"
+// Regression test for issue #<ISSUE_NUMBER>
+
+type R =
+    static member F(p: nativeptr<uint16>) = 0us
+    static member F(p: nativeptr<int64>) = 0L

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MemberDefinitions/OverloadingMembers/NativePtrOverloads04.fs

@@ -0,0 +1,9 @@
+module NativePtrOverloads04
+open Microsoft.FSharp.NativeInterop
+#nowarn "9"
+[<Measure>] type kg
+[<Measure>] type m
+
+type S =
+    static member H(p: nativeptr<int<kg>>) = 1
+    static member H(p: nativeptr<int<m>>) = 2  // expect duplicate member error

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MemberDefinitions/OverloadingMembers/OverloadingMembers.fs

@@ -235,3 +235,49 @@ module MemberDefinitions_OverloadingMembers =
         compilation
         |> verifyCompileAndRun
         |> shouldSucceed
+
+    // Native pointer overload tests for regression fix
+
+    // NativePtrOverloads01.fs - distinct native pointer element types should compile
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NativePtrOverloads01.fs"|])>]
+    let ``NativePtrOverloads01_fs`` compilation =
+        compilation
+        |> asLibrary
+        |> withOptions ["--nowarn:9"]
+        |> compile
+        |> shouldSucceed
+
+    // NativePtrOverloads02.fs - duplicate exact signatures should fail
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NativePtrOverloads02.fs"|])>]
+    let ``NativePtrOverloads02_fs`` compilation =
+        compilation
+        |> asLibrary
+        |> withOptions ["--nowarn:9"]
+        |> compile
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 438, Line 7, Col 19, Line 7, Col 20, "Duplicate method. The method 'M' has the same name and signature as another method in type 'Q'.")
+            (Error 438, Line 6, Col 19, Line 6, Col 20, "Duplicate method. The method 'M' has the same name and signature as another method in type 'Q'.")           
+        ]
+
+    // NativePtrOverloads03.fs - regression test, previously failing overloads should now compile
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NativePtrOverloads03.fs"|])>]
+    let ``NativePtrOverloads03_fs`` compilation =
+        compilation
+        |> asLibrary
+        |> withOptions ["--nowarn:9"]
+        |> compile
+        |> shouldSucceed
+
+    // NativePtrOverloads04.fs - erased differences via measures should still fail
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NativePtrOverloads04.fs"|])>]
+    let ``NativePtrOverloads04_fs`` compilation =
+        compilation
+        |> asLibrary
+        |> withOptions ["--nowarn:9"]
+        |> compile
+        |> shouldFail
+        |> withDiagnostics [            
+            (Error 438, Line 9, Col 19, Line 9, Col 20, "Duplicate method. The method 'H' has the same name and signature as another method in type 'S' once tuples, functions, units of measure and/or provided types are erased.")
+            (Error 438, Line 8, Col 19, Line 8, Col 20, "Duplicate method. The method 'H' has the same name and signature as another method in type 'S' once tuples, functions, units of measure and/or provided types are erased.")
+        ]

tests/fsharp/typecheck/sigs/neg23.bsl

@@ -11,14 +11,6 @@ neg23.fs(28,21,28,24): typecheck error FS0438: Duplicate method. The method 'Foo
 
 neg23.fs(26,21,26,24): typecheck error FS0438: Duplicate method. The method 'Foo' has the same name and signature as another method in type 'DuplicateOverloadUpToErasure3.SomeClass'.
 
-neg23.fs(55,21,55,24): typecheck error FS0438: Duplicate method. The method 'Foo' has the same name and signature as another method in type 'DuplicateOverloadUpToErasure6.SomeClass' once tuples, functions, units of measure and/or provided types are erased.
-
-neg23.fs(53,21,53,24): typecheck error FS0438: Duplicate method. The method 'Foo' has the same name and signature as another method in type 'DuplicateOverloadUpToErasure6.SomeClass' once tuples, functions, units of measure and/or provided types are erased.
-
-neg23.fs(64,21,64,24): typecheck error FS0438: Duplicate method. The method 'Foo' has the same name and signature as another method in type 'DuplicateOverloadUpToErasure7.SomeClass' once tuples, functions, units of measure and/or provided types are erased.
-
-neg23.fs(62,21,62,24): typecheck error FS0438: Duplicate method. The method 'Foo' has the same name and signature as another method in type 'DuplicateOverloadUpToErasure7.SomeClass' once tuples, functions, units of measure and/or provided types are erased.
-
 neg23.fs(76,9,76,11): typecheck error FS0410: The type 'IA' is less accessible than the value, member or type 'IB' it is used in.
 
 neg23.fs(83,18,83,20): typecheck error FS0439: The method 'X0' has curried arguments but has the same name as another method in type 'TestCurriedMemberRestrictions.C'. Methods with curried arguments cannot be overloaded. Consider using a method taking tupled arguments.

tests/fsharp/typecheck/sigs/neg23.fs

@@ -46,17 +46,17 @@ module DuplicateOverloadUpToErasure5 =  begin
         member this.Foo (x:System.Tuple<int,int,int,int,int,int,System.Tuple<int>>) = printfn "method 2"
 end
 
-module DuplicateOverloadUpToErasure6 =  begin
-
+module NotAnyMoreDuplicateOverloadUpToErasure6 =  begin
+    // This is not the same IL type, not a duplicate
     type SomeClass() =
 
         member this.Foo (x:nativeptr<int>) = printfn "method 1"
 
         member this.Foo (x:nativeint) =  printfn "method 2"
 end
 
-module DuplicateOverloadUpToErasure7 =  begin
-
+module NotAnyMoreDuplicateOverloadUpToErasure7 =  begin
+    // This is not the same IL type, not a duplicate
     type SomeClass() =
 
         member this.Foo (x:(int*int)*int*(int*nativeptr<int>)*int*int) = printfn "method 1"