Enable passing return values from non-C# functions.

* Annotate that a binding handles a return value via new
HandlesReturnAttribute in azure-webjobs-sdk.

Author: kashimiz

src/WebJobs.Script/Binding/ExtensionBinding.cs

@@ -28,7 +28,7 @@ public ExtensionBinding(ScriptHostConfiguration config, ScriptBinding binding, B
             Attributes = _binding.GetAttributes();
         }
 
-        internal Collection<Attribute> Attributes { get; private set; }
+        public Collection<Attribute> Attributes { get; private set; }
 
         public override Collection<CustomAttributeBuilder> GetCustomAttributes(Type parameterType)
         {

src/WebJobs.Script/Binding/FunctionBinding.cs

@@ -53,7 +53,6 @@ internal static Collection<FunctionBinding> GetBindings(ScriptHostConfiguration
                             {
                                 throw new InvalidOperationException("Http binding can only be used for output.");
                             }
-                            bindings.Add(new HttpBinding(config, bindingMetadata, FileAccess.Write));
                             break;
                         default:
                             FunctionBinding binding = null;

src/WebJobs.Script/Binding/Http/HttpBinding.cs

@@ -3,54 +3,21 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Dynamic;
 using System.Globalization;
 using System.IO;
-using System.Linq;
 using System.Net;
-using System.Reflection.Emit;
-using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.WebApiCompatShim;
 using Microsoft.Azure.WebJobs.Script.Description;
-using Microsoft.Net.Http.Headers;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.WebJobs.Script.Binding
 {
-    public class HttpBinding : FunctionBinding
+    public class HttpBinding
     {
-        public HttpBinding(ScriptHostConfiguration config, BindingMetadata metadata, FileAccess access)
-            : base(config, metadata, access)
-        {
-        }
-
-        public override Collection<CustomAttributeBuilder> GetCustomAttributes(Type parameterType)
-        {
-            return null;
-        }
-
-        public override Task BindAsync(BindingContext context)
-        {
-            HttpRequest request = (HttpRequest)context.TriggerValue;
-
-            object content = context.Value;
-            if (content is Stream)
-            {
-                // for script language functions (e.g. PowerShell, BAT, etc.) the value
-                // will be a Stream which we need to convert to string
-                ConvertStreamToValue((Stream)content, DataType.String, ref content);
-            }
-
-            IActionResult response = CreateResult(request, content);
-            request.HttpContext.Items[ScriptConstants.AzureFunctionsHttpResponseKey] = response;
-
-            return Task.CompletedTask;
-        }
-
         internal static IActionResult CreateResult(HttpRequest request, object content)
         {
             string stringContent = content as string;
@@ -188,17 +155,31 @@ internal static void SetResponse(HttpRequest request, object result)
             IActionResult actionResult = result as IActionResult;
             if (actionResult == null)
             {
-                var objectResult = new ObjectResult(result);
-
-                if (result is System.Net.Http.HttpResponseMessage)
+                if (result is Stream)
                 {
-                    // To maintain backwards compatibility, if the type returned is an
-                    // instance of an HttpResponseMessage, add the appropriate formatter to
-                    // handle the response
-                    objectResult.Formatters.Add(new HttpResponseMessageOutputFormatter());
+                    // for script language functions (e.g. PowerShell, BAT, etc.) the value
+                    // will be a Stream which we need to convert to string
+                    FunctionBinding.ConvertStreamToValue((Stream)result, DataType.String, ref result);
+                    actionResult = CreateResult(request, result);
                 }
+                else if (result is JObject)
+                {
+                    actionResult = CreateResult(request, result);
+                }
+                else
+                {
+                    var objectResult = new ObjectResult(result);
 
-                actionResult = objectResult;
+                    if (result is System.Net.Http.HttpResponseMessage)
+                    {
+                        // To maintain backwards compatibility, if the type returned is an
+                        // instance of an HttpResponseMessage, add the appropriate formatter to
+                        // handle the response
+                        objectResult.Formatters.Add(new HttpResponseMessageOutputFormatter());
+                    }
+
+                    actionResult = objectResult;
+                }
             }
 
             request.HttpContext.Items[ScriptConstants.AzureFunctionsHttpResponseKey] = actionResult;

src/WebJobs.Script/Description/Rpc/WorkerFunctionDescriptorProvider.cs

@@ -3,7 +3,11 @@
 
 using System;
 using System.Collections.ObjectModel;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
 using System.Threading.Tasks.Dataflow;
+using Microsoft.Azure.WebJobs.Description;
 using Microsoft.Azure.WebJobs.Script.Binding;
 using Microsoft.Azure.WebJobs.Script.Rpc;
 
@@ -40,5 +44,47 @@ protected override IFunctionInvoker CreateFunctionInvoker(string scriptFilePath,
             });
             return new WorkerLanguageInvoker(Host, triggerMetadata, functionMetadata, inputBindings, outputBindings, inputBuffer);
         }
+
+        protected override Collection<ParameterDescriptor> GetFunctionParameters(IFunctionInvoker functionInvoker, FunctionMetadata functionMetadata,
+            BindingMetadata triggerMetadata, Collection<CustomAttributeBuilder> methodAttributes, Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings)
+        {
+            var parameters = base.GetFunctionParameters(functionInvoker, functionMetadata, triggerMetadata, methodAttributes, inputBindings, outputBindings);
+
+            var bindings = inputBindings.Union(outputBindings);
+
+            try
+            {
+                var triggerHandlesReturnValueBinding = bindings.SingleOrDefault(b =>
+                    b.Metadata.IsTrigger &&
+                    (b as ExtensionBinding)?.Attributes.SingleOrDefault(a =>
+                        (a.GetType().GetCustomAttribute(typeof(BindingAttribute)) as BindingAttribute)?.TriggerHandlesReturnValue == true)
+                    != null);
+
+                if (triggerHandlesReturnValueBinding != null)
+                {
+                    var byRefType = typeof(object).MakeByRefType();
+
+                    ParameterDescriptor returnDescriptor = new ParameterDescriptor(ScriptConstants.SystemReturnParameterName, byRefType);
+                    returnDescriptor.Attributes |= ParameterAttributes.Out;
+
+                    Collection<CustomAttributeBuilder> customAttributes = triggerHandlesReturnValueBinding.GetCustomAttributes(byRefType);
+                    if (customAttributes != null)
+                    {
+                        foreach (var customAttribute in customAttributes)
+                        {
+                            returnDescriptor.CustomAttributes.Add(customAttribute);
+                        }
+                    }
+
+                    parameters.Add(returnDescriptor);
+                }
+            }
+            catch (InvalidOperationException ex)
+            {
+                throw new InvalidOperationException("Multiple bindings cannot be designated as HandlesReturnValue.", ex);
+            }
+
+            return parameters;
+        }
     }
 }

src/WebJobs.Script/Description/Rpc/WorkerLanguageInvoker.cs

@@ -73,7 +73,7 @@ protected override async Task<object> InvokeCore(object[] parameters, FunctionIn
             result = await invocationContext.ResultSource.Task;
 
             await BindOutputsAsync(triggerValue, context.Binder, result);
-            return null;
+            return result.Return;
         }
 
         private async Task<(string name, DataType type, object value)[]> BindInputsAsync(Binder binder)