Adds back lookup of 'all' targets

pylib/gyp/generator/analyzer.py

 # Copyright (c) 2014 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.
 
 """
 This script is intended for use as a GYP_GENERATOR. It takes as input (by way of
 the generator flag config_path) the path of a json file that dictates the files
 and targets to search for. The following keys are supported:
 files: list of paths (relative) of the files to search for.
 targets: list of targets to search for. The target names are unqualified.
@@ skipping 256 matching lines @@
     if _ToLocalPath(toplevel_dir, rel_include_file) in files:
       if debug:
         print 'included gyp file modified, gyp_file=', build_file, \
             'included file=', rel_include_file
       return True
   return False
 
 
 def _GetOrCreateTargetByName(targets, target_name):
   """Creates or returns the Target at targets[target_name]. If there is no
-  Target for |target_name| one is created."""
+  Target for |target_name| one is created. Returns a tuple of whether a new
+  Target was created and the Target."""
   if target_name in targets:
-    return targets[target_name]
+    return False, targets[target_name]
   target = Target(target_name)
   targets[target_name] = target
-  return target
+  return True, target
 
 
 def _DoesTargetTypeRequireBuild(target_dict):
   """Returns true if the target type is such that it needs to be built."""
   # If a 'none' target has rules or actions we assume it requires a build.
   return bool(target_dict['type'] != 'none' or
               target_dict.get('actions') or target_dict.get('rules'))
 
 
 def _GenerateTargets(data, target_list, target_dicts, toplevel_dir, files,
                      build_files):
   """Returns a tuple of the following:
   . A dictionary mapping from fully qualified name to Target.
   . A list of the targets that have a source file in |files|.
+  . Set of root Targets reachable from the the files |build_files|. This
+    is the set of targets built by the 'all' target.
   This sets the |match_status| of the targets that contain any of the source
   files in |files| to MATCH_STATUS_MATCHES.
   |toplevel_dir| is the root of the source tree."""
   # Maps from target name to Target.
   targets = {}
 
   # Targets that matched.
   matching_targets = []
 
   # Queue of targets to visit.
   targets_to_visit = target_list[:]
 
   # Maps from build file to a boolean indicating whether the build file is in
   # |files|.
   build_file_in_files = {}
 
+  # Root targets across all files.
+  roots = set()
+
+  # Set of Targets in |build_files|.
+  build_file_targets = set()
+
   while len(targets_to_visit) > 0:
     target_name = targets_to_visit.pop()
-    target = _GetOrCreateTargetByName(targets, target_name)
-    if target.visited:
+    created_target, target = _GetOrCreateTargetByName(targets, target_name)
+    if created_target:
+      roots.add(target)
+    elif target.visited:
       continue
 
     target.visited = True
     target.requires_build = _DoesTargetTypeRequireBuild(
         target_dicts[target_name])
     target_type = target_dicts[target_name]['type']
     target.is_executable = target_type == 'executable'
     target.is_static_library = target_type == 'static_library'
     target.is_or_has_linked_ancestor = (target_type == 'executable' or
                                         target_type == 'shared_library')
 
     build_file = gyp.common.ParseQualifiedTarget(target_name)[0]
     if not build_file in build_file_in_files:
       build_file_in_files[build_file] = \
           _WasBuildFileModified(build_file, data, files, toplevel_dir)
 
+    if build_file in build_files:
+      build_file_targets.add(target)
+
     # If a build file (or any of its included files) is modified we assume all
     # targets in the file are modified.
     if build_file_in_files[build_file]:
       print 'matching target from modified build file', target_name
       target.match_status = MATCH_STATUS_MATCHES
       matching_targets.append(target)
     else:
       sources = _ExtractSources(target_name, target_dicts[target_name],
                                 toplevel_dir)
       for source in sources:
         if _ToGypPath(os.path.normpath(source)) in files:
           print 'target', target_name, 'matches', source
           target.match_status = MATCH_STATUS_MATCHES
           matching_targets.append(target)
           break
 
     # Add dependencies to visit as well as updating back pointers for deps.
     for dep in target_dicts[target_name].get('dependencies', []):
       targets_to_visit.append(dep)
 
-      dep_target = _GetOrCreateTargetByName(targets, dep)
+      created_dep_target, dep_target = _GetOrCreateTargetByName(targets, dep)
+      if not created_dep_target:
+        roots.discard(dep_target)
 
       target.deps.add(dep_target)
       dep_target.back_deps.add(target)
 
-  return targets, matching_targets
+  return targets, matching_targets, roots & build_file_targets
 
 
 def _GetUnqualifiedToTargetMapping(all_targets, to_find):
   """Returns a mapping (dictionary) from unqualified name to Target for all the
   Targets in |to_find|."""
   result = {}
   if not to_find:
     return result
   to_find = set(to_find)
   for target_name in all_targets.keys():
@@ skipping 147 matching lines @@
     toplevel_dir = _ToGypPath(os.path.abspath(params['options'].toplevel_dir))
     if debug:
       print 'toplevel_dir', toplevel_dir
 
     if _WasGypIncludeFileModified(params, config.files):
       result_dict = { 'status': all_changed_string,
                       'targets': list(config.targets) }
       _WriteOutput(params, **result_dict)
       return
 
-    all_targets, matching_targets = _GenerateTargets(
+    all_targets, matching_targets, _ = _GenerateTargets(
       data, target_list, target_dicts, toplevel_dir, frozenset(config.files),
       params['build_files'])
 
     unqualified_mapping = _GetUnqualifiedToTargetMapping(all_targets,
                                                          config.targets)
     invalid_targets = None
     if len(unqualified_mapping) != len(config.targets):
       invalid_targets = _NamesNotIn(config.targets, unqualified_mapping)
 
     if matching_targets:
@@ skipping 18 matching lines @@
     result_dict = { 'targets': build_targets,
                     'status': found_dependency_string if matching_targets else
                               no_dependency_string,
                     'build_targets': build_targets}
     if invalid_targets:
       result_dict['invalid_targets'] = invalid_targets
     _WriteOutput(params, **result_dict)
 
   except Exception as e:
     _WriteOutput(params, error=str(e))