markTransitive & markExternal return the jobs, unfmt

include/swift/Driver/CoarseGrainedDependencyGraph.h

@@ -158,14 +158,13 @@ protected:
 
   /// See CoarseGrainedDependencyGraph::markTransitive.
 
-  void markTransitive(SmallVectorImpl<const void *> &visited,
-                      const void *node, MarkTracerImpl *tracer = nullptr);
+  std::vector<const void*> markTransitive(const void *node, MarkTracerImpl *tracer = nullptr);
+
   bool markIntransitive(const void *node) {
     assert(Provides.count(node) && "node is not in the graph");
     return Marked.insert(node).second;
   }
-  void markExternal(SmallVectorImpl<const void *> &visited,
-                    StringRef externalDependency);
+  std::vector<const void*> markExternal(StringRef externalDependency);
 
 public:
   void forEachUnmarkedJobDirectlyDependentOnExternalSwiftdeps(
@@ -202,13 +201,14 @@ class CoarseGrainedDependencyGraph : public CoarseGrainedDependencyGraphImpl {
   using Traits = llvm::PointerLikeTypeTraits<T>;
   static_assert(Traits::NumLowBitsAvailable >= 0, "not a pointer-like type");
 
-  static void copyBack(SmallVectorImpl<T> &result,
-                       ArrayRef<const void *> rawNodes) {
-    result.reserve(result.size() + rawNodes.size());
+  static std::vector<T> copyBack(ArrayRef<const void *> rawNodes) {
+    std::vector<T> result;
+    result.reserve(rawNodes.size());
     std::transform(rawNodes.begin(), rawNodes.end(), std::back_inserter(result),
                    [](const void *rawNode) {
       return Traits::getFromVoidPointer(const_cast<void *>(rawNode));
     });
+    return result;
   }
 
 public:
@@ -286,23 +286,20 @@ public:
   ///
   /// The traversal routines use
   /// \p visited to avoid endless recursion.
-  template <unsigned N>
-  void markTransitive(SmallVector<T, N> &visited, T node,
+  std::vector<T> markTransitive(T node,
                       MarkTracer *tracer = nullptr) {
-    SmallVector<const void *, N> rawMarked;
+    std::vector<const void *> rawMarked =
     CoarseGrainedDependencyGraphImpl::markTransitive(
-        rawMarked, Traits::getAsVoidPointer(node), tracer);
+        Traits::getAsVoidPointer(node), tracer);
     // FIXME: How can we avoid this copy?
-    copyBack(visited, rawMarked);
+    return copyBack(rawMarked);
   }
 
-  template <unsigned N>
-  void markExternal(SmallVector<T, N> &visited, StringRef externalDependency) {
-    SmallVector<const void *, N> rawMarked;
-    CoarseGrainedDependencyGraphImpl::markExternal(rawMarked,
-                                                   externalDependency);
+  std::vector<T>
+  markExternal(StringRef externalDependency) {
+    const auto rawMarked = CoarseGrainedDependencyGraphImpl::markExternal(externalDependency);
     // FIXME: How can we avoid this copy?
-    copyBack(visited, rawMarked);
+    return copyBack(rawMarked);
   }
 
   /// Marks \p node without marking any dependencies.

include/swift/Driver/FineGrainedDependencyDriverGraph.h

@@ -304,8 +304,7 @@ public:
   /// 2. Jobs not previously known to need dependencies reexamined after they
   /// are recompiled. Such jobs are added to the \ref cascadingJobs set, and
   /// accessed via \ref isMarked.
-  void markTransitive(
-      SmallVectorImpl<const driver::Job *> &consequentJobsToRecompile,
+  std::vector<const driver::Job*> markTransitive(
       const driver::Job *jobToBeRecompiled, const void *ignored = nullptr);
 
   /// "Mark" this node only.
@@ -316,8 +315,7 @@ public:
 
   std::vector<StringRef> getExternalDependencies() const;
 
-  void markExternal(SmallVectorImpl<const driver::Job *> &uses,
-                    StringRef externalDependency);
+  std::vector<const driver::Job*> markExternal(StringRef externalDependency);
 
   void forEachUnmarkedJobDirectlyDependentOnExternalSwiftdeps(
       StringRef externalDependency, function_ref<void(const driver::Job *)> fn);
@@ -436,8 +434,7 @@ private:
       std::unordered_set<const ModuleDepGraphNode *> &foundDependents,
       const ModuleDepGraphNode *definition);
 
-  void computeUniqueJobsFromNodes(
-      SmallVectorImpl<const driver::Job *> &uniqueJobs,
+  std::vector<const driver::Job*> computeUniqueJobsFromNodes(
       const std::unordered_set<const ModuleDepGraphNode *> &nodes);
 
   /// Record a visit to this node for later dependency printing