dep 1.0.0 → 1.2.0

package/node_modules/node-gyp/gyp/pylib/gyp/generator/analyzer.py

@@ -1,805 +0,0 @@
-# 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.
-test_targets: unqualified target names to search for. Any target in this list
-that depends upon a file in |files| is output regardless of the type of target
-or chain of dependencies.
-additional_compile_targets: Unqualified targets to search for in addition to
-test_targets. Targets in the combined list that depend upon a file in |files|
-are not necessarily output. For example, if the target is of type none then the
-target is not output (but one of the descendants of the target will be).
-
-The following is output:
-error: only supplied if there is an error.
-compile_targets: minimal set of targets that directly or indirectly (for
-  targets of type none) depend on the files in |files| and is one of the
-  supplied targets or a target that one of the supplied targets depends on.
-  The expectation is this set of targets is passed into a build step. This list
-  always contains the output of test_targets as well.
-test_targets: set of targets from the supplied |test_targets| that either
-  directly or indirectly depend upon a file in |files|. This list if useful
-  if additional processing needs to be done for certain targets after the
-  build, such as running tests.
-status: outputs one of three values: none of the supplied files were found,
-  one of the include files changed so that it should be assumed everything
-  changed (in this case test_targets and compile_targets are not output) or at
-  least one file was found.
-invalid_targets: list of supplied targets that were not found.
-
-Example:
-Consider a graph like the following:
-  A     D
- / \
-B   C
-A depends upon both B and C, A is of type none and B and C are executables.
-D is an executable, has no dependencies and nothing depends on it.
-If |additional_compile_targets| = ["A"], |test_targets| = ["B", "C"] and
-files = ["b.cc", "d.cc"] (B depends upon b.cc and D depends upon d.cc), then
-the following is output:
-|compile_targets| = ["B"] B must built as it depends upon the changed file b.cc
-and the supplied target A depends upon it. A is not output as a build_target
-as it is of type none with no rules and actions.
-|test_targets| = ["B"] B directly depends upon the change file b.cc.
-
-Even though the file d.cc, which D depends upon, has changed D is not output
-as it was not supplied by way of |additional_compile_targets| or |test_targets|.
-
-If the generator flag analyzer_output_path is specified, output is written
-there. Otherwise output is written to stdout.
-
-In Gyp the "all" target is shorthand for the root targets in the files passed
-to gyp. For example, if file "a.gyp" contains targets "a1" and
-"a2", and file "b.gyp" contains targets "b1" and "b2" and "a2" has a dependency
-on "b2" and gyp is supplied "a.gyp" then "all" consists of "a1" and "a2".
-Notice that "b1" and "b2" are not in the "all" target as "b.gyp" was not
-directly supplied to gyp. OTOH if both "a.gyp" and "b.gyp" are supplied to gyp
-then the "all" target includes "b1" and "b2".
-"""
-
-import json
-import os
-import posixpath
-
-import gyp.common
-
-debug = False
-
-found_dependency_string = "Found dependency"
-no_dependency_string = "No dependencies"
-# Status when it should be assumed that everything has changed.
-all_changed_string = "Found dependency (all)"
-
-# MatchStatus is used indicate if and how a target depends upon the supplied
-# sources.
-# The target's sources contain one of the supplied paths.
-MATCH_STATUS_MATCHES = 1
-# The target has a dependency on another target that contains one of the
-# supplied paths.
-MATCH_STATUS_MATCHES_BY_DEPENDENCY = 2
-# The target's sources weren't in the supplied paths and none of the target's
-# dependencies depend upon a target that matched.
-MATCH_STATUS_DOESNT_MATCH = 3
-# The target doesn't contain the source, but the dependent targets have not yet
-# been visited to determine a more specific status yet.
-MATCH_STATUS_TBD = 4
-
-generator_supports_multiple_toolsets = gyp.common.CrossCompileRequested()
-
-generator_wants_static_library_dependencies_adjusted = False
-
-generator_default_variables = {}
-for dirname in [
-    "INTERMEDIATE_DIR",
-    "SHARED_INTERMEDIATE_DIR",
-    "PRODUCT_DIR",
-    "LIB_DIR",
-    "SHARED_LIB_DIR",
-]:
-    generator_default_variables[dirname] = "!!!"
-
-for unused in [
-    "RULE_INPUT_PATH",
-    "RULE_INPUT_ROOT",
-    "RULE_INPUT_NAME",
-    "RULE_INPUT_DIRNAME",
-    "RULE_INPUT_EXT",
-    "EXECUTABLE_PREFIX",
-    "EXECUTABLE_SUFFIX",
-    "STATIC_LIB_PREFIX",
-    "STATIC_LIB_SUFFIX",
-    "SHARED_LIB_PREFIX",
-    "SHARED_LIB_SUFFIX",
-    "CONFIGURATION_NAME",
-]:
-    generator_default_variables[unused] = ""
-
-
-def _ToGypPath(path):
-    """Converts a path to the format used by gyp."""
-    if os.sep == "\\" and os.altsep == "/":
-        return path.replace("\\", "/")
-    return path
-
-
-def _ResolveParent(path, base_path_components):
-    """Resolves |path|, which starts with at least one '../'. Returns an empty
-    string if the path shouldn't be considered. See _AddSources() for a
-    description of |base_path_components|."""
-    depth = 0
-    while path.startswith("../"):
-        depth += 1
-        path = path[3:]
-    # Relative includes may go outside the source tree. For example, an action may
-    # have inputs in /usr/include, which are not in the source tree.
-    if depth > len(base_path_components):
-        return ""
-    if depth == len(base_path_components):
-        return path
-    return (
-        "/".join(base_path_components[0 : len(base_path_components) - depth])
-        + "/"
-        + path
-    )
-
-
-def _AddSources(sources, base_path, base_path_components, result):
-    """Extracts valid sources from |sources| and adds them to |result|. Each
-    source file is relative to |base_path|, but may contain '..'. To make
-    resolving '..' easier |base_path_components| contains each of the
-    directories in |base_path|. Additionally each source may contain variables.
-    Such sources are ignored as it is assumed dependencies on them are expressed
-    and tracked in some other means."""
-    # NOTE: gyp paths are always posix style.
-    for source in sources:
-        if not len(source) or source.startswith(("!!!", "$")):
-            continue
-        # variable expansion may lead to //.
-        org_source = source
-        source = source[0] + source[1:].replace("//", "/")
-        if source.startswith("../"):
-            source = _ResolveParent(source, base_path_components)
-            if len(source):
-                result.append(source)
-            continue
-        result.append(base_path + source)
-        if debug:
-            print("AddSource", org_source, result[len(result) - 1])
-
-
-def _ExtractSourcesFromAction(action, base_path, base_path_components, results):
-    if "inputs" in action:
-        _AddSources(action["inputs"], base_path, base_path_components, results)
-
-
-def _ToLocalPath(toplevel_dir, path):
-    """Converts |path| to a path relative to |toplevel_dir|."""
-    if path == toplevel_dir:
-        return ""
-    if path.startswith(toplevel_dir + "/"):
-        return path[len(toplevel_dir) + len("/") :]
-    return path
-
-
-def _ExtractSources(target, target_dict, toplevel_dir):
-    # |target| is either absolute or relative and in the format of the OS. Gyp
-    # source paths are always posix. Convert |target| to a posix path relative to
-    # |toplevel_dir_|. This is done to make it easy to build source paths.
-    base_path = posixpath.dirname(_ToLocalPath(toplevel_dir, _ToGypPath(target)))
-    base_path_components = base_path.split("/")
-
-    # Add a trailing '/' so that _AddSources() can easily build paths.
-    if len(base_path):
-        base_path += "/"
-
-    if debug:
-        print("ExtractSources", target, base_path)
-
-    results = []
-    if "sources" in target_dict:
-        _AddSources(target_dict["sources"], base_path, base_path_components, results)
-    # Include the inputs from any actions. Any changes to these affect the
-    # resulting output.
-    if "actions" in target_dict:
-        for action in target_dict["actions"]:
-            _ExtractSourcesFromAction(action, base_path, base_path_components, results)
-    if "rules" in target_dict:
-        for rule in target_dict["rules"]:
-            _ExtractSourcesFromAction(rule, base_path, base_path_components, results)
-
-    return results
-
-
-class Target:
-    """Holds information about a particular target:
-    deps: set of Targets this Target depends upon. This is not recursive, only the
-      direct dependent Targets.
-    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.
-    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:
-    """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()
-        self.additional_compile_target_names = set()
-        self.test_target_names = set()
-
-    def Init(self, params):
-        """Initializes Config. This is a separate method as it raises an exception
-        if there is a parse error."""
-        generator_flags = params.get("generator_flags", {})
-        config_path = generator_flags.get("config_path", None)
-        if not config_path:
-            return
-        try:
-            f = open(config_path)
-            config = json.load(f)
-            f.close()
-        except OSError:
-            raise Exception("Unable to open file " + config_path)
-        except ValueError as e:
-            raise Exception("Unable to parse config file " + config_path + str(e))
-        if not isinstance(config, dict):
-            raise Exception("config_path must be a JSON file containing a dictionary")
-        self.files = config.get("files", [])
-        self.additional_compile_target_names = set(
-            config.get("additional_compile_targets", [])
-        )
-        self.test_target_names = set(config.get("test_targets", []))
-
-
-def _WasBuildFileModified(build_file, data, files, toplevel_dir):
-    """Returns true if the build file |build_file| is either in |files| or
-    one of the files included by |build_file| is in |files|. |toplevel_dir| is
-    the root of the source tree."""
-    if _ToLocalPath(toplevel_dir, _ToGypPath(build_file)) in files:
-        if debug:
-            print("gyp file modified", build_file)
-        return True
-
-    # First element of included_files is the file itself.
-    if len(data[build_file]["included_files"]) <= 1:
-        return False
-
-    for include_file in data[build_file]["included_files"][1:]:
-        # |included_files| are relative to the directory of the |build_file|.
-        rel_include_file = _ToGypPath(
-            gyp.common.UnrelativePath(include_file, build_file)
-        )
-        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. Returns a tuple of whether a new
-    Target was created and the Target."""
-    if target_name in targets:
-        return False, targets[target_name]
-    target = Target(target_name)
-    targets[target_name] = 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|.
-    . Targets that constitute the 'all' target. See description at top of file
-      for details on 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.
-    name_to_target = {}
-
-    # 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()
-        created_target, target = _GetOrCreateTargetByName(name_to_target, 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 in {
-            "executable",
-            "shared_library",
-        }
-
-        build_file = gyp.common.ParseQualifiedTarget(target_name)[0]
-        if build_file not 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)
-
-            created_dep_target, dep_target = _GetOrCreateTargetByName(
-                name_to_target, dep
-            )
-            if not created_dep_target:
-                roots.discard(dep_target)
-
-            target.deps.add(dep_target)
-            dep_target.back_deps.add(target)
-
-    return name_to_target, matching_targets, roots & build_file_targets
-
-
-def _GetUnqualifiedToTargetMapping(all_targets, to_find):
-    """Returns a tuple of the following:
-    . mapping (dictionary) from unqualified name to Target for all the
-      Targets in |to_find|.
-    . any target names not found. If this is empty all targets were found."""
-    result = {}
-    if not to_find:
-        return {}, []
-    to_find = set(to_find)
-    for target_name in all_targets:
-        extracted = gyp.common.ParseQualifiedTarget(target_name)
-        if len(extracted) > 1 and extracted[1] in to_find:
-            to_find.remove(extracted[1])
-            result[extracted[1]] = all_targets[target_name]
-            if not to_find:
-                return result, []
-    return result, list(to_find)
-
-
-def _DoesTargetDependOnMatchingTargets(target):
-    """Returns true if |target| or any of its dependencies is one of the
-    targets containing the files supplied as input to analyzer. This updates
-    |matches| of the Targets as it recurses.
-    target: the Target to look for."""
-    if target.match_status == MATCH_STATUS_DOESNT_MATCH:
-        return False
-    if target.match_status in {
-        MATCH_STATUS_MATCHES,
-        MATCH_STATUS_MATCHES_BY_DEPENDENCY,
-    }:
-        return True
-    for dep in target.deps:
-        if _DoesTargetDependOnMatchingTargets(dep):
-            target.match_status = MATCH_STATUS_MATCHES_BY_DEPENDENCY
-            print("\t", target.name, "matches by dep", dep.name)
-            return True
-    target.match_status = MATCH_STATUS_DOESNT_MATCH
-    return False
-
-
-def _GetTargetsDependingOnMatchingTargets(possible_targets):
-    """Returns the list of Targets in |possible_targets| that depend (either
-    directly on indirectly) on at least one of the targets containing the files
-    supplied as input to analyzer.
-    possible_targets: targets to search from."""
-    found = []
-    print("Targets that matched by dependency:")
-    for target in possible_targets:
-        if _DoesTargetDependOnMatchingTargets(target):
-            found.append(target)
-    return found
-
-
-def _AddCompileTargets(target, roots, add_if_no_ancestor, result):
-    """Recurses through all targets that depend on |target|, adding all targets
-    that need to be built (and are in |roots|) to |result|.
-    roots: set of root targets.
-    add_if_no_ancestor: If true and there are no ancestors of |target| then add
-    |target| to |result|. |target| must still be in |roots|.
-    result: targets that need to be built are added here."""
-    if target.visited:
-        return
-
-    target.visited = True
-    target.in_roots = target in roots
-
-    for back_dep_target in target.back_deps:
-        _AddCompileTargets(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)
-        )
-        or (
-            target.is_static_library
-            and add_if_no_ancestor
-            and not target.is_or_has_linked_ancestor
-        )
-    ):
-        print(
-            "\t\tadding to compile targets",
-            target.name,
-            "executable",
-            target.is_executable,
-            "added_to_compile_targets",
-            target.added_to_compile_targets,
-            "add_if_no_ancestor",
-            add_if_no_ancestor,
-            "requires_build",
-            target.requires_build,
-            "is_static_library",
-            target.is_static_library,
-            "is_or_has_linked_ancestor",
-            target.is_or_has_linked_ancestor,
-        )
-        result.add(target)
-        target.added_to_compile_targets = True
-
-
-def _GetCompileTargets(matching_targets, supplied_targets):
-    """Returns the set of Targets that require a build.
-    matching_targets: targets that changed and need to be built.
-    supplied_targets: set of targets supplied to analyzer to search from."""
-    result = set()
-    for target in matching_targets:
-        print("finding compile targets for match", target.name)
-        _AddCompileTargets(target, supplied_targets, True, result)
-    return result
-
-
-def _WriteOutput(params, **values):
-    """Writes the output, either to stdout or a file is specified."""
-    if "error" in values:
-        print("Error:", values["error"])
-    if "status" in values:
-        print(values["status"])
-    if "targets" in values:
-        values["targets"].sort()
-        print("Supplied targets that depend on changed files:")
-        for target in values["targets"]:
-            print("\t", target)
-    if "invalid_targets" in values:
-        values["invalid_targets"].sort()
-        print("The following targets were not found:")
-        for target in values["invalid_targets"]:
-            print("\t", target)
-    if "build_targets" in values:
-        values["build_targets"].sort()
-        print("Targets that require a build:")
-        for target in values["build_targets"]:
-            print("\t", target)
-    if "compile_targets" in values:
-        values["compile_targets"].sort()
-        print("Targets that need to be built:")
-        for target in values["compile_targets"]:
-            print("\t", target)
-    if "test_targets" in values:
-        values["test_targets"].sort()
-        print("Test targets:")
-        for target in values["test_targets"]:
-            print("\t", target)
-
-    output_path = params.get("generator_flags", {}).get("analyzer_output_path", None)
-    if not output_path:
-        print(json.dumps(values))
-        return
-    try:
-        f = open(output_path, "w")
-        f.write(json.dumps(values) + "\n")
-        f.close()
-    except OSError as e:
-        print("Error writing to output file", output_path, str(e))
-
-
-def _WasGypIncludeFileModified(params, files):
-    """Returns true if one of the files in |files| is in the set of included
-    files."""
-    if params["options"].includes:
-        for include in params["options"].includes:
-            if _ToGypPath(os.path.normpath(include)) in files:
-                print("Include file modified, assuming all changed", include)
-                return True
-    return False
-
-
-def _NamesNotIn(names, mapping):
-    """Returns a list of the values in |names| that are not in |mapping|."""
-    return [name for name in names if name not in mapping]
-
-
-def _LookupTargets(names, mapping):
-    """Returns a list of the mapping[name] for each value in |names| that is in
-    |mapping|."""
-    return [mapping[name] for name in names if name in mapping]
-
-
-def CalculateVariables(default_variables, params):
-    """Calculate additional variables for use in the build (called by gyp)."""
-    flavor = gyp.common.GetFlavor(params)
-    if flavor == "mac":
-        default_variables.setdefault("OS", "mac")
-    elif flavor == "win":
-        default_variables.setdefault("OS", "win")
-        gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
-    else:
-        operating_system = flavor
-        if flavor == "android":
-            operating_system = "linux"  # Keep this legacy behavior for now.
-        default_variables.setdefault("OS", operating_system)
-
-
-class TargetCalculator:
-    """Calculates the matching test_targets and matching compile_targets."""
-
-    def __init__(
-        self,
-        files,
-        additional_compile_target_names,
-        test_target_names,
-        data,
-        target_list,
-        target_dicts,
-        toplevel_dir,
-        build_files,
-    ):
-        self._additional_compile_target_names = set(additional_compile_target_names)
-        self._test_target_names = set(test_target_names)
-        (
-            self._name_to_target,
-            self._changed_targets,
-            self._root_targets,
-        ) = _GenerateTargets(
-            data, target_list, target_dicts, toplevel_dir, frozenset(files), build_files
-        )
-        (
-            self._unqualified_mapping,
-            self.invalid_targets,
-        ) = _GetUnqualifiedToTargetMapping(
-            self._name_to_target, self._supplied_target_names_no_all()
-        )
-
-    def _supplied_target_names(self):
-        return self._additional_compile_target_names | self._test_target_names
-
-    def _supplied_target_names_no_all(self):
-        """Returns the supplied test targets without 'all'."""
-        result = self._supplied_target_names()
-        result.discard("all")
-        return result
-
-    def is_build_impacted(self):
-        """Returns true if the supplied files impact the build at all."""
-        return self._changed_targets
-
-    def find_matching_test_target_names(self):
-        """Returns the set of output test targets."""
-        assert self.is_build_impacted()
-        # Find the test targets first. 'all' is special cased to mean all the
-        # root targets. To deal with all the supplied |test_targets| are expanded
-        # to include the root targets during lookup. If any of the root targets
-        # match, we remove it and replace it with 'all'.
-        test_target_names_no_all = set(self._test_target_names)
-        test_target_names_no_all.discard("all")
-        test_targets_no_all = _LookupTargets(
-            test_target_names_no_all, self._unqualified_mapping
-        )
-        test_target_names_contains_all = "all" in self._test_target_names
-        if test_target_names_contains_all:
-            test_targets = list(set(test_targets_no_all) | set(self._root_targets))
-        else:
-            test_targets = list(test_targets_no_all)
-        print("supplied test_targets")
-        for target_name in self._test_target_names:
-            print("\t", target_name)
-        print("found test_targets")
-        for target in test_targets:
-            print("\t", target.name)
-        print("searching for matching test targets")
-        matching_test_targets = _GetTargetsDependingOnMatchingTargets(test_targets)
-        matching_test_targets_contains_all = test_target_names_contains_all and set(
-            matching_test_targets
-        ) & set(self._root_targets)
-        if matching_test_targets_contains_all:
-            # Remove any of the targets for all that were not explicitly supplied,
-            # 'all' is subsequently added to the matching names below.
-            matching_test_targets = list(
-                set(matching_test_targets) & set(test_targets_no_all)
-            )
-        print("matched test_targets")
-        for target in matching_test_targets:
-            print("\t", target.name)
-        matching_target_names = [
-            gyp.common.ParseQualifiedTarget(target.name)[1]
-            for target in matching_test_targets
-        ]
-        if matching_test_targets_contains_all:
-            matching_target_names.append("all")
-            print("\tall")
-        return matching_target_names
-
-    def find_matching_compile_target_names(self):
-        """Returns the set of output compile targets."""
-        assert self.is_build_impacted()
-        # Compile targets are found by searching up from changed targets.
-        # Reset the visited status for _GetBuildTargets.
-        for target in self._name_to_target.values():
-            target.visited = False
-
-        supplied_targets = _LookupTargets(
-            self._supplied_target_names_no_all(), self._unqualified_mapping
-        )
-        if "all" in self._supplied_target_names():
-            supplied_targets = list(set(supplied_targets) | set(self._root_targets))
-        print("Supplied test_targets & compile_targets")
-        for target in supplied_targets:
-            print("\t", target.name)
-        print("Finding compile targets")
-        compile_targets = _GetCompileTargets(self._changed_targets, supplied_targets)
-        return [
-            gyp.common.ParseQualifiedTarget(target.name)[1]
-            for target in compile_targets
-        ]
-
-
-def GenerateOutput(target_list, target_dicts, data, params):
-    """Called by gyp as the final stage. Outputs results."""
-    config = Config()
-    try:
-        config.Init(params)
-
-        if not config.files:
-            raise Exception(
-                "Must specify files to analyze via config_path generator flag"
-            )
-
-        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,
-                "test_targets": list(config.test_target_names),
-                "compile_targets": list(
-                    config.additional_compile_target_names | config.test_target_names
-                ),
-            }
-            _WriteOutput(params, **result_dict)
-            return
-
-        calculator = TargetCalculator(
-            config.files,
-            config.additional_compile_target_names,
-            config.test_target_names,
-            data,
-            target_list,
-            target_dicts,
-            toplevel_dir,
-            params["build_files"],
-        )
-        if not calculator.is_build_impacted():
-            result_dict = {
-                "status": no_dependency_string,
-                "test_targets": [],
-                "compile_targets": [],
-            }
-            if calculator.invalid_targets:
-                result_dict["invalid_targets"] = calculator.invalid_targets
-            _WriteOutput(params, **result_dict)
-            return
-
-        test_target_names = calculator.find_matching_test_target_names()
-        compile_target_names = calculator.find_matching_compile_target_names()
-        found_at_least_one_target = compile_target_names or test_target_names
-        result_dict = {
-            "test_targets": test_target_names,
-            "status": found_dependency_string
-            if found_at_least_one_target
-            else no_dependency_string,
-            "compile_targets": list(set(compile_target_names) | set(test_target_names)),
-        }
-        if calculator.invalid_targets:
-            result_dict["invalid_targets"] = calculator.invalid_targets
-        _WriteOutput(params, **result_dict)
-
-    except Exception as e:
-        _WriteOutput(params, error=str(e))