ci: dist-apple's iOS row builds, packs and runs for real on macos-15

tests/ios-app-consumer, until now checked only at the plan level (no
runner in this workflow but macos-15 has an Apple SDK), gains a real
target row: `[target.aarch64-ios-sim] runner = ["simctl-run"]`, backed
by `xim:apple-simulator-tools` 0.2.0 (published today; its `.app`-operand
branch installs and launches a bundle rather than spawning a bare
executable) and `[build] ios_deployment_target = "17.0"`. The fixture's
program now prints `1-2-3`, matching the ecosystem's other device rows.

The new `rules-cross-platform` step mirrors mcpp's own `ci-macos-ios.yml`:
gated on `xcrun --sdk iphonesimulator --show-sdk-path` succeeding, and
skipped rather than failed when the SDK is absent from the runner image.
It builds and packs `--target aarch64-ios-sim --format app`, asserts the
bundle is flat (no Contents/), that Info.plist's MinimumOSVersion and
CFBundleSupportedPlatforms carry the fixture's own declared values, and
runs it with `mcpp run --target aarch64-ios-sim --format app`, asserting
exit 0 and the `1-2-3` line. The existing plan-level Linux step is
unchanged and still passes against the same fixture.

Author: Sunrisepeak

.github/workflows/ci.yml

@@ -1715,6 +1715,88 @@ jobs:
           plutil -lint "$app/Contents/Info.plist"
           echo "ok: one bundle, a valid plist, and it launches"
 
+      # THE iOS ROW, FOR REAL (#622 B1's other half). `tests/ios-app-consumer`
+      # is the same fixture the Linux `consumers` job checks at the plan
+      # level (see that fixture's own header); here it is built, packed and
+      # run against the real target, because this runner -- unlike every
+      # other host this workflow uses -- carries the Xcode SDKs and a
+      # bootable simulator that make `--target aarch64-ios-sim` reachable at
+      # all.
+      #
+      # GATED ON THE SAME PRECONDITION mcpp's OWN iOS LANE GATES ON
+      # (mcpp's `ci-macos-ios.yml`, `ios-host-surface`): the iPhoneSimulator
+      # SDK ships inside Xcode as a separate component, not the Command Line
+      # Tools alone, so its absence is a fact about the runner image and not
+      # a regression in this collection. Skipped rather than failed, and
+      # skipped before anything is provisioned -- the same order `dist-apple`
+      # itself refuses in, and the reason `docs/20-toolchains.md` (mcpp)
+      # gives: "a machine without Xcode should not download a compiler before
+      # being told the compiler is not what is missing."
+      - name: dist-apple's iOS row produces a bundle the simulator launches
+        if: runner.os == 'macOS'
+        working-directory: tests/ios-app-consumer
+        shell: bash
+        run: |
+          set -uo pipefail
+          if ! xcrun --sdk iphonesimulator --show-sdk-path >/dev/null 2>&1; then
+            echo "SKIP: no iphonesimulator SDK on this runner"
+            echo "      (xcrun --sdk iphonesimulator --show-sdk-path failed) -- see"
+            echo "      mcpp's docs/20-toolchains.md, 'The Apple SDKs Are Located, Not Installed'"
+            exit 0
+          fi
+          set -e
+
+          rm -rf target
+          "$MCPP" build --target aarch64-ios-sim
+          if find target -name '*.app' | grep -q .; then
+            echo "FAIL: a plain build produced a bundle"; exit 1
+          fi
+          "$MCPP" pack --target aarch64-ios-sim --format app | tee pack.log
+          app=$(find target -name '*.app' -type d | head -1)
+          test -n "$app" || { cat pack.log; echo "FAIL: no .app bundle"; exit 1; }
+
+          # FLAT, NOT Contents/-SHAPED -- the one difference from the macOS
+          # bundle above, and the whole reason iOS needed its own branch in
+          # `dist/apple.cppm`.
+          if [ -d "$app/Contents" ]; then
+            echo "FAIL: the simulator bundle carries Contents/ -- not a flat iOS layout"
+            exit 1
+          fi
+          plist="$app/Info.plist"
+          test -f "$plist" || { echo "FAIL: no Info.plist at the bundle root"; exit 1; }
+          plutil -lint "$plist"
+
+          # `MinimumOSVersion` MUST CARRY THIS FIXTURE'S OWN `[build]
+          # ios_deployment_target`, not a default the engine invented.
+          minos=$(/usr/libexec/PlistBuddy -c 'Print :MinimumOSVersion' "$plist")
+          [ "$minos" = "17.0" ] || {
+            echo "FAIL: MinimumOSVersion is '$minos', expected 17.0 (this fixture's ios_deployment_target)"
+            exit 1; }
+          plat=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleSupportedPlatforms:0' "$plist")
+          [ "$plat" = "iPhoneSimulator" ] || {
+            echo "FAIL: CFBundleSupportedPlatforms is '$plat', expected iPhoneSimulator"
+            exit 1; }
+
+          exe=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$plist")
+          test -x "$app/$exe" \
+            || { echo "FAIL: $app/$exe is missing or not executable"; ls -la "$app"; exit 1; }
+
+          # THE SIMULATOR, THROUGH THE DECLARED RUNNER. `mcpp run --format
+          # app` hands the packaged bundle to `runner = ["simctl-run"]`
+          # (`xim:apple-simulator-tools` 0.2.0, declared on this target row),
+          # which installs and launches it rather than spawning a bare
+          # executable -- the branch that package's 0.2.0 header records as
+          # needed for an installed bundle. This is the same path a
+          # consumer's own `mcpp run --target aarch64-ios-sim --format app`
+          # takes, not a bare `simctl spawn` this step could call directly.
+          out=$("$MCPP" run --target aarch64-ios-sim --format app 2>&1) && rc=0 || rc=$?
+          printf '%s\n' "$out" | tail -20
+          [ "$rc" -eq 0 ] \
+            || { echo "FAIL: mcpp run --target aarch64-ios-sim --format app exited $rc"; exit 1; }
+          grep -qx '1-2-3' <<<"$out" \
+            || { echo "FAIL: the program's output line '1-2-3' is absent"; exit 1; }
+          echo "ok: a flat iOS Simulator bundle, MinimumOSVersion 17.0, and the simulator ran it"
+
       - name: the rule declared its own compiler
         working-directory: tests/spirv-consumer
         run: |

tests/ios-app-consumer/mcpp.toml

@@ -1,7 +1,7 @@
-# Fixture: the iOS row of dist-apple, checked at the PLAN level.
+# Fixture: the iOS row of dist-apple.
 #
-# NO HOST HERE CAN REACH A REAL MEASUREMENT. `--target aarch64-ios-sim`
-# refuses before `build.mcpp` ever runs, on every host without Xcode:
+# ONE FIXTURE, TWO CI LANES. On every host without Xcode, `--target
+# aarch64-ios-sim` refuses before `build.mcpp` ever runs:
 #
 #   error: target aarch64-ios-sim needs the iphonesimulator SDK, which this
 #   machine does not provide.
@@ -10,10 +10,10 @@
 # measurement... only answerable on the platform the member serves") does not
 # even get this member as far as a plan-level assertion on a non-Apple CI
 # runner: there is no `--target` that reaches `plan_for` with `MCPP_TARGET_OS`
-# actually set to `ios` unless the runner IS a Mac with Xcode installed.
-#
-# This package is instead built for the HOST (an ordinary `mcpp build`, no
-# `--target`), which compiles `build.mcpp` into an ordinary ELF binary at
+# actually set to `ios` unless the runner IS a Mac with Xcode installed. On
+# such a runner (`ubuntu-24.04`, the `consumers` job) this package is instead
+# built for the HOST (an ordinary `mcpp build`, no `--target`), which compiles
+# `build.mcpp` into an ordinary ELF binary at
 # `target/.build-mcpp/build.mcpp.bin` and, on this row, does not even reach
 # `plan_for` at pack time (`generate()`'s call to it runs during the plain
 # build too, and returns `applies == false` because `pack_format()` is
@@ -25,10 +25,17 @@
 # `std::getenv` and nothing else (`hostprogram.cppm`), so this exercises the
 # exact same code `plan_for` runs under a real iOS build -- everything past
 # "which environment variables does this process see" is unchanged.
+#
+# On the `macos-15` runner (the `rules-cross-platform` job) the SAME fixture
+# is instead built, packed and run for real, through `--target
+# aarch64-ios-sim`: see that job's "dist-apple's iOS row produces a bundle the
+# simulator launches" step. `[target.aarch64-ios-sim]` below is what that step
+# exercises and the plan-level lane never reaches, because it never sets
+# `MCPP_TARGET` at all.
 [package]
 name        = "ios-app-consumer"
 version     = "0.3.0"
-description = "Fixture: the iOS row of dist-apple, checked at the plan level"
+description = "Fixture: the iOS row of dist-apple, checked at the plan level and, on macOS, for real"
 license     = "Apache-2.0"
 authors     = ["mcpp-community"]
 
@@ -40,6 +47,29 @@ import_std = true
 [build-dependencies.mcpp]
 plugins = { path = "../..", features = ["dist-apple"], host-module = true }
 
+# THE SAME KEY THE PLAN-LEVEL LANE SETS BY HAND (`MCPP_TARGET_MIN_PLATFORM_
+# VERSION` in `check-ios-plan.sh`), stated here for the real build the macOS
+# lane runs. `mcpp::min_platform_version()` reads this for the effective
+# triple; `dist-apple` copies it into `Info.plist`'s `MinimumOSVersion`
+# unchanged, which is the value the macOS lane compares against.
+[build]
+ios_deployment_target = "17.0"
+
 [targets.ios-app-consumer]
 kind = "bin"
 main = "src/main.cpp"
+
+# THE SIMULATOR ROW ONLY -- the device row (`aarch64-ios`) keeps `runner`
+# unset, as `examples/13-platform-targets/mcpp.toml` does: an artifact cannot
+# be run off an iOS device without a signature the developer owns.
+[target.aarch64-ios-sim]
+runner = ["simctl-run"]
+
+# Declared beside the row that uses it, as every other cross-target fixture in
+# this ecosystem declares its runner's payload. `xim:apple-simulator-tools`
+# 0.2.0 is the release whose `simctl-run` installs and launches a `.app` when
+# the operand is a bundle (see this repository's README and CHANGELOG) --
+# `mcpp pack --format app` is what this fixture's macOS lane runs, so the
+# 0.1.0 bare-executable branch is not enough.
+[target.aarch64-ios-sim.xlings.workspace]
+"xim:apple-simulator-tools" = "0.2.0"

tests/ios-app-consumer/src/main.cpp

@@ -1,2 +1,2 @@
 #include <cstdio>
-int main() { std::puts("ios-app-consumer ok"); return 0; }
+int main() { std::puts("1-2-3"); return 0; }