Makes analyzer always output static_libraries that have changed

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 165 matching lines @@
   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.
-  is_executable: true if the type of target is executable."""
+  is_executable: true if the type of target is executable.
+  is_static_library: true if the type of target is static_library.
+  is_or_has_linked_ancestor: true if the target does a link (eg executable), or
+    if there is a target in back_deps that does a link."""
   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
+    self.is_static_library = False
+    self.is_or_has_linked_ancestor = 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 93 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'
+    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
@@ skipping 81 matching lines @@
   if target.visited:
     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
+    target.is_or_has_linked_ancestor |= (
+      back_dep_target.is_or_has_linked_ancestor)
 
   # 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.
+  # And always add static_libraries that have no dependencies on them from
+  # linkables. This is necessary as the other dependencies on them may be
+  # static libraries themselves, which are not compile time dependencies.
   if target.in_roots and \
         (target.is_executable or
          (not target.added_to_compile_targets and
-          (add_if_no_ancestor or target.requires_build))):
+          (add_if_no_ancestor or target.requires_build)) or
+         (target.is_static_library and add_if_no_ancestor and
+          not target.is_or_has_linked_ancestor)):
     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 128 matching lines @@
     result_dict = { 'targets': matched_search_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))