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

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

@@ -234,7 +234,28 @@ internal QueryNode BindFunctionCall(FunctionCallToken functionCallToken)
 
             // If there isn't, bind as Uri function
             // Bind all arguments
-            List<QueryNode> argumentNodes = new List<QueryNode>(functionCallToken.Arguments.Select(ar => this.bindMethod(ar)));
+            List<QueryNode> argumentNodes = functionCallToken.Arguments.Select(argument =>
+            {
+                // If the function is IsOf or Cast and the argument is a dotted identifier, we need to bind it differently
+                string functionCallTokenName = IsUnboundFunction(functionCallToken.Name);
+                if ((ExpressionConstants.UnboundFunctionIsOf == functionCallTokenName || ExpressionConstants.UnboundFunctionCast == functionCallTokenName) && argument.ValueToken is DottedIdentifierToken dottedIdentifier)
+                {
+                    // Find the type of the dotted identifier by resolving it against the model. This also ensure case-insensitive resolution.
+                    IEdmSchemaType dottedIdentifierType = UriEdmHelpers.FindTypeFromModel(state.Model, dottedIdentifier.Identifier, this.Resolver);
+
+                    // If the dotted identifier is a primitive type and the next token is not null, we need to ensure next token is null
+                    if (dottedIdentifierType is IEdmPrimitiveType && dottedIdentifier.NextToken != null)
+                    {
+                        // If the next token is not null, we need to ensure it is null
+                        dottedIdentifier = new DottedIdentifierToken(dottedIdentifier.Identifier, null);
+                    }
+
+                    return this.TryBindDottedIdentifierForIsOfOrCastFunctionCall(dottedIdentifier, dottedIdentifierType);
+                }
+
+                return this.bindMethod(argument);
+            }).ToList();
+
             return BindAsUriFunction(functionCallToken, argumentNodes);
         }
 
@@ -426,6 +447,50 @@ private bool TryBindIdentifier(string identifier, IEnumerable<FunctionParameterT
             return true;
         }
 
+        /// <summary>
+        /// Binds a <see cref="DottedIdentifierToken"/> for the 'isof' and 'cast' function calls.
+        /// </summary>
+        /// <param name="dottedIdentifierToken">The dotted identifier token to bind.</param>
+        /// <param name="childType">The child type to bind to.</param>
+        /// <returns>A <see cref="QueryNode"/> representing the bound single resource node.</returns>
+        /// <exception cref="ODataException">Thrown when the token cannot be bound as a single resource node.</exception>
+        private QueryNode TryBindDottedIdentifierForIsOfOrCastFunctionCall(DottedIdentifierToken dottedIdentifierToken, IEdmSchemaType childType)
+        {
+            QueryNode parent = null;
+            IEdmType parentType = null;
+
+            if (state.ImplicitRangeVariable != null)
+            {
+                if (dottedIdentifierToken.NextToken == null)
+                {
+                    parent = NodeFactory.CreateRangeVariableReferenceNode(state.ImplicitRangeVariable);
+                    parentType = state.ImplicitRangeVariable.TypeReference.Definition;
+                }
+                else
+                {
+                    parent = this.bindMethod(dottedIdentifierToken.NextToken);
+                    parentType = parent.GetEdmType();
+                }
+            }
+
+            if (childType is not IEdmStructuredType childStructuredType)
+            {
+                return this.bindMethod(dottedIdentifierToken);
+            }
+
+            if (parentType != null)
+            {
+                this.state.ParsedSegments.Add(new TypeSegment(childType, parentType, null));
+            }
+
+            if (parent is CollectionResourceNode parentAsCollection)
+            {
+                return new CollectionResourceCastNode(parentAsCollection, childStructuredType);
+            }
+
+            return new SingleResourceCastNode(parent as SingleResourceNode, childStructuredType);
+        }
+
         /// <summary>
         /// Bind path segment's operation or operationImport's parameters.
         /// </summary>

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

@@ -409,20 +409,24 @@ 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'")]
+        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, 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);
@@ -499,17 +503,21 @@ public void ParseFilterEnumMemberUndefined4()
             parse.Throws<ODataException>(Strings.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>(Strings.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>(Strings.CastBinder_EnumOnlyCastToOrFromString);
         }