third_party/gn/abseil-cpp/BUILD.gn

# Copyright 2021 The Dawn & Tint Authors
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
#    list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
#    this list of conditions and the following disclaimer in the documentation
#    and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its
#    contributors may be used to endorse or promote products derived from
#    this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# This file exists for two reasons:
# a) it allows for when using Dawn outside of Chromium to only include
#    the minimal amount of abseil needed (Chromium already includes
#    all of abseil, so there is no need to minimize there)
# b) addresses the fact that the BUILD.gn files supplied via Chromium
#    for abseill are opinionated on exactly where the checkout of
#    abseil should be, and some embedders (i.e. Skia) use a different
#    location.

import("../../../scripts/dawn_overrides_with_defaults.gni")

import("${dawn_root}/scripts/dawn_features.gni")

config("absl_config") {
  if (!build_with_chromium && is_clang) {
    cflags = [
      # Allow the use of enable_if()
      "-Wno-gcc-compat",
      "-Wno-unreachable-code-break",

      # Allows use of _Nullable, _Nonnull & _Null_unspecified
      "-Wno-nullability-extension",

      # vlog has some shadowing, which Windows Clang doesn't like
      "-Wno-shadow",
    ]
  }

  include_dirs = [ "${dawn_abseil_dir}" ]
}

template("absl_source_set") {
  source_set(target_name) {
    forward_variables_from(invoker, "*")

    if (!defined(public_configs)) {
      public_configs = []
    }
    public_configs += [ ":absl_config" ]
  }
}

#
# absl
#

# Includes only what is defined in this file, not all deps from the
# original abseil GN file. If there are missing dependencies when
# using this target that indicates they need to be ported over.
#
# DO NOT DEPEND ON THIS IN DAWN CODE
#
# This exists only for third party dependencies that need it. When
# using abseil in Dawn, use depend directly on the target that is
# needed
source_set("absl") {
  public_deps = [ ":absl_component_deps" ]
}

# Commented out deps are targets that exist in the original BUILD.gn,
# but currently do not have an equivalent here. DO NOT just uncomment
# them, since that will cause symbol duplication issues. The rules
# will need to be ported to this file to use.
group("absl_component_deps") {
  public_deps = [
    ":absl_check",
    ":absl_log",
    ":absl_vlog_is_on",
    ":algorithm",
    ":any_invocable",
    ":base",
    ":bits",
    ":cleanup",
    ":config",
    ":container",
    ":cord",
    ":core_headers",
    ":die_if_null",

    # "//third_party/abseil-cpp/absl/container:btree",
    ":fixed_array",
    ":flat_hash_map",
    ":flat_hash_set",

    # "//third_party/abseil-cpp/absl/functional:bind_front",
    ":function_ref",
    ":has_ostream_operator",

    # "//third_party/abseil-cpp/absl/functional:overload",
    ":hash",
    ":inlined_vector",
    ":int128",
    ":log_entry",
    ":log_globals",
    ":log_initialize",
    ":log_severity",
    ":log_sink",
    ":log_sink_registry",
    ":memory",
    ":no_destructor",
    ":nullability",
    ":optional",
    ":prefetch",
    ":span",

    # "//third_party/abseil-cpp/absl/container:node_hash_map",
    # "//third_party/abseil-cpp/absl/container:node_hash_set",
    # "//third_party/abseil-cpp/absl/debugging:failure_signal_handler",
    ":stacktrace",

    # "//third_party/abseil-cpp/absl/random",
    # "//third_party/abseil-cpp/absl/random:bit_gen_ref",
    # "//third_party/abseil-cpp/absl/random:distributions",
    ":status",
    ":statusor",
    ":str_format",
    ":string_view",
    ":strings",
    ":symbolize",
    ":synchronization",
    ":time",
    ":type_traits",
    ":utility",
    ":variant",
  ]

  # Dependencies that preferably shouldn't be public in chromium.
  public_deps += [
    # public in abseil, but deprecated in chromium, yet used.
    ":dynamic_annotations",

    # base/logging.cc uses this non-public absl dependency while there no better
    # alternative to inject abort hook. See notes in `base/logging.cc`.
    ":raw_logging_internal",

    # absl internal utilities used by protobuf.
    ":if_constexpr",
    ":layout",
  ]

  if (is_component_build) {
    public_deps += [ ":absl_full_deps" ]
  }

  # The following dependencies currently don't build with NaCl.
  # TODO(https://crbug.com/1114625): Fix build errors and remove this section.
  #
  # Note: This target currently is not implemented in this file, so
  # this logic is disabled, if :failure_signal_handler gets ported
  # this will need to be re-enabled
  # if (is_nacl) {
  #   public_deps -=
  #       [ "//third_party/abseil-cpp/absl/debugging:failure_signal_handler" ]
  # }
}

# The 'absl_full' target is not implemented here, since it includes a
# bunch of targets that are generally not allowed in Chromium.  If you
# think you need to add it in, because a dependency uses it, seriously
# consider if you can avoid doing that, since it will likely be a lot
# of effort to implement, and opens the door to should we just fork
# the entire GN structure from upstream.
#
# Examples of of how to avoid implementing this, there are custom
# build rules for googletest in standalone builds, and a stub fuzztest
# BUILD.gn.

# Commented out deps are targets that exist in the original BUILD.gn,
# but currently do not have an equivalent here. DO NOT just uncomment
# them, since that will cause symbol duplication issues. The rules
# will need to be ported to this file to use.
group("absl_full_deps") {
  public_deps = [
    # Banned because each flag registration generates a static initializer, and
    # the flag registration mechanism is problematic in component builds.
    # "//third_party/abseil-cpp/absl/flags:config",
    # "//third_party/abseil-cpp/absl/flags:flag",
    # "//third_party/abseil-cpp/absl/flags:parse",
    # "//third_party/abseil-cpp/absl/flags:reflection",
    # "//third_party/abseil-cpp/absl/flags:usage",

    # Banned because the LOG and CHECK macros conflict with Chrome's version of
    # those macros.
    ":log",
    ":check",
  ]
  # public_configs = [ "//third_party/abseil-cpp/absl/flags:absl_flags_config" ]
}

#
# absl/algorithm
#

absl_source_set("algorithm") {
  public = [ "${dawn_abseil_dir}/absl/algorithm/algorithm.h" ]
  deps = [ ":config" ]
}

absl_source_set("container") {
  public = [ "${dawn_abseil_dir}/absl/algorithm/container.h" ]
  public_deps = [
    ":algorithm",
    ":core_headers",
    ":nullability",
    ":type_traits",
  ]
}

#
# absl/base
#

absl_source_set("atomic_hook") {
  public = [ "${dawn_abseil_dir}/absl/base/internal/atomic_hook.h" ]
  public_deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("base") {
  sources = [
    "${dawn_abseil_dir}/absl/base/internal/cycleclock.cc",
    "${dawn_abseil_dir}/absl/base/internal/spinlock.cc",
    "${dawn_abseil_dir}/absl/base/internal/sysinfo.cc",
    "${dawn_abseil_dir}/absl/base/internal/thread_identity.cc",
    "${dawn_abseil_dir}/absl/base/internal/unscaledcycleclock.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/base/call_once.h",
    "${dawn_abseil_dir}/absl/base/casts.h",
    "${dawn_abseil_dir}/absl/base/internal/cycleclock.h",
    "${dawn_abseil_dir}/absl/base/internal/low_level_scheduling.h",
    "${dawn_abseil_dir}/absl/base/internal/per_thread_tls.h",
    "${dawn_abseil_dir}/absl/base/internal/spinlock.h",
    "${dawn_abseil_dir}/absl/base/internal/sysinfo.h",
    "${dawn_abseil_dir}/absl/base/internal/thread_identity.h",
    "${dawn_abseil_dir}/absl/base/internal/tsan_mutex_interface.h",
    "${dawn_abseil_dir}/absl/base/internal/unscaledcycleclock.h",
  ]

  public_deps = [
    ":atomic_hook",
    ":base_internal",
    ":config",
    ":core_headers",
    ":cycleclock_internal",
    ":dynamic_annotations",
    ":log_severity",
    ":nullability",
    ":raw_logging_internal",
    ":spinlock_wait",
    ":type_traits",
  ]
}

absl_source_set("base_internal") {
  public = [
    "${dawn_abseil_dir}/absl/base/internal/hide_ptr.h",
    "${dawn_abseil_dir}/absl/base/internal/identity.h",
    "${dawn_abseil_dir}/absl/base/internal/inline_variable.h",
    "${dawn_abseil_dir}/absl/base/internal/invoke.h",
    "${dawn_abseil_dir}/absl/base/internal/scheduling_mode.h",
  ]
  public_deps = [
    ":config",
    ":type_traits",
  ]
}

absl_source_set("config") {
  public = [
    "${dawn_abseil_dir}/absl/base/config.h",
    "${dawn_abseil_dir}/absl/base/options.h",
    "${dawn_abseil_dir}/absl/base/policy_checks.h",
  ]
}

absl_source_set("core_headers") {
  public = [
    "${dawn_abseil_dir}/absl/base/attributes.h",
    "${dawn_abseil_dir}/absl/base/const_init.h",
    "${dawn_abseil_dir}/absl/base/macros.h",
    "${dawn_abseil_dir}/absl/base/optimization.h",
    "${dawn_abseil_dir}/absl/base/port.h",
    "${dawn_abseil_dir}/absl/base/thread_annotations.h",
  ]
  public_deps = [ ":config" ]
}

absl_source_set("cycleclock_internal") {
  public = [
    "${dawn_abseil_dir}/absl/base/internal/cycleclock_config.h",
    "${dawn_abseil_dir}/absl/base/internal/unscaledcycleclock_config.h",
  ]
  deps = [
    ":base_internal",
    ":config",
  ]
}

absl_source_set("dynamic_annotations") {
  public = [ "${dawn_abseil_dir}/absl/base/dynamic_annotations.h" ]

  deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("endian") {
  public = [
    "${dawn_abseil_dir}/absl/base/internal/endian.h",
    "${dawn_abseil_dir}/absl/base/internal/unaligned_access.h",
  ]
  public_deps = [
    ":base",
    ":config",
    ":core_headers",
  ]
}

absl_source_set("errno_saver") {
  public = [ "${dawn_abseil_dir}/absl/base/internal/errno_saver.h" ]
  public_deps = [ ":config" ]
}

absl_source_set("log_severity") {
  sources = [ "${dawn_abseil_dir}/absl/base/log_severity.cc" ]
  public = [ "${dawn_abseil_dir}/absl/base/log_severity.h" ]
  public_deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("malloc_internal") {
  sources = [ "${dawn_abseil_dir}/absl/base/internal/low_level_alloc.cc" ]
  public = [
    "${dawn_abseil_dir}/absl/base/internal/direct_mmap.h",
    "${dawn_abseil_dir}/absl/base/internal/low_level_alloc.h",
  ]
  public_deps = [
    ":base",
    ":base_internal",
    ":config",
    ":core_headers",
    ":dynamic_annotations",
    ":raw_logging_internal",
  ]
}

absl_source_set("no_destructor") {
  public = [ "${dawn_abseil_dir}/absl/base/no_destructor.h" ]
  deps = [
    ":config",
    ":nullability",
  ]
}

absl_source_set("nullability") {
  sources = [ "${dawn_abseil_dir}/absl/base/internal/nullability_impl.h" ]
  public = [ "${dawn_abseil_dir}/absl/base/nullability.h" ]
  deps = [
    ":core_headers",
    ":type_traits",
  ]
}

absl_source_set("prefetch") {
  public = [ "${dawn_abseil_dir}/absl/base/prefetch.h" ]
  deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("raw_logging_internal") {
  sources = [ "${dawn_abseil_dir}/absl/base/internal/raw_logging.cc" ]
  public = [ "${dawn_abseil_dir}/absl/base/internal/raw_logging.h" ]
  public_deps = [
    ":atomic_hook",
    ":core_headers",
    ":errno_saver",
    ":log_severity",
  ]
}

absl_source_set("spinlock_wait") {
  sources = [
    "${dawn_abseil_dir}/absl/base/internal/spinlock_akaros.inc",
    "${dawn_abseil_dir}/absl/base/internal/spinlock_linux.inc",
    "${dawn_abseil_dir}/absl/base/internal/spinlock_posix.inc",
    "${dawn_abseil_dir}/absl/base/internal/spinlock_wait.cc",
    "${dawn_abseil_dir}/absl/base/internal/spinlock_win32.inc",
  ]
  public = [ "${dawn_abseil_dir}/absl/base/internal/spinlock_wait.h" ]
  deps = [
    ":base_internal",
    ":core_headers",
    ":errno_saver",
  ]
}

absl_source_set("strerror") {
  sources = [ "${dawn_abseil_dir}/absl/base/internal/strerror.cc" ]
  public = [ "${dawn_abseil_dir}/absl/base/internal/strerror.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":errno_saver",
  ]
}

absl_source_set("throw_delegate") {
  sources = [ "${dawn_abseil_dir}/absl/base/internal/throw_delegate.cc" ]
  public = [ "${dawn_abseil_dir}/absl/base/internal/throw_delegate.h" ]
  public_deps = [ ":raw_logging_internal" ]
}

absl_source_set("tracing_internal") {
  public = [ "${dawn_abseil_dir}/absl/base/internal/tracing.h" ]
  sources = [ "${dawn_abseil_dir}/absl/base/internal/tracing.cc" ]
  deps = [
    ":config",
    ":core_headers",
  ]
}

#
# absl/cleanup
#

absl_source_set("cleanup") {
  public = [ "${dawn_abseil_dir}/absl/cleanup/cleanup.h" ]
  deps = [
    ":cleanup_internal",
    ":config",
    ":core_headers",
  ]
}

absl_source_set("cleanup_internal") {
  public = [ "${dawn_abseil_dir}/absl/cleanup/internal/cleanup.h" ]
  deps = [
    ":base_internal",
    ":core_headers",
    ":utility",
  ]
}

#
# absl/container
#

absl_source_set("common") {
  public = [ "${dawn_abseil_dir}/absl/container/internal/common.h" ]
  deps = [
    ":optional",
    ":type_traits",
  ]
}

absl_source_set("common_policy_traits") {
  public =
      [ "${dawn_abseil_dir}/absl/container/internal/common_policy_traits.h" ]
  deps = [ ":type_traits" ]
}

absl_source_set("compressed_tuple") {
  public = [ "${dawn_abseil_dir}/absl/container/internal/compressed_tuple.h" ]
  deps = [ ":utility" ]
}

absl_source_set("container_memory") {
  public = [ "${dawn_abseil_dir}/absl/container/internal/container_memory.h" ]
  deps = [
    ":config",
    ":memory",
    ":type_traits",
    ":utility",
  ]
}

absl_source_set("fixed_array") {
  public = [ "${dawn_abseil_dir}/absl/container/fixed_array.h" ]
  deps = [
    ":algorithm",
    ":compressed_tuple",
    ":config",
    ":core_headers",
    ":dynamic_annotations",
    ":memory",
    ":throw_delegate",
  ]
}

absl_source_set("flat_hash_map") {
  public = [ "${dawn_abseil_dir}/absl/container/flat_hash_map.h" ]
  deps = [
    ":container",
    ":container_memory",
    ":core_headers",
    ":hash_function_defaults",
    ":memory",
    ":raw_hash_map",
  ]
}

absl_source_set("flat_hash_set") {
  public = [ "${dawn_abseil_dir}/absl/container/flat_hash_set.h" ]
  deps = [
    ":container",
    ":container_memory",
    ":core_headers",
    ":hash_function_defaults",
    ":memory",
    ":raw_hash_set",
  ]
}

absl_source_set("hash_function_defaults") {
  public =
      [ "${dawn_abseil_dir}/absl/container/internal/hash_function_defaults.h" ]
  deps = [
    ":common",
    ":config",
    ":cord",
    ":hash",
    ":string_view",
    ":type_traits",
  ]
}

absl_source_set("hash_policy_traits") {
  public = [ "${dawn_abseil_dir}/absl/container/internal/hash_policy_traits.h" ]
  public_deps = [
    ":common_policy_traits",
    ":type_traits",
  ]
}

absl_source_set("hashtable_debug_hooks") {
  public =
      [ "${dawn_abseil_dir}/absl/container/internal/hashtable_debug_hooks.h" ]
  deps = [ ":config" ]
}

absl_source_set("hashtablez_sampler") {
  public = [ "${dawn_abseil_dir}/absl/container/internal/hashtablez_sampler.h" ]
  sources = [
    "${dawn_abseil_dir}/absl/container/internal/hashtablez_sampler.cc",
    "${dawn_abseil_dir}/absl/container/internal/hashtablez_sampler_force_weak_definition.cc",
  ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":exponential_biased",
    ":memory",
    ":no_destructor",
    ":raw_logging_internal",
    ":sample_recorder",
    ":stacktrace",
    ":synchronization",
    ":time",
    ":tracing_internal",
    ":utility",
  ]
}

absl_source_set("inlined_vector") {
  public = [ "${dawn_abseil_dir}/absl/container/inlined_vector.h" ]
  deps = [
    ":algorithm",
    ":core_headers",
    ":inlined_vector_internal",
    ":memory",
    ":throw_delegate",
    ":type_traits",
  ]
}

absl_source_set("inlined_vector_internal") {
  public = [ "${dawn_abseil_dir}/absl/container/internal/inlined_vector.h" ]
  deps = [
    ":base_internal",
    ":compressed_tuple",
    ":config",
    ":core_headers",
    ":memory",
    ":span",
    ":type_traits",
  ]
}

absl_source_set("layout") {
  public = [ "${dawn_abseil_dir}/absl/container/internal/layout.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":demangle_internal",
    ":span",
    ":strings",
    ":type_traits",
    ":utility",
  ]
}

absl_source_set("raw_hash_map") {
  public = [ "${dawn_abseil_dir}/absl/container/internal/raw_hash_map.h" ]
  deps = [
    ":container_memory",
    ":raw_hash_set",
    ":throw_delegate",
  ]
}

absl_source_set("raw_hash_set") {
  sources = [ "${dawn_abseil_dir}/absl/container/internal/raw_hash_set.cc" ]
  public = [ "${dawn_abseil_dir}/absl/container/internal/raw_hash_set.h" ]
  deps = [
    ":bits",
    ":common",
    ":compressed_tuple",
    ":config",
    ":container_memory",
    ":core_headers",
    ":dynamic_annotations",
    ":endian",
    ":function_ref",
    ":hash",
    ":hash_function_defaults",
    ":hash_policy_traits",
    ":hashtable_debug_hooks",
    ":hashtablez_sampler",
    ":memory",
    ":prefetch",
    ":raw_logging_internal",
    ":type_traits",
    ":utility",
  ]
}

#
# absl/crc
#

absl_source_set("crc32c") {
  public = [
    "${dawn_abseil_dir}/absl/crc/crc32c.h",
    "${dawn_abseil_dir}/absl/crc/internal/crc32c.h",
    "${dawn_abseil_dir}/absl/crc/internal/crc_memcpy.h",
  ]
  sources = [
    "${dawn_abseil_dir}/absl/crc/crc32c.cc",
    "${dawn_abseil_dir}/absl/crc/internal/crc32c_inline.h",
    "${dawn_abseil_dir}/absl/crc/internal/crc_memcpy_fallback.cc",
    "${dawn_abseil_dir}/absl/crc/internal/crc_memcpy_x86_arm_combined.cc",
    "${dawn_abseil_dir}/absl/crc/internal/crc_non_temporal_memcpy.cc",
  ]
  deps = [
    ":config",
    ":core_headers",
    ":cpu_detect",
    ":crc_internal",
    ":endian",
    ":non_temporal_memcpy",
    ":prefetch",
    ":str_format",
    ":string_view",
  ]
}

absl_source_set("crc_internal") {
  public = [
    "${dawn_abseil_dir}/absl/crc/internal/crc.h",
    "${dawn_abseil_dir}/absl/crc/internal/crc32_x86_arm_combined_simd.h",
  ]
  sources = [
    "${dawn_abseil_dir}/absl/crc/internal/crc.cc",
    "${dawn_abseil_dir}/absl/crc/internal/crc_internal.h",
    "${dawn_abseil_dir}/absl/crc/internal/crc_x86_arm_combined.cc",
  ]
  deps = [
    ":bits",
    ":config",
    ":core_headers",
    ":cpu_detect",
    ":endian",
    ":memory",
    ":prefetch",
    ":raw_logging_internal",
  ]
}

absl_source_set("cpu_detect") {
  public = [ "${dawn_abseil_dir}/absl/crc/internal/cpu_detect.h" ]
  sources = [ "${dawn_abseil_dir}/absl/crc/internal/cpu_detect.cc" ]
  deps = [
    ":base",
    ":config",
    ":optional",
  ]
}

absl_source_set("crc_cord_state") {
  public = [ "${dawn_abseil_dir}/absl/crc/internal/crc_cord_state.h" ]
  sources = [ "${dawn_abseil_dir}/absl/crc/internal/crc_cord_state.cc" ]
  deps = [
    ":bits",
    ":config",
    ":crc32c",
    ":no_destructor",
  ]
}

absl_source_set("non_temporal_arm_intrinsics") {
  public =
      [ "${dawn_abseil_dir}/absl/crc/internal/non_temporal_arm_intrinsics.h" ]
  deps = [ ":config" ]
}

absl_source_set("non_temporal_memcpy") {
  public = [ "${dawn_abseil_dir}/absl/crc/internal/non_temporal_memcpy.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":non_temporal_arm_intrinsics",
  ]
}

#
# absl/debugging
#

absl_source_set("debugging_internal") {
  sources = [
    "${dawn_abseil_dir}/absl/debugging/internal/address_is_readable.cc",
    "${dawn_abseil_dir}/absl/debugging/internal/elf_mem_image.cc",
    "${dawn_abseil_dir}/absl/debugging/internal/vdso_support.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/debugging/internal/address_is_readable.h",
    "${dawn_abseil_dir}/absl/debugging/internal/elf_mem_image.h",
    "${dawn_abseil_dir}/absl/debugging/internal/vdso_support.h",
  ]
  deps = [
    ":config",
    ":core_headers",
    ":dynamic_annotations",
    ":errno_saver",
    ":raw_logging_internal",
  ]
}

absl_source_set("bounded_utf8_length_sequence") {
  public = [
    "${dawn_abseil_dir}/absl/debugging/internal/bounded_utf8_length_sequence.h",
  ]
  deps = [
    ":bits",
    ":config",
  ]
}

absl_source_set("decode_rust_punycode") {
  sources =
      [ "${dawn_abseil_dir}/absl/debugging/internal/decode_rust_punycode.cc" ]
  public =
      [ "${dawn_abseil_dir}/absl/debugging/internal/decode_rust_punycode.h" ]
  deps = [
    ":bounded_utf8_length_sequence",
    ":config",
    ":nullability",
    ":utf8_for_code_point",
  ]
}

absl_source_set("demangle_internal") {
  sources = [
    "${dawn_abseil_dir}/absl/debugging/internal/demangle.cc",
    "${dawn_abseil_dir}/absl/debugging/internal/demangle_rust.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/debugging/internal/demangle.h",
    "${dawn_abseil_dir}/absl/debugging/internal/demangle_rust.h",
  ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":decode_rust_punycode",
  ]
}

absl_source_set("examine_stack") {
  sources = [ "${dawn_abseil_dir}/absl/debugging/internal/examine_stack.cc" ]
  public = [ "${dawn_abseil_dir}/absl/debugging/internal/examine_stack.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":raw_logging_internal",
    ":stacktrace",
    ":symbolize",
  ]
}

absl_source_set("leak_check") {
  sources = [ "${dawn_abseil_dir}/absl/debugging/leak_check.cc" ]
  public = [ "${dawn_abseil_dir}/absl/debugging/leak_check.h" ]
  deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("stacktrace") {
  sources = [
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_aarch64-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_arm-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_config.h",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_emscripten-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_generic-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_powerpc-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_riscv-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_unimplemented-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_win32-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/internal/stacktrace_x86-inl.inc",
    "${dawn_abseil_dir}/absl/debugging/stacktrace.cc",
  ]
  public = [ "${dawn_abseil_dir}/absl/debugging/stacktrace.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":debugging_internal",
    ":dynamic_annotations",
    ":raw_logging_internal",
  ]
}

absl_source_set("symbolize") {
  sources = [
    "${dawn_abseil_dir}/absl/debugging/symbolize.cc",
    "${dawn_abseil_dir}/absl/debugging/symbolize_darwin.inc",
    "${dawn_abseil_dir}/absl/debugging/symbolize_elf.inc",
    "${dawn_abseil_dir}/absl/debugging/symbolize_emscripten.inc",
    "${dawn_abseil_dir}/absl/debugging/symbolize_unimplemented.inc",
    "${dawn_abseil_dir}/absl/debugging/symbolize_win32.inc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/debugging/internal/symbolize.h",
    "${dawn_abseil_dir}/absl/debugging/symbolize.h",
  ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":debugging_internal",
    ":demangle_internal",
    ":dynamic_annotations",
    ":malloc_internal",
    ":raw_logging_internal",
    ":string_view",
    ":strings",
  ]
}

#
# absl/functional
#

absl_source_set("any_invocable") {
  sources = [ "${dawn_abseil_dir}/absl/functional/internal/any_invocable.h" ]
  public = [ "${dawn_abseil_dir}/absl/functional/any_invocable.h" ]
  deps = [
    ":base_internal",
    ":config",
    ":core_headers",
    ":type_traits",
    ":utility",
  ]
}

absl_source_set("function_ref") {
  sources = [ "${dawn_abseil_dir}/absl/functional/internal/function_ref.h" ]
  public = [ "${dawn_abseil_dir}/absl/functional/function_ref.h" ]
  deps = [
    ":any_invocable",
    ":base_internal",
    ":core_headers",
    ":type_traits",
  ]
}

absl_source_set("overload") {
  public = [ "${dawn_abseil_dir}/absl/functional/overload.h" ]
  deps = [
    ":config",
    ":type_traits",
  ]
}

absl_source_set("utf8_for_code_point") {
  sources =
      [ "${dawn_abseil_dir}/absl/debugging/internal/utf8_for_code_point.cc" ]
  public =
      [ "${dawn_abseil_dir}/absl/debugging/internal/utf8_for_code_point.h" ]
  deps = [ ":config" ]
}

#
# absl/hash
#

absl_source_set("city") {
  public = [ "${dawn_abseil_dir}/absl/hash/internal/city.h" ]
  sources = [ "${dawn_abseil_dir}/absl/hash/internal/city.cc" ]
  deps = [
    ":config",
    ":core_headers",
    ":endian",
  ]
}

absl_source_set("hash") {
  sources = [
    "${dawn_abseil_dir}/absl/hash/internal/hash.cc",
    "${dawn_abseil_dir}/absl/hash/internal/hash.h",
  ]
  public = [ "${dawn_abseil_dir}/absl/hash/hash.h" ]
  deps = [
    ":bits",
    ":city",
    ":config",
    ":core_headers",
    ":endian",
    ":fixed_array",
    ":function_ref",
    ":int128",
    ":low_level_hash",
    ":optional",
    ":string_view",
    ":type_traits",
    ":utility",
    ":variant",
  ]
}

absl_source_set("low_level_hash") {
  public = [ "${dawn_abseil_dir}/absl/hash/internal/low_level_hash.h" ]
  sources = [ "${dawn_abseil_dir}/absl/hash/internal/low_level_hash.cc" ]
  deps = [
    ":config",
    ":endian",
    ":int128",
    ":prefetch",
  ]
}

#
# absl/log
#

absl_source_set("log") {
  public = [ "${dawn_abseil_dir}/absl/log/log.h" ]
  deps = [
    ":log_impl",
    ":vlog_is_on",
  ]
}

# There are separated absl/log:globals and absl/log/internal:globals
# targets in the original GN files. Renamed to log_global and
# _log_global respectively.

absl_source_set("log_globals") {
  sources = [ "${dawn_abseil_dir}/absl/log/globals.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/globals.h" ]
  deps = [
    ":atomic_hook",
    ":config",
    ":core_headers",
    ":hash",
    ":log_severity",
    ":raw_logging_internal",
    ":string_view",
    ":vlog_config",
  ]
}

absl_source_set("_log_globals") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/globals.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/globals.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":log_severity",
    ":raw_logging_internal",
    ":string_view",
    ":strings",
    ":time",
  ]
}

absl_source_set("log_config") {
  public = [ "${dawn_abseil_dir}/absl/log/internal/config.h" ]
  deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("absl_check") {
  public = [ "${dawn_abseil_dir}/absl/log/absl_check.h" ]
  deps = [ ":check_impl" ]
}

absl_source_set("absl_log") {
  public = [ "${dawn_abseil_dir}/absl/log/absl_log.h" ]
  deps = [ ":log_impl" ]
}

absl_source_set("absl_vlog_is_on") {
  public = [ "${dawn_abseil_dir}/absl/log/absl_vlog_is_on.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":strings",
    ":vlog_config",
  ]
}

absl_source_set("append_truncated") {
  public = [ "${dawn_abseil_dir}/absl/log/internal/append_truncated.h" ]
  deps = [
    ":config",
    ":span",
    ":string_view",
  ]
}

absl_source_set("check") {
  public = [ "${dawn_abseil_dir}/absl/log/check.h" ]
  deps = [
    ":check_impl",
    ":check_op",
    ":conditions",
    ":log_message",
    ":strip",
  ]
}

absl_source_set("check_impl") {
  public = [ "${dawn_abseil_dir}/absl/log/internal/check_impl.h" ]
  deps = [
    ":check_op",
    ":conditions",
    ":core_headers",
    ":log_message",
    ":strip",
  ]
}

absl_source_set("check_op") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/check_op.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/check_op.h" ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":leak_check",
    ":nullability",
    ":nullguard",
    ":nullstream",
    ":strings",
    ":strip",
  ]
}

absl_source_set("conditions") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/conditions.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/conditions.h" ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":voidify",
  ]
}

absl_source_set("die_if_null") {
  sources = [ "${dawn_abseil_dir}/absl/log/die_if_null.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/die_if_null.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":log",
    ":strings",
  ]
}

absl_source_set("fnmatch") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/fnmatch.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/fnmatch.h" ]
  deps = [
    ":config",
    ":strings",
  ]
}

absl_source_set("format") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/log_format.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/log_format.h" ]
  deps = [
    ":_log_globals",
    ":append_truncated",
    ":config",
    ":core_headers",
    ":log_config",
    ":log_severity",
    ":span",
    ":str_format",
    ":string_view",
    ":strings",
    ":time",
  ]
}

absl_source_set("log_initialize") {
  sources = [ "${dawn_abseil_dir}/absl/log/initialize.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/initialize.h" ]
  deps = [
    ":_log_globals",
    ":config",
    ":log_globals",
    ":time",
  ]
}

absl_source_set("log_entry") {
  sources = [ "${dawn_abseil_dir}/absl/log/log_entry.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/log_entry.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":log_config",
    ":log_severity",
    ":span",
    ":string_view",
    ":time",
  ]
}

absl_source_set("log_impl") {
  public = [ "${dawn_abseil_dir}/absl/log/internal/log_impl.h" ]
  deps = [
    ":absl_vlog_is_on",
    ":conditions",
    ":log_message",
    ":strip",
  ]
}

absl_source_set("log_message") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/log_message.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/log_message.h" ]
  deps = [
    ":_log_globals",
    ":_log_globals",
    ":append_truncated",
    ":base",
    ":config",
    ":core_headers",
    ":errno_saver",
    ":examine_stack",
    ":format",
    ":inlined_vector",
    ":log_entry",
    ":log_globals",
    ":log_severity",
    ":log_sink",
    ":log_sink_registry",
    ":log_sink_set",
    ":memory",
    ":nullability",
    ":nullguard",
    ":proto",
    ":raw_logging_internal",
    ":span",
    ":strerror",
    ":string_view",
    ":strings",
    ":structured_proto",
    ":time",
  ]
}

absl_source_set("log_sink") {
  sources = [ "${dawn_abseil_dir}/absl/log/log_sink.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/log_sink.h" ]
  deps = [
    ":config",
    ":log_entry",
  ]
}

absl_source_set("log_sink_registry") {
  public = [ "${dawn_abseil_dir}/absl/log/log_sink_registry.h" ]
  deps = [
    ":config",
    ":log_sink",
    ":log_sink_set",
    ":nullability",
  ]
}

absl_source_set("log_sink_set") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/log_sink_set.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/log_sink_set.h" ]
  deps = [
    ":_log_globals",
    ":base",
    ":cleanup",
    ":config",
    ":core_headers",
    ":log_config",
    ":log_entry",
    ":log_globals",
    ":log_severity",
    ":log_sink",
    ":no_destructor",
    ":raw_logging_internal",
    ":span",
    ":string_view",
    ":synchronization",
  ]
  if (is_android) {
    libs = [ "log" ]
  }
}

absl_source_set("nullguard") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/nullguard.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/nullguard.h" ]
  deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("nullstream") {
  public = [ "${dawn_abseil_dir}/absl/log/internal/nullstream.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":log_severity",
    ":string_view",
  ]
}

absl_source_set("proto") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/proto.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/proto.h" ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":span",
    ":string_view",
  ]
}

absl_source_set("strip") {
  public = [ "${dawn_abseil_dir}/absl/log/internal/strip.h" ]
  deps = [
    ":core_headers",
    ":log_message",
    ":log_severity",
    ":nullstream",
  ]
}

absl_source_set("structured_proto") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/structured_proto.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/structured_proto.h" ]
  deps = [
    ":config",
    ":proto",
    ":span",
    ":strings",
    ":variant",
  ]
}

absl_source_set("vlog_config") {
  sources = [ "${dawn_abseil_dir}/absl/log/internal/vlog_config.cc" ]
  public = [ "${dawn_abseil_dir}/absl/log/internal/vlog_config.h" ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":fnmatch",
    ":memory",
    ":no_destructor",
    ":optional",
    ":strings",
    ":synchronization",
  ]
}

absl_source_set("vlog_is_on") {
  public = [ "${dawn_abseil_dir}/absl/log/vlog_is_on.h" ]
  deps = [ ":absl_vlog_is_on" ]
}

absl_source_set("voidify") {
  public = [ "${dawn_abseil_dir}/absl/log/internal/voidify.h" ]
  deps = [ ":config" ]
}

#
# absl/memory
#

absl_source_set("memory") {
  public = [ "${dawn_abseil_dir}/absl/memory/memory.h" ]
  deps = [
    ":core_headers",
    ":type_traits",
  ]
}

#
# absl/meta
#

absl_source_set("type_traits") {
  public = [ "${dawn_abseil_dir}/absl/meta/type_traits.h" ]
  deps = [
    ":config",
    ":core_headers",
  ]
}

#
# absl/numeric
#

absl_source_set("bits") {
  public = [
    "${dawn_abseil_dir}/absl/numeric/bits.h",
    "${dawn_abseil_dir}/absl/numeric/internal/bits.h",
  ]
  deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("int128") {
  sources = [
    "${dawn_abseil_dir}/absl/numeric/int128.cc",
    "${dawn_abseil_dir}/absl/numeric/int128_have_intrinsic.inc",
    "${dawn_abseil_dir}/absl/numeric/int128_no_intrinsic.inc",
  ]
  public = [ "${dawn_abseil_dir}/absl/numeric/int128.h" ]
  deps = [
    ":bits",
    ":compare",
    ":config",
    ":core_headers",
  ]
}

#
# absl/profiling
#

absl_source_set("exponential_biased") {
  sources =
      [ "${dawn_abseil_dir}/absl/profiling/internal/exponential_biased.cc" ]
  public = [ "${dawn_abseil_dir}/absl/profiling/internal/exponential_biased.h" ]
  deps = [
    ":config",
    ":core_headers",
  ]
}

absl_source_set("sample_recorder") {
  public = [ "${dawn_abseil_dir}/absl/profiling/internal/sample_recorder.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":synchronization",
    ":time",
  ]
}

#
# absl/strings
#

absl_source_set("strings") {
  sources = [
    "${dawn_abseil_dir}/absl/strings/ascii.cc",
    "${dawn_abseil_dir}/absl/strings/charconv.cc",
    "${dawn_abseil_dir}/absl/strings/escaping.cc",
    "${dawn_abseil_dir}/absl/strings/internal/charconv_bigint.cc",
    "${dawn_abseil_dir}/absl/strings/internal/charconv_bigint.h",
    "${dawn_abseil_dir}/absl/strings/internal/charconv_parse.cc",
    "${dawn_abseil_dir}/absl/strings/internal/charconv_parse.h",
    "${dawn_abseil_dir}/absl/strings/internal/memutil.cc",
    "${dawn_abseil_dir}/absl/strings/internal/memutil.h",
    "${dawn_abseil_dir}/absl/strings/internal/stl_type_traits.h",
    "${dawn_abseil_dir}/absl/strings/internal/str_join_internal.h",
    "${dawn_abseil_dir}/absl/strings/internal/str_split_internal.h",
    "${dawn_abseil_dir}/absl/strings/internal/stringify_sink.cc",
    "${dawn_abseil_dir}/absl/strings/internal/stringify_sink.h",
    "${dawn_abseil_dir}/absl/strings/match.cc",
    "${dawn_abseil_dir}/absl/strings/numbers.cc",
    "${dawn_abseil_dir}/absl/strings/str_cat.cc",
    "${dawn_abseil_dir}/absl/strings/str_replace.cc",
    "${dawn_abseil_dir}/absl/strings/str_split.cc",
    "${dawn_abseil_dir}/absl/strings/substitute.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/strings/ascii.h",
    "${dawn_abseil_dir}/absl/strings/charconv.h",
    "${dawn_abseil_dir}/absl/strings/escaping.h",
    "${dawn_abseil_dir}/absl/strings/internal/string_constant.h",
    "${dawn_abseil_dir}/absl/strings/match.h",
    "${dawn_abseil_dir}/absl/strings/numbers.h",
    "${dawn_abseil_dir}/absl/strings/str_cat.h",
    "${dawn_abseil_dir}/absl/strings/str_join.h",
    "${dawn_abseil_dir}/absl/strings/str_replace.h",
    "${dawn_abseil_dir}/absl/strings/str_split.h",
    "${dawn_abseil_dir}/absl/strings/strip.h",
    "${dawn_abseil_dir}/absl/strings/substitute.h",
  ]
  public_deps = [
    ":base",
    ":bits",
    ":endian",
    ":int128",
    ":raw_logging_internal",
    ":string_view",
    ":strings_internal",
    ":throw_delegate",
    ":type_traits",
  ]
}

absl_source_set("cord") {
  sources = [
    "${dawn_abseil_dir}/absl/strings/cord.cc",
    "${dawn_abseil_dir}/absl/strings/cord_analysis.cc",
    "${dawn_abseil_dir}/absl/strings/cord_analysis.h",
    "${dawn_abseil_dir}/absl/strings/cord_buffer.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/strings/cord.h",
    "${dawn_abseil_dir}/absl/strings/cord_buffer.h",
  ]
  deps = [
    ":bits",
    ":compare",
    ":config",
    ":cord_internal",
    ":cordz_info",
    ":cordz_update_scope",
    ":cordz_update_tracker",
    ":core_headers",
    ":crc32c",
    ":crc_cord_state",
    ":endian",
    ":function_ref",
    ":inlined_vector",
    ":nullability",
    ":optional",
    ":raw_logging_internal",
    ":span",
    ":string_view",
    ":strings",
    ":strings_internal",
    ":type_traits",
  ]
}

absl_source_set("cord_internal") {
  sources = [
    "${dawn_abseil_dir}/absl/strings/internal/cord_internal.cc",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_btree.cc",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_btree_navigator.cc",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_btree_reader.cc",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_consume.cc",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_crc.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/strings/internal/cord_data_edge.h",
    "${dawn_abseil_dir}/absl/strings/internal/cord_internal.h",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_btree.h",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_btree_navigator.h",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_btree_reader.h",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_consume.h",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_crc.h",
    "${dawn_abseil_dir}/absl/strings/internal/cord_rep_flat.h",
  ]
  visibility = [ ":*" ]
  deps = [
    ":base_internal",
    ":compressed_tuple",
    ":config",
    ":container_memory",
    ":core_headers",
    ":crc_cord_state",
    ":endian",
    ":function_ref",
    ":inlined_vector",
    ":nullability",
    ":raw_logging_internal",
    ":span",
    ":string_view",
    ":strings",
  ]
}

absl_source_set("cordz_functions") {
  sources = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_functions.cc" ]
  public = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_functions.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":exponential_biased",
    ":raw_logging_internal",
  ]
}

absl_source_set("cordz_handle") {
  sources = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_handle.cc" ]
  public = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_handle.h" ]
  deps = [
    ":config",
    ":no_destructor",
    ":raw_logging_internal",
    ":synchronization",
  ]
}

absl_source_set("cordz_info") {
  sources = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_info.cc" ]
  public = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_info.h" ]
  deps = [
    ":base",
    ":config",
    ":cord_internal",
    ":cordz_functions",
    ":cordz_handle",
    ":cordz_statistics",
    ":cordz_update_tracker",
    ":core_headers",
    ":inlined_vector",
    ":raw_logging_internal",
    ":span",
    ":stacktrace",
    ":synchronization",
    ":time",
  ]
}

absl_source_set("cordz_statistics") {
  public = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_statistics.h" ]
  deps = [
    ":config",
    ":cordz_update_tracker",
  ]
}

absl_source_set("cordz_update_scope") {
  public = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_update_scope.h" ]
  deps = [
    ":config",
    ":cord_internal",
    ":cordz_info",
    ":cordz_update_tracker",
    ":core_headers",
  ]
}

absl_source_set("cordz_update_tracker") {
  public = [ "${dawn_abseil_dir}/absl/strings/internal/cordz_update_tracker.h" ]
  deps = [ ":config" ]
}

absl_source_set("has_ostream_operator") {
  public = [ "${dawn_abseil_dir}/absl/strings/has_ostream_operator.h" ]
  deps = [ ":config" ]
}

absl_source_set("strings_internal") {
  sources = [
    "${dawn_abseil_dir}/absl/strings/internal/escaping.cc",
    "${dawn_abseil_dir}/absl/strings/internal/ostringstream.cc",
    "${dawn_abseil_dir}/absl/strings/internal/utf8.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/strings/internal/escaping.h",
    "${dawn_abseil_dir}/absl/strings/internal/ostringstream.h",
    "${dawn_abseil_dir}/absl/strings/internal/resize_uninitialized.h",
    "${dawn_abseil_dir}/absl/strings/internal/utf8.h",
  ]
  deps = [
    ":endian",
    ":raw_logging_internal",
    ":type_traits",
  ]
}

absl_source_set("string_view") {
  sources = [ "${dawn_abseil_dir}/absl/strings/string_view.cc" ]
  public = [ "${dawn_abseil_dir}/absl/strings/string_view.h" ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":throw_delegate",
  ]
}

absl_source_set("str_format") {
  public = [ "${dawn_abseil_dir}/absl/strings/str_format.h" ]
  deps = [
    ":core_headers",
    ":nullability",
    ":span",
    ":str_format_internal",
    ":string_view",
  ]
}

absl_source_set("str_format_internal") {
  sources = [
    "${dawn_abseil_dir}/absl/strings/internal/str_format/arg.cc",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/bind.cc",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/extension.cc",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/float_conversion.cc",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/output.cc",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/parser.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/strings/internal/str_format/arg.h",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/bind.h",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/checker.h",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/extension.h",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/float_conversion.h",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/output.h",
    "${dawn_abseil_dir}/absl/strings/internal/str_format/parser.h",
  ]
  deps = [
    ":bits",
    ":config",
    ":core_headers",
    ":fixed_array",
    ":function_ref",
    ":inlined_vector",
    ":int128",
    ":optional",
    ":span",
    ":string_view",
    ":strings",
    ":type_traits",
    ":utility",
  ]
}

#
# absl/status
#

absl_source_set("status") {
  public = [
    "${dawn_abseil_dir}/absl/status/status.h",
    "${dawn_abseil_dir}/absl/status/status_payload_printer.h",
  ]
  sources = [
    "${dawn_abseil_dir}/absl/status/internal/status_internal.cc",
    "${dawn_abseil_dir}/absl/status/internal/status_internal.h",
    "${dawn_abseil_dir}/absl/status/status.cc",
    "${dawn_abseil_dir}/absl/status/status_payload_printer.cc",
  ]
  deps = [
    ":atomic_hook",
    ":config",
    ":cord",
    ":core_headers",
    ":function_ref",
    ":inlined_vector",
    ":leak_check",
    ":memory",
    ":no_destructor",
    ":nullability",
    ":optional",
    ":raw_logging_internal",
    ":span",
    ":stacktrace",
    ":str_format",
    ":strerror",
    ":string_view",
    ":strings",
    ":symbolize",
  ]
}

absl_source_set("statusor") {
  public = [ "${dawn_abseil_dir}/absl/status/statusor.h" ]
  sources = [
    "${dawn_abseil_dir}/absl/status/internal/statusor_internal.h",
    "${dawn_abseil_dir}/absl/status/statusor.cc",
  ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":has_ostream_operator",
    ":nullability",
    ":raw_logging_internal",
    ":status",
    ":str_format",
    ":string_view",
    ":strings",
    ":type_traits",
    ":utility",
    ":variant",
  ]
}

#
# absl/synchronization
#

absl_source_set("graphcycles_internal") {
  sources =
      [ "${dawn_abseil_dir}/absl/synchronization/internal/graphcycles.cc" ]
  public = [ "${dawn_abseil_dir}/absl/synchronization/internal/graphcycles.h" ]
  deps = [
    ":base",
    ":base_internal",
    ":config",
    ":core_headers",
    ":malloc_internal",
    ":raw_logging_internal",
  ]
  visibility = [ ":*" ]
}

absl_source_set("kernel_timeout_internal") {
  sources =
      [ "${dawn_abseil_dir}/absl/synchronization/internal/kernel_timeout.cc" ]
  public =
      [ "${dawn_abseil_dir}/absl/synchronization/internal/kernel_timeout.h" ]
  deps = [
    ":base",
    ":config",
    ":core_headers",
    ":raw_logging_internal",
    ":time",
  ]
}

absl_source_set("synchronization") {
  sources = [
    "${dawn_abseil_dir}/absl/synchronization/barrier.cc",
    "${dawn_abseil_dir}/absl/synchronization/blocking_counter.cc",
    "${dawn_abseil_dir}/absl/synchronization/internal/create_thread_identity.cc",
    "${dawn_abseil_dir}/absl/synchronization/internal/futex_waiter.cc",
    "${dawn_abseil_dir}/absl/synchronization/internal/per_thread_sem.cc",
    "${dawn_abseil_dir}/absl/synchronization/internal/pthread_waiter.cc",
    "${dawn_abseil_dir}/absl/synchronization/internal/sem_waiter.cc",
    "${dawn_abseil_dir}/absl/synchronization/internal/stdcpp_waiter.cc",
    "${dawn_abseil_dir}/absl/synchronization/internal/waiter_base.cc",
    "${dawn_abseil_dir}/absl/synchronization/internal/win32_waiter.cc",
    "${dawn_abseil_dir}/absl/synchronization/mutex.cc",
    "${dawn_abseil_dir}/absl/synchronization/notification.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/synchronization/barrier.h",
    "${dawn_abseil_dir}/absl/synchronization/blocking_counter.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/create_thread_identity.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/futex.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/futex_waiter.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/per_thread_sem.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/pthread_waiter.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/sem_waiter.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/stdcpp_waiter.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/waiter.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/waiter_base.h",
    "${dawn_abseil_dir}/absl/synchronization/internal/win32_waiter.h",
    "${dawn_abseil_dir}/absl/synchronization/mutex.h",
    "${dawn_abseil_dir}/absl/synchronization/notification.h",
  ]
  deps = [
    ":atomic_hook",
    ":base",
    ":base_internal",
    ":config",
    ":core_headers",
    ":dynamic_annotations",
    ":graphcycles_internal",
    ":kernel_timeout_internal",
    ":malloc_internal",
    ":raw_logging_internal",
    ":stacktrace",
    ":symbolize",
    ":time",
    ":tracing_internal",
  ]
}

#
# absl/time
#

absl_source_set("civil_time") {
  sources =
      [ "${dawn_abseil_dir}/absl/time/internal/cctz/src/civil_time_detail.cc" ]
  public = [
    "${dawn_abseil_dir}/absl/time/internal/cctz/include/cctz/civil_time.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/include/cctz/civil_time_detail.h",
  ]
  deps = [ ":config" ]
}

absl_source_set("time") {
  sources = [
    "${dawn_abseil_dir}/absl/time/civil_time.cc",
    "${dawn_abseil_dir}/absl/time/clock.cc",
    "${dawn_abseil_dir}/absl/time/duration.cc",
    "${dawn_abseil_dir}/absl/time/format.cc",
    "${dawn_abseil_dir}/absl/time/internal/get_current_time_chrono.inc",
    "${dawn_abseil_dir}/absl/time/internal/get_current_time_posix.inc",
    "${dawn_abseil_dir}/absl/time/time.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/time/civil_time.h",
    "${dawn_abseil_dir}/absl/time/clock.h",
    "${dawn_abseil_dir}/absl/time/time.h",
  ]
  deps = [
    ":base",
    ":civil_time",
    ":config",
    ":core_headers",
    ":int128",
    ":optional",
    ":raw_logging_internal",
    ":string_view",
    ":strings",
    ":time_zone",
  ]
}

absl_source_set("time_zone") {
  sources = [
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_fixed.cc",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_fixed.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_format.cc",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_if.cc",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_if.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_impl.cc",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_impl.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_info.cc",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_info.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_libc.cc",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_libc.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_lookup.cc",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_posix.cc",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/time_zone_posix.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/tzfile.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/src/zone_info_source.cc",
  ]
  public = [
    "${dawn_abseil_dir}/absl/time/internal/cctz/include/cctz/time_zone.h",
    "${dawn_abseil_dir}/absl/time/internal/cctz/include/cctz/zone_info_source.h",
  ]
  defines = []
  if (is_apple) {
    frameworks = [ "Foundation.framework" ]

    # Work-around for https://github.com/llvm/llvm-project/issues/117630
    defines += [ "_XOPEN_SOURCE=700" ]
  }
  deps = [
    ":civil_time",
    ":config",
  ]
  if (is_fuchsia) {
    # Remove when fixed in Fuchsia SDK:
    # https://bugs.fuchsia.dev/p/fuchsia/issues/detail?id=127301
    cflags_cc = [ "-Wno-sign-conversion" ]
    deps += [
      "//third_party/fuchsia-sdk/sdk/fidl/fuchsia.intl:fuchsia.intl_hlcpp",
      "//third_party/fuchsia-sdk/sdk/pkg/async",
      "//third_party/fuchsia-sdk/sdk/pkg/async-loop-cpp",
      "//third_party/fuchsia-sdk/sdk/pkg/sys_cpp",
      "//third_party/fuchsia-sdk/sdk/pkg/zx",
    ]
  }
}

#
# absl/types
#

absl_source_set("bad_optional_access") {
  sources = [ "${dawn_abseil_dir}/absl/types/bad_optional_access.cc" ]
  public = [ "${dawn_abseil_dir}/absl/types/bad_optional_access.h" ]
  public_deps = [ ":config" ]
  deps = [ ":raw_logging_internal" ]
}

absl_source_set("bad_variant_access") {
  sources = [ "${dawn_abseil_dir}/absl/types/bad_variant_access.cc" ]
  public = [ "${dawn_abseil_dir}/absl/types/bad_variant_access.h" ]
  public_deps = [ ":config" ]
  deps = [ ":raw_logging_internal" ]
}

absl_source_set("compare") {
  public = [ "${dawn_abseil_dir}/absl/types/compare.h" ]
  deps = [
    ":config",
    ":core_headers",
    ":type_traits",
  ]
}

absl_source_set("optional") {
  sources = [ "${dawn_abseil_dir}/absl/types/internal/optional.h" ]
  public = [ "${dawn_abseil_dir}/absl/types/optional.h" ]
  public_deps = [
    ":bad_optional_access",
    ":base_internal",
    ":config",
    ":core_headers",
    ":memory",
    ":nullability",
    ":type_traits",
    ":utility",
  ]
}

absl_source_set("span") {
  public = [ "${dawn_abseil_dir}/absl/types/span.h" ]
  sources = [ "${dawn_abseil_dir}/absl/types/internal/span.h" ]
  public_deps = [
    ":algorithm",
    ":core_headers",
    ":nullability",
    ":throw_delegate",
    ":type_traits",
  ]
}

absl_source_set("variant") {
  sources = [ "${dawn_abseil_dir}/absl/types/internal/variant.h" ]
  public = [ "${dawn_abseil_dir}/absl/types/variant.h" ]
  public_deps = [
    ":bad_variant_access",
    ":base_internal",
    ":config",
    ":core_headers",
    ":type_traits",
    ":utility",
  ]
}

#
# absl/utility
#

absl_source_set("utility") {
  public = [ "${dawn_abseil_dir}/absl/utility/utility.h" ]
  deps = [
    ":base_internal",
    ":config",
    ":type_traits",
  ]
}

absl_source_set("if_constexpr") {
  public = [ "${dawn_abseil_dir}/absl/utility/internal/if_constexpr.h" ]
  deps = [ ":config" ]
}