Add support for collection parameters in URI functions

Author: gathogojr

src/Microsoft.OData.Core/SRResources.Designer.cs

@@ -2624,4 +2624,7 @@
   <data name="TaskUtils_NullContinuationTask" xml:space="preserve">
     <value>The continuation task returned by the operation cannot be null.</value>
   </data>
+  <data name="MetadataBinder_FunctionArgumentNotSingleValueOrCollectionNode" xml:space="preserve">
+    <value>The argument for an invocation of a function with name '{0}' is not a single value or collection. Arguments for this function must be either a single value or collection.</value>
+  </data>
 </root>

src/Microsoft.OData.Core/SRResources.resx

@@ -671,19 +671,19 @@ private static object ConvertFromResourceOrCollectionValue(string value, IEdmMod
                 {
                     ODataJsonPropertyAndValueDeserializer deserializer = new ODataJsonPropertyAndValueDeserializer(context);
 
-                    // TODO: The way JSON array literals look in the URI is different that response payload with an array in it.
+                    // TODO: The way JSON array literals look in the URI is different than response payload with an array in it.
                     // The fact that we have to manually setup the underlying reader shows this different in the protocol.
                     // There is a discussion on if we should change this or not.
                     deserializer.JsonReader.Read(); // Move to first thing
                     object rawResult = deserializer.ReadNonEntityValue(
-                        null /*payloadTypeName*/,
-                        typeReference,
-                        null /*DuplicatePropertyNameChecker*/,
-                        null /*CollectionWithoutExpectedTypeValidator*/,
-                        true /*validateNullValue*/,
-                        false /*isTopLevelPropertyValue*/,
-                        false /*insideResourceValue*/,
-                        null /*propertyName*/);
+                        payloadTypeName: null,
+                        expectedValueTypeReference: typeReference,
+                        propertyAndAnnotationCollector: null,
+                        collectionValidator: null,
+                        validateNullValue: true,
+                        isTopLevelPropertyValue: false,
+                        insideResourceValue: false,
+                        propertyName: null);
                     deserializer.ReadPayloadEnd(false);
 
                     return rawResult;

src/Microsoft.OData.Core/Uri/ODataUriConversionUtils.cs

@@ -51,7 +51,7 @@ public static object ConvertFromUriLiteral(string value, ODataVersion version, I
 
             if (model == null)
             {
-                model = Microsoft.OData.Edm.EdmCoreModel.Instance;
+                model = EdmCoreModel.Instance;
             }
 
             // Let ExpressionLexer try to get a primitive
@@ -149,7 +149,7 @@ public static string ConvertToUriLiteral(object value, ODataVersion version, IEd
 
             if (model == null)
             {
-                model = Microsoft.OData.Edm.EdmCoreModel.Instance;
+                model = EdmCoreModel.Instance;
             }
 
             ODataNullValue nullValue = value as ODataNullValue;

src/Microsoft.OData.Core/Uri/ODataUriUtils.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.OData.UriParser
 {
-    using System.Diagnostics;
+    using Microsoft.OData.Edm;
 
     /// <summary>
     /// Class that knows how to bind literal values.
@@ -48,8 +48,8 @@ internal static QueryNode BindInLiteral(LiteralToken literalToken)
             {
                 if (literalToken.ExpectedEdmTypeReference != null)
                 {
-                    OData.Edm.IEdmCollectionTypeReference collectionReference =
-                        literalToken.ExpectedEdmTypeReference as OData.Edm.IEdmCollectionTypeReference;
+                    IEdmCollectionTypeReference collectionReference =
+                        literalToken.ExpectedEdmTypeReference as IEdmCollectionTypeReference;
                     if (collectionReference != null)
                     {
                         ODataCollectionValue collectionValue = literalToken.Value as ODataCollectionValue;

src/Microsoft.OData.Core/UriParser/Binders/FunctionCallBinder.cs

@@ -7,12 +7,12 @@
 namespace Microsoft.OData.UriParser
 {
     using System;
+    using System.Collections.Generic;
     using System.Diagnostics;
-    using System.Linq;
-    using Microsoft.OData.Edm;
     using Microsoft.OData;
-    using Microsoft.OData.Metadata;
     using Microsoft.OData.Core;
+    using Microsoft.OData.Edm;
+    using Microsoft.OData.Metadata;
 
     /// <summary>
     /// Helper methods for metadata binding.
@@ -66,14 +66,14 @@ internal static SingleValueNode ConvertToTypeIfNeeded(SingleValueNode source, IE
                     IEdmEnumType enumType = targetTypeReference.Definition as IEdmEnumType;
                     if (enumType.ContainsMember(memberName, StringComparison.Ordinal))
                     {
-                        string literalText = ODataUriUtils.ConvertToUriLiteral(constantNode.Value, default(ODataVersion));
+                        string literalText = ODataUriUtils.ConvertToUriLiteral(constantNode.Value, default);
                         return new ConstantNode(new ODataEnumValue(memberName, enumType.ToString()), literalText, targetTypeReference);
                     }
 
                     // If the member name is an integral value, we should try to convert it to the enum member name and find the enum member with the matching integral value
                     if (long.TryParse(memberName, out long memberIntegralValue) && enumType.TryParse(memberIntegralValue, out IEdmEnumMember enumMember))
                     {
-                        string literalText = ODataUriUtils.ConvertToUriLiteral(enumMember.Name, default(ODataVersion));
+                        string literalText = ODataUriUtils.ConvertToUriLiteral(enumMember.Name, default);
                         return new ConstantNode(new ODataEnumValue(enumMember.Name, enumType.ToString()), literalText, targetTypeReference);
                     }
 
@@ -111,8 +111,8 @@ internal static SingleValueNode ConvertToTypeIfNeeded(SingleValueNode source, IE
                             var targetDecimalType = (IEdmDecimalTypeReference)targetTypeReference;
                             return decimalType.Precision == targetDecimalType.Precision &&
                                    decimalType.Scale == targetDecimalType.Scale ?
-                                   (SingleValueNode)candidate :
-                                   (SingleValueNode)(new ConvertNode(candidate, targetTypeReference));
+                                   candidate :
+                                   new ConvertNode(candidate, targetTypeReference);
                         }
                         else
                         {
@@ -134,6 +134,138 @@ internal static SingleValueNode ConvertToTypeIfNeeded(SingleValueNode source, IE
             }
         }
 
+        /// <summary>
+        /// Converts a collection node's element type to <paramref name="targetTypeReference"/> when possible,
+        /// materializing a new <see cref="CollectionConstantNode"/> for constant collections;
+        /// leaves non-constant/open or non-convertible collections unchanged.
+        /// </summary>
+        /// <param name="source">Source collection node.</param>
+        /// <param name="targetTypeReference">Desired collection type (must be a collection).</param>
+        /// <returns>Converted collection node or original source.</returns>
+        internal static CollectionNode ConvertToTypeIfNeeded(CollectionNode source, IEdmTypeReference targetTypeReference)
+        {
+            Debug.Assert(source != null, "source != null");
+
+            if (targetTypeReference == null)
+            {
+                return source;
+            }
+
+            IEdmCollectionTypeReference sourceCollectionType = source.CollectionType;
+            if (sourceCollectionType == null) // Open collection? Leave as is
+            {
+                return source;
+            }
+
+            if (!targetTypeReference.IsCollection())
+            {
+                throw new ODataException(Error.Format(SRResources.MetadataBinder_CannotConvertToType, source.CollectionType.FullName(), targetTypeReference.FullName()));
+            }
+
+            IEdmCollectionTypeReference targetCollectionType = targetTypeReference.AsCollection();
+
+            if (sourceCollectionType.IsEquivalentTo(targetCollectionType))
+            {
+                IEdmTypeReference sourceElemType = sourceCollectionType.ElementType();
+                IEdmTypeReference targetElemType = targetCollectionType.ElementType();
+                if (source is CollectionConstantNode colConstantNode
+                    && sourceElemType.IsTypeDefinition()
+                    && targetElemType.IsPrimitive()
+                    && sourceElemType.AsPrimitive().PrimitiveKind() == targetElemType.AsPrimitive().PrimitiveKind())
+                {
+                    List<ConstantNode> convertedNodes = ConvertNodes(colConstantNode.Collection, targetElemType);
+                    
+                    return new CollectionConstantNode(convertedNodes, BuildCollectionLiteral(convertedNodes, targetElemType), targetCollectionType);
+                }
+
+                return source;
+            }
+
+            IEdmTypeReference sourceElementType = sourceCollectionType.ElementType();
+            IEdmTypeReference targetElementType = targetCollectionType.ElementType();
+
+            if (!TypePromotionUtils.CanConvertTo(null, sourceElementType, targetElementType))
+            {
+                throw new ODataException(Error.Format(SRResources.MetadataBinder_CannotConvertToType, sourceElementType.FullName(), targetElementType.FullName()));
+            }
+            
+            if (source is CollectionConstantNode collectionConstantNode)
+            {
+                List<ConstantNode> convertedNodes = ConvertNodes(collectionConstantNode.Collection, targetElementType);
+
+                return new CollectionConstantNode(convertedNodes, BuildCollectionLiteral(convertedNodes, targetElementType), targetCollectionType);
+            }
+
+            // Non-constant collections: leave as-is (conversion implicit)
+            return source;
+        }
+
+        /// <summary>
+        /// Converts each constant value to <paramref name="targetElementType"/>, applying enum/numeric coercion; preserves null items.
+        /// </summary>
+        /// <param name="nodes">Original constant value nodes.</param>
+        /// <param name="targetElementType">The target primitive type.</param>
+        /// <returns>List of converted constant nodes.</returns>
+        private static List<ConstantNode> ConvertNodes(IList<ConstantNode> nodes, IEdmTypeReference targetElementType)
+        {
+            List<ConstantNode> convertedNodes = new List<ConstantNode>(nodes.Count);
+
+            for (int i = 0; i < nodes.Count; i++)
+            {
+                ConstantNode item = nodes[i];
+                if (item == null)
+                {
+                    // Preserve null
+                    convertedNodes.Add(new ConstantNode(null, "null", targetElementType));
+                    continue;
+                }
+
+                ConstantNode convertedNode = ConvertToTypeIfNeeded(item, targetElementType) as ConstantNode;
+
+                // If ConvertToTypeIfNeeded returned a ConvertNode, force materialization into a ConstantNode
+                if (convertedNode == null)
+                {
+                    // Try to keep original literal text if meaningful
+                    string literal = item.LiteralText ?? ODataUriUtils.ConvertToUriLiteral(item.Value, ODataVersion.V4);
+                    convertedNode = new ConstantNode(item.Value, literal, targetElementType);
+                }
+
+                convertedNodes.Add(convertedNode);
+            }
+
+            return convertedNodes;
+        }
+
+        /// <summary>
+        /// Builds a bracketed collection literal (e.g. [1,2,3]) from constant nodes, quoting/escaping strings and preserving nulls.
+        /// </summary>
+        /// <param name="nodes">Constant nodes representing items.</param>
+        /// <param name="typeReference">Element type for string quoting rules.</param>
+        /// <returns>OData collection literal text.</returns>
+        private static string BuildCollectionLiteral(List<ConstantNode> nodes, IEdmTypeReference typeReference)
+        {
+            List<string> list = new List<string>();
+            for (int i = 0; i < nodes.Count; i++)
+            {
+                ConstantNode node = nodes[i];
+                if (node == null || node.Value == null)
+                {
+                    list.Add("null");
+                    continue;
+                }
+                
+                string literal = node.LiteralText ?? ODataUriUtils.ConvertToUriLiteral(node.Value, ODataVersion.V4);
+                if (typeReference.IsString() && !(literal.Length > 1 && literal[0] == '\'' && literal[^1] == '\''))
+                {
+                    literal = $"'{literal.Replace("'", "''", StringComparison.Ordinal)}'";
+                }
+
+                list.Add(literal);
+            }
+
+            return "[" + string.Join(",", list) + "]";
+        }
+
         /// <summary>
         /// Retrieves type associated to a segment.
         /// </summary>

src/Microsoft.OData.Core/UriParser/Binders/LiteralBinder.cs

@@ -112,7 +112,7 @@ private static QueryToken ParseComplexOrCollectionAlias(QueryToken queryToken, I
             string valueStr;
             if (valueToken != null && (valueStr = valueToken.Value as string) != null && !string.IsNullOrEmpty(valueToken.OriginalText))
             {
-                var lexer = new ExpressionLexer(valueToken.OriginalText, true /*moveToFirstToken*/, false /*useSemicolonDelimiter*/, true /*parsingFunctionParameters*/);
+                var lexer = new ExpressionLexer(valueToken.OriginalText, moveToFirstToken: true, useSemicolonDelimiter: false, parsingFunctionParameters: true);
                 if (lexer.CurrentToken.Kind == ExpressionTokenKind.BracketedExpression || lexer.CurrentToken.Kind == ExpressionTokenKind.BracedExpression)
                 {
                     object result = valueStr;

src/Microsoft.OData.Core/UriParser/Binders/MetadataBindingUtils.cs

@@ -482,12 +482,13 @@ public ODataUri ParseUri()
             ExceptionUtils.CheckArgumentNotNull(this.uri, "uri");
 
             ODataPath path = this.ParsePath();
+            // NOTE: ParseCompute should be called before ParseSelectAndExpand because $compute may add computed properties to the select/expand clause.
+            ComputeClause compute = this.ParseCompute();
             SelectExpandClause selectExpand = this.ParseSelectAndExpand();
             FilterClause filter = this.ParseFilter();
             OrderByClause orderBy = this.ParseOrderBy();
             SearchClause search = this.ParseSearch();
             ApplyClause apply = this.ParseApply();
-            ComputeClause compute = this.ParseCompute();
             long? top = this.ParseTop();
             long? skip = this.ParseSkip();
             long? index = this.ParseIndex();

src/Microsoft.OData.Core/UriParser/Binders/ParameterAliasBinder.cs

@@ -357,6 +357,8 @@ public virtual IEnumerable<IEdmOperationImport> ResolveOperationImports(IEdmMode
                 .Where(source => string.Equals(identifier, source.Name, StringComparison.OrdinalIgnoreCase));
         }
 
+        // TODO: Why does this method only handle SingleValueNode?
+        // What about other QueryNode types like CollectionNode?
         /// <summary>
         /// Resolve operation's parameters.
         /// </summary>