Fix 'isof' and 'cast' unquoted type params issue

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

@@ -720,12 +720,19 @@ private static IEdmTypeReference ValidateIsOfOrCast(BindingState state, bool isC
                     Error.Format(SRResources.MetadataBinder_CastOrIsOfExpressionWithWrongNumberOfOperands, args.Count));
             }
 
-            ConstantNode typeArgument = args.Last() as ConstantNode;
+            QueryNode queryNode = args[^1];
 
+            string typeArgumentFullName = null;
             IEdmTypeReference returnType = null;
-            if (typeArgument != null)
+            if (queryNode is SingleResourceCastNode singleResourceCastNode)
             {
-                returnType = TryGetTypeReference(state.Model, typeArgument.Value as string, state.Configuration.Resolver);
+                returnType = singleResourceCastNode.TypeReference;
+                typeArgumentFullName = returnType.FullName();
+            }
+            else if (queryNode is ConstantNode constantNode)
+            {
+                typeArgumentFullName = constantNode.Value as string;
+                returnType = TryGetTypeReference(state.Model, typeArgumentFullName, state.Configuration.Resolver);
             }
 
             if (returnType == null)
@@ -758,7 +765,7 @@ private static IEdmTypeReference ValidateIsOfOrCast(BindingState state, bool isC
             {
                 // throw if cast enum to not-string :
                 if ((args[0].GetEdmTypeReference() is IEdmEnumTypeReference)
-                    && !string.Equals(typeArgument.Value as string, Microsoft.OData.Metadata.EdmConstants.EdmStringTypeName, StringComparison.Ordinal))
+                    && !string.Equals(typeArgumentFullName, Microsoft.OData.Metadata.EdmConstants.EdmStringTypeName, state.Configuration.Resolver?.EnableCaseInsensitive == true ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))
                 {
                     throw new ODataException(SRResources.CastBinder_EnumOnlyCastToOrFromString);
                 }

src/Microsoft.OData.Core/UriParser/Parsers/FunctionCallParser.cs

@@ -11,6 +11,7 @@ namespace Microsoft.OData.UriParser
     using System.Diagnostics;
     using System.Linq;
     using Microsoft.OData.Core;
+    using Microsoft.OData.Edm;
 
     /// <summary>
     /// Implementation of IFunctionCallParser that allows functions calls and parses arguments with a provided method.
@@ -101,7 +102,7 @@ public bool TryParseIdentifierAsFunction(QueryToken parent, out QueryToken resul
                 this.Lexer.NextToken();
             }
 
-            FunctionParameterToken[] arguments = this.ParseArgumentListOrEntityKeyList(() => lexer.RestorePosition(position));
+            FunctionParameterToken[] arguments = this.ParseArgumentListOrEntityKeyList(() => lexer.RestorePosition(position), functionName);
             if (arguments != null)
             {
                 result = new FunctionCallToken(functionName.ToString(), arguments, parent);
@@ -114,8 +115,9 @@ public bool TryParseIdentifierAsFunction(QueryToken parent, out QueryToken resul
         /// Parses argument lists or entity key value list.
         /// </summary>
         /// <param name="restoreAction">Action invoked for restoring a state during failure.</param>
+        /// <param name="functionName">The name of the function being called. Default is an empty span.</param>
         /// <returns>The lexical tokens representing the arguments.</returns>
-        public FunctionParameterToken[] ParseArgumentListOrEntityKeyList(Action restoreAction = null)
+        public FunctionParameterToken[] ParseArgumentListOrEntityKeyList(Action restoreAction = null, ReadOnlySpan<char> functionName = default)
         {
             if (this.Lexer.CurrentToken.Kind != ExpressionTokenKind.OpenParen)
             {
@@ -136,7 +138,7 @@ public FunctionParameterToken[] ParseArgumentListOrEntityKeyList(Action restoreA
             }
             else
             {
-                arguments = this.ParseArguments();
+                arguments = this.ParseArguments(functionName);
             }
 
             if (this.Lexer.CurrentToken.Kind != ExpressionTokenKind.CloseParen)
@@ -161,33 +163,53 @@ public FunctionParameterToken[] ParseArgumentListOrEntityKeyList(Action restoreA
         /// Arguments can either be of the form a=1,b=2,c=3 or 1,2,3.
         /// They cannot be mixed between those two styles.
         /// </remarks>
+        /// <param name="functionName">The name of the function being called. Default is an empty span.</param>
         /// <returns>The lexical tokens representing the arguments.</returns>
-        public FunctionParameterToken[] ParseArguments()
+        public FunctionParameterToken[] ParseArguments(ReadOnlySpan<char> functionName = default)
         {
             ICollection<FunctionParameterToken> argList;
             if (this.TryReadArgumentsAsNamedValues(out argList))
             {
                 return argList.ToArray();
             }
 
-            return this.ReadArgumentsAsPositionalValues().ToArray();
+            return this.ReadArgumentsAsPositionalValues(functionName).ToArray();
         }
 
         /// <summary>
         /// Read the list of arguments as a set of positional values
         /// </summary>
+        /// <param name="functionName">The name of the function being called. Default is an empty span.</param>
         /// <returns>A list of FunctionParameterTokens representing each argument</returns>
-        private List<FunctionParameterToken> ReadArgumentsAsPositionalValues()
+        private List<FunctionParameterToken> ReadArgumentsAsPositionalValues(ReadOnlySpan<char> functionName = default)
         {
+            // Store the parent expression of the current argument.
+            Stack<QueryToken> expressionParents = new Stack<QueryToken>();
+            bool isFunctionCallNameCastOrIsOf = functionName.Length > 0 &&
+                (functionName.SequenceEqual(ExpressionConstants.UnboundFunctionCast.AsSpan()) || functionName.SequenceEqual(ExpressionConstants.UnboundFunctionIsOf.AsSpan()));
             List<FunctionParameterToken> argList = new List<FunctionParameterToken>();
             while (true)
             {
-                argList.Add(new FunctionParameterToken(null, this.parser.ParseExpression()));
+                // If we have a parent expression, we need to set the parent of the next argument to the current argument.
+                QueryToken parentExpression = expressionParents.Count > 0 ? expressionParents.Pop() : null;
+                QueryToken parameterToken = this.parser.ParseExpression();
+
+                // If the function call is cast or isof, set the parent of the next argument to the current argument.
+                if (parentExpression != null && isFunctionCallNameCastOrIsOf)
+                {
+                    parameterToken = SetParentForCurrentParameterToken(parentExpression, parameterToken);
+                }
+
+                argList.Add(new FunctionParameterToken(null, parameterToken));
                 if (this.Lexer.CurrentToken.Kind != ExpressionTokenKind.Comma)
                 {
                     break;
                 }
 
+                // In case of comma, we need to parse the next argument
+                // but first we need to set the parent of the next argument to the current argument.
+                expressionParents.Push(parameterToken);
+
                 this.Lexer.NextToken();
             }
 
@@ -213,5 +235,35 @@ private bool TryReadArgumentsAsNamedValues(out ICollection<FunctionParameterToke
 
             return false;
         }
+
+        /// <summary>
+        /// Set the parent of the next argument to the current argument.
+        /// For example, in the following query:
+        ///     cast(Location, NS.HomeAddress) where Location is the parentExpression and NS.HomeAddress is the parameterToken.
+        ///     isof(Location, NS.HomeAddress) where Location is the parentExpression and NS.HomeAddress is the parameterToken.
+        /// </summary>
+        /// <param name="parentExpression">The previous parameter token.</param>
+        /// <param name="parameterToken">The current parameter token.</param>
+        /// <returns>The updated parameter token.</returns>
+        private static QueryToken SetParentForCurrentParameterToken(QueryToken parentExpression, QueryToken parameterToken)
+        {
+            if (parameterToken is not DottedIdentifierToken dottedIdentifierToken || dottedIdentifierToken?.NextToken is not null)
+            {
+                return parameterToken;
+            }
+
+            // Check if the identifier is a primitive type
+            IEdmSchemaType schemaType = NormalizedModelElementsCache.EdmCoreModelInstance.FindSchemaTypes(dottedIdentifierToken.Identifier)?.FirstOrDefault();
+
+            // If the identifier is a primitive type
+            if (schemaType is IEdmPrimitiveType)
+            {
+                return parameterToken;
+            }
+
+            // Set the parent of the next argument to the current argument
+            dottedIdentifierToken.NextToken = parentExpression;
+            return dottedIdentifierToken;
+        }
     }
 }

src/Microsoft.OData.Core/UriParser/Resolver/NormalizedModelElementsCache.cs

@@ -20,6 +20,11 @@ namespace Microsoft.OData.Edm
     /// </summary>
     internal sealed class NormalizedModelElementsCache
     {
+        /// <summary>
+        /// Provides a shared, normalized case-insensitive cache of model elements for the EDM core model.
+        /// </summary>
+        public static readonly NormalizedModelElementsCache EdmCoreModelInstance = new NormalizedModelElementsCache(EdmCoreModel.Instance);
+
         // We create different caches for different types of schema elements because all current usage request schema elements
         // of specific types. If we were to use a single dictionary <string, ISchemaElement> we would need
         // to do additional work (and allocations) during lookups to filter the results to the subset that matches the request type.

test/UnitTests/Microsoft.OData.Core.Tests/ScenarioTests/UriParser/EnumFilterFunctionalTests.cs

@@ -410,20 +410,26 @@ public void ParseFilterWithNullEnumValue()
             convertNode.Source.ShouldBeConstantQueryNode((object)null);
         }
 
-        [Fact]
-        public void ParseFilterCastMethod1()
+        [Theory]
+        [InlineData("cast(NS.Color'Green', 'Edm.String') eq 'blue'")]
+        [InlineData("cast(NS.Color'Green', Edm.String) eq 'blue'")]
+        [InlineData("cast(NS.Color'Green', edm.string) eq 'blue'")]
+        [InlineData("cast(NS.Color'Green', EDM.STRING) eq 'blue'")]
+        public void ParseFilterCastMethodWithEdmPrimitiveTypes(string filterQuery)
         {
-            var filter = ParseFilter("cast(NS.Color'Green', 'Edm.String') eq 'blue'", this.userModel, this.entityType, this.entitySet);
+            var filter = ParseFilter(filterQuery, true, this.userModel, this.entityType, this.entitySet);
             var bon = filter.Expression.ShouldBeBinaryOperatorNode(BinaryOperatorKind.Equal);
             var convertNode = Assert.IsType<ConvertNode>(bon.Left);
             var functionCallNode = Assert.IsType<SingleValueFunctionCallNode>(convertNode.Source);
             Assert.Equal("cast", functionCallNode.Name); // ConvertNode is because cast() result's nullable=false.
         }
 
-        [Fact]
-        public void ParseFilterCastMethod2()
+        [Theory]
+        [InlineData("cast('Green', 'NS.Color') eq NS.Color'Green'")]
+        [InlineData("cast('Green', NS.Color) eq NS.Color'Green'")]
+        public void ParseFilterCastMethodWithOrWithoutSingleQuotesOnType(string filterQuery)
         {
-            var filter = ParseFilter("cast('Green', 'NS.Color') eq NS.Color'Green'", this.userModel, this.entityType, this.entitySet);
+            var filter = ParseFilter(filterQuery, this.userModel, this.entityType, this.entitySet);
             var bon = filter.Expression.ShouldBeBinaryOperatorNode(BinaryOperatorKind.Equal);
             var functionCallNode = Assert.IsType<SingleValueFunctionCallNode>(bon.Left);
             Assert.Equal("cast", functionCallNode.Name);
@@ -500,17 +506,20 @@ public void ParseFilterEnumMemberUndefined4()
             parse.Throws<ODataException>(Error.Format(SRResources.Binder_IsNotValidEnumConstant, "NS.ColorFlags'Red,2'"));
         }
 
-        [Fact]
-        public void ParseFilterEnumTypesWrongCast1()
+        [Theory]
+        [InlineData("cast(NS.ColorFlags'Green', 'Edm.Int64') eq 2")]
+        [InlineData("cast(NS.ColorFlags'Green', Edm.Int64) eq 2")]
+        public void ParseFilterEnumTypesWrongCast1(string filter)
         {
-            Action parse = () => ParseFilter("cast(NS.ColorFlags'Green', 'Edm.Int64') eq 2", this.userModel, this.entityType, this.entitySet);
+            Action parse = () => ParseFilter(filter, this.userModel, this.entityType, this.entitySet);
             parse.Throws<ODataException>(SRResources.CastBinder_EnumOnlyCastToOrFromString);
         }
-
-        [Fact]
-        public void ParseFilterEnumTypesWrongCast2()
+        [Theory]
+        [InlineData("cast(321, 'NS.ColorFlags') eq 2")]
+        [InlineData("cast(321, NS.ColorFlags) eq 2")]
+        public void ParseFilterEnumTypesWrongCast2(string filter)
         {
-            Action parse = () => ParseFilter("cast(321, 'NS.ColorFlags') eq 2", this.userModel, this.entityType, this.entitySet);
+            Action parse = () => ParseFilter(filter, this.userModel, this.entityType, this.entitySet);
             parse.Throws<ODataException>(SRResources.CastBinder_EnumOnlyCastToOrFromString);
         }
 
@@ -536,7 +545,7 @@ public void ParseFilterWithInOperatorWithEnums(string filterOptionValue)
             IEdmEnumType colorType = this.GetIEdmType<IEdmEnumType>(colorTypeName);
             IEdmEnumMember enumMember = colorType.Members.First(m => m.Name == enumValue);
 
-            string expectedLiteral = "'Green'"; 
+            string expectedLiteral = "'Green'";
             if (filterOptionValue.StartsWith(colorTypeName)) // if the filterOptionValue is already fully qualified, then the expectedLiteral should be the same as filterOptionValue
             {
                 expectedLiteral = "NS.Color'Green'";
@@ -651,5 +660,11 @@ private FilterClause ParseFilter(string text, IEdmModel edmModel, IEdmEntityType
         {
             return new ODataQueryOptionParser(edmModel, entityType, edmEntitySet, new Dictionary<string, string>() { { "$filter", text } }).ParseFilter();
         }
+
+        private FilterClause ParseFilter(string text, bool caseInsensitive, IEdmModel edmModel, IEdmEntityType edmEntityType, IEdmEntitySet edmEntitySet)
+        {
+            return new ODataQueryOptionParser(edmModel, entityType, edmEntitySet, new Dictionary<string, string>() { { "$filter", text } })
+            { Resolver = new ODataUriResolver() { EnableCaseInsensitive = caseInsensitive } }.ParseFilter();
+        }
     }
 }