SERVER-23608 Make MatchExpressionParser take a CollatorInterface*

1 files changed, 682 insertions, 207 deletions

diff --git a/src/mongo/db/matcher/expression_parser_leaf_test.cpp b/src/mongo/db/matcher/expression_parser_leaf_test.cpp
index 23eb7e79ac1..b3a3639defd 100644
--- a/src/mongo/db/matcher/expression_parser_leaf_test.cpp
+++ b/src/mongo/db/matcher/expression_parser_leaf_test.cpp
@@ -39,6 +39,7 @@
 #include "mongo/db/matcher/expression.h"
 #include "mongo/db/matcher/expression_leaf.h"
 #include "mongo/db/matcher/extensions_callback_disallow_extensions.h"
+#include "mongo/db/query/collation/collator_interface_mock.h"
 #include "mongo/platform/decimal128.h"
 #include "mongo/util/log.h"
 
@@ -47,10 +48,36 @@ namespace mongo {
 using std::endl;
 using std::string;
 
+TEST(MatchExpressionParserLeafTest, NullCollation) {
+    BSONObj query = BSON("x"
+                         << "string");
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::EQ, result.getValue()->matchType());
+    EqualityMatchExpression* match = static_cast<EqualityMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == collator);
+}
+
+
+TEST(MatchExpressionParserLeafTest, Collation) {
+    BSONObj query = BSON("x"
+                         << "string");
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::EQ, result.getValue()->matchType());
+    EqualityMatchExpression* match = static_cast<EqualityMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == &collator);
+}
+
 TEST(MatchExpressionParserLeafTest, SimpleEQ2) {
     BSONObj query = BSON("x" << BSON("$eq" << 2));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(!result.getValue()->matchesBSON(BSON("x" << 1)));
@@ -60,25 +87,78 @@ TEST(MatchExpressionParserLeafTest, SimpleEQ2) {
 
 TEST(MatchExpressionParserLeafTest, SimpleEQUndefined) {
     BSONObj query = BSON("x" << BSON("$eq" << BSONUndefined));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
+TEST(MatchExpressionParserLeafTest, EQNullCollation) {
+    BSONObj query = BSON("x" << BSON("$eq"
+                                     << "string"));
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::EQ, result.getValue()->matchType());
+    EqualityMatchExpression* match = static_cast<EqualityMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == collator);
+}
+
+
+TEST(MatchExpressionParserLeafTest, EQCollation) {
+    BSONObj query = BSON("x" << BSON("$eq"
+                                     << "string"));
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::EQ, result.getValue()->matchType());
+    EqualityMatchExpression* match = static_cast<EqualityMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == &collator);
+}
+
 TEST(MatchExpressionParserLeafTest, SimpleGT1) {
     BSONObj query = BSON("x" << BSON("$gt" << 2));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(!result.getValue()->matchesBSON(BSON("x" << 2)));
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 3)));
 }
 
+TEST(MatchExpressionParserLeafTest, GTNullCollation) {
+    BSONObj query = BSON("x" << BSON("$gt"
+                                     << "abc"));
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::GT, result.getValue()->matchType());
+    GTMatchExpression* match = static_cast<GTMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == collator);
+}
+
+
+TEST(MatchExpressionParserLeafTest, GTCollation) {
+    BSONObj query = BSON("x" << BSON("$gt"
+                                     << "abc"));
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::GT, result.getValue()->matchType());
+    GTMatchExpression* match = static_cast<GTMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == &collator);
+}
+
 TEST(MatchExpressionParserLeafTest, SimpleLT1) {
     BSONObj query = BSON("x" << BSON("$lt" << 2));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 1)));
@@ -86,10 +166,36 @@ TEST(MatchExpressionParserLeafTest, SimpleLT1) {
     ASSERT(!result.getValue()->matchesBSON(BSON("x" << 3)));
 }
 
+TEST(MatchExpressionParserLeafTest, LTNullCollation) {
+    BSONObj query = BSON("x" << BSON("$lt"
+                                     << "abc"));
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::LT, result.getValue()->matchType());
+    LTMatchExpression* match = static_cast<LTMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == collator);
+}
+
+
+TEST(MatchExpressionParserLeafTest, LTCollation) {
+    BSONObj query = BSON("x" << BSON("$lt"
+                                     << "abc"));
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::LT, result.getValue()->matchType());
+    LTMatchExpression* match = static_cast<LTMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == &collator);
+}
+
 TEST(MatchExpressionParserLeafTest, SimpleGTE1) {
     BSONObj query = BSON("x" << BSON("$gte" << 2));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(!result.getValue()->matchesBSON(BSON("x" << 1)));
@@ -97,10 +203,36 @@ TEST(MatchExpressionParserLeafTest, SimpleGTE1) {
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 3)));
 }
 
+TEST(MatchExpressionParserLeafTest, GTENullCollation) {
+    BSONObj query = BSON("x" << BSON("$gte"
+                                     << "abc"));
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::GTE, result.getValue()->matchType());
+    GTEMatchExpression* match = static_cast<GTEMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == collator);
+}
+
+
+TEST(MatchExpressionParserLeafTest, GTECollation) {
+    BSONObj query = BSON("x" << BSON("$gte"
+                                     << "abc"));
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::GTE, result.getValue()->matchType());
+    GTEMatchExpression* match = static_cast<GTEMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == &collator);
+}
+
 TEST(MatchExpressionParserLeafTest, SimpleLTE1) {
     BSONObj query = BSON("x" << BSON("$lte" << 2));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 1)));
@@ -108,10 +240,36 @@ TEST(MatchExpressionParserLeafTest, SimpleLTE1) {
     ASSERT(!result.getValue()->matchesBSON(BSON("x" << 3)));
 }
 
+TEST(MatchExpressionParserLeafTest, LTENullCollation) {
+    BSONObj query = BSON("x" << BSON("$lte"
+                                     << "abc"));
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::LTE, result.getValue()->matchType());
+    LTEMatchExpression* match = static_cast<LTEMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == collator);
+}
+
+
+TEST(MatchExpressionParserLeafTest, LTECollation) {
+    BSONObj query = BSON("x" << BSON("$lte"
+                                     << "abc"));
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::LTE, result.getValue()->matchType());
+    LTEMatchExpression* match = static_cast<LTEMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == &collator);
+}
+
 TEST(MatchExpressionParserLeafTest, SimpleNE1) {
     BSONObj query = BSON("x" << BSON("$ne" << 2));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 1)));
@@ -119,37 +277,68 @@ TEST(MatchExpressionParserLeafTest, SimpleNE1) {
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 3)));
 }
 
+TEST(MatchExpressionParserLeafTest, NENullCollation) {
+    BSONObj query = BSON("x" << BSON("$ne"
+                                     << "string"));
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::NOT, result.getValue()->matchType());
+    MatchExpression* child = result.getValue()->getChild(0);
+    ASSERT_EQUALS(MatchExpression::EQ, child->matchType());
+    EqualityMatchExpression* eqMatch = static_cast<EqualityMatchExpression*>(child);
+    ASSERT_TRUE(eqMatch->getCollator() == collator);
+}
+
+
+TEST(MatchExpressionParserLeafTest, NECollation) {
+    BSONObj query = BSON("x" << BSON("$ne"
+                                     << "string"));
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::NOT, result.getValue()->matchType());
+    MatchExpression* child = result.getValue()->getChild(0);
+    ASSERT_EQUALS(MatchExpression::EQ, child->matchType());
+    EqualityMatchExpression* eqMatch = static_cast<EqualityMatchExpression*>(child);
+    ASSERT_TRUE(eqMatch->getCollator() == &collator);
+}
+
 TEST(MatchExpressionParserLeafTest, SimpleModBad1) {
     BSONObj query = BSON("x" << BSON("$mod" << BSON_ARRAY(3 << 2)));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     query = BSON("x" << BSON("$mod" << BSON_ARRAY(3)));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(!result.isOK());
 
     query = BSON("x" << BSON("$mod" << BSON_ARRAY(3 << 2 << 4)));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(!result.isOK());
 
     query = BSON("x" << BSON("$mod" << BSON_ARRAY("q" << 2)));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(!result.isOK());
 
     query = BSON("x" << BSON("$mod" << 3));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(!result.isOK());
 
     query = BSON("x" << BSON("$mod" << BSON("a" << 1 << "b" << 2)));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(!result.isOK());
 }
 
 TEST(MatchExpressionParserLeafTest, SimpleMod1) {
     BSONObj query = BSON("x" << BSON("$mod" << BSON_ARRAY(3 << 2)));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 5)));
@@ -159,8 +348,9 @@ TEST(MatchExpressionParserLeafTest, SimpleMod1) {
 
 TEST(MatchExpressionParserLeafTest, SimpleModNotNumber) {
     BSONObj query = BSON("x" << BSON("$mod" << BSON_ARRAY(2 << "r")));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 2)));
@@ -170,11 +360,59 @@ TEST(MatchExpressionParserLeafTest, SimpleModNotNumber) {
                                                 << "a")));
 }
 
+TEST(MatchExpressionParserLeafTest, IdCollation) {
+    BSONObj query = BSON("$id"
+                         << "string");
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::EQ, result.getValue()->matchType());
+    EqualityMatchExpression* match = static_cast<EqualityMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == collator);
+}
+
+TEST(MatchExpressionParserLeafTest, IdNullCollation) {
+    BSONObj query = BSON("$id"
+                         << "string");
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::EQ, result.getValue()->matchType());
+    EqualityMatchExpression* match = static_cast<EqualityMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == &collator);
+}
+
+TEST(MatchExpressionParserLeafTest, RefCollation) {
+    BSONObj query = BSON("$ref"
+                         << "coll");
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::EQ, result.getValue()->matchType());
+    EqualityMatchExpression* match = static_cast<EqualityMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == nullptr);
+}
+
+TEST(MatchExpressionParserLeafTest, DbCollation) {
+    BSONObj query = BSON("$db"
+                         << "db");
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::EQ, result.getValue()->matchType());
+    EqualityMatchExpression* match = static_cast<EqualityMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == nullptr);
+}
 
 TEST(MatchExpressionParserLeafTest, SimpleIN1) {
     BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY(2 << 3)));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(!result.getValue()->matchesBSON(BSON("x" << 1)));
@@ -182,14 +420,37 @@ TEST(MatchExpressionParserLeafTest, SimpleIN1) {
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 3)));
 }
 
+TEST(MatchExpressionParserLeafTest, INNullCollation) {
+    BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY("string")));
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::MATCH_IN, result.getValue()->matchType());
+    InMatchExpression* match = static_cast<InMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == collator);
+}
+
+TEST(MatchExpressionParserLeafTest, INCollation) {
+    BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY("string")));
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::MATCH_IN, result.getValue()->matchType());
+    InMatchExpression* match = static_cast<InMatchExpression*>(result.getValue().get());
+    ASSERT_TRUE(match->getCollator() == &collator);
+}
+
 TEST(MatchExpressionParserLeafTest, INSingleDBRef) {
     OID oid = OID::gen();
     BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$ref"
                                                               << "coll"
                                                               << "$id" << oid << "$db"
                                                               << "db"))));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     OID oidx = OID::gen();
@@ -251,8 +512,9 @@ TEST(MatchExpressionParserLeafTest, INMultipleDBRef) {
                                                                  << "coll"
                                                                  << "$id" << oid << "$db"
                                                                  << "db"))));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     OID oidx = OID::gen();
@@ -351,8 +613,9 @@ TEST(MatchExpressionParserLeafTest, INDBRefWithOptionalField1) {
     BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$ref"
                                                               << "coll"
                                                               << "$id" << oid << "foo" << 12345))));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     OID oidx = OID::gen();
@@ -377,57 +640,62 @@ TEST(MatchExpressionParserLeafTest, INInvalidDBRefs) {
     // missing $id
     BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$ref"
                                                               << "coll"))));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
 
     // second field is not $id
     query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$ref"
                                                       << "coll"
                                                       << "$foo" << 1))));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 
     OID oid = OID::gen();
 
     // missing $ref field
     query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$id" << oid << "foo" << 3))));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 
     // missing $id and $ref field
     query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$db"
                                                       << "test"
                                                       << "foo" << 3))));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
 TEST(MatchExpressionParserLeafTest, INExpressionDocument) {
     BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$foo" << 1))));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
 TEST(MatchExpressionParserLeafTest, INNotArray) {
     BSONObj query = BSON("x" << BSON("$in" << 5));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
 TEST(MatchExpressionParserLeafTest, INUndefined) {
     BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY(BSONUndefined)));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
 TEST(MatchExpressionParserLeafTest, INNotElemMatch) {
     BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$elemMatch" << 1))));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
@@ -438,16 +706,18 @@ TEST(MatchExpressionParserLeafTest, INRegexTooLong) {
     BSONObjBuilder operand;
     operand.appendArray("$in", inArray.obj());
     BSONObj query = BSON("x" << operand.obj());
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
 TEST(MatchExpressionParserLeafTest, INRegexTooLong2) {
     string tooLargePattern(50 * 1000, 'z');
     BSONObj query = BSON("x" << BSON("$in" << BSON_ARRAY(BSON("$regex" << tooLargePattern))));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
@@ -460,8 +730,9 @@ TEST(MatchExpressionParserLeafTest, INRegexStuff) {
     operand.appendArray("$in", inArray.obj());
 
     BSONObj query = BSON("a" << operand.obj());
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     BSONObj matchFirst = BSON("a"
@@ -486,8 +757,9 @@ TEST(MatchExpressionParserLeafTest, INRegexStuff) {
 
 TEST(MatchExpressionParserLeafTest, SimpleNIN1) {
     BSONObj query = BSON("x" << BSON("$nin" << BSON_ARRAY(2 << 3)));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 1)));
@@ -497,18 +769,45 @@ TEST(MatchExpressionParserLeafTest, SimpleNIN1) {
 
 TEST(MatchExpressionParserLeafTest, NINNotArray) {
     BSONObj query = BSON("x" << BSON("$nin" << 5));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
+TEST(MatchExpressionParserLeafTest, NINNullCollation) {
+    BSONObj query = BSON("x" << BSON("$nin" << BSON_ARRAY("string")));
+    CollatorInterface* collator = nullptr;
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::NOT, result.getValue()->matchType());
+    MatchExpression* child = result.getValue()->getChild(0);
+    ASSERT_EQUALS(MatchExpression::MATCH_IN, child->matchType());
+    InMatchExpression* inMatch = static_cast<InMatchExpression*>(child);
+    ASSERT_TRUE(inMatch->getCollator() == collator);
+}
+
+TEST(MatchExpressionParserLeafTest, NINCollation) {
+    BSONObj query = BSON("x" << BSON("$nin" << BSON_ARRAY("string")));
+    CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual);
+    StatusWithMatchExpression result =
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), &collator);
+    ASSERT_TRUE(result.isOK());
+    ASSERT_EQUALS(MatchExpression::NOT, result.getValue()->matchType());
+    MatchExpression* child = result.getValue()->getChild(0);
+    ASSERT_EQUALS(MatchExpression::MATCH_IN, child->matchType());
+    InMatchExpression* inMatch = static_cast<InMatchExpression*>(child);
+    ASSERT_TRUE(inMatch->getCollator() == &collator);
+}
 
 TEST(MatchExpressionParserLeafTest, Regex1) {
     BSONObjBuilder b;
     b.appendRegex("x", "abc", "i");
     BSONObj query = b.obj();
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x"
@@ -524,8 +823,9 @@ TEST(MatchExpressionParserLeafTest, Regex2) {
                                      << "abc"
                                      << "$options"
                                      << "i"));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x"
@@ -541,8 +841,9 @@ TEST(MatchExpressionParserLeafTest, Regex3) {
                                      << "i"
                                      << "$regex"
                                      << "abc"));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     log() << "result: " << result.getStatus() << endl;
     ASSERT_TRUE(result.isOK());
 
@@ -560,35 +861,37 @@ TEST(MatchExpressionParserLeafTest, RegexBad) {
                                      << "abc"
                                      << "$optionas"
                                      << "i"));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 
     // $regex does not with numbers
     query = BSON("x" << BSON("$regex" << 123));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 
     query = BSON("x" << BSON("$regex" << BSON_ARRAY("abc")));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 
     query = BSON("x" << BSON("$optionas"
                              << "i"));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 
     query = BSON("x" << BSON("$options"
                              << "i"));
-    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+    result = MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
 TEST(MatchExpressionParserLeafTest, RegexEmbeddedNULByte) {
     BSONObj query = BSON("x" << BSON("$regex"
                                      << "^a\\x00b"));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     StringData value("a\0b", StringData::LiteralTag());
@@ -601,8 +904,9 @@ TEST(MatchExpressionParserLeafTest, ExistsYes1) {
     BSONObjBuilder b;
     b.appendBool("$exists", true);
     BSONObj query = BSON("x" << b.obj());
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x"
@@ -615,8 +919,9 @@ TEST(MatchExpressionParserLeafTest, ExistsNO1) {
     BSONObjBuilder b;
     b.appendBool("$exists", false);
     BSONObj query = BSON("x" << b.obj());
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(!result.getValue()->matchesBSON(BSON("x"
@@ -627,8 +932,9 @@ TEST(MatchExpressionParserLeafTest, ExistsNO1) {
 
 TEST(MatchExpressionParserLeafTest, Type1) {
     BSONObj query = BSON("x" << BSON("$type" << String));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x"
@@ -638,8 +944,9 @@ TEST(MatchExpressionParserLeafTest, Type1) {
 
 TEST(MatchExpressionParserLeafTest, Type2) {
     BSONObj query = BSON("x" << BSON("$type" << (double)NumberDouble));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(result.getValue()->matchesBSON(BSON("x" << 5.3)));
@@ -648,8 +955,9 @@ TEST(MatchExpressionParserLeafTest, Type2) {
 
 TEST(MatchExpressionParserLeafTest, TypeDoubleOperator) {
     BSONObj query = BSON("x" << BSON("$type" << 1.5));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(!result.getValue()->matchesBSON(BSON("x" << 5.3)));
@@ -659,8 +967,9 @@ TEST(MatchExpressionParserLeafTest, TypeDoubleOperator) {
 TEST(MatchExpressionParserLeafTest, TypeDecimalOperator) {
     if (Decimal128::enabled) {
         BSONObj query = BSON("x" << BSON("$type" << mongo::NumberDecimal));
+        CollatorInterface* collator = nullptr;
         StatusWithMatchExpression result =
-            MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+            MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
         ASSERT_TRUE(result.isOK());
 
         ASSERT_FALSE(result.getValue()->matchesBSON(BSON("x" << 5.3)));
@@ -670,8 +979,9 @@ TEST(MatchExpressionParserLeafTest, TypeDecimalOperator) {
 
 TEST(MatchExpressionParserLeafTest, TypeNull) {
     BSONObj query = BSON("x" << BSON("$type" << jstNULL));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_TRUE(result.isOK());
 
     ASSERT(!result.getValue()->matchesBSON(BSONObj()));
@@ -685,35 +995,44 @@ TEST(MatchExpressionParserLeafTest, TypeBadType) {
     BSONObjBuilder b;
     b.append("$type", (JSTypeMax + 1));
     BSONObj query = BSON("x" << b.obj());
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_NOT_OK(result.getStatus());
 }
 
 TEST(MatchExpressionParserLeafTest, TypeBad) {
     BSONObj query = BSON("x" << BSON("$type" << BSON("x" << 1)));
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression result =
-        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions());
+        MatchExpressionParser::parse(query, ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_FALSE(result.isOK());
 }
 
 TEST(MatchExpressionParserLeafTest, TypeBadString) {
+    CollatorInterface* collator = nullptr;
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$type: null}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$type: true}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$type: {}}}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(fromjson("{a: {$type: ObjectId('000000000000000000000000')}}"),
-                                     ExtensionsCallbackDisallowExtensions()).getStatus());
+                                     ExtensionsCallbackDisallowExtensions(),
+                                     collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$type: []}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnameDouble) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeNumberDouble = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'double'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'double'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typeNumberDouble.getStatus());
     TypeMatchExpression* tmeNumberDouble =
         static_cast<TypeMatchExpression*>(typeNumberDouble.getValue().get());
@@ -724,8 +1043,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnameDouble) {
 
 TEST(MatchExpressionParserLeafTest, TypeStringNameNumberDecimal) {
     if (Decimal128::enabled) {
+        CollatorInterface* collator = nullptr;
         StatusWithMatchExpression typeNumberDecimal = MatchExpressionParser::parse(
-            fromjson("{a: {$type: 'decimal'}}"), ExtensionsCallbackDisallowExtensions());
+            fromjson("{a: {$type: 'decimal'}}"), ExtensionsCallbackDisallowExtensions(), collator);
         ASSERT_OK(typeNumberDecimal.getStatus());
         TypeMatchExpression* tmeNumberDecimal =
             static_cast<TypeMatchExpression*>(typeNumberDecimal.getValue().get());
@@ -736,8 +1056,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringNameNumberDecimal) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnameNumberInt) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeNumberInt = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'int'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'int'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typeNumberInt.getStatus());
     TypeMatchExpression* tmeNumberInt =
         static_cast<TypeMatchExpression*>(typeNumberInt.getValue().get());
@@ -747,8 +1068,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnameNumberInt) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnameNumberLong) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeNumberLong = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'long'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'long'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typeNumberLong.getStatus());
     TypeMatchExpression* tmeNumberLong =
         static_cast<TypeMatchExpression*>(typeNumberLong.getValue().get());
@@ -758,8 +1080,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnameNumberLong) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnameString) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeString = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'string'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'string'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typeString.getStatus());
     TypeMatchExpression* tmeString = static_cast<TypeMatchExpression*>(typeString.getValue().get());
     ASSERT(tmeString->getType() == String);
@@ -768,8 +1091,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnameString) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnamejstOID) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typejstOID = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'objectId'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'objectId'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typejstOID.getStatus());
     TypeMatchExpression* tmejstOID = static_cast<TypeMatchExpression*>(typejstOID.getValue().get());
     ASSERT(tmejstOID->getType() == jstOID);
@@ -778,8 +1102,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnamejstOID) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnamejstNULL) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typejstNULL = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'null'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'null'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typejstNULL.getStatus());
     TypeMatchExpression* tmejstNULL =
         static_cast<TypeMatchExpression*>(typejstNULL.getValue().get());
@@ -789,8 +1114,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnamejstNULL) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnameBool) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeBool = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'bool'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'bool'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typeBool.getStatus());
     TypeMatchExpression* tmeBool = static_cast<TypeMatchExpression*>(typeBool.getValue().get());
     ASSERT(tmeBool->getType() == Bool);
@@ -799,8 +1125,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnameBool) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnameObject) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeObject = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'object'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'object'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typeObject.getStatus());
     TypeMatchExpression* tmeObject = static_cast<TypeMatchExpression*>(typeObject.getValue().get());
     ASSERT(tmeObject->getType() == Object);
@@ -809,8 +1136,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnameObject) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnameArray) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeArray = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'array'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'array'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typeArray.getStatus());
     TypeMatchExpression* tmeArray = static_cast<TypeMatchExpression*>(typeArray.getValue().get());
     ASSERT(tmeArray->getType() == Array);
@@ -819,8 +1147,9 @@ TEST(MatchExpressionParserLeafTest, TypeStringnameArray) {
 }
 
 TEST(MatchExpressionParserLeafTest, TypeStringnameNumber) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeNumber = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 'number'}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 'number'}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_OK(typeNumber.getStatus());
     TypeMatchExpression* tmeNumber = static_cast<TypeMatchExpression*>(typeNumber.getValue().get());
     ASSERT_TRUE(tmeNumber->matchesBSON(fromjson("{a: 5.4}")));
@@ -830,20 +1159,23 @@ TEST(MatchExpressionParserLeafTest, TypeStringnameNumber) {
 }
 
 TEST(MatchExpressionParserLeafTest, InvalidTypeCodeLessThanMinKeyFailsToParse) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeNumber = MatchExpressionParser::parse(
-        fromjson("{a: {$type: -20}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: -20}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_NOT_OK(typeNumber.getStatus());
 }
 
 TEST(MatchExpressionParserLeafTest, InvalidTypeCodeGreaterThanMaxKeyFailsToParse) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeNumber = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 400}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 400}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_NOT_OK(typeNumber.getStatus());
 }
 
 TEST(MatchExpressionParserLeafTest, InvalidTypeCodeUnusedBetweenMinAndMaxFailsToParse) {
+    CollatorInterface* collator = nullptr;
     StatusWithMatchExpression typeNumber = MatchExpressionParser::parse(
-        fromjson("{a: {$type: 62}}"), ExtensionsCallbackDisallowExtensions());
+        fromjson("{a: {$type: 62}}"), ExtensionsCallbackDisallowExtensions(), collator);
     ASSERT_NOT_OK(typeNumber.getStatus());
 }
 
@@ -855,8 +1187,9 @@ TEST(MatchExpressionParserLeafTest, ValidTypeCodesParseSuccessfully) {
 
     for (auto type : validTypes) {
         BSONObj predicate = BSON("a" << BSON("$type" << type));
-        auto expression =
-            MatchExpressionParser::parse(predicate, ExtensionsCallbackDisallowExtensions());
+        CollatorInterface* collator = nullptr;
+        auto expression = MatchExpressionParser::parse(
+            predicate, ExtensionsCallbackDisallowExtensions(), collator);
         ASSERT_OK(expression.getStatus());
         auto typeExpression = static_cast<TypeMatchExpression*>(expression.getValue().get());
         ASSERT_EQ(type, typeExpression->getType());
@@ -866,45 +1199,62 @@ TEST(MatchExpressionParserLeafTest, ValidTypeCodesParseSuccessfully) {
 TEST(MatchExpressionParserTest, BitTestMatchExpressionValidMask) {
     const double k2Power53 = scalbn(1, 32);
 
+    CollatorInterface* collator = nullptr;
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllSet" << 54)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAllSet" << std::numeric_limits<long long>::max())),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllSet" << k2Power53)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllSet" << k2Power53 - 1)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
 
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllClear" << 54)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAllClear" << std::numeric_limits<long long>::max())),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllClear" << k2Power53)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllClear" << k2Power53 - 1)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
 
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnySet" << 54)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAnySet" << std::numeric_limits<long long>::max())),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnySet" << k2Power53)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnySet" << k2Power53 - 1)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
 
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnyClear" << 54)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAnyClear" << std::numeric_limits<long long>::max())),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnyClear" << k2Power53)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnyClear" << k2Power53 - 1)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
 }
 
 TEST(MatchExpressionParserTest, BitTestMatchExpressionValidArray) {
@@ -914,335 +1264,460 @@ TEST(MatchExpressionParserTest, BitTestMatchExpressionValidArray) {
     ASSERT_EQ(BSONType::NumberLong, bsonArrayLongLong[2].type());
     ASSERT_EQ(BSONType::NumberLong, bsonArrayLongLong[3].type());
 
+    CollatorInterface* collator = nullptr;
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllSet" << BSON_ARRAY(0))),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAllSet" << BSON_ARRAY(0 << 1 << 2 << 3))),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllSet" << bsonArrayLongLong)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAllSet" << BSON_ARRAY(std::numeric_limits<int>::max()))),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
 
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllClear" << BSON_ARRAY(0))),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAllClear" << BSON_ARRAY(0 << 1 << 2 << 3))),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllClear" << bsonArrayLongLong)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAllClear" << BSON_ARRAY(std::numeric_limits<int>::max()))),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
 
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnySet" << BSON_ARRAY(0))),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAnySet" << BSON_ARRAY(0 << 1 << 2 << 3))),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnySet" << bsonArrayLongLong)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAnySet" << BSON_ARRAY(std::numeric_limits<int>::max()))),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
 
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnyClear" << BSON_ARRAY(0))),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAnyClear" << BSON_ARRAY(0 << 1 << 2 << 3))),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnyClear" << bsonArrayLongLong)),
-                                           ExtensionsCallbackDisallowExtensions()).getStatus());
+                                           ExtensionsCallbackDisallowExtensions(),
+                                           collator).getStatus());
     ASSERT_OK(MatchExpressionParser::parse(
                   BSON("a" << BSON("$bitsAnyClear" << BSON_ARRAY(std::numeric_limits<int>::max()))),
-                  ExtensionsCallbackDisallowExtensions()).getStatus());
+                  ExtensionsCallbackDisallowExtensions(),
+                  collator).getStatus());
 }
 
 TEST(MatchExpressionParserTest, BitTestMatchExpressionValidBinData) {
+    CollatorInterface* collator = nullptr;
     ASSERT_OK(
         MatchExpressionParser::parse(
             fromjson("{a: {$bitsAllSet: {$binary: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}}}"),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_OK(
         MatchExpressionParser::parse(
             fromjson(
                 "{a: {$bitsAllClear: {$binary: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}}}"),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_OK(
         MatchExpressionParser::parse(
             fromjson("{a: {$bitsAnySet: {$binary: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}}}"),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_OK(
         MatchExpressionParser::parse(
             fromjson(
                 "{a: {$bitsAnyClear: {$binary: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}}}"),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 }
 
 TEST(MatchExpressionParserTest, BitTestMatchExpressionInvalidMaskType) {
+    CollatorInterface* collator = nullptr;
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: null}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: true}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: {}}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: ''}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: null}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: true}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: {}}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: ''}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(
                       fromjson("{a: {$bitsAllClear: ObjectId('000000000000000000000000')}}"),
-                      ExtensionsCallbackDisallowExtensions()).getStatus());
+                      ExtensionsCallbackDisallowExtensions(),
+                      collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: null}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: true}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: {}}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: ''}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(
                       fromjson("{a: {$bitsAnySet: ObjectId('000000000000000000000000')}}"),
-                      ExtensionsCallbackDisallowExtensions()).getStatus());
+                      ExtensionsCallbackDisallowExtensions(),
+                      collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: null}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: true}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: {}}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: ''}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(
                       fromjson("{a: {$bitsAnyClear: ObjectId('000000000000000000000000')}}"),
-                      ExtensionsCallbackDisallowExtensions()).getStatus());
+                      ExtensionsCallbackDisallowExtensions(),
+                      collator).getStatus());
 }
 
 TEST(MatchExpressionParserTest, BitTestMatchExpressionInvalidMaskValue) {
     const double kLongLongMaxAsDouble = scalbn(1, std::numeric_limits<long long>::digits);
 
+    CollatorInterface* collator = nullptr;
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: NaN}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: -54}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(
                       BSON("a" << BSON("$bitsAllSet" << std::numeric_limits<double>::max())),
-                      ExtensionsCallbackDisallowExtensions()).getStatus());
+                      ExtensionsCallbackDisallowExtensions(),
+                      collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllSet" << kLongLongMaxAsDouble)),
-                                     ExtensionsCallbackDisallowExtensions()).getStatus());
+                                     ExtensionsCallbackDisallowExtensions(),
+                                     collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: 2.5}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: NaN}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: -54}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(
                       BSON("a" << BSON("$bitsAllClear" << std::numeric_limits<double>::max())),
-                      ExtensionsCallbackDisallowExtensions()).getStatus());
+                      ExtensionsCallbackDisallowExtensions(),
+                      collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(BSON("a" << BSON("$bitsAllClear" << kLongLongMaxAsDouble)),
-                                     ExtensionsCallbackDisallowExtensions()).getStatus());
+                                     ExtensionsCallbackDisallowExtensions(),
+                                     collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: 2.5}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: NaN}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: -54}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(
                       BSON("a" << BSON("$bitsAnySet" << std::numeric_limits<double>::max())),
-                      ExtensionsCallbackDisallowExtensions()).getStatus());
+                      ExtensionsCallbackDisallowExtensions(),
+                      collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnySet" << kLongLongMaxAsDouble)),
-                                     ExtensionsCallbackDisallowExtensions()).getStatus());
+                                     ExtensionsCallbackDisallowExtensions(),
+                                     collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: 2.5}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: NaN}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: -54}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(
                       BSON("a" << BSON("$bitsAnyClear" << std::numeric_limits<double>::max())),
-                      ExtensionsCallbackDisallowExtensions()).getStatus());
+                      ExtensionsCallbackDisallowExtensions(),
+                      collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(BSON("a" << BSON("$bitsAnyClear" << kLongLongMaxAsDouble)),
-                                     ExtensionsCallbackDisallowExtensions()).getStatus());
+                                     ExtensionsCallbackDisallowExtensions(),
+                                     collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: 2.5}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
 }
 
 TEST(MatchExpressionParserTest, BitTestMatchExpressionInvalidArray) {
+    CollatorInterface* collator = nullptr;
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [null]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [true]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: ['']}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [{}]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [[]]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [-1]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [2.5]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             fromjson(
                 "{a: {$bitsAllSet: [{$binary: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}]}}"),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [null]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [true]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: ['']}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [{}]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [[]]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [-1]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [2.5]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             fromjson(
                 "{a: {$bitsAllClear: [{$binary: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}]}}"),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [null]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [true]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: ['']}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [{}]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [[]]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [-1]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [2.5]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             fromjson(
                 "{a: {$bitsAnySet: [{$binary: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}]}}"),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [null]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [true]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: ['']}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [{}]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [[]]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [-1]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [2.5]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             fromjson(
                 "{a: {$bitsAnyClear: [{$binary: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}]}}"),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 }
 
 TEST(MatchExpressionParserTest, BitTestMatchExpressionInvalidArrayValue) {
+    CollatorInterface* collator = nullptr;
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [-54]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [NaN]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [2.5]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [1e100]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllSet: [-1e100]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             BSON("a" << BSON("$bitsAllSet" << BSON_ARRAY(std::numeric_limits<long long>::max()))),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             BSON("a" << BSON("$bitsAllSet" << BSON_ARRAY(std::numeric_limits<long long>::min()))),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [-54]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [NaN]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [2.5]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [1e100]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAllClear: [-1e100]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             BSON("a" << BSON("$bitsAllClear" << BSON_ARRAY(std::numeric_limits<long long>::max()))),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             BSON("a" << BSON("$bitsAllClear" << BSON_ARRAY(std::numeric_limits<long long>::min()))),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [-54]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [NaN]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [2.5]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [1e100]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnySet: [-1e100]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             BSON("a" << BSON("$bitsAnySet" << BSON_ARRAY(std::numeric_limits<long long>::max()))),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             BSON("a" << BSON("$bitsAnySet" << BSON_ARRAY(std::numeric_limits<long long>::min()))),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [-54]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [NaN]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [2.5]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [1e100]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(MatchExpressionParser::parse(fromjson("{a: {$bitsAnyClear: [-1e100]}}"),
-                                               ExtensionsCallbackDisallowExtensions()).getStatus());
+                                               ExtensionsCallbackDisallowExtensions(),
+                                               collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             BSON("a" << BSON("$bitsAnyClear" << BSON_ARRAY(std::numeric_limits<long long>::max()))),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
     ASSERT_NOT_OK(
         MatchExpressionParser::parse(
             BSON("a" << BSON("$bitsAnyClear" << BSON_ARRAY(std::numeric_limits<long long>::min()))),
-            ExtensionsCallbackDisallowExtensions()).getStatus());
+            ExtensionsCallbackDisallowExtensions(),
+            collator).getStatus());
 }
 }