Consider OS version when matching artifacts to platforms

We currently largely ignore OS version, and for most platforms that
doesn't really matter. But binaries built for a particular FreeBSD
version are forward- but not backward-compatible with other FreeBSD
versions, and that isn't accounted for when choosing artifacts. That
means that whenever the FreeBSD version used in the RootFS is bumped,
entries in Artifacts.toml corresponding to older versions need to be
manually deleted so they don't get chosen instead.

More care is needed here than I had anticipated, as `platforms_match`
has documented but unfortunate behavior when both arguments have
`compare_version_cap` set for their `os_version` comparison strategies.
The function assumes that this case occurs only when both arguments are
host platforms, and it compares their versions using `==`. That strategy
is set explicitly for `CompilerShard` targets with a comment about
treating the OS version as a bound, except it doesn't act as a bound as
such if the comparator is e.g. `HostPlatform()`.

Author: ararslan

src/Platforms.jl

@@ -19,28 +19,33 @@ nbits(::AnyPlatform) = nbits(default_host_platform)
 proc_family(::AnyPlatform) = "any"
 Base.show(io::IO, ::AnyPlatform) = print(io, "AnyPlatform")
 
+function _agnostic(p::Platform, keeps)
+    filtered_tags = (Symbol(k) => convert(String, v) for (k, v) in tags(p) if k ∈ keeps)
+    return Platform(arch(p)::String, os(p)::String; filtered_tags...)
+end
+_agnostic(p::AnyPlatform, _) = p
+
 """
     abi_agnostic(p::AbstractPlatform)
 
 Strip out any tags that are not the basic annotations like `libc` and `call_abi`.
 """
-function abi_agnostic(p::Platform)
-    keeps = ("libc", "call_abi", "os_version")
-    filtered_tags = Dict{Symbol,String}(Symbol(k) => v for (k, v) in tags(p) if k ∈ keeps)
-    return Platform(arch(p)::String, os(p)::String; filtered_tags...)
-end
-abi_agnostic(p::AnyPlatform) = p
+abi_agnostic(p::AbstractPlatform) = _agnostic(p, ("libc", "call_abi", "os_version"))
 
 """
-    abi_agnostic(p::AbstractPlatform)
+    libabi_agnostic(p::AbstractPlatform)
 
 Like `abi_agnostic`, but keep the sanitizer ABI tags.
 """
-function libabi_agnostic(p::Platform)
-    keeps = ("libc", "call_abi", "os_version", "sanitize")
-    filtered_tags = Dict{Symbol,String}(Symbol(k) => v for (k, v) in tags(p) if k ∈ keeps)
-    return Platform(arch(p)::String, os(p)::String; filtered_tags...)
-end
+libabi_agnostic(p::AbstractPlatform) = _agnostic(p, ("libc", "call_abi", "os_version", "sanitize"))
+
+"""
+    os_version_agnostic(p::AbstractPlatform)
+
+Strip out an `os_version` tag if it exists.
+"""
+os_version_agnostic(p::AbstractPlatform) =
+    _agnostic(p, filter(!in(("arch", "os", "os_version")), keys(tags(p))))
 
 platforms_match_with_sanitize(a::AbstractPlatform, b::AbstractPlatform) =
     platforms_match(a, b) && sanitize(a) == sanitize(b)

src/Rootfs.jl

@@ -59,6 +59,28 @@ function Base.:(==)(a::CompilerShard, b::CompilerShard)
            a.archive_type == b.archive_type
 end
 
+# For a `CompilerShard` to match a `Platform`, the shard's target with OS version stripped
+# must match, and the OS version if present must be less than or equal to the platform's.
+# This is effectively `platforms_match` with a `compare_version_cap` comparison strategy for
+# OS version, except it works "correctly" (IMO) when both arguments have that strategy set.
+# It also ignores any strategy that's set.
+function Base.BinaryPlatforms.platforms_match(cs::CompilerShard, p::AbstractPlatform)
+    if cs.target === nothing
+        return platforms_match(cs.host, p)
+    elseif !platforms_match(os_version_agnostic(cs.target), os_version_agnostic(p))
+        return false
+    else
+        sv = os_version(cs.target)
+        pv = os_version(p)
+        return sv === nothing || pv === nothing || pv >= sv
+    end
+end
+
+Base.BinaryPlatforms.platforms_match(p::AbstractPlatform, cs::CompilerShard) = platforms_match(cs, p)
+
+Base.BinaryPlatforms.platforms_match(a::CompilerShard, b::CompilerShard) =
+    platforms_match(something(a.target, a.host), something(b.target, b.host))
+
 """
     artifact_name(cs::CompilerShard)
 
@@ -606,7 +628,7 @@ function choose_shards(p::AbstractPlatform;
 
         for cs in all_compiler_shards()
             if cs.name == name && cs.version == version &&
-               (target === nothing || platforms_match(cs.target, target)) &&
+               (target === nothing || platforms_match(cs, target)) &&
                cs.archive_type == archive_type
                 return cs
             end
@@ -711,7 +733,7 @@ function choose_shards(p::AbstractPlatform;
     else
         function find_latest_version(name)
             versions = [cs.version for cs in all_compiler_shards()
-                if cs.name == name && cs.archive_type == archive_type && platforms_match(something(cs.target, p), p)
+                if cs.name == name && cs.archive_type == archive_type && platforms_match(cs, p)
             ]
             isempty(versions) && error("No latest shard found for $name")
             return maximum(versions)
@@ -770,8 +792,8 @@ function supported_platforms(;exclude::Union{Vector{<:Platform},Function}=Return
         # BSDs
         Platform("x86_64", "macos"),
         Platform("aarch64", "macos"),
-        Platform("x86_64", "freebsd"),
-        Platform("aarch64", "freebsd"),
+        Platform("x86_64", "freebsd"; os_version="13.2"),
+        Platform("aarch64", "freebsd"; os_version="13.2"),
 
         # Windows
         Platform("i686", "windows"),