rules.bzl

# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under both the MIT license found in the
# LICENSE-MIT file in the root directory of this source tree and the Apache
# License, Version 2.0 found in the LICENSE-APACHE file in the root directory
# of this source tree.

load("@prelude//:is_full_meta_repo.bzl", "is_full_meta_repo")

# Combine the attributes we generate, we the custom implementations we have.
load("@prelude//:rules_impl.bzl", "extra_attributes", "extra_implemented_rules", "rule_decl_records", "toolchain_rule_names", "transitions")
load("@prelude//apple:apple_platforms.bzl", "APPLE_PLATFORMS_KEY")
load("@prelude//configurations:rules.bzl", _config_implemented_rules = "implemented_rules")
load("@prelude//decls:common.bzl", "prelude_rule")

def _unimplemented(name, ctx):
    fail("Unimplemented rule type `{}` for target `{}`.".format(name, ctx.label))

def _unimplemented_impl(name):
    # We could use a lambda here, but then it means every single parse evaluates a lambda.
    # Lambda's have tricky semantics, so using partial lets us test Starlark prototypes with
    # some features disabled.
    return partial(_unimplemented, name)

def _mk_rule(rule_spec: typing.Any, extra_attrs: dict[str, typing.Any] = dict(), impl_override: [typing.Callable, None] = None, **kwargs):
    name = rule_spec.name
    attributes = rule_spec.attrs

    # We want native code-containing rules to be marked incompatible with fat
    # platforms. Getting the ones that use cxx/apple toolchains is a little
    # overly broad as it includes things like python that don't themselves have
    # native code but need the toolchains if they depend on native code and in
    # that case incompatibility is transitive and they'll get it.
    fat_platform_compatible = True
    if name not in ("python_library", "python_binary", "python_test"):
        for toolchain_attr in ("_apple_toolchain", "_cxx_toolchain", "_go_toolchain"):
            if toolchain_attr in attributes:
                fat_platform_compatible = False

    # Fat platforms is an idea specific to our toolchains, so doesn't apply to
    # open source. Ideally this restriction would be done at the toolchain level.
    if not is_full_meta_repo():
        fat_platform_compatible = True

    attributes = dict(attributes)
    attributes.update(extra_attrs)
    if not fat_platform_compatible:
        # copy so we don't try change the passed in object
        attributes["_cxx_toolchain_target_configuration"] = attrs.dep(default = "prelude//platforms:fat_platform_incompatible")

    # Add _apple_platforms to all rules so that we may query the target platform to use until we support configuration
    # modifiers and can use them to set the configuration to use for operations.
    # Map of string identifier to platform.
    attributes[APPLE_PLATFORMS_KEY] = attrs.dict(key = attrs.string(), value = attrs.dep(), sorted = False, default = {})

    extra_args = dict(kwargs)
    cfg = transitions.get(name)
    if cfg != None:
        extra_args["cfg"] = cfg

    if rule_spec.docs:
        doc = rule_spec.docs

        # This is awkward. When generating documentation, we'll strip leading whitespace
        # like it's a python docstring. For that to work here, we need the "Examples:" line
        # to match the other lines for leading whitespace. We've just hardcoded this to
        # be what its expected to be in prelude.
        # TODO(cjhopman): Figure out something better here.
        if rule_spec.examples:
            doc += "\n{}Examples:\n{}".format(" " * 8, rule_spec.examples)
        if rule_spec.further:
            doc += "\n{}Additional notes:\n{}".format(" " * 8, rule_spec.further)

        extra_args["doc"] = doc

    impl = rule_spec.impl
    extra_impl = getattr(extra_implemented_rules, name, None)
    if extra_impl:
        if impl:
            fail("{} had an impl in the declaration and in the extra_implemented_rules overrides".format(name))
        impl = extra_impl
    if not impl:
        impl = _unimplemented_impl(name)
    if impl_override != None:
        impl = impl_override
    if rule_spec.uses_plugins != None:
        extra_args["uses_plugins"] = rule_spec.uses_plugins
    if rule_spec.supports_incoming_transition != None:
        extra_args["supports_incoming_transition"] = rule_spec.supports_incoming_transition

    extra_args.setdefault("is_configuration_rule", name in _config_implemented_rules)
    extra_args.setdefault("is_toolchain_rule", name in toolchain_rule_names)
    return rule(
        impl = impl,
        attrs = attributes,
        **extra_args
    )

def _flatten_decls():
    decls = {}
    for decl_set in rule_decl_records:
        for rule in dir(decl_set):
            decls[rule] = getattr(decl_set, rule)
    return decls

def _update_rules(rules: dict[str, typing.Any], extra_attributes: typing.Any):
    for k in dir(extra_attributes):
        v = getattr(extra_attributes, k)
        if k in rules:
            d = dict(rules[k].attrs)
            d.update(v)
            rules[k] = prelude_rule(
                name = rules[k].name,
                impl = rules[k].impl,
                attrs = d,
                docs = rules[k].docs,
                examples = rules[k].examples,
                further = rules[k].further,
                uses_plugins = rules[k].uses_plugins,
                supports_incoming_transition = rules[k].supports_incoming_transition,
            )
        else:
            rules[k] = prelude_rule(
                name = k,
                impl = None,
                attrs = v,
                docs = None,
                examples = None,
                further = None,
                uses_plugins = None,
                supports_incoming_transition = None,
            )

_declared_rules = _flatten_decls()
_update_rules(_declared_rules, extra_attributes)

rules = {rule.name: _mk_rule(rule) for rule in _declared_rules.values()}

# The rules are accessed by doing module.name, so we have to put them on the correct module.
load_symbols(rules)

# TODO(akrieger): Remove this and instead refactor to allow impl bzl files to export attrs.
def clone_rule(rule: str, extra_attrs: dict[str, typing.Any] = dict(), impl_override = None, **kwargs):
    if not rule in _declared_rules:
        fail("Tried clone rule {} which does not exist".format(rule))
    return _mk_rule(_declared_rules[rule], extra_attrs, impl_override, **kwargs)