dist-apple: the iOS row takes the single-binary path without a staged tree, and resolves its icon directory

The floor check at the end of submit() unconditionally measured pack_stage_dir(), even when the layout step had already taken the single-binary (${mcpp.target_file:<target>}) path because pack_stage_dir() was empty -- the shape a host that cannot walk an iOS Mach-O's closure hands this member. Measuring an empty path produced 'the staged tree at  holds only 0 bytes', a warning about a tree that was never asked for. The check now runs only when p.appdir is non-empty.

options::icon named a project-relative path, but the actions that read it (ditto in the layout and icon steps) run with the build directory as their cwd, not the manifest directory -- so a relative icon directory or file validated at plan time and then failed inside the graph ('ditto: Cannot get the real path for source'). options::icon is now resolved against mcpp::manifest_dir() once, before validation, on both the iOS directory case and the macOS .icns case; a directory that still does not exist or holds no *.png is refused at plan time, naming options::icon and the resolved path.

tests/ios-app-consumer/ios-icons/AppIcon60x60@2x.png is now a real 1x1 PNG (written with Python's zlib/struct) rather than placeholder text, so the icon path is exercised for real. check-ios-plan.sh gains three assertions: a non-empty fabricated stage names ${mcpp.stage_dir} with no staged-tree warning, an empty MCPP_PACK_STAGE_DIR takes the ${mcpp.target_file:...} path with no staged-tree warning, and a manifest directory with no ios-icons/ is refused at plan time naming options::icon and the resolved path.

Author: Sunrisepeak

dist/apple.cppm

@@ -547,19 +547,47 @@ inline plan plan_for(options opt = {}) {
     const std::string executableName = stage.empty()
         ? target : bundle_executable_name(launcher);
 
+    // `options::icon` IS RESOLVED AGAINST THE MANIFEST DIRECTORY HERE, ONCE,
+    // BEFORE ANY VALIDATION OR ACTION ARGV USES IT -- ON BOTH ROWS.
+    //
+    // This program's own cwd is the manifest directory when mcpp runs it (the
+    // usual case a project author sees, and why a bare relative path like
+    // `"ios-icons"` validates below without complaint). But the ACTIONS this
+    // member declares -- the `ditto` calls in the layout and icon steps -- are
+    // graph edges ninja runs later, with the BUILD directory as their cwd, not
+    // the manifest directory. A relative `options::icon` therefore reached
+    // `ditto` as a path that does not exist from where `ditto` was standing:
+    //
+    //   ditto ios-icons .../IosAppConsumer.app
+    //   ditto: Cannot get the real path for source 'ios-icons'
+    //
+    // failing inside the graph, on a host with no way to run this member
+    // again to explain why. Resolving here, against `mcpp::manifest_dir()`,
+    // makes every later use -- the validation immediately below and the
+    // `icon.argv` this function builds further down -- see the same absolute
+    // path regardless of which directory the thing reading it is standing in.
+    // An already-absolute `options::icon` is left alone.
+    if (!opt.icon.empty()) {
+        std::filesystem::path iconPath(opt.icon);
+        if (!iconPath.is_absolute())
+            opt.icon = (std::filesystem::path(mcpp::manifest_dir()) / iconPath).string();
+    }
+
     // macOS: `options::icon` is a FILE. iOS: it is a DIRECTORY of flat PNGs
     // (see the `options::icon` comment and the header's icon paragraph) --
     // two different validations of the same field, because the two
     // platforms' icon conventions are not the same shape and this member
-    // does not invent a third field to hold the distinction.
+    // does not invent a third field to hold the distinction. Both refusals
+    // name `options::icon` and the (now-resolved) path, so a project sees
+    // exactly what this member read rather than a bare relative name it typed.
     std::vector<std::string> iosIconStems;
     if (!opt.icon.empty()) {
         if (isIos) {
             std::error_code ec;
             if (!std::filesystem::is_directory(opt.icon, ec)) {
                 std::cerr << std::format(
-                    "mcpp.dist.apple: the iOS icon {} is not a directory. "
-                    "Set `options::icon` to a directory of flat PNGs "
+                    "mcpp.dist.apple: `options::icon` ({}) is not a "
+                    "directory. Set it to a directory of flat PNGs "
                     "(one per size Apple's Home Screen and Settings need); "
                     "this member lists their stems under `CFBundleIcons` "
                     "and does not generate sizes itself.", opt.icon) << '\n';
@@ -574,13 +602,15 @@ inline plan plan_for(options opt = {}) {
             std::sort(iosIconStems.begin(), iosIconStems.end());
             if (iosIconStems.empty()) {
                 std::cerr << std::format(
-                    "mcpp.dist.apple: the icon directory {} carries no "
+                    "mcpp.dist.apple: `options::icon` ({}) carries no "
                     "*.png files.", opt.icon) << '\n';
                 p.reason = "icon directory carries no PNGs";
                 return p;
             }
         } else if (!is_file(opt.icon)) {
-            std::cerr << std::format("mcpp.dist.apple: the icon {} was not found", opt.icon) << '\n';
+            std::cerr << std::format(
+                "mcpp.dist.apple: `options::icon` ({}) was not found",
+                opt.icon) << '\n';
             p.reason = "icon not found";
             return p;
         }
@@ -763,7 +793,8 @@ inline bool submit(const plan& p) {
         a.submit();
     }
 
-    // A FLOOR ON THIS MEMBER'S OWN OUTPUT, ON THE SUCCESS PATH.
+    // A FLOOR ON THIS MEMBER'S OWN OUTPUT, ON THE SUCCESS PATH -- AND ONLY
+    // WHEN A STAGED TREE IS THE THING BEING MEASURED.
     //
     // The assembled bundle does not exist when this program runs -- ditto and
     // codesign have not been invoked yet, only declared -- so what this
@@ -774,24 +805,38 @@ inline bool submit(const plan& p) {
     // verify, or the bare-filename assumption `bundle_executable_name`
     // documents not holding for a non-default staging layout -- all of those
     // happen after this program has already exited.
-    std::error_code ec;
-    std::uintmax_t bytes = 0;
-    for (auto const& e : std::filesystem::recursive_directory_iterator(p.appdir, ec)) {
-        if (ec) break;
-        if (e.is_regular_file(ec)) bytes += std::filesystem::file_size(e.path(), ec);
-    }
-    // Loose on purpose, matching `dist/appimage.cppm`'s own bound: this
-    // exists to catch "nothing was staged", not to police a size budget.
-    // Unlike that member, nothing is written INTO the staged tree here --
-    // `Info.plist` and the icon live outside it until the layout and install
-    // steps run -- so even a low bound is already suspicious.
-    if (bytes < 4u * 1024u) {
-        static char msg[512];
-        std::snprintf(msg, sizeof msg,
-            "mcpp.dist.apple: the staged tree at %s holds only %llu bytes, "
-            "which is not a program; the .app will not launch anything",
-            p.appdir.c_str(), static_cast<unsigned long long>(bytes));
-        mcpp::warning(msg);
+    //
+    // `p.appdir` IS `pack_stage_dir()`, WHICH THE HEADER COMMENT ALREADY
+    // DOCUMENTS AS OPTIONAL. When it is empty -- the common iOS case, since
+    // the host running mcpp cannot always execute an iOS Mach-O to walk its
+    // closure -- there is no tree to measure at all: the layout step above
+    // already took the single-binary path (`${mcpp.target_file:<target>}`),
+    // and `recursive_directory_iterator` on an empty path opens nothing,
+    // leaving `bytes` at zero. Running the check anyway turned that "no tree
+    // was ever asked for" into "the staged tree at  holds only 0 bytes",
+    // naming a path that is blank because none exists -- a warning about a
+    // defect that was never present. So this floor applies only when a
+    // staged tree exists to be measured.
+    if (!p.appdir.empty()) {
+        std::error_code ec;
+        std::uintmax_t bytes = 0;
+        for (auto const& e : std::filesystem::recursive_directory_iterator(p.appdir, ec)) {
+            if (ec) break;
+            if (e.is_regular_file(ec)) bytes += std::filesystem::file_size(e.path(), ec);
+        }
+        // Loose on purpose, matching `dist/appimage.cppm`'s own bound: this
+        // exists to catch "nothing was staged", not to police a size budget.
+        // Unlike that member, nothing is written INTO the staged tree here --
+        // `Info.plist` and the icon live outside it until the layout and
+        // install steps run -- so even a low bound is already suspicious.
+        if (bytes < 4u * 1024u) {
+            static char msg[512];
+            std::snprintf(msg, sizeof msg,
+                "mcpp.dist.apple: the staged tree at %s holds only %llu bytes, "
+                "which is not a program; the .app will not launch anything",
+                p.appdir.c_str(), static_cast<unsigned long long>(bytes));
+            mcpp::warning(msg);
+        }
     }
     return true;
 }

tests/ios-app-consumer/check-ios-plan.sh

@@ -26,16 +26,29 @@ echo "ok: build.mcpp compiled to $BIN"
 
 run_row() {
     # $1=label $2=MCPP_TARGET_OS $3=MCPP_TARGET_ENV(or empty) $4=out log path
-    local label="$1" os="$2" envv="$3" log="$4"
+    # $5=stage mode: "" (default) fabricates a non-empty staged tree, exactly
+    #    as every row did before this parameter existed; "EMPTY" instead sends
+    #    MCPP_PACK_STAGE_DIR="" -- the shape a host that cannot walk an iOS
+    #    Mach-O's closure actually hands this member.
+    # $6=MCPP_MANIFEST_DIR override, empty by default (matches every row's
+    #    behaviour before this parameter existed: the fixture's own directory,
+    #    read through this script's cwd rather than through the variable).
+    local label="$1" os="$2" envv="$3" log="$4" stage_mode="${5:-}" manifest="${6:-}"
     local stage out
-    stage=$(mktemp -d) out=$(mktemp -d)
-    mkdir -p "$stage/bin"
-    head -c 5000 /dev/urandom > "$stage/bin/ios-app-consumer"
+    if [ "$stage_mode" = "EMPTY" ]; then
+        stage=""
+    else
+        stage=$(mktemp -d)
+        mkdir -p "$stage/bin"
+        head -c 5000 /dev/urandom > "$stage/bin/ios-app-consumer"
+    fi
+    out=$(mktemp -d)
     env -i PATH="$PATH" \
         MCPP_PACK_FORMAT=app \
         MCPP_TARGET_OS="$os" \
         MCPP_TARGET_ENV="$envv" \
         MCPP_PACK_STAGE_DIR="$stage" \
+        MCPP_MANIFEST_DIR="$manifest" \
         MCPP_TARGET_MIN_PLATFORM_VERSION="$([ "$os" = ios ] && echo 18.0)" \
         MCPP_PKG_NAME=ios-app-consumer \
         MCPP_PKG_VERSION=0.3.0 \
@@ -67,8 +80,39 @@ grep -q 'LSMinimumSystemVersion' "$plist" && fail "the iOS plist carries the mac
 grep -q '<key>CFBundleIcons</key>' "$plist" || fail "no CFBundleIcons key for the directory icon" "$plist"
 grep -q 'AppIcon60x60@2x</string>' "$plist" || fail "the icon list is missing a stem"  "$plist"
 grep -q 'AppIcon76x76@2x~ipad</string>' "$plist" || fail "the icon list is missing a stem" "$plist"
+# THE STAGED-TREE SIDE OF THE mcpp.stage_dir / target_file DECISION: this row
+# fabricates a non-empty MCPP_PACK_STAGE_DIR (see run_row), so the layout step
+# must name the tree, and the floor check in `submit()` must find enough
+# bytes in it to stay quiet.
+grep 'mcpp.dist.apple.layout' "$log" | grep -q '\${mcpp\.stage_dir}' \
+    || fail "the layout step did not name \${mcpp.stage_dir} for a non-empty staged tree" "$log"
+grep -q 'holds only' "$log" \
+    && fail "a non-empty staged tree still produced the 0-byte staged-tree warning" "$log"
 echo "ok: flat layout, no codesign, a named warning, and every iOS-only plist key"
 
+echo "== iOS Simulator row, an empty pack_stage_dir (#622 B2 defect 1) =="
+run_row simnostage ios sim /tmp/ios-plan-sim-nostage.log EMPTY > /dev/null
+log=/tmp/ios-plan-sim-nostage.log
+grep -q 'mcpp.dist.apple.layout' "$log" || fail "no layout step planned with an empty stage dir" "$log"
+grep 'mcpp.dist.apple.layout' "$log" | grep -q '\${mcpp\.target_file:ios-app-consumer}' \
+    || fail "the layout step did not name \${mcpp.target_file:...} with an empty stage dir" "$log"
+grep 'mcpp.dist.apple.layout' "$log" | grep -q '\${mcpp\.stage_dir}' \
+    && fail "the layout step named \${mcpp.stage_dir} even though pack_stage_dir() was empty" "$log"
+grep -q 'holds only' "$log" \
+    && fail "an empty pack_stage_dir produced the misleading 0-byte staged-tree warning" "$log"
+echo "ok: an empty pack_stage_dir takes the single-binary path, named through \${mcpp.target_file:...}, with no staged-tree warning"
+
+echo "== iOS Simulator row, a manifest directory with no ios-icons/ (#622 B2 defect 2) =="
+badmanifest=$(mktemp -d)
+run_row simbadicon ios sim /tmp/ios-plan-sim-badicon.log "" "$badmanifest" > /dev/null
+log=/tmp/ios-plan-sim-badicon.log
+grep -q 'options::icon' "$log" || fail "the missing-icon refusal did not name options::icon" "$log"
+grep -qF "$badmanifest/ios-icons" "$log" \
+    || fail "the missing-icon refusal did not resolve options::icon against MCPP_MANIFEST_DIR" "$log"
+grep -q 'mcpp.dist.apple.layout' "$log" \
+    && fail "a layout step was planned even though the icon directory was refused" "$log"
+echo "ok: a relative options::icon resolves against MCPP_MANIFEST_DIR, and a missing directory is refused at plan time, naming options::icon and the path"
+
 echo "== iOS device row =="
 outdir=$(run_row device ios "" /tmp/ios-plan-device.log)
 log=/tmp/ios-plan-device.log