Reduce the number of scanner calls in large cross-products of targets and sources.

1 files changed, 26 insertions, 0 deletions

diff --git a/src/engine/SCons/Executor.py b/src/engine/SCons/Executor.py
index 1d7a107..c58f82e 100644
--- a/src/engine/SCons/Executor.py
+++ b/src/engine/SCons/Executor.py
@@ -150,6 +150,32 @@ class Executor:
         """
         return 0
 
+    def scan(self, scanner):
+        """Scan this Executor's source files for implicit dependencies
+        and update all of the targets with them.  This essentially
+        short-circuits an N^2 scan of the sources for each individual
+        targets, which is a hell of a lot more efficient.
+        """
+        env = self.get_build_env()
+        select_specific_scanner = lambda t: (t[0], t[1].select(t[0]))
+        remove_null_scanners = lambda t: not t[1] is None
+        add_scanner_path = lambda t, s=self: (t[0], t[1], s.get_build_scanner_path(t[1]))
+        if scanner:
+            initial_scanners = lambda src, s=scanner: (src, s)
+        else:
+            initial_scanners = lambda src, e=env: (src, e.get_scanner(src.scanner_key()))
+        scanner_list = map(initial_scanners, self.sources)
+        scanner_list = filter(remove_null_scanners, scanner_list)
+        scanner_list = map(select_specific_scanner, scanner_list)
+        scanner_list = filter(remove_null_scanners, scanner_list)
+        scanner_path_list = map(add_scanner_path, scanner_list)
+        deps = []
+        for src, scanner, path in scanner_path_list:
+            deps.extend(src.get_implicit_deps(env, scanner, path))
+
+        for tgt in self.targets:
+            tgt.add_to_implicit(deps)
+
 if not SCons.Memoize.has_metaclass:
     _Base = Executor
     class Executor(SCons.Memoize.Memoizer, _Base):