Fixing issue with directive references in F#

Author: fabiocav

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

@@ -47,7 +47,7 @@ public ImmutableArray<Diagnostic> GetDiagnostics()
 
         public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
         {
-            EnsureAssemblyOption();
+            EnsureAssemblyOption(false);
 
             // Scrape the compiled assembly for entry points
             IList<MethodReference<MethodInfo>> methods =
@@ -87,18 +87,11 @@ public Assembly EmitAndLoad(CancellationToken cancellationToken)
             return _assemblyOption.Value;
         }
 
-        private void EnsureAssemblyOption()
+        private void EnsureAssemblyOption(bool includeDiagnostics = true)
         {
             if (_assemblyOption == null)
             {
-                var diagnostics = this.GetDiagnostics();
-                var diagnosticsText = new System.Text.StringBuilder();
-                foreach (var diagostic in diagnostics)
-                {
-                    diagnosticsText.Append(diagostic.ToString());
-                }
-
-                throw new CompilationErrorException("Script compilation failed. " + diagnosticsText, this.GetDiagnostics());
+                throw new CompilationErrorException("Script compilation failed.", includeDiagnostics ? this.GetDiagnostics() : ImmutableArray<Diagnostic>.Empty);
             }
         }
     }

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

@@ -114,16 +114,13 @@ 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");
 
-                var references = script.Options.MetadataReferences
-                    .Cast<UnresolvedMetadataReference>()
-                    .Aggregate(new List<PortableExecutableReference>(), (a, r) =>
-                    {
-                        a.AddRange(_metadataResolver.ResolveReference(r.Reference, string.Empty, r.Properties));
-                        return a;
-                    });
+                var references = script.GetCompilation().References
+                    .Where(m => !(m is UnresolvedMetadataReference))
+                    .Select(m => "-r:" + m.Display)
+                    .Distinct(new FileNameEqualityComparer());
 
                 // Add the references as reported by the metadata resolver.
-                otherFlags.AddRange(references.Select(r => "-r:" + r.Display));
+                otherFlags.AddRange(references);
 
                 if (_optimizationLevel == OptimizationLevel.Debug)
                 {
@@ -201,5 +198,33 @@ private static string GetFunctionSource(FunctionMetadata functionMetadata)
 
             return code ?? string.Empty;
         }
+
+        private class FileNameEqualityComparer : IEqualityComparer<string>
+        {
+            public bool Equals(string x, string y)
+            {
+                if (string.Equals(x, y))
+                {
+                    return true;
+                }
+
+                if (string.IsNullOrEmpty(x) || string.IsNullOrEmpty(y))
+                {
+                    return false;
+                }
+
+                return string.Equals(Path.GetFileName(x), Path.GetFileName(y));
+            }
+
+            public int GetHashCode(string obj)
+            {
+                if (string.IsNullOrEmpty(obj))
+                {
+                    return 0;
+                }
+
+                return Path.GetFileName(obj).GetHashCode();
+            }
+        }
     }
 }