Fixes NixOS#6939.

We don't need to return the accessor here (in fact it rarely makes
sense to return a path from the EvalCache).

The URLs 'git+file:///foo' and 'git+file:///foo?rev=bla' are not
exactly the same. The former can use the dirty tree at /foo, while the
latter won't (it will use the latest committed revision of branch
'bla'). So since we use the latter in the in-memory lock file, the
subsequent call to fetchTree won't be able to see any dirty changes to
/foo, which isn't what we want.

E.g. instead of

  error: Package ‘steam’ in /__virtual__/4/pkgs/games/steam/steam.nix:43 has an unfree license (‘unfreeRedistributable’), refusing to evaluate.

you now get

  error: Package ‘steam’ in «github:nixos/nixpkgs/b82ccafb54163ab9024e893e578d840577785fea»/pkgs/games/steam/steam.nix:43 has an unfree license (‘unfreeRedistributable’), refusing to evaluate.

These are purely related to NIX_PATH / -I command line parsing, so put
them in libexpr.

Fixes NixOS#7026.

This gets rid of stack trace entries like

       … from call site

       at «stdin»:0: (source not available)

This fixes the error

  in pure evaluation mode, 'fetchTree' requires a locked input

when using '--override-input X Y' where Y is an unlocked input (e.g. a
dirty Git tree).

Also, make LockFile use ref instead of std::shared_ptr.

…aracter

As suggested by @aszlig in NixOS#6530 (comment).

We're not even using those timestamps, but doing the conversion to
local time takes a lot of time. For instance, this patch speeds up
'nix flake metadata nixpkgs` from 0.542s to 0.094s.

Fixes an issue reported by @erikarvstedt where
InputAccessor::fetchToStore() wouldn't cache the store path the first
time.

In particular, 'path:..' got turned into 'path:.' because isRelative()
returned a CanonPath, which cannot represent '..'.

Reported by @erikarvstedt.

Reported by @lheckemann.

…ent flake

As suggested by @Ma27.

This makes lib.isStorePath in nixpkgs return true for source trees and
fixes some cases where /__nix_virtual__ showed up in the NixOS manual.

This is needed to verify that the source tree served by GitHub hasn't
changed compared to the lock file. Computing the narHash for a nixpkgs
source tree only takes ~0.6s and it's cached. So the cost is fairly
negligible compared to the download time.

This reverts commit 0286edb for now
since it doesn't handle directories correctly.

This avoids an inconsistency where a '/' is implicitly inserted when
you append to the root of a source tree, but not when you append to
any other path.

…t FS

This makes

  let foo = "foo"; in /${foo}

work again.

toDerivedPaths() now returns DerivedPathWithInfo, which is DerivedPath
with some attributes needed by 'nix profile' etc.

Preparation for NixOS#7417.

This makes 'nix build' work on paths (which will be copied to the
store) and store paths (returned as is). E.g. the following flake
output attributes can be built using 'nix build .#foo':

  foo = ./src;
  foo = self.outPath;
  foo = builtins.fetchTarball { ... };
  foo = (builtins.fetchTree { .. }).outPath;
  foo = builtins.fetchTree { .. } + "/README.md";
  foo = builtins.storePath /nix/store/...;

Note that this is potentially risky, e.g.

  foo = /.;

will cause Nix to try to copy the entire file system to the store.

What doesn't work yet:

  foo = self;
  foo = builtins.fetchTree { .. };

because we don't handle attrsets with an outPath attribute in it yet,
and

  foo = builtins.storePath /nix/store/.../README.md;

since result symlinks have to point to a store path currently (rather
than a file inside a store path).

Fixes NixOS#7417.

This is like builtins.{filterSource,path}, but returns a virtual path
that applies the filter lazily, rather than copying the result to the
Nix store. Thus filterPath can be composed.

Co-authored-by: Robert Hensing <[email protected]>

This is needed for std::span.

Tarballs are now unpacked into a content-addressed cache, specifically
a Git repository in ~/.cache/nix/tarball-cache so that we can use
GitAccessor to provide random access.

Ideally this would be a fatal error, but tree hashes won't be correct
for repos that use submodules. (But OTOH, the GitHub fetcher doesn't
support submodules anyway...)

This reverts commit 37b4a9e. This
doesn't handle the case where there is no slash.

On aarch64-linux we're forced to use gcc 9, which doesn't support
std::span yet.