Skip to main content

go_library

name​

def name(
    *,
    name: str,
    default_target_platform: None | str = ...,
    target_compatible_with: list[str] = ...,
    compatible_with: list[str] = ...,
    exec_compatible_with: list[str] = ...,
    visibility: list[str] = ...,
    within_view: list[str] = ...,
    metadata: OpaqueMetadata = ...,
    tests: list[str] = ...,
    modifiers: OpaqueMetadata = ...,
    _apple_platforms: dict[str, str] = ...,
    _asan: bool = ...,
    _build_tags: list[str] = ...,
    _cgo_enabled: None | bool = ...,
    _coverage_mode: None | str = ...,
    _cxx_toolchain: str = ...,
    _exec_os_type: str = ...,
    _go_stdlib: str = ...,
    _go_toolchain: str = ...,
    _race: bool = ...,
    assembler_flags: list[str] = ...,
    compiler_flags: list[str] = ...,
    contacts: list[str] = ...,
    cxx_compiler_flags: list[str] = ...,
    cxx_preprocessor_flags: list[str] = ...,
    default_host_platform: None | str = ...,
    deps: list[str] = ...,
    embedcfg: None | str = ...,
    external_linker_flags: list[str] = ...,
    generate_exported_header: bool = ...,
    header_namespace: None | str = ...,
    headers: list[str] | dict[str, str] = ...,
    labels: list[str] = ...,
    licenses: list[str] = ...,
    link_style: None | str = ...,
    override_cgo_enabled: None | bool = ...,
    package_name: None | str = ...,
    package_root: None | str = ...,
    srcs: list[str] = ...,
) -> None

A go_library() rule builds a native library from the supplied set of Go source files and dependencies.

Parameters​

  • name: name of the target
  • default_target_platform: specifies the default target platform, used when no platforms are specified on the command line
  • target_compatible_with: a list of constraints that are required to be satisfied for this target to be compatible with a configuration
  • compatible_with: a list of constraints that are required to be satisfied for this target to be compatible with a configuration
  • exec_compatible_with: a list of constraints that are required to be satisfied for this target to be compatible with an execution platform
  • visibility: a list of visibility patterns restricting what targets can depend on this one
  • within_view: a list of visibility patterns restricting what this target can depend on
  • metadata: a key-value map of metadata associated with this target
  • tests: a list of targets that provide tests for this one
  • modifiers: an array of modifiers associated with this target
  • assembler_flags: The set of additional assembler flags to pass to go tool asm.
  • compiler_flags: The set of additional compiler flags to pass to go tool compile.
  • cxx_compiler_flags: GCC/Clang flags to use when compiling any of the above C/C++ sources (which require compilation).
  • cxx_preprocessor_flags: GCC/Clang flags to use when preprocessing any of the above C/C++ sources (which require preprocessing).
  • deps: The set of dependencies of this rule. Currently, this only supports go_library rules.
  • external_linker_flags: Extra external linker flags passed to go link via -extld argument.
  • generate_exported_header: Generate header file with declaration for functions exported with //export The header name for target cell//foo/bar:lib will be foo/bar/lib.h
  • header_namespace: A path prefix when including headers of this target. Defaults to the path from the root of the repository to the directory where this target is defined. Can contain forward slashes (/), but cannot start with one. See headers for more information.
  • headers: The set of header files that are made available for inclusion to the source files in this target. These should be specified as either a list of header files or a dictionary of header names to header files. The header name can contain forward slashes (/). The headers can be included with #include "$HEADER_NAMESPACE/$HEADER_NAME" or #include <$HEADER_NAMESPACE/$HEADER_NAME> , where $HEADER_NAMESPACE is the value of the target's header_namespace attribute, and $HEADER_NAME is the header name if specified, and the filename of the header file otherwise. See header_namespace for more information.
  • link_style: Determines whether to build and link this rule's dependencies statically or dynamically. Can be one of the following values: static, static_pic or shared. This argument is relevant only if the cgo extension is enabled. Otherwise, Buck ignores this argument.
  • override_cgo_enabled: Per-target analog of CGO_ENABLED env-var, overrides its value for the target, but not for its dependencies.
  • package_name: Sets the full name of the package being compiled. This defaults to the path from the buck root. (e.g. given a ./.buckconfig, a rule in ./a/b/BUCK defaults to package "a/b")
  • package_root: Sets Go package direactory (relative to BUCK file). By default (or if None passes) package_root is being detected automatically. Empty string of Go package is on the same level as BUCK file otherwise the subdirectory name. Example for srcs = ["foo/bar.go"], package_root = "foo"
  • srcs: The set of source files to be compiled by this rule. .go files will be compiled with the Go compiler, .s files will be compiled with the assembler, and everything else is assumed to be files that may be #included by the assembler.

Details​

Examples:

For more examples, check out our integration tests.


go_library(
  name='greeting',
  srcs=[
    'greeting.go',
  ],
  deps=[
    ':join',
  ],
)