feat(third_party/bazel): Check in rules_haskell from Tweag r/17

1 files changed, 395 insertions, 0 deletions

diff --git a/third_party/bazel/rules_haskell/haskell/protobuf.bzl b/third_party/bazel/rules_haskell/haskell/protobuf.bzl
new file mode 100644
index 000000000000..5c8b9a817648
--- /dev/null
+++ b/third_party/bazel/rules_haskell/haskell/protobuf.bzl
@@ -0,0 +1,395 @@
+"""Support for protocol buffers"""
+
+load(
+    ":private/haskell_impl.bzl",
+    _haskell_library_impl = "haskell_library_impl",
+)
+load("@bazel_skylib//lib:paths.bzl", "paths")
+load(
+    "@io_tweag_rules_haskell//haskell:providers.bzl",
+    "HaskellInfo",
+    "HaskellLibraryInfo",
+    "HaskellProtobufInfo",
+)
+
+def _capitalize_first_letter(c):
+    """Capitalize the first letter of the input. Unlike the built-in
+    `capitalize()` method, doesn't lower-case the other characters. This helps
+    mimic the behavior of `proto-lens-protoc`, which turns `Foo/Bar/BAZ.proto`
+    into `Foo/Bar/BAZ.hs` (rather than `Foo/Bar/Baz.hs`).
+
+    Args:
+      c: A non-empty string word.
+
+    Returns:
+      The input with the first letter upper-cased.
+    """
+    return c[0].capitalize() + c[1:]
+
+def _camel_case(comp):
+    """Camel-case the input string, preserving any existing capital letters.
+    """
+
+    # Split on both "-" and "_", matching the behavior of proto-lens-protoc.
+    # Be sure to ignore any empty segments from input with leading or trailing
+    # delimiters.
+    return "".join([
+        _capitalize_first_letter(c2)
+        for c1 in comp.split("_")
+        for c2 in c1.split("-")
+        if len(c2) > 0
+    ])
+
+def _proto_lens_output_file(path):
+    """The output file from `proto-lens-protoc` when run on the given `path`.
+    """
+
+    path = path[:-len(".proto")]
+    result = "/".join([_camel_case(p) for p in path.split("/")]) + ".hs"
+
+    return "Proto/" + result
+
+def _proto_lens_fields_file(path):
+    """The fields file from `proto-lens-protoc` when run on the given `path`.
+    """
+
+    path = path[:-len(".proto")]
+    result = "/".join([_camel_case(p) for p in path.split("/")]) + "_Fields.hs"
+
+    return "Proto/" + result
+
+def _proto_path(proto, proto_source_roots):
+    """A path to the proto file which matches any import statements."""
+    proto_path = proto.path
+    for p in proto_source_roots:
+        if proto_path.startswith(p):
+            return paths.relativize(proto_path, p)
+
+    return paths.relativize(
+        proto_path,
+        paths.join(proto.root.path, proto.owner.workspace_root),
+    )
+
+def _haskell_proto_aspect_impl(target, ctx):
+    pb = ctx.toolchains["@io_tweag_rules_haskell//protobuf:toolchain"].tools
+
+    args = ctx.actions.args()
+
+    src_prefix = paths.join(
+        ctx.label.workspace_root,
+        ctx.label.package,
+    )
+
+    args.add("--plugin=protoc-gen-haskell=" + pb.plugin.path)
+
+    hs_files = []
+    inputs = []
+
+    direct_proto_paths = [target.proto.proto_source_root]
+    transitive_proto_paths = target.proto.transitive_proto_path
+
+    args.add_all([
+        "-I{0}={1}".format(_proto_path(s, transitive_proto_paths), s.path)
+        for s in target.proto.transitive_sources.to_list()
+    ])
+
+    inputs.extend(target.proto.transitive_sources.to_list())
+
+    for src in target.proto.direct_sources:
+        inputs.append(src)
+
+        # As with the native rules, require the .proto file to be in the same
+        # Bazel package as the proto_library rule. This allows us to put the
+        # output .hs file next to the input .proto file. Unfortunately Skylark
+        # doesn't let us check the package of the file directly, so instead we
+        # just look at its short_path and rely on the proto_library rule itself
+        # to check for consistency. We use the file's path rather than its
+        # dirname/basename in case it's in a subdirectory; for example, if the
+        # proto_library rule is in "foo/BUILD" but the .proto file is
+        # "foo/bar/baz.proto".
+
+        if not src.path.startswith(paths.join(src.root.path, src_prefix)):
+            fail("Mismatch between rule context " + str(ctx.label.package) +
+                 " and source file " + src.short_path)
+        if src.basename[-6:] != ".proto":
+            fail("bad extension for proto file " + src)
+
+        args.add(src.path)
+        hs_files.append(ctx.actions.declare_file(
+            _proto_lens_output_file(
+                _proto_path(src, direct_proto_paths),
+            ),
+        ))
+        hs_files.append(ctx.actions.declare_file(
+            _proto_lens_fields_file(
+                _proto_path(src, direct_proto_paths),
+            ),
+        ))
+
+    args.add_all([
+        "--proto_path=" + target.proto.proto_source_root,
+        "--haskell_out=no-runtime:" + paths.join(
+            hs_files[0].root.path,
+            src_prefix,
+        ),
+    ])
+
+    ctx.actions.run(
+        inputs = depset([pb.protoc, pb.plugin] + inputs),
+        outputs = hs_files,
+        mnemonic = "HaskellProtoc",
+        executable = pb.protoc,
+        arguments = [args],
+    )
+
+    patched_attrs = {
+        "compiler_flags": [],
+        "src_strip_prefix": "",
+        "repl_interpreted": True,
+        "repl_ghci_args": [],
+        "version": "",
+        "linkstatic": False,
+        "_ghci_script": ctx.attr._ghci_script,
+        "_ghci_repl_wrapper": ctx.attr._ghci_repl_wrapper,
+        "hidden_modules": [],
+        "exports": {},
+        "name": "proto-autogen-" + ctx.rule.attr.name,
+        "srcs": hs_files,
+        "deps": ctx.rule.attr.deps +
+                ctx.toolchains["@io_tweag_rules_haskell//protobuf:toolchain"].deps,
+        "prebuilt_dependencies": ctx.toolchains["@io_tweag_rules_haskell//protobuf:toolchain"].prebuilt_deps,
+        "plugins": [],
+        "_cc_toolchain": ctx.attr._cc_toolchain,
+    }
+
+    patched_ctx = struct(
+        actions = ctx.actions,
+        attr = struct(**patched_attrs),
+        bin_dir = ctx.bin_dir,
+        disabled_features = ctx.rule.attr.features,
+        executable = struct(
+            _ls_modules = ctx.executable._ls_modules,
+        ),
+        # Necessary for CC interop (see cc.bzl).
+        features = ctx.rule.attr.features,
+        file = ctx.file,
+        files = struct(
+            srcs = hs_files,
+            _cc_toolchain = ctx.files._cc_toolchain,
+            extra_srcs = depset(),
+        ),
+        genfiles_dir = ctx.genfiles_dir,
+        label = ctx.label,
+        toolchains = ctx.toolchains,
+        var = ctx.var,
+    )
+
+    # TODO this pattern match is very brittle. Let's not do this. The
+    # order should match the order in the return value expression in
+    # haskell_library_impl().
+    [hs_info, cc_info, coverage_info, default_info, library_info] = _haskell_library_impl(patched_ctx)
+
+    return [
+        cc_info,  # CcInfo
+        hs_info,  # HaskellInfo
+        library_info,  # HaskellLibraryInfo
+        # We can't return DefaultInfo here because target already provides that.
+        HaskellProtobufInfo(files = default_info.files),
+    ]
+
+_haskell_proto_aspect = aspect(
+    _haskell_proto_aspect_impl,
+    attr_aspects = ["deps"],
+    attrs = {
+        "_ghci_script": attr.label(
+            allow_single_file = True,
+            default = Label("@io_tweag_rules_haskell//haskell:assets/ghci_script"),
+        ),
+        "_ghci_repl_wrapper": attr.label(
+            allow_single_file = True,
+            default = Label("@io_tweag_rules_haskell//haskell:private/ghci_repl_wrapper.sh"),
+        ),
+        "_ls_modules": attr.label(
+            executable = True,
+            cfg = "host",
+            default = Label("@io_tweag_rules_haskell//haskell:ls_modules"),
+        ),
+        "_cc_toolchain": attr.label(
+            default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
+        ),
+    },
+    toolchains = [
+        "@io_tweag_rules_haskell//haskell:toolchain",
+        "@io_tweag_rules_haskell//protobuf:toolchain",
+    ],
+)
+
+def _haskell_proto_library_impl(ctx):
+    dep = ctx.attr.deps[0]  # FIXME
+    return [
+        dep[CcInfo],
+        dep[HaskellInfo],
+        dep[HaskellLibraryInfo],
+        DefaultInfo(files = dep[HaskellProtobufInfo].files),
+    ]
+
+haskell_proto_library = rule(
+    _haskell_proto_library_impl,
+    attrs = {
+        "deps": attr.label_list(
+            mandatory = True,
+            allow_files = False,
+            aspects = [_haskell_proto_aspect],
+            doc = "List of `proto_library` targets to use for generation.",
+        ),
+    },
+    toolchains = [
+        "@io_tweag_rules_haskell//haskell:toolchain",
+        "@io_tweag_rules_haskell//protobuf:toolchain",
+    ],
+)
+
+"""Generate Haskell library allowing to use protobuf definitions with help
+of [`proto-lens`](https://github.com/google/proto-lens#readme).
+
+Example:
+  ```bzl
+  proto_library(
+    name = "foo_proto",
+    srcs = ["foo.proto"],
+  )
+
+  haskell_proto_library(
+    name = "foo_haskell_proto",
+    deps = [":foo_proto"],
+  )
+  ```
+
+`haskell_proto_library` targets require `haskell_proto_toolchain` to be
+registered.
+"""
+
+def _protobuf_toolchain_impl(ctx):
+    if ctx.attr.prebuilt_deps:
+        print("""The attribute 'prebuilt_deps' has been deprecated,
+use the 'deps' attribute instead.
+""")
+
+    return [
+        platform_common.ToolchainInfo(
+            name = ctx.label.name,
+            tools = struct(
+                plugin = ctx.executable.plugin,
+                protoc = ctx.executable.protoc,
+            ),
+            deps = ctx.attr.deps,
+            prebuilt_deps = ctx.attr.prebuilt_deps,
+        ),
+    ]
+
+_protobuf_toolchain = rule(
+    _protobuf_toolchain_impl,
+    attrs = {
+        "protoc": attr.label(
+            executable = True,
+            cfg = "host",
+            allow_single_file = True,
+            mandatory = True,
+            doc = "protoc compiler",
+        ),
+        "plugin": attr.label(
+            executable = True,
+            cfg = "host",
+            allow_single_file = True,
+            mandatory = True,
+            doc = "proto-lens-protoc plugin for protoc",
+        ),
+        "deps": attr.label_list(
+            doc = "List of other Haskell libraries to be linked to protobuf libraries.",
+        ),
+        "prebuilt_deps": attr.string_list(
+            doc = "Non-Bazel supplied Cabal dependencies for protobuf libraries.",
+        ),
+    },
+)
+
+def haskell_proto_toolchain(
+        name,
+        plugin,
+        deps = [],
+        prebuilt_deps = [],
+        protoc = Label("@com_google_protobuf//:protoc"),
+        **kwargs):
+    """Declare a Haskell protobuf toolchain.
+
+    You need at least one of these declared somewhere in your `BUILD` files
+    for the `haskell_proto_library` rules to work. Once declared, you then
+    need to *register* the toolchain using `register_toolchains` in your
+    `WORKSPACE` file (see example below).
+
+    Example:
+
+      In a `BUILD` file:
+
+      ```bzl
+      haskell_proto_toolchain(
+        name = "protobuf-toolchain",
+        protoc = "@com_google_protobuf//:protoc",
+        plugin = "@hackage-proto-lens-protoc//:bin/proto-lens-protoc",
+        prebuilt_deps = [
+          "base",
+          "bytestring",
+          "containers",
+          "data-default-class",
+          "lens-family",
+          "lens-labels",
+          "proto-lens",
+          "text",
+        ],
+      )
+      ```
+
+      The `prebuilt_deps` and `deps` arguments allow to specify Haskell
+      libraries to use to compile the auto-generated source files.
+
+      In `WORKSPACE` you could have something like this:
+
+      ```bzl
+      http_archive(
+        name = "com_google_protobuf",
+        sha256 = "cef7f1b5a7c5fba672bec2a319246e8feba471f04dcebfe362d55930ee7c1c30",
+        strip_prefix = "protobuf-3.5.0",
+        urls = ["https://github.com/google/protobuf/archive/v3.5.0.zip"],
+      )
+
+      nixpkgs_package(
+        name = "protoc_gen_haskell",
+        repository = "@nixpkgs",
+        attribute_path = "haskell.packages.ghc822.proto-lens-protoc
+      )
+
+      register_toolchains(
+        "//tests:ghc", # assuming you called your Haskell toolchain "ghc"
+        "//tests:protobuf-toolchain",
+      )
+      ```
+    """
+    impl_name = name + "-impl"
+    _protobuf_toolchain(
+        name = impl_name,
+        plugin = plugin,
+        deps = deps,
+        prebuilt_deps = prebuilt_deps,
+        protoc = protoc,
+        visibility = ["//visibility:public"],
+        **kwargs
+    )
+
+    native.toolchain(
+        name = name,
+        toolchain_type = "@io_tweag_rules_haskell//protobuf:toolchain",
+        toolchain = ":" + impl_name,
+        exec_compatible_with = [
+            "@bazel_tools//platforms:x86_64",
+        ],
+    )