diff --git a/src/mongo/db/matcher/expression_array.cpp b/src/mongo/db/matcher/expression_array.cpp
index cbff0adf1c..79b51f37a6 100644
--- a/src/mongo/db/matcher/expression_array.cpp
+++ b/src/mongo/db/matcher/expression_array.cpp
@@ -68,8 +68,8 @@ bool ArrayMatchingMatchExpression::equivalent(const MatchExpression* other) cons
 
 ElemMatchObjectMatchExpression::ElemMatchObjectMatchExpression(
     StringData path, std::unique_ptr<MatchExpression> sub, clonable_ptr<ErrorAnnotation> annotation)
-    : ArrayMatchingMatchExpression(ELEM_MATCH_OBJECT, path, std::move(annotation)),
-      _sub(std::move(sub)) {}
+    : ArrayMatchingMatchExpression(ELEM_MATCH_OBJECT, path, std::move(annotation)), _children(1)
+    { _children[0] = std::move(sub); }
 
 bool ElemMatchObjectMatchExpression::matchesArray(const BSONObj& anArray,
                                                   MatchDetails* details) const {
@@ -78,7 +78,7 @@ bool ElemMatchObjectMatchExpression::matchesArray(const BSONObj& anArray,
         BSONElement inner = i.next();
         if (!inner.isABSONObj())
             continue;
-        if (_sub->matchesBSON(inner.Obj(), nullptr)) {
+        if (_children[0]->matchesBSON(inner.Obj(), nullptr)) {
             if (details && details->needRecord()) {
                 details->setElemMatchKey(inner.fieldName());
             }
@@ -98,19 +98,19 @@ void ElemMatchObjectMatchExpression::debugString(StringBuilder& debug, int inden
         td->debugString(&debug);
     }
     debug << "\n";
-    _sub->debugString(debug, indentationLevel + 1);
+    _children[0]->debugString(debug, indentationLevel + 1);
 }
 
 BSONObj ElemMatchObjectMatchExpression::getSerializedRightHandSide() const {
     BSONObjBuilder subBob;
-    _sub->serialize(&subBob, true);
+    _children[0]->serialize(&subBob, true);
     return BSON("$elemMatch" << subBob.obj());
 }
 
 MatchExpression::ExpressionOptimizerFunc ElemMatchObjectMatchExpression::getOptimizer() const {
     return [](std::unique_ptr<MatchExpression> expression) {
         auto& elemExpression = static_cast<ElemMatchObjectMatchExpression&>(*expression);
-        elemExpression._sub = MatchExpression::optimize(std::move(elemExpression._sub));
+        elemExpression._children[0] = MatchExpression::optimize(std::move(elemExpression._children[0]));
 
         return expression;
     };
@@ -121,14 +121,14 @@ MatchExpression::ExpressionOptimizerFunc ElemMatchObjectMatchExpression::getOpti
 ElemMatchValueMatchExpression::ElemMatchValueMatchExpression(
     StringData path, std::unique_ptr<MatchExpression> sub, clonable_ptr<ErrorAnnotation> annotation)
     : ArrayMatchingMatchExpression(ELEM_MATCH_VALUE, path, std::move(annotation)),
-      _subs(makeVector(std::move(sub))) {}
+      _children(makeVector(std::move(sub))) {}
 
 ElemMatchValueMatchExpression::ElemMatchValueMatchExpression(
     StringData path, clonable_ptr<ErrorAnnotation> annotation)
     : ArrayMatchingMatchExpression(ELEM_MATCH_VALUE, path, std::move(annotation)) {}
 
 void ElemMatchValueMatchExpression::add(std::unique_ptr<MatchExpression> sub) {
-    _subs.push_back(std::move(sub));
+    _children.push_back(std::move(sub));
 }
 
 bool ElemMatchValueMatchExpression::matchesArray(const BSONObj& anArray,
@@ -148,8 +148,8 @@ bool ElemMatchValueMatchExpression::matchesArray(const BSONObj& anArray,
 }
 
 bool ElemMatchValueMatchExpression::_arrayElementMatchesAll(const BSONElement& e) const {
-    for (unsigned i = 0; i < _subs.size(); i++) {
-        if (!_subs[i]->matchesSingleElement(e))
+    for (unsigned i = 0; i < _children.size(); i++) {
+        if (!_children[i]->matchesSingleElement(e))
             return false;
     }
     return true;
@@ -165,15 +165,15 @@ void ElemMatchValueMatchExpression::debugString(StringBuilder& debug, int indent
         td->debugString(&debug);
     }
     debug << "\n";
-    for (unsigned i = 0; i < _subs.size(); i++) {
-        _subs[i]->debugString(debug, indentationLevel + 1);
+    for (unsigned i = 0; i < _children.size(); i++) {
+        _children[i]->debugString(debug, indentationLevel + 1);
     }
 }
 
 BSONObj ElemMatchValueMatchExpression::getSerializedRightHandSide() const {
     BSONObjBuilder emBob;
 
-    for (auto&& child : _subs) {
+    for (auto&& child : _children) {
         child->serialize(&emBob, false);
     }
 
@@ -182,7 +182,7 @@ BSONObj ElemMatchValueMatchExpression::getSerializedRightHandSide() const {
 
 MatchExpression::ExpressionOptimizerFunc ElemMatchValueMatchExpression::getOptimizer() const {
     return [](std::unique_ptr<MatchExpression> expression) {
-        auto& subs = static_cast<ElemMatchValueMatchExpression&>(*expression)._subs;
+        auto& subs = static_cast<ElemMatchValueMatchExpression&>(*expression)._children;
 
         for (auto& subExpression : subs)
             subExpression = MatchExpression::optimize(std::move(subExpression));
diff --git a/src/mongo/db/matcher/expression_array.h b/src/mongo/db/matcher/expression_array.h
index 16637c2b37..c33cad03f2 100644
--- a/src/mongo/db/matcher/expression_array.h
+++ b/src/mongo/db/matcher/expression_array.h
@@ -81,7 +81,7 @@ public:
     virtual std::unique_ptr<MatchExpression> shallowClone() const {
         std::unique_ptr<ElemMatchObjectMatchExpression> e =
             std::make_unique<ElemMatchObjectMatchExpression>(
-                path(), _sub->shallowClone(), _errorAnnotation);
+                path(), _children[0]->shallowClone(), _errorAnnotation);
         if (getTag()) {
             e->setTag(getTag()->clone());
         }
@@ -93,7 +93,7 @@ public:
     BSONObj getSerializedRightHandSide() const final;
 
     const std::vector<std::unique_ptr<MatchExpression>>* getChildVector() const final {
-        return nullptr;
+        return &_children;
     }
 
     virtual size_t numChildren() const {
@@ -101,15 +101,15 @@ public:
     }
 
     virtual MatchExpression* getChild(size_t i) const {
-        return _sub.get();
+        return _children[0].get();
     }
 
     std::unique_ptr<MatchExpression> releaseChild() {
-        return std::move(_sub);
+        return std::move(_children[0]);
     }
 
     void resetChild(std::unique_ptr<MatchExpression> newChild) {
-        _sub = std::move(newChild);
+        _children[0] = std::move(newChild);
     }
 
     void acceptVisitor(MatchExpressionMutableVisitor* visitor) final {
@@ -123,7 +123,7 @@ public:
 private:
     ExpressionOptimizerFunc getOptimizer() const final;
 
-    std::unique_ptr<MatchExpression> _sub;
+    std::vector<std::unique_ptr<MatchExpression>> _children;
 };
 
 class ElemMatchValueMatchExpression final : public ArrayMatchingMatchExpression {
@@ -141,8 +141,8 @@ public:
     virtual std::unique_ptr<MatchExpression> shallowClone() const {
         std::unique_ptr<ElemMatchValueMatchExpression> e =
             std::make_unique<ElemMatchValueMatchExpression>(path(), _errorAnnotation);
-        for (size_t i = 0; i < _subs.size(); ++i) {
-            e->add(_subs[i]->shallowClone());
+        for (size_t i = 0; i < _children.size(); ++i) {
+            e->add(_children[i]->shallowClone());
         }
         if (getTag()) {
             e->setTag(getTag()->clone());
@@ -155,15 +155,15 @@ public:
     BSONObj getSerializedRightHandSide() const final;
 
     const std::vector<std::unique_ptr<MatchExpression>>* getChildVector() const final {
-        return &_subs;
+        return &_children;
     }
 
     virtual size_t numChildren() const {
-        return _subs.size();
+        return _children.size();
     }
 
     virtual MatchExpression* getChild(size_t i) const {
-        return _subs[i].get();
+        return _children[i].get();
     }
 
     void acceptVisitor(MatchExpressionMutableVisitor* visitor) final {
@@ -179,7 +179,7 @@ private:
 
     bool _arrayElementMatchesAll(const BSONElement& e) const;
 
-    std::vector<std::unique_ptr<MatchExpression>> _subs;
+    std::vector<std::unique_ptr<MatchExpression>> _children;
 };
 
 class SizeMatchExpression : public ArrayMatchingMatchExpression {
diff --git a/src/mongo/db/matcher/expression_tree.cpp b/src/mongo/db/matcher/expression_tree.cpp
index e41b95d186..c5f1c44d27 100644
--- a/src/mongo/db/matcher/expression_tree.cpp
+++ b/src/mongo/db/matcher/expression_tree.cpp
@@ -42,21 +42,21 @@
 namespace mongo {
 
 void ListOfMatchExpression::_debugList(StringBuilder& debug, int indentationLevel) const {
-    for (unsigned i = 0; i < _expressions.size(); i++)
-        _expressions[i]->debugString(debug, indentationLevel + 1);
+    for (unsigned i = 0; i < _children.size(); i++)
+        _children[i]->debugString(debug, indentationLevel + 1);
 }
 
 void ListOfMatchExpression::_listToBSON(BSONArrayBuilder* out, bool includePath) const {
-    for (unsigned i = 0; i < _expressions.size(); i++) {
+    for (unsigned i = 0; i < _children.size(); i++) {
         BSONObjBuilder childBob(out->subobjStart());
-        _expressions[i]->serialize(&childBob, includePath);
+        _children[i]->serialize(&childBob, includePath);
     }
     out->doneFast();
 }
 
 MatchExpression::ExpressionOptimizerFunc ListOfMatchExpression::getOptimizer() const {
     return [](std::unique_ptr<MatchExpression> expression) -> std::unique_ptr<MatchExpression> {
-        auto& children = static_cast<ListOfMatchExpression&>(*expression)._expressions;
+        auto& children = static_cast<ListOfMatchExpression&>(*expression)._children;
 
         // Recursively apply optimizations to child expressions.
         for (auto& childExpression : children)
@@ -81,7 +81,7 @@ MatchExpression::ExpressionOptimizerFunc ListOfMatchExpression::getOptimizer() c
                     // Move all of the grandchildren from the child expression to
                     // absorbedExpressions.
                     auto& grandChildren =
-                        static_cast<ListOfMatchExpression&>(*childExpressionPtr)._expressions;
+                        static_cast<ListOfMatchExpression&>(*childExpressionPtr)._children;
                     std::move(grandChildren.begin(),
                               grandChildren.end(),
                               std::back_inserter(absorbedExpressions));
@@ -306,12 +306,12 @@ bool ListOfMatchExpression::equivalent(const MatchExpression* other) const {
 
     const ListOfMatchExpression* realOther = static_cast<const ListOfMatchExpression*>(other);
 
-    if (_expressions.size() != realOther->_expressions.size())
+    if (_children.size() != realOther->_children.size())
         return false;
 
     // TOOD: order doesn't matter
-    for (unsigned i = 0; i < _expressions.size(); i++)
-        if (!_expressions[i]->equivalent(realOther->_expressions[i].get()))
+    for (unsigned i = 0; i < _children.size(); i++)
+        if (!_children[i]->equivalent(realOther->_children[i].get()))
             return false;
 
     return true;
diff --git a/src/mongo/db/matcher/expression_tree.h b/src/mongo/db/matcher/expression_tree.h
index 60562bd7c3..4cf07169f2 100644
--- a/src/mongo/db/matcher/expression_tree.h
+++ b/src/mongo/db/matcher/expression_tree.h
@@ -46,42 +46,42 @@ public:
     ListOfMatchExpression(MatchType type,
                           clonable_ptr<ErrorAnnotation> annotation,
                           std::vector<std::unique_ptr<MatchExpression>> expressions)
-        : MatchExpression(type, std::move(annotation)), _expressions(std::move(expressions)) {}
+        : MatchExpression(type, std::move(annotation)), _children(std::move(expressions)) {}
 
     void add(std::unique_ptr<MatchExpression> e) {
-        _expressions.push_back(std::move(e));
+        _children.push_back(std::move(e));
     }
 
     void clear() {
-        _expressions.clear();
+        _children.clear();
     }
 
     virtual size_t numChildren() const {
-        return _expressions.size();
+        return _children.size();
     }
 
     MatchExpression* getChild(size_t i) const final {
-        return _expressions[i].get();
+        return _children[i].get();
     }
 
     /*
      * Replaces the ith child with nullptr, and releases ownership of the child.
      */
     std::unique_ptr<MatchExpression> releaseChild(size_t i) {
-        return std::move(_expressions[i]);
+        return std::move(_children[i]);
     }
 
     /*
      * Removes the ith child, and releases ownership of the child.
      */
     virtual std::unique_ptr<MatchExpression> removeChild(size_t i) {
-        auto child = std::move(_expressions[i]);
-        _expressions.erase(_expressions.begin() + i);
+        auto child = std::move(_children[i]);
+        _children.erase(_children.begin() + i);
         return child;
     }
 
     const std::vector<std::unique_ptr<MatchExpression>>* getChildVector() const final {
-        return &_expressions;
+        return &_children;
     }
 
     bool equivalent(const MatchExpression* other) const final;
@@ -98,7 +98,7 @@ protected:
 private:
     ExpressionOptimizerFunc getOptimizer() const final;
 
-    std::vector<std::unique_ptr<MatchExpression>> _expressions;
+    std::vector<std::unique_ptr<MatchExpression>> _children;
 };
 
 class AndMatchExpression : public ListOfMatchExpression {
