feat: add support for Swift old-style packages to swift_package

deps.bzl

@@ -55,9 +55,9 @@ def swift_bazel_dependencies():
     maybe(
         http_archive,
         name = "cgrindel_bazel_starlib",
-        sha256 = "42a496dddbc089c68cd72b1f20dfe6acf474c53043dafe230ec887f617c0c252",
-        strip_prefix = "bazel-starlib-0.9.0",
+        sha256 = "99132d1074717e3952ebe57e9bddcd76e735bc83336093d8dc6a0820e6819998",
+        strip_prefix = "bazel-starlib-0.10.0",
         urls = [
-            "http://github.com/cgrindel/bazel-starlib/archive/v0.9.0.tar.gz",
+            "http://github.com/cgrindel/bazel-starlib/archive/v0.10.0.tar.gz",
         ],
     )

gazelle/internal/swift/repo_name.go

@@ -8,6 +8,9 @@ import (
 	"github.com/cgrindel/swift_bazel/gazelle/internal/spreso"
 )
 
+// The logic in RepoNameFromURL must stay in-sync with bazel_repo_names.from_url in
+// swiftpkg/internal/bazel_repo_names.bzl.
+
 func RepoNameFromURL(url string) (string, error) {
 	if url == "" {
 		return "", fmt.Errorf("URL cannot be empty string")

swiftpkg/internal/BUILD.bazel

@@ -6,7 +6,7 @@ bzl_library(
     srcs = ["swift_package.bzl"],
     visibility = ["//swiftpkg:__subpackages__"],
     deps = [
-        ":package_infos",
+        ":pkginfos",
         ":spm_versions",
         "@bazel_skylib//lib:dicts",
         "@bazel_skylib//lib:versions",
@@ -16,8 +16,8 @@ bzl_library(
 )
 
 bzl_library(
-    name = "package_infos",
-    srcs = ["package_infos.bzl"],
+    name = "pkginfos",
+    srcs = ["pkginfos.bzl"],
     visibility = ["//swiftpkg:__subpackages__"],
     deps = [":repository_utils"],
 )
@@ -49,8 +49,83 @@ bzl_library(
     deps = ["@bazel_skylib//lib:paths"],
 )
 
+bzl_library(
+    name = "build_decls",
+    srcs = ["build_decls.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+    deps = [":starlark_codegen"],
+)
+
+bzl_library(
+    name = "pkginfo_targets",
+    srcs = ["pkginfo_targets.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+    deps = ["@bazel_skylib//lib:paths"],
+)
+
+bzl_library(
+    name = "pkginfo_target_deps",
+    srcs = ["pkginfo_target_deps.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+    deps = ["@cgrindel_bazel_starlib//bzllib:defs"],
+)
+
+bzl_library(
+    name = "load_statements",
+    srcs = ["load_statements.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+    deps = [
+        ":starlark_codegen",
+        "@bazel_skylib//lib:sets",
+    ],
+)
+
+bzl_library(
+    name = "swiftpkg_build_files",
+    srcs = ["swiftpkg_build_files.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+    deps = [
+        ":pkginfo_targets",
+        ":pkginfos",
+    ],
+)
+
+bzl_library(
+    name = "build_files",
+    srcs = ["build_files.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+    deps = [
+        ":build_decls",
+        ":load_statements",
+    ],
+)
+
+bzl_library(
+    name = "bazel_repo_names",
+    srcs = ["bazel_repo_names.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+)
+
+bzl_library(
+    name = "pkginfo_ext_deps",
+    srcs = ["pkginfo_ext_deps.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+)
+
 bzl_library(
     name = "repository_files",
     srcs = ["repository_files.bzl"],
     visibility = ["//swiftpkg:__subpackages__"],
 )
+
+bzl_library(
+    name = "starlark_codegen",
+    srcs = ["starlark_codegen.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+)
+
+bzl_library(
+    name = "validations",
+    srcs = ["validations.bzl"],
+    visibility = ["//swiftpkg:__subpackages__"],
+)

swiftpkg/internal/bazel_repo_names.bzl

@@ -0,0 +1,23 @@
+"""Module for creating Bazel repository names."""
+
+# The logic in from_url must stay in-sync with the RepoNameFromURL logic in
+# gazelle/internal/swift/repo_name.go.
+def _from_url(url):
+    if url.startswith("https://"):
+        host_and_path = url.removeprefix("https://")
+    elif url.startswith("http://"):
+        host_and_path = url.removeprefix("http://")
+    else:
+        fail("Only https:// and http:// URLs are supported. url:", url)
+    host_and_path = host_and_path.removesuffix(".git")
+    host_sep_idx = host_and_path.find("/")
+    if host_sep_idx < 0:
+        fail("Invalid URL: host separator was not found. url:", url)
+    elif host_sep_idx == 0:
+        fail("Invalid URL: host not specified. url:", url)
+    path = host_and_path[host_sep_idx + 1:]
+    return path.replace("/", "_").replace("-", "_")
+
+bazel_repo_names = struct(
+    from_url = _from_url,
+)

swiftpkg/internal/build_decls.bzl

@@ -0,0 +1,80 @@
+"""API for creating and managing build file declarations"""
+
+load("@bazel_skylib//lib:sets.bzl", "sets")
+load(":starlark_codegen.bzl", scg = "starlark_codegen")
+
+def _new(kind, name, attrs = {}, comments = []):
+    return struct(
+        kind = kind,
+        name = name,
+        attrs = attrs,
+        comments = comments,
+        to_starlark_parts = _to_starlark_parts,
+    )
+
+def _to_starlark_parts(decl, indent):
+    parts = []
+    for c in decl.comments:
+        parts.append(scg.indent(indent, "{}\n".format(c)))
+    parts.append(scg.indent(indent, "{}(\n".format(decl.kind)))
+    parts.extend(scg.attr("name", decl.name, indent + 1))
+
+    # Sort the keys to ensure that we have a consistent output. It would be
+    # ideal to output them in a manner that matches Buildifier output rules.
+    keys = sorted(decl.attrs.keys())
+    for key in keys:
+        val = decl.attrs[key]
+        parts.extend(scg.attr(key, val, indent + 1))
+    parts.append(scg.indent(indent, ")"))
+
+    return parts
+
+def _uniq(decls):
+    """Sort and check for duplicate declarations.
+
+    Args:
+        decls: A `list` of build declaration `struct` values as returned by
+            `build_decls.new`.
+
+    Returns:
+        A `list` of build declarations sorted by type-name.
+    """
+    index_by_type_name = {}
+    for decl in decls:
+        key = "{kind}_{name}".format(
+            kind = decl.kind,
+            name = decl.name,
+        )
+        existing_values = index_by_type_name.get(key, default = [])
+        existing_values.append(decl)
+        index_by_type_name[key] = existing_values
+
+    # Collect in type-name order
+    results = []
+    for type_name in sorted(index_by_type_name.keys()):
+        existing_values = index_by_type_name[type_name]
+        results.extend(existing_values)
+
+    # Check for any duplicate decl names
+    names = sets.make()
+    for decl in results:
+        name = decl.name
+        if sets.contains(names, name):
+            fail("A duplicate decl name was found. name: {}".format(name))
+        sets.insert(names, name)
+
+    return results
+
+def _get(decls, name, fail_if_not_found = True):
+    for decl in decls:
+        if decl.name == name:
+            return decl
+    if fail_if_not_found:
+        fail("Failed to find build declaration. name:", name)
+    return None
+
+build_decls = struct(
+    new = _new,
+    uniq = _uniq,
+    get = _get,
+)

swiftpkg/internal/build_files.bzl

@@ -0,0 +1,58 @@
+"""Module for defining and generating Bazel build files."""
+
+load("//swiftpkg/internal:build_decls.bzl", "build_decls")
+load("//swiftpkg/internal:load_statements.bzl", "load_statements")
+
+def _new(load_stmts = [], decls = []):
+    """Create a `struct` that represents the parts of a Bazel build file.
+
+    Args:
+        load_stmts: A `list` of load statement `struct` values as returned
+            by `load_statements.new`.
+        decls: A `list` of declaration `struct` values as returned by
+            `build_decls.new`.
+
+    Returns:
+        A `struct` representing parts of a Bazel  build file.
+    """
+    if len(load_stmts) == 0 and len(decls) == 0:
+        fail("""\
+Attempted to create a build file with no load statements or declarations.\
+""")
+    return struct(
+        load_stmts = load_stmts,
+        decls = decls,
+    )
+
+def _merge(*bld_files):
+    """Merge build file `struct` values into a single value.
+
+    The load statements will be sorted and deduped. The targets will be sorted
+    by type and name.
+
+    Args:
+        *bld_files: A `sequence` of build file declaration `struct` values
+            as returned by `build_files.new`.
+
+    Returns:
+        A merged build file declaration `struct`.
+    """
+    if len(bld_files) == 0:
+        fail("Attempted to merge build files, but none were provided.")
+
+    load_stmts = []
+    decls = []
+    for bf in bld_files:
+        load_stmts.extend(bf.load_stmts)
+        decls.extend(bf.decls)
+    load_stmts = load_statements.uniq(load_stmts)
+    decls = build_decls.uniq(decls)
+    return _new(
+        load_stmts = load_stmts,
+        decls = decls,
+    )
+
+build_files = struct(
+    new = _new,
+    merge = _merge,
+)

swiftpkg/internal/load_statements.bzl

@@ -0,0 +1,81 @@
+"""Module for creating and managing Starlark load statements."""
+
+load("@bazel_skylib//lib:sets.bzl", "sets")
+load(":starlark_codegen.bzl", scg = "starlark_codegen")
+
+def _new(location, *symbols):
+    """Create a load statement `struct`.
+
+    The list of symbols will be sorted and uniquified.
+
+    Args:
+        location: A `string` representing the location of a Starlark file.
+        *symbols: A `sequence` of symbols to be loaded from the location.
+
+    Returns:
+        A `struct` that includes the location and the cleaned up symbols.
+    """
+    if len(symbols) < 1:
+        fail("""\
+Expected at least one symbol to be specified. location: {location}\
+""".format(location = location))
+
+    # Get a unique set
+    symbols_set = sets.make(symbols)
+    new_symbols = sorted(sets.to_list(symbols_set))
+    return struct(
+        location = location,
+        symbols = new_symbols,
+        to_starlark_parts = _to_starlark_parts,
+    )
+
+def _to_starlark_parts(load_stmt, indent):
+    parts = [
+        scg.indent(indent),
+        "load(",
+        scg.normalize(load_stmt.location),
+    ]
+
+    # The symbols should already be sorted and deduped.
+    for symbol in load_stmt.symbols:
+        parts.extend([", ", scg.normalize(symbol)])
+    parts.append(")")
+    return parts
+
+def _index(load_stmts):
+    index_by_location = {}
+    for load_stmt in load_stmts:
+        location = load_stmt.location
+        existing_values = index_by_location.get(location, default = [])
+        existing_values.append(load_stmt)
+        index_by_location[location] = existing_values
+    return index_by_location
+
+def _uniq(load_stmts):
+    """Sort and dedupe load statements.
+
+    Args:
+        load_stmts: A `list` of load statements as created by
+            `load_statments.new`.
+
+    Returns:
+        A `list` of load statements sorted and deduplicated.
+    """
+    index_by_location = _index(load_stmts)
+
+    # Collect results in location-sorted order
+    results = []
+    for location in sorted(index_by_location.keys()):
+        existing_values = index_by_location[location]
+        symbols = []
+        for load_stmt in existing_values:
+            symbols.extend(load_stmt.symbols)
+        new_load_stmt = _new(location, *symbols)
+        results.append(new_load_stmt)
+
+    return results
+
+load_statements = struct(
+    new = _new,
+    uniq = _uniq,
+)

swiftpkg/internal/pkginfo_ext_deps.bzl

@@ -0,0 +1,13 @@
+"""Module for generating data from external dependencies created by `pkginfos`."""
+
+def _find_by_identity(ext_deps, identity, fail_if_not_found = True):
+    for ext_dep in ext_deps:
+        if ext_dep.identity == identity:
+            return ext_dep
+    if fail_if_not_found:
+        fail("Failed to find external dependency with identity", identity)
+    return None
+
+pkginfo_ext_deps = struct(
+    find_by_identity = _find_by_identity,
+)