# Copyright 2022 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/compiled_action.gni")
import("//build/config/clang/clang.gni")
import("//build/cpp/library_headers.gni")
import("//build/go/go_library.gni")
import("//build/toolchain/toolchain_environment.gni")
import("//build/toolchain/zircon/user_basic_redirect.gni")

if (support_rust) {
  import("//build/rust/config.gni")
  import("//build/rust/rustc_library.gni")
}

# TODO(https://fxbug.dev/42172629, https://fxbug.dev/42175173): "cpp"
supported_zither_backends = [
  "asm",  # Assembly data layout bindings.
  "c",  # C data layout bindings.
  "go",  # Go data layout bindings.
  "legacy_syscall_cdecl",  # Legacy C syscall declarations.
  "zircon_ifs",  # Syscall text ABI bindings.
  "kernel",  # Internal kernel bindings.
  "go_runtime",  # go.git source files for Fuchsia support.
  "syscall_docs",  # Syscall documentation markdown.
]

if (support_rust) {
  supported_zither_backends += [
    "rust",  # Rust data layout bindings.
    "rust_syscall",  # Thin Rust FFI syscall wrappers.
  ]
}

_clang_format = {
  script = "$clang_prefix/clang-format"
  inputs = [ "//.clang-format" ]
  args = [ "--style=file:" + rebase_path(inputs[0], root_build_dir) ]
  extensions = [ ".h" ]
}

_gofmt = {
  script = "//prebuilt/third_party/go/$host_platform/bin/gofmt"

  # The go backends emits both go and non-go files (e.g., text and assembly);
  # restrict the use of the formatter to the go files.
  extensions = [ "go" ]
}

if (support_rust) {
  _rustfmt = {
    script = "$rustc_prefix/bin/rustfmt"
    inputs = [ "//rustfmt.toml" ]
    args = [ "--config-path=" + rebase_path(inputs[0], root_build_dir) ]
  }
}

# Information on supported backends, accessible via
# `supported_zither_backend_info[ "$backend" ]`.
#
# Each backend scope contains the following:
#
#  * output_namespace
#    - Required: Describes the output subdirectory of the output directory
#      passed to zither in which the backend artifacts will be written. This
#      subdirectory has backend-specific significance as an C include path,
#      Go package name, etc. Given a FIDL library name `library_name` and
#      referring to this scope as `output_namespace_info`, one can reconstruct
#      this path as follows:
#      ```
#      output_namespace_info = {
#        prefix_parts = []
#        suffix_parts = []
#        part_separator = "/"
#        forward_variables_from(backend_info.output_namespace, "*")
#        parts = prefix_parts
#        if (defined(library_name_separator)) {
#         parts += [ string_replace(library_name, ".", library_name_separator) ]
#        }
#        path += suffix_parts
#        path = string_join(part_separator, parts)
#      }
#      output_namespace = output_namespace_info.path
#      ```
#    - Type: scope
#
#    The scope contains the following:
#      * prefix_parts
#        - Optional: The path parts that prefix the output subdirectory.
#        - Type: list(string)
#        - Default: []
#
#      * library_name_separator
#        - Optional: The separator with which the '.'-separated tokens of the
#          FIDL library name should be joined in the output subdirectory
#          namespace (in between the prefix and suffix parts ). A value of "."
#          will just use the library name unchanged as path token.
#        - Type: string
#
#      * suffix_parts
#        - Optional: The path parts that suffix the output subdirectory.
#        - Type: list(string)
#        - Default: []
#
#      * part_separator
#        - Optional: The path part separator.
#        - Type: string
#        - Default: "/"
#
#  * formatter
#    - Optional: A formatting specification for Zither outputs. The shape and
#      semantics of this parameter are identical to the `formatter` parameter
#      of `golden_files()`. While `formatter.extensions` is not consumed by
#      Zither - it makes sure to only format the appropriate files - it is
#      consumed in zither_golden_files() for the formatting of goldens outside
#      of Zither.
#    - Type: scope
#
supported_zither_backend_info = {
  c = {
    output_namespace = {
      prefix_parts = [ "fidl" ]
      library_name_separator = "."
      suffix_parts = [
        "data",
        "c",
      ]
      supports_override = true
    }
    formatter = _clang_format

    _library_template = "_zither_c_family_library"
  }
  asm = {
    output_namespace = {
      prefix_parts = [ "fidl" ]
      library_name_separator = "."
      suffix_parts = [
        "data",
        "asm",
      ]
      supports_override = true
    }
    formatter = _clang_format

    _library_template = "_zither_c_family_library"
  }
  go = {
    output_namespace = {
      prefix_parts = [
        "fidl",
        "data",
      ]
      library_name_separator = "/"
    }
    formatter = _gofmt

    _library_template = "_zither_go_library"
  }
  if (support_rust) {
    rust = {
      output_namespace = {
        prefix_parts = [
          "fidl",
          "data",
        ]
        library_name_separator = "-"
        part_separator = "-"
      }
      formatter = _rustfmt
      _library_template = "_zither_rust_library"
    }
  }
  zircon_ifs = {
    output_namespace = {
    }
    _library_template = "_zither_zircon_ifs_file"
  }

  kernel = {
    formatter = _clang_format
    output_namespace = {
      prefix_parts = [
        "lib",
        "syscalls",
      ]
    }

    _library_template = "_zither_kernel_sources"
  }

  legacy_syscall_cdecl = {
    formatter = _clang_format
    output_namespace = {
      prefix_parts = [
        "zircon",
        "syscalls",
        "internal",
      ]
    }
    _library_template = "_zither_legacy_syscall_cdecl_sources"
  }

  if (support_rust) {
    rust_syscall = {
      output_namespace = {
        library_name_separator = "-"
      }
      formatter = _rustfmt
      _library_template = "_zither_rust_library"
    }
  }

  go_runtime = {
    output_namespace = {
    }
    formatter = _gofmt
    _library_template = "_zither_go_runtime_sources"
  }

  syscall_docs = {
    output_namespace = {
    }
    _library_template = "_zither_syscall_docs"
  }
}

# Internal Zither invocation helper template used by `zither_library()`.
#
# Parameters:
#
#  * backend
#    - Required: The Zither backend to invoke.
#    - Type: string
#
#  * fidl_ir_json
#    - Required: The path to the associated FIDL IR JSON file.
#    - Type: path
#
#  * fidl_ir_target
#    - Required: The label of the target that generates the FIDL IR JSON file.
#    - Type: label
#
#  * output_dir
#    - Required: The directory for Zither outputs.
#    - Type: path
#
#  * generated_files
#    - Required: The expected set of Zither outputs, which necessarily must
#      start with "$output_dir/".
#    - Type: list(path)
#
#  * formatter
#    - Optional: See `supported_zither_backend_info`.
#    - Type: scope.
#
#  * testonly, visibility, deps
#    - Usual GN meanings. `deps` is just expected to contain whatever produced
#      the FIDL IR file.
#
template("_zither") {
  if (current_toolchain == default_toolchain) {
    forward_variables_from(invoker,
                           [
                             "generated_files",
                             "backend",
                             "output_dir",
                             "output_namespace_override",
                             "formatter",
                           ])

    main_target = target_name

    # Internal subtarget used to check that a given backend's outputs were
    # fully specified; used for testing.
    output_check_target = "$target_name.check"

    output_manifest = "$output_dir/outputs.json"

    compiled_action(main_target) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "fidl_ir_json",
                               "fidl_ir_target",
                             ])
      visibility = [ ":*" ]

      tool = "//zircon/tools/zither"
      mnemonic = "ZITHER"

      inputs = [ fidl_ir_json ]

      # Ensure that outputs.json is first so that related template internals
      # may readily access it.
      outputs = [ output_manifest ] + generated_files
      args = [
        "-ir",
        rebase_path(fidl_ir_json, root_build_dir),
        "-backend",
        backend,
        "-output-manifest",
        rebase_path(output_manifest, root_build_dir),
        "-output-dir",
        rebase_path(output_dir, root_build_dir),
        "-source-dir",
        rebase_path("//", root_build_dir),
      ]

      if (defined(output_namespace_override)) {
        args += [
          "-output-namespace",
          output_namespace_override,
        ]
      }

      if (defined(formatter)) {
        inputs += [ formatter.script ]
        args += [
          "-formatter",
          rebase_path(formatter.script, root_build_dir),
        ]
        if (defined(formatter.args)) {
          args += [ "-formatter-args" ] + formatter.args
        }
        if (defined(formatter.inputs)) {
          inputs += formatter.inputs
        }
      }
      deps = [ fidl_ir_target ]
    }

    # Ensures that the outputs were fully specified above.
    action(output_check_target) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])

      script = "//zircon/tools/zither/scripts/check-outputs.py"

      # Stamp file.
      outputs = [ "$target_gen_dir/$output_check_target.stamp" ]

      inputs = generated_files + [ output_manifest ]
      args = [
               "--stamp",
               rebase_path(outputs[0], root_build_dir),
               "--manifest",
               rebase_path(output_manifest, root_build_dir),
             ] + rebase_path(generated_files, root_build_dir)
      deps = [ ":$main_target" ]
    }
  } else {
    group(target_name) {
      forward_variables_from(invoker, [ "testonly" ])
      visibility = [ ":*" ]
      deps = [ ":$target_name($default_toolchain)" ]
    }
    not_needed(invoker, "*", [ "testonly" ])
  }
}

#
# Internal language library helper templates used by `zither_library()`.
#
# Parameters:
#
#  * source_names
#    - Required: The list of the basenames (i.e., stripped of .fidl and
#      .test.fidl extensions) of the source FIDL files.
#
#  * output_namespace
#    - Required: The subdirectory of `output_dir` that has the Zither outputs
#      for entries.
#    - Type: relative path
#
#  * fidl_ir_json, fidl_ir_target, output_dir, formatter
#    - Same as `_zither()`.
#
#  * testonly, visibility, deps
#    - Usual GN meanings.
#

template("_zither_c_family_library") {
  main_target = target_name
  zither_target = "$target_name.gen"

  forward_variables_from(invoker,
                         [
                           "source_names",
                           "output_dir",
                           "output_namespace",
                         ])

  generated_files = []
  foreach(name, source_names) {
    generated_files += [ "${output_dir}/${output_namespace}/${name}.h" ]
  }
  if (invoker.backend == "c") {
    generated_files += [ "${output_dir}/README.md" ]
  }

  _zither(zither_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "deps",
                             "fidl_ir_json",
                             "fidl_ir_target",
                             "generated_files",
                             "backend",
                             "formatter",
                           ])
    if (defined(invoker.output_namespace_override) &&
        invoker.output_namespace_override) {
      output_namespace_override = output_namespace
    }
  }

  library_headers(main_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "generated_files",
                           ])
    include_dir = output_dir
    headers = rebase_path(generated_files, include_dir)
    deps = [
      ":${zither_target}($default_toolchain)",
      ":${zither_target}.check($default_toolchain)",
    ]
  }
}

template("_zither_go_library") {
  assert(invoker.backend == "go")

  main_target = target_name
  zither_target = "$target_name.gen"

  forward_variables_from(invoker,
                         [
                           "source_names",
                           "output_dir",
                           "output_namespace",
                         ])

  generated_files = [ "${output_dir}/${output_namespace}/pkg_name.txt" ]
  foreach(name, source_names) {
    generated_files += [ "${output_dir}/${output_namespace}/${name}.go" ]
  }

  _zither(zither_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "deps",
                             "fidl_ir_json",
                             "fidl_ir_target",
                             "generated_files",
                             "formatter",
                           ])
    backend = "go"
  }

  go_library(main_target) {
    forward_variables_from(invoker,
                           [
                             "visibility",
                             "testonly",
                             "generated_files",
                           ])
    name = output_namespace
    source_dir = "${output_dir}/${output_namespace}"
    sources = rebase_path(generated_files, source_dir)
    non_go_deps = [
      ":${zither_target}($default_toolchain)",
      ":${zither_target}.check($default_toolchain)",
    ]
  }
}

if (support_rust) {
  template("_zither_rust_library") {
    assert(invoker.backend == "rust" || invoker.backend == "rust_syscall")

    main_target = target_name
    zither_target = "$target_name.gen"

    forward_variables_from(invoker,
                           [
                             "source_names",
                             "output_namespace",
                           ])

    # Underscore to prevent rustc_library() from thinking that this value is a
    # specification of output_dir for the associated rlib.
    _output_dir = invoker.output_dir

    generated_files = []
    if (invoker.backend == "rust_syscall") {
      crate_name = "fuchsia-zircon-sys"
      crate_root = "${_output_dir}/${output_namespace}/src/definitions.rs"
      crate_deps = [ "//src/lib/zircon/rust:fuchsia-zircon-types" ]
      not_needed([ "source_names" ])
    } else {
      foreach(name, source_names) {
        name = string_replace(name, "-", "_")
        generated_files +=
            [ "${_output_dir}/${output_namespace}/src/${name}.rs" ]
      }
      crate_name = output_namespace
      crate_root = "${_output_dir}/${output_namespace}/src/lib.rs"
      crate_deps = [
        "//third_party/rust_crates:bitflags",
        "//third_party/rust_crates:zerocopy",
      ]
    }
    generated_files += [ crate_root ]

    _zither(zither_target) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                               "deps",
                               "fidl_ir_json",
                               "fidl_ir_target",
                               "generated_files",
                               "backend",
                               "formatter",
                               "output_dir",
                             ])
    }

    rustc_library(main_target) {
      forward_variables_from(invoker,
                             [
                               "visibility",
                               "testonly",
                             ])
      name = crate_name
      edition = "2021"
      source_root = crate_root

      # Namespace by target so that there is no rlib collision between fidl()
      # targets in the same file.
      output_dir = "$target_out_dir/$main_target"

      sources = generated_files
      non_rust_deps = [
        ":${zither_target}($default_toolchain)",
        ":${zither_target}.check($default_toolchain)",
      ]
      deps = crate_deps
      configs -= [ "//build/config/rust/lints:allow_unused_results" ]
      disable_clippy = true
    }
  }
}

template("_zither_zircon_ifs_file") {
  assert(invoker.backend == "zircon_ifs")

  main_target = target_name
  zither_target = "$target_name.gen"

  not_needed(invoker, [ "source_names" ])

  forward_variables_from(invoker, [ "output_dir" ])
  ifs_file = "${output_dir}/zircon.ifs"
  json_file = "${output_dir}/libzircon.json"

  _zither(zither_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "deps",
                             "fidl_ir_json",
                             "fidl_ir_target",
                           ])
    backend = "zircon_ifs"
    generated_files = [
      ifs_file,
      json_file,
    ]
  }

  group(main_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    public_deps = [
      ":${zither_target}($default_toolchain)",
      ":${zither_target}.check($default_toolchain)",
    ]

    metadata = {
      link_output_barrier = []
      link_output_path = [ rebase_path(ifs_file, root_build_dir) ]
    }
  }
}

template("_zither_kernel_sources") {
  assert(invoker.backend == "kernel")

  main_target = target_name
  zither_target = "$target_name.gen"

  not_needed(invoker, [ "source_names" ])

  forward_variables_from(invoker,
                         [
                           "output_dir",
                           "output_namespace",
                         ])
  generated_files = [
    "$output_dir/${output_namespace}/category.inc",
    "$output_dir/${output_namespace}/kernel.inc",
    "$output_dir/${output_namespace}/kernel-wrappers.inc",
    "$output_dir/${output_namespace}/syscalls.inc",
    "$output_dir/${output_namespace}/zx-syscall-numbers.h",
  ]

  _zither(zither_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "deps",
                             "backend",
                             "fidl_ir_json",
                             "fidl_ir_target",
                             "generated_files",
                             "formatter",
                           ])
  }

  library_headers(main_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "generated_files",
                           ])
    include_dir = output_dir
    headers = rebase_path(generated_files, include_dir)
    deps = [
      ":${zither_target}($default_toolchain)",
      ":${zither_target}.check($default_toolchain)",
    ]
  }
}

template("_zither_legacy_syscall_cdecl_sources") {
  assert(invoker.backend == "legacy_syscall_cdecl")

  main_target = target_name
  zither_target = "$target_name.gen"
  headers_target = "$target_name.headers"

  not_needed(invoker, [ "source_names" ])

  forward_variables_from(invoker,
                         [
                           "output_dir",
                           "output_namespace",
                         ])
  generated_files = [
    "$output_dir/${output_namespace}/cdecls.inc",
    "$output_dir/${output_namespace}/cdecls-next.inc",
    "$output_dir/${output_namespace}/testonly-cdecls.inc",
  ]

  _zither(zither_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "deps",
                             "backend",
                             "fidl_ir_json",
                             "fidl_ir_target",
                             "generated_files",
                             "formatter",
                           ])
  }

  # HACK: Our build's redefinition of `source_set()` automatically includes
  # a dependency on the Zircon public headers in the conventional, Fuchsia
  # toolchains, which in turn depend on this target. Such a dependency is not
  # conferred in the user.basic toolchain.
  if (toolchain_environment == "user.basic") {
    library_headers(headers_target) {
      visibility = [ ":*" ]
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "generated_files",
                             ])
      include_dir = output_dir
      headers = rebase_path(generated_files, include_dir)
      public_deps = [ ":${zither_target}($default_toolchain)" ]
      deps = [ ":${zither_target}.check($default_toolchain)" ]
    }
  } else {
    not_needed(invoker, "*")
    not_needed("*")
  }

  user_basic_redirect(main_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    public_deps = [ ":$headers_target" ]
  }
}

template("_zither_go_runtime_sources") {
  assert(invoker.backend == "go_runtime")

  main_target = target_name
  zither_target = "$target_name.gen"

  not_needed(invoker, [ "source_names" ])

  _zither(zither_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "deps",
                             "fidl_ir_json",
                             "fidl_ir_target",
                             "formatter",
                             "output_dir",
                           ])
    backend = "go_runtime"
    generated_files = [
      "${output_dir}/src/runtime/vdso_keys_fuchsia.go",
      "${output_dir}/src/runtime/vdsocalls_fuchsia_amd64.s",
      "${output_dir}/src/runtime/vdsocalls_fuchsia_arm64.s",
      "${output_dir}/src/syscall/zx/syscalls_fuchsia_amd64.s",
      "${output_dir}/src/syscall/zx/syscalls_fuchsia_arm64.s",
      "${output_dir}/src/syscall/zx/syscalls_fuchsia.go",
    ]
  }

  group(main_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    deps = [
      ":${zither_target}($default_toolchain)",
      ":${zither_target}.check($default_toolchain)",
    ]
  }
}

template("_zither_syscall_docs") {
  assert(invoker.backend == "syscall_docs")

  main_target = target_name
  zither_target = "$target_name.gen"

  not_needed(invoker, [ "source_names" ])

  _zither(zither_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "deps",
                             "fidl_ir_json",
                             "fidl_ir_target",
                             "output_dir",
                           ])
    backend = "syscall_docs"

    # The set of generated files is not statically known and is instead
    # dynamically determined from zither's output manifest, outputs.json.
    generated_files = []
  }

  group(main_target) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])

    # We purposefully do not depend on
    # ":${zither_target}.check($default_toolchain)" as we do not statically
    # know the set of backend outputs in GN.
    public_deps = [ ":${zither_target}($default_toolchain)" ]
  }
}

# Define a full set of per-backend targets for a Zither library.
#
# `zither_library()` is meant to be instantiated within `fidl()`. It consumes
# FIDL source and defines the relevant language library targets that collect
# the bindings of the various supported Zither backends. These backends are
# listed in `supported_zither_backends` and the details of their bindings can
# be found in //zircon/tools/zither/README.md. The associated backend library
# subtargets are as follows where `${output_namespace}` is as described above in
# `supported_zither_backend_info`:
#
# Subtargets:
#  * ${target_name}.${backend_name}
#    Each supported backend, corresponding to a named entry of
#    `supported_zither_backends`, yields a subtarget for generating the
#    associated bindings. For more information about a given backend's set of
#    bindings see //zircon/tools/zither/backends/${backend_name}/README.md.
#
# Parameters - supplied indirectly via fidl():
#
#  * library_name
#    - Required: The name of the FIDL library.
#    - Type: string
#
#  * sources
#    - Required: The input FIDL sources, comprising one library necessarily of the
#      name $target_name.
#    - Type: list(path)
#
#  * fidl_gen_dir
#    - Required: The directory under which Zither outputs should be generated.
#    - Type: path
#
#  * fidl_ir_json
#    - Required: The path to the associated FIDL IR JSON file.
#    - Type: path
#
#  * fidl_ir_target
#    - Required: The label of the target that generates the FIDL IR JSON file.
#    - Type: label
#
# Parameters - supplied directly via `fidl() { zither = {...} }`:
#
#  * ${backend_name}
#    - Optional: Additional backend-specific parameters
#    - Type: scope
#
#    Each scope contains:
#    * output_namespace
#      - Optional: This is the namespace/layout under which backend outputs are
#        generated within the specified output directory. By default, this is
#        backend-specific. The value can determine the name of the resulting
#        library/package/crate/etc. (when a function of source layout), as well
#        as the 'include' namespace of the headers generated by a C family
#        backend. A backend only supports this parameter if
#        `supported_zither_backend_info["$backend_name"].output_namespace.supports_overrides`
#        is defined and true.
#      - Type: string or relative path
#
template("zither_library") {
  assert(defined(invoker.sources),
         "zither_library(\"$target_name\") requires `sources`")
  assert(defined(invoker.library_name),
         "zither_library(\"target_name\") must define `library_name`")
  assert(defined(invoker.fidl_gen_dir),
         "zither_library(\"target_name\") must define `fidl_gen_dir`")
  assert(defined(invoker.fidl_ir_json),
         "zither_library(\"target_name\") must define `fidl_ir_json`")
  assert(defined(invoker.fidl_ir_target),
         "zither_library(\"target_name\") must define `fidl_ir_target`")

  foreach(backend, supported_zither_backends) {
    backend_info = {
    }  # Clear from previous iteration.
    backend_info = supported_zither_backend_info[backend]

    target(backend_info._library_template, "${target_name}.${backend}") {
      forward_variables_from(invoker,
                             [
                               "backend",
                               "fidl_gen_dir",
                               "fidl_ir_json",
                               "fidl_ir_target",
                               "testonly",
                               "visibility",
                             ])
      forward_variables_from(backend_info, [ "formatter" ])

      output_dir = "${fidl_gen_dir}/${backend}"

      # TODO(crbug.com/gn/328): For some reason, replacing the predicate with
      # `defined(invoker[backend])` yields an "Assignment had no effect..."
      # error.
      if ({
            forward_variables_from(invoker, [ backend ])
          } !=
          {
          }) {
        forward_variables_from(invoker[backend], "*")
      }

      if (defined(output_namespace)) {
        output_namespace_info = backend_info.output_namespace
        assert(
            defined(output_namespace_info.supports_override) &&
                output_namespace_info.supports_override,
            "Zither backend \"$backend\" does not support output namespace overrides (\"$output_namespace\")")
        output_namespace_override = true
      } else {
        output_namespace_info = {
          prefix_parts = []
          suffix_parts = []
          part_separator = "/"
          forward_variables_from(backend_info.output_namespace, "*")
          parts = prefix_parts
          if (defined(library_name_separator)) {
            parts += [ string_replace(invoker.library_name,
                                      ".",
                                      library_name_separator) ]
          }
          parts += suffix_parts
          path = string_join(part_separator, parts)
        }
        if (output_namespace_info.path != "") {
          output_namespace = output_namespace_info.path
        }
      }

      source_names = []
      foreach(source, invoker.sources) {
        # Strip any .fidl or .test.fidl extensions.
        name = get_path_info(source, "name")
        if (get_path_info(name, "extension") == "test") {
          name = get_path_info(name, "name")
        }

        # Ignore overview.fidl files, which do not contribute declarations:
        #
        # See https://fuchsia.dev/fuchsia-src/development/languages/fidl/guides/style#library-overview.
        if (name != "overview") {
          source_names += [ name ]
        }
      }
    }
  }
}