syntax/testdata/scan.star

# Copyright 2014 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# (From https://github.com/bazelbuild/rules_go/blob/master/go/def.bzl@a6f9d0c)

load("//go/private:repositories.bzl", "go_repositories")
load("//go/private:go_repository.bzl", "go_repository", "new_go_repository")
load("//go/private:go_prefix.bzl", "go_prefix")
load("//go/private:json.bzl", "json_marshal")

"""These are bare-bones Go rules.

In order of priority:

- BUILD file must be written by hand.

- No support for SWIG

- No test sharding or test XML.

"""

_DEFAULT_LIB = "go_default_library"

_VENDOR_PREFIX = "/vendor/"

go_filetype = FileType([
    ".go",
    ".s",
    ".S",
    ".h",  # may be included by .s
])

# be consistent to cc_library.
hdr_exts = [
    ".h",
    ".hh",
    ".hpp",
    ".hxx",
    ".inc",
]

cc_hdr_filetype = FileType(hdr_exts)

# Extensions of files we can build with the Go compiler or with cc_library.
# This is a subset of the extensions recognized by go/build.
cgo_filetype = FileType([
    ".go",
    ".c",
    ".cc",
    ".cxx",
    ".cpp",
    ".s",
    ".S",
    ".h",
    ".hh",
    ".hpp",
    ".hxx",
])

################

def go_environment_vars(ctx):
    """Return a map of environment variables for use with actions, based on
    the arguments. Uses the ctx.fragments.cpp.cpu attribute, if present,
    and picks a default of target_os="linux" and target_arch="amd64"
    otherwise.

    Args:
      The starlark Context.

    Returns:
      A dict of environment variables for running Go tool commands that build for
      the target OS and architecture.
    """
    default_toolchain = {"GOOS": "linux", "GOARCH": "amd64"}
    bazel_to_go_toolchain = {
        "k8": {"GOOS": "linux", "GOARCH": "amd64"},
        "piii": {"GOOS": "linux", "GOARCH": "386"},
        "darwin": {"GOOS": "darwin", "GOARCH": "amd64"},
        "darwin_x86_64": {"GOOS": "darwin", "GOARCH": "amd64"},
        "freebsd": {"GOOS": "freebsd", "GOARCH": "amd64"},
        "armeabi-v7a": {"GOOS": "linux", "GOARCH": "arm"},
        "arm": {"GOOS": "linux", "GOARCH": "arm"},
    }
    env = {}
    if hasattr(ctx.file, "go_tool"):
        env["GOROOT"] = ctx.file.go_tool.dirname + "/.."
    env.update(bazel_to_go_toolchain.get(ctx.fragments.cpp.cpu, default_toolchain))
    return env

def _is_darwin_cpu(ctx):
    cpu = ctx.fragments.cpp.cpu
    return cpu == "darwin" or cpu == "darwin_x86_64"

def _emit_generate_params_action(cmds, ctx, fn):
    cmds_all = [
        # Use bash explicitly. /bin/sh is default, and it may be linked to a
        # different shell, e.g., /bin/dash on Ubuntu.
        "#!/bin/bash",
        "set -e",
    ]
    cmds_all += cmds
    cmds_all_str = "\n".join(cmds_all) + "\n"
    f = ctx.new_file(ctx.configuration.bin_dir, fn)
    ctx.file_action(
        output = f,
        content = cmds_all_str,
        executable = True,
    )
    return f

def _emit_go_asm_action(ctx, source, hdrs, out_obj):
    """Construct the command line for compiling Go Assembly code.
    Constructs a symlink tree to accomodate for workspace name.
    Args:
      ctx: The starlark Context.
      source: a source code artifact
      hdrs: list of .h files that may be included
      out_obj: the artifact (configured target?) that should be produced
    """
    params = {
        "go_tool": ctx.file.go_tool.path,
        "includes": [f.dirname for f in hdrs] + [ctx.file.go_include.path],
        "source": source.path,
        "out": out_obj.path,
    }

    inputs = hdrs + ctx.files.toolchain + [source]
    ctx.action(
        inputs = inputs,
        outputs = [out_obj],
        mnemonic = "GoAsmCompile",
        executable = ctx.executable._asm,
        arguments = [json_marshal(params)],
    )

def _go_importpath(ctx):
    """Returns the expected importpath of the go_library being built.

    Args:
      ctx: The starlark Context

    Returns:
      Go importpath of the library
    """
    path = ctx.attr.importpath
    if path != "":
        return path
    path = ctx.attr.go_prefix.go_prefix
    if path.endswith("/"):
        path = path[:-1]
    if ctx.label.package:
        path += "/" + ctx.label.package
    if ctx.label.name != _DEFAULT_LIB:
        path += "/" + ctx.label.name
    if path.rfind(_VENDOR_PREFIX) != -1:
        path = path[len(_VENDOR_PREFIX) + path.rfind(_VENDOR_PREFIX):]
    if path[0] == "/":
        path = path[1:]
    return path

def _emit_go_compile_action(ctx, sources, deps, libpaths, out_object, gc_goopts):
    """Construct the command line for compiling Go code.

    Args:
      ctx: The starlark Context.
      sources: an iterable of source code artifacts (or CTs? or labels?)
      deps: an iterable of dependencies. Each dependency d should have an
        artifact in d.transitive_go_libraries representing all imported libraries.
      libpaths: the set of paths to search for imported libraries.
      out_object: the object file that should be produced
      gc_goopts: additional flags to pass to the compiler.
    """
    if ctx.coverage_instrumented():
        sources = _emit_go_cover_action(ctx, sources)

    # Compile filtered files.
    args = [
        "-cgo",
        ctx.file.go_tool.path,
        "tool",
        "compile",
        "-o",
        out_object.path,
        "-trimpath",
        "-abs-.",
        "-I",
        "-abs-.",
    ]
    inputs = depset(sources + ctx.files.toolchain)
    for dep in deps:
        inputs += dep.transitive_go_libraries
    for path in libpaths:
        args += ["-I", path]
    args += gc_goopts + [("" if i.basename.startswith("_cgo") else "-filter-") + i.path for i in sources]
    ctx.action(
        inputs = list(inputs),
        outputs = [out_object],
        mnemonic = "GoCompile",
        executable = ctx.executable._filter_exec,
        arguments = args,
        env = go_environment_vars(ctx),
    )

    return sources

def _emit_go_pack_action(ctx, out_lib, objects):
    """Construct the command line for packing objects together.

    Args:
      ctx: The starlark Context.
      out_lib: the archive that should be produced
      objects: an iterable of object files to be added to the output archive file.
    """
    ctx.action(
        inputs = objects + ctx.files.toolchain,
        outputs = [out_lib],
        mnemonic = "GoPack",
        executable = ctx.file.go_tool,
        arguments = ["tool", "pack", "c", out_lib.path] + [a.path for a in objects],
        env = go_environment_vars(ctx),
    )

def _emit_go_cover_action(ctx, sources):
    """Construct the command line for test coverage instrument.

    Args:
      ctx: The starlark Context.
      sources: an iterable of Go source files.

    Returns:
      A list of Go source code files which might be coverage instrumented.
    """
    outputs = []

    # TODO(linuxerwang): make the mode configurable.
    count = 0

    for src in sources:
        if not src.path.endswith(".go") or src.path.endswith("_test.go"):
            outputs += [src]
            continue

        cover_var = "GoCover_%d" % count
        out = ctx.new_file(src, src.basename[:-3] + "_" + cover_var + ".cover.go")
        outputs += [out]
        ctx.action(
            inputs = [src] + ctx.files.toolchain,
            outputs = [out],
            mnemonic = "GoCover",
            executable = ctx.file.go_tool,
            arguments = ["tool", "cover", "--mode=set", "-var=%s" % cover_var, "-o", out.path, src.path],
            env = go_environment_vars(ctx),
        )
        count += 1

    return outputs

def go_library_impl(ctx):
    """Implements the go_library() rule."""

    sources = depset(ctx.files.srcs)
    go_srcs = depset([s for s in sources if s.basename.endswith(".go")])
    asm_srcs = [s for s in sources if s.basename.endswith(".s") or s.basename.endswith(".S")]
    asm_hdrs = [s for s in sources if s.basename.endswith(".h")]
    deps = ctx.attr.deps
    dep_runfiles = [d.data_runfiles for d in deps]

    cgo_object = None
    if hasattr(ctx.attr, "cgo_object"):
        cgo_object = ctx.attr.cgo_object

    if ctx.attr.library:
        go_srcs += ctx.attr.library.go_sources
        asm_srcs += ctx.attr.library.asm_sources
        asm_hdrs += ctx.attr.library.asm_headers
        deps += ctx.attr.library.direct_deps
        dep_runfiles += [ctx.attr.library.data_runfiles]
        if ctx.attr.library.cgo_object:
            if cgo_object:
                fail("go_library %s cannot have cgo_object because the package " +
                     "already has cgo_object in %s" % (
                         ctx.label.name,
                         ctx.attr.library.name,
                     ))
            cgo_object = ctx.attr.library.cgo_object
    if not go_srcs:
        fail("may not be empty", "srcs")

    transitive_cgo_deps = depset([], order = "topological")
    if cgo_object:
        dep_runfiles += [cgo_object.data_runfiles]
        transitive_cgo_deps += cgo_object.cgo_deps

    extra_objects = [cgo_object.cgo_obj] if cgo_object else []
    for src in asm_srcs:
        obj = ctx.new_file(src, "%s.dir/%s.o" % (ctx.label.name, src.basename[:-2]))
        _emit_go_asm_action(ctx, src, asm_hdrs, obj)
        extra_objects += [obj]

    lib_name = _go_importpath(ctx) + ".a"
    out_lib = ctx.new_file(lib_name)
    out_object = ctx.new_file(ctx.label.name + ".o")
    search_path = out_lib.path[:-len(lib_name)]
    gc_goopts = _gc_goopts(ctx)
    transitive_go_libraries = depset([out_lib])
    transitive_go_library_paths = depset([search_path])
    for dep in deps:
        transitive_go_libraries += dep.transitive_go_libraries
        transitive_cgo_deps += dep.transitive_cgo_deps
        transitive_go_library_paths += dep.transitive_go_library_paths

    go_srcs = _emit_go_compile_action(
        ctx,
        sources = go_srcs,
        deps = deps,
        libpaths = transitive_go_library_paths,
        out_object = out_object,
        gc_goopts = gc_goopts,
    )
    _emit_go_pack_action(ctx, out_lib, [out_object] + extra_objects)

    dylibs = []
    if cgo_object:
        dylibs += [d for d in cgo_object.cgo_deps if d.path.endswith(".so")]

    runfiles = ctx.runfiles(files = dylibs, collect_data = True)
    for d in dep_runfiles:
        runfiles = runfiles.merge(d)

    return struct(
        label = ctx.label,
        files = depset([out_lib]),
        runfiles = runfiles,
        go_sources = go_srcs,
        asm_sources = asm_srcs,
        asm_headers = asm_hdrs,
        cgo_object = cgo_object,
        direct_deps = ctx.attr.deps,
        transitive_cgo_deps = transitive_cgo_deps,
        transitive_go_libraries = transitive_go_libraries,
        transitive_go_library_paths = transitive_go_library_paths,
        gc_goopts = gc_goopts,
    )

def _c_linker_options(ctx, blocklist = []):
    """Extracts flags to pass to $(CC) on link from the current context

    Args:
      ctx: the current context
      blocklist: Any flags starts with any of these prefixes are filtered out from
        the return value.

    Returns:
      A list of command line flags
    """
    cpp = ctx.fragments.cpp
    features = ctx.features
    options = cpp.compiler_options(features)
    options += cpp.unfiltered_compiler_options(features)
    options += cpp.link_options
    options += cpp.mostly_static_link_options(ctx.features, False)
    filtered = []
    for opt in options:
        if any([opt.startswith(prefix) for prefix in blocklist]):
            continue
        filtered.append(opt)
    return filtered

def _gc_goopts(ctx):
    gc_goopts = [
        ctx.expand_make_variables("gc_goopts", f, {})
        for f in ctx.attr.gc_goopts
    ]
    if ctx.attr.library:
        gc_goopts += ctx.attr.library.gc_goopts
    return gc_goopts

def _gc_linkopts(ctx):
    gc_linkopts = [
        ctx.expand_make_variables("gc_linkopts", f, {})
        for f in ctx.attr.gc_linkopts
    ]
    for k, v in ctx.attr.x_defs.items():
        gc_linkopts += ["-X", "%s='%s'" % (k, v)]
    return gc_linkopts

def _extract_extldflags(gc_linkopts, extldflags):
    """Extracts -extldflags from gc_linkopts and combines them into a single list.

    Args:
      gc_linkopts: a list of flags passed in through the gc_linkopts attributes.
        ctx.expand_make_variables should have already been applied.
      extldflags: a list of flags to be passed to the external linker.

    Return:
      A tuple containing the filtered gc_linkopts with external flags removed,
      and a combined list of external flags.
    """
    filtered_gc_linkopts = []
    is_extldflags = False
    for opt in gc_linkopts:
        if is_extldflags:
            is_extldflags = False
            extldflags += [opt]
        elif opt == "-extldflags":
            is_extldflags = True
        else:
            filtered_gc_linkopts += [opt]
    return filtered_gc_linkopts, extldflags

def _emit_go_link_action(
        ctx,
        transitive_go_library_paths,
        transitive_go_libraries,
        cgo_deps,
        libs,
        executable,
        gc_linkopts):
    """Sets up a symlink tree to libraries to link together."""
    config_strip = len(ctx.configuration.bin_dir.path) + 1
    pkg_depth = executable.dirname[config_strip:].count("/") + 1

    ld = "%s" % ctx.fragments.cpp.compiler_executable
    extldflags = _c_linker_options(ctx) + [
        "-Wl,-rpath,$ORIGIN/" + ("../" * pkg_depth),
    ]
    for d in cgo_deps:
        if d.basename.endswith(".so"):
            short_dir = d.dirname[len(d.root.path):]
            extldflags += ["-Wl,-rpath,$ORIGIN/" + ("../" * pkg_depth) + short_dir]
    gc_linkopts, extldflags = _extract_extldflags(gc_linkopts, extldflags)

    link_cmd = [
        ctx.file.go_tool.path,
        "tool",
        "link",
        "-L",
        ".",
    ]
    for path in transitive_go_library_paths:
        link_cmd += ["-L", path]
    link_cmd += [
        "-o",
        executable.path,
    ] + gc_linkopts + ['"${STAMP_XDEFS[@]}"']

    # workaround for a bug in ld(1) on Mac OS X.
    # http://lists.apple.com/archives/Darwin-dev/2006/Sep/msg00084.html
    # TODO(yugui) Remove this workaround once rules_go stops supporting XCode 7.2
    # or earlier.
    if not _is_darwin_cpu(ctx):
        link_cmd += ["-s"]

    link_cmd += [
        "-extld",
        ld,
        "-extldflags",
        "'%s'" % " ".join(extldflags),
    ] + [lib.path for lib in libs]

    # Avoided -s on OSX but but it requires dsymutil to be on $PATH.
    # TODO(yugui) Remove this workaround once rules_go stops supporting XCode 7.2
    # or earlier.
    cmds = ["export PATH=$PATH:/usr/bin"]

    cmds += [
        "STAMP_XDEFS=()",
    ]

    stamp_inputs = []
    if ctx.attr.linkstamp:
        # read workspace status files, converting "KEY value" lines
        # to "-X $linkstamp.KEY=value" arguments to the go linker.
        stamp_inputs = [ctx.info_file, ctx.version_file]
        for f in stamp_inputs:
            cmds += [
                "while read -r key value || [[ -n $key ]]; do",
                "  STAMP_XDEFS+=(-X \"%s.$key=$value\")" % ctx.attr.linkstamp,
                "done < " + f.path,
            ]

    cmds += [" ".join(link_cmd)]

    f = _emit_generate_params_action(cmds, ctx, lib.basename + ".GoLinkFile.params")

    ctx.action(
        inputs = [f] + (list(transitive_go_libraries) + [lib] + list(cgo_deps) +
                        ctx.files.toolchain + ctx.files._crosstool) + stamp_inputs,
        outputs = [executable],
        command = f.path,
        mnemonic = "GoLink",
        env = go_environment_vars(ctx),
    )

def go_binary_impl(ctx):
    """go_binary_impl emits actions for compiling and linking a go executable."""
    lib_result = go_library_impl(ctx)
    _emit_go_link_action(
        ctx,
        transitive_go_libraries = lib_result.transitive_go_libraries,
        transitive_go_library_paths = lib_result.transitive_go_library_paths,
        cgo_deps = lib_result.transitive_cgo_deps,
        libs = lib_result.files,
        executable = ctx.outputs.executable,
        gc_linkopts = _gc_linkopts(ctx),
    )

    return struct(
        files = depset([ctx.outputs.executable]),
        runfiles = lib_result.runfiles,
        cgo_object = lib_result.cgo_object,
    )

def go_test_impl(ctx):
    """go_test_impl implements go testing.

    It emits an action to run the test generator, and then compiles the
    test into a binary."""

    lib_result = go_library_impl(ctx)
    main_go = ctx.new_file(ctx.label.name + "_main_test.go")
    main_object = ctx.new_file(ctx.label.name + "_main_test.o")
    main_lib = ctx.new_file(ctx.label.name + "_main_test.a")
    go_import = _go_importpath(ctx)

    cmds = [
        "UNFILTERED_TEST_FILES=(%s)" %
        " ".join(["'%s'" % f.path for f in lib_result.go_sources]),
        "FILTERED_TEST_FILES=()",
        "while read -r line; do",
        '  if [ -n "$line" ]; then',
        '    FILTERED_TEST_FILES+=("$line")',
        "  fi",
        'done < <(\'%s\' -cgo "${UNFILTERED_TEST_FILES[@]}")' %
        ctx.executable._filter_tags.path,
        " ".join([
            "'%s'" % ctx.executable.test_generator.path,
            "--package",
            go_import,
            "--output",
            "'%s'" % main_go.path,
            '"${FILTERED_TEST_FILES[@]}"',
        ]),
    ]
    f = _emit_generate_params_action(
        cmds,
        ctx,
        ctx.label.name + ".GoTestGenTest.params",
    )
    inputs = (list(lib_result.go_sources) + list(ctx.files.toolchain) +
              [f, ctx.executable._filter_tags, ctx.executable.test_generator])
    ctx.action(
        inputs = inputs,
        outputs = [main_go],
        command = f.path,
        mnemonic = "GoTestGenTest",
        env = dict(go_environment_vars(ctx), RUNDIR = ctx.label.package),
    )

    _emit_go_compile_action(
        ctx,
        sources = depset([main_go]),
        deps = ctx.attr.deps + [lib_result],
        libpaths = lib_result.transitive_go_library_paths,
        out_object = main_object,
        gc_goopts = _gc_goopts(ctx),
    )
    _emit_go_pack_action(ctx, main_lib, [main_object])
    _emit_go_link_action(
        ctx,
        transitive_go_library_paths = lib_result.transitive_go_library_paths,
        transitive_go_libraries = lib_result.transitive_go_libraries,
        cgo_deps = lib_result.transitive_cgo_deps,
        libs = [main_lib],
        executable = ctx.outputs.executable,
        gc_linkopts = _gc_linkopts(ctx),
    )

    # TODO(bazel-team): the Go tests should do a chdir to the directory
    # holding the data files, so open-source go tests continue to work
    # without code changes.
    runfiles = ctx.runfiles(files = [ctx.outputs.executable])
    runfiles = runfiles.merge(lib_result.runfiles)
    return struct(
        files = depset([ctx.outputs.executable]),
        runfiles = runfiles,
    )

go_env_attrs = {
    "toolchain": attr.label(
        default = Label("//go/toolchain:toolchain"),
        allow_files = True,
        cfg = "host",
    ),
    "go_tool": attr.label(
        default = Label("//go/toolchain:go_tool"),
        single_file = True,
        allow_files = True,
        cfg = "host",
    ),
    "go_prefix": attr.label(
        providers = ["go_prefix"],
        default = Label(
            "//:go_prefix",
            relative_to_caller_repository = True,
        ),
        allow_files = False,
        cfg = "host",
    ),
    "go_src": attr.label(
        default = Label("//go/toolchain:go_src"),
        allow_files = True,
        cfg = "host",
    ),
    "go_include": attr.label(
        default = Label("//go/toolchain:go_include"),
        single_file = True,
        allow_files = True,
        cfg = "host",
    ),
    "go_root": attr.label(
        providers = ["go_root"],
        default = Label(
            "//go/toolchain:go_root",
        ),
        allow_files = False,
        cfg = "host",
    ),
    "_filter_tags": attr.label(
        default = Label("//go/tools/filter_tags"),
        cfg = "host",
        executable = True,
        single_file = True,
    ),
    "_filter_exec": attr.label(
        default = Label("//go/tools/filter_exec"),
        cfg = "host",
        executable = True,
        single_file = True,
    ),
    "_asm": attr.label(
        default = Label("//go/tools/builders:asm"),
        cfg = "host",
        executable = True,
        single_file = True,
    ),
}

go_library_attrs = go_env_attrs + {
    "data": attr.label_list(
        allow_files = True,
        cfg = "data",
    ),
    "srcs": attr.label_list(allow_files = go_filetype),
    "deps": attr.label_list(
        providers = [
            "transitive_go_library_paths",
            "transitive_go_libraries",
            "transitive_cgo_deps",
        ],
    ),
    "importpath": attr.string(),
    "library": attr.label(
        providers = [
            "direct_deps",
            "go_sources",
            "asm_sources",
            "cgo_object",
            "gc_goopts",
        ],
    ),
    "gc_goopts": attr.string_list(),
}

_crosstool_attrs = {
    "_crosstool": attr.label(
        default = Label("//tools/defaults:crosstool"),
    ),
}

go_link_attrs = go_library_attrs + _crosstool_attrs + {
    "gc_linkopts": attr.string_list(),
    "linkstamp": attr.string(),
    "x_defs": attr.string_dict(),
}

go_library = rule(
    go_library_impl,
    attrs = go_library_attrs + {
        "cgo_object": attr.label(
            providers = [
                "cgo_obj",
                "cgo_deps",
            ],
        ),
    },
    fragments = ["cpp"],
)

go_binary = rule(
    go_binary_impl,
    attrs = go_library_attrs + _crosstool_attrs + go_link_attrs,
    executable = True,
    fragments = ["cpp"],
)

go_test = rule(
    go_test_impl,
    attrs = go_library_attrs + _crosstool_attrs + go_link_attrs + {
        "test_generator": attr.label(
            executable = True,
            default = Label(
                "//go/tools:generate_test_main",
            ),
            cfg = "host",
        ),
    },
    executable = True,
    fragments = ["cpp"],
    test = True,
)

def _pkg_dir(workspace_root, package_name):
    if workspace_root and package_name:
        return workspace_root + "/" + package_name
    if workspace_root:
        return workspace_root
    if package_name:
        return package_name
    return "."

def _exec_path(path):
    if path.startswith("/"):
        return path
    return "${execroot}/" + path

def _cgo_filter_srcs_impl(ctx):
    srcs = ctx.files.srcs
    dsts = []
    cmds = []
    for src in srcs:
        stem, _, ext = src.path.rpartition(".")
        dst_basename = "%s.filtered.%s" % (stem, ext)
        dst = ctx.new_file(src, dst_basename)
        cmds += [
            "if '%s' -cgo -quiet '%s'; then" %
            (ctx.executable._filter_tags.path, src.path),
            "  cp '%s' '%s'" % (src.path, dst.path),
            "else",
            "  echo -n >'%s'" % dst.path,
            "fi",
        ]
        dsts.append(dst)

    if ctx.label.package == "":
        script_name = ctx.label.name + ".CGoFilterSrcs.params"
    else:
        script_name = ctx.label.package + "/" + ctx.label.name + ".CGoFilterSrcs.params"
    f = _emit_generate_params_action(cmds, ctx, script_name)
    ctx.action(
        inputs = [f, ctx.executable._filter_tags] + srcs,
        outputs = dsts,
        command = f.path,
        mnemonic = "CgoFilterSrcs",
    )
    return struct(
        files = depset(dsts),
    )

_cgo_filter_srcs = rule(
    implementation = _cgo_filter_srcs_impl,
    attrs = {
        "srcs": attr.label_list(
            allow_files = cgo_filetype,
        ),
        "_filter_tags": attr.label(
            default = Label("//go/tools/filter_tags"),
            cfg = "host",
            executable = True,
            single_file = True,
        ),
    },
    fragments = ["cpp"],
)

def _cgo_codegen_impl(ctx):
    go_srcs = ctx.files.srcs
    srcs = go_srcs + ctx.files.c_hdrs
    linkopts = ctx.attr.linkopts
    copts = ctx.fragments.cpp.c_options + ctx.attr.copts
    deps = depset([], order = "topological")
    for d in ctx.attr.deps:
        srcs += list(d.cc.transitive_headers)
        deps += d.cc.libs
        copts += ["-D" + define for define in d.cc.defines]
        for inc in d.cc.include_directories:
            copts += ["-I", _exec_path(inc)]
        for hdr in ctx.files.c_hdrs:
            copts += ["-iquote", hdr.dirname]
        for inc in d.cc.quote_include_directories:
            copts += ["-iquote", _exec_path(inc)]
        for inc in d.cc.system_include_directories:
            copts += ["-isystem", _exec_path(inc)]
        for lib in d.cc.libs:
            if lib.basename.startswith("lib") and lib.basename.endswith(".so"):
                linkopts += ["-L", lib.dirname, "-l", lib.basename[3:-3]]
            else:
                linkopts += [lib.path]
        linkopts += d.cc.link_flags

    p = _pkg_dir(ctx.label.workspace_root, ctx.label.package) + "/"
    if p == "./":
        p = ""  # workaround when cgo_library in repository root
    out_dir = (ctx.configuration.genfiles_dir.path + "/" +
               p + ctx.attr.outdir)
    cc = ctx.fragments.cpp.compiler_executable
    cmds = [
        # We cannot use env for CC because $(CC) on OSX is relative
        # and '../' does not work fine due to symlinks.
        "export CC=$(cd $(dirname {cc}); pwd)/$(basename {cc})".format(cc = cc),
        "export CXX=$CC",
        'objdir="%s/gen"' % out_dir,
        "execroot=$(pwd)",
        'mkdir -p "$objdir"',
        "unfiltered_go_files=(%s)" % " ".join(["'%s'" % f.path for f in go_srcs]),
        "filtered_go_files=()",
        'for file in "${unfiltered_go_files[@]}"; do',
        '  stem=$(basename "$file" .go)',
        '  if %s -cgo -quiet "$file"; then' % ctx.executable._filter_tags.path,
        '    filtered_go_files+=("$file")',
        "  else",
        '    grep --max-count 1 "^package " "$file" >"$objdir/$stem.go"',
        '    echo -n >"$objdir/$stem.c"',
        "  fi",
        "done",
        "if [ ${#filtered_go_files[@]} -eq 0 ]; then",
        "  echo no buildable Go source files in %s >&1" % str(ctx.label),
        "  exit 1",
        "fi",
        '"$GOROOT/bin/go" tool cgo -objdir "$objdir" -- %s "${filtered_go_files[@]}"' %
        " ".join(['"%s"' % copt for copt in copts]),
        # Rename the outputs using glob so we don't have to understand cgo's mangling
        # TODO(#350): might be fixed by this?.
        'for file in "${filtered_go_files[@]}"; do',
        '  stem=$(basename "$file" .go)',
        '  mv "$objdir/"*"$stem.cgo1.go" "$objdir/$stem.go"',
        '  mv "$objdir/"*"$stem.cgo2.c" "$objdir/$stem.c"',
        "done",
        "rm -f $objdir/_cgo_.o $objdir/_cgo_flags",
    ]

    f = _emit_generate_params_action(cmds, ctx, out_dir + ".CGoCodeGenFile.params")

    inputs = (srcs + ctx.files.toolchain + ctx.files._crosstool +
              [f, ctx.executable._filter_tags])
    ctx.action(
        inputs = inputs,
        outputs = ctx.outputs.outs,
        mnemonic = "CGoCodeGen",
        progress_message = "CGoCodeGen %s" % ctx.label,
        command = f.path,
        env = go_environment_vars(ctx) + {
            "CGO_LDFLAGS": " ".join(linkopts),
        },
    )
    return struct(
        label = ctx.label,
        files = depset(ctx.outputs.outs),
        cgo_deps = deps,
    )

_cgo_codegen_rule = rule(
    _cgo_codegen_impl,
    attrs = go_env_attrs + _crosstool_attrs + {
        "srcs": attr.label_list(
            allow_files = go_filetype,
            non_empty = True,
        ),
        "c_hdrs": attr.label_list(
            allow_files = cc_hdr_filetype,
        ),
        "deps": attr.label_list(
            allow_files = False,
            providers = ["cc"],
        ),
        "copts": attr.string_list(),
        "linkopts": attr.string_list(),
        "outdir": attr.string(mandatory = True),
        "outs": attr.output_list(
            mandatory = True,
            non_empty = True,
        ),
    },
    fragments = ["cpp"],
    output_to_genfiles = True,
)

def _cgo_codegen(
        name,
        srcs,
        c_hdrs = [],
        deps = [],
        copts = [],
        linkopts = [],
        go_tool = None,
        toolchain = None):
    """Generates glue codes for interop between C and Go

    Args:
      name: A unique name of the rule
      srcs: list of Go source files.
        Each of them must contain `import "C"`.
      c_hdrs: C/C++ header files necessary to determine kinds of
        C/C++ identifiers in srcs.
      deps: A list of cc_library rules.
        The generated codes are expected to be linked with these deps.
      linkopts: A list of linker options,
        These flags are passed to the linker when the generated codes
        are linked into the target binary.
    """
    outdir = name + ".dir"
    outgen = outdir + "/gen"

    go_thunks = []
    c_thunks = []
    for s in srcs:
        if not s.endswith(".go"):
            fail("not a .go file: %s" % s)
        basename = s[:-3]
        if basename.rfind("/") >= 0:
            basename = basename[basename.rfind("/") + 1:]
        go_thunks.append(outgen + "/" + basename + ".go")
        c_thunks.append(outgen + "/" + basename + ".c")

    outs = struct(
        name = name,
        outdir = outgen,
        go_thunks = go_thunks,
        c_thunks = c_thunks,
        c_exports = [
            outgen + "/_cgo_export.c",
            outgen + "/_cgo_export.h",
        ],
        c_dummy = outgen + "/_cgo_main.c",
        gotypes = outgen + "/_cgo_gotypes.go",
    )

    _cgo_codegen_rule(
        name = name,
        srcs = srcs,
        c_hdrs = c_hdrs,
        deps = deps,
        copts = copts,
        linkopts = linkopts,
        go_tool = go_tool,
        toolchain = toolchain,
        outdir = outdir,
        outs = outs.go_thunks + outs.c_thunks + outs.c_exports + [
            outs.c_dummy,
            outs.gotypes,
        ],
        visibility = ["//visibility:private"],
    )
    return outs

def _cgo_import_impl(ctx):
    cmds = [
        (ctx.file.go_tool.path + " tool cgo" +
         " -dynout " + ctx.outputs.out.path +
         " -dynimport " + ctx.file.cgo_o.path +
         " -dynpackage $(%s %s)" % (
             ctx.executable._extract_package.path,
             ctx.file.sample_go_src.path,
         )),
    ]
    f = _emit_generate_params_action(cmds, ctx, ctx.outputs.out.path + ".CGoImportGenFile.params")
    ctx.action(
        inputs = (ctx.files.toolchain +
                  [
                      f,
                      ctx.file.go_tool,
                      ctx.executable._extract_package,
                      ctx.file.cgo_o,
                      ctx.file.sample_go_src,
                  ]),
        outputs = [ctx.outputs.out],
        command = f.path,
        mnemonic = "CGoImportGen",
        env = go_environment_vars(ctx),
    )
    return struct(
        files = depset([ctx.outputs.out]),
    )

_cgo_import = rule(
    _cgo_import_impl,
    attrs = go_env_attrs + {
        "cgo_o": attr.label(
            allow_files = True,
            single_file = True,
        ),
        "sample_go_src": attr.label(
            allow_files = True,
            single_file = True,
        ),
        "out": attr.output(
            mandatory = True,
        ),
        "_extract_package": attr.label(
            default = Label("//go/tools/extract_package"),
            executable = True,
            cfg = "host",
        ),
    },
    fragments = ["cpp"],
)

def _cgo_genrule_impl(ctx):
    return struct(
        label = ctx.label,
        go_sources = ctx.files.srcs,
        asm_sources = [],
        asm_headers = [],
        cgo_object = ctx.attr.cgo_object,
        direct_deps = ctx.attr.deps,
        gc_goopts = [],
    )

_cgo_genrule = rule(
    _cgo_genrule_impl,
    attrs = {
        "srcs": attr.label_list(allow_files = FileType([".go"])),
        "cgo_object": attr.label(
            providers = [
                "cgo_obj",
                "cgo_deps",
            ],
        ),
        "deps": attr.label_list(
            providers = [
                "direct_deps",
                "transitive_go_library_paths",
                "transitive_go_libraries",
                "transitive_cgo_deps",
            ],
        ),
    },
    fragments = ["cpp"],
)

"""Generates symbol-import directives for cgo

Args:
  cgo_o: The loadable object to extract dynamic symbols from.
  sample_go_src: A go source which is compiled together with the generated file.
    The generated file will have the same Go package name as this file.
  out: Destination of the generated codes.
"""

def _cgo_object_impl(ctx):
    arguments = _c_linker_options(ctx, blocklist = [
        # never link any dependency libraries
        "-l",
        "-L",
        # manage flags to ld(1) by ourselves
        "-Wl,",
    ])
    arguments += [
        "-o",
        ctx.outputs.out.path,
        "-nostdlib",
        "-Wl,-r",
    ]
    if _is_darwin_cpu(ctx):
        arguments += ["-shared", "-Wl,-all_load"]
    else:
        arguments += ["-Wl,-whole-archive"]

    lo = ctx.files.src[-1]
    arguments += [lo.path]

    ctx.action(
        inputs = [lo] + ctx.files._crosstool,
        outputs = [ctx.outputs.out],
        mnemonic = "CGoObject",
        progress_message = "Linking %s" % ctx.outputs.out.short_path,
        executable = ctx.fragments.cpp.compiler_executable,
        arguments = arguments,
    )
    runfiles = ctx.runfiles(collect_data = True)
    runfiles = runfiles.merge(ctx.attr.src.data_runfiles)
    return struct(
        files = depset([ctx.outputs.out]),
        cgo_obj = ctx.outputs.out,
        cgo_deps = ctx.attr.cgogen.cgo_deps,
        runfiles = runfiles,
    )

_cgo_object = rule(
    _cgo_object_impl,
    attrs = _crosstool_attrs + {
        "src": attr.label(
            mandatory = True,
            providers = ["cc"],
        ),
        "cgogen": attr.label(
            mandatory = True,
            providers = ["cgo_deps"],
        ),
        "out": attr.output(
            mandatory = True,
        ),
    },
    fragments = ["cpp"],
)

"""Generates _all.o to be archived together with Go objects.

Args:
  src: source static library which contains objects
  cgogen: _cgo_codegen rule which knows the dependency cc_library() rules
    to be linked together with src when we generate the final go binary.
"""

def _setup_cgo_library(name, srcs, cdeps, copts, clinkopts, go_tool, toolchain):
    go_srcs = [s for s in srcs if s.endswith(".go")]
    c_hdrs = [s for s in srcs if any([s.endswith(ext) for ext in hdr_exts])]
    c_srcs = [s for s in srcs if not s in (go_srcs + c_hdrs)]

    # Split cgo files into .go parts and .c parts (plus some other files).
    cgogen = _cgo_codegen(
        name = name + ".cgo",
        srcs = go_srcs,
        c_hdrs = c_hdrs,
        deps = cdeps,
        copts = copts,
        linkopts = clinkopts,
        go_tool = go_tool,
        toolchain = toolchain,
    )

    # Filter c_srcs with build constraints.
    c_filtered_srcs = []
    if len(c_srcs) > 0:
        c_filtered_srcs_name = name + "_filter_cgo_srcs"
        _cgo_filter_srcs(
            name = c_filtered_srcs_name,
            srcs = c_srcs,
        )
        c_filtered_srcs.append(":" + c_filtered_srcs_name)

    pkg_dir = _pkg_dir(
        "external/" + REPOSITORY_NAME[1:] if len(REPOSITORY_NAME) > 1 else "",
        PACKAGE_NAME,
    )

    # Platform-specific settings
    native.config_setting(
        name = name + "_windows_setting",
        values = {
            "cpu": "x64_windows_msvc",
        },
    )
    platform_copts = select({
        ":" + name + "_windows_setting": ["-mthreads"],
        "//conditions:default": ["-pthread"],
    })
    platform_linkopts = select({
        ":" + name + "_windows_setting": ["-mthreads"],
        "//conditions:default": ["-pthread"],
    })

    # Bundles objects into an archive so that _cgo_.o and _all.o can share them.
    native.cc_library(
        name = cgogen.outdir + "/_cgo_lib",
        srcs = cgogen.c_thunks + cgogen.c_exports + c_filtered_srcs + c_hdrs,
        deps = cdeps,
        copts = copts + platform_copts + [
            "-I",
            pkg_dir,
            "-I",
            "$(GENDIR)/" + pkg_dir + "/" + cgogen.outdir,
            # The generated thunks often contain unused variables.
            "-Wno-unused-variable",
        ],
        linkopts = clinkopts + platform_linkopts,
        linkstatic = 1,
        # _cgo_.o and _all.o keep all objects in this archive.
        # But it should not be very annoying in the final binary target
        # because _cgo_object rule does not propagate alwayslink=1
        alwayslink = 1,
        visibility = ["//visibility:private"],
    )

    # Loadable object which cgo reads when it generates _cgo_import.go
    native.cc_binary(
        name = cgogen.outdir + "/_cgo_.o",
        srcs = [cgogen.c_dummy],
        deps = cdeps + [cgogen.outdir + "/_cgo_lib"],
        copts = copts,
        linkopts = clinkopts,
        visibility = ["//visibility:private"],
    )
    _cgo_import(
        name = "%s.cgo.importgen" % name,
        cgo_o = cgogen.outdir + "/_cgo_.o",
        out = cgogen.outdir + "/_cgo_import.go",
        sample_go_src = go_srcs[0],
        go_tool = go_tool,
        toolchain = toolchain,
        visibility = ["//visibility:private"],
    )

    _cgo_object(
        name = cgogen.outdir + "/_cgo_object",
        src = cgogen.outdir + "/_cgo_lib",
        out = cgogen.outdir + "/_all.o",
        cgogen = cgogen.name,
        visibility = ["//visibility:private"],
    )
    return cgogen

def cgo_genrule(
        name,
        srcs,
        copts = [],
        clinkopts = [],
        cdeps = [],
        **kwargs):
    cgogen = _setup_cgo_library(
        name = name,
        srcs = srcs,
        cdeps = cdeps,
        copts = copts,
        clinkopts = clinkopts,
        toolchain = None,
        go_tool = None,
    )
    _cgo_genrule(
        name = name,
        srcs = cgogen.go_thunks + [
            cgogen.gotypes,
            cgogen.outdir + "/_cgo_import.go",
        ],
        cgo_object = cgogen.outdir + "/_cgo_object",
        **kwargs
    )

def cgo_library(
        name,
        srcs,
        toolchain = None,
        go_tool = None,
        copts = [],
        clinkopts = [],
        cdeps = [],
        **kwargs):
    """Builds a cgo-enabled go library.

    Args:
      name: A unique name for this rule.
      srcs: List of Go, C and C++ files that are processed to build a Go library.
        Those Go files must contain `import "C"`.
        C and C++ files can be anything allowed in `srcs` attribute of
        `cc_library`.
      copts: Add these flags to the C++ compiler.
      clinkopts: Add these flags to the C++ linker.
      cdeps: List of C/C++ libraries to be linked into the binary target.
        They must be `cc_library` rules.
      deps: List of other libraries to be linked to this library target.
      data: List of files needed by this rule at runtime.

    NOTE:
      `srcs` cannot contain pure-Go files, which do not have `import "C"`.
      So you need to define another `go_library` when you build a go package with
      both cgo-enabled and pure-Go sources.

      ```
      cgo_library(
          name = "cgo_enabled",
          srcs = ["cgo-enabled.go", "foo.cc", "bar.S", "baz.a"],
      )

      go_library(
          name = "go_default_library",
          srcs = ["pure-go.go"],
          library = ":cgo_enabled",
      )
      ```
    """
    cgogen = _setup_cgo_library(
        name = name,
        srcs = srcs,
        cdeps = cdeps,
        copts = copts,
        clinkopts = clinkopts,
        go_tool = go_tool,
        toolchain = toolchain,
    )

    go_library(
        name = name,
        srcs = cgogen.go_thunks + [
            cgogen.gotypes,
            cgogen.outdir + "/_cgo_import.go",
        ],
        cgo_object = cgogen.outdir + "/_cgo_object",
        go_tool = go_tool,
        toolchain = toolchain,
        **kwargs
    )