Make more string values work as installables

As discussed in NixOS#7417, it would be good to make more string values work
as installables. That is to say, if an installable refers to a value,
and the value is a string, it used to not work at all, since NixOS#7484, it
works somewhat, and this PR make it work some more.

The new cases that are added for `BuiltPath` contexts:

- Fixed input- or content-addressed derivation:

  ```
  nix-repl> hello.out.outPath
  "/nix/store/jppfl2bp1zhx8sgs2mgifmsx6dv16mv2-hello-2.12"

  nix-repl> :p builtins.getContext hello.out.outPath
  { "/nix/store/c7jrxqjhdda93lhbkanqfs07x2bzazbm-hello-2.12.drv" = { outputs = [ "out" ]; }; }

  The string matches the specified single output of that derivation, so
  it should also be valid.

- Floating content-addressed derivation:

  ```
  nix-repl> (hello.overrideAttrs (_: { __contentAddressed = true; })).out.outPath
  "/1a08j26xqc0zm8agps8anxpjji410yvsx4pcgyn4bfan1ddkx2g0"

  nix-repl> :p builtins.getContext (hello.overrideAttrs (_: { __contentAddressed = true; })).out.outPath
  { "/nix/store/qc645pyf9wl37c6qvqzaqkwsm1gp48al-hello-2.12.drv" = { outputs = [ "out" ]; }; }
  ```

  The string is not a path but a placeholder, however it also matches
  the context, and because it is a CA derivation we have no better
  option. This should also be valid.

We may also want to think about richer attrset based values (also
discussed in that issue and NixOS#6507), but this change "completes" our
string-based building blocks, from which the others can be desugared
into or at least described/document/taught in terms of.

Progress towards NixOS#7417

src/libcmd/installable-flake.cc

@@ -109,16 +109,49 @@ DerivedPathsWithInfo InstallableFlake::toDerivedPaths()
         else if (v.type() == nString) {
             NixStringContext context;
             auto s = state->forceString(v, context, noPos, fmt("while evaluating the flake output attribute '%s'", attrPath));
-            auto storePath = state->store->maybeParseStorePath(s);
-            if (storePath && context.count(NixStringContextElem::Opaque { .path = *storePath })) {
-                return {{
-                    .path = DerivedPath::Opaque {
-                        .path = std::move(*storePath),
+            if (context.size() != 1)
+                throw Error(
+                    "flake output attribute '%s' evaluates a string '%s' which which has multiple entries in its context. It should only have one entry",
+                    attrPath, s);
+            return {{
+                .path = std::visit(overloaded {
+                    [&](NixStringContextElem::Opaque && o) -> DerivedPath {
+                       auto sExpected = state->store->printStorePath(o.path);
+                       if (s != sExpected)
+                           throw Error(
+                               "flake output attribute '%s' evaluates to the path string '%s', but its context has the different path '%s'",
+                               attrPath, s, sExpected);
+                       return DerivedPath::Opaque {
+                           .path = std::move(o.path),
+                       };
+                    },
+                    [&](NixStringContextElem::DrvDeep && o) -> DerivedPath {
+                       throw Error(
+                           "flake output attribute '%s' evaluates to the string '%s' whose context context refers to a complete source and binary closure. This is not supported at this time",
+                           attrPath, s);
+                    },
+                    [&](NixStringContextElem::Built && o) -> DerivedPath {
+                       auto drv = state->store->readDerivation(o.drvPath);
+                       auto i = drv.outputs.find(o.output);
+                       if (i == drv.outputs.end())
+                           throw Error("derivation '%s' does not have output '%s'", state->store->printStorePath(o.drvPath), o.output);
+                       auto optOutputPath = i->second.path(*state->store, drv.name, o.output);
+                       // This is testing for the case of CA derivations
+                       auto sExpected = optOutputPath
+                           ? state->store->printStorePath(*optOutputPath)
+                           : downstreamPlaceholder(*state->store, o.drvPath, o.output);
+                       if (s != sExpected)
+                           throw Error(
+                               "flake output attribute '%s' evaluates to a string '%s' whose context has the output '%s' from derivation '%s', but the string is not the right placeholder for this derivation output. It should be '%s'",
+                               attrPath, s, o.output, state->store->printStorePath(o.drvPath), sExpected);
+                       return DerivedPath::Built {
+                           .drvPath = std::move(o.drvPath),
+                           .outputs = OutputsSpec::Names { std::move(o.output) },
+                       };
                     },
-                    .info = make_ref<ExtraPathInfo>(),
-                }};
-            } else
-                throw Error("flake output attribute '%s' evaluates to the string '%s' which is not a store path", attrPath, s);
+                }, ((NixStringContextElem &&) *context.begin()).raw()),
+                .info = make_ref<ExtraPathInfo>(),
+            }};
         }
 
         else

tests/flakes/build-paths.sh

@@ -41,10 +41,25 @@ cat > $flake1Dir/flake.nix <<EOF
     a8 = builtins.storePath $dep;
 
     a9 = "$dep";
+
+    drvCall = with import ./config.nix; mkDerivation {
+      name = "simple";
+      builder = ./simple.builder.sh;
+      PATH = "";
+      goodPath = path;
+    };
+
+    a10 = builtins.unsafeDiscardOutputDependency self.drvCall.drvPath;
+
+    a11 = self.drvCall.drvPath;
+
+    a12 = self.drvCall.outPath;
   };
 }
 EOF
 
+cp ../simple.nix ../simple.builder.sh ../config.nix $flake1Dir/
+
 echo bar > $flake1Dir/foo
 
 nix build --json --out-link $TEST_ROOT/result $flake1Dir#a1
@@ -64,3 +79,11 @@ nix build --impure --json --out-link $TEST_ROOT/result $flake1Dir#a8
 diff common.sh $TEST_ROOT/result
 
 (! nix build --impure --json --out-link $TEST_ROOT/result $flake1Dir#a9)
+
+nix build --json --out-link $TEST_ROOT/result $flake1Dir#a10
+[[ $(readlink -e $TEST_ROOT/result) = *simple.drv ]]
+
+(! nix build --json --out-link $TEST_ROOT/result $flake1Dir#a11)
+
+nix build --json --out-link $TEST_ROOT/result $flake1Dir#a12
+[[ -e $TEST_ROOT/result/hello ]]