Split the parsing of an App and its resolving

That way things (like `nix flake check`) can evaluate the `app` outputs
without having to build anything

src/libcmd/installables.hh

@@ -23,6 +23,12 @@ struct App
     // FIXME: add args, sandbox settings, metadata, ...
 };
 
+struct UnresolvedApp
+{
+    App unresolved;
+    App resolve(ref<Store>);
+};
+
 struct Installable
 {
     virtual ~Installable() { }
@@ -33,7 +39,7 @@ struct Installable
 
     DerivedPath toDerivedPath();
 
-    App toApp(EvalState & state);
+    UnresolvedApp toApp(EvalState & state);
 
     virtual std::pair<Value *, Pos> toValue(EvalState & state)
     {

src/nix/app.cc

@@ -58,33 +58,24 @@ std::string resolveString(Store & store, const std::string & toResolve, const Bu
     return rewriteStrings(toResolve, rewrites);
 }
 
-App Installable::toApp(EvalState & state)
+UnresolvedApp Installable::toApp(EvalState & state)
 {
     auto [cursor, attrPath] = getCursor(state);
 
     auto type = cursor->getAttr("type")->getString();
 
-    auto checkProgram = [&](const Path & program)
-    {
-        if (!state.store->isInStore(program))
-            throw Error("app program '%s' is not in the Nix store", program);
-    };
-
-    std::vector<std::shared_ptr<Installable>> context;
-    std::string unresolvedProgram;
-
-
     if (type == "app") {
-        auto [program, context_] = cursor->getAttr("program")->getStringWithContext();
+        auto [program, context] = cursor->getAttr("program")->getStringWithContext();
-        unresolvedProgram = program;
 
-        for (auto & [path, name] : context_)
+
-            context.push_back(std::make_shared<InstallableDerivedPath>(
+        std::vector<StorePathWithOutputs> context2;
-                state.store,
+        for (auto & [path, name] : context)
-                DerivedPathBuilt{
+            context2.push_back({state.store->parseStorePath(path), {name}});
-                    .drvPath = state.store->parseStorePath(path),
+
-                    .outputs = {name},
+        return UnresolvedApp{App {
-                }));
+            .context = std::move(context2),
+            .program = program,
+        }};
     }
 
     else if (type == "derivation") {
@@ -98,24 +89,33 @@ App Installable::toApp(EvalState & state)
             aMainProgram
             ? aMainProgram->getString()
             : DrvName(name).name;
-        unresolvedProgram = outPath + "/bin/" + mainProgram;
+        auto program = outPath + "/bin/" + mainProgram;
-        context = {std::make_shared<InstallableDerivedPath>(
+        return UnresolvedApp { App {
-            state.store,
+            .context = { { drvPath, {outputName} } },
-            DerivedPathBuilt{
+            .program = program,
-                .drvPath = drvPath,
+        }};
-                .outputs = {outputName},
-            })};
     }
 
     else
         throw Error("attribute '%s' has unsupported type '%s'", attrPath, type);
+}
 
-    auto builtContext = build(state.store, Realise::Outputs, context);
+App UnresolvedApp::resolve(ref<Store> store)
-    auto program = resolveString(*state.store, unresolvedProgram, builtContext);
+{
-    checkProgram(program);
+    auto res = unresolved;
-    return App {
+
-        .program = program,
+    std::vector<std::shared_ptr<Installable>> installableContext;
-    };
+
+    for (auto & ctxElt : unresolved.context)
+        installableContext.push_back(
+            std::make_shared<InstallableDerivedPath>(store, ctxElt.toDerivedPath()));
+
+    auto builtContext = build(store, Realise::Outputs, installableContext);
+    res.program = resolveString(*store, unresolved.program, builtContext);
+    if (store->isInStore(res.program))
+        throw Error("app program '%s' is not in the Nix store", res.program);
+
+    return res;
 }
 
 }

src/nix/bundle.cc

@@ -69,8 +69,7 @@ struct CmdBundle : InstallableCommand
     {
         auto evalState = getEvalState();
 
-        auto app = installable->toApp(*evalState);
+        auto app = installable->toApp(*evalState).resolve(store);
-        store->buildPaths(toDerivedPaths(app.context));
 
         auto [bundlerFlakeRef, bundlerName] = parseFlakeRefWithFragment(bundler, absPath("."));
         const flake::LockFlags lockFlags{ .writeLockFile = false };

src/nix/run.cc

@@ -178,9 +178,7 @@ struct CmdRun : InstallableCommand, RunCommon
     {
         auto state = getEvalState();
 
-        auto app = installable->toApp(*state);
+        auto app = installable->toApp(*state).resolve(store);
-
-        state->store->buildPaths(toDerivedPaths(app.context));
 
         Strings allArgs{app.program};
         for (auto & i : args) allArgs.push_back(i);