SERVER-48848 Implement logical operators in grammar

author: Nick Zolnierz <nicholas.zolnierz@mongodb.com> 2020-08-19 16:57:10 -0400
committer: Evergreen Agent <no-reply@evergreen.mongodb.com> 2020-09-08 16:52:45 +0000
commit: 647dcb8b2c3f8419a1e14061857590a2b8613b73 (patch)
tree: cc1f2764fdf2f23e5538dd7a03543f868043ab65
parent: ec0866979a0749f6ee3a97b9932f73e6e21bf165 (diff)
download: mongo-647dcb8b2c3f8419a1e14061857590a2b8613b73.tar.gz
13 files changed, 2898 insertions, 2253 deletions
diff --git a/src/mongo/db/cst/SConscript b/src/mongo/db/cst/SConscript
index 8077cce2ce7..cd89e6750ea 100644
--- a/src/mongo/db/cst/SConscript
+++ b/src/mongo/db/cst/SConscript
@@ -31,6 +31,7 @@ env.CppUnitTest(
         'bson_lexer_test.cpp',
         'cst_error_test.cpp',
         'cst_expression_test.cpp',
+        'cst_match_test.cpp',
         'cst_match_translation_test.cpp',
         'cst_test.cpp',
     ],
diff --git a/src/mongo/db/cst/bson_lexer.cpp b/src/mongo/db/cst/bson_lexer.cpp
index dbce1618749..1cdcf5aec68 100644
--- a/src/mongo/db/cst/bson_lexer.cpp
+++ b/src/mongo/db/cst/bson_lexer.cpp
@@ -59,6 +59,7 @@ const StringMap<ParserGen::token_type> reservedKeyLookup = {
     {"$atan2", ParserGen::token::ATAN2},
     {"$and", ParserGen::token::AND},
     {"$or", ParserGen::token::OR},
+    {"$nor", ParserGen::token::NOR},
     {"$not", ParserGen::token::NOT},
     {"$const", ParserGen::token::CONST_EXPR},
     {"$literal", ParserGen::token::LITERAL},
diff --git a/src/mongo/db/cst/c_node.h b/src/mongo/db/cst/c_node.h
index cb1b92b509e..0255da7b70f 100644
--- a/src/mongo/db/cst/c_node.h
+++ b/src/mongo/db/cst/c_node.h
@@ -90,6 +90,13 @@ struct CNode {
         return toStringHelper(0) + "\n";
     }
 
+    friend std::ostream& operator<<(std::ostream& stream, const CNode& cst) {
+        return stream << cst.toString();
+    }
+    friend StringBuilder& operator<<(StringBuilder& stream, const CNode& cst) {
+        return stream << cst.toString();
+    }
+
     /**
      * Produce BSON representing this CST. This is for debugging and testing with structured output,
      * not for decompiling to the input query. The produced BSON will consist of arrays, objects,
diff --git a/src/mongo/db/cst/cst_match_test.cpp b/src/mongo/db/cst/cst_match_test.cpp
new file mode 100755
index 00000000000..01aaeb7672c
--- /dev/null
+++ b/src/mongo/db/cst/cst_match_test.cpp
@@ -0,0 +1,245 @@
+/**
+ *    Copyright (C) 2020-present MongoDB, Inc.
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the Server Side Public License, version 1,
+ *    as published by MongoDB, Inc.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    Server Side Public License for more details.
+ *
+ *    You should have received a copy of the Server Side Public License
+ *    along with this program. If not, see
+ *    <http://www.mongodb.com/licensing/server-side-public-license>.
+ *
+ *    As a special exception, the copyright holders give permission to link the
+ *    code of portions of this program with the OpenSSL library under certain
+ *    conditions as described in each individual source file and distribute
+ *    linked combinations including the program with the OpenSSL library. You
+ *    must comply with the Server Side Public License in all respects for
+ *    all of the code used other than as permitted herein. If you modify file(s)
+ *    with this exception, you may extend this exception to your version of the
+ *    file(s), but you are not obligated to do so. If you do not wish to do so,
+ *    delete this exception statement from your version. If you delete this
+ *    exception statement from all source files in the program, then also delete
+ *    it in the license file.
+ */
+
+#include "mongo/platform/basic.h"
+
+#include <string>
+
+#include "mongo/bson/json.h"
+#include "mongo/db/cst/bson_lexer.h"
+#include "mongo/db/cst/c_node.h"
+#include "mongo/db/cst/key_fieldname.h"
+#include "mongo/db/cst/key_value.h"
+#include "mongo/db/cst/parser_gen.hpp"
+#include "mongo/unittest/bson_test_util.h"
+#include "mongo/unittest/unittest.h"
+
+namespace mongo {
+namespace {
+
+TEST(CstMatchTest, ParsesEmptyPredicate) {
+    CNode output;
+    auto input = fromjson("{filter: {}}");
+    BSONLexer lexer(input["filter"]);
+    auto parseTree = ParserGen(lexer, &output);
+    ASSERT_EQ(0, parseTree.parse());
+    ASSERT_EQ(output.toBson().toString(), "{}");
+}
+
+TEST(CstMatchTest, ParsesEqualityPredicates) {
+    CNode output;
+    auto input = fromjson("{filter: {a: 5.0, b: NumberInt(10), _id: NumberLong(15)}}");
+    BSONLexer lexer(input["filter"]);
+    auto parseTree = ParserGen(lexer, &output);
+    ASSERT_EQ(0, parseTree.parse());
+    ASSERT_EQ(output.toBson().toString(),
+              "{ a: \"<UserDouble 5.000000>\", b: \"<UserInt 10>\", _id: \"<UserLong 15>\" }");
+}
+
+TEST(CstMatchTest, ParsesLogicalOperatorsWithOneChild) {
+    {
+        CNode output;
+        auto input = fromjson("{filter: {$and: [{a: 1}]}}");
+        BSONLexer lexer(input["filter"]);
+        auto parseTree = ParserGen(lexer, &output);
+        ASSERT_EQ(0, parseTree.parse());
+        ASSERT_EQ(output.toBson().toString(), "{ andExpr: [ { a: \"<UserInt 1>\" } ] }");
+    }
+    {
+        CNode output;
+        auto input = fromjson("{filter: {$or: [{a: 1}]}}");
+        BSONLexer lexer(input["filter"]);
+        auto parseTree = ParserGen(lexer, &output);
+        ASSERT_EQ(0, parseTree.parse());
+        ASSERT_EQ(output.toBson().toString(), "{ orExpr: [ { a: \"<UserInt 1>\" } ] }");
+    }
+    {
+        CNode output;
+        auto input = fromjson("{filter: {$nor: [{a: 1}]}}");
+        BSONLexer lexer(input["filter"]);
+        auto parseTree = ParserGen(lexer, &output);
+        ASSERT_EQ(0, parseTree.parse());
+        ASSERT_EQ(output.toBson().toString(), "{ norExpr: [ { a: \"<UserInt 1>\" } ] }");
+    }
+}
+
+TEST(CstMatchTest, ParsesLogicalOperatorsWithMultipleChildren) {
+    {
+        CNode output;
+        auto input = fromjson("{filter: {$and: [{a: 1}, {b: 'bee'}]}}");
+        BSONLexer lexer(input["filter"]);
+        auto parseTree = ParserGen(lexer, &output);
+        ASSERT_EQ(0, parseTree.parse());
+        ASSERT_EQ(output.toBson().toString(),
+                  "{ andExpr: [ { b: \"<UserString bee>\" }, { a: \"<UserInt 1>\" } ] }");
+    }
+    {
+        CNode output;
+        auto input = fromjson("{filter: {$or: [{a: 1}, {b: 'bee'}]}}");
+        BSONLexer lexer(input["filter"]);
+        auto parseTree = ParserGen(lexer, &output);
+        ASSERT_EQ(0, parseTree.parse());
+        ASSERT_EQ(output.toBson().toString(),
+                  "{ orExpr: [ { b: \"<UserString bee>\" }, { a: \"<UserInt 1>\" } ] }");
+    }
+    {
+        CNode output;
+        auto input = fromjson("{filter: {$nor: [{a: 1}, {b: 'bee'}]}}");
+        BSONLexer lexer(input["filter"]);
+        auto parseTree = ParserGen(lexer, &output);
+        ASSERT_EQ(0, parseTree.parse());
+        ASSERT_EQ(output.toBson().toString(),
+                  "{ norExpr: [ { b: \"<UserString bee>\" }, { a: \"<UserInt 1>\" } ] }");
+    }
+}
+
+TEST(CstMatchTest, ParsesNotWithRegex) {
+    CNode output;
+    auto input = fromjson("{filter: {a: {$not: /^a/}}}");
+    BSONLexer lexer(input["filter"]);
+    auto parseTree = ParserGen(lexer, &output);
+    ASSERT_EQ(0, parseTree.parse());
+    ASSERT_EQ(output.toBson().toString(), "{ a: { notExpr: \"<UserRegex /^a/>\" } }");
+}
+
+TEST(CstMatchTest, ParsesNotWithChildExpression) {
+    CNode output;
+    auto input = fromjson("{filter: {a: {$not: {$not: /^a/}}}}");
+    BSONLexer lexer(input["filter"]);
+    auto parseTree = ParserGen(lexer, &output);
+    ASSERT_EQ(0, parseTree.parse());
+    ASSERT_EQ(output.toBson().toString(), "{ a: { notExpr: { notExpr: \"<UserRegex /^a/>\" } } }");
+}
+
+TEST(CstMatchTest, FailsToParseNotWithNonObject) {
+    CNode output;
+    auto input = fromjson("{filter: {a: {$not: 1}}}");
+    BSONLexer lexer(input["filter"]);
+    ASSERT_THROWS_CODE_AND_WHAT(ParserGen(lexer, nullptr).parse(),
+                                AssertionException,
+                                ErrorCodes::FailedToParse,
+                                "syntax error, unexpected 1 (int), expecting object or regex at "
+                                "element '1' within '$not' of input filter");
+}
+
+TEST(CstMatchTest, FailsToParseUnknownOperatorWithinNotExpression) {
+    CNode output;
+    auto input = fromjson("{filter: {a: {$not: {$and: [{a: 1}]}}}}");
+    BSONLexer lexer(input["filter"]);
+    ASSERT_THROWS_CODE_AND_WHAT(ParserGen(lexer, nullptr).parse(),
+                                AssertionException,
+                                ErrorCodes::FailedToParse,
+                                "syntax error, unexpected AND, expecting NOT at "
+                                "element '$and' within '$not' of input filter");
+}
+
+TEST(CstMatchTest, FailsToParseNotWithEmptyObject) {
+    CNode output;
+    auto input = fromjson("{filter: {a: {$not: {}}}}");
+    BSONLexer lexer(input["filter"]);
+    ASSERT_THROWS_CODE_AND_WHAT(ParserGen(lexer, nullptr).parse(),
+                                AssertionException,
+                                ErrorCodes::FailedToParse,
+                                "syntax error, unexpected end of object, expecting NOT at element "
+                                "'end object' within '$not' of input filter");
+}
+
+TEST(CstMatchTest, FailsToParseDollarPrefixedPredicates) {
+    {
+        auto input = fromjson("{filter: {$atan2: [3, 5]}}");
+        BSONLexer lexer(input["filter"]);
+        ASSERT_THROWS_CODE_AND_WHAT(
+            ParserGen(lexer, nullptr).parse(),
+            AssertionException,
+            ErrorCodes::FailedToParse,
+            "syntax error, unexpected ATAN2 at element '$atan2' of input filter");
+    }
+    {
+        auto input = fromjson("{filter: {$prefixed: 5}}");
+        BSONLexer lexer(input["filter"]);
+        ASSERT_THROWS_CODE_AND_WHAT(
+            ParserGen(lexer, nullptr).parse(),
+            AssertionException,
+            ErrorCodes::FailedToParse,
+            "syntax error, unexpected $-prefixed fieldname at element '$prefixed' of input filter");
+    }
+    {
+        auto input = fromjson("{filter: {$$ROOT: 5}}");
+        BSONLexer lexer(input["filter"]);
+        ASSERT_THROWS_CODE_AND_WHAT(
+            ParserGen(lexer, nullptr).parse(),
+            AssertionException,
+            ErrorCodes::FailedToParse,
+            "syntax error, unexpected $-prefixed fieldname at element '$$ROOT' of input filter");
+    }
+}
+
+TEST(CstMatchTest, FailsToParseDollarPrefixedPredicatesWithinLogicalExpression) {
+    auto input = fromjson("{filter: {$and: [{$prefixed: 5}]}}");
+    BSONLexer lexer(input["filter"]);
+    ASSERT_THROWS_CODE_AND_WHAT(
+        ParserGen(lexer, nullptr).parse(),
+        AssertionException,
+        ErrorCodes::FailedToParse,
+        "syntax error, unexpected $-prefixed fieldname at element '$prefixed' within array at "
+        "index 0 within '$and' of input filter");
+}
+
+TEST(CstMatchTest, FailsToParseNonArrayLogicalKeyword) {
+    auto input = fromjson("{filter: {$and: {a: 5}}}");
+    BSONLexer lexer(input["filter"]);
+    ASSERT_THROWS_CODE_AND_WHAT(ParserGen(lexer, nullptr).parse(),
+                                AssertionException,
+                                ErrorCodes::FailedToParse,
+                                "syntax error, unexpected object, expecting array at element "
+                                "'start object' within '$and' of input filter");
+}
+
+TEST(CstMatchTest, FailsToParseNonObjectWithinLogicalKeyword) {
+    auto input = fromjson("{filter: {$or: [5]}}");
+    BSONLexer lexer(input["filter"]);
+    ASSERT_THROWS_CODE_AND_WHAT(ParserGen(lexer, nullptr).parse(),
+                                AssertionException,
+                                ErrorCodes::FailedToParse,
+                                "syntax error, unexpected arbitrary integer, expecting object at "
+                                "element '5' within array at index 0 within '$or' of input filter");
+}
+
+TEST(CstMatchTest, FailsToParseLogicalKeywordWithEmptyArray) {
+    auto input = fromjson("{filter: {$nor: []}}");
+    BSONLexer lexer(input["filter"]);
+    ASSERT_THROWS_CODE_AND_WHAT(ParserGen(lexer, nullptr).parse(),
+                                AssertionException,
+                                ErrorCodes::FailedToParse,
+                                "syntax error, unexpected end of array, expecting object at "
+                                "element 'end array' within '$nor' of input filter");
+}
+
+}  // namespace
+}  // namespace mongo
diff --git a/src/mongo/db/cst/cst_match_translation.cpp b/src/mongo/db/cst/cst_match_translation.cpp
index 14a563cffc3..0d6df7b2a51 100755
--- a/src/mongo/db/cst/cst_match_translation.cpp
+++ b/src/mongo/db/cst/cst_match_translation.cpp
@@ -1,82 +1,148 @@
-/**
- *    Copyright (C) 2020-present MongoDB, Inc.
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the Server Side Public License, version 1,
- *    as published by MongoDB, Inc.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    Server Side Public License for more details.
- *
- *    You should have received a copy of the Server Side Public License
- *    along with this program. If not, see
- *    <http://www.mongodb.com/licensing/server-side-public-license>.
- *
- *    As a special exception, the copyright holders give permission to link the
- *    code of portions of this program with the OpenSSL library under certain
- *    conditions as described in each individual source file and distribute
- *    linked combinations including the program with the OpenSSL library. You
- *    must comply with the Server Side Public License in all respects for
- *    all of the code used other than as permitted herein. If you modify file(s)
- *    with this exception, you may extend this exception to your version of the
- *    file(s), but you are not obligated to do so. If you do not wish to do so,
- *    delete this exception statement from your version. If you delete this
- *    exception statement from all source files in the program, then also delete
- *    it in the license file.
- */
-
-#include <algorithm>
-#include <boost/intrusive_ptr.hpp>
-#include <boost/optional.hpp>
-#include <iterator>
-
-#include "mongo/base/string_data.h"
-#include "mongo/bson/bsonmisc.h"
-#include "mongo/db/cst/c_node.h"
-#include "mongo/db/cst/cst_match_translation.h"
-#include "mongo/db/cst/cst_pipeline_translation.h"
-#include "mongo/db/cst/key_fieldname.h"
-#include "mongo/db/cst/key_value.h"
-
-namespace mongo::cst_match_translation {
-namespace {
-
-std::unique_ptr<MatchExpression> translateMatchElement(const CNode::Fieldname& field,
-                                                       const CNode& cst) {
-    if (auto fieldName = stdx::get_if<UserFieldname>(&field)) {
-        // Expression is over a user fieldname.
-        return stdx::visit(
-            visit_helper::Overloaded{
-                [&](const CNode::ObjectChildren& userObject) -> std::unique_ptr<MatchExpression> {
-                    MONGO_UNREACHABLE;
-                },
-                [&](const CNode::ArrayChildren& userObject) -> std::unique_ptr<MatchExpression> {
-                    MONGO_UNREACHABLE;
-                },
-                // Other types are always treated as equality predicates.
-                [&](auto&& userValue) -> std::unique_ptr<MatchExpression> {
-                    return std::make_unique<EqualityMatchExpression>(
-                        StringData(*fieldName),
-                        cst_pipeline_translation::translateLiteralLeaf(cst));
-                }},
-            cst.payload);
-    } else {
-        // Top level match expression.
-    }
-    MONGO_UNREACHABLE;
-}
-
-}  // namespace
-
-std::unique_ptr<MatchExpression> translateMatchExpression(
-    const CNode& cst, const boost::intrusive_ptr<ExpressionContext>& expCtx) {
-    auto root = std::make_unique<AndMatchExpression>();
-    for (auto&& [field, expr] : cst.objectChildren()) {
-        root->add(translateMatchElement(field, expr).release());
-    }
-    return root;
-}
-
-}  // namespace mongo::cst_match_translation
+/**
+ *    Copyright (C) 2020-present MongoDB, Inc.
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the Server Side Public License, version 1,
+ *    as published by MongoDB, Inc.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    Server Side Public License for more details.
+ *
+ *    You should have received a copy of the Server Side Public License
+ *    along with this program. If not, see
+ *    <http://www.mongodb.com/licensing/server-side-public-license>.
+ *
+ *    As a special exception, the copyright holders give permission to link the
+ *    code of portions of this program with the OpenSSL library under certain
+ *    conditions as described in each individual source file and distribute
+ *    linked combinations including the program with the OpenSSL library. You
+ *    must comply with the Server Side Public License in all respects for
+ *    all of the code used other than as permitted herein. If you modify file(s)
+ *    with this exception, you may extend this exception to your version of the
+ *    file(s), but you are not obligated to do so. If you do not wish to do so,
+ *    delete this exception statement from your version. If you delete this
+ *    exception statement from all source files in the program, then also delete
+ *    it in the license file.
+ */
+
+#include <algorithm>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/optional.hpp>
+#include <iterator>
+
+#include "mongo/base/string_data.h"
+#include "mongo/bson/bsonmisc.h"
+#include "mongo/db/cst/c_node.h"
+#include "mongo/db/cst/cst_match_translation.h"
+#include "mongo/db/cst/cst_pipeline_translation.h"
+#include "mongo/db/cst/key_fieldname.h"
+#include "mongo/db/cst/key_value.h"
+#include "mongo/db/matcher/expression_tree.h"
+#include "mongo/util/visit_helper.h"
+
+namespace mongo::cst_match_translation {
+namespace {
+
+std::unique_ptr<MatchExpression> translateMatchPredicate(
+    const CNode::Fieldname& fieldName,
+    const CNode& cst,
+    const boost::intrusive_ptr<ExpressionContext>& expCtx);
+
+/**
+ * Walk an array of nodes and produce a vector of MatchExpressions.
+ */
+template <class Type>
+std::unique_ptr<Type> translateTreeExpr(const CNode::ArrayChildren& array,
+                                        const boost::intrusive_ptr<ExpressionContext>& expCtx) {
+    auto expr = std::make_unique<Type>();
+    for (auto&& node : array) {
+        // Tree expressions require each element to be an object.
+        for (auto&& [fieldName, child] : node.objectChildren()) {
+            expr->add(translateMatchPredicate(fieldName, child, expCtx).release());
+        }
+    }
+    return expr;
+}
+
+std::unique_ptr<MatchExpression> translateNot(
+    const CNode::Fieldname& fieldName,
+    const CNode& argument,
+    const boost::intrusive_ptr<ExpressionContext>& expCtx) {
+    // $not can accept a regex or an object expression.
+    if (auto regex = stdx::get_if<UserRegex>(&argument.payload)) {
+        auto regexExpr = std::make_unique<RegexMatchExpression>(
+            stdx::get<UserFieldname>(fieldName), regex->pattern, regex->flags);
+        return std::make_unique<NotMatchExpression>(std::move(regexExpr));
+    }
+
+    auto root = std::make_unique<AndMatchExpression>();
+    root->add(translateMatchPredicate(fieldName, argument, expCtx).release());
+    return std::make_unique<NotMatchExpression>(std::move(root));
+}
+
+std::unique_ptr<MatchExpression> translatePathExpression(
+    const CNode::Fieldname& fieldName,
+    const CNode::ObjectChildren& object,
+    const boost::intrusive_ptr<ExpressionContext>& expCtx) {
+    for (auto&& [op, argument] : object) {
+        switch (stdx::get<KeyFieldname>(op)) {
+            case KeyFieldname::notExpr:
+                return translateNot(fieldName, argument, expCtx);
+            default:
+                MONGO_UNREACHABLE;
+        }
+    }
+    MONGO_UNREACHABLE;
+}
+
+std::unique_ptr<MatchExpression> translateMatchPredicate(
+    const CNode::Fieldname& fieldName,
+    const CNode& cst,
+    const boost::intrusive_ptr<ExpressionContext>& expCtx) {
+    if (auto keyField = stdx::get_if<KeyFieldname>(&fieldName)) {
+        // Top level match expression.
+        switch (*keyField) {
+            case KeyFieldname::andExpr:
+                return translateTreeExpr<AndMatchExpression>(cst.arrayChildren(), expCtx);
+            case KeyFieldname::orExpr:
+                return translateTreeExpr<OrMatchExpression>(cst.arrayChildren(), expCtx);
+            case KeyFieldname::norExpr:
+                return translateTreeExpr<NorMatchExpression>(cst.arrayChildren(), expCtx);
+            default:
+                MONGO_UNREACHABLE;
+        }
+    } else {
+        // Expression is over a user fieldname.
+        return stdx::visit(
+            visit_helper::Overloaded{
+                [&](const CNode::ObjectChildren& userObject) -> std::unique_ptr<MatchExpression> {
+                    return translatePathExpression(fieldName, userObject, expCtx);
+                },
+                [&](const CNode::ArrayChildren& userObject) -> std::unique_ptr<MatchExpression> {
+                    MONGO_UNREACHABLE;
+                },
+                // Other types are always treated as equality predicates.
+                [&](auto&& userValue) -> std::unique_ptr<MatchExpression> {
+                    return std::make_unique<EqualityMatchExpression>(
+                        StringData{stdx::get<UserFieldname>(fieldName)},
+                        cst_pipeline_translation::translateLiteralLeaf(cst));
+                }},
+            cst.payload);
+    }
+    MONGO_UNREACHABLE;
+}
+
+}  // namespace
+
+std::unique_ptr<MatchExpression> translateMatchExpression(
+    const CNode& cst, const boost::intrusive_ptr<ExpressionContext>& expCtx) {
+    auto root = std::make_unique<AndMatchExpression>();
+    for (const auto& [fieldName, expr] : cst.objectChildren()) {
+        root->add(translateMatchPredicate(fieldName, expr, expCtx).release());
+    }
+    return root;
+}
+
+}  // namespace mongo::cst_match_translation
diff --git a/src/mongo/db/cst/cst_match_translation.h b/src/mongo/db/cst/cst_match_translation.h
index 4cd368bacb8..50bc77910ad 100755
--- a/src/mongo/db/cst/cst_match_translation.h
+++ b/src/mongo/db/cst/cst_match_translation.h
@@ -1,45 +1,45 @@
-/**
- *    Copyright (C) 2020-present MongoDB, Inc.
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the Server Side Public License, version 1,
- *    as published by MongoDB, Inc.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    Server Side Public License for more details.
- *
- *    You should have received a copy of the Server Side Public License
- *    along with this program. If not, see
- *    <http://www.mongodb.com/licensing/server-side-public-license>.
- *
- *    As a special exception, the copyright holders give permission to link the
- *    code of portions of this program with the OpenSSL library under certain
- *    conditions as described in each individual source file and distribute
- *    linked combinations including the program with the OpenSSL library. You
- *    must comply with the Server Side Public License in all respects for
- *    all of the code used other than as permitted herein. If you modify file(s)
- *    with this exception, you may extend this exception to your version of the
- *    file(s), but you are not obligated to do so. If you do not wish to do so,
- *    delete this exception statement from your version. If you delete this
- *    exception statement from all source files in the program, then also delete
- *    it in the license file.
- */
-
-#pragma once
-
-#include "mongo/platform/basic.h"
-
-#include "mongo/db/matcher/expression.h"
-#include "mongo/db/pipeline/expression_context.h"
-
-namespace mongo::cst_match_translation {
-
-/**
- * Walk an expression CNode and produce a MatchExpression.
- */
-std::unique_ptr<MatchExpression> translateMatchExpression(
-    const CNode& cst, const boost::intrusive_ptr<ExpressionContext>& expCtx);
-
-}  // namespace mongo::cst_match_translation
+/**
+ *    Copyright (C) 2020-present MongoDB, Inc.
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the Server Side Public License, version 1,
+ *    as published by MongoDB, Inc.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    Server Side Public License for more details.
+ *
+ *    You should have received a copy of the Server Side Public License
+ *    along with this program. If not, see
+ *    <http://www.mongodb.com/licensing/server-side-public-license>.
+ *
+ *    As a special exception, the copyright holders give permission to link the
+ *    code of portions of this program with the OpenSSL library under certain
+ *    conditions as described in each individual source file and distribute
+ *    linked combinations including the program with the OpenSSL library. You
+ *    must comply with the Server Side Public License in all respects for
+ *    all of the code used other than as permitted herein. If you modify file(s)
+ *    with this exception, you may extend this exception to your version of the
+ *    file(s), but you are not obligated to do so. If you do not wish to do so,
+ *    delete this exception statement from your version. If you delete this
+ *    exception statement from all source files in the program, then also delete
+ *    it in the license file.
+ */
+
+#pragma once
+
+#include "mongo/platform/basic.h"
+
+#include "mongo/db/matcher/expression.h"
+#include "mongo/db/pipeline/expression_context.h"
+
+namespace mongo::cst_match_translation {
+
+/**
+ * Walk an expression CNode and produce a MatchExpression.
+ */
+std::unique_ptr<MatchExpression> translateMatchExpression(
+    const CNode& cst, const boost::intrusive_ptr<ExpressionContext>& expCtx);
+
+}  // namespace mongo::cst_match_translation
diff --git a/src/mongo/db/cst/cst_match_translation_test.cpp b/src/mongo/db/cst/cst_match_translation_test.cpp
index e9c91bc6707..2d23731858e 100755
--- a/src/mongo/db/cst/cst_match_translation_test.cpp
+++ b/src/mongo/db/cst/cst_match_translation_test.cpp
@@ -1,89 +1,179 @@
-/**
- *    Copyright (C) 2020-present MongoDB, Inc.
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the Server Side Public License, version 1,
- *    as published by MongoDB, Inc.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    Server Side Public License for more details.
- *
- *    You should have received a copy of the Server Side Public License
- *    along with this program. If not, see
- *    <http://www.mongodb.com/licensing/server-side-public-license>.
- *
- *    As a special exception, the copyright holders give permission to link the
- *    code of portions of this program with the OpenSSL library under certain
- *    conditions as described in each individual source file and distribute
- *    linked combinations including the program with the OpenSSL library. You
- *    must comply with the Server Side Public License in all respects for
- *    all of the code used other than as permitted herein. If you modify file(s)
- *    with this exception, you may extend this exception to your version of the
- *    file(s), but you are not obligated to do so. If you do not wish to do so,
- *    delete this exception statement from your version. If you delete this
- *    exception statement from all source files in the program, then also delete
- *    it in the license file.
- */
-
-#include "mongo/platform/basic.h"
-
-#include <boost/intrusive_ptr.hpp>
-#include <string>
-
-#include "mongo/bson/bsonobj.h"
-#include "mongo/db/cst/c_node.h"
-#include "mongo/db/cst/cst_match_translation.h"
-#include "mongo/db/cst/key_fieldname.h"
-#include "mongo/db/cst/key_value.h"
-#include "mongo/db/matcher/expression_leaf.h"
-#include "mongo/db/matcher/expression_tree.h"
-#include "mongo/db/namespace_string.h"
-#include "mongo/db/pipeline/expression_context_for_test.h"
-#include "mongo/unittest/unittest.h"
-
-namespace mongo {
-namespace {
-
-auto getExpCtx() {
-    auto nss = NamespaceString{"db", "coll"};
-    return boost::intrusive_ptr<ExpressionContextForTest>{new ExpressionContextForTest(nss)};
-}
-
-TEST(CstMatchTranslationTest, TranslatesEmpty) {
-    const auto cst = CNode{CNode::ObjectChildren{}};
-    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
-    auto andExpr = dynamic_cast<AndMatchExpression*>(match.get());
-    ASSERT(andExpr);
-    ASSERT_EQ(0, andExpr->numChildren());
-}
-
-TEST(CstMatchTranslationTest, TranslatesSinglePredicate) {
-    const auto cst = CNode{CNode::ObjectChildren{{UserFieldname{"a"}, CNode{UserInt{1}}}}};
-    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
-    ASSERT_BSONOBJ_EQ(match->serialize(), fromjson("{$and: [{a: {$eq: 1}}]}"));
-}
-
-TEST(CstMatchTranslationTest, TranslatesMultipleEqualityPredicates) {
-    const auto cst = CNode{CNode::ObjectChildren{
-        {UserFieldname{"a"}, CNode{UserInt{1}}},
-        {UserFieldname{"b"}, CNode{UserNull{}}},
-    }};
-    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
-    ASSERT_BSONOBJ_EQ(match->serialize(), fromjson("{$and: [{a: {$eq: 1}}, {b: {$eq: null}}]}"));
-}
-
-TEST(CstMatchTranslationTest, TranslatesEqualityPredicatesWithId) {
-    const auto cst = CNode{CNode::ObjectChildren{
-        {UserFieldname{"_id"}, CNode{UserNull{}}},
-    }};
-    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
-    auto andExpr = dynamic_cast<AndMatchExpression*>(match.get());
-    ASSERT(andExpr);
-    ASSERT_EQ(1, andExpr->numChildren());
-    ASSERT_BSONOBJ_EQ(match->serialize(), fromjson("{$and: [{_id: {$eq: null}}]}"));
-}
-
-}  // namespace
-}  // namespace mongo
+/**
+ *    Copyright (C) 2020-present MongoDB, Inc.
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the Server Side Public License, version 1,
+ *    as published by MongoDB, Inc.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    Server Side Public License for more details.
+ *
+ *    You should have received a copy of the Server Side Public License
+ *    along with this program. If not, see
+ *    <http://www.mongodb.com/licensing/server-side-public-license>.
+ *
+ *    As a special exception, the copyright holders give permission to link the
+ *    code of portions of this program with the OpenSSL library under certain
+ *    conditions as described in each individual source file and distribute
+ *    linked combinations including the program with the OpenSSL library. You
+ *    must comply with the Server Side Public License in all respects for
+ *    all of the code used other than as permitted herein. If you modify file(s)
+ *    with this exception, you may extend this exception to your version of the
+ *    file(s), but you are not obligated to do so. If you do not wish to do so,
+ *    delete this exception statement from your version. If you delete this
+ *    exception statement from all source files in the program, then also delete
+ *    it in the license file.
+ */
+
+#include "mongo/platform/basic.h"
+
+#include <boost/intrusive_ptr.hpp>
+#include <string>
+
+#include "mongo/bson/bsonobj.h"
+#include "mongo/db/cst/bson_lexer.h"
+#include "mongo/db/cst/c_node.h"
+#include "mongo/db/cst/cst_match_translation.h"
+#include "mongo/db/cst/key_fieldname.h"
+#include "mongo/db/cst/key_value.h"
+#include "mongo/db/matcher/expression_leaf.h"
+#include "mongo/db/matcher/expression_tree.h"
+#include "mongo/db/namespace_string.h"
+#include "mongo/db/pipeline/expression_context_for_test.h"
+#include "mongo/unittest/unittest.h"
+
+namespace mongo {
+namespace {
+
+auto getExpCtx() {
+    auto nss = NamespaceString{"db", "coll"};
+    return boost::intrusive_ptr<ExpressionContextForTest>{new ExpressionContextForTest(nss)};
+}
+
+auto parseMatchToCst(BSONObj input) {
+    CNode output;
+    BSONLexer lexer(input["filter"]);
+    auto parseTree = ParserGen(lexer, &output);
+    ASSERT_EQ(0, parseTree.parse());
+    return output;
+}
+
+TEST(CstMatchTranslationTest, TranslatesEmpty) {
+    const auto cst = CNode{CNode::ObjectChildren{}};
+    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+    auto andExpr = dynamic_cast<AndMatchExpression*>(match.get());
+    ASSERT(andExpr);
+    ASSERT_EQ(0, andExpr->numChildren());
+}
+
+TEST(CstMatchTranslationTest, TranslatesSinglePredicate) {
+    const auto cst = CNode{CNode::ObjectChildren{{UserFieldname{"a"}, CNode{UserInt{1}}}}};
+    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+    ASSERT_BSONOBJ_EQ(match->serialize(), fromjson("{$and: [{a: {$eq: 1}}]}"));
+}
+
+TEST(CstMatchTranslationTest, TranslatesMultipleEqualityPredicates) {
+    const auto cst = CNode{CNode::ObjectChildren{
+        {UserFieldname{"a"}, CNode{UserInt{1}}},
+        {UserFieldname{"b"}, CNode{UserNull{}}},
+    }};
+    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+    ASSERT_BSONOBJ_EQ(match->serialize(), fromjson("{$and: [{a: {$eq: 1}}, {b: {$eq: null}}]}"));
+}
+
+TEST(CstMatchTranslationTest, TranslatesEqualityPredicatesWithId) {
+    const auto cst = CNode{CNode::ObjectChildren{
+        {UserFieldname{"_id"}, CNode{UserNull{}}},
+    }};
+    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+    auto andExpr = dynamic_cast<AndMatchExpression*>(match.get());
+    ASSERT(andExpr);
+    ASSERT_EQ(1, andExpr->numChildren());
+    ASSERT_BSONOBJ_EQ(match->serialize(), fromjson("{$and: [{_id: {$eq: null}}]}"));
+}
+
+TEST(CstMatchTranslationTest, TranslatesEmptyObject) {
+    const auto cst = CNode{CNode::ObjectChildren{}};
+    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+    auto andExpr = dynamic_cast<AndMatchExpression*>(match.get());
+    ASSERT(andExpr);
+    ASSERT_EQ(0, andExpr->numChildren());
+}
+
+TEST(CstMatchTranslationTest, TranslatesNotWithRegex) {
+    auto input = fromjson("{filter: {a: {$not: /b/}}}");
+    auto cst = parseMatchToCst(input);
+    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+    auto andExpr = dynamic_cast<AndMatchExpression*>(match.get());
+    ASSERT(andExpr);
+    ASSERT_EQ(1, andExpr->numChildren());
+    auto notExpr = dynamic_cast<NotMatchExpression*>(andExpr->getChild(0));
+    ASSERT(notExpr);
+    auto regex = dynamic_cast<RegexMatchExpression*>(notExpr->getChild(0));
+    ASSERT(regex);
+    ASSERT_EQ("a", regex->path());
+    ASSERT_EQ(match->serialize().toString(), "{ $and: [ { a: { $not: { $regex: \"b\" } } } ] }");
+}
+
+TEST(CstMatchTranslationTest, TranslatesNotWithExpression) {
+    auto input = fromjson("{filter: {a: {$not: {$not: /b/}}}}");
+    auto cst = parseMatchToCst(input);
+    auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+    ASSERT_EQ(match->serialize().toString(),
+              "{ $and: [ { $nor: [ { a: { $not: { $regex: \"b\" } } } ] } ] }");
+}
+
+TEST(CstMatchTranslationTest, TranslatesLogicalTreeExpressions) {
+    {
+        auto input = fromjson("{filter: {$and: [{b: {$not: /a/}}]}}");
+        auto cst = parseMatchToCst(input);
+        auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+        ASSERT_EQ(match->serialize().toString(),
+                  "{ $and: [ { $and: [ { b: { $not: { $regex: \"a\" } } } ] } ] }");
+    }
+    {
+        auto input = fromjson("{filter: {$or: [{b: {$not: /a/}}, {a: {$not: /b/}}]}}");
+        auto cst = parseMatchToCst(input);
+        auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+        ASSERT_EQ(match->serialize().toString(),
+                  "{ $and: [ { $or: [ { a: { $not: { $regex: \"b\" } } }, { b: { $not: { $regex: "
+                  "\"a\" } } } ] } ] }");
+    }
+    {
+        auto input = fromjson("{filter: {$nor: [{b: {$not: /a/}}]}}");
+        auto cst = parseMatchToCst(input);
+        auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+        ASSERT_EQ(match->serialize().toString(),
+                  "{ $and: [ { $nor: [ { b: { $not: { $regex: \"a\" } } } ] } ] }");
+    }
+}
+
+TEST(CstMatchTranslationTest, TranslatesNestedLogicalTreeExpressions) {
+    {
+        auto input = fromjson("{filter: {$and: [{$or: [{b: {$not: /a/}}]}]}}");
+        auto cst = parseMatchToCst(input);
+        auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+        ASSERT_EQ(match->serialize().toString(),
+                  "{ $and: [ { $and: [ { $or: [ { b: { $not: { $regex: \"a\" } } } ] } ] } ] }");
+    }
+    {
+        auto input = fromjson("{filter: {$or: [{$and: [{b: {$not: /a/}}, {a: {$not: /b/}}]}]}}");
+        auto cst = parseMatchToCst(input);
+        auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+        ASSERT_EQ(match->serialize().toString(),
+                  "{ $and: [ { $or: [ { $and: [ { a: { $not: { $regex: \"b\" } } }, { b: { $not: { "
+                  "$regex: \"a\" } } } ] } ] } ] }");
+    }
+    {
+        auto input = fromjson("{filter: {$and: [{$nor: [{b: {$not: /a/}}]}]}}");
+        auto cst = parseMatchToCst(input);
+        auto match = cst_match_translation::translateMatchExpression(cst, getExpCtx());
+        ASSERT_EQ(match->serialize().toString(),
+                  "{ $and: [ { $and: [ { $nor: [ { b: { $not: { $regex: \"a\" } } } ] } ] } ] }");
+    }
+}
+
+}  // namespace
+}  // namespace mongo
diff --git a/src/mongo/db/cst/cst_test.cpp b/src/mongo/db/cst/cst_test.cpp
index ee1c2aacc17..df7fc81f06b 100644
--- a/src/mongo/db/cst/cst_test.cpp
+++ b/src/mongo/db/cst/cst_test.cpp
@@ -868,46 +868,6 @@ TEST(CstGrammarTest, ParsesValidTrunc) {
         "{ projectInclusion: { val: { trunc: [ \"<UserDouble 1.234000>\", \"<UserInt 2>\" ] } } }");
 }
 
-TEST(CstGrammarTest, ParsesEmptyMatchInFind) {
-    CNode output;
-    auto input = fromjson("{filter: {}}");
-    BSONLexer lexer(input["filter"]);
-    auto parseTree = ParserGen(lexer, &output);
-    ASSERT_EQ(0, parseTree.parse());
-    ASSERT_EQ(output.toBson().toString(), "{}");
-}
-
-TEST(CstGrammarTest, ParsesMatchWithEqualityPredicates) {
-    CNode output;
-    auto input = fromjson("{filter: {a: 5.0, b: NumberInt(10), _id: NumberLong(15)}}");
-    BSONLexer lexer(input["filter"]);
-    auto parseTree = ParserGen(lexer, &output);
-    ASSERT_EQ(0, parseTree.parse());
-    ASSERT_EQ(output.toBson().toString(),
-              "{ a: \"<UserDouble 5.000000>\", b: \"<UserInt 10>\", _id: \"<UserLong 15>\" }");
-}
-
-TEST(CstGrammarTest, FailsToParseDollarPrefixedPredicates) {
-    {
-        auto input = fromjson("{filter: {$atan2: [3, 5]}}");
-        BSONLexer lexer(input["filter"]);
-        ASSERT_THROWS_CODE_AND_WHAT(
-            ParserGen(lexer, nullptr).parse(),
-            AssertionException,
-            ErrorCodes::FailedToParse,
-            "syntax error, unexpected ATAN2 at element '$atan2' of input filter");
-    }
-    {
-        auto input = fromjson("{filter: {$prefixed: 5}}");
-        BSONLexer lexer(input["filter"]);
-        ASSERT_THROWS_CODE_AND_WHAT(
-            ParserGen(lexer, nullptr).parse(),
-            AssertionException,
-            ErrorCodes::FailedToParse,
-            "syntax error, unexpected $-prefixed fieldname at element '$prefixed' of input filter");
-    }
-}
-
 TEST(CstGrammarTest, ParsesBasicSort) {
     CNode output;
     auto input = fromjson("{sort: {val: 1, test: -1}}");
diff --git a/src/mongo/db/cst/grammar.yy b/src/mongo/db/cst/grammar.yy
index dd3cd8ae01e..c1a9ca68cb7 100644
--- a/src/mongo/db/cst/grammar.yy
+++ b/src/mongo/db/cst/grammar.yy
@@ -181,6 +181,7 @@
     MOD
     MULTIPLY
     NE
+    NOR
     NOT
     OR
     POW
@@ -255,10 +256,10 @@
 //
 
 // Possible user fieldnames.
-%nterm <CNode::Fieldname> projectionFieldname expressionFieldname stageAsUserFieldname filterFieldname
+%nterm <CNode::Fieldname> projectionFieldname expressionFieldname stageAsUserFieldname predFieldname
 %nterm <CNode::Fieldname> argAsUserFieldname aggExprAsUserFieldname invariableUserFieldname
 %nterm <CNode::Fieldname> idAsUserFieldname valueFieldname
-%nterm <std::pair<CNode::Fieldname, CNode>> projectField expressionField valueField filterField
+%nterm <std::pair<CNode::Fieldname, CNode>> projectField expressionField valueField
 
 // Literals.
 %nterm <CNode> dbPointer javascript symbol javascriptWScope int timestamp long double decimal
@@ -283,7 +284,11 @@
 %nterm <std::pair<CNode::Fieldname, CNode>> onErrorArg onNullArg
 %nterm <std::pair<CNode::Fieldname, CNode>> formatArg timezoneArg charsArg optionsArg
 %nterm <std::vector<CNode>> expressions values exprZeroToTwo
-%nterm <CNode> matchExpression filterFields filterVal
+
+// Match expressions.
+%nterm <CNode> match predicates compoundMatchExprs predValue additionalExprs
+%nterm <std::pair<CNode::Fieldname, CNode>> predicate logicalExpr operatorExpression notExpr
+%nterm <CNode::Fieldname> logicalExprField
 
 // Sort related rules
 %nterm <CNode> sortSpecs specList metaSort oneOrNegOne metaSortKeyword
@@ -299,14 +304,14 @@ start:
     ARG_PIPELINE pipeline {
         *cst = $pipeline;
     }
-    | ARG_FILTER matchExpression {
-        *cst = $matchExpression;
+    | ARG_FILTER match {
+        *cst = $match;
     }
-    | ARG_QUERY matchExpression {
-        *cst = $matchExpression;
+    | ARG_QUERY match {
+        *cst = $match;
     }
-    | ARG_Q matchExpression {
-        *cst = $matchExpression;
+    | ARG_Q match {
+        *cst = $match;
     }
     | ARG_SORT sortSpecs {
         *cst = $sortSpecs;
@@ -491,36 +496,92 @@ projectionFieldname:
     invariableUserFieldname | stageAsUserFieldname | argAsUserFieldname | aggExprAsUserFieldname
 ;
 
-matchExpression:
-    START_OBJECT filterFields END_OBJECT {
-        $$ = $filterFields;
+match:
+    START_OBJECT predicates END_OBJECT {
+        $$ = $predicates;
     }
 ;
 
-filterFields:
+predicates:
     %empty {
         $$ = CNode::noopLeaf();
     }
-    | filterFields[filterArg] filterField {
+    | predicates[filterArg] predicate {
         $$ = $filterArg;
-        $$.objectChildren().emplace_back($filterField);
+        $$.objectChildren().emplace_back($predicate);
     }
 ;
 
-filterField: filterFieldname filterVal {
-        $$ = {$filterFieldname, $filterVal};
+predicate: predFieldname predValue {
+        $$ = {$predFieldname, $predValue};
+    }
+    | logicalExpr {
+        $$ = $logicalExpr;
     }
 ;
 
-filterVal:
-    value
+// TODO SERVER-48847: This rule assumes that object predicates always contain sub-expressions.
+// Will need to expand to allow comparisons against literal objects (note that order of fields
+// in object predicates is important! --> {a: 1, $gt: 2} is different than {$gt: 2, a: 1}).
+predValue:
+    simpleValue 
+    | START_OBJECT compoundMatchExprs END_OBJECT {
+        $$ = $compoundMatchExprs;
+    }
 ;
 
-// Filter predicates are *not* allowed over $-prefixed field names.
-filterFieldname:
-    idAsUserFieldname | invariableUserFieldname | argAsUserFieldname
+compoundMatchExprs: 
+    %empty {
+        $$ = CNode::noopLeaf();
+    }
+    | compoundMatchExprs[exprs] operatorExpression {
+        $$ = $exprs;
+        $$.objectChildren().emplace_back($operatorExpression);
+    }
 ;
 
+// Rules for the operators which act on a path.
+operatorExpression: notExpr
+
+notExpr:
+    NOT regex {
+        $$ = std::pair{KeyFieldname::notExpr, $regex};
+    }
+    // $not requires an object with atleast one expression.
+    | NOT START_OBJECT operatorExpression compoundMatchExprs END_OBJECT {
+        auto&& exprs = $compoundMatchExprs;
+        exprs.objectChildren().emplace_back($operatorExpression);
+
+        $$ = std::pair{KeyFieldname::notExpr, std::move(exprs)};
+    }
+;
+
+// Logical expressions accept an array of objects, with at least one element.
+logicalExpr: logicalExprField START_ARRAY match additionalExprs END_ARRAY {
+        auto&& children = $additionalExprs;
+        children.arrayChildren().emplace_back($match);
+        $$ = {$logicalExprField, std::move(children)};
+    }
+;
+
+logicalExprField: 
+    AND { $$ = KeyFieldname::andExpr; }
+    | OR { $$ = KeyFieldname::orExpr; }
+    | NOR { $$ = KeyFieldname::norExpr; }
+
+additionalExprs: 
+    %empty {
+        $$ = CNode{CNode::ArrayChildren{}};
+    }
+    | additionalExprs[exprs] match {
+        $$ = $exprs;
+        $$.arrayChildren().emplace_back($match);
+    }
+;
+
+// Filter predicates are *not* allowed over $-prefixed field names.
+predFieldname: idAsUserFieldname | argAsUserFieldname | invariableUserFieldname;
+
 invariableUserFieldname:
     FIELDNAME {
         $$ = UserFieldname{$1};
diff --git a/src/mongo/db/cst/key_fieldname.h b/src/mongo/db/cst/key_fieldname.h
index 1c9b9b7f570..56a44ef79fd 100644
--- a/src/mongo/db/cst/key_fieldname.h
+++ b/src/mongo/db/cst/key_fieldname.h
@@ -75,6 +75,7 @@
     ENUMIFY(mod)                 \
     ENUMIFY(multiply)            \
     ENUMIFY(ne)                  \
+    ENUMIFY(norExpr)             \
     ENUMIFY(notExpr)             \
     ENUMIFY(onErrorArg)          \
     ENUMIFY(onNullArg)           \
diff --git a/src/mongo/db/cst/parser_gen.cpp b/src/mongo/db/cst/parser_gen.cpp
index 8a09ff6ad2c..ef4502af82b 100644
--- a/src/mongo/db/cst/parser_gen.cpp
+++ b/src/mongo/db/cst/parser_gen.cpp
@@ -240,27 +240,27 @@ ParserGen::stack_symbol_type::stack_symbol_type() {}
 ParserGen::stack_symbol_type::stack_symbol_type(YY_RVREF(stack_symbol_type) that)
     : super_type(YY_MOVE(that.state), YY_MOVE(that.location)) {
     switch (that.type_get()) {
-        case 114:  // "BinData"
+        case 115:  // "BinData"
             value.YY_MOVE_OR_COPY<BSONBinData>(YY_MOVE(that.value));
             break;
 
-        case 121:  // "Code"
+        case 122:  // "Code"
             value.YY_MOVE_OR_COPY<BSONCode>(YY_MOVE(that.value));
             break;
 
-        case 123:  // "CodeWScope"
+        case 124:  // "CodeWScope"
             value.YY_MOVE_OR_COPY<BSONCodeWScope>(YY_MOVE(that.value));
             break;
 
-        case 120:  // "dbPointer"
+        case 121:  // "dbPointer"
             value.YY_MOVE_OR_COPY<BSONDBRef>(YY_MOVE(that.value));
             break;
 
-        case 119:  // "regex"
+        case 120:  // "regex"
             value.YY_MOVE_OR_COPY<BSONRegEx>(YY_MOVE(that.value));
             break;
 
-        case 122:  // "Symbol"
+        case 123:  // "Symbol"
             value.YY_MOVE_OR_COPY<BSONSymbol>(YY_MOVE(that.value));
             break;
 
@@ -377,92 +377,98 @@ ParserGen::stack_symbol_type::stack_symbol_type(YY_RVREF(stack_symbol_type) that
         case 258:  // sqrt
         case 259:  // subtract
         case 260:  // trunc
-        case 270:  // matchExpression
-        case 271:  // filterFields
-        case 272:  // filterVal
-        case 273:  // sortSpecs
-        case 274:  // specList
-        case 275:  // metaSort
-        case 276:  // oneOrNegOne
-        case 277:  // metaSortKeyword
+        case 270:  // match
+        case 271:  // predicates
+        case 272:  // compoundMatchExprs
+        case 273:  // predValue
+        case 274:  // additionalExprs
+        case 280:  // sortSpecs
+        case 281:  // specList
+        case 282:  // metaSort
+        case 283:  // oneOrNegOne
+        case 284:  // metaSortKeyword
             value.YY_MOVE_OR_COPY<CNode>(YY_MOVE(that.value));
             break;
 
-        case 135:  // projectionFieldname
-        case 136:  // expressionFieldname
-        case 137:  // stageAsUserFieldname
-        case 138:  // filterFieldname
-        case 139:  // argAsUserFieldname
-        case 140:  // aggExprAsUserFieldname
-        case 141:  // invariableUserFieldname
-        case 142:  // idAsUserFieldname
-        case 143:  // valueFieldname
+        case 136:  // projectionFieldname
+        case 137:  // expressionFieldname
+        case 138:  // stageAsUserFieldname
+        case 139:  // predFieldname
+        case 140:  // argAsUserFieldname
+        case 141:  // aggExprAsUserFieldname
+        case 142:  // invariableUserFieldname
+        case 143:  // idAsUserFieldname
+        case 144:  // valueFieldname
+        case 279:  // logicalExprField
             value.YY_MOVE_OR_COPY<CNode::Fieldname>(YY_MOVE(that.value));
             break;
 
-        case 117:  // "Date"
+        case 118:  // "Date"
             value.YY_MOVE_OR_COPY<Date_t>(YY_MOVE(that.value));
             break;
 
-        case 127:  // "arbitrary decimal"
+        case 128:  // "arbitrary decimal"
             value.YY_MOVE_OR_COPY<Decimal128>(YY_MOVE(that.value));
             break;
 
-        case 116:  // "ObjectID"
+        case 117:  // "ObjectID"
             value.YY_MOVE_OR_COPY<OID>(YY_MOVE(that.value));
             break;
 
-        case 128:  // "Timestamp"
+        case 129:  // "Timestamp"
             value.YY_MOVE_OR_COPY<Timestamp>(YY_MOVE(that.value));
             break;
 
-        case 130:  // "maxKey"
+        case 131:  // "maxKey"
             value.YY_MOVE_OR_COPY<UserMaxKey>(YY_MOVE(that.value));
             break;
 
-        case 129:  // "minKey"
+        case 130:  // "minKey"
             value.YY_MOVE_OR_COPY<UserMinKey>(YY_MOVE(that.value));
             break;
 
-        case 118:  // "null"
+        case 119:  // "null"
             value.YY_MOVE_OR_COPY<UserNull>(YY_MOVE(that.value));
             break;
 
-        case 115:  // "undefined"
+        case 116:  // "undefined"
             value.YY_MOVE_OR_COPY<UserUndefined>(YY_MOVE(that.value));
             break;
 
-        case 126:  // "arbitrary double"
+        case 127:  // "arbitrary double"
             value.YY_MOVE_OR_COPY<double>(YY_MOVE(that.value));
             break;
 
-        case 124:  // "arbitrary integer"
+        case 125:  // "arbitrary integer"
             value.YY_MOVE_OR_COPY<int>(YY_MOVE(that.value));
             break;
 
-        case 125:  // "arbitrary long"
+        case 126:  // "arbitrary long"
             value.YY_MOVE_OR_COPY<long long>(YY_MOVE(that.value));
             break;
 
-        case 144:  // projectField
-        case 145:  // expressionField
-        case 146:  // valueField
-        case 147:  // filterField
+        case 145:  // projectField
+        case 146:  // expressionField
+        case 147:  // valueField
         case 261:  // onErrorArg
         case 262:  // onNullArg
         case 263:  // formatArg
         case 264:  // timezoneArg
         case 265:  // charsArg
         case 266:  // optionsArg
-        case 278:  // sortSpec
+        case 275:  // predicate
+        case 276:  // logicalExpr
+        case 277:  // operatorExpression
+        case 278:  // notExpr
+        case 285:  // sortSpec
             value.YY_MOVE_OR_COPY<std::pair<CNode::Fieldname, CNode>>(YY_MOVE(that.value));
             break;
 
-        case 112:  // "fieldname"
-        case 113:  // "string"
-        case 131:  // "$-prefixed string"
-        case 132:  // "$$-prefixed string"
-        case 133:  // "$-prefixed fieldname"
+        case 113:  // "fieldname"
+        case 114:  // "string"
+        case 132:  // "$-prefixed string"
+        case 133:  // "$$-prefixed string"
+        case 134:  // "$-prefixed fieldname"
             value.YY_MOVE_OR_COPY<std::string>(YY_MOVE(that.value));
             break;
 
@@ -485,27 +491,27 @@ ParserGen::stack_symbol_type::stack_symbol_type(YY_RVREF(stack_symbol_type) that
 ParserGen::stack_symbol_type::stack_symbol_type(state_type s, YY_MOVE_REF(symbol_type) that)
     : super_type(s, YY_MOVE(that.location)) {
     switch (that.type_get()) {
-        case 114:  // "BinData"
+        case 115:  // "BinData"
             value.move<BSONBinData>(YY_MOVE(that.value));
             break;
 
-        case 121:  // "Code"
+        case 122:  // "Code"
             value.move<BSONCode>(YY_MOVE(that.value));
             break;
 
-        case 123:  // "CodeWScope"
+        case 124:  // "CodeWScope"
             value.move<BSONCodeWScope>(YY_MOVE(that.value));
             break;
 
-        case 120:  // "dbPointer"
+        case 121:  // "dbPointer"
             value.move<BSONDBRef>(YY_MOVE(that.value));
             break;
 
-        case 119:  // "regex"
+        case 120:  // "regex"
             value.move<BSONRegEx>(YY_MOVE(that.value));
             break;
 
-        case 122:  // "Symbol"
+        case 123:  // "Symbol"
             value.move<BSONSymbol>(YY_MOVE(that.value));
             break;
 
@@ -622,92 +628,98 @@ ParserGen::stack_symbol_type::stack_symbol_type(state_type s, YY_MOVE_REF(symbol
         case 258:  // sqrt
         case 259:  // subtract
         case 260:  // trunc
-        case 270:  // matchExpression
-        case 271:  // filterFields
-        case 272:  // filterVal
-        case 273:  // sortSpecs
-        case 274:  // specList
-        case 275:  // metaSort
-        case 276:  // oneOrNegOne
-        case 277:  // metaSortKeyword
+        case 270:  // match
+        case 271:  // predicates
+        case 272:  // compoundMatchExprs
+        case 273:  // predValue
+        case 274:  // additionalExprs
+        case 280:  // sortSpecs
+        case 281:  // specList
+        case 282:  // metaSort
+        case 283:  // oneOrNegOne
+        case 284:  // metaSortKeyword
             value.move<CNode>(YY_MOVE(that.value));
             break;
 
-        case 135:  // projectionFieldname
-        case 136:  // expressionFieldname
-        case 137:  // stageAsUserFieldname
-        case 138:  // filterFieldname
-        case 139:  // argAsUserFieldname
-        case 140:  // aggExprAsUserFieldname
-        case 141:  // invariableUserFieldname
-        case 142:  // idAsUserFieldname
-        case 143:  // valueFieldname
+        case 136:  // projectionFieldname
+        case 137:  // expressionFieldname
+        case 138:  // stageAsUserFieldname
+        case 139:  // predFieldname
+        case 140:  // argAsUserFieldname
+        case 141:  // aggExprAsUserFieldname
+        case 142:  // invariableUserFieldname
+        case 143:  // idAsUserFieldname
+        case 144:  // valueFieldname
+        case 279:  // logicalExprField
             value.move<CNode::Fieldname>(YY_MOVE(that.value));
             break;
 
-        case 117:  // "Date"
+        case 118:  // "Date"
             value.move<Date_t>(YY_MOVE(that.value));
             break;
 
-        case 127:  // "arbitrary decimal"
+        case 128:  // "arbitrary decimal"
             value.move<Decimal128>(YY_MOVE(that.value));
             break;
 
-        case 116:  // "ObjectID"
+        case 117:  // "ObjectID"
             value.move<OID>(YY_MOVE(that.value));
             break;
 
-        case 128:  // "Timestamp"
+        case 129:  // "Timestamp"
             value.move<Timestamp>(YY_MOVE(that.value));
             break;
 
-        case 130:  // "maxKey"
+        case 131:  // "maxKey"
             value.move<UserMaxKey>(YY_MOVE(that.value));
             break;
 
-        case 129:  // "minKey"
+        case 130:  // "minKey"
             value.move<UserMinKey>(YY_MOVE(that.value));
             break;
 
-        case 118:  // "null"
+        case 119:  // "null"
             value.move<UserNull>(YY_MOVE(that.value));
             break;
 
-        case 115:  // "undefined"
+        case 116:  // "undefined"
             value.move<UserUndefined>(YY_MOVE(that.value));
             break;
 
-        case 126:  // "arbitrary double"
+        case 127:  // "arbitrary double"
             value.move<double>(YY_MOVE(that.value));
             break;
 
-        case 124:  // "arbitrary integer"
+        case 125:  // "arbitrary integer"
             value.move<int>(YY_MOVE(that.value));
             break;
 
-        case 125:  // "arbitrary long"
+        case 126:  // "arbitrary long"
             value.move<long long>(YY_MOVE(that.value));
             break;
 
-        case 144:  // projectField
-        case 145:  // expressionField
-        case 146:  // valueField
-        case 147:  // filterField
+        case 145:  // projectField
+        case 146:  // expressionField
+        case 147:  // valueField
         case 261:  // onErrorArg
         case 262:  // onNullArg
         case 263:  // formatArg
         case 264:  // timezoneArg
         case 265:  // charsArg
         case 266:  // optionsArg
-        case 278:  // sortSpec
+        case 275:  // predicate
+        case 276:  // logicalExpr
+        case 277:  // operatorExpression
+        case 278:  // notExpr
+        case 285:  // sortSpec
             value.move<std::pair<CNode::Fieldname, CNode>>(YY_MOVE(that.value));
             break;
 
-        case 112:  // "fieldname"
-        case 113:  // "string"
-        case 131:  // "$-prefixed string"
-        case 132:  // "$$-prefixed string"
-        case 133:  // "$-prefixed fieldname"
+        case 113:  // "fieldname"
+        case 114:  // "string"
+        case 132:  // "$-prefixed string"
+        case 133:  // "$$-prefixed string"
+        case 134:  // "$-prefixed fieldname"
             value.move<std::string>(YY_MOVE(that.value));
             break;
 
@@ -730,27 +742,27 @@ ParserGen::stack_symbol_type& ParserGen::stack_symbol_type::operator=(
     const stack_symbol_type& that) {
     state = that.state;
     switch (that.type_get()) {
-        case 114:  // "BinData"
+        case 115:  // "BinData"
             value.copy<BSONBinData>(that.value);
             break;
 
-        case 121:  // "Code"
+        case 122:  // "Code"
             value.copy<BSONCode>(that.value);
             break;
 
-        case 123:  // "CodeWScope"
+        case 124:  // "CodeWScope"
             value.copy<BSONCodeWScope>(that.value);
             break;
 
-        case 120:  // "dbPointer"
+        case 121:  // "dbPointer"
             value.copy<BSONDBRef>(that.value);
             break;
 
-        case 119:  // "regex"
+        case 120:  // "regex"
             value.copy<BSONRegEx>(that.value);
             break;
 
-        case 122:  // "Symbol"
+        case 123:  // "Symbol"
             value.copy<BSONSymbol>(that.value);
             break;
 
@@ -867,92 +879,98 @@ ParserGen::stack_symbol_type& ParserGen::stack_symbol_type::operator=(
         case 258:  // sqrt
         case 259:  // subtract
         case 260:  // trunc
-        case 270:  // matchExpression
-        case 271:  // filterFields
-        case 272:  // filterVal
-        case 273:  // sortSpecs
-        case 274:  // specList
-        case 275:  // metaSort
-        case 276:  // oneOrNegOne
-        case 277:  // metaSortKeyword
+        case 270:  // match
+        case 271:  // predicates
+        case 272:  // compoundMatchExprs
+        case 273:  // predValue
+        case 274:  // additionalExprs
+        case 280:  // sortSpecs
+        case 281:  // specList
+        case 282:  // metaSort
+        case 283:  // oneOrNegOne
+        case 284:  // metaSortKeyword
             value.copy<CNode>(that.value);
             break;
 
-        case 135:  // projectionFieldname
-        case 136:  // expressionFieldname
-        case 137:  // stageAsUserFieldname
-        case 138:  // filterFieldname
-        case 139:  // argAsUserFieldname
-        case 140:  // aggExprAsUserFieldname
-        case 141:  // invariableUserFieldname
-        case 142:  // idAsUserFieldname
-        case 143:  // valueFieldname
+        case 136:  // projectionFieldname
+        case 137:  // expressionFieldname
+        case 138:  // stageAsUserFieldname
+        case 139:  // predFieldname
+        case 140:  // argAsUserFieldname
+        case 141:  // aggExprAsUserFieldname
+        case 142:  // invariableUserFieldname
+        case 143:  // idAsUserFieldname
+        case 144:  // valueFieldname
+        case 279:  // logicalExprField
             value.copy<CNode::Fieldname>(that.value);
             break;
 
-        case 117:  // "Date"
+        case 118:  // "Date"
             value.copy<Date_t>(that.value);
             break;
 
-        case 127:  // "arbitrary decimal"
+        case 128:  // "arbitrary decimal"
             value.copy<Decimal128>(that.value);
             break;
 
-        case 116:  // "ObjectID"
+        case 117:  // "ObjectID"
             value.copy<OID>(that.value);
             break;
 
-        case 128:  // "Timestamp"
+        case 129:  // "Timestamp"
             value.copy<Timestamp>(that.value);
             break;
 
-        case 130:  // "maxKey"
+        case 131:  // "maxKey"
             value.copy<UserMaxKey>(that.value);
             break;
 
-        case 129:  // "minKey"
+        case 130:  // "minKey"
             value.copy<UserMinKey>(that.value);
             break;
 
-        case 118:  // "null"
+        case 119:  // "null"
             value.copy<UserNull>(that.value);
             break;
 
-        case 115:  // "undefined"
+        case 116:  // "undefined"
             value.copy<UserUndefined>(that.value);
             break;
 
-        case 126:  // "arbitrary double"
+        case 127:  // "arbitrary double"
             value.copy<double>(that.value);
             break;
 
-        case 124:  // "arbitrary integer"
+        case 125:  // "arbitrary integer"
             value.copy<int>(that.value);
             break;
 
-        case 125:  // "arbitrary long"
+        case 126:  // "arbitrary long"
             value.copy<long long>(that.value);
             break;
 
-        case 144:  // projectField
-        case 145:  // expressionField
-        case 146:  // valueField
-        case 147:  // filterField
+        case 145:  // projectField
+        case 146:  // expressionField
+        case 147:  // valueField
         case 261:  // onErrorArg
         case 262:  // onNullArg
         case 263:  // formatArg
         case 264:  // timezoneArg
         case 265:  // charsArg
         case 266:  // optionsArg
-        case 278:  // sortSpec
+        case 275:  // predicate
+        case 276:  // logicalExpr
+        case 277:  // operatorExpression
+        case 278:  // notExpr
+        case 285:  // sortSpec
             value.copy<std::pair<CNode::Fieldname, CNode>>(that.value);
             break;
 
-        case 112:  // "fieldname"
-        case 113:  // "string"
-        case 131:  // "$-prefixed string"
-        case 132:  // "$$-prefixed string"
-        case 133:  // "$-prefixed fieldname"
+        case 113:  // "fieldname"
+        case 114:  // "string"
+        case 132:  // "$-prefixed string"
+        case 133:  // "$$-prefixed string"
+        case 134:  // "$-prefixed fieldname"
             value.copy<std::string>(that.value);
             break;
 
@@ -973,27 +991,27 @@ ParserGen::stack_symbol_type& ParserGen::stack_symbol_type::operator=(
 ParserGen::stack_symbol_type& ParserGen::stack_symbol_type::operator=(stack_symbol_type& that) {
     state = that.state;
     switch (that.type_get()) {
-        case 114:  // "BinData"
+        case 115:  // "BinData"
             value.move<BSONBinData>(that.value);
             break;
 
-        case 121:  // "Code"
+        case 122:  // "Code"
             value.move<BSONCode>(that.value);
             break;
 
-        case 123:  // "CodeWScope"
+        case 124:  // "CodeWScope"
             value.move<BSONCodeWScope>(that.value);
             break;
 
-        case 120:  // "dbPointer"
+        case 121:  // "dbPointer"
             value.move<BSONDBRef>(that.value);
             break;
 
-        case 119:  // "regex"
+        case 120:  // "regex"
             value.move<BSONRegEx>(that.value);
             break;
 
-        case 122:  // "Symbol"
+        case 123:  // "Symbol"
             value.move<BSONSymbol>(that.value);
             break;
 
@@ -1110,92 +1128,98 @@ ParserGen::stack_symbol_type& ParserGen::stack_symbol_type::operator=(stack_symb
         case 258:  // sqrt
         case 259:  // subtract
         case 260:  // trunc
-        case 270:  // matchExpression
-        case 271:  // filterFields
-        case 272:  // filterVal
-        case 273:  // sortSpecs
-        case 274:  // specList
-        case 275:  // metaSort
-        case 276:  // oneOrNegOne
-        case 277:  // metaSortKeyword
+        case 270:  // match
+        case 271:  // predicates
+        case 272:  // compoundMatchExprs
+        case 273:  // predValue
+        case 274:  // additionalExprs
+        case 280:  // sortSpecs
+        case 281:  // specList
+        case 282:  // metaSort
+        case 283:  // oneOrNegOne
+        case 284:  // metaSortKeyword
             value.move<CNode>(that.value);
             break;
 
-        case 135:  // projectionFieldname
-        case 136:  // expressionFieldname
-        case 137:  // stageAsUserFieldname
-        case 138:  // filterFieldname
-        case 139:  // argAsUserFieldname
-        case 140:  // aggExprAsUserFieldname
-        case 141:  // invariableUserFieldname
-        case 142:  // idAsUserFieldname
-        case 143:  // valueFieldname
+        case 136:  // projectionFieldname
+        case 137:  // expressionFieldname
+        case 138:  // stageAsUserFieldname
+        case 139:  // predFieldname
+        case 140:  // argAsUserFieldname
+        case 141:  // aggExprAsUserFieldname
+        case 142:  // invariableUserFieldname
+        case 143:  // idAsUserFieldname
+        case 144:  // valueFieldname
+        case 279:  // logicalExprField
             value.move<CNode::Fieldname>(that.value);
             break;
 
-        case 117:  // "Date"
+        case 118:  // "Date"
             value.move<Date_t>(that.value);
             break;
 
-        case 127:  // "arbitrary decimal"
+        case 128:  // "arbitrary decimal"
             value.move<Decimal128>(that.value);
             break;
 
-        case 116:  // "ObjectID"
+        case 117:  // "ObjectID"
             value.move<OID>(that.value);
             break;
 
-        case 128:  // "Timestamp"
+        case 129:  // "Timestamp"
             value.move<Timestamp>(that.value);
             break;
 
-        case 130:  // "maxKey"
+        case 131:  // "maxKey"
             value.move<UserMaxKey>(that.value);
             break;
 
-        case 129:  // "minKey"
+        case 130:  // "minKey"
             value.move<UserMinKey>(that.value);
             break;
 
-        case 118:  // "null"
+        case 119:  // "null"
             value.move<UserNull>(that.value);
             break;
 
-        case 115:  // "undefined"
+        case 116:  // "undefined"
             value.move<UserUndefined>(that.value);
             break;
 
-        case 126:  // "arbitrary double"
+        case 127:  // "arbitrary double"
             value.move<double>(that.value);
             break;
 
-        case 124:  // "arbitrary integer"
+        case 125:  // "arbitrary integer"
             value.move<int>(that.value);
             break;
 
-        case 125:  // "arbitrary long"
+        case 126:  // "arbitrary long"
             value.move<long long>(that.value);
             break;
 
-        case 144:  // projectField
-        case 145:  // expressionField
-        case 146:  // valueField
-        case 147:  // filterField
+        case 145:  // projectField
+        case 146:  // expressionField
+        case 147:  // valueField
         case 261:  // onErrorArg
         case 262:  // onNullArg
         case 263:  // formatArg
         case 264:  // timezoneArg
         case 265:  // charsArg
         case 266:  // optionsArg
-        case 278:  // sortSpec
+        case 275:  // predicate
+        case 276:  // logicalExpr
+        case 277:  // operatorExpression
+        case 278:  // notExpr
+        case 285:  // sortSpec
             value.move<std::pair<CNode::Fieldname, CNode>>(that.value);
             break;
 
-        case 112:  // "fieldname"
-        case 113:  // "string"
-        case 131:  // "$-prefixed string"
-        case 132:  // "$$-prefixed string"
-        case 133:  // "$-prefixed fieldname"
+        case 113:  // "fieldname"
+        case 114:  // "string"
+        case 132:  // "$-prefixed string"
+        case 133:  // "$$-prefixed string"
+        case 134:  // "$-prefixed fieldname"
             value.move<std::string>(that.value);
             break;
 
@@ -1421,27 +1445,27 @@ int ParserGen::parse() {
                correct type. The default '$$ = $1' action is NOT applied
                when using variants.  */
             switch (yyr1_[yyn]) {
-                case 114:  // "BinData"
+                case 115:  // "BinData"
                     yylhs.value.emplace<BSONBinData>();
                     break;
 
-                case 121:  // "Code"
+                case 122:  // "Code"
                     yylhs.value.emplace<BSONCode>();
                     break;
 
-                case 123:  // "CodeWScope"
+                case 124:  // "CodeWScope"
                     yylhs.value.emplace<BSONCodeWScope>();
                     break;
 
-                case 120:  // "dbPointer"
+                case 121:  // "dbPointer"
                     yylhs.value.emplace<BSONDBRef>();
                     break;
 
-                case 119:  // "regex"
+                case 120:  // "regex"
                     yylhs.value.emplace<BSONRegEx>();
                     break;
 
-                case 122:  // "Symbol"
+                case 123:  // "Symbol"
                     yylhs.value.emplace<BSONSymbol>();
                     break;
 
@@ -1558,92 +1582,98 @@ int ParserGen::parse() {
                 case 258:  // sqrt
                 case 259:  // subtract
                 case 260:  // trunc
-                case 270:  // matchExpression
-                case 271:  // filterFields
-                case 272:  // filterVal
-                case 273:  // sortSpecs
-                case 274:  // specList
-                case 275:  // metaSort
-                case 276:  // oneOrNegOne
-                case 277:  // metaSortKeyword
+                case 270:  // match
+                case 271:  // predicates
+                case 272:  // compoundMatchExprs
+                case 273:  // predValue
+                case 274:  // additionalExprs
+                case 280:  // sortSpecs
+                case 281:  // specList
+                case 282:  // metaSort
+                case 283:  // oneOrNegOne
+                case 284:  // metaSortKeyword
                     yylhs.value.emplace<CNode>();
                     break;
 
-                case 135:  // projectionFieldname
-                case 136:  // expressionFieldname
-                case 137:  // stageAsUserFieldname
-                case 138:  // filterFieldname
-                case 139:  // argAsUserFieldname
-                case 140:  // aggExprAsUserFieldname
-                case 141:  // invariableUserFieldname
-                case 142:  // idAsUserFieldname
-                case 143:  // valueFieldname
+                case 136:  // projectionFieldname
+                case 137:  // expressionFieldname
+                case 138:  // stageAsUserFieldname
+                case 139:  // predFieldname
+                case 140:  // argAsUserFieldname
+                case 141:  // aggExprAsUserFieldname
+                case 142:  // invariableUserFieldname
+                case 143:  // idAsUserFieldname
+                case 144:  // valueFieldname
+                case 279:  // logicalExprField
                     yylhs.value.emplace<CNode::Fieldname>();
                     break;
 
-                case 117:  // "Date"
+                case 118:  // "Date"
                     yylhs.value.emplace<Date_t>();
                     break;
 
-                case 127:  // "arbitrary decimal"
+                case 128:  // "arbitrary decimal"
                     yylhs.value.emplace<Decimal128>();
                     break;
 
-                case 116:  // "ObjectID"
+                case 117:  // "ObjectID"
                     yylhs.value.emplace<OID>();
                     break;
 
-                case 128:  // "Timestamp"
+                case 129:  // "Timestamp"
                     yylhs.value.emplace<Timestamp>();
                     break;
 
-                case 130:  // "maxKey"
+                case 131:  // "maxKey"
                     yylhs.value.emplace<UserMaxKey>();
                     break;
 
-                case 129:  // "minKey"
+                case 130:  // "minKey"
                     yylhs.value.emplace<UserMinKey>();
                     break;
 
-                case 118:  // "null"
+                case 119:  // "null"
                     yylhs.value.emplace<UserNull>();
                     break;
 
-                case 115:  // "undefined"
+                case 116:  // "undefined"
                     yylhs.value.emplace<UserUndefined>();
                     break;
 
-                case 126:  // "arbitrary double"
+                case 127:  // "arbitrary double"
                     yylhs.value.emplace<double>();
                     break;
 
-                case 124:  // "arbitrary integer"
+                case 125:  // "arbitrary integer"
                     yylhs.value.emplace<int>();
                     break;
 
-                case 125:  // "arbitrary long"
+                case 126:  // "arbitrary long"
                     yylhs.value.emplace<long long>();
                     break;
 
-                case 144:  // projectField
-                case 145:  // expressionField
-                case 146:  // valueField
-                case 147:  // filterField
+                case 145:  // projectField
+                case 146:  // expressionField
+                case 147:  // valueField
                 case 261:  // onErrorArg
                 case 262:  // onNullArg
                 case 263:  // formatArg
                 case 264:  // timezoneArg
                 case 265:  // charsArg
                 case 266:  // optionsArg
-                case 278:  // sortSpec
+                case 275:  // predicate
+                case 276:  // logicalExpr
+                case 277:  // operatorExpression
+                case 278:  // notExpr
+                case 285:  // sortSpec
                     yylhs.value.emplace<std::pair<CNode::Fieldname, CNode>>();
                     break;
 
-                case 112:  // "fieldname"
-                case 113:  // "string"
-                case 131:  // "$-prefixed string"
-                case 132:  // "$$-prefixed string"
-                case 133:  // "$-prefixed fieldname"
+                case 113:  // "fieldname"
+                case 114:  // "string"
+                case 132:  // "$-prefixed string"
+                case 133:  // "$$-prefixed string"
+                case 134:  // "$-prefixed fieldname"
                     yylhs.value.emplace<std::string>();
                     break;
 
@@ -1673,127 +1703,127 @@ int ParserGen::parse() {
             {
                 switch (yyn) {
                     case 2:
-#line 299 "src/mongo/db/cst/grammar.yy"
+#line 304 "src/mongo/db/cst/grammar.yy"
                     {
                         *cst = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1749 "src/mongo/db/cst/parser_gen.cpp"
+#line 1779 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 3:
-#line 302 "src/mongo/db/cst/grammar.yy"
+#line 307 "src/mongo/db/cst/grammar.yy"
                     {
                         *cst = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1757 "src/mongo/db/cst/parser_gen.cpp"
+#line 1787 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 4:
-#line 305 "src/mongo/db/cst/grammar.yy"
+#line 310 "src/mongo/db/cst/grammar.yy"
                     {
                         *cst = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1765 "src/mongo/db/cst/parser_gen.cpp"
+#line 1795 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 5:
-#line 308 "src/mongo/db/cst/grammar.yy"
+#line 313 "src/mongo/db/cst/grammar.yy"
                     {
                         *cst = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1773 "src/mongo/db/cst/parser_gen.cpp"
+#line 1803 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 6:
-#line 311 "src/mongo/db/cst/grammar.yy"
+#line 316 "src/mongo/db/cst/grammar.yy"
                     {
                         *cst = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1781 "src/mongo/db/cst/parser_gen.cpp"
+#line 1811 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 7:
-#line 318 "src/mongo/db/cst/grammar.yy"
+#line 323 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                     }
-#line 1789 "src/mongo/db/cst/parser_gen.cpp"
+#line 1819 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 8:
-#line 324 "src/mongo/db/cst/grammar.yy"
+#line 329 "src/mongo/db/cst/grammar.yy"
                     {
                     }
-#line 1795 "src/mongo/db/cst/parser_gen.cpp"
+#line 1825 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 9:
-#line 325 "src/mongo/db/cst/grammar.yy"
+#line 330 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{CNode::ArrayChildren{YY_MOVE(yystack_[2].value.as<CNode>())}};
                     }
-#line 1803 "src/mongo/db/cst/parser_gen.cpp"
+#line 1833 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 10:
-#line 333 "src/mongo/db/cst/grammar.yy"
+#line 338 "src/mongo/db/cst/grammar.yy"
                     {
                         lexer.sortObjTokens();
                     }
-#line 1809 "src/mongo/db/cst/parser_gen.cpp"
+#line 1839 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 12:
-#line 336 "src/mongo/db/cst/grammar.yy"
+#line 341 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1815 "src/mongo/db/cst/parser_gen.cpp"
+#line 1845 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 13:
-#line 336 "src/mongo/db/cst/grammar.yy"
+#line 341 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1821 "src/mongo/db/cst/parser_gen.cpp"
+#line 1851 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 14:
-#line 336 "src/mongo/db/cst/grammar.yy"
+#line 341 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1827 "src/mongo/db/cst/parser_gen.cpp"
+#line 1857 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 15:
-#line 336 "src/mongo/db/cst/grammar.yy"
+#line 341 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1833 "src/mongo/db/cst/parser_gen.cpp"
+#line 1863 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 16:
-#line 336 "src/mongo/db/cst/grammar.yy"
+#line 341 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1839 "src/mongo/db/cst/parser_gen.cpp"
+#line 1869 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 17:
-#line 336 "src/mongo/db/cst/grammar.yy"
+#line 341 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1845 "src/mongo/db/cst/parser_gen.cpp"
+#line 1875 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 18:
-#line 339 "src/mongo/db/cst/grammar.yy"
+#line 344 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{std::pair{
                             KeyFieldname::sample,
@@ -1801,20 +1831,20 @@ int ParserGen::parse() {
                                 {KeyFieldname::sizeArg, YY_MOVE(yystack_[1].value.as<CNode>())},
                             }}}}};
                     }
-#line 1857 "src/mongo/db/cst/parser_gen.cpp"
+#line 1887 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 19:
-#line 349 "src/mongo/db/cst/grammar.yy"
+#line 354 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             std::pair{KeyFieldname::inhibitOptimization, CNode::noopLeaf()}}};
                     }
-#line 1865 "src/mongo/db/cst/parser_gen.cpp"
+#line 1895 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 20:
-#line 355 "src/mongo/db/cst/grammar.yy"
+#line 360 "src/mongo/db/cst/grammar.yy"
                     {
                         auto pipeline = YY_MOVE(yystack_[1].value.as<CNode>());
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{std::pair{
@@ -1823,61 +1853,61 @@ int ParserGen::parse() {
                                 {KeyFieldname::collArg, YY_MOVE(yystack_[3].value.as<CNode>())},
                                 {KeyFieldname::pipelineArg, std::move(pipeline)}}}}}};
                     }
-#line 1878 "src/mongo/db/cst/parser_gen.cpp"
+#line 1908 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 21:
-#line 365 "src/mongo/db/cst/grammar.yy"
+#line 370 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1884 "src/mongo/db/cst/parser_gen.cpp"
+#line 1914 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 22:
-#line 365 "src/mongo/db/cst/grammar.yy"
+#line 370 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1890 "src/mongo/db/cst/parser_gen.cpp"
+#line 1920 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 23:
-#line 365 "src/mongo/db/cst/grammar.yy"
+#line 370 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1896 "src/mongo/db/cst/parser_gen.cpp"
+#line 1926 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 24:
-#line 365 "src/mongo/db/cst/grammar.yy"
+#line 370 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1902 "src/mongo/db/cst/parser_gen.cpp"
+#line 1932 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 25:
-#line 369 "src/mongo/db/cst/grammar.yy"
+#line 374 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             std::pair{KeyFieldname::skip, YY_MOVE(yystack_[0].value.as<CNode>())}}};
                     }
-#line 1910 "src/mongo/db/cst/parser_gen.cpp"
+#line 1940 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 26:
-#line 374 "src/mongo/db/cst/grammar.yy"
+#line 379 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{std::pair{
                             KeyFieldname::limit, YY_MOVE(yystack_[0].value.as<CNode>())}}};
                     }
-#line 1918 "src/mongo/db/cst/parser_gen.cpp"
+#line 1948 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 27:
-#line 379 "src/mongo/db/cst/grammar.yy"
+#line 384 "src/mongo/db/cst/grammar.yy"
                     {
                         auto&& fields = YY_MOVE(yystack_[1].value.as<CNode>());
                         if (auto inclusion =
@@ -1893,308 +1923,308 @@ int ParserGen::parse() {
                             // function.
                             error(yystack_[3].location, inclusion.getStatus().reason());
                     }
-#line 1936 "src/mongo/db/cst/parser_gen.cpp"
+#line 1966 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 28:
-#line 395 "src/mongo/db/cst/grammar.yy"
+#line 400 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode::noopLeaf();
                     }
-#line 1944 "src/mongo/db/cst/parser_gen.cpp"
+#line 1974 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 29:
-#line 398 "src/mongo/db/cst/grammar.yy"
+#line 403 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                         yylhs.value.as<CNode>().objectChildren().emplace_back(
                             YY_MOVE(yystack_[0].value.as<std::pair<CNode::Fieldname, CNode>>()));
                     }
-#line 1953 "src/mongo/db/cst/parser_gen.cpp"
+#line 1983 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 30:
-#line 405 "src/mongo/db/cst/grammar.yy"
+#line 410 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = {
                             KeyFieldname::id, YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 1961 "src/mongo/db/cst/parser_gen.cpp"
+#line 1991 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 31:
-#line 408 "src/mongo/db/cst/grammar.yy"
+#line 413 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = {
                             YY_MOVE(yystack_[1].value.as<CNode::Fieldname>()),
                             YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 1969 "src/mongo/db/cst/parser_gen.cpp"
+#line 1999 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 32:
-#line 414 "src/mongo/db/cst/grammar.yy"
+#line 419 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1975 "src/mongo/db/cst/parser_gen.cpp"
+#line 2005 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 33:
-#line 415 "src/mongo/db/cst/grammar.yy"
+#line 420 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1981 "src/mongo/db/cst/parser_gen.cpp"
+#line 2011 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 34:
-#line 416 "src/mongo/db/cst/grammar.yy"
+#line 421 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1987 "src/mongo/db/cst/parser_gen.cpp"
+#line 2017 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 35:
-#line 417 "src/mongo/db/cst/grammar.yy"
+#line 422 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1993 "src/mongo/db/cst/parser_gen.cpp"
+#line 2023 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 36:
-#line 418 "src/mongo/db/cst/grammar.yy"
+#line 423 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 1999 "src/mongo/db/cst/parser_gen.cpp"
+#line 2029 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 37:
-#line 419 "src/mongo/db/cst/grammar.yy"
+#line 424 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2005 "src/mongo/db/cst/parser_gen.cpp"
+#line 2035 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 38:
-#line 420 "src/mongo/db/cst/grammar.yy"
+#line 425 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2011 "src/mongo/db/cst/parser_gen.cpp"
+#line 2041 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 39:
-#line 421 "src/mongo/db/cst/grammar.yy"
+#line 426 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2017 "src/mongo/db/cst/parser_gen.cpp"
+#line 2047 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 40:
-#line 422 "src/mongo/db/cst/grammar.yy"
+#line 427 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2023 "src/mongo/db/cst/parser_gen.cpp"
+#line 2053 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 41:
-#line 423 "src/mongo/db/cst/grammar.yy"
+#line 428 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2029 "src/mongo/db/cst/parser_gen.cpp"
+#line 2059 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 42:
-#line 424 "src/mongo/db/cst/grammar.yy"
+#line 429 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2035 "src/mongo/db/cst/parser_gen.cpp"
+#line 2065 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 43:
-#line 425 "src/mongo/db/cst/grammar.yy"
+#line 430 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{NonZeroKey{1}};
                     }
-#line 2043 "src/mongo/db/cst/parser_gen.cpp"
+#line 2073 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 44:
-#line 428 "src/mongo/db/cst/grammar.yy"
+#line 433 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{NonZeroKey{-1}};
                     }
-#line 2051 "src/mongo/db/cst/parser_gen.cpp"
+#line 2081 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 45:
-#line 431 "src/mongo/db/cst/grammar.yy"
+#line 436 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{NonZeroKey{YY_MOVE(yystack_[0].value.as<int>())}};
                     }
-#line 2059 "src/mongo/db/cst/parser_gen.cpp"
+#line 2089 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 46:
-#line 434 "src/mongo/db/cst/grammar.yy"
+#line 439 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::intZeroKey};
                     }
-#line 2067 "src/mongo/db/cst/parser_gen.cpp"
+#line 2097 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 47:
-#line 437 "src/mongo/db/cst/grammar.yy"
+#line 442 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{NonZeroKey{1ll}};
                     }
-#line 2075 "src/mongo/db/cst/parser_gen.cpp"
+#line 2105 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 48:
-#line 440 "src/mongo/db/cst/grammar.yy"
+#line 445 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{NonZeroKey{-1ll}};
                     }
-#line 2083 "src/mongo/db/cst/parser_gen.cpp"
+#line 2113 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 49:
-#line 443 "src/mongo/db/cst/grammar.yy"
+#line 448 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{NonZeroKey{YY_MOVE(yystack_[0].value.as<long long>())}};
                     }
-#line 2091 "src/mongo/db/cst/parser_gen.cpp"
+#line 2121 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 50:
-#line 446 "src/mongo/db/cst/grammar.yy"
+#line 451 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::longZeroKey};
                     }
-#line 2099 "src/mongo/db/cst/parser_gen.cpp"
+#line 2129 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 51:
-#line 449 "src/mongo/db/cst/grammar.yy"
+#line 454 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{NonZeroKey{1.0}};
                     }
-#line 2107 "src/mongo/db/cst/parser_gen.cpp"
+#line 2137 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 52:
-#line 452 "src/mongo/db/cst/grammar.yy"
+#line 457 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{NonZeroKey{-1.0}};
                     }
-#line 2115 "src/mongo/db/cst/parser_gen.cpp"
+#line 2145 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 53:
-#line 455 "src/mongo/db/cst/grammar.yy"
+#line 460 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{NonZeroKey{YY_MOVE(yystack_[0].value.as<double>())}};
                     }
-#line 2123 "src/mongo/db/cst/parser_gen.cpp"
+#line 2153 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 54:
-#line 458 "src/mongo/db/cst/grammar.yy"
+#line 463 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::doubleZeroKey};
                     }
-#line 2131 "src/mongo/db/cst/parser_gen.cpp"
+#line 2161 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 55:
-#line 461 "src/mongo/db/cst/grammar.yy"
+#line 466 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{NonZeroKey{1.0}};
                     }
-#line 2139 "src/mongo/db/cst/parser_gen.cpp"
+#line 2169 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 56:
-#line 464 "src/mongo/db/cst/grammar.yy"
+#line 469 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{NonZeroKey{-1.0}};
                     }
-#line 2147 "src/mongo/db/cst/parser_gen.cpp"
+#line 2177 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 57:
-#line 467 "src/mongo/db/cst/grammar.yy"
+#line 472 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{NonZeroKey{YY_MOVE(yystack_[0].value.as<Decimal128>())}};
                     }
-#line 2155 "src/mongo/db/cst/parser_gen.cpp"
+#line 2185 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 58:
-#line 470 "src/mongo/db/cst/grammar.yy"
+#line 475 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::decimalZeroKey};
                     }
-#line 2163 "src/mongo/db/cst/parser_gen.cpp"
+#line 2193 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 59:
-#line 473 "src/mongo/db/cst/grammar.yy"
+#line 478 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::trueKey};
                     }
-#line 2171 "src/mongo/db/cst/parser_gen.cpp"
+#line 2201 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 60:
-#line 476 "src/mongo/db/cst/grammar.yy"
+#line 481 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::falseKey};
                     }
-#line 2179 "src/mongo/db/cst/parser_gen.cpp"
+#line 2209 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 61:
-#line 479 "src/mongo/db/cst/grammar.yy"
+#line 484 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2185 "src/mongo/db/cst/parser_gen.cpp"
+#line 2215 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 62:
-#line 480 "src/mongo/db/cst/grammar.yy"
+#line 485 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2191 "src/mongo/db/cst/parser_gen.cpp"
+#line 2221 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 63:
-#line 481 "src/mongo/db/cst/grammar.yy"
+#line 486 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 2197 "src/mongo/db/cst/parser_gen.cpp"
+#line 2227 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 64:
-#line 482 "src/mongo/db/cst/grammar.yy"
+#line 487 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             c_node_disambiguation::disambiguateCompoundProjection(
@@ -2206,841 +2236,961 @@ int ParserGen::parse() {
                                       "object project field cannot contain both inclusion and "
                                       "exclusion indicators");
                     }
-#line 2208 "src/mongo/db/cst/parser_gen.cpp"
+#line 2238 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 65:
-#line 491 "src/mongo/db/cst/grammar.yy"
+#line 496 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 2214 "src/mongo/db/cst/parser_gen.cpp"
+#line 2244 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 66:
-#line 491 "src/mongo/db/cst/grammar.yy"
+#line 496 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 2220 "src/mongo/db/cst/parser_gen.cpp"
+#line 2250 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 67:
-#line 491 "src/mongo/db/cst/grammar.yy"
+#line 496 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 2226 "src/mongo/db/cst/parser_gen.cpp"
+#line 2256 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 68:
-#line 491 "src/mongo/db/cst/grammar.yy"
+#line 496 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 2232 "src/mongo/db/cst/parser_gen.cpp"
+#line 2262 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 69:
-#line 495 "src/mongo/db/cst/grammar.yy"
+#line 500 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                     }
-#line 2240 "src/mongo/db/cst/parser_gen.cpp"
+#line 2270 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 70:
-#line 501 "src/mongo/db/cst/grammar.yy"
+#line 506 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode::noopLeaf();
                     }
-#line 2248 "src/mongo/db/cst/parser_gen.cpp"
+#line 2278 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 71:
-#line 504 "src/mongo/db/cst/grammar.yy"
+#line 509 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                         yylhs.value.as<CNode>().objectChildren().emplace_back(
                             YY_MOVE(yystack_[0].value.as<std::pair<CNode::Fieldname, CNode>>()));
                     }
-#line 2257 "src/mongo/db/cst/parser_gen.cpp"
+#line 2287 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 72:
-#line 510 "src/mongo/db/cst/grammar.yy"
+#line 515 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = {
                             YY_MOVE(yystack_[1].value.as<CNode::Fieldname>()),
                             YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 2265 "src/mongo/db/cst/parser_gen.cpp"
+#line 2295 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 73:
-#line 516 "src/mongo/db/cst/grammar.yy"
+#line 518 "src/mongo/db/cst/grammar.yy"
                     {
-                        yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
+                        yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
+                            YY_MOVE(yystack_[0].value.as<std::pair<CNode::Fieldname, CNode>>());
                     }
-#line 2271 "src/mongo/db/cst/parser_gen.cpp"
+#line 2303 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
                     case 74:
-#line 521 "src/mongo/db/cst/grammar.yy"
+#line 527 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
+                    }
+#line 2309 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 75:
+#line 528 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
+                    }
+#line 2317 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 76:
+#line 534 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode>() = CNode::noopLeaf();
+                    }
+#line 2325 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 77:
+#line 537 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
+                        yylhs.value.as<CNode>().objectChildren().emplace_back(
+                            YY_MOVE(yystack_[0].value.as<std::pair<CNode::Fieldname, CNode>>()));
+                    }
+#line 2334 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 78:
+#line 544 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
+                            YY_MOVE(yystack_[0].value.as<std::pair<CNode::Fieldname, CNode>>());
+                    }
+#line 2340 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 79:
+#line 547 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = std::pair{
+                            KeyFieldname::notExpr, YY_MOVE(yystack_[0].value.as<CNode>())};
+                    }
+#line 2348 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 80:
+#line 551 "src/mongo/db/cst/grammar.yy"
+                    {
+                        auto&& exprs = YY_MOVE(yystack_[1].value.as<CNode>());
+                        exprs.objectChildren().emplace_back(
+                            YY_MOVE(yystack_[2].value.as<std::pair<CNode::Fieldname, CNode>>()));
+
+                        yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
+                            std::pair{KeyFieldname::notExpr, std::move(exprs)};
+                    }
+#line 2359 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 81:
+#line 560 "src/mongo/db/cst/grammar.yy"
+                    {
+                        auto&& children = YY_MOVE(yystack_[1].value.as<CNode>());
+                        children.arrayChildren().emplace_back(
+                            YY_MOVE(yystack_[2].value.as<CNode>()));
+                        yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = {
+                            YY_MOVE(yystack_[4].value.as<CNode::Fieldname>()), std::move(children)};
+                    }
+#line 2369 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 82:
+#line 568 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode::Fieldname>() = KeyFieldname::andExpr;
+                    }
+#line 2375 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 83:
+#line 569 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode::Fieldname>() = KeyFieldname::orExpr;
+                    }
+#line 2381 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 84:
+#line 570 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode::Fieldname>() = KeyFieldname::norExpr;
+                    }
+#line 2387 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 85:
+#line 573 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode>() = CNode{CNode::ArrayChildren{}};
+                    }
+#line 2395 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 86:
+#line 576 "src/mongo/db/cst/grammar.yy"
+                    {
+                        yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
+                        yylhs.value.as<CNode>().arrayChildren().emplace_back(
+                            YY_MOVE(yystack_[0].value.as<CNode>()));
+                    }
+#line 2404 "src/mongo/db/cst/parser_gen.cpp"
+                    break;
+
+                    case 87:
+#line 583 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 2277 "src/mongo/db/cst/parser_gen.cpp"
+#line 2410 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 75:
-#line 521 "src/mongo/db/cst/grammar.yy"
+                    case 88:
+#line 583 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 2283 "src/mongo/db/cst/parser_gen.cpp"
+#line 2416 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 76:
-#line 521 "src/mongo/db/cst/grammar.yy"
+                    case 89:
+#line 583 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 2289 "src/mongo/db/cst/parser_gen.cpp"
+#line 2422 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 77:
-#line 525 "src/mongo/db/cst/grammar.yy"
+                    case 90:
+#line 586 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             UserFieldname{YY_MOVE(yystack_[0].value.as<std::string>())};
                     }
-#line 2297 "src/mongo/db/cst/parser_gen.cpp"
+#line 2430 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 78:
-#line 533 "src/mongo/db/cst/grammar.yy"
+                    case 91:
+#line 594 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             UserFieldname{"$_internalInhibitOptimization"};
                     }
-#line 2305 "src/mongo/db/cst/parser_gen.cpp"
+#line 2438 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 79:
-#line 536 "src/mongo/db/cst/grammar.yy"
+                    case 92:
+#line 597 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$unionWith"};
                     }
-#line 2313 "src/mongo/db/cst/parser_gen.cpp"
+#line 2446 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 80:
-#line 539 "src/mongo/db/cst/grammar.yy"
+                    case 93:
+#line 600 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$skip"};
                     }
-#line 2321 "src/mongo/db/cst/parser_gen.cpp"
+#line 2454 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 81:
-#line 542 "src/mongo/db/cst/grammar.yy"
+                    case 94:
+#line 603 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$limit"};
                     }
-#line 2329 "src/mongo/db/cst/parser_gen.cpp"
+#line 2462 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 82:
-#line 545 "src/mongo/db/cst/grammar.yy"
+                    case 95:
+#line 606 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$project"};
                     }
-#line 2337 "src/mongo/db/cst/parser_gen.cpp"
+#line 2470 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 83:
-#line 548 "src/mongo/db/cst/grammar.yy"
+                    case 96:
+#line 609 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$sample"};
                     }
-#line 2345 "src/mongo/db/cst/parser_gen.cpp"
+#line 2478 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 84:
-#line 557 "src/mongo/db/cst/grammar.yy"
+                    case 97:
+#line 618 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"coll"};
                     }
-#line 2353 "src/mongo/db/cst/parser_gen.cpp"
+#line 2486 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 85:
-#line 560 "src/mongo/db/cst/grammar.yy"
+                    case 98:
+#line 621 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"pipeline"};
                     }
-#line 2361 "src/mongo/db/cst/parser_gen.cpp"
+#line 2494 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 86:
-#line 563 "src/mongo/db/cst/grammar.yy"
+                    case 99:
+#line 624 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"size"};
                     }
-#line 2369 "src/mongo/db/cst/parser_gen.cpp"
+#line 2502 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 87:
-#line 566 "src/mongo/db/cst/grammar.yy"
+                    case 100:
+#line 627 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"input"};
                     }
-#line 2377 "src/mongo/db/cst/parser_gen.cpp"
+#line 2510 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 88:
-#line 569 "src/mongo/db/cst/grammar.yy"
+                    case 101:
+#line 630 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"to"};
                     }
-#line 2385 "src/mongo/db/cst/parser_gen.cpp"
+#line 2518 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 89:
-#line 572 "src/mongo/db/cst/grammar.yy"
+                    case 102:
+#line 633 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"onError"};
                     }
-#line 2393 "src/mongo/db/cst/parser_gen.cpp"
+#line 2526 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 90:
-#line 575 "src/mongo/db/cst/grammar.yy"
+                    case 103:
+#line 636 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"onNull"};
                     }
-#line 2401 "src/mongo/db/cst/parser_gen.cpp"
+#line 2534 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 91:
-#line 578 "src/mongo/db/cst/grammar.yy"
+                    case 104:
+#line 639 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"dateString"};
                     }
-#line 2409 "src/mongo/db/cst/parser_gen.cpp"
+#line 2542 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 92:
-#line 581 "src/mongo/db/cst/grammar.yy"
+                    case 105:
+#line 642 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"format"};
                     }
-#line 2417 "src/mongo/db/cst/parser_gen.cpp"
+#line 2550 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 93:
-#line 584 "src/mongo/db/cst/grammar.yy"
+                    case 106:
+#line 645 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"timezone"};
                     }
-#line 2425 "src/mongo/db/cst/parser_gen.cpp"
+#line 2558 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 94:
-#line 587 "src/mongo/db/cst/grammar.yy"
+                    case 107:
+#line 648 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"date"};
                     }
-#line 2433 "src/mongo/db/cst/parser_gen.cpp"
+#line 2566 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 95:
-#line 590 "src/mongo/db/cst/grammar.yy"
+                    case 108:
+#line 651 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"chars"};
                     }
-#line 2441 "src/mongo/db/cst/parser_gen.cpp"
+#line 2574 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 96:
-#line 593 "src/mongo/db/cst/grammar.yy"
+                    case 109:
+#line 654 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"regex"};
                     }
-#line 2449 "src/mongo/db/cst/parser_gen.cpp"
+#line 2582 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 97:
-#line 596 "src/mongo/db/cst/grammar.yy"
+                    case 110:
+#line 657 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"options"};
                     }
-#line 2457 "src/mongo/db/cst/parser_gen.cpp"
+#line 2590 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 98:
-#line 599 "src/mongo/db/cst/grammar.yy"
+                    case 111:
+#line 660 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"find"};
                     }
-#line 2465 "src/mongo/db/cst/parser_gen.cpp"
+#line 2598 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 99:
-#line 602 "src/mongo/db/cst/grammar.yy"
+                    case 112:
+#line 663 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"replacement"};
                     }
-#line 2473 "src/mongo/db/cst/parser_gen.cpp"
+#line 2606 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 100:
-#line 605 "src/mongo/db/cst/grammar.yy"
+                    case 113:
+#line 666 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"filter"};
                     }
-#line 2481 "src/mongo/db/cst/parser_gen.cpp"
+#line 2614 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 101:
-#line 608 "src/mongo/db/cst/grammar.yy"
+                    case 114:
+#line 669 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"q"};
                     }
-#line 2489 "src/mongo/db/cst/parser_gen.cpp"
+#line 2622 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 102:
-#line 616 "src/mongo/db/cst/grammar.yy"
+                    case 115:
+#line 677 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$add"};
                     }
-#line 2497 "src/mongo/db/cst/parser_gen.cpp"
+#line 2630 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 103:
-#line 619 "src/mongo/db/cst/grammar.yy"
+                    case 116:
+#line 680 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$atan2"};
                     }
-#line 2505 "src/mongo/db/cst/parser_gen.cpp"
+#line 2638 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 104:
-#line 622 "src/mongo/db/cst/grammar.yy"
+                    case 117:
+#line 683 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$and"};
                     }
-#line 2513 "src/mongo/db/cst/parser_gen.cpp"
+#line 2646 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 105:
-#line 625 "src/mongo/db/cst/grammar.yy"
+                    case 118:
+#line 686 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$const"};
                     }
-#line 2521 "src/mongo/db/cst/parser_gen.cpp"
+#line 2654 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 106:
-#line 628 "src/mongo/db/cst/grammar.yy"
+                    case 119:
+#line 689 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$literal"};
                     }
-#line 2529 "src/mongo/db/cst/parser_gen.cpp"
+#line 2662 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 107:
-#line 631 "src/mongo/db/cst/grammar.yy"
+                    case 120:
+#line 692 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$or"};
                     }
-#line 2537 "src/mongo/db/cst/parser_gen.cpp"
+#line 2670 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 108:
-#line 634 "src/mongo/db/cst/grammar.yy"
+                    case 121:
+#line 695 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$not"};
                     }
-#line 2545 "src/mongo/db/cst/parser_gen.cpp"
+#line 2678 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 109:
-#line 637 "src/mongo/db/cst/grammar.yy"
+                    case 122:
+#line 698 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$cmp"};
                     }
-#line 2553 "src/mongo/db/cst/parser_gen.cpp"
+#line 2686 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 110:
-#line 640 "src/mongo/db/cst/grammar.yy"
+                    case 123:
+#line 701 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$eq"};
                     }
-#line 2561 "src/mongo/db/cst/parser_gen.cpp"
+#line 2694 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 111:
-#line 643 "src/mongo/db/cst/grammar.yy"
+                    case 124:
+#line 704 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$gt"};
                     }
-#line 2569 "src/mongo/db/cst/parser_gen.cpp"
+#line 2702 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 112:
-#line 646 "src/mongo/db/cst/grammar.yy"
+                    case 125:
+#line 707 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$gte"};
                     }
-#line 2577 "src/mongo/db/cst/parser_gen.cpp"
+#line 2710 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 113:
-#line 649 "src/mongo/db/cst/grammar.yy"
+                    case 126:
+#line 710 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$lt"};
                     }
-#line 2585 "src/mongo/db/cst/parser_gen.cpp"
+#line 2718 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 114:
-#line 652 "src/mongo/db/cst/grammar.yy"
+                    case 127:
+#line 713 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$lte"};
                     }
-#line 2593 "src/mongo/db/cst/parser_gen.cpp"
+#line 2726 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 115:
-#line 655 "src/mongo/db/cst/grammar.yy"
+                    case 128:
+#line 716 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$ne"};
                     }
-#line 2601 "src/mongo/db/cst/parser_gen.cpp"
+#line 2734 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 116:
-#line 658 "src/mongo/db/cst/grammar.yy"
+                    case 129:
+#line 719 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$convert"};
                     }
-#line 2609 "src/mongo/db/cst/parser_gen.cpp"
+#line 2742 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 117:
-#line 661 "src/mongo/db/cst/grammar.yy"
+                    case 130:
+#line 722 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toBool"};
                     }
-#line 2617 "src/mongo/db/cst/parser_gen.cpp"
+#line 2750 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 118:
-#line 664 "src/mongo/db/cst/grammar.yy"
+                    case 131:
+#line 725 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toDate"};
                     }
-#line 2625 "src/mongo/db/cst/parser_gen.cpp"
+#line 2758 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 119:
-#line 667 "src/mongo/db/cst/grammar.yy"
+                    case 132:
+#line 728 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toDecimal"};
                     }
-#line 2633 "src/mongo/db/cst/parser_gen.cpp"
+#line 2766 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 120:
-#line 670 "src/mongo/db/cst/grammar.yy"
+                    case 133:
+#line 731 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toDouble"};
                     }
-#line 2641 "src/mongo/db/cst/parser_gen.cpp"
+#line 2774 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 121:
-#line 673 "src/mongo/db/cst/grammar.yy"
+                    case 134:
+#line 734 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toInt"};
                     }
-#line 2649 "src/mongo/db/cst/parser_gen.cpp"
+#line 2782 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 122:
-#line 676 "src/mongo/db/cst/grammar.yy"
+                    case 135:
+#line 737 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toLong"};
                     }
-#line 2657 "src/mongo/db/cst/parser_gen.cpp"
+#line 2790 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 123:
-#line 679 "src/mongo/db/cst/grammar.yy"
+                    case 136:
+#line 740 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toObjectId"};
                     }
-#line 2665 "src/mongo/db/cst/parser_gen.cpp"
+#line 2798 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 124:
-#line 682 "src/mongo/db/cst/grammar.yy"
+                    case 137:
+#line 743 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toString"};
                     }
-#line 2673 "src/mongo/db/cst/parser_gen.cpp"
+#line 2806 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 125:
-#line 685 "src/mongo/db/cst/grammar.yy"
+                    case 138:
+#line 746 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$type"};
                     }
-#line 2681 "src/mongo/db/cst/parser_gen.cpp"
+#line 2814 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 126:
-#line 688 "src/mongo/db/cst/grammar.yy"
+                    case 139:
+#line 749 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$abs"};
                     }
-#line 2689 "src/mongo/db/cst/parser_gen.cpp"
+#line 2822 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 127:
-#line 691 "src/mongo/db/cst/grammar.yy"
+                    case 140:
+#line 752 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$ceil"};
                     }
-#line 2697 "src/mongo/db/cst/parser_gen.cpp"
+#line 2830 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 128:
-#line 694 "src/mongo/db/cst/grammar.yy"
+                    case 141:
+#line 755 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$divide"};
                     }
-#line 2705 "src/mongo/db/cst/parser_gen.cpp"
+#line 2838 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 129:
-#line 697 "src/mongo/db/cst/grammar.yy"
+                    case 142:
+#line 758 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$exp"};
                     }
-#line 2713 "src/mongo/db/cst/parser_gen.cpp"
+#line 2846 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 130:
-#line 700 "src/mongo/db/cst/grammar.yy"
+                    case 143:
+#line 761 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$floor"};
                     }
-#line 2721 "src/mongo/db/cst/parser_gen.cpp"
+#line 2854 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 131:
-#line 703 "src/mongo/db/cst/grammar.yy"
+                    case 144:
+#line 764 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$ln"};
                     }
-#line 2729 "src/mongo/db/cst/parser_gen.cpp"
+#line 2862 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 132:
-#line 706 "src/mongo/db/cst/grammar.yy"
+                    case 145:
+#line 767 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$log"};
                     }
-#line 2737 "src/mongo/db/cst/parser_gen.cpp"
+#line 2870 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 133:
-#line 709 "src/mongo/db/cst/grammar.yy"
+                    case 146:
+#line 770 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$log10"};
                     }
-#line 2745 "src/mongo/db/cst/parser_gen.cpp"
+#line 2878 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 134:
-#line 712 "src/mongo/db/cst/grammar.yy"
+                    case 147:
+#line 773 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$mod"};
                     }
-#line 2753 "src/mongo/db/cst/parser_gen.cpp"
+#line 2886 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 135:
-#line 715 "src/mongo/db/cst/grammar.yy"
+                    case 148:
+#line 776 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$multiply"};
                     }
-#line 2761 "src/mongo/db/cst/parser_gen.cpp"
+#line 2894 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 136:
-#line 718 "src/mongo/db/cst/grammar.yy"
+                    case 149:
+#line 779 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$pow"};
                     }
-#line 2769 "src/mongo/db/cst/parser_gen.cpp"
+#line 2902 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 137:
-#line 721 "src/mongo/db/cst/grammar.yy"
+                    case 150:
+#line 782 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$round"};
                     }
-#line 2777 "src/mongo/db/cst/parser_gen.cpp"
+#line 2910 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 138:
-#line 724 "src/mongo/db/cst/grammar.yy"
+                    case 151:
+#line 785 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$sqrt"};
                     }
-#line 2785 "src/mongo/db/cst/parser_gen.cpp"
+#line 2918 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 139:
-#line 727 "src/mongo/db/cst/grammar.yy"
+                    case 152:
+#line 788 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$subtract"};
                     }
-#line 2793 "src/mongo/db/cst/parser_gen.cpp"
+#line 2926 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 140:
-#line 730 "src/mongo/db/cst/grammar.yy"
+                    case 153:
+#line 791 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$trunc"};
                     }
-#line 2801 "src/mongo/db/cst/parser_gen.cpp"
+#line 2934 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 141:
-#line 733 "src/mongo/db/cst/grammar.yy"
+                    case 154:
+#line 794 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$concat"};
                     }
-#line 2809 "src/mongo/db/cst/parser_gen.cpp"
+#line 2942 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 142:
-#line 736 "src/mongo/db/cst/grammar.yy"
+                    case 155:
+#line 797 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$dateFromString"};
                     }
-#line 2817 "src/mongo/db/cst/parser_gen.cpp"
+#line 2950 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 143:
-#line 739 "src/mongo/db/cst/grammar.yy"
+                    case 156:
+#line 800 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$dateToString"};
                     }
-#line 2825 "src/mongo/db/cst/parser_gen.cpp"
+#line 2958 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 144:
-#line 742 "src/mongo/db/cst/grammar.yy"
+                    case 157:
+#line 803 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$indexOfBytes"};
                     }
-#line 2833 "src/mongo/db/cst/parser_gen.cpp"
+#line 2966 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 145:
-#line 745 "src/mongo/db/cst/grammar.yy"
+                    case 158:
+#line 806 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$indexOfCP"};
                     }
-#line 2841 "src/mongo/db/cst/parser_gen.cpp"
+#line 2974 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 146:
-#line 748 "src/mongo/db/cst/grammar.yy"
+                    case 159:
+#line 809 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$ltrim"};
                     }
-#line 2849 "src/mongo/db/cst/parser_gen.cpp"
+#line 2982 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 147:
-#line 751 "src/mongo/db/cst/grammar.yy"
+                    case 160:
+#line 812 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$meta"};
                     }
-#line 2857 "src/mongo/db/cst/parser_gen.cpp"
+#line 2990 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 148:
-#line 754 "src/mongo/db/cst/grammar.yy"
+                    case 161:
+#line 815 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$regexFind"};
                     }
-#line 2865 "src/mongo/db/cst/parser_gen.cpp"
+#line 2998 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 149:
-#line 757 "src/mongo/db/cst/grammar.yy"
+                    case 162:
+#line 818 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$regexFindAll"};
                     }
-#line 2873 "src/mongo/db/cst/parser_gen.cpp"
+#line 3006 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 150:
-#line 760 "src/mongo/db/cst/grammar.yy"
+                    case 163:
+#line 821 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$regexMatch"};
                     }
-#line 2881 "src/mongo/db/cst/parser_gen.cpp"
+#line 3014 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 151:
-#line 763 "src/mongo/db/cst/grammar.yy"
+                    case 164:
+#line 824 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$replaceOne"};
                     }
-#line 2889 "src/mongo/db/cst/parser_gen.cpp"
+#line 3022 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 152:
-#line 766 "src/mongo/db/cst/grammar.yy"
+                    case 165:
+#line 827 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$replaceAll"};
                     }
-#line 2897 "src/mongo/db/cst/parser_gen.cpp"
+#line 3030 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 153:
-#line 769 "src/mongo/db/cst/grammar.yy"
+                    case 166:
+#line 830 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$rtrim"};
                     }
-#line 2905 "src/mongo/db/cst/parser_gen.cpp"
+#line 3038 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 154:
-#line 772 "src/mongo/db/cst/grammar.yy"
+                    case 167:
+#line 833 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$split"};
                     }
-#line 2913 "src/mongo/db/cst/parser_gen.cpp"
+#line 3046 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 155:
-#line 775 "src/mongo/db/cst/grammar.yy"
+                    case 168:
+#line 836 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$strLenBytes"};
                     }
-#line 2921 "src/mongo/db/cst/parser_gen.cpp"
+#line 3054 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 156:
-#line 778 "src/mongo/db/cst/grammar.yy"
+                    case 169:
+#line 839 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$strLenCP"};
                     }
-#line 2929 "src/mongo/db/cst/parser_gen.cpp"
+#line 3062 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 157:
-#line 781 "src/mongo/db/cst/grammar.yy"
+                    case 170:
+#line 842 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$strcasecmp"};
                     }
-#line 2937 "src/mongo/db/cst/parser_gen.cpp"
+#line 3070 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 158:
-#line 784 "src/mongo/db/cst/grammar.yy"
+                    case 171:
+#line 845 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$substr"};
                     }
-#line 2945 "src/mongo/db/cst/parser_gen.cpp"
+#line 3078 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 159:
-#line 787 "src/mongo/db/cst/grammar.yy"
+                    case 172:
+#line 848 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$substrBytes"};
                     }
-#line 2953 "src/mongo/db/cst/parser_gen.cpp"
+#line 3086 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 160:
-#line 790 "src/mongo/db/cst/grammar.yy"
+                    case 173:
+#line 851 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$substrCP"};
                     }
-#line 2961 "src/mongo/db/cst/parser_gen.cpp"
+#line 3094 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 161:
-#line 793 "src/mongo/db/cst/grammar.yy"
+                    case 174:
+#line 854 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toLower"};
                     }
-#line 2969 "src/mongo/db/cst/parser_gen.cpp"
+#line 3102 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 162:
-#line 796 "src/mongo/db/cst/grammar.yy"
+                    case 175:
+#line 857 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$trim"};
                     }
-#line 2977 "src/mongo/db/cst/parser_gen.cpp"
+#line 3110 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 163:
-#line 799 "src/mongo/db/cst/grammar.yy"
+                    case 176:
+#line 860 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"$toUpper"};
                     }
-#line 2985 "src/mongo/db/cst/parser_gen.cpp"
+#line 3118 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 164:
-#line 806 "src/mongo/db/cst/grammar.yy"
+                    case 177:
+#line 867 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserString{YY_MOVE(yystack_[0].value.as<std::string>())}};
                     }
-#line 2993 "src/mongo/db/cst/parser_gen.cpp"
+#line 3126 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 165:
-#line 811 "src/mongo/db/cst/grammar.yy"
+                    case 178:
+#line 872 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserString{"randVal"}};
                     }
-#line 3001 "src/mongo/db/cst/parser_gen.cpp"
+#line 3134 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 166:
-#line 814 "src/mongo/db/cst/grammar.yy"
+                    case 179:
+#line 875 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserString{"textScore"}};
                     }
-#line 3009 "src/mongo/db/cst/parser_gen.cpp"
+#line 3142 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 167:
-#line 820 "src/mongo/db/cst/grammar.yy"
+                    case 180:
+#line 881 "src/mongo/db/cst/grammar.yy"
                     {
                         std::string str = YY_MOVE(yystack_[0].value.as<std::string>());
                         if (str.size() == 1) {
@@ -3048,11 +3198,11 @@ int ParserGen::parse() {
                         }
                         yylhs.value.as<CNode>() = CNode{UserFieldPath{str.substr(1), false}};
                     }
-#line 3021 "src/mongo/db/cst/parser_gen.cpp"
+#line 3154 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 168:
-#line 828 "src/mongo/db/cst/grammar.yy"
+                    case 181:
+#line 889 "src/mongo/db/cst/grammar.yy"
                     {
                         std::string str = YY_MOVE(yystack_[0].value.as<std::string>()).substr(2);
                         auto status = c_node_validation::validateVariableName(str);
@@ -3061,879 +3211,879 @@ int ParserGen::parse() {
                         }
                         yylhs.value.as<CNode>() = CNode{UserFieldPath{str, true}};
                     }
-#line 3034 "src/mongo/db/cst/parser_gen.cpp"
+#line 3167 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 169:
-#line 837 "src/mongo/db/cst/grammar.yy"
+                    case 182:
+#line 898 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserBinary{YY_MOVE(yystack_[0].value.as<BSONBinData>())}};
                     }
-#line 3042 "src/mongo/db/cst/parser_gen.cpp"
+#line 3175 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 170:
-#line 843 "src/mongo/db/cst/grammar.yy"
+                    case 183:
+#line 904 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserUndefined{}};
                     }
-#line 3050 "src/mongo/db/cst/parser_gen.cpp"
+#line 3183 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 171:
-#line 849 "src/mongo/db/cst/grammar.yy"
+                    case 184:
+#line 910 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserObjectId{}};
                     }
-#line 3058 "src/mongo/db/cst/parser_gen.cpp"
+#line 3191 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 172:
-#line 855 "src/mongo/db/cst/grammar.yy"
+                    case 185:
+#line 916 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserDate{YY_MOVE(yystack_[0].value.as<Date_t>())}};
                     }
-#line 3066 "src/mongo/db/cst/parser_gen.cpp"
+#line 3199 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 173:
-#line 861 "src/mongo/db/cst/grammar.yy"
+                    case 186:
+#line 922 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserNull{}};
                     }
-#line 3074 "src/mongo/db/cst/parser_gen.cpp"
+#line 3207 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 174:
-#line 867 "src/mongo/db/cst/grammar.yy"
+                    case 187:
+#line 928 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserRegex{YY_MOVE(yystack_[0].value.as<BSONRegEx>())}};
                     }
-#line 3082 "src/mongo/db/cst/parser_gen.cpp"
+#line 3215 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 175:
-#line 873 "src/mongo/db/cst/grammar.yy"
+                    case 188:
+#line 934 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserDBPointer{YY_MOVE(yystack_[0].value.as<BSONDBRef>())}};
                     }
-#line 3090 "src/mongo/db/cst/parser_gen.cpp"
+#line 3223 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 176:
-#line 879 "src/mongo/db/cst/grammar.yy"
+                    case 189:
+#line 940 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserJavascript{YY_MOVE(yystack_[0].value.as<BSONCode>())}};
                     }
-#line 3098 "src/mongo/db/cst/parser_gen.cpp"
+#line 3231 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 177:
-#line 885 "src/mongo/db/cst/grammar.yy"
+                    case 190:
+#line 946 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserSymbol{YY_MOVE(yystack_[0].value.as<BSONSymbol>())}};
                     }
-#line 3106 "src/mongo/db/cst/parser_gen.cpp"
+#line 3239 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 178:
-#line 891 "src/mongo/db/cst/grammar.yy"
+                    case 191:
+#line 952 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserJavascriptWithScope{
                             YY_MOVE(yystack_[0].value.as<BSONCodeWScope>())}};
                     }
-#line 3114 "src/mongo/db/cst/parser_gen.cpp"
+#line 3247 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 179:
-#line 897 "src/mongo/db/cst/grammar.yy"
+                    case 192:
+#line 958 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserTimestamp{YY_MOVE(yystack_[0].value.as<Timestamp>())}};
                     }
-#line 3122 "src/mongo/db/cst/parser_gen.cpp"
+#line 3255 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 180:
-#line 903 "src/mongo/db/cst/grammar.yy"
+                    case 193:
+#line 964 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserMinKey{YY_MOVE(yystack_[0].value.as<UserMinKey>())}};
                     }
-#line 3130 "src/mongo/db/cst/parser_gen.cpp"
+#line 3263 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 181:
-#line 909 "src/mongo/db/cst/grammar.yy"
+                    case 194:
+#line 970 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserMaxKey{YY_MOVE(yystack_[0].value.as<UserMaxKey>())}};
                     }
-#line 3138 "src/mongo/db/cst/parser_gen.cpp"
+#line 3271 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 182:
-#line 915 "src/mongo/db/cst/grammar.yy"
+                    case 195:
+#line 976 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserInt{YY_MOVE(yystack_[0].value.as<int>())}};
                     }
-#line 3146 "src/mongo/db/cst/parser_gen.cpp"
+#line 3279 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 183:
-#line 918 "src/mongo/db/cst/grammar.yy"
+                    case 196:
+#line 979 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserInt{0}};
                     }
-#line 3154 "src/mongo/db/cst/parser_gen.cpp"
+#line 3287 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 184:
-#line 921 "src/mongo/db/cst/grammar.yy"
+                    case 197:
+#line 982 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserInt{1}};
                     }
-#line 3162 "src/mongo/db/cst/parser_gen.cpp"
+#line 3295 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 185:
-#line 924 "src/mongo/db/cst/grammar.yy"
+                    case 198:
+#line 985 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserInt{-1}};
                     }
-#line 3170 "src/mongo/db/cst/parser_gen.cpp"
+#line 3303 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 186:
-#line 930 "src/mongo/db/cst/grammar.yy"
+                    case 199:
+#line 991 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserLong{YY_MOVE(yystack_[0].value.as<long long>())}};
                     }
-#line 3178 "src/mongo/db/cst/parser_gen.cpp"
+#line 3311 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 187:
-#line 933 "src/mongo/db/cst/grammar.yy"
+                    case 200:
+#line 994 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserLong{0ll}};
                     }
-#line 3186 "src/mongo/db/cst/parser_gen.cpp"
+#line 3319 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 188:
-#line 936 "src/mongo/db/cst/grammar.yy"
+                    case 201:
+#line 997 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserLong{1ll}};
                     }
-#line 3194 "src/mongo/db/cst/parser_gen.cpp"
+#line 3327 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 189:
-#line 939 "src/mongo/db/cst/grammar.yy"
+                    case 202:
+#line 1000 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserLong{-1ll}};
                     }
-#line 3202 "src/mongo/db/cst/parser_gen.cpp"
+#line 3335 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 190:
-#line 945 "src/mongo/db/cst/grammar.yy"
+                    case 203:
+#line 1006 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserDouble{YY_MOVE(yystack_[0].value.as<double>())}};
                     }
-#line 3210 "src/mongo/db/cst/parser_gen.cpp"
+#line 3343 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 191:
-#line 948 "src/mongo/db/cst/grammar.yy"
+                    case 204:
+#line 1009 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserDouble{0.0}};
                     }
-#line 3218 "src/mongo/db/cst/parser_gen.cpp"
+#line 3351 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 192:
-#line 951 "src/mongo/db/cst/grammar.yy"
+                    case 205:
+#line 1012 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserDouble{1.0}};
                     }
-#line 3226 "src/mongo/db/cst/parser_gen.cpp"
+#line 3359 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 193:
-#line 954 "src/mongo/db/cst/grammar.yy"
+                    case 206:
+#line 1015 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserDouble{-1.0}};
                     }
-#line 3234 "src/mongo/db/cst/parser_gen.cpp"
+#line 3367 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 194:
-#line 960 "src/mongo/db/cst/grammar.yy"
+                    case 207:
+#line 1021 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{UserDecimal{YY_MOVE(yystack_[0].value.as<Decimal128>())}};
                     }
-#line 3242 "src/mongo/db/cst/parser_gen.cpp"
+#line 3375 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 195:
-#line 963 "src/mongo/db/cst/grammar.yy"
+                    case 208:
+#line 1024 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserDecimal{0.0}};
                     }
-#line 3250 "src/mongo/db/cst/parser_gen.cpp"
+#line 3383 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 196:
-#line 966 "src/mongo/db/cst/grammar.yy"
+                    case 209:
+#line 1027 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserDecimal{1.0}};
                     }
-#line 3258 "src/mongo/db/cst/parser_gen.cpp"
+#line 3391 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 197:
-#line 969 "src/mongo/db/cst/grammar.yy"
+                    case 210:
+#line 1030 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserDecimal{-1.0}};
                     }
-#line 3266 "src/mongo/db/cst/parser_gen.cpp"
+#line 3399 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 198:
-#line 975 "src/mongo/db/cst/grammar.yy"
+                    case 211:
+#line 1036 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserBoolean{true}};
                     }
-#line 3274 "src/mongo/db/cst/parser_gen.cpp"
+#line 3407 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 199:
-#line 978 "src/mongo/db/cst/grammar.yy"
+                    case 212:
+#line 1039 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{UserBoolean{false}};
                     }
-#line 3282 "src/mongo/db/cst/parser_gen.cpp"
+#line 3415 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 200:
-#line 984 "src/mongo/db/cst/grammar.yy"
+                    case 213:
+#line 1045 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3288 "src/mongo/db/cst/parser_gen.cpp"
+#line 3421 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 201:
-#line 985 "src/mongo/db/cst/grammar.yy"
+                    case 214:
+#line 1046 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3294 "src/mongo/db/cst/parser_gen.cpp"
+#line 3427 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 202:
-#line 986 "src/mongo/db/cst/grammar.yy"
+                    case 215:
+#line 1047 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3300 "src/mongo/db/cst/parser_gen.cpp"
+#line 3433 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 203:
-#line 987 "src/mongo/db/cst/grammar.yy"
+                    case 216:
+#line 1048 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3306 "src/mongo/db/cst/parser_gen.cpp"
+#line 3439 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 204:
-#line 988 "src/mongo/db/cst/grammar.yy"
+                    case 217:
+#line 1049 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3312 "src/mongo/db/cst/parser_gen.cpp"
+#line 3445 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 205:
-#line 989 "src/mongo/db/cst/grammar.yy"
+                    case 218:
+#line 1050 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3318 "src/mongo/db/cst/parser_gen.cpp"
+#line 3451 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 206:
-#line 990 "src/mongo/db/cst/grammar.yy"
+                    case 219:
+#line 1051 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3324 "src/mongo/db/cst/parser_gen.cpp"
+#line 3457 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 207:
-#line 991 "src/mongo/db/cst/grammar.yy"
+                    case 220:
+#line 1052 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3330 "src/mongo/db/cst/parser_gen.cpp"
+#line 3463 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 208:
-#line 992 "src/mongo/db/cst/grammar.yy"
+                    case 221:
+#line 1053 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3336 "src/mongo/db/cst/parser_gen.cpp"
+#line 3469 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 209:
-#line 993 "src/mongo/db/cst/grammar.yy"
+                    case 222:
+#line 1054 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3342 "src/mongo/db/cst/parser_gen.cpp"
+#line 3475 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 210:
-#line 994 "src/mongo/db/cst/grammar.yy"
+                    case 223:
+#line 1055 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3348 "src/mongo/db/cst/parser_gen.cpp"
+#line 3481 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 211:
-#line 995 "src/mongo/db/cst/grammar.yy"
+                    case 224:
+#line 1056 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3354 "src/mongo/db/cst/parser_gen.cpp"
+#line 3487 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 212:
-#line 996 "src/mongo/db/cst/grammar.yy"
+                    case 225:
+#line 1057 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3360 "src/mongo/db/cst/parser_gen.cpp"
+#line 3493 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 213:
-#line 997 "src/mongo/db/cst/grammar.yy"
+                    case 226:
+#line 1058 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3366 "src/mongo/db/cst/parser_gen.cpp"
+#line 3499 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 214:
-#line 998 "src/mongo/db/cst/grammar.yy"
+                    case 227:
+#line 1059 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3372 "src/mongo/db/cst/parser_gen.cpp"
+#line 3505 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 215:
-#line 999 "src/mongo/db/cst/grammar.yy"
+                    case 228:
+#line 1060 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3378 "src/mongo/db/cst/parser_gen.cpp"
+#line 3511 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 216:
-#line 1000 "src/mongo/db/cst/grammar.yy"
+                    case 229:
+#line 1061 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3384 "src/mongo/db/cst/parser_gen.cpp"
+#line 3517 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 217:
-#line 1001 "src/mongo/db/cst/grammar.yy"
+                    case 230:
+#line 1062 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3390 "src/mongo/db/cst/parser_gen.cpp"
+#line 3523 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 218:
-#line 1002 "src/mongo/db/cst/grammar.yy"
+                    case 231:
+#line 1063 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3396 "src/mongo/db/cst/parser_gen.cpp"
+#line 3529 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 219:
-#line 1003 "src/mongo/db/cst/grammar.yy"
+                    case 232:
+#line 1064 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3402 "src/mongo/db/cst/parser_gen.cpp"
+#line 3535 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 220:
-#line 1004 "src/mongo/db/cst/grammar.yy"
+                    case 233:
+#line 1065 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3408 "src/mongo/db/cst/parser_gen.cpp"
+#line 3541 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 221:
-#line 1011 "src/mongo/db/cst/grammar.yy"
+                    case 234:
+#line 1072 "src/mongo/db/cst/grammar.yy"
                     {
                     }
-#line 3414 "src/mongo/db/cst/parser_gen.cpp"
+#line 3547 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 222:
-#line 1012 "src/mongo/db/cst/grammar.yy"
+                    case 235:
+#line 1073 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::vector<CNode>>() =
                             YY_MOVE(yystack_[0].value.as<std::vector<CNode>>());
                         yylhs.value.as<std::vector<CNode>>().emplace_back(
                             YY_MOVE(yystack_[1].value.as<CNode>()));
                     }
-#line 3423 "src/mongo/db/cst/parser_gen.cpp"
+#line 3556 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 223:
-#line 1019 "src/mongo/db/cst/grammar.yy"
+                    case 236:
+#line 1080 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3429 "src/mongo/db/cst/parser_gen.cpp"
+#line 3562 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 224:
-#line 1019 "src/mongo/db/cst/grammar.yy"
+                    case 237:
+#line 1080 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3435 "src/mongo/db/cst/parser_gen.cpp"
+#line 3568 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 225:
-#line 1023 "src/mongo/db/cst/grammar.yy"
+                    case 238:
+#line 1084 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{CNode::ArrayChildren{YY_MOVE(yystack_[2].value.as<CNode>()),
                                                        YY_MOVE(yystack_[1].value.as<CNode>())}};
                     }
-#line 3443 "src/mongo/db/cst/parser_gen.cpp"
+#line 3576 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 226:
-#line 1028 "src/mongo/db/cst/grammar.yy"
+                    case 239:
+#line 1089 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3449 "src/mongo/db/cst/parser_gen.cpp"
+#line 3582 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 227:
-#line 1028 "src/mongo/db/cst/grammar.yy"
+                    case 240:
+#line 1089 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3455 "src/mongo/db/cst/parser_gen.cpp"
+#line 3588 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 228:
-#line 1028 "src/mongo/db/cst/grammar.yy"
+                    case 241:
+#line 1089 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3461 "src/mongo/db/cst/parser_gen.cpp"
+#line 3594 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 229:
-#line 1028 "src/mongo/db/cst/grammar.yy"
+                    case 242:
+#line 1089 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3467 "src/mongo/db/cst/parser_gen.cpp"
+#line 3600 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 230:
-#line 1028 "src/mongo/db/cst/grammar.yy"
+                    case 243:
+#line 1089 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3473 "src/mongo/db/cst/parser_gen.cpp"
+#line 3606 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 231:
-#line 1028 "src/mongo/db/cst/grammar.yy"
+                    case 244:
+#line 1089 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3479 "src/mongo/db/cst/parser_gen.cpp"
+#line 3612 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 232:
-#line 1029 "src/mongo/db/cst/grammar.yy"
+                    case 245:
+#line 1090 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3485 "src/mongo/db/cst/parser_gen.cpp"
+#line 3618 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 233:
-#line 1029 "src/mongo/db/cst/grammar.yy"
+                    case 246:
+#line 1090 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3491 "src/mongo/db/cst/parser_gen.cpp"
+#line 3624 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 234:
-#line 1035 "src/mongo/db/cst/grammar.yy"
+                    case 247:
+#line 1096 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{YY_MOVE(yystack_[1].value.as<std::vector<CNode>>())};
                     }
-#line 3499 "src/mongo/db/cst/parser_gen.cpp"
+#line 3632 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 235:
-#line 1043 "src/mongo/db/cst/grammar.yy"
+                    case 248:
+#line 1104 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                     }
-#line 3507 "src/mongo/db/cst/parser_gen.cpp"
+#line 3640 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 236:
-#line 1049 "src/mongo/db/cst/grammar.yy"
+                    case 249:
+#line 1110 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode::noopLeaf();
                     }
-#line 3515 "src/mongo/db/cst/parser_gen.cpp"
+#line 3648 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 237:
-#line 1052 "src/mongo/db/cst/grammar.yy"
+                    case 250:
+#line 1113 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                         yylhs.value.as<CNode>().objectChildren().emplace_back(
                             YY_MOVE(yystack_[0].value.as<std::pair<CNode::Fieldname, CNode>>()));
                     }
-#line 3524 "src/mongo/db/cst/parser_gen.cpp"
+#line 3657 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 238:
-#line 1059 "src/mongo/db/cst/grammar.yy"
+                    case 251:
+#line 1120 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = {
                             YY_MOVE(yystack_[1].value.as<CNode::Fieldname>()),
                             YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 3532 "src/mongo/db/cst/parser_gen.cpp"
+#line 3665 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 239:
-#line 1066 "src/mongo/db/cst/grammar.yy"
+                    case 252:
+#line 1127 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 3538 "src/mongo/db/cst/parser_gen.cpp"
+#line 3671 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 240:
-#line 1066 "src/mongo/db/cst/grammar.yy"
+                    case 253:
+#line 1127 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 3544 "src/mongo/db/cst/parser_gen.cpp"
+#line 3677 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 241:
-#line 1066 "src/mongo/db/cst/grammar.yy"
+                    case 254:
+#line 1127 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 3550 "src/mongo/db/cst/parser_gen.cpp"
+#line 3683 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 242:
-#line 1066 "src/mongo/db/cst/grammar.yy"
+                    case 255:
+#line 1127 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 3556 "src/mongo/db/cst/parser_gen.cpp"
+#line 3689 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 243:
-#line 1070 "src/mongo/db/cst/grammar.yy"
+                    case 256:
+#line 1131 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() = UserFieldname{"_id"};
                     }
-#line 3564 "src/mongo/db/cst/parser_gen.cpp"
+#line 3697 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 244:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 257:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3570 "src/mongo/db/cst/parser_gen.cpp"
+#line 3703 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 245:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 258:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3576 "src/mongo/db/cst/parser_gen.cpp"
+#line 3709 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 246:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 259:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3582 "src/mongo/db/cst/parser_gen.cpp"
+#line 3715 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 247:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 260:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3588 "src/mongo/db/cst/parser_gen.cpp"
+#line 3721 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 248:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 261:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3594 "src/mongo/db/cst/parser_gen.cpp"
+#line 3727 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 249:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 262:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3600 "src/mongo/db/cst/parser_gen.cpp"
+#line 3733 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 250:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 263:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3606 "src/mongo/db/cst/parser_gen.cpp"
+#line 3739 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 251:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 264:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3612 "src/mongo/db/cst/parser_gen.cpp"
+#line 3745 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 252:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 265:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3618 "src/mongo/db/cst/parser_gen.cpp"
+#line 3751 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 253:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 266:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3624 "src/mongo/db/cst/parser_gen.cpp"
+#line 3757 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 254:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 267:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3630 "src/mongo/db/cst/parser_gen.cpp"
+#line 3763 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 255:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 268:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3636 "src/mongo/db/cst/parser_gen.cpp"
+#line 3769 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 256:
-#line 1076 "src/mongo/db/cst/grammar.yy"
+                    case 269:
+#line 1137 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3642 "src/mongo/db/cst/parser_gen.cpp"
+#line 3775 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 257:
-#line 1077 "src/mongo/db/cst/grammar.yy"
+                    case 270:
+#line 1138 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3648 "src/mongo/db/cst/parser_gen.cpp"
+#line 3781 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 258:
-#line 1077 "src/mongo/db/cst/grammar.yy"
+                    case 271:
+#line 1138 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3654 "src/mongo/db/cst/parser_gen.cpp"
+#line 3787 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 259:
-#line 1077 "src/mongo/db/cst/grammar.yy"
+                    case 272:
+#line 1138 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3660 "src/mongo/db/cst/parser_gen.cpp"
+#line 3793 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 260:
-#line 1077 "src/mongo/db/cst/grammar.yy"
+                    case 273:
+#line 1138 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3666 "src/mongo/db/cst/parser_gen.cpp"
+#line 3799 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 261:
-#line 1081 "src/mongo/db/cst/grammar.yy"
+                    case 274:
+#line 1142 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::add, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3675 "src/mongo/db/cst/parser_gen.cpp"
+#line 3808 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 262:
-#line 1088 "src/mongo/db/cst/grammar.yy"
+                    case 275:
+#line 1149 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::atan2, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3684 "src/mongo/db/cst/parser_gen.cpp"
+#line 3817 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 263:
-#line 1094 "src/mongo/db/cst/grammar.yy"
+                    case 276:
+#line 1155 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::abs, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3692 "src/mongo/db/cst/parser_gen.cpp"
+#line 3825 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 264:
-#line 1099 "src/mongo/db/cst/grammar.yy"
+                    case 277:
+#line 1160 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::ceil, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3700 "src/mongo/db/cst/parser_gen.cpp"
+#line 3833 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 265:
-#line 1104 "src/mongo/db/cst/grammar.yy"
+                    case 278:
+#line 1165 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::divide,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 3709 "src/mongo/db/cst/parser_gen.cpp"
+#line 3842 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 266:
-#line 1110 "src/mongo/db/cst/grammar.yy"
+                    case 279:
+#line 1171 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::exponent, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3717 "src/mongo/db/cst/parser_gen.cpp"
+#line 3850 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 267:
-#line 1115 "src/mongo/db/cst/grammar.yy"
+                    case 280:
+#line 1176 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::floor, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3725 "src/mongo/db/cst/parser_gen.cpp"
+#line 3858 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 268:
-#line 1120 "src/mongo/db/cst/grammar.yy"
+                    case 281:
+#line 1181 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::ln, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3733 "src/mongo/db/cst/parser_gen.cpp"
+#line 3866 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 269:
-#line 1125 "src/mongo/db/cst/grammar.yy"
+                    case 282:
+#line 1186 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::log,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 3742 "src/mongo/db/cst/parser_gen.cpp"
+#line 3875 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 270:
-#line 1131 "src/mongo/db/cst/grammar.yy"
+                    case 283:
+#line 1192 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::logten, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3750 "src/mongo/db/cst/parser_gen.cpp"
+#line 3883 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 271:
-#line 1136 "src/mongo/db/cst/grammar.yy"
+                    case 284:
+#line 1197 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::mod,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 3759 "src/mongo/db/cst/parser_gen.cpp"
+#line 3892 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 272:
-#line 1142 "src/mongo/db/cst/grammar.yy"
+                    case 285:
+#line 1203 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::multiply,
@@ -3944,292 +4094,292 @@ int ParserGen::parse() {
                             yylhs.value.as<CNode>().objectChildren()[0].second.arrayChildren();
                         array.insert(array.end(), others.begin(), others.end());
                     }
-#line 3771 "src/mongo/db/cst/parser_gen.cpp"
+#line 3904 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 273:
-#line 1151 "src/mongo/db/cst/grammar.yy"
+                    case 286:
+#line 1212 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::pow,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 3780 "src/mongo/db/cst/parser_gen.cpp"
+#line 3913 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 274:
-#line 1157 "src/mongo/db/cst/grammar.yy"
+                    case 287:
+#line 1218 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::round,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 3789 "src/mongo/db/cst/parser_gen.cpp"
+#line 3922 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 275:
-#line 1163 "src/mongo/db/cst/grammar.yy"
+                    case 288:
+#line 1224 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::sqrt, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3797 "src/mongo/db/cst/parser_gen.cpp"
+#line 3930 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 276:
-#line 1168 "src/mongo/db/cst/grammar.yy"
+                    case 289:
+#line 1229 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::subtract,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 3806 "src/mongo/db/cst/parser_gen.cpp"
+#line 3939 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 277:
-#line 1174 "src/mongo/db/cst/grammar.yy"
+                    case 290:
+#line 1235 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::trunc,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 3815 "src/mongo/db/cst/parser_gen.cpp"
+#line 3948 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 278:
-#line 1180 "src/mongo/db/cst/grammar.yy"
+                    case 291:
+#line 1241 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3821 "src/mongo/db/cst/parser_gen.cpp"
+#line 3954 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 279:
-#line 1180 "src/mongo/db/cst/grammar.yy"
+                    case 292:
+#line 1241 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3827 "src/mongo/db/cst/parser_gen.cpp"
+#line 3960 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 280:
-#line 1180 "src/mongo/db/cst/grammar.yy"
+                    case 293:
+#line 1241 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3833 "src/mongo/db/cst/parser_gen.cpp"
+#line 3966 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 281:
-#line 1184 "src/mongo/db/cst/grammar.yy"
+                    case 294:
+#line 1245 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::andExpr, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3842 "src/mongo/db/cst/parser_gen.cpp"
+#line 3975 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 282:
-#line 1191 "src/mongo/db/cst/grammar.yy"
+                    case 295:
+#line 1252 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::orExpr, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 3851 "src/mongo/db/cst/parser_gen.cpp"
+#line 3984 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 283:
-#line 1198 "src/mongo/db/cst/grammar.yy"
+                    case 296:
+#line 1259 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::notExpr,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 3860 "src/mongo/db/cst/parser_gen.cpp"
+#line 3993 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 284:
-#line 1205 "src/mongo/db/cst/grammar.yy"
+                    case 297:
+#line 1266 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3866 "src/mongo/db/cst/parser_gen.cpp"
+#line 3999 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 285:
-#line 1205 "src/mongo/db/cst/grammar.yy"
+                    case 298:
+#line 1266 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3872 "src/mongo/db/cst/parser_gen.cpp"
+#line 4005 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 286:
-#line 1205 "src/mongo/db/cst/grammar.yy"
+                    case 299:
+#line 1266 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3878 "src/mongo/db/cst/parser_gen.cpp"
+#line 4011 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 287:
-#line 1205 "src/mongo/db/cst/grammar.yy"
+                    case 300:
+#line 1266 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3884 "src/mongo/db/cst/parser_gen.cpp"
+#line 4017 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 288:
-#line 1205 "src/mongo/db/cst/grammar.yy"
+                    case 301:
+#line 1266 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3890 "src/mongo/db/cst/parser_gen.cpp"
+#line 4023 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 289:
-#line 1205 "src/mongo/db/cst/grammar.yy"
+                    case 302:
+#line 1266 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3896 "src/mongo/db/cst/parser_gen.cpp"
+#line 4029 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 290:
-#line 1205 "src/mongo/db/cst/grammar.yy"
+                    case 303:
+#line 1266 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3902 "src/mongo/db/cst/parser_gen.cpp"
+#line 4035 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 291:
-#line 1206 "src/mongo/db/cst/grammar.yy"
+                    case 304:
+#line 1267 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3908 "src/mongo/db/cst/parser_gen.cpp"
+#line 4041 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 292:
-#line 1206 "src/mongo/db/cst/grammar.yy"
+                    case 305:
+#line 1267 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3914 "src/mongo/db/cst/parser_gen.cpp"
+#line 4047 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 293:
-#line 1206 "src/mongo/db/cst/grammar.yy"
+                    case 306:
+#line 1267 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3920 "src/mongo/db/cst/parser_gen.cpp"
+#line 4053 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 294:
-#line 1206 "src/mongo/db/cst/grammar.yy"
+                    case 307:
+#line 1267 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3926 "src/mongo/db/cst/parser_gen.cpp"
+#line 4059 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 295:
-#line 1206 "src/mongo/db/cst/grammar.yy"
+                    case 308:
+#line 1267 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3932 "src/mongo/db/cst/parser_gen.cpp"
+#line 4065 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 296:
-#line 1206 "src/mongo/db/cst/grammar.yy"
+                    case 309:
+#line 1267 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3938 "src/mongo/db/cst/parser_gen.cpp"
+#line 4071 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 297:
-#line 1206 "src/mongo/db/cst/grammar.yy"
+                    case 310:
+#line 1267 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3944 "src/mongo/db/cst/parser_gen.cpp"
+#line 4077 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 298:
-#line 1206 "src/mongo/db/cst/grammar.yy"
+                    case 311:
+#line 1267 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3950 "src/mongo/db/cst/parser_gen.cpp"
+#line 4083 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 299:
-#line 1207 "src/mongo/db/cst/grammar.yy"
+                    case 312:
+#line 1268 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3956 "src/mongo/db/cst/parser_gen.cpp"
+#line 4089 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 300:
-#line 1207 "src/mongo/db/cst/grammar.yy"
+                    case 313:
+#line 1268 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3962 "src/mongo/db/cst/parser_gen.cpp"
+#line 4095 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 301:
-#line 1207 "src/mongo/db/cst/grammar.yy"
+                    case 314:
+#line 1268 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3968 "src/mongo/db/cst/parser_gen.cpp"
+#line 4101 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 302:
-#line 1207 "src/mongo/db/cst/grammar.yy"
+                    case 315:
+#line 1268 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3974 "src/mongo/db/cst/parser_gen.cpp"
+#line 4107 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 303:
-#line 1207 "src/mongo/db/cst/grammar.yy"
+                    case 316:
+#line 1268 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3980 "src/mongo/db/cst/parser_gen.cpp"
+#line 4113 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 304:
-#line 1207 "src/mongo/db/cst/grammar.yy"
+                    case 317:
+#line 1268 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3986 "src/mongo/db/cst/parser_gen.cpp"
+#line 4119 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 305:
-#line 1207 "src/mongo/db/cst/grammar.yy"
+                    case 318:
+#line 1268 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 3992 "src/mongo/db/cst/parser_gen.cpp"
+#line 4125 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 306:
-#line 1211 "src/mongo/db/cst/grammar.yy"
+                    case 319:
+#line 1272 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::concat, CNode{CNode::ArrayChildren{}}}}};
@@ -4238,47 +4388,47 @@ int ParserGen::parse() {
                             yylhs.value.as<CNode>().objectChildren()[0].second.arrayChildren();
                         array.insert(array.end(), others.begin(), others.end());
                     }
-#line 4004 "src/mongo/db/cst/parser_gen.cpp"
+#line 4137 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 307:
-#line 1221 "src/mongo/db/cst/grammar.yy"
+                    case 320:
+#line 1282 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
                             std::pair{KeyFieldname::formatArg, CNode{KeyValue::absentKey}};
                     }
-#line 4012 "src/mongo/db/cst/parser_gen.cpp"
+#line 4145 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 308:
-#line 1224 "src/mongo/db/cst/grammar.yy"
+                    case 321:
+#line 1285 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = std::pair{
                             KeyFieldname::formatArg, YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4020 "src/mongo/db/cst/parser_gen.cpp"
+#line 4153 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 309:
-#line 1230 "src/mongo/db/cst/grammar.yy"
+                    case 322:
+#line 1291 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
                             std::pair{KeyFieldname::timezoneArg, CNode{KeyValue::absentKey}};
                     }
-#line 4028 "src/mongo/db/cst/parser_gen.cpp"
+#line 4161 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 310:
-#line 1233 "src/mongo/db/cst/grammar.yy"
+                    case 323:
+#line 1294 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = std::pair{
                             KeyFieldname::timezoneArg, YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4036 "src/mongo/db/cst/parser_gen.cpp"
+#line 4169 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 311:
-#line 1240 "src/mongo/db/cst/grammar.yy"
+                    case 324:
+#line 1301 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::dateFromString,
@@ -4294,11 +4444,11 @@ int ParserGen::parse() {
                                  YY_MOVE(yystack_[2]
                                              .value.as<std::pair<CNode::Fieldname, CNode>>())}}}}};
                     }
-#line 4046 "src/mongo/db/cst/parser_gen.cpp"
+#line 4179 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 312:
-#line 1249 "src/mongo/db/cst/grammar.yy"
+                    case 325:
+#line 1310 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::dateToString,
@@ -4311,38 +4461,38 @@ int ParserGen::parse() {
                                  YY_MOVE(yystack_[2]
                                              .value.as<std::pair<CNode::Fieldname, CNode>>())}}}}};
                     }
-#line 4056 "src/mongo/db/cst/parser_gen.cpp"
+#line 4189 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 313:
-#line 1257 "src/mongo/db/cst/grammar.yy"
+                    case 326:
+#line 1318 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::vector<CNode>>() = CNode::ArrayChildren{};
                     }
-#line 4064 "src/mongo/db/cst/parser_gen.cpp"
+#line 4197 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 314:
-#line 1260 "src/mongo/db/cst/grammar.yy"
+                    case 327:
+#line 1321 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::vector<CNode>>() =
                             CNode::ArrayChildren{YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4072 "src/mongo/db/cst/parser_gen.cpp"
+#line 4205 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 315:
-#line 1263 "src/mongo/db/cst/grammar.yy"
+                    case 328:
+#line 1324 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::vector<CNode>>() =
                             CNode::ArrayChildren{YY_MOVE(yystack_[1].value.as<CNode>()),
                                                  YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4080 "src/mongo/db/cst/parser_gen.cpp"
+#line 4213 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 316:
-#line 1270 "src/mongo/db/cst/grammar.yy"
+                    case 329:
+#line 1331 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::indexOfBytes,
@@ -4353,11 +4503,11 @@ int ParserGen::parse() {
                             yylhs.value.as<CNode>().objectChildren()[0].second.arrayChildren();
                         array.insert(array.end(), others.begin(), others.end());
                     }
-#line 4092 "src/mongo/db/cst/parser_gen.cpp"
+#line 4225 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 317:
-#line 1281 "src/mongo/db/cst/grammar.yy"
+                    case 330:
+#line 1342 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::indexOfCP,
@@ -4368,29 +4518,29 @@ int ParserGen::parse() {
                             yylhs.value.as<CNode>().objectChildren()[0].second.arrayChildren();
                         array.insert(array.end(), others.begin(), others.end());
                     }
-#line 4104 "src/mongo/db/cst/parser_gen.cpp"
+#line 4237 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 318:
-#line 1291 "src/mongo/db/cst/grammar.yy"
+                    case 331:
+#line 1352 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
                             std::pair{KeyFieldname::charsArg, CNode{KeyValue::absentKey}};
                     }
-#line 4112 "src/mongo/db/cst/parser_gen.cpp"
+#line 4245 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 319:
-#line 1294 "src/mongo/db/cst/grammar.yy"
+                    case 332:
+#line 1355 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = std::pair{
                             KeyFieldname::charsArg, YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4120 "src/mongo/db/cst/parser_gen.cpp"
+#line 4253 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 320:
-#line 1300 "src/mongo/db/cst/grammar.yy"
+                    case 333:
+#line 1361 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::ltrim,
@@ -4399,11 +4549,11 @@ int ParserGen::parse() {
                                  YY_MOVE(yystack_[4]
                                              .value.as<std::pair<CNode::Fieldname, CNode>>())}}}}};
                     }
-#line 4130 "src/mongo/db/cst/parser_gen.cpp"
+#line 4263 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 321:
-#line 1308 "src/mongo/db/cst/grammar.yy"
+                    case 334:
+#line 1369 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::rtrim,
@@ -4412,11 +4562,11 @@ int ParserGen::parse() {
                                  YY_MOVE(yystack_[4]
                                              .value.as<std::pair<CNode::Fieldname, CNode>>())}}}}};
                     }
-#line 4140 "src/mongo/db/cst/parser_gen.cpp"
+#line 4273 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 322:
-#line 1316 "src/mongo/db/cst/grammar.yy"
+                    case 335:
+#line 1377 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::trim,
@@ -4425,29 +4575,29 @@ int ParserGen::parse() {
                                  YY_MOVE(yystack_[4]
                                              .value.as<std::pair<CNode::Fieldname, CNode>>())}}}}};
                     }
-#line 4150 "src/mongo/db/cst/parser_gen.cpp"
+#line 4283 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 323:
-#line 1324 "src/mongo/db/cst/grammar.yy"
+                    case 336:
+#line 1385 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
                             std::pair{KeyFieldname::optionsArg, CNode{KeyValue::absentKey}};
                     }
-#line 4158 "src/mongo/db/cst/parser_gen.cpp"
+#line 4291 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 324:
-#line 1327 "src/mongo/db/cst/grammar.yy"
+                    case 337:
+#line 1388 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = std::pair{
                             KeyFieldname::optionsArg, YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4166 "src/mongo/db/cst/parser_gen.cpp"
+#line 4299 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 325:
-#line 1332 "src/mongo/db/cst/grammar.yy"
+                    case 338:
+#line 1393 "src/mongo/db/cst/grammar.yy"
                     {
                         // Note that the order of these arguments must match the constructor for the
                         // regex expression.
@@ -4456,38 +4606,38 @@ int ParserGen::parse() {
                             {KeyFieldname::regexArg, YY_MOVE(yystack_[1].value.as<CNode>())},
                             YY_MOVE(yystack_[3].value.as<std::pair<CNode::Fieldname, CNode>>())}};
                     }
-#line 4178 "src/mongo/db/cst/parser_gen.cpp"
+#line 4311 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 326:
-#line 1341 "src/mongo/db/cst/grammar.yy"
+                    case 339:
+#line 1402 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::regexFind, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4186 "src/mongo/db/cst/parser_gen.cpp"
+#line 4319 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 327:
-#line 1347 "src/mongo/db/cst/grammar.yy"
+                    case 340:
+#line 1408 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::regexFindAll, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4194 "src/mongo/db/cst/parser_gen.cpp"
+#line 4327 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 328:
-#line 1353 "src/mongo/db/cst/grammar.yy"
+                    case 341:
+#line 1414 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::regexMatch, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4202 "src/mongo/db/cst/parser_gen.cpp"
+#line 4335 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 329:
-#line 1360 "src/mongo/db/cst/grammar.yy"
+                    case 342:
+#line 1421 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::replaceOne,
@@ -4497,11 +4647,11 @@ int ParserGen::parse() {
                                  {KeyFieldname::replacementArg,
                                   YY_MOVE(yystack_[2].value.as<CNode>())}}}}}};
                     }
-#line 4213 "src/mongo/db/cst/parser_gen.cpp"
+#line 4346 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 330:
-#line 1370 "src/mongo/db/cst/grammar.yy"
+                    case 343:
+#line 1431 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::replaceAll,
@@ -4511,51 +4661,51 @@ int ParserGen::parse() {
                                  {KeyFieldname::replacementArg,
                                   YY_MOVE(yystack_[2].value.as<CNode>())}}}}}};
                     }
-#line 4224 "src/mongo/db/cst/parser_gen.cpp"
+#line 4357 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 331:
-#line 1379 "src/mongo/db/cst/grammar.yy"
+                    case 344:
+#line 1440 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::split,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 4233 "src/mongo/db/cst/parser_gen.cpp"
+#line 4366 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 332:
-#line 1386 "src/mongo/db/cst/grammar.yy"
+                    case 345:
+#line 1447 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::strLenBytes, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4242 "src/mongo/db/cst/parser_gen.cpp"
+#line 4375 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 333:
-#line 1393 "src/mongo/db/cst/grammar.yy"
+                    case 346:
+#line 1454 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::strLenCP, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4251 "src/mongo/db/cst/parser_gen.cpp"
+#line 4384 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 334:
-#line 1401 "src/mongo/db/cst/grammar.yy"
+                    case 347:
+#line 1462 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::strcasecmp,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 4260 "src/mongo/db/cst/parser_gen.cpp"
+#line 4393 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 335:
-#line 1409 "src/mongo/db/cst/grammar.yy"
+                    case 348:
+#line 1470 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::substr,
@@ -4563,11 +4713,11 @@ int ParserGen::parse() {
                                                         YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 4269 "src/mongo/db/cst/parser_gen.cpp"
+#line 4402 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 336:
-#line 1417 "src/mongo/db/cst/grammar.yy"
+                    case 349:
+#line 1478 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::substrBytes,
@@ -4575,11 +4725,11 @@ int ParserGen::parse() {
                                                         YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 4278 "src/mongo/db/cst/parser_gen.cpp"
+#line 4411 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 337:
-#line 1425 "src/mongo/db/cst/grammar.yy"
+                    case 350:
+#line 1486 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::substrCP,
@@ -4587,575 +4737,575 @@ int ParserGen::parse() {
                                                         YY_MOVE(yystack_[3].value.as<CNode>()),
                                                         YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 4287 "src/mongo/db/cst/parser_gen.cpp"
+#line 4420 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 338:
-#line 1432 "src/mongo/db/cst/grammar.yy"
+                    case 351:
+#line 1493 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toLower, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4295 "src/mongo/db/cst/parser_gen.cpp"
+#line 4428 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 339:
-#line 1438 "src/mongo/db/cst/grammar.yy"
+                    case 352:
+#line 1499 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toUpper, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4303 "src/mongo/db/cst/parser_gen.cpp"
+#line 4436 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 340:
-#line 1444 "src/mongo/db/cst/grammar.yy"
+                    case 353:
+#line 1505 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::randVal};
                     }
-#line 4311 "src/mongo/db/cst/parser_gen.cpp"
+#line 4444 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 341:
-#line 1447 "src/mongo/db/cst/grammar.yy"
+                    case 354:
+#line 1508 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::textScore};
                     }
-#line 4319 "src/mongo/db/cst/parser_gen.cpp"
+#line 4452 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 342:
-#line 1453 "src/mongo/db/cst/grammar.yy"
+                    case 355:
+#line 1514 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::meta, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4327 "src/mongo/db/cst/parser_gen.cpp"
+#line 4460 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 343:
-#line 1459 "src/mongo/db/cst/grammar.yy"
+                    case 356:
+#line 1520 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                     }
-#line 4335 "src/mongo/db/cst/parser_gen.cpp"
+#line 4468 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 344:
-#line 1464 "src/mongo/db/cst/grammar.yy"
+                    case 357:
+#line 1525 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode::noopLeaf();
                     }
-#line 4343 "src/mongo/db/cst/parser_gen.cpp"
+#line 4476 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 345:
-#line 1467 "src/mongo/db/cst/grammar.yy"
+                    case 358:
+#line 1528 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                         yylhs.value.as<CNode>().objectChildren().emplace_back(
                             YY_MOVE(yystack_[0].value.as<std::pair<CNode::Fieldname, CNode>>()));
                     }
-#line 4352 "src/mongo/db/cst/parser_gen.cpp"
+#line 4485 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 346:
-#line 1474 "src/mongo/db/cst/grammar.yy"
+                    case 359:
+#line 1535 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::intOneKey};
                     }
-#line 4360 "src/mongo/db/cst/parser_gen.cpp"
+#line 4493 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 347:
-#line 1477 "src/mongo/db/cst/grammar.yy"
+                    case 360:
+#line 1538 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::intNegOneKey};
                     }
-#line 4368 "src/mongo/db/cst/parser_gen.cpp"
+#line 4501 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 348:
-#line 1480 "src/mongo/db/cst/grammar.yy"
+                    case 361:
+#line 1541 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::longOneKey};
                     }
-#line 4376 "src/mongo/db/cst/parser_gen.cpp"
+#line 4509 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 349:
-#line 1483 "src/mongo/db/cst/grammar.yy"
+                    case 362:
+#line 1544 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::longNegOneKey};
                     }
-#line 4384 "src/mongo/db/cst/parser_gen.cpp"
+#line 4517 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 350:
-#line 1486 "src/mongo/db/cst/grammar.yy"
+                    case 363:
+#line 1547 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::doubleOneKey};
                     }
-#line 4392 "src/mongo/db/cst/parser_gen.cpp"
+#line 4525 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 351:
-#line 1489 "src/mongo/db/cst/grammar.yy"
+                    case 364:
+#line 1550 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::doubleNegOneKey};
                     }
-#line 4400 "src/mongo/db/cst/parser_gen.cpp"
+#line 4533 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 352:
-#line 1492 "src/mongo/db/cst/grammar.yy"
+                    case 365:
+#line 1553 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::decimalOneKey};
                     }
-#line 4408 "src/mongo/db/cst/parser_gen.cpp"
+#line 4541 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 353:
-#line 1495 "src/mongo/db/cst/grammar.yy"
+                    case 366:
+#line 1556 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{KeyValue::decimalNegOneKey};
                     }
-#line 4416 "src/mongo/db/cst/parser_gen.cpp"
+#line 4549 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 354:
-#line 1500 "src/mongo/db/cst/grammar.yy"
+                    case 367:
+#line 1561 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = {
                             YY_MOVE(yystack_[1].value.as<CNode::Fieldname>()),
                             YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4424 "src/mongo/db/cst/parser_gen.cpp"
+#line 4557 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 355:
-#line 1502 "src/mongo/db/cst/grammar.yy"
+                    case 368:
+#line 1563 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = {
                             YY_MOVE(yystack_[1].value.as<CNode::Fieldname>()),
                             YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4432 "src/mongo/db/cst/parser_gen.cpp"
+#line 4565 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 356:
-#line 1508 "src/mongo/db/cst/grammar.yy"
+                    case 369:
+#line 1569 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4438 "src/mongo/db/cst/parser_gen.cpp"
+#line 4571 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 357:
-#line 1508 "src/mongo/db/cst/grammar.yy"
+                    case 370:
+#line 1569 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4444 "src/mongo/db/cst/parser_gen.cpp"
+#line 4577 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 358:
-#line 1512 "src/mongo/db/cst/grammar.yy"
+                    case 371:
+#line 1573 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::constExpr,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 4453 "src/mongo/db/cst/parser_gen.cpp"
+#line 4586 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 359:
-#line 1519 "src/mongo/db/cst/grammar.yy"
+                    case 372:
+#line 1580 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::literal,
                              CNode{CNode::ArrayChildren{YY_MOVE(yystack_[2].value.as<CNode>())}}}}};
                     }
-#line 4462 "src/mongo/db/cst/parser_gen.cpp"
+#line 4595 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 360:
-#line 1526 "src/mongo/db/cst/grammar.yy"
+                    case 373:
+#line 1587 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4468 "src/mongo/db/cst/parser_gen.cpp"
+#line 4601 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 361:
-#line 1526 "src/mongo/db/cst/grammar.yy"
+                    case 374:
+#line 1587 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4474 "src/mongo/db/cst/parser_gen.cpp"
+#line 4607 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 362:
-#line 1530 "src/mongo/db/cst/grammar.yy"
+                    case 375:
+#line 1591 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4480 "src/mongo/db/cst/parser_gen.cpp"
+#line 4613 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 363:
-#line 1530 "src/mongo/db/cst/grammar.yy"
+                    case 376:
+#line 1591 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4486 "src/mongo/db/cst/parser_gen.cpp"
+#line 4619 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 364:
-#line 1534 "src/mongo/db/cst/grammar.yy"
+                    case 377:
+#line 1595 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() =
                             CNode{YY_MOVE(yystack_[1].value.as<std::vector<CNode>>())};
                     }
-#line 4494 "src/mongo/db/cst/parser_gen.cpp"
+#line 4627 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 365:
-#line 1540 "src/mongo/db/cst/grammar.yy"
+                    case 378:
+#line 1601 "src/mongo/db/cst/grammar.yy"
                     {
                     }
-#line 4500 "src/mongo/db/cst/parser_gen.cpp"
+#line 4633 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 366:
-#line 1541 "src/mongo/db/cst/grammar.yy"
+                    case 379:
+#line 1602 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::vector<CNode>>() =
                             YY_MOVE(yystack_[0].value.as<std::vector<CNode>>());
                         yylhs.value.as<std::vector<CNode>>().emplace_back(
                             YY_MOVE(yystack_[1].value.as<CNode>()));
                     }
-#line 4509 "src/mongo/db/cst/parser_gen.cpp"
+#line 4642 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 367:
-#line 1548 "src/mongo/db/cst/grammar.yy"
+                    case 380:
+#line 1609 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                     }
-#line 4517 "src/mongo/db/cst/parser_gen.cpp"
+#line 4650 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 368:
-#line 1554 "src/mongo/db/cst/grammar.yy"
+                    case 381:
+#line 1615 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode::noopLeaf();
                     }
-#line 4525 "src/mongo/db/cst/parser_gen.cpp"
+#line 4658 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 369:
-#line 1557 "src/mongo/db/cst/grammar.yy"
+                    case 382:
+#line 1618 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[1].value.as<CNode>());
                         yylhs.value.as<CNode>().objectChildren().emplace_back(
                             YY_MOVE(yystack_[0].value.as<std::pair<CNode::Fieldname, CNode>>()));
                     }
-#line 4534 "src/mongo/db/cst/parser_gen.cpp"
+#line 4667 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 370:
-#line 1564 "src/mongo/db/cst/grammar.yy"
+                    case 383:
+#line 1625 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = {
                             YY_MOVE(yystack_[1].value.as<CNode::Fieldname>()),
                             YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4542 "src/mongo/db/cst/parser_gen.cpp"
+#line 4675 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 371:
-#line 1571 "src/mongo/db/cst/grammar.yy"
+                    case 384:
+#line 1632 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 4548 "src/mongo/db/cst/parser_gen.cpp"
+#line 4681 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 372:
-#line 1572 "src/mongo/db/cst/grammar.yy"
+                    case 385:
+#line 1633 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 4554 "src/mongo/db/cst/parser_gen.cpp"
+#line 4687 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 373:
-#line 1573 "src/mongo/db/cst/grammar.yy"
+                    case 386:
+#line 1634 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 4560 "src/mongo/db/cst/parser_gen.cpp"
+#line 4693 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 374:
-#line 1574 "src/mongo/db/cst/grammar.yy"
+                    case 387:
+#line 1635 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 4566 "src/mongo/db/cst/parser_gen.cpp"
+#line 4699 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 375:
-#line 1575 "src/mongo/db/cst/grammar.yy"
+                    case 388:
+#line 1636 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode::Fieldname>() =
                             YY_MOVE(yystack_[0].value.as<CNode::Fieldname>());
                     }
-#line 4572 "src/mongo/db/cst/parser_gen.cpp"
+#line 4705 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 376:
-#line 1578 "src/mongo/db/cst/grammar.yy"
+                    case 389:
+#line 1639 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4578 "src/mongo/db/cst/parser_gen.cpp"
+#line 4711 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 377:
-#line 1578 "src/mongo/db/cst/grammar.yy"
+                    case 390:
+#line 1639 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4584 "src/mongo/db/cst/parser_gen.cpp"
+#line 4717 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 378:
-#line 1578 "src/mongo/db/cst/grammar.yy"
+                    case 391:
+#line 1639 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4590 "src/mongo/db/cst/parser_gen.cpp"
+#line 4723 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 379:
-#line 1578 "src/mongo/db/cst/grammar.yy"
+                    case 392:
+#line 1639 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4596 "src/mongo/db/cst/parser_gen.cpp"
+#line 4729 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 380:
-#line 1578 "src/mongo/db/cst/grammar.yy"
+                    case 393:
+#line 1639 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4602 "src/mongo/db/cst/parser_gen.cpp"
+#line 4735 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 381:
-#line 1578 "src/mongo/db/cst/grammar.yy"
+                    case 394:
+#line 1639 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4608 "src/mongo/db/cst/parser_gen.cpp"
+#line 4741 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 382:
-#line 1578 "src/mongo/db/cst/grammar.yy"
+                    case 395:
+#line 1639 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4614 "src/mongo/db/cst/parser_gen.cpp"
+#line 4747 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 383:
-#line 1580 "src/mongo/db/cst/grammar.yy"
+                    case 396:
+#line 1641 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::cmp, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4623 "src/mongo/db/cst/parser_gen.cpp"
+#line 4756 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 384:
-#line 1585 "src/mongo/db/cst/grammar.yy"
+                    case 397:
+#line 1646 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::eq, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4632 "src/mongo/db/cst/parser_gen.cpp"
+#line 4765 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 385:
-#line 1590 "src/mongo/db/cst/grammar.yy"
+                    case 398:
+#line 1651 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::gt, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4641 "src/mongo/db/cst/parser_gen.cpp"
+#line 4774 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 386:
-#line 1595 "src/mongo/db/cst/grammar.yy"
+                    case 399:
+#line 1656 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::gte, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4650 "src/mongo/db/cst/parser_gen.cpp"
+#line 4783 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 387:
-#line 1600 "src/mongo/db/cst/grammar.yy"
+                    case 400:
+#line 1661 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::lt, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4659 "src/mongo/db/cst/parser_gen.cpp"
+#line 4792 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 388:
-#line 1605 "src/mongo/db/cst/grammar.yy"
+                    case 401:
+#line 1666 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::lte, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4668 "src/mongo/db/cst/parser_gen.cpp"
+#line 4801 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 389:
-#line 1610 "src/mongo/db/cst/grammar.yy"
+                    case 402:
+#line 1671 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::ne, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4677 "src/mongo/db/cst/parser_gen.cpp"
+#line 4810 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 390:
-#line 1616 "src/mongo/db/cst/grammar.yy"
+                    case 403:
+#line 1677 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4683 "src/mongo/db/cst/parser_gen.cpp"
+#line 4816 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 391:
-#line 1617 "src/mongo/db/cst/grammar.yy"
+                    case 404:
+#line 1678 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4689 "src/mongo/db/cst/parser_gen.cpp"
+#line 4822 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 392:
-#line 1618 "src/mongo/db/cst/grammar.yy"
+                    case 405:
+#line 1679 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4695 "src/mongo/db/cst/parser_gen.cpp"
+#line 4828 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 393:
-#line 1619 "src/mongo/db/cst/grammar.yy"
+                    case 406:
+#line 1680 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4701 "src/mongo/db/cst/parser_gen.cpp"
+#line 4834 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 394:
-#line 1620 "src/mongo/db/cst/grammar.yy"
+                    case 407:
+#line 1681 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4707 "src/mongo/db/cst/parser_gen.cpp"
+#line 4840 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 395:
-#line 1621 "src/mongo/db/cst/grammar.yy"
+                    case 408:
+#line 1682 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4713 "src/mongo/db/cst/parser_gen.cpp"
+#line 4846 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 396:
-#line 1622 "src/mongo/db/cst/grammar.yy"
+                    case 409:
+#line 1683 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4719 "src/mongo/db/cst/parser_gen.cpp"
+#line 4852 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 397:
-#line 1623 "src/mongo/db/cst/grammar.yy"
+                    case 410:
+#line 1684 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4725 "src/mongo/db/cst/parser_gen.cpp"
+#line 4858 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 398:
-#line 1624 "src/mongo/db/cst/grammar.yy"
+                    case 411:
+#line 1685 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4731 "src/mongo/db/cst/parser_gen.cpp"
+#line 4864 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 399:
-#line 1625 "src/mongo/db/cst/grammar.yy"
+                    case 412:
+#line 1686 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = YY_MOVE(yystack_[0].value.as<CNode>());
                     }
-#line 4737 "src/mongo/db/cst/parser_gen.cpp"
+#line 4870 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 400:
-#line 1630 "src/mongo/db/cst/grammar.yy"
+                    case 413:
+#line 1691 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
                             std::pair{KeyFieldname::onErrorArg, CNode{KeyValue::absentKey}};
                     }
-#line 4745 "src/mongo/db/cst/parser_gen.cpp"
+#line 4878 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 401:
-#line 1633 "src/mongo/db/cst/grammar.yy"
+                    case 414:
+#line 1694 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = std::pair{
                             KeyFieldname::onErrorArg, YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4753 "src/mongo/db/cst/parser_gen.cpp"
+#line 4886 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 402:
-#line 1640 "src/mongo/db/cst/grammar.yy"
+                    case 415:
+#line 1701 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() =
                             std::pair{KeyFieldname::onNullArg, CNode{KeyValue::absentKey}};
                     }
-#line 4761 "src/mongo/db/cst/parser_gen.cpp"
+#line 4894 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 403:
-#line 1643 "src/mongo/db/cst/grammar.yy"
+                    case 416:
+#line 1704 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<std::pair<CNode::Fieldname, CNode>>() = std::pair{
                             KeyFieldname::onNullArg, YY_MOVE(yystack_[0].value.as<CNode>())};
                     }
-#line 4769 "src/mongo/db/cst/parser_gen.cpp"
+#line 4902 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 404:
-#line 1650 "src/mongo/db/cst/grammar.yy"
+                    case 417:
+#line 1711 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::convert,
@@ -5167,92 +5317,92 @@ int ParserGen::parse() {
                                  YY_MOVE(yystack_[4]
                                              .value.as<std::pair<CNode::Fieldname, CNode>>())}}}}};
                     }
-#line 4780 "src/mongo/db/cst/parser_gen.cpp"
+#line 4913 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 405:
-#line 1659 "src/mongo/db/cst/grammar.yy"
+                    case 418:
+#line 1720 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toBool, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4788 "src/mongo/db/cst/parser_gen.cpp"
+#line 4921 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 406:
-#line 1664 "src/mongo/db/cst/grammar.yy"
+                    case 419:
+#line 1725 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toDate, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4796 "src/mongo/db/cst/parser_gen.cpp"
+#line 4929 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 407:
-#line 1669 "src/mongo/db/cst/grammar.yy"
+                    case 420:
+#line 1730 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toDecimal, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4804 "src/mongo/db/cst/parser_gen.cpp"
+#line 4937 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 408:
-#line 1674 "src/mongo/db/cst/grammar.yy"
+                    case 421:
+#line 1735 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toDouble, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4812 "src/mongo/db/cst/parser_gen.cpp"
+#line 4945 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 409:
-#line 1679 "src/mongo/db/cst/grammar.yy"
+                    case 422:
+#line 1740 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toInt, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4820 "src/mongo/db/cst/parser_gen.cpp"
+#line 4953 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 410:
-#line 1684 "src/mongo/db/cst/grammar.yy"
+                    case 423:
+#line 1745 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toLong, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4828 "src/mongo/db/cst/parser_gen.cpp"
+#line 4961 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 411:
-#line 1689 "src/mongo/db/cst/grammar.yy"
+                    case 424:
+#line 1750 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toObjectId, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4836 "src/mongo/db/cst/parser_gen.cpp"
+#line 4969 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 412:
-#line 1694 "src/mongo/db/cst/grammar.yy"
+                    case 425:
+#line 1755 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::toString, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4844 "src/mongo/db/cst/parser_gen.cpp"
+#line 4977 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
-                    case 413:
-#line 1699 "src/mongo/db/cst/grammar.yy"
+                    case 426:
+#line 1760 "src/mongo/db/cst/grammar.yy"
                     {
                         yylhs.value.as<CNode>() = CNode{CNode::ObjectChildren{
                             {KeyFieldname::type, YY_MOVE(yystack_[1].value.as<CNode>())}}};
                     }
-#line 4852 "src/mongo/db/cst/parser_gen.cpp"
+#line 4985 "src/mongo/db/cst/parser_gen.cpp"
                     break;
 
 
-#line 4856 "src/mongo/db/cst/parser_gen.cpp"
+#line 4989 "src/mongo/db/cst/parser_gen.cpp"
 
                     default:
                         break;
@@ -5501,325 +5651,336 @@ std::string ParserGen::yysyntax_error_(state_type yystate, const symbol_type& yy
 }
 
 
-const short ParserGen::yypact_ninf_ = -619;
+const short ParserGen::yypact_ninf_ = -611;
 
 const signed char ParserGen::yytable_ninf_ = -1;
 
 const short ParserGen::yypact_[] = {
-    77,   -82,  -75,  -82,  -82,  -71,  38,   -619, -619, -28,  -619, -619, -619, -619, -619, -619,
-    849,  174,  10,   413,  -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, 850,  -619, -619, -619, -619, -26,  18,
-    -22,  -13,  18,   -619, 41,   -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, 132,  -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, 850,  -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, 47,   -619, -619, -619, -619, -619, -619,
-    60,   -619, 86,   9,    -28,  -619, -619, -619, -619, -619, -619, -619, -619, 35,   -619, -619,
-    850,  68,   523,  -619, 633,  18,   -56,  -619, -619, -49,  -619, -619, -619, 850,  -619, -619,
-    1062, 1062, -619, -619, -619, -619, -619, 73,   120,  -619, -619, 102,  -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, 956,  743,  -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, 6,    -619, -619, 956,  -619, 115,  956,  72,
-    72,   88,   956,  88,   114,  116,  -619, -619, -619, 118,  88,   956,  956,  88,   88,   119,
-    121,  122,  956,  125,  956,  88,   88,   -619, 130,  131,  88,   134,  72,   137,  -619, -619,
-    -619, -619, -619, 138,  -619, 141,  956,  142,  956,  956,  144,  147,  148,  149,  956,  956,
-    956,  956,  956,  956,  956,  956,  956,  956,  -619, 151,  956,  19,   160,  -619, -619, 177,
-    198,  199,  956,  203,  205,  207,  956,  850,  153,  166,  244,  956,  219,  220,  221,  222,
-    223,  956,  956,  850,  225,  956,  226,  227,  228,  267,  956,  956,  230,  956,  231,  956,
-    232,  264,  236,  237,  271,  273,  956,  267,  956,  241,  956,  242,  243,  956,  956,  956,
-    956,  245,  246,  247,  249,  250,  254,  256,  257,  258,  259,  267,  956,  261,  -619, 956,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, 956,  -619, -619, -619, 265,  266,  956,
-    956,  956,  956,  -619, -619, -619, -619, -619, 956,  956,  268,  -619, 956,  -619, -619, -619,
-    956,  275,  956,  956,  -619, 269,  -619, 956,  -619, 956,  -619, -619, 956,  956,  956,  294,
-    956,  -619, 956,  -619, -619, 956,  956,  956,  956,  -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, 300,  956,  -619, -619, 272,  270,  274,  302,  305,  305,  278,  956,  956,
-    280,  282,  -619, 956,  286,  956,  287,  289,  314,  320,  321,  293,  956,  296,  297,  956,
-    956,  956,  298,  956,  299,  -619, -619, -619, 956,  322,  956,  323,  323,  301,  956,  303,
-    306,  -619, 304,  308,  311,  307,  -619, 313,  956,  324,  956,  956,  315,  316,  317,  318,
-    325,  326,  327,  319,  328,  329,  -619, 956,  333,  -619, 956,  302,  322,  -619, -619, 334,
-    335,  -619, 336,  -619, 337,  -619, -619, 956,  343,  345,  -619, 338,  -619, -619, 339,  340,
-    341,  -619, 342,  -619, -619, 956,  -619, 322,  344,  -619, -619, -619, -619, 346,  956,  956,
-    -619, -619, -619, -619, -619, 347,  348,  349,  -619, 350,  351,  352,  353,  -619, 354,  355,
-    -619, -619, -619, -619};
+    67,   -49,  -42,  -49,  -49,  -47,  106,  -611, -611, 17,   -611, -611, -611, -611, -611, -611,
+    865,  71,   70,   417,  -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, 1105, -611, -611, -611,
+    -611, -611, 25,   26,   92,   29,   34,   92,   -611, 83,   -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, 35,   -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -49,  87,   -611, -611, -611, -611, -611,
+    -611, 113,  -611, 137,  60,   17,   -611, -611, -611, -611, -611, -611, -611, -611, 95,   -611,
+    -611, -17,  -611, -611, 535,  92,   -46,  -611, -611, -63,  -611, -83,  -611, -611, -18,  -611,
+    243,  243,  -611, -611, -611, -611, -611, 126,  156,  -611, -611, 130,  105,  -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, 891,  757,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -8,   -611, -611, -611, 891,
+    -611, 134,  891,  88,   88,   90,   891,  90,   93,   109,  -611, -611, -611, 114,  90,   891,
+    891,  90,   90,   115,  116,  117,  891,  118,  891,  90,   90,   -611, 120,  121,  90,   122,
+    88,   131,  -611, -611, -611, -611, -611, 132,  -611, 133,  891,  136,  891,  891,  140,  141,
+    147,  148,  891,  891,  891,  891,  891,  891,  891,  891,  891,  891,  -611, 149,  891,  886,
+    152,  -1,   -611, -611, 180,  183,  196,  891,  197,  206,  207,  891,  998,  172,  245,  244,
+    891,  211,  212,  213,  214,  216,  891,  891,  998,  218,  891,  219,  220,  222,  261,  891,
+    891,  224,  891,  225,  891,  228,  260,  230,  232,  271,  275,  891,  261,  891,  246,  891,
+    248,  249,  891,  891,  891,  891,  251,  255,  256,  257,  258,  262,  264,  265,  266,  267,
+    261,  891,  268,  -611, 891,  -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, 891,
+    -611, -611, -611, 270,  998,  -611, 272,  -611, -611, -611, -611, 891,  891,  891,  891,  -611,
+    -611, -611, -611, -611, 891,  891,  273,  -611, 891,  -611, -611, -611, 891,  274,  891,  891,
+    -611, 276,  -611, 891,  -611, 891,  -611, -611, 891,  891,  891,  301,  891,  -611, 891,  -611,
+    -611, 891,  891,  891,  891,  -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, 307,
+    891,  -611, -611, 279,  280,  998,  282,  646,  285,  309,  277,  277,  289,  891,  891,  291,
+    293,  -611, 891,  294,  891,  295,  297,  322,  328,  331,  302,  891,  303,  304,  891,  891,
+    891,  305,  891,  306,  -611, -611, -611, -611, -611, 998,  -611, -611, 891,  335,  891,  327,
+    327,  308,  891,  312,  332,  -611, 333,  334,  336,  338,  -611, 339,  891,  359,  891,  891,
+    340,  341,  342,  343,  345,  346,  347,  348,  349,  350,  -611, -611, 891,  263,  -611, 891,
+    309,  335,  -611, -611, 351,  352,  -611, 353,  -611, 354,  -611, -611, 891,  361,  370,  -611,
+    355,  -611, -611, 357,  358,  360,  -611, 362,  -611, -611, 891,  -611, 335,  363,  -611, -611,
+    -611, -611, 364,  891,  891,  -611, -611, -611, -611, -611, 365,  366,  367,  -611, 369,  371,
+    375,  392,  -611, 396,  400,  -611, -611, -611, -611};
 
 const short ParserGen::yydefact_[] = {
-    0,   0,   0,   0,   0,   0,   0,   70,  3,   8,   2,   5,   4,   344, 6,   1,   0,   0,   0,
-    0,   95,  84,  94,  91,  100, 98,  92,  87,  89,  90,  97,  85,  101, 96,  99,  86,  93,  88,
-    69,  243, 77,  0,   76,  75,  74,  71,  0,   0,   0,   0,   0,   10,  0,   12,  13,  14,  15,
-    16,  17,  7,   126, 102, 104, 103, 127, 109, 141, 105, 116, 142, 143, 128, 343, 110, 129, 130,
-    111, 112, 144, 145, 106, 131, 132, 133, 113, 114, 146, 147, 134, 135, 115, 108, 107, 136, 148,
-    149, 150, 152, 151, 137, 153, 154, 138, 78,  81,  82,  83,  80,  79,  157, 155, 156, 158, 159,
-    160, 139, 117, 118, 119, 120, 121, 122, 161, 123, 124, 163, 162, 140, 125, 372, 373, 374, 371,
-    375, 0,   345, 199, 198, 197, 196, 195, 193, 192, 191, 185, 184, 183, 189, 188, 187, 165, 365,
-    368, 166, 164, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 182, 186, 190, 194, 179, 180,
-    181, 167, 168, 209, 210, 211, 212, 213, 218, 214, 215, 216, 219, 220, 73,  200, 201, 203, 204,
-    205, 217, 206, 207, 208, 360, 361, 362, 363, 202, 72,  0,   21,  22,  23,  24,  26,  28,  0,
-    25,  0,   0,   8,   353, 352, 351, 350, 347, 346, 349, 348, 0,   354, 355, 365, 0,   0,   19,
-    0,   0,   0,   11,  9,   0,   366, 364, 367, 0,   369, 27,  0,   0,   66,  67,  68,  65,  29,
-    0,   0,   340, 341, 0,   370, 60,  59,  56,  55,  58,  52,  51,  54,  44,  43,  46,  48,  47,
-    50,  221, 236, 45,  49,  53,  57,  39,  40,  41,  42,  61,  62,  63,  32,  33,  34,  35,  36,
-    37,  38,  30,  64,  226, 227, 228, 244, 245, 229, 278, 279, 280, 230, 356, 357, 233, 284, 285,
-    286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 305,
-    304, 231, 376, 377, 378, 379, 380, 381, 382, 232, 390, 391, 392, 393, 394, 395, 396, 397, 398,
-    399, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 31,  18,  0,
-    342, 223, 221, 224, 0,   0,   0,   0,   0,   0,   0,   0,   0,   10,  10,  10,  0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   10,  0,   0,   0,   0,   0,   0,   10,
-    10,  10,  10,  10,  0,   10,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   10,  0,   0,   0,   0,   222, 234, 0,   0,   0,   0,   0,   0,
-    0,   221, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   318, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   318, 0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   318, 0,   0,
-    235, 0,   240, 241, 239, 242, 237, 20,  263, 261, 281, 0,   262, 264, 383, 0,   0,   0,   0,
-    0,   0,   384, 266, 267, 385, 386, 0,   0,   0,   268, 0,   270, 387, 388, 0,   0,   0,   0,
-    389, 0,   282, 0,   326, 0,   327, 328, 0,   0,   0,   0,   0,   275, 0,   332, 333, 0,   0,
-    0,   0,   405, 406, 407, 408, 409, 410, 338, 411, 412, 339, 0,   0,   413, 238, 0,   0,   0,
-    400, 307, 307, 0,   313, 313, 0,   0,   319, 0,   0,   221, 0,   0,   323, 0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   225, 306, 358, 0,   402, 0,   309, 309, 0,   314, 0,
-    0,   359, 0,   0,   0,   0,   283, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   401, 0,   0,   308, 0,   400, 402, 265, 315, 0,   0,   269, 0,   271, 0,   273,
-    324, 0,   0,   0,   274, 0,   331, 334, 0,   0,   0,   276, 0,   277, 403, 0,   310, 402, 0,
-    316, 317, 320, 272, 0,   0,   0,   321, 335, 336, 337, 322, 0,   0,   0,   325, 0,   0,   0,
-    0,   312, 0,   0,   404, 311, 330, 329};
+    0,   0,   0,   0,   0,   0,   0,   70,  3,   8,   2,   5,   4,   357, 6,   1,   0,   0,   0,
+    0,   82,  108, 97,  107, 104, 113, 111, 105, 100, 102, 103, 110, 98,  114, 109, 112, 99,  106,
+    101, 69,  256, 84,  83,  90,  0,   88,  89,  87,  71,  73,  0,   0,   0,   0,   0,   0,   10,
+    0,   12,  13,  14,  15,  16,  17,  7,   139, 115, 117, 116, 140, 122, 154, 118, 129, 155, 156,
+    141, 356, 123, 142, 143, 124, 125, 157, 158, 119, 144, 145, 146, 126, 127, 159, 160, 147, 148,
+    128, 121, 120, 149, 161, 162, 163, 165, 164, 150, 166, 167, 151, 91,  94,  95,  96,  93,  92,
+    170, 168, 169, 171, 172, 173, 152, 130, 131, 132, 133, 134, 135, 174, 136, 137, 176, 175, 153,
+    138, 385, 386, 387, 384, 388, 0,   358, 212, 211, 210, 209, 208, 206, 205, 204, 198, 197, 196,
+    202, 201, 200, 178, 76,  179, 177, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 195, 199,
+    203, 207, 192, 193, 194, 180, 181, 222, 223, 224, 225, 226, 231, 227, 228, 229, 232, 233, 213,
+    214, 216, 217, 218, 230, 219, 220, 221, 74,  215, 72,  0,   0,   21,  22,  23,  24,  26,  28,
+    0,   25,  0,   0,   8,   366, 365, 364, 363, 360, 359, 362, 361, 0,   367, 368, 0,   85,  19,
+    0,   0,   0,   11,  9,   0,   75,  0,   77,  78,  0,   27,  0,   0,   66,  67,  68,  65,  29,
+    0,   0,   353, 354, 0,   0,   79,  81,  86,  60,  59,  56,  55,  58,  52,  51,  54,  44,  43,
+    46,  48,  47,  50,  234, 249, 45,  49,  53,  57,  39,  40,  41,  42,  61,  62,  63,  32,  33,
+    34,  35,  36,  37,  38,  30,  64,  239, 240, 241, 257, 258, 242, 291, 292, 293, 243, 369, 370,
+    246, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
+    315, 316, 318, 317, 244, 389, 390, 391, 392, 393, 394, 395, 245, 403, 404, 405, 406, 407, 408,
+    409, 410, 411, 412, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273,
+    31,  18,  0,   355, 76,  236, 234, 237, 0,   0,   0,   0,   0,   0,   0,   0,   0,   10,  10,
+    10,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   10,  0,   0,   0,
+    0,   0,   0,   10,  10,  10,  10,  10,  0,   10,  0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   10,  0,   0,   0,   0,   0,   235, 247, 0,
+    0,   0,   0,   0,   0,   0,   234, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   331, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   331, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   331, 0,   0,   248, 0,   253, 254, 252, 255, 250, 20,  80,  276, 274, 294, 0,   275,
+    277, 396, 0,   378, 381, 0,   373, 374, 375, 376, 0,   0,   0,   0,   397, 279, 280, 398, 399,
+    0,   0,   0,   281, 0,   283, 400, 401, 0,   0,   0,   0,   402, 0,   295, 0,   339, 0,   340,
+    341, 0,   0,   0,   0,   0,   288, 0,   345, 346, 0,   0,   0,   0,   418, 419, 420, 421, 422,
+    423, 351, 424, 425, 352, 0,   0,   426, 251, 0,   0,   378, 0,   0,   0,   413, 320, 320, 0,
+    326, 326, 0,   0,   332, 0,   0,   234, 0,   0,   336, 0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   238, 319, 379, 377, 380, 0,   382, 371, 0,   415, 0,   322, 322, 0,   327,
+    0,   0,   372, 0,   0,   0,   0,   296, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   383, 414, 0,   0,   321, 0,   413, 415, 278, 328, 0,   0,   282, 0,   284,
+    0,   286, 337, 0,   0,   0,   287, 0,   344, 347, 0,   0,   0,   289, 0,   290, 416, 0,   323,
+    415, 0,   329, 330, 333, 285, 0,   0,   0,   334, 348, 349, 350, 335, 0,   0,   0,   338, 0,
+    0,   0,   0,   325, 0,   0,   417, 324, 343, 342};
 
 const short ParserGen::yypgoto_[] = {
-    -619, -619, -619, -221, -619, -16,  139,  -15,  -14,  145,  -619, -619, -619, -619, -189,
-    -174, -152, -143, -35,  -132, -34,  -41,  -27,  -125, -112, -36,  -165, -619, -107, -105,
-    -101, -619, -91,  -85,  -70,  -37,  -619, -619, -619, -619, -619, -619, 165,  -619, -619,
-    -619, -619, -619, -619, -619, -619, 146,  -40,  -296, -61,  -230, -346, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -209, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619, -619,
-    -619, -619, -619, -619, -619, -619, -619, -246, -618, -172, -203, -410, -619, -352, 180,
-    -170, 194,  -619, -619, -619, -619, -619, -619, -619, -619, -619, -48,  -619};
+    -611, -611, -611, -222, -611, -15,  175,  -14,  -13,  -178, -611, -611, -611, -200, -185, -161,
+    -158, -40,  -149, -35,  -45,  -31,  -142, -140, -430, -195, -611, -129, -103, -100, -611, -98,
+    -92,  -131, -44,  -611, -611, -611, -611, -611, -611, 201,  -611, -611, -611, -611, -611, -611,
+    -611, -611, 204,  -39,  -361, -74,  -150, -333, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -235, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -611, -203, -610,
+    -133, -169, -446, -611, -362, -124, -132, 15,   -611, 94,   -611, -611, -611, -611, 208,  -611,
+    -611, -611, -611, -611, -611, -611, -611, -611, -52,  -611};
 
 const short ParserGen::yydefgoto_[] = {
-    -1,  241, 495, 129, 41,  130, 131, 132, 133, 134, 246, 500, 238, 45,  174, 175, 176, 177, 178,
-    179, 180, 181, 182, 183, 184, 224, 186, 187, 188, 189, 190, 191, 192, 193, 194, 362, 196, 197,
-    198, 226, 199, 10,  18,  52,  53,  54,  55,  56,  57,  58,  228, 287, 206, 363, 364, 435, 289,
-    290, 427, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
-    308, 309, 310, 464, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325,
-    326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
-    345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 601, 632, 603, 635, 529, 617,
-    365, 225, 607, 8,   16,  200, 14,  19,  222, 223, 251, 135, 6,   465, 211};
+    -1,  241, 500, 134, 44,  135, 136, 137, 138, 139, 246, 505, 618, 178, 179, 180, 181, 182,
+    183, 184, 185, 186, 187, 188, 581, 189, 190, 191, 192, 193, 194, 195, 196, 197, 366, 520,
+    521, 522, 583, 199, 10,  18,  57,  58,  59,  60,  61,  62,  63,  228, 290, 207, 367, 368,
+    440, 292, 293, 431, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
+    308, 309, 310, 311, 312, 313, 469, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
+    325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342,
+    343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360,
+    621, 653, 623, 656, 541, 637, 369, 582, 627, 8,   16,  225, 200, 238, 48,  49,  236, 237,
+    50,  14,  19,  223, 224, 251, 140, 6,   470, 212};
 
 const short ParserGen::yytable_[] = {
-    42,  43,  44,  210, 195, 185, 204, 242, 7,   204, 209, 429, 202, 203, 9,   202, 203, 150, 664,
-    13,  205, 432, 433, 205, 249, 20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,
-    15,  33,  34,  35,  153, 36,  37,  678, 141, 142, 143, 250, 462, 273, 273, 59,  138, 139, 140,
-    154, 141, 142, 143, 543, 17,  494, 201, 248, 274, 274, 207, 39,  431, 144, 145, 146, 436, 280,
-    280, 208, 147, 148, 149, 563, 229, 445, 446, 212, 509, 1,   275, 275, 452, 227, 454, 230, 2,
-    3,   4,   276, 276, 231, 5,   233, 103, 104, 105, 106, 107, 108, 277, 277, 473, 235, 475, 476,
-    195, 278, 278, 359, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 279, 279, 493, 40,  167,
-    281, 281, 282, 282, 360, 505, 283, 283, 437, 165, 166, 167, 168, 361, 514, 444, 284, 284, 447,
-    448, 520, 521, 285, 285, 524, 430, 455, 456, 267, 530, 531, 460, 533, 511, 535, 213, 214, 286,
-    286, 215, 216, 542, 512, 544, 434, 546, 288, 288, 549, 550, 551, 552, 217, 218, 195, 204, 247,
-    466, 467, 219, 220, 202, 203, 564, 11,  12,  566, 195, 252, 205, 438, 501, 439, 496, 443, 449,
-    567, 450, 451, 243, 245, 453, 570, 571, 572, 573, 458, 459, 502, 221, 461, 574, 575, 463, 470,
-    577, 613, 472, 474, 578, 477, 580, 581, 478, 479, 480, 583, 492, 584, 503, 504, 585, 586, 587,
-    506, 589, 507, 590, 508, 513, 591, 592, 593, 594, 46,  47,  48,  49,  50,  51,  515, 516, 517,
-    518, 519, 596, 523, 525, 526, 527, 528, 532, 534, 536, 537, 606, 606, 538, 539, 540, 611, 541,
-    545, 547, 548, 579, 553, 554, 555, 621, 556, 557, 624, 625, 626, 558, 628, 559, 560, 561, 562,
-    630, 565, 633, 588, 568, 569, 638, 576, 582, 595, 598, 597, 600, 602, 599, 428, 646, 605, 648,
-    649, 609, 610, 440, 441, 442, 612, 616, 614, 615, 618, 619, 660, 620, 631, 662, 622, 623, 627,
-    629, 457, 647, 637, 639, 634, 641, 640, 644, 669, 642, 468, 469, 643, 471, 645, 661, 650, 651,
-    652, 653, 657, 670, 677, 671, 244, 654, 655, 656, 237, 658, 659, 681, 682, 491, 232, 665, 666,
-    667, 668, 672, 673, 674, 675, 676, 358, 679, 663, 680, 683, 684, 685, 686, 687, 688, 689, 690,
-    691, 604, 636, 195, 510, 234, 608, 0,   0,   0,   0,   0,   497, 498, 499, 195, 522, 60,  61,
-    62,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  0,   33,  34,  35,  0,
-    36,  37,  63,  0,   0,   64,  65,  66,  67,  68,  69,  70,  0,   0,   0,   71,  0,   0,   0,
-    0,   72,  73,  74,  75,  76,  77,  39,  78,  79,  0,   0,   0,   80,  81,  82,  83,  0,   0,
-    0,   84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  0,   94,  95,  96,  97,  98,  99,  100,
-    101, 102, 103, 104, 105, 106, 107, 108, 0,   0,   109, 110, 111, 112, 113, 114, 115, 0,   116,
-    117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 40,  60,  61,  62,  20,  21,  22,
-    23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  0,   33,  34,  35,  0,   36,  37,  63,  0,
-    0,   64,  65,  66,  67,  68,  69,  70,  0,   0,   0,   71,  0,   0,   0,   0,   236, 73,  74,
-    75,  76,  77,  39,  78,  79,  0,   0,   0,   80,  81,  82,  83,  0,   0,   0,   84,  85,  86,
-    87,  88,  89,  90,  91,  92,  93,  0,   94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104,
-    105, 106, 107, 108, 0,   0,   109, 110, 111, 112, 113, 114, 115, 0,   116, 117, 118, 119, 120,
-    121, 122, 123, 124, 125, 126, 127, 128, 40,  60,  61,  62,  20,  21,  22,  23,  24,  25,  26,
-    27,  28,  29,  30,  31,  32,  0,   33,  34,  35,  0,   36,  37,  63,  0,   0,   64,  65,  66,
-    67,  68,  69,  70,  0,   0,   0,   71,  0,   0,   0,   0,   239, 73,  74,  75,  76,  77,  240,
-    78,  79,  0,   0,   0,   80,  81,  82,  83,  0,   0,   0,   84,  85,  86,  87,  88,  89,  90,
-    91,  92,  93,  0,   94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108,
-    0,   0,   109, 110, 111, 112, 113, 114, 115, 0,   116, 117, 118, 119, 120, 121, 122, 123, 124,
-    125, 126, 127, 128, 40,  366, 367, 368, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   369, 0,   0,   370, 371, 372, 373, 374, 375, 376,
-    0,   0,   0,   377, 0,   0,   0,   0,   0,   378, 379, 380, 381, 382, 0,   383, 384, 0,   0,
-    0,   385, 386, 387, 388, 0,   0,   0,   389, 390, 391, 0,   392, 393, 394, 395, 396, 397, 0,
-    398, 399, 400, 401, 402, 403, 404, 405, 406, 0,   0,   0,   0,   0,   0,   0,   0,   407, 408,
-    409, 410, 411, 412, 413, 0,   414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426,
-    20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  0,   33,  34,  35,  0,   36,
-    37,  0,   0,   136, 137, 0,   0,   0,   0,   0,   0,   0,   138, 139, 140, 0,   141, 142, 143,
-    38,  0,   0,   0,   0,   0,   39,  0,   0,   0,   144, 145, 146, 0,   0,   0,   0,   147, 148,
-    149, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   150, 0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   151, 152, 0,   0,   0,   0,   0,   0,   0,   153, 0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   40,  0,   154, 155, 156, 157, 158, 159,
-    160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 136, 137, 0,   0,   0,
-    0,   0,   0,   0,   138, 139, 140, 0,   141, 142, 143, 0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   144, 145, 146, 0,   0,   0,   0,   147, 148, 149, 0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   150, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    267, 268, 0,   0,   0,   0,   0,   0,   0,   153, 0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
-    168, 169, 170, 171, 172, 173, 253, 254, 0,   0,   0,   0,   0,   0,   0,   255, 256, 257, 0,
-    258, 259, 260, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   261, 262, 263, 0,   0,   0,
-    0,   264, 265, 266, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   150, 0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   267, 268, 0,   0,   0,   0,   0,   0,
-    0,   153, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   154, 155, 156,
-    157, 158, 159, 160, 161, 162, 163, 164, 269, 270, 271, 272, 169, 170, 171};
+    198, 45,  46,  47,  211, 434, 242, 205, 252, 436, 205, 249, 203, 441, 518, 203, 210, 204, 11,
+    12,  204, 206, 450, 451, 206, 254, 534, 234, 155, 457, 555, 459, 146, 147, 148, 248, 250, 164,
+    437, 438, 276, 276, 7,   507, 13,  283, 283, 685, 9,   478, 575, 480, 481, 157, 235, 277, 277,
+    486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 467, 158, 498, 235, 214, 215, 7,   699, 216,
+    217, 1,   511, 278, 278, 515, 279, 279, 2,   3,   4,   526, 218, 219, 5,   280, 280, 532, 533,
+    220, 221, 536, 281, 281, 282, 282, 542, 543, 253, 545, 15,  547, 17,  289, 289, 284, 284, 64,
+    554, 201, 556, 202, 558, 171, 208, 561, 562, 563, 564, 209, 222, 213, 143, 144, 145, 227, 146,
+    147, 148, 229, 576, 285, 285, 578, 286, 286, 287, 287, 230, 149, 150, 151, 288, 288, 579, 231,
+    152, 153, 154, 51,  52,  53,  54,  55,  56,  233, 585, 586, 587, 588, 291, 291, 471, 472, 362,
+    589, 590, 363, 364, 592, 235, 435, 270, 593, 439, 595, 596, 443, 205, 523, 598, 650, 599, 203,
+    247, 600, 601, 602, 204, 604, 506, 605, 206, 444, 606, 607, 608, 609, 448, 454, 455, 456, 458,
+    501, 463, 464, 466, 243, 245, 611, 226, 169, 170, 171, 172, 468, 475, 477, 508, 442, 479, 509,
+    626, 626, 482, 483, 449, 631, 633, 452, 453, 484, 485, 497, 510, 512, 641, 460, 461, 644, 645,
+    646, 465, 648, 513, 514, 525, 255, 524, 527, 528, 529, 530, 651, 531, 654, 535, 537, 538, 659,
+    539, 540, 544, 546, 256, 257, 548, 549, 550, 667, 551, 669, 670, 258, 259, 260, 552, 261, 262,
+    263, 553, 594, 682, 622, 557, 681, 559, 560, 683, 565, 264, 265, 266, 566, 567, 568, 569, 267,
+    268, 269, 570, 690, 571, 572, 573, 574, 577, 580, 603, 584, 591, 155, 432, 597, 610, 698, 612,
+    620, 613, 615, 445, 446, 447, 619, 702, 703, 625, 270, 271, 629, 630, 632, 636, 634, 635, 638,
+    157, 462, 639, 640, 642, 643, 647, 649, 652, 655, 658, 473, 474, 660, 476, 158, 159, 160, 161,
+    162, 163, 164, 165, 166, 167, 168, 272, 273, 274, 275, 173, 174, 175, 661, 496, 662, 663, 668,
+    664, 665, 691, 666, 671, 672, 673, 674, 675, 676, 677, 692, 678, 679, 680, 686, 687, 688, 689,
+    693, 519, 694, 695, 244, 696, 617, 697, 700, 701, 704, 705, 706, 519, 707, 232, 708, 502, 503,
+    504, 709, 65,  66,  67,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  710,
+    34,  35,  36,  711, 37,  38,  68,  712, 361, 69,  70,  71,  72,  73,  74,  75,  684, 624, 657,
+    76,  614, 628, 433, 365, 77,  78,  79,  80,  81,  82,  40,  83,  84,  0,   0,   519, 85,  86,
+    87,  88,  0,   0,   0,   89,  90,  91,  92,  93,  94,  95,  0,   96,  97,  98,  0,   99,  100,
+    101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 0,   0,   114, 115, 116, 117,
+    118, 119, 120, 0,   121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 43,  0,
+    0,   0,   0,   0,   0,   519, 65,  66,  67,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,
+    31,  32,  33,  0,   34,  35,  36,  0,   37,  38,  68,  0,   0,   69,  70,  71,  72,  73,  74,
+    75,  0,   0,   519, 76,  0,   0,   0,   0,   239, 78,  79,  80,  81,  82,  240, 83,  84,  0,
+    0,   0,   85,  86,  87,  88,  0,   0,   0,   89,  90,  91,  92,  93,  94,  95,  0,   96,  97,
+    98,  0,   99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 0,   0,
+    114, 115, 116, 117, 118, 119, 120, 0,   121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
+    132, 133, 43,  65,  66,  67,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,
+    0,   34,  35,  36,  0,   37,  38,  68,  0,   0,   69,  70,  71,  72,  73,  74,  75,  0,   0,
+    0,   76,  0,   0,   0,   0,   616, 78,  79,  80,  81,  82,  40,  83,  84,  0,   0,   0,   85,
+    86,  87,  88,  0,   0,   0,   89,  90,  91,  92,  93,  94,  95,  0,   96,  97,  98,  0,   99,
+    100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 0,   0,   114, 115, 116,
+    117, 118, 119, 120, 0,   121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 43,
+    370, 371, 372, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   373, 0,   0,   374, 375, 376, 377, 378, 379, 380, 0,   0,   0,   381, 0,
+    0,   0,   0,   0,   382, 383, 384, 385, 386, 0,   387, 388, 0,   0,   0,   389, 390, 391, 392,
+    0,   0,   0,   393, 394, 395, 0,   396, 397, 398, 0,   399, 400, 401, 0,   402, 403, 404, 405,
+    406, 407, 408, 409, 410, 0,   0,   0,   0,   0,   0,   0,   0,   411, 412, 413, 414, 415, 416,
+    417, 0,   418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 20,  21,  22,  23,
+    24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  0,   34,  35,  36,  0,   37,  38,  0,   21,
+    22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  0,   34,  35,  36,  39,  37,  38,
+    0,   0,   0,   40,  0,   0,   141, 142, 0,   0,   0,   0,   0,   0,   0,   143, 144, 145, 499,
+    146, 147, 148, 0,   41,  40,  42,  0,   0,   0,   0,   0,   0,   149, 150, 151, 0,   0,   0,
+    0,   152, 153, 154, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   155, 0,   0,   0,
+    0,   108, 109, 110, 111, 112, 113, 0,   0,   43,  0,   0,   270, 271, 0,   0,   0,   0,   0,
+    0,   0,   157, 0,   0,   0,   0,   0,   0,   0,   0,   43,  0,   0,   0,   0,   0,   158, 159,
+    160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 141,
+    142, 0,   0,   0,   0,   0,   0,   0,   143, 144, 145, 0,   146, 147, 148, 0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   149, 150, 151, 0,   0,   0,   0,   152, 153, 154, 0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   155, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   516, 517, 0,   0,   0,   0,   0,   0,   0,   157, 0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   158, 159, 160, 161, 162, 163, 164, 165, 166,
+    167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 141, 142, 0,   0,   0,   0,   0,   0,
+    0,   143, 144, 145, 0,   146, 147, 148, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   149,
+    150, 151, 0,   0,   0,   0,   152, 153, 154, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   155, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   156,
+    0,   0,   0,   0,   0,   0,   0,   157, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173,
+    174, 175, 176, 177};
 
 const short ParserGen::yycheck_[] = {
-    16,  16,  16,  51,  41,  41,  47,  228, 90,  50,  50,  363, 47,  47,  89,  50,  50,  73,  636,
-    90,  47,  367, 368, 50,  73,  6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,
-    0,   20,  21,  22,  98,  24,  25,  663, 40,  41,  42,  98,  396, 240, 241, 43,  36,  37,  38,
-    113, 40,  41,  42,  471, 90,  44,  90,  230, 240, 241, 90,  50,  366, 53,  54,  55,  370, 240,
-    241, 90,  60,  61,  62,  491, 22,  379, 380, 44,  438, 10,  240, 241, 386, 44,  388, 7,   17,
-    18,  19,  240, 241, 90,  23,  66,  83,  84,  85,  86,  87,  88,  240, 241, 406, 43,  408, 409,
-    151, 240, 241, 44,  414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 240, 241, 426, 112, 126,
-    240, 241, 240, 241, 17,  434, 240, 241, 371, 124, 125, 126, 127, 44,  443, 378, 240, 241, 381,
-    382, 449, 450, 240, 241, 453, 43,  389, 390, 89,  458, 459, 394, 461, 13,  463, 36,  37,  240,
-    241, 40,  41,  470, 9,   472, 89,  474, 240, 241, 477, 478, 479, 480, 53,  54,  224, 229, 229,
-    399, 400, 60,  61,  229, 229, 492, 3,   4,   495, 237, 237, 229, 89,  44,  89,  427, 89,  89,
-    505, 89,  89,  228, 228, 89,  511, 512, 513, 514, 89,  89,  44,  90,  89,  520, 521, 89,  89,
-    524, 581, 89,  89,  528, 89,  530, 531, 89,  89,  89,  535, 89,  537, 44,  44,  540, 541, 542,
-    44,  544, 44,  546, 44,  8,   549, 550, 551, 552, 83,  84,  85,  86,  87,  88,  44,  44,  44,
-    44,  44,  564, 44,  44,  44,  44,  6,   44,  44,  44,  13,  574, 575, 44,  44,  11,  579, 11,
-    44,  44,  44,  13,  44,  44,  44,  588, 44,  44,  591, 592, 593, 44,  595, 44,  44,  44,  44,
-    600, 44,  602, 13,  43,  43,  606, 43,  43,  13,  44,  43,  14,  12,  44,  360, 616, 43,  618,
-    619, 44,  43,  374, 375, 376, 43,  16,  44,  43,  13,  13,  631, 43,  15,  634, 43,  43,  43,
-    43,  391, 20,  44,  43,  24,  44,  43,  43,  647, 44,  401, 402, 44,  404, 44,  25,  44,  44,
-    44,  44,  44,  21,  661, 21,  228, 43,  43,  43,  226, 44,  44,  670, 671, 424, 212, 44,  44,
-    44,  44,  44,  44,  44,  44,  44,  241, 44,  635, 44,  44,  44,  44,  44,  44,  44,  44,  44,
-    44,  572, 604, 439, 439, 224, 575, -1,  -1,  -1,  -1,  -1,  427, 427, 427, 451, 451, 3,   4,
-    5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  -1,  20,  21,  22,  -1,
-    24,  25,  26,  -1,  -1,  29,  30,  31,  32,  33,  34,  35,  -1,  -1,  -1,  39,  -1,  -1,  -1,
-    -1,  44,  45,  46,  47,  48,  49,  50,  51,  52,  -1,  -1,  -1,  56,  57,  58,  59,  -1,  -1,
-    -1,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  -1,  74,  75,  76,  77,  78,  79,  80,
-    81,  82,  83,  84,  85,  86,  87,  88,  -1,  -1,  91,  92,  93,  94,  95,  96,  97,  -1,  99,
-    100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 3,   4,   5,   6,   7,   8,
-    9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  -1,  20,  21,  22,  -1,  24,  25,  26,  -1,
-    -1,  29,  30,  31,  32,  33,  34,  35,  -1,  -1,  -1,  39,  -1,  -1,  -1,  -1,  44,  45,  46,
-    47,  48,  49,  50,  51,  52,  -1,  -1,  -1,  56,  57,  58,  59,  -1,  -1,  -1,  63,  64,  65,
-    66,  67,  68,  69,  70,  71,  72,  -1,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,
-    85,  86,  87,  88,  -1,  -1,  91,  92,  93,  94,  95,  96,  97,  -1,  99,  100, 101, 102, 103,
-    104, 105, 106, 107, 108, 109, 110, 111, 112, 3,   4,   5,   6,   7,   8,   9,   10,  11,  12,
-    13,  14,  15,  16,  17,  18,  -1,  20,  21,  22,  -1,  24,  25,  26,  -1,  -1,  29,  30,  31,
-    32,  33,  34,  35,  -1,  -1,  -1,  39,  -1,  -1,  -1,  -1,  44,  45,  46,  47,  48,  49,  50,
-    51,  52,  -1,  -1,  -1,  56,  57,  58,  59,  -1,  -1,  -1,  63,  64,  65,  66,  67,  68,  69,
-    70,  71,  72,  -1,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,
-    -1,  -1,  91,  92,  93,  94,  95,  96,  97,  -1,  99,  100, 101, 102, 103, 104, 105, 106, 107,
-    108, 109, 110, 111, 112, 3,   4,   5,   -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  26,  -1,  -1,  29,  30,  31,  32,  33,  34,  35,
-    -1,  -1,  -1,  39,  -1,  -1,  -1,  -1,  -1,  45,  46,  47,  48,  49,  -1,  51,  52,  -1,  -1,
-    -1,  56,  57,  58,  59,  -1,  -1,  -1,  63,  64,  65,  -1,  67,  68,  69,  70,  71,  72,  -1,
-    74,  75,  76,  77,  78,  79,  80,  81,  82,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  91,  92,
-    93,  94,  95,  96,  97,  -1,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
-    6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  -1,  20,  21,  22,  -1,  24,
-    25,  -1,  -1,  27,  28,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  36,  37,  38,  -1,  40,  41,  42,
-    44,  -1,  -1,  -1,  -1,  -1,  50,  -1,  -1,  -1,  53,  54,  55,  -1,  -1,  -1,  -1,  60,  61,
-    62,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  73,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  89,  90,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  98,  -1,
-    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  112, -1,  113, 114, 115, 116, 117, 118,
-    119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 27,  28,  -1,  -1,  -1,
-    -1,  -1,  -1,  -1,  36,  37,  38,  -1,  40,  41,  42,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-    -1,  -1,  53,  54,  55,  -1,  -1,  -1,  -1,  60,  61,  62,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-    -1,  -1,  -1,  73,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-    89,  90,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  98,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-    -1,  -1,  -1,  -1,  -1,  113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
-    127, 128, 129, 130, 131, 132, 27,  28,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  36,  37,  38,  -1,
-    40,  41,  42,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  53,  54,  55,  -1,  -1,  -1,
-    -1,  60,  61,  62,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  73,  -1,  -1,  -1,  -1,
-    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  89,  90,  -1,  -1,  -1,  -1,  -1,  -1,
-    -1,  98,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  113, 114, 115,
-    116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130};
+    44,  16,  16,  16,  56,  367, 228, 52,  91,  370, 55,  74,  52,  374, 444, 55,  55,  52,  3,
+    4,   55,  52,  383, 384, 55,  43,  456, 44,  74,  390, 476, 392, 40,  41,  42,  230, 99,  120,
+    371, 372, 240, 241, 91,  44,  91,  240, 241, 657, 90,  410, 496, 412, 413, 99,  71,  240, 241,
+    418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 400, 114, 430, 71,  36,  37,  91,  684, 40,
+    41,  10,  439, 240, 241, 443, 240, 241, 17,  18,  19,  448, 53,  54,  23,  240, 241, 454, 455,
+    60,  61,  458, 240, 241, 240, 241, 463, 464, 235, 466, 0,   468, 91,  240, 241, 240, 241, 43,
+    475, 90,  477, 91,  479, 127, 91,  482, 483, 484, 485, 91,  91,  44,  36,  37,  38,  44,  40,
+    41,  42,  22,  497, 240, 241, 500, 240, 241, 240, 241, 7,   53,  54,  55,  240, 241, 511, 91,
+    60,  61,  62,  84,  85,  86,  87,  88,  89,  66,  523, 524, 525, 526, 240, 241, 403, 404, 44,
+    532, 533, 17,  44,  536, 71,  43,  90,  540, 90,  542, 543, 90,  229, 13,  547, 617, 549, 229,
+    229, 552, 553, 554, 229, 556, 44,  558, 229, 90,  561, 562, 563, 564, 90,  90,  90,  90,  90,
+    431, 90,  90,  90,  228, 228, 576, 201, 125, 126, 127, 128, 90,  90,  90,  44,  375, 90,  44,
+    589, 590, 90,  90,  382, 594, 596, 385, 386, 90,  90,  90,  44,  44,  603, 393, 394, 606, 607,
+    608, 398, 610, 44,  44,  8,   238, 9,   44,  44,  44,  44,  620, 44,  622, 44,  44,  44,  626,
+    44,  6,   44,  44,  27,  28,  44,  13,  44,  636, 44,  638, 639, 36,  37,  38,  11,  40,  41,
+    42,  11,  13,  25,  12,  44,  652, 44,  44,  655, 44,  53,  54,  55,  44,  44,  44,  44,  60,
+    61,  62,  44,  668, 44,  44,  44,  44,  44,  43,  13,  43,  43,  74,  363, 43,  13,  682, 43,
+    14,  44,  43,  378, 379, 380, 44,  691, 692, 43,  90,  91,  44,  43,  43,  16,  44,  43,  13,
+    99,  395, 13,  43,  43,  43,  43,  43,  15,  24,  44,  405, 406, 43,  408, 114, 115, 116, 117,
+    118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 43,  428, 44,  44,  20,
+    44,  43,  21,  44,  44,  44,  44,  44,  43,  43,  43,  21,  44,  44,  44,  44,  44,  44,  44,
+    44,  444, 44,  44,  228, 44,  583, 44,  44,  44,  44,  44,  44,  456, 44,  213, 44,  431, 431,
+    431, 44,  3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  44,
+    20,  21,  22,  44,  24,  25,  26,  44,  241, 29,  30,  31,  32,  33,  34,  35,  656, 587, 624,
+    39,  581, 590, 365, 252, 44,  45,  46,  47,  48,  49,  50,  51,  52,  -1,  -1,  516, 56,  57,
+    58,  59,  -1,  -1,  -1,  63,  64,  65,  66,  67,  68,  69,  -1,  71,  72,  73,  -1,  75,  76,
+    77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  -1,  -1,  92,  93,  94,  95,
+    96,  97,  98,  -1,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, -1,
+    -1,  -1,  -1,  -1,  -1,  581, 3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,
+    16,  17,  18,  -1,  20,  21,  22,  -1,  24,  25,  26,  -1,  -1,  29,  30,  31,  32,  33,  34,
+    35,  -1,  -1,  617, 39,  -1,  -1,  -1,  -1,  44,  45,  46,  47,  48,  49,  50,  51,  52,  -1,
+    -1,  -1,  56,  57,  58,  59,  -1,  -1,  -1,  63,  64,  65,  66,  67,  68,  69,  -1,  71,  72,
+    73,  -1,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  -1,  -1,
+    92,  93,  94,  95,  96,  97,  98,  -1,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
+    111, 112, 113, 3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,
+    -1,  20,  21,  22,  -1,  24,  25,  26,  -1,  -1,  29,  30,  31,  32,  33,  34,  35,  -1,  -1,
+    -1,  39,  -1,  -1,  -1,  -1,  44,  45,  46,  47,  48,  49,  50,  51,  52,  -1,  -1,  -1,  56,
+    57,  58,  59,  -1,  -1,  -1,  63,  64,  65,  66,  67,  68,  69,  -1,  71,  72,  73,  -1,  75,
+    76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  -1,  -1,  92,  93,  94,
+    95,  96,  97,  98,  -1,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
+    3,   4,   5,   -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+    -1,  -1,  -1,  -1,  26,  -1,  -1,  29,  30,  31,  32,  33,  34,  35,  -1,  -1,  -1,  39,  -1,
+    -1,  -1,  -1,  -1,  45,  46,  47,  48,  49,  -1,  51,  52,  -1,  -1,  -1,  56,  57,  58,  59,
+    -1,  -1,  -1,  63,  64,  65,  -1,  67,  68,  69,  -1,  71,  72,  73,  -1,  75,  76,  77,  78,
+    79,  80,  81,  82,  83,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  92,  93,  94,  95,  96,  97,
+    98,  -1,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 5,   6,   7,   8,
+    9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  -1,  20,  21,  22,  -1,  24,  25,  -1,  6,
+    7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  -1,  20,  21,  22,  44,  24,  25,
+    -1,  -1,  -1,  50,  -1,  -1,  27,  28,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  36,  37,  38,  44,
+    40,  41,  42,  -1,  70,  50,  72,  -1,  -1,  -1,  -1,  -1,  -1,  53,  54,  55,  -1,  -1,  -1,
+    -1,  60,  61,  62,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  74,  -1,  -1,  -1,
+    -1,  84,  85,  86,  87,  88,  89,  -1,  -1,  113, -1,  -1,  90,  91,  -1,  -1,  -1,  -1,  -1,
+    -1,  -1,  99,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  113, -1,  -1,  -1,  -1,  -1,  114, 115,
+    116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 27,
+    28,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  36,  37,  38,  -1,  40,  41,  42,  -1,  -1,  -1,  -1,
+    -1,  -1,  -1,  -1,  -1,  -1,  53,  54,  55,  -1,  -1,  -1,  -1,  60,  61,  62,  -1,  -1,  -1,
+    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  74,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+    -1,  -1,  -1,  -1,  -1,  90,  91,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  99,  -1,  -1,  -1,  -1,
+    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  114, 115, 116, 117, 118, 119, 120, 121, 122,
+    123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 27,  28,  -1,  -1,  -1,  -1,  -1,  -1,
+    -1,  36,  37,  38,  -1,  40,  41,  42,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  53,
+    54,  55,  -1,  -1,  -1,  -1,  60,  61,  62,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+    -1,  74,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  91,
+    -1,  -1,  -1,  -1,  -1,  -1,  -1,  99,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+    -1,  -1,  -1,  114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
+    130, 131, 132, 133};
 
 const short ParserGen::yystos_[] = {
-    0,   10,  17,  18,  19,  23,  279, 90,  270, 89,  175, 270, 270, 90,  273, 0,   271, 90,  176,
-    274, 6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  20,  21,  22,  24,  25,
-    44,  50,  112, 138, 139, 141, 142, 147, 83,  84,  85,  86,  87,  88,  177, 178, 179, 180, 181,
-    182, 183, 43,  3,   4,   5,   26,  29,  30,  31,  32,  33,  34,  35,  39,  44,  45,  46,  47,
-    48,  49,  51,  52,  56,  57,  58,  59,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  74,
-    75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  91,  92,  93,  94,  95,
-    96,  97,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 137, 139, 140, 141,
-    142, 143, 278, 27,  28,  36,  37,  38,  40,  41,  42,  53,  54,  55,  60,  61,  62,  73,  89,
-    90,  98,  113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-    130, 131, 132, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
-    164, 165, 166, 167, 168, 169, 170, 171, 172, 174, 272, 90,  152, 154, 155, 156, 186, 90,  90,
-    186, 280, 281, 44,  36,  37,  40,  41,  53,  54,  60,  61,  90,  275, 276, 159, 268, 173, 44,
-    184, 22,  7,   90,  176, 66,  268, 43,  44,  143, 146, 44,  50,  135, 137, 139, 140, 141, 144,
-    186, 160, 73,  98,  277, 159, 27,  28,  36,  37,  38,  40,  41,  42,  53,  54,  55,  60,  61,
-    62,  89,  90,  124, 125, 126, 127, 148, 149, 150, 151, 153, 157, 158, 160, 162, 163, 164, 166,
-    167, 168, 185, 188, 190, 191, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
-    206, 207, 208, 209, 210, 211, 212, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
-    226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
-    245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 185, 44,  17,
-    44,  169, 187, 188, 267, 3,   4,   5,   26,  29,  30,  31,  32,  33,  34,  35,  39,  45,  46,
-    47,  48,  49,  51,  52,  56,  57,  58,  59,  63,  64,  65,  67,  68,  69,  70,  71,  72,  74,
-    75,  76,  77,  78,  79,  80,  81,  82,  91,  92,  93,  94,  95,  96,  97,  99,  100, 101, 102,
-    103, 104, 105, 106, 107, 108, 109, 110, 111, 192, 155, 267, 43,  187, 190, 190, 89,  189, 187,
-    189, 89,  89,  280, 280, 280, 89,  189, 187, 187, 189, 189, 89,  89,  89,  187, 89,  187, 189,
-    189, 280, 89,  89,  189, 89,  190, 89,  213, 280, 213, 213, 280, 280, 89,  280, 89,  187, 89,
-    187, 187, 89,  89,  89,  89,  187, 187, 187, 187, 187, 187, 187, 187, 187, 187, 280, 89,  187,
-    44,  136, 137, 139, 141, 142, 145, 44,  44,  44,  44,  187, 44,  44,  44,  267, 159, 13,  9,
-    8,   187, 44,  44,  44,  44,  44,  187, 187, 159, 44,  187, 44,  44,  44,  6,   265, 187, 187,
-    44,  187, 44,  187, 44,  13,  44,  44,  11,  11,  187, 265, 187, 44,  187, 44,  44,  187, 187,
-    187, 187, 44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  265, 187, 44,  187, 187, 43,  43,
-    187, 187, 187, 187, 187, 187, 43,  187, 187, 13,  187, 187, 43,  187, 187, 187, 187, 187, 13,
-    187, 187, 187, 187, 187, 187, 13,  187, 43,  44,  44,  14,  261, 12,  263, 263, 43,  187, 269,
-    269, 44,  43,  187, 43,  267, 44,  43,  16,  266, 13,  13,  43,  187, 43,  43,  187, 187, 187,
-    43,  187, 43,  187, 15,  262, 187, 24,  264, 264, 44,  187, 43,  43,  44,  44,  44,  43,  44,
-    187, 20,  187, 187, 44,  44,  44,  44,  43,  43,  43,  44,  44,  44,  187, 25,  187, 261, 262,
-    44,  44,  44,  44,  187, 21,  21,  44,  44,  44,  44,  44,  187, 262, 44,  44,  187, 187, 44,
-    44,  44,  44,  44,  44,  44,  44,  44};
+    0,   10,  17,  18,  19,  23,  286, 91,  270, 90,  175, 270, 270, 91,  280, 0,   271, 91,  176,
+    281, 5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  20,  21,  22,  24,
+    25,  44,  50,  70,  72,  113, 139, 140, 142, 143, 275, 276, 279, 84,  85,  86,  87,  88,  89,
+    177, 178, 179, 180, 181, 182, 183, 43,  3,   4,   5,   26,  29,  30,  31,  32,  33,  34,  35,
+    39,  44,  45,  46,  47,  48,  49,  51,  52,  56,  57,  58,  59,  63,  64,  65,  66,  67,  68,
+    69,  71,  72,  73,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,
+    92,  93,  94,  95,  96,  97,  98,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+    112, 138, 140, 141, 142, 143, 144, 285, 27,  28,  36,  37,  38,  40,  41,  42,  53,  54,  55,
+    60,  61,  62,  74,  91,  99,  114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
+    127, 128, 129, 130, 131, 132, 133, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 160,
+    161, 162, 163, 164, 165, 166, 167, 168, 169, 174, 273, 90,  91,  152, 154, 155, 156, 186, 91,
+    91,  186, 287, 288, 44,  36,  37,  40,  41,  53,  54,  60,  61,  91,  282, 283, 272, 270, 44,
+    184, 22,  7,   91,  176, 66,  44,  71,  277, 278, 274, 44,  50,  136, 138, 140, 141, 142, 145,
+    186, 160, 74,  99,  284, 91,  168, 43,  270, 27,  28,  36,  37,  38,  40,  41,  42,  53,  54,
+    55,  60,  61,  62,  90,  91,  125, 126, 127, 128, 148, 149, 150, 151, 153, 157, 158, 160, 162,
+    163, 164, 166, 167, 168, 185, 188, 190, 191, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
+    203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 214, 215, 216, 217, 218, 219, 220, 221, 222,
+    223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
+    242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,
+    185, 44,  17,  44,  277, 169, 187, 188, 267, 3,   4,   5,   26,  29,  30,  31,  32,  33,  34,
+    35,  39,  45,  46,  47,  48,  49,  51,  52,  56,  57,  58,  59,  63,  64,  65,  67,  68,  69,
+    71,  72,  73,  75,  76,  77,  78,  79,  80,  81,  82,  83,  92,  93,  94,  95,  96,  97,  98,
+    100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 192, 155, 272, 267, 43,  187,
+    190, 190, 90,  189, 187, 189, 90,  90,  287, 287, 287, 90,  189, 187, 187, 189, 189, 90,  90,
+    90,  187, 90,  187, 189, 189, 287, 90,  90,  189, 90,  190, 90,  213, 287, 213, 213, 287, 287,
+    90,  287, 90,  187, 90,  187, 187, 90,  90,  90,  90,  187, 187, 187, 187, 187, 187, 187, 187,
+    187, 187, 287, 90,  187, 44,  137, 138, 140, 142, 143, 146, 44,  44,  44,  44,  44,  187, 44,
+    44,  44,  267, 90,  91,  159, 169, 170, 171, 172, 13,  9,   8,   187, 44,  44,  44,  44,  44,
+    187, 187, 159, 44,  187, 44,  44,  44,  6,   265, 187, 187, 44,  187, 44,  187, 44,  13,  44,
+    44,  11,  11,  187, 265, 187, 44,  187, 44,  44,  187, 187, 187, 187, 44,  44,  44,  44,  44,
+    44,  44,  44,  44,  44,  265, 187, 44,  187, 187, 43,  159, 268, 173, 43,  187, 187, 187, 187,
+    187, 187, 43,  187, 187, 13,  187, 187, 43,  187, 187, 187, 187, 187, 13,  187, 187, 187, 187,
+    187, 187, 13,  187, 43,  44,  268, 43,  44,  144, 147, 44,  14,  261, 12,  263, 263, 43,  187,
+    269, 269, 44,  43,  187, 43,  267, 44,  43,  16,  266, 13,  13,  43,  187, 43,  43,  187, 187,
+    187, 43,  187, 43,  159, 187, 15,  262, 187, 24,  264, 264, 44,  187, 43,  43,  44,  44,  44,
+    43,  44,  187, 20,  187, 187, 44,  44,  44,  44,  43,  43,  43,  44,  44,  44,  187, 25,  187,
+    261, 262, 44,  44,  44,  44,  187, 21,  21,  44,  44,  44,  44,  44,  187, 262, 44,  44,  187,
+    187, 44,  44,  44,  44,  44,  44,  44,  44,  44};
 
 const short ParserGen::yyr1_[] = {
-    0,   134, 279, 279, 279, 279, 279, 175, 176, 176, 281, 280, 177, 177, 177, 177, 177, 177, 183,
-    178, 179, 186, 186, 186, 186, 180, 181, 182, 184, 184, 144, 144, 185, 185, 185, 185, 185, 185,
+    0,   135, 286, 286, 286, 286, 286, 175, 176, 176, 288, 287, 177, 177, 177, 177, 177, 177, 183,
+    178, 179, 186, 186, 186, 186, 180, 181, 182, 184, 184, 145, 145, 185, 185, 185, 185, 185, 185,
     185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
-    185, 185, 185, 185, 185, 185, 185, 185, 135, 135, 135, 135, 270, 271, 271, 147, 272, 138, 138,
-    138, 141, 137, 137, 137, 137, 137, 137, 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
-    139, 139, 139, 139, 139, 139, 139, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
-    140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
-    140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
-    140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 160, 160, 160, 161, 174, 162, 163,
-    164, 166, 167, 168, 148, 149, 150, 151, 153, 157, 158, 152, 152, 152, 152, 154, 154, 154, 154,
-    155, 155, 155, 155, 156, 156, 156, 156, 165, 165, 169, 169, 169, 169, 169, 169, 169, 169, 169,
-    169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 267, 267, 187, 187, 189, 188, 188,
-    188, 188, 188, 188, 188, 188, 190, 191, 192, 192, 145, 136, 136, 136, 136, 142, 193, 193, 193,
-    193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 194, 195, 246, 247, 248,
-    249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 196, 196, 196, 197, 198, 199, 203,
-    203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
-    203, 203, 204, 263, 263, 264, 264, 205, 206, 269, 269, 269, 207, 208, 265, 265, 209, 216, 226,
-    266, 266, 213, 210, 211, 212, 214, 215, 217, 218, 219, 220, 221, 222, 223, 224, 225, 277, 277,
-    275, 273, 274, 274, 276, 276, 276, 276, 276, 276, 276, 276, 278, 278, 200, 200, 201, 202, 159,
-    159, 170, 170, 171, 268, 268, 172, 173, 173, 146, 143, 143, 143, 143, 143, 227, 227, 227, 227,
-    227, 227, 227, 228, 229, 230, 231, 232, 233, 234, 235, 235, 235, 235, 235, 235, 235, 235, 235,
-    235, 261, 261, 262, 262, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245};
+    185, 185, 185, 185, 185, 185, 185, 185, 136, 136, 136, 136, 270, 271, 271, 275, 275, 273, 273,
+    272, 272, 277, 278, 278, 276, 279, 279, 279, 274, 274, 139, 139, 139, 142, 138, 138, 138, 138,
+    138, 138, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
+    140, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+    141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+    141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+    141, 141, 141, 141, 141, 141, 160, 160, 160, 161, 174, 162, 163, 164, 166, 167, 168, 148, 149,
+    150, 151, 153, 157, 158, 152, 152, 152, 152, 154, 154, 154, 154, 155, 155, 155, 155, 156, 156,
+    156, 156, 165, 165, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
+    169, 169, 169, 169, 169, 169, 267, 267, 187, 187, 189, 188, 188, 188, 188, 188, 188, 188, 188,
+    190, 191, 192, 192, 146, 137, 137, 137, 137, 143, 193, 193, 193, 193, 193, 193, 193, 193, 193,
+    193, 193, 193, 193, 193, 193, 193, 193, 194, 195, 246, 247, 248, 249, 250, 251, 252, 253, 254,
+    255, 256, 257, 258, 259, 260, 196, 196, 196, 197, 198, 199, 203, 203, 203, 203, 203, 203, 203,
+    203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 204, 263, 263, 264,
+    264, 205, 206, 269, 269, 269, 207, 208, 265, 265, 209, 216, 226, 266, 266, 213, 210, 211, 212,
+    214, 215, 217, 218, 219, 220, 221, 222, 223, 224, 225, 284, 284, 282, 280, 281, 281, 283, 283,
+    283, 283, 283, 283, 283, 283, 285, 285, 200, 200, 201, 202, 159, 159, 170, 170, 171, 268, 268,
+    172, 173, 173, 147, 144, 144, 144, 144, 144, 227, 227, 227, 227, 227, 227, 227, 228, 229, 230,
+    231, 232, 233, 234, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 261, 261, 262, 262, 236,
+    237, 238, 239, 240, 241, 242, 243, 244, 245};
 
 const signed char ParserGen::yyr2_[] = {
-    0,  2, 2, 2, 2, 2, 2, 3, 0, 4, 0, 2,  1,  1, 1,  1, 1, 1, 5, 3, 7, 1, 1, 1, 1, 2, 2, 4, 0, 2,
-    2,  2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1,  1, 1, 1, 1, 1, 1, 1, 1, 3, 0, 2,  2,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,  2,  1, 1,  4, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 0, 2, 2, 1,
-    1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1,  1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 7, 4, 4, 4, 7,
-    4,  7, 8, 7, 7, 4, 7, 7, 1, 1, 1, 4,  4,  6, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1,  1, 1, 1, 1, 1, 6, 0, 2, 0, 2, 11, 10, 0, 1,  2, 8, 8, 0, 2, 8, 8, 8, 0, 2, 7, 4, 4, 4, 11,
-    11, 7, 4, 4, 7, 8, 8, 8, 4, 4, 1, 1,  4,  3, 0,  2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 6, 6,
-    1,  1, 1, 1, 3, 0, 2, 3, 0, 2, 2, 1,  1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 4, 4, 4,
-    1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2,  0,  2, 11, 4, 4, 4, 4, 4, 4, 4, 4, 4};
+    0, 2,  2,  2, 2, 2, 2, 3, 0, 4, 0, 2, 1, 1, 1,  1,  1, 1, 5, 3, 7, 1, 1, 1, 1, 2, 2, 4, 0, 2, 2,
+    2, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1,  1,  1, 1, 1, 1, 3, 0, 2, 2, 1, 1, 3, 0,  2,  1, 2, 5, 5, 1, 1, 1, 0, 2, 1, 1, 1, 1, 1, 1,
+    1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 0, 2, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 3,
+    3, 0,  2,  2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 7,
+    4, 4,  4,  7, 4, 7, 8, 7, 7, 4, 7, 7, 1, 1, 1,  4,  4, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1,  1,  1, 1, 1, 1, 1, 1, 6, 0, 2, 0, 2, 11, 10, 0, 1, 2, 8, 8, 0, 2, 8, 8, 8, 0, 2, 7, 4, 4,
+    4, 11, 11, 7, 4, 4, 7, 8, 8, 8, 4, 4, 1, 1, 4,  3,  0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 6,
+    6, 1,  1,  1, 1, 3, 0, 2, 3, 0, 2, 2, 1, 1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 4, 4, 4,
+    1, 1,  1,  1, 1, 1, 1, 1, 1, 1, 0, 2, 0, 2, 11, 4,  4, 4, 4, 4, 4, 4, 4, 4};
 
 
 // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
@@ -5894,6 +6055,7 @@ const char* const ParserGen::yytname_[] = {"\"EOF\"",
                                            "MOD",
                                            "MULTIPLY",
                                            "NE",
+                                           "NOR",
                                            "NOT",
                                            "OR",
                                            "POW",
@@ -5962,7 +6124,7 @@ const char* const ParserGen::yytname_[] = {"\"EOF\"",
                                            "projectionFieldname",
                                            "expressionFieldname",
                                            "stageAsUserFieldname",
-                                           "filterFieldname",
+                                           "predFieldname",
                                            "argAsUserFieldname",
                                            "aggExprAsUserFieldname",
                                            "invariableUserFieldname",
@@ -5971,7 +6133,6 @@ const char* const ParserGen::yytname_[] = {"\"EOF\"",
                                            "projectField",
                                            "expressionField",
                                            "valueField",
-                                           "filterField",
                                            "dbPointer",
                                            "javascript",
                                            "symbol",
@@ -6094,9 +6255,16 @@ const char* const ParserGen::yytname_[] = {"\"EOF\"",
                                            "expressions",
                                            "values",
                                            "exprZeroToTwo",
-                                           "matchExpression",
-                                           "filterFields",
-                                           "filterVal",
+                                           "match",
+                                           "predicates",
+                                           "compoundMatchExprs",
+                                           "predValue",
+                                           "additionalExprs",
+                                           "predicate",
+                                           "logicalExpr",
+                                           "operatorExpression",
+                                           "notExpr",
+                                           "logicalExprField",
                                            "sortSpecs",
                                            "specList",
                                            "metaSort",
@@ -6110,32 +6278,33 @@ const char* const ParserGen::yytname_[] = {"\"EOF\"",
 
 #if YYDEBUG
 const short ParserGen::yyrline_[] = {
-    0,    299,  299,  302,  305,  308,  311,  318,  324,  325,  333,  333,  336,  336,  336,  336,
-    336,  336,  339,  349,  355,  365,  365,  365,  365,  369,  374,  379,  395,  398,  405,  408,
-    414,  415,  416,  417,  418,  419,  420,  421,  422,  423,  424,  425,  428,  431,  434,  437,
-    440,  443,  446,  449,  452,  455,  458,  461,  464,  467,  470,  473,  476,  479,  480,  481,
-    482,  491,  491,  491,  491,  495,  501,  504,  510,  516,  521,  521,  521,  525,  533,  536,
-    539,  542,  545,  548,  557,  560,  563,  566,  569,  572,  575,  578,  581,  584,  587,  590,
-    593,  596,  599,  602,  605,  608,  616,  619,  622,  625,  628,  631,  634,  637,  640,  643,
-    646,  649,  652,  655,  658,  661,  664,  667,  670,  673,  676,  679,  682,  685,  688,  691,
-    694,  697,  700,  703,  706,  709,  712,  715,  718,  721,  724,  727,  730,  733,  736,  739,
-    742,  745,  748,  751,  754,  757,  760,  763,  766,  769,  772,  775,  778,  781,  784,  787,
-    790,  793,  796,  799,  806,  811,  814,  820,  828,  837,  843,  849,  855,  861,  867,  873,
-    879,  885,  891,  897,  903,  909,  915,  918,  921,  924,  930,  933,  936,  939,  945,  948,
-    951,  954,  960,  963,  966,  969,  975,  978,  984,  985,  986,  987,  988,  989,  990,  991,
-    992,  993,  994,  995,  996,  997,  998,  999,  1000, 1001, 1002, 1003, 1004, 1011, 1012, 1019,
-    1019, 1023, 1028, 1028, 1028, 1028, 1028, 1028, 1029, 1029, 1035, 1043, 1049, 1052, 1059, 1066,
-    1066, 1066, 1066, 1070, 1076, 1076, 1076, 1076, 1076, 1076, 1076, 1076, 1076, 1076, 1076, 1076,
-    1076, 1077, 1077, 1077, 1077, 1081, 1088, 1094, 1099, 1104, 1110, 1115, 1120, 1125, 1131, 1136,
-    1142, 1151, 1157, 1163, 1168, 1174, 1180, 1180, 1180, 1184, 1191, 1198, 1205, 1205, 1205, 1205,
-    1205, 1205, 1205, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1207, 1207, 1207, 1207, 1207,
-    1207, 1207, 1211, 1221, 1224, 1230, 1233, 1239, 1248, 1257, 1260, 1263, 1269, 1280, 1291, 1294,
-    1300, 1308, 1316, 1324, 1327, 1332, 1341, 1347, 1353, 1359, 1369, 1379, 1386, 1393, 1400, 1408,
-    1416, 1424, 1432, 1438, 1444, 1447, 1453, 1459, 1464, 1467, 1474, 1477, 1480, 1483, 1486, 1489,
-    1492, 1495, 1500, 1502, 1508, 1508, 1512, 1519, 1526, 1526, 1530, 1530, 1534, 1540, 1541, 1548,
-    1554, 1557, 1564, 1571, 1572, 1573, 1574, 1575, 1578, 1578, 1578, 1578, 1578, 1578, 1578, 1580,
-    1585, 1590, 1595, 1600, 1605, 1610, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625,
-    1630, 1633, 1640, 1643, 1649, 1659, 1664, 1669, 1674, 1679, 1684, 1689, 1694, 1699};
+    0,    304,  304,  307,  310,  313,  316,  323,  329,  330,  338,  338,  341,  341,  341,  341,
+    341,  341,  344,  354,  360,  370,  370,  370,  370,  374,  379,  384,  400,  403,  410,  413,
+    419,  420,  421,  422,  423,  424,  425,  426,  427,  428,  429,  430,  433,  436,  439,  442,
+    445,  448,  451,  454,  457,  460,  463,  466,  469,  472,  475,  478,  481,  484,  485,  486,
+    487,  496,  496,  496,  496,  500,  506,  509,  515,  518,  527,  528,  534,  537,  544,  547,
+    551,  560,  568,  569,  570,  573,  576,  583,  583,  583,  586,  594,  597,  600,  603,  606,
+    609,  618,  621,  624,  627,  630,  633,  636,  639,  642,  645,  648,  651,  654,  657,  660,
+    663,  666,  669,  677,  680,  683,  686,  689,  692,  695,  698,  701,  704,  707,  710,  713,
+    716,  719,  722,  725,  728,  731,  734,  737,  740,  743,  746,  749,  752,  755,  758,  761,
+    764,  767,  770,  773,  776,  779,  782,  785,  788,  791,  794,  797,  800,  803,  806,  809,
+    812,  815,  818,  821,  824,  827,  830,  833,  836,  839,  842,  845,  848,  851,  854,  857,
+    860,  867,  872,  875,  881,  889,  898,  904,  910,  916,  922,  928,  934,  940,  946,  952,
+    958,  964,  970,  976,  979,  982,  985,  991,  994,  997,  1000, 1006, 1009, 1012, 1015, 1021,
+    1024, 1027, 1030, 1036, 1039, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055,
+    1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1072, 1073, 1080, 1080, 1084, 1089,
+    1089, 1089, 1089, 1089, 1089, 1090, 1090, 1096, 1104, 1110, 1113, 1120, 1127, 1127, 1127, 1127,
+    1131, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1137, 1138, 1138,
+    1138, 1138, 1142, 1149, 1155, 1160, 1165, 1171, 1176, 1181, 1186, 1192, 1197, 1203, 1212, 1218,
+    1224, 1229, 1235, 1241, 1241, 1241, 1245, 1252, 1259, 1266, 1266, 1266, 1266, 1266, 1266, 1266,
+    1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1268, 1268, 1268, 1268, 1268, 1268, 1268, 1272,
+    1282, 1285, 1291, 1294, 1300, 1309, 1318, 1321, 1324, 1330, 1341, 1352, 1355, 1361, 1369, 1377,
+    1385, 1388, 1393, 1402, 1408, 1414, 1420, 1430, 1440, 1447, 1454, 1461, 1469, 1477, 1485, 1493,
+    1499, 1505, 1508, 1514, 1520, 1525, 1528, 1535, 1538, 1541, 1544, 1547, 1550, 1553, 1556, 1561,
+    1563, 1569, 1569, 1573, 1580, 1587, 1587, 1591, 1591, 1595, 1601, 1602, 1609, 1615, 1618, 1625,
+    1632, 1633, 1634, 1635, 1636, 1639, 1639, 1639, 1639, 1639, 1639, 1639, 1641, 1646, 1651, 1656,
+    1661, 1666, 1671, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1691, 1694, 1701,
+    1704, 1710, 1720, 1725, 1730, 1735, 1740, 1745, 1750, 1755, 1760};
 
 // Print the state stack on the debug stream.
 void ParserGen::yystack_print_() {
@@ -6160,6 +6329,6 @@ void ParserGen::yy_reduce_print_(int yyrule) {
 
 #line 57 "src/mongo/db/cst/grammar.yy"
 }  // namespace mongo
-#line 5887 "src/mongo/db/cst/parser_gen.cpp"
+#line 6040 "src/mongo/db/cst/parser_gen.cpp"
 
-#line 1703 "src/mongo/db/cst/grammar.yy"
+#line 1764 "src/mongo/db/cst/grammar.yy"
diff --git a/src/mongo/db/cst/parser_gen.hpp b/src/mongo/db/cst/parser_gen.hpp
index 7fe3e6dfe2e..ac121559118 100644
--- a/src/mongo/db/cst/parser_gen.hpp
+++ b/src/mongo/db/cst/parser_gen.hpp
@@ -486,9 +486,11 @@ public:
             // sqrt
             // subtract
             // trunc
-            // matchExpression
-            // filterFields
-            // filterVal
+            // match
+            // predicates
+            // compoundMatchExprs
+            // predValue
+            // additionalExprs
             // sortSpecs
             // specList
             // metaSort
@@ -499,12 +501,13 @@ public:
             // projectionFieldname
             // expressionFieldname
             // stageAsUserFieldname
-            // filterFieldname
+            // predFieldname
             // argAsUserFieldname
             // aggExprAsUserFieldname
             // invariableUserFieldname
             // idAsUserFieldname
             // valueFieldname
+            // logicalExprField
             char dummy8[sizeof(CNode::Fieldname)];
 
             // "Date"
@@ -543,13 +546,16 @@ public:
             // projectField
             // expressionField
             // valueField
-            // filterField
             // onErrorArg
             // onNullArg
             // formatArg
             // timezoneArg
             // charsArg
             // optionsArg
+            // predicate
+            // logicalExpr
+            // operatorExpression
+            // notExpr
             // sortSpec
             char dummy20[sizeof(std::pair<CNode::Fieldname, CNode>)];
 
@@ -670,70 +676,71 @@ public:
             MOD = 67,
             MULTIPLY = 68,
             NE = 69,
-            NOT = 70,
-            OR = 71,
-            POW = 72,
-            RAND_VAL = 73,
-            REGEX_FIND = 74,
-            REGEX_FIND_ALL = 75,
-            REGEX_MATCH = 76,
-            REPLACE_ALL = 77,
-            REPLACE_ONE = 78,
-            ROUND = 79,
-            RTRIM = 80,
-            SPLIT = 81,
-            SQRT = 82,
-            STAGE_INHIBIT_OPTIMIZATION = 83,
-            STAGE_LIMIT = 84,
-            STAGE_PROJECT = 85,
-            STAGE_SAMPLE = 86,
-            STAGE_SKIP = 87,
-            STAGE_UNION_WITH = 88,
-            START_ARRAY = 89,
-            START_OBJECT = 90,
-            STR_CASE_CMP = 91,
-            STR_LEN_BYTES = 92,
-            STR_LEN_CP = 93,
-            SUBSTR = 94,
-            SUBSTR_BYTES = 95,
-            SUBSTR_CP = 96,
-            SUBTRACT = 97,
-            TEXT_SCORE = 98,
-            TO_BOOL = 99,
-            TO_DATE = 100,
-            TO_DECIMAL = 101,
-            TO_DOUBLE = 102,
-            TO_INT = 103,
-            TO_LONG = 104,
-            TO_LOWER = 105,
-            TO_OBJECT_ID = 106,
-            TO_STRING = 107,
-            TO_UPPER = 108,
-            TRIM = 109,
-            TRUNC = 110,
-            TYPE = 111,
-            FIELDNAME = 112,
-            STRING = 113,
-            BINARY = 114,
-            UNDEFINED = 115,
-            OBJECT_ID = 116,
-            DATE_LITERAL = 117,
-            JSNULL = 118,
-            REGEX = 119,
-            DB_POINTER = 120,
-            JAVASCRIPT = 121,
-            SYMBOL = 122,
-            JAVASCRIPT_W_SCOPE = 123,
-            INT_OTHER = 124,
-            LONG_OTHER = 125,
-            DOUBLE_OTHER = 126,
-            DECIMAL_OTHER = 127,
-            TIMESTAMP = 128,
-            MIN_KEY = 129,
-            MAX_KEY = 130,
-            DOLLAR_STRING = 131,
-            DOLLAR_DOLLAR_STRING = 132,
-            DOLLAR_PREF_FIELDNAME = 133
+            NOR = 70,
+            NOT = 71,
+            OR = 72,
+            POW = 73,
+            RAND_VAL = 74,
+            REGEX_FIND = 75,
+            REGEX_FIND_ALL = 76,
+            REGEX_MATCH = 77,
+            REPLACE_ALL = 78,
+            REPLACE_ONE = 79,
+            ROUND = 80,
+            RTRIM = 81,
+            SPLIT = 82,
+            SQRT = 83,
+            STAGE_INHIBIT_OPTIMIZATION = 84,
+            STAGE_LIMIT = 85,
+            STAGE_PROJECT = 86,
+            STAGE_SAMPLE = 87,
+            STAGE_SKIP = 88,
+            STAGE_UNION_WITH = 89,
+            START_ARRAY = 90,
+            START_OBJECT = 91,
+            STR_CASE_CMP = 92,
+            STR_LEN_BYTES = 93,
+            STR_LEN_CP = 94,
+            SUBSTR = 95,
+            SUBSTR_BYTES = 96,
+            SUBSTR_CP = 97,
+            SUBTRACT = 98,
+            TEXT_SCORE = 99,
+            TO_BOOL = 100,
+            TO_DATE = 101,
+            TO_DECIMAL = 102,
+            TO_DOUBLE = 103,
+            TO_INT = 104,
+            TO_LONG = 105,
+            TO_LOWER = 106,
+            TO_OBJECT_ID = 107,
+            TO_STRING = 108,
+            TO_UPPER = 109,
+            TRIM = 110,
+            TRUNC = 111,
+            TYPE = 112,
+            FIELDNAME = 113,
+            STRING = 114,
+            BINARY = 115,
+            UNDEFINED = 116,
+            OBJECT_ID = 117,
+            DATE_LITERAL = 118,
+            JSNULL = 119,
+            REGEX = 120,
+            DB_POINTER = 121,
+            JAVASCRIPT = 122,
+            SYMBOL = 123,
+            JAVASCRIPT_W_SCOPE = 124,
+            INT_OTHER = 125,
+            LONG_OTHER = 126,
+            DOUBLE_OTHER = 127,
+            DECIMAL_OTHER = 128,
+            TIMESTAMP = 129,
+            MIN_KEY = 130,
+            MAX_KEY = 131,
+            DOLLAR_STRING = 132,
+            DOLLAR_DOLLAR_STRING = 133,
+            DOLLAR_PREF_FIELDNAME = 134
         };
     };
 
@@ -957,27 +964,27 @@ public:
 
             // Type destructor.
             switch (yytype) {
-                case 114:  // "BinData"
+                case 115:  // "BinData"
                     value.template destroy<BSONBinData>();
                     break;
 
-                case 121:  // "Code"
+                case 122:  // "Code"
                     value.template destroy<BSONCode>();
                     break;
 
-                case 123:  // "CodeWScope"
+                case 124:  // "CodeWScope"
                     value.template destroy<BSONCodeWScope>();
                     break;
 
-                case 120:  // "dbPointer"
+                case 121:  // "dbPointer"
                     value.template destroy<BSONDBRef>();
                     break;
 
-                case 119:  // "regex"
+                case 120:  // "regex"
                     value.template destroy<BSONRegEx>();
                     break;
 
-                case 122:  // "Symbol"
+                case 123:  // "Symbol"
                     value.template destroy<BSONSymbol>();
                     break;
 
@@ -1094,92 +1101,98 @@ public:
                 case 258:  // sqrt
                 case 259:  // subtract
                 case 260:  // trunc
-                case 270:  // matchExpression
-                case 271:  // filterFields
-                case 272:  // filterVal
-                case 273:  // sortSpecs
-                case 274:  // specList
-                case 275:  // metaSort
-                case 276:  // oneOrNegOne
-                case 277:  // metaSortKeyword
+                case 270:  // match
+                case 271:  // predicates
+                case 272:  // compoundMatchExprs
+                case 273:  // predValue
+                case 274:  // additionalExprs
+                case 280:  // sortSpecs
+                case 281:  // specList
+                case 282:  // metaSort
+                case 283:  // oneOrNegOne
+                case 284:  // metaSortKeyword
                     value.template destroy<CNode>();
                     break;
 
-                case 135:  // projectionFieldname
-                case 136:  // expressionFieldname
-                case 137:  // stageAsUserFieldname
-                case 138:  // filterFieldname
-                case 139:  // argAsUserFieldname
-                case 140:  // aggExprAsUserFieldname
-                case 141:  // invariableUserFieldname
-                case 142:  // idAsUserFieldname
-                case 143:  // valueFieldname
+                case 136:  // projectionFieldname
+                case 137:  // expressionFieldname
+                case 138:  // stageAsUserFieldname
+                case 139:  // predFieldname
+                case 140:  // argAsUserFieldname
+                case 141:  // aggExprAsUserFieldname
+                case 142:  // invariableUserFieldname
+                case 143:  // idAsUserFieldname
+                case 144:  // valueFieldname
+                case 279:  // logicalExprField
                     value.template destroy<CNode::Fieldname>();
                     break;
 
-                case 117:  // "Date"
+                case 118:  // "Date"
                     value.template destroy<Date_t>();
                     break;
 
-                case 127:  // "arbitrary decimal"
+                case 128:  // "arbitrary decimal"
                     value.template destroy<Decimal128>();
                     break;
 
-                case 116:  // "ObjectID"
+                case 117:  // "ObjectID"
                     value.template destroy<OID>();
                     break;
 
-                case 128:  // "Timestamp"
+                case 129:  // "Timestamp"
                     value.template destroy<Timestamp>();
                     break;
 
-                case 130:  // "maxKey"
+                case 131:  // "maxKey"
                     value.template destroy<UserMaxKey>();
                     break;
 
-                case 129:  // "minKey"
+                case 130:  // "minKey"
                     value.template destroy<UserMinKey>();
                     break;
 
-                case 118:  // "null"
+                case 119:  // "null"
                     value.template destroy<UserNull>();
                     break;
 
-                case 115:  // "undefined"
+                case 116:  // "undefined"
                     value.template destroy<UserUndefined>();
                     break;
 
-                case 126:  // "arbitrary double"
+                case 127:  // "arbitrary double"
                     value.template destroy<double>();
                     break;
 
-                case 124:  // "arbitrary integer"
+                case 125:  // "arbitrary integer"
                     value.template destroy<int>();
                     break;
 
-                case 125:  // "arbitrary long"
+                case 126:  // "arbitrary long"
                     value.template destroy<long long>();
                     break;
 
-                case 144:  // projectField
-                case 145:  // expressionField
-                case 146:  // valueField
-                case 147:  // filterField
+                case 145:  // projectField
+                case 146:  // expressionField
+                case 147:  // valueField
                 case 261:  // onErrorArg
                 case 262:  // onNullArg
                 case 263:  // formatArg
                 case 264:  // timezoneArg
                 case 265:  // charsArg
                 case 266:  // optionsArg
-                case 278:  // sortSpec
+                case 275:  // predicate
+                case 276:  // logicalExpr
+                case 277:  // operatorExpression
+                case 278:  // notExpr
+                case 285:  // sortSpec
                     value.template destroy<std::pair<CNode::Fieldname, CNode>>();
                     break;
 
-                case 112:  // "fieldname"
-                case 113:  // "string"
-                case 131:  // "$-prefixed string"
-                case 132:  // "$$-prefixed string"
-                case 133:  // "$-prefixed fieldname"
+                case 113:  // "fieldname"
+                case 114:  // "string"
+                case 132:  // "$-prefixed string"
+                case 133:  // "$$-prefixed string"
+                case 134:  // "$-prefixed fieldname"
                     value.template destroy<std::string>();
                     break;
 
@@ -1287,12 +1300,12 @@ public:
                 tok == token::LOGTEN || tok == token::LONG_NEGATIVE_ONE || tok == token::LONG_ONE ||
                 tok == token::LONG_ZERO || tok == token::LT || tok == token::LTE ||
                 tok == token::LTRIM || tok == token::META || tok == token::MOD ||
-                tok == token::MULTIPLY || tok == token::NE || tok == token::NOT ||
-                tok == token::OR || tok == token::POW || tok == token::RAND_VAL ||
-                tok == token::REGEX_FIND || tok == token::REGEX_FIND_ALL ||
-                tok == token::REGEX_MATCH || tok == token::REPLACE_ALL ||
-                tok == token::REPLACE_ONE || tok == token::ROUND || tok == token::RTRIM ||
-                tok == token::SPLIT || tok == token::SQRT ||
+                tok == token::MULTIPLY || tok == token::NE || tok == token::NOR ||
+                tok == token::NOT || tok == token::OR || tok == token::POW ||
+                tok == token::RAND_VAL || tok == token::REGEX_FIND ||
+                tok == token::REGEX_FIND_ALL || tok == token::REGEX_MATCH ||
+                tok == token::REPLACE_ALL || tok == token::REPLACE_ONE || tok == token::ROUND ||
+                tok == token::RTRIM || tok == token::SPLIT || tok == token::SQRT ||
                 tok == token::STAGE_INHIBIT_OPTIMIZATION || tok == token::STAGE_LIMIT ||
                 tok == token::STAGE_PROJECT || tok == token::STAGE_SAMPLE ||
                 tok == token::STAGE_SKIP || tok == token::STAGE_UNION_WITH ||
@@ -1334,12 +1347,12 @@ public:
                 tok == token::LOGTEN || tok == token::LONG_NEGATIVE_ONE || tok == token::LONG_ONE ||
                 tok == token::LONG_ZERO || tok == token::LT || tok == token::LTE ||
                 tok == token::LTRIM || tok == token::META || tok == token::MOD ||
-                tok == token::MULTIPLY || tok == token::NE || tok == token::NOT ||
-                tok == token::OR || tok == token::POW || tok == token::RAND_VAL ||
-                tok == token::REGEX_FIND || tok == token::REGEX_FIND_ALL ||
-                tok == token::REGEX_MATCH || tok == token::REPLACE_ALL ||
-                tok == token::REPLACE_ONE || tok == token::ROUND || tok == token::RTRIM ||
-                tok == token::SPLIT || tok == token::SQRT ||
+                tok == token::MULTIPLY || tok == token::NE || tok == token::NOR ||
+                tok == token::NOT || tok == token::OR || tok == token::POW ||
+                tok == token::RAND_VAL || tok == token::REGEX_FIND ||
+                tok == token::REGEX_FIND_ALL || tok == token::REGEX_MATCH ||
+                tok == token::REPLACE_ALL || tok == token::REPLACE_ONE || tok == token::ROUND ||
+                tok == token::RTRIM || tok == token::SPLIT || tok == token::SQRT ||
                 tok == token::STAGE_INHIBIT_OPTIMIZATION || tok == token::STAGE_LIMIT ||
                 tok == token::STAGE_PROJECT || tok == token::STAGE_SAMPLE ||
                 tok == token::STAGE_SKIP || tok == token::STAGE_UNION_WITH ||
@@ -2206,6 +2219,15 @@ public:
     }
 #endif
 #if 201103L <= YY_CPLUSPLUS
+    static symbol_type make_NOR(location_type l) {
+        return symbol_type(token::NOR, std::move(l));
+    }
+#else
+    static symbol_type make_NOR(const location_type& l) {
+        return symbol_type(token::NOR, l);
+    }
+#endif
+#if 201103L <= YY_CPLUSPLUS
     static symbol_type make_NOT(location_type l) {
         return symbol_type(token::NOT, std::move(l));
     }
@@ -3056,10 +3078,10 @@ private:
     /// Constants.
     enum {
         yyeof_ = 0,
-        yylast_ = 1192,   ///< Last index in yytable_.
-        yynnts_ = 148,    ///< Number of nonterminal symbols.
+        yylast_ = 1238,   ///< Last index in yytable_.
+        yynnts_ = 154,    ///< Number of nonterminal symbols.
         yyfinal_ = 15,    ///< Termination state number.
-        yyntokens_ = 134  ///< Number of tokens.
+        yyntokens_ = 135  ///< Number of tokens.
     };
 
 
@@ -3078,27 +3100,27 @@ template <typename Base>
 ParserGen::basic_symbol<Base>::basic_symbol(basic_symbol&& that)
     : Base(std::move(that)), value(), location(std::move(that.location)) {
     switch (this->type_get()) {
-        case 114:  // "BinData"
+        case 115:  // "BinData"
             value.move<BSONBinData>(std::move(that.value));
             break;
 
-        case 121:  // "Code"
+        case 122:  // "Code"
             value.move<BSONCode>(std::move(that.value));
             break;
 
-        case 123:  // "CodeWScope"
+        case 124:  // "CodeWScope"
             value.move<BSONCodeWScope>(std::move(that.value));
             break;
 
-        case 120:  // "dbPointer"
+        case 121:  // "dbPointer"
             value.move<BSONDBRef>(std::move(that.value));
             break;
 
-        case 119:  // "regex"
+        case 120:  // "regex"
             value.move<BSONRegEx>(std::move(that.value));
             break;
 
-        case 122:  // "Symbol"
+        case 123:  // "Symbol"
             value.move<BSONSymbol>(std::move(that.value));
             break;
 
@@ -3215,92 +3237,98 @@ ParserGen::basic_symbol<Base>::basic_symbol(basic_symbol&& that)
         case 258:  // sqrt
         case 259:  // subtract
         case 260:  // trunc
-        case 270:  // matchExpression
-        case 271:  // filterFields
-        case 272:  // filterVal
-        case 273:  // sortSpecs
-        case 274:  // specList
-        case 275:  // metaSort
-        case 276:  // oneOrNegOne
-        case 277:  // metaSortKeyword
+        case 270:  // match
+        case 271:  // predicates
+        case 272:  // compoundMatchExprs
+        case 273:  // predValue
+        case 274:  // additionalExprs
+        case 280:  // sortSpecs
+        case 281:  // specList
+        case 282:  // metaSort
+        case 283:  // oneOrNegOne
+        case 284:  // metaSortKeyword
             value.move<CNode>(std::move(that.value));
             break;
 
-        case 135:  // projectionFieldname
-        case 136:  // expressionFieldname
-        case 137:  // stageAsUserFieldname
-        case 138:  // filterFieldname
-        case 139:  // argAsUserFieldname
-        case 140:  // aggExprAsUserFieldname
-        case 141:  // invariableUserFieldname
-        case 142:  // idAsUserFieldname
-        case 143:  // valueFieldname
+        case 136:  // projectionFieldname
+        case 137:  // expressionFieldname
+        case 138:  // stageAsUserFieldname
+        case 139:  // predFieldname
+        case 140:  // argAsUserFieldname
+        case 141:  // aggExprAsUserFieldname
+        case 142:  // invariableUserFieldname
+        case 143:  // idAsUserFieldname
+        case 144:  // valueFieldname
+        case 279:  // logicalExprField
             value.move<CNode::Fieldname>(std::move(that.value));
             break;
 
-        case 117:  // "Date"
+        case 118:  // "Date"
             value.move<Date_t>(std::move(that.value));
             break;
 
-        case 127:  // "arbitrary decimal"
+        case 128:  // "arbitrary decimal"
             value.move<Decimal128>(std::move(that.value));
             break;
 
-        case 116:  // "ObjectID"
+        case 117:  // "ObjectID"
             value.move<OID>(std::move(that.value));
             break;
 
-        case 128:  // "Timestamp"
+        case 129:  // "Timestamp"
             value.move<Timestamp>(std::move(that.value));
             break;
 
-        case 130:  // "maxKey"
+        case 131:  // "maxKey"
             value.move<UserMaxKey>(std::move(that.value));
             break;
 
-        case 129:  // "minKey"
+        case 130:  // "minKey"
             value.move<UserMinKey>(std::move(that.value));
             break;
 
-        case 118:  // "null"
+        case 119:  // "null"
             value.move<UserNull>(std::move(that.value));
             break;
 
-        case 115:  // "undefined"
+        case 116:  // "undefined"
             value.move<UserUndefined>(std::move(that.value));
             break;
 
-        case 126:  // "arbitrary double"
+        case 127:  // "arbitrary double"
             value.move<double>(std::move(that.value));
             break;
 
-        case 124:  // "arbitrary integer"
+        case 125:  // "arbitrary integer"
             value.move<int>(std::move(that.value));
             break;
 
-        case 125:  // "arbitrary long"
+        case 126:  // "arbitrary long"
             value.move<long long>(std::move(that.value));
             break;
 
-        case 144:  // projectField
-        case 145:  // expressionField
-        case 146:  // valueField
-        case 147:  // filterField
+        case 145:  // projectField
+        case 146:  // expressionField
+        case 147:  // valueField
         case 261:  // onErrorArg
         case 262:  // onNullArg
         case 263:  // formatArg
         case 264:  // timezoneArg
         case 265:  // charsArg
         case 266:  // optionsArg
-        case 278:  // sortSpec
+        case 275:  // predicate
+        case 276:  // logicalExpr
+        case 277:  // operatorExpression
+        case 278:  // notExpr
+        case 285:  // sortSpec
             value.move<std::pair<CNode::Fieldname, CNode>>(std::move(that.value));
             break;
 
-        case 112:  // "fieldname"
-        case 113:  // "string"
-        case 131:  // "$-prefixed string"
-        case 132:  // "$$-prefixed string"
-        case 133:  // "$-prefixed fieldname"
+        case 113:  // "fieldname"
+        case 114:  // "string"
+        case 132:  // "$-prefixed string"
+        case 133:  // "$$-prefixed string"
+        case 134:  // "$-prefixed fieldname"
             value.move<std::string>(std::move(that.value));
             break;
 
@@ -3320,27 +3348,27 @@ template <typename Base>
 ParserGen::basic_symbol<Base>::basic_symbol(const basic_symbol& that)
     : Base(that), value(), location(that.location) {
     switch (this->type_get()) {
-        case 114:  // "BinData"
+        case 115:  // "BinData"
             value.copy<BSONBinData>(YY_MOVE(that.value));
             break;
 
-        case 121:  // "Code"
+        case 122:  // "Code"
             value.copy<BSONCode>(YY_MOVE(that.value));
             break;
 
-        case 123:  // "CodeWScope"
+        case 124:  // "CodeWScope"
             value.copy<BSONCodeWScope>(YY_MOVE(that.value));
             break;
 
-        case 120:  // "dbPointer"
+        case 121:  // "dbPointer"
             value.copy<BSONDBRef>(YY_MOVE(that.value));
             break;
 
-        case 119:  // "regex"
+        case 120:  // "regex"
             value.copy<BSONRegEx>(YY_MOVE(that.value));
             break;
 
-        case 122:  // "Symbol"
+        case 123:  // "Symbol"
             value.copy<BSONSymbol>(YY_MOVE(that.value));
             break;
 
@@ -3457,92 +3485,98 @@ ParserGen::basic_symbol<Base>::basic_symbol(const basic_symbol& that)
         case 258:  // sqrt
         case 259:  // subtract
         case 260:  // trunc
-        case 270:  // matchExpression
-        case 271:  // filterFields
-        case 272:  // filterVal
-        case 273:  // sortSpecs
-        case 274:  // specList
-        case 275:  // metaSort
-        case 276:  // oneOrNegOne
-        case 277:  // metaSortKeyword
+        case 270:  // match
+        case 271:  // predicates
+        case 272:  // compoundMatchExprs
+        case 273:  // predValue
+        case 274:  // additionalExprs
+        case 280:  // sortSpecs
+        case 281:  // specList
+        case 282:  // metaSort
+        case 283:  // oneOrNegOne
+        case 284:  // metaSortKeyword
             value.copy<CNode>(YY_MOVE(that.value));
             break;
 
-        case 135:  // projectionFieldname
-        case 136:  // expressionFieldname
-        case 137:  // stageAsUserFieldname
-        case 138:  // filterFieldname
-        case 139:  // argAsUserFieldname
-        case 140:  // aggExprAsUserFieldname
-        case 141:  // invariableUserFieldname
-        case 142:  // idAsUserFieldname
-        case 143:  // valueFieldname
+        case 136:  // projectionFieldname
+        case 137:  // expressionFieldname
+        case 138:  // stageAsUserFieldname
+        case 139:  // predFieldname
+        case 140:  // argAsUserFieldname
+        case 141:  // aggExprAsUserFieldname
+        case 142:  // invariableUserFieldname
+        case 143:  // idAsUserFieldname
+        case 144:  // valueFieldname
+        case 279:  // logicalExprField
             value.copy<CNode::Fieldname>(YY_MOVE(that.value));
             break;
 
-        case 117:  // "Date"
+        case 118:  // "Date"
             value.copy<Date_t>(YY_MOVE(that.value));
             break;
 
-        case 127:  // "arbitrary decimal"
+        case 128:  // "arbitrary decimal"
             value.copy<Decimal128>(YY_MOVE(that.value));
             break;
 
-        case 116:  // "ObjectID"
+        case 117:  // "ObjectID"
             value.copy<OID>(YY_MOVE(that.value));
             break;
 
-        case 128:  // "Timestamp"
+        case 129:  // "Timestamp"
             value.copy<Timestamp>(YY_MOVE(that.value));
             break;
 
-        case 130:  // "maxKey"
+        case 131:  // "maxKey"
             value.copy<UserMaxKey>(YY_MOVE(that.value));
             break;
 
-        case 129:  // "minKey"
+        case 130:  // "minKey"
             value.copy<UserMinKey>(YY_MOVE(that.value));
             break;
 
-        case 118:  // "null"
+        case 119:  // "null"
             value.copy<UserNull>(YY_MOVE(that.value));
             break;
 
-        case 115:  // "undefined"
+        case 116:  // "undefined"
             value.copy<UserUndefined>(YY_MOVE(that.value));
             break;
 
-        case 126:  // "arbitrary double"
+        case 127:  // "arbitrary double"
             value.copy<double>(YY_MOVE(that.value));
             break;
 
-        case 124:  // "arbitrary integer"
+        case 125:  // "arbitrary integer"
             value.copy<int>(YY_MOVE(that.value));
             break;
 
-        case 125:  // "arbitrary long"
+        case 126:  // "arbitrary long"
             value.copy<long long>(YY_MOVE(that.value));
             break;
 
-        case 144:  // projectField
-        case 145:  // expressionField
-        case 146:  // valueField
-        case 147:  // filterField
+        case 145:  // projectField
+        case 146:  // expressionField
+        case 147:  // valueField
         case 261:  // onErrorArg
         case 262:  // onNullArg
         case 263:  // formatArg
         case 264:  // timezoneArg
         case 265:  // charsArg
         case 266:  // optionsArg
-        case 278:  // sortSpec
+        case 275:  // predicate
+        case 276:  // logicalExpr
+        case 277:  // operatorExpression
+        case 278:  // notExpr
+        case 285:  // sortSpec
             value.copy<std::pair<CNode::Fieldname, CNode>>(YY_MOVE(that.value));
             break;
 
-        case 112:  // "fieldname"
-        case 113:  // "string"
-        case 131:  // "$-prefixed string"
-        case 132:  // "$$-prefixed string"
-        case 133:  // "$-prefixed fieldname"
+        case 113:  // "fieldname"
+        case 114:  // "string"
+        case 132:  // "$-prefixed string"
+        case 133:  // "$$-prefixed string"
+        case 134:  // "$-prefixed fieldname"
             value.copy<std::string>(YY_MOVE(that.value));
             break;
 
@@ -3567,27 +3601,27 @@ template <typename Base>
 void ParserGen::basic_symbol<Base>::move(basic_symbol& s) {
     super_type::move(s);
     switch (this->type_get()) {
-        case 114:  // "BinData"
+        case 115:  // "BinData"
             value.move<BSONBinData>(YY_MOVE(s.value));
             break;
 
-        case 121:  // "Code"
+        case 122:  // "Code"
             value.move<BSONCode>(YY_MOVE(s.value));
             break;
 
-        case 123:  // "CodeWScope"
+        case 124:  // "CodeWScope"
             value.move<BSONCodeWScope>(YY_MOVE(s.value));
             break;
 
-        case 120:  // "dbPointer"
+        case 121:  // "dbPointer"
             value.move<BSONDBRef>(YY_MOVE(s.value));
             break;
 
-        case 119:  // "regex"
+        case 120:  // "regex"
             value.move<BSONRegEx>(YY_MOVE(s.value));
             break;
 
-        case 122:  // "Symbol"
+        case 123:  // "Symbol"
             value.move<BSONSymbol>(YY_MOVE(s.value));
             break;
 
@@ -3704,92 +3738,98 @@ void ParserGen::basic_symbol<Base>::move(basic_symbol& s) {
         case 258:  // sqrt
         case 259:  // subtract
         case 260:  // trunc
-        case 270:  // matchExpression
-        case 271:  // filterFields
-        case 272:  // filterVal
-        case 273:  // sortSpecs
-        case 274:  // specList
-        case 275:  // metaSort
-        case 276:  // oneOrNegOne
-        case 277:  // metaSortKeyword
+        case 270:  // match
+        case 271:  // predicates
+        case 272:  // compoundMatchExprs
+        case 273:  // predValue
+        case 274:  // additionalExprs
+        case 280:  // sortSpecs
+        case 281:  // specList
+        case 282:  // metaSort
+        case 283:  // oneOrNegOne
+        case 284:  // metaSortKeyword
             value.move<CNode>(YY_MOVE(s.value));
             break;
 
-        case 135:  // projectionFieldname
-        case 136:  // expressionFieldname
-        case 137:  // stageAsUserFieldname
-        case 138:  // filterFieldname
-        case 139:  // argAsUserFieldname
-        case 140:  // aggExprAsUserFieldname
-        case 141:  // invariableUserFieldname
-        case 142:  // idAsUserFieldname
-        case 143:  // valueFieldname
+        case 136:  // projectionFieldname
+        case 137:  // expressionFieldname
+        case 138:  // stageAsUserFieldname
+        case 139:  // predFieldname
+        case 140:  // argAsUserFieldname
+        case 141:  // aggExprAsUserFieldname
+        case 142:  // invariableUserFieldname
+        case 143:  // idAsUserFieldname
+        case 144:  // valueFieldname
+        case 279:  // logicalExprField
             value.move<CNode::Fieldname>(YY_MOVE(s.value));
             break;
 
-        case 117:  // "Date"
+        case 118:  // "Date"
             value.move<Date_t>(YY_MOVE(s.value));
             break;
 
-        case 127:  // "arbitrary decimal"
+        case 128:  // "arbitrary decimal"
             value.move<Decimal128>(YY_MOVE(s.value));
             break;
 
-        case 116:  // "ObjectID"
+        case 117:  // "ObjectID"
             value.move<OID>(YY_MOVE(s.value));
             break;
 
-        case 128:  // "Timestamp"
+        case 129:  // "Timestamp"
             value.move<Timestamp>(YY_MOVE(s.value));
             break;
 
-        case 130:  // "maxKey"
+        case 131:  // "maxKey"
             value.move<UserMaxKey>(YY_MOVE(s.value));
             break;
 
-        case 129:  // "minKey"
+        case 130:  // "minKey"
             value.move<UserMinKey>(YY_MOVE(s.value));
             break;
 
-        case 118:  // "null"
+        case 119:  // "null"
             value.move<UserNull>(YY_MOVE(s.value));
             break;
 
-        case 115:  // "undefined"
+        case 116:  // "undefined"
             value.move<UserUndefined>(YY_MOVE(s.value));
             break;
 
-        case 126:  // "arbitrary double"
+        case 127:  // "arbitrary double"
             value.move<double>(YY_MOVE(s.value));
             break;
 
-        case 124:  // "arbitrary integer"
+        case 125:  // "arbitrary integer"
             value.move<int>(YY_MOVE(s.value));
             break;
 
-        case 125:  // "arbitrary long"
+        case 126:  // "arbitrary long"
             value.move<long long>(YY_MOVE(s.value));
             break;
 
-        case 144:  // projectField
-        case 145:  // expressionField
-        case 146:  // valueField
-        case 147:  // filterField
+        case 145:  // projectField
+        case 146:  // expressionField
+        case 147:  // valueField
         case 261:  // onErrorArg
         case 262:  // onNullArg
         case 263:  // formatArg
         case 264:  // timezoneArg
         case 265:  // charsArg
         case 266:  // optionsArg
-        case 278:  // sortSpec
+        case 275:  // predicate
+        case 276:  // logicalExpr
+        case 277:  // operatorExpression
+        case 278:  // notExpr
+        case 285:  // sortSpec
             value.move<std::pair<CNode::Fieldname, CNode>>(YY_MOVE(s.value));
             break;
 
-        case 112:  // "fieldname"
-        case 113:  // "string"
-        case 131:  // "$-prefixed string"
-        case 132:  // "$$-prefixed string"
-        case 133:  // "$-prefixed fieldname"
+        case 113:  // "fieldname"
+        case 114:  // "string"
+        case 132:  // "$-prefixed string"
+        case 133:  // "$$-prefixed string"
+        case 134:  // "$-prefixed fieldname"
             value.move<std::string>(YY_MOVE(s.value));
             break;
 
@@ -3834,7 +3874,7 @@ inline int ParserGen::by_type::type_get() const YY_NOEXCEPT {
 
 #line 57 "src/mongo/db/cst/grammar.yy"
 }  // namespace mongo
-#line 4844 "src/mongo/db/cst/parser_gen.hpp"
+#line 4890 "src/mongo/db/cst/parser_gen.hpp"
 
 
 #endif  // !YY_YY_SRC_MONGO_DB_CST_PARSER_GEN_HPP_INCLUDED
diff --git a/src/mongo/db/matcher/expression_tree.h b/src/mongo/db/matcher/expression_tree.h
index dd773d1652f..a37fa00b48f 100644
--- a/src/mongo/db/matcher/expression_tree.h
+++ b/src/mongo/db/matcher/expression_tree.h
@@ -227,6 +227,10 @@ public:
                                 clonable_ptr<ErrorAnnotation> annotation = nullptr)
         : MatchExpression(NOT, std::move(annotation)), _exp(e) {}
 
+    explicit NotMatchExpression(std::unique_ptr<MatchExpression> expr,
+                                clonable_ptr<ErrorAnnotation> annotation = nullptr)
+        : MatchExpression(NOT, std::move(annotation)), _exp(std::move(expr)) {}
+
     virtual std::unique_ptr<MatchExpression> shallowClone() const {
         std::unique_ptr<NotMatchExpression> self =
             std::make_unique<NotMatchExpression>(_exp->shallowClone().release(), _errorAnnotation);
author	Nick Zolnierz <nicholas.zolnierz@mongodb.com>	2020-08-19 16:57:10 -0400
committer	Evergreen Agent <no-reply@evergreen.mongodb.com>	2020-09-08 16:52:45 +0000
commit	647dcb8b2c3f8419a1e14061857590a2b8613b73 (patch)
tree	cc1f2764fdf2f23e5538dd7a03543f868043ab65
parent	ec0866979a0749f6ee3a97b9932f73e6e21bf165 (diff)
download	mongo-647dcb8b2c3f8419a1e14061857590a2b8613b73.tar.gz