Qt toolchain

[limdor]

No description provided.

[lummax]

Is there a reason to not use https://docs.bazel.build/versions/main/skylark/lib/dict.html#get ? It is available at least from 1.0 onward.

Because this uses QT_DIR, I think repository_rule() down below should set environ = ["QT_DIR"] https://docs.bazel.build/versions/main/skylark/lib/globals.html#repository_rule

[limdor]

As it is right now you are right that get could be used. What happened is that the code evolved. Initially getting the variable was done in a case insensitive way this is why get could have not been used. This should be redone and make clear what behavior is wanted, here the full discussion: #17 (comment)

[lummax]

I took the liberty to adapt this a little to our use-case at work. This is stripped down to suit our needs, but I am happy to collaborate on this and help with this PR.

BUILD.bazel:

toolchain_type(
    name = "toolchain_type",
    visibility = ["//visibility:public"],
)

qt_toolchain(
    name = "conan_dependencies",
    moc = "@conan_dependencies_qt_installer//:moc",
    rcc = "@conan_dependencies_qt_installer//:rcc",
)

toolchain(
    name = "qt",
    toolchain = ":conan_dependencies",
    toolchain_type = ":toolchain_type",
)

defs.bzl:

load("@rules_cc//cc:defs.bzl", "cc_library")

QT_TOOLCHAIN = "//projects/support/bazel/compilation/qt:toolchain_type"

QtSDK = provider(
    fields = {
        "rcc": "Label for the the `rcc` binary",
        "moc": "Label for the the `moc` binary",
    },
)

def _qt_toolchain_impl(ctx):
    return [
        platform_common.ToolchainInfo(
            qt_sdk = QtSDK(
                rcc = ctx.executable.rcc,
                moc = ctx.executable.moc,
            ),
        ),
    ]

qt_toolchain = rule(
    implementation = _qt_toolchain_impl,
    attrs = {
        "rcc": attr.label(allow_files = True, executable = True, cfg = "exec"),
        "moc": attr.label(allow_files = True, executable = True, cfg = "exec"),
    },
)

def _qt_rcc(ctx):
    qt_sdk = ctx.toolchains[QT_TOOLCHAIN].qt_sdk
    out = ctx.actions.declare_file(ctx.label.name)

    resource_name = ctx.attr.resource_name
    if not resource_name:
        resource_name = out.basename
        if out.extension:
            resource_name = resource_name[:-len(out.extension) - 1]

    args = [
        "--name",
        resource_name,
        "--output",
        out.path,
        ctx.file.qrc.path,
    ]
    ctx.actions.run(
        inputs = ctx.files.files + [ctx.file.qrc],
        outputs = [out],
        arguments = args,
        executable = qt_sdk.rcc,
    )
    return [DefaultInfo(files = depset(direct = [out]))]

qt_rcc = rule(
    implementation = _qt_rcc,
    attrs = {
        "resource_name": attr.string(),
        "files": attr.label_list(allow_files = True),
        "qrc": attr.label(allow_single_file = True, mandatory = True),
    },
    toolchains = [QT_TOOLCHAIN],
)

def _qt_gen_qrc(ctx):
    out = ctx.actions.declare_file(ctx.label.name)

    content = """<!DOCTYPE RCC>
<RCC>
  <qresource>
%s
  </qresource>
</RCC>
"""
    lines = ["    <file>%s</file>" % f.path for f in ctx.files.files]
    ctx.actions.write(out, content % "\n".join(lines))
    return [DefaultInfo(files = depset(direct = [out]))]

qt_gen_qrc = rule(
    implementation = _qt_gen_qrc,
    attrs = {"files": attr.label_list(allow_files = True)},
)

def _qt_moc(ctx):
    qt_sdk = ctx.toolchains[QT_TOOLCHAIN].qt_sdk
    outputs = []

    for hdr in ctx.files.hdrs:
        out = ctx.actions.declare_file(hdr.basename[:-len(hdr.extension)] + ctx.attr.extension)
        outputs.append(out)

        ctx.actions.run(
            inputs = [hdr],
            outputs = [out],
            arguments = [hdr.path, "-o", out.path],
            executable = qt_sdk.moc,
        )

    return [DefaultInfo(files = depset(direct = outputs))]

qt_moc = rule(
    implementation = _qt_moc,
    attrs = {
        "hdrs": attr.label_list(allow_files = True),
        "extension": attr.string(default = "cpp"),
    },
    toolchains = [QT_TOOLCHAIN],
)

PS: thank you @limdor, https://github.com/limdor/bazel-examples/tree/master/linux_toolchain helped tremendously!

[lummax]

And just for someone else to be able to find it: https://github.com/qt/qtbase/blob/dev/src/tools/rcc/rcc.cpp#L237

One should set SOURCE_DATE_EPOCH to a non-zero value when using rcc for optimal cache reuse.

[Debupt]

hello, curious about this part, how can we pass bin path to qt_toolchain rule to get moc, rcc and uic path?