Add an option to prune unwanted targets

pylib/gyp/input.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
 from compiler.ast import Module
 from compiler.ast import Node
@@ skipping 2544 matching lines @@
   for index in xrange(0, len(the_list)):
     item = the_list[index]
     if isinstance(item, int):
       the_list[index] = str(item)
     elif isinstance(item, dict):
       TurnIntIntoStrInDict(item)
     elif isinstance(item, list):
       TurnIntIntoStrInList(item)
 
 
+def PruneUnwantedTargets(targets, flat_list, dependency_nodes, build_files):
+  """
+  Return only the targets that are deep dependencies of the targets specified
+  in |build_files|.
+  """
+  wanted_targets = {}
+  for target in flat_list:
+    if gyp.common.BuildFile(target) in build_files:
+      wanted_targets[target] = targets[target]
+      for dependency in dependency_nodes[target].DeepDependencies():
+        wanted_targets[dependency] = targets[dependency]
+
+  wanted_flat_list = [t for t in flat_list if t in wanted_targets]
+  return [wanted_targets, wanted_flat_list]
+
+
 def VerifyNoCollidingTargets(targets):
   """Verify that no two targets in the same directory share the same name.
 
   Arguments:
     targets: A list of targets in the form 'path/to/file.gyp:target_name'.
   """
   # Keep a dict going from 'subdirectory:target_name' to 'foo.gyp'.
   used = {}
   for target in targets:
     # Separate out 'path/to/file.gyp, 'target_name' from
     # 'path/to/file.gyp:target_name'.
     path, name = target.rsplit(':', 1)
     # Separate out 'path/to', 'file.gyp' from 'path/to/file.gyp'.
     subdir, gyp = os.path.split(path)
     # Use '.' for the current directory '', so that the error messages make
     # more sense.
     if not subdir:
       subdir = '.'
     # Prepare a key like 'path/to:target_name'.
     key = subdir + ':' + name
     if key in used:
       # Complain if this target is already used.
       raise GypError('Duplicate target name "%s" in directory "%s" used both '
                      'in "%s" and "%s".' % (name, subdir, gyp, used[key]))
     used[key] = gyp
 
 
 def Load(build_files, variables, includes, depth, generator_input_info, check,
-         circular_check, parallel):
+         circular_check, parallel, prune_targets):
   # Set up path_sections and non_configuration_keys with the default data plus
   # the generator-specifc data.
   global path_sections
   path_sections = base_path_sections[:]
   path_sections.extend(generator_input_info['path_sections'])
 
   global non_configuration_keys
   non_configuration_keys = base_non_configuration_keys[:]
   non_configuration_keys.extend(generator_input_info['non_configuration_keys'])
 
   # TODO(mark) handle variants if the generator doesn't want them directly.
   generator_handles_variants = \
       generator_input_info['generator_handles_variants']
 
   global absolute_build_file_paths
   absolute_build_file_paths = \
       generator_input_info['generator_wants_absolute_build_file_paths']
 
   global multiple_toolsets
   multiple_toolsets = generator_input_info[
       'generator_supports_multiple_toolsets']
 
   # A generator can have other lists (in addition to sources) be processed
   # for rules.
   extra_sources_for_rules = generator_input_info['extra_sources_for_rules']
 
+  # Normalize paths everywhere.  This is important because paths will be

[scottmg, 2013/09/26 22:11:07]

Why did this need to move?

+  # used as keys to the data dict and for references between input files.
+  build_files = [os.path.normpath(i) for i in build_files]
+
   # Load build files.  This loads every target-containing build file into
   # the |data| dictionary such that the keys to |data| are build file names,
   # and the values are the entire build file contents after "early" or "pre"
   # processing has been done and includes have been resolved.
   # NOTE: data contains both "target" files (.gyp) and "includes" (.gypi), as
   # well as meta-data (e.g. 'included_files' key). 'target_build_files' keeps
   # track of the keys corresponding to "target" files.
   data = {'target_build_files': set()}
   aux_data = {}
   for build_file in build_files:
-    # Normalize paths everywhere.  This is important because paths will be
-    # used as keys to the data dict and for references between input files.
-    build_file = os.path.normpath(build_file)
     try:
       if parallel:
         LoadTargetBuildFileParallel(build_file, data, aux_data,
                                     variables, includes, depth, check)
       else:
         LoadTargetBuildFile(build_file, data, aux_data,
                             variables, includes, depth, check, True)
     except Exception, e:
       gyp.common.ExceptionAppend(e, 'while trying to load %s' % build_file)
       raise
@@ skipping 28 matching lines @@
   # Make sure every dependency appears at most once.
   RemoveDuplicateDependencies(targets)
 
   if circular_check:
     # Make sure that any targets in a.gyp don't contain dependencies in other
     # .gyp files that further depend on a.gyp.
     VerifyNoGYPFileCircularDependencies(targets)
 
   [dependency_nodes, flat_list] = BuildDependencyList(targets)
 
+  if prune_targets:
+    # Remove, from |targets| and |flat_list|, the targets that are not deep
+    # dependencies of the targets specified in |build_files|.
+    [targets, flat_list] = PruneUnwantedTargets(

[scottmg, 2013/09/26 22:11:07]

[ ] around targets, flat_list is odd here. Just return a tuple from the
function.

+        targets, flat_list, dependency_nodes, build_files)
+
   # Check that no two targets in the same directory have the same name.
   VerifyNoCollidingTargets(flat_list)
 
   # Handle dependent settings of various types.
   for settings_type in ['all_dependent_settings',
                         'direct_dependent_settings',
                         'link_settings']:
     DoDependentSettings(settings_type, flat_list, targets, dependency_nodes)
 
     # Take out the dependent settings now that they've been published to all
@@ skipping 50 matching lines @@
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]