Makes analyzer output names of all executable target types

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 160 matching lines @@
   match_status: one of the MatchStatus values.
   back_deps: set of Targets that have a dependency on this Target.
   visited: used during iteration to indicate whether we've visited this target.
     This is used for two iterations, once in building the set of Targets and
     again in _GetBuildTargets().
   name: fully qualified name of the target.
   requires_build: True if the target type is such that it needs to be built.
     See _DoesTargetTypeRequireBuild for details.
   added_to_compile_targets: used when determining if the target was added to the
     set of targets that needs to be built.
-  in_roots: true if this target is a descendant of one of the root nodes."""
+  in_roots: true if this target is a descendant of one of the root nodes.
+  is_executable: true if the type of target is executable."""
   def __init__(self, name):
     self.deps = set()
     self.match_status = MATCH_STATUS_TBD
     self.back_deps = set()
     self.name = name
     # TODO(sky): I don't like hanging this off Target. This state is specific
     # to certain functions and should be isolated there.
     self.visited = False
     self.requires_build = False
     self.added_to_compile_targets = False
     self.in_roots = False
+    self.is_executable = False
 
 
 class Config(object):
   """Details what we're looking for
   files: set of files to search for
   targets: see file description for details."""
   def __init__(self):
     self.files = []
     self.targets = set()
 
@@ skipping 92 matching lines @@
     target_name = targets_to_visit.pop()
     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.is_executable = target_dicts[target_name]['type'] == 'executable'
 
     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)
 
     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
@@ skipping 82 matching lines @@
     return
 
   target.visited = True
   target.in_roots = not target.back_deps and target in roots
 
   for back_dep_target in target.back_deps:
     _AddBuildTargets(back_dep_target, roots, False, result)
     target.added_to_compile_targets |= back_dep_target.added_to_compile_targets
     target.in_roots |= back_dep_target.in_roots
 
-  if not target.added_to_compile_targets and target.in_roots and \
-        (add_if_no_ancestor or target.requires_build):
+  # Always add 'executable' targets. Even though they may be built by other
+  # targets that depend upon them it makes detection of what is going to be
+  # built easier.
+  if target.in_roots and \
+        (target.is_executable or
+         (not target.added_to_compile_targets and
+          (add_if_no_ancestor or target.requires_build))):
     result.add(target)
     target.added_to_compile_targets = True
 
 
 def _GetBuildTargets(matching_targets, roots):
   """Returns the set of Targets that require a build.
   matching_targets: targets that changed and need to be built.
   roots: set of root targets in the build files to search from."""
   result = set()
   for target in matching_targets:
@@ skipping 124 matching lines @@
     result_dict = { 'targets': matched_search_targets,
                     'status': found_dependency_string if matching_targets else
                               no_dependency_string,
                     'build_targets': build_targets}
     if warning:
       result_dict['warning'] = warning
     _WriteOutput(params, **result_dict)
 
   except Exception as e:
     _WriteOutput(params, error=str(e))