#440

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -1795,19 +1795,25 @@ private Expression ParseMemberAccess(Type? type, Expression? expression, string?
 
  if (_textParser.CurrentToken.Id == TokenId.OpenParen)
  {
+ Expression[]? args = null;
+
  var isStaticAccess = expression == null;
 
- if (!isStaticAccess && type != typeof(string))
+ if (!isStaticAccess)
  {
  var enumerableType = TypeHelper.FindGenericType(typeof(IEnumerable<>), type);
  if (enumerableType != null)
  {
- Type elementType = enumerableType.GetTypeInfo().GetGenericTypeArguments()[0];
- return ParseEnumerable(expression!, elementType, id, errorPos, type);
+ var elementType = enumerableType.GetTypeInfo().GetGenericTypeArguments()[0];
+ if (TryParseEnumerable(expression!, elementType, id, errorPos, type, out args, out var enumerableExpression))
+ {
+ return enumerableExpression;
+ }
  }
  }
 
- Expression[] args = ParseArgumentList();
+ // If args is not set by TryParseEnumerable (in case when the expression is not an Enumerable), do parse the argument list here.
+ args ??= ParseArgumentList();
  switch (_methodFinder.FindMethod(type, id, isStaticAccess, ref expression, ref args, out var methodBase))
  {
  case 0:
@@ -2038,7 +2044,7 @@ private Expression ParseAsEnumOrNestedClass(string id)
  return ParseMemberAccess(type, null, identifier);
  }
 
- private Expression ParseEnumerable(Expression instance, Type elementType, string methodName, int errorPos, Type? type)
+ private bool TryParseEnumerable(Expression instance, Type elementType, string methodName, int errorPos, Type? type, out Expression[]? args, [NotNullWhen(true)] out Expression? expression)
  {
  var oldParent = _parent;
 
@@ -2057,15 +2063,24 @@ private Expression ParseEnumerable(Expression instance, Type elementType, string
  _it = innerIt;
  }
 
- Expression[] args = ParseArgumentList();
+ args = ParseArgumentList();
+
+ var t = type ?? instance.Type;
+ if (t == typeof(string) && _methodFinder.ContainsMethod(t, methodName, false, instance, ref args))
+ {
+ // In case the type is a string, and does contain the methodName (like "IndexOf"), then return false to indicate that the methodName is not an Enumerable method.
+ expression = null;
+ return false;
+ }
 
  _it = outerIt;
  _parent = oldParent;
 
  if (type != null && TypeHelper.IsDictionary(type) && _methodFinder.ContainsMethod(type, methodName, false))
  {
  var dictionaryMethod = type.GetMethod(methodName)!;
- return Expression.Call(instance, dictionaryMethod, args);
+ expression = Expression.Call(instance, dictionaryMethod, args);
+ return true;
  }
 
  // #794 - Check if the method is an aggregate (Average or Sum) method and try to update the arguments to match the method arguments
@@ -2139,7 +2154,8 @@ private Expression ParseEnumerable(Expression instance, Type elementType, string
  }
  }
 
- return Expression.Call(callType, methodName, typeArgs, args);
+ expression = Expression.Call(callType, methodName, typeArgs, args);
+ return true;
  }
 
  private Type ResolveTypeFromArgumentExpression(string functionName, Expression argumentExpression, int? arguments = null)