Updating function signature to recognize local types used in generic type arguments

Author: fabiocav

src/WebJobs.Script/Description/CSharp/CSharpFunctionSignature.cs

@@ -64,11 +64,23 @@ public static CSharpFunctionSignature FromCompilation(Compilation compilation, I
             IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
 
             var signature = new CSharpFunctionSignature(entryPointReference.Parameters);
-            signature.HasLocalTypeReference = entryPointReference.Parameters.Any(p => p.Type.ContainingAssembly == entryPointReference.ContainingAssembly);
+            signature.HasLocalTypeReference = entryPointReference.Parameters.Any(p => IsOrUsesAssemblyType(p.Type, entryPointReference.ContainingAssembly));
 
             return signature;
         }
 
+        private static bool IsOrUsesAssemblyType(ITypeSymbol typeSymbol, IAssemblySymbol assemblySymbol)
+        {
+            if (typeSymbol.ContainingAssembly == assemblySymbol)
+            {
+                return true;
+            }
+
+            INamedTypeSymbol namedTypeSymbol = typeSymbol as INamedTypeSymbol;
+            return namedTypeSymbol != null && namedTypeSymbol.IsGenericType
+                && namedTypeSymbol.TypeArguments.Any(t => IsOrUsesAssemblyType(t, assemblySymbol));
+        }
+
         private static bool AreParametersEquivalent(IParameterSymbol param1, IParameterSymbol param2)
         {
             if (ReferenceEquals(param1, param2))

test/WebJobs.Script.Tests/CSharpFunctionSignatureTests.cs

@@ -96,5 +96,79 @@ public class Test
 
             Assert.True(signature1.HasLocalTypeReference);
         }
+
+        [Fact]
+        public void Matches_IsTrue_WhenUsingLocalTypesAsGenericArguments()
+        {
+            var function1 = @"using System;
+using System.Collections.Generic;
+public static void Run(string id, ICollection<Test> test1)
+{
+    
+}
+
+public class Test 
+{
+    public string Id { get; set; }
+}";
+
+            var tree = CSharpSyntaxTree.ParseText(function1, CSharpParseOptions.Default.WithKind(SourceCodeKind.Script));
+            var references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(string).Assembly.Location) };
+            var compilation = CSharpCompilation.Create("test1", references: references).AddSyntaxTrees(tree);
+
+            var signature1 = CSharpFunctionSignature.FromCompilation(compilation, new FunctionEntryPointResolver());
+
+            Assert.True(signature1.HasLocalTypeReference);
+        }
+
+        [Fact]
+        public void Matches_IsTrue_WhenUsingLocalTypesAsDeepGenericArguments()
+        {
+            var function1 = @"using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+public static void Run(string id, ICollection<Task<Test>> test1)
+{
+    
+}
+
+public class Test 
+{
+    public string Id { get; set; }
+}";
+
+            var tree = CSharpSyntaxTree.ParseText(function1, CSharpParseOptions.Default.WithKind(SourceCodeKind.Script));
+            var references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(string).Assembly.Location) };
+            var compilation = CSharpCompilation.Create("test1", references: references).AddSyntaxTrees(tree);
+
+            var signature1 = CSharpFunctionSignature.FromCompilation(compilation, new FunctionEntryPointResolver());
+
+            Assert.True(signature1.HasLocalTypeReference);
+        }
+
+        [Fact]
+        public void Matches_IsFalse_WhenNotUsingLocalTypes()
+        {
+            var function1 = @"using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+public static void Run(string id, int test1)
+{
+    
+}
+
+public class Test 
+{
+    public string Id { get; set; }
+}";
+
+            var tree = CSharpSyntaxTree.ParseText(function1, CSharpParseOptions.Default.WithKind(SourceCodeKind.Script));
+            var references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(string).Assembly.Location) };
+            var compilation = CSharpCompilation.Create("test1", references: references).AddSyntaxTrees(tree);
+
+            var signature1 = CSharpFunctionSignature.FromCompilation(compilation, new FunctionEntryPointResolver());
+
+            Assert.False(signature1.HasLocalTypeReference);
+        }
     }
 }