Expressive target declarations in BUILD files

[kaos]

This idea is a bit on the wild side, but I think it may have potential..

It serves two main purposes:

a) Flexibility in field values and meta field values

b) Target-lookups from within BUILD files.

So, here's a rough straw-man sketch of this idea:

# some/BUILD

@python_sources
def some_name():
    # Function calls in the target body provides field values.
    
    # Set description and tags
    description("foo bar")
    tags("this", "and", "that")

    # Optional dependencies based on if `src/foo:bar` is tagged with `foo`
    # The `target[ADDR]` syntax requests a single target with ADDR
    if "foo" in target["src/foo:bar"].tags:
        dependencies("quux", "qorgi")

    # Append additional tags from all targets in `src/proj/lib::`
    # The `targets[SPEC]` syntax requests all targets for the `SPEC`.
    for t in targets["src/proj/lib::"]:
        # `self` allows access to the field values currently being defined in this target body.
        tags(*self.tags, *t.tags)

The idea being that this syntax would be fully compatible with the regular syntax, and only used for cases where the extra flexibility is needed.

Also, this is just sci-fi day-dreaming on my part--not something that I'm actually in need of today.

Declaring the field values as function calls, allows attaching additional information to the field values in a natural way. Also the arguments to the method itself may be used for oob pragma style information/control what-not.

@target 
def example(pragma="declaration"):
  field(value, meta=data, additional=info)

[cognifloyd]

That seems very scary and a bit too magical for me.

I could, however, see turning targets into a context manager:

with python_sources(name="some_name") as some_name:
    # Function calls in the target body provides field values.
    
    # Set description and tags
    some_name.description("foo bar")
    some_name.tags("this", "and", "that")

    # Optional dependencies based on if `src/foo:bar` is tagged with `foo`
    # The `target[ADDR]` syntax requests a single target with ADDR
    if "foo" in __target__["src/foo:bar"].tags:
        some_name.dependencies("quux", "qorgi")

    # Append additional tags from all targets in `src/proj/lib::`
    # The `targets[SPEC]` syntax requests all targets for the `SPEC`.
    for t in __targets__["src/proj/lib::"]:
        # `self` allows access to the field values currently being defined in this target body.
        some_name.tags(*self.tags, *t.tags)

That would mean that object construction would be complete when __exit__ is called on the object at the end of the context.

[kaos]

Close enough to my crazy idea; I like it :)