[Repo Assist] tests: add GenerativeMethodsTests (6 focused method tests for generative type providers) (#505)

🤖 *This is an automated PR from Repo Assist.*

## Summary

**Task 9 – Testing Improvements**: Add `GenerativeMethodsTests.fs` with
6 dedicated tests for methods in generative type providers.

---

## Changes

### New: `tests/GenerativeMethodsTests.fs`

Six tests covering methods in generative type providers:

1. **Instance method is present** — verifies `Greet()` is emitted, is
non-static
2. **Instance method return type** — verifies `Greet()` returns `string`
with no parameters
3. **Instance method with parameters** — verifies `Add(x: int, y: int) :
int` has correct parameter names, types, and return type
4. **Static method is present** — verifies `Create()` is emitted as a
static method returning `obj`
5. **Method lookup by name** — calls `GetMethod(name)` for all three
methods; directly exercises the `ILMethodDefs` lazy name-lookup
dictionary
6. **Method count** — verifies the exact number of declared methods on
the generated type

### Updated: `tests/FSharp.TypeProviders.SDK.Tests.fsproj`

Added `GenerativeMethodsTests.fs` to the compile group (after
`GenerativeDelegateTests.fs`).

---

## Motivation

The existing tests exercise methods indirectly (e.g. via
`BasicGenerativeProvisionTests.fs`) but there was no dedicated,
self-contained file for method reflection on generative types — unlike
the dedicated files already present for events, delegates, enums,
interfaces, structs, abstract classes, and equality comparisons. Having
a focused file makes it easier to diagnose regressions and documents the
expected method-reflection contract.

---

## Test Status

✅ **137/137 tests pass** (baseline was 131; 6 new tests added, all
green)

```
Passed!  - Failed: 0, Passed: 137, Skipped: 0, Total: 137
```




> Generated by 🌈 Repo Assist, see [workflow
run](https://github.com/fsprojects/FSharp.TypeProviders.SDK/actions/runs/24541555872).
[Learn
more](https://github.com/githubnext/agentics/blob/main/docs/repo-assist.md).
>
> To install this [agentic
workflow](https://github.com/githubnext/agentics/blob/97143ac59cb3a13ef2a77581f929f06719c7402a/workflows/repo-assist.md),
run
> ```
> gh aw add
githubnext/agentics@97143ac
> ```

<!-- gh-aw-agentic-workflow: Repo Assist, engine: copilot, model: auto,
id: 24541555872, workflow_id: repo-assist, run:
https://github.com/fsprojects/FSharp.TypeProviders.SDK/actions/runs/24541555872
-->

<!-- gh-aw-workflow-id: repo-assist -->

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

tests/FSharp.TypeProviders.SDK.Tests.fsproj

@@ -23,6 +23,7 @@
     <Compile Include="GenerativeEventsTests.fs" />
     <Compile Include="GenerativePropertiesTests.fs" />
     <Compile Include="GenerativeDelegateTests.fs" />
+    <Compile Include="GenerativeMethodsTests.fs" />
     <Compile Include="ReferencedAssemblies.fs" />
   </ItemGroup>
   <ItemGroup>

tests/GenerativeMethodsTests.fs

@@ -0,0 +1,147 @@
+module TPSDK.GenerativeMethodsTests
+
+#nowarn "760" // IDisposable needs new
+
+open System
+open System.Reflection
+open Microsoft.FSharp.Core.CompilerServices
+open Microsoft.FSharp.Quotations
+open Xunit
+open ProviderImplementation.ProvidedTypes
+open ProviderImplementation.ProvidedTypesTesting
+
+/// Type provider with a generative type that has instance methods, a static method, and a constructor.
+/// The Widget type exposes:
+///   - instance method  Greet()        : string
+///   - instance method  Add(x:int, y:int) : int
+///   - static  method   Create()       : obj
+[<TypeProvider>]
+type GenerativeMethodsProvider (config: TypeProviderConfig) as this =
+    inherit TypeProviderForNamespaces (config)
+
+    let ns = "Methods.Provided"
+    let tempAssembly = ProvidedAssembly()
+    let container = ProvidedTypeDefinition(tempAssembly, ns, "Container", Some typeof<obj>, isErased = false)
+
+    do
+        let widgetType = ProvidedTypeDefinition("Widget", Some typeof<obj>, isErased = false)
+
+        // Instance method: Greet() : string
+        let greetCode (_args: Expr list) = <@@ "Hello" @@>
+        let greetMethod = ProvidedMethod("Greet", [], typeof<string>, invokeCode = greetCode, isStatic = false)
+        widgetType.AddMember greetMethod
+
+        // Instance method with parameters: Add(x: int, y: int) : int
+        let addCode (args: Expr list) = <@@ (%%(args.[1]) : int) + (%%(args.[2]) : int) @@>
+        let addMethod =
+            ProvidedMethod(
+                "Add",
+                [ ProvidedParameter("x", typeof<int>); ProvidedParameter("y", typeof<int>) ],
+                typeof<int>,
+                invokeCode = addCode,
+                isStatic = false)
+        widgetType.AddMember addMethod
+
+        // Static method: Create() : obj
+        let createCode (_args: Expr list) = <@@ obj() @@>
+        let createMethod = ProvidedMethod("Create", [], typeof<obj>, invokeCode = createCode, isStatic = true)
+        widgetType.AddMember createMethod
+
+        widgetType.AddMember (ProvidedConstructor([], invokeCode = fun _ -> <@@ () @@>))
+        container.AddMember widgetType
+
+        tempAssembly.AddTypes [container]
+        this.AddNamespace(ns, [container])
+
+let loadTestAssembly () =
+    let runtimeAssemblyRefs = Targets.DotNetStandard20FSharpRefs()
+    let runtimeAssembly = runtimeAssemblyRefs.[0]
+    let cfg = Testing.MakeSimulatedTypeProviderConfig (__SOURCE_DIRECTORY__, runtimeAssembly, runtimeAssemblyRefs)
+    let tp = GenerativeMethodsProvider(cfg) :> TypeProviderForNamespaces
+    let providedNamespace = tp.Namespaces.[0]
+    let providedType = providedNamespace.GetTypes().[0] :?> ProvidedTypeDefinition
+    Assert.Equal("Container", providedType.Name)
+    let bytes = (tp :> ITypeProvider).GetGeneratedAssemblyContents(providedType.Assembly)
+    Assembly.Load bytes
+
+[<Fact>]
+let ``Generative instance method Greet is present in generated assembly``() =
+    let assembly = loadTestAssembly ()
+    let containerType = assembly.ExportedTypes |> Seq.find (fun t -> t.Name = "Container")
+    let widgetType = containerType.GetNestedType("Widget")
+    Assert.NotNull(widgetType)
+
+    let meth = widgetType.GetMethod("Greet", BindingFlags.Instance ||| BindingFlags.Public)
+    Assert.NotNull(meth)
+    Assert.Equal("Greet", meth.Name)
+    Assert.False(meth.IsStatic, "Greet should be an instance method")
+
+[<Fact>]
+let ``Generative instance method Greet has correct return type``() =
+    let assembly = loadTestAssembly ()
+    let containerType = assembly.ExportedTypes |> Seq.find (fun t -> t.Name = "Container")
+    let widgetType = containerType.GetNestedType("Widget")
+    Assert.NotNull(widgetType)
+
+    let meth = widgetType.GetMethod("Greet", BindingFlags.Instance ||| BindingFlags.Public)
+    Assert.NotNull(meth)
+    Assert.Equal(typeof<string>, meth.ReturnType)
+    let parms = meth.GetParameters()
+    Assert.Equal(0, parms.Length)
+
+[<Fact>]
+let ``Generative instance method Add has correct parameter types``() =
+    let assembly = loadTestAssembly ()
+    let containerType = assembly.ExportedTypes |> Seq.find (fun t -> t.Name = "Container")
+    let widgetType = containerType.GetNestedType("Widget")
+    Assert.NotNull(widgetType)
+
+    let meth = widgetType.GetMethod("Add", BindingFlags.Instance ||| BindingFlags.Public)
+    Assert.NotNull(meth)
+    Assert.Equal("Add", meth.Name)
+    Assert.Equal(typeof<int>, meth.ReturnType)
+
+    let parms = meth.GetParameters()
+    Assert.Equal(2, parms.Length)
+    Assert.Equal("x", parms.[0].Name)
+    Assert.Equal(typeof<int>, parms.[0].ParameterType)
+    Assert.Equal("y", parms.[1].Name)
+    Assert.Equal(typeof<int>, parms.[1].ParameterType)
+
+[<Fact>]
+let ``Generative static method Create is present and is static``() =
+    let assembly = loadTestAssembly ()
+    let containerType = assembly.ExportedTypes |> Seq.find (fun t -> t.Name = "Container")
+    let widgetType = containerType.GetNestedType("Widget")
+    Assert.NotNull(widgetType)
+
+    let meth = widgetType.GetMethod("Create", BindingFlags.Static ||| BindingFlags.Public)
+    Assert.NotNull(meth)
+    Assert.Equal("Create", meth.Name)
+    Assert.True(meth.IsStatic, "Create should be a static method")
+    Assert.Equal(typeof<obj>, meth.ReturnType)
+
+[<Fact>]
+let ``Generative type methods can be looked up by name``() =
+    // Directly exercises the ILMethodDefs lazy name-lookup dictionary.
+    let assembly = loadTestAssembly ()
+    let containerType = assembly.ExportedTypes |> Seq.find (fun t -> t.Name = "Container")
+    let widgetType = containerType.GetNestedType("Widget")
+    Assert.NotNull(widgetType)
+
+    let bf = BindingFlags.Instance ||| BindingFlags.Static ||| BindingFlags.Public
+    Assert.NotNull(widgetType.GetMethod("Greet",  bf))
+    Assert.NotNull(widgetType.GetMethod("Add",    bf))
+    Assert.NotNull(widgetType.GetMethod("Create", bf))
+
+[<Fact>]
+let ``Generative type has expected method count``() =
+    let assembly = loadTestAssembly ()
+    let containerType = assembly.ExportedTypes |> Seq.find (fun t -> t.Name = "Container")
+    let widgetType = containerType.GetNestedType("Widget")
+    Assert.NotNull(widgetType)
+
+    // 3 declared methods: Greet, Add, Create  (excludes inherited Object methods and .ctor)
+    let declaredMethods =
+        widgetType.GetMethods(BindingFlags.Instance ||| BindingFlags.Static ||| BindingFlags.Public ||| BindingFlags.DeclaredOnly)
+    Assert.Equal(3, declaredMethods.Length)