SERVER-42852 Make PlanStage consistently hold children by unique_ptr.

49 files changed, 469 insertions, 527 deletions

diff --git a/src/mongo/db/exec/and_hash.cpp b/src/mongo/db/exec/and_hash.cpp
index 1b2e9983286..6c913377c4f 100644
--- a/src/mongo/db/exec/and_hash.cpp
+++ b/src/mongo/db/exec/and_hash.cpp
@@ -71,8 +71,8 @@ AndHashStage::AndHashStage(OperationContext* opCtx, WorkingSet* ws, size_t maxMe
       _memUsage(0),
       _maxMemUsage(maxMemUsage) {}
 
-void AndHashStage::addChild(PlanStage* child) {
-    _children.emplace_back(child);
+void AndHashStage::addChild(std::unique_ptr<PlanStage> child) {
+    _children.emplace_back(std::move(child));
 }
 
 size_t AndHashStage::getMemUsage() const {
diff --git a/src/mongo/db/exec/and_hash.h b/src/mongo/db/exec/and_hash.h
index 2b8c326c3ce..3659504486d 100644
--- a/src/mongo/db/exec/and_hash.h
+++ b/src/mongo/db/exec/and_hash.h
@@ -55,7 +55,7 @@ public:
      */
     AndHashStage(OperationContext* opCtx, WorkingSet* ws, size_t maxMemUsage);
 
-    void addChild(PlanStage* child);
+    void addChild(std::unique_ptr<PlanStage> child);
 
     /**
      * Returns memory usage.
diff --git a/src/mongo/db/exec/and_sorted.cpp b/src/mongo/db/exec/and_sorted.cpp
index 6c60553a76e..6cda1ad2bf1 100644
--- a/src/mongo/db/exec/and_sorted.cpp
+++ b/src/mongo/db/exec/and_sorted.cpp
@@ -53,8 +53,8 @@ AndSortedStage::AndSortedStage(OperationContext* opCtx, WorkingSet* ws)
       _isEOF(false) {}
 
 
-void AndSortedStage::addChild(PlanStage* child) {
-    _children.emplace_back(child);
+void AndSortedStage::addChild(std::unique_ptr<PlanStage> child) {
+    _children.emplace_back(std::move(child));
 }
 
 bool AndSortedStage::isEOF() {
diff --git a/src/mongo/db/exec/and_sorted.h b/src/mongo/db/exec/and_sorted.h
index a01ebc70d3a..3d72d15c1f9 100644
--- a/src/mongo/db/exec/and_sorted.h
+++ b/src/mongo/db/exec/and_sorted.h
@@ -49,7 +49,7 @@ class AndSortedStage final : public PlanStage {
 public:
     AndSortedStage(OperationContext* opCtx, WorkingSet* ws);
 
-    void addChild(PlanStage* child);
+    void addChild(std::unique_ptr<PlanStage> child);
 
     StageState doWork(WorkingSetID* out) final;
     bool isEOF() final;
diff --git a/src/mongo/db/exec/cached_plan.cpp b/src/mongo/db/exec/cached_plan.cpp
index 0c46d328c8a..97e2c9dd5a9 100644
--- a/src/mongo/db/exec/cached_plan.cpp
+++ b/src/mongo/db/exec/cached_plan.cpp
@@ -63,13 +63,13 @@ CachedPlanStage::CachedPlanStage(OperationContext* opCtx,
                                  CanonicalQuery* cq,
                                  const QueryPlannerParams& params,
                                  size_t decisionWorks,
-                                 PlanStage* root)
+                                 std::unique_ptr<PlanStage> root)
     : RequiresAllIndicesStage(kStageType, opCtx, collection),
       _ws(ws),
       _canonicalQuery(cq),
       _plannerParams(params),
       _decisionWorks(decisionWorks) {
-    _children.emplace_back(root);
+    _children.emplace_back(std::move(root));
 }
 
 Status CachedPlanStage::pickBestPlan(PlanYieldPolicy* yieldPolicy) {
@@ -215,11 +215,10 @@ Status CachedPlanStage::replan(PlanYieldPolicy* yieldPolicy, bool shouldCache) {
     }
 
     if (1 == solutions.size()) {
-        PlanStage* newRoot;
         // Only one possible plan. Build the stages from the solution.
-        verify(StageBuilder::build(
-            getOpCtx(), collection(), *_canonicalQuery, *solutions[0], _ws, &newRoot));
-        _children.emplace_back(newRoot);
+        auto newRoot =
+            StageBuilder::build(getOpCtx(), collection(), *_canonicalQuery, *solutions[0], _ws);
+        _children.emplace_back(std::move(newRoot));
         _replannedQs = std::move(solutions.back());
         solutions.pop_back();
 
@@ -244,12 +243,10 @@ Status CachedPlanStage::replan(PlanYieldPolicy* yieldPolicy, bool shouldCache) {
             solutions[ix]->cacheData->indexFilterApplied = _plannerParams.indexFiltersApplied;
         }
 
-        PlanStage* nextPlanRoot;
-        verify(StageBuilder::build(
-            getOpCtx(), collection(), *_canonicalQuery, *solutions[ix], _ws, &nextPlanRoot));
+        auto nextPlanRoot =
+            StageBuilder::build(getOpCtx(), collection(), *_canonicalQuery, *solutions[ix], _ws);
 
-        // Takes ownership of 'nextPlanRoot'.
-        multiPlanStage->addPlan(std::move(solutions[ix]), nextPlanRoot, _ws);
+        multiPlanStage->addPlan(std::move(solutions[ix]), std::move(nextPlanRoot), _ws);
     }
 
     // Delegate to the MultiPlanStage's plan selection facility.
diff --git a/src/mongo/db/exec/cached_plan.h b/src/mongo/db/exec/cached_plan.h
index 45ca2ed166c..bc7b1bc50bb 100644
--- a/src/mongo/db/exec/cached_plan.h
+++ b/src/mongo/db/exec/cached_plan.h
@@ -62,7 +62,7 @@ public:
                     CanonicalQuery* cq,
                     const QueryPlannerParams& params,
                     size_t decisionWorks,
-                    PlanStage* root);
+                    std::unique_ptr<PlanStage> root);
 
     bool isEOF() final;
 
diff --git a/src/mongo/db/exec/ensure_sorted.cpp b/src/mongo/db/exec/ensure_sorted.cpp
index 611835aaba6..e4c0acc052b 100644
--- a/src/mongo/db/exec/ensure_sorted.cpp
+++ b/src/mongo/db/exec/ensure_sorted.cpp
@@ -45,9 +45,9 @@ const char* EnsureSortedStage::kStageType = "ENSURE_SORTED";
 EnsureSortedStage::EnsureSortedStage(OperationContext* opCtx,
                                      BSONObj pattern,
                                      WorkingSet* ws,
-                                     PlanStage* child)
+                                     std::unique_ptr<PlanStage> child)
     : PlanStage(kStageType, opCtx), _ws(ws) {
-    _children.emplace_back(child);
+    _children.emplace_back(std::move(child));
     _pattern = FindCommon::transformSortSpec(pattern);
 }
 
diff --git a/src/mongo/db/exec/ensure_sorted.h b/src/mongo/db/exec/ensure_sorted.h
index 0f7e09dfa6d..3e3915b6a78 100644
--- a/src/mongo/db/exec/ensure_sorted.h
+++ b/src/mongo/db/exec/ensure_sorted.h
@@ -42,7 +42,10 @@ namespace mongo {
  */
 class EnsureSortedStage final : public PlanStage {
 public:
-    EnsureSortedStage(OperationContext* opCtx, BSONObj pattern, WorkingSet* ws, PlanStage* child);
+    EnsureSortedStage(OperationContext* opCtx,
+                      BSONObj pattern,
+                      WorkingSet* ws,
+                      std::unique_ptr<PlanStage> child);
 
     bool isEOF() final;
     StageState doWork(WorkingSetID* out) final;
diff --git a/src/mongo/db/exec/fetch.cpp b/src/mongo/db/exec/fetch.cpp
index 2e30f53e302..bb09866f983 100644
--- a/src/mongo/db/exec/fetch.cpp
+++ b/src/mongo/db/exec/fetch.cpp
@@ -51,14 +51,14 @@ const char* FetchStage::kStageType = "FETCH";
 
 FetchStage::FetchStage(OperationContext* opCtx,
                        WorkingSet* ws,
-                       PlanStage* child,
+                       std::unique_ptr<PlanStage> child,
                        const MatchExpression* filter,
                        const Collection* collection)
     : RequiresCollectionStage(kStageType, opCtx, collection),
       _ws(ws),
       _filter(filter),
       _idRetrying(WorkingSet::INVALID_ID) {
-    _children.emplace_back(child);
+    _children.emplace_back(std::move(child));
 }
 
 FetchStage::~FetchStage() {}
diff --git a/src/mongo/db/exec/fetch.h b/src/mongo/db/exec/fetch.h
index cdfaad31083..074bd63b4d2 100644
--- a/src/mongo/db/exec/fetch.h
+++ b/src/mongo/db/exec/fetch.h
@@ -52,7 +52,7 @@ class FetchStage : public RequiresCollectionStage {
 public:
     FetchStage(OperationContext* opCtx,
                WorkingSet* ws,
-               PlanStage* child,
+               std::unique_ptr<PlanStage> child,
                const MatchExpression* filter,
                const Collection* collection);
 
diff --git a/src/mongo/db/exec/geo_near.cpp b/src/mongo/db/exec/geo_near.cpp
index d9e7749e5fc..ccf5575044f 100644
--- a/src/mongo/db/exec/geo_near.cpp
+++ b/src/mongo/db/exec/geo_near.cpp
@@ -40,7 +40,6 @@
 #include "mongo/base/owned_pointer_vector.h"
 #include "mongo/db/bson/dotted_path_support.h"
 #include "mongo/db/exec/fetch.h"
-#include "mongo/db/exec/index_scan.h"
 #include "mongo/db/geo/geoconstants.h"
 #include "mongo/db/geo/geoparser.h"
 #include "mongo/db/geo/hash.h"
@@ -265,46 +264,24 @@ static R2Annulus twoDDistanceBounds(const GeoNearParams& nearParams,
     return fullBounds;
 }
 
-class GeoNear2DStage::DensityEstimator {
-public:
-    DensityEstimator(PlanStage::Children* children,
-                     BSONObj infoObj,
-                     const GeoNearParams* nearParams,
-                     const R2Annulus& fullBounds)
-        : _children(children), _nearParams(nearParams), _fullBounds(fullBounds), _currentLevel(0) {
-        GeoHashConverter::Parameters hashParams;
-        Status status = GeoHashConverter::parseParameters(std::move(infoObj), &hashParams);
-        // The index status should always be valid.
-        invariant(status.isOK());
-
-        _converter.reset(new GeoHashConverter(hashParams));
-        _centroidCell = _converter->hash(_nearParams->nearQuery->centroid->oldPoint);
-
-        // Since appendVertexNeighbors(level, output) requires level < hash.getBits(),
-        // we have to start to find documents at most GeoHash::kMaxBits - 1. Thus the finest
-        // search area is 16 * finest cell area at GeoHash::kMaxBits.
-        _currentLevel = std::max(0, hashParams.bits - 1);
-    }
+GeoNear2DStage::DensityEstimator::DensityEstimator(PlanStage::Children* children,
+                                                   BSONObj infoObj,
+                                                   const GeoNearParams* nearParams,
+                                                   const R2Annulus& fullBounds)
+    : _children(children), _nearParams(nearParams), _fullBounds(fullBounds), _currentLevel(0) {
+    GeoHashConverter::Parameters hashParams;
+    Status status = GeoHashConverter::parseParameters(std::move(infoObj), &hashParams);
+    // The index status should always be valid.
+    invariant(status.isOK());
 
-    PlanStage::StageState work(OperationContext* opCtx,
-                               WorkingSet* workingSet,
-                               const IndexDescriptor* twoDIndex,
-                               WorkingSetID* out,
-                               double* estimatedDistance);
+    _converter.reset(new GeoHashConverter(hashParams));
+    _centroidCell = _converter->hash(_nearParams->nearQuery->centroid->oldPoint);
 
-private:
-    void buildIndexScan(OperationContext* opCtx,
-                        WorkingSet* workingSet,
-                        const IndexDescriptor* twoDIndex);
-
-    PlanStage::Children* _children;    // Points to PlanStage::_children in the NearStage.
-    const GeoNearParams* _nearParams;  // Not owned here.
-    const R2Annulus& _fullBounds;
-    IndexScan* _indexScan = nullptr;  // Owned in PlanStage::_children.
-    unique_ptr<GeoHashConverter> _converter;
-    GeoHash _centroidCell;
-    unsigned _currentLevel;
-};
+    // Since appendVertexNeighbors(level, output) requires level < hash.getBits(),
+    // we have to start to find documents at most GeoHash::kMaxBits - 1. Thus the finest
+    // search area is 16 * finest cell area at GeoHash::kMaxBits.
+    _currentLevel = std::max(0, hashParams.bits - 1);
+}
 
 // Initialize the internal states
 void GeoNear2DStage::DensityEstimator::buildIndexScan(OperationContext* opCtx,
@@ -546,10 +523,10 @@ class FetchStageWithMatch final : public FetchStage {
 public:
     FetchStageWithMatch(OperationContext* opCtx,
                         WorkingSet* ws,
-                        PlanStage* child,
+                        std::unique_ptr<PlanStage> child,
                         MatchExpression* filter,
                         const Collection* collection)
-        : FetchStage(opCtx, ws, child, filter, collection), _matcher(filter) {}
+        : FetchStage(opCtx, ws, std::move(child), filter, collection), _matcher(filter) {}
 
 private:
     // Owns matcher
@@ -722,7 +699,7 @@ GeoNear2DStage::nextInterval(OperationContext* opCtx,
         .transitional_ignore();
 
     // 2D indexes support covered search over additional fields they contain
-    IndexScan* scan = new IndexScan(opCtx, scanParams, workingSet, _nearParams.filter);
+    auto scan = std::make_unique<IndexScan>(opCtx, scanParams, workingSet, _nearParams.filter);
 
     MatchExpression* docMatcher = nullptr;
 
@@ -733,8 +710,8 @@ GeoNear2DStage::nextInterval(OperationContext* opCtx,
     }
 
     // FetchStage owns index scan
-    _children.emplace_back(
-        new FetchStageWithMatch(opCtx, workingSet, scan, docMatcher, collection));
+    _children.emplace_back(std::make_unique<FetchStageWithMatch>(
+        opCtx, workingSet, std::move(scan), docMatcher, collection));
 
     return StatusWith<CoveredInterval*>(new CoveredInterval(
         _children.back().get(), nextBounds.getInner(), nextBounds.getOuter(), isLastInterval));
@@ -831,44 +808,20 @@ S2Region* buildS2Region(const R2Annulus& sphereBounds) {
 }
 }  // namespace
 
-// Estimate the density of data by search the nearest cells level by level around center.
-class GeoNear2DSphereStage::DensityEstimator {
-public:
-    DensityEstimator(PlanStage::Children* children,
-                     const GeoNearParams* nearParams,
-                     const S2IndexingParams& indexParams,
-                     const R2Annulus& fullBounds)
-        : _children(children),
-          _nearParams(nearParams),
-          _indexParams(indexParams),
-          _fullBounds(fullBounds),
-          _currentLevel(0) {
-        // cellId.AppendVertexNeighbors(level, output) requires level < finest,
-        // so we use the minimum of max_level - 1 and the user specified finest
-        int level = std::min(S2::kMaxCellLevel - 1, gInternalQueryS2GeoFinestLevel.load());
-        _currentLevel = std::max(0, level);
-    }
-
-    // Search for a document in neighbors at current level.
-    // Return IS_EOF is such document exists and set the estimated distance to the nearest doc.
-    PlanStage::StageState work(OperationContext* opCtx,
-                               WorkingSet* workingSet,
-                               const IndexDescriptor* s2Index,
-                               WorkingSetID* out,
-                               double* estimatedDistance);
-
-private:
-    void buildIndexScan(OperationContext* opCtx,
-                        WorkingSet* workingSet,
-                        const IndexDescriptor* s2Index);
-
-    PlanStage::Children* _children;    // Points to PlanStage::_children in the NearStage.
-    const GeoNearParams* _nearParams;  // Not owned here.
-    const S2IndexingParams _indexParams;
-    const R2Annulus& _fullBounds;
-    int _currentLevel;
-    IndexScan* _indexScan = nullptr;  // Owned in PlanStage::_children.
-};
+GeoNear2DSphereStage::DensityEstimator::DensityEstimator(PlanStage::Children* children,
+                                                         const GeoNearParams* nearParams,
+                                                         const S2IndexingParams& indexParams,
+                                                         const R2Annulus& fullBounds)
+    : _children(children),
+      _nearParams(nearParams),
+      _indexParams(indexParams),
+      _fullBounds(fullBounds),
+      _currentLevel(0) {
+    // cellId.AppendVertexNeighbors(level, output) requires level < finest,
+    // so we use the minimum of max_level - 1 and the user specified finest
+    int level = std::min(S2::kMaxCellLevel - 1, gInternalQueryS2GeoFinestLevel.load());
+    _currentLevel = std::max(0, level);
+}
 
 // Setup the index scan stage for neighbors at this level.
 void GeoNear2DSphereStage::DensityEstimator::buildIndexScan(OperationContext* opCtx,
@@ -1077,10 +1030,11 @@ GeoNear2DSphereStage::nextInterval(OperationContext* opCtx,
     OrderedIntervalList* coveredIntervals = &scanParams.bounds.fields[s2FieldPosition];
     ExpressionMapping::S2CellIdsToIntervalsWithParents(cover, _indexParams, coveredIntervals);
 
-    IndexScan* scan = new IndexScan(opCtx, scanParams, workingSet, nullptr);
+    auto scan = std::make_unique<IndexScan>(opCtx, scanParams, workingSet, nullptr);
 
     // FetchStage owns index scan
-    _children.emplace_back(new FetchStage(opCtx, workingSet, scan, _nearParams.filter, collection));
+    _children.emplace_back(std::make_unique<FetchStage>(
+        opCtx, workingSet, std::move(scan), _nearParams.filter, collection));
 
     return StatusWith<CoveredInterval*>(new CoveredInterval(
         _children.back().get(), nextBounds.getInner(), nextBounds.getOuter(), isLastInterval));
diff --git a/src/mongo/db/exec/geo_near.h b/src/mongo/db/exec/geo_near.h
index 33295de7b39..ce23ccd6e38 100644
--- a/src/mongo/db/exec/geo_near.h
+++ b/src/mongo/db/exec/geo_near.h
@@ -29,6 +29,7 @@
 
 #pragma once
 
+#include "mongo/db/exec/index_scan.h"
 #include "mongo/db/exec/near.h"
 #include "mongo/db/exec/plan_stats.h"
 #include "mongo/db/exec/working_set.h"
@@ -84,6 +85,33 @@ protected:
                                      WorkingSetID* out) final;
 
 private:
+    class DensityEstimator {
+    public:
+        DensityEstimator(PlanStage::Children* children,
+                         BSONObj infoObj,
+                         const GeoNearParams* nearParams,
+                         const R2Annulus& fullBounds);
+
+        PlanStage::StageState work(OperationContext* opCtx,
+                                   WorkingSet* workingSet,
+                                   const IndexDescriptor* twoDIndex,
+                                   WorkingSetID* out,
+                                   double* estimatedDistance);
+
+    private:
+        void buildIndexScan(OperationContext* opCtx,
+                            WorkingSet* workingSet,
+                            const IndexDescriptor* twoDIndex);
+
+        PlanStage::Children* _children;    // Points to PlanStage::_children in the NearStage.
+        const GeoNearParams* _nearParams;  // Not owned here.
+        const R2Annulus& _fullBounds;
+        IndexScan* _indexScan = nullptr;  // Owned in PlanStage::_children.
+        std::unique_ptr<GeoHashConverter> _converter;
+        GeoHash _centroidCell;
+        unsigned _currentLevel;
+    };
+
     const GeoNearParams _nearParams;
 
     // The total search annulus
@@ -98,7 +126,6 @@ private:
     // Keeps track of the region that has already been scanned
     R2CellUnion _scannedCells;
 
-    class DensityEstimator;
     std::unique_ptr<DensityEstimator> _densityEstimator;
 };
 
@@ -126,6 +153,35 @@ protected:
                                      WorkingSetID* out) final;
 
 private:
+    // Estimate the density of data by search the nearest cells level by level around center.
+    class DensityEstimator {
+    public:
+        DensityEstimator(PlanStage::Children* children,
+                         const GeoNearParams* nearParams,
+                         const S2IndexingParams& indexParams,
+                         const R2Annulus& fullBounds);
+
+        // Search for a document in neighbors at current level.
+        // Return IS_EOF is such document exists and set the estimated distance to the nearest doc.
+        PlanStage::StageState work(OperationContext* opCtx,
+                                   WorkingSet* workingSet,
+                                   const IndexDescriptor* s2Index,
+                                   WorkingSetID* out,
+                                   double* estimatedDistance);
+
+    private:
+        void buildIndexScan(OperationContext* opCtx,
+                            WorkingSet* workingSet,
+                            const IndexDescriptor* s2Index);
+
+        PlanStage::Children* _children;    // Points to PlanStage::_children in the NearStage.
+        const GeoNearParams* _nearParams;  // Not owned here.
+        const S2IndexingParams _indexParams;
+        const R2Annulus& _fullBounds;
+        int _currentLevel;
+        IndexScan* _indexScan = nullptr;  // Owned in PlanStage::_children.
+    };
+
     const GeoNearParams _nearParams;
 
     S2IndexingParams _indexParams;
@@ -142,7 +198,6 @@ private:
     // Keeps track of the region that has already been scanned
     S2CellUnion _scannedCells;
 
-    class DensityEstimator;
     std::unique_ptr<DensityEstimator> _densityEstimator;
 };
 
diff --git a/src/mongo/db/exec/limit.cpp b/src/mongo/db/exec/limit.cpp
index 605babeeb31..e800d614039 100644
--- a/src/mongo/db/exec/limit.cpp
+++ b/src/mongo/db/exec/limit.cpp
@@ -43,10 +43,13 @@ using std::vector;
 // static
 const char* LimitStage::kStageType = "LIMIT";
 
-LimitStage::LimitStage(OperationContext* opCtx, long long limit, WorkingSet* ws, PlanStage* child)
+LimitStage::LimitStage(OperationContext* opCtx,
+                       long long limit,
+                       WorkingSet* ws,
+                       std::unique_ptr<PlanStage> child)
     : PlanStage(kStageType, opCtx), _ws(ws), _numToReturn(limit) {
     _specificStats.limit = _numToReturn;
-    _children.emplace_back(child);
+    _children.emplace_back(std::move(child));
 }
 
 LimitStage::~LimitStage() {}
diff --git a/src/mongo/db/exec/limit.h b/src/mongo/db/exec/limit.h
index 61f2e3d1476..f807838b540 100644
--- a/src/mongo/db/exec/limit.h
+++ b/src/mongo/db/exec/limit.h
@@ -45,7 +45,10 @@ namespace mongo {
  */
 class LimitStage final : public PlanStage {
 public:
-    LimitStage(OperationContext* opCtx, long long limit, WorkingSet* ws, PlanStage* child);
+    LimitStage(OperationContext* opCtx,
+               long long limit,
+               WorkingSet* ws,
+               std::unique_ptr<PlanStage> child);
     ~LimitStage();
 
     bool isEOF() final;
diff --git a/src/mongo/db/exec/merge_sort.cpp b/src/mongo/db/exec/merge_sort.cpp
index 8ab56f2b7ad..cc7d40b073e 100644
--- a/src/mongo/db/exec/merge_sort.cpp
+++ b/src/mongo/db/exec/merge_sort.cpp
@@ -57,11 +57,11 @@ MergeSortStage::MergeSortStage(OperationContext* opCtx,
       _dedup(params.dedup),
       _merging(StageWithValueComparison(ws, params.pattern, params.collator)) {}
 
-void MergeSortStage::addChild(PlanStage* child) {
-    _children.emplace_back(child);
+void MergeSortStage::addChild(std::unique_ptr<PlanStage> child) {
+    _children.emplace_back(std::move(child));
 
     // We have to call work(...) on every child before we can pick a min.
-    _noResultToMerge.push(child);
+    _noResultToMerge.push(_children.back().get());
 }
 
 bool MergeSortStage::isEOF() {
diff --git a/src/mongo/db/exec/merge_sort.h b/src/mongo/db/exec/merge_sort.h
index 5a25a3243cd..714f6e0c68a 100644
--- a/src/mongo/db/exec/merge_sort.h
+++ b/src/mongo/db/exec/merge_sort.h
@@ -59,7 +59,7 @@ class MergeSortStage final : public PlanStage {
 public:
     MergeSortStage(OperationContext* opCtx, const MergeSortStageParams& params, WorkingSet* ws);
 
-    void addChild(PlanStage* child);
+    void addChild(std::unique_ptr<PlanStage> child);
 
     bool isEOF() final;
     StageState doWork(WorkingSetID* out) final;
diff --git a/src/mongo/db/exec/multi_plan.cpp b/src/mongo/db/exec/multi_plan.cpp
index 929d22f756d..45c409c7ab3 100644
--- a/src/mongo/db/exec/multi_plan.cpp
+++ b/src/mongo/db/exec/multi_plan.cpp
@@ -75,10 +75,10 @@ MultiPlanStage::MultiPlanStage(OperationContext* opCtx,
       _statusMemberId(WorkingSet::INVALID_ID) {}
 
 void MultiPlanStage::addPlan(std::unique_ptr<QuerySolution> solution,
-                             PlanStage* root,
+                             std::unique_ptr<PlanStage> root,
                              WorkingSet* ws) {
-    _candidates.push_back(CandidatePlan(std::move(solution), root, ws));
-    _children.emplace_back(root);
+    _children.emplace_back(std::move(root));
+    _candidates.push_back(CandidatePlan(std::move(solution), _children.back().get(), ws));
 }
 
 bool MultiPlanStage::isEOF() {
diff --git a/src/mongo/db/exec/multi_plan.h b/src/mongo/db/exec/multi_plan.h
index d11797b5582..f70b2800e63 100644
--- a/src/mongo/db/exec/multi_plan.h
+++ b/src/mongo/db/exec/multi_plan.h
@@ -95,9 +95,11 @@ public:
     const SpecificStats* getSpecificStats() const final;
 
     /**
-     * Takes ownership of PlanStage. Does not take ownership of WorkingSet.
+     * Adsd a new candidate plan to be considered for selection by the MultiPlanStage trial period.
      */
-    void addPlan(std::unique_ptr<QuerySolution> solution, PlanStage* root, WorkingSet* sharedWs);
+    void addPlan(std::unique_ptr<QuerySolution> solution,
+                 std::unique_ptr<PlanStage> root,
+                 WorkingSet* sharedWs);
 
     /**
      * Runs all plans added by addPlan, ranks them, and picks a best.
diff --git a/src/mongo/db/exec/or.cpp b/src/mongo/db/exec/or.cpp
index 8269b599f43..3800536b62c 100644
--- a/src/mongo/db/exec/or.cpp
+++ b/src/mongo/db/exec/or.cpp
@@ -47,8 +47,8 @@ const char* OrStage::kStageType = "OR";
 OrStage::OrStage(OperationContext* opCtx, WorkingSet* ws, bool dedup, const MatchExpression* filter)
     : PlanStage(kStageType, opCtx), _ws(ws), _filter(filter), _currentChild(0), _dedup(dedup) {}
 
-void OrStage::addChild(PlanStage* child) {
-    _children.emplace_back(child);
+void OrStage::addChild(std::unique_ptr<PlanStage> child) {
+    _children.emplace_back(std::move(child));
 }
 
 void OrStage::addChildren(Children childrenToAdd) {
diff --git a/src/mongo/db/exec/or.h b/src/mongo/db/exec/or.h
index dff62d17d51..8d2c043ee46 100644
--- a/src/mongo/db/exec/or.h
+++ b/src/mongo/db/exec/or.h
@@ -46,7 +46,7 @@ class OrStage final : public PlanStage {
 public:
     OrStage(OperationContext* opCtx, WorkingSet* ws, bool dedup, const MatchExpression* filter);
 
-    void addChild(PlanStage* child);
+    void addChild(std::unique_ptr<PlanStage> child);
 
     void addChildren(Children childrenToAdd);
 
diff --git a/src/mongo/db/exec/shard_filter.cpp b/src/mongo/db/exec/shard_filter.cpp
index ed25ef0ad8e..3ca72e989a0 100644
--- a/src/mongo/db/exec/shard_filter.cpp
+++ b/src/mongo/db/exec/shard_filter.cpp
@@ -53,9 +53,9 @@ const char* ShardFilterStage::kStageType = "SHARDING_FILTER";
 ShardFilterStage::ShardFilterStage(OperationContext* opCtx,
                                    ScopedCollectionMetadata metadata,
                                    WorkingSet* ws,
-                                   PlanStage* child)
+                                   std::unique_ptr<PlanStage> child)
     : PlanStage(kStageType, opCtx), _ws(ws), _shardFilterer(std::move(metadata)) {
-    _children.emplace_back(child);
+    _children.emplace_back(std::move(child));
 }
 
 ShardFilterStage::~ShardFilterStage() {}
diff --git a/src/mongo/db/exec/shard_filter.h b/src/mongo/db/exec/shard_filter.h
index d8284ad4e6f..5fdb2a2a247 100644
--- a/src/mongo/db/exec/shard_filter.h
+++ b/src/mongo/db/exec/shard_filter.h
@@ -74,7 +74,7 @@ public:
     ShardFilterStage(OperationContext* opCtx,
                      ScopedCollectionMetadata metadata,
                      WorkingSet* ws,
-                     PlanStage* child);
+                     std::unique_ptr<PlanStage> child);
     ~ShardFilterStage();
 
     bool isEOF() final;
diff --git a/src/mongo/db/exec/skip.cpp b/src/mongo/db/exec/skip.cpp
index a87a9dd745b..bc488c1b410 100644
--- a/src/mongo/db/exec/skip.cpp
+++ b/src/mongo/db/exec/skip.cpp
@@ -43,9 +43,12 @@ using std::vector;
 // static
 const char* SkipStage::kStageType = "SKIP";
 
-SkipStage::SkipStage(OperationContext* opCtx, long long toSkip, WorkingSet* ws, PlanStage* child)
+SkipStage::SkipStage(OperationContext* opCtx,
+                     long long toSkip,
+                     WorkingSet* ws,
+                     std::unique_ptr<PlanStage> child)
     : PlanStage(kStageType, opCtx), _ws(ws), _toSkip(toSkip) {
-    _children.emplace_back(child);
+    _children.emplace_back(std::move(child));
 }
 
 SkipStage::~SkipStage() {}
diff --git a/src/mongo/db/exec/skip.h b/src/mongo/db/exec/skip.h
index c885f275f31..8751cb22471 100644
--- a/src/mongo/db/exec/skip.h
+++ b/src/mongo/db/exec/skip.h
@@ -44,7 +44,10 @@ namespace mongo {
  */
 class SkipStage final : public PlanStage {
 public:
-    SkipStage(OperationContext* opCtx, long long toSkip, WorkingSet* ws, PlanStage* child);
+    SkipStage(OperationContext* opCtx,
+              long long toSkip,
+              WorkingSet* ws,
+              std::unique_ptr<PlanStage> child);
     ~SkipStage();
 
     bool isEOF() final;
diff --git a/src/mongo/db/exec/sort.cpp b/src/mongo/db/exec/sort.cpp
index 13f1615ee11..1dfae92f7f6 100644
--- a/src/mongo/db/exec/sort.cpp
+++ b/src/mongo/db/exec/sort.cpp
@@ -69,7 +69,7 @@ bool SortStage::WorkingSetComparator::operator()(const SortableDataItem& lhs,
 SortStage::SortStage(OperationContext* opCtx,
                      const SortStageParams& params,
                      WorkingSet* ws,
-                     PlanStage* child)
+                     std::unique_ptr<PlanStage> child)
     : PlanStage(kStageType, opCtx),
       _ws(ws),
       _pattern(params.pattern),
@@ -78,7 +78,7 @@ SortStage::SortStage(OperationContext* opCtx,
       _sorted(false),
       _resultIterator(_data.end()),
       _memUsage(0) {
-    _children.emplace_back(child);
+    _children.emplace_back(std::move(child));
 
     BSONObj sortComparator = FindCommon::transformSortSpec(_pattern);
     _sortKeyComparator = std::make_unique<WorkingSetComparator>(sortComparator);
diff --git a/src/mongo/db/exec/sort.h b/src/mongo/db/exec/sort.h
index adadc9ad121..8fc5827fe13 100644
--- a/src/mongo/db/exec/sort.h
+++ b/src/mongo/db/exec/sort.h
@@ -72,7 +72,7 @@ public:
     SortStage(OperationContext* opCtx,
               const SortStageParams& params,
               WorkingSet* ws,
-              PlanStage* child);
+              std::unique_ptr<PlanStage> child);
     ~SortStage();
 
     bool isEOF() final;
diff --git a/src/mongo/db/exec/sort_key_generator.cpp b/src/mongo/db/exec/sort_key_generator.cpp
index 98800394762..2439da67cb3 100644
--- a/src/mongo/db/exec/sort_key_generator.cpp
+++ b/src/mongo/db/exec/sort_key_generator.cpp
@@ -50,13 +50,13 @@ namespace mongo {
 const char* SortKeyGeneratorStage::kStageType = "SORT_KEY_GENERATOR";
 
 SortKeyGeneratorStage::SortKeyGeneratorStage(const boost::intrusive_ptr<ExpressionContext>& pExpCtx,
-                                             PlanStage* child,
+                                             std::unique_ptr<PlanStage> child,
                                              WorkingSet* ws,
                                              const BSONObj& sortSpecObj)
     : PlanStage(kStageType, pExpCtx->opCtx),
       _ws(ws),
       _sortKeyGen({{sortSpecObj, pExpCtx}, pExpCtx->getCollator()}) {
-    _children.emplace_back(child);
+    _children.emplace_back(std::move(child));
 }
 
 bool SortKeyGeneratorStage::isEOF() {
diff --git a/src/mongo/db/exec/sort_key_generator.h b/src/mongo/db/exec/sort_key_generator.h
index c7a9e2dfd4b..5732f2008f6 100644
--- a/src/mongo/db/exec/sort_key_generator.h
+++ b/src/mongo/db/exec/sort_key_generator.h
@@ -51,7 +51,7 @@ class WorkingSetMember;
 class SortKeyGeneratorStage final : public PlanStage {
 public:
     SortKeyGeneratorStage(const boost::intrusive_ptr<ExpressionContext>& pExpCtx,
-                          PlanStage* child,
+                          std::unique_ptr<PlanStage> child,
                           WorkingSet* ws,
                           const BSONObj& sortSpecObj);
 
diff --git a/src/mongo/db/exec/sort_test.cpp b/src/mongo/db/exec/sort_test.cpp
index 65971d6ac15..7ff0614d7eb 100644
--- a/src/mongo/db/exec/sort_test.cpp
+++ b/src/mongo/db/exec/sort_test.cpp
@@ -108,9 +108,9 @@ public:
             new ExpressionContext(getOpCtx(), collator));
 
         auto sortKeyGen = std::make_unique<SortKeyGeneratorStage>(
-            pExpCtx, queuedDataStage.release(), &ws, params.pattern);
+            pExpCtx, std::move(queuedDataStage), &ws, params.pattern);
 
-        SortStage sort(getOpCtx(), params, &ws, sortKeyGen.release());
+        SortStage sort(getOpCtx(), params, &ws, std::move(sortKeyGen));
 
         WorkingSetID id = WorkingSet::INVALID_ID;
         PlanStage::StageState state = PlanStage::NEED_TIME;
@@ -167,10 +167,10 @@ TEST_F(SortStageTest, SortEmptyWorkingSet) {
 
     // QueuedDataStage will be owned by SortStage.
     auto queuedDataStage = std::make_unique<QueuedDataStage>(getOpCtx(), &ws);
-    auto sortKeyGen =
-        std::make_unique<SortKeyGeneratorStage>(pExpCtx, queuedDataStage.release(), &ws, BSONObj());
+    auto sortKeyGen = std::make_unique<SortKeyGeneratorStage>(
+        pExpCtx, std::move(queuedDataStage), &ws, BSONObj());
     SortStageParams params;
-    SortStage sort(getOpCtx(), params, &ws, sortKeyGen.release());
+    SortStage sort(getOpCtx(), params, &ws, std::move(sortKeyGen));
 
     // Check initial EOF state.
     ASSERT_FALSE(sort.isEOF());
diff --git a/src/mongo/db/exec/stagedebug_cmd.cpp b/src/mongo/db/exec/stagedebug_cmd.cpp
index 3baee889ab1..50bbb7e624b 100644
--- a/src/mongo/db/exec/stagedebug_cmd.cpp
+++ b/src/mongo/db/exec/stagedebug_cmd.cpp
@@ -170,13 +170,13 @@ public:
         std::vector<std::unique_ptr<MatchExpression>> exprs;
         unique_ptr<WorkingSet> ws(new WorkingSet());
 
-        PlanStage* userRoot = parseQuery(opCtx, collection, planObj, ws.get(), &exprs);
+        std::unique_ptr<PlanStage> userRoot{
+            parseQuery(opCtx, collection, planObj, ws.get(), &exprs)};
         uassert(16911, "Couldn't parse plan from " + cmdObj.toString(), nullptr != userRoot);
 
         // Add a fetch at the top for the user so we can get obj back for sure.
-        // TODO: Do we want to do this for the user?  I think so.
         unique_ptr<PlanStage> rootFetch =
-            std::make_unique<FetchStage>(opCtx, ws.get(), userRoot, nullptr, collection);
+            std::make_unique<FetchStage>(opCtx, ws.get(), std::move(userRoot), nullptr, collection);
 
         auto statusWithPlanExecutor = PlanExecutor::make(
             opCtx, std::move(ws), std::move(rootFetch), collection, PlanExecutor::YIELD_AUTO);
@@ -307,12 +307,12 @@ public:
                 BSONElement e = it.next();
                 uassert(16922, "node of AND isn't an obj?: " + e.toString(), e.isABSONObj());
 
-                PlanStage* subNode = parseQuery(opCtx, collection, e.Obj(), workingSet, exprs);
+                std::unique_ptr<PlanStage> subNode{
+                    parseQuery(opCtx, collection, e.Obj(), workingSet, exprs)};
                 uassert(16923,
                         "Can't parse sub-node of AND: " + e.Obj().toString(),
                         nullptr != subNode);
-                // takes ownership
-                andStage->addChild(subNode);
+                andStage->addChild(std::move(subNode));
                 ++nodesAdded;
             }
 
@@ -331,12 +331,12 @@ public:
                 BSONElement e = it.next();
                 uassert(16925, "node of AND isn't an obj?: " + e.toString(), e.isABSONObj());
 
-                PlanStage* subNode = parseQuery(opCtx, collection, e.Obj(), workingSet, exprs);
+                std::unique_ptr<PlanStage> subNode{
+                    parseQuery(opCtx, collection, e.Obj(), workingSet, exprs)};
                 uassert(16926,
                         "Can't parse sub-node of AND: " + e.Obj().toString(),
                         nullptr != subNode);
-                // takes ownership
-                andStage->addChild(subNode);
+                andStage->addChild(std::move(subNode));
                 ++nodesAdded;
             }
 
@@ -355,23 +355,23 @@ public:
                 if (!e.isABSONObj()) {
                     return nullptr;
                 }
-                PlanStage* subNode = parseQuery(opCtx, collection, e.Obj(), workingSet, exprs);
+                std::unique_ptr<PlanStage> subNode{
+                    parseQuery(opCtx, collection, e.Obj(), workingSet, exprs)};
                 uassert(
                     16936, "Can't parse sub-node of OR: " + e.Obj().toString(), nullptr != subNode);
-                // takes ownership
-                orStage->addChild(subNode);
+                orStage->addChild(std::move(subNode));
             }
 
             return orStage.release();
         } else if ("fetch" == nodeName) {
             uassert(
                 16929, "Node argument must be provided to fetch", nodeArgs["node"].isABSONObj());
-            PlanStage* subNode =
-                parseQuery(opCtx, collection, nodeArgs["node"].Obj(), workingSet, exprs);
+            std::unique_ptr<PlanStage> subNode{
+                parseQuery(opCtx, collection, nodeArgs["node"].Obj(), workingSet, exprs)};
             uassert(28731,
                     "Can't parse sub-node of FETCH: " + nodeArgs["node"].Obj().toString(),
                     nullptr != subNode);
-            return new FetchStage(opCtx, workingSet, subNode, matcher, collection);
+            return new FetchStage(opCtx, workingSet, std::move(subNode), matcher, collection);
         } else if ("limit" == nodeName) {
             uassert(16937,
                     "Limit stage doesn't have a filter (put it on the child)",
@@ -379,24 +379,26 @@ public:
             uassert(
                 16930, "Node argument must be provided to limit", nodeArgs["node"].isABSONObj());
             uassert(16931, "Num argument must be provided to limit", nodeArgs["num"].isNumber());
-            PlanStage* subNode =
-                parseQuery(opCtx, collection, nodeArgs["node"].Obj(), workingSet, exprs);
+            std::unique_ptr<PlanStage> subNode{
+                parseQuery(opCtx, collection, nodeArgs["node"].Obj(), workingSet, exprs)};
             uassert(28732,
                     "Can't parse sub-node of LIMIT: " + nodeArgs["node"].Obj().toString(),
                     nullptr != subNode);
-            return new LimitStage(opCtx, nodeArgs["num"].numberInt(), workingSet, subNode);
+            return new LimitStage(
+                opCtx, nodeArgs["num"].numberInt(), workingSet, std ::move(subNode));
         } else if ("skip" == nodeName) {
             uassert(16938,
                     "Skip stage doesn't have a filter (put it on the child)",
                     nullptr == matcher);
             uassert(16932, "Node argument must be provided to skip", nodeArgs["node"].isABSONObj());
             uassert(16933, "Num argument must be provided to skip", nodeArgs["num"].isNumber());
-            PlanStage* subNode =
-                parseQuery(opCtx, collection, nodeArgs["node"].Obj(), workingSet, exprs);
+            std::unique_ptr<PlanStage> subNode{
+                parseQuery(opCtx, collection, nodeArgs["node"].Obj(), workingSet, exprs)};
             uassert(28733,
                     "Can't parse sub-node of SKIP: " + nodeArgs["node"].Obj().toString(),
                     nullptr != subNode);
-            return new SkipStage(opCtx, nodeArgs["num"].numberInt(), workingSet, subNode);
+            return new SkipStage(
+                opCtx, nodeArgs["num"].numberInt(), workingSet, std::move(subNode));
         } else if ("cscan" == nodeName) {
             CollectionScanParams params;
 
@@ -429,12 +431,12 @@ public:
                 BSONElement e = it.next();
                 uassert(16973, "node of mergeSort isn't an obj?: " + e.toString(), e.isABSONObj());
 
-                PlanStage* subNode = parseQuery(opCtx, collection, e.Obj(), workingSet, exprs);
+                std::unique_ptr<PlanStage> subNode{
+                    parseQuery(opCtx, collection, e.Obj(), workingSet, exprs)};
                 uassert(16974,
                         "Can't parse sub-node of mergeSort: " + e.Obj().toString(),
                         nullptr != subNode);
-                // takes ownership
-                mergeStage->addChild(subNode);
+                mergeStage->addChild(std::move(subNode));
             }
             return mergeStage.release();
         } else if ("text" == nodeName) {
diff --git a/src/mongo/db/exec/subplan.cpp b/src/mongo/db/exec/subplan.cpp
index 97fb663f7c6..789fca69ce9 100644
--- a/src/mongo/db/exec/subplan.cpp
+++ b/src/mongo/db/exec/subplan.cpp
@@ -271,16 +271,14 @@ Status SubplanStage::choosePlanForSubqueries(PlanYieldPolicy* yieldPolicy) {
 
             // Dump all the solutions into the MPS.
             for (size_t ix = 0; ix < branchResult->solutions.size(); ++ix) {
-                PlanStage* nextPlanRoot;
-                invariant(StageBuilder::build(getOpCtx(),
-                                              collection(),
-                                              *branchResult->canonicalQuery,
-                                              *branchResult->solutions[ix],
-                                              _ws,
-                                              &nextPlanRoot));
-
-                // Takes ownership of 'nextPlanRoot'.
-                multiPlanStage->addPlan(std::move(branchResult->solutions[ix]), nextPlanRoot, _ws);
+                auto nextPlanRoot = StageBuilder::build(getOpCtx(),
+                                                        collection(),
+                                                        *branchResult->canonicalQuery,
+                                                        *branchResult->solutions[ix],
+                                                        _ws);
+
+                multiPlanStage->addPlan(
+                    std::move(branchResult->solutions[ix]), std::move(nextPlanRoot), _ws);
             }
 
             Status planSelectStat = multiPlanStage->pickBestPlan(yieldPolicy);
@@ -340,7 +338,6 @@ Status SubplanStage::choosePlanForSubqueries(PlanYieldPolicy* yieldPolicy) {
 
     LOG(5) << "Subplanner: fully tagged tree is " << redact(solnRoot->toString());
 
-    // Takes ownership of 'solnRoot'
     _compositeSolution =
         QueryPlannerAnalysis::analyzeDataAccess(*_query, _plannerParams, std::move(solnRoot));
 
@@ -355,11 +352,10 @@ Status SubplanStage::choosePlanForSubqueries(PlanYieldPolicy* yieldPolicy) {
     // Use the index tags from planning each branch to construct the composite solution,
     // and set that solution as our child stage.
     _ws->clear();
-    PlanStage* root;
-    invariant(StageBuilder::build(
-        getOpCtx(), collection(), *_query, *_compositeSolution.get(), _ws, &root));
+    auto root =
+        StageBuilder::build(getOpCtx(), collection(), *_query, *_compositeSolution.get(), _ws);
     invariant(_children.empty());
-    _children.emplace_back(root);
+    _children.emplace_back(std::move(root));
 
     return Status::OK();
 }
@@ -387,11 +383,10 @@ Status SubplanStage::choosePlanWholeQuery(PlanYieldPolicy* yieldPolicy) {
     }
 
     if (1 == solutions.size()) {
-        PlanStage* root;
         // Only one possible plan.  Run it.  Build the stages from the solution.
-        verify(StageBuilder::build(getOpCtx(), collection(), *_query, *solutions[0], _ws, &root));
+        auto root = StageBuilder::build(getOpCtx(), collection(), *_query, *solutions[0], _ws);
         invariant(_children.empty());
-        _children.emplace_back(root);
+        _children.emplace_back(std::move(root));
 
         // This SubplanStage takes ownership of the query solution.
         _compositeSolution = std::move(solutions.back());
@@ -410,13 +405,10 @@ Status SubplanStage::choosePlanWholeQuery(PlanYieldPolicy* yieldPolicy) {
                 solutions[ix]->cacheData->indexFilterApplied = _plannerParams.indexFiltersApplied;
             }
 
-            // version of StageBuild::build when WorkingSet is shared
-            PlanStage* nextPlanRoot;
-            verify(StageBuilder::build(
-                getOpCtx(), collection(), *_query, *solutions[ix], _ws, &nextPlanRoot));
+            auto nextPlanRoot =
+                StageBuilder::build(getOpCtx(), collection(), *_query, *solutions[ix], _ws);
 
-            // Takes ownership of 'nextPlanRoot'.
-            multiPlanStage->addPlan(std::move(solutions[ix]), nextPlanRoot, _ws);
+            multiPlanStage->addPlan(std::move(solutions[ix]), std::move(nextPlanRoot), _ws);
         }
 
         // Delegate the the MultiPlanStage's plan selection facility.
diff --git a/src/mongo/db/exec/text.cpp b/src/mongo/db/exec/text.cpp
index 93054164ebb..9efb4915c61 100644
--- a/src/mongo/db/exec/text.cpp
+++ b/src/mongo/db/exec/text.cpp
@@ -140,7 +140,7 @@ unique_ptr<PlanStage> TextStage::buildTextTree(OperationContext* opCtx,
         // WorkingSetMember inputs have fetched data.
         const MatchExpression* emptyFilter = nullptr;
         auto fetchStage = std::make_unique<FetchStage>(
-            opCtx, ws, textSearcher.release(), emptyFilter, collection);
+            opCtx, ws, std::move(textSearcher), emptyFilter, collection);
 
         textMatchStage = std::make_unique<TextMatchStage>(
             opCtx, std::move(fetchStage), _params.query, _params.spec, ws);
diff --git a/src/mongo/db/exec/trial_stage.cpp b/src/mongo/db/exec/trial_stage.cpp
index c54c6e91dc9..1e5b36fb7c4 100644
--- a/src/mongo/db/exec/trial_stage.cpp
+++ b/src/mongo/db/exec/trial_stage.cpp
@@ -174,8 +174,8 @@ void TrialStage::_assessTrialAndBuildFinalPlan() {
     // final plan which UNIONs across the QueuedDataStage and the trial plan.
     std::unique_ptr<PlanStage> unionPlan =
         std::make_unique<OrStage>(getOpCtx(), _ws, false, nullptr);
-    static_cast<OrStage*>(unionPlan.get())->addChild(_queuedData.release());
-    static_cast<OrStage*>(unionPlan.get())->addChild(_children.front().release());
+    static_cast<OrStage*>(unionPlan.get())->addChild(std::move(_queuedData));
+    static_cast<OrStage*>(unionPlan.get())->addChild(std::move(_children.front()));
     _replaceCurrentPlan(unionPlan);
 }
 
diff --git a/src/mongo/db/pipeline/pipeline_d.cpp b/src/mongo/db/pipeline/pipeline_d.cpp
index e235c28f6ca..12c95222fe3 100644
--- a/src/mongo/db/pipeline/pipeline_d.cpp
+++ b/src/mongo/db/pipeline/pipeline_d.cpp
@@ -146,12 +146,12 @@ StatusWith<unique_ptr<PlanExecutor, PlanExecutor::Deleter>> createRandomCursorEx
             sampleSize / (numRecords * kMaxSampleRatioForRandCursor), kMaxSampleRatioForRandCursor);
         // The trial plan is SHARDING_FILTER-MULTI_ITERATOR.
         auto randomCursorPlan =
-            std::make_unique<ShardFilterStage>(opCtx, shardMetadata, ws.get(), root.release());
+            std::make_unique<ShardFilterStage>(opCtx, shardMetadata, ws.get(), std::move(root));
         // The backup plan is SHARDING_FILTER-COLLSCAN.
         std::unique_ptr<PlanStage> collScanPlan = std::make_unique<CollectionScan>(
             opCtx, coll, CollectionScanParams{}, ws.get(), nullptr);
         collScanPlan = std::make_unique<ShardFilterStage>(
-            opCtx, shardMetadata, ws.get(), collScanPlan.release());
+            opCtx, shardMetadata, ws.get(), std::move(collScanPlan));
         // Place a TRIAL stage at the root of the plan tree, and pass it the trial and backup plans.
         root = std::make_unique<TrialStage>(opCtx,
                                             ws.get(),
diff --git a/src/mongo/db/query/get_executor.cpp b/src/mongo/db/query/get_executor.cpp
index d36775885ce..4b039fa7aaf 100644
--- a/src/mongo/db/query/get_executor.cpp
+++ b/src/mongo/db/query/get_executor.cpp
@@ -385,7 +385,7 @@ StatusWith<PrepareExecutionResult> prepareExecution(OperationContext* opCtx,
                 CollectionShardingState::get(opCtx, canonicalQuery->nss())
                     ->getOrphansFilter(opCtx, collection),
                 ws,
-                root.release());
+                std::move(root));
         }
 
         // There might be a projection. The idhack stage will always fetch the full
@@ -397,7 +397,7 @@ StatusWith<PrepareExecutionResult> prepareExecution(OperationContext* opCtx,
             if (canonicalQuery->getProj()->wantSortKey()) {
                 root = std::make_unique<SortKeyGeneratorStage>(
                     canonicalQuery->getExpCtx(),
-                    root.release(),
+                    std::move(root),
                     ws,
                     canonicalQuery->getQueryRequest().getSort());
             }
@@ -456,23 +456,23 @@ StatusWith<PrepareExecutionResult> prepareExecution(OperationContext* opCtx,
                     LOG(2) << "Using fast count: " << redact(canonicalQuery->toStringShort());
                 }
 
-                PlanStage* rawRoot;
-                verify(StageBuilder::build(
-                    opCtx, collection, *canonicalQuery, *querySolution, ws, &rawRoot));
+                auto root =
+                    StageBuilder::build(opCtx, collection, *canonicalQuery, *querySolution, ws);
 
                 // Add a CachedPlanStage on top of the previous root.
                 //
                 // 'decisionWorks' is used to determine whether the existing cache entry should
                 // be evicted, and the query replanned.
-                root = std::make_unique<CachedPlanStage>(opCtx,
-                                                         collection,
-                                                         ws,
-                                                         canonicalQuery.get(),
-                                                         plannerParams,
-                                                         cs->decisionWorks,
-                                                         rawRoot);
-                return PrepareExecutionResult(
-                    std::move(canonicalQuery), std::move(querySolution), std::move(root));
+                auto cachedPlanStage = std::make_unique<CachedPlanStage>(opCtx,
+                                                                         collection,
+                                                                         ws,
+                                                                         canonicalQuery.get(),
+                                                                         plannerParams,
+                                                                         cs->decisionWorks,
+                                                                         std::move(root));
+                return PrepareExecutionResult(std::move(canonicalQuery),
+                                              std::move(querySolution),
+                                              std::move(cachedPlanStage));
             }
         }
     }
@@ -507,10 +507,8 @@ StatusWith<PrepareExecutionResult> prepareExecution(OperationContext* opCtx,
         for (size_t i = 0; i < solutions.size(); ++i) {
             if (turnIxscanIntoCount(solutions[i].get())) {
                 // We're not going to cache anything that's fast count.
-                PlanStage* rawRoot;
-                verify(StageBuilder::build(
-                    opCtx, collection, *canonicalQuery, *solutions[i], ws, &rawRoot));
-                root.reset(rawRoot);
+                auto root =
+                    StageBuilder::build(opCtx, collection, *canonicalQuery, *solutions[i], ws);
 
                 LOG(2) << "Using fast count: " << redact(canonicalQuery->toStringShort())
                        << ", planSummary: " << Explain::getPlanSummary(root.get());
@@ -523,10 +521,7 @@ StatusWith<PrepareExecutionResult> prepareExecution(OperationContext* opCtx,
 
     if (1 == solutions.size()) {
         // Only one possible plan.  Run it.  Build the stages from the solution.
-        PlanStage* rawRoot;
-        verify(
-            StageBuilder::build(opCtx, collection, *canonicalQuery, *solutions[0], ws, &rawRoot));
-        root.reset(rawRoot);
+        auto root = StageBuilder::build(opCtx, collection, *canonicalQuery, *solutions[0], ws);
 
         LOG(2) << "Only one plan is available; it will be run but will not be cached. "
                << redact(canonicalQuery->toStringShort())
@@ -545,13 +540,11 @@ StatusWith<PrepareExecutionResult> prepareExecution(OperationContext* opCtx,
                 solutions[ix]->cacheData->indexFilterApplied = plannerParams.indexFiltersApplied;
             }
 
-            // version of StageBuild::build when WorkingSet is shared
-            PlanStage* nextPlanRoot;
-            verify(StageBuilder::build(
-                opCtx, collection, *canonicalQuery, *solutions[ix], ws, &nextPlanRoot));
+            auto nextPlanRoot =
+                StageBuilder::build(opCtx, collection, *canonicalQuery, *solutions[ix], ws);
 
             // Takes ownership of 'nextPlanRoot'.
-            multiPlanStage->addPlan(std::move(solutions[ix]), nextPlanRoot, ws);
+            multiPlanStage->addPlan(std::move(solutions[ix]), std::move(nextPlanRoot), ws);
         }
 
         root = std::move(multiPlanStage);
@@ -1450,10 +1443,8 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorForS
     invariant(soln);
 
     unique_ptr<WorkingSet> ws = std::make_unique<WorkingSet>();
-    PlanStage* rawRoot;
-    verify(StageBuilder::build(
-        opCtx, collection, *parsedDistinct->getQuery(), *soln, ws.get(), &rawRoot));
-    unique_ptr<PlanStage> root(rawRoot);
+    auto root =
+        StageBuilder::build(opCtx, collection, *parsedDistinct->getQuery(), *soln, ws.get());
 
     LOG(2) << "Using fast distinct: " << redact(parsedDistinct->getQuery()->toStringShort())
            << ", planSummary: " << Explain::getPlanSummary(root.get());
@@ -1493,14 +1484,8 @@ getExecutorDistinctFromIndexSolutions(OperationContext* opCtx,
             // Build and return the SSR over solutions[i].
             unique_ptr<WorkingSet> ws = std::make_unique<WorkingSet>();
             unique_ptr<QuerySolution> currentSolution = std::move(solutions[i]);
-            PlanStage* rawRoot;
-            verify(StageBuilder::build(opCtx,
-                                       collection,
-                                       *parsedDistinct->getQuery(),
-                                       *currentSolution,
-                                       ws.get(),
-                                       &rawRoot));
-            unique_ptr<PlanStage> root(rawRoot);
+            auto root = StageBuilder::build(
+                opCtx, collection, *parsedDistinct->getQuery(), *currentSolution, ws.get());
 
             LOG(2) << "Using fast distinct: " << redact(parsedDistinct->getQuery()->toStringShort())
                    << ", planSummary: " << Explain::getPlanSummary(root.get());
diff --git a/src/mongo/db/query/internal_plans.cpp b/src/mongo/db/query/internal_plans.cpp
index 4e65301e867..860cf5a4ebd 100644
--- a/src/mongo/db/query/internal_plans.cpp
+++ b/src/mongo/db/query/internal_plans.cpp
@@ -217,7 +217,7 @@ std::unique_ptr<PlanStage> InternalPlanner::_indexScan(OperationContext* opCtx,
         std::make_unique<IndexScan>(opCtx, std::move(params), ws, nullptr);
 
     if (InternalPlanner::IXSCAN_FETCH & options) {
-        root = std::make_unique<FetchStage>(opCtx, ws, root.release(), nullptr, collection);
+        root = std::make_unique<FetchStage>(opCtx, ws, std::move(root), nullptr, collection);
     }
 
     return root;
diff --git a/src/mongo/db/query/stage_builder.cpp b/src/mongo/db/query/stage_builder.cpp
index 508690ae278..48cc9e39027 100644
--- a/src/mongo/db/query/stage_builder.cpp
+++ b/src/mongo/db/query/stage_builder.cpp
@@ -65,14 +65,14 @@
 
 namespace mongo {
 
-using std::unique_ptr;
-
-PlanStage* buildStages(OperationContext* opCtx,
-                       const Collection* collection,
-                       const CanonicalQuery& cq,
-                       const QuerySolution& qsol,
-                       const QuerySolutionNode* root,
-                       WorkingSet* ws) {
+// Returns a non-null pointer to the root of a plan tree, or a non-OK status if the PlanStage tree
+// could not be constructed.
+std::unique_ptr<PlanStage> buildStages(OperationContext* opCtx,
+                                       const Collection* collection,
+                                       const CanonicalQuery& cq,
+                                       const QuerySolution& qsol,
+                                       const QuerySolutionNode* root,
+                                       WorkingSet* ws) {
     switch (root->getType()) {
         case STAGE_COLLSCAN: {
             const CollectionScanNode* csn = static_cast<const CollectionScanNode*>(root);
@@ -85,16 +85,13 @@ PlanStage* buildStages(OperationContext* opCtx,
             params.minTs = csn->minTs;
             params.maxTs = csn->maxTs;
             params.stopApplyingFilterAfterFirstMatch = csn->stopApplyingFilterAfterFirstMatch;
-            return new CollectionScan(opCtx, collection, params, ws, csn->filter.get());
+            return std::make_unique<CollectionScan>(
+                opCtx, collection, params, ws, csn->filter.get());
         }
         case STAGE_IXSCAN: {
             const IndexScanNode* ixn = static_cast<const IndexScanNode*>(root);
 
-            if (nullptr == collection) {
-                warning() << "Can't ixscan null namespace";
-                return nullptr;
-            }
-
+            invariant(collection);
             auto descriptor = collection->getIndexCatalog()->findIndexByName(
                 opCtx, ixn->index.identifier.catalogName);
             invariant(descriptor,
@@ -113,124 +110,87 @@ PlanStage* buildStages(OperationContext* opCtx,
             params.direction = ixn->direction;
             params.addKeyMetadata = ixn->addKeyMetadata;
             params.shouldDedup = ixn->shouldDedup;
-            return new IndexScan(opCtx, std::move(params), ws, ixn->filter.get());
+            return std::make_unique<IndexScan>(opCtx, std::move(params), ws, ixn->filter.get());
         }
         case STAGE_FETCH: {
             const FetchNode* fn = static_cast<const FetchNode*>(root);
-            PlanStage* childStage = buildStages(opCtx, collection, cq, qsol, fn->children[0], ws);
-            if (nullptr == childStage) {
-                return nullptr;
-            }
-            return new FetchStage(opCtx, ws, childStage, fn->filter.get(), collection);
+            auto childStage = buildStages(opCtx, collection, cq, qsol, fn->children[0], ws);
+            return std::make_unique<FetchStage>(
+                opCtx, ws, std::move(childStage), fn->filter.get(), collection);
         }
         case STAGE_SORT: {
             const SortNode* sn = static_cast<const SortNode*>(root);
-            PlanStage* childStage = buildStages(opCtx, collection, cq, qsol, sn->children[0], ws);
-            if (nullptr == childStage) {
-                return nullptr;
-            }
+            auto childStage = buildStages(opCtx, collection, cq, qsol, sn->children[0], ws);
             SortStageParams params;
             params.pattern = sn->pattern;
             params.limit = sn->limit;
             params.allowDiskUse = sn->allowDiskUse;
-            return new SortStage(opCtx, params, ws, childStage);
+            return std::make_unique<SortStage>(opCtx, params, ws, std::move(childStage));
         }
         case STAGE_SORT_KEY_GENERATOR: {
             const SortKeyGeneratorNode* keyGenNode = static_cast<const SortKeyGeneratorNode*>(root);
-            PlanStage* childStage =
-                buildStages(opCtx, collection, cq, qsol, keyGenNode->children[0], ws);
-            if (nullptr == childStage) {
-                return nullptr;
-            }
-            return new SortKeyGeneratorStage(cq.getExpCtx(), childStage, ws, keyGenNode->sortSpec);
+            auto childStage = buildStages(opCtx, collection, cq, qsol, keyGenNode->children[0], ws);
+            return std::make_unique<SortKeyGeneratorStage>(
+                cq.getExpCtx(), std::move(childStage), ws, keyGenNode->sortSpec);
         }
         case STAGE_PROJECTION_DEFAULT: {
             auto pn = static_cast<const ProjectionNodeDefault*>(root);
-            unique_ptr<PlanStage> childStage{
-                buildStages(opCtx, collection, cq, qsol, pn->children[0], ws)};
-            if (nullptr == childStage) {
-                return nullptr;
-            }
-            return new ProjectionStageDefault(opCtx,
-                                              pn->projection,
-                                              ws,
-                                              std::move(childStage),
-                                              pn->fullExpression,
-                                              cq.getCollator());
+            auto childStage = buildStages(opCtx, collection, cq, qsol, pn->children[0], ws);
+            return std::make_unique<ProjectionStageDefault>(opCtx,
+                                                            pn->projection,
+                                                            ws,
+                                                            std::move(childStage),
+                                                            pn->fullExpression,
+                                                            cq.getCollator());
         }
         case STAGE_PROJECTION_COVERED: {
             auto pn = static_cast<const ProjectionNodeCovered*>(root);
-            unique_ptr<PlanStage> childStage{
-                buildStages(opCtx, collection, cq, qsol, pn->children[0], ws)};
-            if (nullptr == childStage) {
-                return nullptr;
-            }
-            return new ProjectionStageCovered(
+            auto childStage = buildStages(opCtx, collection, cq, qsol, pn->children[0], ws);
+            return std::make_unique<ProjectionStageCovered>(
                 opCtx, pn->projection, ws, std::move(childStage), pn->coveredKeyObj);
         }
         case STAGE_PROJECTION_SIMPLE: {
             auto pn = static_cast<const ProjectionNodeSimple*>(root);
-            unique_ptr<PlanStage> childStage{
-                buildStages(opCtx, collection, cq, qsol, pn->children[0], ws)};
-            if (nullptr == childStage) {
-                return nullptr;
-            }
-            return new ProjectionStageSimple(opCtx, pn->projection, ws, std::move(childStage));
+            auto childStage = buildStages(opCtx, collection, cq, qsol, pn->children[0], ws);
+            return std::make_unique<ProjectionStageSimple>(
+                opCtx, pn->projection, ws, std::move(childStage));
         }
         case STAGE_LIMIT: {
             const LimitNode* ln = static_cast<const LimitNode*>(root);
-            PlanStage* childStage = buildStages(opCtx, collection, cq, qsol, ln->children[0], ws);
-            if (nullptr == childStage) {
-                return nullptr;
-            }
-            return new LimitStage(opCtx, ln->limit, ws, childStage);
+            auto childStage = buildStages(opCtx, collection, cq, qsol, ln->children[0], ws);
+            return std::make_unique<LimitStage>(opCtx, ln->limit, ws, std::move(childStage));
         }
         case STAGE_SKIP: {
             const SkipNode* sn = static_cast<const SkipNode*>(root);
-            PlanStage* childStage = buildStages(opCtx, collection, cq, qsol, sn->children[0], ws);
-            if (nullptr == childStage) {
-                return nullptr;
-            }
-            return new SkipStage(opCtx, sn->skip, ws, childStage);
+            auto childStage = buildStages(opCtx, collection, cq, qsol, sn->children[0], ws);
+            return std::make_unique<SkipStage>(opCtx, sn->skip, ws, std::move(childStage));
         }
         case STAGE_AND_HASH: {
             const AndHashNode* ahn = static_cast<const AndHashNode*>(root);
             auto ret = std::make_unique<AndHashStage>(opCtx, ws);
             for (size_t i = 0; i < ahn->children.size(); ++i) {
-                PlanStage* childStage =
-                    buildStages(opCtx, collection, cq, qsol, ahn->children[i], ws);
-                if (nullptr == childStage) {
-                    return nullptr;
-                }
-                ret->addChild(childStage);
+                auto childStage = buildStages(opCtx, collection, cq, qsol, ahn->children[i], ws);
+                ret->addChild(std::move(childStage));
             }
-            return ret.release();
+            return ret;
         }
         case STAGE_OR: {
             const OrNode* orn = static_cast<const OrNode*>(root);
             auto ret = std::make_unique<OrStage>(opCtx, ws, orn->dedup, orn->filter.get());
             for (size_t i = 0; i < orn->children.size(); ++i) {
-                PlanStage* childStage =
-                    buildStages(opCtx, collection, cq, qsol, orn->children[i], ws);
-                if (nullptr == childStage) {
-                    return nullptr;
-                }
-                ret->addChild(childStage);
+                auto childStage = buildStages(opCtx, collection, cq, qsol, orn->children[i], ws);
+                ret->addChild(std::move(childStage));
             }
-            return ret.release();
+            return ret;
         }
         case STAGE_AND_SORTED: {
             const AndSortedNode* asn = static_cast<const AndSortedNode*>(root);
             auto ret = std::make_unique<AndSortedStage>(opCtx, ws);
             for (size_t i = 0; i < asn->children.size(); ++i) {
-                PlanStage* childStage =
-                    buildStages(opCtx, collection, cq, qsol, asn->children[i], ws);
-                if (nullptr == childStage) {
-                    return nullptr;
-                }
-                ret->addChild(childStage);
+                auto childStage = buildStages(opCtx, collection, cq, qsol, asn->children[i], ws);
+                ret->addChild(std::move(childStage));
             }
-            return ret.release();
+            return ret;
         }
         case STAGE_SORT_MERGE: {
             const MergeSortNode* msn = static_cast<const MergeSortNode*>(root);
@@ -240,14 +200,10 @@ PlanStage* buildStages(OperationContext* opCtx,
             params.collator = cq.getCollator();
             auto ret = std::make_unique<MergeSortStage>(opCtx, params, ws);
             for (size_t i = 0; i < msn->children.size(); ++i) {
-                PlanStage* childStage =
-                    buildStages(opCtx, collection, cq, qsol, msn->children[i], ws);
-                if (nullptr == childStage) {
-                    return nullptr;
-                }
-                ret->addChild(childStage);
+                auto childStage = buildStages(opCtx, collection, cq, qsol, msn->children[i], ws);
+                ret->addChild(std::move(childStage));
             }
-            return ret.release();
+            return ret;
         }
         case STAGE_GEO_NEAR_2D: {
             const GeoNear2DNode* node = static_cast<const GeoNear2DNode*>(root);
@@ -259,13 +215,12 @@ PlanStage* buildStages(OperationContext* opCtx,
             params.addPointMeta = node->addPointMeta;
             params.addDistMeta = node->addDistMeta;
 
+            invariant(collection);
             const IndexDescriptor* twoDIndex = collection->getIndexCatalog()->findIndexByName(
                 opCtx, node->index.identifier.catalogName);
             invariant(twoDIndex);
 
-            GeoNear2DStage* nearStage = new GeoNear2DStage(params, opCtx, ws, twoDIndex);
-
-            return nearStage;
+            return std::make_unique<GeoNear2DStage>(params, opCtx, ws, twoDIndex);
         }
         case STAGE_GEO_NEAR_2DSPHERE: {
             const GeoNear2DSphereNode* node = static_cast<const GeoNear2DSphereNode*>(root);
@@ -277,14 +232,16 @@ PlanStage* buildStages(OperationContext* opCtx,
             params.addPointMeta = node->addPointMeta;
             params.addDistMeta = node->addDistMeta;
 
+            invariant(collection);
             const IndexDescriptor* s2Index = collection->getIndexCatalog()->findIndexByName(
                 opCtx, node->index.identifier.catalogName);
             invariant(s2Index);
 
-            return new GeoNear2DSphereStage(params, opCtx, ws, s2Index);
+            return std::make_unique<GeoNear2DSphereStage>(params, opCtx, ws, s2Index);
         }
         case STAGE_TEXT: {
             const TextNode* node = static_cast<const TextNode*>(root);
+            invariant(collection);
             const IndexDescriptor* desc = collection->getIndexCatalog()->findIndexByName(
                 opCtx, node->index.identifier.catalogName);
             invariant(desc);
@@ -296,33 +253,24 @@ PlanStage* buildStages(OperationContext* opCtx,
             params.index = desc;
             params.indexPrefix = node->indexPrefix;
             // We assume here that node->ftsQuery is an FTSQueryImpl, not an FTSQueryNoop. In
-            // practice,
-            // this means that it is illegal to use the StageBuilder on a QuerySolution created by
-            // planning a query that contains "no-op" expressions. TODO: make StageBuilder::build()
-            // fail in this case (this improvement is being tracked by SERVER-21510).
+            // practice, this means that it is illegal to use the StageBuilder on a QuerySolution
+            // created by planning a query that contains "no-op" expressions.
             params.query = static_cast<FTSQueryImpl&>(*node->ftsQuery);
             params.wantTextScore = (cq.getProj() && cq.getProj()->wantTextScore());
-            return new TextStage(opCtx, params, ws, node->filter.get());
+            return std::make_unique<TextStage>(opCtx, params, ws, node->filter.get());
         }
         case STAGE_SHARDING_FILTER: {
             const ShardingFilterNode* fn = static_cast<const ShardingFilterNode*>(root);
-            PlanStage* childStage = buildStages(opCtx, collection, cq, qsol, fn->children[0], ws);
-            if (nullptr == childStage) {
-                return nullptr;
-            }
+            auto childStage = buildStages(opCtx, collection, cq, qsol, fn->children[0], ws);
 
             auto css = CollectionShardingState::get(opCtx, collection->ns());
-            return new ShardFilterStage(
-                opCtx, css->getOrphansFilter(opCtx, collection), ws, childStage);
+            return std::make_unique<ShardFilterStage>(
+                opCtx, css->getOrphansFilter(opCtx, collection), ws, std::move(childStage));
         }
         case STAGE_DISTINCT_SCAN: {
             const DistinctNode* dn = static_cast<const DistinctNode*>(root);
 
-            if (nullptr == collection) {
-                warning() << "Can't distinct-scan null namespace";
-                return nullptr;
-            }
-
+            invariant(collection);
             auto descriptor = collection->getIndexCatalog()->findIndexByName(
                 opCtx, dn->index.identifier.catalogName);
             invariant(descriptor);
@@ -338,16 +286,12 @@ PlanStage* buildStages(OperationContext* opCtx,
             params.scanDirection = dn->direction;
             params.bounds = dn->bounds;
             params.fieldNo = dn->fieldNo;
-            return new DistinctScan(opCtx, std::move(params), ws);
+            return std::make_unique<DistinctScan>(opCtx, std::move(params), ws);
         }
         case STAGE_COUNT_SCAN: {
             const CountScanNode* csn = static_cast<const CountScanNode*>(root);
 
-            if (nullptr == collection) {
-                warning() << "Can't fast-count null namespace (collection null)";
-                return nullptr;
-            }
-
+            invariant(collection);
             auto descriptor = collection->getIndexCatalog()->findIndexByName(
                 opCtx, csn->index.identifier.catalogName);
             invariant(descriptor);
@@ -364,15 +308,13 @@ PlanStage* buildStages(OperationContext* opCtx,
             params.startKeyInclusive = csn->startKeyInclusive;
             params.endKey = csn->endKey;
             params.endKeyInclusive = csn->endKeyInclusive;
-            return new CountScan(opCtx, std::move(params), ws);
+            return std::make_unique<CountScan>(opCtx, std::move(params), ws);
         }
         case STAGE_ENSURE_SORTED: {
             const EnsureSortedNode* esn = static_cast<const EnsureSortedNode*>(root);
-            PlanStage* childStage = buildStages(opCtx, collection, cq, qsol, esn->children[0], ws);
-            if (nullptr == childStage) {
-                return nullptr;
-            }
-            return new EnsureSortedStage(opCtx, esn->pattern, ws, childStage);
+            auto childStage = buildStages(opCtx, collection, cq, qsol, esn->children[0], ws);
+            return std::make_unique<EnsureSortedStage>(
+                opCtx, esn->pattern, ws, std::move(childStage));
         }
         case STAGE_CACHED_PLAN:
         case STAGE_CHANGE_STREAM_PROXY:
@@ -397,30 +339,26 @@ PlanStage* buildStages(OperationContext* opCtx,
             warning() << "Can't build exec tree for node " << nodeStr << endl;
         }
     }
-    return nullptr;
+
+    MONGO_UNREACHABLE;
 }
 
-// static (this one is used for Cached and MultiPlanStage)
-bool StageBuilder::build(OperationContext* opCtx,
-                         const Collection* collection,
-                         const CanonicalQuery& cq,
-                         const QuerySolution& solution,
-                         WorkingSet* wsIn,
-                         PlanStage** rootOut) {
+std::unique_ptr<PlanStage> StageBuilder::build(OperationContext* opCtx,
+                                               const Collection* collection,
+                                               const CanonicalQuery& cq,
+                                               const QuerySolution& solution,
+                                               WorkingSet* wsIn) {
     // Only QuerySolutions derived from queries parsed with context, or QuerySolutions derived from
     // queries that disallow extensions, can be properly executed. If the query does not have
     // $text/$where context (and $text/$where are allowed), then no attempt should be made to
     // execute the query.
     invariant(!cq.canHaveNoopMatchNodes());
 
-    if (nullptr == wsIn || nullptr == rootOut) {
-        return false;
-    }
+    invariant(wsIn);
+    invariant(solution.root);
+
     QuerySolutionNode* solutionNode = solution.root.get();
-    if (nullptr == solutionNode) {
-        return false;
-    }
-    return nullptr != (*rootOut = buildStages(opCtx, collection, cq, solution, solutionNode, wsIn));
+    return buildStages(opCtx, collection, cq, solution, solutionNode, wsIn);
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/query/stage_builder.h b/src/mongo/db/query/stage_builder.h
index 9ffceef53cf..a0437832822 100644
--- a/src/mongo/db/query/stage_builder.h
+++ b/src/mongo/db/query/stage_builder.h
@@ -43,21 +43,17 @@ class OperationContext;
 class StageBuilder {
 public:
     /**
-     * Turns 'solution' into an executable tree of PlanStage(s).
+     * Turns 'solution' into an executable tree of PlanStage(s). Returns a pointer to the root of
+     * the plan stage tree.
      *
-     * 'cq' must be the CanonicalQuery from which 'solution' is derived.
-     *
-     * Returns true if the PlanStage tree was built successfully.  The root of the tree is in
-     * *rootOut and the WorkingSet that the tree uses is in wsIn.
-     *
-     * Returns false otherwise.  *rootOut and *wsOut are invalid.
+     * 'cq' must be the CanonicalQuery from which 'solution' is derived. Illegal to call if 'wsIn'
+     * is nullptr, or if 'solution.root' is nullptr.
      */
-    static bool build(OperationContext* opCtx,
-                      const Collection* collection,
-                      const CanonicalQuery& cq,
-                      const QuerySolution& solution,
-                      WorkingSet* wsIn,
-                      PlanStage** rootOut);
+    static std::unique_ptr<PlanStage> build(OperationContext* opCtx,
+                                            const Collection* collection,
+                                            const CanonicalQuery& cq,
+                                            const QuerySolution& solution,
+                                            WorkingSet* wsIn);
 };
 
 }  // namespace mongo
diff --git a/src/mongo/dbtests/plan_ranking.cpp b/src/mongo/dbtests/plan_ranking.cpp
index dddeb46e162..b4c9d67380e 100644
--- a/src/mongo/dbtests/plan_ranking.cpp
+++ b/src/mongo/dbtests/plan_ranking.cpp
@@ -130,10 +130,8 @@ public:
         unique_ptr<WorkingSet> ws(new WorkingSet());
         // Put each solution from the planner into the MPR.
         for (size_t i = 0; i < solutions.size(); ++i) {
-            PlanStage* root;
-            ASSERT(StageBuilder::build(&_opCtx, collection, *cq, *solutions[i], ws.get(), &root));
-            // Takes ownership of 'root'.
-            _mps->addPlan(std::move(solutions[i]), root, ws.get());
+            auto root = StageBuilder::build(&_opCtx, collection, *cq, *solutions[i], ws.get());
+            _mps->addPlan(std::move(solutions[i]), std::move(root), ws.get());
         }
         // This is what sets a backup plan, should we test for it.
         PlanYieldPolicy yieldPolicy(PlanExecutor::NO_YIELD,
diff --git a/src/mongo/dbtests/query_plan_executor.cpp b/src/mongo/dbtests/query_plan_executor.cpp
index 4d645862ffc..82f6251867a 100644
--- a/src/mongo/dbtests/query_plan_executor.cpp
+++ b/src/mongo/dbtests/query_plan_executor.cpp
@@ -151,8 +151,9 @@ public:
         const Collection* coll = db->getCollection(&_opCtx, nss);
 
         unique_ptr<WorkingSet> ws(new WorkingSet());
-        IndexScan* ix = new IndexScan(&_opCtx, ixparams, ws.get(), nullptr);
-        unique_ptr<PlanStage> root(new FetchStage(&_opCtx, ws.get(), ix, nullptr, coll));
+        auto ixscan = std::make_unique<IndexScan>(&_opCtx, ixparams, ws.get(), nullptr);
+        unique_ptr<PlanStage> root =
+            std::make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ixscan), nullptr, coll);
 
         auto qr = std::make_unique<QueryRequest>(nss);
         auto statusWithCQ = CanonicalQuery::canonicalize(&_opCtx, std::move(qr));
diff --git a/src/mongo/dbtests/query_stage_and.cpp b/src/mongo/dbtests/query_stage_and.cpp
index d48063a2903..a4059b60115 100644
--- a/src/mongo/dbtests/query_stage_and.cpp
+++ b/src/mongo/dbtests/query_stage_and.cpp
@@ -205,12 +205,12 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar >= 10.
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 10);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // 'ah' reads the first child into its hash table: foo=20, foo=19, ..., foo=0
         // in that order. Read half of them.
@@ -292,13 +292,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar <= 19 (descending).
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 19);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // First call to work reads the first result from the children. The first result for the
         // first scan over foo is {foo: 20, bar: 20, baz: 20}. The first result for the second scan
@@ -372,13 +372,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar >= 10
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 10);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // foo == bar == baz, and foo<=20, bar>=10, so our values are:
         // foo == 10, 11, 12, 13, 14, 15. 16, 17, 18, 19, 20
@@ -421,13 +421,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1 << "big" << 1), coll));
         params.bounds.startKey = BSON("" << 20 << "" << big);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar >= 10
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 10);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Stage execution should fail.
         ASSERT_EQUALS(-1, countResults(ah.get()));
@@ -468,13 +468,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar >= 10
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1 << "big" << 1), coll));
         params.bounds.startKey = BSON("" << 10 << "" << big);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // foo == bar == baz, and foo<=20, bar>=10, so our values are:
         // foo == 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20.
@@ -510,18 +510,18 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar >= 10
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 10);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // 5 <= baz <= 15
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("baz" << 1), coll));
         params.bounds.startKey = BSON("" << 5);
         params.bounds.endKey = BSON("" << 15);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // foo == bar == baz, and foo<=20, bar>=10, 5<=baz<=15, so our values are:
         // foo == 10, 11, 12, 13, 14, 15.
@@ -568,18 +568,18 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar >= 10
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1 << "big" << 1), coll));
         params.bounds.startKey = BSON("" << 10 << "" << big);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // 5 <= baz <= 15
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("baz" << 1), coll));
         params.bounds.startKey = BSON("" << 5);
         params.bounds.endKey = BSON("" << 15);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Stage execution should fail.
         ASSERT_EQUALS(-1, countResults(ah.get()));
@@ -613,13 +613,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar == 5.  Index scan should be eof.
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 5);
         params.bounds.endKey = BSON("" << 5);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         int count = 0;
         int works = 0;
@@ -669,7 +669,7 @@ public:
         // Foo >= 100
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 100);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar <= 100
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
@@ -681,7 +681,7 @@ public:
                                     << "");
         params.bounds.boundInclusion = BoundInclusion::kIncludeStartKeyOnly;
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         ASSERT_EQUALS(0, countResults(ah.get()));
     }
@@ -717,17 +717,18 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        IndexScan* firstScan = new IndexScan(&_opCtx, params, &ws, nullptr);
+        auto firstScan = std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr);
 
         // First child of the AND_HASH stage is a Fetch. The NULL in the
         // constructor means there is no filter.
-        FetchStage* fetch = new FetchStage(&_opCtx, &ws, firstScan, nullptr, coll);
-        ah->addChild(fetch);
+        auto fetch =
+            std::make_unique<FetchStage>(&_opCtx, &ws, std::move(firstScan), nullptr, coll);
+        ah->addChild(std::move(fetch));
 
         // Bar >= 10
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 10);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Check that the AndHash stage returns docs {foo: 10, bar: 10}
         // through {foo: 20, bar: 20}.
@@ -769,17 +770,18 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.direction = -1;
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar >= 10
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 10);
-        IndexScan* secondScan = new IndexScan(&_opCtx, params, &ws, nullptr);
+        auto secondScan = std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr);
 
         // Second child of the AND_HASH stage is a Fetch. The NULL in the
         // constructor means there is no filter.
-        FetchStage* fetch = new FetchStage(&_opCtx, &ws, secondScan, nullptr, coll);
-        ah->addChild(fetch);
+        auto fetch =
+            std::make_unique<FetchStage>(&_opCtx, &ws, std::move(secondScan), nullptr, coll);
+        ah->addChild(std::move(fetch));
 
         // Check that the AndHash stage returns docs {foo: 10, bar: 10}
         // through {foo: 20, bar: 20}.
@@ -827,8 +829,8 @@ public:
             childStage2->pushBack(PlanStage::NEED_TIME);
             childStage2->pushBack(PlanStage::FAILURE);
 
-            andHashStage->addChild(childStage1.release());
-            andHashStage->addChild(childStage2.release());
+            andHashStage->addChild(std::move(childStage1));
+            andHashStage->addChild(std::move(childStage2));
 
             WorkingSetID id = WorkingSet::INVALID_ID;
             PlanStage::StageState state = PlanStage::NEED_TIME;
@@ -868,8 +870,8 @@ public:
                 childStage2->pushBack(id);
             }
 
-            andHashStage->addChild(childStage1.release());
-            andHashStage->addChild(childStage2.release());
+            andHashStage->addChild(std::move(childStage1));
+            andHashStage->addChild(std::move(childStage2));
 
             WorkingSetID id = WorkingSet::INVALID_ID;
             PlanStage::StageState state = PlanStage::NEED_TIME;
@@ -908,8 +910,8 @@ public:
             }
             childStage2->pushBack(PlanStage::FAILURE);
 
-            andHashStage->addChild(childStage1.release());
-            andHashStage->addChild(childStage2.release());
+            andHashStage->addChild(std::move(childStage1));
+            andHashStage->addChild(std::move(childStage2));
 
             WorkingSetID id = WorkingSet::INVALID_ID;
             PlanStage::StageState state = PlanStage::NEED_TIME;
@@ -955,13 +957,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Scan over bar == 1.
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Get the set of RecordIds in our collection to use later.
         set<RecordId> data;
@@ -1072,19 +1074,19 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // bar == 1
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // baz == 1
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("baz" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         ASSERT_EQUALS(50, countResults(ah.get()));
     }
@@ -1117,13 +1119,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 7);
         params.bounds.endKey = BSON("" << 7);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Bar == 20, not EOF.
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.bounds.endKey = BSON("" << 20);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         ASSERT_EQUALS(0, countResults(ah.get()));
     }
@@ -1160,13 +1162,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 7);
         params.bounds.endKey = BSON("" << 7);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // bar == 20.
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 20);
         params.bounds.endKey = BSON("" << 20);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         ASSERT_EQUALS(0, countResults(ah.get()));
     }
@@ -1199,13 +1201,13 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // Intersect with 7 <= bar < 10000
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 7);
         params.bounds.endKey = BSON("" << 10000);
-        ah->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        ah->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         WorkingSetID lastId = WorkingSet::INVALID_ID;
 
@@ -1261,18 +1263,19 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        IndexScan* firstScan = new IndexScan(&_opCtx, params, &ws, nullptr);
+        auto firstScan = std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr);
 
         // First child of the AND_SORTED stage is a Fetch. The NULL in the
         // constructor means there is no filter.
-        FetchStage* fetch = new FetchStage(&_opCtx, &ws, firstScan, nullptr, coll);
-        as->addChild(fetch);
+        auto fetch =
+            std::make_unique<FetchStage>(&_opCtx, &ws, std::move(firstScan), nullptr, coll);
+        as->addChild(std::move(fetch));
 
         // bar == 1
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        as->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        as->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         for (int i = 0; i < 50; i++) {
             BSONObj obj = getNext(as.get(), &ws);
@@ -1313,18 +1316,19 @@ public:
         auto params = makeIndexScanParams(&_opCtx, getIndex(BSON("foo" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        as->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+        as->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
 
         // bar == 1
         params = makeIndexScanParams(&_opCtx, getIndex(BSON("bar" << 1), coll));
         params.bounds.startKey = BSON("" << 1);
         params.bounds.endKey = BSON("" << 1);
-        IndexScan* secondScan = new IndexScan(&_opCtx, params, &ws, nullptr);
+        auto secondScan = std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr);
 
         // Second child of the AND_SORTED stage is a Fetch. The NULL in the
         // constructor means there is no filter.
-        FetchStage* fetch = new FetchStage(&_opCtx, &ws, secondScan, nullptr, coll);
-        as->addChild(fetch);
+        auto fetch =
+            std::make_unique<FetchStage>(&_opCtx, &ws, std::move(secondScan), nullptr, coll);
+        as->addChild(std::move(fetch));
 
         for (int i = 0; i < 50; i++) {
             BSONObj obj = getNext(as.get(), &ws);
diff --git a/src/mongo/dbtests/query_stage_cached_plan.cpp b/src/mongo/dbtests/query_stage_cached_plan.cpp
index bfb99241e81..fd3b508fc37 100644
--- a/src/mongo/dbtests/query_stage_cached_plan.cpp
+++ b/src/mongo/dbtests/query_stage_cached_plan.cpp
@@ -158,7 +158,7 @@ public:
         }
 
         CachedPlanStage cachedPlanStage(
-            &_opCtx, collection, &_ws, cq, plannerParams, decisionWorks, mockChild.release());
+            &_opCtx, collection, &_ws, cq, plannerParams, decisionWorks, std::move(mockChild));
 
         // This should succeed after triggering a replan.
         PlanYieldPolicy yieldPolicy(PlanExecutor::NO_YIELD,
@@ -205,7 +205,7 @@ TEST_F(QueryStageCachedPlan, QueryStageCachedPlanFailure) {
     // High enough so that we shouldn't trigger a replan based on works.
     const size_t decisionWorks = 50;
     CachedPlanStage cachedPlanStage(
-        &_opCtx, collection, &_ws, cq.get(), plannerParams, decisionWorks, mockChild.release());
+        &_opCtx, collection, &_ws, cq.get(), plannerParams, decisionWorks, std::move(mockChild));
 
     // This should succeed after triggering a replan.
     PlanYieldPolicy yieldPolicy(PlanExecutor::NO_YIELD,
@@ -255,7 +255,7 @@ TEST_F(QueryStageCachedPlan, QueryStageCachedPlanHitMaxWorks) {
     }
 
     CachedPlanStage cachedPlanStage(
-        &_opCtx, collection, &_ws, cq.get(), plannerParams, decisionWorks, mockChild.release());
+        &_opCtx, collection, &_ws, cq.get(), plannerParams, decisionWorks, std::move(mockChild));
 
     // This should succeed after triggering a replan.
     PlanYieldPolicy yieldPolicy(PlanExecutor::NO_YIELD,
@@ -459,7 +459,7 @@ TEST_F(QueryStageCachedPlan, ThrowsOnYieldRecoveryWhenIndexIsDroppedBeforePlanSe
                                     cq.get(),
                                     plannerParams,
                                     decisionWorks,
-                                    new QueuedDataStage(&_opCtx, &_ws));
+                                    std::make_unique<QueuedDataStage>(&_opCtx, &_ws));
 
     // Drop an index while the CachedPlanStage is in a saved state. Restoring should fail, since we
     // may still need the dropped index for plan selection.
@@ -501,7 +501,7 @@ TEST_F(QueryStageCachedPlan, DoesNotThrowOnYieldRecoveryWhenIndexIsDroppedAferPl
                                     cq.get(),
                                     plannerParams,
                                     decisionWorks,
-                                    new QueuedDataStage(&_opCtx, &_ws));
+                                    std::make_unique<QueuedDataStage>(&_opCtx, &_ws));
 
     PlanYieldPolicy yieldPolicy(PlanExecutor::YIELD_MANUAL,
                                 _opCtx.getServiceContext()->getFastClockSource());
diff --git a/src/mongo/dbtests/query_stage_ensure_sorted.cpp b/src/mongo/dbtests/query_stage_ensure_sorted.cpp
index f5d9c8b4c50..a3a81a84660 100644
--- a/src/mongo/dbtests/query_stage_ensure_sorted.cpp
+++ b/src/mongo/dbtests/query_stage_ensure_sorted.cpp
@@ -86,8 +86,8 @@ public:
         // Initialization.
         BSONObj pattern = fromjson(patternStr);
         auto sortKeyGen = std::make_unique<SortKeyGeneratorStage>(
-            pExpCtx, queuedDataStage.release(), &ws, pattern);
-        EnsureSortedStage ess(opCtx.get(), pattern, &ws, sortKeyGen.release());
+            pExpCtx, std::move(queuedDataStage), &ws, pattern);
+        EnsureSortedStage ess(opCtx.get(), pattern, &ws, std::move(sortKeyGen));
         WorkingSetID id = WorkingSet::INVALID_ID;
         PlanStage::StageState state = PlanStage::NEED_TIME;
 
@@ -125,9 +125,9 @@ TEST_F(QueryStageEnsureSortedTest, EnsureSortedEmptyWorkingSet) {
 
     WorkingSet ws;
     auto queuedDataStage = std::make_unique<QueuedDataStage>(opCtx.get(), &ws);
-    auto sortKeyGen =
-        std::make_unique<SortKeyGeneratorStage>(pExpCtx, queuedDataStage.release(), &ws, BSONObj());
-    EnsureSortedStage ess(opCtx.get(), BSONObj(), &ws, sortKeyGen.release());
+    auto sortKeyGen = std::make_unique<SortKeyGeneratorStage>(
+        pExpCtx, std::move(queuedDataStage), &ws, BSONObj());
+    EnsureSortedStage ess(opCtx.get(), BSONObj(), &ws, std::move(sortKeyGen));
 
     WorkingSetID id = WorkingSet::INVALID_ID;
     PlanStage::StageState state = PlanStage::NEED_TIME;
diff --git a/src/mongo/dbtests/query_stage_fetch.cpp b/src/mongo/dbtests/query_stage_fetch.cpp
index a03c7a64e8e..8e6b0930e90 100644
--- a/src/mongo/dbtests/query_stage_fetch.cpp
+++ b/src/mongo/dbtests/query_stage_fetch.cpp
@@ -138,8 +138,8 @@ public:
             mockStage->pushBack(id);
         }
 
-        unique_ptr<FetchStage> fetchStage(
-            new FetchStage(&_opCtx, &ws, mockStage.release(), nullptr, coll));
+        auto fetchStage =
+            std::make_unique<FetchStage>(&_opCtx, &ws, std::move(mockStage), nullptr, coll);
 
         WorkingSetID id = WorkingSet::INVALID_ID;
         PlanStage::StageState state;
@@ -207,8 +207,8 @@ public:
         unique_ptr<MatchExpression> filterExpr = std::move(statusWithMatcher.getValue());
 
         // Matcher requires that foo==6 but we only have data with foo==5.
-        unique_ptr<FetchStage> fetchStage(
-            new FetchStage(&_opCtx, &ws, mockStage.release(), filterExpr.get(), coll));
+        auto fetchStage = std::make_unique<FetchStage>(
+            &_opCtx, &ws, std::move(mockStage), filterExpr.get(), coll);
 
         // First call should return a fetch request as it's not in memory.
         WorkingSetID id = WorkingSet::INVALID_ID;
diff --git a/src/mongo/dbtests/query_stage_limit_skip.cpp b/src/mongo/dbtests/query_stage_limit_skip.cpp
index 1ef07023e7c..69dd1d5b6da 100644
--- a/src/mongo/dbtests/query_stage_limit_skip.cpp
+++ b/src/mongo/dbtests/query_stage_limit_skip.cpp
@@ -56,7 +56,7 @@ using std::unique_ptr;
 static const int N = 50;
 
 /* Populate a QueuedDataStage and return it.  Caller owns it. */
-QueuedDataStage* getMS(OperationContext* opCtx, WorkingSet* ws) {
+std::unique_ptr<QueuedDataStage> getMS(OperationContext* opCtx, WorkingSet* ws) {
     auto ms = std::make_unique<QueuedDataStage>(opCtx, ws);
 
     // Put N ADVANCED results into the mock stage, and some other stalling results (YIELD/TIME).
@@ -72,7 +72,7 @@ QueuedDataStage* getMS(OperationContext* opCtx, WorkingSet* ws) {
         ms->pushBack(PlanStage::NEED_TIME);
     }
 
-    return ms.release();
+    return ms;
 }
 
 int countResults(PlanStage* stage) {
diff --git a/src/mongo/dbtests/query_stage_merge_sort.cpp b/src/mongo/dbtests/query_stage_merge_sort.cpp
index 445a6891ed9..14a0d2019d8 100644
--- a/src/mongo/dbtests/query_stage_merge_sort.cpp
+++ b/src/mongo/dbtests/query_stage_merge_sort.cpp
@@ -169,18 +169,18 @@ public:
         // Sort by c:1
         MergeSortStageParams msparams;
         msparams.pattern = BSON("c" << 1);
-        MergeSortStage* ms = new MergeSortStage(&_opCtx, msparams, ws.get());
+        auto ms = std::make_unique<MergeSortStage>(&_opCtx, msparams, ws.get());
 
         // a:1
         auto params = makeIndexScanParams(&_opCtx, getIndex(firstIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         // b:1
         params = makeIndexScanParams(&_opCtx, getIndex(secondIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         unique_ptr<FetchStage> fetchStage =
-            make_unique<FetchStage>(&_opCtx, ws.get(), ms, nullptr, coll);
+            make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ms), nullptr, coll);
         // Must fetch if we want to easily pull out an obj.
         auto statusWithPlanExecutor = PlanExecutor::make(
             &_opCtx, std::move(ws), std::move(fetchStage), coll, PlanExecutor::NO_YIELD);
@@ -234,17 +234,17 @@ public:
         // Sort by c:1
         MergeSortStageParams msparams;
         msparams.pattern = BSON("c" << 1);
-        MergeSortStage* ms = new MergeSortStage(&_opCtx, msparams, ws.get());
+        auto ms = std::make_unique<MergeSortStage>(&_opCtx, msparams, ws.get());
 
         // a:1
         auto params = makeIndexScanParams(&_opCtx, getIndex(firstIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         // b:1
         params = makeIndexScanParams(&_opCtx, getIndex(secondIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
         unique_ptr<FetchStage> fetchStage =
-            make_unique<FetchStage>(&_opCtx, ws.get(), ms, nullptr, coll);
+            make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ms), nullptr, coll);
 
         auto statusWithPlanExecutor = PlanExecutor::make(
             &_opCtx, std::move(ws), std::move(fetchStage), coll, PlanExecutor::NO_YIELD);
@@ -298,17 +298,17 @@ public:
         MergeSortStageParams msparams;
         msparams.dedup = false;
         msparams.pattern = BSON("c" << 1);
-        MergeSortStage* ms = new MergeSortStage(&_opCtx, msparams, ws.get());
+        auto ms = std::make_unique<MergeSortStage>(&_opCtx, msparams, ws.get());
 
         // a:1
         auto params = makeIndexScanParams(&_opCtx, getIndex(firstIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         // b:1
         params = makeIndexScanParams(&_opCtx, getIndex(secondIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
         unique_ptr<FetchStage> fetchStage =
-            make_unique<FetchStage>(&_opCtx, ws.get(), ms, nullptr, coll);
+            make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ms), nullptr, coll);
 
         auto statusWithPlanExecutor = PlanExecutor::make(
             &_opCtx, std::move(ws), std::move(fetchStage), coll, PlanExecutor::NO_YIELD);
@@ -364,21 +364,21 @@ public:
         // Sort by c:-1
         MergeSortStageParams msparams;
         msparams.pattern = BSON("c" << -1);
-        MergeSortStage* ms = new MergeSortStage(&_opCtx, msparams, ws.get());
+        auto ms = std::make_unique<MergeSortStage>(&_opCtx, msparams, ws.get());
 
         // a:1
         auto params = makeIndexScanParams(&_opCtx, getIndex(firstIndex, coll));
         params.bounds.startKey = objWithMaxKey(1);
         params.bounds.endKey = objWithMinKey(1);
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         // b:1
         params = makeIndexScanParams(&_opCtx, getIndex(secondIndex, coll));
         params.bounds.startKey = objWithMaxKey(1);
         params.bounds.endKey = objWithMinKey(1);
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
         unique_ptr<FetchStage> fetchStage =
-            make_unique<FetchStage>(&_opCtx, ws.get(), ms, nullptr, coll);
+            make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ms), nullptr, coll);
 
         auto statusWithPlanExecutor = PlanExecutor::make(
             &_opCtx, std::move(ws), std::move(fetchStage), coll, PlanExecutor::NO_YIELD);
@@ -432,19 +432,19 @@ public:
         // Sort by c:1
         MergeSortStageParams msparams;
         msparams.pattern = BSON("c" << 1);
-        MergeSortStage* ms = new MergeSortStage(&_opCtx, msparams, ws.get());
+        auto ms = std::make_unique<MergeSortStage>(&_opCtx, msparams, ws.get());
 
         // a:1
         auto params = makeIndexScanParams(&_opCtx, getIndex(firstIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         // b:51 (EOF)
         params = makeIndexScanParams(&_opCtx, getIndex(secondIndex, coll));
         params.bounds.startKey = BSON("" << 51 << "" << MinKey);
         params.bounds.endKey = BSON("" << 51 << "" << MaxKey);
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
         unique_ptr<FetchStage> fetchStage =
-            make_unique<FetchStage>(&_opCtx, ws.get(), ms, nullptr, coll);
+            make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ms), nullptr, coll);
 
         auto statusWithPlanExecutor = PlanExecutor::make(
             &_opCtx, std::move(ws), std::move(fetchStage), coll, PlanExecutor::NO_YIELD);
@@ -482,7 +482,7 @@ public:
         // Sort by foo:1
         MergeSortStageParams msparams;
         msparams.pattern = BSON("foo" << 1);
-        MergeSortStage* ms = new MergeSortStage(&_opCtx, msparams, ws.get());
+        auto ms = std::make_unique<MergeSortStage>(&_opCtx, msparams, ws.get());
 
         int numIndices = 20;
         for (int i = 0; i < numIndices; ++i) {
@@ -493,10 +493,10 @@ public:
             BSONObj indexSpec = BSON(index << 1 << "foo" << 1);
             addIndex(indexSpec);
             auto params = makeIndexScanParams(&_opCtx, getIndex(indexSpec, coll));
-            ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+            ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
         }
         unique_ptr<FetchStage> fetchStage =
-            make_unique<FetchStage>(&_opCtx, ws.get(), ms, nullptr, coll);
+            make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ms), nullptr, coll);
 
         auto statusWithPlanExecutor = PlanExecutor::make(
             &_opCtx, std::move(ws), std::move(fetchStage), coll, PlanExecutor::NO_YIELD);
@@ -547,7 +547,7 @@ public:
             BSONObj indexSpec = BSON(index << 1 << "foo" << 1);
             addIndex(indexSpec);
             auto params = makeIndexScanParams(&_opCtx, getIndex(indexSpec, coll));
-            ms->addChild(new IndexScan(&_opCtx, params, &ws, nullptr));
+            ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr));
         }
 
         set<RecordId> recordIds;
@@ -670,8 +670,12 @@ public:
             params.bounds.startKey = BSON("" << 5);
             params.bounds.endKey = BSON("" << 10);
             auto fetchStage = std::make_unique<FetchStage>(
-                &_opCtx, &ws, new IndexScan(&_opCtx, params, &ws, nullptr), nullptr, coll);
-            ms->addChild(fetchStage.release());
+                &_opCtx,
+                &ws,
+                std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr),
+                nullptr,
+                coll);
+            ms->addChild(std::move(fetchStage));
         }
 
         // Second child scans [4, 10].
@@ -680,8 +684,12 @@ public:
             params.bounds.startKey = BSON("" << 4);
             params.bounds.endKey = BSON("" << 10);
             auto fetchStage = std::make_unique<FetchStage>(
-                &_opCtx, &ws, new IndexScan(&_opCtx, params, &ws, nullptr), nullptr, coll);
-            ms->addChild(fetchStage.release());
+                &_opCtx,
+                &ws,
+                std::make_unique<IndexScan>(&_opCtx, params, &ws, nullptr),
+                nullptr,
+                coll);
+            ms->addChild(std::move(fetchStage));
         }
 
         // First doc should be {a: 4}.
@@ -761,18 +769,17 @@ public:
         MergeSortStageParams msparams;
         msparams.pattern = BSON("c" << 1 << "d" << 1);
         msparams.collator = nullptr;
-        MergeSortStage* ms = new MergeSortStage(&_opCtx, msparams, ws.get());
+        auto ms = std::make_unique<MergeSortStage>(&_opCtx, msparams, ws.get());
 
         // a:1
         auto params = makeIndexScanParams(&_opCtx, getIndex(firstIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         // b:1
         params = makeIndexScanParams(&_opCtx, getIndex(secondIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
-        unique_ptr<FetchStage> fetchStage =
-            make_unique<FetchStage>(&_opCtx, ws.get(), ms, nullptr, coll);
+        auto fetchStage = make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ms), nullptr, coll);
         // Must fetch if we want to easily pull out an obj.
         auto statusWithPlanExecutor = PlanExecutor::make(
             &_opCtx, std::move(ws), std::move(fetchStage), coll, PlanExecutor::NO_YIELD);
@@ -829,18 +836,18 @@ public:
         msparams.pattern = BSON("c" << 1 << "d" << 1);
         CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString);
         msparams.collator = &collator;
-        MergeSortStage* ms = new MergeSortStage(&_opCtx, msparams, ws.get());
+        auto ms = std::make_unique<MergeSortStage>(&_opCtx, msparams, ws.get());
 
         // a:1
         auto params = makeIndexScanParams(&_opCtx, getIndex(firstIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         // b:1
         params = makeIndexScanParams(&_opCtx, getIndex(secondIndex, coll));
-        ms->addChild(new IndexScan(&_opCtx, params, ws.get(), nullptr));
+        ms->addChild(std::make_unique<IndexScan>(&_opCtx, params, ws.get(), nullptr));
 
         unique_ptr<FetchStage> fetchStage =
-            make_unique<FetchStage>(&_opCtx, ws.get(), ms, nullptr, coll);
+            make_unique<FetchStage>(&_opCtx, ws.get(), std::move(ms), nullptr, coll);
         // Must fetch if we want to easily pull out an obj.
         auto statusWithPlanExecutor = PlanExecutor::make(
             &_opCtx, std::move(ws), std::move(fetchStage), coll, PlanExecutor::NO_YIELD);
diff --git a/src/mongo/dbtests/query_stage_multiplan.cpp b/src/mongo/dbtests/query_stage_multiplan.cpp
index 20d82757c3e..c08ca0abad0 100644
--- a/src/mongo/dbtests/query_stage_multiplan.cpp
+++ b/src/mongo/dbtests/query_stage_multiplan.cpp
@@ -148,10 +148,8 @@ unique_ptr<PlanStage> getIxScanPlan(OperationContext* opCtx,
     ixparams.bounds.boundInclusion = BoundInclusion::kIncludeBothStartAndEndKeys;
     ixparams.direction = 1;
 
-    IndexScan* ix = new IndexScan(opCtx, ixparams, sharedWs, nullptr);
-    unique_ptr<PlanStage> root(new FetchStage(opCtx, sharedWs, ix, nullptr, coll));
-
-    return root;
+    auto ixscan = std::make_unique<IndexScan>(opCtx, ixparams, sharedWs, nullptr);
+    return std::make_unique<FetchStage>(opCtx, sharedWs, std::move(ixscan), nullptr, coll);
 }
 
 unique_ptr<MatchExpression> makeMatchExpressionFromFilter(OperationContext* opCtx,
@@ -197,8 +195,8 @@ std::unique_ptr<MultiPlanStage> runMultiPlanner(OperationContext* opCtx,
     auto cq = makeCanonicalQuery(opCtx, nss, BSON("foo" << desiredFooValue));
 
     unique_ptr<MultiPlanStage> mps = std::make_unique<MultiPlanStage>(opCtx, coll, cq.get());
-    mps->addPlan(createQuerySolution(), ixScanRoot.release(), sharedWs.get());
-    mps->addPlan(createQuerySolution(), collScanRoot.release(), sharedWs.get());
+    mps->addPlan(createQuerySolution(), std::move(ixScanRoot), sharedWs.get());
+    mps->addPlan(createQuerySolution(), std::move(collScanRoot), sharedWs.get());
 
     // Plan 0 aka the first plan aka the index scan should be the best.
     PlanYieldPolicy yieldPolicy(PlanExecutor::NO_YIELD,
@@ -245,8 +243,8 @@ TEST_F(QueryStageMultiPlanTest, MPSCollectionScanVsHighlySelectiveIXScan) {
 
     unique_ptr<MultiPlanStage> mps =
         std::make_unique<MultiPlanStage>(_opCtx.get(), ctx.getCollection(), cq.get());
-    mps->addPlan(createQuerySolution(), ixScanRoot.release(), sharedWs.get());
-    mps->addPlan(createQuerySolution(), collScanRoot.release(), sharedWs.get());
+    mps->addPlan(createQuerySolution(), std::move(ixScanRoot), sharedWs.get());
+    mps->addPlan(createQuerySolution(), std::move(collScanRoot), sharedWs.get());
 
     // Plan 0 aka the first plan aka the index scan should be the best.
     PlanYieldPolicy yieldPolicy(PlanExecutor::NO_YIELD, _clock);
@@ -403,10 +401,8 @@ TEST_F(QueryStageMultiPlanTest, MPSBackupPlan) {
     unique_ptr<WorkingSet> ws(new WorkingSet());
     // Put each solution from the planner into the MPR.
     for (size_t i = 0; i < solutions.size(); ++i) {
-        PlanStage* root;
-        ASSERT(StageBuilder::build(_opCtx.get(), collection, *cq, *solutions[i], ws.get(), &root));
-        // Takes ownership of 'root'.
-        mps->addPlan(std::move(solutions[i]), root, ws.get());
+        auto root = StageBuilder::build(_opCtx.get(), collection, *cq, *solutions[i], ws.get());
+        mps->addPlan(std::move(solutions[i]), std::move(root), ws.get());
     }
 
     // This sets a backup plan.
@@ -492,8 +488,8 @@ TEST_F(QueryStageMultiPlanTest, MPSExplainAllPlans) {
         std::make_unique<MultiPlanStage>(_opCtx.get(), ctx.getCollection(), cq.get());
 
     // Put each plan into the MultiPlanStage. Takes ownership of 'firstPlan' and 'secondPlan'.
-    mps->addPlan(std::make_unique<QuerySolution>(), firstPlan.release(), ws.get());
-    mps->addPlan(std::make_unique<QuerySolution>(), secondPlan.release(), ws.get());
+    mps->addPlan(std::make_unique<QuerySolution>(), std::move(firstPlan), ws.get());
+    mps->addPlan(std::make_unique<QuerySolution>(), std::move(secondPlan), ws.get());
 
     // Making a PlanExecutor chooses the best plan.
     auto exec = uassertStatusOK(PlanExecutor::make(
@@ -595,8 +591,8 @@ TEST_F(QueryStageMultiPlanTest, ShouldReportErrorIfExceedsTimeLimitDuringPlannin
                                   ctx.getCollection(),
                                   canonicalQuery.get(),
                                   MultiPlanStage::CachingMode::NeverCache);
-    multiPlanStage.addPlan(createQuerySolution(), ixScanRoot.release(), sharedWs.get());
-    multiPlanStage.addPlan(createQuerySolution(), collScanRoot.release(), sharedWs.get());
+    multiPlanStage.addPlan(createQuerySolution(), std::move(ixScanRoot), sharedWs.get());
+    multiPlanStage.addPlan(createQuerySolution(), std::move(collScanRoot), sharedWs.get());
 
     AlwaysTimeOutYieldPolicy alwaysTimeOutPolicy(serviceContext()->getFastClockSource());
     ASSERT_EQ(ErrorCodes::ExceededTimeLimit, multiPlanStage.pickBestPlan(&alwaysTimeOutPolicy));
@@ -635,8 +631,8 @@ TEST_F(QueryStageMultiPlanTest, ShouldReportErrorIfKilledDuringPlanning) {
                                   ctx.getCollection(),
                                   canonicalQuery.get(),
                                   MultiPlanStage::CachingMode::NeverCache);
-    multiPlanStage.addPlan(createQuerySolution(), ixScanRoot.release(), sharedWs.get());
-    multiPlanStage.addPlan(createQuerySolution(), collScanRoot.release(), sharedWs.get());
+    multiPlanStage.addPlan(createQuerySolution(), std::move(ixScanRoot), sharedWs.get());
+    multiPlanStage.addPlan(createQuerySolution(), std::move(collScanRoot), sharedWs.get());
 
     AlwaysPlanKilledYieldPolicy alwaysPlanKilledYieldPolicy(serviceContext()->getFastClockSource());
     ASSERT_EQ(ErrorCodes::QueryPlanKilled,
diff --git a/src/mongo/dbtests/query_stage_sort.cpp b/src/mongo/dbtests/query_stage_sort.cpp
index dcf7687ded7..27561076276 100644
--- a/src/mongo/dbtests/query_stage_sort.cpp
+++ b/src/mongo/dbtests/query_stage_sort.cpp
@@ -121,9 +121,9 @@ public:
         params.limit = limit();
 
         auto keyGenStage = std::make_unique<SortKeyGeneratorStage>(
-            _pExpCtx, queuedDataStage.release(), ws.get(), params.pattern);
+            _pExpCtx, std::move(queuedDataStage), ws.get(), params.pattern);
 
-        auto ss = std::make_unique<SortStage>(&_opCtx, params, ws.get(), keyGenStage.release());
+        auto ss = std::make_unique<SortStage>(&_opCtx, params, ws.get(), std::move(keyGenStage));
 
         // The PlanExecutor will be automatically registered on construction due to the auto
         // yield policy, so it can receive invalidations when we remove documents later.
@@ -159,13 +159,13 @@ public:
         params.limit = limit();
 
         auto keyGenStage = std::make_unique<SortKeyGeneratorStage>(
-            _pExpCtx, queuedDataStage.release(), ws.get(), params.pattern);
+            _pExpCtx, std::move(queuedDataStage), ws.get(), params.pattern);
 
         auto sortStage =
-            std::make_unique<SortStage>(&_opCtx, params, ws.get(), keyGenStage.release());
+            std::make_unique<SortStage>(&_opCtx, params, ws.get(), std::move(keyGenStage));
 
         auto fetchStage =
-            std::make_unique<FetchStage>(&_opCtx, ws.get(), sortStage.release(), nullptr, coll);
+            std::make_unique<FetchStage>(&_opCtx, ws.get(), std::move(sortStage), nullptr, coll);
 
         // Must fetch so we can look at the doc as a BSONObj.
         auto statusWithPlanExecutor = PlanExecutor::make(
@@ -561,13 +561,13 @@ public:
         params.pattern = BSON("b" << -1 << "c" << 1 << "a" << 1);
 
         auto keyGenStage = std::make_unique<SortKeyGeneratorStage>(
-            _pExpCtx, queuedDataStage.release(), ws.get(), params.pattern);
+            _pExpCtx, std::move(queuedDataStage), ws.get(), params.pattern);
 
         auto sortStage =
-            std::make_unique<SortStage>(&_opCtx, params, ws.get(), keyGenStage.release());
+            std::make_unique<SortStage>(&_opCtx, params, ws.get(), std::move(keyGenStage));
 
         auto fetchStage =
-            std::make_unique<FetchStage>(&_opCtx, ws.get(), sortStage.release(), nullptr, coll);
+            std::make_unique<FetchStage>(&_opCtx, ws.get(), std::move(sortStage), nullptr, coll);
 
         // We don't get results back since we're sorting some parallel arrays.
         auto statusWithPlanExecutor = PlanExecutor::make(
diff --git a/src/mongo/dbtests/query_stage_sort_key_generator.cpp b/src/mongo/dbtests/query_stage_sort_key_generator.cpp
index 18185250ff9..51fd476078c 100644
--- a/src/mongo/dbtests/query_stage_sort_key_generator.cpp
+++ b/src/mongo/dbtests/query_stage_sort_key_generator.cpp
@@ -78,7 +78,7 @@ BSONObj extractSortKey(const char* sortSpec, const char* doc, const CollatorInte
 
     BSONObj sortPattern = fromjson(sortSpec);
     SortKeyGeneratorStage sortKeyGen{
-        pExpCtx, mockStage.release(), &workingSet, std::move(sortPattern)};
+        pExpCtx, std::move(mockStage), &workingSet, std::move(sortPattern)};
     return extractKeyFromKeyGenStage(&sortKeyGen, &workingSet);
 }
 
@@ -107,7 +107,7 @@ BSONObj extractSortKeyCovered(const char* sortSpec,
 
     BSONObj sortPattern = fromjson(sortSpec);
     SortKeyGeneratorStage sortKeyGen{
-        pExpCtx, mockStage.release(), &workingSet, std::move(sortPattern)};
+        pExpCtx, std::move(mockStage), &workingSet, std::move(sortPattern)};
     return extractKeyFromKeyGenStage(&sortKeyGen, &workingSet);
 }