SYMBOL INDEX (3953 symbols across 469 files)

FILE: .github/workflows/generate-release-yml.rs
  type Pattern (line 26) | type Pattern = Box<dyn Fn(&str, &str) -> String + 'static>;
  function parse_pattern (line 28) | fn parse_pattern(pattern: &String) -> Option<(Pattern, Vec<&'static str>...
  function substitute_value (line 45) | fn substitute_value(pattern: &Pattern, value: &Yaml, substitution: &str)...
  function expand_value (line 67) | fn expand_value(value: &Yaml) -> Yaml {
  function main (line 96) | fn main() -> anyhow::Result<()> {

FILE: build/fbcode_builder/CMake/fb_py_test_main.py
  class get_cpu_instr_counter (line 42) | class get_cpu_instr_counter:
    method read (line 43) | def read(self):
  class TestStatus (line 52) | class TestStatus:
  class PathMatcher (line 62) | class PathMatcher:
    method __init__ (line 63) | def __init__(self, include_patterns, omit_patterns):
    method omit (line 67) | def omit(self, path):
    method include (line 78) | def include(self, path):
  class DebugWipeFinder (line 82) | class DebugWipeFinder(PathFinder):
    method __init__ (line 88) | def __init__(self, matcher):
    method find_spec (line 91) | def find_spec(self, fullname, path=None, target=None):
  function optimize_for_coverage (line 128) | def optimize_for_coverage(cov, include_patterns, omit_patterns):
  class TeeStream (line 138) | class TeeStream:
    method __init__ (line 139) | def __init__(self, *streams):
    method write (line 142) | def write(self, data):
    method flush (line 146) | def flush(self):
    method isatty (line 150) | def isatty(self):
  class CallbackStream (line 154) | class CallbackStream:
    method __init__ (line 155) | def __init__(self, callback, bytes_callback=None, orig=None):
    method write (line 170) | def write(self, data):
    method flush (line 173) | def flush(self):
    method isatty (line 176) | def isatty(self):
    method fileno (line 179) | def fileno(self):
  class BuckTestResult (line 183) | class BuckTestResult(unittest.TextTestResult):
    method __init__ (line 191) | def __init__(
    method getResults (line 203) | def getResults(self):
    method startTest (line 206) | def startTest(self, test):
    method _find_next_test (line 227) | def _find_next_test(self, suite):
    method stopTest (line 245) | def stopTest(self, test):
    method stopTestRun (line 282) | def stopTestRun(self):
    method _withTest (line 288) | def _withTest(self, test):
    method _setStatus (line 293) | def _setStatus(self, test, status, message=None, stacktrace=None):
    method setStatus (line 302) | def setStatus(self, test, status, message=None, stacktrace=None):
    method setException (line 314) | def setException(self, test, status, excinfo):
    method addSuccess (line 323) | def addSuccess(self, test):
    method addError (line 327) | def addError(self, test, err):
    method addFailure (line 331) | def addFailure(self, test, err):
    method addSkip (line 335) | def addSkip(self, test, reason):
    method addExpectedFailure (line 339) | def addExpectedFailure(self, test, err):
    method addUnexpectedSuccess (line 343) | def addUnexpectedSuccess(self, test):
    method addStdout (line 347) | def addStdout(self, val):
    method addStdoutBytes (line 353) | def addStdoutBytes(self, val):
    method addStderr (line 357) | def addStderr(self, val):
    method addStderrBytes (line 363) | def addStderrBytes(self, val):
  class BuckTestRunner (line 368) | class BuckTestRunner(unittest.TextTestRunner):
    method __init__ (line 369) | def __init__(self, main_program, suite, show_output=True, **kwargs):
    method _makeResult (line 375) | def _makeResult(self):
  function _format_test_name (line 386) | def _format_test_name(test_class, attrname):
  class StderrLogHandler (line 390) | class StderrLogHandler(logging.StreamHandler):
    method __init__ (line 401) | def __init__(self):
    method stream (line 405) | def stream(self):
  class RegexTestLoader (line 409) | class RegexTestLoader(unittest.TestLoader):
    method __init__ (line 410) | def __init__(self, regex=None):
    method getTestCaseNames (line 414) | def getTestCaseNames(self, testCaseClass):
  class Loader (line 431) | class Loader:
    method __init__ (line 435) | def __init__(self, modules, regex=None):
    method load_all (line 439) | def load_all(self):
    method load_args (line 449) | def load_args(self, args):
  class MainProgram (line 486) | class MainProgram:
    method __init__ (line 495) | def __init__(self, argv):
    method init_option_parser (line 500) | def init_option_parser(self):
    method parse_options (line 580) | def parse_options(self, argv):
    method setup_logging (line 592) | def setup_logging(self):
    method create_loader (line 629) | def create_loader(self):
    method load_tests (line 634) | def load_tests(self):
    method get_tests (line 651) | def get_tests(self, test_suite):
    method run (line 662) | def run(self):
    method run_tests (line 680) | def run_tests(self, test_suite):
    method get_abbr_impl (line 704) | def get_abbr_impl(self):
    method start_coverage (line 718) | def start_coverage(self):
    method get_coverage (line 743) | def get_coverage(self):
    method convert_to_diff_cov_str (line 780) | def convert_to_diff_cov_str(self, analysis):
  function main (line 800) | def main(argv):

FILE: build/fbcode_builder/CMake/fb_py_win_main.c
  function locate_py_main (line 13) | int locate_py_main(int argc, wchar_t** argv) {
  function wmain (line 47) | int wmain() {

FILE: build/fbcode_builder/CMake/make_fbpy_archive.py
  class UsageError (line 19) | class UsageError(Exception):
    method __init__ (line 20) | def __init__(self, message):
    method __str__ (line 23) | def __str__(self):
  class BadManifestError (line 27) | class BadManifestError(UsageError):
    method __init__ (line 28) | def __init__(self, path, line_num, message):
  function parse_manifest (line 41) | def parse_manifest(manifest, path_map):
  function populate_install_tree (line 93) | def populate_install_tree(inst_dir, path_map):
  function build_pex (line 127) | def build_pex(args, path_map):
  function build_zipapp (line 157) | def build_zipapp(args, path_map):
  function create_main_module (line 177) | def create_main_module(args, inst_dir, path_map):
  function build_install_dir (line 198) | def build_install_dir(args, path_map):
  function ensure_directory (line 213) | def ensure_directory(path):
  function install_library (line 221) | def install_library(args, path_map):
  function parse_manifests (line 242) | def parse_manifests(args):
  function check_main_module (line 258) | def check_main_module(args, path_map):
  function main (line 303) | def main():

FILE: build/fbcode_builder/getdeps.py
  class UsageError (line 46) | class UsageError(Exception):
  class ValidateManifest (line 60) | class ValidateManifest(SubCmd):
    method run (line 61) | def run(self, args):
    method setup_parser (line 70) | def setup_parser(self, parser):
  class ShowHostType (line 75) | class ShowHostType(SubCmd):
    method run (line 76) | def run(self, args):
  class ProjectCmdBase (line 82) | class ProjectCmdBase(SubCmd):
    method run (line 83) | def run(self, args):
    method process_project_dir_arguments (line 120) | def process_project_dir_arguments(self, args, loader):
    method setup_parser (line 161) | def setup_parser(self, parser):
    method setup_project_cmd_parser (line 220) | def setup_project_cmd_parser(self, parser):
    method create_builder (line 223) | def create_builder(self, loader, manifest):
    method check_built (line 239) | def check_built(self, loader, manifest):
  class CachedProject (line 246) | class CachedProject:
    method __init__ (line 250) | def __init__(self, cache, loader, m):
    method is_cacheable (line 269) | def is_cacheable(self):
    method was_cached (line 273) | def was_cached(self):
    method download (line 277) | def download(self):
    method upload (line 302) | def upload(self):
  class FetchCmd (line 322) | class FetchCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 323) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 338) | def run_project_cmd(self, args, loader, manifest):
  class InstallSysDepsCmd (line 371) | class InstallSysDepsCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 372) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 409) | def run_project_cmd(self, args, loader, manifest):
  class ListDepsCmd (line 491) | class ListDepsCmd(ProjectCmdBase):
    method run_project_cmd (line 492) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 497) | def setup_project_cmd_parser(self, parser):
  function clean_dirs (line 507) | def clean_dirs(opts):
  class CleanCmd (line 516) | class CleanCmd(SubCmd):
    method run (line 517) | def run(self, args):
  class ShowScratchDirCmd (line 523) | class ShowScratchDirCmd(SubCmd):
    method run (line 524) | def run(self, args):
  class ShowBuildDirCmd (line 530) | class ShowBuildDirCmd(ProjectCmdBase):
    method run_project_cmd (line 531) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 541) | def setup_project_cmd_parser(self, parser):
  class ShowInstDirCmd (line 551) | class ShowInstDirCmd(ProjectCmdBase):
    method run_project_cmd (line 552) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 568) | def setup_project_cmd_parser(self, parser):
  class QueryPathsCmd (line 578) | class QueryPathsCmd(ProjectCmdBase):
    method run_project_cmd (line 579) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 600) | def setup_project_cmd_parser(self, parser):
  class ShowSourceDirCmd (line 610) | class ShowSourceDirCmd(ProjectCmdBase):
    method run_project_cmd (line 611) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 621) | def setup_project_cmd_parser(self, parser):
  class BuildCmd (line 631) | class BuildCmd(ProjectCmdBase):
    method run_project_cmd (line 632) | def run_project_cmd(self, args, loader, manifest):
    method compute_dep_change_status (line 757) | def compute_dep_change_status(self, m, built_marker, loader):
    method compute_source_change_status (line 793) | def compute_source_change_status(
    method setup_project_cmd_parser (line 834) | def setup_project_cmd_parser(self, parser):
  class FixupDeps (line 897) | class FixupDeps(ProjectCmdBase):
    method run_project_cmd (line 898) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 924) | def setup_project_cmd_parser(self, parser):
  class TestCmd (line 938) | class TestCmd(ProjectCmdBase):
    method run_project_cmd (line 939) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 953) | def setup_project_cmd_parser(self, parser):
  class DebugCmd (line 982) | class DebugCmd(ProjectCmdBase):
    method run_project_cmd (line 983) | def run_project_cmd(self, args, loader, manifest):
  class EnvCmd (line 991) | class EnvCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 992) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 1002) | def run_project_cmd(self, args, loader, manifest):
  class GenerateGitHubActionsCmd (line 1009) | class GenerateGitHubActionsCmd(ProjectCmdBase):
    method run_project_cmd (line 1021) | def run_project_cmd(self, args, loader, manifest):
    method get_run_on (line 1033) | def get_run_on(self, args):
    method write_job_for_platform (line 1066) | def write_job_for_platform(self, platform, args):  # noqa: C901
    method setup_project_cmd_parser (line 1415) | def setup_project_cmd_parser(self, parser):
  function get_arg_var_name (line 1486) | def get_arg_var_name(args):
  function parse_args (line 1494) | def parse_args():
  function main (line 1627) | def main():

FILE: build/fbcode_builder/getdeps/builder.py
  class BuilderBase (line 38) | class BuilderBase:
    method __init__ (line 39) | def __init__(
    method _get_cmd_prefix (line 79) | def _get_cmd_prefix(self) -> list[str]:
    method _check_cmd (line 101) | def _check_cmd(self, cmd: list[str], **kwargs: object) -> None:
    method _run_cmd (line 110) | def _run_cmd(
    method _reconfigure (line 143) | def _reconfigure(self, reconfigure: bool) -> bool:
    method _apply_patchfile (line 150) | def _apply_patchfile(self) -> None:
    method prepare (line 185) | def prepare(self, reconfigure: bool) -> None:
    method debug (line 191) | def debug(self, reconfigure: bool) -> None:
    method printenv (line 201) | def printenv(self, reconfigure: bool) -> None:
    method build (line 224) | def build(self, reconfigure: bool) -> None:
    method _job_weight_mib (line 254) | def _job_weight_mib(self) -> int:
    method num_jobs (line 273) | def num_jobs(self) -> int:
    method memory_limit_preexec_fn (line 277) | def memory_limit_preexec_fn(self) -> Callable[[], None] | None:
    method run_tests (line 285) | def run_tests(
    method _prepare (line 299) | def _prepare(self, reconfigure: bool) -> None:
    method _build (line 305) | def _build(self, reconfigure: bool) -> None:
    method _compute_env (line 312) | def _compute_env(self, env: Env | None = None) -> Env:
    method get_dev_run_script_path (line 325) | def get_dev_run_script_path(self) -> str:
    method get_dev_run_extra_path_dirs (line 329) | def get_dev_run_extra_path_dirs(
  class MakeBuilder (line 341) | class MakeBuilder(BuilderBase):
    method __init__ (line 342) | def __init__(
    method _make_binary (line 371) | def _make_binary(self) -> str | None:
    method _get_prefix (line 374) | def _get_prefix(self) -> list[str]:
    method _build (line 377) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 406) | def run_tests(
  class CMakeBootStrapBuilder (line 447) | class CMakeBootStrapBuilder(MakeBuilder):
    method _build (line 448) | def _build(self, reconfigure: bool) -> None:
  class AutoconfBuilder (line 459) | class AutoconfBuilder(BuilderBase):
    method __init__ (line 460) | def __init__(
    method _make_binary (line 493) | def _make_binary(self) -> str | None:
    method _build (line 496) | def _build(self, reconfigure: bool) -> None:
  class Iproute2Builder (line 540) | class Iproute2Builder(BuilderBase):
    method __init__ (line 545) | def __init__(
    method _build (line 567) | def _build(self, reconfigure: bool) -> None:
  class MesonBuilder (line 585) | class MesonBuilder(BuilderBase):
    method __init__ (line 588) | def __init__(
    method _build (line 610) | def _build(self, reconfigure: bool) -> None:
  class CMakeBuilder (line 644) | class CMakeBuilder(BuilderBase):
    method __init__ (line 757) | def __init__(
    method _invalidate_cache (line 801) | def _invalidate_cache(self) -> None:
    method _needs_reconfigure (line 813) | def _needs_reconfigure(self) -> bool:
    method _write_build_script (line 820) | def _write_build_script(self, **kwargs: object) -> None:
    method _compute_cmake_define_args (line 856) | def _compute_cmake_define_args(self, env: Env) -> list[str]:
    method _run_include_rewriter (line 924) | def _run_include_rewriter(self) -> None:
    method _build (line 941) | def _build(self, reconfigure: bool) -> None:
    method _build_targets (line 1005) | def _build_targets(self, targets: Sequence[str]) -> None:
    method _get_missing_test_executables (line 1044) | def _get_missing_test_executables(
    method run_tests (line 1082) | def run_tests(
  class NinjaBootstrap (line 1345) | class NinjaBootstrap(BuilderBase):
    method __init__ (line 1346) | def __init__(
    method _build (line 1368) | def _build(self, reconfigure: bool) -> None:
  class OpenSSLBuilder (line 1381) | class OpenSSLBuilder(BuilderBase):
    method __init__ (line 1382) | def __init__(
    method _build (line 1404) | def _build(self, reconfigure: bool) -> None:
  class Boost (line 1469) | class Boost(BuilderBase):
    method __init__ (line 1470) | def __init__(
    method _build (line 1499) | def _build(self, reconfigure: bool) -> None:
  class NopBuilder (line 1554) | class NopBuilder(BuilderBase):
    method __init__ (line 1555) | def __init__(
    method build (line 1569) | def build(self, reconfigure: bool) -> None:
  class SetupPyBuilder (line 1609) | class SetupPyBuilder(BuilderBase):
    method _build (line 1610) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 1640) | def run_tests(
  class SqliteBuilder (line 1667) | class SqliteBuilder(BuilderBase):
    method __init__ (line 1668) | def __init__(
    method _build (line 1690) | def _build(self, reconfigure: bool) -> None:

FILE: build/fbcode_builder/getdeps/buildopts.py
  function detect_project (line 34) | def detect_project(path: str) -> tuple[str | None, str | None]:
  class BuildOptions (line 53) | class BuildOptions:
    method __init__ (line 54) | def __init__(
    method manifests_dir (line 196) | def manifests_dir(self) -> str:
    method is_darwin (line 199) | def is_darwin(self) -> bool:
    method is_windows (line 202) | def is_windows(self) -> bool:
    method is_arm (line 205) | def is_arm(self) -> bool:
    method get_vcvars_path (line 208) | def get_vcvars_path(self) -> str | None:
    method is_linux (line 211) | def is_linux(self) -> bool:
    method is_freebsd (line 214) | def is_freebsd(self) -> bool:
    method get_num_jobs (line 217) | def get_num_jobs(self, job_weight: int) -> int:
    method get_context_generator (line 228) | def get_context_generator(
    method compute_env_for_install_dirs (line 251) | def compute_env_for_install_dirs(
    method add_homebrew_package_to_env (line 389) | def add_homebrew_package_to_env(self, package: str, env: Env) -> bool:
    method add_prefix_to_env (line 397) | def add_prefix_to_env(
  function list_win32_subst_letters (line 529) | def list_win32_subst_letters() -> dict[str, str]:
  function find_existing_win32_subst_for_path (line 545) | def find_existing_win32_subst_for_path(
  function find_unused_drive_letter (line 556) | def find_unused_drive_letter() -> str | None:
  function map_subst_path (line 580) | def map_subst_path(path: str) -> str:
  function _check_host_type (line 611) | def _check_host_type(args: argparse.Namespace, host_type: HostType | Non...
  function setup_build_options (line 623) | def setup_build_options(

FILE: build/fbcode_builder/getdeps/cache.py
  class ArtifactCache (line 11) | class ArtifactCache:
    method download_to_file (line 17) | def download_to_file(self, name: str, dest_file_name: str) -> bool:
    method upload_from_file (line 28) | def upload_from_file(self, name: str, source_file_name: str) -> None:
  function create_cache (line 38) | def create_cache() -> ArtifactCache | None:

FILE: build/fbcode_builder/getdeps/cargo.py
  class CargoBuilder (line 25) | class CargoBuilder(BuilderBase):
    method __init__ (line 26) | def __init__(
    method run_cargo (line 61) | def run_cargo(
    method build_source_dir (line 80) | def build_source_dir(self) -> str:
    method workspace_dir (line 83) | def workspace_dir(self) -> str:
    method manifest_dir (line 86) | def manifest_dir(self, manifest: str) -> str:
    method recreate_dir (line 89) | def recreate_dir(self, src: str, dst: str) -> None:
    method recreate_linked_dir (line 97) | def recreate_linked_dir(self, src: str, dst: str) -> None:
    method cargo_config_file (line 105) | def cargo_config_file(self) -> str:
    method _create_cargo_config (line 112) | def _create_cargo_config(self) -> dict[str, dict[str, str]]:
    method _prepare (line 178) | def _prepare(self, reconfigure: bool) -> None:
    method _build (line 187) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 223) | def run_tests(
    method _patchup_workspace (line 256) | def _patchup_workspace(self, dep_to_git: dict[str, dict[str, str]]) ->...
    method _resolve_config (line 325) | def _resolve_config(
    method _resolve_dep_to_git (line 360) | def _resolve_dep_to_git(self) -> dict[str, dict[str, str]]:
    method _resolve_dep_to_crates (line 448) | def _resolve_dep_to_crates(
    method _extract_crates_used (line 492) | def _extract_crates_used(
    method _resolve_crate_to_path (line 521) | def _resolve_crate_to_path(

FILE: build/fbcode_builder/getdeps/copytree.py
  function containing_repo_type (line 23) | def containing_repo_type(path: str) -> tuple[str | None, str | None]:
  function find_eden_root (line 36) | def find_eden_root(dirpath: str) -> str | None:
  function prefetch_dir_if_eden (line 55) | def prefetch_dir_if_eden(dirpath: str) -> None:
  function simple_copytree (line 73) | def simple_copytree(src_dir: str, dest_dir: str, symlinks: bool = False)...
  function _remove_readonly_and_try_again (line 106) | def _remove_readonly_and_try_again(
  function rmtree_more (line 134) | def rmtree_more(path: str) -> None:

FILE: build/fbcode_builder/getdeps/dyndeps.py
  function copyfile (line 29) | def copyfile(src: str, dest: str) -> None:
  class DepBase (line 34) | class DepBase:
    method __init__ (line 35) | def __init__(
    method list_dynamic_deps (line 53) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method interesting_dep (line 56) | def interesting_dep(self, d: str) -> bool:
    method process_deps (line 64) | def process_deps(
    method find_all_dependencies (line 97) | def find_all_dependencies(self, build_dir: str) -> list[str]:
    method munge_in_place (line 114) | def munge_in_place(self, objfile: str, final_lib_dir: str) -> None:
    method rewrite_dep (line 142) | def rewrite_dep(
    method resolve_loader_path (line 152) | def resolve_loader_path(self, dep: str) -> str | None:
    method list_objs_in_dir (line 163) | def list_objs_in_dir(
    method is_objfile (line 180) | def is_objfile(self, objfile: str) -> bool:
    method strip_debug_info (line 183) | def strip_debug_info(self, objfile: str) -> None:
    method check_call_verbose (line 188) | def check_call_verbose(self, args: list[str]) -> None:
  class WinDeps (line 193) | class WinDeps(DepBase):
    method __init__ (line 194) | def __init__(
    method find_dumpbin (line 204) | def find_dumpbin(self) -> str:
    method list_dynamic_deps (line 239) | def list_dynamic_deps(self, exe: str) -> list[str]:
    method rewrite_dep (line 254) | def rewrite_dep(
    method interesting_dep (line 282) | def interesting_dep(self, d: str) -> bool:
    method is_objfile (line 289) | def is_objfile(self, objfile: str) -> bool:
    method emit_dev_run_script (line 296) | def emit_dev_run_script(self, script_path: str, dep_dirs: list[str]) -...
    method compute_dependency_paths (line 312) | def compute_dependency_paths(self, build_dir: str) -> list[str]:
    method compute_dependency_paths_fast (line 328) | def compute_dependency_paths_fast(self, build_dir: str) -> list[str]:
    method read_custom_dep_dirs (line 344) | def read_custom_dep_dirs(self, build_dir: str) -> set[str]:
    method _get_dev_run_script_contents (line 364) | def _get_dev_run_script_contents(self, path_dirs: list[str]) -> str:
  class ElfDeps (line 382) | class ElfDeps(DepBase):
    method __init__ (line 383) | def __init__(
    method list_dynamic_deps (line 409) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method rewrite_dep (line 420) | def rewrite_dep(
    method is_objfile (line 436) | def is_objfile(self, objfile: str) -> bool:
    method strip_debug_info (line 444) | def strip_debug_info(self, objfile: str) -> None:
  class MachDeps (line 452) | class MachDeps(DepBase):
    method interesting_dep (line 453) | def interesting_dep(self, d: str) -> bool:
    method is_objfile (line 458) | def is_objfile(self, objfile: str) -> bool:
    method list_dynamic_deps (line 470) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method rewrite_dep (line 489) | def rewrite_dep(
  function create_dyn_dep_munger (line 514) | def create_dyn_dep_munger(

FILE: build/fbcode_builder/getdeps/envfuncs.py
  class Env (line 16) | class Env:
    method __init__ (line 17) | def __init__(self, src: Mapping[str, str] | None = None) -> None:
    method update (line 24) | def update(self, src: Mapping[str, str]) -> None:
    method copy (line 28) | def copy(self) -> Env:
    method _key (line 31) | def _key(self, key: str) -> str | None:
    method get (line 60) | def get(self, key: str, defval: str | None = None) -> str | None:
    method __getitem__ (line 66) | def __getitem__(self, key: str) -> str:
    method unset (line 72) | def unset(self, key: str) -> None:
    method __delitem__ (line 80) | def __delitem__(self, key: str) -> None:
    method __repr__ (line 83) | def __repr__(self) -> str:
    method set (line 86) | def set(self, key: str, value: str) -> None:
    method __setitem__ (line 107) | def __setitem__(self, key: str, value: str) -> None:
    method __iter__ (line 110) | def __iter__(self) -> Iterator[str]:
    method __len__ (line 113) | def __len__(self) -> int:
    method keys (line 116) | def keys(self) -> KeysView[str]:
    method values (line 119) | def values(self) -> ValuesView[str]:
    method items (line 122) | def items(self) -> ItemsView[str, str]:
  function add_path_entry (line 126) | def add_path_entry(
  function add_flag (line 145) | def add_flag(env: Env, name: str, flag: str, append: bool = True) -> None:
  function tpx_path (line 162) | def tpx_path() -> str:
  function path_search (line 166) | def path_search(
  function _perform_path_search (line 191) | def _perform_path_search(path: str, exename: str) -> str | None:

FILE: build/fbcode_builder/getdeps/errors.py
  class TransientFailure (line 9) | class TransientFailure(Exception):
  class ManifestNotFound (line 17) | class ManifestNotFound(Exception):
    method __init__ (line 18) | def __init__(self, manifest_name: str) -> None:

FILE: build/fbcode_builder/getdeps/expr.py
  function parse_expr (line 15) | def parse_expr(expr_text: str, valid_variables: set[str]) -> ExprNode:
  class ExprNode (line 44) | class ExprNode:
    method eval (line 45) | def eval(self, ctx: dict[str, str | None]) -> bool:
  class TrueExpr (line 49) | class TrueExpr(ExprNode):
    method eval (line 50) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 53) | def __str__(self) -> str:
  class NotExpr (line 57) | class NotExpr(ExprNode):
    method __init__ (line 58) | def __init__(self, node: ExprNode) -> None:
    method eval (line 61) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 64) | def __str__(self) -> str:
  class AllExpr (line 68) | class AllExpr(ExprNode):
    method __init__ (line 69) | def __init__(self, nodes: list[ExprNode]) -> None:
    method eval (line 72) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 78) | def __str__(self) -> str:
  class AnyExpr (line 85) | class AnyExpr(ExprNode):
    method __init__ (line 86) | def __init__(self, nodes: list[ExprNode]) -> None:
    method eval (line 89) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 95) | def __str__(self) -> str:
  class EqualExpr (line 102) | class EqualExpr(ExprNode):
    method __init__ (line 103) | def __init__(self, key: str, value: str) -> None:
    method eval (line 107) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 110) | def __str__(self) -> str:
  class Parser (line 114) | class Parser:
    method __init__ (line 115) | def __init__(self, text: str, valid_variables: set[str]) -> None:
    method parse (line 120) | def parse(self) -> ExprNode:
    method top (line 129) | def top(self) -> ExprNode:
    method ident (line 158) | def ident(self) -> str:
    method parse_not (line 164) | def parse_not(self) -> NotExpr:
    method parse_any (line 172) | def parse_any(self) -> AnyExpr:
    method parse_all (line 183) | def parse_all(self) -> AllExpr:

FILE: build/fbcode_builder/getdeps/fetcher.py
  function file_name_is_cmake_file (line 42) | def file_name_is_cmake_file(file_name: str) -> bool:
  class ChangeStatus (line 52) | class ChangeStatus:
    method __init__ (line 65) | def __init__(self, all_changed: bool = False) -> None:
    method record_change (line 76) | def record_change(self, file_name: str) -> None:
    method sources_changed (line 96) | def sources_changed(self) -> bool:
    method build_changed (line 103) | def build_changed(self) -> bool:
  class Fetcher (line 111) | class Fetcher(ABC):
    method update (line 117) | def update(self) -> ChangeStatus:
    method clean (line 126) | def clean(self) -> None:
    method hash (line 132) | def hash(self) -> str:
    method get_src_dir (line 146) | def get_src_dir(self) -> str:
  class LocalDirFetcher (line 152) | class LocalDirFetcher:
    method __init__ (line 159) | def __init__(self, path: str) -> None:
    method update (line 162) | def update(self) -> ChangeStatus:
    method hash (line 165) | def hash(self) -> str:
    method get_src_dir (line 168) | def get_src_dir(self) -> str:
    method clean (line 171) | def clean(self) -> None:
  class SystemPackageFetcher (line 175) | class SystemPackageFetcher:
    method __init__ (line 176) | def __init__(
    method packages_are_installed (line 188) | def packages_are_installed(self) -> bool:
    method update (line 224) | def update(self) -> ChangeStatus:
    method hash (line 228) | def hash(self) -> str:
    method get_src_dir (line 234) | def get_src_dir(self) -> None:
  class PreinstalledNopFetcher (line 238) | class PreinstalledNopFetcher(SystemPackageFetcher):
    method __init__ (line 239) | def __init__(self) -> None:
  class GitFetcher (line 243) | class GitFetcher(Fetcher):
    method __init__ (line 246) | def __init__(
    method _update (line 291) | def _update(self) -> ChangeStatus:
    method update (line 320) | def update(self) -> ChangeStatus:
    method _clone (line 326) | def _clone(self) -> None:
    method clean (line 347) | def clean(self) -> None:
    method hash (line 351) | def hash(self) -> str:
    method get_src_dir (line 354) | def get_src_dir(self) -> str:
  function does_file_need_update (line 358) | def does_file_need_update(
  function copy_if_different (line 392) | def copy_if_different(src_name: str, dest_name: str) -> bool:
  function filter_strip_marker (line 417) | def filter_strip_marker(dest_name: str, marker: str) -> None:
  function list_files_under_dir_newer_than_timestamp (line 442) | def list_files_under_dir_newer_than_timestamp(
  class ShipitPathMap (line 453) | class ShipitPathMap:
    method __init__ (line 454) | def __init__(self) -> None:
    method add_mapping (line 460) | def add_mapping(self, fbsource_dir: str, target_dir: str) -> None:
    method add_exclusion (line 468) | def add_exclusion(self, pattern: str) -> None:
    method _minimize_roots (line 472) | def _minimize_roots(self) -> None:
    method _sort_mapping (line 490) | def _sort_mapping(self) -> None:
    method _map_name (line 493) | def _map_name(self, norm_name: str, dest_root: str) -> str | None:
    method mirror (line 520) | def mirror(self, fbsource_root: str, dest_root: str) -> ChangeStatus:
  class FbsourceRepoData (line 594) | class FbsourceRepoData(NamedTuple):
  function get_fbsource_repo_data (line 602) | def get_fbsource_repo_data(build_options: BuildOptions) -> FbsourceRepoD...
  function is_public_commit (line 636) | def is_public_commit(build_options: BuildOptions) -> bool:  # noqa: C901
  class SimpleShipitTransformerFetcher (line 727) | class SimpleShipitTransformerFetcher(Fetcher):
    method __init__ (line 728) | def __init__(
    method clean (line 741) | def clean(self) -> None:
    method update (line 745) | def update(self) -> ChangeStatus:
    method hash (line 765) | def hash(self) -> str:
    method get_src_dir (line 771) | def get_src_dir(self) -> str:
  class SubFetcher (line 775) | class SubFetcher(Fetcher):
    method __init__ (line 778) | def __init__(self, base: Fetcher, subs: list[tuple[Fetcher, str]]) -> ...
    method update (line 782) | def update(self) -> ChangeStatus:
    method clean (line 794) | def clean(self) -> None:
    method hash (line 799) | def hash(self) -> str:
    method get_src_dir (line 805) | def get_src_dir(self) -> str:
  class ShipitTransformerFetcher (line 809) | class ShipitTransformerFetcher(Fetcher):
    method _shipit_paths (line 811) | def _shipit_paths(cls, build_options: BuildOptions) -> list[str]:
    method __init__ (line 824) | def __init__(
    method update (line 839) | def update(self) -> ChangeStatus:
    method clean (line 845) | def clean(self) -> None:
    method available (line 850) | def available(cls, build_options: BuildOptions) -> bool:
    method run_shipit (line 856) | def run_shipit(self) -> None:
    method hash (line 900) | def hash(self) -> str:
    method get_src_dir (line 904) | def get_src_dir(self) -> str:
  function download_url_to_file_with_progress (line 908) | def download_url_to_file_with_progress(url: str, file_name: str) -> None:
  class ArchiveFetcher (line 1011) | class ArchiveFetcher(Fetcher):
    method __init__ (line 1012) | def __init__(
    method _verify_hash (line 1034) | def _verify_hash(self) -> None:
    method _download_dir (line 1049) | def _download_dir(self) -> str:
    method _download (line 1056) | def _download(self) -> None:
    method clean (line 1074) | def clean(self) -> None:
    method update (line 1078) | def update(self) -> ChangeStatus:
    method hash (line 1148) | def hash(self) -> str:
    method get_src_dir (line 1151) | def get_src_dir(self) -> str:
  function homebrew_package_prefix (line 1155) | def homebrew_package_prefix(package: str) -> str | None:

FILE: build/fbcode_builder/getdeps/include_rewriter.py
  class IncludePathRewriter (line 27) | class IncludePathRewriter:
    method __init__ (line 43) | def __init__(self, mappings: list[tuple[str, str]], verbose: bool = Fa...
    method rewrite_file (line 65) | def rewrite_file(self, file_path: Path, dry_run: bool = False) -> bool:
    method process_directory (line 128) | def process_directory(self, source_dir: Path, dry_run: bool = False) -...
  function rewrite_includes_from_manifest (line 175) | def rewrite_includes_from_manifest(

FILE: build/fbcode_builder/getdeps/load.py
  class Loader (line 26) | class Loader:
    method _list_manifests (line 29) | def _list_manifests(self, build_opts: BuildOptions) -> Iterator[str]:
    method _load_manifest (line 39) | def _load_manifest(self, path: str) -> ManifestParser:
    method load_project (line 42) | def load_project(
    method load_all (line 55) | def load_all(self, build_opts: BuildOptions) -> dict[str, ManifestPars...
  class ResourceLoader (line 69) | class ResourceLoader(Loader):
    method __init__ (line 70) | def __init__(self, namespace: str, manifests_dir: str) -> None:
    method _list_manifests (line 74) | def _list_manifests(self, build_opts: BuildOptions) -> Iterator[str]:
    method _find_manifest (line 89) | def _find_manifest(self, project_name: str) -> str:
    method _load_manifest (line 97) | def _load_manifest(self, path: str) -> ManifestParser:
    method load_project (line 103) | def load_project(
  function patch_loader (line 114) | def patch_loader(namespace: str, manifests_dir: str = "manifests") -> None:
  function load_project (line 119) | def load_project(build_opts: BuildOptions, project_name: str) -> Manifes...
  function load_all_manifests (line 125) | def load_all_manifests(build_opts: BuildOptions) -> dict[str, ManifestPa...
  class ManifestLoader (line 129) | class ManifestLoader:
    method __init__ (line 137) | def __init__(
    method load_manifest (line 155) | def load_manifest(self, name: str) -> ManifestParser:
    method load_all_manifests (line 162) | def load_all_manifests(self) -> dict[str, ManifestParser]:
    method dependencies_of (line 177) | def dependencies_of(self, manifest: ManifestParser) -> list[ManifestPa...
    method manifests_in_dependency_order (line 185) | def manifests_in_dependency_order(
    method set_project_src_dir (line 263) | def set_project_src_dir(self, project_name: str, path: str) -> None:
    method set_project_build_dir (line 266) | def set_project_build_dir(self, project_name: str, path: str) -> None:
    method set_project_install_dir (line 269) | def set_project_install_dir(self, project_name: str, path: str) -> None:
    method set_project_install_prefix (line 272) | def set_project_install_prefix(self, project_name: str, path: str) -> ...
    method create_fetcher (line 275) | def create_fetcher(
    method get_project_hash (line 285) | def get_project_hash(self, manifest: ManifestParser) -> str:
    method _compute_project_hash (line 292) | def _compute_project_hash(self, manifest: ManifestParser) -> str:
    method _get_project_dir_name (line 368) | def _get_project_dir_name(self, manifest: ManifestParser) -> str:
    method get_project_install_dir (line 375) | def get_project_install_dir(self, manifest: ManifestParser) -> str:
    method get_project_build_dir (line 383) | def get_project_build_dir(self, manifest: ManifestParser) -> str:
    method get_project_install_prefix (line 391) | def get_project_install_prefix(self, manifest: ManifestParser) -> str ...
    method get_project_install_dir_respecting_install_prefix (line 394) | def get_project_install_dir_respecting_install_prefix(

FILE: build/fbcode_builder/getdeps/manifest.py
  function parse_conditional_section_name (line 166) | def parse_conditional_section_name(name: str, section_def: str) -> ExprN...
  function validate_allowed_fields (line 171) | def validate_allowed_fields(
  function validate_allow_values (line 192) | def validate_allow_values(
  function validate_section (line 208) | def validate_section(
  class ManifestParser (line 243) | class ManifestParser:
    method __init__ (line 244) | def __init__(self, file_name: str, fp: str | typing.IO[str] | None = N...
    method get (line 299) | def get(
    method get_dependencies (line 327) | def get_dependencies(self, ctx: ManifestContext) -> list[str]:
    method get_section_as_args (line 345) | def get_section_as_args(
    method get_section_as_ordered_pairs (line 377) | def get_section_as_ordered_pairs(
    method get_section_as_dict (line 403) | def get_section_as_dict(
    method update_hash (line 425) | def update_hash(self, hasher: hashlib._Hash, ctx: ManifestContext) -> ...
    method is_first_party_project (line 451) | def is_first_party_project(self) -> bool:
    method get_required_system_packages (line 455) | def get_required_system_packages(
    method _is_satisfied_by_preinstalled_environment (line 466) | def _is_satisfied_by_preinstalled_environment(self, ctx: ManifestConte...
    method get_repo_url (line 483) | def get_repo_url(self, ctx: ManifestContext) -> str | None:
    method _create_fetcher (line 486) | def _create_fetcher(
    method create_fetcher (line 574) | def create_fetcher(
    method get_builder_name (line 594) | def get_builder_name(self, ctx: ManifestContext) -> str:
    method create_builder (line 600) | def create_builder(  # noqa:C901
    method create_prepare_builders (line 817) | def create_prepare_builders(
    method create_cargo_builder (line 844) | def create_cargo_builder(
  class ManifestContext (line 876) | class ManifestContext:
    method __init__ (line 893) | def __init__(self, ctx_dict: dict[str, str | None]) -> None:
    method get (line 897) | def get(self, key: str) -> str | None:
    method set (line 900) | def set(self, key: str, value: str | None) -> None:
    method copy (line 904) | def copy(self) -> ManifestContext:
    method __str__ (line 907) | def __str__(self) -> str:
  class ContextGenerator (line 914) | class ContextGenerator:
    method __init__ (line 920) | def __init__(self, default_ctx: dict[str, str | None]) -> None:
    method set_value_for_project (line 924) | def set_value_for_project(
    method set_value_for_all_projects (line 933) | def set_value_for_all_projects(self, key: str, value: str | None) -> N...
    method get_context (line 938) | def get_context(self, project_name: str) -> ManifestContext:

FILE: build/fbcode_builder/getdeps/platform.py
  function is_windows (line 16) | def is_windows() -> bool:
  function get_linux_type (line 22) | def get_linux_type() -> tuple[str | None, str | None, str | None]:
  function _get_available_ram_linux (line 59) | def _get_available_ram_linux() -> int:
  function _get_available_ram_macos (line 90) | def _get_available_ram_macos() -> int:
  function _get_available_ram_windows (line 117) | def _get_available_ram_windows() -> int:
  function _get_available_ram_freebsd (line 148) | def _get_available_ram_freebsd() -> int:
  function get_available_ram (line 174) | def get_available_ram() -> int:
  function is_current_host_arm (line 192) | def is_current_host_arm() -> bool:
  class HostType (line 201) | class HostType:
    method __init__ (line 202) | def __init__(
    method is_windows (line 242) | def is_windows(self) -> bool:
    method is_arm (line 252) | def is_arm(self) -> bool:
    method is_darwin (line 255) | def is_darwin(self) -> bool:
    method is_linux (line 258) | def is_linux(self) -> bool:
    method is_freebsd (line 261) | def is_freebsd(self) -> bool:
    method as_tuple_string (line 264) | def as_tuple_string(self) -> str:
    method get_package_manager (line 271) | def get_package_manager(self) -> str | None:
    method from_tuple_string (line 287) | def from_tuple_string(s: str) -> HostType:
    method __eq__ (line 291) | def __eq__(self, b: object) -> bool:

FILE: build/fbcode_builder/getdeps/py_wheel_builder.py
  class PythonWheelBuilder (line 99) | class PythonWheelBuilder(BuilderBase):
    method _build (line 109) | def _build(self, reconfigure: bool) -> None:
    method _run_cmake_build (line 178) | def _run_cmake_build(self, reconfigure: bool) -> None:
    method _write_cmakelists (line 195) | def _write_cmakelists(
    method _write_cmake_config_template (line 222) | def _write_cmake_config_template(self) -> None:
    method _add_sources (line 229) | def _add_sources(
    method _parse_wheel_name (line 244) | def _parse_wheel_name(self) -> WheelNameInfo:
    method _read_wheel_metadata (line 281) | def _read_wheel_metadata(self, wheel_name: WheelNameInfo) -> email.mes...
  function _to_cmake_path (line 287) | def _to_cmake_path(path: str) -> str:

FILE: build/fbcode_builder/getdeps/runcmd.py
  class RunCommandError (line 21) | class RunCommandError(Exception):
  function make_memory_limit_preexec_fn (line 25) | def make_memory_limit_preexec_fn(
  function _print_env_diff (line 72) | def _print_env_diff(env: Env, log_fn: Callable[[str], None]) -> None:
  function check_cmd (line 94) | def check_cmd(
  function run_cmd (line 107) | def run_cmd(
  function _run_cmd (line 145) | def _run_cmd(
  function _pipe_output (line 218) | def _pipe_output(p: subprocess.Popen[bytes], log_fn: Callable[[str], Non...
  function _pipe_output (line 244) | def _pipe_output(p: subprocess.Popen[bytes], log_fn: Callable[[str], Non...

FILE: build/fbcode_builder/getdeps/subcmd.py
  class SubCmd (line 14) | class SubCmd:
    method run (line 18) | def run(self, args: argparse.Namespace) -> int:
    method setup_parser (line 22) | def setup_parser(self, parser: argparse.ArgumentParser) -> None:
  function add_subcommands (line 31) | def add_subcommands(
  function cmd (line 49) | def cmd(

FILE: build/fbcode_builder/getdeps/test/expr_test.py
  class ExprTest (line 14) | class ExprTest(unittest.TestCase):
    method test_equal (line 15) | def test_equal(self) -> None:
    method test_not_equal (line 22) | def test_not_equal(self) -> None:
    method test_bad_not (line 28) | def test_bad_not(self) -> None:
    method test_bad_variable (line 33) | def test_bad_variable(self) -> None:
    method test_all (line 38) | def test_all(self) -> None:
    method test_any (line 45) | def test_any(self) -> None:

FILE: build/fbcode_builder/getdeps/test/manifest_test.py
  class ManifestTest (line 16) | class ManifestTest(unittest.TestCase):
    method test_missing_section (line 17) | def test_missing_section(self) -> None:
    method test_missing_name (line 23) | def test_missing_name(self) -> None:
    method test_minimal (line 35) | def test_minimal(self) -> None:
    method test_minimal_with_fbsource_path (line 46) | def test_minimal_with_fbsource_path(self) -> None:
    method test_unknown_field (line 58) | def test_unknown_field(self) -> None:
    method test_invalid_section_name (line 75) | def test_invalid_section_name(self) -> None:
    method test_value_in_dependencies_section (line 90) | def test_value_in_dependencies_section(self) -> None:
    method test_invalid_conditional_section_name (line 110) | def test_invalid_conditional_section_name(self) -> None:
    method test_section_as_args (line 129) | def test_section_as_args(self) -> None:
    method test_section_as_dict (line 169) | def test_section_as_dict(self) -> None:
    method test_parse_common_manifests (line 207) | def test_parse_common_manifests(self) -> None:
    method test_mismatch_name (line 213) | def test_mismatch_name(self) -> None:
    method test_duplicate_manifest (line 226) | def test_duplicate_manifest(self) -> None:
    method assertRaisesRegex (line 235) | def assertRaisesRegex(self, *args, **kwargs):

FILE: build/fbcode_builder/getdeps/test/platform_test.py
  class PlatformTest (line 14) | class PlatformTest(unittest.TestCase):
    method test_create (line 15) | def test_create(self) -> None:
    method test_rendering_of_none (line 23) | def test_rendering_of_none(self) -> None:
    method test_is_methods (line 27) | def test_is_methods(self) -> None:

FILE: build/fbcode_builder/getdeps/test/retry_test.py
  class RetryTest (line 18) | class RetryTest(unittest.TestCase):
    method _get_build_opts (line 19) | def _get_build_opts(self) -> BuildOptions:
    method _get_manifest (line 24) | def _get_manifest(self) -> ManifestParser:
    method _get_archive_fetcher (line 29) | def _get_archive_fetcher(self) -> ArchiveFetcher:
    method test_no_retries (line 41) | def test_no_retries(
    method test_retries (line 77) | def test_retries(
    method test_all_retries (line 124) | def test_all_retries(

FILE: build/fbcode_builder/getdeps/test/scratch_test.py
  class Win32SubstTest (line 14) | class Win32SubstTest(unittest.TestCase):
    method test_no_existing_subst (line 15) | def test_no_existing_subst(self) -> None:
    method test_exact_match_returns_drive_path (line 29) | def test_exact_match_returns_drive_path(self) -> None:
    method test_multiple_exact_matches_returns_arbitrary_drive_path (line 45) | def test_multiple_exact_matches_returns_arbitrary_drive_path(self) -> ...
    method test_drive_letter_is_case_insensitive (line 58) | def test_drive_letter_is_case_insensitive(self) -> None:
    method test_path_components_are_case_insensitive (line 67) | def test_path_components_are_case_insensitive(self) -> None:

FILE: build/fbcode_builder/getdeps/test/strip_marker_test.py
  class ManifestStripMarkerTest (line 17) | class ManifestStripMarkerTest(unittest.TestCase):
    method test_default_strip_marker (line 18) | def test_default_strip_marker(self) -> None:
    method test_custom_strip_marker (line 28) | def test_custom_strip_marker(self) -> None:
  class FilterStripMarkerTest (line 40) | class FilterStripMarkerTest(unittest.TestCase):
    method _write_temp (line 41) | def _write_temp(self, content: str) -> str:
    method _read (line 48) | def _read(self, path: str) -> str:
    method test_single_line_removal (line 52) | def test_single_line_removal(self) -> None:
    method test_block_removal (line 60) | def test_block_removal(self) -> None:
    method test_no_marker_present_no_change (line 76) | def test_no_marker_present_no_change(self) -> None:
    method test_custom_marker_single_line (line 85) | def test_custom_marker_single_line(self) -> None:
    method test_custom_marker_block (line 94) | def test_custom_marker_block(self) -> None:
    method test_custom_marker_ignores_default (line 109) | def test_custom_marker_ignores_default(self) -> None:
    method test_mixed_single_and_block (line 119) | def test_mixed_single_and_block(self) -> None:
    method test_marker_with_regex_metacharacters (line 136) | def test_marker_with_regex_metacharacters(self) -> None:
    method test_binary_file_skipped (line 147) | def test_binary_file_skipped(self) -> None:

FILE: watchman/ChildProcess.cpp
  type watchman (line 17) | namespace watchman {
    function json_args_to_string_vec (line 268) | static std::vector<std::string_view> json_args_to_string_vec(
    function signo (line 422) | int signo

FILE: watchman/ChildProcess.h
  function namespace (line 21) | namespace watchman {

FILE: watchman/Client.cpp
  type watchman (line 28) | namespace watchman {
    function ClientContext (line 204) | ClientContext Client::getClientInfo() const {
    function ClientDebugStatus (line 285) | ClientDebugStatus UserClient::getDebugStatus() const {
  function w_leave_state (line 515) | void w_leave_state(

FILE: watchman/Client.h
  type Query (line 30) | struct Query
  type QueryResult (line 31) | struct QueryResult
  type ClientContext (line 32) | struct ClientContext
  function ClientContext (line 45) | ClientContext getClientInfo() const;
  type PrivateBadge (line 235) | struct PrivateBadge {}

FILE: watchman/ClientContext.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/Clock.cpp
  type timeval (line 21) | struct timeval
  function QuerySince (line 130) | QuerySince ClockSpec::evaluate(
  function clock_id_string (line 198) | bool clock_id_string(
  function w_string (line 218) | w_string ClockPosition::toClockString() const {
  function json_ref (line 226) | json_ref ClockSpec::toJson() const {

FILE: watchman/Clock.h
  function namespace (line 15) | namespace watchman {
  type ClockPosition (line 60) | struct ClockPosition {
  function ClockTicks (line 62) | ClockTicks ticks{0}
  type Timestamp (line 72) | struct Timestamp {
  type Clock (line 76) | struct Clock {
  type NamedCursor (line 82) | struct NamedCursor {

FILE: watchman/Command.cpp
  type watchman (line 16) | namespace watchman {
    function Command (line 23) | Command Command::parse(const json_ref& pdu) {
    function json_ref (line 46) | json_ref Command::render() const {
    function is_pretty (line 118) | bool is_pretty(Pretty pretty, const FileDescriptor& stdOut) {

FILE: watchman/Command.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/CommandRegistry.cpp
  type watchman (line 14) | namespace watchman {
    type CommandRegistry (line 20) | struct CommandRegistry {
      method CommandRegistry (line 23) | CommandRegistry() {
      method CommandRegistry (line 27) | static CommandRegistry& get() {
    function json_ref (line 46) | json_ref UntypedResponse::toJson() && {
    function CommandDefinition (line 79) | const CommandDefinition* CommandDefinition::lookup(std::string_view na...
    function capability_register (line 106) | void capability_register(std::string_view name) {
    function capability_supported (line 110) | bool capability_supported(std::string_view name) {
    function json_ref (line 116) | json_ref capability_get_list() {

FILE: watchman/CommandRegistry.h
  function namespace (line 20) | namespace watchman {
  function printResultRaw (line 213) | static void printResultRaw(const json_ref& result) {

FILE: watchman/Connect.cpp
  function w_stm_connect (line 15) | ResultErrno<std::unique_ptr<Stream>> w_stm_connect(int timeoutms) {

FILE: watchman/Connect.h
  function namespace (line 13) | namespace watchman {

FILE: watchman/Constants.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/ContentHash.cpp
  type watchman (line 27) | namespace watchman {
    function HashValue (line 58) | HashValue ContentHashCache::computeHashImmediate(const char* fullPath) {
    function HashValue (line 141) | HashValue ContentHashCache::computeHashImmediate(
    function w_string (line 167) | const w_string& ContentHashCache::rootPath() const {
    function CacheStats (line 171) | CacheStats ContentHashCache::stats() const {

FILE: watchman/ContentHash.h
  function namespace (line 14) | namespace watchman {
  function namespace (line 29) | namespace std {
  function namespace (line 38) | namespace watchman {

FILE: watchman/Cookie.h
  function namespace (line 13) | namespace watchman {

FILE: watchman/CookieSync.cpp
  type watchman (line 16) | namespace watchman {

FILE: watchman/CookieSync.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/Errors.cpp
  class error_category (line 28) | class error_category
  class inotify_category (line 56) | class inotify_category

FILE: watchman/Errors.h
  type class (line 26) | enum class
  function class (line 40) | class error_category : public std::error_category {
  function std (line 53) | inline std::error_condition make_error_condition(error_code e) {
  function std (line 59) | inline std::error_code make_error_code(error_code e) {
  type windows_error_code (line 72) | enum windows_error_code : uint32_t {}
  function std (line 77) | inline std::error_condition make_error_condition(windows_error_code e) {
  function std (line 84) | inline std::error_code make_error_code(windows_error_code e) {
  function class (line 91) | class inotify_category : public std::error_category {
  type NoPrefix (line 102) | struct NoPrefix {}
  function throwf (line 118) | [[noreturn]] static void throwf(
  function class (line 135) | class CommandValidationError : public WatchmanError<CommandValidationErr...
  function class (line 144) | class QueryParseError : public WatchmanError<QueryParseError> {
  function class (line 153) | class QueryExecError : public WatchmanError<QueryExecError> {
  function class (line 162) | class RootResolveError : public WatchmanError<RootResolveError> {
  function class (line 171) | class RootNotConnectedError : public WatchmanError<RootNotConnectedError> {
  function namespace (line 180) | namespace std {

FILE: watchman/FlagMap.cpp
  function w_expand_flags (line 12) | void w_expand_flags(

FILE: watchman/FlagMap.h
  type flag_map (line 13) | struct flag_map {
  type flag_map (line 25) | struct flag_map

FILE: watchman/GroupLookup.cpp
  type group (line 22) | struct group
  type group (line 26) | struct group

FILE: watchman/GroupLookup.h
  type group (line 19) | struct group

FILE: watchman/Hash.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/IgnoreSet.cpp
  type watchman (line 16) | namespace watchman {

FILE: watchman/IgnoreSet.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/InMemoryView.cpp
  type watchman (line 30) | namespace watchman {
    function make_path_name (line 37) | inline std::string make_path_name(
    type timespec (line 165) | struct timespec
    type timespec (line 169) | struct timespec
    type timespec (line 173) | struct timespec
    function w_string_piece (line 177) | w_string_piece InMemoryFileResult::baseName() {
    function w_string_piece (line 181) | w_string_piece InMemoryFileResult::dirName() {
    function watchman_dir (line 238) | watchman_dir* ViewDatabase::resolveDir(const w_string& dir_name, bool ...
    function watchman_dir (line 309) | const watchman_dir* ViewDatabase::resolveDir(const w_string& dir_name)...
    function watchman_file (line 355) | watchman_file* ViewDatabase::getOrCreateChildFile(
    type watchman_file (line 419) | struct watchman_file
    function json_ref (line 442) | json_ref InMemoryView::PendingChangeLogEntry::asJsonValue() const {
    function ClockStamp (line 493) | ClockStamp InMemoryView::ageOutFile(
    type watchman_file (line 600) | struct watchman_file
    type watchman_dir (line 704) | struct watchman_dir
    type watchman_dir (line 772) | struct watchman_dir
    type watchman_file (line 894) | struct watchman_file
    function ClockPosition (line 909) | ClockPosition InMemoryView::getMostRecentRootNumberAndTickValue() const {
    function w_string (line 913) | w_string InMemoryView::getCurrentClockString() const {
    function ClockTicks (line 922) | ClockTicks InMemoryView::getLastAgeOutTickValue() const {
    function w_string (line 1152) | const w_string& InMemoryView::getName() const {
    function json_ref (line 1160) | json_ref InMemoryView::getWatcherDebugInfo() const {
    function json_ref (line 1172) | json_ref InMemoryView::getViewDebugInfo() const {
    type watchman_file (line 1207) | struct watchman_file

FILE: watchman/InMemoryView.h
  type watchman_file (line 29) | struct watchman_file
  type GlobTree (line 35) | struct GlobTree
  type InMemoryViewCaches (line 39) | struct InMemoryViewCaches {
  function class (line 81) | class ViewDatabase {
  function ClockPosition (line 155) | ClockPosition getMostRecentRootNumberAndTickValue() const override;
  function ClockRoot (line 383) | const ClockRoot rootNumber_{0}
  function ClockTicks (line 386) | ClockTicks lastAgeOutTick_{0}
  function lastWarmedTick_ (line 428) | uint32_t lastWarmedTick_{0}
  type PendingChangeLogEntry (line 430) | struct PendingChangeLogEntry {

FILE: watchman/LRUCache.h
  function namespace (line 18) | namespace watchman {

FILE: watchman/LogConfig.cpp
  type watchman::logging (line 11) | namespace watchman::logging {

FILE: watchman/LogConfig.h
  function namespace (line 12) | namespace watchman::logging {

FILE: watchman/Logging.cpp
  function write_stderr (line 34) | void write_stderr(const String& str) {
  function write_stderr (line 41) | void write_stderr(const String& str, Strings&&... strings) {
  function log_stack_trace (line 47) | static void log_stack_trace() {
  type watchman (line 60) | namespace watchman {
    type levelMaps (line 63) | struct levelMaps {
      method levelMaps (line 69) | levelMaps()
    function levelMaps (line 85) | levelMaps& getLevelMaps() {
      method levelMaps (line 69) | levelMaps()
    function w_string (line 92) | const w_string& logLevelToLabel(LogLevel level) {
    function LogLevel (line 96) | LogLevel logLabelToLevel(const w_string& label) {
    function Log (line 106) | Log& getLog() {
    type tm (line 112) | struct tm
    type timeval (line 127) | struct timeval
    function LONG (line 229) | LONG WINAPI exception_filter(LPEXCEPTION_POINTERS excep) {

FILE: watchman/Logging.h
  function namespace (line 18) | namespace watchman {

FILE: watchman/MapUtil.h
  function namespace (line 10) | namespace watchman {

FILE: watchman/Options.cpp
  type watchman (line 19) | namespace watchman {
    function print_command_list_for_help (line 211) | void print_command_list_for_help(FILE* where) {
    function usage (line 228) | [[noreturn]] void usage(const OptDesc* opts_2, FILE* where) {
    function w_getopt (line 304) | std::vector<std::string>
    function parseOptions (line 444) | std::vector<std::string> parseOptions(int* argcp, char*** argvp) {

FILE: watchman/Options.h
  function namespace (line 14) | namespace watchman {

FILE: watchman/PDU.cpp
  type watchman (line 17) | namespace watchman {
    function PduType (line 76) | inline PduType PduBuffer::detectPdu() {
    function output_bytes (line 328) | static bool output_bytes(const char* buf, int x) {
    type jbuffer_write_data (line 487) | struct jbuffer_write_data {
      method flush (line 491) | bool flush() {
      method write (line 506) | static int write(const char* buffer, size_t size, void* ptr) {
      method write (line 511) | int write(const char* buffer, size_t size) {

FILE: watchman/PDU.h
  function namespace (line 14) | namespace watchman {

FILE: watchman/PathUtils.cpp
  type watchman (line 30) | namespace watchman {
    function verify_dir_ownership (line 32) | void verify_dir_ownership(const std::string& state_dir) {
    function create_state_dir (line 154) | void create_state_dir(const char* state_dir, std::error_code& ec) {
    function create_log_dir (line 186) | void create_log_dir(const char* log_dir, std::error_code& ec) {
    function compute_file_name (line 211) | void compute_file_name(

FILE: watchman/PathUtils.h
  function namespace (line 13) | namespace watchman {

FILE: watchman/PendingCollection.cpp
  type watchman (line 16) | namespace watchman {
    function is_path_prefix (line 26) | bool is_path_prefix(

FILE: watchman/PendingCollection.h
  type watchman_dir (line 18) | struct watchman_dir
  function namespace (line 20) | namespace watchman {

FILE: watchman/PerfSample.cpp
  type watchman (line 24) | namespace watchman {
    class PerfLogThread (line 26) | class PerfLogThread {
      type State (line 27) | struct State {
        method State (line 28) | explicit State(bool start) : running(start) {}
      method PerfLogThread (line 41) | explicit PerfLogThread(bool start) : state_(std::in_place, start) {
      method stop (line 51) | void stop() {
      method addSample (line 63) | void addSample(json_ref&& sample) {
    function PerfLogThread (line 70) | PerfLogThread& getPerfThread(bool start = true) {
      type State (line 27) | struct State {
        method State (line 28) | explicit State(bool start) : running(start) {}
      method PerfLogThread (line 41) | explicit PerfLogThread(bool start) : state_(std::in_place, start) {
      method stop (line 51) | void stop() {
      method addSample (line 63) | void addSample(json_ref&& sample) {
    function processSamples (line 78) | void processSamples(
    function perf_shutdown (line 357) | void perf_shutdown() {

FILE: watchman/PerfSample.h
  type RootMetadata (line 23) | struct RootMetadata {
  function json_ref (line 45) | json_ref meta_data{json_object()};

FILE: watchman/Poison.cpp
  type watchman (line 12) | namespace watchman {
    function set_poison_state (line 16) | void set_poison_state(

FILE: watchman/Poison.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/ProcessLock.cpp
  type watchman (line 19) | namespace watchman {
    function ProcessLock (line 21) | ProcessLock ProcessLock::acquire(const std::string& pid_file) {

FILE: watchman/ProcessLock.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/ProcessUtil.cpp
  type watchman (line 12) | namespace watchman {
    function ProcessInfoCache (line 17) | ProcessInfoCache& getProcessInfoCache() {
    function ProcessInfoHandle (line 23) | ProcessInfoHandle lookupProcessInfo(pid_t pid) {

FILE: watchman/ProcessUtil.h
  function namespace (line 12) | namespace facebook::eden {
  function namespace (line 16) | namespace watchman {

FILE: watchman/PubSub.cpp
  type watchman (line 12) | namespace watchman {
    function getPending (line 95) | void getPending(
    function json_ref (line 181) | json_ref Publisher::getDebugInfo() const {

FILE: watchman/PubSub.h
  function namespace (line 18) | namespace watchman {

FILE: watchman/QueryableView.cpp
  type watchman (line 12) | namespace watchman {
    function ClockTicks (line 38) | ClockTicks QueryableView::getLastAgeOutTickValue() const {

FILE: watchman/QueryableView.h
  function namespace (line 19) | namespace watchman {

FILE: watchman/Result.h
  function namespace (line 15) | namespace watchman {
  function error_type (line 230) | const error_type& error() const& {

FILE: watchman/RingBuffer.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/SanityCheck.cpp
  type watchman (line 20) | namespace watchman {
    function decodeNext (line 24) | std::optional<json_ref>
    function check_my_sock (line 36) | void check_my_sock(watchman_stream* client) {
    function check_clock_command (line 88) | void check_clock_command(watchman_stream* client, const json_ref& root) {
    function json_ref (line 130) | json_ref get_watch_list(watchman_stream* client) {
    function do_clock_check (line 158) | void do_clock_check(watchman_stream* client) {
    function sanityCheckThread (line 195) | void sanityCheckThread() noexcept {
    function startSanityCheckThread (line 232) | void startSanityCheckThread() {

FILE: watchman/SanityCheck.h
  function namespace (line 10) | namespace watchman {

FILE: watchman/Serde.h
  function namespace (line 43) | namespace detail {
  type Object (line 119) | struct Object {}
  function json_ref (line 144) | static json_ref toJson(const T& v) {
  function T (line 155) | static T fromJson(const json_ref& v) {
  function json_ref (line 173) | struct Serde<json_ref> {
  function bool (line 183) | struct Serde<bool> {
  function json_int_t (line 195) | struct Serde<json_int_t> {
  function w_string (line 207) | struct Serde<w_string> {
  function string (line 219) | struct Serde<std::string> {
  function push (line 266) | static size_t push(
  function write (line 287) | static void write(
  function json_ref (line 309) | static json_ref toJson(const Tuple& tuple) {
  function Tuple (line 322) | static Tuple fromJson(const json_ref& j) {
  function json_ref (line 342) | static json_ref toJson(const std::optional<T>& o) {
  function std (line 346) | static std::optional<T> fromJson(const json_ref& j) {
  function throw (line 469) | throw MissingKey{"key is missing"}

FILE: watchman/Shutdown.cpp
  function w_is_stopping (line 20) | bool w_is_stopping() {
  function w_request_shutdown (line 24) | void w_request_shutdown() {
  function w_push_listener_thread_event (line 32) | void w_push_listener_thread_event(std::shared_ptr<watchman_event> event) {

FILE: watchman/Shutdown.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/SignalHandler.cpp
  function crash_handler (line 21) | static void crash_handler(int signo, siginfo_t* si, void*) {
  function terminationHandler (line 142) | [[noreturn]] void terminationHandler() {
  type watchman (line 160) | namespace watchman {
    function setup_signal_handlers (line 162) | void setup_signal_handlers() {

FILE: watchman/SignalHandler.h
  function namespace (line 10) | namespace watchman {

FILE: watchman/SymlinkTargets.cpp
  type watchman (line 13) | namespace watchman {
    function w_string (line 38) | w_string SymlinkTargetCache::readLinkImmediate(
    function w_string (line 52) | const w_string& SymlinkTargetCache::rootPath() const {
    function CacheStats (line 56) | CacheStats SymlinkTargetCache::stats() const {

FILE: watchman/SymlinkTargets.h
  function namespace (line 16) | namespace watchman {
  function namespace (line 29) | namespace std {
  function namespace (line 38) | namespace watchman {

FILE: watchman/ThreadPool.cpp
  type watchman (line 11) | namespace watchman {
    function ThreadPool (line 13) | ThreadPool& getThreadPool() {

FILE: watchman/ThreadPool.h
  function namespace (line 17) | namespace watchman {

FILE: watchman/TriggerCommand.cpp
  type watchman (line 22) | namespace watchman {
    function parse_redirection (line 26) | void parse_redirection(
    function prepare_stdin (line 66) | ResultErrno<std::unique_ptr<watchman_stream>> prepare_stdin(
    function spawn_command (line 144) | void spawn_command(

FILE: watchman/TriggerCommand.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/UserDir.cpp
  type watchman (line 25) | namespace watchman {
    function getWatchmanAppDataPath (line 43) | std::string getWatchmanAppDataPath() {
    function computeTemporaryDirectory (line 77) | std::string computeTemporaryDirectory() {
    function computeUserName (line 91) | std::string computeUserName() {
    function computeHomeDirectory (line 137) | std::string computeHomeDirectory() {
    function computeXDGStateHomeDirectory (line 177) | std::string computeXDGStateHomeDirectory() {
    function computeWatchmanStateDirectory (line 195) | std::string computeWatchmanStateDirectory(const std::string& user) {

FILE: watchman/UserDir.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/WatchmanConfig.cpp
  type ConfigState (line 21) | struct ConfigState {
  function loadSystemConfig (line 27) | std::optional<std::pair<json_ref, w_string>> loadSystemConfig() {
  function loadUserConfig (line 91) | std::optional<json_ref> loadUserConfig() {
  function cfg_shutdown (line 130) | void cfg_shutdown() {
  function w_string (line 135) | w_string cfg_get_global_config_file_path() {
  function cfg_load_global_config_file (line 139) | void cfg_load_global_config_file() {
  function cfg_set_global (line 159) | void cfg_set_global(const char* name, const json_ref& val) {
  function cfg_get_json (line 168) | std::optional<json_ref> cfg_get_json(const char* name) {
  function is_array_of_strings (line 191) | static bool is_array_of_strings(const json_ref& ref) {
  function prepend_watchmanconfig_to_array (line 205) | static void prepend_watchmanconfig_to_array(std::vector<json_ref>& ref) {
  function cfg_compute_root_files (line 227) | std::optional<json_ref> cfg_compute_root_files(bool* enforcing) {
  function cfg_pretty_print_root_files (line 277) | std::string cfg_pretty_print_root_files(const json_ref& root_files) {
  function json_int_t (line 294) | json_int_t cfg_get_int(const char* name, json_int_t defval) {
  function cfg_get_bool (line 307) | bool cfg_get_bool(const char* name, bool defval) {
  function cfg_get_double (line 320) | double cfg_get_double(const char* name, double defval) {
  function mode_t (line 369) | mode_t cfg_get_perms(const char* name, bool write_bits, bool execute_bit...
  type watchman (line 395) | namespace watchman {
    function json_int_t (line 433) | json_int_t Configuration::getInt(const char* name, json_int_t defval) ...

FILE: watchman/WatchmanConfig.h
  function namespace (line 33) | namespace watchman {

FILE: watchman/XattrUtils.cpp
  type watchman (line 18) | namespace watchman {
    type acl_ea_entry (line 66) | struct acl_ea_entry {
    type acl_ea_header (line 72) | struct acl_ea_header {
    function setSecondaryGroupACL (line 79) | bool setSecondaryGroupACL(

FILE: watchman/XattrUtils.h
  function namespace (line 10) | namespace watchman {

FILE: watchman/benchmarks/bser.cpp
  function predictable_bser_data (line 16) | std::vector<char> predictable_bser_data() {
  function w_string (line 54) | w_string random_string(std::mt19937& mt) {
  function clamped_sub (line 75) | inline unsigned clamped_sub(unsigned x, unsigned y) {
  function json_ref (line 79) | json_ref random_array(std::mt19937& mt, unsigned depth) {
  function json_ref (line 91) | json_ref random_object(std::mt19937& mt, unsigned depth) {
  function json_ref (line 103) | json_ref random_value(std::mt19937& mt, unsigned depth = 0) {
  function unpredictable_bser_data (line 136) | std::vector<char> unpredictable_bser_data() {
  type ParseBenchmark (line 170) | struct ParseBenchmark {
    method run (line 173) | static void run(benchmark::State& state) {
  function bser_parse_predictable (line 187) | void bser_parse_predictable(benchmark::State& state) {
  function bser_parse_unpredictable (line 192) | void bser_parse_unpredictable(benchmark::State& state) {
  function main (line 199) | int main(int argc, char** argv) {

FILE: watchman/benchmarks/string.cpp
  function string_allocate_and_deallocate (line 13) | void string_allocate_and_deallocate(benchmark::State& state) {
  function string_hash (line 22) | void string_hash(benchmark::State& state) {
  function string_piece_hash (line 32) | void string_piece_hash(benchmark::State& state) {
  function main (line 44) | int main(int argc, char** argv) {

FILE: watchman/bser.cpp
  function limitedReservation (line 65) | void limitedReservation(T& container, size_t size) {
  function is_bser_version_supported (line 74) | bool is_bser_version_supported(const bser_ctx_t* ctx) {
  function bser_real (line 78) | int bser_real(const bser_ctx_t* ctx, double val, void* data) {
  function bser_int (line 90) | int bser_int(const bser_ctx_t* ctx, json_int_t val, void* data) {
  function bser_generic_string (line 135) | int bser_generic_string(
  function bser_bytestring (line 159) | int bser_bytestring(const bser_ctx_t* ctx, w_string_piece str, void* dat...
  function bser_utf8string (line 163) | int bser_utf8string(const bser_ctx_t* ctx, w_string_piece str, void* dat...
  function bser_mixedstring (line 171) | int bser_mixedstring(const bser_ctx_t* ctx, w_string_piece str, void* da...
  function bser_template (line 184) | int bser_template(
  function bser_array (line 242) | int bser_array(const bser_ctx_t* ctx, const json_ref& array, void* data) {
  function bser_object (line 270) | int bser_object(const bser_ctx_t* ctx, const json_ref& obj, void* data) {
  function w_bser_dump (line 303) | int w_bser_dump(const bser_ctx_t* ctx, const json_ref& json, void* data) {
  function measure (line 344) | int measure(const char*, size_t size, void* ptr) {
  function w_bser_write_pdu (line 352) | int w_bser_write_pdu(
  class BserParser (line 411) | class BserParser {
    method BserParser (line 413) | BserParser(const char* buf, const char* end)
    method json_ref (line 424) | json_ref expectValue() {
    method json_ref (line 428) | json_ref parseValue(char value_type) {
    method expectType (line 486) | char expectType(std::initializer_list<char> types) {
    method json_int_t (line 511) | json_int_t parseInteger() {
    method json_int_t (line 517) | json_int_t parseInteger(char type) {
    method parseReal (line 532) | double parseReal() {
    method json_int_t (line 543) | json_int_t expectInteger() {
    method expectSize (line 548) | size_t expectSize(const char* label) {
    method parseString (line 561) | std::string_view parseString() {
    method expectString (line 566) | std::string_view expectString() {
    method parseArray (line 571) | std::vector<json_ref> parseArray() {
    method expectArray (line 584) | std::vector<json_ref> expectArray() {
    method json_ref (line 589) | json_ref parseTemplate() {
    method json_ref (line 635) | json_ref parseObject() {
    type BumpDepth (line 660) | struct BumpDepth {
      method BumpDepth (line 661) | explicit BumpDepth(size_t& depth) : depth{depth} {
  function bunser_int (line 681) | std::optional<json_int_t>
  function json_ref (line 731) | json_ref bunser(const char* buf, const char* end) {

FILE: watchman/bser.h
  type bser_ctx_t (line 13) | typedef struct bser_ctx {
  function class (line 19) | class BserParseError : public std::exception {
  function class (line 43) | class BserParseTooDeep : public BserParseError {

FILE: watchman/build/package/substcontrol.py
  function main (line 33) | def main():

FILE: watchman/cli/src/audit.rs
  type AuditCmd (line 30) | pub(crate) struct AuditCmd {
    method to_audit_option (line 455) | fn to_audit_option(&self) -> AuditOption {
    method run (line 464) | pub async fn run(&self) -> anyhow::Result<()> {
  function is_cookie (line 66) | fn is_cookie<T: AsRef<Path>>(name: T) -> bool {
  function from_windows_epoch (line 77) | fn from_windows_epoch(epoch: i64) -> i64 {
  type AuditOption (line 82) | pub struct AuditOption {
  method default (line 90) | fn default() -> Self {
  function audit_repo (line 100) | pub async fn audit_repo(

FILE: watchman/cli/src/main.rs
  type MainCommand (line 17) | struct MainCommand {
  type TopLevelSubcommand (line 23) | enum TopLevelSubcommand {
    method run (line 29) | async fn run(&self) -> anyhow::Result<()> {
  function main (line 39) | async fn main() {

FILE: watchman/cli/src/rage/mod.rs
  type RageExpression (line 39) | struct RageExpression {
    method new (line 45) | fn new(expr: Expression, cmd: &'static str) -> Self {
    method config (line 52) | fn config<T: FnOnce(Expression) -> Expression>(mut self, fun: T) -> Se...
    method read (line 57) | fn read(&self) -> String {
  function getuid (line 72) | fn getuid() -> nix::unistd::Uid {
  type WatchmanRage (line 76) | struct WatchmanRage {
    method new (line 81) | async fn new() -> Self {
    method empty_line (line 88) | fn empty_line(&mut self) -> Result<()> {
    method run (line 93) | async fn run(&mut self) -> Result<()> {
    method print_system_info (line 124) | fn print_system_info(&mut self) -> Result<()> {
    method print_package_version (line 149) | fn print_package_version(&mut self) -> Result<()> {
    method print_package_version (line 159) | fn print_package_version(&mut self) -> Result<()> {
    method print_cli_version (line 168) | fn print_cli_version(&mut self) -> Result<()> {
    method print_watchman_env (line 177) | fn print_watchman_env(&mut self) -> Result<()> {
    method print_inotify (line 197) | fn print_inotify(&mut self) -> Result<()> {
    method print_launchd_info (line 256) | fn print_launchd_info(&mut self) -> Result<()> {
    method print_state_info (line 291) | fn print_state_info(&mut self) -> Result<()> {
    method print_running_watchman (line 373) | fn print_running_watchman(&mut self) -> Result<()> {
    method print_watchman_service_info (line 386) | async fn print_watchman_service_info(&mut self) -> Result<()> {
    method check_watchman_config (line 438) | async fn check_watchman_config(&mut self, client: &Client, root: &Reso...
    method collect_watch_info (line 481) | async fn collect_watch_info(&mut self, client: &Client, repo: &Path) -...
    method wait (line 557) | fn wait(self) {
  type RageCmd (line 563) | pub(crate) struct RageCmd {}
    method run (line 566) | pub(crate) async fn run(&self) -> Result<()> {

FILE: watchman/cli/src/rage/stream.rs
  type FbReporter (line 24) | pub struct FbReporter {}
    method new (line 27) | pub fn new(hostname: Option<String>) -> Result<Self> {
    method wait (line 31) | pub fn wait(mut self) {
  method write (line 37) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 41) | fn flush(&mut self) -> io::Result<()> {
  type Stream (line 50) | pub enum Stream {
    method new_stdout (line 57) | fn new_stdout() -> Self {
    method new (line 61) | pub fn new(hostname: Option<String>) -> Self {
    method is_redirected (line 72) | pub fn is_redirected(&self) -> bool {
    method out (line 80) | fn out(&mut self) -> &mut dyn Write {
    method wait (line 87) | pub fn wait(self) {
  method write (line 96) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 100) | fn flush(&mut self) -> io::Result<()> {

FILE: watchman/cmds/debug.cpp
  type watchman (line 25) | namespace watchman {
    function UntypedResponse (line 28) | static UntypedResponse cmd_debug_recrawl(Client* client, const json_re...
    function UntypedResponse (line 45) | static UntypedResponse cmd_debug_show_cursors(
    function UntypedResponse (line 76) | static UntypedResponse cmd_debug_ageout(Client* client, const json_ref...
    function UntypedResponse (line 94) | static UntypedResponse cmd_debug_poison(Client* client, const json_ref...
    function UntypedResponse (line 113) | static UntypedResponse cmd_debug_drop_privs(Client* client, const json...
    type DebugSetParallelCrawlCommand (line 122) | struct DebugSetParallelCrawlCommand
      type Response (line 129) | struct Response : BaseResponse {
        method map (line 133) | void map(X& x) {
      method Response (line 139) | static Response handle(Client* client, const Request& req) {
        method map (line 133) | void map(X& x) {
    function UntypedResponse (line 152) | static UntypedResponse cmd_debug_set_subscriptions_paused(
    function json_ref (line 193) | static json_ref getDebugSubscriptionInfo(Root* root) {
    function UntypedResponse (line 223) | static UntypedResponse cmd_debug_get_subscriptions(
    function UntypedResponse (line 246) | static UntypedResponse cmd_debug_get_asserted_states(
    function shellQuoteCommand (line 269) | std::string shellQuoteCommand(std::string_view command) {
    type DebugStatusCommand (line 289) | struct DebugStatusCommand : PrettyCommand<DebugStatusCommand> {
      type Response (line 296) | struct Response : BaseResponse {
        method map (line 301) | void map(X& x) {
      method Response (line 308) | static Response handle(Client*, const Request&) {
        method map (line 301) | void map(X& x) {
      method printResult (line 316) | static void printResult(const Response& response) {
    type DebugRootStatusCommand (line 359) | struct DebugRootStatusCommand : TypedCommand<DebugRootStatusCommand> {
      type Response (line 365) | struct Response : BaseResponse {
        method map (line 369) | void map(X& x) {
      method Response (line 375) | static Response handle(Client* client, const Request& req) {
        method map (line 369) | void map(X& x) {
    function UntypedResponse (line 385) | static UntypedResponse cmd_debug_watcher_info(
    function UntypedResponse (line 397) | static UntypedResponse cmd_debug_watcher_info_clear(
    function addCacheStats (line 413) | void addCacheStats(UntypedResponse& resp, const CacheStats& stats) {
    function UntypedResponse (line 426) | UntypedResponse debugContentHashCache(Client* client, const json_ref& ...
    function UntypedResponse (line 450) | UntypedResponse debugSymlinkTargetCache(Client* client, const json_ref...

FILE: watchman/cmds/find.cpp
  function UntypedResponse (line 20) | static UntypedResponse cmd_find(Client* client, const json_ref& args) {

FILE: watchman/cmds/heapprof.cpp
  function UntypedResponse (line 20) | static UntypedResponse cmd_debug_prof_dump(Client*, const json_ref&) {

FILE: watchman/cmds/info.cpp
  class VersionCommand (line 26) | class VersionCommand : public PrettyCommand<VersionCommand> {
    type RequestOptions (line 33) | struct RequestOptions : serde::Object {
      method map (line 38) | void map(X& x) {
    type Response (line 46) | struct Response : BaseResponse {
      method map (line 52) | void map(X& x) {
    method Response (line 60) | static Response handle(Client*, const Request& request) {
      method map (line 52) | void map(X& x) {
    method printResult (line 95) | static void printResult(const Response& response) {
  function UntypedResponse (line 115) | static UntypedResponse cmd_list_capabilities(Client*, const json_ref&) {
  function UntypedResponse (line 127) | static UntypedResponse cmd_get_sockname(Client*, const json_ref&) {
  function UntypedResponse (line 156) | static UntypedResponse cmd_get_config(Client* client, const json_ref& ar...

FILE: watchman/cmds/log.cpp
  function UntypedResponse (line 19) | static UntypedResponse cmd_loglevel(Client* client, const json_ref& args) {
  function UntypedResponse (line 57) | static UntypedResponse cmd_log(Client*, const json_ref& args) {
  function UntypedResponse (line 80) | static UntypedResponse cmd_global_log_level(Client*, const json_ref& arg...
  function UntypedResponse (line 105) | static UntypedResponse cmd_get_log(Client*, const json_ref& args) {

FILE: watchman/cmds/query.cpp
  function UntypedResponse (line 20) | static UntypedResponse cmd_query(Client* client, const json_ref& args) {

FILE: watchman/cmds/since.cpp
  function UntypedResponse (line 20) | static UntypedResponse cmd_since(Client* client, const json_ref& args) {

FILE: watchman/cmds/state.cpp
  type state_arg (line 19) | struct state_arg {
  function parse_state_arg (line 26) | static void parse_state_arg(Client*, const json_ref& args, state_arg* pa...
  type watchman (line 61) | namespace watchman {
    function UntypedResponse (line 63) | static UntypedResponse cmd_state_enter(
  function UntypedResponse (line 152) | static UntypedResponse cmd_state_leave(

FILE: watchman/cmds/subscribe.cpp
  type sub_action (line 61) | enum class sub_action { no_sync_needed, execute, defer, drop }
  function get_subscription_action (line 63) | static std::tuple<sub_action, w_string> get_subscription_action(
  function ClockSpec (line 308) | ClockSpec ClientSubscription::runSubscriptionRules(
  function UntypedResponse (line 323) | static UntypedResponse cmd_flush_subscriptions(
  function UntypedResponse (line 450) | static UntypedResponse cmd_unsubscribe(
  function UntypedResponse (line 480) | static UntypedResponse cmd_subscribe(Client* clientbase, const json_ref&...

FILE: watchman/cmds/trigger.cpp
  function UntypedResponse (line 25) | static UntypedResponse cmd_trigger_delete(
  function UntypedResponse (line 74) | static UntypedResponse cmd_trigger_list(Client* client, const json_ref& ...
  function json_ref (line 85) | static json_ref build_legacy_trigger(
  function UntypedResponse (line 134) | static UntypedResponse cmd_trigger(Client* client, const json_ref& args) {

FILE: watchman/cmds/watch.cpp
  function w_cmd_realpath_root (line 21) | void w_cmd_realpath_root(Command& command) {
  function annotate_with_clock (line 49) | static void annotate_with_clock(
  function UntypedResponse (line 61) | static UntypedResponse cmd_clock(Client* client, const json_ref& args) {
  function UntypedResponse (line 105) | static UntypedResponse cmd_watch_delete(Client* client, const json_ref& ...
  function UntypedResponse (line 123) | static UntypedResponse cmd_watch_del_all(Client*, const json_ref&) {
  function UntypedResponse (line 137) | static UntypedResponse cmd_watch_list(Client*, const json_ref&) {
  function find_file_in_dir_tree (line 154) | static bool find_file_in_dir_tree(
  function find_project_root (line 183) | bool find_project_root(
  function check_no_watchman (line 200) | void check_no_watchman(w_string resolved_root) {
  function w_string (line 217) | static w_string resolve_projpath(
  function UntypedResponse (line 281) | static UntypedResponse cmd_watch(Client* client, const json_ref& args) {
  function UntypedResponse (line 311) | static UntypedResponse cmd_watch_project(Client* client, const json_ref&...

FILE: watchman/cppclient/CLI.cpp
  function main (line 33) | int main(int argc, char** argv) {

FILE: watchman/cppclient/WatchmanClient.cpp
  type watchman (line 15) | namespace watchman {

FILE: watchman/cppclient/WatchmanClient.h
  function namespace (line 80) | namespace watchman {

FILE: watchman/cppclient/WatchmanConnection.cpp
  type watchman (line 25) | namespace watchman {

FILE: watchman/cppclient/WatchmanConnection.h
  function namespace (line 22) | namespace watchman {

FILE: watchman/cppclient/WatchmanResponseError.cpp
  type watchman (line 10) | namespace watchman {

FILE: watchman/fs/DirHandle.h
  function namespace (line 13) | namespace watchman {

FILE: watchman/fs/FSDetect.cpp
  type watchman (line 33) | namespace watchman {
    function CaseSensitivity (line 35) | CaseSensitivity getCaseSensitivityForPath([[maybe_unused]] const char*...
  function find_fstype_in_linux_proc_mounts (line 51) | std::optional<w_string> find_fstype_in_linux_proc_mounts(
  function w_string (line 111) | w_string w_fstype_detect_macos_nfs(w_string fstype, w_string edenfs_indi...
  function w_string (line 125) | w_string w_fstype([[maybe_unused]] const char* path) {

FILE: watchman/fs/FSDetect.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/fs/FileDescriptor.cpp
  type watchman (line 27) | namespace watchman {
    function FileDescriptor (line 71) | FileDescriptor& FileDescriptor::operator=(FileDescriptor&& other) noex...
    function FileInformation (line 177) | FileInformation FileDescriptor::getInfo() const {
    function w_string (line 218) | w_string FileDescriptor::getOpenedPath() const {
    function w_string (line 318) | w_string FileDescriptor::readSymbolicLink() const {
    function FileDescriptor (line 463) | const FileDescriptor& FileDescriptor::stdIn() {
    function FileDescriptor (line 475) | const FileDescriptor& FileDescriptor::stdOut() {
    function FileDescriptor (line 487) | const FileDescriptor& FileDescriptor::stdErr() {
    function ULONG (line 501) | ULONG FileDescriptor::getReparseTag() const {

FILE: watchman/fs/FileDescriptor.h
  type FileInformation (line 18) | struct FileInformation
  type REPARSE_DATA_BUFFER (line 19) | struct REPARSE_DATA_BUFFER
  type class (line 21) | enum class
  function fdType (line 34) | struct OpenFileHandleOptions {

FILE: watchman/fs/FileInformation.cpp
  type watchman (line 13) | namespace watchman {
    type stat (line 16) | struct stat
    function DType (line 50) | DType FileInformation::dtype() const {
    function FileInformation (line 103) | FileInformation FileInformation::makeDeletedFileInformation() {
  function w_path_exists (line 116) | bool w_path_exists(const char* path) {

FILE: watchman/fs/FileInformation.h
  type class (line 55) | enum class
  type FileInformation (line 87) | struct FileInformation {
  function size (line 93) | uint64_t size{0}
  function gid_t (line 100) | gid_t gid{0}
  function ino_t (line 101) | ino_t ino{0}
  function dev_t (line 102) | dev_t dev{0}
  function nlink_t (line 103) | nlink_t nlink{0}
  function fileAttributes (line 106) | uint32_t fileAttributes{0}
  type timespec (line 109) | struct timespec
  type timespec (line 110) | struct timespec
  type timespec (line 111) | struct timespec
  function DType (line 114) | DType dtype() const;

FILE: watchman/fs/FileSystem.cpp
  type watchman (line 29) | namespace watchman {
    class RealFileSystem (line 33) | class RealFileSystem final : public FileSystem {
      method openDir (line 35) | std::unique_ptr<DirHandle> openDir(const char* path, bool strict = t...
      method FileInformation (line 40) | FileInformation getFileInformation(
      method touch (line 51) | void touch(const char* path) override {
    function checkCanonicalBaseName (line 76) | void checkCanonicalBaseName(const char* path) {
    function FileDescriptor (line 146) | FileDescriptor openFileHandle(
    function FileInformation (line 262) | FileInformation getFileInformation(
    function w_string (line 303) | w_string getCurrentDirectory() {
    function w_string (line 320) | w_string realPath(const char* path) {
    function w_string (line 341) | w_string readSymbolicLink(const char* path) {
    function isOnSameMount (line 385) | bool isOnSameMount(
  function mkdir (line 409) | int mkdir(const char* path, int) {

FILE: watchman/fs/FileSystem.h
  function namespace (line 27) | namespace watchman {

FILE: watchman/fs/ParallelWalk.cpp
  type watchman (line 14) | namespace watchman {
    type ParallelWalkerContext (line 19) | struct ParallelWalkerContext {
      method ParallelWalkerContext (line 33) | ParallelWalkerContext(
      method taskAwareDequeue (line 44) | std::optional<T> taskAwareDequeue(Queue<T>& queue) {
    function createExecutor (line 62) | folly::Executor::KeepAlive<> createExecutor(size_t threadCountHint) {
    function pathJoin (line 78) | folly::fbstring pathJoin(
    class ReadDirTaskCounter (line 91) | class ReadDirTaskCounter {
      method ReadDirTaskCounter (line 106) | explicit ReadDirTaskCounter(std::shared_ptr<ParallelWalkerContext> c...
      method ReadDirTaskCounter (line 111) | ReadDirTaskCounter(const ReadDirTaskCounter& rhs) {
      method ReadDirTaskCounter (line 116) | ReadDirTaskCounter() = delete;
      method ReadDirTaskCounter (line 120) | ReadDirTaskCounter(ReadDirTaskCounter&&) = default;
      method ReadDirTaskCounter (line 122) | ReadDirTaskCounter(ReadDirTaskCounter&&) = delete;
      method ReadDirTaskCounter (line 124) | ReadDirTaskCounter& operator=(const ReadDirTaskCounter&) = delete;
      method ReadDirTaskCounter (line 125) | ReadDirTaskCounter& operator=(ReadDirTaskCounter&&) = delete;
    function readDirTask (line 154) | void readDirTask(

FILE: watchman/fs/ParallelWalk.h
  function namespace (line 17) | namespace watchman {

FILE: watchman/fs/ParallelWalkMain.cpp
  function walk (line 15) | void walk(watchman::AbsolutePath path, size_t threadCountHint) {
  function main (line 62) | int main(int argc, char* argv[]) {

FILE: watchman/fs/Pipe.cpp
  type watchman (line 14) | namespace watchman {

FILE: watchman/fs/Pipe.h
  function namespace (line 11) | namespace watchman {

FILE: watchman/fs/UnixDirHandle.cpp
  type watchman (line 28) | namespace watchman {
    type timespec (line 48) | struct timespec
    type timespec (line 49) | struct timespec
    type timespec (line 50) | struct timespec
    class UnixDirHandle (line 64) | class UnixDirHandle : public DirHandle {
      type attrlist (line 68) | struct attrlist
      type DirEntry (line 74) | struct DirEntry
    function DIR (line 86) | static DIR* opendir_nofollow(const char* path) {
    function use_bulkstat_by_default (line 111) | static bool use_bulkstat_by_default() {
    function openDir (line 132) | std::unique_ptr<DirHandle> openDir(const char* path, bool strict) {
    function flagsToLabel (line 137) | static std::string flagsToLabel(
    function DirEntry (line 221) | const DirEntry* UnixDirHandle::readDir() {

FILE: watchman/fs/WinDirHandle.cpp
  type watchman (line 17) | namespace watchman {
    class WinDirHandle (line 22) | class WinDirHandle : public DirHandle {
      method WinDirHandle (line 39) | explicit WinDirHandle(const char* path, bool strict) {
      method DirEntry (line 61) | const DirEntry* readDir() override {
      method DirEntry (line 79) | const DirEntry* readDirWin8() {
      method DirEntry (line 127) | const DirEntry* readDirWin7() {
    function openDir (line 185) | std::unique_ptr<DirHandle> openDir(const char* path, bool strict) {

FILE: watchman/fs/WindowsTime.cpp
  type watchman (line 12) | namespace watchman {
    function FILETIME_LARGE_INTEGER_to_timespec (line 24) | void FILETIME_LARGE_INTEGER_to_timespec(LARGE_INTEGER ft, timespec* ts) {
    function FILETIME_to_timespec (line 33) | void FILETIME_to_timespec(const FILETIME* ft, timespec* ts) {

FILE: watchman/fs/WindowsTime.h
  function namespace (line 13) | namespace watchman {

FILE: watchman/fuzz/BserDecode.cpp
  function LLVMFuzzerTestOneInput (line 10) | int LLVMFuzzerTestOneInput(void const* data, size_t size) {

FILE: watchman/fuzz/JsonDecode.cpp
  function LLVMFuzzerTestOneInput (line 10) | int LLVMFuzzerTestOneInput(void const* data, size_t size) {

FILE: watchman/fuzz/PyBserDecode.cpp
  function LLVMFuzzerTestOneInput (line 10) | int LLVMFuzzerTestOneInput(void const* data, size_t size) {

FILE: watchman/integration/capabilities.js
  function optional (line 11) | function optional() {
  function required (line 22) | function required() {
  function synth (line 33) | function synth() {

FILE: watchman/integration/cppclient.cpp
  function main (line 27) | int main(int argc, char** argv) {

FILE: watchman/integration/eden/test_eden_glob_upper_bound.py
  function populate (line 17) | def populate(
  class TestEdenGlobUpperBound (line 39) | class TestEdenGlobUpperBound(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method setUp (line 40) | def setUp(self):
    method test_eden_since_upper_bound (line 44) | def test_eden_since_upper_bound(self) -> None:
    method test_eden_trailing_slash (line 73) | def test_eden_trailing_slash(self) -> None:
    method test_eden_since_empty_upper_bound (line 91) | def test_eden_since_empty_upper_bound(self) -> None:
    method test_eden_since_upper_bound_case_insensitive (line 116) | def test_eden_since_upper_bound_case_insensitive(self) -> None:
    method test_eden_since_upper_bound_includedotfiles (line 146) | def test_eden_since_upper_bound_includedotfiles(self) -> None:
    method test_eden_since_upper_bound_name_escaping (line 176) | def test_eden_since_upper_bound_name_escaping(self) -> None:
    method test_eden_since_upper_bound_name_normalization (line 203) | def test_eden_since_upper_bound_name_normalization(self) -> None:
    method test_eden_since_upper_bound_name_set_normalization (line 228) | def test_eden_since_upper_bound_name_set_normalization(self) -> None:
    method test_eden_since_upper_bound_match_noescape (line 255) | def test_eden_since_upper_bound_match_noescape(self) -> None:
    method test_eden_since_upper_bound_match_escape (line 279) | def test_eden_since_upper_bound_match_escape(self) -> None:
    method test_eden_since_upper_bound_dirname_escaping (line 303) | def test_eden_since_upper_bound_dirname_escaping(self) -> None:
    method test_eden_since_upper_bound_match_complex_pattern (line 326) | def test_eden_since_upper_bound_match_complex_pattern(self) -> None:
    method assertGlobUpperBound (line 374) | def assertGlobUpperBound(self, expected_patterns) -> None:

FILE: watchman/integration/eden/test_eden_journal.py
  class TestEdenJournal (line 16) | class TestEdenJournal(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_eden_journal (line 17) | def test_eden_journal(self) -> None:
    method test_two_rapid_checkouts_show_briefly_changed_files (line 103) | def test_two_rapid_checkouts_show_briefly_changed_files(self) -> None:
    method test_aba_checkouts_show_briefly_changed_files (line 160) | def test_aba_checkouts_show_briefly_changed_files(self) -> None:
    method test_querying_with_truncated_journal_returns_fresh_instance (line 213) | def test_querying_with_truncated_journal_returns_fresh_instance(self) ...
    method test_changing_root_tree (line 270) | def test_changing_root_tree(self) -> None:

FILE: watchman/integration/eden/test_eden_pathgen.py
  function populate (line 16) | def populate(repo) -> None:
  class TestEdenPathGenerator (line 32) | class TestEdenPathGenerator(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_defer_mtime (line 33) | def test_defer_mtime(self) -> None:
    method test_eden_readlink (line 47) | def test_eden_readlink(self) -> None:
    method test_non_existent_file (line 62) | def test_non_existent_file(self) -> None:
    method test_eden_watch (line 93) | def test_eden_watch(self) -> None:
    method test_path_and_glob_dotfiles (line 291) | def test_path_and_glob_dotfiles(self):

FILE: watchman/integration/eden/test_eden_query.py
  function populate (line 11) | def populate(repo) -> None:
  class TestEdenQuery (line 25) | class TestEdenQuery(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_eden_path_query (line 26) | def test_eden_path_query(self) -> None:

FILE: watchman/integration/eden/test_eden_scm.py
  function populate (line 12) | def populate(repo) -> None:
  class TestEdenScm (line 21) | class TestEdenScm(WatchmanEdenTestCase.WatchmanEdenTestCase, HgMixin):
    method test_eden_cachedScm (line 22) | def test_eden_cachedScm(self) -> None:

FILE: watchman/integration/eden/test_eden_sha1.py
  class TestEdenSha1 (line 16) | class TestEdenSha1(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method write_file_and_hash (line 17) | def write_file_and_hash(self, filename, content) -> str:
    method test_eden_sha1 (line 26) | def test_eden_sha1(self) -> None:

FILE: watchman/integration/eden/test_eden_shutdown.py
  class TestEdenShutdown (line 12) | class TestEdenShutdown(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_shutdown_and_restart (line 13) | def test_shutdown_and_restart(self) -> None:

FILE: watchman/integration/eden/test_eden_since.py
  function populate (line 18) | def populate(
  class TestEdenSince (line 41) | class TestEdenSince(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_eden_lazy_eval (line 42) | def test_eden_lazy_eval(self) -> None:
    method test_eden_empty_relative_root (line 58) | def test_eden_empty_relative_root(self) -> None:
    method test_eden_since (line 79) | def test_eden_since(self) -> None:
    method query_adir_change_since (line 213) | def query_adir_change_since(self, root, clock):
    method test_eden_since_removal (line 230) | def test_eden_since_removal(self) -> None:
    method test_eden_since_across_update (line 255) | def test_eden_since_across_update(self) -> None:
    method test_eden_since_over_threshold (line 296) | def test_eden_since_over_threshold(self) -> None:
    method test_eden_since_dotfiles_change (line 356) | def test_eden_since_dotfiles_change(self) -> None:
    method test_eden_since_fresh_instance_dotfiles (line 386) | def test_eden_since_fresh_instance_dotfiles(self) -> None:

FILE: watchman/integration/eden/test_eden_subscribe.py
  function possible_cookie (line 15) | def possible_cookie(name):
  class TestEdenSubscribe (line 19) | class TestEdenSubscribe(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method requiresPersistentSession (line 20) | def requiresPersistentSession(self) -> bool:
    method test_eden_subscribe (line 23) | def test_eden_subscribe(self) -> None:
    method assertWaitForAssertedStates (line 97) | def assertWaitForAssertedStates(self, root, states) -> None:
    method test_state_enter_leave (line 113) | def test_state_enter_leave(self) -> None:

FILE: watchman/integration/eden/test_eden_suffix.py
  function populate (line 11) | def populate(repo) -> None:
  class TestEdenQuery (line 28) | class TestEdenQuery(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_simple_suffix (line 29) | def test_simple_suffix(self) -> None:

FILE: watchman/integration/eden/test_eden_takeover.py
  function populate (line 12) | def populate(repo):
  class TestEdenTakeover (line 18) | class TestEdenTakeover(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_eden_takeover (line 19) | def test_eden_takeover(self) -> None:

FILE: watchman/integration/eden/test_eden_unmount.py
  function populate (line 14) | def populate(repo):
  class TestEdenUnmount (line 20) | class TestEdenUnmount(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_eden_unmount (line 21) | def test_eden_unmount(self) -> None:
    method test_eden_unmount_watch (line 35) | def test_eden_unmount_watch(self) -> None:

FILE: watchman/integration/eden/test_eden_watch_parent.py
  class TestEdenWatchParent (line 15) | class TestEdenWatchParent(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_eden_watch_parent (line 16) | def test_eden_watch_parent(self) -> None:

FILE: watchman/integration/eden/test_eden_watch_root.py
  class TestEdenWatchRoot (line 16) | class TestEdenWatchRoot(WatchmanEdenTestCase.WatchmanEdenTestCase):
    method test_eden_watch_root (line 17) | def test_eden_watch_root(self) -> None:

FILE: watchman/integration/lib/Interrupt.py
  function wasInterrupted (line 12) | def wasInterrupted() -> bool:
  function setInterrupted (line 17) | def setInterrupted() -> None:
  function checkInterrupt (line 22) | def checkInterrupt() -> None:

FILE: watchman/integration/lib/TempDir.py
  class TempDir (line 23) | class TempDir:
    method __init__ (line 33) | def __init__(self, keepAtShutdown: bool = False) -> None:
    method get_dir (line 65) | def get_dir(self):
    method set_keep (line 68) | def set_keep(self, value) -> None:
    method _retry_rmtree (line 71) | def _retry_rmtree(self, top) -> None:
  function _remove_readonly (line 83) | def _remove_readonly(func, path, exc_info) -> None:
  function get_temp_dir (line 105) | def get_temp_dir(keep=None):

FILE: watchman/integration/lib/WatchmanEdenTestCase.py
  function is_sandcastle (line 21) | def is_sandcastle():
  function is_buck_build (line 31) | def is_buck_build():
  function can_run_eden (line 40) | def can_run_eden():
  class WatchmanEdenTestCase (line 43) | class WatchmanEdenTestCase:
    method setUp (line 60) | def setUp(self) -> None:
    method _restoreHome (line 92) | def _restoreHome(self) -> None:
    method cleanUpEden (line 96) | def cleanUpEden(self) -> None:
    method cleanUpWatchman (line 99) | def cleanUpWatchman(self):
    method makeEdenMount (line 111) | def makeEdenMount(self, populate_fn=None):
    method repoForPath (line 130) | def repoForPath(self, path):
    method setDefaultConfiguration (line 139) | def setDefaultConfiguration(self):
    method isCaseSensitiveMount (line 142) | def isCaseSensitiveMount(self, path) -> bool:
  class WatchmanEdenTestCase (line 48) | class WatchmanEdenTestCase(WatchmanTestCase.WatchmanTestCase):
    method setUp (line 60) | def setUp(self) -> None:
    method _restoreHome (line 92) | def _restoreHome(self) -> None:
    method cleanUpEden (line 96) | def cleanUpEden(self) -> None:
    method cleanUpWatchman (line 99) | def cleanUpWatchman(self):
    method makeEdenMount (line 111) | def makeEdenMount(self, populate_fn=None):
    method repoForPath (line 130) | def repoForPath(self, path):
    method setDefaultConfiguration (line 139) | def setDefaultConfiguration(self):
    method isCaseSensitiveMount (line 142) | def isCaseSensitiveMount(self, path) -> bool:

FILE: watchman/integration/lib/WatchmanInstance.py
  function getSharedInstance (line 35) | def getSharedInstance(config=None):
  function mergeTestConfig (line 50) | def mergeTestConfig(config):
  class InitWithFilesMixin (line 56) | class InitWithFilesMixin:
    method _init_state (line 57) | def _init_state(self) -> None:
    method get_state_args (line 81) | def get_state_args(self):
  class InitWithDirMixin (line 91) | class InitWithDirMixin:
    method _init_state (line 97) | def _init_state(self) -> None:
    method get_state_args (line 121) | def get_state_args(self):
  class _Instance (line 125) | class _Instance:
    method __init__ (line 130) | def __init__(
    method __del__ (line 143) | def __del__(self) -> None:
    method __enter__ (line 146) | def __enter__(self) -> "_Instance":
    method __exit__ (line 149) | def __exit__(self, *exc_info) -> None:
    method getSockPath (line 152) | def getSockPath(self):
    method getUnixSockPath (line 157) | def getUnixSockPath(self):
    method getNamedPipePath (line 160) | def getNamedPipePath(self):
    method getCLILogContents (line 163) | def getCLILogContents(self) -> str:
    method getServerLogContents (line 168) | def getServerLogContents(self) -> str:
    method stop (line 173) | def stop(self) -> None:
    method watchmanBinary (line 179) | def watchmanBinary(self) -> str:
    method commandViaCLI (line 182) | def commandViaCLI(self, cmd, prefix=None):
    method start (line 197) | def start(self, extra_env=None) -> None:
    method _waitForSuspend (line 241) | def _waitForSuspend(self, suspended, timeout: float) -> bool:
    method _susresBinary (line 263) | def _susresBinary(self) -> str:
    method suspend (line 266) | def suspend(self) -> None:
    method resume (line 277) | def resume(self) -> None:
  class Instance (line 289) | class Instance(_Instance, InitWithFilesMixin):
  class InstanceWithStateDir (line 293) | class InstanceWithStateDir(_Instance, InitWithDirMixin):

FILE: watchman/integration/lib/WatchmanSCMTestCase.py
  class HgMixin (line 19) | class HgMixin:
    method hg (line 20) | def hg(self, args, cwd=None):
  class WatchmanSCMTestCase (line 55) | class WatchmanSCMTestCase(WatchmanTestCase.WatchmanTestCase, HgMixin):
    method __init__ (line 56) | def __init__(self, methodName: str = "run") -> None:
    method requiresPersistentSession (line 59) | def requiresPersistentSession(self) -> bool:
    method skipIfNoFSMonitor (line 62) | def skipIfNoFSMonitor(self) -> None:
    method checkOSApplicability (line 77) | def checkOSApplicability(self) -> None:
    method resolveCommitHash (line 81) | def resolveCommitHash(self, revset, cwd=None) -> str:
    method waitForStatesToVacate (line 86) | def waitForStatesToVacate(self, root) -> None:
    method getConsolidatedFileList (line 94) | def getConsolidatedFileList(self, dat):
    method getSubFatClocksOnly (line 100) | def getSubFatClocksOnly(self, subname, root):

FILE: watchman/integration/lib/WatchmanTestCase.py
  function wrap_with_backoff (line 33) | def wrap_with_backoff(fn):
  class TempDirPerTestMixin (line 59) | class TempDirPerTestMixin(unittest.TestCase):
    method __init__ (line 60) | def __init__(self, *args, **kwargs) -> None:
    method setUp (line 64) | def setUp(self) -> None:
    method _getTempDirName (line 74) | def _getTempDirName(self) -> str:
    method mkdtemp (line 77) | def mkdtemp(self, **kwargs):
    method mktemp (line 80) | def mktemp(self, prefix: str = "") -> str:
  class WatchmanTestCase (line 86) | class WatchmanTestCase(TempDirPerTestMixin, unittest.TestCase):
    method __init__ (line 96) | def __init__(self, methodName: str = "run") -> None:
    method requiresPersistentSession (line 106) | def requiresPersistentSession(self) -> bool:
    method checkPersistentSession (line 109) | def checkPersistentSession(self) -> None:
    method checkOSApplicability (line 113) | def checkOSApplicability(self) -> None:
    method skipIfCapabilityMissing (line 118) | def skipIfCapabilityMissing(self, cap, reason) -> None:
    method setUp (line 123) | def setUp(self) -> None:
    method tearDown (line 128) | def tearDown(self) -> None:
    method getClient (line 138) | def getClient(
    method __logTestInfo (line 157) | def __logTestInfo(self, test, msg):
    method setAttemptNumber (line 164) | def setAttemptNumber(self, attempt: int) -> None:
    method __clearClient (line 167) | def __clearClient(self):
    method _getTempDirName (line 172) | def _getTempDirName(self) -> str:
    method _getLongTestID (line 178) | def _getLongTestID(self) -> str:
    method run (line 182) | def run(self, result):
    method dumpLogs (line 202) | def dumpLogs(self) -> None:
    method getLogSample (line 207) | def getLogSample(self) -> str:
    method getServerLogContents (line 224) | def getServerLogContents(self):
    method setConfiguration (line 231) | def setConfiguration(
    method removeRelative (line 239) | def removeRelative(self, base, *fname) -> None:
    method touch (line 243) | def touch(self, fname, times=None) -> None:
    method touchRelative (line 253) | def touchRelative(self, base, *fname) -> None:
    method __clearWatches (line 257) | def __clearWatches(self):
    method __del__ (line 266) | def __del__(self) -> None:
    method watchmanCommand (line 269) | def watchmanCommand(self, *args):
    method watchmanInstance (line 273) | def watchmanInstance(self):
    method watchmanConfig (line 276) | def watchmanConfig(self):
    method _waitForCheck (line 284) | def _waitForCheck(self, cond, res_check, timeout: float):
    method waitFor (line 299) | def waitFor(self, cond, timeout=None):
    method waitForEqual (line 303) | def waitForEqual(self, expected, actual_cond, timeout=None):
    method getTimeout (line 307) | def getTimeout(self, timeout=None) -> float:
    method assertWaitFor (line 310) | def assertWaitFor(self, cond, timeout=None, message=None):
    method assertWaitForEqual (line 319) | def assertWaitForEqual(self, expected, actual_cond, timeout=None, mess...
    method getFileList (line 333) | def getFileList(self, root, cursor=None, relativeRoot=None):
    method waitForSync (line 344) | def waitForSync(self, root) -> None:
    method getWatchList (line 353) | def getWatchList(self):
    method assertFileListsEqual (line 358) | def assertFileListsEqual(self, list1, list2, message=None) -> None:
    method fileListsEqual (line 363) | def fileListsEqual(self, list1, list2) -> bool:
    method fileListContains (line 368) | def fileListContains(self, list1, list2) -> bool:
    method assertFileListContains (line 374) | def assertFileListContains(self, list1, list2, message=None) -> None:
    method assertFileList (line 380) | def assertFileList(
    method assertQueryRepsonseEqual (line 398) | def assertQueryRepsonseEqual(self, expected_resp, actual_resp) -> None:
    method assertWatchListContains (line 409) | def assertWatchListContains(self, roots, message=None) -> None:
    method waitForSub (line 416) | def waitForSub(
    method waitForSubFileList (line 444) | def waitForSubFileList(self, name, root, fileList: List[str], timeout=...
    method getSubscription (line 459) | def getSubscription(
    method normalizeFiles (line 470) | def normalizeFiles(self, data):
    method isCaseInsensitive (line 485) | def isCaseInsensitive(self):
    method suspendWatchman (line 493) | def suspendWatchman(self) -> None:
    method resumeWatchman (line 496) | def resumeWatchman(self) -> None:
    method rootIsWatched (line 499) | def rootIsWatched(self, r) -> bool:
  function skip_for (line 508) | def skip_for(transports=None, codecs=None):
  function expand_matrix (line 529) | def expand_matrix(test_class) -> None:

FILE: watchman/integration/lib/node.py
  function _find_node (line 13) | def _find_node():
  function _find_yarn (line 17) | def _find_yarn():
  function _ensure_can_run (line 23) | def _ensure_can_run(binary_path) -> None:

FILE: watchman/integration/lib/path_utils.py
  function open_file_win (line 17) | def open_file_win(path):
  function get_canonical_filesystem_path (line 32) | def get_canonical_filesystem_path(name):
  function get_canonical_filesystem_path (line 63) | def get_canonical_filesystem_path(name):
  function get_canonical_filesystem_path (line 75) | def get_canonical_filesystem_path(name):
  function norm_relative_path (line 79) | def norm_relative_path(path):
  function norm_absolute_path (line 88) | def norm_absolute_path(path):

FILE: watchman/integration/test_absroot.py
  class TestAbsoluteRoot (line 19) | class TestAbsoluteRoot(WatchmanTestCase.WatchmanTestCase):
    method test_dot (line 20) | def test_dot(self) -> None:
    method test_root (line 41) | def test_root(self) -> None:

FILE: watchman/integration/test_age_file.py
  class TestAgeOutFile (line 18) | class TestAgeOutFile(WatchmanTestCase.WatchmanTestCase):
    method test_age_file (line 20) | def test_age_file(self) -> None:

FILE: watchman/integration/test_age_watch.py
  class TestAgeOutWatch (line 19) | class TestAgeOutWatch(WatchmanTestCase.WatchmanTestCase):
    method makeRootAndConfig (line 20) | def makeRootAndConfig(self):
    method test_watchReap (line 27) | def test_watchReap(self) -> None:

FILE: watchman/integration/test_auth.py
  class TestAuth (line 15) | class TestAuth(WatchmanTestCase.WatchmanTestCase):
    method requiresPersistentSession (line 16) | def requiresPersistentSession(self) -> bool:
    method test_dropPriv (line 19) | def test_dropPriv(self) -> None:

FILE: watchman/integration/test_big.py
  function populate_tests (line 17) | def populate_tests(original_test_class):
  class TestBig (line 42) | class TestBig(WatchmanTestCase.WatchmanTestCase):
    method checkOSApplicability (line 43) | def checkOSApplicability(self) -> None:
    method do_test_bigQuery (line 47) | def do_test_bigQuery(self, sizes: List[int]) -> None:

FILE: watchman/integration/test_big_file.py
  class TestBigFile (line 17) | class TestBigFile(WatchmanTestCase.WatchmanTestCase):
    method test_big_file (line 18) | def test_big_file(self) -> None:

FILE: watchman/integration/test_bsdish.py
  class TestBSDish (line 16) | class TestBSDish(WatchmanTestCase.WatchmanTestCase):
    method test_bsdish_toplevel (line 17) | def test_bsdish_toplevel(self) -> None:

FILE: watchman/integration/test_bser_cli.py
  class TestDashJCliOption (line 21) | class TestDashJCliOption(unittest.TestCase):
    method getSockPath (line 22) | def getSockPath(self):
    method doJson (line 25) | def doJson(self, addNewLine, pretty: bool = False) -> None:
    method test_jsonInputNoNewLine (line 58) | def test_jsonInputNoNewLine(self) -> None:
    method test_jsonInputNewLine (line 61) | def test_jsonInputNewLine(self) -> None:
    method test_jsonInputPretty (line 64) | def test_jsonInputPretty(self) -> None:
    method test_bserInput (line 67) | def test_bserInput(self) -> None:

FILE: watchman/integration/test_bulkstat.py
  class TestBulkStat (line 13) | class TestBulkStat(WatchmanTestCase.WatchmanTestCase):
    method test_bulkstat_on (line 14) | def test_bulkstat_on(self) -> None:
    method test_bulkstat_off (line 28) | def test_bulkstat_off(self) -> None:

FILE: watchman/integration/test_capabilities.py
  class TestCapabilities (line 18) | class TestCapabilities(WatchmanTestCase.WatchmanTestCase):
    method test_capabilities (line 19) | def test_capabilities(self) -> None:
    method test_capabilityCheck (line 44) | def test_capabilityCheck(self) -> None:
    method test_capabilitySynth (line 66) | def test_capabilitySynth(self) -> None:
    method test_full_capability_set (line 100) | def test_full_capability_set(self) -> None:

FILE: watchman/integration/test_case_sensitive.py
  class TestCaseSensitive (line 15) | class TestCaseSensitive(WatchmanTestCase.WatchmanTestCase):
    method test_changeCase (line 16) | def test_changeCase(self) -> None:

FILE: watchman/integration/test_clock.py
  class TestClock (line 14) | class TestClock(WatchmanTestCase.WatchmanTestCase):
    method test_clock (line 15) | def test_clock(self) -> None:
    method test_clock_sync (line 22) | def test_clock_sync(self) -> None:

FILE: watchman/integration/test_command.py
  class TestCommand (line 15) | class TestCommand(WatchmanTestCase.WatchmanTestCase):
    method test_unknown_commands_print_json_error (line 16) | def test_unknown_commands_print_json_error(self) -> None:

FILE: watchman/integration/test_content_hash.py
  class TestContentHash (line 18) | class TestContentHash(WatchmanTestCase.WatchmanTestCase):
    method write_file_and_hash (line 19) | def write_file_and_hash(self, filename, content) -> str:
    method test_contentHash (line 28) | def test_contentHash(self) -> None:
    method test_contentHashWarming (line 115) | def test_contentHashWarming(self) -> None:
    method test_cacheLimit (line 145) | def test_cacheLimit(self) -> None:

FILE: watchman/integration/test_cookie.py
  class TestCookie (line 18) | class TestCookie(WatchmanTestCase.WatchmanTestCase):
    method test_delete_cookie_dir (line 19) | def test_delete_cookie_dir(self) -> None:
    method test_other_cookies (line 46) | def test_other_cookies(self) -> None:

FILE: watchman/integration/test_cppclient.py
  class TestCppClient (line 27) | class TestCppClient(unittest.TestCase):
    method setUp (line 28) | def setUp(self) -> None:
    method tearDown (line 32) | def tearDown(self) -> None:
    method test_cppclient (line 36) | def test_cppclient(self) -> None:

FILE: watchman/integration/test_cursor.py
  class TestCursor (line 16) | class TestCursor(WatchmanTestCase.WatchmanTestCase):
    method test_cursor (line 17) | def test_cursor(self) -> None:

FILE: watchman/integration/test_dir_move.py
  class TestDirMove (line 19) | class TestDirMove(WatchmanTestCase.WatchmanTestCase):
    method checkOSApplicability (line 22) | def checkOSApplicability(self) -> None:
    method build_under (line 26) | def build_under(self, root, name, latency: float = 0) -> None:
    method test_atomicMove (line 32) | def test_atomicMove(self) -> None:
    method test_NonAtomicMove (line 51) | def test_NonAtomicMove(self) -> None:

FILE: watchman/integration/test_dirname.py
  class TestDirName (line 16) | class TestDirName(WatchmanTestCase.WatchmanTestCase):
    method test_dirname (line 17) | def test_dirname(self) -> None:

FILE: watchman/integration/test_empty.py
  class TestEmpty (line 16) | class TestEmpty(WatchmanTestCase.WatchmanTestCase):
    method test_empty (line 17) | def test_empty(self) -> None:

FILE: watchman/integration/test_fields.py
  class TestFields (line 16) | class TestFields(WatchmanTestCase.WatchmanTestCase):
    method test_fields (line 17) | def test_fields(self) -> None:

FILE: watchman/integration/test_find.py
  class TestFind (line 17) | class TestFind(WatchmanTestCase.WatchmanTestCase):
    method test_find (line 18) | def test_find(self) -> None:

FILE: watchman/integration/test_fishy.py
  class TestFishy (line 16) | class TestFishy(WatchmanTestCase.WatchmanTestCase):
    method checkOSApplicability (line 17) | def checkOSApplicability(self) -> None:
    method test_fishy (line 21) | def test_fishy(self) -> None:
    method test_more_moves (line 45) | def test_more_moves(self) -> None:
    method test_even_more_moves (line 64) | def test_even_more_moves(self) -> None:
    method test_notify_dir (line 92) | def test_notify_dir(self) -> None:

FILE: watchman/integration/test_force_recrawl.py
  class TestForceRecrawl (line 15) | class TestForceRecrawl(WatchmanTestCase.WatchmanTestCase):
    method test_force_recrawl (line 16) | def test_force_recrawl(self) -> None:

FILE: watchman/integration/test_fork.py
  class TestSince (line 17) | class TestSince(WatchmanTestCase.WatchmanTestCase):
    method checkOSApplicability (line 18) | def checkOSApplicability(self) -> None:
    method test_forkclient (line 22) | def test_forkclient(self) -> None:

FILE: watchman/integration/test_fsevents_resync.py
  class TestFSEventsResync (line 20) | class TestFSEventsResync(WatchmanTestCase.WatchmanTestCase):
    method checkOSApplicability (line 21) | def checkOSApplicability(self) -> None:
    method test_resync (line 25) | def test_resync(self) -> None:

FILE: watchman/integration/test_fstype.py
  class TestIllegalFSType (line 15) | class TestIllegalFSType(WatchmanTestCase.WatchmanTestCase):
    method test_Illegal (line 16) | def test_Illegal(self) -> None:

FILE: watchman/integration/test_glob.py
  class TestGlob (line 19) | class TestGlob(WatchmanTestCase.WatchmanTestCase):
    method test_glob (line 20) | def test_glob(self) -> None:
    method test_glob_generator_empty (line 162) | def test_glob_generator_empty(self) -> None:
    method test_glob_generator_absolute (line 173) | def test_glob_generator_absolute(self) -> None:
    method test_case_sensitive (line 189) | def test_case_sensitive(self) -> None:

FILE: watchman/integration/test_ignore.py
  class TestIgnore (line 18) | class TestIgnore(WatchmanTestCase.WatchmanTestCase):
    method test_ignore_git (line 19) | def test_ignore_git(self) -> None:
    method test_invalid_ignore (line 35) | def test_invalid_ignore(self) -> None:
    method test_ignore_overlap_vcs_ignore (line 46) | def test_ignore_overlap_vcs_ignore(self) -> None:
    method test_ignore_generic (line 59) | def test_ignore_generic(self) -> None:

FILE: watchman/integration/test_info.py
  class TestInfo (line 17) | class TestInfo(WatchmanTestCase.WatchmanTestCase):
    method test_sock_name (line 18) | def test_sock_name(self) -> None:
    method test_get_config_empty (line 25) | def test_get_config_empty(self) -> None:
    method test_get_config (line 30) | def test_get_config(self) -> None:
    method get_config (line 38) | def get_config(self, root):

FILE: watchman/integration/test_invalid_expr.py
  class TestInvalidExpr (line 15) | class TestInvalidExpr(WatchmanTestCase.WatchmanTestCase):
    method test_invalid_expr_term (line 16) | def test_invalid_expr_term(self) -> None:
    method test_invalid_sync_timeout (line 41) | def test_invalid_sync_timeout(self) -> None:

FILE: watchman/integration/test_invalid_watchmanconfig.py
  class TestWatchmanConfigValid (line 16) | class TestWatchmanConfigValid(WatchmanTestCase.WatchmanTestCase):
    method test_trailing_comma (line 17) | def test_trailing_comma(self) -> None:

FILE: watchman/integration/test_kqueue_and_fsevents_recrawl.py
  class TestKQueueAndFSEventsRecrawl (line 18) | class TestKQueueAndFSEventsRecrawl(WatchmanTestCase.WatchmanTestCase):
    method checkOSApplicability (line 19) | def checkOSApplicability(self) -> None:
    method test_recrawl (line 23) | def test_recrawl(self) -> None:

FILE: watchman/integration/test_local_saved_state.py
  function is_ubuntu (line 16) | def is_ubuntu() -> bool:
  class TestSavedState (line 27) | class TestSavedState(WatchmanSCMTestCase.WatchmanSCMTestCase):
    method checkOSApplicability (line 28) | def checkOSApplicability(self) -> None:
    method setUp (line 36) | def setUp(self) -> None:
    method getQuery (line 102) | def getQuery(self, config):
    method getLocalFilename (line 117) | def getLocalFilename(self, saved_state_rev, metadata):
    method saveState (line 124) | def saveState(self, project, bookmark, local_storage, metadata=None):
    method getConfig (line 133) | def getConfig(self, result):
    method assertStorageTypeLocal (line 136) | def assertStorageTypeLocal(self, result) -> None:
    method assertCommitIDEquals (line 139) | def assertCommitIDEquals(self, result, commit_id) -> None:
    method assertCommitIDNotPresent (line 142) | def assertCommitIDNotPresent(self, result) -> None:
    method assertSavedStateErrorEquals (line 145) | def assertSavedStateErrorEquals(self, result, error_string) -> None:
    method assertSavedStateInfo (line 148) | def assertSavedStateInfo(self, result, path, commit_id) -> None:
    method assertMergebaseEquals (line 153) | def assertMergebaseEquals(self, result, mergebase) -> None:
    method test_localSavedStateErrorHandling (line 156) | def test_localSavedStateErrorHandling(self) -> None:
    method test_localSavedStateNoStateFound (line 170) | def test_localSavedStateNoStateFound(self) -> None:
    method test_localSavedStateNotWithinLimit (line 187) | def test_localSavedStateNotWithinLimit(self) -> None:
    method test_localSavedStateNotWithinLimitOmitChangedFiles (line 208) | def test_localSavedStateNotWithinLimitOmitChangedFiles(self) -> None:
    method test_localSavedStateNotWithinLimitError (line 230) | def test_localSavedStateNotWithinLimitError(self) -> None:
    method test_localSavedStateLookupSuccess (line 254) | def test_localSavedStateLookupSuccess(self) -> None:
    method test_localSavedStateLookupSuccessOmitChangedFiles (line 279) | def test_localSavedStateLookupSuccessOmitChangedFiles(self) -> None:
    method test_localSavedStateLookupSuccessWithMetadata (line 307) | def test_localSavedStateLookupSuccessWithMetadata(self) -> None:
    method test_localSavedStateFailureIfMetadataDoesNotMatch (line 333) | def test_localSavedStateFailureIfMetadataDoesNotMatch(self) -> None:
    method test_localSavedStateFailureIfNoMetadataForFileThatHasIt (line 352) | def test_localSavedStateFailureIfNoMetadataForFileThatHasIt(self) -> N...
    method test_localSavedStateSubscription (line 371) | def test_localSavedStateSubscription(self) -> None:

FILE: watchman/integration/test_log.py
  class TestLog (line 15) | class TestLog(WatchmanTestCase.WatchmanTestCase):
    method test_invalidNumArgsLogLevel (line 16) | def test_invalidNumArgsLogLevel(self) -> None:
    method test_invalidLevelLogLevel (line 23) | def test_invalidLevelLogLevel(self) -> None:
    method test_invalidNumArgsLog (line 29) | def test_invalidNumArgsLog(self) -> None:
    method test_invalidLevelLog (line 36) | def test_invalidLevelLog(self) -> None:

FILE: watchman/integration/test_match.py
  class TestMatch (line 17) | class TestMatch(WatchmanTestCase.WatchmanTestCase):
    method test_match (line 18) | def test_match(self) -> None:

FILE: watchman/integration/test_name.py
  class TestNameExpr (line 17) | class TestNameExpr(WatchmanTestCase.WatchmanTestCase):
    method test_name_expr (line 18) | def test_name_expr(self) -> None:

FILE: watchman/integration/test_nice.py
  class TestNice (line 18) | class TestNice(unittest.TestCase):
    method test_failing_to_start_when_nice (line 22) | def test_failing_to_start_when_nice(self) -> None:
    method test_failing_to_start_when_nice_foreground (line 31) | def test_failing_to_start_when_nice_foreground(self) -> None:

FILE: watchman/integration/test_nodejs.py
  function find_js_tests (line 26) | def find_js_tests(test_class) -> None:
  class NodeTestCase (line 66) | class NodeTestCase(WatchmanTestCase.TempDirPerTestMixin, unittest.TestCa...
    method setAttemptNumber (line 69) | def setAttemptNumber(self, attempt: int) -> None:
    method runTest (line 76) | def runTest(self) -> None:
    method _getTempDirName (line 121) | def _getTempDirName(self):

FILE: watchman/integration/test_path_generator.py
  class TestPathGenerator (line 16) | class TestPathGenerator(WatchmanTestCase.WatchmanTestCase):
    method test_path_generator_dot (line 17) | def test_path_generator_dot(self) -> None:
    method test_path_generator_case (line 32) | def test_path_generator_case(self) -> None:
    method test_path_generator_relative_root (line 60) | def test_path_generator_relative_root(self) -> None:
    method test_path_generator_empty (line 103) | def test_path_generator_empty(self) -> None:

FILE: watchman/integration/test_pcre.py
  class TestPcre (line 15) | class TestPcre(WatchmanTestCase.WatchmanTestCase):
    method check_pcre (line 16) | def check_pcre(self) -> None:
    method test_big_pcre (line 21) | def test_big_pcre(self) -> None:
    method test_pcre (line 46) | def test_pcre(self) -> None:

FILE: watchman/integration/test_perms.py
  function is_root (line 17) | def is_root() -> bool:
  class TestPerms (line 22) | class TestPerms(WatchmanTestCase.WatchmanTestCase):
    method checkOSApplicability (line 23) | def checkOSApplicability(self) -> None:
    method test_permDeniedSubDir (line 28) | def test_permDeniedSubDir(self) -> None:
    method test_permDeniedRoot (line 40) | def test_permDeniedRoot(self) -> None:

FILE: watchman/integration/test_remove.py
  class TestRemove (line 17) | class TestRemove(WatchmanTestCase.WatchmanTestCase):
    method test_remove (line 18) | def test_remove(self) -> None:

FILE: watchman/integration/test_remove_then_add.py
  class TestRemoveThenAdd (line 17) | class TestRemoveThenAdd(WatchmanTestCase.WatchmanTestCase):
    method checkOSApplicability (line 18) | def checkOSApplicability(self) -> None:
    method test_remove_then_add (line 22) | def test_remove_then_add(self) -> None:

FILE: watchman/integration/test_request_id.py
  function is_hg_installed (line 18) | def is_hg_installed() -> bool:
  class TestRequestId (line 38) | class TestRequestId(WatchmanTestCase.WatchmanTestCase):
    method test_queryRequestId (line 39) | def test_queryRequestId(self) -> None:
    method skipIfNoHgRequestIdSupport (line 55) | def skipIfNoHgRequestIdSupport(self) -> None:
    method test_scmHgRequestId (line 78) | def test_scmHgRequestId(self) -> None:

FILE: watchman/integration/test_restrictions.py
  class TestWatchRestrictions (line 17) | class TestWatchRestrictions(WatchmanTestCase.WatchmanTestCase):
    method test_rootRestrict (line 18) | def test_rootRestrict(self) -> None:
    method runWatchTests (line 30) | def runWatchTests(self, config, expect) -> None:
    method assertWatchSucceeds (line 57) | def assertWatchSucceeds(self, inst, client, path) -> None:
    method assertWatchProjectSucceeds (line 60) | def assertWatchProjectSucceeds(self, inst, client, path) -> None:
    method assertWatchIsRestricted (line 63) | def assertWatchIsRestricted(self, inst, client, path) -> None:
    method assertWatchProjectIsRestricted (line 94) | def assertWatchProjectIsRestricted(self, inst, client, path) -> None:
    method test_invalidRoot (line 119) | def test_invalidRoot(self) -> None:

FILE: watchman/integration/test_saved_state.py
  class TestSavedState (line 15) | class TestSavedState(WatchmanSCMTestCase.WatchmanSCMTestCase):
    method setUp (line 16) | def setUp(self) -> None:
    method get_skeleton_query (line 32) | def get_skeleton_query(self):
    method test_unsupportedStorageType (line 42) | def test_unsupportedStorageType(self) -> None:

FILE: watchman/integration/test_scm.py
  function is_ubuntu (line 17) | def is_ubuntu() -> bool:
  class TestScm (line 28) | class TestScm(WatchmanSCMTestCase.WatchmanSCMTestCase):
    method test_not_supported (line 29) | def test_not_supported(self) -> None:
    method test_scmHg (line 49) | def test_scmHg(self) -> None:

FILE: watchman/integration/test_since.py
  class TestSince (line 18) | class TestSince(WatchmanTestCase.WatchmanTestCase):
    method test_sinceIssue1 (line 19) | def test_sinceIssue1(self) -> None:
    method test_sinceIssue2 (line 38) | def test_sinceIssue2(self) -> None:
    method test_sinceRelativeRoot (line 77) | def test_sinceRelativeRoot(self) -> None:
    method assertFreshInstanceForSince (line 135) | def assertFreshInstanceForSince(self, root, cursor, empty: bool = Fals...
    method test_sinceFreshInstance (line 147) | def test_sinceFreshInstance(self) -> None:
    method test_reAddWatchFreshInstance (line 204) | def test_reAddWatchFreshInstance(self) -> None:
    method test_recrawlFreshInstance (line 229) | def test_recrawlFreshInstance(self) -> None:
    method test_recrawlFreshInstanceWarningSuppressed (line 250) | def test_recrawlFreshInstanceWarningSuppressed(self) -> None:

FILE: watchman/integration/test_since_term.py
  class TestSinceTerm (line 17) | class TestSinceTerm(WatchmanTestCase.WatchmanTestCase):
    method test_since_term (line 18) | def test_since_term(self) -> None:

FILE: watchman/integration/test_site_spawn.py
  class TestSiteSpawn (line 22) | class TestSiteSpawn(unittest.TestCase):
    method test_failingSpawner (line 23) | def test_failingSpawner(self) -> None:
    method test_no_site_spawner (line 37) | def test_no_site_spawner(self) -> None:
    method test_spawner (line 51) | def test_spawner(self) -> None:

FILE: watchman/integration/test_size.py
  class TestSizeExpr (line 16) | class TestSizeExpr(WatchmanTestCase.WatchmanTestCase):
    method test_size_expr (line 17) | def test_size_expr(self) -> None:

FILE: watchman/integration/test_sock_perms.py
  class TestSockPerms (line 35) | class TestSockPerms(unittest.TestCase):
    method _new_instance (line 36) | def _new_instance(self, config):
    method _get_custom_gid (line 42) | def _get_custom_gid(self):
    method _get_non_member_group (line 52) | def _get_non_member_group(self):
    method waitFor (line 60) | def waitFor(self, cond, timeout: float = 60):
    method assertWaitFor (line 73) | def assertWaitFor(
    method test_too_open_user_dir (line 85) | def test_too_open_user_dir(self) -> None:
    method test_invalid_sock_group (line 101) | def test_invalid_sock_group(self) -> None:
    method test_user_not_in_sock_group (line 131) | def test_user_not_in_sock_group(self) -> None:
    method test_default_sock_group (line 143) | def test_default_sock_group(self) -> None:
    method test_custom_sock_group (line 153) | def test_custom_sock_group(self) -> None:
    method test_user_previously_in_sock_group (line 163) | def test_user_previously_in_sock_group(self) -> None:
    method test_invalid_sock_access (line 193) | def test_invalid_sock_access(self) -> None:
    method test_default_sock_access (line 214) | def test_default_sock_access(self) -> None:
    method test_custom_sock_access_group (line 222) | def test_custom_sock_access_group(self) -> None:
    method test_custom_sock_access_others (line 230) | def test_custom_sock_access_others(self) -> None:
    method test_sock_access_upgrade (line 238) | def test_sock_access_upgrade(self) -> None:
    method test_sock_access_downgrade (line 248) | def test_sock_access_downgrade(self) -> None:
    method test_sock_access_group_change (line 258) | def test_sock_access_group_change(self) -> None:
    method test_sock_access_via_acl (line 271) | def test_sock_access_via_acl(self) -> None:
    method test_sock_access_via_acl_user_not_in_sock_group (line 281) | def test_sock_access_via_acl_user_not_in_sock_group(self) -> None:
    method test_sock_symlink (line 290) | def test_sock_symlink(self) -> None:
    method assertFileMode (line 328) | def assertFileMode(self, f, mode, follow_symlink=True) -> None:
    method assertFileGID (line 335) | def assertFileGID(self, f, gid, follow_symlink=True) -> None:
    method assertACL (line 342) | def assertACL(self, f, group, expected_regex) -> None:

FILE: watchman/integration/test_subscribe.py
  class TestSubscribe (line 21) | class TestSubscribe(WatchmanTestCase.WatchmanTestCase):
    method requiresPersistentSession (line 22) | def requiresPersistentSession(self) -> bool:
    method wlockExists (line 25) | def wlockExists(self, subdata, exists) -> bool:
    method matchStateSubscription (line 40) | def matchStateSubscription(self, subdata, mode):
    method assertWaitForAssertedStates (line 46) | def assertWaitForAssertedStates(self, root, states) -> None:
    method test_state_enter_leave (line 62) | def test_state_enter_leave(self) -> None:
    method test_defer_state (line 96) | def test_defer_state(self) -> None:
    method test_drop_state (line 174) | def test_drop_state(self) -> None:
    method test_defer_vcs (line 229) | def test_defer_vcs(self) -> None:
    method test_immediate_subscribe (line 285) | def test_immediate_subscribe(self) -> None:
    method test_multi_cancel (line 319) | def test_multi_cancel(self) -> None:
    method test_subscribe (line 346) | def test_subscribe(self) -> None:
    method test_flush_subscriptions (line 414) | def test_flush_subscriptions(self) -> None:
    method test_unsub_deadlock (line 601) | def test_unsub_deadlock(self) -> None:
    method test_subscription_cleanup (line 622) | def test_subscription_cleanup(self) -> None:
    method test_subscribe_unicode (line 678) | def test_subscribe_unicode(self) -> None:
    method test_unique_name_error (line 726) | def test_unique_name_error(self) -> None:
    method test_resubscribe_same_name_no_error (line 759) | def test_resubscribe_same_name_no_error(self) -> None:
    method test_resubscribe_same_name_no_warning (line 796) | def test_resubscribe_same_name_no_warning(self) -> None:
    method test_multi_client_same_name (line 836) | def test_multi_client_same_name(self) -> None:
    method test_unique_name_warning (line 901) | def test_unique_name_warning(self) -> None:
    method findSubscriptionContainingFile (line 921) | def findSubscriptionContainingFile(self, subdata, filename):
    method normFileList (line 928) | def normFileList(self, files):

FILE: watchman/integration/test_suffix.py
  class TestMatch (line 17) | class TestMatch(WatchmanTestCase.WatchmanTestCase):
    method test_match_suffix (line 18) | def test_match_suffix(self) -> None:
    method test_suffix_expr (line 141) | def test_suffix_expr(self) -> None:

FILE: watchman/integration/test_suffix_generator.py
  class TestSuffixGenerator (line 17) | class TestSuffixGenerator(WatchmanTestCase.WatchmanTestCase):
    method test_suffix_generator (line 18) | def test_suffix_generator(self) -> None:
    method test_suffix_generator_empty (line 60) | def test_suffix_generator_empty(self) -> None:

FILE: watchman/integration/test_trigger.py
  class TestTrigger (line 20) | class TestTrigger(WatchmanTestCase.WatchmanTestCase):
    method requiresPersistentSession (line 21) | def requiresPersistentSession(self) -> bool:
    method hasTriggerInLogs (line 25) | def hasTriggerInLogs(self, root, triggerName) -> bool:
    method test_triggerIssue141 (line 35) | def test_triggerIssue141(self) -> None:
    method validate_trigger_output (line 71) | def validate_trigger_output(self, root, files, context) -> None:
    method test_legacyTrigger (line 111) | def test_legacyTrigger(self) -> None:

FILE: watchman/integration/test_trigger_chdir.py
  class TestTrigger (line 24) | class TestTrigger(WatchmanTestCase.WatchmanTestCase):
    method fileContains (line 25) | def fileContains(self, file_name, thing) -> bool:
    method fileHasValidJson (line 33) | def fileHasValidJson(self, file_name) -> bool:
    method checkOSApplicability (line 44) | def checkOSApplicability(self) -> None:
    method test_triggerChdir (line 48) | def test_triggerChdir(self) -> None:
    method test_triggerChdirRelativeRoot (line 78) | def test_triggerChdirRelativeRoot(self) -> None:
    method test_triggerMaxFiles (line 118) | def test_triggerMaxFiles(self) -> None:
    method test_triggerNamePerLine (line 173) | def test_triggerNamePerLine(self) -> None:
    method test_triggerNamePerLineRelativeRoot (line 202) | def test_triggerNamePerLineRelativeRoot(self) -> None:
    method test_triggerNamePerLineAppend (line 225) | def test_triggerNamePerLineAppend(self) -> None:
    method test_triggerJsonNameOnly (line 253) | def test_triggerJsonNameOnly(self) -> None:
    method test_triggerJsonNameAndSize (line 277) | def test_triggerJsonNameAndSize(self) -> None:

FILE: watchman/integration/test_trigger_error.py
  class TestTriggerError (line 15) | class TestTriggerError(WatchmanTestCase.WatchmanTestCase):
    method assertTriggerRegError (line 16) | def assertTriggerRegError(self, err, *args) -> None:
    method test_bad_args (line 21) | def test_bad_args(self) -> None:

FILE: watchman/integration/test_two_deep.py
  class TestTwoDeep (line 17) | class TestTwoDeep(WatchmanTestCase.WatchmanTestCase):
    method test_two_deep (line 18) | def test_two_deep(self) -> None:

FILE: watchman/integration/test_type.py
  class TestTypeExpr (line 17) | class TestTypeExpr(WatchmanTestCase.WatchmanTestCase):
    method test_type_expr (line 18) | def test_type_expr(self) -> None:

FILE: watchman/integration/test_watch_del_all.py
  class TestWatchDelAll (line 16) | class TestWatchDelAll(WatchmanTestCase.WatchmanTestCase):
    method test_watch_del_all (line 17) | def test_watch_del_all(self) -> None:

FILE: watchman/integration/test_watch_project.py
  function make_empty_watchmanconfig (line 17) | def make_empty_watchmanconfig(dir) -> None:
  class TestWatchProject (line 23) | class TestWatchProject(WatchmanTestCase.WatchmanTestCase):
    method runProjectTests (line 24) | def runProjectTests(
    method test_watchProject (line 79) | def test_watchProject(self) -> None:
    method test_watchProjectWatchmanConfig (line 91) | def test_watchProjectWatchmanConfig(self) -> None:
    method test_watchProjectEnforcing (line 107) | def test_watchProjectEnforcing(self) -> None:
    method test_reUseNestedWatch (line 123) | def test_reUseNestedWatch(self) -> None:

FILE: watchman/integration/test_wm_wait.py
  class TestWatchmanWait (line 19) | class TestWatchmanWait(WatchmanTestCase.WatchmanTestCase):
    method requiresPersistentSession (line 20) | def requiresPersistentSession(self) -> bool:
    method spawnWatchmanWait (line 23) | def spawnWatchmanWait(self, cmdArgs):
    method assertWaitedFileList (line 44) | def assertWaitedFileList(self, stdout, expected) -> None:
    method assertWaitForWmWaitWatch (line 49) | def assertWaitForWmWaitWatch(self, root) -> None:
    method test_wait (line 67) | def test_wait(self) -> None:
    method test_rel_root (line 91) | def test_rel_root(self) -> None:

FILE: watchman/java/src/com/facebook/watchman/Callback.java
  type Callback (line 12) | public interface Callback {
    method call (line 13) | void call(Map<String, Object> message) throws Exception;

FILE: watchman/java/src/com/facebook/watchman/CapabilitiesStrategy.java
  class CapabilitiesStrategy (line 20) | public class CapabilitiesStrategy {
    method checkWatchProjectCapability (line 28) | public static boolean checkWatchProjectCapability(WatchmanClient clien...

FILE: watchman/java/src/com/facebook/watchman/Deserializer.java
  type Deserializer (line 14) | public interface Deserializer {
    method deserialize (line 21) | Map<String, Object> deserialize(InputStream stream) throws IOException;

FILE: watchman/java/src/com/facebook/watchman/WatchmanClient.java
  type WatchmanClient (line 19) | public interface WatchmanClient {
    method clock (line 21) | ListenableFuture<Map<String, Object>> clock(Path path);
    method clock (line 22) | ListenableFuture<Map<String, Object>> clock(Path path, Number syncTime...
    method watch (line 24) | ListenableFuture<Map<String, Object>> watch(Path path);
    method watchDel (line 26) | ListenableFuture<Map<String,Object>> watchDel(Path path);
    method unsubscribe (line 28) | ListenableFuture<Boolean> unsubscribe(SubscriptionDescriptor descriptor);
    method subscribe (line 30) | ListenableFuture<SubscriptionDescriptor> subscribe(
    method version (line 35) | ListenableFuture<Map<String, Object>> version();
    method version (line 37) | ListenableFuture<Map<String, Object>> version(
    method run (line 41) | ListenableFuture<Map<String, Object>> run(List<Object> command);
    method unsubscribeAll (line 43) | ListenableFuture<Boolean> unsubscribeAll();
    method close (line 45) | void close() throws IOException;
    method start (line 47) | void start();
    class SubscriptionDescriptor (line 49) | @Value.Immutable
      method root (line 52) | public abstract String root();
      method name (line 53) | public abstract String name();
      method hashCode (line 55) | @Override

FILE: watchman/java/src/com/facebook/watchman/WatchmanClientImpl.java
  class WatchmanClientImpl (line 39) | public class WatchmanClientImpl implements WatchmanClient {
    method WatchmanClientImpl (line 51) | public WatchmanClientImpl(WatchmanTransport transport) throws IOExcept...
    method WatchmanClientImpl (line 65) | @VisibleForTesting
    method clock (line 79) | @Override
    method clock (line 87) | @Override
    method watch (line 97) | @Override
    method watchDel (line 112) | @Override
    method unsubscribe (line 120) | @Override
    method subscribe (line 148) | @Override
    method version (line 180) | @Override
    method version (line 186) | @Override
    method run (line 197) | @Override
    method unsubscribeAll (line 205) | @Override
    method close (line 230) | @Override
    method start (line 235) | @Override
    class UnilateralCallbackImpl (line 240) | private class UnilateralCallbackImpl implements Callback {
      method call (line 242) | @Override

FILE: watchman/java/src/com/facebook/watchman/WatchmanConnection.java
  class WatchmanConnection (line 35) | public class WatchmanConnection {
    method WatchmanConnection (line 49) | public WatchmanConnection(WatchmanTransport transport) throws IOExcept...
    method WatchmanConnection (line 59) | public WatchmanConnection(
    method WatchmanConnection (line 72) | public WatchmanConnection(
    method WatchmanConnection (line 86) | public WatchmanConnection(
    method WatchmanConnection (line 98) | public WatchmanConnection(
    method WatchmanConnection (line 111) | public WatchmanConnection(
    method WatchmanConnection (line 125) | public WatchmanConnection(
    method checkMessageUnilateral (line 154) | private boolean checkMessageUnilateral(Map<String, Object> response) {
    method run (line 162) | public ListenableFuture<Map<String, Object>> run(final Object command) {
    method failAllCommands (line 203) | private void failAllCommands(Exception e) {
    method close (line 211) | public void close() throws IOException {
    method start (line 222) | public void start() {
    class IncomingMessageThread (line 226) | private class IncomingMessageThread implements Runnable {
      method run (line 228) | @Override
    type QueuedCommand (line 263) | @Value.Immutable
      method command (line 266) | Object command();
      method latch (line 267) | CountDownLatch latch();
      method resultRef (line 268) | AtomicReference<Map<String, Object>> resultRef();
      method errorRef (line 269) | AtomicReference<Exception> errorRef();
    type WatchmanCommandListener (line 282) | public interface WatchmanCommandListener {
      method onStart (line 283) | void onStart();
      method onSent (line 284) | void onSent();
      method onReceived (line 285) | void onReceived();
    method incomingMessageGetterFromTransport (line 292) | private static Callable<Map<String, Object>> incomingMessageGetterFrom...

FILE: watchman/java/src/com/facebook/watchman/WatchmanException.java
  class WatchmanException (line 12) | public class WatchmanException extends Exception {
    method WatchmanException (line 16) | public WatchmanException() {
    method WatchmanException (line 21) | public WatchmanException(String reason) {
    method WatchmanException (line 26) | public WatchmanException(String error, Map<String, Object> response) {
    method getResponse (line 31) | public Map<String, Object> getResponse() {

FILE: watchman/java/src/com/facebook/watchman/WatchmanTransport.java
  type WatchmanTransport (line 14) | public interface WatchmanTransport extends Closeable {
    method getInputStream (line 15) | InputStream getInputStream();
    method getOutputStream (line 16) | OutputStream getOutputStream();

FILE: watchman/java/src/com/facebook/watchman/WatchmanTransportBuilder.java
  class WatchmanTransportBuilder (line 36) | public class WatchmanTransportBuilder {
    class BufferingOutputHandler (line 37) | private static class BufferingOutputHandler extends NuAbstractProcessH...
      method BufferingOutputHandler (line 44) | public BufferingOutputHandler() {
      method onStart (line 50) | @Override
      method onStdout (line 56) | @Override
      method getOutput (line 69) | public ByteBuffer getOutput() throws IOException {
    method discoverTransport (line 77) | public static WatchmanTransport discoverTransport() throws WatchmanTra...
    method discoverTransport (line 81) | public static WatchmanTransport discoverTransport(long duration, TimeU...
    method discoverTransport (line 92) | public static WatchmanTransport discoverTransport(Path watchmanPath, l...

FILE: watchman/java/src/com/facebook/watchman/WatchmanTransportUnavailableException.java
  class WatchmanTransportUnavailableException (line 10) | public class WatchmanTransportUnavailableException extends Exception {
    method WatchmanTransportUnavailableException (line 12) | public WatchmanTransportUnavailableException() {
    method WatchmanTransportUnavailableException (line 16) | public WatchmanTransportUnavailableException(String message) {
    method WatchmanTransportUnavailableException (line 20) | public WatchmanTransportUnavailableException(String message, Throwable...

FILE: watchman/java/src/com/facebook/watchman/bser/BserConstants.java
  class BserConstants (line 10) | public class BserConstants {
    method BserConstants (line 12) | private BserConstants() { }

FILE: watchman/java/src/com/facebook/watchman/bser/BserDeserializer.java
  class BserDeserializer (line 42) | public class BserDeserializer implements Deserializer {
    type KeyOrdering (line 43) | public enum KeyOrdering {
    class BserEofException (line 52) | @SuppressWarnings("serial")
      method BserEofException (line 54) | public BserEofException(String message) {
      method BserEofException (line 58) | public BserEofException(String message, Throwable cause) {
    method BserDeserializer (line 72) | public BserDeserializer(KeyOrdering keyOrdering) {
    method deserializeBserValue (line 92) | @Nullable
    method deserialize (line 105) | @SuppressWarnings("unchecked")
    method readBserBuffer (line 110) | private ByteBuffer readBserBuffer(InputStream inputStream) throws IOEx...
    method deserializeIntLen (line 181) | private int deserializeIntLen(ByteBuffer buffer, byte type) throws IOE...
    method deserializeNumber (line 198) | private Number deserializeNumber(ByteBuffer buffer, byte type) throws ...
    method deserializeString (line 213) | private String deserializeString(ByteBuffer buffer) throws IOException {
    method deserializeArray (line 233) | private List<Object> deserializeArray(ByteBuffer buffer) throws IOExce...
    method deserializeObject (line 246) | private Map<String, Object> deserializeObject(ByteBuffer buffer) throw...
    method deserializeTemplate (line 273) | private List<Map<String, Object>> deserializeTemplate(ByteBuffer buffe...
    method deserializeRecursive (line 301) | @Nullable
    method deserializeRecursiveWithType (line 307) | private Object deserializeRecursiveWithType(ByteBuffer buffer, byte ty...

FILE: watchman/java/src/com/facebook/watchman/bser/BserSerializer.java
  class BserSerializer (line 36) | public class BserSerializer {
    type BserIntegralEncodedSize (line 40) | private enum BserIntegralEncodedSize {
      method BserIntegralEncodedSize (line 48) | private BserIntegralEncodedSize(int size) {
    method BserSerializer (line 55) | public BserSerializer() {
    method serializeToStream (line 64) | public void serializeToStream(Object value, OutputStream outputStream)...
    method serializeToBuffer (line 89) | public ByteBuffer serializeToBuffer(Object value, ByteBuffer buffer) t...
    method appendRecursive (line 101) | @SuppressWarnings("unchecked")
    method appendString (line 160) | private static ByteBuffer appendString(
    method appendLong (line 177) | private static ByteBuffer appendLong(ByteBuffer buffer, long value) {
    method getEncodedSize (line 183) | private static BserIntegralEncodedSize getEncodedSize(long value) {
    method appendLongWithSize (line 198) | private static ByteBuffer appendLongWithSize(
    method increaseBufferCapacityIfNeeded (line 225) | private static ByteBuffer increaseBufferCapacityIfNeeded(ByteBuffer bu...
    method resizeBufferWithCapacity (line 238) | private static ByteBuffer resizeBufferWithCapacity(ByteBuffer buffer, ...

FILE: watchman/java/src/com/facebook/watchman/environment/ExecutableFinder.java
  class ExecutableFinder (line 31) | public class ExecutableFinder {
    method apply (line 48) | @Override
    method apply (line 55) | @Override
    method getExecutable (line 61) | public static Path getExecutable(
    method getOptionalExecutable (line 73) | public static Optional<Path> getOptionalExecutable(
    method getOptionalExecutable (line 79) | public static Optional<Path> getOptionalExecutable(
    method isExecutable (line 100) | private static boolean isExecutable(Path exe) {
    method getPaths (line 126) | private static ImmutableSet<Path> getPaths(ImmutableMap<String, String...
    method getExecutableSuffixes (line 155) | private static ImmutableSet<String> getExecutableSuffixes(ImmutableMap...
    method ExecutableFinder (line 172) | private ExecutableFinder() {}

FILE: watchman/java/src/com/facebook/watchman/environment/FileFinder.java
  class FileFinder (line 23) | public class FileFinder {
    method apply (line 28) | @Override
    method apply (line 38) | @Override
    method apply (line 48) | @Override
    method combine (line 61) | public static ImmutableSet<String> combine(
    method getOptionalFile (line 96) | public static Optional<Path> getOptionalFile(
    method getOptionalFile (line 109) | public static Optional<Path> getOptionalFile(
    method getOptionalFile (line 125) | public static Optional<Path> getOptionalFile(
    method getOptionalFile (line 138) | public static Optional<Path> getOptionalFile(
    method FileFinder (line 158) | private FileFinder() {}

FILE: watchman/java/src/com/facebook/watchman/unixsocket/ReferenceCountedFileDescriptor.java
  class ReferenceCountedFileDescriptor (line 40) | class ReferenceCountedFileDescriptor {
    method ReferenceCountedFileDescriptor (line 45) | public ReferenceCountedFileDescriptor(int fd) {
    method finalize (line 51) | @Override
    method acquire (line 56) | public synchronized int acquire() {
    method release (line 61) | public synchronized void release() throws IOException {
    method close (line 68) | public synchronized void close() throws IOException {
    method doClose (line 81) | private void doClose() throws IOException {

FILE: watchman/java/src/com/facebook/watchman/unixsocket/UnixDomainSocket.java
  class UnixDomainSocket (line 52) | public class UnixDomainSocket extends Socket implements WatchmanTransport {
    method createSocketWithPath (line 60) | public static UnixDomainSocket createSocketWithPath(Path path) throws ...
    method UnixDomainSocket (line 82) | private UnixDomainSocket(ReferenceCountedFileDescriptor fd) {
    method getInputStream (line 88) | @Override
    method getOutputStream (line 93) | @Override
    method shutdownInput (line 98) | @Override
    method shutdownOutput (line 103) | @Override
    method doShutdown (line 108) | private void doShutdown(int how) throws IOException {
    method close (line 121) | @Override
    method finalize (line 136) | @Override
    class UnixDomainSocketInputStream (line 141) | private class UnixDomainSocketInputStream extends InputStream {
      method read (line 142) | @Override
      method read (line 155) | @Override
      method doRead (line 168) | private int doRead(ByteBuffer buf) throws IOException {
    class UnixDomainSocketOutputStream (line 183) | private class UnixDomainSocketOutputStream extends OutputStream {
      method write (line 185) | @Override
      method write (line 192) | @Override
      method doWrite (line 201) | private void doWrite(ByteBuffer buf) throws IOException {

FILE: watchman/java/src/com/facebook/watchman/unixsocket/UnixDomainSocketLibrary.java
  class UnixDomainSocketLibrary (line 43) | class UnixDomainSocketLibrary {
    method UnixDomainSocketLibrary (line 52) | private UnixDomainSocketLibrary() { }
    method isBsdish (line 57) | private static boolean isBsdish() {
    class SockaddrUn (line 66) | public static class SockaddrUn extends Structure implements Structure....
      class SunLenAndFamily (line 71) | public static class SunLenAndFamily extends Structure {
        method getFieldOrder (line 75) | @Override
      class SunFamily (line 85) | public static class SunFamily extends Union {
      method SockaddrUn (line 96) | public SockaddrUn() {
      method SockaddrUn (line 110) | public SockaddrUn(String path) throws IOException {
      method getFieldOrder (line 131) | @Override
    method socket (line 141) | public static native int socket(int domain, int type, int protocol) th...
    method connect (line 142) | public static native int connect(int fd, SockaddrUn address, int addre...
    method bind (line 144) | public static native int bind(int fd, SockaddrUn address, int addressLen)
    method listen (line 146) | public static native int listen(int fd, int backlog) throws LastErrorE...
    method accept (line 147) | public static native int accept(int fd, SockaddrUn address, IntByRefer...
    method read (line 149) | public static native int read(int fd, ByteBuffer buffer, int count)
    method write (line 151) | public static native int write(int fd, ByteBuffer buffer, int count)
    method close (line 153) | public static native int close(int fd) throws LastErrorException;
    method shutdown (line 154) | public static native int shutdown(int fd, int how) throws LastErrorExc...

FILE: watchman/java/src/com/facebook/watchman/windowspipe/WindowsNamedPipe.java
  class WindowsNamedPipe (line 28) | public class WindowsNamedPipe implements WatchmanTransport {
    method WindowsNamedPipe (line 39) | public WindowsNamedPipe(String path) throws IOException {
    method close (line 69) | @Override
    method getInputStream (line 76) | @Override
    method getOutputStream (line 81) | @Override
    class NamedPipeOutputStream (line 86) | private class NamedPipeOutputStream extends OutputStream {
      method write (line 87) | @Override
      method write (line 92) | @Override
    class NamedPipeInputStream (line 116) | private class NamedPipeInputStream extends InputStream {
      method read (line 118) | @Override
      method read (line 125) | @Override

FILE: watchman/java/src/com/facebook/watchman/windowspipe/WindowsNamedPipeLibrary.java
  type WindowsNamedPipeLibrary (line 18) | public interface WindowsNamedPipeLibrary extends WinNT {
    method GetOverlappedResult (line 22) | boolean GetOverlappedResult(HANDLE hFile,
    method ReadFile (line 27) | boolean ReadFile(HANDLE hFile, Memory pointer, int nNumberOfBytesToRead,
    method CreateFile (line 30) | HANDLE CreateFile(String lpFileName, int dwDesiredAccess, int dwShareM...
    method CreateEvent (line 35) | HANDLE CreateEvent(WinBase.SECURITY_ATTRIBUTES lpEventAttributes,
    method CloseHandle (line 38) | boolean CloseHandle(HANDLE hObject);
    method WriteFile (line 40) | boolean WriteFile(HANDLE hFile, byte[] lpBuffer, int nNumberOfBytesToW...
    method GetLastError (line 44) | int GetLastError();

FILE: watchman/java/test/com/facebook/watchman/CapabilitiesTest.java
  class CapabilitiesTest (line 22) | public class CapabilitiesTest {
    method testWatchProjectVersionCalled (line 30) | @Test
    method testWatchProjectCapabilitySupported (line 59) | @Test
    method testWatchProjectCapabilityUnsupported (line 84) | @Test
    method testIntegration (line 103) | @Test

FILE: watchman/java/test/com/facebook/watchman/WatchmanClientTest.java
  class WatchmanClientTest (line 35) | public class WatchmanClientTest extends WatchmanTestBase {
    method setClient (line 44) | @Before
    method subscribeTriggersListenerTest (line 59) | @SuppressWarnings("unchecked")
    method watchProjectWithUnilateralTest (line 98) | @SuppressWarnings("unchecked")
    method watchProjectRequestTest (line 122) | @SuppressWarnings("unchecked")
    method watchDelRequestTest (line 143) | @SuppressWarnings("unchecked")
    method watchRequestTest (line 165) | @SuppressWarnings("unchecked")
    method subscribeRequestTest (line 182) | @SuppressWarnings("unchecked")
    method unsubscribeRequestTest (line 208) | @SuppressWarnings("unchecked")
    method clockRequestWithoutTimeoutTest (line 239) | @SuppressWarnings("unchecked")
    method clockRequestWithTimeoutTest (line 262) | @SuppressWarnings("unchecked")
    method versionRequestTestNoCapabilities (line 289) | @SuppressWarnings("unchecked")
    method versionRequestTestWithCapabilities (line 310) | @SuppressWarnings("unchecked")

FILE: watchman/java/test/com/facebook/watchman/WatchmanConnectionTest.java
  class WatchmanConnectionTest (line 43) | public class WatchmanConnectionTest extends WatchmanTestBase {
    method sendCommandTest (line 53) | @SuppressWarnings("unchecked")
    method singleCommandTest (line 71) | @Test
    method exceptionThrownTest (line 120) | @SuppressWarnings("ThrowableInstanceNeverThrown")
    method testUnilateralMessageBeforeResponse (line 146) | @Test
    method testCurrentRequestCanceled (line 219) | @Test
    method propagatesDeserializationException (line 293) | @Test
    method propagatesInterruptionException (line 326) | @Test

FILE: watchman/java/test/com/facebook/watchman/WatchmanTestBase.java
  class WatchmanTestBase (line 22) | public class WatchmanTestBase {
    method setUp (line 28) | @Before
    method deepObjectEquals (line 40) | @SuppressWarnings("unchecked")
    method deepObjectEquals (line 61) | @SuppressWarnings("unchecked")

FILE: watchman/java/test/com/facebook/watchman/bser/BserDeserializerTest.java
  class BserDeserializerTest (line 41) | @SuppressWarnings("unchecked")
    method getByteStream (line 74) | private static InputStream getByteStream(String base16) {
    method deserializeEmptyArray (line 78) | @Test
    method deserializeEmptyArrayTwiceReturnsSameArray (line 87) | @Test
    method deserializeArrayOfInt8 (line 97) | @Test
    method deserializeString (line 106) | @Test
    method sameStringDeserializedTwiceReturnsSameInstance (line 115) | @Test
    method deserializeEmptyMap (line 125) | @Test
    method deserializeEmptyMapTwiceReturnsSameMap (line 134) | @Test
    method deserializeUnsortedMapOfStringToInt8 (line 144) | @Test
    method deserializeSortedMapOfStringToInt8 (line 155) | @Test
    method deserializeTemplate (line 166) | @Test
    method deserializeInt8 (line 191) | @Test
    method sameInt8DeserializedTwiceReturnsSameInstance (line 198) | @Test
    method deserializeInt16 (line 207) | @Test
    method deserializeInt32 (line 215) | @Test
    method deserializeInt64 (line 223) | @Test
    method deserializeReal (line 231) | @Test
    method deserializeTrue (line 239) | @Test
    method deserializeFalse (line 246) | @Test
    method deserializeNull (line 253) | @Test
    method throwIfSniffLengthTooShort (line 260) | @Test
    method throwIfInvalidHeader (line 268) | @Test
    method throwIfInvalidHeaderLengthType (line 276) | @Test
    method throwIfHeaderLengthIsNegative (line 284) | @Test
    method throwIfBodyLengthIsOverMaxInt (line 292) | @Test
    method throwIfHeaderLengthTooShort (line 300) | @Test
    method throwIfRemainingLengthTooShort (line 308) | @Test
    method throwIfStringNotUTF8 (line 316) | @Test
    method throwIfArrayLengthTooShort (line 323) | @Test
    method throwIfMapLengthTooShort (line 331) | @Test
    method throwIfMapKeyNotString (line 339) | @Test

FILE: watchman/java/test/com/facebook/watchman/bser/BserSerializerTest.java
  class BserSerializerTest (line 35) | public class BserSerializerTest {
    method setUp (line 106) | @Before
    method assertEncodingMatches (line 111) | private ByteBuffer assertEncodingMatches(Object object, String base16)...
    method serializeEmptyArray (line 126) | @Test
    method serializeArrayOfInt8 (line 131) | @Test
    method serializeString (line 138) | @Test
    method serializeEmptyMap (line 143) | @Test
    method serializeInt8Map (line 148) | @Test
    method serializeInt8 (line 158) | @Test
    method serializeInt16 (line 163) | @Test
    method serializeInt32 (line 168) | @Test
    method serializeInt64 (line 173) | @Test
    method serializeMinInt8 (line 178) | @Test
    method serializeMinInt16 (line 183) | @Test
    method serializeMinInt32 (line 188) | @Test
    method serializeMinInt64 (line 193) | @Test
    method serializeReal (line 198) | @Test
    method serializeTrue (line 203) | @Test
    method serializeFalse (line 208) | @Test
    method serializeNull (line 213) | @Test
    method throwIfStringNotUTF8 (line 218) | @Test
    method throwIfMapKeyNotString (line 226) | @Test
    method smallObjectReusesInputBuffer (line 234) | @Test
    method largeObjectAllocatesNewBuffer (line 241) | @Test
    method serializeTrueToStream (line 248) | @Test

FILE: watchman/java/test/com/facebook/watchman/environment/ExecutableFinderTest.java
  class ExecutableFinderTest (line 30) | public class ExecutableFinderTest {
    method testSearchPathsFileFoundReturnsPath (line 34) | @Test
    method testSearchPathsNonExecutableFileIsIgnored (line 49) | @Test
    method testSearchPathsDirAndFileFoundReturnsFileNotDir (line 66) | @Test
    method testSearchPathsMultipleFileFoundReturnsFirstPath (line 82) | @Test
    method testSearchPathsSymlinkToExecutableInsidePathReturnsPath (line 98) | @Test
    method testSearchPathsSymlinkToExecutableOutsideSearchPathReturnsPath (line 113) | @Test
    method testSearchPathsFileNotFoundReturnsAbsent (line 131) | @Test
    method testSearchPathsEmptyReturnsAbsent (line 145) | @Test
    method testSearchPathsWithIsExecutableFunctionFailure (line 155) | @Test
    method testSearchPathsWithExtensions (line 173) | @Test
    method testSearchPathsWithExtensionsNoMatch (line 186) | @Test
    method testThatADirectoryIsNotConsideredAnExecutable (line 199) | @Test
    method createExecutable (line 212) | private Path createExecutable(String executablePath) throws IOException {
    method makeExecutable (line 218) | public static void makeExecutable(Path file) throws IOException {

FILE: watchman/java/test/com/facebook/watchman/environment/FileFinderTest.java
  class FileFinderTest (line 24) | public class FileFinderTest {
    method combine (line 28) | @Test
    method firstMatchInPath (line 55) | @Test
    method matchAny (line 67) | @Test
    method noMatch (line 92) | @Test

FILE: watchman/java/test/com/facebook/watchman/fakes/FakeWatchmanClient.java
  class FakeWatchmanClient (line 21) | public class FakeWatchmanClient implements WatchmanClient {
    method clock (line 23) | @Override
    method clock (line 28) | @Override
    method watch (line 33) | @Override
    method watchDel (line 38) | @Override
    method unsubscribe (line 43) | @Override
    method subscribe (line 48) | @Override
    method version (line 54) | @Override
    method version (line 59) | @Override
    method run (line 65) | @Override
    method unsubscribeAll (line 70) | @Override
    method close (line 75) | @Override
    method start (line 80) | @Override

FILE: watchman/java/test/com/facebook/watchman/util/TemporaryPaths.java
  class TemporaryPaths (line 20) | public class TemporaryPaths extends ExternalResource {
    method TemporaryPaths (line 25) | public TemporaryPaths() {
    method TemporaryPaths (line 29) | public TemporaryPaths(boolean keepContents) {
    method before (line 33) | @Override
    method getRoot (line 38) | public Path getRoot() {
    method newFolder (line 42) | public Path newFolder() throws IOException {
    method after (line 46) | @Override
    method newFile (line 79) | public Path newFile(String fileName) throws IOException {
    method newFile (line 90) | public Path newFile() throws IOException {
    method newFolder (line 94) | public Path newFolder(String... name) throws IOException {

FILE: watchman/listener-user.cpp
  function UntypedResponse (line 23) | static UntypedResponse cmd_shutdown(Client*, const json_ref&) {
  function add_root_warnings_to_response (line 37) | void add_root_warnings_to_response(
  function doResolveOrCreateRoot (line 60) | std::shared_ptr<Root>
  function resolveRootByName (line 78) | std::shared_ptr<Root>
  function resolveRoot (line 115) | std::shared_ptr<Root> resolveRoot(Client* client, const json_ref& args) {
  function resolveOrCreateRoot (line 119) | std::shared_ptr<Root> resolveOrCreateRoot(

FILE: watchman/listener.cpp
  function w_listener_prep_inetd (line 51) | void w_listener_prep_inetd() {
  function FileDescriptor (line 66) | static FileDescriptor get_listener_unix_domain_socket(const char* path) {
  function FileDescriptor (line 172) | static FileDescriptor create_pipe_server(const char* path) {
  function named_pipe_accept_loop_internal (line 186) | static void named_pipe_accept_loop_internal(
  function named_pipe_accept_loop (line 256) | static void named_pipe_accept_loop() {
  class AcceptLoop (line 278) | class AcceptLoop {
    method AcceptLoop (line 283) | AcceptLoop(std::string name, FileDescriptor&& fd) {
    method AcceptLoop (line 298) | AcceptLoop(const AcceptLoop&) = delete;
    method AcceptLoop (line 299) | AcceptLoop& operator=(const AcceptLoop&) = delete;
    method AcceptLoop (line 301) | AcceptLoop(AcceptLoop&& other) {
    method AcceptLoop (line 305) | AcceptLoop& operator=(AcceptLoop&& other) {
    method join (line 320) | void join() {
    method accept_thread (line 329) | static void accept_thread(
  function w_start_listener (line 385) | bool w_start_listener() {
  function UntypedResponse (line 573) | static UntypedResponse cmd_get_pid(Client*, const json_ref&) {

FILE: watchman/main.cpp
  function detect_low_process_priority (line 86) | void detect_low_process_priority() {
  function detect_starting_command (line 112) | std::optional<std::string> detect_starting_command(pid_t ppid) {
  function run_service (line 129) | [[noreturn]] static void run_service(ProcessLock::Handle&&, pid_t ppid) {
  function close_random_fds (line 228) | static void close_random_fds() {
  function run_service_in_foreground (line 275) | [[noreturn]] static void run_service_in_foreground() {
  type SpawnResult (line 285) | struct [[nodiscard]] SpawnResult {
    type Status (line 286) | enum Status {
    method SpawnResult (line 291) | SpawnResult() = delete;
    method SpawnResult (line 293) | SpawnResult(Status s, std::string r = {})
    method exitIfFailed (line 296) | void exitIfFailed() {
  function SpawnResult (line 316) | static SpawnResult run_service_as_daemon() {
    type Status (line 286) | enum Status {
    method SpawnResult (line 291) | SpawnResult() = delete;
    method SpawnResult (line 293) | SpawnResult(Status s, std::string r = {})
    method exitIfFailed (line 296) | void exitIfFailed() {
  function SpawnResult (line 359) | static SpawnResult spawn_win32(const std::vector<std::string>& daemon_ar...
    type Status (line 286) | enum Status {
    method SpawnResult (line 291) | SpawnResult() = delete;
    method SpawnResult (line 293) | SpawnResult(Status s, std::string r = {})
    method exitIfFailed (line 296) | void exitIfFailed() {
  function SpawnResult (line 399) | static SpawnResult spawn_site_specific(
    type Status (line 286) | enum Status {
    method SpawnResult (line 291) | SpawnResult() = delete;
    method SpawnResult (line 293) | SpawnResult(Status s, std::string r = {})
    method exitIfFailed (line 296) | void exitIfFailed() {
  function escape_args_for_sh (line 456) | std::vector<std::string> escape_args_for_sh(
  function prep_args_for_plist (line 467) | std::string prep_args_for_plist(
  function SpawnResult (line 479) | static SpawnResult spawn_via_launchd() {
    type Status (line 286) | enum Status {
    method SpawnResult (line 291) | SpawnResult() = delete;
    method SpawnResult (line 293) | SpawnResult(Status s, std::string r = {})
    method exitIfFailed (line 296) | void exitIfFailed() {
  function parse_encoding (line 616) | static void parse_encoding(std::string_view enc, PduType* pdu) {
  function initialize_winsock (line 637) | bool initialize_winsock() {
  function initialize_uds (line 646) | bool initialize_uds() {
  function setup_sock_name (line 666) | static void setup_sock_name() {
  function try_command (line 746) | static ResultErrno<folly::Unit> try_command(
  function try_client_mode_command (line 771) | static bool try_client_mode_command(const Command& command, bool pretty) {
  function parse_cmdline (line 788) | static std::vector<std::string> parse_cmdline(int* argcp, char*** argvp) {
  function Command (line 810) | static Command build_command_from_stdin() {
  function Command (line 850) | static Command build_command(int argc, char** argv) {
  function SpawnResult (line 872) | static SpawnResult try_spawn_watchman(
    type Status (line 286) | enum Status {
    method SpawnResult (line 291) | SpawnResult() = delete;
    method SpawnResult (line 293) | SpawnResult(Status s, std::string r = {})
    method exitIfFailed (line 296) | void exitIfFailed() {
  function inner_main (line 911) | static int inner_main(int argc, char** argv) {
  function main (line 1038) | int main(int argc, char** argv) {

FILE: watchman/node/bser/index.js
  function nextPow2 (line 20) | function nextPow2(size) {
  function Accumulator (line 25) | function Accumulator(initsize) {
  function BunserBuf (line 220) | function BunserBuf() {
  function loadFromBuffer (line 439) | function loadFromBuffer(input) {
  function byteswap64 (line 456) | function byteswap64(buf) {
  function dump_int64 (line 464) | function dump_int64(buf, val) {
  function dump_int (line 481) | function dump_int(buf, val) {
  function dump_any (line 497) | function dump_any(buf, val) {
  function dumpToBuffer (line 570) | function dumpToBuffer(val) {

FILE: watchman/node/bser/test/bser.js
  function roundtrip (line 26) | function roundtrip(val) {

FILE: watchman/node/bser/test_bser.py
  class BserTestCase (line 22) | class BserTestCase(unittest.TestCase):
    method runTest (line 26) | def runTest(self):

FILE: watchman/node/index.js
  class WatchmanError (line 46) | class WatchmanError extends Error {
  class Client (line 56) | class Client extends EventEmitter {
    method constructor (line 64) | constructor(options /*: Options */) {
    method sendNextCommand (line 75) | sendNextCommand() {
    method cancelCommands (line 97) | cancelCommands(why /*: string*/) {
    method connect (line 116) | connect() {
    method command (line 277) | command(args /*: mixed*/, done /*: CommandCallback */ = () => {}) {
    method _synthesizeCapabilityCheck (line 296) | _synthesizeCapabilityCheck /*:: <T: { capabilities?: ?{[key: string]: ...
    method capabilityCheck (line 320) | capabilityCheck(
    method end (line 356) | end() {
  function vers_compare (line 376) | function vers_compare(aStr /*:string*/, bStr /*:string*/) {
  function have_cap (line 388) | function have_cap(vers /*:string */, name /*:string*/) {

FILE: watchman/portability/Backtrace.cpp
  function sym_init (line 41) | static void sym_init() {
  function backtrace (line 49) | size_t backtrace(void** frames, size_t n_frames) {
  function backtrace_from_exception (line 131) | size_t backtrace_from_exception(

FILE: watchman/portability/Backtrace.h
  type _EXCEPTION_POINTERS (line 17) | struct _EXCEPTION_POINTERS

FILE: watchman/portability/PosixSpawn.cpp
  function pid_t (line 23) | pid_t waitpid(pid_t pid, int* status, int options) {
  function posix_spawnattr_init (line 58) | int posix_spawnattr_init(posix_spawnattr_t* attrp) {
  function posix_spawnattr_setflags (line 63) | int posix_spawnattr_setflags(posix_spawnattr_t* attrp, short flags) {
  function posix_spawnattr_getflags (line 68) | int posix_spawnattr_getflags(posix_spawnattr_t* attrp, short* flags) {
  function posix_spawnattr_setcwd_np (line 73) | int posix_spawnattr_setcwd_np(posix_spawnattr_t* attrp, const char* path) {
  function posix_spawnattr_destroy (line 88) | int posix_spawnattr_destroy(posix_spawnattr_t* attrp) {
  function posix_spawn_file_actions_init (line 93) | int posix_spawn_file_actions_init(posix_spawn_file_actions_t* actions) {
  function posix_spawn_file_actions_adddup2 (line 98) | int posix_spawn_file_actions_adddup2(
  function posix_spawn_file_actions_adddup2_handle_np (line 117) | int posix_spawn_file_actions_adddup2_handle_np(
  function posix_spawn_file_actions_addopen (line 136) | int posix_spawn_file_actions_addopen(
  function posix_spawn_file_actions_destroy (line 165) | int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* actions) {
  function posix_spawn_common (line 270) | static int posix_spawn_common(
  function posix_spawn (line 479) | int posix_spawn(
  function posix_spawnp (line 489) | int posix_spawnp(

FILE: watchman/portability/PosixSpawn.h
  type posix_spawnattr_t (line 21) | typedef struct _posix_spawnattr {
  type _posix_spawn_file_action (line 36) | struct _posix_spawn_file_action {
  type posix_spawn_file_actions_t (line 50) | typedef struct _posix_spawn_file_actions {

FILE: watchman/portability/WinError.cpp
  function map_win32_err (line 29) | int map_win32_err(uint32_t err) {

FILE: watchman/python/pywatchman/__init__.py
  function log (line 79) | def log(fmt, *args):
  function log (line 88) | def log(fmt, *args):
  function _win32_strerror (line 92) | def _win32_strerror(err):
  class WatchmanError (line 114) | class WatchmanError(Exception):
    method __init__ (line 126) | def __init__(self, msg=None, cmd=None):
    method setCommand (line 130) | def setCommand(self, cmd):
    method __str__ (line 133) | def __str__(self):
  class BSERv1Unsupported (line 139) | class BSERv1Unsupported(WatchmanError):
  class UseAfterFork (line 143) | class UseAfterFork(WatchmanError):
  class WatchmanEnvironmentError (line 147) | class WatchmanEnvironmentError(WatchmanError):
    method __init__ (line 148) | def __init__(self, msg, errno, errmsg, cmd=None):
  class SocketConnectError (line 154) | class SocketConnectError(WatchmanError):
    method __init__ (line 155) | def __init__(self, sockpath, exc):
  class SocketTimeout (line 163) | class SocketTimeout(WatchmanError):
  class CommandError (line 173) | class CommandError(WatchmanError):
    method __init__ (line 179) | def __init__(self, msg, cmd=None):
  function is_named_pipe_path (line 183) | def is_named_pipe_path(path: str) -> bool:
  class SockPath (line 188) | class SockPath:
    method __init__ (line 195) | def __init__(
    method legacy_sockpath (line 212) | def legacy_sockpath(self):
  class Transport (line 221) | class Transport:
    method close (line 226) | def close(self):
    method readBytes (line 230) | def readBytes(self, size):
    method write (line 234) | def write(self, buf):
    method setTimeout (line 238) | def setTimeout(self, value):
    method readLine (line 241) | def readLine(self):
  class Codec (line 266) | class Codec:
    method __init__ (line 271) | def __init__(self, transport):
    method receive (line 274) | def receive(self):
    method send (line 277) | def send(self, *args):
    method setTimeout (line 280) | def setTimeout(self, value):
  class SocketTransport (line 284) | class SocketTransport(Transport):
    method __init__ (line 290) | def __init__(self):
    method close (line 293) | def close(self):
    method setTimeout (line 298) | def setTimeout(self, value):
    method readBytes (line 302) | def readBytes(self, size):
    method write (line 311) | def write(self, data):
  class UnixSocketTransport (line 319) | class UnixSocketTransport(SocketTransport):
    method __init__ (line 322) | def __init__(self, sockpath, timeout):
  class WindowsUnixSocketTransport (line 337) | class WindowsUnixSocketTransport(SocketTransport):
    method __init__ (line 343) | def __init__(self, sockpath, timeout):
  class TcpSocketTransport (line 360) | class TcpSocketTransport(SocketTransport):
    method __init__ (line 363) | def __init__(self, sockpath, timeout):
  function _get_overlapped_result_ex_impl (line 393) | def _get_overlapped_result_ex_impl(pipe, olap, nbytes, millis, alertable):
  class WindowsNamedPipeTransport (line 433) | class WindowsNamedPipeTransport(Transport):
    method __init__ (line 436) | def __init__(self, sockpath, timeout):
    method _raise_win_err (line 475) | def _raise_win_err(self, msg, err):
    method _make_win_err (line 478) | def _make_win_err(self, msg, err):
    method close (line 481) | def close(self):
    method setTimeout (line 492) | def setTimeout(self, value):
    method readBytes (line 496) | def readBytes(self, size):
    method write (line 564) | def write(self, data):
  function _default_binpath (line 599) | def _default_binpath(binpath=None) -> str:
  class CLIProcessTransport (line 608) | class CLIProcessTransport(Transport):
    method __init__ (line 631) | def __init__(self, sockpath, timeout, binpath=None):
    method close (line 636) | def close(self):
    method _connect (line 645) | def _connect(self):
    method readBytes (line 665) | def readBytes(self, size):
    method write (line 673) | def write(self, data):
  class BserCodec (line 685) | class BserCodec(Codec):
    method __init__ (line 688) | def __init__(self, transport, value_encoding, value_errors):
    method _loads (line 693) | def _loads(self, response):
    method receive (line 700) | def receive(self):
    method send (line 719) | def send(self, *args):
  class ImmutableBserCodec (line 724) | class ImmutableBserCodec(BserCodec):
    method _loads (line 728) | def _loads(self, response):
  class Bser2WithFallbackCodec (line 737) | class Bser2WithFallbackCodec(BserCodec):
    method __init__ (line 740) | def __init__(self, transport, value_encoding, value_errors):
    method receive (line 763) | def receive(self):
    method send (line 787) | def send(self, *args):
  class ImmutableBser2Codec (line 797) | class ImmutableBser2Codec(Bser2WithFallbackCodec, ImmutableBserCodec):
  class JsonCodec (line 804) | class JsonCodec(Codec):
    method __init__ (line 809) | def __init__(self, transport):
    method receive (line 816) | def receive(self):
    method send (line 830) | def send(self, *args):
  class client (line 839) | class client:
    method __init__ (line 856) | def __init__(
    method _makeBSERCodec (line 929) | def _makeBSERCodec(self, codec):
    method _parseEncoding (line 935) | def _parseEncoding(self, enc):
    method _hasprop (line 951) | def _hasprop(self, result, name):
    method _resolvesockname (line 956) | def _resolvesockname(self):
    method _connect (line 1009) | def _connect(self):
    method __del__ (line 1031) | def __del__(self):
    method __enter__ (line 1034) | def __enter__(self):
    method __exit__ (line 1038) | def __exit__(self, exc_type, exc_value, exc_traceback):
    method close (line 1041) | def close(self):
    method receive (line 1048) | def receive(self):
    method isUnilateralResponse (line 1087) | def isUnilateralResponse(self, res):
    method getLog (line 1096) | def getLog(self, remove=True):
    method getSubscription (line 1107) | def getSubscription(self, name, remove=True, root=None):
    method query (line 1142) | def query(self, *args):
    method capabilityCheck (line 1174) | def capabilityCheck(self, optional=None, required=None):
    method listCapabilities (line 1188) | def listCapabilities(self):
    method setTimeout (line 1191) | def setTimeout(self, value):

FILE: watchman/python/pywatchman/bser.c
  function Py_ssize_t (line 10) | static Py_ssize_t bserobj_tuple_length(PyObject* o) {
  function PyObject (line 16) | static PyObject* bserobj_tuple_item(PyObject* o, Py_ssize_t i) {
  function bserobj_dealloc (line 35) | static void bserobj_dealloc(PyObject* o) {
  function PyObject (line 43) | static PyObject* bserobj_getattrro(PyObject* o, PyObject* name) {
  function bunser_int (line 164) | int bunser_int(const char** ptr, const char* end, int64_t* val) {
  function bunser_bytestring (line 222) | static int bunser_bytestring(
  function PyObject (line 245) | static PyObject*
  function PyObject (line 301) | static PyObject*
  function PyObject (line 394) | static PyObject*
  function PyObject (line 524) | PyObject* bser_loads_recursive(

FILE: watchman/python/pywatchman/bser.h
  type bserObject (line 44) | typedef struct {
  type unser_ctx_t (line 52) | typedef struct loads_ctx {

FILE: watchman/python/pywatchman/bsermodule.c
  type __int8 (line 18) | typedef __int8 int8_t;
  type __int16 (line 19) | typedef __int16 int16_t;
  type __int32 (line 20) | typedef __int32 int32_t;
  type __int64 (line 21) | typedef __int64 int64_t;
  function next_power_2 (line 47) | static inline uint32_t next_power_2(uint32_t n) {
  type bser_buffer (line 57) | struct bser_buffer {
  type bser_t (line 64) | typedef struct bser_buffer bser_t;
  function bser_append (line 66) | static int bser_append(bser_t* bser, const char* data, uint32_t len) {
  function bser_init (line 96) | static int bser_init(bser_t* bser, uint32_t version, uint32_t capabiliti...
  function bser_dtor (line 123) | static void bser_dtor(bser_t* bser) {
  function bser_long (line 128) | static int bser_long(bser_t* bser, int64_t val) {
  function bser_bytestring (line 170) | static int bser_bytestring(bser_t* bser, PyObject* sval) {
  function bser_recursive (line 213) | static int bser_recursive(bser_t* bser, PyObject* val) {
  function PyObject (line 324) | static PyObject* bser_dumps(PyObject* self, PyObject* args, PyObject* kw) {
  function _pdu_info_helper (line 374) | static int _pdu_info_helper(
  function pdu_info_helper (line 423) | static int pdu_info_helper(
  function PyObject (line 462) | static PyObject* bser_pdu_info(PyObject* self, PyObject* args) {
  function PyObject (line 471) | static PyObject* bser_pdu_len(PyObject* self, PyObject* args) {
  function PyObject (line 480) | static PyObject* bser_loads(PyObject* self, PyObject* args, PyObject* kw) {
  function PyObject (line 544) | static PyObject* bser_load(PyObject* self, PyObject* args, PyObject* kw) {
  type PyModuleDef (line 643) | struct PyModuleDef
  function PyMODINIT_FUNC (line 652) | PyMODINIT_FUNC PyInit_bser(void) {
  function PyMODINIT_FUNC (line 662) | PyMODINIT_FUNC initbser(void) {

FILE: watchman/python/pywatchman/capabilities.py
  function parse_version (line 9) | def parse_version(vstr) -> int:
  function check (line 27) | def check(version, name: str):
  function synthesize (line 33) | def synthesize(vers, opts):

FILE: watchman/python/pywatchman/encoding.py
  function get_local_encoding (line 19) | def get_local_encoding() -> str:
  function encode_local (line 28) | def encode_local(s):
  function decode_local (line 32) | def decode_local(bs):

FILE: watchman/python/pywatchman/load.py
  function _read_bytes (line 21) | def _read_bytes(fp, buf):
  function load (line 45) | def load(fp, mutable: bool = True, value_encoding=None, value_errors=None):

FILE: watchman/python/pywatchman/pybser.py
  function tobytes (line 34) | def tobytes(i):
  function _int_size (line 47) | def _int_size(x) -> int:
  function _buf_pos (line 61) | def _buf_pos(buf, pos) -> bytes:
  class _bser_buffer (line 69) | class _bser_buffer:
    method __init__ (line 70) | def __init__(self, version):
    method ensure_size (line 85) | def ensure_size(self, size):
    method append_long (line 94) | def append_long(self, val):
    method append_string (line 110) | def append_string(self, s):
    method append_recursive (line 161) | def append_recursive(self, val):
  function dumps (line 247) | def dumps(obj, version: int = 1, capabilities: int = 0):
  class _BunserDict (line 268) | class _BunserDict:
    method __init__ (line 271) | def __init__(self, keys, values):
    method __getattr__ (line 275) | def __getattr__(self, name):
    method __getitem__ (line 278) | def __getitem__(self, key):
    method __len__ (line 290) | def __len__(self):
  class Bunser (line 294) | class Bunser:
    method __init__ (line 295) | def __init__(self, mutable=True, value_encoding=None, value_errors=None):
    method unser_int (line 307) | def unser_int(buf, pos):
    method unser_utf8_string (line 332) | def unser_utf8_string(self, buf, pos):
    method unser_bytestring (line 337) | def unser_bytestring(self, buf, pos):
    method unser_array (line 345) | def unser_array(self, buf, pos):
    method unser_object (line 357) | def unser_object(self, buf, pos):
    method unser_template (line 379) | def unser_template(self, buf, pos):
    method loads_recursive (line 413) | def loads_recursive(self, buf, pos):
  function _pdu_info_helper (line 448) | def _pdu_info_helper(buf):
  function pdu_info (line 466) | def pdu_info(buf):
  function pdu_len (line 471) | def pdu_len(buf):
  function loads (line 476) | def loads(buf, mutable: bool = True, value_encoding=None, value_errors=N...
  function load (line 511) | def load(fp, mutable: bool = True, value_encoding=None, value_errors=None):

FILE: watchman/python/pywatchman/windows.py
  class OVERLAPPED (line 43) | class OVERLAPPED(ctypes.Structure):
    method __init__ (line 52) | def __init__(self):
  class WSAData64 (line 193) | class WSAData64(ctypes.Structure):
  class SOCKADDR_UN (line 210) | class SOCKADDR_UN(ctypes.Structure):
  class WindowsSocketException (line 214) | class WindowsSocketException(Exception):
    method __init__ (line 215) | def __init__(self, code: int) -> None:
  class WindowsSocketHandle (line 221) | class WindowsSocketHandle:
    method _checkReturnCode (line 229) | def _checkReturnCode(retcode):
    method __init__ (line 236) | def __init__(self):
    method fileno (line 248) | def fileno(self) -> int:
    method settimeout (line 251) | def settimeout(self, timeout: int) -> None:
    method connect (line 271) | def connect(self, address: str) -> None:
    method send (line 280) | def send(self, buff: bytes) -> int:
    method sendall (line 285) | def sendall(self, buff: bytes) -> None:
    method recv (line 294) | def recv(self, size: int) -> bytes:
    method getpeername (line 300) | def getpeername(self) -> str:
    method getsockname (line 303) | def getsockname(self) -> str:
    method close (line 306) | def close(self) -> int:

FILE: watchman/python/pywatchman_aio/__init__.py
  function _resolve_sockname_helper (line 33) | def _resolve_sockname_helper():
  function _resolve_sockname (line 66) | async def _resolve_sockname():
  class AsyncTransport (line 72) | class AsyncTransport:
    method activate (line 75) | async def activate(self, **kwargs):
    method read (line 79) | async def read(self, size):
    method write (line 83) | async def write(self, buf):
    method close (line 87) | def close(self):
  class AsyncUnixSocketTransport (line 92) | class AsyncUnixSocketTransport(AsyncTransport):
    method __init__ (line 95) | def __init__(self):
    method activate (line 100) | async def activate(self, **kwargs):
    method write (line 106) | async def write(self, data):
    method read (line 110) | async def read(self, size):
    method close (line 116) | def close(self):
  class AsyncCodec (line 121) | class AsyncCodec:
    method __init__ (line 124) | def __init__(self, transport):
    method receive (line 127) | async def receive(self):
    method send (line 131) | async def send(self, *args):
    method close (line 135) | def close(self):
  class AsyncBserCodec (line 142) | class AsyncBserCodec(AsyncCodec):
    method receive (line 145) | async def receive(self):
    method send (line 164) | async def send(self, *args):
    method _loads (line 168) | def _loads(self, response):
  class ReceiveLoopError (line 178) | class ReceiveLoopError(Exception):
  class AIOClient (line 182) | class AIOClient:
    method __init__ (line 201) | def __init__(self, connection):
    method __enter__ (line 210) | def __enter__(self):
    method __exit__ (line 213) | def __exit__(self, type, value, traceback):
    method receive_bilateral_response (line 217) | async def receive_bilateral_response(self):
    method query (line 225) | async def query(self, *args):
    method capability_check (line 236) | async def capability_check(self, optional=None, required=None):
    method get_subscription (line 245) | async def get_subscription(self, name, root):
    method pop_log (line 261) | async def pop_log(self):
    method close (line 268) | def close(self):
    method enable_receiving (line 276) | def enable_receiving(self, loop=None):
    method from_socket (line 292) | async def from_socket(cls, sockname: typing.Optional[str] = None) -> "...
    method _receive_loop (line 309) | async def _receive_loop(self):
    method _broadcast_exception (line 330) | async def _broadcast_exception(self, ex):
    method _check_error (line 337) | def _check_error(self, res):
    method _check_receive_loop (line 343) | def _check_receive_loop(self):
    method _is_unilateral (line 349) | def _is_unilateral(self, res):
    method _ensure_subscription_queue_exists (line 352) | def _ensure_subscription_queue_exists(self, name, root):
    method _process_unilateral_response (line 357) | async def _process_unilateral_response(self, response):

FILE: watchman/python/tests/tests.py
  class TestSocketTimeout (line 44) | class TestSocketTimeout(unittest.TestCase):
    method test_exception_handling (line 45) | def test_exception_handling(self):
  class TestTransportErrorHandling (line 52) | class TestTransportErrorHandling(unittest.TestCase):
    method test_transport_error (line 53) | def test_transport_error(self):
  class TestLocalTransport (line 100) | class TestLocalTransport(unittest.TestCase):
    method test_missing_socket_file_raises_connect_error (line 101) | def test_missing_socket_file_raises_connect_error(self):
    method make_deleted_socket_path (line 108) | def make_deleted_socket_path(self):
    method make_deleted_windows_socket_path (line 116) | def make_deleted_windows_socket_path(self):
    method make_deleted_unix_socket_path (line 119) | def make_deleted_unix_socket_path(self):
  function expand_bser_mods (line 124) | def expand_bser_mods(test_class):
  class FakeFile (line 156) | class FakeFile:
    method __init__ (line 157) | def __init__(self, data):
    method readinto (line 161) | def readinto(self, buf):
  class TestBSERDump (line 171) | class TestBSERDump(unittest.TestCase):
    method setUp (line 172) | def setUp(self):
    method raw (line 175) | def raw(self, structured_input, bser_output):
    method roundtrip (line 179) | def roundtrip(self, val, mutable=True, value_encoding=None, value_erro...
    method munged (line 194) | def munged(self, val, munged, value_encoding=None, value_errors=None):
    method test_raw (line 203) | def test_raw(self):
    method test_int (line 223) | def test_int(self):
    method test_negative_int (line 230) | def test_negative_int(self):
    method test_float (line 236) | def test_float(self):
    method test_bool (line 239) | def test_bool(self):
    method test_none (line 243) | def test_none(self):
    method test_string (line 246) | def test_string(self):
    method test_list (line 288) | def test_list(self):
    method test_tuple (line 292) | def test_tuple(self):
    method test_dict (line 296) | def test_dict(self):
    method assertItemAttributes (line 339) | def assertItemAttributes(self, dictish, attrish):
    method test_template (line 345) | def test_template(self):
    method test_pdu_info (line 367) | def test_pdu_info(self):
    method test_pdu_len (line 385) | def test_pdu_len(self):
    method test_garbage (line 395) | def test_garbage(self):
    method test_string_lengths (line 404) | def test_string_lengths(self):
    method test_big_string_lengths (line 422) | def test_big_string_lengths(self):
    method test_fuzz_examples (line 431) | def test_fuzz_examples(self):

FILE: watchman/query/FileResult.cpp
  type watchman (line 10) | namespace watchman {

FILE: watchman/query/FileResult.h
  type NotSymlink (line 18) | struct NotSymlink {}
  function Properties (line 85) | enum Property : Properties {

FILE: watchman/query/GlobEscaping.cpp
  type watchman (line 11) | namespace watchman {
    function w_string (line 12) | w_string convertLiteralPathToGlob(w_string_piece literal) {
    function w_string (line 29) | w_string convertNoEscapeGlobToGlob(w_string_piece noescapePattern) {

FILE: watchman/query/GlobEscaping.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/query/GlobTree.cpp
  type watchman (line 13) | namespace watchman {

FILE: watchman/query/GlobTree.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/query/LocalFileResult.cpp
  type watchman (line 11) | namespace watchman {
    type timespec (line 51) | struct timespec
    type timespec (line 59) | struct timespec
    type timespec (line 67) | struct timespec
    function w_string_piece (line 75) | w_string_piece LocalFileResult::baseName() {
    function w_string_piece (line 79) | w_string_piece LocalFileResult::dirName() {

FILE: watchman/query/LocalFileResult.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/query/Query.cpp
  type watchman (line 12) | namespace watchman {

FILE: watchman/query/Query.h
  function namespace (line 17) | namespace watchman {

FILE: watchman/query/QueryContext.cpp
  function file_result_to_json (line 24) | std::optional<json_ref> file_result_to_json(
  function w_string (line 51) | const w_string& QueryContext::getWholeName() {
  function w_string (line 58) | w_string QueryContext::computeWholeName(FileResult* file) const {
  function RenderResult (line 147) | RenderResult QueryContext::renderResults() {

FILE: watchman/query/QueryContext.h
  type watchman_file (line 16) | struct watchman_file
  type Query (line 21) | struct Query
  type class (line 24) | enum class
  type QueryContext (line 34) | struct QueryContext
  function generationStarted (line 53) | void generationStarted() {
  function num_deduped (line 77) | uint32_t num_deduped{0}
  function disableFreshInstance (line 80) | bool disableFreshInstance{false};

FILE: watchman/query/QueryExpr.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/query/QueryResult.cpp
  type watchman (line 10) | namespace watchman {
    function json_ref (line 12) | json_ref RenderResult::toJson() && {
    function json_ref (line 20) | json_ref QueryDebugInfo::render() const {

FILE: watchman/query/QueryResult.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/query/TermRegistry.cpp
  type watchman (line 14) | namespace watchman {
    type RegisteredParser (line 18) | struct RegisteredParser {
    type Init (line 30) | struct Init {
      method Init (line 31) | Init() {
  function QueryExprParser (line 42) | QueryExprParser getQueryExprParser(const w_string& name) {
  function parseQueryExpr (line 55) | std::unique_ptr<QueryExpr> parseQueryExpr(Query* query, const json_ref& ...

FILE: watchman/query/TermRegistry.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/query/base.cpp
  class NotExpr (line 21) | class NotExpr : public QueryExpr {
    method NotExpr (line 25) | explicit NotExpr(std::unique_ptr<QueryExpr> other_expr)
    method EvaluateResult (line 28) | EvaluateResult evaluate(QueryContextBase* ctx, FileResult* file) overr...
    method parse (line 36) | static std::unique_ptr<QueryExpr> parse(Query* query, const json_ref& ...
    method computeGlobUpperBound (line 47) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 58) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 68) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 72) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {
  class TrueExpr (line 79) | class TrueExpr : public QueryExpr {
    method EvaluateResult (line 81) | EvaluateResult evaluate(QueryContextBase*, FileResult*) override {
    method parse (line 85) | static std::unique_ptr<QueryExpr> parse(Query*, const json_ref&) {
    method computeGlobUpperBound (line 89) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 95) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 99) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 103) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {
  class FalseExpr (line 110) | class FalseExpr : public QueryExpr {
    method EvaluateResult (line 112) | EvaluateResult evaluate(QueryContextBase*, FileResult*) override {
    method parse (line 116) | static std::unique_ptr<QueryExpr> parse(Query*, const json_ref&) {
    method computeGlobUpperBound (line 120) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 126) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 130) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 134) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {
  class ListExpr (line 141) | class ListExpr : public QueryExpr {
    method ListExpr (line 146) | ListExpr(bool isAll, std::vector<std::unique_ptr<QueryExpr>> exprs)
    method EvaluateResult (line 149) | EvaluateResult evaluate(QueryContextBase* ctx, FileResult* file) overr...
    method parse (line 183) | static std::unique_ptr<QueryExpr>
    method parseAllOf (line 219) | static std::unique_ptr<QueryExpr> parseAllOf(
    method parseAnyOf (line 224) | static std::unique_ptr<QueryExpr> parseAnyOf(
    method computeGlobUpperBound (line 230) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 308) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 340) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 358) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/dirname.cpp
  function is_dir_sep (line 19) | static inline bool is_dir_sep(int c) {
  class DirNameExpr (line 23) | class DirNameExpr : public QueryExpr {
    type w_query_int_compare (line 25) | struct w_query_int_compare
    method DirNameExpr (line 31) | explicit DirNameExpr(
    method EvaluateResult (line 43) | EvaluateResult evaluate(QueryContextBase* ctx, FileResult*) override {
    method parse (line 80) | static std::unique_ptr<QueryExpr>
    method parseDirName (line 139) | static std::unique_ptr<QueryExpr> parseDirName(
    method parseIDirName (line 144) | static std::unique_ptr<QueryExpr> parseIDirName(
    method computeGlobUpperBound (line 150) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 178) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 182) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 186) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/empty.cpp
  type watchman (line 14) | namespace watchman {
    class QueryContextBase (line 16) | class QueryContextBase
    class ExistsExpr (line 18) | class ExistsExpr : public QueryExpr {
      method EvaluateResult (line 20) | EvaluateResult evaluate(QueryContextBase*, FileResult* file) override {
      method parse (line 24) | static std::unique_ptr<QueryExpr> parse(Query*, const json_ref&) {
      method computeGlobUpperBound (line 28) | std::optional<std::vector<std::string>> computeGlobUpperBound(
      method ReturnOnlyFiles (line 34) | ReturnOnlyFiles listOnlyFiles() const override {
      method SimpleSuffixType (line 38) | SimpleSuffixType evaluateSimpleSuffix() const override {
      method getSuffixQueryGlobPatterns (line 42) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {
    class EmptyExpr (line 48) | class EmptyExpr : public QueryExpr {
      method EvaluateResult (line 50) | EvaluateResult evaluate(QueryContextBase*, FileResult* file) override {
      method parse (line 77) | static std::unique_ptr<QueryExpr> parse(Query*, const json_ref&) {
      method computeGlobUpperBound (line 81) | std::optional<std::vector<std::string>> computeGlobUpperBound(
      method ReturnOnlyFiles (line 87) | ReturnOnlyFiles listOnlyFiles() const override {
      method SimpleSuffixType (line 91) | SimpleSuffixType evaluateSimpleSuffix() const override {
      method getSuffixQueryGlobPatterns (line 95) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/eval.cpp
  function computeUnconditionalLogFilePrefixes (line 33) | std::vector<w_string> computeUnconditionalLogFilePrefixes() {
  function w_query_process_file (line 57) | void w_query_process_file(
  function time_generator (line 127) | void time_generator(
  function default_generators (line 134) | static void default_generators(
  function execute_common (line 163) | static void execute_common(
  function QueryResult (line 308) | QueryResult w_query_execute(

FILE: watchman/query/eval.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/query/fieldlist.cpp
  type watchman (line 15) | namespace watchman {
    function make_name (line 19) | std::optional<json_ref> make_name(FileResult* file, const QueryContext...
    function make_symlink (line 23) | std::optional<json_ref> make_symlink(FileResult* file, const QueryCont...
    function make_sha1_hex (line 35) | std::optional<json_ref> make_sha1_hex(FileResult* file, const QueryCon...
    function make_size (line 69) | std::optional<json_ref> make_size(FileResult* file, const QueryContext...
    function make_exists (line 77) | std::optional<json_ref> make_exists(FileResult* file, const QueryConte...
    function make_new (line 85) | std::optional<json_ref> make_new(FileResult* file, const QueryContext*...
  function make_type_field (line 204) | std::optional<json_ref> make_type_field(FileResult* file, const QueryCon...
  function build_defs (line 273) | std::unordered_map<w_string, QueryFieldRenderer> build_defs() {
  function json_ref (line 324) | json_ref field_list_to_json_name_array(const QueryFieldList& fieldList) {
  function parse_field_list (line 335) | void parse_field_list(
  type register_field_capabilities (line 364) | struct register_field_capabilities {
    method register_field_capabilities (line 365) | register_field_capabilities() {

FILE: watchman/query/glob.cpp
  type watchman (line 19) | namespace watchman {
    function GlobTree (line 70) | GlobTree* lookup_node_child(
    function add_glob (line 86) | bool add_glob(GlobTree* tree, const w_string& glob_str) {
    function parse_globs (line 151) | void parse_globs(Query* res, const json_ref& query) {
    function w_string (line 191) | static w_string parse_suffix(const json_ref& ele) {
    function parse_suffixes (line 201) | void parse_suffixes(Query* res, const json_ref& query) {

FILE: watchman/query/intcompare.cpp
  type watchman (line 17) | namespace watchman {
    type w_query_icmp_op (line 23) | enum w_query_icmp_op
    function parse_int_compare (line 35) | void parse_int_compare(const json_ref& term, struct w_query_int_compar...
    function eval_int_compare (line 69) | bool eval_int_compare(json_int_t ival, struct w_query_int_compare* com...
    class SizeExpr (line 89) | class SizeExpr : public QueryExpr {
      method SizeExpr (line 93) | explicit SizeExpr(w_query_int_compare comp) : comp(comp) {}
      method EvaluateResult (line 95) | EvaluateResult evaluate(QueryContextBase*, FileResult* file) override {
      method parse (line 115) | static std::unique_ptr<QueryExpr> parse(Query*, const json_ref& term) {
      method computeGlobUpperBound (line 126) | std::optional<std::vector<std::string>> computeGlobUpperBound(
      method ReturnOnlyFiles (line 132) | ReturnOnlyFiles listOnlyFiles() const override {
      method SimpleSuffixType (line 136) | SimpleSuffixType evaluateSimpleSuffix() const override {
      method getSuffixQueryGlobPatterns (line 140) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/intcompare.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/query/match.cpp
  type watchman (line 19) | namespace watchman {
    function w_string_piece (line 24) | w_string_piece trimGlobAfterDoubleStar(w_string_piece pattern) {
    class WildMatchExpr (line 61) | class WildMatchExpr : public QueryExpr {
      method WildMatchExpr (line 69) | WildMatchExpr(
      method EvaluateResult (line 81) | EvaluateResult evaluate(QueryContextBase* ctx, FileResult* file) ove...
      method parse (line 110) | static std::unique_ptr<QueryExpr>
      method parseMatch (line 174) | static std::unique_ptr<QueryExpr> parseMatch(
      method parseIMatch (line 179) | static std::unique_ptr<QueryExpr> parseIMatch(
      method computeGlobUpperBound (line 185) | std::optional<std::vector<std::string>> computeGlobUpperBound(
      method ReturnOnlyFiles (line 212) | ReturnOnlyFiles listOnlyFiles() const override {
      method SimpleSuffixType (line 216) | SimpleSuffixType evaluateSimpleSuffix() const override {
      method getSuffixQueryGlobPatterns (line 220) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/name.cpp
  class NameExpr (line 19) | class NameExpr : public QueryExpr {
    method NameExpr (line 24) | explicit NameExpr(
    method EvaluateResult (line 33) | EvaluateResult evaluate(QueryContextBase* ctx, FileResult* file) overr...
    method parse (line 68) | static std::unique_ptr<QueryExpr>
    method parseName (line 143) | static std::unique_ptr<QueryExpr> parseName(
    method parseIName (line 148) | static std::unique_ptr<QueryExpr> parseIName(
    method computeGlobUpperBound (line 154) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 186) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 190) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 194) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/parse.cpp
  type watchman (line 19) | namespace watchman {
    function parse_since (line 23) | bool parse_since(Query* res, const json_ref& query) {
    function parse_paths (line 39) | bool parse_paths(Query* res, const json_ref& query) {
    function parse_relative_root (line 87) | void parse_relative_root(
    function parse_query_expression (line 114) | void parse_query_expression(Query* res, const json_ref& query) {
    function parse_request_id (line 124) | void parse_request_id(Query* res, const json_ref& query) {
    function json_int_t (line 138) | json_int_t parse_nonnegative_integer(std::string_view name, json_ref v) {
    function parse_sync (line 150) | void parse_sync(Query* res, const json_ref& query) {
    function parse_lock_timeout (line 180) | void parse_lock_timeout(Query* res, const json_ref& query) {
    function parse_bool_param (line 201) | bool parse_bool_param(
    function parse_dedup (line 215) | void parse_dedup(Query* res, const json_ref& query) {
    function parse_fail_if_no_saved_state (line 219) | void parse_fail_if_no_saved_state(Query* res, const json_ref& query) {
    function parse_omit_changed_files (line 224) | void parse_omit_changed_files(Query* res, const json_ref& query) {
    function parse_empty_on_fresh_instance (line 229) | void parse_empty_on_fresh_instance(Query* res, const json_ref& query) {
    function parse_always_include_directories (line 234) | void parse_always_include_directories(Query* res, const json_ref& quer...
    function parse_benchmark (line 239) | void parse_benchmark(Query* res, const json_ref& query) {
    function parse_case_sensitive (line 251) | void parse_case_sensitive(
    function parseQuery (line 266) | std::shared_ptr<Query> parseQuery(
    function w_query_legacy_field_list (line 306) | void w_query_legacy_field_list(QueryFieldList* flist) {
    function parseQueryLegacy (line 338) | std::shared_ptr<Query> parseQueryLegacy(

FILE: watchman/query/parse.h
  function namespace (line 14) | namespace watchman {

FILE: watchman/query/pcre.cpp
  class PcreExpr (line 23) | class PcreExpr : public QueryExpr {
    method PcreExpr (line 29) | explicit PcreExpr(pcre2_code* re, pcre2_match_data* matchData, bool wh...
    method EvaluateResult (line 41) | EvaluateResult evaluate(QueryContextBase* ctx, FileResult* file) overr...
    method parse (line 67) | static std::unique_ptr<QueryExpr>
    method parsePcre (line 136) | static std::unique_ptr<QueryExpr> parsePcre(
    method parseIPcre (line 141) | static std::unique_ptr<QueryExpr> parseIPcre(
    method computeGlobUpperBound (line 147) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 160) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 164) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 168) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/since.cpp
  type watchman (line 20) | namespace watchman {
    class QueryContextBase (line 21) | class QueryContextBase
  type since_what (line 24) | enum since_what { SINCE_OCLOCK, SINCE_CCLOCK, SINCE_MTIME, SINCE_CTIME }
  type since_what (line 27) | enum since_what
  class SinceExpr (line 36) | class SinceExpr : public QueryExpr {
    type since_what (line 38) | enum since_what
    method SinceExpr (line 41) | explicit SinceExpr(std::unique_ptr<ClockSpec> spec, enum since_what fi...
    method EvaluateResult (line 44) | EvaluateResult evaluate(QueryContextBase* ctx, FileResult* file) overr...
    method parse (line 101) | static std::unique_ptr<QueryExpr> parse(Query*, const json_ref& term) {
    method computeGlobUpperBound (line 164) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 170) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 174) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 178) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/suffix.cpp
  class SuffixExpr (line 22) | class SuffixExpr : public QueryExpr {
    method SuffixExpr (line 26) | explicit SuffixExpr(std::unordered_set<w_string>&& suffixSet)
    method EvaluateResult (line 29) | EvaluateResult evaluate(QueryContextBase*, FileResult* file) override {
    method parse (line 44) | static std::unique_ptr<QueryExpr> parse(Query*, const json_ref& term) {
    method aggregate (line 76) | std::unique_ptr<QueryExpr> aggregate(
    method computeGlobUpperBound (line 94) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 102) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 106) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 110) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/query/type.cpp
  class TypeExpr (line 19) | class TypeExpr : public QueryExpr {
    method TypeExpr (line 23) | explicit TypeExpr(char arg) : arg(arg) {}
    method EvaluateResult (line 25) | EvaluateResult evaluate(QueryContextBase*, FileResult* file) override {
    method parse (line 81) | static std::unique_ptr<QueryExpr> parse(Query*, const json_ref& term) {
    method computeGlobUpperBound (line 106) | std::optional<std::vector<std::string>> computeGlobUpperBound(
    method ReturnOnlyFiles (line 116) | ReturnOnlyFiles listOnlyFiles() const override {
    method SimpleSuffixType (line 123) | SimpleSuffixType evaluateSimpleSuffix() const override {
    method getSuffixQueryGlobPatterns (line 130) | std::vector<std::string> getSuffixQueryGlobPatterns() const override {

FILE: watchman/root/Root.h
  function namespace (line 29) | namespace watchman {
  function Object (line 167) | struct RootDebugStatus : serde::Object {
  function std (line 233) | const std::chrono::milliseconds trigger_settle{0}
  function std (line 239) | const std::chrono::seconds gc_interval{DEFAULT_GC_INTERVAL};

FILE: watchman/root/dir.cpp
  function w_string (line 18) | w_string watchman_dir::getFullPath() const {
  function watchman_file (line 22) | watchman_file* watchman_dir::getChildFile(w_string_piece name_2) const {
  function watchman_dir (line 30) | watchman_dir* watchman_dir::getChildDir(w_string_piece name_2) const {
  function w_string (line 38) | w_string watchman_dir::getFullPathToChild(w_string_piece extra) const {

FILE: watchman/root/file.cpp
  function free_file_node (line 60) | void free_file_node(struct watchman_file* file) {

FILE: watchman/root/init.cpp
  type watchman (line 18) | namespace watchman {
    function json_ref (line 43) | json_ref ClientStateAssertions::debugStates() const {
    function json_ref (line 137) | json_ref getIgnoreVcs(const Configuration& config) {
    function w_string (line 159) | w_string computeCookieDir(
    function IgnoreSet (line 195) | IgnoreSet computeIgnoreSet(
    function RootMetadata (line 295) | RootMetadata Root::getRootMetadata() const {

FILE: watchman/root/iothread.cpp
  type watchman (line 23) | namespace watchman {
    function getBiggestTimeout (line 156) | std::chrono::milliseconds getBiggestTimeout(const Root& root) {
    function apply_dir_size_hint (line 431) | void apply_dir_size_hint(watchman_dir* dir, uint32_t ndirs, uint32_t n...
    type stat (line 523) | struct stat
    type watchman_file (line 557) | struct watchman_file
    class CrawlerFileSystem (line 618) | class CrawlerFileSystem : public FileSystem {
      method openDir (line 620) | std::unique_ptr<DirHandle> openDir(const char* path, bool strict) ov...
      method FileInformation (line 641) | FileInformation getFileInformation(
      method touch (line 647) | void touch(const char* path) override {
      method CrawlerFileSystem (line 651) | CrawlerFileSystem(
      method CrawlerFileSystem (line 659) | CrawlerFileSystem() = delete;
      method CrawlerFileSystem (line 660) | CrawlerFileSystem(CrawlerFileSystem&&) = delete;
      method CrawlerFileSystem (line 661) | CrawlerFileSystem(const CrawlerFileSystem&) = delete;
      method CrawlerFileSystem (line 662) | CrawlerFileSystem& operator=(CrawlerFileSystem&&) = delete;
      method CrawlerFileSystem (line 663) | CrawlerFileSystem& operator=(const CrawlerFileSystem&) = delete;
    function did_file_change (line 792) | bool did_file_change(

FILE: watchman/root/notifythread.cpp
  type watchman (line 13) | namespace watchman {

FILE: watchman/root/resolve.cpp
  function root_check_restrict (line 26) | bool root_check_restrict(const char* watch_path) {
  function check_allowed_fs (line 64) | static void check_allowed_fs(const char* filename, const w_string& fs_ty...
  function load_root_config (line 114) | std::optional<json_ref> load_root_config(const char* path) {
  function root_resolve (line 132) | std::shared_ptr<Root>
  function w_root_resolve (line 278) | std::shared_ptr<Root> w_root_resolve(const char* filename, bool auto_wat...
  function w_root_resolve_for_client_mode (line 296) | std::shared_ptr<Root> w_root_resolve_for_client_mode(const char* filenam...

FILE: watchman/root/resolve.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/root/test/RootTest.cpp
  function TEST (line 16) | TEST(RootTest, IgnoreSet_includes_ignore_vcs_if_no_ignore_dirs) {

FILE: watchman/root/warnerr.cpp
  type watchman (line 14) | namespace watchman {
    function handle_open_errno (line 16) | void handle_open_errno(

FILE: watchman/root/warnerr.h
  type watchman_dir (line 14) | struct watchman_dir
  function namespace (line 16) | namespace watchman {

FILE: watchman/root/watchlist.cpp
  type watchman (line 18) | namespace watchman {
    function findEnclosingRoot (line 39) | bool findEnclosingRoot(
    function json_ref (line 67) | json_ref w_root_stop_watch_all() {
    function json_ref (line 111) | json_ref w_root_watch_list_to_json() {
    function RootDebugStatus (line 135) | RootDebugStatus Root::getStatus() const {
    function json_ref (line 263) | json_ref Root::triggerListToJson() const {
    function w_root_free_watched_roots (line 276) | void w_root_free_watched_roots() {

FILE: watchman/root/watchlist.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/ruby/ruby-watchman/ext/ruby-watchman/extconf.rb
  function header (line 8) | def header(item)

FILE: watchman/ruby/ruby-watchman/ext/ruby-watchman/watchman.c
  type watchman_t (line 22) | typedef struct {
  function watchman_append (line 66) | void watchman_append(watchman_t* w, const char* data, size_t len) {
  function watchman_t (line 81) | watchman_t* watchman_init() {
  function watchman_free (line 95) | void watchman_free(watchman_t* w) {
  function watchman_dump_int (line 103) | void watchman_dump_int(watchman_t* w, int64_t num) {
  function watchman_dump_string (line 128) | void watchman_dump_string(watchman_t* w, VALUE string) {
  function watchman_dump_double (line 137) | void watchman_dump_double(watchman_t* w, double num) {
  function watchman_dump_array (line 147) | void watchman_dump_array(watchman_t* w, VALUE array) {
  function watchman_dump_hash_iterator (line 160) | int watchman_dump_hash_iterator(VALUE key, VALUE value, VALUE data) {
  function watchman_dump_hash (line 170) | void watchman_dump_hash(watchman_t* w, VALUE hash) {
  function watchman_dump (line 182) | void watchman_dump(watchman_t* w, VALUE serializable) {
  function watchman_load_int (line 217) | int64_t watchman_load_int(char** ptr, char* end) {
  function VALUE (line 267) | VALUE watchman_load_string(char** ptr, char* end) {
  function watchman_load_double (line 297) | double watchman_load_double(char** ptr, char* end) {
  function watchman_load_array_header (line 311) | int64_t watchman_load_array_header(char** ptr, char* end) {
  function VALUE (line 333) | VALUE watchman_load_array(char** ptr, char* end) {
  function VALUE (line 351) | VALUE watchman_load_hash(char** ptr, char* end) {
  function VALUE (line 383) | VALUE watchman_load_template(char** ptr, char* end) {
  function VALUE (line 423) | VALUE watchman_load(char** ptr, char* end) {
  function VALUE (line 466) | VALUE RubyWatchman_load(VALUE self, VALUE serialized) {
  function VALUE (line 520) | VALUE RubyWatchman_dump(VALUE self, VALUE serializable) {
  function VALUE (line 552) | VALUE RubyWatchman_query(VALUE self, VALUE query, VALUE socket) {
  function Init_ext (line 660) | void Init_ext() {

FILE: watchman/ruby/ruby-watchman/lib/ruby-watchman/version.rb
  type RubyWatchman (line 6) | module RubyWatchman

FILE: watchman/ruby/ruby-watchman/spec/ruby_watchman_spec.rb
  function binary (line 9) | def binary(str)
  function little_endian? (line 17) | def little_endian?
  function roundtrip (line 28) | def roundtrip(value)

FILE: watchman/runtests.py
  function default_concurrency (line 79) | def default_concurrency():
  function interrupt_handler (line 189) | def interrupt_handler(signo, frame):
  class Result (line 196) | class Result(unittest.TestResult):
    method shouldStop (line 204) | def shouldStop(self):
    method startTest (line 209) | def startTest(self, test):
    method addSuccess (line 213) | def addSuccess(self, test):
    method addSkip (line 234) | def addSkip(self, test, reason):
    method __printFail (line 253) | def __printFail(self, test, err):
    method addFailure (line 280) | def addFailure(self, test, err):
    method addError (line 284) | def addError(self, test, err):
    method setAttemptNumber (line 288) | def setAttemptNumber(self, attempt):
    method _attempts (line 291) | def _attempts(self):
  function expandFilesList (line 297) | def expandFilesList(files):
  function shouldIncludeTestFile (line 315) | def shouldIncludeTestFile(filename):
  function shouldIncludeTestName (line 333) | def shouldIncludeTestName(name):
  class Loader (line 348) | class Loader(unittest.TestLoader):
    method __init__ (line 351) | def __init__(self):
    method loadTestsFromTestCase (line 354) | def loadTestsFromTestCase(self, testCaseClass):
    method getTestCaseNames (line 357) | def getTestCaseNames(self, testCaseClass):
    method loadTestsFromModule (line 361) | def loadTestsFromModule(self, module, *args, **kw):
  class ThreadSafeFile (line 393) | class ThreadSafeFile:
    method __init__ (line 394) | def __init__(self, f):
    method _getlock (line 399) | def _getlock(self):
    method _droplock (line 403) | def _droplock(self):
    method __getattr__ (line 409) | def __getattr__(self, name):
    method __setattr__ (line 415) | def __setattr__(self, name, value):
    method write (line 421) | def write(self, data):
    method flush (line 427) | def flush(self):
  function runner (line 439) | def runner():
  function expand_suite (line 540) | def expand_suite(suite, target=None):
  function queue_jobs (line 557) | def queue_jobs(tests):

FILE: watchman/rust/serde_bser/src/bytestring.rs
  type ByteString (line 36) | pub struct ByteString(#[serde(with = "serde_bytes")] Vec<u8>);
    method fmt (line 39) | fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fm...
    method fmt (line 46) | fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fm...
    type Target (line 53) | type Target = [u8];
    method deref (line 55) | fn deref(&self) -> &[u8] {
    method deref_mut (line 61) | fn deref_mut(&mut self) -> &mut [u8] {
    method as_bytes (line 68) | pub fn as_bytes(&self) -> &[u8] {
    method into_bytes (line 73) | pub fn into_bytes(self) -> Vec<u8> {
    method as_escaped_string (line 80) | pub fn as_escaped_string(&self) -> String {
    method from (line 112) | fn from(vec: Vec<u8>) -> Self {
    method from (line 119) | fn from(s: String) -> Self {
    method from (line 125) | fn from(s: &str) -> Self {
    type Error (line 132) | type Error = std::string::FromUtf8Error;
    method try_into (line 134) | fn try_into(self) -> Result<String, Self::Error> {
    type Error (line 142) | type Error = std::string::FromUtf8Error;
    method try_into (line 145) | fn try_into(self) -> Result<OsString, Self::Error> {
    method try_into (line 150) | fn try_into(self) -> Result<OsString, Self::Error> {
    type Error (line 159) | type Error = std::string::FromUtf8Error;
    method try_into (line 161) | fn try_into(self) -> Result<PathBuf, Self::Error> {
  type Error (line 170) | type Error = &'static str;
  method try_into (line 173) | fn try_into(self) -> Result<ByteString, Self::Error> {
  method try_into (line 178) | fn try_into(self) -> Result<ByteString, Self::Error> {
  type Error (line 189) | type Error = &'static str;
  method try_into (line 191) | fn try_into(self) -> Result<ByteString, Self::Error> {
  function test_serde (line 203) | fn test_serde() {

FILE: watchman/rust/serde_bser/src/de/bunser.rs
  type Bunser (line 20) | pub struct Bunser<R> {
  type PduInfo (line 25) | pub struct PduInfo {
  function new (line 35) | pub fn new(read: R) -> Self {
  function read_pdu (line 43) | pub fn read_pdu(&mut self) -> Result<PduInfo> {
  function read_count (line 65) | pub fn read_count(&self) -> i64 {
  function end (line 69) | pub fn end(&self, pdu_info: &PduInfo) -> Result<()> {
  function peek (line 81) | pub fn peek(&mut self) -> Result<u8> {
  function discard (line 86) | pub fn discard(&mut self) {
  function read_bytes (line 92) | pub fn read_bytes<'s>(&'s mut self, len: i64) -> Result<Reference<'de, '...
  function next_i8 (line 101) | pub fn next_i8(&mut self) -> Result<i8> {
  function next_i16 (line 113) | pub fn next_i16(&mut self) -> Result<i16> {
  function next_i32 (line 125) | pub fn next_i32(&mut self) -> Result<i32> {
  function next_i64 (line 137) | pub fn next_i64(&mut self) -> Result<i64> {
  function check_next_int (line 149) | pub fn check_next_int(&mut self) -> Result<i64> {
  function next_f64 (line 166) | pub fn next_f64(&mut self) -> Result<f64> {

FILE: watchman/rust/serde_bser/src/de/map.rs
  type MapAccess (line 17) | pub struct MapAccess<'a, R> {
  function new (line 29) | pub fn new(de: &'a mut Deserializer<R>, nitems: usize, _guard: &Reentran...
  type Error (line 41) | type Error = Error;
  function next_key_seed (line 43) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
  function next_value_seed (line 56) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
  type MapKey (line 66) | struct MapKey<'a, R> {
  type Error (line 74) | type Error = Error;
  function deserialize_any (line 77) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_option (line 93) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_newtype_struct (line 102) | fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) ...
  function deserialize_enum (line 110) | fn deserialize_enum<V>(
  function deserialize_bytes (line 123) | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_byte_buf (line 131) | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>

FILE: watchman/rust/serde_bser/src/de/mod.rs
  type Deserializer (line 33) | pub struct Deserializer<R> {
  function from_trait (line 51) | fn from_trait<'de, R, T>(read: R) -> Result<T>
  function from_slice (line 64) | pub fn from_slice<'de, T>(slice: &'de [u8]) -> Result<T>
  function from_reader (line 71) | pub fn from_reader<R, T>(rdr: R) -> Result<T>
  function new (line 83) | pub fn new(read: R) -> Result<Self> {
  function end (line 94) | pub fn end(&self) -> Result<()> {
  function capabilities (line 99) | pub fn capabilities(&self) -> u32 {
  function parse_value (line 103) | fn parse_value<V>(&mut self, visitor: V) -> Result<V::Value>
  function template_keys (line 156) | fn template_keys(&mut self) -> Result<Vec<template::Key<'de>>> {
  function visit_bytestring (line 162) | fn visit_bytestring<V>(&mut self, visitor: V) -> Result<V::Value>
  function visit_utf8string (line 174) | fn visit_utf8string<V>(&mut self, visitor: V) -> Result<V::Value>
  function visit_bool (line 192) | fn visit_bool<V>(&mut self, visitor: V, value: bool) -> Result<V::Value>
  function visit_unit (line 201) | fn visit_unit<V>(&mut self, visitor: V) -> Result<V::Value>
  type Error (line 214) | type Error = Error;
  function deserialize_any (line 217) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_option (line 226) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_newtype_struct (line 240) | fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Resul...
  function deserialize_enum (line 251) | fn deserialize_enum<V>(

FILE: watchman/rust/serde_bser/src/de/read.rs
  type ByteBuf (line 31) | struct ByteBuf<'a>(&'a [u8]);
  function fmt (line 34) | fn fmt(&self, fmtr: &mut fmt::Formatter) -> result::Result<(), fmt::Erro...
  type DeRead (line 51) | pub trait DeRead<'de> {
    method next (line 53) | fn next(&mut self) -> anyhow::Result<u8>;
    method peek (line 55) | fn peek(&mut self) -> anyhow::Result<u8>;
    method read_count (line 58) | fn read_count(&self) -> usize;
    method discard (line 60) | fn discard(&mut self);
    method next_bytes (line 62) | fn next_bytes<'s>(
    method next_u32 (line 68) | fn next_u32(&mut self, scratch: &mut Vec<u8>) -> anyhow::Result<u32> {
  type SliceRead (line 77) | pub struct SliceRead<'a> {
  function new (line 83) | pub fn new(slice: &'a [u8]) -> Self {
  type IoRead (line 88) | pub struct IoRead<R>
  function new (line 102) | pub fn new(reader: R) -> Self {
  method drop (line 116) | fn drop(&mut self) {
  function next (line 122) | fn next(&mut self) -> anyhow::Result<u8> {
  function peek (line 131) | fn peek(&mut self) -> anyhow::Result<u8> {
  function read_count (line 139) | fn read_count(&self) -> usize {
  function discard (line 144) | fn discard(&mut self) {
  function next_bytes (line 148) | fn next_bytes<'s>(
  function next (line 168) | fn next(&mut self) -> anyhow::Result<u8> {
  function peek (line 181) | fn peek(&mut self) -> anyhow::Result<u8> {
  function read_count (line 196) | fn read_count(&self) -> usize {
  function discard (line 204) | fn discard(&mut self) {
  function next_bytes (line 208) | fn next_bytes<'s>(
  type Reference (line 231) | pub enum Reference<'b, 'c, T: ?Sized> {
  function map_result (line 240) | pub fn map_result<F, U, E>(self, f: F) -> anyhow::Result<Reference<'b, '...
  function get_ref (line 252) | pub fn get_ref<'a>(&self) -> &'a T

FILE: watchman/rust/serde_bser/src/de/reentrant.rs
  type ReentrantLimit (line 17) | pub struct ReentrantLimit(Rc<Cell<usize>>);
    method new (line 21) | pub fn new(limit: usize) -> Self {
    method acquire (line 27) | pub fn acquire<S: Into<String>>(&mut self, kind: S) -> Result<Reentran...
  type ReentrantGuard (line 37) | pub struct ReentrantGuard(Rc<Cell<usize>>);
  method drop (line 40) | fn drop(&mut self) {

FILE: watchman/rust/serde_bser/src/de/seq.rs
  type SeqAccess (line 15) | pub struct SeqAccess<'a, R> {
  function new (line 27) | pub fn new(de: &'a mut Deserializer<R>, nitems: usize, _guard: &Reentran...
  type Error (line 39) | type Error = Error;
  function next_element_seed (line 41) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>

FILE: watchman/rust/serde_bser/src/de/template.rs
  type Key (line 29) | pub struct Key<'a>(#[serde(borrow)] Cow<'a, str>);
  type Template (line 49) | pub struct Template<'a, 'de, R> {
  function new (line 59) | pub fn new(
  type Error (line 77) | type Error = Error;
  function next_element_seed (line 79) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
  type ObjectDeserializer (line 97) | struct ObjectDeserializer<'a, 'de, R> {
  type Error (line 106) | type Error = Error;
  function deserialize_any (line 109) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_newtype_struct (line 117) | fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) ...
  function deserialize_enum (line 125) | fn deserialize_enum<V>(
  type TemplateObject (line 144) | struct TemplateObject<'a, 'de, R> {
  function new (line 154) | fn new(de: &'a mut Deserializer<R>, keys: Rc<Vec<Key<'de>>>) -> Self {
  type Error (line 163) | type Error = Error;
  function next_key_seed (line 165) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
  function next_value_seed (line 182) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
  type KeyDeserializer (line 190) | struct KeyDeserializer<'a, 'de> {
  type Error (line 195) | type Error = Error;
  function deserialize_any (line 198) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
  type ValueDeserializer (line 215) | struct ValueDeserializer<'a, R> {
  type Error (line 223) | type Error = Error;
  function deserialize_any (line 226) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_option (line 244) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_newtype_struct (line 258) | fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Resul...

FILE: watchman/rust/serde_bser/src/de/test.rs
  type Bytestring (line 21) | struct Bytestring<'a>(#[serde(borrow)] Cow<'a, [u8]>);
  function from (line 24) | fn from(value: &'a [u8]) -> Self {
  function eq (line 30) | fn eq(&self, rhs: &&'b [u8]) -> bool {
  type BytestringArray (line 36) | struct BytestringArray<'a>(#[serde(borrow)] Vec<Bytestring<'a>>);
  type BytestringObject (line 39) | struct BytestringObject<'a>(#[serde(borrow)] HashMap<Bytestring<'a>, Byt...
  type TwoBytestrings (line 42) | struct TwoBytestrings<'a>(
  type BytestringVariant (line 48) | enum BytestringVariant<'a> {
  type StringVariant (line 64) | enum StringVariant {
  function test_basic_array (line 72) | fn test_basic_array() {
  function test_basic_object (line 85) | fn test_basic_object() {
  function test_basic_tuple (line 103) | fn test_basic_tuple() {
  function test_bare_variant (line 117) | fn test_bare_variant() {
  function test_unit_variant (line 129) | fn test_unit_variant() {
  function test_newtype_variant (line 141) | fn test_newtype_variant() {
  function test_tuple_variant (line 158) | fn test_tuple_variant() {
  function test_struct_variant (line 177) | fn test_struct_variant() {
  type BytestringTemplateObject (line 202) | struct BytestringTemplateObject<'a> {
  type TemplateObject (line 210) | struct TemplateObject {
  function test_template (line 217) | fn test_template() {
  type RequestResult (line 266) | pub enum RequestResult<T, E> {
  type FileInfo (line 272) | pub struct FileInfo {
  type Files (line 278) | pub struct Files {
  type RequestError (line 283) | pub struct RequestError {
  type BytestringFileInfo (line 288) | pub struct BytestringFileInfo<'a> {
  type BytestringFiles (line 295) | pub struct BytestringFiles<'a> {
  type BytestringRequestError (line 301) | pub struct BytestringRequestError<'a> {
  function test_compact_arrays (line 307) | fn test_compact_arrays() {
  function test_compact_arrays_untagged_enum (line 363) | fn test_compact_arrays_untagged_enum() {
  function test_arrays (line 410) | fn test_arrays() {
  function test_arrays_untagged_enum (line 466) | fn test_arrays_untagged_enum() {

FILE: watchman/rust/serde_bser/src/de/variant.rs
  type VariantAccess (line 36) | pub struct VariantAccess<'a, R> {
  function new (line 47) | pub fn new(de: &'a mut Deserializer<R>, _guard: &ReentrantGuard) -> Self {
  type Error (line 58) | type Error = Error;
  function unit_variant (line 60) | fn unit_variant(self) -> Result<()> {
  function newtype_variant_seed (line 64) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
  function tuple_variant (line 71) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
  function struct_variant (line 78) | fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V)...
  type UnitVariantAccess (line 87) | pub struct UnitVariantAccess<'a, R> {
  function new (line 95) | pub fn new(de: &'a mut Deserializer<R>) -> Self {
  type Error (line 106) | type Error = Error;
  function unit_variant (line 108) | fn unit_variant(self) -> Result<()> {
  function newtype_variant_seed (line 112) | fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
  function tuple_variant (line 122) | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
  function struct_variant (line 132) | fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V...

FILE: watchman/rust/serde_bser/src/errors.rs
  type Result (line 16) | pub type Result<T> = ::std::result::Result<T, Error>;
  type Error (line 19) | pub enum Error {
    method de_reader_error (line 55) | pub fn de_reader_error(source: anyhow::Error) -> Self {
    method custom (line 61) | fn custom<T: fmt::Display>(msg: T) -> Self {
    method custom (line 69) | fn custom<T: fmt::Display>(msg: T) -> Self {

FILE: watchman/rust/serde_bser/src/header.rs
  constant EMPTY_HEADER (line 10) | pub const EMPTY_HEADER: &[u8] = b"\x00\x02\x00\x00\x00\x00\x05\x00\x00\x...
  constant BSER_ARRAY (line 12) | pub const BSER_ARRAY: u8 = 0x00;
  constant BSER_OBJECT (line 13) | pub const BSER_OBJECT: u8 = 0x01;
  constant BSER_BYTESTRING (line 14) | pub const BSER_BYTESTRING: u8 = 0x02;
  constant BSER_INT8 (line 15) | pub const BSER_INT8: u8 = 0x03;
  constant BSER_INT16 (line 16) | pub const BSER_INT16: u8 = 0x04;
  constant BSER_INT32 (line 17) | pub const BSER_INT32: u8 = 0x05;
  constant BSER_INT64 (line 18) | pub const BSER_INT64: u8 = 0x06;
  constant BSER_REAL (line 19) | pub const BSER_REAL: u8 = 0x07;
  constant BSER_TRUE (line 20) | pub const BSER_TRUE: u8 = 0x08;
  constant BSER_FALSE (line 21) | pub const BSER_FALSE: u8 = 0x09;
  constant BSER_NULL (line 22) | pub const BSER_NULL: u8 = 0x0a;
  constant BSER_TEMPLATE (line 23) | pub const BSER_TEMPLATE: u8 = 0x0b;
  constant BSER_SKIP (line 24) | pub const BSER_SKIP: u8 = 0x0c;
  constant BSER_UTF8STRING (line 25) | pub const BSER_UTF8STRING: u8 = 0x0d;
  constant BSER_CAP_DISABLE_UNICODE (line 30) | pub const BSER_CAP_DISABLE_UNICODE: u8 = 0x01;
  constant BSER_CAP_DISABLE_UNICODE_FOR_ERRORS (line 32) | pub const BSER_CAP_DISABLE_UNICODE_FOR_ERRORS: u8 = 0x02;
  function header_byte_desc (line 34) | pub fn header_byte_desc(byte: u8) -> String {

FILE: watchman/rust/serde_bser/src/ser/count_write.rs
  type CountWrite (line 12) | pub struct CountWrite {
    method new (line 17) | pub fn new() -> Self {
    method count (line 22) | pub fn count(&self) -> usize {
  method write (line 29) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 35) | fn flush(&mut self) -> io::Result<()> {

FILE: watchman/rust/serde_bser/src/ser/mod.rs
  constant HIGHWATER (line 23) | const HIGHWATER: usize = 4096;
  function serialize (line 25) | pub fn serialize<W, T>(mut writer: W, value: T) -> Result<W>
  type Serializer (line 48) | pub struct Serializer<W> {
  function new (line 73) | fn new(writer: W) -> Self {
  function flush (line 83) | pub fn flush(&mut self) -> io::Result<()> {
  function finish (line 99) | pub fn finish(mut self) -> io::Result<W> {
  function try_finish (line 107) | pub fn try_finish(mut self) -> ::std::result::Result<W, (Self, io::Error...
  function maybe_flush (line 115) | fn maybe_flush(&mut self) -> Result<()> {
  function put_i8 (line 124) | fn put_i8(&mut self, v: i8) {
  function put_i16 (line 130) | fn put_i16(&mut self, v: i16) {
  function put_i32 (line 140) | fn put_i32(&mut self, v: i32) {
  function put_i64 (line 150) | fn put_i64(&mut self, v: i64) {
  type Ok (line 177) | type Ok = ();
  type Error (line 178) | type Error = Error;
  type SerializeSeq (line 180) | type SerializeSeq = Compound<'a, W>;
  type SerializeTuple (line 181) | type SerializeTuple = Compound<'a, W>;
  type SerializeTupleStruct (line 182) | type SerializeTupleStruct = Compound<'a, W>;
  type SerializeTupleVariant (line 183) | type SerializeTupleVariant = Compound<'a, W>;
  type SerializeMap (line 184) | type SerializeMap = Compound<'a, W>;
  type SerializeStruct (line 185) | type SerializeStruct = Compound<'a, W>;
  type SerializeStructVariant (line 186) | type SerializeStructVariant = Compound<'a, W>;
  function serialize_bool (line 189) | fn serialize_bool(self, value: bool) -> Result<()> {
  function serialize_i8 (line 198) | fn serialize_i8(self, v: i8) -> Result<()> {
  function serialize_i16 (line 203) | fn serialize_i16(self, v: i16) -> Result<()> {
  function serialize_i32 (line 208) | fn serialize_i32(self, v: i32) -> Result<()> {
  function serialize_i64 (line 213) | fn serialize_i64(self, v: i64) -> Result<()> {
  function serialize_u8 (line 218) | fn serialize_u8(self, v: u8) -> Result<()> {
  function serialize_u16 (line 224) | fn serialize_u16(self, v: u16) -> Result<()> {
  function serialize_u32 (line 230) | fn serialize_u32(self, v: u32) -> Result<()> {
  function serialize_u64 (line 236) | fn serialize_u64(self, v: u64) -> Result<()> {
  function serialize_f32 (line 247) | fn serialize_f32(self, v: f32) -> Result<()> {
  function serialize_f64 (line 252) | fn serialize_f64(self, v: f64) -> Result<()> {
  function serialize_char (line 263) | fn serialize_char(self, v: char) -> Result<()> {
  function serialize_str (line 268) | fn serialize_str(self, v: &str) -> Result<()> {
  function serialize_bytes (line 277) | fn serialize_bytes(self, v: &[u8]) -> Result<()> {
  function serialize_unit (line 286) | fn serialize_unit(self) -> Result<()> {
  function serialize_unit_struct (line 291) | fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
  function serialize_unit_variant (line 296) | fn serialize_unit_variant(
  function serialize_newtype_struct (line 306) | fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> ...
  function serialize_newtype_variant (line 315) | fn serialize_newtype_variant<T>(
  function serialize_none (line 334) | fn serialize_none(self) -> Result<()> {
  function serialize_some (line 339) | fn serialize_some<T>(self, value: &T) -> Result<()>
  function serialize_seq (line 347) | fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
  function serialize_tuple (line 355) | fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
  function serialize_tuple_struct (line 364) | fn serialize_tuple_struct(
  function serialize_tuple_variant (line 373) | fn serialize_tuple_variant(
  function serialize_map (line 390) | fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
  function serialize_struct (line 398) | fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Sel...
  function serialize_struct_variant (line 407) | fn serialize_struct_variant(
  type Compound (line 422) | pub struct Compound<'a, W> {

FILE: watchman/rust/serde_bser/src/ser/test.rs
  type TestEnum (line 15) | enum TestEnum {
  type SerializeStruct (line 23) | struct SerializeStruct {
  constant BASIC_SERIALIZED (line 30) | const BASIC_SERIALIZED: &[u8] = b"\x00\x02\x00\x00\x00\x00\x04\xcb\x00\x...
  function test_basic_serialize (line 41) | fn test_basic_serialize() {

FILE: watchman/rust/serde_bser/src/value.rs
  type Value (line 26) | pub enum Value {
    method from (line 38) | fn from(v: Vec<Value>) -> Self {
    method from (line 44) | fn from(v: HashMap<String, Value>) -> Self {
    method from (line 50) | fn from(v: bool) -> Self {
    method from (line 56) | fn from(s: &str) -> Self {
    method from (line 62) | fn from(s: String) -> Self {
    method from (line 77) | fn from(v: i64) -> Self {
    method deserialize (line 96) | fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
  type Error (line 68) | type Error = &'static str;
  method try_into (line 70) | fn try_into(self) -> Result<Value, Self::Error> {
  type Error (line 83) | type Error = &'static str;
  function try_into (line 85) | fn try_into(self) -> Result<Value, Self::Error> {
  method serialize (line 238) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: watchman/rust/watchman_client/examples/glob.rs
  type Cli (line 16) | struct Cli {
  function main (line 22) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function run (line 31) | async fn run() -> Result<(), Box<dyn std::error::Error>> {

FILE: watchman/rust/watchman_client/examples/since.rs
  type Cli (line 18) | struct Cli {
  function main (line 33) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function run (line 42) | async fn run() -> Result<(), Box<dyn std::error::Error>> {

FILE: watchman/rust/watchman_client/examples/state.rs
  type Cli (line 15) | struct Cli {
  function main (line 21) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function run (line 30) | async fn run() -> Result<(), Box<dyn std::error::Error>> {

FILE: watchman/rust/watchman_client/examples/subscribe.rs
  type Cli (line 17) | struct Cli {
  function main (line 23) | async fn main() {
  function run (line 31) | async fn run() -> Result<(), Box<dyn std::error::Error>> {

FILE: watchman/rust/watchman_client/examples/trigger.rs
  type Cli (line 18) | enum Cli {
    method path (line 45) | fn path(&self) -> &Path {
  function main (line 55) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function run (line 64) | async fn run() -> Result<(), Box<dyn std::error::Error>> {

FILE: watchman/rust/watchman_client/src/expr.rs
  type Expr (line 20) | pub enum Expr {
  method from (line 89) | fn from(val: Expr) -> Self {
  type NameTerm (line 183) | pub struct NameTerm {
  type DirNameTerm (line 194) | pub struct DirNameTerm {
  type PcreTerm (line 211) | pub struct PcreTerm {
  type MatchTerm (line 224) | pub struct MatchTerm {
  type RelOp (line 241) | pub enum RelOp {
    method into_term (line 251) | fn into_term(self, field: &str) -> Value {
  type SinceTerm (line 268) | pub enum SinceTerm {
  function val (line 290) | fn val(expr: Expr) -> Value {
  function exprs (line 295) | fn exprs() {

FILE: watchman/rust/watchman_client/src/fields.rs
  type QueryFieldName (line 23) | pub trait QueryFieldName {
    method field_name (line 24) | fn field_name() -> &'static str;
  type QueryFieldList (line 30) | pub trait QueryFieldList {
    method field_list (line 31) | fn field_list() -> Vec<&'static str>;
    method field_list (line 344) | fn field_list() -> Vec<&'static str> {
    method field_list (line 361) | fn field_list() -> Vec<&'static str> {
  type NameOnly (line 339) | pub struct NameOnly {
    method from (line 350) | fn from(path: PathBuf) -> Self {
  type NoField (line 358) | pub struct NoField {}

FILE: watchman/rust/watchman_client/src/lib.rs
  type ConnectionLost (line 94) | pub enum ConnectionLost {
  type Error (line 103) | pub enum Error {
  type TaskError (line 151) | enum TaskError {
  type Connector (line 179) | pub struct Connector {
    method new (line 190) | pub fn new() -> Self {
    method watchman_cli_path (line 203) | pub fn watchman_cli_path<P: AsRef<Path>>(mut self, path: P) -> Self {
    method unix_domain_socket (line 209) | pub fn unix_domain_socket<P: AsRef<Path>>(mut self, path: P) -> Self {
    method resolve_unix_domain_path (line 216) | async fn resolve_unix_domain_path(&self) -> Result<PathBuf, Error> {
    method connect (line 270) | pub async fn connect(&self) -> Result<Client, Error> {
  type CanonicalPath (line 309) | pub struct CanonicalPath(PathBuf);
    method canonicalize (line 317) | pub fn canonicalize<P: AsRef<Path>>(path: P) -> Result<Self, std::io::...
    method with_canonicalized_path (line 325) | pub fn with_canonicalized_path(path: PathBuf) -> Self {
    method strip_unc_escape (line 341) | fn strip_unc_escape(path: PathBuf) -> PathBuf {
    method strip_unc_escape (line 350) | fn strip_unc_escape(path: PathBuf) -> PathBuf {
    method into_path_buf (line 355) | pub fn into_path_buf(self) -> PathBuf {
  type ResolvedRoot (line 366) | pub struct ResolvedRoot {
    method watcher (line 380) | pub fn watcher(&self) -> &str {
    method project_root (line 385) | pub fn project_root(&self) -> &Path {
    method path (line 390) | pub fn path(&self) -> PathBuf {
    method project_relative_path (line 400) | pub fn project_relative_path(&self) -> Option<&Path> {
  type ReadWriteStream (line 405) | trait ReadWriteStream: AsyncRead + AsyncWrite + std::marker::Unpin + Sen...
  type SendRequest (line 410) | struct SendRequest {
    method respond (line 418) | fn respond(self, result: Result<Bytes, String>) {
  type SubscriptionNotification (line 423) | enum SubscriptionNotification {
  type TaskItem (line 428) | enum TaskItem {
  type BserSplitter (line 434) | struct BserSplitter;
  type Item (line 437) | type Item = Bytes;
  type Error (line 438) | type Error = TaskError;
  method decode (line 440) | fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, S...
  type Client (line 481) | pub struct Client {
    method generic_request (line 841) | pub async fn generic_request<Request, Response>(
    method version (line 854) | pub async fn version(&self) -> Result<GetVersionResponse, Error> {
    method watch_list (line 858) | pub async fn watch_list(&self) -> Result<WatchListResponse, Error> {
    method state_enter (line 877) | pub async fn state_enter(
    method state_leave (line 906) | pub async fn state_leave(
    method resolve_root (line 941) | pub async fn resolve_root(&self, path: CanonicalPath) -> Result<Resolv...
    method query (line 1014) | pub async fn query<F>(
    method subscribe (line 1050) | pub async fn subscribe<F>(
    method glob (line 1104) | pub async fn glob(&self, root: &ResolvedRoot, globs: &[&str]) -> Resul...
    method clock (line 1138) | pub async fn clock(
    method get_config (line 1154) | pub async fn get_config(&self, root: &ResolvedRoot) -> Result<Watchman...
    method register_trigger (line 1162) | pub async fn register_trigger(
    method remove_trigger (line 1174) | pub async fn remove_trigger(
    method list_triggers (line 1190) | pub async fn list_triggers(&self, root: &ResolvedRoot) -> Result<Trigg...
    method get_asserted_states (line 1197) | pub async fn get_asserted_states(
  type ClientTask (line 487) | struct ClientTask {
    method run (line 503) | async fn run(&mut self) -> Result<(), TaskError> {
    method run_loop (line 515) | async fn run_loop(&mut self) -> Result<(), TaskError> {
    method register_subscription (line 539) | fn register_subscription(
    method fail_all (line 550) | fn fail_all(&mut self, err: &TaskError) {
    method send_next_request (line 558) | async fn send_next_request(&mut self) -> Result<(), TaskError> {
    method queue_request (line 578) | async fn queue_request(&mut self, request: SendRequest) -> Result<(), ...
    method process_pdu (line 585) | async fn process_pdu(&mut self, pdu: Bytes) -> Result<(), TaskError> {
  method drop (line 497) | fn drop(&mut self) {
  function bunser (line 629) | fn bunser<T>(buf: &[u8]) -> Result<T, Error>
  type ClientInner (line 640) | struct ClientInner {
    method generic_request (line 650) | pub(crate) async fn generic_request<Request, Response>(
  type SubscriptionData (line 708) | pub enum SubscriptionData<F>
  type Subscription (line 762) | pub struct Subscription<F>
  function name (line 778) | pub fn name(&self) -> &str {
  function next (line 786) | pub async fn next(&mut self) -> Result<SubscriptionData<F>, Error> {
  function cancel (line 825) | pub async fn cancel(self) -> Result<(), Error> {
  type TestStruct (line 1221) | struct TestStruct {
  function connection_builder_paths (line 1226) | fn connection_builder_paths() {
  function test_decoder (line 1232) | async fn test_decoder() {
  function test_decoder_err (line 1273) | fn test_decoder_err() {
  function test_bounds (line 1289) | fn test_bounds() {

FILE: watchman/rust/watchman_client/src/named_pipe.rs
  type NamedPipe (line 30) | pub struct NamedPipe {
    method connect (line 35) | pub async fn connect(path: PathBuf) -> Result<Self, Error> {
  method poll_read (line 77) | fn poll_read(
  method poll_write (line 87) | fn poll_write(
  method poll_flush (line 95) | fn poll_flush(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Result<()...
  method poll_shutdown (line 99) | fn poll_shutdown(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Result...

FILE: watchman/rust/watchman_client/src/pdu.rs
  type GetVersionResponse (line 22) | pub struct GetVersionResponse {
  type WatchListResponse (line 27) | pub struct WatchListResponse {
  type GetSockNameResponse (line 33) | pub struct GetSockNameResponse {
  type ClockResponse (line 41) | pub struct ClockResponse {
  type ClockRequest (line 48) | pub struct ClockRequest(pub &'static str, pub PathBuf, pub ClockRequestP...
  type ClockRequestParams (line 51) | pub struct ClockRequestParams {
  type GetConfigRequest (line 58) | pub struct GetConfigRequest(pub &'static str, pub PathBuf);
  type WatchmanConfig (line 65) | pub struct WatchmanConfig {
  type GetConfigResponse (line 71) | pub struct GetConfigResponse {
  type StateEnterLeaveParams (line 78) | pub struct StateEnterLeaveParams<'a> {
  type StateEnterLeaveRequest (line 91) | pub struct StateEnterLeaveRequest<'a>(pub &'static str, pub PathBuf, pub...
  type StateEnterLeaveResponse (line 95) | pub struct StateEnterLeaveResponse {
  type WatchProjectRequest (line 104) | pub struct WatchProjectRequest(pub &'static str, pub PathBuf);
  type WatchProjectResponse (line 108) | pub struct WatchProjectResponse {
  type PathGeneratorElement (line 125) | pub enum PathGeneratorElement {
  type QueryRequest (line 132) | pub struct QueryRequest(pub &'static str, pub PathBuf, pub QueryRequestC...
  function is_false (line 135) | fn is_false(v: &bool) -> bool {
  type SettleDurationMs (line 141) | pub struct SettleDurationMs(pub std::time::Duration);
    method from (line 144) | fn from(duration: std::time::Duration) -> Self {
  function from (line 150) | fn from(val: SettleDurationMs) -> Self {
  type SyncTimeout (line 157) | pub enum SyncTimeout {
    method is_default (line 177) | fn is_default(&self) -> bool {
    method is_disabled (line 184) | fn is_disabled(&self) -> bool {
    method from (line 193) | fn from(duration: std::time::Duration) -> Self {
  function from (line 204) | fn from(val: SyncTimeout) -> Self {
  type QueryRequestCommon (line 241) | pub struct QueryRequestCommon {
  type QueryDebugInfo (line 401) | pub struct QueryDebugInfo {
  type QueryResult (line 410) | pub struct QueryResult<F>
  type SubscribeRequest (line 451) | pub struct SubscribeRequest {
  type SubscribeCommand (line 527) | pub struct SubscribeCommand(
  type SubscribeResponse (line 537) | pub struct SubscribeResponse {
  type TriggerRequest (line 564) | pub struct TriggerRequest {
  type TriggerStdinConfig (line 619) | pub enum TriggerStdinConfig {
    method serialize (line 627) | fn serialize<S>(this: &Option<Self>, serializer: S) -> Result<S::Ok, S...
  type TriggerCommand (line 641) | pub struct TriggerCommand(pub &'static str, pub PathBuf, pub TriggerRequ...
  type TriggerResponse (line 644) | pub struct TriggerResponse {
  type TriggerDelCommand (line 651) | pub struct TriggerDelCommand(pub &'static str, pub PathBuf, pub String);
  type TriggerDelResponse (line 654) | pub struct TriggerDelResponse {
  type TriggerListCommand (line 661) | pub struct TriggerListCommand(pub &'static str, pub PathBuf);
  type TriggerListResponse (line 664) | pub struct TriggerListResponse {
  type Unsubscribe (line 670) | pub struct Unsubscribe(pub &'static str, pub PathBuf, pub String);
  type UnsubscribeResponse (line 673) | pub struct UnsubscribeResponse {
  type GetAssertedStatesRequest (line 679) | pub struct GetAssertedStatesRequest(pub &'static str, pub PathBuf);
  type State (line 682) | pub struct State {
  type GetAssertedStatesResponse (line 688) | pub struct GetAssertedStatesResponse {
  type Clock (line 707) | pub enum Clock {
  type ClockSpec (line 725) | pub enum ClockSpec {
    method null (line 745) | pub fn null() -> Self {
    method named_cursor (line 768) | pub fn named_cursor(cursor: &str) -> Self {
    method unix_timestamp (line 778) | pub fn unix_timestamp(time_t: i64) -> Self {
  method default (line 732) | fn default() -> Self {
  method from (line 784) | fn from(val: ClockSpec) -> Self {
  type FatClockData (line 796) | pub struct FatClockData {
  type ScmAwareClockData (line 806) | pub struct ScmAwareClockData {
  type SavedStateClockData (line 822) | pub struct SavedStateClockData {
  type ContentSha1Hex (line 837) | pub enum ContentSha1Hex {
  type FileType (line 869) | pub enum FileType {
    method fmt (line 882) | fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    method from (line 888) | fn from(s: String) -> Self {
  method from (line 905) | fn from(val: FileType) -> Self {
  function convert_bser_value (line 930) | fn convert_bser_value<T>(input: Value) -> T
  function test_content_sha1hex_hash (line 939) | fn test_content_sha1hex_hash() {
  function test_content_sha1hex_error (line 949) | fn test_content_sha1hex_error() {
  function test_content_sha1hex_none (line 963) | fn test_content_sha1hex_none() {

FILE: watchman/saved_state/LocalSavedStateInterface.cpp
  type watchman (line 19) | namespace watchman {
    function w_string (line 89) | w_string LocalSavedStateInterface::getLocalPath(w_string_piece commitI...

FILE: watchman/saved_state/LocalSavedStateInterface.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/saved_state/SavedStateFactory.cpp
  type watchman (line 18) | namespace watchman {
    function getInterface (line 20) | std::unique_ptr<SavedStateInterface> getInterface(

FILE: watchman/saved_state/SavedStateFactory.h
  function namespace (line 14) | namespace watchman {

FILE: watchman/saved_state/SavedStateInterface.cpp
  type watchman (line 13) | namespace watchman {

FILE: watchman/saved_state/SavedStateInterface.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/scm/Git.cpp
  function replaceEmbeddedNulls (line 25) | void replaceEmbeddedNulls(std::string& str) {
  function gitExecutablePath (line 29) | std::string gitExecutablePath() {
  type GitResult (line 33) | struct GitResult {
  function GitResult (line 37) | GitResult runGit(
  type watchman (line 70) | namespace watchman {
    type timespec (line 94) | struct timespec
    type timeval (line 101) | struct timeval
    type timespec (line 103) | struct timespec
    function w_string (line 110) | w_string Git::mergeBaseWith(

FILE: watchman/scm/Git.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/scm/Mercurial.cpp
  function replaceEmbeddedNulls (line 29) | void replaceEmbeddedNulls(std::string& str) {
  function hgExecutablePath (line 33) | std::string hgExecutablePath() {
  type MercurialResult (line 41) | struct MercurialResult {
  function MercurialResult (line 45) | MercurialResult runMercurial(
  type watchman (line 76) | namespace watchman {
    type timespec (line 139) | struct timespec
    type timeval (line 146) | struct timeval
    type timespec (line 148) | struct timespec
    function w_string (line 155) | w_string Mercurial::mergeBaseWith(

FILE: watchman/scm/Mercurial.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/scm/SCM.cpp
  type watchman (line 15) | namespace watchman {
    function w_string (line 25) | const w_string& SCM::getRootPath() const {
    function w_string (line 29) | const w_string& SCM::getSCMRoot() const {
    function findFileInDirTree (line 33) | std::optional<w_string> findFileInDirTree(

FILE: watchman/scm/SCM.h
  function namespace (line 17) | namespace watchman {

FILE: watchman/sockname.cpp
  type watchman (line 12) | namespace watchman {

FILE: watchman/sockname.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/state.cpp
  type state (line 37) | struct state {
  function state_saver (line 47) | static void state_saver() noexcept {
  function w_state_shutdown (line 68) | void w_state_shutdown() {
  function w_state_load (line 77) | bool w_state_load() {
  function do_state_save (line 114) | static bool do_state_save() {
  function w_state_save (line 145) | void w_state_save() {
  function w_root_save_state (line 154) | bool w_root_save_state(json_ref& state) {
  function w_root_load_state (line 182) | bool w_root_load_state(const json_ref& state) {

FILE: watchman/stream.cpp
  function w_poll_events (line 19) | int w_poll_events(EventPoll* p, int n, int timeoutms) {
  function w_mkstemp (line 33) | std::unique_ptr<watchman_stream> w_mkstemp(char* templ) {

FILE: watchman/stream_stdout.cpp
  class StdioStream (line 16) | class StdioStream : public watchman_stream {
    method StdioStream (line 20) | explicit StdioStream(const FileDescriptor& fd) : fd_(fd) {}
    method read (line 22) | int read(void* buf, int size) override {
    method write (line 35) | int write(const void* buf, int size) override {
    method watchman_event (line 48) | watchman_event* getEvents() override {
    method setNonBlock (line 53) | void setNonBlock(bool) override {}
    method rewind (line 55) | bool rewind() override {
    method shutdown (line 59) | bool shutdown() override {
    method peerIsOwner (line 63) | bool peerIsOwner() override {
    method pid_t (line 67) | pid_t getPeerProcessID() const override {
  function watchman_stream (line 77) | watchman_stream* w_stm_stdout() {
  function watchman_stream (line 82) | watchman_stream* w_stm_stdin() {

FILE: watchman/stream_unix.cpp
  class PollableEvent (line 39) | class PollableEvent : public watchman_event {
  class PipeEvent (line 45) | class PipeEvent : public PollableEvent {
    method notify (line 49) | void notify() override {
    method testAndClear (line 53) | bool testAndClear() override {
    method getFd (line 66) | FileDescriptor::system_handle_type getFd() const override {
    method system_handle (line 70) | FileDescriptor::system_handle_type system_handle() override {
    method isSocket (line 74) | bool isSocket() override {
  class FakeSocketEvent (line 82) | class FakeSocketEvent : public PollableEvent {
    method FakeSocketEvent (line 87) | explicit FakeSocketEvent(FileDescriptor::system_handle_type fd)
    method notify (line 90) | void notify() override {}
    method testAndClear (line 91) | bool testAndClear() override {
    method getFd (line 94) | FileDescriptor::system_handle_type getFd() const override {
    method system_handle (line 98) | FileDescriptor::system_handle_type system_handle() override {
    method isSocket (line 102) | bool isSocket() override {
  class UnixStream (line 107) | class UnixStream : public watchman_stream {
    type ucred (line 112) | struct ucred
    type xucred (line 114) | struct xucred
    type ucred_deleter (line 117) | struct ucred_deleter {
    method UnixStream (line 127) | explicit UnixStream(FileDescriptor&& descriptor)
    method FileDescriptor (line 158) | const FileDescriptor& getFileDescriptor() const override {
    method read (line 162) | int read(void* buf, int size) override {
    method write (line 176) | int write(const void* buf, int size) override {
    method watchman_event (line 231) | watchman_event* getEvents() override {
    method setNonBlock (line 235) | void setNonBlock(bool nonb) override {
    method rewind (line 244) | bool rewind() override {
    method shutdown (line 252) | bool shutdown() override {
    method peerIsOwner (line 267) | bool peerIsOwner() override {
    method pid_t (line 292) | pid_t getPeerProcessID() const override {
  function w_event_make_sockets (line 316) | std::unique_ptr<watchman_event> w_event_make_sockets() {
  function w_poll_events_sockets (line 321) | int w_poll_events_sockets(EventPoll* p, int n, int timeoutms) {
  function w_stm_fdopen (line 354) | std::unique_ptr<watchman_stream> w_stm_fdopen(FileDescriptor&& fd) {
  function w_stm_connect_unix (line 366) | ResultErrno<std::unique_ptr<watchman_stream>> w_stm_connect_unix(
  function w_stm_open (line 428) | std::unique_ptr<watchman_stream>

FILE: watchman/stream_win.cpp
  class win_handle (line 26) | class win_handle
    type overlapped_op (line 79) | struct overlapped_op
    type write_buf (line 86) | struct write_buf
    method FileDescriptor (line 101) | const FileDescriptor& getFileDescriptor() const override {
    method HANDLE (line 106) | inline HANDLE handle() const {
    method pid_t (line 110) | pid_t getPeerProcessID() const override {
  class WindowsEvent (line 29) | class WindowsEvent : public watchman_event {
    method WindowsEvent (line 33) | explicit WindowsEvent(bool initialState = false)
    method notify (line 40) | void notify() override {
    method testAndClear (line 44) | bool testAndClear() override {
    method reset (line 50) | void reset() {
    method system_handle (line 54) | FileDescriptor::system_handle_type system_handle() override {
    method isSocket (line 58) | bool isSocket() override {
  type overlapped_op (line 64) | struct overlapped_op {
    class win_handle (line 66) | class win_handle
    type write_buf (line 67) | struct write_buf
  type write_buf (line 70) | struct write_buf {
    type write_buf (line 71) | struct write_buf
  class win_handle (line 77) | class win_handle : public watchman_stream {
    type overlapped_op (line 79) | struct overlapped_op
    type write_buf (line 86) | struct write_buf
    method FileDescriptor (line 101) | const FileDescriptor& getFileDescriptor() const override {
    method HANDLE (line 106) | inline HANDLE handle() const {
    method pid_t (line 110) | pid_t getPeerProcessID() const override {
  function BOOL (line 147) | static BOOL WINAPI get_overlapped_result_ex_impl(
  function BOOL (line 192) | static BOOL WINAPI probe_get_overlapped_result_ex(
  type write_buf (line 230) | struct write_buf
    type write_buf (line 71) | struct write_buf
  function move_from_read_buffer (line 240) | static void move_from_read_buffer(
  function win_read_handle_completion (line 269) | static bool win_read_handle_completion(class win_handle* h) {
  function win_read_blocking (line 327) | static int win_read_blocking(class win_handle* h, void* buf, int size) {
  function win_read_non_blocking (line 358) | static int win_read_non_blocking(class win_handle* h, void* buf, int siz...
  class win_handle (line 442) | class win_handle
    type overlapped_op (line 79) | struct overlapped_op
    type write_buf (line 86) | struct write_buf
    method FileDescriptor (line 101) | const FileDescriptor& getFileDescriptor() const override {
    method HANDLE (line 106) | inline HANDLE handle() const {
    method pid_t (line 110) | pid_t getPeerProcessID() const override {
  function write_completed (line 444) | static void CALLBACK
  function initiate_write (line 502) | static void initiate_write(class win_handle* h) {
  type write_buf (line 538) | struct write_buf
    type write_buf (line 71) | struct write_buf
  function watchman_event (line 586) | watchman_event* win_handle::getEvents() {
  function w_event_make_named_pipe (line 624) | std::unique_ptr<watchman_event> w_event_make_named_pipe() {
  function w_stm_fdopen_windows (line 636) | std::unique_ptr<watchman_stream> w_stm_fdopen_windows(FileDescriptor&& h...
  function w_stm_connect_named_pipe (line 644) | std::unique_ptr<watchman_stream> w_stm_connect_named_pipe(
  function w_poll_events_named_pipe (line 698) | int w_poll_events_named_pipe(EventPoll* p, int n, int timeoutms) {
  function FileDescriptor (line 743) | FileDescriptor w_handle_open(const char* path, int flags) {
  function w_stm_open (line 797) | std::unique_ptr<watchman_stream> w_stm_open(const char* path, int flags,...

FILE: watchman/string.cpp
  type watchman (line 32) | namespace watchman {
    type StringHeader (line 33) | struct StringHeader
  function w_string (line 50) | w_string w_string_piece::asWString(w_string_type_t stringType) const {
  function w_string (line 54) | w_string w_string_piece::asLowerCase(w_string_type_t stringType) const {
  function w_string (line 77) | w_string w_string_piece::asUTF8Clean() const {
  function w_string_piece (line 132) | w_string_piece w_string_piece::dirName() const {
  function w_string_piece (line 154) | w_string_piece w_string_piece::baseName() const {
  function w_string_piece (line 177) | w_string_piece w_string_piece::suffix() const {
  function w_string (line 296) | w_string& w_string::operator=(const w_string& other) {
  function w_string (line 317) | w_string& w_string::operator=(w_string&& other) noexcept {
  function hash_string (line 334) | inline uint32_t hash_string(const char* str, size_t len) {
  function StringHash (line 348) | StringHash w_string::computeAndStoreHash() const noexcept {
  function checked_len (line 356) | static inline uint32_t checked_len(size_t len) {
  function w_string (line 369) | w_string w_string::dirName() const {
  function w_string (line 373) | w_string w_string::baseName() const {
  function w_string (line 381) | w_string w_string::normalizeSeparators(char targetSeparator) const {
  function w_string (line 436) | w_string w_string::pathCat(std::initializer_list<w_string_piece> elems) {
  function StringHash (line 466) | StringHash w_string_piece::hashValue() const noexcept {
  function strlen_uint32 (line 470) | uint32_t strlen_uint32(const char* str) {
  function StringHeader (line 563) | static StringHeader*
  function w_string_delref (line 574) | void w_string_delref(StringHeader* str) {
  function w_string_equal_caseless (line 583) | bool w_string_equal_caseless(w_string_piece a, w_string_piece b) {
  function w_string_piece (line 632) | w_string_piece w_string_canon_path(w_string_piece str) {
  function w_string_path_is_absolute (line 641) | bool w_string_path_is_absolute(w_string_piece path) {

FILE: watchman/telemetry/LogEvent.cpp
  type watchman (line 13) | namespace watchman {
    function getLogEventCounters (line 15) | std::pair<int64_t, int64_t> getLogEventCounters(const LogEventType& ty...

FILE: watchman/telemetry/LogEvent.h
  function namespace (line 22) | namespace watchman {

FILE: watchman/telemetry/WatchmanStats.cpp
  type watchman (line 12) | namespace watchman {
    function WatchmanStatsPtr (line 22) | WatchmanStatsPtr getWatchmanStats() {

FILE: watchman/telemetry/WatchmanStats.h
  function namespace (line 19) | namespace watchman {

FILE: watchman/telemetry/WatchmanStructuredLogger.cpp
  type watchman (line 14) | namespace watchman {
    function getLogger (line 23) | std::shared_ptr<StructuredLogger> getLogger() {
    function DynamicEvent (line 36) | DynamicEvent WatchmanStructuredLogger::populateDefaultFields(

FILE: watchman/telemetry/WatchmanStructuredLogger.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/test/ArtTest.cpp
  function FILE (line 16) | static FILE* open_test_file(const char* name) {
  function TEST (line 40) | TEST(Art, insert) {
  function TEST (line 56) | TEST(Art, insert_verylong) {
  function TEST (line 111) | TEST(Art, insert_search) {
  function TEST (line 151) | TEST(Art, insert_delete) {
  function TEST (line 197) | TEST(Art, insert_iter) {
  type prefix_data (line 231) | struct prefix_data {
  function TEST (line 245) | TEST(Art, iter_prefix) {
  function TEST (line 320) | TEST(Art, long_prefix) {
  function TEST (line 345) | TEST(Art, prefix) {
  function TEST (line 367) | TEST(Art, insert_search_uuid) {

FILE: watchman/test/BserTest.cpp
  function S (line 31) | std::string S(const char (&str)[N]) {
  function dump_to_string (line 35) | int dump_to_string(const char* buffer, size_t size, void* data) {
  function hexdump (line 41) | void hexdump(const char* start, const char* end) {
  function bdumps (line 67) | std::unique_ptr<std::string>
  function bdumps_pdu (line 79) | std::unique_ptr<std::string>
  function check_roundtrip (line 139) | void check_roundtrip(
  function check_serialization (line 172) | void check_serialization(
  function check_bser_typed_strings (line 242) | void check_bser_typed_strings() {
  function TEST (line 274) | TEST(Bser, bser_tests) {
  function TEST (line 324) | TEST(Bser, bunser_int_returns_needed) {
  function Alloc (line 349) | Alloc normal_malloc(size_t size) {
  function get_page_size (line 360) | size_t get_page_size() {
  function allocate_pages (line 366) | std::tuple<void*, size_t> allocate_pages(size_t size) {
  function deallocate_pages (line 379) | void deallocate_pages(void* p, size_t actual_size) {
  function allocate_pages (line 385) | std::tuple<void*, size_t> allocate_pages(size_t size) {
  function deallocate_pages (line 405) | void deallocate_pages(void* p, size_t actual_size) {
  function Alloc (line 411) | Alloc page_head(size_t size) {
  function Alloc (line 419) | Alloc page_tail(size_t size) {
  function literal (line 441) | std::string_view literal(const char (&p)[N]) {
  function TEST (line 446) | TEST(Bser, fuzz_examples) {
  function TEST (line 496) | TEST(Bser, detect_array_stack_overflow) {

FILE: watchman/test/CacheTest.cpp
  type watchman::lrucache (line 20) | namespace watchman::lrucache {
  function TEST (line 29) | TEST(CacheTest, basics) {
  function TEST (line 72) | TEST(CacheTest, future) {
  function main (line 163) | int main(int argc, char* argv[]) {

FILE: watchman/test/ChildProcTest.cpp
  function test_pipe_input (line 41) | void test_pipe_input(bool threaded) {
  function TEST (line 76) | TEST(ChildProcess, stresstest_pipe_output) {
  function TEST (line 95) | TEST(ChildProcess, inputThreaded) {
  function TEST (line 99) | TEST(ChildProcess, inputNotThreaded) {

FILE: watchman/test/FSDetectTest.cpp
  function TEST (line 12) | TEST(FSType, fstype) {
  function TEST (line 62) | TEST(FSType, fstype_two_entries) {

FILE: watchman/test/FailsToStartViewTest.cpp
  function Configuration (line 27) | Configuration getConfiguration() {
  class FailsToStartViewTest (line 34) | class FailsToStartViewTest : public Test {
    method FailsToStartViewTest (line 49) | FailsToStartViewTest() {
  function TEST_F (line 54) | TEST_F(FailsToStartViewTest, can_start) {

FILE: watchman/test/GlobUpperBoundTest.cpp
  function expr_to_upper_bound (line 21) | std::optional<std::vector<std::string>> expr_to_upper_bound(
  class CaseInvariantGlobUpperBoundTest (line 38) | class CaseInvariantGlobUpperBoundTest
  function TEST_P (line 45) | TEST_P(CaseInvariantGlobUpperBoundTest, term_false) {
  function TEST_P (line 52) | TEST_P(CaseInvariantGlobUpperBoundTest, term_true) {
  function TEST_P (line 58) | TEST_P(CaseInvariantGlobUpperBoundTest, term_since) {
  function TEST_P (line 65) | TEST_P(CaseInvariantGlobUpperBoundTest, term_exists) {
  function TEST_P (line 72) | TEST_P(CaseInvariantGlobUpperBoundTest, term_empty) {
  function TEST_P (line 79) | TEST_P(CaseInvariantGlobUpperBoundTest, term_size) {
  function TEST_P (line 86) | TEST_P(CaseInvariantGlobUpperBoundTest, term_suffix) {
  function TEST_P (line 93) | TEST_P(CaseInvariantGlobUpperBoundTest, term_type) {
  function TEST_P (line 100) | TEST_P(CaseInvariantGlobUpperBoundTest, term_name_basename) {
  function TEST (line 110) | TEST(GlobUpperBoundTest, term_name_wholename) {
  function TEST (line 126) | TEST(GlobUpperBoundTest, term_name_wholename_multi) {
  function TEST_P (line 146) | TEST_P(CaseInvariantGlobUpperBoundTest, term_name_escape) {
  function TEST_P (line 153) | TEST_P(CaseInvariantGlobUpperBoundTest, term_name_multi_escape) {
  function TEST_P (line 160) | TEST_P(CaseInvariantGlobUpperBoundTest, term_name_normalize) {
  function TEST_P (line 167) | TEST_P(CaseInvariantGlobUpperBoundTest, term_name_multi_normalize) {
  function TEST (line 174) | TEST(GlobUpperBoundTest, term_iname_wholename) {
  function TEST_P (line 193) | TEST_P(CaseInvariantGlobUpperBoundTest, term_match_basename) {
  function TEST_P (line 204) | TEST_P(CaseInvariantGlobUpperBoundTest, term_match_wholename) {
  function TEST_P (line 211) | TEST_P(CaseInvariantGlobUpperBoundTest, term_match_trim_doublestar) {
  function TEST_P (line 226) | TEST_P(CaseInvariantGlobUpperBoundTest, term_match_escaped_doublestar) {
  function TEST_P (line 241) | TEST_P(CaseInvariantGlobUpperBoundTest, term_match_dotfiles) {
  function TEST_P (line 257) | TEST_P(CaseInvariantGlobUpperBoundTest, term_match_noescape) {
  function TEST_P (line 265) | TEST_P(CaseInvariantGlobUpperBoundTest, term_match_escape) {
  function TEST (line 272) | TEST(GlobUpperBoundTest, term_imatch_wholename) {
  function TEST_P (line 293) | TEST_P(CaseInvariantGlobUpperBoundTest, term_pcre_basename) {
  function TEST_P (line 304) | TEST_P(CaseInvariantGlobUpperBoundTest, term_pcre_wholename) {
  function TEST (line 313) | TEST(GlobUpperBoundTest, term_ipcre_wholename) {
  function TEST_P (line 334) | TEST_P(CaseInvariantGlobUpperBoundTest, term_dirname_root_unbounded) {
  function TEST_P (line 340) | TEST_P(CaseInvariantGlobUpperBoundTest, term_dirname_root_exact_depth) {
  function TEST (line 349) | TEST(GlobUpperBoundTest, term_dirname_prefix) {
  function TEST_P (line 364) | TEST_P(CaseInvariantGlobUpperBoundTest, term_dirname_escape) {
  function TEST_P (line 370) | TEST_P(CaseInvariantGlobUpperBoundTest, term_dirname_prefix_depth_zero) {
  function TEST (line 379) | TEST(GlobUpperBoundTest, term_idirname) {
  function TEST_P (line 397) | TEST_P(CaseInvariantGlobUpperBoundTest, term_not) {
  function TEST_P (line 409) | TEST_P(CaseInvariantGlobUpperBoundTest, term_allof_nested_anyof) {
  function TEST_P (line 425) | TEST_P(CaseInvariantGlobUpperBoundTest, term_allof_prefers_fewer_globs) {
  function TEST_P (line 437) | TEST_P(CaseInvariantGlobUpperBoundTest, term_anyof_unbounded) {
  function TEST_P (line 449) | TEST_P(CaseInvariantGlobUpperBoundTest, term_anyof_nested_allof) {
  function TEST (line 467) | TEST(GlobUpperBoundTest, term_anyof_dedupes) {
  function TEST_P (line 505) | TEST_P(CaseInvariantGlobUpperBoundTest, term_anyof_dedupes_expensive_glo...

FILE: watchman/test/IgnoreTest.cpp
  type test_case (line 50) | struct test_case {
  function run_correctness_test (line 55) | void run_correctness_test(
  function add_strings (line 67) | void add_strings(
  function init_state (line 78) | void init_state(IgnoreSet* state) {
  function TEST (line 83) | TEST(Ignore, correctness) {
  function build_list_with_prefix (line 115) | std::vector<w_string> build_list_with_prefix(const char* prefix, size_t ...
  function bench_list (line 161) | void bench_list(const char* label, const char* prefix) {
  function TEST (line 180) | TEST(Ignore, bench_all_ignores) {
  function TEST (line 184) | TEST(Ignore, bench_no_ignores) {

FILE: watchman/test/InMemoryViewTest.cpp
  function Configuration (line 26) | Configuration getConfiguration(bool usePwalk) {
  class InMemoryViewTest (line 32) | class InMemoryViewTest : public testing::TestWithParam<bool /* pwalk */> {
    method InMemoryViewTest (line 46) | InMemoryViewTest() {
  function TEST_P (line 51) | TEST_P(InMemoryViewTest, can_construct) {
  function TEST_P (line 60) | TEST_P(InMemoryViewTest, drive_initial_crawl) {
  function TEST_P (line 84) | TEST_P(InMemoryViewTest, respond_to_watcher_events) {
  function TEST_P (line 149) | TEST_P(InMemoryViewTest, wait_for_respond_to_watcher_events) {
  function TEST_P (line 214) | TEST_P(
  function TEST_P (line 294) | TEST_P(
  function TEST_P (line 380) | TEST_P(
  function TEST_P (line 438) | TEST_P(InMemoryViewTest, waitUntilReadyToQuery_waits_for_initial_crawl) {
  function TEST_P (line 470) | TEST_P(InMemoryViewTest, directory_removal_does_not_report_parent) {

FILE: watchman/test/JsonBenchmark.cpp
  function encode_doubles (line 13) | void encode_doubles(benchmark::State& state) {
  function encode_zero_point_zero (line 36) | void encode_zero_point_zero(benchmark::State& state) {
  function decode_doubles (line 53) | void decode_doubles(benchmark::State& state) {

FILE: watchman/test/JsonTest.cpp
  function json_dtostr (line 13) | std::string json_dtostr(double value) {
  function TEST (line 24) | TEST(JsonTest, dtostr) {
  function TEST (line 40) | TEST(JsonTest, double_round_trip) {
  function TEST (line 58) | TEST(JsonTest, too_deep_parse_tree) {

FILE: watchman/test/LocalSavedStateInterfaceTest.cpp
  function expect_query_parse_error (line 17) | void expect_query_parse_error(
  function TEST (line 26) | TEST(LocalSavedStateInterfaceTest, max_commits) {
  function TEST (line 57) | TEST(LocalSavedStateInterfaceTest, localStoragePath) {
  function TEST (line 80) | TEST(LocalSavedStateInterfaceTest, project) {
  function TEST (line 103) | TEST(LocalSavedStateInterfaceTest, project_metadata) {
  function TEST (line 120) | TEST(LocalSavedStateInterfaceTest, path) {

FILE: watchman/test/LogTest.cpp
  function w_request_shutdown (line 13) | void w_request_shutdown(void) {}
  function TEST (line 15) | TEST(Log, logging) {

FILE: watchman/test/MapUtilTest.cpp
  function TEST (line 18) | TEST(MapUtil, map_contains_any) {
  function TEST (line 60) | TEST(MapUtil, map_contains_any_of) {

FILE: watchman/test/MercurialTest.cpp
  function TEST (line 13) | TEST(Mercurial, convertCommitDate) {

FILE: watchman/test/PathUtilsTest.cpp
  class PathUtilsTest (line 28) | class PathUtilsTest : public ::testing::Test {
    method SetUp (line 30) | void SetUp() override {
    method TearDown (line 35) | void TearDown() override {
    method setWatchmanStateDir (line 40) | void setWatchmanStateDir(const std::string& stateDirPath) {
    method getTempPath (line 45) | std::string getTempPath() const {
    method getRandomSuffix (line 49) | std::string getRandomSuffix() const {
    method checkDirectoryPermissions (line 56) | void checkDirectoryPermissions(const std::string& dir_path) {
  function TEST_F (line 95) | TEST_F(PathUtilsTest, computeFileNameWithExistingDirectory) {
  function TEST_F (line 129) | TEST_F(PathUtilsTest, computeFileNameWithSymlinkToExistingDirectory) {
  function TEST_F (line 167) | TEST_F(PathUtilsTest, computeFileNameWithNonExistingDirectory) {
  function TEST_F (line 201) | TEST_F(PathUtilsTest, computeFileNameRelativePathRequireAbsolute) {
  function TEST_F (line 220) | TEST_F(PathUtilsTest, computeFileNameRelativePathNoRequireAbsolute) {
  function TEST_F (line 235) | TEST_F(PathUtilsTest, createLogDirCreatesNewDirectory) {
  function TEST_F (line 259) | TEST_F(PathUtilsTest, createLogDirFailsWhenParentMissing) {
  function TEST_F (line 273) | TEST_F(PathUtilsTest, createLogDirHandlesExistingDirectory) {
  function TEST_F (line 289) | TEST_F(PathUtilsTest, createLogDirHandlesSymlinkToExistingDirectory) {
  function TEST_F (line 306) | TEST_F(PathUtilsTest, createLogDirDoesNotExitOnDifferentOwnership) {
  function TEST_F (line 327) | TEST_F(PathUtilsTest, computeFileNameDifferentSuffixes) {

FILE: watchman/test/PendingCollectionTest.cpp
  type watchman (line 17) | namespace watchman {
  function build_list (line 32) | void build_list(
  function process_items (line 59) | size_t process_items(PendingCollection::LockedPtr& coll) {
  function TEST (line 73) | TEST(Pending, bench) {
  class PendingCollectionFixture (line 143) | class PendingCollectionFixture : public testing::Test {
  class WrappedPendingCollection (line 149) | class WrappedPendingCollection : public PendingCollectionBase {
    method WrappedPendingCollection (line 151) | WrappedPendingCollection() : PendingCollectionBase{cond} {}
  class NaivePendingCollection (line 162) | class NaivePendingCollection {
    method add (line 164) | void add(
    method getPendingItemCount (line 211) | size_t getPendingItemCount() const {
    method stealItems (line 219) | std::shared_ptr<watchman_pending_fs> stealItems() {
  function TYPED_TEST (line 233) | TYPED_TEST(PendingCollectionFixture, add_one_item) {
  function TYPED_TEST (line 246) | TYPED_TEST(PendingCollectionFixture, add_two_items) {
  function TYPED_TEST (line 265) | TYPED_TEST(PendingCollectionFixture, same_item_consolidates) {
  function TYPED_TEST (line 277) | TYPED_TEST(PendingCollectionFixture, prune_obsoleted_children) {
  function TYPED_TEST (line 288) | TYPED_TEST(
  function TYPED_TEST (line 301) | TYPED_TEST(
  function TYPED_TEST (line 316) | TYPED_TEST(PendingCollectionFixture, unrelated_prefixes_dont_prune) {
  function TYPED_TEST (line 334) | TYPED_TEST(PendingCollectionFixture, queue_crawl_then_notify) {
  function TYPED_TEST (line 353) | TYPED_TEST(PendingCollectionFixture, queue_notify_then_crawl) {
  function TYPED_TEST (line 370) | TYPED_TEST(PendingCollectionFixture, real_example) {

FILE: watchman/test/PerfSampleTest.cpp
  function json_ref (line 17) | json_ref make_sample(int i) {
  function TEST (line 22) | TEST(Perf, sample_batches_are_limited_to_batch_size) {
  function TEST (line 52) | TEST(Perf, sample_batches_are_limited_if_total_size_exceeds_argv_limit) {
  function TEST (line 85) | TEST(Perf, large_samples_are_passed_in_stdin) {

FILE: watchman/test/ResultTest.cpp
  function TEST (line 15) | TEST(Result, empty) {
  function TEST (line 26) | TEST(Result, simple_value) {
  function TEST (line 59) | TEST(Result, error) {
  function TEST (line 91) | TEST(Result, non_exception_error_type) {

FILE: watchman/test/ReturnOnlyFilesTest.cpp
  function expr_return_only_files (line 21) | std::optional<QueryExpr::ReturnOnlyFiles> expr_return_only_files(
  function TEST (line 38) | TEST(ReturnOnlyFilesTest, false) {
  function TEST (line 44) | TEST(ReturnOnlyFilesTest, true) {
  function TEST (line 50) | TEST(ReturnOnlyFilesTest, type_d) {
  function TEST (line 56) | TEST(ReturnOnlyFilesTest, type_f) {
  function TEST (line 62) | TEST(ReturnOnlyFilesTest, type_l) {
  function TEST (line 68) | TEST(ReturnOnlyFilesTest, dirname) {
  function TEST (line 74) | TEST(ReturnOnlyFilesTest, idirname) {
  function TEST (line 80) | TEST(ReturnOnlyFilesTest, empty) {
  function TEST (line 86) | TEST(ReturnOnlyFilesTest, exists) {
  function TEST (line 92) | TEST(ReturnOnlyFilesTest, match) {
  function TEST (line 98) | TEST(ReturnOnlyFilesTest, imatch) {
  function TEST (line 104) | TEST(ReturnOnlyFilesTest, name) {
  function TEST (line 110) | TEST(ReturnOnlyFilesTest, iname) {
  function TEST (line 116) | TEST(ReturnOnlyFilesTest, pcre) {
  function TEST (line 122) | TEST(ReturnOnlyFilesTest, ipcre) {
  function TEST (line 128) | TEST(ReturnOnlyFilesTest, since) {
  function TEST (line 134) | TEST(ReturnOnlyFilesTest, size) {
  function TEST (line 140) | TEST(ReturnOnlyFilesTest, suffix) {
  function TEST (line 146) | TEST(ReturnOnlyFilesTest, allof_yes) {
  function TEST (line 152) | TEST(ReturnOnlyFilesTest, allof_no) {
  function TEST (line 158) | TEST(ReturnOnlyFilesTest, allof_unrelated) {
  function TEST (line 164) | TEST(ReturnOnlyFilesTest, allof_yesno) {
  function TEST (line 170) | TEST(ReturnOnlyFilesTest, not_allof_yesno) {
  function TEST (line 177) | TEST(ReturnOnlyFilesTest, anyof_no) {
  function TEST (line 183) | TEST(ReturnOnlyFilesTest, anyof_yes) {
  function TEST (line 189) | TEST(ReturnOnlyFilesTest, anyof_unrelated) {

FILE: watchman/test/RingBufferTest.cpp
  function TEST (line 14) | TEST(RingBufferTest, writes_can_be_read) {
  function TEST (line 29) | TEST(RingBufferTest, writes_can_be_cleared) {

FILE: watchman/test/SerdeTest.cpp
  type HasField (line 15) | struct HasField : public serde::Object {
    method map (line 19) | void map(X& x) {
  function TEST (line 24) | TEST(SerdeTest, map_boolean) {
  function roundtrip (line 41) | void roundtrip(const T& value) {
  function TEST (line 49) | TEST(SerdeTest, integer_roundtrip) {
  function TEST (line 75) | TEST(SerdeTest, array_roundtrip) {
  function TEST (line 79) | TEST(SerdeTest, map_roundtrip) {
  function TEST (line 84) | TEST(SerdeTest, missing_keys_are_okay) {
  type RequiredField (line 96) | struct RequiredField : serde::Object {
    method map (line 100) | void map(X& x) {
  function TEST (line 105) | TEST(SerdeTest, required_keys_are_necessary) {
  type Base (line 120) | struct Base : serde::Object {
    method map (line 124) | void map(X& x) {
  type Derived (line 129) | struct Derived : Base {
    method map (line 134) | void map(X& x) {
  function TEST (line 141) | TEST(SerdeTest, base_class) {
  type OptionalMembers (line 162) | struct OptionalMembers : serde::Object {
    method map (line 167) | void map(X& x) {
  function TEST (line 173) | TEST(SerdeTest, optional_field) {
  function TEST (line 205) | TEST(SerdeTest, arrays_as_tuples) {
  function TEST (line 236) | TEST(SerdeTest, longer_arrays_are_not_rejected) {
  type SkippedThings (line 244) | struct SkippedThings : serde::Object {
    method map (line 249) | void map(X& m) {
  function TEST (line 257) | TEST(SerdeTest, non_defaults_after_defaults_are_encoded) {
  function TEST (line 271) | TEST(SerdeTest, skip_if) {

FILE: watchman/test/StringTest.cpp
  function TEST (line 12) | TEST(String, fmt) {
  function TEST (line 24) | TEST(String, integrals) {
  function TEST (line 51) | TEST(String, strings) {
  function TEST (line 93) | TEST(String, pointers) {
  function TEST (line 118) | TEST(String, double) {
  function TEST (line 123) | TEST(String, canon_path) {
  function TEST (line 131) | TEST(String, concat) {
  function TEST (line 136) | TEST(String, lowercase_suffix) {
  function TEST (line 167) | TEST(String, string_piece_suffix) {
  function TEST (line 201) | TEST(String, string_piece_lowercase_suffix) {
  function TEST (line 238) | TEST(String, path_cat) {
  function TEST (line 260) | TEST(String, basename_dirname) {
  function TEST (line 327) | TEST(String, operators) {
  function TEST (line 336) | TEST(String, piece_and_string_should_have_same_hash) {
  function TEST (line 342) | TEST(String, split) {
  function TEST (line 388) | TEST(String, path_equal) {
  function TEST (line 401) | TEST(String, truncated_head) {
  function TEST (line 423) | TEST(String, truncated_tail) {
  function TEST (line 445) | TEST(String, contains) {
  function TEST (line 455) | TEST(String, allocate_many_sizes) {

FILE: watchman/test/SuffixQueryTest.cpp
  function parse_json (line 22) | std::optional<json_ref> parse_json(std::string expression_json) {
  function expr_evaluate_simple_suffix (line 33) | std::optional<SimpleSuffixType> expr_evaluate_simple_suffix(
  function expr_get_suffix_glob (line 46) | std::optional<std::vector<std::string>> expr_get_suffix_glob(
  function TEST (line 63) | TEST(SuffixQueryTest, false) {
  function TEST (line 69) | TEST(SuffixQueryTest, false_glob) {
  function TEST (line 75) | TEST(SuffixQueryTest, type_d) {
  function TEST (line 81) | TEST(SuffixQueryTest, type_d_glob) {
  function TEST (line 87) | TEST(SuffixQueryTest, type_f) {
  function TEST (line 93) | TEST(SuffixQueryTest, type_f_glob) {
  function TEST (line 98) | TEST(SuffixQueryTest, suffix) {
  function TEST (line 104) | TEST(SuffixQueryTest, suffix_glob) {
  function TEST (line 110) | TEST(SuffixQueryTest, allof_excl) {
  function TEST (line 116) | TEST(SuffixQueryTest, allof_excl_glob) {
  function TEST (line 122) | TEST(SuffixQueryTest, allof_yes) {
  function TEST (line 129) | TEST(SuffixQueryTest, allof_yes_glob) {

FILE: watchman/test/WatcherSelectionDarwinTest.cpp
  function Configuration (line 25) | Configuration getConfiguration(bool perferSplit) {
  class WatcherSelectionDarwinTest (line 33) | class WatcherSelectionDarwinTest
  function TEST_P (line 44) | TEST_P(WatcherSelectionDarwinTest, selectionTest) {
  function TEST_P (line 56) | TEST_P(WatcherSelectionDarwinTest, selectionTest) {

FILE: watchman/test/WildmatchTest.cpp
  function run_test (line 17) | static void run_test(const json_ref& test_case_data) {
  function TEST (line 31) | TEST(WildMatch, tests) {

FILE: watchman/test/async/AsyncWatchmanTestCase.py
  class AsyncWatchmanTestCase (line 17) | class AsyncWatchmanTestCase(unittest.TestCase):
    method setUp (line 18) | def setUp(self):
    method tearDown (line 23) | def tearDown(self):
    method run (line 26) | def run(self, result):
    method touch (line 31) | def touch(self, fname, times=None):
    method touch_relative (line 41) | def touch_relative(self, base, *fname):
    method watchman_command (line 45) | def watchman_command(self, *args):
    method get_file_list (line 49) | def get_file_list(self, root):
    method assert_sub_contains_all (line 54) | def assert_sub_contains_all(self, sub, what):
    method assert_file_sets_equal (line 59) | def assert_file_sets_equal(self, iter1, iter2, message=None):
    method assert_root_file_set (line 65) | def assert_root_file_set(self, root, files):
    method wait_for_sub (line 68) | def wait_for_sub(self, name, root, timeout=10):

FILE: watchman/test/async/test_dead_socket.py
  class TestDeadSocket (line 19) | class TestDeadSocket(IsolatedAsyncioTestCase):
    method test_query_dead_socket (line 21) | def test_query_dead_socket(self):
    method test_subscription_dead_socket (line 33) | def test_subscription_dead_socket(self):
    method _async_runner (line 48) | def _async_runner(self, test_core):

FILE: watchman/test/async/test_subscribe_async.py
  class TestSubscribe (line 16) | class TestSubscribe(AsyncWatchmanTestCase.AsyncWatchmanTestCase):
    method test_subscribe (line 18) | def test_subscribe(self):

FILE: watchman/test/lib/FakeFileSystem.cpp
  type watchman (line 11) | namespace watchman {
    function parseAbsolute (line 22) | folly::StringPiece parseAbsolute(folly::StringPiece path) {
    function parseAbsolute (line 30) | folly::StringPiece parseAbsolute(const char* path) {
    function parseAbsoluteBasename (line 38) | std::pair<folly::StringPiece, folly::StringPiece> parseAbsoluteBasename(
    function withPath (line 60) | std::invoke_result_t<Func, const FakeInode&> withPath(
    function withPath (line 95) | std::invoke_result_t<Func, FakeInode&> withPath(
    class FakeDirHandle (line 124) | class FakeDirHandle : public DirHandle {
      type FakeDirEntry (line 126) | struct FakeDirEntry {
      method FakeDirHandle (line 131) | explicit FakeDirHandle(std::vector<FakeDirEntry> entries)
      method DirEntry (line 134) | const DirEntry* readDir() override {
      method getFd (line 147) | int getFd() const override {
    function FileInformation (line 189) | FileInformation FakeFileSystem::getFileInformation(
    function FileInformation (line 294) | FileInformation FakeFileSystem::fakeDir() {
    function FileInformation (line 310) | FileInformation FakeFileSystem::fakeFile() {

FILE: watchman/test/lib/FakeFileSystem.h
  function namespace (line 21) | namespace watchman {

FILE: watchman/test/lib/FakeFileSystemTest.cpp
  function TEST (line 17) | TEST(FakeFileSystemTest, get_root) {
  function TEST (line 23) | TEST(FakeFileSystemTest, defineContents_populates_files_and_directories) {
  function TEST (line 39) | TEST(FakeFileSystemTest, openDir_enumerates_entries_without_stat) {
  function TEST (line 67) | TEST(FakeFileSystemTest, openDir_enumerates_entries_with_stat) {
  function TEST (line 100) | TEST(FakeFileSystemTest, touch_makes_an_empty_file) {
  function TEST (line 123) | TEST(FakeFileSystemTest, recursively_remove_directory) {
  function TEST (line 136) | TEST(FakeFileSystemTest, recursive_removal_fails_if_parent_is_file) {
  function TEST (line 149) | TEST(FakeFileSystemTest, recursive_removal_fails_if_child_does_not_exist) {

FILE: watchman/test/lib/FakeWatcher.cpp
  type watchman (line 11) | namespace watchman {

FILE: watchman/test/lib/FakeWatcher.h
  function namespace (line 12) | namespace watchman {

FILE: watchman/thirdparty/getopt/GetOpt.cpp
  function getopt_long (line 52) | int getopt_long(

FILE: watchman/thirdparty/getopt/GetOpt.h
  type option (line 21) | struct option {
  type option (line 35) | struct option

FILE: watchman/thirdparty/jansson/dump.cpp
  type object_key (line 23) | struct object_key {
  function dump_to_string (line 28) | static int dump_to_string(const char* buffer, size_t size, void* data) {
  function dump_to_file (line 34) | static int dump_to_file(const char* buffer, size_t size, void* data) {
  function dump_indent (line 45) | static int dump_indent(
  function dump_string (line 67) | static int dump_string(
  function do_dump (line 173) | static int do_dump(
  function json_dumps (line 349) | std::string json_dumps(const json_ref& json, size_t flags) {
  function json_dumpf (line 358) | int json_dumpf(const json_ref& json, FILE* output, size_t flags) {
  function json_dump_file (line 362) | int json_dump_file(const json_ref& json, const char* path, size_t flags) {
  function json_dump_callback (line 370) | int json_dump_callback(

FILE: watchman/thirdparty/jansson/error.cpp
  function jsonp_error_init (line 11) | void jsonp_error_init(json_error_t* error, const char* source) {
  function jsonp_error_set_source (line 24) | void jsonp_error_set_source(json_error_t* error, const char* source) {
  function jsonp_error_set (line 40) | void jsonp_error_set(
  function jsonp_error_vset (line 54) | void jsonp_error_vset(

FILE: watchman/thirdparty/jansson/jansson.h
  type json_type (line 26) | enum json_type : char {
  function format_as (line 38) | inline char format_as(json_type type) {
  type json_t (line 42) | struct json_t {
  function class (line 57) | class json_ref {
  function json_error_t (line 250) | struct json_error_t {
  function json_object_set (line 283) | inline int json_object_set(
  function json_object_set_nocheck (line 290) | inline int json_object_set_nocheck(

FILE: watchman/thirdparty/jansson/jansson_private.h
  function json_t (line 17) | struct json_object_t : json_t {
  function json_t (line 26) | struct json_array_t : json_t {
  function json_t (line 34) | struct json_string_t : json_t {
  function json_t (line 40) | struct json_real_t : json_t {
  function json_t (line 46) | struct json_integer_t : json_t {
  function json_object_t (line 52) | inline json_object_t* json_to_object(const json_t* json) {
  function json_array_t (line 56) | inline json_array_t* json_to_array(const json_t* json) {
  function json_string_t (line 60) | inline json_string_t* json_to_string(const json_t* json) {
  function json_real_t (line 64) | inline json_real_t* json_to_real(const json_t* json) {
  function json_integer_t (line 68) | inline json_integer_t* json_to_integer(const json_t* json) {

FILE: watchman/thirdparty/jansson/load.cpp
  type lex_t (line 76) | struct lex_t {
  class BumpDepth (line 89) | class BumpDepth {
    method BumpDepth (line 91) | explicit BumpDepth(lex_t* lex) : lex_{lex} {
    method BumpDepth (line 98) | BumpDepth(const BumpDepth&) = delete;
    method BumpDepth (line 99) | BumpDepth(BumpDepth&&) = delete;
    method BumpDepth (line 100) | BumpDepth& operator=(const BumpDepth&) = delete;
    method BumpDepth (line 101) | BumpDepth& operator=(BumpDepth&&) = delete;
  function lex_t (line 108) | inline lex_t* stream_to_lex(stream_t* stream) {
  function error_set (line 114) | static void
  function stream_init (line 170) | static void stream_init(stream_t* stream, get_func get, error_func error...
  function stream_get (line 183) | static int stream_get(stream_t* stream, json_error_t* error) {
  function stream_unget (line 247) | static void stream_unget(stream_t* stream, int c) {
  function lex_get (line 263) | static int lex_get(lex_t* lex, json_error_t* error) {
  function lex_save (line 267) | static void lex_save(lex_t* lex, int c) {
  function lex_get_save (line 271) | static int lex_get_save(lex_t* lex, json_error_t* error) {
  function lex_unget (line 278) | static void lex_unget(lex_t* lex, int c) {
  function lex_unget_unsave (line 282) | static void lex_unget_unsave(lex_t* lex, int c) {
  function lex_save_cached (line 292) | static void lex_save_cached(lex_t* lex) {
  function decode_unicode_escape (line 301) | static int32_t decode_unicode_escape(const char* str) {
  function lex_scan_string (line 323) | static void lex_scan_string(lex_t* lex, json_error_t* error) {
  function lex_scan_number (line 480) | static int lex_scan_number(lex_t* lex, int c, json_error_t* error) {
  function lex_scan (line 571) | static int lex_scan(lex_t* lex, json_error_t* error) {
  function lex_steal_string (line 638) | static std::string lex_steal_string(lex_t* lex) {
  function lex_init (line 646) | static int lex_init(lex_t* lex, get_func get, error_func error, void* da...
  function parse_object (line 658) | static std::optional<json_ref>
  function parse_array (line 715) | static std::optional<json_ref>
  function parse_value (line 748) | static std::optional<json_ref>
  function parse_json (line 797) | static std::optional<json_ref>
  function string_get (line 832) | static int string_get(void* data) {
  function string_error (line 844) | static int string_error(void*) {
  function json_loads (line 848) | std::optional<json_ref>
  function buffer_get (line 875) | static int buffer_get(void* data) {
  function buffer_error (line 886) | static int buffer_error(void*) {
  function json_loadb (line 890) | std::optional<json_ref> json_loadb(
  function json_loadf (line 915) | std::optional<json_ref>
  function json_ref (line 938) | json_ref json_load_file(const char* path, size_t flags) {

FILE: watchman/thirdparty/jansson/strconv.cpp
  function _locale_t (line 22) | _locale_t getCLocale() {
  function locale_t (line 27) | locale_t getCLocale() {
  function jsonp_strtod (line 34) | int jsonp_strtod(std::string& strbuffer, double* out) {
  function jsonp_dtostr (line 55) | int jsonp_dtostr(char* buffer, size_t size, double value) {

FILE: watchman/thirdparty/jansson/utf.cpp
  function utf8_encode (line 11) | int utf8_encode(int32_t codepoint, char* buffer, int* size) {
  function utf8_check_first (line 38) | int utf8_check_first(char byte) {
  function utf8_check_full (line 69) | int utf8_check_full(const char* buffer, int size, int32_t* codepoint) {
  function utf8_check_string (line 141) | int utf8_check_string(const char* string, int length) {
  function utf8_fix_string (line 165) | void utf8_fix_string(char* string, size_t length) {

FILE: watchman/thirdparty/jansson/value.cpp
  function json_ref (line 70) | json_ref& json_ref::operator=(const json_ref& other) {
  function json_ref (line 83) | json_ref& json_ref::operator=(json_ref&& other) noexcept {
  function w_string (line 96) | const w_string& json_ref::asString() const {
  function json_ref (line 186) | json_ref json_object(std::unordered_map<w_string, json_ref> values) {
  function json_ref (line 190) | json_ref json_object(
  function json_ref (line 202) | json_ref json_object() {
  function json_object_size (line 206) | size_t json_object_size(const json_ref& json) {
  function json_ref (line 220) | json_ref json_ref::get_default(const char* key, json_ref defval) const {
  function json_ref (line 232) | const json_ref& json_ref::get(const char* key) const {
  function json_object_get (line 258) | std::optional<json_ref> json_object_get(const json_ref& json, const char...
  function json_object_set_new_nocheck (line 271) | int json_object_set_new_nocheck(
  function json_object_set_new (line 303) | int json_object_set_new(
  function json_object_equal (line 314) | static int json_object_equal(const json_ref& object1, const json_ref& ob...
  function json_ref (line 334) | static json_ref json_object_deep_copy(const json_ref& object) {
  function json_ref (line 360) | json_ref json_array(std::vector<json_ref> values) {
  function json_ref (line 364) | json_ref json_array(std::initializer_list<json_ref> values) {
  function json_array_set_template (line 368) | int json_array_set_template(const json_ref& json, const json_ref& templ) {
  function json_array_set_template_new (line 372) | int json_array_set_template_new(const json_ref& json, json_ref&& templ) {
  function json_array_get_template (line 380) | std::optional<json_ref> json_array_get_template(const json_ref& array) {
  function json_array_size (line 387) | size_t json_array_size(const json_ref& json) {
  function json_array_equal (line 395) | static int json_array_equal(const json_ref& array1, const json_ref& arra...
  function json_ref (line 412) | static json_ref json_array_deep_copy(const json_ref& array) {
  function json_ref (line 426) | json_ref w_string_to_json(w_string str) {
  function w_string (line 438) | const w_string& json_to_w_string(const json_ref& json) {
  function json_string_equal (line 446) | static int json_string_equal(const json_ref& string1, const json_ref& st...
  function json_ref (line 456) | json_ref json_integer(json_int_t value) {
  function json_int_t (line 460) | json_int_t json_integer_value(const json_ref& json) {
  function json_int_t (line 467) | json_int_t json_ref::asInt() const {
  function json_integer_equal (line 471) | static int json_integer_equal(
  function json_ref (line 481) | json_ref json_real(double value) {
  function json_real_value (line 488) | double json_real_value(const json_ref& json) {
  function json_real_equal (line 496) | static int json_real_equal(const json_ref& real1, const json_ref& real2) {
  function json_number_value (line 502) | double json_number_value(const json_ref& json) {
  function json_ref (line 513) | json_ref json_true() {
  function json_ref (line 517) | json_ref json_false() {
  function json_ref (line 521) | json_ref json_null() {
  function json_equal (line 553) | int json_equal(const json_ref& json1, const json_ref& json2) {
  function json_ref (line 581) | json_ref json_deep_copy(const json_ref& json) {

FILE: watchman/thirdparty/libart/src/art-inl.h
  function namespace (line 21) | namespace detail {
  function Node (line 103) | Node(NODE4) {
  function Node (line 214) | Node(NODE16) {
  function Node (line 361) | Node(NODE48) {

FILE: watchman/thirdparty/libart/src/art.h
  type Leaf (line 16) | struct Leaf
  type Node (line 17) | struct Node
  type Node_type (line 18) | enum Node_type : uint8_t { NODE4 = 1, NODE16, NODE48, NODE256 }
  type Deleter (line 20) | struct Deleter {
  type Node (line 30) | struct Node {
  function partial_len (line 33) | uint32_t partial_len{0}
  type Node4 (line 61) | struct Node4
  type Node16 (line 62) | struct Node16
  type Node48 (line 63) | struct Node48
  type Node256 (line 64) | struct Node256
  function IS_LEAF (line 84) | static inline bool IS_LEAF(const Node* x) {
  function Leaf (line 88) | static inline Leaf* LEAF_RAW(const Node* x) {
  function NodePtr (line 92) | static inline NodePtr LeafToNode(LeafPtr&& leaf) {
  function LeafPtr (line 96) | static inline LeafPtr NodeToLeaf(NodePtr&& node) {
  function Node (line 108) | struct Node4 : public Node {
  function Node (line 122) | struct Node16 : public Node {
  function Node (line 138) | struct Node48 : public Node {
  function Node (line 153) | struct Node256 : public Node {
  type Leaf (line 167) | struct Leaf {

FILE: watchman/thirdparty/libart/tests/runner.c
  function main (line 6) | int main(void)

FILE: watchman/thirdparty/wildmatch/wildmatch.c
  type uchar (line 24) | typedef unsigned char uchar;
  function dowild (line 67) | static int dowild(const uchar *p, const uchar *text, unsigned int flags)
  function wildmatch (line 321) | int wildmatch(const char *pattern, const char *text,

FILE: watchman/thirdparty/wildmatch/wildmatch.h
  type wildopts (line 22) | struct wildopts
  type wildopts (line 26) | struct wildopts

FILE: watchman/watcher/Watcher.cpp
  type watchman (line 10) | namespace watchman {

FILE: watchman/watcher/Watcher.h
  type watchman_file (line 18) | struct watchman_file
  function namespace (line 20) | namespace watchman {

FILE: watchman/watcher/WatcherRegistry.cpp
  function WatcherRegistry (line 41) | const WatcherRegistry* WatcherRegistry::getWatcherByName(
  function reportWatcher (line 52) | static inline std::shared_ptr<watchman::QueryableView> reportWatcher(

FILE: watchman/watcher/WatcherRegistry.h
  function namespace (line 17) | namespace watchman {

FILE: watchman/watcher/eden.cpp
  function DType (line 54) | DType getDTypeFromEden(EdenDtype dtype) {
  function SyncBehavior (line 82) | SyncBehavior getSyncBehavior() {
  type watchman (line 92) | namespace watchman {
    type NameAndDType (line 94) | struct NameAndDType {
      method NameAndDType (line 98) | explicit NameAndDType(std::string name, DType dtype = DType::Unknown)
    class SettleCallback (line 107) | class SettleCallback : public folly::HHWheelTimer::Callback {
      method SettleCallback (line 109) | SettleCallback(folly::EventBase* eventBase, std::shared_ptr<Root> root)
      method timeoutExpired (line 112) | void timeoutExpired() noexcept override {
      method callbackCanceled (line 125) | void callbackCanceled() noexcept override {
    function resolveSocketPath (line 140) | std::string resolveSocketPath(w_string_piece rootPath) {
    function getEdenSocketAddress (line 171) | folly::SocketAddress getEdenSocketAddress(w_string_piece rootPath) {
    function getEdenClient (line 181) | std::unique_ptr<StreamingEdenServiceAsyncClient> getEdenClient(
    class GetJournalPositionCallback (line 186) | class GetJournalPositionCallback : public folly::HHWheelTimer::Callback {
      method GetJournalPositionCallback (line 188) | GetJournalPositionCallback(
      method timeoutExpired (line 196) | void timeoutExpired() noexcept override {
    class EdenFileResult (line 219) | class EdenFileResult : public FileResult {
      method EdenFileResult (line 221) | EdenFileResult(
      method stat (line 254) | std::optional<FileInformation> stat() override {
      method dtype (line 262) | std::optional<DType> dtype() override {
      method size (line 278) | std::optional<size_t> size() override {
      method accessedTime (line 286) | std::optional<struct timespec> accessedTime() override {
      method modifiedTime (line 294) | std::optional<struct timespec> modifiedTime() override {
      method changedTime (line 302) | std::optional<struct timespec> changedTime() override {
      method w_string_piece (line 310) | w_string_piece baseName() override {
      method w_string_piece (line 314) | w_string_piece dirName() override {
      method setExists (line 318) | void setExists(bool exists) noexcept {
      method exists (line 325) | std::optional<bool> exists() override {
      method readLink (line 333) | std::optional<ResolvedSymlink> readLink() override {
      method ctime (line 341) | std::optional<ClockStamp> ctime() override {
      method otime (line 345) | std::optional<ClockStamp> otime() override {
      method getContentSha1 (line 349) | std::optional<FileResult::ContentHash> getContentSha1() override {
      method batchFetchProperties (line 380) | void batchFetchProperties(
      method loadSymlinkTargets (line 491) | static void loadSymlinkTargets(
      method loadFileInformation (line 506) | static void loadFileInformation(
      method applyInformationOrError (line 562) | void applyInformationOrError(const EntryInformationOrError& infoOrEr...
      method applyInformationOrError (line 571) | void applyInformationOrError(const FileInformationOrError& infoOrErr) {
    function escapeGlobSpecialChars (line 588) | static std::string escapeGlobSpecialChars(w_string_piece str) {
    function filterOutPaths (line 616) | void filterOutPaths(
    function appendGlobResultToNameAndDTypeVec (line 639) | void appendGlobResultToNameAndDTypeVec(
    function globNameAndDType (line 658) | std::vector<NameAndDType> globNameAndDType(
    function makeThriftChannel (line 738) | std::shared_ptr<apache::thrift::RequestChannel> makeThriftChannel(
    class EdenView (line 764) | class EdenView final : public QueryableView {
      method EdenView (line 766) | explicit EdenView(const w_string& root_path, const Configuration& co...
      method timeGenerator (line 780) | void timeGenerator(const Query* /*query*/, QueryContext* ctx) const ...
      method waitForSettle (line 827) | folly::SemiFuture<folly::Unit> waitForSettle(
      method syncToNow (line 835) | CookieSync::SyncResult syncToNow(
      method sync (line 846) | folly::SemiFuture<CookieSync::SyncResult> sync(
      method executeGlobBasedQuery (line 876) | void executeGlobBasedQuery(
      method w_string_piece (line 929) | w_string_piece computeRelativePathPiece(QueryContext* ctx) const {
      method pathGenerator (line 939) | void pathGenerator(const Query* query, QueryContext* ctx) const over...
      method globGenerator (line 982) | void globGenerator(const Query* query, QueryContext* ctx) const over...
      method allFilesGenerator (line 1011) | void allFilesGenerator(const Query*, QueryContext* ctx) const overri...
      method ClockPosition (line 1033) | ClockPosition getMostRecentRootNumberAndTickValue() const override {
      method w_string (line 1041) | w_string getCurrentClockString() const override {
      method doAnyOfTheseFilesExist (line 1045) | bool doAnyOfTheseFilesExist(
      method startThreads (line 1050) | void startThreads(const std::shared_ptr<Root>& root) override {
      method stopThreads (line 1056) | void stopThreads(std::string_view /*reason*/) override {
      method json_ref (line 1060) | json_ref getWatcherDebugInfo() const override {
      method clearWatcherDebugInfo (line 1064) | void clearWatcherDebugInfo() override {}
      method EdenFSSubcription (line 1069) | EdenFSSubcription rocketSubscribe(
      method subscriberThread (line 1137) | void subscriberThread(std::shared_ptr<Root> root) noexcept {
      method w_string (line 1179) | const w_string& getName() const override {
      method waitUntilReadyToQuery (line 1184) | folly::SemiFuture<folly::Unit> waitUntilReadyToQuery() override {
      method getGlobPatternsForAllFiles (line 1194) | std::vector<std::string> getGlobPatternsForAllFiles(QueryContext* ct...
      method isSimpleSuffixQuery (line 1233) | bool isSimpleSuffixQuery(QueryContext* ctx) const {
      method getSuffixQueryGlobPatterns (line 1245) | std::vector<std::string> getSuffixQueryGlobPatterns(QueryContext* ct...
      method getSuffixQueryRelativeRoot (line 1249) | std::string getSuffixQueryRelativeRoot(QueryContext* ctx) const {
      method getAllFilesForFreshInstance (line 1259) | std::vector<NameAndDType> getAllFilesForFreshInstance(
      type GetAllChangesSinceResult (line 1285) | struct GetAllChangesSinceResult {
      method GetAllChangesSinceResult (line 1294) | GetAllChangesSinceResult makeFreshInstance(QueryContext* ctx) const {
      method GetAllChangesSinceResult (line 1304) | GetAllChangesSinceResult getAllChangesSinceStreaming(
      method GetAllChangesSinceResult (line 1422) | GetAllChangesSinceResult getAllChangesSince(QueryContext* ctx) const {
    function isEdenStopped (line 1484) | bool isEdenStopped(w_string root) {
    function isProjfs (line 1513) | bool isProjfs(const w_string& path) {
    function findEdenFSRoot (line 1523) | std::optional<w_string> findEdenFSRoot(w_string_piece root_path) {
    function detectEden (line 1545) | std::shared_ptr<QueryableView> detectEden(

FILE: watchman/watcher/fsevents.cpp
  type watchman (line 33) | namespace watchman {
    type CFDeleter (line 41) | struct CFDeleter {
    type FSEventsStream (line 52) | struct FSEventsStream {
      method FSEventsStream (line 63) | FSEventsStream(
    type FSEventsLogEntry (line 102) | struct FSEventsLogEntry {
      method FSEventsLogEntry (line 106) | FSEventsLogEntry() = default;
      method FSEventsLogEntry (line 108) | explicit FSEventsLogEntry(uint32_t flags, const char* name) noexcept {
      method json_ref (line 114) | json_ref asJsonValue() {
    function watcherFromRoot (line 129) | std::shared_ptr<FSEventsWatcher> watcherFromRoot(
    function log_drop_event (line 140) | static void log_drop_event(const std::shared_ptr<Root>& root, bool isK...
    function fse_pipe_callback (line 315) | static void fse_pipe_callback(CFFileDescriptorRef, CFOptionFlags, void...
    type stat (line 342) | struct stat
    function isRootRemoved (line 684) | bool isRootRemoved(
    function json_ref (line 830) | json_ref FSEventsWatcher::getDebugInfo() {
    function UntypedResponse (line 859) | UntypedResponse FSEventsWatcher::cmd_debug_fsevents_inject_drop(

FILE: watchman/watcher/fsevents.h
  function namespace (line 18) | namespace watchman {

FILE: watchman/watcher/inotify.cpp
  type flag_map (line 44) | struct flag_map
  type pending_move (line 64) | struct pending_move {
    method pending_move (line 68) | pending_move(
  type InotifyLogEntry (line 77) | struct InotifyLogEntry {
    method InotifyLogEntry (line 81) | InotifyLogEntry() = default;
    method InotifyLogEntry (line 83) | explicit InotifyLogEntry(inotify_event* evt) noexcept {
    method json_ref (line 98) | json_ref asJsonValue() {
    method w_string_piece (line 110) | w_string_piece namePiece() const {
  type InotifyWatcher (line 125) | struct InotifyWatcher : public Watcher {
    type maps (line 141) | struct maps {
    type inotify_event (line 153) | struct inotify_event
    type inotify_event (line 173) | struct inotify_event
  type inotify_event (line 237) | struct inotify_event
  type inotify_event (line 422) | struct inotify_event
  type inotify_event (line 426) | struct inotify_event
  type pollfd (line 465) | struct pollfd
  function json_ref (line 487) | json_ref InotifyWatcher::getDebugInfo() {
  function detectInotify (line 513) | std::shared_ptr<QueryableView> detectInotify(

FILE: watchman/watcher/kqueue.cpp
  type watchman (line 27) | namespace watchman {
    type KQueueUdata (line 31) | enum KQueueUdata {
    function is_udata_dir (line 35) | bool is_udata_dir(void* udata) {
    type flag_map (line 49) | struct flag_map
    type watchman_file (line 71) | struct watchman_file
    type kevent (line 72) | struct kevent
    type stat (line 109) | struct stat
    type stat (line 162) | struct stat
    type kevent (line 163) | struct kevent
    type timespec (line 229) | struct timespec
    type kevent (line 274) | struct kevent
    type pollfd (line 314) | struct pollfd

FILE: watchman/watcher/kqueue.h
  function namespace (line 15) | namespace watchman {

FILE: watchman/watcher/kqueue_and_fsevents.cpp
  type watchman (line 23) | namespace watchman {
    class PendingEventsCond (line 25) | class PendingEventsCond {
      method notifyOneOrStop (line 32) | bool notifyOneOrStop() {
      method shouldStop (line 45) | bool shouldStop() {
      method waitAndClear (line 53) | bool waitAndClear(int timeoutms) {
      method stopAll (line 65) | void stopAll() {
      type Inner (line 72) | struct Inner {
    class KQueueAndFSEventsWatcher (line 87) | class KQueueAndFSEventsWatcher : public Watcher {
      type watchman_file (line 101) | struct watchman_file
    function startThread (line 135) | bool startThread(
    type watchman_file (line 227) | struct watchman_file
    function makeKQueueAndFSEventsWatcher (line 297) | std::shared_ptr<InMemoryView> makeKQueueAndFSEventsWatcher(
    function watcherFromRoot (line 318) | std::shared_ptr<KQueueAndFSEventsWatcher> watcherFromRoot(
    function UntypedResponse (line 329) | static UntypedResponse cmd_debug_kqueue_and_fsevents_recrawl(

FILE: watchman/watcher/portfs.cpp
  type watchman_port_file (line 20) | struct watchman_port_file {
  type PortFSWatcher (line 29) | struct PortFSWatcher : public Watcher {
    type watchman_file (line 52) | struct watchman_file
  type flag_map (line 66) | struct flag_map
  function make_port_file (line 78) | static std::unique_ptr<watchman_port_file> make_port_file(
  type stat (line 150) | struct stat
  type watchman_file (line 176) | struct watchman_file
  type stat (line 188) | struct stat
  type timeval (line 215) | struct timeval
  type watchman_port_file (line 247) | struct watchman_port_file
  type watchman_port_file (line 251) | struct watchman_port_file
  type pollfd (line 280) | struct pollfd

FILE: watchman/watcher/win32.cpp
  type Item (line 31) | struct Item {
    method Item (line 35) | Item(w_string&& path, PendingFlags flags)
  type WinWatcher (line 41) | struct WinWatcher : public Watcher {

FILE: watchman/watchman_cmd.h
  function namespace (line 16) | namespace watchman {

FILE: watchman/watchman_dir.h
  type watchman_file (line 12) | struct watchman_file
  type watchman_dir (line 14) | struct watchman_dir {

FILE: watchman/watchman_file.h
  type watchman_file (line 21) | struct watchman_file
  type watchman_file (line 57) | struct watchman_file

FILE: watchman/watchman_stream.h
  function class (line 18) | class Event {
  type EventPoll (line 41) | struct EventPoll {

FILE: watchman/watchman_string.h
  type w_string_type_t (line 28) | enum w_string_type_t : uint8_t {
  function format_as (line 39) | inline uint8_t format_as(w_string_type_t type) {
  function namespace (line 43) | namespace watchman {
  function is_slash (line 149) | inline bool is_slash(char c) {
  function class (line 162) | class w_string_piece {
  function w_string (line 457) | w_string rv{s}; // Will deallocate if fn fails.
  function w_string (line 486) | w_string format(fmt::string_view format_str, Args&&... args) {
  function w_string (line 519) | w_string dirName() const;
  function namespace (line 552) | namespace fmt {

FILE: watchman/watchman_time.h
  function timespec (line 17) | timespec ts{0, 0};
  function timespec (line 33) | inline timespec systemClockToTimeSpec(
  function w_timeval_compare (line 43) | static inline int w_timeval_compare(struct timeval a, struct timeval b) {
  function w_timeval_add (line 73) | static inline void w_timeval_add(
  function w_timeval_sub (line 86) | static inline void w_timeval_sub(
  function w_timeval_to_timespec (line 99) | static inline void w_timeval_to_timespec(
  function w_timespec_to_timeval (line 110) | static inline void w_timespec_to_timeval(
  function w_timeval_abs_seconds (line 122) | static inline double w_timeval_abs_seconds(struct timeval tv) {
  function w_timeval_diff (line 128) | static inline double w_timeval_diff(struct timeval start, struct timeval...

FILE: watchman/winbuild/susres.cpp
  function apply (line 32) | int apply(DWORD pid, BOOL suspend) {
  function usage (line 67) | void usage() {
  function main (line 74) | int main(int argc, char** argv) {

FILE: website/.eslintrc.js
  constant OFF (line 10) | const OFF = 0;
  constant WARNING (line 11) | const WARNING = 1;
  constant ERROR (line 12) | const ERROR = 2;

FILE: website/docusaurus.config.js
  constant CATEGORY_ORDER (line 12) | const CATEGORY_ORDER = [
  method sidebarItemsGenerator (line 50) | async sidebarItemsGenerator({

FILE: website/src/pages/index.js
  function HomepageHeader (line 17) | function HomepageHeader() {
  function Home (line 38) | function Home() {