rules_lang

bazel_dep(name = "rules_lang", version = "0.5.0")

from docs/aion.md

Polyglot.Aion — spec → multi-language source emit pipeline (public API).

Architecture (upgraded from the initial macro to a real provider / aspect / toolchain stack — see INTERNAL.md):

• aion_spec rule — wraps a Polyglot.Core.Lir.Module-producing Lean module in an AionSpecInfo provider.
• aion_emit_toolchain rule — defines a per-target-language projection (import_module, render_fn, src_files) as an AionEmitToolchainInfo provider. Repos register their own toolchains; no rules_lang edits needed for a new language.
• aion_emit macro — composes the internal _aion_emit_main_gen rule (which reads both providers and writes the lean Main) with lean_emit (which compiles).
• aion_spec_aspect — propagates AionSpecInfo through dep graphs for additional consumers (doc-gen, fixture-validation, metrics).

Default usage (point at a registered toolchain by label):

load("@rules_lang//rules:aion.bzl", "aion_spec", "aion_emit")

aion_spec(
    name   = "logger_spec",
    srcs   = [
        "LoggerSpec.lean",                    # builds loggerModule
        "LoggerEmit/LoggerEmit.lean",         # catalog
    ],
    module = "Aion.V0.Logger.LoggerSpec",
    symbol = "loggerModule",
)

aion_emit(
    name   = "logger_ts",
    spec   = ":logger_spec",
    target = "@rules_lang//polyglot:typescript_aion_emit_toolchain",
    out    = "logger.ts",
    deps   = LAKE_PACKAGES,
)

Shortcut: target accepts the bare language name "typescript" / "sql" / "python" / "rust" and resolves to the corresponding @rules_lang//polyglot:<lang>_aion_emit_toolchain label. Custom toolchains use an explicit label.

Adding a new target language (in any repo):

aion_emit_toolchain(
    name = "haskell_aion_emit_toolchain",
    language = "haskell",
    import_module = "Polyglot.Haskell",
    render_fn = "Polyglot.Haskell.OfLir.render",
    src_files = [
      "@polyglot_ast//:Polyglot/Core/Lir.lean",
      "@polyglot_ast//:Polyglot/Core.lean",
      "@polyglot_ast//:Polyglot/Haskell/OfLir.lean",
    ],
)

Then use target = ":haskell_aion_emit_toolchain" (or its full label from another package).

aion_emit_toolchain

load("@rules_lang//polyglot:aion.bzl", "aion_emit_toolchain")

aion_emit_toolchain(name, atlas, import_module, language, render_fn)

Defines a per-target-language projection for aion_emit. Each language registers one of these; aion_emit(target = ":<tc>", ...) consumes it via the provider. Adding a new target language is a new aion_emit_toolchain declaration — no rules_lang edits needed.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
atlas	The imported polyglot atlas (a lean_imported_library over the prebuilt olean): provides Core.Lir + the language’s Render/OfLir as compiled oleans, no source recompile. Forwarded as LeanInfo so aion_emit’s lean_emit deps on it.	Label	required
import_module	Lean module the generated Main imports to reach the lowering (e.g. Polyglot.Typescript).	String	required
language	Human-readable language identifier (e.g. typescript, sql).	String	required
render_fn	Fully-qualified Lean function name Lir.Module → String (e.g. Polyglot.Typescript.OfLir.render).	String	required

aion_spec

load("@rules_lang//polyglot:aion.bzl", "aion_spec")

aion_spec(name, srcs, module, symbol)

Wraps a set of Lean files producing a Polyglot.Core.Lir.Module into an AionSpecInfo-bearing target. Consumers like aion_emit, doc-gen, fixture-validation, etc. read the provider.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
srcs	Lean files. Must include the module defining the spec_symbol Lir.Module value and any catalog modules it imports.	List of labels	required
module	Fully-qualified Lean module path housing the Lir.Module value (e.g. Aion.V0.Logger.LoggerSpec).	String	required
symbol	Name of the Lir.Module value within that module (e.g. loggerModule).	String	required

AionEmitToolchainInfo

load("@rules_lang//polyglot:aion.bzl", "AionEmitToolchainInfo")

AionEmitToolchainInfo(import_module, render_fn, language)

Toolchain config for projecting a Lir.Module to one specific target language.

FIELDS

Name	Description
import_module	Lean module the generated Main imports to reach the lowering (e.g. Polyglot.Typescript).
render_fn	fully-qualified Lean function name Lir.Module → String (e.g. Polyglot.Typescript.OfLir.render).
language	human-readable language identifier (e.g. typescript, sql) — surfaced in progress messages.

AionSpecInfo

load("@rules_lang//polyglot:aion.bzl", "AionSpecInfo")

AionSpecInfo(srcs, module, symbol)

Information about an aion_spec target — a Lean module producing a Polyglot.Core.Lir.Module.

FIELDS

Name	Description
srcs	depset of .lean files (the spec module + any catalog modules it imports).
module	fully-qualified Lean module path housing the Lir.Module value (e.g. Aion.V0.Logger.LoggerSpec).
symbol	name of the Lir.Module value within that module (e.g. loggerModule).

aion_emit

load("@rules_lang//polyglot:aion.bzl", "aion_emit")

aion_emit(name, spec, target, out, deps, visibility)

Project a Lir-spec target to source via the toolchain’s lowering.

PARAMETERS

Name	Description	Default Value
name	target name. The lean compilation runs as <name> (a lean_emit underneath); the Main-generation step is <name>_main_gen (private intermediate).	none
spec	label of an aion_spec target (provides AionSpecInfo).	none
target	either a bare language name ("typescript", "sql", "python", "rust") — resolved to the registered toolchain at @rules_lang//polyglot:<lang>_aion_emit_toolchain — or an explicit label of an aion_emit_toolchain target.	none
out	emitted source filename (e.g. "logger.ts").	none
deps	lean_emit deps (typically LAKE_PACKAGES).	None
visibility	forwarded to the emitted lean_emit target.	None

aion_spec_aspect

load("@rules_lang//polyglot:aion.bzl", "aion_spec_aspect")

aion_spec_aspect()

Walks a target’s deps / spec / specs attrs collecting AionSpecInfo records. Adds an AionSpecCollection provider with a depset of all specs reachable through that subgraph.

Apply to rule attrs via attr.label(aspects = [aion_spec_aspect]) in a consumer rule’s definition. Then inside that rule’s impl, read ctx.attr.<edge>[AionSpecCollection].specs to iterate the specs.

ASPECT ATTRIBUTES

Name	Type
deps	String
spec	String
specs	String

ATTRIBUTES

from docs/sql.md

Polyglot.Sql — the SQL parse/projection Bazel axis.

A proto_library-shaped layering for SQL: raw sources at the top, parsed AST in the middle, projection rules (json / proto / lean / catalog) at the bottom. Each dialect (postgres, sqlite, …) plugs in via a toolchain implementing one of the per-dialect toolchain types declared in //polyglot/sql:BUILD.bazel.

sql_library                 ← raw .sql sources, dialect-tagged
    │   SqlInfo {srcs, dialect}
    ▼
sql_ast_library             ← dialect parser → canonical AST file
    │   SqlAstInfo {asts: [(sql, ast, format)], dialect}
    │
    ├──► sql_json_library   (future projection — AST as JSON)
    ├──► sql_proto_library  (future projection — AST as protobuf bytes)
    ├──► sql_lean_library   (future projection — AST decoded into Lean)
    │
    └──► sql_catalog_library
             SqlCatalogInfo {snapshot: lean/json/ttl, dialect}
             ← folds DDL stmt-by-stmt and emits a cumulative
             `Pg.Catalog.Snapshot` (or dialect-equivalent).

Aspect: sql_ast_aspect propagates over deps of any rule and attaches an AST artifact per transitively-reachable sql_library source. Useful for sweeps that want to lint every SQL in a build closure without declaring a parse rule per file.

This skeleton ships:

• SqlInfo, SqlAstInfo, SqlCatalogInfo, SqlToolchainInfo
• sql_library
• sql_ast_library (postgres dialect path wired; sqlite stub)
• sql_catalog_library (postgres path delegates to a Python tool that decodes .pgpb via protoc- generated bindings and emits a Lean Pg.Catalog.Snapshot)
• sql_ast_aspect

The json / proto / lean projection rules are placeholders pending the proto-grounded Lean codegen track (see the “future” comment in the roadmap — Pg.Ast generated from @libpg_query//:pg_query.proto).

sql_ast_library

load("@rules_lang//polyglot:sql.bzl", "sql_ast_library")

sql_ast_library(name, deps)

Parses each .sql source in deps via the dialect’s toolchain.

Output is one AST file per source (currently .pgpb for postgres). Downstream sql_*_library projection rules consume the resulting SqlAstInfo.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	sql_library targets to parse.	List of labels	required

sql_catalog_library

load("@rules_lang//polyglot:sql.bzl", "sql_catalog_library")

sql_catalog_library(name, deps, folder, module_name, output_format)

Folds a sequence of parsed DDL ASTs into a catalog snapshot.

Walks every CREATE SCHEMA / DOMAIN / TYPE / TABLE / FUNCTION across the transitive sql_ast_library closure, maintains running catalog state, and emits a single snapshot file in the requested format.

Dialect-neutral: dispatches to the folder binary, which the dialect’s ecosystem supplies (e.g. rules_postgres provides @rules_postgres//tools:pgpb_to_snapshot). For convenience, dialect-specific wrappers (pg_sql_catalog_library) pre-fill folder so consumers don’t have to.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	sql_ast_library targets whose ASTs should be folded.	List of labels	required
folder	Dialect-specific catalog-folder binary. Consumes one or more AST files (in lexicographic order by short_path) and emits a snapshot file. Invocation: —module —output [—format ] [ …] For postgres: @rules_postgres//tools:pgpb_to_snapshot.	Label	required
module_name	Lean (or analogous) module name (defaults to target name).	String	optional	""
output_format	Output projection format.	String	optional	"lean"

sql_library

load("@rules_lang//polyglot:sql.bzl", "sql_library")

sql_library(name, deps, srcs, dialect)

Declares a set of .sql source files of a single dialect.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	Other sql_library targets to roll up. Must match dialect.	List of labels	optional	[]
srcs	SQL source files contributed by this library.	List of labels	optional	[]
dialect	SQL dialect of the sources.	String	optional	"postgres"

SqlAstInfo

load("@rules_lang//polyglot:sql.bzl", "SqlAstInfo")

SqlAstInfo(asts, dialect)

Carries parsed AST files alongside their SQL sources.

Each entry of asts is a struct(sql=File, ast=File, format=string). format lets downstream projection rules pick the correct decoder (e.g. ‘libpg_query_protobuf’ vs ‘sqlite_native’).

FIELDS

Name	Description
asts	depset[struct(sql: File, ast: File, format: string)]
dialect	string

SqlCatalogInfo

load("@rules_lang//polyglot:sql.bzl", "SqlCatalogInfo")

SqlCatalogInfo(snapshot, dialect, output_format)

Carries a cumulative catalog snapshot folded over DDLs.

The snapshot File is the final emitted artifact (Lean source by default; future support for JSON/TTL via the output_format attribute). dialect matches the upstream SqlAstInfo.dialect.

FIELDS

Name	Description
snapshot	File — emitted Pg.Catalog.Snapshot artifact.
dialect	string
output_format	string — ‘lean’ | ‘json’ | ‘ttl’

SqlInfo

load("@rules_lang//polyglot:sql.bzl", "SqlInfo")

SqlInfo(srcs, dialect)

Carries raw SQL source files plus their declared dialect.

Surfaced by sql_library and propagated through deps. The dialect is what tells sql_ast_library which toolchain to resolve.

FIELDS

Name	Description
srcs	depset[File] — .sql source files (transitively).
dialect	string — ‘postgres’ | ‘sqlite’ | …

SqlToolchainInfo

load("@rules_lang//polyglot:sql.bzl", "SqlToolchainInfo")

SqlToolchainInfo(parser, parser_format, proto_descriptor, version, dialect)

The dialect-specific parser binary + format contract.

Every *_sql_toolchain rule emits this. parser is invoked as <parser> <input.sql> > <output.ast>. parser_format is what downstream projection rules use to pick the right decoder.

FIELDS

Name	Description
parser	File — executable; consumes .sql arg, emits AST on stdout.
parser_format	string — ‘libpg_query_protobuf’ | …
proto_descriptor	File or None — .proto schema (if AST is proto-shaped).
version	string — parser version (e.g. ‘17-6.2.2’).
dialect	string — matches the toolchain_type’s dialect tag.

sql_ast_aspect

load("@rules_lang//polyglot:sql.bzl", "sql_ast_aspect")

sql_ast_aspect()

Propagates over deps, attaching SqlAstInfo to every transitive sql_library. Lets downstream rules consume parsed ASTs without per-file sql_ast_library declarations.

ASPECT ATTRIBUTES

Name	Type
deps	String

ATTRIBUTES