Workaround for target assemblies where packages with transitive references contain type providers (#388)

dsyme · web-flow · commit 7ea7cde0af0d · 2022-08-17T16:39:45.000+01:00
* compute correct referenced assemblies

* apply fix

* update template paket.lock

* add testing

* fix lang version
diff --git a/src/FSharp.TypeProviders.SDK.fsproj b/src/FSharp.TypeProviders.SDK.fsproj
@@ -10,6 +10,7 @@
     <Description>The core implementation of an F# type provider</Description>
     <Tags>F# fsharp typeprovider</Tags>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <LangVersion>5.0</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="AssemblyInfo.fs" />
diff --git a/src/ProvidedTypes.fs b/src/ProvidedTypes.fs
diff --git a/src/ProvidedTypes.fsi b/src/ProvidedTypes.fsi
@@ -1,4 +1,4 @@
-﻿// Copyright (c) Microsoft Corporation 2005-2014 and other contributors.
+// Copyright (c) Microsoft Corporation 2005-2014 and other contributors.
 // This sample code is provided "as is" without warranty of any kind.
 // We disclaim all warranties, either express or implied, including the
 // warranties of merchantability and fitness for a particular purpose.
@@ -404,9 +404,6 @@ type ProvidedTypesContext =
     /// Try to find the given target assembly in the context
     member TryBindSimpleAssemblyNameToTarget: assemblyName: string  -> Choice<Assembly, exn> 
 
-    /// Get the list of referenced assemblies determined by the type provider configuration
-    member ReferencedAssemblyPaths: string list
-
     /// Get the resolved referenced assemblies determined by the type provider configuration
     member GetTargetAssemblies : unit -> Assembly[]
 
@@ -509,8 +506,7 @@ type TypeProviderForNamespaces =
 
 #if !NO_GENERATIVE
     /// Register that a given file is a provided generated target assembly, e.g. an assembly produced by an external
-    /// code generation tool.  This assembly should be a target assembly, i.e. use the same asssembly references
-    /// as given by TargetContext.ReferencedAssemblyPaths
+    /// code generation tool.  This assembly should be a target assembly.
     member RegisterGeneratedTargetAssembly: fileName: string -> Assembly
 #endif
 
@@ -557,4 +553,3 @@ module internal AssemblyReader =
     
         val GetWeakReaderCache : unit -> System.Collections.Concurrent.ConcurrentDictionary<(string * string), DateTime * WeakReference<ILModuleReader>>
         val GetStrongReaderCache : unit -> System.Collections.Concurrent.ConcurrentDictionary<(string * string), DateTime * int * ILModuleReader>
-    
diff --git a/templates/content/basic/paket.lock b/templates/content/basic/paket.lock
diff --git a/tests/BasicErasedProvisionTests.fs b/tests/BasicErasedProvisionTests.fs
@@ -1,11 +1,4 @@
-#if INTERACTIVE
-#load "../src/ProvidedTypes.fsi" "../src/ProvidedTypes.fs"
-#load "../src/ProvidedTypesTesting.fs"
-
-#else
-
 module TPSDK.BasicErasedTests
-#endif
 
 open System
 open System.Reflection
@@ -451,7 +444,7 @@ type ErasingProviderWithCustomAttributes (config : TypeProviderConfig) as this =
         this.AddNamespace(ns, createTypes())
 
 [<Fact>]
-let ``ErasingConstructorProvider generates for .NET Standard 2.0 correctly``() : unit  = 
+let ``ErasingConstructorProvider generates for netstandard20 correctly``() : unit  = 
     printfn "--------- Generating code for .NET Standard 2.0  ------"
     let res = testCrossTargeting (Targets.DotNetStandard20FSharpRefs()) (fun args -> new ErasingConstructorProvider(args)) [| |]
     Assert.False(res.Contains "[FSharp.Core, Version=3.259.4.1")
diff --git a/tests/BasicGenerativeProvisionTests.fs b/tests/BasicGenerativeProvisionTests.fs
@@ -1,10 +1,4 @@
-#if INTERACTIVE
-#load "../src/ProvidedTypes.fsi" "../src/ProvidedTypes.fs"
-#load "../src/ProvidedTypesTesting.fs"
-
-#else
-module TPSDK.Tests.BasicGenerativeTests
-#endif
+module TPSDK.BasicGenerativeTests
 
 open System
 open System.IO
diff --git a/tests/FSharp.TypeProviders.SDK.Tests.fsproj b/tests/FSharp.TypeProviders.SDK.Tests.fsproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFramework>net5.0</TargetFramework>
     <IsPackable>false</IsPackable>
+    <LangVersion>5.0</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <None Include="paket.references" />
@@ -17,6 +18,7 @@
     <Compile Include="GenerativeEnumsProvisionTests.fs" />
     <Compile Include="GenerativeInterfacesTests.fs" />
     <Compile Include="GenerativeAbstractClassesTests.fs" />
+    <Compile Include="ReferencedAssemblies.fs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\src\FSharp.TypeProviders.SDK.fsproj" />
diff --git a/tests/GeneratedCodeTests.fs b/tests/GeneratedCodeTests.fs
@@ -1,11 +1,4 @@
-#if INTERACTIVE
-#load "../src/ProvidedTypes.fsi" "../src/ProvidedTypes.fs" 
-#load "../src/ProvidedTypesTesting.fs"
-
-#else
-
 module TPSDK.GeneratedCodeTests
-#endif
 
 open System
 open System.Reflection
diff --git a/tests/GeneratedOpTests.fs b/tests/GeneratedOpTests.fs
@@ -1,11 +1,4 @@
-#if INTERACTIVE
-#load "../src/ProvidedTypes.fsi" "../src/ProvidedTypes.fs" 
-#load "../src/ProvidedTypesTesting.fs"
-
-#else
-
 module TPSDK.GeneratedOpTests
-#endif
 
 open System
 open System.Reflection
diff --git a/tests/GenerativeAbstractClassesTests.fs b/tests/GenerativeAbstractClassesTests.fs
@@ -1,11 +1,4 @@
-#if INTERACTIVE
-#load "../src/ProvidedTypes.fsi" "../src/ProvidedTypes.fs" 
-#load "../src/ProvidedTypesTesting.fs"
-
-#else
-
-module FSharp.TypeProviders.SDK.Tests.GenerativeAbstractClassesTests
-#endif
+module TPSDK.GenerativeAbstractClassesTests
 
 #nowarn "760" // IDisposable needs new
 
diff --git a/tests/GenerativeEnumsProvisionTests.fs b/tests/GenerativeEnumsProvisionTests.fs
@@ -1,11 +1,4 @@
-#if INTERACTIVE
-#load "../src/ProvidedTypes.fsi" "../src/ProvidedTypes.fs" 
-#load "../src/ProvidedTypesTesting.fs"
-
-#else
-
 module TPSDK.GenerativeEnumsProvisionTests
-#endif
 
 #nowarn "760" // IDisposable needs new
 
diff --git a/tests/GenerativeInterfacesTests.fs b/tests/GenerativeInterfacesTests.fs
@@ -1,11 +1,4 @@
-#if INTERACTIVE
-#load "../src/ProvidedTypes.fsi" "../src/ProvidedTypes.fs" 
-#load "../src/ProvidedTypesTesting.fs"
-
-#else
-
-module FSharp.TypeProviders.SDK.Tests.GenerativeInterfacesTests
-#endif
+module TPSDK.GenerativeInterfacesTests
 
 #nowarn "760" // IDisposable needs new
 
diff --git a/tests/ProvidedTypesTesting.fs b/tests/ProvidedTypesTesting.fs
@@ -15,17 +15,61 @@ open Microsoft.FSharp.Quotations
 open Microsoft.FSharp.Quotations.Patterns
 open Microsoft.FSharp.Reflection
 
+module Utils = 
+    let isNull x = match x with null -> true | _ -> false
+
+
+/// Simulate a real host of TypeProviderConfig
+type internal DllInfo(path: string) =
+   // Must have a property called FileName
+    member _.FileName = path
+
+/// Simulate a real host of TypeProviderConfig
+// Must be a type called TcImports
+type internal TcImports(bas: TcImports option, dllInfosInitial: DllInfo list) =
+    // Must have a field called "dllInfos"
+    let mutable dllInfos = dllInfosInitial
+    member _.Base = bas
+    member _.DllInfos = dllInfos
+    member _.AddReferencedDlls paths = dllInfos <- dllInfos @ [ for p in paths -> DllInfo(p) ]
+
 type internal Testing() =
 
     /// Simulates a real instance of TypeProviderConfig
-    static member MakeSimulatedTypeProviderConfig (resolutionFolder: string, runtimeAssembly: string, runtimeAssemblyRefs: string list, ?isHostedExecution, ?isInvalidationSupported) =
+    static member MakeSimulatedTypeProviderConfigIncremental (resolutionFolder: string, runtimeAssembly: string, runtimeAssemblyRefs: string list, ?isHostedExecution, ?isInvalidationSupported) =
         let runtimeAssemblyRefs = (runtimeAssembly :: runtimeAssemblyRefs) |> List.distinct
-        let cfg = TypeProviderConfig(fun _ -> failwith "SystemRuntimeContainsType is deprecated and should never be called")
+        let cfg = TypeProviderConfig(fun _ -> false)
         cfg.IsHostedExecution <- defaultArg isHostedExecution false
         cfg.IsInvalidationSupported <- defaultArg isInvalidationSupported true
         cfg.ResolutionFolder <- resolutionFolder
         cfg.RuntimeAssembly <- runtimeAssembly
         cfg.ReferencedAssemblies <- Array.ofList runtimeAssemblyRefs
+        let (?<-) cfg prop value =
+            let ty = cfg.GetType()
+            match ty.GetProperty(prop,BindingFlags.Instance ||| BindingFlags.Public ||| BindingFlags.NonPublic) with
+            | null -> 
+                let fld = ty.GetField(prop,BindingFlags.Instance ||| BindingFlags.Public ||| BindingFlags.NonPublic)
+                if fld = null then failwith ("expected TypeProviderConfig to have a property or field "+prop)
+                fld.SetValue(cfg, value)|> ignore
+            | p -> 
+                p.GetSetMethod(nonPublic = true).Invoke(cfg, [| box value |]) |> ignore
+
+        // Fake an implementation of SystemRuntimeContainsType the shape expected by AssemblyResolver.fs.
+        let dllInfos = [yield DllInfo(runtimeAssembly); for r in runtimeAssemblyRefs do yield DllInfo(r)]
+        let tcImports = TcImports(Some(TcImports(None,[])),dllInfos)
+        let systemRuntimeContainsType = (fun (_s:string) -> if tcImports.DllInfos.Length = 1 then true else true)
+        cfg?systemRuntimeContainsType <- systemRuntimeContainsType
+
+        //Diagnostics.Debugger.Launch() |> ignore
+        Diagnostics.Debug.Assert(cfg.GetType().GetField("systemRuntimeContainsType",BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Instance) |> isNull |> not)
+        Diagnostics.Debug.Assert(systemRuntimeContainsType.GetType().GetField("tcImports",BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Instance) |> isNull |> not)
+        Diagnostics.Debug.Assert(typeof<TcImports>.GetField("dllInfos",BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Instance) |> isNull |> not)
+        Diagnostics.Debug.Assert(typeof<TcImports>.GetProperty("Base",BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Instance) |> isNull |> not)
+        Diagnostics.Debug.Assert(typeof<DllInfo>.GetProperty("FileName",BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Instance) |> isNull |> not)
+        cfg, tcImports
+
+    static member MakeSimulatedTypeProviderConfig (resolutionFolder: string, runtimeAssembly: string, runtimeAssemblyRefs: string list, ?isHostedExecution, ?isInvalidationSupported) =
+        let cfg, _ = Testing.MakeSimulatedTypeProviderConfigIncremental (resolutionFolder, runtimeAssembly, runtimeAssemblyRefs, ?isHostedExecution=isHostedExecution, ?isInvalidationSupported=isInvalidationSupported)
         cfg
 
     /// Simulates a real instance of TypeProviderConfig and then creates an instance of the last
diff --git a/tests/ReferencedAssemblies.fs b/tests/ReferencedAssemblies.fs
@@ -0,0 +1,37 @@
+﻿module TPSDK.ReferencedAssemblies
+
+open System.Reflection
+open Microsoft.FSharp.Core.CompilerServices
+open Xunit
+open ProviderImplementation.ProvidedTypes
+open ProviderImplementation.ProvidedTypesTesting
+
+[<Fact>]
+// See https://github.com/dotnet/fsharp/issues/13710
+let ``test incremental target assemblies are available via simulated tcImports additions``() =
+    let refs = Targets.DotNetStandard20FSharpRefs()
+    let config, tcImports = Testing.MakeSimulatedTypeProviderConfigIncremental (resolutionFolder=__SOURCE_DIRECTORY__, runtimeAssembly="whatever.dll", runtimeAssemblyRefs=refs)
+    use tp1 = new TypeProviderForNamespaces(config)
+    let ctxt1 = tp1.TargetContext
+    let ns = "TestNamespace"
+    let thisAssembly = Assembly.GetExecutingAssembly()
+    let myType = ProvidedTypeDefinition(thisAssembly, ns, "TestType", Some typeof<obj>)
+    tp1.AddNamespace(ns, [myType] )
+
+    // The initial assembly references should include at least netstandard
+    printfn "finding netstandard in targets..."
+    Assert.True(ctxt1.GetTargetAssemblies() |> Array.exists (fun a -> a.GetName().Name = "netstandard"))
+
+    // We add a dummy assembly as an additional reference (we use the current assembly for no particular reason)
+    tcImports.AddReferencedDlls [ thisAssembly.Location ]
+
+    // We now evaluate the static parameters, indicating the type provider actually starts to get used
+    // This causes the type provider to do a one-off re-evaluation of the available referenced DLLs
+    let ty = tp1.Namespaces.[0].GetTypes().[0]
+    let tp2 = (tp1 :> ITypeProvider)
+    let _dummy = tp2.GetStaticParameters(ty)
+
+    // After this, the asembly is available in the target assemblies
+    printfn "finding thisAssembly in targets..."
+    Assert.True(ctxt1.GetTargetAssemblies() |> Array.exists (fun a -> a.GetName().Name = thisAssembly.GetName().Name))
+
