CSHARP-5572: Rename KnownSerializer to NodeSerializer at reviewer's request

Author: rstam

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/UnknownSerializerFinder.cs renamed to src/MongoDB.Driver/Linq/Linq3Implementation/SerializerFinders/MissingSerializerFinder.cs

@@ -14,48 +14,47 @@
  */
 
 using System.Linq.Expressions;
-using MongoDB.Bson;
 using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
 using ExpressionVisitor = System.Linq.Expressions.ExpressionVisitor;
 
-namespace MongoDB.Driver.Linq.Linq3Implementation.KnownSerializerFinders;
+namespace MongoDB.Driver.Linq.Linq3Implementation.SerializerFinders;
 
-internal class UnknownSerializerFinder : ExpressionVisitor
+internal class MissingSerializerFinder : ExpressionVisitor
 {
-    public static Expression FindExpressionWithUnknownSerializer(Expression expression, KnownSerializerMap knownSerializers)
+    public static Expression FindExpressionWithMissingSerializer(Expression expression, SerializerMap nodeSerializers)
     {
-        var visitor = new UnknownSerializerFinder(knownSerializers);
+        var visitor = new MissingSerializerFinder(nodeSerializers);
         visitor.Visit(expression);
-        return visitor._expressionWithUnknownSerializer;
+        return visitor._expressionWithMissingSerializer;
     }
 
-    private Expression _expressionWithUnknownSerializer = null;
-    private readonly KnownSerializerMap _knownSerializers;
+    private Expression _expressionWithMissingSerializer = null;
+    private readonly SerializerMap _nodeSerializers;
 
-    public UnknownSerializerFinder(KnownSerializerMap knownSerializers)
+    public MissingSerializerFinder(SerializerMap nodeSerializers)
     {
-        _knownSerializers = knownSerializers;
+        _nodeSerializers = nodeSerializers;
     }
 
-    public Expression ExpressionWithUnknownSerializer => _expressionWithUnknownSerializer;
+    public Expression ExpressionWithMissingSerializer => _expressionWithMissingSerializer;
 
     public override Expression Visit(Expression node)
     {
-        if (_knownSerializers.IsKnown(node, out var knownSerializer))
+        if (_nodeSerializers.IsKnown(node, out var nodeSerializer))
         {
-            if (knownSerializer is IIgnoreSubtreeSerializer or IUnknowableSerializer)
+            if (nodeSerializer is IIgnoreSubtreeSerializer or IUnknowableSerializer)
             {
                 return node; // don't visit subtree
             }
         }
 
         base.Visit(node);
 
-        if (_expressionWithUnknownSerializer == null &&
+        if (_expressionWithMissingSerializer == null &&
             node != null &&
-            _knownSerializers.IsNotKnown(node))
+            _nodeSerializers.IsNotKnown(node))
         {
-            _expressionWithUnknownSerializer = node;
+            _expressionWithMissingSerializer = node;
         }
 
         return node;

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinder.cs renamed to src/MongoDB.Driver/Linq/Linq3Implementation/SerializerFinders/SerializerFinder.cs

@@ -15,16 +15,16 @@
 
 using System.Linq.Expressions;
 
-namespace MongoDB.Driver.Linq.Linq3Implementation.KnownSerializerFinders;
+namespace MongoDB.Driver.Linq.Linq3Implementation.SerializerFinders;
 
-internal static class KnownSerializerFinder
+internal static class SerializerFinder
 {
-    public static void FindKnownSerializers(
+    public static void FindSerializers(
         Expression expression,
         ExpressionTranslationOptions translationOptions,
-        KnownSerializerMap knownSerializers)
+        SerializerMap nodeSerializers)
     {
-        var visitor = new KnownSerializerFinderVisitor(translationOptions, knownSerializers);
+        var visitor = new SerializerFinderVisitor(translationOptions, nodeSerializers);
 
         do
         {
@@ -35,10 +35,10 @@ public static void FindKnownSerializers(
         while (visitor.IsMakingProgress);
 
         //#if DEBUG
-        var expressionWithUnknownSerializer = UnknownSerializerFinder.FindExpressionWithUnknownSerializer(expression, knownSerializers);
-        if (expressionWithUnknownSerializer != null)
+        var expressionWithMissingSerializer = MissingSerializerFinder.FindExpressionWithMissingSerializer(expression, nodeSerializers);
+        if (expressionWithMissingSerializer != null)
         {
-            throw new ExpressionNotSupportedException(expressionWithUnknownSerializer, because: "we were unable to determine which serializer to use for the result");
+            throw new ExpressionNotSupportedException(expressionWithMissingSerializer, because: "we were unable to determine which serializer to use for the result");
         }
         //#endif
     }

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderHelperMethods.cs renamed to src/MongoDB.Driver/Linq/Linq3Implementation/SerializerFinders/SerializerFinderHelperMethods.cs

@@ -23,44 +23,44 @@
 using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
 using IOrderedEnumerableSerializer=MongoDB.Driver.Linq.Linq3Implementation.Serializers.IOrderedEnumerableSerializer;
 
-namespace MongoDB.Driver.Linq.Linq3Implementation.KnownSerializerFinders;
+namespace MongoDB.Driver.Linq.Linq3Implementation.SerializerFinders;
 
-internal partial class KnownSerializerFinderVisitor
+internal partial class SerializerFinderVisitor
 {
-    private void AddKnownSerializer(Expression node, IBsonSerializer serializer) => _knownSerializers.AddSerializer(node, serializer);
+    private void AddNodeSerializer(Expression node, IBsonSerializer serializer) => _nodeSerializers.AddSerializer(node, serializer);
 
-    private bool AreAllKnown(IEnumerable<Expression> nodes, out IReadOnlyList<IBsonSerializer> knownSerializers)
+    private bool AreAllKnown(IEnumerable<Expression> nodes, out IReadOnlyList<IBsonSerializer> nodeSerializers)
     {
-        var knownSerializersList = new List<IBsonSerializer>();
+        var nodeSerializersList = new List<IBsonSerializer>();
         foreach (var node in nodes)
         {
             if (IsKnown(node, out var nodeSerializer))
             {
-                knownSerializersList.Add(nodeSerializer);
+                nodeSerializersList.Add(nodeSerializer);
             }
             else
             {
-                knownSerializers = null;
+                nodeSerializers = null;
                 return false;
             }
         }
 
-        knownSerializers = knownSerializersList;
+        nodeSerializers = nodeSerializersList;
         return true;
     }
 
-    private bool IsAnyKnown(IEnumerable<Expression> nodes, out IBsonSerializer knownSerializer)
+    private bool IsAnyKnown(IEnumerable<Expression> nodes, out IBsonSerializer nodeSerializer)
     {
         foreach (var node in nodes)
         {
-            if (IsKnown(node, out var nodeSerializer))
+            if (IsKnown(node, out var outSerializer))
             {
-                knownSerializer = nodeSerializer;
+                nodeSerializer = outSerializer;
                 return true;
             }
         }
 
-        knownSerializer = null;
+        nodeSerializer = null;
         return false;
     }
 
@@ -69,24 +69,24 @@ private bool IsAnyNotKnown(IEnumerable<Expression> nodes)
         return nodes.Any(IsNotKnown);
     }
 
-    private bool CanDeduceSerializer(Expression node1, Expression node2, out Expression unknownNode, out IBsonSerializer knownSerializer)
+    private bool CanDeduceSerializer(Expression node1, Expression node2, out Expression unknownNode, out IBsonSerializer otherNodeSerializer)
     {
         if (IsNotKnown(node1) && IsKnown(node2, out var node2Serializer))
         {
             unknownNode = node1;
-            knownSerializer = node2Serializer;
+            otherNodeSerializer = node2Serializer;
             return true;
         }
 
         if (IsNotKnown(node2) && IsKnown(node1, out var node1Serializer))
         {
             unknownNode = node2;
-            knownSerializer = node1Serializer;
+            otherNodeSerializer = node1Serializer;
             return true;
         }
 
         unknownNode = null;
-        knownSerializer = null;
+        otherNodeSerializer = null;
         return false;
     }
 
@@ -125,47 +125,53 @@ IBsonSerializer CreateCollectionSerializerFromItemSerializer(Type collectionType
 
     private void DeduceBaseTypeAndDerivedTypeSerializers(Expression baseTypeExpression, Expression derivedTypeExpression)
     {
-        if (IsNotKnown(baseTypeExpression) && IsKnown(derivedTypeExpression, out var knownDerivedTypeSerializer))
+        IBsonSerializer baseTypeSerializer;
+        IBsonSerializer derivedTypeSerializer;
+
+        if (IsNotKnown(baseTypeExpression) && IsKnown(derivedTypeExpression, out derivedTypeSerializer))
         {
-            var baseTypeSerializer = knownDerivedTypeSerializer.GetBaseTypeSerializer(baseTypeExpression.Type);
-            AddKnownSerializer(baseTypeExpression, baseTypeSerializer);
+            baseTypeSerializer = derivedTypeSerializer.GetBaseTypeSerializer(baseTypeExpression.Type);
+            AddNodeSerializer(baseTypeExpression, baseTypeSerializer);
         }
 
-        if (IsNotKnown(derivedTypeExpression) && IsKnown(baseTypeExpression, out var knownBaseTypeSerializer))
+        if (IsNotKnown(derivedTypeExpression) && IsKnown(baseTypeExpression, out baseTypeSerializer))
         {
-            var derivedTypeSerializer = knownBaseTypeSerializer.GetDerivedTypeSerializer(baseTypeExpression.Type);
-            AddKnownSerializer(derivedTypeExpression, derivedTypeSerializer);
+            derivedTypeSerializer = baseTypeSerializer.GetDerivedTypeSerializer(baseTypeExpression.Type);
+            AddNodeSerializer(derivedTypeExpression, derivedTypeSerializer);
         }
     }
 
     private void DeduceBooleanSerializer(Expression node)
     {
         if (IsNotKnown(node))
         {
-            AddKnownSerializer(node, BooleanSerializer.Instance);
+            AddNodeSerializer(node, BooleanSerializer.Instance);
         }
     }
 
     private void DeduceCharSerializer(Expression node)
     {
         if (IsNotKnown(node))
         {
-            AddKnownSerializer(node, CharSerializer.Instance);
+            AddNodeSerializer(node, CharSerializer.Instance);
         }
     }
 
     private void DeduceCollectionAndCollectionSerializers(Expression collectionExpression1, Expression collectionExpression2)
     {
-        if (IsNotKnown(collectionExpression1) && IsKnown(collectionExpression2, out var knownCollectionSerializer2))
+        IBsonSerializer collectionSerializer1;
+        IBsonSerializer collectionSerializer2;
+
+        if (IsNotKnown(collectionExpression1) && IsKnown(collectionExpression2, out collectionSerializer2))
         {
-            var collectionSerializer1 = CreateCollectionSerializerFromCollectionSerializer(collectionExpression1.Type, knownCollectionSerializer2);
-            AddKnownSerializer(collectionExpression1, collectionSerializer1);
+            collectionSerializer1 = CreateCollectionSerializerFromCollectionSerializer(collectionExpression1.Type, collectionSerializer2);
+            AddNodeSerializer(collectionExpression1, collectionSerializer1);
         }
 
-        if (IsNotKnown(collectionExpression2) && IsKnown(collectionExpression1, out var knownCollectionSerializer1))
+        if (IsNotKnown(collectionExpression2) && IsKnown(collectionExpression1, out collectionSerializer1))
         {
-            var collectionSerializer2 = CreateCollectionSerializerFromCollectionSerializer(collectionExpression2.Type, knownCollectionSerializer1);
-            AddKnownSerializer(collectionExpression2, collectionSerializer2);
+             collectionSerializer2 = CreateCollectionSerializerFromCollectionSerializer(collectionExpression2.Type, collectionSerializer1);
+            AddNodeSerializer(collectionExpression2, collectionSerializer2);
         }
     }
 
@@ -178,15 +184,15 @@ private void DeduceItemAndCollectionSerializers(Expression itemExpression, Expre
     {
         if (IsNotKnown(itemExpression) && IsItemSerializerKnown(collectionExpression, out var itemSerializer))
         {
-            AddKnownSerializer(itemExpression, itemSerializer);
+            AddNodeSerializer(itemExpression, itemSerializer);
         }
 
         if (IsNotKnown(collectionExpression) && IsKnown(itemExpression, out itemSerializer))
         {
             var collectionSerializer = CreateCollectionSerializerFromItemSerializer(collectionExpression.Type, itemSerializer);
             if (collectionSerializer != null)
             {
-                AddKnownSerializer(collectionExpression, collectionSerializer);
+                AddNodeSerializer(collectionExpression, collectionSerializer);
             }
         }
     }
@@ -195,28 +201,28 @@ private void DeduceSerializer(Expression node, IBsonSerializer serializer)
     {
         if (IsNotKnown(node) && serializer != null)
         {
-            AddKnownSerializer(node, serializer);
+            AddNodeSerializer(node, serializer);
         }
     }
 
     private void DeduceSerializers(Expression expression1, Expression expression2)
     {
         if (IsNotKnown(expression1) && IsKnown(expression2, out var expression2Serializer) && expression2Serializer.ValueType == expression1.Type)
         {
-            AddKnownSerializer(expression1, expression2Serializer);
+            AddNodeSerializer(expression1, expression2Serializer);
         }
 
         if (IsNotKnown(expression2) && IsKnown(expression1, out var expression1Serializer)&&  expression1Serializer.ValueType == expression2.Type)
         {
-            AddKnownSerializer(expression2, expression1Serializer);
+            AddNodeSerializer(expression2, expression1Serializer);
         }
     }
 
     private void DeduceStringSerializer(Expression node)
     {
         if (IsNotKnown(node))
         {
-            AddKnownSerializer(node, StringSerializer.Instance);
+            AddNodeSerializer(node, StringSerializer.Instance);
         }
     }
 
@@ -225,7 +231,7 @@ private void DeduceUnknowableSerializer(Expression node)
         if (IsNotKnown(node))
         {
             var unknowableSerializer = UnknowableSerializer.Create(node.Type);
-            AddKnownSerializer(node, unknowableSerializer);
+            AddNodeSerializer(node, unknowableSerializer);
         }
     }
 
@@ -243,9 +249,9 @@ nodeSerializer is IBsonArraySerializer arraySerializer &&
         return false;
     }
 
-    private bool IsKnown(Expression node) => _knownSerializers.IsKnown(node);
+    private bool IsKnown(Expression node) => _nodeSerializers.IsKnown(node);
 
-    private bool IsKnown(Expression node, out IBsonSerializer knownSerializer) => _knownSerializers.IsKnown(node, out knownSerializer);
+    private bool IsKnown(Expression node, out IBsonSerializer nodeSerializer) => _nodeSerializers.IsKnown(node, out nodeSerializer);
 
-    private bool IsNotKnown(Expression node) => _knownSerializers.IsNotKnown(node);
+    private bool IsNotKnown(Expression node) => _nodeSerializers.IsNotKnown(node);
 }

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderNewExpressionSerializerCreator.cs renamed to src/MongoDB.Driver/Linq/Linq3Implementation/SerializerFinders/SerializerFinderNewExpressionSerializerCreator.cs

@@ -23,9 +23,9 @@
 using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
 using MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToAggregationExpressionTranslators;
 
-namespace MongoDB.Driver.Linq.Linq3Implementation.KnownSerializerFinders;
+namespace MongoDB.Driver.Linq.Linq3Implementation.SerializerFinders;
 
-internal partial class KnownSerializerFinderVisitor
+internal partial class SerializerFinderVisitor
 {
     public IBsonSerializer CreateNewExpressionSerializer(
         Expression expression,