Split the parsing of an App and its resolving

thufschmitt · thufschmitt · commit ca96f5219489 · 2021-05-17T17:50:41.000+02:00
That way things (like `nix flake check`) can evaluate the `app` outputs
without having to build anything
diff --git a/src/libcmd/installables.hh b/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)
     {
diff --git a/src/nix/app.cc b/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);
-    };
+    if (type == "app") {
+        auto [program, context] = cursor->getAttr("program")->getStringWithContext();
 
-    std::vector<std::shared_ptr<Installable>> context;
-    std::string unresolvedProgram;
 
+        std::vector<StorePathWithOutputs> context2;
+        for (auto & [path, name] : context)
+            context2.push_back({state.store->parseStorePath(path), {name}});
 
-    if (type == "app") {
-        auto [program, context_] = cursor->getAttr("program")->getStringWithContext();
-        unresolvedProgram = program;
-
-        for (auto & [path, name] : context_)
-            context.push_back(std::make_shared<InstallableDerivedPath>(
-                state.store,
-                DerivedPathBuilt{
-                    .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;
-        context = {std::make_shared<InstallableDerivedPath>(
-            state.store,
-            DerivedPathBuilt{
-                .drvPath = drvPath,
-                .outputs = {outputName},
-            })};
+        auto program = outPath + "/bin/" + mainProgram;
+        return UnresolvedApp { App {
+            .context = { { drvPath, {outputName} } },
+            .program = program,
+        }};
     }
 
     else
         throw Error("attribute '%s' has unsupported type '%s'", attrPath, type);
+}
+
+App UnresolvedApp::resolve(ref<Store> store)
+{
+    auto res = unresolved;
+
+    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(state.store, Realise::Outputs, context);
-    auto program = resolveString(*state.store, unresolvedProgram, builtContext);
-    checkProgram(program);
-    return App {
-        .program = program,
-    };
+    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;
 }
 
 }
diff --git a/src/nix/bundle.cc b/src/nix/bundle.cc
@@ -69,8 +69,7 @@ struct CmdBundle : InstallableCommand
     {
         auto evalState = getEvalState();
 
-        auto app = installable->toApp(*evalState);
-        store->buildPaths(toDerivedPaths(app.context));
+        auto app = installable->toApp(*evalState).resolve(store);
 
         auto [bundlerFlakeRef, bundlerName] = parseFlakeRefWithFragment(bundler, absPath("."));
         const flake::LockFlags lockFlags{ .writeLockFile = false };
diff --git a/src/nix/run.cc b/src/nix/run.cc
@@ -178,9 +178,7 @@ struct CmdRun : InstallableCommand, RunCommon
     {
         auto state = getEvalState();
 
-        auto app = installable->toApp(*state);
-
-        state->store->buildPaths(toDerivedPaths(app.context));
+        auto app = installable->toApp(*state).resolve(store);
 
         Strings allArgs{app.program};
         for (auto & i : args) allArgs.push_back(i);

Original file line number	Diff line number	Diff line change
`@@ -69,8 +69,7 @@ struct CmdBundle : InstallableCommand`
`69`	`69`	`{`
`70`	`70`	`auto evalState = getEvalState();`
`71`	`71`
`72`		`- auto app = installable->toApp(*evalState);`
`73`		`- store->buildPaths(toDerivedPaths(app.context));`
	`72`	`+ auto app = installable->toApp(*evalState).resolve(store);`
`74`	`73`
`75`	`74`	`auto [bundlerFlakeRef, bundlerName] = parseFlakeRefWithFragment(bundler, absPath("."));`
`76`	`75`	`const flake::LockFlags lockFlags{ .writeLockFile = false };`
Original file line number	Diff line number	Diff line change
`@@ -178,9 +178,7 @@ struct CmdRun : InstallableCommand, RunCommon`
`178`	`178`	`{`
`179`	`179`	`auto state = getEvalState();`
`180`	`180`
`181`		`- auto app = installable->toApp(*state);`
`182`		`-`
`183`		`- state->store->buildPaths(toDerivedPaths(app.context));`
	`181`	`+ auto app = installable->toApp(*state).resolve(store);`
`184`	`182`
`185`	`183`	`Strings allArgs{app.program};`
`186`	`184`	`for (auto & i : args) allArgs.push_back(i);`