Make more string values work as installables

As discussed in #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 #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 #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 #7417

src/libcmd/installables.cc

@@ -617,17 +617,49 @@ DerivedPathsWithInfo InstallableFlake::toDerivedPaths()
         }
 
         else if (v.type() == nString) {
-            PathSet 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(std::string(s))) {
-                return {{
-                    .path = DerivedPath::Opaque {
-                        .path = std::move(*storePath),
-                    }
-                }};
-            } else
-                throw Error("flake output attribute '%s' evaluates to the string '%s' which is not a store path", attrPath, s);
+            auto context = v.getContext(*state->store);
+            std::string_view s = state->forceString(v, noPos, fmt("while evaluating the flake output attribute '%s'", attrPath));
+            if (context.size() != 1)
+                throw Error(
+                    "flake output attribute '%s' evaluates to the string '%s' which does not denote exactly one store",
+                    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 string '%s' which should be '%s' but is not",
+                               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' which unsupported String Context",
+                           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);
+                       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 the string '%s' which should be '%s' but is not",
+                               attrPath, s, sExpected);
+                       return DerivedPath::Built {
+                           .drvPath = std::move(o.drvPath),
+                           .outputs = OutputsSpec::Names { std::move(o.output) },
+                       };
+                    },
+                }, context[0].raw()),
+            }};
         }
 
         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 ]]