Fixing a few issues that were primarily impacting F#:

1 - Ensuring that package resolver does not return duplicate references
2 - Ensuring that the MetadataResolver handles duplicates when adding default references
3 - Fixing F# compilation service to get the script references and removing dependency on C# compilation
4 - Fixing issue preventing the load context from being initialized for F#, which would trigger dependency resolution failures.

Author: fabiocav

src/WebJobs.Script/Description/DotNet/CSharp/CSharpCompilationService.cs

@@ -18,34 +18,23 @@ namespace Microsoft.Azure.WebJobs.Script.Description
     [CLSCompliant(false)]
     public class CSharpCompilationService : ICompilationService
     {
-        private readonly IFunctionMetadataResolver _metadataResolver;
+        private static readonly string[] FileTypes = { ".csx", ".cs" };
         private static readonly Encoding UTF8WithNoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
         private static readonly Lazy<InteractiveAssemblyLoader> AssemblyLoader
           = new Lazy<InteractiveAssemblyLoader>(() => new InteractiveAssemblyLoader(), LazyThreadSafetyMode.ExecutionAndPublication);
 
         private readonly OptimizationLevel _optimizationLevel;
+        private readonly IFunctionMetadataResolver _metadataResolver;
 
         public CSharpCompilationService(IFunctionMetadataResolver metadataResolver, OptimizationLevel optimizationLevel)
         {
             _metadataResolver = metadataResolver;
             _optimizationLevel = optimizationLevel;
         }
 
-        public string Language
-        {
-            get
-            {
-                return "CSharp";
-            }
-        }
+        public string Language => "CSharp";
 
-        public IEnumerable<string> SupportedFileTypes
-        {
-            get
-            {
-                return new[] { ".csx", ".cs" };
-            }
-        }
+        public IEnumerable<string> SupportedFileTypes => FileTypes;
 
         public ICompilation GetFunctionCompilation(FunctionMetadata functionMetadata)
         {

src/WebJobs.Script/Description/DotNet/DotNetCompilationServiceFactory.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Immutable;
 using System.Globalization;
+using Microsoft.Azure.WebJobs.Host;
 using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.CodeAnalysis;
 
@@ -14,15 +15,15 @@ public sealed class DotNetCompilationServiceFactory : ICompilationServiceFactory
     {
         private static readonly ImmutableArray<ScriptType> SupportedScriptTypes = new[] { ScriptType.CSharp, ScriptType.FSharp, ScriptType.DotNetAssembly }.ToImmutableArray();
         private static OptimizationLevel? _optimizationLevel;
+        private readonly TraceWriter _traceWriter;
 
-        ImmutableArray<ScriptType> ICompilationServiceFactory.SupportedScriptTypes
+        public DotNetCompilationServiceFactory(TraceWriter traceWriter)
         {
-            get
-            {
-                return SupportedScriptTypes;
-            }
+            _traceWriter = traceWriter;
         }
 
+        ImmutableArray<ScriptType> ICompilationServiceFactory.SupportedScriptTypes => SupportedScriptTypes;
+
         internal static OptimizationLevel OptimizationLevel
         {
             get
@@ -60,7 +61,7 @@ public ICompilationService CreateService(ScriptType scriptType, IFunctionMetadat
                 case ScriptType.CSharp:
                     return new CSharpCompilationService(metadataResolver, OptimizationLevel);
                 case ScriptType.FSharp:
-                    return new FSharpCompiler(metadataResolver, OptimizationLevel);
+                    return new FSharpCompiler(metadataResolver, OptimizationLevel, _traceWriter);
                 case ScriptType.DotNetAssembly:
                     return new RawAssemblyCompilationService();
                 default:

src/WebJobs.Script/Description/DotNet/DotNetFunctionDescriptorProvider.cs

@@ -21,7 +21,7 @@ internal sealed class DotNetFunctionDescriptorProvider : FunctionDescriptorProvi
         private readonly ICompilationServiceFactory _compilationServiceFactory;
 
         public DotNetFunctionDescriptorProvider(ScriptHost host, ScriptHostConfiguration config)
-           : this(host, config, new DotNetCompilationServiceFactory())
+           : this(host, config, new DotNetCompilationServiceFactory(host.TraceWriter))
         {
         }
 

src/WebJobs.Script/Description/DotNet/DotNetFunctionInvoker.cs

@@ -258,15 +258,16 @@ private async Task<MethodInfo> CreateFunctionTarget(CancellationToken cancellati
                 using (_metricsLogger.LatencyEvent(eventName))
                 {
                     ICompilation compilation = _compilationService.GetFunctionCompilation(Metadata);
+
+                    Assembly assembly = compilation.EmitAndLoad(cancellationToken);
+                    _assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
+
                     FunctionSignature functionSignature = compilation.GetEntryPointSignature(_functionEntryPointResolver);
 
                     ImmutableArray<Diagnostic> bindingDiagnostics = ValidateFunctionBindingArguments(functionSignature, _triggerInputName, _inputBindings, _outputBindings, throwIfFailed: true);
                     TraceCompilationDiagnostics(bindingDiagnostics);
 
-                    Assembly assembly = compilation.EmitAndLoad(cancellationToken);
-                    _assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
-
-                    // Get our function entry point
+                    // Set our function entry point signature
                     _functionSignature = functionSignature;
                     System.Reflection.TypeInfo scriptType = assembly.DefinedTypes
                         .FirstOrDefault(t => string.Compare(t.Name, functionSignature.ParentTypeName, StringComparison.Ordinal) == 0);

src/WebJobs.Script/Description/DotNet/FSharp/FSharpCompilationService.cs

@@ -4,11 +4,13 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Host;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Scripting;
 using Microsoft.CodeAnalysis.Scripting.Hosting;
@@ -22,36 +24,26 @@ namespace Microsoft.Azure.WebJobs.Script.Description
 {
     internal class FSharpCompiler : ICompilationService
     {
-        private static readonly string[] TheWatchedFileTypes = { ".fs", ".fsx", ".dll", ".exe", ".fsi" };
+        private static readonly string[] FileTypes = { ".fs", ".fsx", ".dll", ".exe", ".fsi" };
         private readonly IFunctionMetadataResolver _metadataResolver;
         private static readonly Lazy<InteractiveAssemblyLoader> AssemblyLoader
         = new Lazy<InteractiveAssemblyLoader>(() => new InteractiveAssemblyLoader(), LazyThreadSafetyMode.ExecutionAndPublication);
 
         private readonly OptimizationLevel _optimizationLevel;
         private readonly Regex _hashRRegex;
+        private readonly TraceWriter _traceWriter;
 
-        public FSharpCompiler(IFunctionMetadataResolver metadataResolver, OptimizationLevel optimizationLevel)
+        public FSharpCompiler(IFunctionMetadataResolver metadataResolver, OptimizationLevel optimizationLevel, TraceWriter traceWriter)
         {
             _metadataResolver = metadataResolver;
             _optimizationLevel = optimizationLevel;
+            _traceWriter = traceWriter;
             _hashRRegex = new Regex(@"^\s*#r\s+", RegexOptions.Compiled | RegexOptions.IgnoreCase);
         }
 
-        public string Language
-        {
-            get
-            {
-                return "FSharp";
-            }
-        }
+        public string Language => "FSharp";
 
-        public IEnumerable<string> SupportedFileTypes
-        {
-            get
-            {
-                return TheWatchedFileTypes;
-            }
-        }
+        public IEnumerable<string> SupportedFileTypes => FileTypes;
 
         public ICompilation GetFunctionCompilation(FunctionMetadata functionMetadata)
         {
@@ -77,7 +69,6 @@ public ICompilation GetFunctionCompilation(FunctionMetadata functionMetadata)
             var resolverSource = resolverSourceBuilder.ToString();
 
             Script<object> script = CodeAnalysis.CSharp.Scripting.CSharpScript.Create(resolverSource, options: _metadataResolver.CreateScriptOptions(), assemblyLoader: AssemblyLoader.Value);
-            Compilation compilation = script.GetCompilation();
 
             var compiler = new SimpleSourceCodeServices(msbuildEnabled: FSharpOption<bool>.Some(false));
 
@@ -90,7 +81,7 @@ public ICompilation GetFunctionCompilation(FunctionMetadata functionMetadata)
 
             string scriptFilePath = Path.Combine(scriptPath, Path.GetFileName(functionMetadata.ScriptFile));
 
-            var assemblyName = FunctionAssemblyLoader.GetAssemblyNameFromMetadata(functionMetadata, compilation.AssemblyName);
+            var assemblyName = FunctionAssemblyLoader.GetAssemblyNameFromMetadata(functionMetadata, Guid.NewGuid().ToString());
             var assemblyFileName = Path.Combine(scriptPath, assemblyName + ".dll");
             var pdbName = Path.ChangeExtension(assemblyFileName, "pdb");
 
@@ -123,31 +114,16 @@ public ICompilation GetFunctionCompilation(FunctionMetadata functionMetadata)
                 // as dictated by the C# reference resolver, and F# doesn't like getting multiple references to those.
                 otherFlags.Add("--noframework");
 
-                // Add the references as reported by the C# reference resolver.
-                foreach (var mdr in compilation.References)
-                {
-                    if (!mdr.Display.Contains("Unresolved "))
+                var references = script.Options.MetadataReferences
+                    .Cast<UnresolvedMetadataReference>()
+                    .Aggregate(new List<PortableExecutableReference>(), (a, r) =>
                     {
-                        otherFlags.Add("-r:" + mdr.Display);
-                    }
-                }
+                        a.AddRange(_metadataResolver.ResolveReference(r.Reference, string.Empty, r.Properties));
+                        return a;
+                    });
 
-                // Above we have used the C# reference resolver to get the basic set of DLL references for the compilation.
-                //
-                // However F# has its own view on default options. For scripts these should include the
-                // following framework facade references.
-
-                otherFlags.Add("-r:System.Linq.dll"); // System.Linq.Expressions.Expression<T> 
-                otherFlags.Add("-r:System.Reflection.dll"); // System.Reflection.ParameterInfo
-                otherFlags.Add("-r:System.Linq.Expressions.dll"); // System.Linq.IQueryable<T>
-                otherFlags.Add("-r:System.Threading.Tasks.dll"); // valuetype [System.Threading.Tasks]System.Threading.CancellationToken
-                otherFlags.Add("-r:System.IO.dll");  //  System.IO.TextWriter
-                otherFlags.Add("-r:System.Net.Requests.dll");  //  System.Net.WebResponse etc.
-                otherFlags.Add("-r:System.Collections.dll"); // System.Collections.Generic.List<T>
-                otherFlags.Add("-r:System.Runtime.Numerics.dll"); // BigInteger
-                otherFlags.Add("-r:System.Threading.dll");  // OperationCanceledException
-                otherFlags.Add("-r:System.Runtime.dll");
-                otherFlags.Add("-r:System.Numerics.dll");
+                // Add the references as reported by the metadata resolver.
+                otherFlags.AddRange(references.Select(r => "-r:" + r.Display));
 
                 if (_optimizationLevel == OptimizationLevel.Debug)
                 {
@@ -196,13 +172,17 @@ public ICompilation GetFunctionCompilation(FunctionMetadata functionMetadata)
                     var assembly = Assembly.Load(assemblyBytes, pdbBytes);
                     assemblyOption = FSharpOption<Assembly>.Some(assembly);
                 }
+                else
+                {
+                    _traceWriter.Verbose($"F# compilation failed with arguments: { string.Join(" ", otherFlags) }");
+                }
             }
             finally
             {
                 DeleteDirectoryAsync(scriptPath, recursive: true)
                 .ContinueWith(t => t.Exception.Handle(e =>
                 {
-                    // TODO: Trace
+                    _traceWriter.Warning($"Unable to delete F# compilation file: { e.ToString() }");
                     return true;
                 }), TaskContinuationOptions.OnlyOnFaulted);
             }

src/WebJobs.Script/Description/DotNet/FunctionMetadataResolver.cs

@@ -43,8 +43,9 @@ public sealed class FunctionMetadataResolver : MetadataReferenceResolver, IFunct
                 "System.Configuration",
                 "System.Xml",
                 "System.Net.Http",
+                "System.Runtime",
+                "System.Threading.Tasks",
                 "Microsoft.CSharp",
-                typeof(object).Assembly.Location,
                 typeof(IAsyncCollector<>).Assembly.Location, /*Microsoft.Azure.WebJobs*/
                 typeof(JobHost).Assembly.Location, /*Microsoft.Azure.WebJobs.Host*/
                 typeof(CoreJobHostConfigurationExtensions).Assembly.Location, /*Microsoft.Azure.WebJobs.Extensions*/
@@ -117,13 +118,11 @@ public override int GetHashCode()
 
         public IReadOnlyCollection<string> GetCompilationReferences()
         {
-            // Add package reference assemblies
-            var result = new List<string>(_packageAssemblyResolver.AssemblyReferences);
-
-            // Add default references
-            result.AddRange(DefaultAssemblyReferences);
+            // Combine our default references with package references
+            var combinedReferences = DefaultAssemblyReferences
+                .Union(_packageAssemblyResolver.AssemblyReferences);
 
-            return result.AsReadOnly();
+            return new ReadOnlyCollection<string>(combinedReferences.ToList());
         }
 
         /// <summary>
@@ -189,7 +188,7 @@ private ImmutableArray<PortableExecutableReference> GetMetadataFromReferencePath
             {
                 bool externalReference = false;
                 string basePath = _privateAssembliesPath;
-                
+
                 // If this is a relative assembly reference, use the function directory as the base probing path
                 if (reference.IndexOfAny(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }) > -1)
                 {

src/WebJobs.Script/Description/DotNet/PackageAssemblyResolver.cs

@@ -44,7 +44,7 @@ public IEnumerable<string> AssemblyReferences
                     assemblies.AddRange(p.Assemblies.Values);
                     assemblies.AddRange(p.FrameworkAssemblies.Values);
                     return assemblies;
-                });
+                }).Distinct();
             }
         }
 

test/WebJobs.Script.Tests/Description/DotNet/DotNetFunctionInvokerTests.cs

@@ -7,6 +7,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Script.Binding;
 using Microsoft.Azure.WebJobs.Script.Description;
@@ -33,7 +34,9 @@ public async Task ReloadScript_WithInvalidCompilationAndMissingMethod_ReportsRes
             // Create the invoker dependencies and setup the appropriate method to throw the exception
             RunDependencies dependencies = CreateDependencies();
             dependencies.Compilation.Setup(c => c.GetEntryPointSignature(It.IsAny<IFunctionEntryPointResolver>()))
-             .Throws(exception);
+                .Throws(exception);
+            dependencies.Compilation.Setup(c => c.EmitAndLoad(It.IsAny<CancellationToken>()))
+                .Returns(typeof(object).Assembly);
 
             string rootFunctionsFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
             Directory.CreateDirectory(rootFunctionsFolder);
@@ -102,7 +105,7 @@ public async Task Compilation_WithMissingBindingArguments_LogsAF004Warning()
 
             var invoker = new DotNetFunctionInvoker(dependencies.Host.Object, metadata, new Collection<FunctionBinding>(),
                 new Collection<FunctionBinding> { testBinding.Object }, new FunctionEntryPointResolver(), new FunctionAssemblyLoader(string.Empty),
-                new DotNetCompilationServiceFactory(), dependencies.TraceWriterFactory.Object);
+                new DotNetCompilationServiceFactory(NullTraceWriter.Instance), dependencies.TraceWriterFactory.Object);
 
             await invoker.GetFunctionTargetAsync();
 
@@ -140,7 +143,7 @@ public async Task Compilation_OnSecondaryHost_SuppressesLogs()
 
             var invoker = new DotNetFunctionInvoker(dependencies.Host.Object, metadata, new Collection<FunctionBinding>(),
                 new Collection<FunctionBinding> { testBinding.Object }, new FunctionEntryPointResolver(), new FunctionAssemblyLoader(string.Empty),
-                new DotNetCompilationServiceFactory(), dependencies.TraceWriterFactory.Object);
+                new DotNetCompilationServiceFactory(NullTraceWriter.Instance), dependencies.TraceWriterFactory.Object);
 
             await invoker.GetFunctionTargetAsync();