Regain lost performance improvements by using paths instead of targets for scanner calls and re-using Binder objects for identical paths.

6 files changed, 44 insertions, 31 deletions

diff --git a/src/engine/SCons/Scanner/CTests.py b/src/engine/SCons/Scanner/CTests.py
index e3caa5f..4c21fe9 100644
--- a/src/engine/SCons/Scanner/CTests.py
+++ b/src/engine/SCons/Scanner/CTests.py
@@ -188,7 +188,7 @@ class DummyEnvironment(UserDict.UserDict):
             return [self.data[strSubst[1:]]]
         return [[strSubst]]
 
-    def subst_path(self, path, target=None):
+    def subst_path(self, path, target=None, source=None):
         if type(path) != type([]):
             path = [path]
         return map(self.subst, path)
diff --git a/src/engine/SCons/Scanner/FortranTests.py b/src/engine/SCons/Scanner/FortranTests.py
index 75264ac..4c82522 100644
--- a/src/engine/SCons/Scanner/FortranTests.py
+++ b/src/engine/SCons/Scanner/FortranTests.py
@@ -236,7 +236,7 @@ class DummyEnvironment:
             return self[arg[1:]]
         return arg
 
-    def subst_path(self, path, target=None):
+    def subst_path(self, path, target=None, source=None):
         if type(path) != type([]):
             path = [path]
         return map(self.subst, path)
diff --git a/src/engine/SCons/Scanner/IDLTests.py b/src/engine/SCons/Scanner/IDLTests.py
index 31a40ea..db842c3 100644
--- a/src/engine/SCons/Scanner/IDLTests.py
+++ b/src/engine/SCons/Scanner/IDLTests.py
@@ -201,7 +201,7 @@ class DummyEnvironment:
     def subst(self, arg):
         return arg
 
-    def subst_path(self, path, target=None):
+    def subst_path(self, path, target=None, source=None):
         if type(path) != type([]):
             path = [path]
         return map(self.subst, path)
diff --git a/src/engine/SCons/Scanner/ProgTests.py b/src/engine/SCons/Scanner/ProgTests.py
index 7e33866..c31b392 100644
--- a/src/engine/SCons/Scanner/ProgTests.py
+++ b/src/engine/SCons/Scanner/ProgTests.py
@@ -78,7 +78,7 @@ class DummyEnvironment:
             return ''
         return s
 
-    def subst_path(self, path, target=None):
+    def subst_path(self, path, target=None, source=None):
         if type(path) != type([]):
             path = [path]
         return map(self.subst, path)
diff --git a/src/engine/SCons/Scanner/ScannerTests.py b/src/engine/SCons/Scanner/ScannerTests.py
index 493a330..c38dc84 100644
--- a/src/engine/SCons/Scanner/ScannerTests.py
+++ b/src/engine/SCons/Scanner/ScannerTests.py
@@ -42,7 +42,7 @@ class DummyEnvironment(UserDict.UserDict):
         if strSubst[0] == '$':
             return [self.data[strSubst[1:]]]
         return [[strSubst]]
-    def subst_path(self, path, target=None):
+    def subst_path(self, path, target=None, source=None):
         if type(path) != type([]):
             path = [path]
         return map(self.subst, path)
@@ -124,6 +124,25 @@ class BaseTestCase(unittest.TestCase):
         else:
             self.failIf(hasattr(self, "arg"), "an argument was given when it shouldn't have been")
 
+    def test_path(self):
+        """Test the Scanner.Base path() method"""
+        def pf(env, cwd, target, source, argument=None):
+            return "pf: %s %s %s %s %s" % \
+                        (env.VARIABLE, cwd, target[0], source[0], argument)
+
+        env = DummyEnvironment()
+        env.VARIABLE = 'v1'
+        target = DummyNode('target')
+        source = DummyNode('source')
+
+        s = SCons.Scanner.Base(self.func, path_function=pf)
+        p = s.path(env, 'here', [target], [source])
+        assert p == "pf: v1 here target source None", p
+
+        s = SCons.Scanner.Base(self.func, path_function=pf, argument="xyz")
+        p = s.path(env, 'here', [target], [source])
+        assert p == "pf: v1 here target source xyz", p
+
     def test_positional(self):
         """Test the Scanner.Base class using positional arguments"""
         s = SCons.Scanner.Base(self.func, "Pos")
diff --git a/src/engine/SCons/Scanner/__init__.py b/src/engine/SCons/Scanner/__init__.py
index 1322fff..c7cf382 100644
--- a/src/engine/SCons/Scanner/__init__.py
+++ b/src/engine/SCons/Scanner/__init__.py
@@ -54,8 +54,7 @@ def Scanner(function, *args, **kw):
         return apply(Base, (function,) + args, kw)
 
 
-class Binder:
-    __metaclass__ = SCons.Memoize.Memoized_Metaclass
+class _Binder:
     def __init__(self, bindval):
         self._val = bindval
     def __call__(self):
@@ -63,43 +62,39 @@ class Binder:
     def __str__(self):
         return str(self._val)
         #debug: return 'B<%s>'%str(self._val)
-    
+
+BinderDict = {}
+
+def Binder(path):
+    try:
+        return BinderDict[path]
+    except KeyError:
+        b = _Binder(path)
+        BinderDict[path] = b
+        return b
+
+
 class FindPathDirs:
     """A class to bind a specific *PATH variable name and the fs object
     to a function that will return all of the *path directories."""
-    __metaclass__ = SCons.Memoize.Memoized_Metaclass
     def __init__(self, variable, fs):
         self.variable = variable
         self.fs = fs
-    def __call__(self, env, dir, target=None, argument=None):
-        "__cacheable__"
+    def __call__(self, env, dir, target=None, source=None, argument=None):
+        # The goal is that we've made caching this unnecessary
+        # because the caching takes place at higher layers.
         try:
             path = env[self.variable]
         except KeyError:
             return ()
 
-        path = env.subst_path(path, target=target)
+        path = env.subst_path(path, target=target, source=source)
         path_tuple = tuple(self.fs.Rsearchall(path,
                                               must_exist = 0, #kwq!
                                               clazz = SCons.Node.FS.Dir,
                                               cwd = dir))
         return Binder(path_tuple)
 
-if not SCons.Memoize.has_metaclass:
-    _FPD_Base = FindPathDirs
-    class FindPathDirs(SCons.Memoize.Memoizer, _FPD_Base):
-        "Cache-backed version of FindPathDirs"
-        def __init__(self, *args, **kw):
-            apply(_FPD_Base.__init__, (self,)+args, kw)
-            SCons.Memoize.Memoizer.__init__(self)
-    _BinderBase = Binder
-    class Binder(SCons.Memoize.Memoizer, _BinderBase):
-        "Cache-backed version of Binder"
-        def __init__(self, *args, **kw):
-            apply(_BinderBase.__init__, (self,)+args, kw)
-            SCons.Memoize.Memoizer.__init__(self)
-
-
 class Base:
     """
     The base class for dependency scanners.  This implements
@@ -189,14 +184,13 @@ class Base:
         self.scan_check = scan_check
         self.recursive = recursive
 
-    def path(self, env, dir=None, target=None):
-        "__cacheable__"
+    def path(self, env, dir=None, target=None, source=None):
         if not self.path_function:
             return ()
         if not self.argument is _null:
-            return self.path_function(env, dir, target, self.argument)
+            return self.path_function(env, dir, target, source, self.argument)
         else:
-            return self.path_function(env, dir, target)
+            return self.path_function(env, dir, target, source)
 
     def __call__(self, node, env, path = ()):
         """