VS-79: Linq expressions are not analyzed without "using MongoDB.Driver.Linq;" (#28)

Author: BorisDog

src/MongoDB.Analyzer/Core/Linq/LinqExpressionProcessor.cs

@@ -76,17 +76,22 @@ public static ExpressionsAnalysis ProcessSemanticModel(MongoAnalyzerContext cont
  {
  var methodSymbol = invocationNode.GetMethodSymbol(semanticModel);
 
- if (!methodSymbol.IsDefinedInMongoLinq() ||
- !methodSymbol.ReceiverType.IsIMongoQueryable() ||
- !methodSymbol.ReturnType.IsIMongoQueryable())
+ if (!methodSymbol.IsDefinedInMongoLinqOrSystemLinq() ||
+ !methodSymbol.ReceiverType.IsIQueryable() ||
+ !methodSymbol.ReturnType.IsIQueryable())
  {
  continue;
  }
 
  deepestMongoQueryableNode = invocationNode
  .NestedInvocations()
  .FirstOrDefault(n =>
- n.GetMethodSymbol(semanticModel)?.ReducedFrom?.ReceiverType.IsMongoQueryable() != true);
+ {
+ var currentMethodSymbol = n.GetMethodSymbol(semanticModel);
+
+ // Find the first method that is not receiving IQueryable or is not defined in System.Linq or MongoDB.Driver.Linq
+ return !((currentMethodSymbol?.ReceiverType).IsIQueryable() && currentMethodSymbol.IsDefinedInMongoLinqOrSystemLinq());
+ });
  }
  else
  {
@@ -245,6 +250,11 @@ private static (SyntaxNode RewrittenLinqExpression, ConstantsMapper ConstantsMap
 
  var symbolInfo = semanticModel.GetSymbolInfo(identifierNode);
 
+ if (symbolInfo.Symbol == null)
+ {
+ return default;
+ }
+
  var rewriteResult = symbolInfo.Symbol.Kind switch
  {
  SymbolKind.Field => HandleField(rewriteContext, nodeToHandle, symbolInfo),
@@ -262,7 +272,7 @@ SymbolKind.Parameter or
  nodesRemapping[rewriteResult.NodeToReplace] = rewriteResult.NewNode;
  break;
  case RewriteAction.Invalid:
- return (null, null);
+ return default;
  }
  }
 
@@ -272,7 +282,7 @@ SymbolKind.Parameter or
  }
  catch
  {
- return (null, null);
+ return default;
  }
  }
 
@@ -359,8 +369,8 @@ private static RewriteResult HandleMethod(
  SymbolInfo symbolInfo)
  {
  var methodSymbol = symbolInfo.Symbol as IMethodSymbol;
- if (methodSymbol.ReceiverType.IsIMongoQueryable() ||
- methodSymbol.ReturnType.IsIMongoQueryable() ||
+ if (methodSymbol.ReceiverType.IsIQueryable() ||
+ methodSymbol.ReturnType.IsIQueryable() ||
  methodSymbol.ReturnType == null ||
  IsChildOfLambdaOrQueryParameter(rewriteContext, identifierNode, symbolInfo))
  {

src/MongoDB.Analyzer/Core/Utilities/SymbolExtensions.cs

@@ -16,6 +16,11 @@ namespace MongoDB.Analyzer.Core;
 
 internal static class SymbolExtensions
 {
+ private const string AssemblyMongoDBDriver = "MongoDB.Driver";
+ private const string NamespaceMongoDBDriver = "MongoDB.Driver";
+ private const string NamespaceMongoDBLinq = "MongoDB.Driver.Linq";
+ private const string NamespaceSystemLinq = "System.Linq";
+
  private static readonly HashSet<string> s_supportedCollections = new()
  {
  "System.Collections.Generic.List<T>",
@@ -41,9 +46,16 @@ public static bool IsContainedInLambdaOrQueryParameter(this ISymbol symbol, Synt
  _ => symbol.IsContainedInLambda(parentNode)
  };
 
- public static bool IsDefinedInMongoLinq(this ISymbol symbol) =>
- symbol?.ContainingModule?.Name?.ToLowerInvariant() == "mongodb.driver.dll" &&
- symbol?.ContainingNamespace?.Name == "Linq";
+ public static bool IsDefinedInMongoLinqOrSystemLinq(this ISymbol symbol)
+ {
+ var containingNamespace = symbol?.ContainingNamespace?.ToDisplayString();
+
+ // In case of system linq, the containing module is not validated for simplicity,
+ // as it can differ in different .net frameworks.
+ return containingNamespace == NamespaceSystemLinq ||
+ containingNamespace == NamespaceMongoDBLinq &&
+ symbol?.ContainingAssembly.Name == AssemblyMongoDBDriver;
+ }
 
  public static bool IsBuilder(this ITypeSymbol typeSymbol) =>
  typeSymbol?.Name switch
@@ -92,16 +104,16 @@ public static bool IsFindFluentMethod(this IMethodSymbol methodSymbol) =>
 
  public static bool IsFindOptions(this ITypeSymbol namedTypeSymbol) =>
  namedTypeSymbol?.Name == "FindOptions" &&
- namedTypeSymbol?.ContainingAssembly.Name == "MongoDB.Driver";
+ namedTypeSymbol?.ContainingAssembly.Name == AssemblyMongoDBDriver;
 
- public static bool IsIMongoCollection(this ITypeSymbol typeSymbol) => ImplementsOrIsInterface(typeSymbol, "MongoDB.Driver", "IMongoCollection");
+ public static bool IsIMongoCollection(this ITypeSymbol typeSymbol) => ImplementsOrIsInterface(typeSymbol, NamespaceMongoDBDriver, "IMongoCollection");
 
  public static bool IsIMongoQueryable(this ITypeSymbol typeSymbol) =>
- ImplementsOrIsInterface(typeSymbol, "MongoDB.Driver.Linq", "IMongoQueryable") ||
- ImplementsOrIsInterface(typeSymbol, "MongoDB.Driver.Linq", "IOrderedMongoQueryable");
+ ImplementsOrIsInterface(typeSymbol, NamespaceMongoDBLinq, "IMongoQueryable") ||
+ ImplementsOrIsInterface(typeSymbol, NamespaceMongoDBLinq, "IOrderedMongoQueryable");
 
- public static bool IsLinqEnumerable(this ITypeSymbol typeSymbol) =>
- typeSymbol?.Name == "Enumerable" && typeSymbol.ContainingNamespace.Name == "Linq";
+ public static bool IsIQueryable(this ITypeSymbol typeSymbol) =>
+ ImplementsOrIsInterface(typeSymbol, NamespaceSystemLinq, nameof(IQueryable));
 
  public static bool IsMongoQueryable(this ITypeSymbol typeSymbol) =>
  typeSymbol?.Name == "MongoQueryable";
@@ -132,11 +144,16 @@ typeSymbol is INamedTypeSymbol namedType &&
  namedType.TypeArguments.Length == 1 &&
  namedType.TypeArguments[0].IsSupportedMongoCollectionType();
 
- private static bool ImplementsOrIsInterface(this ITypeSymbol typeSymbol, string @namespace, string interfaceName) =>
- typeSymbol?.TypeKind switch
+ private static bool ImplementsOrIsInterface(this ITypeSymbol typeSymbol, string @namespace, string interfaceName)
+ {
+ if (typeSymbol == null)
  {
- TypeKind.Class => typeSymbol.Interfaces.Any(i => i.Name == interfaceName && i.ContainingNamespace.ToDisplayString() == @namespace),
- TypeKind.Interface => typeSymbol.Name == interfaceName && typeSymbol.ContainingNamespace.ToDisplayString() == @namespace,
- _ => false
- };
+ return false;
+ }
+
+ return IsType(typeSymbol) || typeSymbol.Interfaces.Any(IsType);
+
+ bool IsType(ITypeSymbol typeSymbol) =>
+ typeSymbol.Name == interfaceName && typeSymbol.ContainingNamespace.ToDisplayString() == @namespace;
+ }
 }