diff --git a/src/build/targets.jam b/src/build/targets.jam
index 134e87585..7f01356ca 100644
--- a/src/build/targets.jam
+++ b/src/build/targets.jam
@@ -917,10 +917,11 @@ class basic-target : abstract-target
                 check-for-unused-sources 
                   $(result) : $(source-target-groups) ;
 
-                create-subvariant-dg $(result) : $(property-set) : $(rproperties) ;
+                local s = [ create-subvariant $(result) : $(property-set) 
+                  : $(rproperties) : $(usage-requirements) ] ;
 
                 self.generated.$(property-set) = 
-                  [ compute-usage-requirements $(rproperties) : $(result) ]
+                  [ compute-usage-requirements $(s) ]
                   $(result) ;
 
                 self.name = $(original-name) ;
@@ -936,8 +937,9 @@ class basic-target : abstract-target
     # Given the set of generated targets, and refined build 
     # properties, determines and sets appripriate usage requirements
     # on those targets.
-    rule compute-usage-requirements ( rproperties : created-targets * )
+    rule compute-usage-requirements ( subvariant )
     {
+        local rproperties = [ $(subvariant).build-properties ] ;
         xusage-requirements = [ $(self.usage-requirements).evaluate-conditionals 
           $(rproperties) ] ;                
         
@@ -952,7 +954,8 @@ class basic-target : abstract-target
     }
     
     # Creates a new subvariant-dg instances for 'targets'
-    local rule create-subvariant-dg ( targets * : build-request : rproperties )
+    local rule create-subvariant ( targets * : build-request : rproperties 
+        : usage-requirements )
     {
         for local e in $(targets)                    
         {
@@ -963,12 +966,13 @@ class basic-target : abstract-target
         # is created.
         local all-targets = 
           [ sequence.transform virtual-target.traverse : $(targets) ] ; 
-        local dg = [ new subvariant-dg $(__name__) : $(build-request) 
-          : $(rproperties) : $(all-targets) ] ;
+        local dg = [ new subvariant $(__name__) : $(build-request) 
+          : $(rproperties) : $(usage-requirements) : $(all-targets) ] ;
         for local v in $(all-targets)          
         {
             $(v).dg $(dg) ;            
         }                        
+        return $(dg) ;
     }
     
         
diff --git a/src/build/virtual-target.jam b/src/build/virtual-target.jam
index 4826ee090..971028864 100644
--- a/src/build/virtual-target.jam
+++ b/src/build/virtual-target.jam
@@ -889,23 +889,25 @@ local rule clone-action-template ( action from cloned-from : new-source )
     return $(cloned) ;
 }
 
-class subvariant-dg 
+class subvariant
 {
     import sequence ;    
     
     rule __init__ ( main-target # The instance of main-target class
         : property-set                     # Properties requested for this target
-        : actual-properties                # Actual used properties
-        : virtual-targets * )
+        : build-properties                 # Actually used properties
+        : sources-usage-requirements       # Properties propagated from sources
+        : created-targets * )              # Top-level created targets
     {        
         self.main-target = $(main-target) ;
         self.properties = $(property-set) ;
-        self.actual-properties = $(actual-properties) ;
-        self.virtual-targets = $(virtual-targets) ;
+        self.build-properties = $(build-properties) ;
+        self.sources-usage-requirements = $(sources-usage-requirements) ;
+        self.created-targets = $(created-targets) ;
 
         # Pre-compose the list of other dependency graphs, on which this one
         # depends
-        local deps = [ $(actual-properties).get implicit-dependency ] ;
+        local deps = [ $(build-properties).get implicit-dependency ] ;
         for local d in $(deps)
         {
             self.other-dg += [ $(d:G=).dg ] ;
@@ -919,12 +921,27 @@ class subvariant-dg
     {
         return $(self.main-target) ;
     }
-
-    rule properties ( )
+    
+    rule created-targets ( ) 
+    {
+        return $(self.created-targets) ;
+    }
+    
+    rule requested-properties ( )
     {
         return $(self.properties) ;
     }
     
+    rule build-properties ( )
+    {
+        return $(self.build-properties) ;
+    }
+        
+    rule sources-usage-requirements ( )
+    {
+        return $(self.sources-usage-requirements) ;
+    }
+        
     # Returns a list of properties which contain implicit includes,
     # needed to handle dependencies of generated headers.
     # The name of feature is given by 'feature', this is typically 'include'.
@@ -950,7 +967,7 @@ class subvariant-dg
     rule compute-target-directories ( )
     {        
         local result ;
-        for local t in $(self.virtual-targets)
+        for local t in $(self.created-targets)
         {
             result = [ sequence.merge $(result) : [ $(t).path ] ] ;
         }
diff --git a/src/tools/builtin.jam b/src/tools/builtin.jam
index cc35c277c..4b900659b 100644
--- a/src/tools/builtin.jam
+++ b/src/tools/builtin.jam
@@ -427,9 +427,11 @@ class lib-target-class : basic-target
                 : $(property-set) : $(source-targets) : LIB ] ;        
     }            
     
-    rule compute-usage-requirements ( rproperties : created-targets * )
+    rule compute-usage-requirements ( subvariant )
     {
-        local result = [ basic-target.compute-usage-requirements $(rproperties) ] ;
+        local rproperties = [ $(subvariant).build-properties ] ;
+        local created-targets = [ $(subvariant).created-targets ] ;  
+        local result = [ basic-target.compute-usage-requirements $(subvariant) ] ;
         
         # For lib targets with <search>, add the value of <search> as <library-path>
         # usage requirement.
diff --git a/src/tools/stlport.jam b/src/tools/stlport.jam
index 65d1545bb..084158ed5 100644
--- a/src/tools/stlport.jam
+++ b/src/tools/stlport.jam
@@ -129,7 +129,7 @@ class stlport-target-class : basic-target
         
     }
     
-    rule compute-usage-requirements ( rproperties : targets * )
+    rule compute-usage-requirements ( subvariant )
     {
         local usage-requirements ;
         usage-requirements += 
@@ -138,6 +138,7 @@ class stlport-target-class : basic-target
              <library-path>$(self.libraries)               
                 ;
             
+        local rproperties = [ $(subvariant).build-properties ] ;
         # CONSIDER: should this "if" sequence be replaced with
         # some use of 'property-map' class?
         if [ $(rproperties).get <runtime-debugging> ] = "on"