Split installTests

That way the CI will run the different ones on different runners

.github/workflows/backport.yml

@@ -8,14 +8,14 @@ jobs:
     if: github.repository_owner == 'NixOS' && github.event.pull_request.merged == true && (github.event_name != 'labeled' || startsWith('backport', github.event.label.name))
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
         with:
           ref: ${{ github.event.pull_request.head.sha }}
           # required to find all branches
           fetch-depth: 0
       - name: Create backport PRs
         # should be kept in sync with `version`
-        uses: zeebe-io/backport-action@v0.0.8
+        uses: zeebe-io/backport-action@v0.0.7
         with:
           # Config README: https://github.com/zeebe-io/backport-action#backport-action
           github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -6,18 +6,20 @@ on:
 
 jobs:
 
-  tests:
+  build:
     needs: [check_cachix]
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 60
+    outputs:
+      flake-outputs-json: ${{ steps.list-outputs.outputs.json }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2.4.0
       with:
         fetch-depth: 0
-    - uses: cachix/install-nix-action@v17
+    - uses: cachix/install-nix-action@v16
     - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
     - uses: cachix/cachix-action@v10
       if: needs.check_cachix.outputs.secret == 'true'
@@ -25,7 +27,32 @@ jobs:
         name: '${{ env.CACHIX_NAME }}'
         signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'
         authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
-    - run: nix --experimental-features 'nix-command flakes' flake check -L
+    - run: nix --experimental-features 'nix-command flakes' build -L
+    - name: List all the tests to run
+      id: list-outputs
+      run: scripts/list-tests-flake-outptus-for-gha
+
+  test:
+    needs: [build, check_cachix]
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        outputName: ${{ fromJson(needs.build.outputs.flake-outputs-json) }}
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2.4.0
+      with:
+        fetch-depth: 0
+    - uses: cachix/install-nix-action@v16
+    - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
+    - uses: cachix/cachix-action@v10
+      if: needs.check_cachix.outputs.secret == 'true'
+      with:
+        name: '${{ env.CACHIX_NAME }}'
+        signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'
+        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+    - run: nix --experimental-features 'nix-command flakes' build .#checks.$(nix eval --raw --impure --expr builtins.currentSystem).${{ matrix.outputName }}  -L
+
 
   check_cachix:
     name: Cachix secret present for installer tests
@@ -40,17 +67,17 @@ jobs:
         run: echo "::set-output name=secret::${{ env._CACHIX_SECRETS != '' }}"
 
   installer:
-    needs: [tests, check_cachix]
+    needs: [test, check_cachix]
     if: github.event_name == 'push' && needs.check_cachix.outputs.secret == 'true'
     runs-on: ubuntu-latest
     outputs:
       installerURL: ${{ steps.prepare-installer.outputs.installerURL }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2.4.0
       with:
         fetch-depth: 0
     - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
-    - uses: cachix/install-nix-action@v17
+    - uses: cachix/install-nix-action@v16
     - uses: cachix/cachix-action@v10
       with:
         name: '${{ env.CACHIX_NAME }}'
@@ -67,26 +94,26 @@ jobs:
         os: [ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2.4.0
     - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
-    - uses: cachix/install-nix-action@v17
+    - uses: cachix/install-nix-action@v16
       with:
         install_url: '${{needs.installer.outputs.installerURL}}'
         install_options: "--tarball-url-prefix https://${{ env.CACHIX_NAME }}.cachix.org/serve"
     - run: nix-instantiate -E 'builtins.currentTime' --eval
 
   docker_push_image:
-    needs: [check_cachix, tests]
+    needs: [check_cachix, build]
     if: >-
       github.event_name == 'push' &&
       github.ref_name == 'master' &&
       needs.check_cachix.outputs.secret == 'true'
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2.4.0
       with:
         fetch-depth: 0
-    - uses: cachix/install-nix-action@v17
+    - uses: cachix/install-nix-action@v16
     - run: echo CACHIX_NAME="$(echo $GITHUB_REPOSITORY-install-tests | tr "[A-Z]/" "[a-z]-")" >> $GITHUB_ENV
     - run: echo NIX_VERSION="$(nix-instantiate --eval -E '(import ./default.nix).defaultPackage.${builtins.currentSystem}.version' | tr -d \")" >> $GITHUB_ENV
     - uses: cachix/cachix-action@v10
@@ -100,7 +127,7 @@ jobs:
     - run: docker tag nix:$NIX_VERSION nixos/nix:$NIX_VERSION
     - run: docker tag nix:$NIX_VERSION nixos/nix:master
     - name: Login to Docker Hub
-      uses: docker/login-action@v2
+      uses: docker/login-action@v1
       with:
         username: ${{ secrets.DOCKERHUB_USERNAME }}
         password: ${{ secrets.DOCKERHUB_TOKEN }}

.github/workflows/hydra_status.yml

@@ -9,7 +9,7 @@ jobs:
     if: github.repository_owner == 'NixOS'
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2.4.0
       with:
         fetch-depth: 0
     - run: bash scripts/check-hydra-status.sh

.gitignore

@@ -35,7 +35,6 @@ perl/Makefile.config
 /src/libexpr/parser-tab.hh
 /src/libexpr/parser-tab.output
 /src/libexpr/nix.tbl
-/src/libexpr/tests/libexpr-tests
 
 # /src/libstore/
 *.gen.*
@@ -80,7 +79,6 @@ perl/Makefile.config
 /tests/shell.drv
 /tests/config.nix
 /tests/ca/config.nix
-/tests/repl-result-out
 
 # /tests/lang/
 /tests/lang/*.out
@@ -92,7 +90,6 @@ perl/Makefile.config
 
 /misc/systemd/nix-daemon.service
 /misc/systemd/nix-daemon.socket
-/misc/systemd/nix-daemon.conf
 /misc/upstart/nix-daemon.conf
 
 /src/resolve-system-dependencies/resolve-system-dependencies

.version

@@ -1 +1 @@
-2.9.2
+2.7.0

Makefile

@@ -8,7 +8,6 @@ makefiles = \
   src/libfetchers/local.mk \
   src/libmain/local.mk \
   src/libexpr/local.mk \
-  src/libexpr/tests/local.mk \
   src/libcmd/local.mk \
   src/nix/local.mk \
   src/resolve-system-dependencies/local.mk \

configure.ac

@@ -294,17 +294,6 @@ esac
 AC_ARG_WITH(sandbox-shell, AS_HELP_STRING([--with-sandbox-shell=PATH],[path of a statically-linked shell to use as /bin/sh in sandboxes]),
   sandbox_shell=$withval)
 AC_SUBST(sandbox_shell)
-if test ${cross_compiling:-no} = no && ! test -z ${sandbox_shell+x}; then
-  AC_MSG_CHECKING([whether sandbox-shell has the standalone feature])
-  # busybox shell sometimes allows executing other busybox applets,
-  # even if they are not in the path, breaking our sandbox
-  if PATH= $sandbox_shell -c "busybox" 2>&1 | grep -qv "not found"; then
-    AC_MSG_RESULT(enabled)
-    AC_MSG_ERROR([Please disable busybox FEATURE_SH_STANDALONE])
-  else
-    AC_MSG_RESULT(disabled)
-  fi
-fi
 
 # Expand all variables in config.status.
 test "$prefix" = NONE && prefix=$ac_default_prefix

doc/manual/anchors.jq

@@ -1,31 +0,0 @@
-"\\[\\]\\{#(?<anchor>[^\\}]+?)\\}" as $empty_anchor_regex |
-"\\[(?<text>[^\\]]+?)\\]\\{#(?<anchor>[^\\}]+?)\\}" as $anchor_regex |
-
-
-def transform_anchors_html:
-    . | gsub($empty_anchor_regex; "<a name=\"" + .anchor + "\"></a>")
-      | gsub($anchor_regex; "<a href=\"#" + .anchor + "\" id=\"" + .anchor + "\">" + .text + "</a>");
-
-
-def transform_anchors_strip:
-    . | gsub($empty_anchor_regex; "")
-      | gsub($anchor_regex; .text);
-
-
-def map_contents_recursively(transformer):
-    . + {
-        Chapter: (.Chapter + {
-            content: .Chapter.content | transformer,
-            sub_items: .Chapter.sub_items | map(map_contents_recursively(transformer)),
-        }),
-    };
-
-
-def process_command:
-    .[0] as $context |
-    .[1] as $body |
-    $body + {
-        sections: $body.sections | map(map_contents_recursively(if $context.renderer == "html" then transform_anchors_html else transform_anchors_strip end)),
-    };
-
-process_command

doc/manual/book.toml

@@ -1,7 +1,2 @@
 [output.html]
 additional-css = ["custom.css"]
-additional-js = ["redirects.js"]
-
-[preprocessor.anchors]
-renderers = ["html"]
-command = "jq --from-file doc/manual/anchors.jq"

doc/manual/generate-builtins.nix

@@ -6,9 +6,9 @@ builtins:
 concatStrings (map
   (name:
     let builtin = builtins.${name}; in
-    "<dt id=\"builtins-${name}\"><a href=\"#builtins-${name}\"><code>${name} "
+    "<dt><code>${name} "
     + concatStringsSep " " (map (s: "<var>${s}</var>") builtin.args)
-    + "</code></a></dt>"
+    + "</code></dt>"
     + "<dd>\n\n"
     + builtin.doc
     + "\n\n</dd>"

doc/manual/generate-options.nix

@@ -6,8 +6,7 @@ options:
 concatStrings (map
   (name:
     let option = options.${name}; in
-    "  - [`${name}`](#conf-${name})"
-    + "<p id=\"conf-${name}\"></p>\n\n"
+    "  - `${name}`  \n\n"
     + concatStrings (map (s: "    ${s}\n") (splitLines option.description)) + "\n\n"
     + (if option.documentDefault
        then "    **Default:** " + (

doc/manual/local.mk

@@ -72,7 +72,6 @@ $(d)/builtins.json: $(bindir)/nix
 	@mv $@.tmp $@
 
 # Generate the HTML manual.
-html: $(docdir)/manual/index.html
 install: $(docdir)/manual/index.html
 
 # Generate 'nix' manpages.
@@ -97,7 +96,7 @@ doc/manual/generated/man1/nix3-manpages: $(d)/src/command-ref/new-cli
 	done
 	@touch $@
 
-$(docdir)/manual/index.html: $(MANUAL_SRCS) $(d)/book.toml $(d)/anchors.jq $(d)/custom.css $(d)/src/SUMMARY.md $(d)/src/command-ref/new-cli $(d)/src/command-ref/conf-file.md $(d)/src/expressions/builtins.md $(call rwildcard, $(d)/src, *.md)
+$(docdir)/manual/index.html: $(MANUAL_SRCS) $(d)/book.toml $(d)/custom.css $(d)/src/SUMMARY.md $(d)/src/command-ref/new-cli $(d)/src/command-ref/conf-file.md $(d)/src/expressions/builtins.md $(call rwildcard, $(d)/src, *.md)
 	$(trace-gen) RUST_LOG=warn mdbook build doc/manual -d $(DESTDIR)$(docdir)/manual
 
 endif

doc/manual/redirects.js

@@ -1,337 +0,0 @@
-// Redirects from old DocBook manual.
-var redirects = {
-  "#part-advanced-topics": "advanced-topics/advanced-topics.html",
-  "#chap-tuning-cores-and-jobs": "advanced-topics/cores-vs-jobs.html",
-  "#chap-diff-hook": "advanced-topics/diff-hook.html",
-  "#check-dirs-are-unregistered": "advanced-topics/diff-hook.html#check-dirs-are-unregistered",
-  "#chap-distributed-builds": "advanced-topics/distributed-builds.html",
-  "#chap-post-build-hook": "advanced-topics/post-build-hook.html",
-  "#chap-post-build-hook-caveats": "advanced-topics/post-build-hook.html#implementation-caveats",
-  "#part-command-ref": "command-ref/command-ref.html",
-  "#conf-allow-import-from-derivation": "command-ref/conf-file.html#conf-allow-import-from-derivation",
-  "#conf-allow-new-privileges": "command-ref/conf-file.html#conf-allow-new-privileges",
-  "#conf-allowed-uris": "command-ref/conf-file.html#conf-allowed-uris",
-  "#conf-allowed-users": "command-ref/conf-file.html#conf-allowed-users",
-  "#conf-auto-optimise-store": "command-ref/conf-file.html#conf-auto-optimise-store",
-  "#conf-binary-cache-public-keys": "command-ref/conf-file.html#conf-binary-cache-public-keys",
-  "#conf-binary-caches": "command-ref/conf-file.html#conf-binary-caches",
-  "#conf-build-compress-log": "command-ref/conf-file.html#conf-build-compress-log",
-  "#conf-build-cores": "command-ref/conf-file.html#conf-build-cores",
-  "#conf-build-extra-chroot-dirs": "command-ref/conf-file.html#conf-build-extra-chroot-dirs",
-  "#conf-build-extra-sandbox-paths": "command-ref/conf-file.html#conf-build-extra-sandbox-paths",
-  "#conf-build-fallback": "command-ref/conf-file.html#conf-build-fallback",
-  "#conf-build-max-jobs": "command-ref/conf-file.html#conf-build-max-jobs",
-  "#conf-build-max-log-size": "command-ref/conf-file.html#conf-build-max-log-size",
-  "#conf-build-max-silent-time": "command-ref/conf-file.html#conf-build-max-silent-time",
-  "#conf-build-repeat": "command-ref/conf-file.html#conf-build-repeat",
-  "#conf-build-timeout": "command-ref/conf-file.html#conf-build-timeout",
-  "#conf-build-use-chroot": "command-ref/conf-file.html#conf-build-use-chroot",
-  "#conf-build-use-sandbox": "command-ref/conf-file.html#conf-build-use-sandbox",
-  "#conf-build-use-substitutes": "command-ref/conf-file.html#conf-build-use-substitutes",
-  "#conf-build-users-group": "command-ref/conf-file.html#conf-build-users-group",
-  "#conf-builders": "command-ref/conf-file.html#conf-builders",
-  "#conf-builders-use-substitutes": "command-ref/conf-file.html#conf-builders-use-substitutes",
-  "#conf-compress-build-log": "command-ref/conf-file.html#conf-compress-build-log",
-  "#conf-connect-timeout": "command-ref/conf-file.html#conf-connect-timeout",
-  "#conf-cores": "command-ref/conf-file.html#conf-cores",
-  "#conf-diff-hook": "command-ref/conf-file.html#conf-diff-hook",
-  "#conf-enforce-determinism": "command-ref/conf-file.html#conf-enforce-determinism",
-  "#conf-env-keep-derivations": "command-ref/conf-file.html#conf-env-keep-derivations",
-  "#conf-extra-binary-caches": "command-ref/conf-file.html#conf-extra-binary-caches",
-  "#conf-extra-platforms": "command-ref/conf-file.html#conf-extra-platforms",
-  "#conf-extra-sandbox-paths": "command-ref/conf-file.html#conf-extra-sandbox-paths",
-  "#conf-extra-substituters": "command-ref/conf-file.html#conf-extra-substituters",
-  "#conf-fallback": "command-ref/conf-file.html#conf-fallback",
-  "#conf-fsync-metadata": "command-ref/conf-file.html#conf-fsync-metadata",
-  "#conf-gc-keep-derivations": "command-ref/conf-file.html#conf-gc-keep-derivations",
-  "#conf-gc-keep-outputs": "command-ref/conf-file.html#conf-gc-keep-outputs",
-  "#conf-hashed-mirrors": "command-ref/conf-file.html#conf-hashed-mirrors",
-  "#conf-http-connections": "command-ref/conf-file.html#conf-http-connections",
-  "#conf-keep-build-log": "command-ref/conf-file.html#conf-keep-build-log",
-  "#conf-keep-derivations": "command-ref/conf-file.html#conf-keep-derivations",
-  "#conf-keep-env-derivations": "command-ref/conf-file.html#conf-keep-env-derivations",
-  "#conf-keep-outputs": "command-ref/conf-file.html#conf-keep-outputs",
-  "#conf-max-build-log-size": "command-ref/conf-file.html#conf-max-build-log-size",
-  "#conf-max-free": "command-ref/conf-file.html#conf-max-free",
-  "#conf-max-jobs": "command-ref/conf-file.html#conf-max-jobs",
-  "#conf-max-silent-time": "command-ref/conf-file.html#conf-max-silent-time",
-  "#conf-min-free": "command-ref/conf-file.html#conf-min-free",
-  "#conf-narinfo-cache-negative-ttl": "command-ref/conf-file.html#conf-narinfo-cache-negative-ttl",
-  "#conf-narinfo-cache-positive-ttl": "command-ref/conf-file.html#conf-narinfo-cache-positive-ttl",
-  "#conf-netrc-file": "command-ref/conf-file.html#conf-netrc-file",
-  "#conf-plugin-files": "command-ref/conf-file.html#conf-plugin-files",
-  "#conf-post-build-hook": "command-ref/conf-file.html#conf-post-build-hook",
-  "#conf-pre-build-hook": "command-ref/conf-file.html#conf-pre-build-hook",
-  "#conf-repeat": "command-ref/conf-file.html#conf-repeat",
-  "#conf-require-sigs": "command-ref/conf-file.html#conf-require-sigs",
-  "#conf-restrict-eval": "command-ref/conf-file.html#conf-restrict-eval",
-  "#conf-run-diff-hook": "command-ref/conf-file.html#conf-run-diff-hook",
-  "#conf-sandbox": "command-ref/conf-file.html#conf-sandbox",
-  "#conf-sandbox-dev-shm-size": "command-ref/conf-file.html#conf-sandbox-dev-shm-size",
-  "#conf-sandbox-paths": "command-ref/conf-file.html#conf-sandbox-paths",
-  "#conf-secret-key-files": "command-ref/conf-file.html#conf-secret-key-files",
-  "#conf-show-trace": "command-ref/conf-file.html#conf-show-trace",
-  "#conf-stalled-download-timeout": "command-ref/conf-file.html#conf-stalled-download-timeout",
-  "#conf-substitute": "command-ref/conf-file.html#conf-substitute",
-  "#conf-substituters": "command-ref/conf-file.html#conf-substituters",
-  "#conf-system": "command-ref/conf-file.html#conf-system",
-  "#conf-system-features": "command-ref/conf-file.html#conf-system-features",
-  "#conf-tarball-ttl": "command-ref/conf-file.html#conf-tarball-ttl",
-  "#conf-timeout": "command-ref/conf-file.html#conf-timeout",
-  "#conf-trace-function-calls": "command-ref/conf-file.html#conf-trace-function-calls",
-  "#conf-trusted-binary-caches": "command-ref/conf-file.html#conf-trusted-binary-caches",
-  "#conf-trusted-public-keys": "command-ref/conf-file.html#conf-trusted-public-keys",
-  "#conf-trusted-substituters": "command-ref/conf-file.html#conf-trusted-substituters",
-  "#conf-trusted-users": "command-ref/conf-file.html#conf-trusted-users",
-  "#extra-sandbox-paths": "command-ref/conf-file.html#extra-sandbox-paths",
-  "#sec-conf-file": "command-ref/conf-file.html",
-  "#env-NIX_PATH": "command-ref/env-common.html#env-NIX_PATH",
-  "#env-common": "command-ref/env-common.html",
-  "#envar-remote": "command-ref/env-common.html#env-NIX_REMOTE",
-  "#sec-common-env": "command-ref/env-common.html",
-  "#ch-files": "command-ref/files.html",
-  "#ch-main-commands": "command-ref/main-commands.html",
-  "#opt-out-link": "command-ref/nix-build.html#opt-out-link",
-  "#sec-nix-build": "command-ref/nix-build.html",
-  "#sec-nix-channel": "command-ref/nix-channel.html",
-  "#sec-nix-collect-garbage": "command-ref/nix-collect-garbage.html",
-  "#sec-nix-copy-closure": "command-ref/nix-copy-closure.html",
-  "#sec-nix-daemon": "command-ref/nix-daemon.html",
-  "#refsec-nix-env-install-examples": "command-ref/nix-env.html#examples",
-  "#rsec-nix-env-install": "command-ref/nix-env.html#operation---install",
-  "#rsec-nix-env-set": "command-ref/nix-env.html#operation---set",
-  "#rsec-nix-env-set-flag": "command-ref/nix-env.html#operation---set-flag",
-  "#rsec-nix-env-upgrade": "command-ref/nix-env.html#operation---upgrade",
-  "#sec-nix-env": "command-ref/nix-env.html",
-  "#ssec-version-comparisons": "command-ref/nix-env.html#versions",
-  "#sec-nix-hash": "command-ref/nix-hash.html",
-  "#sec-nix-instantiate": "command-ref/nix-instantiate.html",
-  "#sec-nix-prefetch-url": "command-ref/nix-prefetch-url.html",
-  "#sec-nix-shell": "command-ref/nix-shell.html",
-  "#ssec-nix-shell-shebang": "command-ref/nix-shell.html#use-as-a--interpreter",
-  "#nixref-queries": "command-ref/nix-store.html#queries",
-  "#opt-add-root": "command-ref/nix-store.html#opt-add-root",
-  "#refsec-nix-store-dump": "command-ref/nix-store.html#operation---dump",
-  "#refsec-nix-store-export": "command-ref/nix-store.html#operation---export",
-  "#refsec-nix-store-import": "command-ref/nix-store.html#operation---import",
-  "#refsec-nix-store-query": "command-ref/nix-store.html#operation---query",
-  "#refsec-nix-store-verify": "command-ref/nix-store.html#operation---verify",
-  "#rsec-nix-store-gc": "command-ref/nix-store.html#operation---gc",
-  "#rsec-nix-store-generate-binary-cache-key": "command-ref/nix-store.html#operation---generate-binary-cache-key",
-  "#rsec-nix-store-realise": "command-ref/nix-store.html#operation---realise",
-  "#rsec-nix-store-serve": "command-ref/nix-store.html#operation---serve",
-  "#sec-nix-store": "command-ref/nix-store.html",
-  "#opt-I": "command-ref/opt-common.html#opt-I",
-  "#opt-attr": "command-ref/opt-common.html#opt-attr",
-  "#opt-common": "command-ref/opt-common.html",
-  "#opt-cores": "command-ref/opt-common.html#opt-cores",
-  "#opt-log-format": "command-ref/opt-common.html#opt-log-format",
-  "#opt-max-jobs": "command-ref/opt-common.html#opt-max-jobs",
-  "#opt-max-silent-time": "command-ref/opt-common.html#opt-max-silent-time",
-  "#opt-timeout": "command-ref/opt-common.html#opt-timeout",
-  "#sec-common-options": "command-ref/opt-common.html",
-  "#ch-utilities": "command-ref/utilities.html",
-  "#chap-hacking": "contributing/hacking.html",
-  "#adv-attr-allowSubstitutes": "expressions/advanced-attributes.html#adv-attr-allowSubstitutes",
-  "#adv-attr-allowedReferences": "expressions/advanced-attributes.html#adv-attr-allowedReferences",
-  "#adv-attr-allowedRequisites": "expressions/advanced-attributes.html#adv-attr-allowedRequisites",
-  "#adv-attr-disallowedReferences": "expressions/advanced-attributes.html#adv-attr-disallowedReferences",
-  "#adv-attr-disallowedRequisites": "expressions/advanced-attributes.html#adv-attr-disallowedRequisites",
-  "#adv-attr-exportReferencesGraph": "expressions/advanced-attributes.html#adv-attr-exportReferencesGraph",
-  "#adv-attr-impureEnvVars": "expressions/advanced-attributes.html#adv-attr-impureEnvVars",
-  "#adv-attr-outputHash": "expressions/advanced-attributes.html#adv-attr-outputHash",
-  "#adv-attr-outputHashAlgo": "expressions/advanced-attributes.html#adv-attr-outputHashAlgo",
-  "#adv-attr-outputHashMode": "expressions/advanced-attributes.html#adv-attr-outputHashMode",
-  "#adv-attr-passAsFile": "expressions/advanced-attributes.html#adv-attr-passAsFile",
-  "#adv-attr-preferLocalBuild": "expressions/advanced-attributes.html#adv-attr-preferLocalBuild",
-  "#fixed-output-drvs": "expressions/advanced-attributes.html#adv-attr-outputHash",
-  "#sec-advanced-attributes": "expressions/advanced-attributes.html",
-  "#sec-arguments": "expressions/arguments-variables.html",
-  "#sec-build-script": "expressions/build-script.html",
-  "#builtin-abort": "expressions/builtins.html#builtins-abort",
-  "#builtin-add": "expressions/builtins.html#builtins-add",
-  "#builtin-all": "expressions/builtins.html#builtins-all",
-  "#builtin-any": "expressions/builtins.html#builtins-any",
-  "#builtin-attrNames": "expressions/builtins.html#builtins-attrNames",
-  "#builtin-attrValues": "expressions/builtins.html#builtins-attrValues",
-  "#builtin-baseNameOf": "expressions/builtins.html#builtins-baseNameOf",
-  "#builtin-bitAnd": "expressions/builtins.html#builtins-bitAnd",
-  "#builtin-bitOr": "expressions/builtins.html#builtins-bitOr",
-  "#builtin-bitXor": "expressions/builtins.html#builtins-bitXor",
-  "#builtin-builtins": "expressions/builtins.html#builtins-builtins",
-  "#builtin-compareVersions": "expressions/builtins.html#builtins-compareVersions",
-  "#builtin-concatLists": "expressions/builtins.html#builtins-concatLists",
-  "#builtin-concatStringsSep": "expressions/builtins.html#builtins-concatStringsSep",
-  "#builtin-currentSystem": "expressions/builtins.html#builtins-currentSystem",
-  "#builtin-deepSeq": "expressions/builtins.html#builtins-deepSeq",
-  "#builtin-derivation": "expressions/builtins.html#builtins-derivation",
-  "#builtin-dirOf": "expressions/builtins.html#builtins-dirOf",
-  "#builtin-div": "expressions/builtins.html#builtins-div",
-  "#builtin-elem": "expressions/builtins.html#builtins-elem",
-  "#builtin-elemAt": "expressions/builtins.html#builtins-elemAt",
-  "#builtin-fetchGit": "expressions/builtins.html#builtins-fetchGit",
-  "#builtin-fetchTarball": "expressions/builtins.html#builtins-fetchTarball",
-  "#builtin-fetchurl": "expressions/builtins.html#builtins-fetchurl",
-  "#builtin-filterSource": "expressions/builtins.html#builtins-filterSource",
-  "#builtin-foldl-prime": "expressions/builtins.html#builtins-foldl-prime",
-  "#builtin-fromJSON": "expressions/builtins.html#builtins-fromJSON",
-  "#builtin-functionArgs": "expressions/builtins.html#builtins-functionArgs",
-  "#builtin-genList": "expressions/builtins.html#builtins-genList",
-  "#builtin-getAttr": "expressions/builtins.html#builtins-getAttr",
-  "#builtin-getEnv": "expressions/builtins.html#builtins-getEnv",
-  "#builtin-hasAttr": "expressions/builtins.html#builtins-hasAttr",
-  "#builtin-hashFile": "expressions/builtins.html#builtins-hashFile",
-  "#builtin-hashString": "expressions/builtins.html#builtins-hashString",
-  "#builtin-head": "expressions/builtins.html#builtins-head",
-  "#builtin-import": "expressions/builtins.html#builtins-import",
-  "#builtin-intersectAttrs": "expressions/builtins.html#builtins-intersectAttrs",
-  "#builtin-isAttrs": "expressions/builtins.html#builtins-isAttrs",
-  "#builtin-isBool": "expressions/builtins.html#builtins-isBool",
-  "#builtin-isFloat": "expressions/builtins.html#builtins-isFloat",
-  "#builtin-isFunction": "expressions/builtins.html#builtins-isFunction",
-  "#builtin-isInt": "expressions/builtins.html#builtins-isInt",
-  "#builtin-isList": "expressions/builtins.html#builtins-isList",
-  "#builtin-isNull": "expressions/builtins.html#builtins-isNull",
-  "#builtin-isString": "expressions/builtins.html#builtins-isString",
-  "#builtin-length": "expressions/builtins.html#builtins-length",
-  "#builtin-lessThan": "expressions/builtins.html#builtins-lessThan",
-  "#builtin-listToAttrs": "expressions/builtins.html#builtins-listToAttrs",
-  "#builtin-map": "expressions/builtins.html#builtins-map",
-  "#builtin-match": "expressions/builtins.html#builtins-match",
-  "#builtin-mul": "expressions/builtins.html#builtins-mul",
-  "#builtin-parseDrvName": "expressions/builtins.html#builtins-parseDrvName",
-  "#builtin-path": "expressions/builtins.html#builtins-path",
-  "#builtin-pathExists": "expressions/builtins.html#builtins-pathExists",
-  "#builtin-placeholder": "expressions/builtins.html#builtins-placeholder",
-  "#builtin-readDir": "expressions/builtins.html#builtins-readDir",
-  "#builtin-readFile": "expressions/builtins.html#builtins-readFile",
-  "#builtin-removeAttrs": "expressions/builtins.html#builtins-removeAttrs",
-  "#builtin-replaceStrings": "expressions/builtins.html#builtins-replaceStrings",
-  "#builtin-seq": "expressions/builtins.html#builtins-seq",
-  "#builtin-sort": "expressions/builtins.html#builtins-sort",
-  "#builtin-split": "expressions/builtins.html#builtins-split",
-  "#builtin-splitVersion": "expressions/builtins.html#builtins-splitVersion",
-  "#builtin-stringLength": "expressions/builtins.html#builtins-stringLength",
-  "#builtin-sub": "expressions/builtins.html#builtins-sub",
-  "#builtin-substring": "expressions/builtins.html#builtins-substring",
-  "#builtin-tail": "expressions/builtins.html#builtins-tail",
-  "#builtin-throw": "expressions/builtins.html#builtins-throw",
-  "#builtin-toFile": "expressions/builtins.html#builtins-toFile",
-  "#builtin-toJSON": "expressions/builtins.html#builtins-toJSON",
-  "#builtin-toPath": "expressions/builtins.html#builtins-toPath",
-  "#builtin-toString": "expressions/builtins.html#builtins-toString",
-  "#builtin-toXML": "expressions/builtins.html#builtins-toXML",
-  "#builtin-trace": "expressions/builtins.html#builtins-trace",
-  "#builtin-tryEval": "expressions/builtins.html#builtins-tryEval",
-  "#builtin-typeOf": "expressions/builtins.html#builtins-typeOf",
-  "#ssec-builtins": "expressions/builtins.html",
-  "#attr-system": "expressions/derivations.html#attr-system",
-  "#ssec-derivation": "expressions/derivations.html",
-  "#ch-expression-language": "expressions/expression-language.html",
-  "#sec-expression-syntax": "expressions/expression-syntax.html",
-  "#sec-generic-builder": "expressions/generic-builder.html",
-  "#sec-constructs": "expressions/language-constructs.html",
-  "#sect-let-expressions": "expressions/language-constructs.html#let-expressions",
-  "#ss-functions": "expressions/language-constructs.html#functions",
-  "#sec-language-operators": "expressions/language-operators.html",
-  "#table-operators": "expressions/language-operators.html",
-  "#ssec-values": "expressions/language-values.html",
-  "#sec-building-simple": "expressions/simple-building-testing.html",
-  "#ch-simple-expression": "expressions/simple-expression.html",
-  "#chap-writing-nix-expressions": "expressions/writing-nix-expressions.html",
-  "#gloss-closure": "glossary.html#gloss-closure",
-  "#gloss-derivation": "glossary.html#gloss-derivation",
-  "#gloss-deriver": "glossary.html#gloss-deriver",
-  "#gloss-nar": "glossary.html#gloss-nar",
-  "#gloss-output-path": "glossary.html#gloss-output-path",
-  "#gloss-profile": "glossary.html#gloss-profile",
-  "#gloss-reachable": "glossary.html#gloss-reachable",
-  "#gloss-reference": "glossary.html#gloss-reference",
-  "#gloss-substitute": "glossary.html#gloss-substitute",
-  "#gloss-user-env": "glossary.html#gloss-user-env",
-  "#gloss-validity": "glossary.html#gloss-validity",
-  "#part-glossary": "glossary.html",
-  "#sec-building-source": "installation/building-source.html",
-  "#ch-env-variables": "installation/env-variables.html",
-  "#sec-installer-proxy-settings": "installation/env-variables.html#proxy-environment-variables",
-  "#sec-nix-ssl-cert-file": "installation/env-variables.html#nix_ssl_cert_file",
-  "#sec-nix-ssl-cert-file-with-nix-daemon-and-macos": "installation/env-variables.html#nix_ssl_cert_file-with-macos-and-the-nix-daemon",
-  "#chap-installation": "installation/installation.html",
-  "#ch-installing-binary": "installation/installing-binary.html",
-  "#sect-macos-installation": "installation/installing-binary.html#macos-installation",
-  "#sect-macos-installation-change-store-prefix": "installation/installing-binary.html#macos-installation",
-  "#sect-macos-installation-encrypted-volume": "installation/installing-binary.html#macos-installation",
-  "#sect-macos-installation-recommended-notes": "installation/installing-binary.html#macos-installation",
-  "#sect-macos-installation-symlink": "installation/installing-binary.html#macos-installation",
-  "#sect-multi-user-installation": "installation/installing-binary.html#multi-user-installation",
-  "#sect-nix-install-binary-tarball": "installation/installing-binary.html#installing-from-a-binary-tarball",
-  "#sect-nix-install-pinned-version-url": "installation/installing-binary.html#installing-a-pinned-nix-version-from-a-url",
-  "#sect-single-user-installation": "installation/installing-binary.html#single-user-installation",
-  "#ch-installing-source": "installation/installing-source.html",
-  "#ssec-multi-user": "installation/multi-user.html",
-  "#ch-nix-security": "installation/nix-security.html",
-  "#sec-obtaining-source": "installation/obtaining-source.html",
-  "#sec-prerequisites-source": "installation/prerequisites-source.html",
-  "#sec-single-user": "installation/single-user.html",
-  "#ch-supported-platforms": "installation/supported-platforms.html",
-  "#ch-upgrading-nix": "installation/upgrading.html",
-  "#ch-about-nix": "introduction.html",
-  "#chap-introduction": "introduction.html",
-  "#ch-basic-package-mgmt": "package-management/basic-package-mgmt.html",
-  "#ssec-binary-cache-substituter": "package-management/binary-cache-substituter.html",
-  "#sec-channels": "package-management/channels.html",
-  "#ssec-copy-closure": "package-management/copy-closure.html",
-  "#sec-garbage-collection": "package-management/garbage-collection.html",
-  "#ssec-gc-roots": "package-management/garbage-collector-roots.html",
-  "#chap-package-management": "package-management/package-management.html",
-  "#sec-profiles": "package-management/profiles.html",
-  "#ssec-s3-substituter": "package-management/s3-substituter.html",
-  "#ssec-s3-substituter-anonymous-reads": "package-management/s3-substituter.html#anonymous-reads-to-your-s3-compatible-binary-cache",
-  "#ssec-s3-substituter-authenticated-reads": "package-management/s3-substituter.html#authenticated-reads-to-your-s3-binary-cache",
-  "#ssec-s3-substituter-authenticated-writes": "package-management/s3-substituter.html#authenticated-writes-to-your-s3-compatible-binary-cache",
-  "#sec-sharing-packages": "package-management/sharing-packages.html",
-  "#ssec-ssh-substituter": "package-management/ssh-substituter.html",
-  "#chap-quick-start": "quick-start.html",
-  "#sec-relnotes": "release-notes/release-notes.html",
-  "#ch-relnotes-0.10.1": "release-notes/rl-0.10.1.html",
-  "#ch-relnotes-0.10": "release-notes/rl-0.10.html",
-  "#ssec-relnotes-0.11": "release-notes/rl-0.11.html",
-  "#ssec-relnotes-0.12": "release-notes/rl-0.12.html",
-  "#ssec-relnotes-0.13": "release-notes/rl-0.13.html",
-  "#ssec-relnotes-0.14": "release-notes/rl-0.14.html",
-  "#ssec-relnotes-0.15": "release-notes/rl-0.15.html",
-  "#ssec-relnotes-0.16": "release-notes/rl-0.16.html",
-  "#ch-relnotes-0.5": "release-notes/rl-0.5.html",
-  "#ch-relnotes-0.6": "release-notes/rl-0.6.html",
-  "#ch-relnotes-0.7": "release-notes/rl-0.7.html",
-  "#ch-relnotes-0.8.1": "release-notes/rl-0.8.1.html",
-  "#ch-relnotes-0.8": "release-notes/rl-0.8.html",
-  "#ch-relnotes-0.9.1": "release-notes/rl-0.9.1.html",
-  "#ch-relnotes-0.9.2": "release-notes/rl-0.9.2.html",
-  "#ch-relnotes-0.9": "release-notes/rl-0.9.html",
-  "#ssec-relnotes-1.0": "release-notes/rl-1.0.html",
-  "#ssec-relnotes-1.1": "release-notes/rl-1.1.html",
-  "#ssec-relnotes-1.10": "release-notes/rl-1.10.html",
-  "#ssec-relnotes-1.11.10": "release-notes/rl-1.11.10.html",
-  "#ssec-relnotes-1.11": "release-notes/rl-1.11.html",
-  "#ssec-relnotes-1.2": "release-notes/rl-1.2.html",
-  "#ssec-relnotes-1.3": "release-notes/rl-1.3.html",
-  "#ssec-relnotes-1.4": "release-notes/rl-1.4.html",
-  "#ssec-relnotes-1.5.1": "release-notes/rl-1.5.1.html",
-  "#ssec-relnotes-1.5.2": "release-notes/rl-1.5.2.html",
-  "#ssec-relnotes-1.5": "release-notes/rl-1.5.html",
-  "#ssec-relnotes-1.6.1": "release-notes/rl-1.6.1.html",
-  "#ssec-relnotes-1.6.0": "release-notes/rl-1.6.html",
-  "#ssec-relnotes-1.7": "release-notes/rl-1.7.html",
-  "#ssec-relnotes-1.8": "release-notes/rl-1.8.html",
-  "#ssec-relnotes-1.9": "release-notes/rl-1.9.html",
-  "#ssec-relnotes-2.0": "release-notes/rl-2.0.html",
-  "#ssec-relnotes-2.1": "release-notes/rl-2.1.html",
-  "#ssec-relnotes-2.2": "release-notes/rl-2.2.html",
-  "#ssec-relnotes-2.3": "release-notes/rl-2.3.html"
-};
-
-var isRoot = (document.location.pathname.endsWith('/') || document.location.pathname.endsWith('/index.html')) && path_to_root === '';
-if (isRoot && redirects[document.location.hash]) {
-  document.location.href = path_to_root + redirects[document.location.hash];
-}

doc/manual/src/SUMMARY.md.in

@@ -71,9 +71,7 @@
   - [Hacking](contributing/hacking.md)
   - [CLI guideline](contributing/cli-guideline.md)
 - [Release Notes](release-notes/release-notes.md)
-  - [Release 2.9 (2022-05-30)](release-notes/rl-2.9.md)
-  - [Release 2.8 (2022-04-19)](release-notes/rl-2.8.md)
-  - [Release 2.7 (2022-03-07)](release-notes/rl-2.7.md)
+  - [Release X.Y (202?-??-??)](release-notes/rl-next.md)
   - [Release 2.6 (2022-01-24)](release-notes/rl-2.6.md)
   - [Release 2.5 (2021-12-13)](release-notes/rl-2.5.md)
   - [Release 2.4 (2021-11-01)](release-notes/rl-2.4.md)

doc/manual/src/advanced-topics/diff-hook.md

@@ -101,7 +101,7 @@ In particular, notice the
 `/nix/store/krpqk0l9ib0ibi1d2w52z293zw455cap-unstable.check` output. Nix
 has copied the build results to that directory where you can examine it.
 
-> []{#check-dirs-are-unregistered} **Note**
+> **Note**
 > 
 > Check paths are not protected against garbage collection, and this
 > path will be deleted on the next garbage collection.

doc/manual/src/advanced-topics/distributed-builds.md

@@ -110,7 +110,7 @@ default, set it to `-`.
 7.  A comma-separated list of *mandatory features*. A machine will only
     be used to build a derivation if all of the machine’s mandatory
     features appear in the derivation’s `requiredSystemFeatures`
-    attribute.
+    attribute..
 
 8.  The (base64-encoded) public host key of the remote machine. If omitted, SSH
     will use its regular known-hosts file. Specifically, the field is calculated

doc/manual/src/command-ref/env-common.md

@@ -2,11 +2,11 @@
 
 Most Nix commands interpret the following environment variables:
 
-  - [`IN_NIX_SHELL`]{#env-IN_NIX_SHELL}\
+  - `IN_NIX_SHELL`\
     Indicator that tells if the current environment was set up by
-    `nix-shell`. It can have the values `pure` or `impure`.
+    `nix-shell`. Since Nix 2.0 the values are `"pure"` and `"impure"`
 
-  - [`NIX_PATH`]{#env-NIX_PATH}\
+  - `NIX_PATH`\
     A colon-separated list of directories used to look up Nix
     expressions enclosed in angle brackets (i.e., `<path>`). For
     instance, the value
@@ -44,7 +44,7 @@ Most Nix commands interpret the following environment variables:
     The Nix search path can also be extended using the `-I` option to
     many Nix commands, which takes precedence over `NIX_PATH`.
 
-  - [`NIX_IGNORE_SYMLINK_STORE`]{#env-NIX_IGNORE_SYMLINK_STORE}\
+  - `NIX_IGNORE_SYMLINK_STORE`\
     Normally, the Nix store directory (typically `/nix/store`) is not
     allowed to contain any symlink components. This is to prevent
     “impure” builds. Builders sometimes “canonicalise” paths by
@@ -66,41 +66,41 @@ Most Nix commands interpret the following environment variables:
 
     Consult the mount 8 manual page for details.
 
-  - [`NIX_STORE_DIR`]{#env-NIX_STORE_DIR}\
+  - `NIX_STORE_DIR`\
     Overrides the location of the Nix store (default `prefix/store`).
 
-  - [`NIX_DATA_DIR`]{#env-NIX_DATA_DIR}\
+  - `NIX_DATA_DIR`\
     Overrides the location of the Nix static data directory (default
     `prefix/share`).
 
-  - [`NIX_LOG_DIR`]{#env-NIX_LOG_DIR}\
+  - `NIX_LOG_DIR`\
     Overrides the location of the Nix log directory (default
     `prefix/var/log/nix`).
 
-  - [`NIX_STATE_DIR`]{#env-NIX_STATE_DIR}\
+  - `NIX_STATE_DIR`\
     Overrides the location of the Nix state directory (default
     `prefix/var/nix`).
 
-  - [`NIX_CONF_DIR`]{#env-NIX_CONF_DIR}\
+  - `NIX_CONF_DIR`\
     Overrides the location of the system Nix configuration directory
     (default `prefix/etc/nix`).
 
-  - [`NIX_CONFIG`]{#env-NIX_CONFIG}\
+  - `NIX_CONFIG`\
     Applies settings from Nix configuration from the environment.
     The content is treated as if it was read from a Nix configuration file.
     Settings are separated by the newline character.
 
-  - [`NIX_USER_CONF_FILES`]{#env-NIX_USER_CONF_FILES}\
+  - `NIX_USER_CONF_FILES`\
     Overrides the location of the user Nix configuration files to load
     from (defaults to the XDG spec locations). The variable is treated
     as a list separated by the `:` token.
 
-  - [`TMPDIR`]{#env-TMPDIR}\
+  - `TMPDIR`\
     Use the specified directory to store temporary files. In particular,
     this includes temporary build directories; these can take up
     substantial amounts of disk space. The default is `/tmp`.
 
-  - [`NIX_REMOTE`]{#env-NIX_REMOTE}\
+  - `NIX_REMOTE`\
     This variable should be set to `daemon` if you want to use the Nix
     daemon to execute Nix operations. This is necessary in [multi-user
     Nix installations](../installation/multi-user.md). If the Nix
@@ -108,16 +108,16 @@ Most Nix commands interpret the following environment variables:
     should be set to `unix://path/to/socket`. Otherwise, it should be
     left unset.
 
-  - [`NIX_SHOW_STATS`]{#env-NIX_SHOW_STATS}\
+  - `NIX_SHOW_STATS`\
     If set to `1`, Nix will print some evaluation statistics, such as
     the number of values allocated.
 
-  - [`NIX_COUNT_CALLS`]{#env-NIX_COUNT_CALLS}\
+  - `NIX_COUNT_CALLS`\
     If set to `1`, Nix will print how often functions were called during
     Nix expression evaluation. This is useful for profiling your Nix
     expressions.
 
-  - [`GC_INITIAL_HEAP_SIZE`]{#env-GC_INITIAL_HEAP_SIZE}\
+  - `GC_INITIAL_HEAP_SIZE`\
     If Nix has been configured to use the Boehm garbage collector, this
     variable sets the initial size of the heap in bytes. It defaults to
     384 MiB. Setting it to a low value reduces memory consumption, but

doc/manual/src/command-ref/nix-build.md

@@ -47,16 +47,16 @@ All options not listed here are passed to `nix-store
 --realise`, except for `--arg` and `--attr` / `-A` which are passed to
 `nix-instantiate`.
 
-  - [`--no-out-link`]{#opt-no-out-link}\
+  - `--no-out-link`\
     Do not create a symlink to the output path. Note that as a result
     the output does not become a root of the garbage collector, and so
     might be deleted by `nix-store
                     --gc`.
 
-  - [`--dry-run`]{#opt-dry-run}\
+  - `--dry-run`\
     Show what store paths would be built or downloaded.
 
-  - [`--out-link`]{#opt-out-link} / `-o` *outlink*\
+  - `--out-link` / `-o` *outlink*\
     Change the name of the symlink to the output path created from
     `result` to *outlink*.
 

doc/manual/src/command-ref/nix-store.md

@@ -22,7 +22,7 @@ This section lists the options that are common to all operations. These
 options are allowed for every subcommand, though they may not always
 have an effect.
 
-  - [`--add-root`]{#opt-add-root} *path*\
+  - `--add-root` *path*\
     Causes the result of a realisation (`--realise` and
     `--force-realise`) to be registered as a root of the garbage
     collector. *path* will be created as a symlink to the resulting

doc/manual/src/command-ref/opt-common.md

@@ -2,13 +2,13 @@
 
 Most Nix commands accept the following command-line options:
 
-  - [`--help`]{#opt-help}\
+  - `--help`\
     Prints out a summary of the command syntax and exits.
 
-  - [`--version`]{#opt-version}\
+  - `--version`\
     Prints out the Nix version number on standard output and exits.
 
-  - [`--verbose`]{#opt-verbose} / `-v`\
+  - `--verbose` / `-v`\
     Increases the level of verbosity of diagnostic messages printed on
     standard error. For each Nix operation, the information printed on
     standard output is well-defined; any diagnostic information is
@@ -37,14 +37,14 @@ Most Nix commands accept the following command-line options:
       - 5\
         “Vomit”: print vast amounts of debug information.
 
-  - [`--quiet`]{#opt-quiet}\
+  - `--quiet`\
     Decreases the level of verbosity of diagnostic messages printed on
     standard error. This is the inverse option to `-v` / `--verbose`.
 
     This option may be specified repeatedly. See the previous verbosity
     levels list.
 
-  - [`--log-format`]{#opt-log-format} *format*\
+  - `--log-format` *format*\
     This option can be used to change the output of the log format, with
     *format* being one of:
 
@@ -66,14 +66,14 @@ Most Nix commands accept the following command-line options:
       - bar-with-logs\
         Display the raw logs, with the progress bar at the bottom.
 
-  - [`--no-build-output`]{#opt-no-build-output} / `-Q`\
+  - `--no-build-output` / `-Q`\
     By default, output written by builders to standard output and
     standard error is echoed to the Nix command's standard error. This
     option suppresses this behaviour. Note that the builder's standard
     output and error are always written to a log file in
     `prefix/nix/var/log/nix`.
 
-  - [`--max-jobs`]{#opt-max-jobs} / `-j` *number*\
+  - `--max-jobs` / `-j` *number*\
     Sets the maximum number of build jobs that Nix will perform in
     parallel to the specified number. Specify `auto` to use the number
     of CPUs in the system. The default is specified by the `max-jobs`
@@ -83,7 +83,7 @@ Most Nix commands accept the following command-line options:
     Setting it to `0` disallows building on the local machine, which is
     useful when you want builds to happen only on remote builders.
 
-  - [`--cores`]{#opt-cores}\
+  - `--cores`\
     Sets the value of the `NIX_BUILD_CORES` environment variable in
     the invocation of builders. Builders can use this variable at
     their discretion to control the maximum amount of parallelism. For
@@ -94,18 +94,18 @@ Most Nix commands accept the following command-line options:
     means that the builder should use all available CPU cores in the
     system.
 
-  - [`--max-silent-time`]{#opt-max-silent-time}\
+  - `--max-silent-time`\
     Sets the maximum number of seconds that a builder can go without
     producing any data on standard output or standard error. The
     default is specified by the `max-silent-time` configuration
     setting. `0` means no time-out.
 
-  - [`--timeout`]{#opt-timeout}\
+  - `--timeout`\
     Sets the maximum number of seconds that a builder can run. The
     default is specified by the `timeout` configuration setting. `0`
     means no timeout.
 
-  - [`--keep-going`]{#opt-keep-going} / `-k`\
+  - `--keep-going` / `-k`\
     Keep going in case of failed builds, to the greatest extent
     possible. That is, if building an input of some derivation fails,
     Nix will still build the other inputs, but not the derivation
@@ -113,13 +113,13 @@ Most Nix commands accept the following command-line options:
     for builds of substitutes), possibly killing builds in progress (in
     case of parallel or distributed builds).
 
-  - [`--keep-failed`]{#opt-keep-failed} / `-K`\
+  - `--keep-failed` / `-K`\
     Specifies that in case of a build failure, the temporary directory
     (usually in `/tmp`) in which the build takes place should not be
     deleted. The path of the build directory is printed as an
     informational message.
 
-  - [`--fallback`]{#opt-fallback}\
+  - `--fallback`\
     Whenever Nix attempts to build a derivation for which substitutes
     are known for each output path, but realising the output paths
     through the substitutes fails, fall back on building the derivation.
@@ -134,12 +134,12 @@ Most Nix commands accept the following command-line options:
     failure in obtaining the substitutes to lead to a full build from
     source (with the related consumption of resources).
 
-  - [`--readonly-mode`]{#opt-readonly-mode}\
+  - `--readonly-mode`\
     When this option is used, no attempt is made to open the Nix
     database. Most Nix operations do need database access, so those
     operations will fail.
 
-  - [`--arg`]{#opt-arg} *name* *value*\
+  - `--arg` *name* *value*\
     This option is accepted by `nix-env`, `nix-instantiate`,
     `nix-shell` and `nix-build`. When evaluating Nix expressions, the
     expression evaluator will automatically try to call functions that
@@ -170,13 +170,13 @@ Most Nix commands accept the following command-line options:
     since the argument is a Nix string literal, you have to escape the
     quotes.)
 
-  - [`--argstr`]{#opt-argstr} *name* *value*\
+  - `--argstr` *name* *value*\
     This option is like `--arg`, only the value is not a Nix
     expression but a string. So instead of `--arg system
     \"i686-linux\"` (the outer quotes are to keep the shell happy) you
     can say `--argstr system i686-linux`.
 
-  - [`--attr`]{#opt-attr} / `-A` *attrPath*\
+  - `--attr` / `-A` *attrPath*\
     Select an attribute from the top-level Nix expression being
     evaluated. (`nix-env`, `nix-instantiate`, `nix-build` and
     `nix-shell` only.) The *attribute path* *attrPath* is a sequence
@@ -191,7 +191,7 @@ Most Nix commands accept the following command-line options:
     attribute of the fourth element of the array in the `foo` attribute
     of the top-level expression.
 
-  - [`--expr`]{#opt-expr} / `-E`\
+  - `--expr` / `-E`\
     Interpret the command line arguments as a list of Nix expressions to
     be parsed and evaluated, rather than as a list of file names of Nix
     expressions. (`nix-instantiate`, `nix-build` and `nix-shell` only.)
@@ -202,17 +202,17 @@ Most Nix commands accept the following command-line options:
     use, give your expression to the `nix-shell -p` convenience flag
     instead.
 
-  - [`-I`]{#opt-I} *path*\
+  - `-I` *path*\
     Add a path to the Nix expression search path. This option may be
     given multiple times. See the `NIX_PATH` environment variable for
     information on the semantics of the Nix search path. Paths added
     through `-I` take precedence over `NIX_PATH`.
 
-  - [`--option`]{#opt-option} *name* *value*\
+  - `--option` *name* *value*\
     Set the Nix configuration option *name* to *value*. This overrides
     settings in the Nix configuration file (see nix.conf5).
 
-  - [`--repair`]{#opt-repair}\
+  - `--repair`\
     Fix corrupted or missing store paths by redownloading or rebuilding
     them. Note that this is slow because it requires computing a
     cryptographic hash of the contents of every path in the closure of

doc/manual/src/contributing/hacking.md

@@ -71,6 +71,18 @@ To install it in `$(pwd)/outputs` and test it:
 nix (Nix) 3.0
 ```
 
+To run a functional test:
+
+```console
+make tests/test-name-should-auto-complete.sh.test
+```
+
+To run the unit-tests for C++ code:
+
+```
+make check
+```
+
 If you have a flakes-enabled Nix you can replace:
 
 ```console
@@ -82,29 +94,3 @@ by:
 ```console
 $ nix develop
 ```
-
-## Testing
-
-Nix comes with three different flavors of tests: unit, functional and integration.
-
-### Unit-tests
-
-The unit-tests for each Nix library (`libexpr`, `libstore`, etc..) are defined
-under `src/{library_name}/tests` using the
-[googletest](https://google.github.io/googletest/) framework.
-
-You can run the whole testsuite with `make check`, or the tests for a specific component with `make libfoo-tests_RUN`. Finer-grained filtering is also possible using the [--gtest_filter](https://google.github.io/googletest/advanced.html#running-a-subset-of-the-tests) command-line option.
-
-### Functional tests
-
-The functional tests reside under the `tests` directory and are listed in `tests/local.mk`.
-The whole testsuite can be run with `make install && make installcheck`.
-Individual tests can be run with `make tests/{testName}.sh.test`.
-
-### Integration tests
-
-The integration tests are defined in the Nix flake under the `hydraJobs.tests` attribute.
-These tests include everything that needs to interact with external services or run Nix in a non-trivial distributed setup.
-Because these tests are expensive and require more than what the standard github-actions setup provides, they only run on the master branch (on <https://hydra.nixos.org/jobset/nix/master>).
-
-You can run them manually with `nix build .#hydraJobs.tests.{testName}` or `nix-build -A hydraJobs.tests.{testName}`

doc/manual/src/expressions/advanced-attributes.md

@@ -2,7 +2,7 @@
 
 Derivations can declare some infrequently used optional attributes.
 
-  - [`allowedReferences`]{#adv-attr-allowedReferences}\
+  - `allowedReferences`\
     The optional attribute `allowedReferences` specifies a list of legal
     references (dependencies) of the output of the builder. For example,
 
@@ -17,7 +17,7 @@ Derivations can declare some infrequently used optional attributes.
     booting Linux don’t have accidental dependencies on other paths in
     the Nix store.
 
-  - [`allowedRequisites`]{#adv-attr-allowedRequisites}\
+  - `allowedRequisites`\
     This attribute is similar to `allowedReferences`, but it specifies
     the legal requisites of the whole closure, so all the dependencies
     recursively. For example,
@@ -30,7 +30,7 @@ Derivations can declare some infrequently used optional attributes.
     runtime dependency than `foobar`, and in addition it enforces that
     `foobar` itself doesn't introduce any other dependency itself.
 
-  - [`disallowedReferences`]{#adv-attr-disallowedReferences}\
+  - `disallowedReferences`\
     The optional attribute `disallowedReferences` specifies a list of
     illegal references (dependencies) of the output of the builder. For
     example,
@@ -42,7 +42,7 @@ Derivations can declare some infrequently used optional attributes.
     enforces that the output of a derivation cannot have a direct
     runtime dependencies on the derivation `foo`.
 
-  - [`disallowedRequisites`]{#adv-attr-disallowedRequisites}\
+  - `disallowedRequisites`\
     This attribute is similar to `disallowedReferences`, but it
     specifies illegal requisites for the whole closure, so all the
     dependencies recursively. For example,
@@ -55,7 +55,7 @@ Derivations can declare some infrequently used optional attributes.
     dependency on `foobar` or any other derivation depending recursively
     on `foobar`.
 
-  - [`exportReferencesGraph`]{#adv-attr-exportReferencesGraph}\
+  - `exportReferencesGraph`\
     This attribute allows builders access to the references graph of
     their inputs. The attribute is a list of inputs in the Nix store
     whose references graph the builder needs to know. The value of
@@ -84,7 +84,7 @@ Derivations can declare some infrequently used optional attributes.
     with a Nix store containing the closure of a bootable NixOS
     configuration).
 
-  - [`impureEnvVars`]{#adv-attr-impureEnvVars}\
+  - `impureEnvVars`\
     This attribute allows you to specify a list of environment variables
     that should be passed from the environment of the calling user to
     the builder. Usually, the environment is cleared completely when the
@@ -112,7 +112,7 @@ Derivations can declare some infrequently used optional attributes.
     > environmental variables come from the environment of the
     > `nix-build`.
 
-  - [`outputHash`]{#adv-attr-outputHash}; [`outputHashAlgo`]{#adv-attr-outputHashAlgo}; [`outputHashMode`]{#adv-attr-outputHashMode}\
+  - `outputHash`; `outputHashAlgo`; `outputHashMode`\
     These attributes declare that the derivation is a so-called
     *fixed-output derivation*, which means that a cryptographic hash of
     the output is already known in advance. When the build of a
@@ -208,7 +208,7 @@ Derivations can declare some infrequently used optional attributes.
     [`nix-hash` command](../command-ref/nix-hash.md) for information
     about converting to and from base-32 notation.)
     
-  - [`__contentAddressed`]{#adv-attr-__contentAddressed}
+  - `__contentAddressed`
     If this **experimental** attribute is set to true, then the derivation
     outputs will be stored in a content-addressed location rather than the
     traditional input-addressed one.
@@ -216,7 +216,7 @@ Derivations can declare some infrequently used optional attributes.
     
     Setting this attribute also requires setting `outputHashMode` and `outputHashAlgo` like for *fixed-output derivations* (see above).
 
-  - [`passAsFile`]{#adv-attr-passAsFile}\
+  - `passAsFile`\
     A list of names of attributes that should be passed via files rather
     than environment variables. For example, if you have
 
@@ -234,7 +234,7 @@ Derivations can declare some infrequently used optional attributes.
     builder, since most operating systems impose a limit on the size
     of the environment (typically, a few hundred kilobyte).
 
-  - [`preferLocalBuild`]{#adv-attr-preferLocalBuild}\
+  - `preferLocalBuild`\
     If this attribute is set to `true` and [distributed building is
     enabled](../advanced-topics/distributed-builds.md), then, if
     possible, the derivation will be built locally instead of forwarded
@@ -242,7 +242,7 @@ Derivations can declare some infrequently used optional attributes.
     where the cost of doing a download or remote build would exceed
     the cost of building locally.
 
-  - [`allowSubstitutes`]{#adv-attr-allowSubstitutes}\
+  - `allowSubstitutes`\
     If this attribute is set to `false`, then Nix will always build this
     derivation; it will not try to substitute its outputs. This is
     useful for very trivial derivations (such as `writeText` in Nixpkgs)

doc/manual/src/expressions/builtin-constants.md

@@ -14,7 +14,7 @@ Here are the constants built into the Nix expression evaluator:
     This allows a Nix expression to fall back gracefully on older Nix
     installations that don’t have the desired built-in function.
 
-  - [`builtins.currentSystem`]{#builtins-currentSystem}\
+  - `builtins.currentSystem`\
     The built-in value `currentSystem` evaluates to the Nix platform
     identifier for the Nix installation on which the expression is being
     evaluated, such as `"i686-linux"` or `"x86_64-darwin"`.

doc/manual/src/expressions/derivations.md

@@ -4,7 +4,7 @@ The most important built-in function is `derivation`, which is used to
 describe a single derivation (a build action). It takes as input a set,
 the attributes of which specify the inputs of the build.
 
-  - There must be an attribute named [`system`]{#attr-system} whose value must be a
+  - There must be an attribute named `system` whose value must be a
     string specifying a Nix system type, such as `"i686-linux"` or
     `"x86_64-darwin"`. (To figure out your system type, run `nix -vv
     --version`.) The build can only be performed on a machine and

doc/manual/src/glossary.md

@@ -1,48 +1,48 @@
 # Glossary
 
-  - [derivation]{#gloss-derivation}\
+  - derivation\
     A description of a build action. The result of a derivation is a
     store object. Derivations are typically specified in Nix expressions
     using the [`derivation` primitive](expressions/derivations.md). These are
     translated into low-level *store derivations* (implicitly by
     `nix-env` and `nix-build`, or explicitly by `nix-instantiate`).
 
-  - [store]{#gloss-store}\
+  - store\
     The location in the file system where store objects live. Typically
     `/nix/store`.
 
-  - [store path]{#gloss-store-path}\
+  - store path\
     The location in the file system of a store object, i.e., an
     immediate child of the Nix store directory.
 
-  - [store object]{#gloss-store-object}\
+  - store object\
     A file that is an immediate child of the Nix store directory. These
     can be regular files, but also entire directory trees. Store objects
     can be sources (objects copied from outside of the store),
     derivation outputs (objects produced by running a build action), or
     derivations (files describing a build action).
 
-  - [substitute]{#gloss-substitute}\
+  - substitute\
     A substitute is a command invocation stored in the Nix database that
     describes how to build a store object, bypassing the normal build
     mechanism (i.e., derivations). Typically, the substitute builds the
     store object by downloading a pre-built version of the store object
     from some server.
 
-  - [purity]{#gloss-purity}\
+  - purity\
     The assumption that equal Nix derivations when run always produce
     the same output. This cannot be guaranteed in general (e.g., a
     builder can rely on external inputs such as the network or the
     system time) but the Nix model assumes it.
 
-  - [Nix expression]{#gloss-nix-expression}\
+  - Nix expression\
     A high-level description of software packages and compositions
     thereof. Deploying software using Nix entails writing Nix
     expressions for your packages. Nix expressions are translated to
     derivations that are stored in the Nix store. These derivations can
     then be built.
 
-  - [reference]{#gloss-reference}\
+  - reference\
     A store path `P` is said to have a reference to a store path `Q` if
     the store object at `P` contains the path `Q` somewhere. The
     *references* of a store path are the set of store paths to which it
@@ -52,11 +52,11 @@
     output paths), whereas an output path only references other output
     paths.
 
-  - [reachable]{#gloss-reachable}\
+  - reachable\
     A store path `Q` is reachable from another store path `P` if `Q`
     is in the *closure* of the *references* relation.
 
-  - [closure]{#gloss-closure}\
+  - closure\
     The closure of a store path is the set of store paths that are
     directly or indirectly “reachable” from that store path; that is,
     it’s the closure of the path under the *references* relation. For
@@ -71,34 +71,34 @@
     to path `Q`, then `Q` is in the closure of `P`. Further, if `Q`
     references `R` then `R` is also in the closure of `P`.
 
-  - [output path]{#gloss-output-path}\
+  - output path\
     A store path produced by a derivation.
 
-  - [deriver]{#gloss-deriver}\
+  - deriver\
     The deriver of an *output path* is the store
     derivation that built it.
 
-  - [validity]{#gloss-validity}\
+  - validity\
     A store path is considered *valid* if it exists in the file system,
     is listed in the Nix database as being valid, and if all paths in
     its closure are also valid.
 
-  - [user environment]{#gloss-user-env}\
+  - user environment\
     An automatically generated store object that consists of a set of
     symlinks to “active” applications, i.e., other store paths. These
     are generated automatically by
     [`nix-env`](command-ref/nix-env.md). See *profiles*.
 
-  - [profile]{#gloss-profile}\
+  - profile\
     A symlink to the current *user environment* of a user, e.g.,
     `/nix/var/nix/profiles/default`.
 
-  - [NAR]{#gloss-nar}\
+  - NAR\
     A *N*ix *AR*chive. This is a serialisation of a path in the Nix
     store. It can contain regular files, directories and symbolic
     links.  NARs are generated and unpacked using `nix-store --dump`
     and `nix-store --restore`.
-  - [`∅`]{#gloss-emtpy-set}\
+  - `∅` \
     The empty set symbol. In the context of profile history, this denotes a package is not present in a particular version of the profile.
-  - [`ε`]{#gloss-epsilon}\
+  - `ε` \
     The epsilon symbol. In the context of a package, this means the version is empty. More precisely, the derivation does not have a version attribute.

doc/manual/src/installation/installing-binary.md

@@ -84,9 +84,7 @@ The installer will modify `/etc/bashrc`, and `/etc/zshrc` if they exist.
 The installer will first back up these files with a `.backup-before-nix`
 extension. The installer will also create `/etc/profile.d/nix.sh`.
 
-## Uninstalling
-
-### Linux
+You can uninstall Nix with the following commands:
 
 ```console
 sudo rm -rf /etc/profile/nix.sh /etc/nix /nix ~root/.nix-profile ~root/.nix-defexpr ~root/.nix-channels ~/.nix-profile ~/.nix-defexpr ~/.nix-channels
@@ -97,97 +95,16 @@ sudo systemctl stop nix-daemon.service
 sudo systemctl disable nix-daemon.socket
 sudo systemctl disable nix-daemon.service
 sudo systemctl daemon-reload
+
+# If you are on macOS, you will need to run:
+sudo launchctl unload /Library/LaunchDaemons/org.nixos.nix-daemon.plist
+sudo rm /Library/LaunchDaemons/org.nixos.nix-daemon.plist
 ```
 
 There may also be references to Nix in `/etc/profile`, `/etc/bashrc`,
 and `/etc/zshrc` which you may remove.
 
-### macOS
-
-1. Edit `/etc/zshrc` and `/etc/bashrc` to remove the lines sourcing
-   `nix-daemon.sh`, which should look like this:
-
-   ```bash
-   # Nix
-   if [ -e '/nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh' ]; then
-     . '/nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh'
-   fi
-   # End Nix
-   ```
-
-   If these files haven't been altered since installing Nix you can simply put
-   the backups back in place:
-
-   ```console
-   sudo mv /etc/zshrc.backup-before-nix /etc/zshrc
-   sudo mv /etc/bashrc.backup-before-nix /etc/bashrc
-   ```
-
-   This will stop shells from sourcing the file and bringing everything you
-   installed using Nix in scope.
-
-2. Stop and remove the Nix daemon services:
-
-   ```console
-   sudo launchctl unload /Library/LaunchDaemons/org.nixos.nix-daemon.plist
-   sudo rm /Library/LaunchDaemons/org.nixos.nix-daemon.plist
-   sudo launchctl unload /Library/LaunchDaemons/org.nixos.darwin-store.plist
-   sudo rm /Library/LaunchDaemons/org.nixos.darwin-store.plist
-   ```
-
-   This stops the Nix daemon and prevents it from being started next time you
-   boot the system.
-
-3. Remove the `nixbld` group and the `_nixbuildN` users:
-
-   ```console
-   sudo dscl . -delete /Groups/nixbld
-   for u in $(sudo dscl . -list /Users | grep _nixbld); do sudo dscl . -delete /Users/$u; done
-   ```
-
-   This will remove all the build users that no longer serve a purpose.
-
-4. Edit fstab using `sudo vifs` to remove the line mounting the Nix Store
-   volume on `/nix`, which looks like this,
-   `LABEL=Nix\040Store /nix apfs rw,nobrowse`. This will prevent automatic
-   mounting of the Nix Store volume.
-
-5. Edit `/etc/synthetic.conf` to remove the `nix` line. If this is the only
-   line in the file you can remove it entirely, `sudo rm /etc/synthetic.conf`.
-   This will prevent the creation of the empty `/nix` directory to provide a
-   mountpoint for the Nix Store volume.
-
-6. Remove the files Nix added to your system:
-
-   ```console
-   sudo rm -rf /etc/nix /var/root/.nix-profile /var/root/.nix-defexpr /var/root/.nix-channels ~/.nix-profile ~/.nix-defexpr ~/.nix-channels
-   ```
-
-   This gets rid of any data Nix may have created except for the store which is
-   removed next.
-
-7. Remove the Nix Store volume:
-   
-   ```console
-   sudo diskutil apfs deleteVolume /nix
-   ```
-
-   This will remove the Nix Store volume and everything that was added to the
-   store.
-
-> **Note**
-> 
-> After you complete the steps here, you will still have an empty `/nix`
-> directory. This is an expected sign of a successful uninstall. The empty
-> `/nix` directory will disappear the next time you reboot.
->
-> You do not have to reboot to finish uninstalling Nix. The uninstall is
-> complete. macOS (Catalina+) directly controls root directories and its
-> read-only root will prevent you from manually deleting the empty `/nix`
-> mountpoint.
-
-# macOS Installation
-[]{#sect-macos-installation-change-store-prefix}[]{#sect-macos-installation-encrypted-volume}[]{#sect-macos-installation-symlink}[]{#sect-macos-installation-recommended-notes}
+# macOS Installation <a name="sect-macos-installation-change-store-prefix"></a><a name="sect-macos-installation-encrypted-volume"></a><a name="sect-macos-installation-symlink"></a><a name="sect-macos-installation-recommended-notes"></a>
 <!-- Note: anchors above to catch permalinks to old explanations -->
 
 We believe we have ironed out how to cleanly support the read-only root

doc/manual/src/release-notes/rl-2.7.md

@@ -1,33 +0,0 @@
-# Release 2.7 (2022-03-07)
-
-* Nix will now make some helpful suggestions when you mistype
-  something on the command line. For instance, if you type `nix build
-  nixpkgs#thunderbrd`, it will suggest `thunderbird`.
-
-* A number of "default" flake output attributes have been
-  renamed. These are:
-
-  * `defaultPackage.<system>` → `packages.<system>.default`
-  * `defaultApps.<system>` → `apps.<system>.default`
-  * `defaultTemplate` → `templates.default`
-  * `defaultBundler.<system>` → `bundlers.<system>.default`
-  * `overlay` → `overlays.default`
-  * `devShell.<system>` → `devShells.<system>.default`
-
-  The old flake output attributes still work, but `nix flake check`
-  will warn about them.
-
-* Breaking API change: `nix bundle` now supports bundlers of the form
-  `bundler.<system>.<name>= derivation: another-derivation;`. This
-  supports additional functionality to inspect evaluation information
-  during bundling. A new
-  [repository](https://github.com/NixOS/bundlers) has various bundlers
-  implemented.
-
-* `nix store ping` now reports the version of the remote Nix daemon.
-
-* `nix flake {init,new}` now display information about which files have been
-  created.
-
-* Templates can now define a `welcomeText` attribute, which is printed out by
-  `nix flake {init,new} --template <template>`.

doc/manual/src/release-notes/rl-2.8.md

@@ -1,53 +0,0 @@
-# Release 2.8 (2022-04-19)
-
-* New experimental command: `nix fmt`, which applies a formatter
-  defined by the `formatter.<system>` flake output to the Nix
-  expressions in a flake.
-
-* Various Nix commands can now read expressions from standard input
-  using `--file -`.
-
-* New experimental builtin function `builtins.fetchClosure` that
-  copies a closure from a binary cache at evaluation time and rewrites
-  it to content-addressed form (if it isn't already). Like
-  `builtins.storePath`, this allows importing pre-built store paths;
-  the difference is that it doesn't require the user to configure
-  binary caches and trusted public keys.
-
-  This function is only available if you enable the experimental
-  feature `fetch-closure`.
-
-* New experimental feature: *impure derivations*. These are
-  derivations that can produce a different result every time they're
-  built. Here is an example:
-
-  ```nix
-  stdenv.mkDerivation {
-    name = "impure";
-    __impure = true; # marks this derivation as impure
-    buildCommand = "date > $out";
-  }
-  ```
-
-  Running `nix build` twice on this expression will build the
-  derivation twice, producing two different content-addressed store
-  paths. Like fixed-output derivations, impure derivations have access
-  to the network. Only fixed-output derivations and impure derivations
-  can depend on an impure derivation.
-
-* `nix store make-content-addressable` has been renamed to `nix store
-  make-content-addressed`.
-
-* The `nixosModule` flake output attribute has been renamed consistent
-  with the `.default` renames in Nix 2.7.
-
-  * `nixosModule` → `nixosModules.default`
-
-  As before, the old output will continue to work, but `nix flake check` will
-  issue a warning about it.
-
-* `nix run` is now stricter in what it accepts: members of the `apps`
-  flake output are now required to be apps (as defined in [the
-  manual](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-run.html#apps)),
-  and members of `packages` or `legacyPackages` must be derivations
-  (not apps).

doc/manual/src/release-notes/rl-2.9.md

@@ -1,47 +0,0 @@
-# Release 2.9 (2022-05-30)
-
-* Running Nix with the new `--debugger` flag will cause it to start a
-  repl session if if an exception is thrown during evaluation, or if
-  `builtins.break` is called.  From there you can inspect the values
-  of variables and evaluate Nix expressions.  In debug mode, the
-  following new repl commands are available:
-
-  ```
-  :env          Show env stack
-  :bt           Show trace stack
-  :st           Show current trace
-  :st <idx>     Change to another trace in the stack
-  :c            Go until end of program, exception, or builtins.break().
-  :s            Go one step
-  ```
-
-  Read more about the debugger
-  [here](https://www.zknotes.com/note/5970).
-
-* Nix now provides better integration with zsh's `run-help`
-  feature. It is now included in the Nix installation in the form of
-  an autoloadable shell function, `run-help-nix`. It picks up Nix
-  subcommands from the currently typed in command and directs the user
-  to the associated man pages.
-
-* `nix repl` has a new build-and-link (`:bl`) command that builds a
-  derivation while creating GC root symlinks.
-
-* The path produced by `builtins.toFile` is now allowed to be imported
-  or read even with restricted evaluation. Note that this will not
-  work with a read-only store.
-
-* `nix build` has a new `--print-out-paths` flag to print the
-  resulting output paths.  This matches the default behaviour of
-  `nix-build`.
-
-* You can now specify which outputs of a derivation `nix` should
-  operate on using the syntax `installable^outputs`,
-  e.g. `nixpkgs#glibc^dev,static` or `nixpkgs#glibc^*`. By default,
-  `nix` will use the outputs specified by the derivation's
-  `meta.outputsToInstall` attribute if it exists, or all outputs
-  otherwise.
-
-* `builtins.fetchTree` (and flake inputs) can now be used to fetch
-  plain files over the `http(s)` and `file` protocols in addition to
-  directory tarballs.

doc/manual/src/release-notes/rl-next.md

@@ -1 +1,15 @@
 # Release X.Y (202?-??-??)
+
+* `nix bundle` breaking API change now supports bundlers of the form
+  `bundler.<system>.<name>= derivation: another-derivation;`. This supports
+  additional functionality to inspect evaluation information during bundling. A
+  new [repository](https://github.com/NixOS/bundlers) has various bundlers
+  implemented.
+
+* `nix store ping` now reports the version of the remote Nix daemon.
+
+* `nix flake {init,new}` now display information about which files have been
+  created.
+
+* Templates can now define a `welcomeText` attribute, which is printed out by
+  `nix flake {init,new} --template <template>`.

docker.nix

@@ -22,7 +22,6 @@ let
     findutils
     iana-etc
     git
-    openssh
   ];
 
   users = {

flake.lock

@@ -18,11 +18,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1645296114,
-        "narHash": "sha256-y53N7TyIkXsjMpOG7RhvqJFGDacLs9HlyHeSTBioqYU=",
+        "lastModified": 1632864508,
+        "narHash": "sha256-d127FIvGR41XbVRDPVvozUPQ/uRHbHwvfyKHwEt5xFM=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "530a53dcbc9437363471167a5e4762c5fcfa34a1",
+        "rev": "82891b5e2c2359d7e58d08849e4c89511ab94234",
         "type": "github"
       },
       "original": {

flake.nix

@@ -15,7 +15,7 @@
         then ""
         else "pre${builtins.substring 0 8 (self.lastModifiedDate or self.lastModified or "19700101")}_${self.shortRev or "dirty"}";
 
-      officialRelease = true;
+      officialRelease = false;
 
       linux64BitSystems = [ "x86_64-linux" "aarch64-linux" ];
       linuxSystems = linux64BitSystems ++ [ "i686-linux" ];
@@ -23,7 +23,7 @@
 
       crossSystems = [ "armv6l-linux" "armv7l-linux" ];
 
-      stdenvs = [ "gccStdenv" "clangStdenv" "clang11Stdenv" "stdenv" "libcxxStdenv" ];
+      stdenvs = [ "gccStdenv" "clangStdenv" "clang11Stdenv" "stdenv" ];
 
       forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f system);
       forAllSystemsAndStdenvs = f: forAllSystems (system:
@@ -102,7 +102,7 @@
             # Tests
             buildPackages.git
             buildPackages.mercurial # FIXME: remove? only needed for tests
-            buildPackages.jq # Also for custom mdBook preprocessor.
+            buildPackages.jq
           ]
           ++ lib.optionals stdenv.hostPlatform.isLinux [(buildPackages.util-linuxMinimal or buildPackages.utillinuxMinimal)];
 
@@ -135,6 +135,11 @@
             }))
             nlohmann_json
           ];
+
+        perlDeps =
+          [ perl
+            perlPackages.DBDSQLite
+          ];
       };
 
       installScriptFor = systems:
@@ -348,7 +353,7 @@
 
             strictDeps = true;
 
-            passthru.perl-bindings = with final; perl.pkgs.toPerlModule (currentStdenv.mkDerivation {
+            passthru.perl-bindings = with final; currentStdenv.mkDerivation {
               name = "nix-perl-${version}";
 
               src = self;
@@ -378,9 +383,8 @@
               enableParallelBuilding = true;
 
               postUnpack = "sourceRoot=$sourceRoot/perl";
-            });
+            };
 
-            meta.platforms = systems;
           };
 
           lowdown-nix = with final; currentStdenv.mkDerivation rec {
@@ -529,26 +533,28 @@
           nixpkgs = nixpkgs-regression;
         };
 
-        installTests = forAllSystems (system:
+        installTestsAgainstSelf = forAllSystems (system:
           let pkgs = nixpkgsFor.${system}; in
-          pkgs.runCommand "install-tests" {
-            againstSelf = testNixVersions pkgs pkgs.nix pkgs.pkgs.nix;
-            againstCurrentUnstable =
-              # FIXME: temporarily disable this on macOS because of #3605.
-              if system == "x86_64-linux"
-              then testNixVersions pkgs pkgs.nix pkgs.nixUnstable
-              else null;
-            # Disabled because the latest stable version doesn't handle
-            # `NIX_DAEMON_SOCKET_PATH` which is required for the tests to work
-            # againstLatestStable = testNixVersions pkgs pkgs.nix pkgs.nixStable;
-          } "touch $out");
+          testNixVersions pkgs pkgs.nix pkgs.pkgs.nix
+        );
+        installTestsAgainstCurrentUnstable = forAllSystems (system:
+          let pkgs = nixpkgsFor.${system}; in
+          # FIXME: temporarily disable this on macOS because of #3605.
+          if system == "x86_64-linux"
+          then testNixVersions pkgs pkgs.nix pkgs.nixUnstable
+          else pkgs.writeText "dummy" "dummy"
+        );
+        # Disabled because the latest stable version doesn't handle
+        # `NIX_DAEMON_SOCKET_PATH` which is required for the tests to work
+        # againstLatestStable = testNixVersions pkgs pkgs.nix pkgs.nixStable;
 
       };
 
       checks = forAllSystems (system: {
         binaryTarball = self.hydraJobs.binaryTarball.${system};
         perlBindings = self.hydraJobs.perlBindings.${system};
-        installTests = self.hydraJobs.installTests.${system};
+        installTestsAgainstCurrentUnstable = self.hydraJobs.installTestsAgainstCurrentUnstable.${system};
+        installTestsAgainstSelf = self.hydraJobs.installTestsAgainstSelf.${system};
       } // (nixpkgs.lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
         dockerImage = self.hydraJobs.dockerImage.${system};
       });
@@ -669,7 +675,7 @@
           outputs = [ "out" "dev" "doc" ];
 
           nativeBuildInputs = nativeBuildDeps;
-          buildInputs = buildDeps ++ propagatedDeps ++ awsDeps;
+          buildInputs = buildDeps ++ propagatedDeps ++ awsDeps ++ perlDeps;
 
           inherit configureFlags;
 

misc/bash/completion.sh

@@ -15,7 +15,7 @@ function _complete_nix {
         else
             COMPREPLY+=("$completion")
         fi
-    done < <(NIX_GET_COMPLETIONS=$cword "${words[@]}" 2>/dev/null)
+    done < <(NIX_GET_COMPLETIONS=$cword "${words[@]/#\~/$HOME}" 2>/dev/null)
     __ltrim_colon_completions "$cur"
 }
 

misc/systemd/local.mk

@@ -1,8 +1,7 @@
 ifdef HOST_LINUX
 
   $(foreach n, nix-daemon.socket nix-daemon.service, $(eval $(call install-file-in, $(d)/$(n), $(prefix)/lib/systemd/system, 0644)))
-  $(foreach n, nix-daemon.conf, $(eval $(call install-file-in, $(d)/$(n), $(prefix)/lib/tmpfiles.d, 0644)))
 
-  clean-files += $(d)/nix-daemon.socket $(d)/nix-daemon.service $(d)/nix-daemon.conf
+  clean-files += $(d)/nix-daemon.socket $(d)/nix-daemon.service
 
 endif

misc/systemd/nix-daemon.conf.in

@@ -1 +0,0 @@
-d @localstatedir@/nix/daemon-socket 0755 root root - -

misc/systemd/nix-daemon.service.in

@@ -1,15 +1,12 @@
 [Unit]
 Description=Nix Daemon
-Documentation=man:nix-daemon https://nixos.org/manual
 RequiresMountsFor=@storedir@
 RequiresMountsFor=@localstatedir@
-RequiresMountsFor=@localstatedir@/nix/db
 ConditionPathIsReadWrite=@localstatedir@/nix/daemon-socket
 
 [Service]
 ExecStart=@@bindir@/nix-daemon nix-daemon --daemon
 KillMode=process
-LimitNOFILE=4096
 
 [Install]
 WantedBy=multi-user.target

misc/zsh/local.mk

@@ -1,2 +1 @@
 $(eval $(call install-file-as, $(d)/completion.zsh, $(datarootdir)/zsh/site-functions/_nix, 0644))
-$(eval $(call install-file-as, $(d)/run-help-nix, $(datarootdir)/zsh/site-functions/run-help-nix, 0644))

misc/zsh/run-help-nix

@@ -1,42 +0,0 @@
-emulate -L zsh
-
-# run-help is a zsh widget that can be bound to a key. It mainly looks up the
-# man page for the currently typed in command.
-#
-# Although run-help works for any command without requiring special support,
-# it can only deduce the right man page based solely on the name of the
-# command. Programs like Nix provide better integration with run-help by
-# helping zsh identify Nix subcommands and their corresponding man pages. This
-# is what this function does.
-#
-# To actually use run-help on zsh, place the following lines in your .zshrc:
-#
-#     (( $+aliases[run-help] )) && unalias run-help
-#     autoload -Uz run-help run-help-nix
-#
-# Then also assign run-help to any key of choice:
-#
-#     bindkey '^[h' run-help
-
-while [[ "$#" != 0 && "$1" == -* ]]; do
-  shift
-done
-
-local -a subcommands; subcommands=( nix3 )
-
-local arg
-for arg in "$@"; do
-  if man -w "${(j:-:)subcommands}-$arg" >/dev/null 2>&1; then
-    subcommands+="$arg"
-  else
-    break
-  fi
-done
-
-if (( $#subcommands > 1 )); then
-  man "${(j:-:)subcommands}"
-else
-  man nix
-fi
-
-return $?

mk/run_test.sh

@@ -7,6 +7,8 @@ green=""
 yellow=""
 normal=""
 
+TESTS_TIMER_LOG=${TESTS_TIMER_LOG:-/dev/null}
+
 post_run_msg="ran test $1..."
 if [ -t 1 ]; then
     red=""
@@ -14,33 +16,22 @@ if [ -t 1 ]; then
     yellow=""
     normal=""
 fi
+(cd tests && env ${TESTS_ENVIRONMENT} init.sh 2>/dev/null > /dev/null)
 
-run_test () {
-    (cd tests && env ${TESTS_ENVIRONMENT} init.sh 2>/dev/null > /dev/null)
-    log="$(cd $(dirname $1) && env ${TESTS_ENVIRONMENT} $(basename $1) 2>&1)"
-    status=$?
-}
-
-run_test "$1"
-
-# Hack: Retry the test if it fails with “unexpected EOF reading a line” as these
-# appear randomly without anyone knowing why.
-# See https://github.com/NixOS/nix/issues/3605 for more info
-if [[ $status -ne 0 && $status -ne 99 && \
-    "$(uname)" == "Darwin" && \
-    "$log" =~ "unexpected EOF reading a line" \
-]]; then
-    echo "$post_run_msg [${yellow}FAIL$normal] (possibly flaky, so will be retried)"
-    echo "$log" | sed 's/^/    /'
-    run_test "$1"
-fi
+start_time=$(date -u +%s)
+echo "$(date -u +%s) $1 start" >> "$TESTS_TIMER_LOG"
+log="$(cd $(dirname $1) && env ${TESTS_ENVIRONMENT} $(basename $1) 2>&1)"
+status=$?
+echo "$(date -u +%s) $1 stop" >> "$TESTS_TIMER_LOG"
+stop_time=$(date -u +%s)
+elapsed_time=$(($stop_time-$start_time))
 
 if [ $status -eq 0 ]; then
-  echo "$post_run_msg [${green}PASS$normal]"
+  echo "$post_run_msg [${green}PASS$normal] in ${elapsed_time}s"
 elif [ $status -eq 99 ]; then
-  echo "$post_run_msg [${yellow}SKIP$normal]"
+  echo "$post_run_msg [${yellow}SKIP$normal] after ${elapsed_time}s"
 else
-  echo "$post_run_msg [${red}FAIL$normal]"
+  echo "$post_run_msg [${red}FAIL$normal] in ${elapsed_time}s"
   echo "$log" | sed 's/^/    /'
   exit "$status"
 fi

perl/lib/Nix/Store.xs

@@ -240,7 +240,7 @@ SV * convertHash(char * algo, char * s, int toBase32)
     PPCODE:
         try {
             auto h = Hash::parseAny(s, parseHashType(algo));
-            auto s = h.to_string(toBase32 ? Base32 : Base16, false);
+            string s = h.to_string(toBase32 ? Base32 : Base16, false);
             XPUSHs(sv_2mortal(newSVpv(s.c_str(), 0)));
         } catch (Error & e) {
             croak("%s", e.what());

scripts/check-hydra-status.sh

@@ -14,7 +14,7 @@ curl -sS -H 'Accept: application/json' https://hydra.nixos.org/jobset/nix/master
 someBuildFailed=0
 
 for buildId in $BUILDS_FOR_LATEST_EVAL; do
-  buildInfo=$(curl --fail -sS -H 'Accept: application/json' "https://hydra.nixos.org/build/$buildId")
+  buildInfo=$(curl -sS -H 'Accept: application/json' "https://hydra.nixos.org/build/$buildId")
 
   finished=$(echo "$buildInfo" | jq -r '.finished')
 

scripts/create-darwin-volume.sh

@@ -246,8 +246,7 @@ get_volume_pass() {
 verify_volume_pass() {
     local volume_special="$1" # (i.e., disk1s7)
     local volume_uuid="$2"
-    _sudo "to confirm the password actually unlocks the volume" \
-        /usr/sbin/diskutil apfs unlockVolume "$volume_special" -verify -stdinpassphrase -user "$volume_uuid"
+    /usr/sbin/diskutil apfs unlockVolume "$volume_special" -verify -stdinpassphrase -user "$volume_uuid"
 }
 
 volume_pass_works() {
@@ -442,13 +441,9 @@ add_nix_vol_fstab_line() {
     local escaped_mountpoint="${NIX_ROOT/ /'\\\'040}"
     shift
 
-    # wrap `ex` to work around a problem with vim plugins breaking exit codes
-    # (see github.com/NixOS/nix/issues/5468)
-    #
-    # the first draft used `--noplugin`, but github.com/NixOS/nix/issues/6462
-    # suggests we need the less-semantic `-u NONE`
-    #
-    # we'd prefer EDITOR="/usr/bin/ex -u NONE" but vifs doesn't word-split
+    # wrap `ex` to work around a problem with vim plugins breaking exit codes;
+    # (see https://github.com/NixOS/nix/issues/5468)
+    # we'd prefer EDITOR="/usr/bin/ex --noplugin" but vifs doesn't word-split
     # the EDITOR env.
     #
     # TODO: at some point we should switch to `--clean`, but it wasn't added
@@ -456,7 +451,7 @@ add_nix_vol_fstab_line() {
     # minver 10.12.6 seems to have released with vim 7.4
     cat > "$SCRATCH/ex_cleanroom_wrapper" <<EOF
 #!/bin/sh
-/usr/bin/ex -u NONE "\$@"
+/usr/bin/ex --noplugin "\$@"
 EOF
     chmod 755 "$SCRATCH/ex_cleanroom_wrapper"
 
@@ -650,9 +645,8 @@ EOF
         task "Configuring /etc/synthetic.conf to make a mount-point at $NIX_ROOT" >&2
         # technically /etc/synthetic.d/nix is supported in Big Sur+
         # but handling both takes even more code...
-        # Note: `-u NONE` disables vim plugins/rc; see note on --clean earlier
         _sudo "to add Nix to /etc/synthetic.conf" \
-            /usr/bin/ex -u NONE /etc/synthetic.conf <<EOF
+            /usr/bin/ex --noplugin /etc/synthetic.conf <<EOF
 :a
 ${NIX_ROOT:1}
 .
@@ -691,27 +685,22 @@ encrypt_volume() {
     local volume_uuid="$1"
     local volume_label="$2"
     local password
-
-    task "Encrypt the Nix volume" >&2
-
     # Note: mount/unmount are late additions to support the right order
     # of operations for creating the volume and then baking its uuid into
     # other artifacts; not as well-trod wrt to potential errors, race
     # conditions, etc.
 
-    _sudo "to mount your Nix volume for encrypting" \
-        /usr/sbin/diskutil mount "$volume_label"
+    /usr/sbin/diskutil mount "$volume_label"
 
     password="$(/usr/bin/xxd -l 32 -p -c 256 /dev/random)"
     _sudo "to add your Nix volume's password to Keychain" \
         /usr/bin/security -i <<EOF
 add-generic-password -a "$volume_label" -s "$volume_uuid" -l "$volume_label encryption password" -D "Encrypted volume password" -j "Added automatically by the Nix installer for use by $NIX_VOLUME_MOUNTD_DEST" -w "$password" -T /System/Library/CoreServices/APFSUserAgent -T /System/Library/CoreServices/CSUserAgent -T /usr/bin/security "/Library/Keychains/System.keychain"
 EOF
-    builtin printf "%s" "$password" | _sudo "to actually encrypt your Nix volume" \
+    builtin printf "%s" "$password" | _sudo "to encrypt your Nix volume" \
         /usr/sbin/diskutil apfs encryptVolume "$volume_label" -user disk -stdinpassphrase
 
-    _sudo "to unmount the encrypted volume" \
-        /usr/sbin/diskutil unmount force "$volume_label"
+    /usr/sbin/diskutil unmount force "$volume_label"
 }
 
 create_volume() {
@@ -820,8 +809,7 @@ setup_volume_daemon() {
     local volume_uuid="$2"
     if ! test_voldaemon; then
         task "Configuring LaunchDaemon to mount '$NIX_VOLUME_LABEL'" >&2
-        # Note: `-u NONE` disables vim plugins/rc; see note on --clean earlier
-        _sudo "to install the Nix volume mounter" /usr/bin/ex -u NONE "$NIX_VOLUME_MOUNTD_DEST" <<EOF
+        _sudo "to install the Nix volume mounter" /usr/bin/ex --noplugin "$NIX_VOLUME_MOUNTD_DEST" <<EOF
 :a
 $(generate_mount_daemon "$cmd_type" "$volume_uuid")
 .

scripts/install-multi-user.sh

@@ -23,10 +23,10 @@ readonly RED='\033[31m'
 # installer allows overriding build user count to speed up installation
 # as creating each user takes non-trivial amount of time on macos
 readonly NIX_USER_COUNT=${NIX_USER_COUNT:-32}
-readonly NIX_BUILD_GROUP_ID="${NIX_BUILD_GROUP_ID:-30000}"
+readonly NIX_BUILD_GROUP_ID="30000"
 readonly NIX_BUILD_GROUP_NAME="nixbld"
 # darwin installer needs to override these
-NIX_FIRST_BUILD_UID="${NIX_FIRST_BUILD_UID:-30001}"
+NIX_FIRST_BUILD_UID="30001"
 NIX_BUILD_USER_NAME_TEMPLATE="nixbld%d"
 # Please don't change this. We don't support it, because the
 # default shell profile that comes with Nix doesn't support it.
@@ -423,18 +423,6 @@ EOF
         fi
     done
 
-    if [ "$(uname -s)" = "Linux" ] && [ ! -e /run/systemd/system ]; then
-        warning <<EOF
-We did not detect systemd on your system. With a multi-user install
-without systemd you will have to manually configure your init system to
-launch the Nix daemon after installation.
-EOF
-        if ! ui_confirm "Do you want to proceed with a multi-user installation?"; then
-            failure <<EOF
-You have aborted the installation.
-EOF
-        fi
-    fi
 }
 
 setup_report() {
@@ -751,7 +739,7 @@ install_from_extracted_nix() {
         cd "$EXTRACTED_NIX_PATH"
 
         _sudo "to copy the basic Nix files to the new store at $NIX_ROOT/store" \
-              cp -RPp ./store/* "$NIX_ROOT/store/"
+              cp -RLp ./store/* "$NIX_ROOT/store/"
 
         _sudo "to make the new store non-writable at $NIX_ROOT/store" \
               chmod -R ugo-w "$NIX_ROOT/store/"

scripts/install-systemd-multi-user.sh

@@ -9,8 +9,6 @@ readonly SERVICE_DEST=/etc/systemd/system/nix-daemon.service
 readonly SOCKET_SRC=/lib/systemd/system/nix-daemon.socket
 readonly SOCKET_DEST=/etc/systemd/system/nix-daemon.socket
 
-readonly TMPFILES_SRC=/lib/tmpfiles.d/nix-daemon.conf
-readonly TMPFILES_DEST=/etc/tmpfiles.d/nix-daemon.conf
 
 # Path for the systemd override unit file to contain the proxy settings
 readonly SERVICE_OVERRIDE=${SERVICE_DEST}.d/override.conf
@@ -85,13 +83,6 @@ EOF
 poly_configure_nix_daemon_service() {
     if [ -e /run/systemd/system ]; then
         task "Setting up the nix-daemon systemd service"
-
-        _sudo "to create the nix-daemon tmpfiles config" \
-              ln -sfn /nix/var/nix/profiles/default/$TMPFILES_SRC $TMPFILES_DEST
-
-        _sudo "to run systemd-tmpfiles once to pick that path up" \
-             systemd-tmpfiles --create --prefix=/nix/var/nix
-
         _sudo "to set up the nix-daemon service" \
               systemctl link "/nix/var/nix/profiles/default$SERVICE_SRC"
 

scripts/install.in

@@ -82,7 +82,7 @@ if [ "$(uname -s)" != "Darwin" ]; then
 fi
 
 if command -v curl > /dev/null 2>&1; then
-    fetch() { curl --fail -L "$1" -o "$2"; }
+    fetch() { curl -L "$1" -o "$2"; }
 elif command -v wget > /dev/null 2>&1; then
     fetch() { wget "$1" -O "$2"; }
 else

scripts/list-tests-flake-outptus-for-gha

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+set -x
+
+nix build --inputs-from . nixpkgs#jq -o jq
+
+TEST_NAMES=$(nix flake show . --json | ./jq-bin/bin/jq -c ".checks[\"$(nix eval --raw --impure --expr builtins.currentSystem)\"] | keys")
+
+
+echo "::set-output name=json::$TEST_NAMES"

src/build-remote/build-remote.cc

@@ -14,7 +14,6 @@
 #include "pathlocks.hh"
 #include "globals.hh"
 #include "serialise.hh"
-#include "build-result.hh"
 #include "store-api.hh"
 #include "derivations.hh"
 #include "local-store.hh"
@@ -33,7 +32,7 @@ std::string escapeUri(std::string uri)
     return uri;
 }
 
-static std::string currentLoad;
+static string currentLoad;
 
 static AutoCloseFD openSlotLock(const Machine & m, uint64_t slot)
 {
@@ -98,7 +97,7 @@ static int main_build_remote(int argc, char * * argv)
         }
 
         std::optional<StorePath> drvPath;
-        std::string storeUri;
+        string storeUri;
 
         while (true) {
 
@@ -184,7 +183,7 @@ static int main_build_remote(int argc, char * * argv)
                     else
                     {
                         // build the hint template.
-                        std::string errorText =
+                        string errorText =
                             "Failed to find a machine for remote build!\n"
                             "derivation: %s\nrequired (system, features): (%s, %s)";
                         errorText += "\n%s available machines:";
@@ -194,7 +193,7 @@ static int main_build_remote(int argc, char * * argv)
                             errorText += "\n(%s, %s, %s, %s)";
 
                         // add the template values.
-                        std::string drvstr;
+                        string drvstr;
                         if (drvPath.has_value())
                             drvstr = drvPath->to_string();
                         else
@@ -209,7 +208,7 @@ static int main_build_remote(int argc, char * * argv)
 
                         for (auto & m : machines)
                             error
-                                % concatStringsSep<std::vector<std::string>>(", ", m.systemTypes)
+                                % concatStringsSep<std::vector<string>>(", ", m.systemTypes)
                                 % m.maxJobs
                                 % concatStringsSep<StringSet>(", ", m.supportedFeatures)
                                 % concatStringsSep<StringSet>(", ", m.mandatoryFeatures);
@@ -300,7 +299,7 @@ connected:
 
         std::set<Realisation> missingRealisations;
         StorePathSet missingPaths;
-        if (settings.isExperimentalFeatureEnabled(Xp::CaDerivations) && !drv.type().hasKnownOutputPaths()) {
+        if (settings.isExperimentalFeatureEnabled(Xp::CaDerivations) && !derivationHasKnownOutputPaths(drv.type())) {
             for (auto & outputName : wantedOutputs) {
                 auto thisOutputHash = outputHashes.at(outputName);
                 auto thisOutputId = DrvOutput{ thisOutputHash, outputName };

src/libcmd/command.cc

@@ -86,11 +86,6 @@ ref<Store> CopyCommand::getDstStore()
 
 EvalCommand::EvalCommand()
 {
-    addFlag({
-        .longName = "debugger",
-        .description = "start an interactive environment if evaluation fails",
-        .handler = {&startReplOnEvalErrors, true},
-    });
 }
 
 EvalCommand::~EvalCommand()
@@ -108,7 +103,7 @@ ref<Store> EvalCommand::getEvalStore()
 
 ref<EvalState> EvalCommand::getEvalState()
 {
-    if (!evalState) {
+    if (!evalState)
         evalState =
             #if HAVE_BOEHMGC
             std::allocate_shared<EvalState>(traceable_allocator<EvalState>(),
@@ -118,11 +113,6 @@ ref<EvalState> EvalCommand::getEvalState()
                 searchPath, getEvalStore(), getStore())
             #endif
             ;
-
-        if (startReplOnEvalErrors) {
-            evalState->debugRepl = &runRepl;        
-        };
-    }
     return ref<EvalState>(evalState);
 }
 
@@ -163,7 +153,7 @@ void BuiltPathsCommand::run(ref<Store> store)
         for (auto & p : store->queryAllValidPaths())
             paths.push_back(BuiltPath::Opaque{p});
     } else {
-        paths = Installable::toBuiltPaths(getEvalStore(), store, realiseMode, operateOn, installables);
+        paths = toBuiltPaths(getEvalStore(), store, realiseMode, operateOn, installables);
         if (recursive) {
             // XXX: This only computes the store path closure, ignoring
             // intermediate realisations
@@ -207,17 +197,16 @@ void StorePathCommand::run(ref<Store> store, std::vector<StorePath> && storePath
     run(store, *storePaths.begin());
 }
 
-Strings editorFor(const Path & file, uint32_t line)
+Strings editorFor(const Pos & pos)
 {
     auto editor = getEnv("EDITOR").value_or("cat");
     auto args = tokenizeString<Strings>(editor);
-    if (line > 0 && (
+    if (pos.line > 0 && (
         editor.find("emacs") != std::string::npos ||
         editor.find("nano") != std::string::npos ||
-        editor.find("vim") != std::string::npos ||
-        editor.find("kak") != std::string::npos))
-        args.push_back(fmt("+%d", line));
-    args.push_back(file);
+        editor.find("vim") != std::string::npos))
+        args.push_back(fmt("+%d", pos.line));
+    args.push_back(pos.file);
     return args;
 }
 

src/libcmd/command.hh

@@ -5,6 +5,7 @@
 #include "common-eval-args.hh"
 #include "path.hh"
 #include "flake/lockfile.hh"
+#include "store-api.hh"
 
 #include <optional>
 
@@ -57,8 +58,6 @@ struct CopyCommand : virtual StoreCommand
 
 struct EvalCommand : virtual StoreCommand, MixEvalArgs
 {
-    bool startReplOnEvalErrors = false;
-
     EvalCommand();
 
     ~EvalCommand();
@@ -83,16 +82,23 @@ struct MixFlakeOptions : virtual Args, EvalCommand
     { return {}; }
 };
 
+/* How to handle derivations in commands that operate on store paths. */
+enum class OperateOn {
+    /* Operate on the output path. */
+    Output,
+    /* Operate on the .drv path. */
+    Derivation
+};
+
 struct SourceExprCommand : virtual Args, MixFlakeOptions
 {
     std::optional<Path> file;
     std::optional<std::string> expr;
-    bool readOnlyMode = false;
 
     // FIXME: move this; not all commands (e.g. 'nix run') use it.
     OperateOn operateOn = OperateOn::Output;
 
-    SourceExprCommand(bool supportReadOnlyMode = false);
+    SourceExprCommand();
 
     std::vector<std::shared_ptr<Installable>> parseInstallables(
         ref<Store> store, std::vector<std::string> ss);
@@ -107,6 +113,19 @@ struct SourceExprCommand : virtual Args, MixFlakeOptions
     void completeInstallable(std::string_view prefix);
 };
 
+enum class Realise {
+    /* Build the derivation. Postcondition: the
+       derivation outputs exist. */
+    Outputs,
+    /* Don't build the derivation. Postcondition: the store derivation
+       exists. */
+    Derivation,
+    /* Evaluate in dry-run mode. Postcondition: nothing. */
+    // FIXME: currently unused, but could be revived if we can
+    // evaluate derivations in-memory.
+    Nothing
+};
+
 /* A command that operates on a list of "installables", which can be
    store paths, attribute paths, Nix expressions, etc. */
 struct InstallablesCommand : virtual Args, SourceExprCommand
@@ -131,13 +150,13 @@ struct InstallableCommand : virtual Args, SourceExprCommand
 {
     std::shared_ptr<Installable> installable;
 
-    InstallableCommand(bool supportReadOnlyMode = false);
+    InstallableCommand();
 
     void prepare() override;
 
     std::optional<FlakeRef> getFlakeRefForCompletion() override
     {
-        return parseFlakeRefWithFragment(_installable, absPath(".")).first;
+        return parseFlakeRef(_installable, absPath("."));
     }
 
 private:
@@ -219,9 +238,41 @@ static RegisterCommand registerCommand2(std::vector<std::string> && name)
     return RegisterCommand(std::move(name), [](){ return make_ref<T>(); });
 }
 
+BuiltPaths build(
+    ref<Store> evalStore,
+    ref<Store> store, Realise mode,
+    const std::vector<std::shared_ptr<Installable>> & installables,
+    BuildMode bMode = bmNormal);
+
+std::set<StorePath> toStorePaths(
+    ref<Store> evalStore,
+    ref<Store> store,
+    Realise mode,
+    OperateOn operateOn,
+    const std::vector<std::shared_ptr<Installable>> & installables);
+
+StorePath toStorePath(
+    ref<Store> evalStore,
+    ref<Store> store,
+    Realise mode,
+    OperateOn operateOn,
+    std::shared_ptr<Installable> installable);
+
+std::set<StorePath> toDerivations(
+    ref<Store> store,
+    const std::vector<std::shared_ptr<Installable>> & installables,
+    bool useDeriver = false);
+
+BuiltPaths toBuiltPaths(
+    ref<Store> evalStore,
+    ref<Store> store,
+    Realise mode,
+    OperateOn operateOn,
+    const std::vector<std::shared_ptr<Installable>> & installables);
+
 /* Helper function to generate args that invoke $EDITOR on
    filename:lineno. */
-Strings editorFor(const Path & file, uint32_t line);
+Strings editorFor(const Pos & pos);
 
 struct MixProfile : virtual StoreCommand
 {
@@ -272,8 +323,4 @@ void printClosureDiff(
     const StorePath & afterPath,
     std::string_view indent);
 
-
-void runRepl(
-    ref<EvalState> evalState,
-    const ValMap & extraEnv);
 }

src/libcmd/installables.cc

@@ -1,6 +1,4 @@
-#include "globals.hh"
 #include "installables.hh"
-#include "util.hh"
 #include "command.hh"
 #include "attr-path.hh"
 #include "common-eval-args.hh"
@@ -14,7 +12,6 @@
 #include "eval-cache.hh"
 #include "url.hh"
 #include "registry.hh"
-#include "build-result.hh"
 
 #include <regex>
 #include <queue>
@@ -101,14 +98,6 @@ MixFlakeOptions::MixFlakeOptions()
             lockFlags.inputOverrides.insert_or_assign(
                 flake::parseInputPath(inputPath),
                 parseFlakeRef(flakeRef, absPath("."), true));
-        }},
-        .completer = {[&](size_t n, std::string_view prefix) {
-            if (n == 0) {
-                if (auto flakeRef = getFlakeRefForCompletion())
-                    completeFlakeInputPath(getEvalState(), *flakeRef, prefix);
-            } else if (n == 1) {
-                completeFlakeRef(getEvalState()->store, prefix);
-            }
         }}
     });
 
@@ -139,14 +128,12 @@ MixFlakeOptions::MixFlakeOptions()
     });
 }
 
-SourceExprCommand::SourceExprCommand(bool supportReadOnlyMode)
+SourceExprCommand::SourceExprCommand()
 {
     addFlag({
         .longName = "file",
         .shortName = 'f',
-        .description =
-            "Interpret installables as attribute paths relative to the Nix expression stored in *file*. "
-            "If *file* is the character -, then a Nix expression will be read from standard input.",
+        .description = "Interpret installables as attribute paths relative to the Nix expression stored in *file*.",
         .category = installablesCategory,
         .labels = {"file"},
         .handler = {&file},
@@ -167,25 +154,11 @@ SourceExprCommand::SourceExprCommand(bool supportReadOnlyMode)
         .category = installablesCategory,
         .handler = {&operateOn, OperateOn::Derivation},
     });
-
-    if (supportReadOnlyMode) {
-        addFlag({
-            .longName = "read-only",
-            .description =
-                "Do not instantiate each evaluated derivation. "
-                "This improves performance, but can cause errors when accessing "
-                "store paths of derivations during evaluation.",
-            .handler = {&readOnlyMode, true},
-        });
-    }
 }
 
 Strings SourceExprCommand::getDefaultFlakeAttrPaths()
 {
-    return {
-        "packages." + settings.thisSystem.get() + ".default",
-        "defaultPackage." + settings.thisSystem.get()
-    };
+    return {"defaultPackage." + settings.thisSystem.get()};
 }
 
 Strings SourceExprCommand::getDefaultFlakeAttrPathPrefixes()
@@ -203,8 +176,6 @@ Strings SourceExprCommand::getDefaultFlakeAttrPathPrefixes()
 void SourceExprCommand::completeInstallable(std::string_view prefix)
 {
     if (file) {
-        completionType = ctAttrs;
-
         evalSettings.pureEval = false;
         auto state = getEvalState();
         Expr *e = state->parseExprFromFile(
@@ -233,14 +204,13 @@ void SourceExprCommand::completeInstallable(std::string_view prefix)
         Value v2;
         state->autoCallFunction(*autoArgs, v1, v2);
 
+        completionType = ctAttrs;
+
         if (v2.type() == nAttrs) {
             for (auto & i : *v2.attrs) {
-                std::string name = state->symbols[i.name];
+                std::string name = i.name;
                 if (name.find(searchWord) == 0) {
-                    if (prefix_ == "")
-                        completions->add(name);
-                    else
-                        completions->add(prefix_ + "." + name);
+                    completions->add(i.name);
                 }
             }
         }
@@ -268,11 +238,10 @@ void completeFlakeRefWithFragment(
         if (hash == std::string::npos) {
             completeFlakeRef(evalState->store, prefix);
         } else {
-            completionType = ctAttrs;
-
             auto fragment = prefix.substr(hash + 1);
             auto flakeRefS = std::string(prefix.substr(0, hash));
-            auto flakeRef = parseFlakeRef(expandTilde(flakeRefS), absPath("."));
+            // FIXME: do tilde expansion.
+            auto flakeRef = parseFlakeRef(flakeRefS, absPath("."));
 
             auto evalCache = openEvalCache(*evalState,
                 std::make_shared<flake::LockedFlake>(lockFlake(*evalState, flakeRef, lockFlags)));
@@ -284,6 +253,8 @@ void completeFlakeRefWithFragment(
                flake. */
             attrPathPrefixes.push_back("");
 
+            completionType = ctAttrs;
+
             for (auto & attrPathPrefixS : attrPathPrefixes) {
                 auto attrPathPrefix = parseAttrPath(*evalState, attrPathPrefixS);
                 auto attrPathS = attrPathPrefixS + std::string(fragment);
@@ -291,19 +262,19 @@ void completeFlakeRefWithFragment(
 
                 std::string lastAttr;
                 if (!attrPath.empty() && !hasSuffix(attrPathS, ".")) {
-                    lastAttr = evalState->symbols[attrPath.back()];
+                    lastAttr = attrPath.back();
                     attrPath.pop_back();
                 }
 
                 auto attr = root->findAlongAttrPath(attrPath);
                 if (!attr) continue;
 
-                for (auto & attr2 : (*attr)->getAttrs()) {
-                    if (hasPrefix(evalState->symbols[attr2], lastAttr)) {
-                        auto attrPath2 = (*attr)->getAttrPath(attr2);
+                for (auto & attr2 : attr->getAttrs()) {
+                    if (hasPrefix(attr2, lastAttr)) {
+                        auto attrPath2 = attr->getAttrPath(attr2);
                         /* Strip the attrpath prefix. */
                         attrPath2.erase(attrPath2.begin(), attrPath2.begin() + attrPathPrefix.size());
-                        completions->add(flakeRefS + "#" + concatStringsSep(".", evalState->symbols.resolve(attrPath2)));
+                        completions->add(flakeRefS + "#" + concatStringsSep(".", attrPath2));
                     }
                 }
             }
@@ -357,16 +328,16 @@ DerivedPath Installable::toDerivedPath()
     return std::move(buildables[0]);
 }
 
-std::vector<ref<eval_cache::AttrCursor>>
+std::vector<std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>>
 Installable::getCursors(EvalState & state)
 {
     auto evalCache =
         std::make_shared<nix::eval_cache::EvalCache>(std::nullopt, state,
             [&]() { return toValue(state).first; });
-    return {evalCache->getRoot()};
+    return {{evalCache->getRoot(), ""}};
 }
 
-ref<eval_cache::AttrCursor>
+std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>
 Installable::getCursor(EvalState & state)
 {
     auto cursors = getCursors(state);
@@ -440,8 +411,10 @@ DerivedPaths InstallableValue::toDerivedPaths()
 
     // Group by derivation, helps with .all in particular
     for (auto & drv : toDerivations()) {
-        for (auto & outputName : drv.outputsToInstall)
-            drvsToOutputs[drv.drvPath].insert(outputName);
+        auto outputName = drv.outputName;
+        if (outputName == "")
+            throw Error("derivation '%s' lacks an 'outputName' attribute", state->store->printStorePath(drv.drvPath));
+        drvsToOutputs[drv.drvPath].insert(outputName);
         drvsToCopy.insert(drv.drvPath);
     }
 
@@ -464,24 +437,14 @@ struct InstallableAttrPath : InstallableValue
     SourceExprCommand & cmd;
     RootValue v;
     std::string attrPath;
-    OutputsSpec outputsSpec;
 
-    InstallableAttrPath(
-        ref<EvalState> state,
-        SourceExprCommand & cmd,
-        Value * v,
-        const std::string & attrPath,
-        OutputsSpec outputsSpec)
-        : InstallableValue(state)
-        , cmd(cmd)
-        , v(allocRootValue(v))
-        , attrPath(attrPath)
-        , outputsSpec(std::move(outputsSpec))
+    InstallableAttrPath(ref<EvalState> state, SourceExprCommand & cmd, Value * v, const std::string & attrPath)
+        : InstallableValue(state), cmd(cmd), v(allocRootValue(v)), attrPath(attrPath)
     { }
 
     std::string what() const override { return attrPath; }
 
-    std::pair<Value *, PosIdx> toValue(EvalState & state) override
+    std::pair<Value *, Pos> toValue(EvalState & state) override
     {
         auto [vRes, pos] = findAlongAttrPath(state, attrPath, *cmd.getAutoArgs(state), **v);
         state.forceValue(*vRes, pos);
@@ -502,21 +465,10 @@ std::vector<InstallableValue::DerivationInfo> InstallableAttrPath::toDerivations
 
     std::vector<DerivationInfo> res;
     for (auto & drvInfo : drvInfos) {
-        auto drvPath = drvInfo.queryDrvPath();
-        if (!drvPath)
-            throw Error("'%s' is not a derivation", what());
-
-        std::set<std::string> outputsToInstall;
-
-        if (auto outputNames = std::get_if<OutputNames>(&outputsSpec))
-            outputsToInstall = *outputNames;
-        else
-            for (auto & output : drvInfo.queryOutputs(false, std::get_if<DefaultOutputs>(&outputsSpec)))
-                outputsToInstall.insert(output.first);
-
-        res.push_back(DerivationInfo {
-            .drvPath = *drvPath,
-            .outputsToInstall = std::move(outputsToInstall)
+        res.push_back({
+            state->store->parseStorePath(drvInfo.queryDrvPath()),
+            state->store->maybeParseStorePath(drvInfo.queryOutPath()),
+            drvInfo.queryOutputName()
         });
     }
 
@@ -594,7 +546,6 @@ InstallableFlake::InstallableFlake(
     ref<EvalState> state,
     FlakeRef && flakeRef,
     std::string_view fragment,
-    OutputsSpec outputsSpec,
     Strings attrPaths,
     Strings prefixes,
     const flake::LockFlags & lockFlags)
@@ -602,7 +553,6 @@ InstallableFlake::InstallableFlake(
       flakeRef(flakeRef),
       attrPaths(fragment == "" ? attrPaths : Strings{(std::string) fragment}),
       prefixes(fragment == "" ? Strings{} : prefixes),
-      outputsSpec(std::move(outputsSpec)),
       lockFlags(lockFlags)
 {
     if (cmd && cmd->getAutoArgs(*state)->size())
@@ -611,53 +561,37 @@ InstallableFlake::InstallableFlake(
 
 std::tuple<std::string, FlakeRef, InstallableValue::DerivationInfo> InstallableFlake::toDerivation()
 {
-    auto attr = getCursor(*state);
+    auto lockedFlake = getLockedFlake();
 
-    auto attrPath = attr->getAttrPathStr();
+    auto cache = openEvalCache(*state, lockedFlake);
+    auto root = cache->getRoot();
 
-    if (!attr->isDerivation())
-        throw Error("flake output attribute '%s' is not a derivation", attrPath);
+    for (auto & attrPath : getActualAttrPaths()) {
+        debug("trying flake output attribute '%s'", attrPath);
 
-    auto drvPath = attr->forceDerivation();
+        auto attr = root->findAlongAttrPath(
+            parseAttrPath(*state, attrPath),
+            true
+        );
 
-    std::set<std::string> outputsToInstall;
-    std::optional<NixInt> priority;
+        if (!attr) continue;
 
-    if (auto aOutputSpecified = attr->maybeGetAttr(state->sOutputSpecified)) {
-        if (aOutputSpecified->getBool()) {
-            if (auto aOutputName = attr->maybeGetAttr("outputName"))
-                outputsToInstall = { aOutputName->getString() };
-        }
+        if (!attr->isDerivation())
+            throw Error("flake output attribute '%s' is not a derivation", attrPath);
+
+        auto drvPath = attr->forceDerivation();
+
+        auto drvInfo = DerivationInfo{
+            std::move(drvPath),
+            state->store->maybeParseStorePath(attr->getAttr(state->sOutPath)->getString()),
+            attr->getAttr(state->sOutputName)->getString()
+        };
+
+        return {attrPath, lockedFlake->flake.lockedRef, std::move(drvInfo)};
     }
 
-    else if (auto aMeta = attr->maybeGetAttr(state->sMeta)) {
-        if (auto aOutputsToInstall = aMeta->maybeGetAttr("outputsToInstall"))
-            for (auto & s : aOutputsToInstall->getListOfStrings())
-                outputsToInstall.insert(s);
-        if (auto aPriority = aMeta->maybeGetAttr("priority"))
-            priority = aPriority->getInt();
-    }
-
-    if (outputsToInstall.empty() || std::get_if<AllOutputs>(&outputsSpec)) {
-        outputsToInstall.clear();
-        if (auto aOutputs = attr->maybeGetAttr(state->sOutputs))
-            for (auto & s : aOutputs->getListOfStrings())
-                outputsToInstall.insert(s);
-    }
-
-    if (outputsToInstall.empty())
-        outputsToInstall.insert("out");
-
-    if (auto outputNames = std::get_if<OutputNames>(&outputsSpec))
-        outputsToInstall = *outputNames;
-
-    auto drvInfo = DerivationInfo {
-        .drvPath = std::move(drvPath),
-        .outputsToInstall = std::move(outputsToInstall),
-        .priority = priority,
-    };
-
-    return {attrPath, getLockedFlake()->flake.lockedRef, std::move(drvInfo)};
+    throw Error("flake '%s' does not provide attribute %s",
+        flakeRef, showAttrPaths(getActualAttrPaths()));
 }
 
 std::vector<InstallableValue::DerivationInfo> InstallableFlake::toDerivations()
@@ -667,12 +601,28 @@ std::vector<InstallableValue::DerivationInfo> InstallableFlake::toDerivations()
     return res;
 }
 
-std::pair<Value *, PosIdx> InstallableFlake::toValue(EvalState & state)
+std::pair<Value *, Pos> InstallableFlake::toValue(EvalState & state)
 {
-    return {&getCursor(state)->forceValue(), noPos};
+    auto lockedFlake = getLockedFlake();
+
+    auto vOutputs = getFlakeOutputs(state, *lockedFlake);
+
+    auto emptyArgs = state.allocBindings(0);
+
+    for (auto & attrPath : getActualAttrPaths()) {
+        try {
+            auto [v, pos] = findAlongAttrPath(state, attrPath, *emptyArgs, *vOutputs);
+            state.forceValue(*v, pos);
+            return {v, pos};
+        } catch (AttrPathNotFound & e) {
+        }
+    }
+
+    throw Error("flake '%s' does not provide attribute %s",
+        flakeRef, showAttrPaths(getActualAttrPaths()));
 }
 
-std::vector<ref<eval_cache::AttrCursor>>
+std::vector<std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>>
 InstallableFlake::getCursors(EvalState & state)
 {
     auto evalCache = openEvalCache(state,
@@ -680,55 +630,21 @@ InstallableFlake::getCursors(EvalState & state)
 
     auto root = evalCache->getRoot();
 
-    std::vector<ref<eval_cache::AttrCursor>> res;
+    std::vector<std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>> res;
 
     for (auto & attrPath : getActualAttrPaths()) {
         auto attr = root->findAlongAttrPath(parseAttrPath(state, attrPath));
-        if (attr) res.push_back(ref(*attr));
+        if (attr) res.push_back({attr, attrPath});
     }
 
     return res;
 }
 
-ref<eval_cache::AttrCursor> InstallableFlake::getCursor(EvalState & state)
-{
-    auto lockedFlake = getLockedFlake();
-
-    auto cache = openEvalCache(state, lockedFlake);
-    auto root = cache->getRoot();
-
-    Suggestions suggestions;
-
-    auto attrPaths = getActualAttrPaths();
-
-    for (auto & attrPath : attrPaths) {
-        debug("trying flake output attribute '%s'", attrPath);
-
-        auto attrOrSuggestions = root->findAlongAttrPath(
-            parseAttrPath(state, attrPath),
-            true
-        );
-
-        if (!attrOrSuggestions) {
-            suggestions += attrOrSuggestions.getSuggestions();
-            continue;
-        }
-
-        return *attrOrSuggestions;
-    }
-
-    throw Error(
-        suggestions,
-        "flake '%s' does not provide attribute %s",
-        flakeRef,
-        showAttrPaths(attrPaths));
-}
-
 std::shared_ptr<flake::LockedFlake> InstallableFlake::getLockedFlake() const
 {
+    flake::LockFlags lockFlagsApplyConfig = lockFlags;
+    lockFlagsApplyConfig.applyNixConfig = true;
     if (!_lockedFlake) {
-        flake::LockFlags lockFlagsApplyConfig = lockFlags;
-        lockFlagsApplyConfig.applyNixConfig = true;
         _lockedFlake = std::make_shared<flake::LockedFlake>(lockFlake(*state, flakeRef, lockFlagsApplyConfig));
     }
     return _lockedFlake;
@@ -753,10 +669,6 @@ std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
 {
     std::vector<std::shared_ptr<Installable>> result;
 
-    if (readOnlyMode) {
-        settings.readOnlyMode = true;
-    }
-
     if (file || expr) {
         if (file && expr)
             throw UsageError("'--file' and '--expr' are exclusive");
@@ -767,24 +679,15 @@ std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
         auto state = getEvalState();
         auto vFile = state->allocValue();
 
-        if (file == "-") {
-            auto e = state->parseStdin();
-            state->eval(e, *vFile);
-        } else if (file)
+        if (file)
             state->evalFile(lookupFileArg(*state, *file), *vFile);
         else {
             auto e = state->parseExprFromString(*expr, absPath("."));
             state->eval(e, *vFile);
         }
 
-        for (auto & s : ss) {
-            auto [prefix, outputsSpec] = parseOutputsSpec(s);
-            result.push_back(
-                std::make_shared<InstallableAttrPath>(
-                    state, *this, vFile,
-                    prefix == "." ? "" : prefix,
-                    outputsSpec));
-        }
+        for (auto & s : ss)
+            result.push_back(std::make_shared<InstallableAttrPath>(state, *this, vFile, s == "." ? "" : s));
 
     } else {
 
@@ -803,13 +706,12 @@ std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
             }
 
             try {
-                auto [flakeRef, fragment, outputsSpec] = parseFlakeRefWithFragmentAndOutputsSpec(s, absPath("."));
+                auto [flakeRef, fragment] = parseFlakeRefWithFragment(s, absPath("."));
                 result.push_back(std::make_shared<InstallableFlake>(
                         this,
                         getEvalState(),
                         std::move(flakeRef),
                         fragment,
-                        outputsSpec,
                         getDefaultFlakeAttrPaths(),
                         getDefaultFlakeAttrPathPrefixes(),
                         lockFlags));
@@ -833,20 +735,56 @@ std::shared_ptr<Installable> SourceExprCommand::parseInstallable(
     return installables.front();
 }
 
-BuiltPaths Installable::build(
-    ref<Store> evalStore,
-    ref<Store> store,
-    Realise mode,
-    const std::vector<std::shared_ptr<Installable>> & installables,
-    BuildMode bMode)
+BuiltPaths getBuiltPaths(ref<Store> evalStore, ref<Store> store, const DerivedPaths & hopefullyBuiltPaths)
 {
     BuiltPaths res;
-    for (auto & [_, builtPath] : build2(evalStore, store, mode, installables, bMode))
-        res.push_back(builtPath);
+    for (const auto & b : hopefullyBuiltPaths)
+        std::visit(
+            overloaded{
+                [&](const DerivedPath::Opaque & bo) {
+                    res.push_back(BuiltPath::Opaque{bo.path});
+                },
+                [&](const DerivedPath::Built & bfd) {
+                    OutputPathMap outputs;
+                    auto drv = evalStore->readDerivation(bfd.drvPath);
+                    auto outputHashes = staticOutputHashes(*evalStore, drv); // FIXME: expensive
+                    auto drvOutputs = drv.outputsAndOptPaths(*store);
+                    for (auto & output : bfd.outputs) {
+                        if (!outputHashes.count(output))
+                            throw Error(
+                                "the derivation '%s' doesn't have an output named '%s'",
+                                store->printStorePath(bfd.drvPath), output);
+                        if (settings.isExperimentalFeatureEnabled(
+                                Xp::CaDerivations)) {
+                            auto outputId =
+                                DrvOutput{outputHashes.at(output), output};
+                            auto realisation =
+                                store->queryRealisation(outputId);
+                            if (!realisation)
+                                throw Error(
+                                    "cannot operate on an output of unbuilt "
+                                    "content-addressed derivation '%s'",
+                                    outputId.to_string());
+                            outputs.insert_or_assign(
+                                output, realisation->outPath);
+                        } else {
+                            // If ca-derivations isn't enabled, assume that
+                            // the output path is statically known.
+                            assert(drvOutputs.count(output));
+                            assert(drvOutputs.at(output).second);
+                            outputs.insert_or_assign(
+                                output, *drvOutputs.at(output).second);
+                        }
+                    }
+                    res.push_back(BuiltPath::Built{bfd.drvPath, outputs});
+                },
+            },
+            b.raw());
+
     return res;
 }
 
-std::vector<std::pair<std::shared_ptr<Installable>, BuiltPath>> Installable::build2(
+BuiltPaths build(
     ref<Store> evalStore,
     ref<Store> store,
     Realise mode,
@@ -857,98 +795,21 @@ std::vector<std::pair<std::shared_ptr<Installable>, BuiltPath>> Installable::bui
         settings.readOnlyMode = true;
 
     std::vector<DerivedPath> pathsToBuild;
-    std::map<DerivedPath, std::vector<std::shared_ptr<Installable>>> backmap;
 
     for (auto & i : installables) {
-        for (auto b : i->toDerivedPaths()) {
-            pathsToBuild.push_back(b);
-            backmap[b].push_back(i);
-        }
+        auto b = i->toDerivedPaths();
+        pathsToBuild.insert(pathsToBuild.end(), b.begin(), b.end());
     }
 
-    std::vector<std::pair<std::shared_ptr<Installable>, BuiltPath>> res;
-
-    switch (mode) {
-
-    case Realise::Nothing:
-    case Realise::Derivation:
+    if (mode == Realise::Nothing || mode == Realise::Derivation)
         printMissing(store, pathsToBuild, lvlError);
+    else if (mode == Realise::Outputs)
+        store->buildPaths(pathsToBuild, bMode, evalStore);
 
-        for (auto & path : pathsToBuild) {
-            for (auto & installable : backmap[path]) {
-                std::visit(overloaded {
-                    [&](const DerivedPath::Built & bfd) {
-                        OutputPathMap outputs;
-                        auto drv = evalStore->readDerivation(bfd.drvPath);
-                        auto outputHashes = staticOutputHashes(*evalStore, drv); // FIXME: expensive
-                        auto drvOutputs = drv.outputsAndOptPaths(*store);
-                        for (auto & output : bfd.outputs) {
-                            auto outputHash = get(outputHashes, output);
-                            if (!outputHash)
-                                throw Error(
-                                    "the derivation '%s' doesn't have an output named '%s'",
-                                    store->printStorePath(bfd.drvPath), output);
-                            if (settings.isExperimentalFeatureEnabled(Xp::CaDerivations)) {
-                                DrvOutput outputId { *outputHash, output };
-                                auto realisation = store->queryRealisation(outputId);
-                                if (!realisation)
-                                    throw Error(
-                                        "cannot operate on an output of the "
-                                        "unbuilt derivation '%s'",
-                                        outputId.to_string());
-                                outputs.insert_or_assign(output, realisation->outPath);
-                            } else {
-                                // If ca-derivations isn't enabled, assume that
-                                // the output path is statically known.
-                                auto drvOutput = get(drvOutputs, output);
-                                assert(drvOutput);
-                                assert(drvOutput->second);
-                                outputs.insert_or_assign(
-                                    output, *drvOutput->second);
-                            }
-                        }
-                        res.push_back({installable, BuiltPath::Built { bfd.drvPath, outputs }});
-                    },
-                    [&](const DerivedPath::Opaque & bo) {
-                        res.push_back({installable, BuiltPath::Opaque { bo.path }});
-                    },
-                }, path.raw());
-            }
-        }
-
-        break;
-
-    case Realise::Outputs: {
-        for (auto & buildResult : store->buildPathsWithResults(pathsToBuild, bMode, evalStore)) {
-            if (!buildResult.success())
-                buildResult.rethrow();
-
-            for (auto & installable : backmap[buildResult.path]) {
-                std::visit(overloaded {
-                    [&](const DerivedPath::Built & bfd) {
-                        std::map<std::string, StorePath> outputs;
-                        for (auto & path : buildResult.builtOutputs)
-                            outputs.emplace(path.first.outputName, path.second.outPath);
-                        res.push_back({installable, BuiltPath::Built { bfd.drvPath, outputs }});
-                    },
-                    [&](const DerivedPath::Opaque & bo) {
-                        res.push_back({installable, BuiltPath::Opaque { bo.path }});
-                    },
-                }, buildResult.path.raw());
-            }
-        }
-
-        break;
-    }
-
-    default:
-        assert(false);
-    }
-
-    return res;
+    return getBuiltPaths(evalStore, store, pathsToBuild);
 }
 
-BuiltPaths Installable::toBuiltPaths(
+BuiltPaths toBuiltPaths(
     ref<Store> evalStore,
     ref<Store> store,
     Realise mode,
@@ -956,19 +817,19 @@ BuiltPaths Installable::toBuiltPaths(
     const std::vector<std::shared_ptr<Installable>> & installables)
 {
     if (operateOn == OperateOn::Output)
-        return Installable::build(evalStore, store, mode, installables);
+        return build(evalStore, store, mode, installables);
     else {
         if (mode == Realise::Nothing)
             settings.readOnlyMode = true;
 
         BuiltPaths res;
-        for (auto & drvPath : Installable::toDerivations(store, installables, true))
+        for (auto & drvPath : toDerivations(store, installables, true))
             res.push_back(BuiltPath::Opaque{drvPath});
         return res;
     }
 }
 
-StorePathSet Installable::toStorePaths(
+StorePathSet toStorePaths(
     ref<Store> evalStore,
     ref<Store> store,
     Realise mode, OperateOn operateOn,
@@ -982,7 +843,7 @@ StorePathSet Installable::toStorePaths(
     return outPaths;
 }
 
-StorePath Installable::toStorePath(
+StorePath toStorePath(
     ref<Store> evalStore,
     ref<Store> store,
     Realise mode, OperateOn operateOn,
@@ -996,7 +857,7 @@ StorePath Installable::toStorePath(
     return *paths.begin();
 }
 
-StorePathSet Installable::toDerivations(
+StorePathSet toDerivations(
     ref<Store> store,
     const std::vector<std::shared_ptr<Installable>> & installables,
     bool useDeriver)
@@ -1033,7 +894,7 @@ InstallablesCommand::InstallablesCommand()
 void InstallablesCommand::prepare()
 {
     if (_installables.empty() && useDefaultInstallables())
-        // FIXME: commands like "nix profile install" should not have a
+        // FIXME: commands like "nix install" should not have a
         // default, probably.
         _installables.push_back(".");
     installables = parseInstallables(getStore(), _installables);
@@ -1043,14 +904,13 @@ std::optional<FlakeRef> InstallablesCommand::getFlakeRefForCompletion()
 {
     if (_installables.empty()) {
         if (useDefaultInstallables())
-            return parseFlakeRefWithFragment(".", absPath(".")).first;
+            return parseFlakeRef(".", absPath("."));
         return {};
     }
-    return parseFlakeRefWithFragment(_installables.front(), absPath(".")).first;
+    return parseFlakeRef(_installables.front(), absPath("."));
 }
 
-InstallableCommand::InstallableCommand(bool supportReadOnlyMode)
-    : SourceExprCommand(supportReadOnlyMode)
+InstallableCommand::InstallableCommand()
 {
     expectArgs({
         .label = "installable",

src/libcmd/installables.hh

@@ -5,7 +5,6 @@
 #include "path-with-outputs.hh"
 #include "derived-path.hh"
 #include "eval.hh"
-#include "store-api.hh"
 #include "flake/flake.hh"
 
 #include <optional>
@@ -30,27 +29,6 @@ struct UnresolvedApp
     App resolve(ref<Store> evalStore, ref<Store> store);
 };
 
-enum class Realise {
-    /* Build the derivation. Postcondition: the
-       derivation outputs exist. */
-    Outputs,
-    /* Don't build the derivation. Postcondition: the store derivation
-       exists. */
-    Derivation,
-    /* Evaluate in dry-run mode. Postcondition: nothing. */
-    // FIXME: currently unused, but could be revived if we can
-    // evaluate derivations in-memory.
-    Nothing
-};
-
-/* How to handle derivations in commands that operate on store paths. */
-enum class OperateOn {
-    /* Operate on the output path. */
-    Output,
-    /* Operate on the .drv path. */
-    Derivation
-};
-
 struct Installable
 {
     virtual ~Installable() { }
@@ -68,7 +46,7 @@ struct Installable
 
     UnresolvedApp toApp(EvalState & state);
 
-    virtual std::pair<Value *, PosIdx> toValue(EvalState & state)
+    virtual std::pair<Value *, Pos> toValue(EvalState & state)
     {
         throw Error("argument '%s' cannot be evaluated", what());
     }
@@ -80,56 +58,16 @@ struct Installable
         return {};
     }
 
-    virtual std::vector<ref<eval_cache::AttrCursor>>
+    virtual std::vector<std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>>
     getCursors(EvalState & state);
 
-    virtual ref<eval_cache::AttrCursor>
+    std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>
     getCursor(EvalState & state);
 
     virtual FlakeRef nixpkgsFlakeRef() const
     {
         return FlakeRef::fromAttrs({{"type","indirect"}, {"id", "nixpkgs"}});
     }
-
-    static BuiltPaths build(
-        ref<Store> evalStore,
-        ref<Store> store,
-        Realise mode,
-        const std::vector<std::shared_ptr<Installable>> & installables,
-        BuildMode bMode = bmNormal);
-
-    static std::vector<std::pair<std::shared_ptr<Installable>, BuiltPath>> build2(
-        ref<Store> evalStore,
-        ref<Store> store,
-        Realise mode,
-        const std::vector<std::shared_ptr<Installable>> & installables,
-        BuildMode bMode = bmNormal);
-
-    static std::set<StorePath> toStorePaths(
-        ref<Store> evalStore,
-        ref<Store> store,
-        Realise mode,
-        OperateOn operateOn,
-        const std::vector<std::shared_ptr<Installable>> & installables);
-
-    static StorePath toStorePath(
-        ref<Store> evalStore,
-        ref<Store> store,
-        Realise mode,
-        OperateOn operateOn,
-        std::shared_ptr<Installable> installable);
-
-    static std::set<StorePath> toDerivations(
-        ref<Store> store,
-        const std::vector<std::shared_ptr<Installable>> & installables,
-        bool useDeriver = false);
-
-    static BuiltPaths toBuiltPaths(
-        ref<Store> evalStore,
-        ref<Store> store,
-        Realise mode,
-        OperateOn operateOn,
-        const std::vector<std::shared_ptr<Installable>> & installables);
 };
 
 struct InstallableValue : Installable
@@ -141,8 +79,8 @@ struct InstallableValue : Installable
     struct DerivationInfo
     {
         StorePath drvPath;
-        std::set<std::string> outputsToInstall;
-        std::optional<NixInt> priority;
+        std::optional<StorePath> outPath;
+        std::string outputName;
     };
 
     virtual std::vector<DerivationInfo> toDerivations() = 0;
@@ -157,7 +95,6 @@ struct InstallableFlake : InstallableValue
     FlakeRef flakeRef;
     Strings attrPaths;
     Strings prefixes;
-    OutputsSpec outputsSpec;
     const flake::LockFlags & lockFlags;
     mutable std::shared_ptr<flake::LockedFlake> _lockedFlake;
 
@@ -166,7 +103,6 @@ struct InstallableFlake : InstallableValue
         ref<EvalState> state,
         FlakeRef && flakeRef,
         std::string_view fragment,
-        OutputsSpec outputsSpec,
         Strings attrPaths,
         Strings prefixes,
         const flake::LockFlags & lockFlags);
@@ -181,17 +117,11 @@ struct InstallableFlake : InstallableValue
 
     std::vector<DerivationInfo> toDerivations() override;
 
-    std::pair<Value *, PosIdx> toValue(EvalState & state) override;
+    std::pair<Value *, Pos> toValue(EvalState & state) override;
 
-    /* Get a cursor to every attrpath in getActualAttrPaths() that
-       exists. */
-    std::vector<ref<eval_cache::AttrCursor>>
+    std::vector<std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>>
     getCursors(EvalState & state) override;
 
-    /* Get a cursor to the first attrpath in getActualAttrPaths() that
-       exists, or throw an exception with suggestions if none exists. */
-    ref<eval_cache::AttrCursor> getCursor(EvalState & state) override;
-
     std::shared_ptr<flake::LockedFlake> getLockedFlake() const;
 
     FlakeRef nixpkgsFlakeRef() const override;

src/libcmd/local.mk

@@ -6,9 +6,9 @@ libcmd_DIR := $(d)
 
 libcmd_SOURCES := $(wildcard $(d)/*.cc)
 
-libcmd_CXXFLAGS += -I src/libutil -I src/libstore -I src/libexpr -I src/libmain -I src/libfetchers -I src/nix
+libcmd_CXXFLAGS += -I src/libutil -I src/libstore -I src/libexpr -I src/libmain -I src/libfetchers
 
-libcmd_LDFLAGS = $(EDITLINE_LIBS) -llowdown -pthread
+libcmd_LDFLAGS += $(LOWDOWN_LIBS) -pthread
 
 libcmd_LIBS = libstore libutil libexpr libmain libfetchers
 

src/libcmd/markdown.cc

@@ -9,12 +9,10 @@ namespace nix {
 
 std::string renderMarkdownToTerminal(std::string_view markdown)
 {
-    int windowWidth = getWindowSize().second;
-
     struct lowdown_opts opts {
         .type = LOWDOWN_TERM,
         .maxdepth = 20,
-        .cols = (size_t) std::max(windowWidth - 5, 60),
+        .cols = std::max(getWindowSize().second, (unsigned short) 80),
         .hmargin = 0,
         .vmargin = 0,
         .feat = LOWDOWN_COMMONMARK | LOWDOWN_FENCED | LOWDOWN_DEFLIST | LOWDOWN_TABLES,

src/libexpr/attr-path.cc

@@ -9,7 +9,7 @@ namespace nix {
 static Strings parseAttrPath(std::string_view s)
 {
     Strings res;
-    std::string cur;
+    string cur;
     auto i = s.begin();
     while (i != s.end()) {
         if (*i == '.') {
@@ -41,13 +41,13 @@ std::vector<Symbol> parseAttrPath(EvalState & state, std::string_view s)
 }
 
 
-std::pair<Value *, PosIdx> findAlongAttrPath(EvalState & state, const std::string & attrPath,
+std::pair<Value *, Pos> findAlongAttrPath(EvalState & state, const string & attrPath,
     Bindings & autoArgs, Value & vIn)
 {
     Strings tokens = parseAttrPath(attrPath);
 
     Value * v = &vIn;
-    PosIdx pos = noPos;
+    Pos pos = noPos;
 
     for (auto & attr : tokens) {
 
@@ -74,16 +74,10 @@ std::pair<Value *, PosIdx> findAlongAttrPath(EvalState & state, const std::strin
                 throw Error("empty attribute name in selection path '%1%'", attrPath);
 
             Bindings::iterator a = v->attrs->find(state.symbols.create(attr));
-            if (a == v->attrs->end()) {
-                std::set<std::string> attrNames;
-                for (auto & attr : *v->attrs)
-                    attrNames.insert(state.symbols[attr.name]);
-
-                auto suggestions = Suggestions::bestMatches(attrNames, attr);
-                throw AttrPathNotFound(suggestions, "attribute '%1%' in selection path '%2%' not found", attr, attrPath);
-            }
+            if (a == v->attrs->end())
+                throw AttrPathNotFound("attribute '%1%' in selection path '%2%' not found", attr, attrPath);
             v = &*a->value;
-            pos = a->pos;
+            pos = *a->pos;
         }
 
         else {
@@ -106,7 +100,7 @@ std::pair<Value *, PosIdx> findAlongAttrPath(EvalState & state, const std::strin
 }
 
 
-std::pair<std::string, uint32_t> findPackageFilename(EvalState & state, Value & v, std::string what)
+Pos findPackageFilename(EvalState & state, Value & v, std::string what)
 {
     Value * v2;
     try {
@@ -127,12 +121,14 @@ std::pair<std::string, uint32_t> findPackageFilename(EvalState & state, Value &
     std::string filename(pos, 0, colon);
     unsigned int lineno;
     try {
-        lineno = std::stoi(std::string(pos, colon + 1, std::string::npos));
+        lineno = std::stoi(std::string(pos, colon + 1, string::npos));
     } catch (std::invalid_argument & e) {
         throw ParseError("cannot parse line number '%s'", pos);
     }
 
-    return { std::move(filename), lineno };
+    Symbol file = state.symbols.create(filename);
+
+    return { foFile, file, lineno, 0 };
 }
 
 

src/libexpr/attr-path.hh

@@ -10,14 +10,11 @@ namespace nix {
 MakeError(AttrPathNotFound, Error);
 MakeError(NoPositionInfo, Error);
 
-std::pair<Value *, PosIdx> findAlongAttrPath(
-    EvalState & state,
-    const std::string & attrPath,
-    Bindings & autoArgs,
-    Value & vIn);
+std::pair<Value *, Pos> findAlongAttrPath(EvalState & state, const string & attrPath,
+    Bindings & autoArgs, Value & vIn);
 
 /* Heuristic to find the filename and lineno or a nix value. */
-std::pair<std::string, uint32_t> findPackageFilename(EvalState & state, Value & v, std::string what);
+Pos findPackageFilename(EvalState & state, Value & v, std::string what);
 
 std::vector<Symbol> parseAttrPath(EvalState & state, std::string_view s);
 

src/libexpr/attr-set.cc

@@ -26,7 +26,7 @@ Bindings * EvalState::allocBindings(size_t capacity)
 /* Create a new attribute named 'name' on an existing attribute set stored
    in 'vAttrs' and return the newly allocated Value which is associated with
    this attribute. */
-Value * EvalState::allocAttr(Value & vAttrs, Symbol name)
+Value * EvalState::allocAttr(Value & vAttrs, const Symbol & name)
 {
     Value * v = allocValue();
     vAttrs.attrs->push_back(Attr(name, v));
@@ -40,7 +40,7 @@ Value * EvalState::allocAttr(Value & vAttrs, std::string_view name)
 }
 
 
-Value & BindingsBuilder::alloc(Symbol name, PosIdx pos)
+Value & BindingsBuilder::alloc(const Symbol & name, ptr<Pos> pos)
 {
     auto value = state.allocValue();
     bindings->push_back(Attr(name, value, pos));
@@ -48,7 +48,7 @@ Value & BindingsBuilder::alloc(Symbol name, PosIdx pos)
 }
 
 
-Value & BindingsBuilder::alloc(std::string_view name, PosIdx pos)
+Value & BindingsBuilder::alloc(std::string_view name, ptr<Pos> pos)
 {
     return alloc(state.symbols.create(name), pos);
 }

src/libexpr/attr-set.hh

@@ -15,27 +15,18 @@ struct Value;
 /* Map one attribute name to its value. */
 struct Attr
 {
-    /* the placement of `name` and `pos` in this struct is important.
-       both of them are uint32 wrappers, they are next to each other
-       to make sure that Attr has no padding on 64 bit machines. that
-       way we keep Attr size at two words with no wasted space. */
     Symbol name;
-    PosIdx pos;
     Value * value;
-    Attr(Symbol name, Value * value, PosIdx pos = noPos)
-        : name(name), pos(pos), value(value) { };
-    Attr() { };
+    ptr<Pos> pos;
+    Attr(Symbol name, Value * value, ptr<Pos> pos = ptr(&noPos))
+        : name(name), value(value), pos(pos) { };
+    Attr() : pos(&noPos) { };
     bool operator < (const Attr & a) const
     {
         return name < a.name;
     }
 };
 
-static_assert(sizeof(Attr) == 2 * sizeof(uint32_t) + sizeof(Value *),
-    "performance of the evaluator is highly sensitive to the size of Attr. "
-    "avoid introducing any padding into Attr if at all possible, and do not "
-    "introduce new fields that need not be present for almost every instance.");
-
 /* Bindings contains all the attributes of an attribute set. It is defined
    by its size and its capacity, the capacity being the number of Attr
    elements allocated after this structure, while the size corresponds to
@@ -44,13 +35,13 @@ class Bindings
 {
 public:
     typedef uint32_t size_t;
-    PosIdx pos;
+    ptr<Pos> pos;
 
 private:
     size_t size_, capacity_;
     Attr attrs[0];
 
-    Bindings(size_t capacity) : size_(0), capacity_(capacity) { }
+    Bindings(size_t capacity) : pos(&noPos), size_(0), capacity_(capacity) { }
     Bindings(const Bindings & bindings) = delete;
 
 public:
@@ -66,7 +57,7 @@ public:
         attrs[size_++] = attr;
     }
 
-    iterator find(Symbol name)
+    iterator find(const Symbol & name)
     {
         Attr key(name, 0);
         iterator i = std::lower_bound(begin(), end(), key);
@@ -74,7 +65,7 @@ public:
         return end();
     }
 
-    Attr * get(Symbol name)
+    Attr * get(const Symbol & name)
     {
         Attr key(name, 0);
         iterator i = std::lower_bound(begin(), end(), key);
@@ -82,6 +73,18 @@ public:
         return nullptr;
     }
 
+    Attr & need(const Symbol & name, const Pos & pos = noPos)
+    {
+        auto a = get(name);
+        if (!a)
+            throw Error({
+                .msg = hintfmt("attribute '%s' missing", name),
+                .errPos = pos
+            });
+
+        return *a;
+    }
+
     iterator begin() { return &attrs[0]; }
     iterator end() { return &attrs[size_]; }
 
@@ -95,15 +98,14 @@ public:
     size_t capacity() { return capacity_; }
 
     /* Returns the attributes in lexicographically sorted order. */
-    std::vector<const Attr *> lexicographicOrder(const SymbolTable & symbols) const
+    std::vector<const Attr *> lexicographicOrder() const
     {
         std::vector<const Attr *> res;
         res.reserve(size_);
         for (size_t n = 0; n < size_; n++)
             res.emplace_back(&attrs[n]);
-        std::sort(res.begin(), res.end(), [&](const Attr * a, const Attr * b) {
-            std::string_view sa = symbols[a->name], sb = symbols[b->name];
-            return sa < sb;
+        std::sort(res.begin(), res.end(), [](const Attr * a, const Attr * b) {
+            return (const string &) a->name < (const string &) b->name;
         });
         return res;
     }
@@ -128,7 +130,7 @@ public:
         : bindings(bindings), state(state)
     { }
 
-    void insert(Symbol name, Value * value, PosIdx pos = noPos)
+    void insert(Symbol name, Value * value, ptr<Pos> pos = ptr(&noPos))
     {
         insert(Attr(name, value, pos));
     }
@@ -143,9 +145,9 @@ public:
         bindings->push_back(attr);
     }
 
-    Value & alloc(Symbol name, PosIdx pos = noPos);
+    Value & alloc(const Symbol & name, ptr<Pos> pos = ptr(&noPos));
 
-    Value & alloc(std::string_view name, PosIdx pos = noPos);
+    Value & alloc(std::string_view name, ptr<Pos> pos = ptr(&noPos));
 
     Bindings * finish()
     {

src/libexpr/common-eval-args.cc

@@ -7,7 +7,6 @@
 #include "registry.hh"
 #include "flake/flakeref.hh"
 #include "store-api.hh"
-#include "command.hh"
 
 namespace nix {
 
@@ -60,9 +59,6 @@ MixEvalArgs::MixEvalArgs()
             fetchers::Attrs extraAttrs;
             if (to.subdir != "") extraAttrs["dir"] = to.subdir;
             fetchers::overrideRegistry(from.input, to.input, extraAttrs);
-        }},
-        .completer = {[&](size_t, std::string_view prefix) {
-            completeFlakeRef(openStore(), prefix);
         }}
     });
 
@@ -81,7 +77,7 @@ Bindings * MixEvalArgs::getAutoArgs(EvalState & state)
     for (auto & i : autoArgs) {
         auto v = state.allocValue();
         if (i.second[0] == 'E')
-            state.mkThunk_(*v, state.parseExprFromString(i.second.substr(1), absPath(".")));
+            state.mkThunk_(*v, state.parseExprFromString(string(i.second, 1), absPath(".")));
         else
             v->mkString(((std::string_view) i.second).substr(1));
         res.insert(state.symbols.create(i.first), v);
@@ -89,17 +85,17 @@ Bindings * MixEvalArgs::getAutoArgs(EvalState & state)
     return res.finish();
 }
 
-Path lookupFileArg(EvalState & state, std::string_view s)
+Path lookupFileArg(EvalState & state, string s)
 {
     if (isUri(s)) {
         return state.store->toRealPath(
             fetchers::downloadTarball(
                 state.store, resolveUri(s), "source", false).first.storePath);
     } else if (s.size() > 2 && s.at(0) == '<' && s.at(s.size() - 1) == '>') {
-        Path p(s.substr(1, s.size() - 2));
+        Path p = s.substr(1, s.size() - 2);
         return state.findFile(p);
     } else
-        return absPath(std::string(s));
+        return absPath(s);
 }
 
 }

src/libexpr/common-eval-args.hh

@@ -22,6 +22,6 @@ private:
     std::map<std::string, std::string> autoArgs;
 };
 
-Path lookupFileArg(EvalState & state, std::string_view s);
+Path lookupFileArg(EvalState & state, string s);
 
 }

src/libexpr/eval-cache.cc

@@ -21,8 +21,6 @@ struct AttrDb
 {
     std::atomic_bool failed{false};
 
-    const Store & cfg;
-
     struct State
     {
         SQLite db;
@@ -35,19 +33,12 @@ struct AttrDb
 
     std::unique_ptr<Sync<State>> _state;
 
-    SymbolTable & symbols;
-
-    AttrDb(
-        const Store & cfg,
-        const Hash & fingerprint,
-        SymbolTable & symbols)
-        : cfg(cfg)
-        , _state(std::make_unique<Sync<State>>())
-        , symbols(symbols)
+    AttrDb(const Hash & fingerprint)
+        : _state(std::make_unique<Sync<State>>())
     {
         auto state(_state->lock());
 
-        Path cacheDir = getCacheDir() + "/nix/eval-cache-v4";
+        Path cacheDir = getCacheDir() + "/nix/eval-cache-v2";
         createDirs(cacheDir);
 
         Path dbPath = cacheDir + "/" + fingerprint.to_string(Base16, false) + ".sqlite";
@@ -106,7 +97,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (symbols[key.second])
+                (key.second)
                 (AttrType::FullAttrs)
                 (0, false).exec();
 
@@ -116,7 +107,7 @@ struct AttrDb
             for (auto & attr : attrs)
                 state->insertAttribute.use()
                     (rowId)
-                    (symbols[attr])
+                    (attr)
                     (AttrType::Placeholder)
                     (0, false).exec();
 
@@ -141,14 +132,14 @@ struct AttrDb
                 }
                 state->insertAttributeWithContext.use()
                     (key.first)
-                    (symbols[key.second])
+                    (key.second)
                     (AttrType::String)
                     (s)
                     (ctx).exec();
             } else {
                 state->insertAttribute.use()
                     (key.first)
-                    (symbols[key.second])
+                    (key.second)
                     (AttrType::String)
                 (s).exec();
             }
@@ -167,7 +158,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (symbols[key.second])
+                (key.second)
                 (AttrType::Bool)
                 (b ? 1 : 0).exec();
 
@@ -175,42 +166,6 @@ struct AttrDb
         });
     }
 
-    AttrId setInt(
-        AttrKey key,
-        int n)
-    {
-        return doSQLite([&]()
-        {
-            auto state(_state->lock());
-
-            state->insertAttribute.use()
-                (key.first)
-                (symbols[key.second])
-                (AttrType::Int)
-                (n).exec();
-
-            return state->db.getLastInsertedRowId();
-        });
-    }
-
-    AttrId setListOfStrings(
-        AttrKey key,
-        const std::vector<std::string> & l)
-    {
-        return doSQLite([&]()
-        {
-            auto state(_state->lock());
-
-            state->insertAttribute.use()
-                (key.first)
-                (symbols[key.second])
-                (AttrType::ListOfStrings)
-                (concatStringsSep("\t", l)).exec();
-
-            return state->db.getLastInsertedRowId();
-        });
-    }
-
     AttrId setPlaceholder(AttrKey key)
     {
         return doSQLite([&]()
@@ -219,7 +174,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (symbols[key.second])
+                (key.second)
                 (AttrType::Placeholder)
                 (0, false).exec();
 
@@ -235,7 +190,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (symbols[key.second])
+                (key.second)
                 (AttrType::Missing)
                 (0, false).exec();
 
@@ -251,7 +206,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (symbols[key.second])
+                (key.second)
                 (AttrType::Misc)
                 (0, false).exec();
 
@@ -267,7 +222,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (symbols[key.second])
+                (key.second)
                 (AttrType::Failed)
                 (0, false).exec();
 
@@ -275,11 +230,13 @@ struct AttrDb
         });
     }
 
-    std::optional<std::pair<AttrId, AttrValue>> getAttr(AttrKey key)
+    std::optional<std::pair<AttrId, AttrValue>> getAttr(
+        AttrKey key,
+        SymbolTable & symbols)
     {
         auto state(_state->lock());
 
-        auto queryAttribute(state->queryAttribute.use()(key.first)(symbols[key.second]));
+        auto queryAttribute(state->queryAttribute.use()(key.first)(key.second));
         if (!queryAttribute.next()) return {};
 
         auto rowId = (AttrType) queryAttribute.getInt(0);
@@ -293,22 +250,18 @@ struct AttrDb
                 std::vector<Symbol> attrs;
                 auto queryAttributes(state->queryAttributes.use()(rowId));
                 while (queryAttributes.next())
-                    attrs.emplace_back(symbols.create(queryAttributes.getStr(0)));
+                    attrs.push_back(symbols.create(queryAttributes.getStr(0)));
                 return {{rowId, attrs}};
             }
             case AttrType::String: {
-                NixStringContext context;
+                std::vector<std::pair<Path, std::string>> context;
                 if (!queryAttribute.isNull(3))
                     for (auto & s : tokenizeString<std::vector<std::string>>(queryAttribute.getStr(3), ";"))
-                        context.push_back(decodeContext(cfg, s));
+                        context.push_back(decodeContext(s));
                 return {{rowId, string_t{queryAttribute.getStr(2), context}}};
             }
             case AttrType::Bool:
                 return {{rowId, queryAttribute.getInt(2) != 0}};
-            case AttrType::Int:
-                return {{rowId, int_t{queryAttribute.getInt(2)}}};
-            case AttrType::ListOfStrings:
-                return {{rowId, tokenizeString<std::vector<std::string>>(queryAttribute.getStr(2), "\t")}};
             case AttrType::Missing:
                 return {{rowId, missing_t()}};
             case AttrType::Misc:
@@ -321,13 +274,10 @@ struct AttrDb
     }
 };
 
-static std::shared_ptr<AttrDb> makeAttrDb(
-    const Store & cfg,
-    const Hash & fingerprint,
-    SymbolTable & symbols)
+static std::shared_ptr<AttrDb> makeAttrDb(const Hash & fingerprint)
 {
     try {
-        return std::make_shared<AttrDb>(cfg, fingerprint, symbols);
+        return std::make_shared<AttrDb>(fingerprint);
     } catch (SQLiteError &) {
         ignoreException();
         return nullptr;
@@ -338,7 +288,7 @@ EvalCache::EvalCache(
     std::optional<std::reference_wrapper<const Hash>> useCache,
     EvalState & state,
     RootLoader rootLoader)
-    : db(useCache ? makeAttrDb(*state.store, *useCache, state.symbols) : nullptr)
+    : db(useCache ? makeAttrDb(*useCache) : nullptr)
     , state(state)
     , rootLoader(rootLoader)
 {
@@ -353,9 +303,9 @@ Value * EvalCache::getRootValue()
     return *value;
 }
 
-ref<AttrCursor> EvalCache::getRoot()
+std::shared_ptr<AttrCursor> EvalCache::getRoot()
 {
-    return make_ref<AttrCursor>(ref(shared_from_this()), std::nullopt);
+    return std::make_shared<AttrCursor>(ref(shared_from_this()), std::nullopt);
 }
 
 AttrCursor::AttrCursor(
@@ -374,7 +324,8 @@ AttrKey AttrCursor::getKey()
     if (!parent)
         return {0, root->state.sEpsilon};
     if (!parent->first->cachedValue) {
-        parent->first->cachedValue = root->db->getAttr(parent->first->getKey());
+        parent->first->cachedValue = root->db->getAttr(
+            parent->first->getKey(), root->state.symbols);
         assert(parent->first->cachedValue);
     }
     return {parent->first->cachedValue->first, parent->second};
@@ -415,17 +366,17 @@ std::vector<Symbol> AttrCursor::getAttrPath(Symbol name) const
 
 std::string AttrCursor::getAttrPathStr() const
 {
-    return concatStringsSep(".", root->state.symbols.resolve(getAttrPath()));
+    return concatStringsSep(".", getAttrPath());
 }
 
 std::string AttrCursor::getAttrPathStr(Symbol name) const
 {
-    return concatStringsSep(".", root->state.symbols.resolve(getAttrPath(name)));
+    return concatStringsSep(".", getAttrPath(name));
 }
 
 Value & AttrCursor::forceValue()
 {
-    debug("evaluating uncached attribute '%s'", getAttrPathStr());
+    debug("evaluating uncached attribute %s", getAttrPathStr());
 
     auto & v = getValue();
 
@@ -446,8 +397,6 @@ Value & AttrCursor::forceValue()
             cachedValue = {root->db->setString(getKey(), v.path), string_t{v.path, {}}};
         else if (v.type() == nBool)
             cachedValue = {root->db->setBool(getKey(), v.boolean), v.boolean};
-        else if (v.type() == nInt)
-            cachedValue = {root->db->setInt(getKey(), v.integer), int_t{v.integer}};
         else if (v.type() == nAttrs)
             ; // FIXME: do something?
         else
@@ -457,30 +406,20 @@ Value & AttrCursor::forceValue()
     return v;
 }
 
-Suggestions AttrCursor::getSuggestionsForAttr(Symbol name)
-{
-    auto attrNames = getAttrs();
-    std::set<std::string> strAttrNames;
-    for (auto & name : attrNames)
-        strAttrNames.insert(root->state.symbols[name]);
-
-    return Suggestions::bestMatches(strAttrNames, root->state.symbols[name]);
-}
-
 std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(Symbol name, bool forceErrors)
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey());
+            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
 
         if (cachedValue) {
             if (auto attrs = std::get_if<std::vector<Symbol>>(&cachedValue->second)) {
                 for (auto & attr : *attrs)
                     if (attr == name)
-                        return std::make_shared<AttrCursor>(root, std::make_pair(shared_from_this(), attr));
+                        return std::make_shared<AttrCursor>(root, std::make_pair(shared_from_this(), name));
                 return nullptr;
             } else if (std::get_if<placeholder_t>(&cachedValue->second)) {
-                auto attr = root->db->getAttr({cachedValue->first, name});
+                auto attr = root->db->getAttr({cachedValue->first, name}, root->state.symbols);
                 if (attr) {
                     if (std::get_if<missing_t>(&attr->second))
                         return nullptr;
@@ -507,11 +446,6 @@ std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(Symbol name, bool forceErro
         return nullptr;
         //throw TypeError("'%s' is not an attribute set", getAttrPathStr());
 
-    for (auto & attr : *v.attrs) {
-        if (root->db)
-            root->db->setPlaceholder({cachedValue->first, attr.name});
-    }
-
     auto attr = v.attrs->get(name);
 
     if (!attr) {
@@ -530,7 +464,7 @@ std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(Symbol name, bool forceErro
         cachedValue2 = {root->db->setPlaceholder({cachedValue->first, name}), placeholder_t()};
     }
 
-    return make_ref<AttrCursor>(
+    return std::make_shared<AttrCursor>(
         root, std::make_pair(shared_from_this(), name), attr->value, std::move(cachedValue2));
 }
 
@@ -539,51 +473,47 @@ std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(std::string_view name)
     return maybeGetAttr(root->state.symbols.create(name));
 }
 
-ref<AttrCursor> AttrCursor::getAttr(Symbol name, bool forceErrors)
+std::shared_ptr<AttrCursor> AttrCursor::getAttr(Symbol name, bool forceErrors)
 {
     auto p = maybeGetAttr(name, forceErrors);
     if (!p)
         throw Error("attribute '%s' does not exist", getAttrPathStr(name));
-    return ref(p);
+    return p;
 }
 
-ref<AttrCursor> AttrCursor::getAttr(std::string_view name)
+std::shared_ptr<AttrCursor> AttrCursor::getAttr(std::string_view name)
 {
     return getAttr(root->state.symbols.create(name));
 }
 
-OrSuggestions<ref<AttrCursor>> AttrCursor::findAlongAttrPath(const std::vector<Symbol> & attrPath, bool force)
+std::shared_ptr<AttrCursor> AttrCursor::findAlongAttrPath(const std::vector<Symbol> & attrPath, bool force)
 {
     auto res = shared_from_this();
     for (auto & attr : attrPath) {
-        auto child = res->maybeGetAttr(attr, force);
-        if (!child) {
-            auto suggestions = res->getSuggestionsForAttr(attr);
-            return OrSuggestions<ref<AttrCursor>>::failed(suggestions);
-        }
-        res = child;
+        res = res->maybeGetAttr(attr, force);
+        if (!res) return {};
     }
-    return ref(res);
+    return res;
 }
 
 std::string AttrCursor::getString()
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey());
+            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
         if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
             if (auto s = std::get_if<string_t>(&cachedValue->second)) {
                 debug("using cached string attribute '%s'", getAttrPathStr());
                 return s->first;
             } else
-                root->state.debugThrowLastTrace(TypeError("'%s' is not a string", getAttrPathStr()));
+                throw TypeError("'%s' is not a string", getAttrPathStr());
         }
     }
 
     auto & v = forceValue();
 
     if (v.type() != nString && v.type() != nPath)
-        root->state.debugThrowLastTrace(TypeError("'%s' is not a string but %s", getAttrPathStr(), showType(v.type())));
+        throw TypeError("'%s' is not a string but %s", getAttrPathStr(), showType(v.type()));
 
     return v.type() == nString ? v.string.s : v.path;
 }
@@ -592,12 +522,12 @@ string_t AttrCursor::getStringWithContext()
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey());
+            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
         if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
             if (auto s = std::get_if<string_t>(&cachedValue->second)) {
                 bool valid = true;
                 for (auto & c : s->second) {
-                    if (!root->state.store->isValidPath(c.first)) {
+                    if (!root->state.store->isValidPath(root->state.store->parseStorePath(c.first))) {
                         valid = false;
                         break;
                     }
@@ -607,122 +537,66 @@ string_t AttrCursor::getStringWithContext()
                     return *s;
                 }
             } else
-                root->state.debugThrowLastTrace(TypeError("'%s' is not a string", getAttrPathStr()));
+                throw TypeError("'%s' is not a string", getAttrPathStr());
         }
     }
 
     auto & v = forceValue();
 
     if (v.type() == nString)
-        return {v.string.s, v.getContext(*root->state.store)};
+        return {v.string.s, v.getContext()};
     else if (v.type() == nPath)
         return {v.path, {}};
     else
-        root->state.debugThrowLastTrace(TypeError("'%s' is not a string but %s", getAttrPathStr(), showType(v.type())));
+        throw TypeError("'%s' is not a string but %s", getAttrPathStr(), showType(v.type()));
 }
 
 bool AttrCursor::getBool()
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey());
+            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
         if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
             if (auto b = std::get_if<bool>(&cachedValue->second)) {
                 debug("using cached Boolean attribute '%s'", getAttrPathStr());
                 return *b;
             } else
-                root->state.debugThrowLastTrace(TypeError("'%s' is not a Boolean", getAttrPathStr()));
+                throw TypeError("'%s' is not a Boolean", getAttrPathStr());
         }
     }
 
     auto & v = forceValue();
 
     if (v.type() != nBool)
-        root->state.debugThrowLastTrace(TypeError("'%s' is not a Boolean", getAttrPathStr()));
+        throw TypeError("'%s' is not a Boolean", getAttrPathStr());
 
     return v.boolean;
 }
 
-NixInt AttrCursor::getInt()
-{
-    if (root->db) {
-        if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey());
-        if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
-            if (auto i = std::get_if<int_t>(&cachedValue->second)) {
-                debug("using cached Integer attribute '%s'", getAttrPathStr());
-                return i->x;
-            } else
-                throw TypeError("'%s' is not an Integer", getAttrPathStr());
-        }
-    }
-
-    auto & v = forceValue();
-
-    if (v.type() != nInt)
-        throw TypeError("'%s' is not an Integer", getAttrPathStr());
-
-    return v.integer;
-}
-
-std::vector<std::string> AttrCursor::getListOfStrings()
-{
-    if (root->db) {
-        if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey());
-        if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
-            if (auto l = std::get_if<std::vector<std::string>>(&cachedValue->second)) {
-                debug("using cached list of strings attribute '%s'", getAttrPathStr());
-                return *l;
-            } else
-                throw TypeError("'%s' is not a list of strings", getAttrPathStr());
-        }
-    }
-
-    debug("evaluating uncached attribute '%s'", getAttrPathStr());
-
-    auto & v = getValue();
-    root->state.forceValue(v, noPos);
-
-    if (v.type() != nList)
-        throw TypeError("'%s' is not a list", getAttrPathStr());
-
-    std::vector<std::string> res;
-
-    for (auto & elem : v.listItems())
-        res.push_back(std::string(root->state.forceStringNoCtx(*elem)));
-
-    if (root->db)
-        cachedValue = {root->db->setListOfStrings(getKey(), res), res};
-
-    return res;
-}
-
 std::vector<Symbol> AttrCursor::getAttrs()
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey());
+            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
         if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
             if (auto attrs = std::get_if<std::vector<Symbol>>(&cachedValue->second)) {
                 debug("using cached attrset attribute '%s'", getAttrPathStr());
                 return *attrs;
             } else
-                root->state.debugThrowLastTrace(TypeError("'%s' is not an attribute set", getAttrPathStr()));
+                throw TypeError("'%s' is not an attribute set", getAttrPathStr());
         }
     }
 
     auto & v = forceValue();
 
     if (v.type() != nAttrs)
-        root->state.debugThrowLastTrace(TypeError("'%s' is not an attribute set", getAttrPathStr()));
+        throw TypeError("'%s' is not an attribute set", getAttrPathStr());
 
     std::vector<Symbol> attrs;
     for (auto & attr : *getValue().attrs)
         attrs.push_back(attr.name);
-    std::sort(attrs.begin(), attrs.end(), [&](Symbol a, Symbol b) {
-        std::string_view sa = root->state.symbols[a], sb = root->state.symbols[b];
-        return sa < sb;
+    std::sort(attrs.begin(), attrs.end(), [](const Symbol & a, const Symbol & b) {
+        return (const string &) a < (const string &) b;
     });
 
     if (root->db)

src/libexpr/eval-cache.hh

@@ -33,7 +33,7 @@ public:
         EvalState & state,
         RootLoader rootLoader);
 
-    ref<AttrCursor> getRoot();
+    std::shared_ptr<AttrCursor> getRoot();
 };
 
 enum AttrType {
@@ -44,18 +44,15 @@ enum AttrType {
     Misc = 4,
     Failed = 5,
     Bool = 6,
-    ListOfStrings = 7,
-    Int = 8,
 };
 
 struct placeholder_t {};
 struct missing_t {};
 struct misc_t {};
 struct failed_t {};
-struct int_t { NixInt x; };
 typedef uint64_t AttrId;
 typedef std::pair<AttrId, Symbol> AttrKey;
-typedef std::pair<std::string, NixStringContext> string_t;
+typedef std::pair<std::string, std::vector<std::pair<Path, std::string>>> string_t;
 
 typedef std::variant<
     std::vector<Symbol>,
@@ -64,9 +61,7 @@ typedef std::variant<
     missing_t,
     misc_t,
     failed_t,
-    bool,
-    int_t,
-    std::vector<std::string>
+    bool
     > AttrValue;
 
 class AttrCursor : public std::enable_shared_from_this<AttrCursor>
@@ -99,19 +94,15 @@ public:
 
     std::string getAttrPathStr(Symbol name) const;
 
-    Suggestions getSuggestionsForAttr(Symbol name);
-
     std::shared_ptr<AttrCursor> maybeGetAttr(Symbol name, bool forceErrors = false);
 
     std::shared_ptr<AttrCursor> maybeGetAttr(std::string_view name);
 
-    ref<AttrCursor> getAttr(Symbol name, bool forceErrors = false);
+    std::shared_ptr<AttrCursor> getAttr(Symbol name, bool forceErrors = false);
 
-    ref<AttrCursor> getAttr(std::string_view name);
+    std::shared_ptr<AttrCursor> getAttr(std::string_view name);
 
-    /* Get an attribute along a chain of attrsets. Note that this does
-       not auto-call functors or functions. */
-    OrSuggestions<ref<AttrCursor>> findAlongAttrPath(const std::vector<Symbol> & attrPath, bool force = false);
+    std::shared_ptr<AttrCursor> findAlongAttrPath(const std::vector<Symbol> & attrPath, bool force = false);
 
     std::string getString();
 
@@ -119,10 +110,6 @@ public:
 
     bool getBool();
 
-    NixInt getInt();
-
-    std::vector<std::string> getListOfStrings();
-
     std::vector<Symbol> getAttrs();
 
     bool isDerivation();

src/libexpr/eval-inline.hh

@@ -2,84 +2,29 @@
 
 #include "eval.hh"
 
+#define LocalNoInline(f) static f __attribute__((noinline)); f
+#define LocalNoInlineNoReturn(f) static f __attribute__((noinline, noreturn)); f
+
 namespace nix {
 
-/* Note: Various places expect the allocated memory to be zeroed. */
-[[gnu::always_inline]]
-inline void * allocBytes(size_t n)
+LocalNoInlineNoReturn(void throwEvalError(const Pos & pos, const char * s))
 {
-    void * p;
-#if HAVE_BOEHMGC
-    p = GC_MALLOC(n);
-#else
-    p = calloc(n, 1);
-#endif
-    if (!p) throw std::bad_alloc();
-    return p;
+    throw EvalError({
+        .msg = hintfmt(s),
+        .errPos = pos
+    });
+}
+
+LocalNoInlineNoReturn(void throwTypeError(const Pos & pos, const char * s, const Value & v))
+{
+    throw TypeError({
+        .msg = hintfmt(s, showType(v)),
+        .errPos = pos
+    });
 }
 
 
-[[gnu::always_inline]]
-Value * EvalState::allocValue()
-{
-#if HAVE_BOEHMGC
-    /* We use the boehm batch allocator to speed up allocations of Values (of which there are many).
-       GC_malloc_many returns a linked list of objects of the given size, where the first word
-       of each object is also the pointer to the next object in the list. This also means that we
-       have to explicitly clear the first word of every object we take. */
-    if (!*valueAllocCache) {
-        *valueAllocCache = GC_malloc_many(sizeof(Value));
-        if (!*valueAllocCache) throw std::bad_alloc();
-    }
-
-    /* GC_NEXT is a convenience macro for accessing the first word of an object.
-       Take the first list item, advance the list to the next item, and clear the next pointer. */
-    void * p = *valueAllocCache;
-    *valueAllocCache = GC_NEXT(p);
-    GC_NEXT(p) = nullptr;
-#else
-    void * p = allocBytes(sizeof(Value));
-#endif
-
-    nrValues++;
-    return (Value *) p;
-}
-
-
-[[gnu::always_inline]]
-Env & EvalState::allocEnv(size_t size)
-{
-    nrEnvs++;
-    nrValuesInEnvs += size;
-
-    Env * env;
-
-#if HAVE_BOEHMGC
-    if (size == 1) {
-        /* see allocValue for explanations. */
-        if (!*env1AllocCache) {
-            *env1AllocCache = GC_malloc_many(sizeof(Env) + sizeof(Value *));
-            if (!*env1AllocCache) throw std::bad_alloc();
-        }
-
-        void * p = *env1AllocCache;
-        *env1AllocCache = GC_NEXT(p);
-        GC_NEXT(p) = nullptr;
-        env = (Env *) p;
-    } else
-#endif
-        env = (Env *) allocBytes(sizeof(Env) + size * sizeof(Value *));
-
-    env->type = Env::Plain;
-
-    /* We assume that env->values has been cleared by the allocator; maybeThunk() and lookupVar fromWith expect this. */
-
-    return *env;
-}
-
-
-[[gnu::always_inline]]
-void EvalState::forceValue(Value & v, const PosIdx pos)
+void EvalState::forceValue(Value & v, const Pos & pos)
 {
     forceValue(v, [&]() { return pos; });
 }
@@ -107,15 +52,13 @@ void EvalState::forceValue(Value & v, Callable getPos)
 }
 
 
-[[gnu::always_inline]]
-inline void EvalState::forceAttrs(Value & v, const PosIdx pos)
+inline void EvalState::forceAttrs(Value & v, const Pos & pos)
 {
     forceAttrs(v, [&]() { return pos; });
 }
 
 
 template <typename Callable>
-[[gnu::always_inline]]
 inline void EvalState::forceAttrs(Value & v, Callable getPos)
 {
     forceValue(v, getPos);
@@ -124,13 +67,25 @@ inline void EvalState::forceAttrs(Value & v, Callable getPos)
 }
 
 
-[[gnu::always_inline]]
-inline void EvalState::forceList(Value & v, const PosIdx pos)
+inline void EvalState::forceList(Value & v, const Pos & pos)
 {
     forceValue(v, pos);
     if (!v.isList())
         throwTypeError(pos, "value is %1% while a list was expected", v);
 }
 
+/* Note: Various places expect the allocated memory to be zeroed. */
+inline void * allocBytes(size_t n)
+{
+    void * p;
+#if HAVE_BOEHMGC
+    p = GC_MALLOC(n);
+#else
+    p = calloc(n, 1);
+#endif
+    if (!p) throw std::bad_alloc();
+    return p;
+}
+
 
 }

src/libexpr/eval.hh

@@ -13,6 +13,7 @@
 #include <unordered_map>
 #include <mutex>
 
+
 namespace nix {
 
 
@@ -22,22 +23,18 @@ class StorePath;
 enum RepairFlag : bool;
 
 
-typedef void (* PrimOpFun) (EvalState & state, const PosIdx pos, Value * * args, Value & v);
+typedef void (* PrimOpFun) (EvalState & state, const Pos & pos, Value * * args, Value & v);
+
 
 struct PrimOp
 {
     PrimOpFun fun;
     size_t arity;
-    std::string name;
+    Symbol name;
     std::vector<std::string> args;
     const char * doc = nullptr;
 };
 
-#if HAVE_BOEHMGC
-    typedef std::map<std::string, Value *, std::less<std::string>, traceable_allocator<std::pair<const std::string, Value *> > > ValMap;
-#else
-    typedef std::map<std::string, Value *> ValMap;
-#endif
 
 struct Env
 {
@@ -47,10 +44,6 @@ struct Env
     Value * values[0];
 };
 
-void printEnvBindings(const EvalState &es, const Expr & expr, const Env & env);
-void printEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env, int lvl = 0);
-
-std::unique_ptr<ValMap> mapStaticEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env);
 
 void copyContext(const Value & v, PathSet & context);
 
@@ -60,9 +53,7 @@ void copyContext(const Value & v, PathSet & context);
 typedef std::map<Path, StorePath> SrcToStore;
 
 
-std::ostream & printValue(const EvalState & state, std::ostream & str, const Value & v);
-std::string printValue(const EvalState & state, const Value & v);
-std::ostream & operator << (std::ostream & os, const ValueType t);
+std::ostream & operator << (std::ostream & str, const Value & v);
 
 
 typedef std::pair<std::string, std::string> SearchPathElem;
@@ -77,34 +68,21 @@ struct RegexCache;
 
 std::shared_ptr<RegexCache> makeRegexCache();
 
-struct DebugTrace {
-    std::optional<ErrPos> pos;
-    const Expr & expr;
-    const Env & env;
-    hintformat hint;
-    bool isError;
-};
 
-void debugError(Error * e, Env & env, Expr & expr);
-
-class EvalState : public std::enable_shared_from_this<EvalState>
+class EvalState
 {
 public:
     SymbolTable symbols;
-    PosTable positions;
-
-    static inline std::string derivationNixPath = "//builtin/derivation.nix";
 
     const Symbol sWith, sOutPath, sDrvPath, sType, sMeta, sName, sValue,
         sSystem, sOverrides, sOutputs, sOutputName, sIgnoreNulls,
         sFile, sLine, sColumn, sFunctor, sToString,
         sRight, sWrong, sStructuredAttrs, sBuilder, sArgs,
-        sContentAddressed, sImpure,
+        sContentAddressed,
         sOutputHash, sOutputHashAlgo, sOutputHashMode,
         sRecurseForDerivations,
         sDescription, sSelf, sEpsilon, sStartSet, sOperator, sKey, sPath,
-        sPrefix,
-        sOutputSpecified;
+        sPrefix;
     Symbol sDerivationNix;
 
     /* If set, force copying files to the Nix store even if they
@@ -126,55 +104,12 @@ public:
     RootValue vCallFlake = nullptr;
     RootValue vImportedDrvToDerivation = nullptr;
 
-    /* Debugger */
-    void (* debugRepl)(ref<EvalState> es, const ValMap & extraEnv);
-    bool debugStop;
-    bool debugQuit;
-    std::list<DebugTrace> debugTraces;
-    std::map<const Expr*, const std::shared_ptr<const StaticEnv>> exprEnvs;
-    const std::shared_ptr<const StaticEnv> getStaticEnv(const Expr & expr) const
-    {
-        auto i = exprEnvs.find(&expr);
-        if (i != exprEnvs.end())
-            return i->second;
-        else
-            return std::shared_ptr<const StaticEnv>();;
-    }
-
-    void runDebugRepl(const Error * error, const Env & env, const Expr & expr);
-
-    template<class E>
-    [[gnu::noinline, gnu::noreturn]]
-    void debugThrow(E && error, const Env & env, const Expr & expr)
-    {
-        if (debugRepl)
-            runDebugRepl(&error, env, expr);
-
-        throw error;
-    }
-
-    template<class E>
-    [[gnu::noinline, gnu::noreturn]]
-    void debugThrowLastTrace(E && e)
-    {
-        // Call this in the situation where Expr and Env are inaccessible.
-        // The debugger will start in the last context that's in the
-        // DebugTrace stack.
-        if (debugRepl && !debugTraces.empty()) {
-            const DebugTrace & last = debugTraces.front();
-            runDebugRepl(&e, last.env, last.expr);
-        }
-
-        throw e;
-    }
-
-
 private:
     SrcToStore srcToStore;
 
     /* A cache from path names to parse trees. */
 #if HAVE_BOEHMGC
-    typedef std::map<Path, Expr *, std::less<Path>, traceable_allocator<std::pair<const Path, Expr *>>> FileParseCache;
+    typedef std::map<Path, Expr *, std::less<Path>, traceable_allocator<std::pair<const Path, Expr *> > > FileParseCache;
 #else
     typedef std::map<Path, Expr *> FileParseCache;
 #endif
@@ -182,7 +117,7 @@ private:
 
     /* A cache from path names to values. */
 #if HAVE_BOEHMGC
-    typedef std::map<Path, Value, std::less<Path>, traceable_allocator<std::pair<const Path, Value>>> FileEvalCache;
+    typedef std::map<Path, Value, std::less<Path>, traceable_allocator<std::pair<const Path, Value> > > FileEvalCache;
 #else
     typedef std::map<Path, Value> FileEvalCache;
 #endif
@@ -198,14 +133,9 @@ private:
     /* Cache used by prim_match(). */
     std::shared_ptr<RegexCache> regexCache;
 
-#if HAVE_BOEHMGC
     /* Allocation cache for GC'd Value objects. */
     std::shared_ptr<void *> valueAllocCache;
 
-    /* Allocation cache for size-1 Env objects. */
-    std::shared_ptr<void *> env1AllocCache;
-#endif
-
 public:
 
     EvalState(
@@ -214,7 +144,13 @@ public:
         std::shared_ptr<Store> buildStore = nullptr);
     ~EvalState();
 
-    void addToSearchPath(const std::string & s);
+    void requireExperimentalFeatureOnEvaluation(
+        const ExperimentalFeature &,
+        const std::string_view fName,
+        const Pos & pos
+    );
+
+    void addToSearchPath(const string & s);
 
     SearchPath getSearchPath() { return searchPath; }
 
@@ -225,9 +161,6 @@ public:
        the real store path if `store` is a chroot store. */
     void allowPath(const StorePath & storePath);
 
-    /* Allow access to a store path and return it as a string. */
-    void allowAndSetStorePathString(const StorePath & storePath, Value & v);
-
     /* Check whether access to a path is allowed and throw an error if
        not. Otherwise return the canonicalised path. */
     Path checkSourcePath(const Path & path);
@@ -245,10 +178,10 @@ public:
 
     /* Parse a Nix expression from the specified file. */
     Expr * parseExprFromFile(const Path & path);
-    Expr * parseExprFromFile(const Path & path, std::shared_ptr<StaticEnv> & staticEnv);
+    Expr * parseExprFromFile(const Path & path, StaticEnv & staticEnv);
 
     /* Parse a Nix expression from the specified string. */
-    Expr * parseExprFromString(std::string s, const Path & basePath, std::shared_ptr<StaticEnv> & staticEnv);
+    Expr * parseExprFromString(std::string s, const Path & basePath, StaticEnv & staticEnv);
     Expr * parseExprFromString(std::string s, const Path & basePath);
 
     Expr * parseStdin();
@@ -258,7 +191,7 @@ public:
        trivial (i.e. doesn't require arbitrary computation). */
     void evalFile(const Path & path, Value & v, bool mustBeTrivial = false);
 
-    /* Like `evalFile`, but with an already parsed expression. */
+    /* Like `cacheFile`, but with an already parsed expression. */
     void cacheFile(
         const Path & path,
         const Path & resolvedPath,
@@ -270,7 +203,7 @@ public:
 
     /* Look up a file in the search path. */
     Path findFile(const std::string_view path);
-    Path findFile(SearchPath & searchPath, const std::string_view path, const PosIdx pos = noPos);
+    Path findFile(SearchPath & searchPath, const std::string_view path, const Pos & pos = noPos);
 
     /* If the specified search path element is a URI, download it. */
     std::pair<bool, std::string> resolveSearchPathElem(const SearchPathElem & elem);
@@ -282,14 +215,14 @@ public:
     /* Evaluation the expression, then verify that it has the expected
        type. */
     inline bool evalBool(Env & env, Expr * e);
-    inline bool evalBool(Env & env, Expr * e, const PosIdx pos);
+    inline bool evalBool(Env & env, Expr * e, const Pos & pos);
     inline void evalAttrs(Env & env, Expr * e, Value & v);
 
     /* If `v' is a thunk, enter it and overwrite `v' with the result
        of the evaluation of the thunk.  If `v' is a delayed function
        application, call the function and overwrite `v' with the
        result.  Otherwise, this is a no-op. */
-    inline void forceValue(Value & v, const PosIdx pos);
+    inline void forceValue(Value & v, const Pos & pos);
 
     template <typename Callable>
     inline void forceValue(Value & v, Callable getPos);
@@ -299,115 +232,42 @@ public:
     void forceValueDeep(Value & v);
 
     /* Force `v', and then verify that it has the expected type. */
-    NixInt forceInt(Value & v, const PosIdx pos);
-    NixFloat forceFloat(Value & v, const PosIdx pos);
-    bool forceBool(Value & v, const PosIdx pos);
+    NixInt forceInt(Value & v, const Pos & pos);
+    NixFloat forceFloat(Value & v, const Pos & pos);
+    bool forceBool(Value & v, const Pos & pos);
 
-    void forceAttrs(Value & v, const PosIdx pos);
+    void forceAttrs(Value & v, const Pos & pos);
 
     template <typename Callable>
     inline void forceAttrs(Value & v, Callable getPos);
 
-    inline void forceList(Value & v, const PosIdx pos);
-    void forceFunction(Value & v, const PosIdx pos); // either lambda or primop
-    std::string_view forceString(Value & v, const PosIdx pos = noPos);
-    std::string_view forceString(Value & v, PathSet & context, const PosIdx pos = noPos);
-    std::string_view forceStringNoCtx(Value & v, const PosIdx pos = noPos);
+    inline void forceList(Value & v, const Pos & pos);
+    void forceFunction(Value & v, const Pos & pos); // either lambda or primop
+    std::string_view forceString(Value & v, const Pos & pos = noPos);
+    std::string_view forceString(Value & v, PathSet & context, const Pos & pos = noPos);
+    std::string_view forceStringNoCtx(Value & v, const Pos & pos = noPos);
 
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const PosIdx pos, const char * s);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const PosIdx pos, const char * s,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const char * s, const std::string & s2);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const PosIdx pos, const char * s, const std::string & s2);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const char * s, const std::string & s2,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const PosIdx pos, const char * s, const std::string & s2,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const char * s, const std::string & s2, const std::string & s3,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const PosIdx pos, const char * s, const std::string & s2, const std::string & s3,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const PosIdx pos, const char * s, const std::string & s2, const std::string & s3);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const char * s, const std::string & s2, const std::string & s3);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const PosIdx pos, const Suggestions & suggestions, const char * s, const std::string & s2,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwEvalError(const PosIdx p1, const char * s, const Symbol sym, const PosIdx p2,
-        Env & env, Expr & expr);
-
-    [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const PosIdx pos, const char * s, const Value & v);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const PosIdx pos, const char * s, const Value & v,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const PosIdx pos, const char * s);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const PosIdx pos, const char * s,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const PosIdx pos, const char * s, const ExprLambda & fun, const Symbol s2,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const PosIdx pos, const Suggestions & suggestions, const char * s, const ExprLambda & fun, const Symbol s2,
-        Env & env, Expr & expr);
-    [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const char * s, const Value & v,
-        Env & env, Expr & expr);
-
-    [[gnu::noinline, gnu::noreturn]]
-    void throwAssertionError(const PosIdx pos, const char * s, const std::string & s1,
-        Env & env, Expr & expr);
-
-    [[gnu::noinline, gnu::noreturn]]
-    void throwUndefinedVarError(const PosIdx pos, const char * s, const std::string & s1,
-        Env & env, Expr & expr);
-
-    [[gnu::noinline, gnu::noreturn]]
-    void throwMissingArgumentError(const PosIdx pos, const char * s, const std::string & s1,
-        Env & env, Expr & expr);
-
-    [[gnu::noinline]]
-    void addErrorTrace(Error & e, const char * s, const std::string & s2) const;
-    [[gnu::noinline]]
-    void addErrorTrace(Error & e, const PosIdx pos, const char * s, const std::string & s2) const;
-
-public:
     /* Return true iff the value `v' denotes a derivation (i.e. a
        set with attribute `type = "derivation"'). */
     bool isDerivation(Value & v);
 
-    std::optional<std::string> tryAttrsToString(const PosIdx pos, Value & v,
+    std::optional<string> tryAttrsToString(const Pos & pos, Value & v,
         PathSet & context, bool coerceMore = false, bool copyToStore = true);
 
     /* String coercion.  Converts strings, paths and derivations to a
        string.  If `coerceMore' is set, also converts nulls, integers,
        booleans and lists to a string.  If `copyToStore' is set,
        referenced paths are copied to the Nix store as a side effect. */
-    BackedStringView coerceToString(const PosIdx pos, Value & v, PathSet & context,
+    BackedStringView coerceToString(const Pos & pos, Value & v, PathSet & context,
         bool coerceMore = false, bool copyToStore = true,
         bool canonicalizePath = true);
 
-    std::string copyPathToStore(PathSet & context, const Path & path);
+    string copyPathToStore(PathSet & context, const Path & path);
 
     /* Path coercion.  Converts strings, paths and derivations to a
        path.  The result is guaranteed to be a canonicalised, absolute
        path.  Nothing is copied to the store. */
-    Path coerceToPath(const PosIdx pos, Value & v, PathSet & context);
-
-    /* Like coerceToPath, but the result must be a store path. */
-    StorePath coerceToStorePath(const PosIdx pos, Value & v, PathSet & context);
+    Path coerceToPath(const Pos & pos, Value & v, PathSet & context);
 
 public:
 
@@ -416,7 +276,7 @@ public:
     Env & baseEnv;
 
     /* The same, but used during parsing to resolve variables. */
-    std::shared_ptr<StaticEnv> staticBaseEnv; // !!! should be private
+    StaticEnv staticBaseEnv; // !!! should be private
 
 private:
 
@@ -424,23 +284,23 @@ private:
 
     void createBaseEnv();
 
-    Value * addConstant(const std::string & name, Value & v);
+    Value * addConstant(const string & name, Value & v);
 
-    void addConstant(const std::string & name, Value * v);
+    void addConstant(const string & name, Value * v);
 
-    Value * addPrimOp(const std::string & name,
+    Value * addPrimOp(const string & name,
         size_t arity, PrimOpFun primOp);
 
     Value * addPrimOp(PrimOp && primOp);
 
 public:
 
-    Value & getBuiltin(const std::string & name);
+    Value & getBuiltin(const string & name);
 
     struct Doc
     {
         Pos pos;
-        std::optional<std::string> name;
+        std::optional<Symbol> name;
         size_t arity;
         std::vector<std::string> args;
         const char * doc;
@@ -457,7 +317,7 @@ private:
     friend struct ExprLet;
 
     Expr * parse(char * text, size_t length, FileOrigin origin, const PathView path,
-        const PathView basePath, std::shared_ptr<StaticEnv> & staticEnv);
+        const PathView basePath, StaticEnv & staticEnv);
 
 public:
 
@@ -468,9 +328,9 @@ public:
     bool isFunctor(Value & fun);
 
     // FIXME: use std::span
-    void callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const PosIdx pos);
+    void callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const Pos & pos);
 
-    void callFunction(Value & fun, Value & arg, Value & vRes, const PosIdx pos)
+    void callFunction(Value & fun, Value & arg, Value & vRes, const Pos & pos)
     {
         Value * args[] = {&arg};
         callFunction(fun, 1, args, vRes, pos);
@@ -481,10 +341,10 @@ public:
     void autoCallFunction(Bindings & args, Value & fun, Value & res);
 
     /* Allocation primitives. */
-    inline Value * allocValue();
-    inline Env & allocEnv(size_t size);
+    Value * allocValue();
+    Env & allocEnv(size_t size);
 
-    Value * allocAttr(Value & vAttrs, Symbol name);
+    Value * allocAttr(Value & vAttrs, const Symbol & name);
     Value * allocAttr(Value & vAttrs, std::string_view name);
 
     Bindings * allocBindings(size_t capacity);
@@ -496,9 +356,9 @@ public:
 
     void mkList(Value & v, size_t length);
     void mkThunk_(Value & v, Expr * expr);
-    void mkPos(Value & v, PosIdx pos);
+    void mkPos(Value & v, ptr<Pos> pos);
 
-    void concatLists(Value & v, size_t nrLists, Value * * lists, const PosIdx pos);
+    void concatLists(Value & v, size_t nrLists, Value * * lists, const Pos & pos);
 
     /* Print statistics. */
     void printStats();
@@ -526,7 +386,7 @@ private:
 
     bool countCalls;
 
-    typedef std::map<std::string, size_t> PrimOpCalls;
+    typedef std::map<Symbol, size_t> PrimOpCalls;
     PrimOpCalls primOpCalls;
 
     typedef std::map<ExprLambda *, size_t> FunctionCalls;
@@ -534,7 +394,7 @@ private:
 
     void incrFunctionCall(ExprLambda * fun);
 
-    typedef std::map<PosIdx, size_t> AttrSelects;
+    typedef std::map<Pos, size_t> AttrSelects;
     AttrSelects attrSelects;
 
     friend struct ExprOpUpdate;
@@ -545,31 +405,21 @@ private:
     friend struct ExprFloat;
     friend struct ExprPath;
     friend struct ExprSelect;
-    friend void prim_getAttr(EvalState & state, const PosIdx pos, Value * * args, Value & v);
-    friend void prim_match(EvalState & state, const PosIdx pos, Value * * args, Value & v);
-    friend void prim_split(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+    friend void prim_getAttr(EvalState & state, const Pos & pos, Value * * args, Value & v);
+    friend void prim_match(EvalState & state, const Pos & pos, Value * * args, Value & v);
+    friend void prim_split(EvalState & state, const Pos & pos, Value * * args, Value & v);
 
     friend struct Value;
 };
 
-struct DebugTraceStacker {
-    DebugTraceStacker(EvalState & evalState, DebugTrace t);
-    ~DebugTraceStacker()
-    {
-        // assert(evalState.debugTraces.front() == trace);
-        evalState.debugTraces.pop_front();
-    }
-    EvalState & evalState;
-    DebugTrace trace;
-};
 
 /* Return a string representing the type of the value `v'. */
-std::string_view showType(ValueType type);
-std::string showType(const Value & v);
+string showType(ValueType type);
+string showType(const Value & v);
 
 /* Decode a context string ‘!<name>!<path>’ into a pair <path,
    name>. */
-NixStringContextElem decodeContext(const Store & store, std::string_view s);
+std::pair<string, string> decodeContext(std::string_view s);
 
 /* If `path' refers to a directory, then append "/default.nix". */
 Path resolveExprPath(Path path);
@@ -653,5 +503,3 @@ extern EvalSettings evalSettings;
 static const std::string corepkgsPrefix{"/__corepkgs__/"};
 
 }
-
-#include "eval-inline.hh"

src/libexpr/flake/config.cc

@@ -1,6 +1,5 @@
 #include "flake.hh"
 #include "globals.hh"
-#include "fetch-settings.hh"
 
 #include <nlohmann/json.hpp>
 
@@ -31,7 +30,7 @@ static void writeTrustedList(const TrustedList & trustedList)
 
 void ConfigFile::apply()
 {
-    std::set<std::string> whitelist{"bash-prompt", "bash-prompt-prefix", "bash-prompt-suffix", "flake-registry"};
+    std::set<std::string> whitelist{"bash-prompt", "bash-prompt-suffix", "flake-registry"};
 
     for (auto & [name, value] : settings) {
 
@@ -50,11 +49,13 @@ void ConfigFile::apply()
         else
             assert(false);
 
-        if (!whitelist.count(baseName) && !nix::fetchSettings.acceptFlakeConfig) {
-            bool trusted = false;
+        if (!whitelist.count(baseName)) {
             auto trustedList = readTrustedList();
-            auto tlname = get(trustedList, name);
-            if (auto saved = tlname ? get(*tlname, valueS) : nullptr) {
+
+            bool trusted = false;
+            if (nix::settings.acceptFlakeConfig){
+                trusted = true;
+            } else if (auto saved = get(get(trustedList, name).value_or(std::map<std::string, bool>()), valueS)) {
                 trusted = *saved;
                 warn("Using saved setting for '%s = %s' from ~/.local/share/nix/trusted-settings.json.", name,valueS);
             } else {
@@ -67,6 +68,7 @@ void ConfigFile::apply()
                     writeTrustedList(trustedList);
                 }
             }
+
             if (!trusted) {
                 warn("ignoring untrusted flake configuration setting '%s'", name);
                 continue;

src/libexpr/flake/flake.cc

@@ -6,7 +6,6 @@
 #include "store-api.hh"
 #include "fetchers.hh"
 #include "finally.hh"
-#include "fetch-settings.hh"
 
 namespace nix {
 
@@ -72,7 +71,7 @@ static std::tuple<fetchers::Tree, FlakeRef, FlakeRef> fetchOrSubstituteTree(
     return {std::move(tree), resolvedRef, lockedRef};
 }
 
-static void forceTrivialValue(EvalState & state, Value & value, const PosIdx pos)
+static void forceTrivialValue(EvalState & state, Value & value, const Pos & pos)
 {
     if (value.isThunk() && value.isTrivial())
         state.forceValue(value, pos);
@@ -80,20 +79,20 @@ static void forceTrivialValue(EvalState & state, Value & value, const PosIdx pos
 
 
 static void expectType(EvalState & state, ValueType type,
-    Value & value, const PosIdx pos)
+    Value & value, const Pos & pos)
 {
     forceTrivialValue(state, value, pos);
     if (value.type() != type)
         throw Error("expected %s but got %s at %s",
-            showType(type), showType(value.type()), state.positions[pos]);
+            showType(type), showType(value.type()), pos);
 }
 
 static std::map<FlakeId, FlakeInput> parseFlakeInputs(
-    EvalState & state, Value * value, const PosIdx pos,
+    EvalState & state, Value * value, const Pos & pos,
     const std::optional<Path> & baseDir, InputPath lockRootPath);
 
 static FlakeInput parseFlakeInput(EvalState & state,
-    const std::string & inputName, Value * value, const PosIdx pos,
+    const std::string & inputName, Value * value, const Pos & pos,
     const std::optional<Path> & baseDir, InputPath lockRootPath)
 {
     expectType(state, nAttrs, *value, pos);
@@ -111,39 +110,37 @@ static FlakeInput parseFlakeInput(EvalState & state,
     for (nix::Attr attr : *(value->attrs)) {
         try {
             if (attr.name == sUrl) {
-                expectType(state, nString, *attr.value, attr.pos);
+                expectType(state, nString, *attr.value, *attr.pos);
                 url = attr.value->string.s;
                 attrs.emplace("url", *url);
             } else if (attr.name == sFlake) {
-                expectType(state, nBool, *attr.value, attr.pos);
+                expectType(state, nBool, *attr.value, *attr.pos);
                 input.isFlake = attr.value->boolean;
             } else if (attr.name == sInputs) {
-                input.overrides = parseFlakeInputs(state, attr.value, attr.pos, baseDir, lockRootPath);
+                input.overrides = parseFlakeInputs(state, attr.value, *attr.pos, baseDir, lockRootPath);
             } else if (attr.name == sFollows) {
-                expectType(state, nString, *attr.value, attr.pos);
+                expectType(state, nString, *attr.value, *attr.pos);
                 auto follows(parseInputPath(attr.value->string.s));
                 follows.insert(follows.begin(), lockRootPath.begin(), lockRootPath.end());
                 input.follows = follows;
             } else {
                 switch (attr.value->type()) {
                     case nString:
-                        attrs.emplace(state.symbols[attr.name], attr.value->string.s);
+                        attrs.emplace(attr.name, attr.value->string.s);
                         break;
                     case nBool:
-                        attrs.emplace(state.symbols[attr.name], Explicit<bool> { attr.value->boolean });
+                        attrs.emplace(attr.name, Explicit<bool> { attr.value->boolean });
                         break;
                     case nInt:
-                        attrs.emplace(state.symbols[attr.name], (long unsigned int)attr.value->integer);
+                        attrs.emplace(attr.name, (long unsigned int)attr.value->integer);
                         break;
                     default:
                         throw TypeError("flake input attribute '%s' is %s while a string, Boolean, or integer is expected",
-                            state.symbols[attr.name], showType(*attr.value));
+                            attr.name, showType(*attr.value));
                 }
             }
         } catch (Error & e) {
-            e.addTrace(
-                state.positions[attr.pos],
-                hintfmt("in flake attribute '%s'", state.symbols[attr.name]));
+            e.addTrace(*attr.pos, hintfmt("in flake attribute '%s'", attr.name));
             throw;
         }
     }
@@ -152,13 +149,13 @@ static FlakeInput parseFlakeInput(EvalState & state,
         try {
             input.ref = FlakeRef::fromAttrs(attrs);
         } catch (Error & e) {
-            e.addTrace(state.positions[pos], hintfmt("in flake input"));
+            e.addTrace(pos, hintfmt("in flake input"));
             throw;
         }
     else {
         attrs.erase("url");
         if (!attrs.empty())
-            throw Error("unexpected flake input attribute '%s', at %s", attrs.begin()->first, state.positions[pos]);
+            throw Error("unexpected flake input attribute '%s', at %s", attrs.begin()->first, pos);
         if (url)
             input.ref = parseFlakeRef(*url, baseDir, true, input.isFlake);
     }
@@ -170,7 +167,7 @@ static FlakeInput parseFlakeInput(EvalState & state,
 }
 
 static std::map<FlakeId, FlakeInput> parseFlakeInputs(
-    EvalState & state, Value * value, const PosIdx pos,
+    EvalState & state, Value * value, const Pos & pos,
     const std::optional<Path> & baseDir, InputPath lockRootPath)
 {
     std::map<FlakeId, FlakeInput> inputs;
@@ -178,11 +175,11 @@ static std::map<FlakeId, FlakeInput> parseFlakeInputs(
     expectType(state, nAttrs, *value, pos);
 
     for (nix::Attr & inputAttr : *(*value).attrs) {
-        inputs.emplace(state.symbols[inputAttr.name],
+        inputs.emplace(inputAttr.name,
             parseFlakeInput(state,
-                state.symbols[inputAttr.name],
+                inputAttr.name,
                 inputAttr.value,
-                inputAttr.pos,
+                *inputAttr.pos,
                 baseDir,
                 lockRootPath));
     }
@@ -220,28 +217,28 @@ static Flake getFlake(
     Value vInfo;
     state.evalFile(flakeFile, vInfo, true); // FIXME: symlink attack
 
-    expectType(state, nAttrs, vInfo, state.positions.add({flakeFile, foFile}, 0, 0));
+    expectType(state, nAttrs, vInfo, Pos(foFile, state.symbols.create(flakeFile), 0, 0));
 
     if (auto description = vInfo.attrs->get(state.sDescription)) {
-        expectType(state, nString, *description->value, description->pos);
+        expectType(state, nString, *description->value, *description->pos);
         flake.description = description->value->string.s;
     }
 
     auto sInputs = state.symbols.create("inputs");
 
     if (auto inputs = vInfo.attrs->get(sInputs))
-        flake.inputs = parseFlakeInputs(state, inputs->value, inputs->pos, flakeDir, lockRootPath);
+        flake.inputs = parseFlakeInputs(state, inputs->value, *inputs->pos, flakeDir, lockRootPath);
 
     auto sOutputs = state.symbols.create("outputs");
 
     if (auto outputs = vInfo.attrs->get(sOutputs)) {
-        expectType(state, nFunction, *outputs->value, outputs->pos);
+        expectType(state, nFunction, *outputs->value, *outputs->pos);
 
         if (outputs->value->isLambda() && outputs->value->lambda.fun->hasFormals()) {
             for (auto & formal : outputs->value->lambda.fun->formals->formals) {
                 if (formal.name != state.sSelf)
-                    flake.inputs.emplace(state.symbols[formal.name], FlakeInput {
-                        .ref = parseFlakeRef(state.symbols[formal.name])
+                    flake.inputs.emplace(formal.name, FlakeInput {
+                        .ref = parseFlakeRef(formal.name)
                     });
             }
         }
@@ -252,41 +249,35 @@ static Flake getFlake(
     auto sNixConfig = state.symbols.create("nixConfig");
 
     if (auto nixConfig = vInfo.attrs->get(sNixConfig)) {
-        expectType(state, nAttrs, *nixConfig->value, nixConfig->pos);
+        expectType(state, nAttrs, *nixConfig->value, *nixConfig->pos);
 
         for (auto & setting : *nixConfig->value->attrs) {
-            forceTrivialValue(state, *setting.value, setting.pos);
+            forceTrivialValue(state, *setting.value, *setting.pos);
             if (setting.value->type() == nString)
-                flake.config.settings.emplace(
-                    state.symbols[setting.name],
-                    std::string(state.forceStringNoCtx(*setting.value, setting.pos)));
+                flake.config.settings.insert({setting.name, string(state.forceStringNoCtx(*setting.value, *setting.pos))});
             else if (setting.value->type() == nPath) {
                 PathSet emptyContext = {};
                 flake.config.settings.emplace(
-                    state.symbols[setting.name],
-                    state.coerceToString(setting.pos, *setting.value, emptyContext, false, true, true) .toOwned());
+                    setting.name,
+                    state.coerceToString(*setting.pos, *setting.value, emptyContext, false, true, true) .toOwned());
             }
             else if (setting.value->type() == nInt)
-                flake.config.settings.emplace(
-                    state.symbols[setting.name],
-                    state.forceInt(*setting.value, setting.pos));
+                flake.config.settings.insert({setting.name, state.forceInt(*setting.value, *setting.pos)});
             else if (setting.value->type() == nBool)
-                flake.config.settings.emplace(
-                    state.symbols[setting.name],
-                    Explicit<bool> { state.forceBool(*setting.value, setting.pos) });
+                flake.config.settings.insert({setting.name, Explicit<bool> { state.forceBool(*setting.value, *setting.pos) }});
             else if (setting.value->type() == nList) {
                 std::vector<std::string> ss;
                 for (auto elem : setting.value->listItems()) {
                     if (elem->type() != nString)
                         throw TypeError("list element in flake configuration setting '%s' is %s while a string is expected",
-                            state.symbols[setting.name], showType(*setting.value));
-                    ss.emplace_back(state.forceStringNoCtx(*elem, setting.pos));
+                            setting.name, showType(*setting.value));
+                    ss.emplace_back(state.forceStringNoCtx(*elem, *setting.pos));
                 }
-                flake.config.settings.emplace(state.symbols[setting.name], ss);
+                flake.config.settings.insert({setting.name, ss});
             }
             else
                 throw TypeError("flake configuration setting '%s' is %s",
-                    state.symbols[setting.name], showType(*setting.value));
+                    setting.name, showType(*setting.value));
         }
     }
 
@@ -296,7 +287,7 @@ static Flake getFlake(
             attr.name != sOutputs &&
             attr.name != sNixConfig)
             throw Error("flake '%s' has an unsupported attribute '%s', at %s",
-                lockedRef, state.symbols[attr.name], state.positions[attr.pos]);
+                lockedRef, attr.name, *attr.pos);
     }
 
     return flake;
@@ -324,7 +315,7 @@ LockedFlake lockFlake(
 
     FlakeCache flakeCache;
 
-    auto useRegistries = lockFlags.useRegistries.value_or(fetchSettings.useRegistries);
+    auto useRegistries = lockFlags.useRegistries.value_or(settings.useRegistries);
 
     auto flake = getFlake(state, topRef, useRegistries, flakeCache);
 
@@ -510,7 +501,7 @@ LockedFlake lockFlake(
                            this input. */
                         debug("creating new input '%s'", inputPathS);
 
-                        if (!lockFlags.allowMutable && !input.ref->input.isLocked())
+                        if (!lockFlags.allowMutable && !input.ref->input.isImmutable())
                             throw Error("cannot update flake input '%s' in pure mode", inputPathS);
 
                         if (input.isFlake) {
@@ -600,7 +591,7 @@ LockedFlake lockFlake(
             if (lockFlags.writeLockFile) {
                 if (auto sourcePath = topRef.input.getSourcePath()) {
                     if (!newLockFile.isImmutable()) {
-                        if (fetchSettings.warnDirty)
+                        if (settings.warnDirty)
                             warn("will not write lock file of flake '%s' because it has a mutable input", topRef);
                     } else {
                         if (!lockFlags.updateLockFile)
@@ -627,7 +618,7 @@ LockedFlake lockFlake(
                         if (lockFlags.commitLockFile) {
                             std::string cm;
 
-                            cm = fetchSettings.commitLockFileSummary.get();
+                            cm = settings.commitLockFileSummary.get();
 
                             if (cm == "") {
                                 cm = fmt("%s: %s", relPath, lockFileExists ? "Update" : "Add");
@@ -659,7 +650,7 @@ LockedFlake lockFlake(
                            now. Corner case: we could have reverted from a
                            dirty to a clean tree! */
                         if (flake.lockedRef.input == prevLockedRef.input
-                            && !flake.lockedRef.input.isLocked())
+                            && !flake.lockedRef.input.isImmutable())
                             throw Error("'%s' did not change after I updated its 'flake.lock' file; is 'flake.lock' under version control?", flake.originalRef);
                     }
                 } else
@@ -712,48 +703,26 @@ void callFlake(EvalState & state,
     state.callFunction(*vTmp2, *vRootSubdir, vRes, noPos);
 }
 
-static void prim_getFlake(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_getFlake(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
-    std::string flakeRefS(state.forceStringNoCtx(*args[0], pos));
+    state.requireExperimentalFeatureOnEvaluation(Xp::Flakes, "builtins.getFlake", pos);
+
+    string flakeRefS(state.forceStringNoCtx(*args[0], pos));
     auto flakeRef = parseFlakeRef(flakeRefS, {}, true);
-    if (evalSettings.pureEval && !flakeRef.input.isLocked())
-        throw Error("cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)", flakeRefS, state.positions[pos]);
+    if (evalSettings.pureEval && !flakeRef.input.isImmutable())
+        throw Error("cannot call 'getFlake' on mutable flake reference '%s', at %s (use --impure to override)", flakeRefS, pos);
 
     callFlake(state,
         lockFlake(state, flakeRef,
             LockFlags {
                 .updateLockFile = false,
-                .writeLockFile = false,
-                .useRegistries = !evalSettings.pureEval && fetchSettings.useRegistries,
+                .useRegistries = !evalSettings.pureEval && settings.useRegistries,
                 .allowMutable  = !evalSettings.pureEval,
             }),
         v);
 }
 
-static RegisterPrimOp r2({
-    .name =  "__getFlake",
-    .args = {"args"},
-    .doc = R"(
-      Fetch a flake from a flake reference, and return its output attributes and some metadata. For example:
-
-      ```nix
-      (builtins.getFlake "nix/55bc52401966fbffa525c574c14f67b00bc4fb3a").packages.x86_64-linux.nix
-      ```
-
-      Unless impure evaluation is allowed (`--impure`), the flake reference
-      must be "locked", e.g. contain a Git revision or content hash. An
-      example of an unlocked usage is:
-
-      ```nix
-      (builtins.getFlake "github:edolstra/dwarffs").rev
-      ```
-
-      This function is only available if you enable the experimental feature
-      `flakes`.
-    )",
-    .fun = prim_getFlake,
-    .experimentalFeature = Xp::Flakes,
-});
+static RegisterPrimOp r2("__getFlake", 1, prim_getFlake);
 
 }
 

src/libexpr/flake/flakeref.cc

@@ -98,7 +98,7 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
     if (std::regex_match(url, match, flakeRegex)) {
         auto parsedURL = ParsedURL{
             .url = url,
-            .base = "flake:" + match.str(1),
+            .base = "flake:" + std::string(match[1]),
             .scheme = "flake",
             .authority = "",
             .path = match[1],
@@ -106,12 +106,12 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
 
         return std::make_pair(
             FlakeRef(Input::fromURL(parsedURL), ""),
-            percentDecode(match.str(6)));
+            percentDecode(std::string(match[6])));
     }
 
     else if (std::regex_match(url, match, pathUrlRegex)) {
         std::string path = match[1];
-        std::string fragment = percentDecode(match.str(3));
+        std::string fragment = percentDecode(std::string(match[3]));
 
         if (baseDir) {
             /* Check if 'url' is a path (either absolute or relative
@@ -176,7 +176,7 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
                             parsedURL.query.insert_or_assign("shallow", "1");
 
                         return std::make_pair(
-                            FlakeRef(Input::fromURL(parsedURL), getOr(parsedURL.query, "dir", "")),
+                            FlakeRef(Input::fromURL(parsedURL), get(parsedURL.query, "dir").value_or("")),
                             fragment);
                     }
 
@@ -189,7 +189,7 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
             if (!hasPrefix(path, "/"))
                 throw BadURL("flake reference '%s' is not an absolute path", url);
             auto query = decodeQuery(match[2]);
-            path = canonPath(path + "/" + getOr(query, "dir", ""));
+            path = canonPath(path + "/" + get(query, "dir").value_or(""));
         }
 
         fetchers::Attrs attrs;
@@ -208,7 +208,7 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
         input.parent = baseDir;
 
         return std::make_pair(
-            FlakeRef(std::move(input), getOr(parsedURL.query, "dir", "")),
+            FlakeRef(std::move(input), get(parsedURL.query, "dir").value_or("")),
             fragment);
     }
 }
@@ -238,15 +238,4 @@ std::pair<fetchers::Tree, FlakeRef> FlakeRef::fetchTree(ref<Store> store) const
     return {std::move(tree), FlakeRef(std::move(lockedInput), subdir)};
 }
 
-std::tuple<FlakeRef, std::string, OutputsSpec> parseFlakeRefWithFragmentAndOutputsSpec(
-    const std::string & url,
-    const std::optional<Path> & baseDir,
-    bool allowMissing,
-    bool isFlake)
-{
-    auto [prefix, outputsSpec] = parseOutputsSpec(url);
-    auto [flakeRef, fragment] = parseFlakeRefWithFragment(prefix, baseDir, allowMissing, isFlake);
-    return {std::move(flakeRef), fragment, outputsSpec};
-}
-
 }

src/libexpr/flake/flakeref.hh

@@ -3,7 +3,6 @@
 #include "types.hh"
 #include "hash.hh"
 #include "fetchers.hh"
-#include "path-with-outputs.hh"
 
 #include <variant>
 
@@ -80,11 +79,4 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
 std::optional<std::pair<FlakeRef, std::string>> maybeParseFlakeRefWithFragment(
     const std::string & url, const std::optional<Path> & baseDir = {});
 
-std::tuple<FlakeRef, std::string, OutputsSpec> parseFlakeRefWithFragmentAndOutputsSpec(
-    const std::string & url,
-    const std::optional<Path> & baseDir = {},
-    bool allowMissing = false,
-    bool isFlake = true);
-
-
 }

src/libexpr/flake/lockfile.cc

@@ -35,7 +35,7 @@ LockedNode::LockedNode(const nlohmann::json & json)
     , originalRef(getFlakeRef(json, "original", nullptr))
     , isFlake(json.find("flake") != json.end() ? (bool) json["flake"] : true)
 {
-    if (!lockedRef.input.isLocked())
+    if (!lockedRef.input.isImmutable())
         throw Error("lockfile contains mutable lock '%s'",
             fetchers::attrsToJSON(lockedRef.input.toAttrs()));
 }
@@ -220,7 +220,7 @@ bool LockFile::isImmutable() const
     for (auto & i : nodes) {
         if (i == root) continue;
         auto lockedNode = std::dynamic_pointer_cast<const LockedNode>(i);
-        if (lockedNode && !lockedNode->lockedRef.input.isLocked()) return false;
+        if (lockedNode && !lockedNode->lockedRef.input.isImmutable()) return false;
     }
 
     return true;

src/libexpr/function-trace.hh

@@ -8,7 +8,7 @@ namespace nix {
 
 struct FunctionCallTrace
 {
-    const Pos pos;
+    const Pos & pos;
     FunctionCallTrace(const Pos & pos);
     ~FunctionCallTrace();
 };

src/libexpr/get-drvs.cc

@@ -1,7 +1,6 @@
 #include "get-drvs.hh"
 #include "util.hh"
 #include "eval-inline.hh"
-#include "derivations.hh"
 #include "store-api.hh"
 #include "path-with-outputs.hh"
 
@@ -12,8 +11,8 @@
 namespace nix {
 
 
-DrvInfo::DrvInfo(EvalState & state, std::string attrPath, Bindings * attrs)
-    : state(&state), attrs(attrs), attrPath(std::move(attrPath))
+DrvInfo::DrvInfo(EvalState & state, const string & attrPath, Bindings * attrs)
+    : state(&state), attrs(attrs), attrPath(attrPath)
 {
 }
 
@@ -23,7 +22,7 @@ DrvInfo::DrvInfo(EvalState & state, ref<Store> store, const std::string & drvPat
 {
     auto [drvPath, selectedOutputs] = parsePathWithOutputs(*store, drvPathWithOutputs);
 
-    this->drvPath = drvPath;
+    this->drvPath = store->printStorePath(drvPath);
 
     auto drv = store->derivationFromPath(drvPath);
 
@@ -34,7 +33,7 @@ DrvInfo::DrvInfo(EvalState & state, ref<Store> store, const std::string & drvPat
 
     outputName =
         selectedOutputs.empty()
-        ? getOr(drv.env, "outputName", "out")
+        ? get(drv.env, "outputName").value_or("out")
         : *selectedOutputs.begin();
 
     auto i = drv.outputs.find(outputName);
@@ -42,11 +41,13 @@ DrvInfo::DrvInfo(EvalState & state, ref<Store> store, const std::string & drvPat
         throw Error("derivation '%s' does not have output '%s'", store->printStorePath(drvPath), outputName);
     auto & [outputName, output] = *i;
 
-    outPath = {output.path(*store, drv.name, outputName)};
+    auto optStorePath = output.path(*store, drv.name, outputName);
+    if (optStorePath)
+        outPath = store->printStorePath(*optStorePath);
 }
 
 
-std::string DrvInfo::queryName() const
+string DrvInfo::queryName() const
 {
     if (name == "" && attrs) {
         auto i = attrs->find(state->sName);
@@ -57,45 +58,34 @@ std::string DrvInfo::queryName() const
 }
 
 
-std::string DrvInfo::querySystem() const
+string DrvInfo::querySystem() const
 {
     if (system == "" && attrs) {
         auto i = attrs->find(state->sSystem);
-        system = i == attrs->end() ? "unknown" : state->forceStringNoCtx(*i->value, i->pos);
+        system = i == attrs->end() ? "unknown" : state->forceStringNoCtx(*i->value, *i->pos);
     }
     return system;
 }
 
 
-std::optional<StorePath> DrvInfo::queryDrvPath() const
+string DrvInfo::queryDrvPath() const
 {
-    if (!drvPath && attrs) {
+    if (drvPath == "" && attrs) {
         Bindings::iterator i = attrs->find(state->sDrvPath);
         PathSet context;
-        if (i == attrs->end())
-            drvPath = {std::nullopt};
-        else
-            drvPath = {state->coerceToStorePath(i->pos, *i->value, context)};
+        drvPath = i != attrs->end() ? state->coerceToPath(*i->pos, *i->value, context) : "";
     }
-    return drvPath.value_or(std::nullopt);
+    return drvPath;
 }
 
 
-StorePath DrvInfo::requireDrvPath() const
-{
-    if (auto drvPath = queryDrvPath())
-        return *drvPath;
-    throw Error("derivation does not contain a 'drvPath' attribute");
-}
-
-
-StorePath DrvInfo::queryOutPath() const
+string DrvInfo::queryOutPath() const
 {
     if (!outPath && attrs) {
         Bindings::iterator i = attrs->find(state->sOutPath);
         PathSet context;
         if (i != attrs->end())
-            outPath = state->coerceToStorePath(i->pos, *i->value, context);
+            outPath = state->coerceToPath(*i->pos, *i->value, context);
     }
     if (!outPath)
         throw UnimplementedError("CA derivations are not yet supported");
@@ -103,69 +93,52 @@ StorePath DrvInfo::queryOutPath() const
 }
 
 
-DrvInfo::Outputs DrvInfo::queryOutputs(bool withPaths, bool onlyOutputsToInstall)
+DrvInfo::Outputs DrvInfo::queryOutputs(bool onlyOutputsToInstall)
 {
     if (outputs.empty()) {
         /* Get the ‘outputs’ list. */
         Bindings::iterator i;
         if (attrs && (i = attrs->find(state->sOutputs)) != attrs->end()) {
-            state->forceList(*i->value, i->pos);
+            state->forceList(*i->value, *i->pos);
 
             /* For each output... */
             for (auto elem : i->value->listItems()) {
-                std::string output(state->forceStringNoCtx(*elem, i->pos));
+                /* Evaluate the corresponding set. */
+                string name(state->forceStringNoCtx(*elem, *i->pos));
+                Bindings::iterator out = attrs->find(state->symbols.create(name));
+                if (out == attrs->end()) continue; // FIXME: throw error?
+                state->forceAttrs(*out->value, *i->pos);
 
-                if (withPaths) {
-                    /* Evaluate the corresponding set. */
-                    Bindings::iterator out = attrs->find(state->symbols.create(output));
-                    if (out == attrs->end()) continue; // FIXME: throw error?
-                    state->forceAttrs(*out->value, i->pos);
-
-                    /* And evaluate its ‘outPath’ attribute. */
-                    Bindings::iterator outPath = out->value->attrs->find(state->sOutPath);
-                    if (outPath == out->value->attrs->end()) continue; // FIXME: throw error?
-                    PathSet context;
-                    outputs.emplace(output, state->coerceToStorePath(outPath->pos, *outPath->value, context));
-                } else
-                    outputs.emplace(output, std::nullopt);
+                /* And evaluate its ‘outPath’ attribute. */
+                Bindings::iterator outPath = out->value->attrs->find(state->sOutPath);
+                if (outPath == out->value->attrs->end()) continue; // FIXME: throw error?
+                PathSet context;
+                outputs[name] = state->coerceToPath(*outPath->pos, *outPath->value, context);
             }
         } else
-            outputs.emplace("out", withPaths ? std::optional{queryOutPath()} : std::nullopt);
+            outputs["out"] = queryOutPath();
     }
-
     if (!onlyOutputsToInstall || !attrs)
         return outputs;
 
-    Bindings::iterator i;
-    if (attrs && (i = attrs->find(state->sOutputSpecified)) != attrs->end() && state->forceBool(*i->value, i->pos)) {
-        Outputs result;
-        auto out = outputs.find(queryOutputName());
-        if (out == outputs.end())
-            throw Error("derivation does not have output '%s'", queryOutputName());
+    /* Check for `meta.outputsToInstall` and return `outputs` reduced to that. */
+    const Value * outTI = queryMeta("outputsToInstall");
+    if (!outTI) return outputs;
+    const auto errMsg = Error("this derivation has bad 'meta.outputsToInstall'");
+        /* ^ this shows during `nix-env -i` right under the bad derivation */
+    if (!outTI->isList()) throw errMsg;
+    Outputs result;
+    for (auto elem : outTI->listItems()) {
+        if (elem->type() != nString) throw errMsg;
+        auto out = outputs.find(elem->string.s);
+        if (out == outputs.end()) throw errMsg;
         result.insert(*out);
-        return result;
-    }
-
-    else {
-        /* Check for `meta.outputsToInstall` and return `outputs` reduced to that. */
-        const Value * outTI = queryMeta("outputsToInstall");
-        if (!outTI) return outputs;
-        const auto errMsg = Error("this derivation has bad 'meta.outputsToInstall'");
-            /* ^ this shows during `nix-env -i` right under the bad derivation */
-        if (!outTI->isList()) throw errMsg;
-        Outputs result;
-        for (auto elem : outTI->listItems()) {
-            if (elem->type() != nString) throw errMsg;
-            auto out = outputs.find(elem->string.s);
-            if (out == outputs.end()) throw errMsg;
-            result.insert(*out);
-        }
-        return result;
     }
+    return result;
 }
 
 
-std::string DrvInfo::queryOutputName() const
+string DrvInfo::queryOutputName() const
 {
     if (outputName == "" && attrs) {
         Bindings::iterator i = attrs->find(state->sOutputName);
@@ -181,7 +154,7 @@ Bindings * DrvInfo::getMeta()
     if (!attrs) return 0;
     Bindings::iterator a = attrs->find(state->sMeta);
     if (a == attrs->end()) return 0;
-    state->forceAttrs(*a->value, a->pos);
+    state->forceAttrs(*a->value, *a->pos);
     meta = a->value->attrs;
     return meta;
 }
@@ -192,7 +165,7 @@ StringSet DrvInfo::queryMetaNames()
     StringSet res;
     if (!getMeta()) return res;
     for (auto & i : *meta)
-        res.emplace(state->symbols[i.name]);
+        res.insert(i.name);
     return res;
 }
 
@@ -217,7 +190,7 @@ bool DrvInfo::checkMeta(Value & v)
 }
 
 
-Value * DrvInfo::queryMeta(const std::string & name)
+Value * DrvInfo::queryMeta(const string & name)
 {
     if (!getMeta()) return 0;
     Bindings::iterator a = meta->find(state->symbols.create(name));
@@ -226,7 +199,7 @@ Value * DrvInfo::queryMeta(const std::string & name)
 }
 
 
-std::string DrvInfo::queryMetaString(const std::string & name)
+string DrvInfo::queryMetaString(const string & name)
 {
     Value * v = queryMeta(name);
     if (!v || v->type() != nString) return "";
@@ -234,7 +207,7 @@ std::string DrvInfo::queryMetaString(const std::string & name)
 }
 
 
-NixInt DrvInfo::queryMetaInt(const std::string & name, NixInt def)
+NixInt DrvInfo::queryMetaInt(const string & name, NixInt def)
 {
     Value * v = queryMeta(name);
     if (!v) return def;
@@ -248,7 +221,7 @@ NixInt DrvInfo::queryMetaInt(const std::string & name, NixInt def)
     return def;
 }
 
-NixFloat DrvInfo::queryMetaFloat(const std::string & name, NixFloat def)
+NixFloat DrvInfo::queryMetaFloat(const string & name, NixFloat def)
 {
     Value * v = queryMeta(name);
     if (!v) return def;
@@ -263,7 +236,7 @@ NixFloat DrvInfo::queryMetaFloat(const std::string & name, NixFloat def)
 }
 
 
-bool DrvInfo::queryMetaBool(const std::string & name, bool def)
+bool DrvInfo::queryMetaBool(const string & name, bool def)
 {
     Value * v = queryMeta(name);
     if (!v) return def;
@@ -278,11 +251,11 @@ bool DrvInfo::queryMetaBool(const std::string & name, bool def)
 }
 
 
-void DrvInfo::setMeta(const std::string & name, Value * v)
+void DrvInfo::setMeta(const string & name, Value * v)
 {
     getMeta();
     auto attrs = state->buildBindings(1 + (meta ? meta->size() : 0));
-    auto sym = state->symbols.create(name);
+    Symbol sym = state->symbols.create(name);
     if (meta)
         for (auto i : *meta)
             if (i.name != sym)
@@ -301,7 +274,7 @@ typedef std::set<Bindings *> Done;
    The result boolean indicates whether it makes sense
    for the caller to recursively search for derivations in `v'. */
 static bool getDerivation(EvalState & state, Value & v,
-    const std::string & attrPath, DrvInfos & drvs, Done & done,
+    const string & attrPath, DrvInfos & drvs, Done & done,
     bool ignoreAssertionFailures)
 {
     try {
@@ -338,7 +311,7 @@ std::optional<DrvInfo> getDerivation(EvalState & state, Value & v,
 }
 
 
-static std::string addToPath(const std::string & s1, const std::string & s2)
+static string addToPath(const string & s1, const string & s2)
 {
     return s1.empty() ? s2 : s1 + "." + s2;
 }
@@ -348,7 +321,7 @@ static std::regex attrRegex("[A-Za-z_][A-Za-z0-9-_+]*");
 
 
 static void getDerivations(EvalState & state, Value & vIn,
-    const std::string & pathPrefix, Bindings & autoArgs,
+    const string & pathPrefix, Bindings & autoArgs,
     DrvInfos & drvs, Done & done,
     bool ignoreAssertionFailures)
 {
@@ -369,11 +342,11 @@ static void getDerivations(EvalState & state, Value & vIn,
            there are names clashes between derivations, the derivation
            bound to the attribute with the "lower" name should take
            precedence). */
-        for (auto & i : v.attrs->lexicographicOrder(state.symbols)) {
-            debug("evaluating attribute '%1%'", state.symbols[i->name]);
-            if (!std::regex_match(std::string(state.symbols[i->name]), attrRegex))
+        for (auto & i : v.attrs->lexicographicOrder()) {
+            debug("evaluating attribute '%1%'", i->name);
+            if (!std::regex_match(std::string(i->name), attrRegex))
                 continue;
-            std::string pathPrefix2 = addToPath(pathPrefix, state.symbols[i->name]);
+            string pathPrefix2 = addToPath(pathPrefix, i->name);
             if (combineChannels)
                 getDerivations(state, *i->value, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
             else if (getDerivation(state, *i->value, pathPrefix2, drvs, done, ignoreAssertionFailures)) {
@@ -382,7 +355,7 @@ static void getDerivations(EvalState & state, Value & vIn,
                    `recurseForDerivations = true' attribute. */
                 if (i->value->type() == nAttrs) {
                     Bindings::iterator j = i->value->attrs->find(state.sRecurseForDerivations);
-                    if (j != i->value->attrs->end() && state.forceBool(*j->value, j->pos))
+                    if (j != i->value->attrs->end() && state.forceBool(*j->value, *j->pos))
                         getDerivations(state, *i->value, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
                 }
             }
@@ -391,7 +364,7 @@ static void getDerivations(EvalState & state, Value & vIn,
 
     else if (v.type() == nList) {
         for (auto [n, elem] : enumerate(v.listItems())) {
-            std::string pathPrefix2 = addToPath(pathPrefix, fmt("%d", n));
+            string pathPrefix2 = addToPath(pathPrefix, fmt("%d", n));
             if (getDerivation(state, *elem, pathPrefix2, drvs, done, ignoreAssertionFailures))
                 getDerivations(state, *elem, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
         }
@@ -401,7 +374,7 @@ static void getDerivations(EvalState & state, Value & vIn,
 }
 
 
-void getDerivations(EvalState & state, Value & v, const std::string & pathPrefix,
+void getDerivations(EvalState & state, Value & v, const string & pathPrefix,
     Bindings & autoArgs, DrvInfos & drvs, bool ignoreAssertionFailures)
 {
     Done done;

src/libexpr/get-drvs.hh

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "eval.hh"
-#include "path.hh"
 
 #include <string>
 #include <map>
@@ -13,16 +12,16 @@ namespace nix {
 struct DrvInfo
 {
 public:
-    typedef std::map<std::string, std::optional<StorePath>> Outputs;
+    typedef std::map<string, Path> Outputs;
 
 private:
     EvalState * state;
 
-    mutable std::string name;
-    mutable std::string system;
-    mutable std::optional<std::optional<StorePath>> drvPath;
-    mutable std::optional<StorePath> outPath;
-    mutable std::string outputName;
+    mutable string name;
+    mutable string system;
+    mutable string drvPath;
+    mutable std::optional<string> outPath;
+    mutable string outputName;
     Outputs outputs;
 
     bool failed = false; // set if we get an AssertionError
@@ -34,38 +33,36 @@ private:
     bool checkMeta(Value & v);
 
 public:
-    std::string attrPath; /* path towards the derivation */
+    string attrPath; /* path towards the derivation */
 
     DrvInfo(EvalState & state) : state(&state) { };
-    DrvInfo(EvalState & state, std::string attrPath, Bindings * attrs);
+    DrvInfo(EvalState & state, const string & attrPath, Bindings * attrs);
     DrvInfo(EvalState & state, ref<Store> store, const std::string & drvPathWithOutputs);
 
-    std::string queryName() const;
-    std::string querySystem() const;
-    std::optional<StorePath> queryDrvPath() const;
-    StorePath requireDrvPath() const;
-    StorePath queryOutPath() const;
-    std::string queryOutputName() const;
-    /** Return the unordered map of output names to (optional) output paths.
-     * The "outputs to install" are determined by `meta.outputsToInstall`. */
-    Outputs queryOutputs(bool withPaths = true, bool onlyOutputsToInstall = false);
+    string queryName() const;
+    string querySystem() const;
+    string queryDrvPath() const;
+    string queryOutPath() const;
+    string queryOutputName() const;
+    /** Return the list of outputs. The "outputs to install" are determined by `meta.outputsToInstall`. */
+    Outputs queryOutputs(bool onlyOutputsToInstall = false);
 
     StringSet queryMetaNames();
-    Value * queryMeta(const std::string & name);
-    std::string queryMetaString(const std::string & name);
-    NixInt queryMetaInt(const std::string & name, NixInt def);
-    NixFloat queryMetaFloat(const std::string & name, NixFloat def);
-    bool queryMetaBool(const std::string & name, bool def);
-    void setMeta(const std::string & name, Value * v);
+    Value * queryMeta(const string & name);
+    string queryMetaString(const string & name);
+    NixInt queryMetaInt(const string & name, NixInt def);
+    NixFloat queryMetaFloat(const string & name, NixFloat def);
+    bool queryMetaBool(const string & name, bool def);
+    void setMeta(const string & name, Value * v);
 
     /*
     MetaInfo queryMetaInfo(EvalState & state) const;
     MetaValue queryMetaInfo(EvalState & state, const string & name) const;
     */
 
-    void setName(const std::string & s) { name = s; }
-    void setDrvPath(StorePath path) { drvPath = {{std::move(path)}}; }
-    void setOutPath(StorePath path) { outPath = {{std::move(path)}}; }
+    void setName(const string & s) { name = s; }
+    void setDrvPath(const string & s) { drvPath = s; }
+    void setOutPath(const string & s) { outPath = s; }
 
     void setFailed() { failed = true; };
     bool hasFailed() { return failed; };
@@ -73,7 +70,7 @@ public:
 
 
 #if HAVE_BOEHMGC
-typedef std::list<DrvInfo, traceable_allocator<DrvInfo>> DrvInfos;
+typedef std::list<DrvInfo, traceable_allocator<DrvInfo> > DrvInfos;
 #else
 typedef std::list<DrvInfo> DrvInfos;
 #endif
@@ -84,7 +81,7 @@ typedef std::list<DrvInfo> DrvInfos;
 std::optional<DrvInfo> getDerivation(EvalState & state,
     Value & v, bool ignoreAssertionFailures);
 
-void getDerivations(EvalState & state, Value & v, const std::string & pathPrefix,
+void getDerivations(EvalState & state, Value & v, const string & pathPrefix,
     Bindings & autoArgs, DrvInfos & drvs,
     bool ignoreAssertionFailures);
 

src/libexpr/lexer.l

@@ -28,13 +28,6 @@ using namespace nix;
 
 namespace nix {
 
-static inline PosIdx makeCurPos(const YYLTYPE & loc, ParseData * data)
-{
-    return data->state.positions.add(data->origin, loc.first_line, loc.first_column);
-}
-
-#define CUR_POS makeCurPos(*yylloc, data)
-
 // backup to recover from yyless(0)
 YYLTYPE prev_yylloc;
 
@@ -44,6 +37,7 @@ static void initLoc(YYLTYPE * loc)
     loc->first_column = loc->last_column = 1;
 }
 
+
 static void adjustLoc(YYLTYPE * loc, const char * s, size_t len)
 {
     prev_yylloc = *loc;
@@ -153,20 +147,14 @@ or          { return OR_KW; }
               try {
                   yylval->n = boost::lexical_cast<int64_t>(yytext);
               } catch (const boost::bad_lexical_cast &) {
-                  throw ParseError({
-                      .msg = hintfmt("invalid integer '%1%'", yytext),
-                      .errPos = data->state.positions[CUR_POS],
-                  });
+                  throw ParseError("invalid integer '%1%'", yytext);
               }
               return INT;
             }
 {FLOAT}     { errno = 0;
               yylval->nf = strtod(yytext, 0);
               if (errno != 0)
-                  throw ParseError({
-                      .msg = hintfmt("invalid float '%1%'", yytext),
-                      .errPos = data->state.positions[CUR_POS],
-                  });
+                  throw ParseError("invalid float '%1%'", yytext);
               return FLOAT;
             }
 
@@ -198,7 +186,7 @@ or          { return OR_KW; }
                    (...|\$[^\{\"\\]|\\.|\$\\.)+ would have triggered.
                    This is technically invalid, but we leave the problem to the
                    parser who fails with exact location. */
-                return EOF;
+                return STR;
               }
 
 \'\'(\ *\n)?     { PUSH_STATE(IND_STRING); return IND_STRING_OPEN; }
@@ -292,10 +280,7 @@ or          { return OR_KW; }
 
 <INPATH_SLASH>{ANY} |
 <INPATH_SLASH><<EOF>> {
-  throw ParseError({
-      .msg = hintfmt("path has a trailing slash"),
-      .errPos = data->state.positions[CUR_POS],
-  });
+  throw ParseError("path has a trailing slash");
 }
 
 {SPATH}     { yylval->path = {yytext, (size_t) yyleng}; return SPATH; }

src/libexpr/nixexpr.cc

@@ -1,19 +1,25 @@
 #include "nixexpr.hh"
 #include "derivations.hh"
-#include "eval.hh"
-#include "symbol-table.hh"
 #include "util.hh"
 
 #include <cstdlib>
 
+
 namespace nix {
 
+
 /* Displaying abstract syntax trees. */
 
-static void showString(std::ostream & str, std::string_view s)
+std::ostream & operator << (std::ostream & str, const Expr & e)
+{
+    e.show(str);
+    return str;
+}
+
+static void showString(std::ostream & str, const string & s)
 {
     str << '"';
-    for (auto c : s)
+    for (auto c : (string) s)
         if (c == '"' || c == '\\' || c == '$') str << "\\" << c;
         else if (c == '\n') str << "\\n";
         else if (c == '\r') str << "\\r";
@@ -22,10 +28,8 @@ static void showString(std::ostream & str, std::string_view s)
     str << '"';
 }
 
-std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
+static void showId(std::ostream & str, const string & s)
 {
-    std::string_view s = symbol;
-
     if (s.empty())
         str << "\"\"";
     else if (s == "if") // FIXME: handle other keywords
@@ -34,7 +38,7 @@ std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
         char c = s[0];
         if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')) {
             showString(str, s);
-            return str;
+            return;
         }
         for (auto c : s)
             if (!((c >= 'a' && c <= 'z') ||
@@ -42,104 +46,82 @@ std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
                   (c >= '0' && c <= '9') ||
                   c == '_' || c == '\'' || c == '-')) {
                 showString(str, s);
-                return str;
+                return;
             }
         str << s;
     }
+}
+
+std::ostream & operator << (std::ostream & str, const Symbol & sym)
+{
+    showId(str, *sym.s);
     return str;
 }
 
-void Expr::show(const SymbolTable & symbols, std::ostream & str) const
+void Expr::show(std::ostream & str) const
 {
     abort();
 }
 
-void ExprInt::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprInt::show(std::ostream & str) const
 {
     str << n;
 }
 
-void ExprFloat::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprFloat::show(std::ostream & str) const
 {
     str << nf;
 }
 
-void ExprString::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprString::show(std::ostream & str) const
 {
     showString(str, s);
 }
 
-void ExprPath::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprPath::show(std::ostream & str) const
 {
     str << s;
 }
 
-void ExprVar::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprVar::show(std::ostream & str) const
 {
-    str << symbols[name];
+    str << name;
 }
 
-void ExprSelect::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprSelect::show(std::ostream & str) const
 {
-    str << "(";
-    e->show(symbols, str);
-    str << ")." << showAttrPath(symbols, attrPath);
-    if (def) {
-        str << " or (";
-        def->show(symbols, str);
-        str << ")";
-    }
+    str << "(" << *e << ")." << showAttrPath(attrPath);
+    if (def) str << " or (" << *def << ")";
 }
 
-void ExprOpHasAttr::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprOpHasAttr::show(std::ostream & str) const
 {
-    str << "((";
-    e->show(symbols, str);
-    str << ") ? " << showAttrPath(symbols, attrPath) << ")";
+    str << "((" << *e << ") ? " << showAttrPath(attrPath) << ")";
 }
 
-void ExprAttrs::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprAttrs::show(std::ostream & str) const
 {
     if (recursive) str << "rec ";
     str << "{ ";
-    typedef const decltype(attrs)::value_type * Attr;
-    std::vector<Attr> sorted;
-    for (auto & i : attrs) sorted.push_back(&i);
-    std::sort(sorted.begin(), sorted.end(), [&](Attr a, Attr b) {
-        std::string_view sa = symbols[a->first], sb = symbols[b->first];
-        return sa < sb;
-    });
-    for (auto & i : sorted) {
-        if (i->second.inherited)
-            str << "inherit " << symbols[i->first] << " " << "; ";
-        else {
-            str << symbols[i->first] << " = ";
-            i->second.e->show(symbols, str);
-            str << "; ";
-        }
-    }
-    for (auto & i : dynamicAttrs) {
-        str << "\"${";
-        i.nameExpr->show(symbols, str);
-        str << "}\" = ";
-        i.valueExpr->show(symbols, str);
-        str << "; ";
-    }
+    for (auto & i : attrs)
+        if (i.second.inherited)
+            str << "inherit " << i.first << " " << "; ";
+        else
+            str << i.first << " = " << *i.second.e << "; ";
+    for (auto & i : dynamicAttrs)
+        str << "\"${" << *i.nameExpr << "}\" = " << *i.valueExpr << "; ";
     str << "}";
 }
 
-void ExprList::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprList::show(std::ostream & str) const
 {
     str << "[ ";
-    for (auto & i : elems) {
-        str << "(";
-        i->show(symbols, str);
-        str << ") ";
-    }
+    for (auto & i : elems)
+        str << "(" << *i << ") ";
     str << "]";
 }
 
-void ExprLambda::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprLambda::show(std::ostream & str) const
 {
     str << "(";
     if (hasFormals()) {
@@ -147,100 +129,74 @@ void ExprLambda::show(const SymbolTable & symbols, std::ostream & str) const
         bool first = true;
         for (auto & i : formals->formals) {
             if (first) first = false; else str << ", ";
-            str << symbols[i.name];
-            if (i.def) {
-                str << " ? ";
-                i.def->show(symbols, str);
-            }
+            str << i.name;
+            if (i.def) str << " ? " << *i.def;
         }
         if (formals->ellipsis) {
             if (!first) str << ", ";
             str << "...";
         }
         str << " }";
-        if (arg) str << " @ ";
+        if (!arg.empty()) str << " @ ";
     }
-    if (arg) str << symbols[arg];
-    str << ": ";
-    body->show(symbols, str);
-    str << ")";
+    if (!arg.empty()) str << arg;
+    str << ": " << *body << ")";
 }
 
-void ExprCall::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprCall::show(std::ostream & str) const
 {
-    str << '(';
-    fun->show(symbols, str);
+    str << '(' << *fun;
     for (auto e : args) {
         str <<  ' ';
-        e->show(symbols, str);
+        str << *e;
     }
     str << ')';
 }
 
-void ExprLet::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprLet::show(std::ostream & str) const
 {
     str << "(let ";
     for (auto & i : attrs->attrs)
         if (i.second.inherited) {
-            str << "inherit " << symbols[i.first] << "; ";
+            str << "inherit " << i.first << "; ";
         }
-        else {
-            str << symbols[i.first] << " = ";
-            i.second.e->show(symbols, str);
-            str << "; ";
-        }
-    str << "in ";
-    body->show(symbols, str);
-    str << ")";
+        else
+            str << i.first << " = " << *i.second.e << "; ";
+    str << "in " << *body << ")";
 }
 
-void ExprWith::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprWith::show(std::ostream & str) const
 {
-    str << "(with ";
-    attrs->show(symbols, str);
-    str << "; ";
-    body->show(symbols, str);
-    str << ")";
+    str << "(with " << *attrs << "; " << *body << ")";
 }
 
-void ExprIf::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprIf::show(std::ostream & str) const
 {
-    str << "(if ";
-    cond->show(symbols, str);
-    str << " then ";
-    then->show(symbols, str);
-    str << " else ";
-    else_->show(symbols, str);
-    str << ")";
+    str << "(if " << *cond << " then " << *then << " else " << *else_ << ")";
 }
 
-void ExprAssert::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprAssert::show(std::ostream & str) const
 {
-    str << "assert ";
-    cond->show(symbols, str);
-    str << "; ";
-    body->show(symbols, str);
+    str << "assert " << *cond << "; " << *body;
 }
 
-void ExprOpNot::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprOpNot::show(std::ostream & str) const
 {
-    str << "(! ";
-    e->show(symbols, str);
-    str << ")";
+    str << "(! " << *e << ")";
 }
 
-void ExprConcatStrings::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprConcatStrings::show(std::ostream & str) const
 {
     bool first = true;
     str << "(";
     for (auto & i : *es) {
         if (first) first = false; else str << " + ";
-        i.second->show(symbols, str);
+        str << *i.second;
     }
     str << ")";
 }
 
-void ExprPos::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprPos::show(std::ostream & str) const
 {
     str << "__curPos";
 }
@@ -255,7 +211,7 @@ std::ostream & operator << (std::ostream & str, const Pos & pos)
         auto f = format(ANSI_BOLD "%1%" ANSI_NORMAL ":%2%:%3%");
         switch (pos.origin) {
             case foFile:
-                f % (const std::string &) pos.file;
+                f % (string) pos.file;
                 break;
             case foStdin:
             case foString:
@@ -271,67 +227,55 @@ std::ostream & operator << (std::ostream & str, const Pos & pos)
 }
 
 
-std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath)
+string showAttrPath(const AttrPath & attrPath)
 {
     std::ostringstream out;
     bool first = true;
     for (auto & i : attrPath) {
         if (!first) out << '.'; else first = false;
-        if (i.symbol)
-            out << symbols[i.symbol];
-        else {
-            out << "\"${";
-            i.expr->show(symbols, out);
-            out << "}\"";
-        }
+        if (i.symbol.set())
+            out << i.symbol;
+        else
+            out << "\"${" << *i.expr << "}\"";
     }
     return out.str();
 }
 
 
+Pos noPos;
+
 
 /* Computing levels/displacements for variables. */
 
-void Expr::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void Expr::bindVars(const StaticEnv & env)
 {
     abort();
 }
 
-void ExprInt::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprInt::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
 }
 
-void ExprFloat::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprFloat::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
 }
 
-void ExprString::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprString::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
 }
 
-void ExprPath::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprPath::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
 }
 
-void ExprVar::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprVar::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
     /* Check whether the variable appears in the environment.  If so,
        set its level and displacement. */
     const StaticEnv * curEnv;
     Level level;
     int withLevel = -1;
-    for (curEnv = env.get(), level = 0; curEnv; curEnv = curEnv->up, level++) {
+    for (curEnv = &env, level = 0; curEnv; curEnv = curEnv->up, level++) {
         if (curEnv->isWith) {
             if (withLevel == -1) withLevel = level;
         } else {
@@ -350,222 +294,176 @@ void ExprVar::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> &
        "undefined variable" error now. */
     if (withLevel == -1)
         throw UndefinedVarError({
-            .msg = hintfmt("undefined variable '%1%'", es.symbols[name]),
-            .errPos = es.positions[pos]
+            .msg = hintfmt("undefined variable '%1%'", name),
+            .errPos = pos
         });
     fromWith = true;
     this->level = withLevel;
 }
 
-void ExprSelect::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprSelect::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    e->bindVars(es, env);
-    if (def) def->bindVars(es, env);
+    e->bindVars(env);
+    if (def) def->bindVars(env);
     for (auto & i : attrPath)
-        if (!i.symbol)
-            i.expr->bindVars(es, env);
+        if (!i.symbol.set())
+            i.expr->bindVars(env);
 }
 
-void ExprOpHasAttr::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprOpHasAttr::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    e->bindVars(es, env);
+    e->bindVars(env);
     for (auto & i : attrPath)
-        if (!i.symbol)
-            i.expr->bindVars(es, env);
+        if (!i.symbol.set())
+            i.expr->bindVars(env);
 }
 
-void ExprAttrs::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprAttrs::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
+    const StaticEnv * dynamicEnv = &env;
+    StaticEnv newEnv(false, &env, recursive ? attrs.size() : 0);
 
     if (recursive) {
-        auto newEnv = std::make_shared<StaticEnv>(false, env.get(), recursive ? attrs.size() : 0);
+        dynamicEnv = &newEnv;
 
         Displacement displ = 0;
         for (auto & i : attrs)
-            newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
+            newEnv.vars.emplace_back(i.first, i.second.displ = displ++);
 
         // No need to sort newEnv since attrs is in sorted order.
 
         for (auto & i : attrs)
-            i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
-
-        for (auto & i : dynamicAttrs) {
-            i.nameExpr->bindVars(es, newEnv);
-            i.valueExpr->bindVars(es, newEnv);
-        }
+            i.second.e->bindVars(i.second.inherited ? env : newEnv);
     }
-    else {
+
+    else
         for (auto & i : attrs)
-            i.second.e->bindVars(es, env);
+            i.second.e->bindVars(env);
 
-        for (auto & i : dynamicAttrs) {
-            i.nameExpr->bindVars(es, env);
-            i.valueExpr->bindVars(es, env);
-        }
+    for (auto & i : dynamicAttrs) {
+        i.nameExpr->bindVars(*dynamicEnv);
+        i.valueExpr->bindVars(*dynamicEnv);
     }
 }
 
-void ExprList::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprList::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
     for (auto & i : elems)
-        i->bindVars(es, env);
+        i->bindVars(env);
 }
 
-void ExprLambda::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprLambda::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    auto newEnv = std::make_shared<StaticEnv>(
-        false, env.get(),
+    StaticEnv newEnv(
+        false, &env,
         (hasFormals() ? formals->formals.size() : 0) +
-        (!arg ? 0 : 1));
+        (arg.empty() ? 0 : 1));
 
     Displacement displ = 0;
 
-    if (arg) newEnv->vars.emplace_back(arg, displ++);
+    if (!arg.empty()) newEnv.vars.emplace_back(arg, displ++);
 
     if (hasFormals()) {
         for (auto & i : formals->formals)
-            newEnv->vars.emplace_back(i.name, displ++);
+            newEnv.vars.emplace_back(i.name, displ++);
 
-        newEnv->sort();
+        newEnv.sort();
 
         for (auto & i : formals->formals)
-            if (i.def) i.def->bindVars(es, newEnv);
+            if (i.def) i.def->bindVars(newEnv);
     }
 
-    body->bindVars(es, newEnv);
+    body->bindVars(newEnv);
 }
 
-void ExprCall::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprCall::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    fun->bindVars(es, env);
+    fun->bindVars(env);
     for (auto e : args)
-        e->bindVars(es, env);
+        e->bindVars(env);
 }
 
-void ExprLet::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprLet::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    auto newEnv = std::make_shared<StaticEnv>(false, env.get(), attrs->attrs.size());
+    StaticEnv newEnv(false, &env, attrs->attrs.size());
 
     Displacement displ = 0;
     for (auto & i : attrs->attrs)
-        newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
+        newEnv.vars.emplace_back(i.first, i.second.displ = displ++);
 
     // No need to sort newEnv since attrs->attrs is in sorted order.
 
     for (auto & i : attrs->attrs)
-        i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
+        i.second.e->bindVars(i.second.inherited ? env : newEnv);
 
-    body->bindVars(es, newEnv);
+    body->bindVars(newEnv);
 }
 
-void ExprWith::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprWith::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
     /* Does this `with' have an enclosing `with'?  If so, record its
        level so that `lookupVar' can look up variables in the previous
        `with' if this one doesn't contain the desired attribute. */
     const StaticEnv * curEnv;
     Level level;
     prevWith = 0;
-    for (curEnv = env.get(), level = 1; curEnv; curEnv = curEnv->up, level++)
+    for (curEnv = &env, level = 1; curEnv; curEnv = curEnv->up, level++)
         if (curEnv->isWith) {
             prevWith = level;
             break;
         }
 
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    attrs->bindVars(es, env);
-    auto newEnv = std::make_shared<StaticEnv>(true, env.get());
-    body->bindVars(es, newEnv);
+    attrs->bindVars(env);
+    StaticEnv newEnv(true, &env);
+    body->bindVars(newEnv);
 }
 
-void ExprIf::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprIf::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    cond->bindVars(es, env);
-    then->bindVars(es, env);
-    else_->bindVars(es, env);
+    cond->bindVars(env);
+    then->bindVars(env);
+    else_->bindVars(env);
 }
 
-void ExprAssert::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprAssert::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    cond->bindVars(es, env);
-    body->bindVars(es, env);
+    cond->bindVars(env);
+    body->bindVars(env);
 }
 
-void ExprOpNot::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprOpNot::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    e->bindVars(es, env);
+    e->bindVars(env);
 }
 
-void ExprConcatStrings::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprConcatStrings::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
-
-    for (auto & i : *this->es)
-        i.second->bindVars(es, env);
+    for (auto & i : *es)
+        i.second->bindVars(env);
 }
 
-void ExprPos::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+void ExprPos::bindVars(const StaticEnv & env)
 {
-    if (es.debugRepl)
-        es.exprEnvs.insert(std::make_pair(this, env));
 }
 
 
 /* Storing function names. */
 
-void Expr::setName(Symbol name)
+void Expr::setName(Symbol & name)
 {
 }
 
 
-void ExprLambda::setName(Symbol name)
+void ExprLambda::setName(Symbol & name)
 {
     this->name = name;
     body->setName(name);
 }
 
 
-std::string ExprLambda::showNamePos(const EvalState & state) const
+string ExprLambda::showNamePos() const
 {
-    std::string id(name
-        ? concatStrings("'", state.symbols[name], "'")
-        : "anonymous function");
-    return fmt("%1% at %2%", id, state.positions[pos]);
+    return (format("%1% at %2%") % (name.set() ? "'" + (string) name + "'" : "anonymous function") % pos).str();
 }
 
 
@@ -575,7 +473,8 @@ std::string ExprLambda::showNamePos(const EvalState & state) const
 size_t SymbolTable::totalSize() const
 {
     size_t n = 0;
-    dump([&] (const std::string & s) { n += s.size(); });
+    for (auto & i : store)
+        n += i.size();
     return n;
 }
 

src/libexpr/nixexpr.hh

@@ -1,12 +1,8 @@
 #pragma once
 
-#include <map>
-#include <vector>
-
 #include "value.hh"
 #include "symbol-table.hh"
 #include "error.hh"
-#include "chunked-vector.hh"
 
 
 namespace nix {
@@ -22,96 +18,35 @@ MakeError(UndefinedVarError, Error);
 MakeError(MissingArgumentError, EvalError);
 MakeError(RestrictedPathError, Error);
 
+
 /* Position objects. */
 
 struct Pos
 {
-    std::string file;
     FileOrigin origin;
-    uint32_t line;
-    uint32_t column;
-
-    explicit operator bool() const { return line > 0; }
-};
-
-class PosIdx {
-    friend class PosTable;
-
-private:
-    uint32_t id;
-
-    explicit PosIdx(uint32_t id): id(id) {}
-
-public:
-    PosIdx() : id(0) {}
-
-    explicit operator bool() const { return id > 0; }
-
-    bool operator<(const PosIdx other) const { return id < other.id; }
-};
-
-class PosTable
-{
-public:
-    class Origin {
-        friend PosTable;
-    private:
-        // must always be invalid by default, add() replaces this with the actual value.
-        // subsequent add() calls use this index as a token to quickly check whether the
-        // current origins.back() can be reused or not.
-        mutable uint32_t idx = std::numeric_limits<uint32_t>::max();
-
-        explicit Origin(uint32_t idx): idx(idx), file{}, origin{} {}
-
-    public:
-        const std::string file;
-        const FileOrigin origin;
-
-        Origin(std::string file, FileOrigin origin): file(std::move(file)), origin(origin) {}
-    };
-
-    struct Offset {
-        uint32_t line, column;
-    };
-
-private:
-    std::vector<Origin> origins;
-    ChunkedVector<Offset, 8192> offsets;
-
-public:
-    PosTable(): offsets(1024)
+    Symbol file;
+    unsigned int line, column;
+    Pos() : origin(foString), line(0), column(0) { };
+    Pos(FileOrigin origin, const Symbol & file, unsigned int line, unsigned int column)
+        : origin(origin), file(file), line(line), column(column) { };
+    operator bool() const
     {
-        origins.reserve(1024);
+        return line != 0;
     }
-
-    PosIdx add(const Origin & origin, uint32_t line, uint32_t column)
+    bool operator < (const Pos & p2) const
     {
-        const auto idx = offsets.add({line, column}).second;
-        if (origins.empty() || origins.back().idx != origin.idx) {
-            origin.idx = idx;
-            origins.push_back(origin);
-        }
-        return PosIdx(idx + 1);
-    }
-
-    Pos operator[](PosIdx p) const
-    {
-        if (p.id == 0 || p.id > offsets.size())
-            return {};
-        const auto idx = p.id - 1;
-        /* we want the last key <= idx, so we'll take prev(first key > idx).
-           this is guaranteed to never rewind origin.begin because the first
-           key is always 0. */
-        const auto pastOrigin = std::upper_bound(
-            origins.begin(), origins.end(), Origin(idx),
-            [] (const auto & a, const auto & b) { return a.idx < b.idx; });
-        const auto origin = *std::prev(pastOrigin);
-        const auto offset = offsets[idx];
-        return {origin.file, origin.origin, offset.line, offset.column};
+        if (!line) return p2.line;
+        if (!p2.line) return false;
+        int d = ((string) file).compare((string) p2.file);
+        if (d < 0) return true;
+        if (d > 0) return false;
+        if (line < p2.line) return true;
+        if (line > p2.line) return false;
+        return column < p2.column;
     }
 };
 
-inline PosIdx noPos = {};
+extern Pos noPos;
 
 std::ostream & operator << (std::ostream & str, const Pos & pos);
 
@@ -127,13 +62,13 @@ struct AttrName
 {
     Symbol symbol;
     Expr * expr;
-    AttrName(Symbol s) : symbol(s) {};
+    AttrName(const Symbol & s) : symbol(s) {};
     AttrName(Expr * e) : expr(e) {};
 };
 
 typedef std::vector<AttrName> AttrPath;
 
-std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath);
+string showAttrPath(const AttrPath & attrPath);
 
 
 /* Abstract syntax of Nix expressions. */
@@ -141,26 +76,27 @@ std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath)
 struct Expr
 {
     virtual ~Expr() { };
-    virtual void show(const SymbolTable & symbols, std::ostream & str) const;
-    virtual void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env);
+    virtual void show(std::ostream & str) const;
+    virtual void bindVars(const StaticEnv & env);
     virtual void eval(EvalState & state, Env & env, Value & v);
     virtual Value * maybeThunk(EvalState & state, Env & env);
-    virtual void setName(Symbol name);
-    virtual PosIdx getPos() const { return noPos; }
+    virtual void setName(Symbol & name);
 };
 
+std::ostream & operator << (std::ostream & str, const Expr & e);
+
 #define COMMON_METHODS \
-    void show(const SymbolTable & symbols, std::ostream & str) const;    \
+    void show(std::ostream & str) const; \
     void eval(EvalState & state, Env & env, Value & v); \
-    void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env);
+    void bindVars(const StaticEnv & env);
 
 struct ExprInt : Expr
 {
     NixInt n;
     Value v;
     ExprInt(NixInt n) : n(n) { v.mkInt(n); };
-    Value * maybeThunk(EvalState & state, Env & env);
     COMMON_METHODS
+    Value * maybeThunk(EvalState & state, Env & env);
 };
 
 struct ExprFloat : Expr
@@ -168,26 +104,26 @@ struct ExprFloat : Expr
     NixFloat nf;
     Value v;
     ExprFloat(NixFloat nf) : nf(nf) { v.mkFloat(nf); };
-    Value * maybeThunk(EvalState & state, Env & env);
     COMMON_METHODS
+    Value * maybeThunk(EvalState & state, Env & env);
 };
 
 struct ExprString : Expr
 {
-    std::string s;
+    string s;
     Value v;
     ExprString(std::string s) : s(std::move(s)) { v.mkString(this->s.data()); };
-    Value * maybeThunk(EvalState & state, Env & env);
     COMMON_METHODS
+    Value * maybeThunk(EvalState & state, Env & env);
 };
 
 struct ExprPath : Expr
 {
-    std::string s;
+    string s;
     Value v;
-    ExprPath(std::string s) : s(std::move(s)) { v.mkPath(this->s.c_str()); };
-    Value * maybeThunk(EvalState & state, Env & env);
+    ExprPath(const string & s) : s(s) { v.mkPath(this->s.c_str()); };
     COMMON_METHODS
+    Value * maybeThunk(EvalState & state, Env & env);
 };
 
 typedef uint32_t Level;
@@ -195,7 +131,7 @@ typedef uint32_t Displacement;
 
 struct ExprVar : Expr
 {
-    PosIdx pos;
+    Pos pos;
     Symbol name;
 
     /* Whether the variable comes from an environment (e.g. a rec, let
@@ -211,21 +147,19 @@ struct ExprVar : Expr
     Level level;
     Displacement displ;
 
-    ExprVar(Symbol name) : name(name) { };
-    ExprVar(const PosIdx & pos, Symbol name) : pos(pos), name(name) { };
-    Value * maybeThunk(EvalState & state, Env & env);
-    PosIdx getPos() const override { return pos; }
+    ExprVar(const Symbol & name) : name(name) { };
+    ExprVar(const Pos & pos, const Symbol & name) : pos(pos), name(name) { };
     COMMON_METHODS
+    Value * maybeThunk(EvalState & state, Env & env);
 };
 
 struct ExprSelect : Expr
 {
-    PosIdx pos;
+    Pos pos;
     Expr * e, * def;
     AttrPath attrPath;
-    ExprSelect(const PosIdx & pos, Expr * e, const AttrPath & attrPath, Expr * def) : pos(pos), e(e), def(def), attrPath(attrPath) { };
-    ExprSelect(const PosIdx & pos, Expr * e, Symbol name) : pos(pos), e(e), def(0) { attrPath.push_back(AttrName(name)); };
-    PosIdx getPos() const override { return pos; }
+    ExprSelect(const Pos & pos, Expr * e, const AttrPath & attrPath, Expr * def) : pos(pos), e(e), def(def), attrPath(attrPath) { };
+    ExprSelect(const Pos & pos, Expr * e, const Symbol & name) : pos(pos), e(e), def(0) { attrPath.push_back(AttrName(name)); };
     COMMON_METHODS
 };
 
@@ -234,20 +168,19 @@ struct ExprOpHasAttr : Expr
     Expr * e;
     AttrPath attrPath;
     ExprOpHasAttr(Expr * e, const AttrPath & attrPath) : e(e), attrPath(attrPath) { };
-    PosIdx getPos() const override { return e->getPos(); }
     COMMON_METHODS
 };
 
 struct ExprAttrs : Expr
 {
     bool recursive;
-    PosIdx pos;
+    Pos pos;
     struct AttrDef {
         bool inherited;
         Expr * e;
-        PosIdx pos;
+        Pos pos;
         Displacement displ; // displacement
-        AttrDef(Expr * e, const PosIdx & pos, bool inherited=false)
+        AttrDef(Expr * e, const Pos & pos, bool inherited=false)
             : inherited(inherited), e(e), pos(pos) { };
         AttrDef() { };
     };
@@ -255,15 +188,14 @@ struct ExprAttrs : Expr
     AttrDefs attrs;
     struct DynamicAttrDef {
         Expr * nameExpr, * valueExpr;
-        PosIdx pos;
-        DynamicAttrDef(Expr * nameExpr, Expr * valueExpr, const PosIdx & pos)
+        Pos pos;
+        DynamicAttrDef(Expr * nameExpr, Expr * valueExpr, const Pos & pos)
             : nameExpr(nameExpr), valueExpr(valueExpr), pos(pos) { };
     };
     typedef std::vector<DynamicAttrDef> DynamicAttrDefs;
     DynamicAttrDefs dynamicAttrs;
-    ExprAttrs(const PosIdx &pos) : recursive(false), pos(pos) { };
-    ExprAttrs() : recursive(false) { };
-    PosIdx getPos() const override { return pos; }
+    ExprAttrs(const Pos &pos) : recursive(false), pos(pos) { };
+    ExprAttrs() : recursive(false), pos(noPos) { };
     COMMON_METHODS
 };
 
@@ -272,18 +204,14 @@ struct ExprList : Expr
     std::vector<Expr *> elems;
     ExprList() { };
     COMMON_METHODS
-
-    PosIdx getPos() const override
-    {
-        return elems.empty() ? noPos : elems.front()->getPos();
-    }
 };
 
 struct Formal
 {
-    PosIdx pos;
+    Pos pos;
     Symbol name;
     Expr * def;
+    Formal(const Pos & pos, const Symbol & name, Expr * def) : pos(pos), name(name), def(def) { };
 };
 
 struct Formals
@@ -292,20 +220,18 @@ struct Formals
     Formals_ formals;
     bool ellipsis;
 
-    bool has(Symbol arg) const
-    {
+    bool has(Symbol arg) const {
         auto it = std::lower_bound(formals.begin(), formals.end(), arg,
             [] (const Formal & f, const Symbol & sym) { return f.name < sym; });
         return it != formals.end() && it->name == arg;
     }
 
-    std::vector<Formal> lexicographicOrder(const SymbolTable & symbols) const
+    std::vector<Formal> lexicographicOrder() const
     {
         std::vector<Formal> result(formals.begin(), formals.end());
         std::sort(result.begin(), result.end(),
-            [&] (const Formal & a, const Formal & b) {
-                std::string_view sa = symbols[a.name], sb = symbols[b.name];
-                return sa < sb;
+            [] (const Formal & a, const Formal & b) {
+                return std::string_view(a.name) < std::string_view(b.name);
             });
         return result;
     }
@@ -313,23 +239,18 @@ struct Formals
 
 struct ExprLambda : Expr
 {
-    PosIdx pos;
+    Pos pos;
     Symbol name;
     Symbol arg;
     Formals * formals;
     Expr * body;
-    ExprLambda(PosIdx pos, Symbol arg, Formals * formals, Expr * body)
+    ExprLambda(const Pos & pos, const Symbol & arg, Formals * formals, Expr * body)
         : pos(pos), arg(arg), formals(formals), body(body)
     {
     };
-    ExprLambda(PosIdx pos, Formals * formals, Expr * body)
-        : pos(pos), formals(formals), body(body)
-    {
-    }
-    void setName(Symbol name);
-    std::string showNamePos(const EvalState & state) const;
+    void setName(Symbol & name);
+    string showNamePos() const;
     inline bool hasFormals() const { return formals != nullptr; }
-    PosIdx getPos() const override { return pos; }
     COMMON_METHODS
 };
 
@@ -337,11 +258,10 @@ struct ExprCall : Expr
 {
     Expr * fun;
     std::vector<Expr *> args;
-    PosIdx pos;
-    ExprCall(const PosIdx & pos, Expr * fun, std::vector<Expr *> && args)
+    Pos pos;
+    ExprCall(const Pos & pos, Expr * fun, std::vector<Expr *> && args)
         : fun(fun), args(args), pos(pos)
     { }
-    PosIdx getPos() const override { return pos; }
     COMMON_METHODS
 };
 
@@ -355,29 +275,26 @@ struct ExprLet : Expr
 
 struct ExprWith : Expr
 {
-    PosIdx pos;
+    Pos pos;
     Expr * attrs, * body;
     size_t prevWith;
-    ExprWith(const PosIdx & pos, Expr * attrs, Expr * body) : pos(pos), attrs(attrs), body(body) { };
-    PosIdx getPos() const override { return pos; }
+    ExprWith(const Pos & pos, Expr * attrs, Expr * body) : pos(pos), attrs(attrs), body(body) { };
     COMMON_METHODS
 };
 
 struct ExprIf : Expr
 {
-    PosIdx pos;
+    Pos pos;
     Expr * cond, * then, * else_;
-    ExprIf(const PosIdx & pos, Expr * cond, Expr * then, Expr * else_) : pos(pos), cond(cond), then(then), else_(else_) { };
-    PosIdx getPos() const override { return pos; }
+    ExprIf(const Pos & pos, Expr * cond, Expr * then, Expr * else_) : pos(pos), cond(cond), then(then), else_(else_) { };
     COMMON_METHODS
 };
 
 struct ExprAssert : Expr
 {
-    PosIdx pos;
+    Pos pos;
     Expr * cond, * body;
-    ExprAssert(const PosIdx & pos, Expr * cond, Expr * body) : pos(pos), cond(cond), body(body) { };
-    PosIdx getPos() const override { return pos; }
+    ExprAssert(const Pos & pos, Expr * cond, Expr * body) : pos(pos), cond(cond), body(body) { };
     COMMON_METHODS
 };
 
@@ -391,20 +308,19 @@ struct ExprOpNot : Expr
 #define MakeBinOp(name, s) \
     struct name : Expr \
     { \
-        PosIdx pos; \
+        Pos pos; \
         Expr * e1, * e2; \
         name(Expr * e1, Expr * e2) : e1(e1), e2(e2) { }; \
-        name(const PosIdx & pos, Expr * e1, Expr * e2) : pos(pos), e1(e1), e2(e2) { }; \
-        void show(const SymbolTable & symbols, std::ostream & str) const \
+        name(const Pos & pos, Expr * e1, Expr * e2) : pos(pos), e1(e1), e2(e2) { }; \
+        void show(std::ostream & str) const \
         { \
-            str << "("; e1->show(symbols, str); str << " " s " "; e2->show(symbols, str); str << ")"; \
+            str << "(" << *e1 << " " s " " << *e2 << ")";   \
         } \
-        void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)    \
+        void bindVars(const StaticEnv & env) \
         { \
-            e1->bindVars(es, env); e2->bindVars(es, env);    \
+            e1->bindVars(env); e2->bindVars(env); \
         } \
         void eval(EvalState & state, Env & env, Value & v); \
-        PosIdx getPos() const override { return pos; } \
     };
 
 MakeBinOp(ExprOpEq, "==")
@@ -417,20 +333,18 @@ MakeBinOp(ExprOpConcatLists, "++")
 
 struct ExprConcatStrings : Expr
 {
-    PosIdx pos;
+    Pos pos;
     bool forceString;
-    std::vector<std::pair<PosIdx, Expr *>> * es;
-    ExprConcatStrings(const PosIdx & pos, bool forceString, std::vector<std::pair<PosIdx, Expr *>> * es)
+    std::vector<std::pair<Pos, Expr *> > * es;
+    ExprConcatStrings(const Pos & pos, bool forceString, std::vector<std::pair<Pos, Expr *> > * es)
         : pos(pos), forceString(forceString), es(es) { };
-    PosIdx getPos() const override { return pos; }
     COMMON_METHODS
 };
 
 struct ExprPos : Expr
 {
-    PosIdx pos;
-    ExprPos(const PosIdx & pos) : pos(pos) { };
-    PosIdx getPos() const override { return pos; }
+    Pos pos;
+    ExprPos(const Pos & pos) : pos(pos) { };
     COMMON_METHODS
 };
 
@@ -468,7 +382,7 @@ struct StaticEnv
         vars.erase(it, end);
     }
 
-    Vars::const_iterator find(Symbol name) const
+    Vars::const_iterator find(const Symbol & name) const
     {
         Vars::value_type key(name, 0);
         auto i = std::lower_bound(vars.begin(), vars.end(), key);

src/libexpr/parser.y

@@ -32,12 +32,12 @@ namespace nix {
         SymbolTable & symbols;
         Expr * result;
         Path basePath;
-        PosTable::Origin origin;
+        Symbol file;
+        FileOrigin origin;
         std::optional<ErrorInfo> error;
-        ParseData(EvalState & state, PosTable::Origin origin)
+        ParseData(EvalState & state)
             : state(state)
             , symbols(state.symbols)
-            , origin(std::move(origin))
             { };
     };
 
@@ -77,26 +77,26 @@ using namespace nix;
 namespace nix {
 
 
-static void dupAttr(const EvalState & state, const AttrPath & attrPath, const PosIdx pos, const PosIdx prevPos)
+static void dupAttr(const AttrPath & attrPath, const Pos & pos, const Pos & prevPos)
 {
     throw ParseError({
          .msg = hintfmt("attribute '%1%' already defined at %2%",
-             showAttrPath(state.symbols, attrPath), state.positions[prevPos]),
-         .errPos = state.positions[pos]
+             showAttrPath(attrPath), prevPos),
+         .errPos = pos
     });
 }
 
-static void dupAttr(const EvalState & state, Symbol attr, const PosIdx pos, const PosIdx prevPos)
+static void dupAttr(Symbol attr, const Pos & pos, const Pos & prevPos)
 {
     throw ParseError({
-        .msg = hintfmt("attribute '%1%' already defined at %2%", state.symbols[attr], state.positions[prevPos]),
-        .errPos = state.positions[pos]
+        .msg = hintfmt("attribute '%1%' already defined at %2%", attr, prevPos),
+        .errPos = pos
     });
 }
 
 
 static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
-    Expr * e, const PosIdx pos, const nix::EvalState & state)
+    Expr * e, const Pos & pos)
 {
     AttrPath::iterator i;
     // All attrpaths have at least one attr
@@ -104,15 +104,15 @@ static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
     // Checking attrPath validity.
     // ===========================
     for (i = attrPath.begin(); i + 1 < attrPath.end(); i++) {
-        if (i->symbol) {
+        if (i->symbol.set()) {
             ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
             if (j != attrs->attrs.end()) {
                 if (!j->second.inherited) {
                     ExprAttrs * attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
-                    if (!attrs2) dupAttr(state, attrPath, pos, j->second.pos);
+                    if (!attrs2) dupAttr(attrPath, pos, j->second.pos);
                     attrs = attrs2;
                 } else
-                    dupAttr(state, attrPath, pos, j->second.pos);
+                    dupAttr(attrPath, pos, j->second.pos);
             } else {
                 ExprAttrs * nested = new ExprAttrs;
                 attrs->attrs[i->symbol] = ExprAttrs::AttrDef(nested, pos);
@@ -126,7 +126,7 @@ static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
     }
     // Expr insertion.
     // ==========================
-    if (i->symbol) {
+    if (i->symbol.set()) {
         ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
         if (j != attrs->attrs.end()) {
             // This attr path is already defined. However, if both
@@ -139,11 +139,11 @@ static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
                 for (auto & ad : ae->attrs) {
                     auto j2 = jAttrs->attrs.find(ad.first);
                     if (j2 != jAttrs->attrs.end()) // Attr already defined in iAttrs, error.
-                        dupAttr(state, ad.first, j2->second.pos, ad.second.pos);
+                        dupAttr(ad.first, j2->second.pos, ad.second.pos);
                     jAttrs->attrs.emplace(ad.first, ad.second);
                 }
             } else {
-                dupAttr(state, attrPath, pos, j->second.pos);
+                dupAttr(attrPath, pos, j->second.pos);
             }
         } else {
             // This attr path is not defined. Let's create it.
@@ -157,14 +157,14 @@ static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
 
 
 static Formals * toFormals(ParseData & data, ParserFormals * formals,
-    PosIdx pos = noPos, Symbol arg = {})
+    Pos pos = noPos, Symbol arg = {})
 {
     std::sort(formals->formals.begin(), formals->formals.end(),
         [] (const auto & a, const auto & b) {
             return std::tie(a.name, a.pos) < std::tie(b.name, b.pos);
         });
 
-    std::optional<std::pair<Symbol, PosIdx>> duplicate;
+    std::optional<std::pair<Symbol, Pos>> duplicate;
     for (size_t i = 0; i + 1 < formals->formals.size(); i++) {
         if (formals->formals[i].name != formals->formals[i + 1].name)
             continue;
@@ -173,18 +173,18 @@ static Formals * toFormals(ParseData & data, ParserFormals * formals,
     }
     if (duplicate)
         throw ParseError({
-            .msg = hintfmt("duplicate formal function argument '%1%'", data.symbols[duplicate->first]),
-            .errPos = data.state.positions[duplicate->second]
+            .msg = hintfmt("duplicate formal function argument '%1%'", duplicate->first),
+            .errPos = duplicate->second
         });
 
     Formals result;
     result.ellipsis = formals->ellipsis;
     result.formals = std::move(formals->formals);
 
-    if (arg && result.has(arg))
+    if (arg.set() && result.has(arg))
         throw ParseError({
-            .msg = hintfmt("duplicate formal function argument '%1%'", data.symbols[arg]),
-            .errPos = data.state.positions[pos]
+            .msg = hintfmt("duplicate formal function argument '%1%'", arg),
+            .errPos = pos
         });
 
     delete formals;
@@ -192,8 +192,8 @@ static Formals * toFormals(ParseData & data, ParserFormals * formals,
 }
 
 
-static Expr * stripIndentation(const PosIdx pos, SymbolTable & symbols,
-    std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>> & es)
+static Expr * stripIndentation(const Pos & pos, SymbolTable & symbols,
+    std::vector<std::pair<Pos, std::variant<Expr *, StringToken> > > & es)
 {
     if (es.empty()) return new ExprString("");
 
@@ -233,7 +233,7 @@ static Expr * stripIndentation(const PosIdx pos, SymbolTable & symbols,
     }
 
     /* Strip spaces from each line. */
-    auto * es2 = new std::vector<std::pair<PosIdx, Expr *>>;
+    std::vector<std::pair<Pos, Expr *> > * es2 = new std::vector<std::pair<Pos, Expr *> >;
     atStartOfLine = true;
     size_t curDropped = 0;
     size_t n = es.size();
@@ -244,7 +244,7 @@ static Expr * stripIndentation(const PosIdx pos, SymbolTable & symbols,
         es2->emplace_back(i->first, e);
     };
     const auto trimString = [&] (const StringToken & t) {
-        std::string s2;
+        string s2;
         for (size_t j = 0; j < t.l; ++j) {
             if (atStartOfLine) {
                 if (t.p[j] == ' ') {
@@ -268,9 +268,9 @@ static Expr * stripIndentation(const PosIdx pos, SymbolTable & symbols,
         /* Remove the last line if it is empty and consists only of
            spaces. */
         if (n == 1) {
-            std::string::size_type p = s2.find_last_of('\n');
-            if (p != std::string::npos && s2.find_first_not_of(' ', p + 1) == std::string::npos)
-                s2 = std::string(s2, 0, p + 1);
+            string::size_type p = s2.find_last_of('\n');
+            if (p != string::npos && s2.find_first_not_of(' ', p + 1) == string::npos)
+                s2 = string(s2, 0, p + 1);
         }
 
         es2->emplace_back(i->first, new ExprString(s2));
@@ -284,9 +284,9 @@ static Expr * stripIndentation(const PosIdx pos, SymbolTable & symbols,
 }
 
 
-static inline PosIdx makeCurPos(const YYLTYPE & loc, ParseData * data)
+static inline Pos makeCurPos(const YYLTYPE & loc, ParseData * data)
 {
-    return data->state.positions.add(data->origin, loc.first_line, loc.first_column);
+    return Pos(data->origin, data->file, loc.first_line, loc.first_column);
 }
 
 #define CUR_POS makeCurPos(*yylocp, data)
@@ -299,7 +299,7 @@ void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, const char * err
 {
     data->error = {
         .msg = hintfmt(error),
-        .errPos = data->state.positions[makeCurPos(*loc, data)]
+        .errPos = makeCurPos(*loc, data)
     };
 }
 
@@ -320,8 +320,8 @@ void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, const char * err
   StringToken uri;
   StringToken str;
   std::vector<nix::AttrName> * attrNames;
-  std::vector<std::pair<nix::PosIdx, nix::Expr *>> * string_parts;
-  std::vector<std::pair<nix::PosIdx, std::variant<nix::Expr *, StringToken>>> * ind_string_parts;
+  std::vector<std::pair<nix::Pos, nix::Expr *> > * string_parts;
+  std::vector<std::pair<nix::Pos, std::variant<nix::Expr *, StringToken> > > * ind_string_parts;
 }
 
 %type <e> start expr expr_function expr_if expr_op
@@ -369,15 +369,15 @@ expr_function
   : ID ':' expr_function
     { $$ = new ExprLambda(CUR_POS, data->symbols.create($1), 0, $3); }
   | '{' formals '}' ':' expr_function
-    { $$ = new ExprLambda(CUR_POS, toFormals(*data, $2), $5); }
+    { $$ = new ExprLambda(CUR_POS, data->symbols.create(""), toFormals(*data, $2), $5); }
   | '{' formals '}' '@' ID ':' expr_function
     {
-      auto arg = data->symbols.create($5);
+      Symbol arg = data->symbols.create($5);
       $$ = new ExprLambda(CUR_POS, arg, toFormals(*data, $2, CUR_POS, arg), $7);
     }
   | ID '@' '{' formals '}' ':' expr_function
     {
-      auto arg = data->symbols.create($1);
+      Symbol arg = data->symbols.create($1);
       $$ = new ExprLambda(CUR_POS, arg, toFormals(*data, $4, CUR_POS, arg), $7);
     }
   | ASSERT expr ';' expr_function
@@ -388,7 +388,7 @@ expr_function
     { if (!$2->dynamicAttrs.empty())
         throw ParseError({
             .msg = hintfmt("dynamic attributes not allowed in let"),
-            .errPos = data->state.positions[CUR_POS]
+            .errPos = CUR_POS
         });
       $$ = new ExprLet($2, $4);
     }
@@ -415,7 +415,7 @@ expr_op
   | expr_op UPDATE expr_op { $$ = new ExprOpUpdate(CUR_POS, $1, $3); }
   | expr_op '?' attrpath { $$ = new ExprOpHasAttr($1, *$3); }
   | expr_op '+' expr_op
-    { $$ = new ExprConcatStrings(CUR_POS, false, new std::vector<std::pair<PosIdx, Expr *>>({{makeCurPos(@1, data), $1}, {makeCurPos(@3, data), $3}})); }
+    { $$ = new ExprConcatStrings(CUR_POS, false, new std::vector<std::pair<Pos, Expr *> >({{makeCurPos(@1, data), $1}, {makeCurPos(@3, data), $3}})); }
   | expr_op '-' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__sub")), {$1, $3}); }
   | expr_op '*' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__mul")), {$1, $3}); }
   | expr_op '/' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__div")), {$1, $3}); }
@@ -466,7 +466,7 @@ expr_simple
       $$ = new ExprConcatStrings(CUR_POS, false, $2);
   }
   | SPATH {
-      std::string path($1.p + 1, $1.l - 2);
+      string path($1.p + 1, $1.l - 2);
       $$ = new ExprCall(CUR_POS,
           new ExprVar(data->symbols.create("__findFile")),
           {new ExprVar(data->symbols.create("__nixPath")),
@@ -477,9 +477,9 @@ expr_simple
       if (noURLLiterals)
           throw ParseError({
               .msg = hintfmt("URL literals are disabled"),
-              .errPos = data->state.positions[CUR_POS]
+              .errPos = CUR_POS
           });
-      $$ = new ExprString(std::string($1));
+      $$ = new ExprString(string($1));
   }
   | '(' expr ')' { $$ = $2; }
   /* Let expressions `let {..., body = ...}' are just desugared
@@ -494,19 +494,19 @@ expr_simple
   ;
 
 string_parts
-  : STR { $$ = new ExprString(std::string($1)); }
+  : STR { $$ = new ExprString(string($1)); }
   | string_parts_interpolated { $$ = new ExprConcatStrings(CUR_POS, true, $1); }
   | { $$ = new ExprString(""); }
   ;
 
 string_parts_interpolated
   : string_parts_interpolated STR
-  { $$ = $1; $1->emplace_back(makeCurPos(@2, data), new ExprString(std::string($2))); }
+  { $$ = $1; $1->emplace_back(makeCurPos(@2, data), new ExprString(string($2))); }
   | string_parts_interpolated DOLLAR_CURLY expr '}' { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $3); }
-  | DOLLAR_CURLY expr '}' { $$ = new std::vector<std::pair<PosIdx, Expr *>>; $$->emplace_back(makeCurPos(@1, data), $2); }
+  | DOLLAR_CURLY expr '}' { $$ = new std::vector<std::pair<Pos, Expr *> >; $$->emplace_back(makeCurPos(@1, data), $2); }
   | STR DOLLAR_CURLY expr '}' {
-      $$ = new std::vector<std::pair<PosIdx, Expr *>>;
-      $$->emplace_back(makeCurPos(@1, data), new ExprString(std::string($1)));
+      $$ = new std::vector<std::pair<Pos, Expr *> >;
+      $$->emplace_back(makeCurPos(@1, data), new ExprString(string($1)));
       $$->emplace_back(makeCurPos(@2, data), $3);
     }
   ;
@@ -520,7 +520,7 @@ path_start
     $$ = new ExprPath(path);
   }
   | HPATH {
-    Path path(getHome() + std::string($1.p + 1, $1.l - 1));
+    Path path(getHome() + string($1.p + 1, $1.l - 1));
     $$ = new ExprPath(path);
   }
   ;
@@ -528,17 +528,17 @@ path_start
 ind_string_parts
   : ind_string_parts IND_STR { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $2); }
   | ind_string_parts DOLLAR_CURLY expr '}' { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $3); }
-  | { $$ = new std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>>; }
+  | { $$ = new std::vector<std::pair<Pos, std::variant<Expr *, StringToken> > >; }
   ;
 
 binds
-  : binds attrpath '=' expr ';' { $$ = $1; addAttr($$, *$2, $4, makeCurPos(@2, data), data->state); }
+  : binds attrpath '=' expr ';' { $$ = $1; addAttr($$, *$2, $4, makeCurPos(@2, data)); }
   | binds INHERIT attrs ';'
     { $$ = $1;
       for (auto & i : *$3) {
           if ($$->attrs.find(i.symbol) != $$->attrs.end())
-              dupAttr(data->state, i.symbol, makeCurPos(@3, data), $$->attrs[i.symbol].pos);
-          auto pos = makeCurPos(@3, data);
+              dupAttr(i.symbol, makeCurPos(@3, data), $$->attrs[i.symbol].pos);
+          Pos pos = makeCurPos(@3, data);
           $$->attrs.emplace(i.symbol, ExprAttrs::AttrDef(new ExprVar(CUR_POS, i.symbol), pos, true));
       }
     }
@@ -547,7 +547,7 @@ binds
       /* !!! Should ensure sharing of the expression in $4. */
       for (auto & i : *$6) {
           if ($$->attrs.find(i.symbol) != $$->attrs.end())
-              dupAttr(data->state, i.symbol, makeCurPos(@6, data), $$->attrs[i.symbol].pos);
+              dupAttr(i.symbol, makeCurPos(@6, data), $$->attrs[i.symbol].pos);
           $$->attrs.emplace(i.symbol, ExprAttrs::AttrDef(new ExprSelect(CUR_POS, $4, i.symbol), makeCurPos(@6, data)));
       }
     }
@@ -565,7 +565,7 @@ attrs
       } else
           throw ParseError({
               .msg = hintfmt("dynamic attributes not allowed in inherit"),
-              .errPos = data->state.positions[makeCurPos(@2, data)]
+              .errPos = makeCurPos(@2, data)
           });
     }
   | { $$ = new AttrPath; }
@@ -621,8 +621,8 @@ formals
   ;
 
 formal
-  : ID { $$ = new Formal{CUR_POS, data->symbols.create($1), 0}; }
-  | ID '?' expr { $$ = new Formal{CUR_POS, data->symbols.create($1), $3}; }
+  : ID { $$ = new Formal(CUR_POS, data->symbols.create($1), 0); }
+  | ID '?' expr { $$ = new Formal(CUR_POS, data->symbols.create($1), $3); }
   ;
 
 %%
@@ -643,22 +643,22 @@ namespace nix {
 
 
 Expr * EvalState::parse(char * text, size_t length, FileOrigin origin,
-    const PathView path, const PathView basePath, std::shared_ptr<StaticEnv> & staticEnv)
+    const PathView path, const PathView basePath, StaticEnv & staticEnv)
 {
     yyscan_t scanner;
-    std::string file;
+    ParseData data(*this);
+    data.origin = origin;
     switch (origin) {
         case foFile:
-            file = path;
+            data.file = data.symbols.create(path);
             break;
         case foStdin:
         case foString:
-            file = text;
+            data.file = data.symbols.create(text);
             break;
         default:
             assert(false);
     }
-    ParseData data(*this, {file, origin});
     data.basePath = basePath;
 
     yylex_init(&scanner);
@@ -668,7 +668,7 @@ Expr * EvalState::parse(char * text, size_t length, FileOrigin origin,
 
     if (res) throw ParseError(data.error.value());
 
-    data.result->bindVars(*this, staticEnv);
+    data.result->bindVars(staticEnv);
 
     return data.result;
 }
@@ -706,7 +706,7 @@ Expr * EvalState::parseExprFromFile(const Path & path)
 }
 
 
-Expr * EvalState::parseExprFromFile(const Path & path, std::shared_ptr<StaticEnv> & staticEnv)
+Expr * EvalState::parseExprFromFile(const Path & path, StaticEnv & staticEnv)
 {
     auto buffer = readFile(path);
     // readFile should have left some extra space for terminators
@@ -715,7 +715,7 @@ Expr * EvalState::parseExprFromFile(const Path & path, std::shared_ptr<StaticEnv
 }
 
 
-Expr * EvalState::parseExprFromString(std::string s, const Path & basePath, std::shared_ptr<StaticEnv> & staticEnv)
+Expr * EvalState::parseExprFromString(std::string s, const Path & basePath, StaticEnv & staticEnv)
 {
     s.append("\0\0", 2);
     return parse(s.data(), s.size(), foString, "", basePath, staticEnv);
@@ -738,16 +738,16 @@ Expr * EvalState::parseStdin()
 }
 
 
-void EvalState::addToSearchPath(const std::string & s)
+void EvalState::addToSearchPath(const string & s)
 {
     size_t pos = s.find('=');
-    std::string prefix;
+    string prefix;
     Path path;
-    if (pos == std::string::npos) {
+    if (pos == string::npos) {
         path = s;
     } else {
-        prefix = std::string(s, 0, pos);
-        path = std::string(s, pos + 1);
+        prefix = string(s, 0, pos);
+        path = string(s, pos + 1);
     }
 
     searchPath.emplace_back(prefix, path);
@@ -760,7 +760,7 @@ Path EvalState::findFile(const std::string_view path)
 }
 
 
-Path EvalState::findFile(SearchPath & searchPath, const std::string_view path, const PosIdx pos)
+Path EvalState::findFile(SearchPath & searchPath, const std::string_view path, const Pos & pos)
 {
     for (auto & i : searchPath) {
         std::string suffix;
@@ -782,13 +782,13 @@ Path EvalState::findFile(SearchPath & searchPath, const std::string_view path, c
     if (hasPrefix(path, "nix/"))
         return concatStrings(corepkgsPrefix, path.substr(4));
 
-    debugThrowLastTrace(ThrownError({
+    throw ThrownError({
         .msg = hintfmt(evalSettings.pureEval
             ? "cannot look up '<%s>' in pure evaluation mode (use '--impure' to override)"
             : "file '%s' was not found in the Nix search path (add it using $NIX_PATH or -I)",
             path),
-        .errPos = positions[pos]
-    }));
+        .errPos = pos
+    });
 }
 
 

src/libexpr/primops.hh

@@ -16,7 +16,6 @@ struct RegisterPrimOp
         size_t arity = 0;
         const char * doc;
         PrimOpFun fun;
-        std::optional<ExperimentalFeature> experimentalFeature;
     };
 
     typedef std::vector<Info> PrimOps;
@@ -36,11 +35,10 @@ struct RegisterPrimOp
 /* These primops are disabled without enableNativeCode, but plugins
    may wish to use them in limited contexts without globally enabling
    them. */
-
 /* Load a ValueInitializer from a DSO and return whatever it initializes */
-void prim_importNative(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+void prim_importNative(EvalState & state, const Pos & pos, Value * * args, Value & v);
 
 /* Execute a program and parse its output */
-void prim_exec(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+void prim_exec(EvalState & state, const Pos & pos, Value * * args, Value & v);
 
 }

src/libexpr/primops/context.cc

@@ -1,11 +1,10 @@
 #include "primops.hh"
 #include "eval-inline.hh"
-#include "derivations.hh"
 #include "store-api.hh"
 
 namespace nix {
 
-static void prim_unsafeDiscardStringContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_unsafeDiscardStringContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     PathSet context;
     auto s = state.coerceToString(pos, *args[0], context);
@@ -15,7 +14,7 @@ static void prim_unsafeDiscardStringContext(EvalState & state, const PosIdx pos,
 static RegisterPrimOp primop_unsafeDiscardStringContext("__unsafeDiscardStringContext", 1, prim_unsafeDiscardStringContext);
 
 
-static void prim_hasContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_hasContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     PathSet context;
     state.forceString(*args[0], context, pos);
@@ -31,14 +30,14 @@ static RegisterPrimOp primop_hasContext("__hasContext", 1, prim_hasContext);
    source-only deployment).  This primop marks the string context so
    that builtins.derivation adds the path to drv.inputSrcs rather than
    drv.inputDrvs. */
-static void prim_unsafeDiscardOutputDependency(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_unsafeDiscardOutputDependency(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     PathSet context;
     auto s = state.coerceToString(pos, *args[0], context);
 
     PathSet context2;
     for (auto & p : context)
-        context2.insert(p.at(0) == '=' ? std::string(p, 1) : p);
+        context2.insert(p.at(0) == '=' ? string(p, 1) : p);
 
     v.mkString(*s, context2);
 }
@@ -65,7 +64,7 @@ static RegisterPrimOp primop_unsafeDiscardOutputDependency("__unsafeDiscardOutpu
    Note that for a given path any combination of the above attributes
    may be present.
 */
-static void prim_getContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_getContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     struct ContextInfo {
         bool path = false;
@@ -77,14 +76,14 @@ static void prim_getContext(EvalState & state, const PosIdx pos, Value * * args,
     auto contextInfos = std::map<Path, ContextInfo>();
     for (const auto & p : context) {
         Path drv;
-        std::string output;
+        string output;
         const Path * path = &p;
         if (p.at(0) == '=') {
-            drv = std::string(p, 1);
+            drv = string(p, 1);
             path = &drv;
         } else if (p.at(0) == '!') {
-            NixStringContextElem ctx = decodeContext(*state.store, p);
-            drv = state.store->printStorePath(ctx.first);
+            std::pair<string, string> ctx = decodeContext(p);
+            drv = ctx.first;
             output = ctx.second;
             path = &drv;
         }
@@ -134,7 +133,7 @@ static RegisterPrimOp primop_getContext("__getContext", 1, prim_getContext);
    See the commentary above unsafeGetContext for details of the
    context representation.
 */
-static void prim_appendContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_appendContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     PathSet context;
     auto orig = state.forceString(*args[0], context, pos);
@@ -144,46 +143,45 @@ static void prim_appendContext(EvalState & state, const PosIdx pos, Value * * ar
     auto sPath = state.symbols.create("path");
     auto sAllOutputs = state.symbols.create("allOutputs");
     for (auto & i : *args[1]->attrs) {
-        const auto & name = state.symbols[i.name];
-        if (!state.store->isStorePath(name))
+        if (!state.store->isStorePath(i.name))
             throw EvalError({
-                .msg = hintfmt("Context key '%s' is not a store path", name),
-                .errPos = state.positions[i.pos]
+                .msg = hintfmt("Context key '%s' is not a store path", i.name),
+                .errPos = *i.pos
             });
         if (!settings.readOnlyMode)
-            state.store->ensurePath(state.store->parseStorePath(name));
-        state.forceAttrs(*i.value, i.pos);
+            state.store->ensurePath(state.store->parseStorePath(i.name));
+        state.forceAttrs(*i.value, *i.pos);
         auto iter = i.value->attrs->find(sPath);
         if (iter != i.value->attrs->end()) {
-            if (state.forceBool(*iter->value, iter->pos))
-                context.emplace(name);
+            if (state.forceBool(*iter->value, *iter->pos))
+                context.insert(i.name);
         }
 
         iter = i.value->attrs->find(sAllOutputs);
         if (iter != i.value->attrs->end()) {
-            if (state.forceBool(*iter->value, iter->pos)) {
-                if (!isDerivation(name)) {
+            if (state.forceBool(*iter->value, *iter->pos)) {
+                if (!isDerivation(i.name)) {
                     throw EvalError({
-                        .msg = hintfmt("Tried to add all-outputs context of %s, which is not a derivation, to a string", name),
-                        .errPos = state.positions[i.pos]
+                        .msg = hintfmt("Tried to add all-outputs context of %s, which is not a derivation, to a string", i.name),
+                        .errPos = *i.pos
                     });
                 }
-                context.insert(concatStrings("=", name));
+                context.insert("=" + string(i.name));
             }
         }
 
         iter = i.value->attrs->find(state.sOutputs);
         if (iter != i.value->attrs->end()) {
-            state.forceList(*iter->value, iter->pos);
-            if (iter->value->listSize() && !isDerivation(name)) {
+            state.forceList(*iter->value, *iter->pos);
+            if (iter->value->listSize() && !isDerivation(i.name)) {
                 throw EvalError({
-                    .msg = hintfmt("Tried to add derivation output context of %s, which is not a derivation, to a string", name),
-                    .errPos = state.positions[i.pos]
+                    .msg = hintfmt("Tried to add derivation output context of %s, which is not a derivation, to a string", i.name),
+                    .errPos = *i.pos
                 });
             }
             for (auto elem : iter->value->listItems()) {
-                auto outputName = state.forceStringNoCtx(*elem, iter->pos);
-                context.insert(concatStrings("!", outputName, "!", name));
+                auto name = state.forceStringNoCtx(*elem, *iter->pos);
+                context.insert(concatStrings("!", name, "!", i.name));
             }
         }
     }

src/libexpr/primops/fetchClosure.cc

@@ -1,163 +0,0 @@
-#include "primops.hh"
-#include "store-api.hh"
-#include "make-content-addressed.hh"
-#include "url.hh"
-
-namespace nix {
-
-static void prim_fetchClosure(EvalState & state, const PosIdx pos, Value * * args, Value & v)
-{
-    state.forceAttrs(*args[0], pos);
-
-    std::optional<std::string> fromStoreUrl;
-    std::optional<StorePath> fromPath;
-    bool toCA = false;
-    std::optional<StorePath> toPath;
-
-    for (auto & attr : *args[0]->attrs) {
-        const auto & attrName = state.symbols[attr.name];
-
-        if (attrName == "fromPath") {
-            PathSet context;
-            fromPath = state.coerceToStorePath(attr.pos, *attr.value, context);
-        }
-
-        else if (attrName == "toPath") {
-            state.forceValue(*attr.value, attr.pos);
-            toCA = true;
-            if (attr.value->type() != nString || attr.value->string.s != std::string("")) {
-                PathSet context;
-                toPath = state.coerceToStorePath(attr.pos, *attr.value, context);
-            }
-        }
-
-        else if (attrName == "fromStore")
-            fromStoreUrl = state.forceStringNoCtx(*attr.value, attr.pos);
-
-        else
-            throw Error({
-                .msg = hintfmt("attribute '%s' isn't supported in call to 'fetchClosure'", attrName),
-                .errPos = state.positions[pos]
-            });
-    }
-
-    if (!fromPath)
-        throw Error({
-            .msg = hintfmt("attribute '%s' is missing in call to 'fetchClosure'", "fromPath"),
-            .errPos = state.positions[pos]
-        });
-
-    if (!fromStoreUrl)
-        throw Error({
-            .msg = hintfmt("attribute '%s' is missing in call to 'fetchClosure'", "fromStore"),
-            .errPos = state.positions[pos]
-        });
-
-    auto parsedURL = parseURL(*fromStoreUrl);
-
-    if (parsedURL.scheme != "http" &&
-        parsedURL.scheme != "https" &&
-        !(getEnv("_NIX_IN_TEST").has_value() && parsedURL.scheme == "file"))
-        throw Error({
-            .msg = hintfmt("'fetchClosure' only supports http:// and https:// stores"),
-            .errPos = state.positions[pos]
-        });
-
-    if (!parsedURL.query.empty())
-        throw Error({
-            .msg = hintfmt("'fetchClosure' does not support URL query parameters (in '%s')", *fromStoreUrl),
-            .errPos = state.positions[pos]
-        });
-
-    auto fromStore = openStore(parsedURL.to_string());
-
-    if (toCA) {
-        if (!toPath || !state.store->isValidPath(*toPath)) {
-            auto remappings = makeContentAddressed(*fromStore, *state.store, { *fromPath });
-            auto i = remappings.find(*fromPath);
-            assert(i != remappings.end());
-            if (toPath && *toPath != i->second)
-                throw Error({
-                    .msg = hintfmt("rewriting '%s' to content-addressed form yielded '%s', while '%s' was expected",
-                        state.store->printStorePath(*fromPath),
-                        state.store->printStorePath(i->second),
-                        state.store->printStorePath(*toPath)),
-                    .errPos = state.positions[pos]
-                });
-            if (!toPath)
-                throw Error({
-                    .msg = hintfmt(
-                        "rewriting '%s' to content-addressed form yielded '%s'; "
-                        "please set this in the 'toPath' attribute passed to 'fetchClosure'",
-                        state.store->printStorePath(*fromPath),
-                        state.store->printStorePath(i->second)),
-                    .errPos = state.positions[pos]
-                });
-        }
-    } else {
-        if (!state.store->isValidPath(*fromPath))
-            copyClosure(*fromStore, *state.store, RealisedPath::Set { *fromPath });
-        toPath = fromPath;
-    }
-
-    /* In pure mode, require a CA path. */
-    if (evalSettings.pureEval) {
-        auto info = state.store->queryPathInfo(*toPath);
-        if (!info->isContentAddressed(*state.store))
-            throw Error({
-                .msg = hintfmt("in pure mode, 'fetchClosure' requires a content-addressed path, which '%s' isn't",
-                    state.store->printStorePath(*toPath)),
-                .errPos = state.positions[pos]
-            });
-    }
-
-    auto toPathS = state.store->printStorePath(*toPath);
-    v.mkString(toPathS, {toPathS});
-}
-
-static RegisterPrimOp primop_fetchClosure({
-    .name = "__fetchClosure",
-    .args = {"args"},
-    .doc = R"(
-      Fetch a Nix store closure from a binary cache, rewriting it into
-      content-addressed form. For example,
-
-      ```nix
-      builtins.fetchClosure {
-        fromStore = "https://cache.nixos.org";
-        fromPath = /nix/store/r2jd6ygnmirm2g803mksqqjm4y39yi6i-git-2.33.1;
-        toPath = /nix/store/ldbhlwhh39wha58rm61bkiiwm6j7211j-git-2.33.1;
-      }
-      ```
-
-      fetches `/nix/store/r2jd...` from the specified binary cache,
-      and rewrites it into the content-addressed store path
-      `/nix/store/ldbh...`.
-
-      If `fromPath` is already content-addressed, or if you are
-      allowing impure evaluation (`--impure`), then `toPath` may be
-      omitted.
-
-      To find out the correct value for `toPath` given a `fromPath`,
-      you can use `nix store make-content-addressed`:
-
-      ```console
-      # nix store make-content-addressed --from https://cache.nixos.org /nix/store/r2jd6ygnmirm2g803mksqqjm4y39yi6i-git-2.33.1
-      rewrote '/nix/store/r2jd6ygnmirm2g803mksqqjm4y39yi6i-git-2.33.1' to '/nix/store/ldbhlwhh39wha58rm61bkiiwm6j7211j-git-2.33.1'
-      ```
-
-      This function is similar to `builtins.storePath` in that it
-      allows you to use a previously built store path in a Nix
-      expression. However, it is more reproducible because it requires
-      specifying a binary cache from which the path can be fetched.
-      Also, requiring a content-addressed final store path avoids the
-      need for users to configure binary cache public keys.
-
-      This function is only available if you enable the experimental
-      feature `fetch-closure`.
-    )",
-    .fun = prim_fetchClosure,
-    .experimentalFeature = Xp::FetchClosure,
-});
-
-}

src/libexpr/primops/fetchMercurial.cc

@@ -7,7 +7,7 @@
 
 namespace nix {
 
-static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_fetchMercurial(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     std::string url;
     std::optional<Hash> rev;
@@ -22,31 +22,31 @@ static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value * * a
         state.forceAttrs(*args[0], pos);
 
         for (auto & attr : *args[0]->attrs) {
-            std::string_view n(state.symbols[attr.name]);
+            std::string_view n(attr.name);
             if (n == "url")
-                url = state.coerceToString(attr.pos, *attr.value, context, false, false).toOwned();
+                url = state.coerceToString(*attr.pos, *attr.value, context, false, false).toOwned();
             else if (n == "rev") {
                 // Ugly: unlike fetchGit, here the "rev" attribute can
                 // be both a revision or a branch/tag name.
-                auto value = state.forceStringNoCtx(*attr.value, attr.pos);
+                auto value = state.forceStringNoCtx(*attr.value, *attr.pos);
                 if (std::regex_match(value.begin(), value.end(), revRegex))
                     rev = Hash::parseAny(value, htSHA1);
                 else
                     ref = value;
             }
             else if (n == "name")
-                name = state.forceStringNoCtx(*attr.value, attr.pos);
+                name = state.forceStringNoCtx(*attr.value, *attr.pos);
             else
                 throw EvalError({
-                    .msg = hintfmt("unsupported argument '%s' to 'fetchMercurial'", state.symbols[attr.name]),
-                    .errPos = state.positions[attr.pos]
+                    .msg = hintfmt("unsupported argument '%s' to 'fetchMercurial'", attr.name),
+                    .errPos = *attr.pos
                 });
         }
 
         if (url.empty())
             throw EvalError({
                 .msg = hintfmt("'url' argument required"),
-                .errPos = state.positions[pos]
+                .errPos = pos
             });
 
     } else
@@ -62,7 +62,7 @@ static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value * * a
     fetchers::Attrs attrs;
     attrs.insert_or_assign("type", "hg");
     attrs.insert_or_assign("url", url.find("://") != std::string::npos ? url : "file://" + url);
-    attrs.insert_or_assign("name", std::string(name));
+    attrs.insert_or_assign("name", string(name));
     if (ref) attrs.insert_or_assign("ref", *ref);
     if (rev) attrs.insert_or_assign("rev", rev->gitRev());
     auto input = fetchers::Input::fromAttrs(std::move(attrs));

src/libexpr/primops/fetchTree.cc

@@ -19,7 +19,7 @@ void emitTreeAttrs(
     bool emptyRevFallback,
     bool forceDirty)
 {
-    assert(input.isLocked());
+    assert(input.isImmutable());
 
     auto attrs = state.buildBindings(8);
 
@@ -90,7 +90,7 @@ struct FetchTreeParams {
 
 static void fetchTree(
     EvalState & state,
-    const PosIdx pos,
+    const Pos & pos,
     Value * * args,
     Value & v,
     std::optional<std::string> type,
@@ -108,46 +108,46 @@ static void fetchTree(
 
         if (auto aType = args[0]->attrs->get(state.sType)) {
             if (type)
-                state.debugThrowLastTrace(EvalError({
+                throw Error({
                     .msg = hintfmt("unexpected attribute 'type'"),
-                    .errPos = state.positions[pos]
-                }));
-            type = state.forceStringNoCtx(*aType->value, aType->pos);
+                    .errPos = pos
+                });
+            type = state.forceStringNoCtx(*aType->value, *aType->pos);
         } else if (!type)
-            state.debugThrowLastTrace(EvalError({
+            throw Error({
                 .msg = hintfmt("attribute 'type' is missing in call to 'fetchTree'"),
-                .errPos = state.positions[pos]
-            }));
+                .errPos = pos
+            });
 
         attrs.emplace("type", type.value());
 
         for (auto & attr : *args[0]->attrs) {
             if (attr.name == state.sType) continue;
-            state.forceValue(*attr.value, attr.pos);
+            state.forceValue(*attr.value, *attr.pos);
             if (attr.value->type() == nPath || attr.value->type() == nString) {
-                auto s = state.coerceToString(attr.pos, *attr.value, context, false, false).toOwned();
-                attrs.emplace(state.symbols[attr.name],
-                    state.symbols[attr.name] == "url"
+                auto s = state.coerceToString(*attr.pos, *attr.value, context, false, false).toOwned();
+                attrs.emplace(attr.name,
+                    attr.name == "url"
                     ? type == "git"
                       ? fixURIForGit(s, state)
                       : fixURI(s, state)
                     : s);
             }
             else if (attr.value->type() == nBool)
-                attrs.emplace(state.symbols[attr.name], Explicit<bool>{attr.value->boolean});
+                attrs.emplace(attr.name, Explicit<bool>{attr.value->boolean});
             else if (attr.value->type() == nInt)
-                attrs.emplace(state.symbols[attr.name], uint64_t(attr.value->integer));
+                attrs.emplace(attr.name, uint64_t(attr.value->integer));
             else
-                state.debugThrowLastTrace(TypeError("fetchTree argument '%s' is %s while a string, Boolean or integer is expected",
-                    state.symbols[attr.name], showType(*attr.value)));
+                throw TypeError("fetchTree argument '%s' is %s while a string, Boolean or integer is expected",
+                    attr.name, showType(*attr.value));
         }
 
         if (!params.allowNameArgument)
             if (auto nameIter = attrs.find("name"); nameIter != attrs.end())
-                state.debugThrowLastTrace(EvalError({
+                throw Error({
                     .msg = hintfmt("attribute 'name' isn’t supported in call to 'fetchTree'"),
-                    .errPos = state.positions[pos]
-                }));
+                    .errPos = pos
+                });
 
         input = fetchers::Input::fromAttrs(std::move(attrs));
     } else {
@@ -166,8 +166,8 @@ static void fetchTree(
     if (!evalSettings.pureEval && !input.isDirect())
         input = lookupInRegistries(state.store, input).first;
 
-    if (evalSettings.pureEval && !input.isLocked())
-        state.debugThrowLastTrace(EvalError("in pure evaluation mode, 'fetchTree' requires a locked input, at %s", state.positions[pos]));
+    if (evalSettings.pureEval && !input.isImmutable())
+        throw Error("in pure evaluation mode, 'fetchTree' requires an immutable input, at %s", pos);
 
     auto [tree, input2] = input.fetch(state.store);
 
@@ -176,7 +176,7 @@ static void fetchTree(
     emitTreeAttrs(state, tree, input2, v, params.emptyRevFallback, false);
 }
 
-static void prim_fetchTree(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_fetchTree(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     settings.requireExperimentalFeature(Xp::Flakes);
     fetchTree(state, pos, args, v, std::nullopt, FetchTreeParams { .allowNameArgument = false });
@@ -185,8 +185,8 @@ static void prim_fetchTree(EvalState & state, const PosIdx pos, Value * * args,
 // FIXME: document
 static RegisterPrimOp primop_fetchTree("fetchTree", 1, prim_fetchTree);
 
-static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v,
-    const std::string & who, bool unpack, std::string name)
+static void fetch(EvalState & state, const Pos & pos, Value * * args, Value & v,
+    const string & who, bool unpack, std::string name)
 {
     std::optional<std::string> url;
     std::optional<Hash> expectedHash;
@@ -198,25 +198,25 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
         state.forceAttrs(*args[0], pos);
 
         for (auto & attr : *args[0]->attrs) {
-            std::string_view n(state.symbols[attr.name]);
+            string n(attr.name);
             if (n == "url")
-                url = state.forceStringNoCtx(*attr.value, attr.pos);
+                url = state.forceStringNoCtx(*attr.value, *attr.pos);
             else if (n == "sha256")
-                expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos), htSHA256);
+                expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA256);
             else if (n == "name")
-                name = state.forceStringNoCtx(*attr.value, attr.pos);
+                name = state.forceStringNoCtx(*attr.value, *attr.pos);
             else
-                state.debugThrowLastTrace(EvalError({
-                    .msg = hintfmt("unsupported argument '%s' to '%s'", n, who),
-                    .errPos = state.positions[attr.pos]
-                }));
-        }
+                throw EvalError({
+                    .msg = hintfmt("unsupported argument '%s' to '%s'", attr.name, who),
+                    .errPos = *attr.pos
+                });
+            }
 
         if (!url)
-            state.debugThrowLastTrace(EvalError({
+            throw EvalError({
                 .msg = hintfmt("'url' argument required"),
-                .errPos = state.positions[pos]
-            }));
+                .errPos = pos
+            });
     } else
         url = state.forceStringNoCtx(*args[0], pos);
 
@@ -228,23 +228,8 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
         name = baseNameOf(*url);
 
     if (evalSettings.pureEval && !expectedHash)
-        state.debugThrowLastTrace(EvalError("in pure evaluation mode, '%s' requires a 'sha256' argument", who));
+        throw Error("in pure evaluation mode, '%s' requires a 'sha256' argument", who);
 
-    // early exit if pinned and already in the store
-    if (expectedHash && expectedHash->type == htSHA256) {
-        auto expectedPath =
-            unpack
-            ? state.store->makeFixedOutputPath(FileIngestionMethod::Recursive, *expectedHash, name, {})
-            : state.store->makeFixedOutputPath(FileIngestionMethod::Flat, *expectedHash, name, {});
-
-        if (state.store->isValidPath(expectedPath)) {
-            state.allowAndSetStorePathString(expectedPath, v);
-            return;
-        }
-    }
-
-    // TODO: fetching may fail, yet the path may be substitutable.
-    //       https://github.com/NixOS/nix/issues/4313
     auto storePath =
         unpack
         ? fetchers::downloadTarball(state.store, *url, name, (bool) expectedHash).first.storePath
@@ -255,14 +240,17 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
             ? state.store->queryPathInfo(storePath)->narHash
             : hashFile(htSHA256, state.store->toRealPath(storePath));
         if (hash != *expectedHash)
-            state.debugThrowLastTrace(EvalError((unsigned int) 102, "hash mismatch in file downloaded from '%s':\n  specified: %s\n  got:       %s",
-                *url, expectedHash->to_string(Base32, true), hash.to_string(Base32, true)));
+            throw Error((unsigned int) 102, "hash mismatch in file downloaded from '%s':\n  specified: %s\n  got:       %s",
+                *url, expectedHash->to_string(Base32, true), hash.to_string(Base32, true));
     }
 
-    state.allowAndSetStorePathString(storePath, v);
+    state.allowPath(storePath);
+
+    auto path = state.store->printStorePath(storePath);
+    v.mkString(path, PathSet({path}));
 }
 
-static void prim_fetchurl(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_fetchurl(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     fetch(state, pos, args, v, "fetchurl", false, "");
 }
@@ -278,7 +266,7 @@ static RegisterPrimOp primop_fetchurl({
     .fun = prim_fetchurl,
 });
 
-static void prim_fetchTarball(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_fetchTarball(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     fetch(state, pos, args, v, "fetchTarball", true, "source");
 }
@@ -329,7 +317,7 @@ static RegisterPrimOp primop_fetchTarball({
     .fun = prim_fetchTarball,
 });
 
-static void prim_fetchGit(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+static void prim_fetchGit(EvalState &state, const Pos &pos, Value **args, Value &v)
 {
     fetchTree(state, pos, args, v, "git", FetchTreeParams { .emptyRevFallback = true, .allowNameArgument = true });
 }

src/libexpr/primops/fromTOML.cc

@@ -5,11 +5,11 @@
 
 namespace nix {
 
-static void prim_fromTOML(EvalState & state, const PosIdx pos, Value * * args, Value & val)
+static void prim_fromTOML(EvalState & state, const Pos & pos, Value * * args, Value & val)
 {
     auto toml = state.forceStringNoCtx(*args[0], pos);
 
-    std::istringstream tomlStream(std::string{toml});
+    std::istringstream tomlStream(string{toml});
 
     std::function<void(Value &, toml::value)> visit;
 
@@ -73,7 +73,7 @@ static void prim_fromTOML(EvalState & state, const PosIdx pos, Value * * args, V
     } catch (std::exception & e) { // TODO: toml::syntax_error
         throw EvalError({
             .msg = hintfmt("while parsing a TOML string: %s", e.what()),
-            .errPos = state.positions[pos]
+            .errPos = pos
         });
     }
 }

src/libexpr/symbol-table.hh

@@ -5,32 +5,44 @@
 #include <unordered_map>
 
 #include "types.hh"
-#include "chunked-vector.hh"
 
 namespace nix {
 
 /* Symbol table used by the parser and evaluator to represent and look
    up identifiers and attributes efficiently.  SymbolTable::create()
    converts a string into a symbol.  Symbols have the property that
-   they can be compared efficiently (using an equality test),
+   they can be compared efficiently (using a pointer equality test),
    because the symbol table stores only one copy of each string. */
 
-/* This class mainly exists to give us an operator<< for ostreams. We could also
-   return plain strings from SymbolTable, but then we'd have to wrap every
-   instance of a symbol that is fmt()ed, which is inconvenient and error-prone. */
-class SymbolStr
+class Symbol
 {
+private:
+    const std::string * s; // pointer into SymbolTable
+    Symbol(const std::string * s) : s(s) { };
     friend class SymbolTable;
 
-private:
-    const std::string * s;
-
-    explicit SymbolStr(const std::string & symbol): s(&symbol) {}
-
 public:
+    Symbol() : s(0) { };
+
+    bool operator == (const Symbol & s2) const
+    {
+        return s == s2.s;
+    }
+
+    // FIXME: remove
     bool operator == (std::string_view s2) const
     {
-        return *s == s2;
+        return s->compare(s2) == 0;
+    }
+
+    bool operator != (const Symbol & s2) const
+    {
+        return s != s2.s;
+    }
+
+    bool operator < (const Symbol & s2) const
+    {
+        return s < s2.s;
     }
 
     operator const std::string & () const
@@ -43,78 +55,51 @@ public:
         return *s;
     }
 
-    friend std::ostream & operator <<(std::ostream & os, const SymbolStr & symbol);
-};
+    bool set() const
+    {
+        return s;
+    }
 
-class Symbol
-{
-    friend class SymbolTable;
+    bool empty() const
+    {
+        return s->empty();
+    }
 
-private:
-    uint32_t id;
-
-    explicit Symbol(uint32_t id): id(id) {}
-
-public:
-    Symbol() : id(0) {}
-
-    explicit operator bool() const { return id > 0; }
-
-    bool operator<(const Symbol other) const { return id < other.id; }
-    bool operator==(const Symbol other) const { return id == other.id; }
-    bool operator!=(const Symbol other) const { return id != other.id; }
+    friend std::ostream & operator << (std::ostream & str, const Symbol & sym);
 };
 
 class SymbolTable
 {
 private:
-    std::unordered_map<std::string_view, std::pair<const std::string *, uint32_t>> symbols;
-    ChunkedVector<std::string, 8192> store{16};
+    std::unordered_map<std::string_view, Symbol> symbols;
+    std::list<std::string> store;
 
 public:
-
     Symbol create(std::string_view s)
     {
         // Most symbols are looked up more than once, so we trade off insertion performance
         // for lookup performance.
         // TODO: could probably be done more efficiently with transparent Hash and Equals
         // on the original implementation using unordered_set
-        // FIXME: make this thread-safe.
         auto it = symbols.find(s);
-        if (it != symbols.end()) return Symbol(it->second.second + 1);
+        if (it != symbols.end()) return it->second;
 
-        const auto & [rawSym, idx] = store.add(std::string(s));
-        symbols.emplace(rawSym, std::make_pair(&rawSym, idx));
-        return Symbol(idx + 1);
-    }
-
-    std::vector<SymbolStr> resolve(const std::vector<Symbol> & symbols) const
-    {
-        std::vector<SymbolStr> result;
-        result.reserve(symbols.size());
-        for (auto sym : symbols)
-            result.push_back((*this)[sym]);
-        return result;
-    }
-
-    SymbolStr operator[](Symbol s) const
-    {
-        if (s.id == 0 || s.id > store.size())
-            abort();
-        return SymbolStr(store[s.id - 1]);
+        auto & rawSym = store.emplace_back(s);
+        return symbols.emplace(rawSym, Symbol(&rawSym)).first->second;
     }
 
     size_t size() const
     {
-        return store.size();
+        return symbols.size();
     }
 
     size_t totalSize() const;
 
     template<typename T>
-    void dump(T callback) const
+    void dump(T callback)
     {
-        store.forEach(callback);
+        for (auto & s : store)
+            callback(s);
     }
 };
 

src/libexpr/tests/json.cc

@@ -1,68 +0,0 @@
-#include "libexprtests.hh"
-#include "value-to-json.hh"
-
-namespace nix {
-// Testing the conversion to JSON
-
-    class JSONValueTest : public LibExprTest {
-        protected:
-            std::string getJSONValue(Value& value) {
-                std::stringstream ss;
-                PathSet ps;
-                printValueAsJSON(state, true, value, noPos, ss, ps);
-                return ss.str();
-            }
-    };
-
-    TEST_F(JSONValueTest, null) {
-        Value v;
-        v.mkNull();
-        ASSERT_EQ(getJSONValue(v), "null");
-    }
-
-    TEST_F(JSONValueTest, BoolFalse) {
-        Value v;
-        v.mkBool(false);
-        ASSERT_EQ(getJSONValue(v),"false");
-    }
-
-    TEST_F(JSONValueTest, BoolTrue) {
-        Value v;
-        v.mkBool(true);
-        ASSERT_EQ(getJSONValue(v), "true");
-    }
-
-    TEST_F(JSONValueTest, IntPositive) {
-        Value v;
-        v.mkInt(100);
-        ASSERT_EQ(getJSONValue(v), "100");
-    }
-
-    TEST_F(JSONValueTest, IntNegative) {
-        Value v;
-        v.mkInt(-100);
-        ASSERT_EQ(getJSONValue(v), "-100");
-    }
-
-    TEST_F(JSONValueTest, String) {
-        Value v;
-        v.mkString("test");
-        ASSERT_EQ(getJSONValue(v), "\"test\"");
-    }
-
-    TEST_F(JSONValueTest, StringQuotes) {
-        Value v;
-
-        v.mkString("test\"");
-        ASSERT_EQ(getJSONValue(v), "\"test\\\"\"");
-    }
-
-    // The dummy store doesn't support writing files. Fails with this exception message:
-    // C++ exception with description "error: operation 'addToStoreFromDump' is
-    // not supported by store 'dummy'" thrown in the test body.
-    TEST_F(JSONValueTest, DISABLED_Path) {
-        Value v;
-        v.mkPath("test");
-        ASSERT_EQ(getJSONValue(v), "\"/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-x\"");
-    }
-} /* namespace nix */

src/libexpr/tests/libexprtests.hh

@@ -1,136 +0,0 @@
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-#include "value.hh"
-#include "nixexpr.hh"
-#include "eval.hh"
-#include "eval-inline.hh"
-#include "store-api.hh"
-
-
-namespace nix {
-    class LibExprTest : public ::testing::Test {
-        public:
-            static void SetUpTestSuite() {
-                initGC();
-            }
-
-        protected:
-            LibExprTest()
-                : store(openStore("dummy://"))
-                , state({}, store)
-            {
-            }
-            Value eval(std::string input, bool forceValue = true) {
-                Value v;
-                Expr * e = state.parseExprFromString(input, "");
-                assert(e);
-                state.eval(e, v);
-                if (forceValue)
-                    state.forceValue(v, noPos);
-                return v;
-            }
-
-            Symbol createSymbol(const char * value) {
-                return state.symbols.create(value);
-            }
-
-            ref<Store> store;
-            EvalState state;
-    };
-
-    MATCHER(IsListType, "") {
-        return arg != nList;
-    }
-
-    MATCHER(IsList, "") {
-        return arg.type() == nList;
-    }
-
-    MATCHER(IsString, "") {
-        return arg.type() == nString;
-    }
-
-    MATCHER(IsNull, "") {
-        return arg.type() == nNull;
-    }
-
-    MATCHER(IsThunk, "") {
-        return arg.type() == nThunk;
-    }
-
-    MATCHER(IsAttrs, "") {
-        return arg.type() == nAttrs;
-    }
-
-    MATCHER_P(IsStringEq, s, fmt("The string is equal to \"%1%\"", s)) {
-        if (arg.type() != nString) {
-            return false;
-        }
-        return std::string_view(arg.string.s) == s;
-    }
-
-    MATCHER_P(IsIntEq, v, fmt("The string is equal to \"%1%\"", v)) {
-        if (arg.type() != nInt) {
-            return false;
-        }
-        return arg.integer == v;
-    }
-
-    MATCHER_P(IsFloatEq, v, fmt("The float is equal to \"%1%\"", v)) {
-        if (arg.type() != nFloat) {
-            return false;
-        }
-        return arg.fpoint == v;
-    }
-
-    MATCHER(IsTrue, "") {
-        if (arg.type() != nBool) {
-            return false;
-        }
-        return arg.boolean == true;
-    }
-
-    MATCHER(IsFalse, "") {
-        if (arg.type() != nBool) {
-            return false;
-        }
-        return arg.boolean == false;
-    }
-
-    MATCHER_P(IsPathEq, p, fmt("Is a path equal to \"%1%\"", p)) {
-            if (arg.type() != nPath) {
-                *result_listener << "Expected a path got " << arg.type();
-                return false;
-            } else if (std::string_view(arg.string.s) != p) {
-                *result_listener << "Expected a path that equals \"" << p << "\" but got: " << arg.string.s;
-                return false;
-            }
-            return true;
-    }
-
-
-    MATCHER_P(IsListOfSize, n, fmt("Is a list of size [%1%]", n)) {
-        if (arg.type() != nList) {
-            *result_listener << "Expected list got " << arg.type();
-            return false;
-        } else if (arg.listSize() != (size_t)n) {
-            *result_listener << "Expected as list of size " << n << " got " << arg.listSize();
-            return false;
-        }
-        return true;
-    }
-
-    MATCHER_P(IsAttrsOfSize, n, fmt("Is a set of size [%1%]", n)) {
-        if (arg.type() != nAttrs) {
-            *result_listener << "Expexted set got " << arg.type();
-            return false;
-        } else if (arg.attrs->size() != (size_t)n) {
-            *result_listener << "Expected a set with " << n << " attributes but got " << arg.attrs->size();
-            return false;
-        }
-        return true;
-    }
-
-
-} /* namespace nix */

src/libexpr/tests/local.mk

@@ -1,15 +0,0 @@
-check: libexpr-tests_RUN
-
-programs += libexpr-tests
-
-libexpr-tests_DIR := $(d)
-
-libexpr-tests_INSTALL_DIR :=
-
-libexpr-tests_SOURCES := $(wildcard $(d)/*.cc)
-
-libexpr-tests_CXXFLAGS += -I src/libexpr -I src/libutil -I src/libstore -I src/libexpr/tests
-
-libexpr-tests_LIBS = libexpr libutil libstore libfetchers
-
-libexpr-tests_LDFLAGS := $(GTEST_LIBS) -lgmock

src/libexpr/tests/primops.cc

@@ -1,839 +0,0 @@
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include "libexprtests.hh"
-
-namespace nix {
-    class CaptureLogger : public Logger
-    {
-        std::ostringstream oss;
-
-        public:
-            CaptureLogger() {}
-
-            std::string get() const {
-                return oss.str();
-            }
-
-            void log(Verbosity lvl, const FormatOrString & fs) override {
-                oss << fs.s << std::endl;
-            }
-
-            void logEI(const ErrorInfo & ei) override {
-                showErrorInfo(oss, ei, loggerSettings.showTrace.get());
-            }
-    };
-
-    class CaptureLogging {
-        Logger * oldLogger;
-        std::unique_ptr<CaptureLogger> tempLogger;
-        public:
-            CaptureLogging() : tempLogger(std::make_unique<CaptureLogger>()) {
-                oldLogger = logger;
-                logger = tempLogger.get();
-            }
-
-            ~CaptureLogging() {
-                logger = oldLogger;
-            }
-
-            std::string get() const {
-                return tempLogger->get();
-            }
-    };
-
-
-    // Testing eval of PrimOp's
-    class PrimOpTest : public LibExprTest {};
-
-
-    TEST_F(PrimOpTest, throw) {
-        ASSERT_THROW(eval("throw \"foo\""), ThrownError);
-    }
-
-    TEST_F(PrimOpTest, abort) {
-        ASSERT_THROW(eval("abort \"abort\""), Abort);
-    }
-
-    TEST_F(PrimOpTest, ceil) {
-        auto v = eval("builtins.ceil 1.9");
-        ASSERT_THAT(v, IsIntEq(2));
-    }
-
-    TEST_F(PrimOpTest, floor) {
-        auto v = eval("builtins.floor 1.9");
-        ASSERT_THAT(v, IsIntEq(1));
-    }
-
-    TEST_F(PrimOpTest, tryEvalFailure) {
-        auto v = eval("builtins.tryEval (throw \"\")");
-        ASSERT_THAT(v, IsAttrsOfSize(2));
-        auto s = createSymbol("success");
-        auto p = v.attrs->get(s);
-        ASSERT_NE(p, nullptr);
-        ASSERT_THAT(*p->value, IsFalse());
-    }
-
-    TEST_F(PrimOpTest, tryEvalSuccess) {
-        auto v = eval("builtins.tryEval 123");
-        ASSERT_THAT(v, IsAttrs());
-        auto s = createSymbol("success");
-        auto p = v.attrs->get(s);
-        ASSERT_NE(p, nullptr);
-        ASSERT_THAT(*p->value, IsTrue());
-        s = createSymbol("value");
-        p = v.attrs->get(s);
-        ASSERT_NE(p, nullptr);
-        ASSERT_THAT(*p->value, IsIntEq(123));
-    }
-
-    TEST_F(PrimOpTest, getEnv) {
-        setenv("_NIX_UNIT_TEST_ENV_VALUE", "test value", 1);
-        auto v = eval("builtins.getEnv \"_NIX_UNIT_TEST_ENV_VALUE\"");
-        ASSERT_THAT(v, IsStringEq("test value"));
-    }
-
-    TEST_F(PrimOpTest, seq) {
-        ASSERT_THROW(eval("let x = throw \"test\"; in builtins.seq x { }"), ThrownError);
-    }
-
-    TEST_F(PrimOpTest, seqNotDeep) {
-        auto v = eval("let x = { z =  throw \"test\"; }; in builtins.seq x { }");
-        ASSERT_THAT(v, IsAttrs());
-    }
-
-    TEST_F(PrimOpTest, deepSeq) {
-        ASSERT_THROW(eval("let x = { z =  throw \"test\"; }; in builtins.deepSeq x { }"), ThrownError);
-    }
-
-    TEST_F(PrimOpTest, trace) {
-        CaptureLogging l;
-        auto v = eval("builtins.trace \"test string 123\" 123");
-        ASSERT_THAT(v, IsIntEq(123));
-        auto text = l.get();
-        ASSERT_NE(text.find("test string 123"), std::string::npos);
-    }
-
-    TEST_F(PrimOpTest, placeholder) {
-        auto v = eval("builtins.placeholder \"out\"");
-        ASSERT_THAT(v, IsStringEq("/1rz4g4znpzjwh1xymhjpm42vipw92pr73vdgl6xs1hycac8kf2n9"));
-    }
-
-    TEST_F(PrimOpTest, baseNameOf) {
-        auto v = eval("builtins.baseNameOf /some/path");
-        ASSERT_THAT(v, IsStringEq("path"));
-    }
-
-    TEST_F(PrimOpTest, dirOf) {
-        auto v = eval("builtins.dirOf /some/path");
-        ASSERT_THAT(v, IsPathEq("/some"));
-    }
-
-    TEST_F(PrimOpTest, attrValues) {
-        auto v = eval("builtins.attrValues { x = \"foo\";  a = 1; }");
-        ASSERT_THAT(v, IsListOfSize(2));
-        ASSERT_THAT(*v.listElems()[0], IsIntEq(1));
-        ASSERT_THAT(*v.listElems()[1], IsStringEq("foo"));
-    }
-
-    TEST_F(PrimOpTest, getAttr) {
-        auto v = eval("builtins.getAttr \"x\" { x = \"foo\"; }");
-        ASSERT_THAT(v, IsStringEq("foo"));
-    }
-
-    TEST_F(PrimOpTest, getAttrNotFound) {
-        // FIXME: TypeError is really bad here, also the error wording is worse
-        // than on Nix <=2.3
-        ASSERT_THROW(eval("builtins.getAttr \"y\" { }"), TypeError);
-    }
-
-    TEST_F(PrimOpTest, unsafeGetAttrPos) {
-        // The `y` attribute is at position
-        const char* expr = "builtins.unsafeGetAttrPos \"y\" { y = \"x\"; }";
-        auto v = eval(expr);
-        ASSERT_THAT(v, IsAttrsOfSize(3));
-
-        auto file = v.attrs->find(createSymbol("file"));
-        ASSERT_NE(file, nullptr);
-        // FIXME: The file when running these tests is the input string?!?
-        ASSERT_THAT(*file->value, IsStringEq(expr));
-
-        auto line = v.attrs->find(createSymbol("line"));
-        ASSERT_NE(line, nullptr);
-        ASSERT_THAT(*line->value, IsIntEq(1));
-
-        auto column = v.attrs->find(createSymbol("column"));
-        ASSERT_NE(column, nullptr);
-        ASSERT_THAT(*column->value, IsIntEq(33));
-    }
-
-    TEST_F(PrimOpTest, hasAttr) {
-        auto v = eval("builtins.hasAttr \"x\" { x = 1; }");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(PrimOpTest, hasAttrNotFound) {
-        auto v = eval("builtins.hasAttr \"x\" { }");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(PrimOpTest, isAttrs) {
-        auto v = eval("builtins.isAttrs {}");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(PrimOpTest, isAttrsFalse) {
-        auto v = eval("builtins.isAttrs null");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(PrimOpTest, removeAttrs) {
-        auto v = eval("builtins.removeAttrs { x = 1; } [\"x\"]");
-        ASSERT_THAT(v, IsAttrsOfSize(0));
-    }
-
-    TEST_F(PrimOpTest, removeAttrsRetains) {
-        auto v = eval("builtins.removeAttrs { x = 1; y = 2; } [\"x\"]");
-        ASSERT_THAT(v, IsAttrsOfSize(1));
-        ASSERT_NE(v.attrs->find(createSymbol("y")), nullptr);
-    }
-
-    TEST_F(PrimOpTest, listToAttrsEmptyList) {
-        auto v = eval("builtins.listToAttrs []");
-        ASSERT_THAT(v, IsAttrsOfSize(0));
-        ASSERT_EQ(v.type(), nAttrs);
-        ASSERT_EQ(v.attrs->size(), 0);
-    }
-
-    TEST_F(PrimOpTest, listToAttrsNotFieldName) {
-        ASSERT_THROW(eval("builtins.listToAttrs [{}]"), Error);
-    }
-
-    TEST_F(PrimOpTest, listToAttrs) {
-        auto v = eval("builtins.listToAttrs [ { name = \"key\"; value = 123; } ]");
-        ASSERT_THAT(v, IsAttrsOfSize(1));
-        auto key = v.attrs->find(createSymbol("key"));
-        ASSERT_NE(key, nullptr);
-        ASSERT_THAT(*key->value, IsIntEq(123));
-    }
-
-    TEST_F(PrimOpTest, intersectAttrs) {
-        auto v = eval("builtins.intersectAttrs { a = 1; b = 2; } { b = 3; c = 4; }");
-        ASSERT_THAT(v, IsAttrsOfSize(1));
-        auto b = v.attrs->find(createSymbol("b"));
-        ASSERT_NE(b, nullptr);
-        ASSERT_THAT(*b->value, IsIntEq(3));
-    }
-
-    TEST_F(PrimOpTest, catAttrs) {
-        auto v = eval("builtins.catAttrs \"a\" [{a = 1;} {b = 0;} {a = 2;}]");
-        ASSERT_THAT(v, IsListOfSize(2));
-        ASSERT_THAT(*v.listElems()[0], IsIntEq(1));
-        ASSERT_THAT(*v.listElems()[1], IsIntEq(2));
-    }
-
-    TEST_F(PrimOpTest, functionArgs) {
-        auto v = eval("builtins.functionArgs ({ x, y ? 123}: 1)");
-        ASSERT_THAT(v, IsAttrsOfSize(2));
-
-        auto x = v.attrs->find(createSymbol("x"));
-        ASSERT_NE(x, nullptr);
-        ASSERT_THAT(*x->value, IsFalse());
-
-        auto y = v.attrs->find(createSymbol("y"));
-        ASSERT_NE(y, nullptr);
-        ASSERT_THAT(*y->value, IsTrue());
-    }
-
-    TEST_F(PrimOpTest, mapAttrs) {
-        auto v = eval("builtins.mapAttrs (name: value: value * 10) { a = 1; b = 2; }");
-        ASSERT_THAT(v, IsAttrsOfSize(2));
-
-        auto a = v.attrs->find(createSymbol("a"));
-        ASSERT_NE(a, nullptr);
-        ASSERT_THAT(*a->value, IsThunk());
-        state.forceValue(*a->value, noPos);
-        ASSERT_THAT(*a->value, IsIntEq(10));
-
-        auto b = v.attrs->find(createSymbol("b"));
-        ASSERT_NE(b, nullptr);
-        ASSERT_THAT(*b->value, IsThunk());
-        state.forceValue(*b->value, noPos);
-        ASSERT_THAT(*b->value, IsIntEq(20));
-    }
-
-    TEST_F(PrimOpTest, isList) {
-        auto v = eval("builtins.isList []");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(PrimOpTest, isListFalse) {
-        auto v = eval("builtins.isList null");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(PrimOpTest, elemtAt) {
-        auto v = eval("builtins.elemAt [0 1 2 3] 3");
-        ASSERT_THAT(v, IsIntEq(3));
-    }
-
-    TEST_F(PrimOpTest, elemtAtOutOfBounds) {
-        ASSERT_THROW(eval("builtins.elemAt [0 1 2 3] 5"), Error);
-    }
-
-    TEST_F(PrimOpTest, head) {
-        auto v = eval("builtins.head [ 3 2 1 0 ]");
-        ASSERT_THAT(v, IsIntEq(3));
-    }
-
-    TEST_F(PrimOpTest, headEmpty) {
-        ASSERT_THROW(eval("builtins.head [ ]"), Error);
-    }
-
-    TEST_F(PrimOpTest, headWrongType) {
-        ASSERT_THROW(eval("builtins.head { }"), Error);
-    }
-
-    TEST_F(PrimOpTest, tail) {
-        auto v = eval("builtins.tail [ 3 2 1 0 ]");
-        ASSERT_THAT(v, IsListOfSize(3));
-        for (const auto [n, elem] : enumerate(v.listItems()))
-            ASSERT_THAT(*elem, IsIntEq(2 - static_cast<int>(n)));
-    }
-
-    TEST_F(PrimOpTest, tailEmpty) {
-        ASSERT_THROW(eval("builtins.tail []"), Error);
-    }
-
-    TEST_F(PrimOpTest, map) {
-        auto v = eval("map (x: \"foo\" + x) [ \"bar\" \"bla\" \"abc\" ]");
-        ASSERT_THAT(v, IsListOfSize(3));
-        auto elem = v.listElems()[0];
-        ASSERT_THAT(*elem, IsThunk());
-        state.forceValue(*elem, noPos);
-        ASSERT_THAT(*elem, IsStringEq("foobar"));
-
-        elem = v.listElems()[1];
-        ASSERT_THAT(*elem, IsThunk());
-        state.forceValue(*elem, noPos);
-        ASSERT_THAT(*elem, IsStringEq("foobla"));
-
-        elem = v.listElems()[2];
-        ASSERT_THAT(*elem, IsThunk());
-        state.forceValue(*elem, noPos);
-        ASSERT_THAT(*elem, IsStringEq("fooabc"));
-    }
-
-    TEST_F(PrimOpTest, filter) {
-        auto v = eval("builtins.filter (x: x == 2) [ 3 2 3 2 3 2 ]");
-        ASSERT_THAT(v, IsListOfSize(3));
-        for (const auto elem : v.listItems())
-            ASSERT_THAT(*elem, IsIntEq(2));
-    }
-
-    TEST_F(PrimOpTest, elemTrue) {
-        auto v = eval("builtins.elem 3 [ 1 2 3 4 5 ]");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(PrimOpTest, elemFalse) {
-        auto v = eval("builtins.elem 6 [ 1 2 3 4 5 ]");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(PrimOpTest, concatLists) {
-        auto v = eval("builtins.concatLists [[1 2] [3 4]]");
-        ASSERT_THAT(v, IsListOfSize(4));
-        for (const auto [i, elem] : enumerate(v.listItems()))
-            ASSERT_THAT(*elem, IsIntEq(static_cast<int>(i)+1));
-    }
-
-    TEST_F(PrimOpTest, length) {
-        auto v = eval("builtins.length [ 1 2 3 ]");
-        ASSERT_THAT(v, IsIntEq(3));
-    }
-
-    TEST_F(PrimOpTest, foldStrict) {
-        auto v = eval("builtins.foldl' (a: b: a + b) 0 [1 2 3]");
-        ASSERT_THAT(v, IsIntEq(6));
-    }
-
-    TEST_F(PrimOpTest, anyTrue) {
-        auto v = eval("builtins.any (x: x == 2) [ 1 2 3 ]");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(PrimOpTest, anyFalse) {
-        auto v = eval("builtins.any (x: x == 5) [ 1 2 3 ]");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(PrimOpTest, allTrue) {
-        auto v = eval("builtins.all (x: x > 0) [ 1 2 3 ]");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(PrimOpTest, allFalse) {
-        auto v = eval("builtins.all (x: x <= 0) [ 1 2 3 ]");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(PrimOpTest, genList) {
-        auto v = eval("builtins.genList (x: x + 1) 3");
-        ASSERT_EQ(v.type(), nList);
-        ASSERT_EQ(v.listSize(), 3);
-        for (const auto [i, elem] : enumerate(v.listItems())) {
-            ASSERT_THAT(*elem, IsThunk());
-            state.forceValue(*elem, noPos);
-            ASSERT_THAT(*elem, IsIntEq(static_cast<int>(i)+1));
-        }
-    }
-
-    TEST_F(PrimOpTest, sortLessThan) {
-        auto v = eval("builtins.sort builtins.lessThan [ 483 249 526 147 42 77 ]");
-        ASSERT_EQ(v.type(), nList);
-        ASSERT_EQ(v.listSize(), 6);
-
-        const std::vector<int> numbers = { 42, 77, 147, 249, 483, 526 };
-        for (const auto [n, elem] : enumerate(v.listItems()))
-            ASSERT_THAT(*elem, IsIntEq(numbers[n]));
-    }
-
-    TEST_F(PrimOpTest, partition) {
-        auto v = eval("builtins.partition (x: x > 10) [1 23 9 3 42]");
-        ASSERT_THAT(v, IsAttrsOfSize(2));
-
-        auto right = v.attrs->get(createSymbol("right"));
-        ASSERT_NE(right, nullptr);
-        ASSERT_THAT(*right->value, IsListOfSize(2));
-        ASSERT_THAT(*right->value->listElems()[0], IsIntEq(23));
-        ASSERT_THAT(*right->value->listElems()[1], IsIntEq(42));
-
-        auto wrong = v.attrs->get(createSymbol("wrong"));
-        ASSERT_NE(wrong, nullptr);
-        ASSERT_EQ(wrong->value->type(), nList);
-        ASSERT_EQ(wrong->value->listSize(), 3);
-        ASSERT_THAT(*wrong->value, IsListOfSize(3));
-        ASSERT_THAT(*wrong->value->listElems()[0], IsIntEq(1));
-        ASSERT_THAT(*wrong->value->listElems()[1], IsIntEq(9));
-        ASSERT_THAT(*wrong->value->listElems()[2], IsIntEq(3));
-    }
-
-    TEST_F(PrimOpTest, concatMap) {
-        auto v = eval("builtins.concatMap (x: x ++ [0]) [ [1 2] [3 4] ]");
-        ASSERT_EQ(v.type(), nList);
-        ASSERT_EQ(v.listSize(), 6);
-
-        const std::vector<int> numbers = { 1, 2, 0, 3, 4, 0 };
-        for (const auto [n, elem] : enumerate(v.listItems()))
-            ASSERT_THAT(*elem, IsIntEq(numbers[n]));
-    }
-
-    TEST_F(PrimOpTest, addInt) {
-        auto v = eval("builtins.add 3 5");
-        ASSERT_THAT(v, IsIntEq(8));
-    }
-
-    TEST_F(PrimOpTest, addFloat) {
-        auto v = eval("builtins.add 3.0 5.0");
-        ASSERT_THAT(v, IsFloatEq(8.0));
-    }
-
-    TEST_F(PrimOpTest, addFloatToInt) {
-        auto v = eval("builtins.add 3.0 5");
-        ASSERT_THAT(v, IsFloatEq(8.0));
-
-        v = eval("builtins.add 3 5.0");
-        ASSERT_THAT(v, IsFloatEq(8.0));
-    }
-
-    TEST_F(PrimOpTest, subInt) {
-        auto v = eval("builtins.sub 5 2");
-        ASSERT_THAT(v, IsIntEq(3));
-    }
-
-    TEST_F(PrimOpTest, subFloat) {
-        auto v = eval("builtins.sub 5.0 2.0");
-        ASSERT_THAT(v, IsFloatEq(3.0));
-    }
-
-    TEST_F(PrimOpTest, subFloatFromInt) {
-        auto v = eval("builtins.sub 5.0 2");
-        ASSERT_THAT(v, IsFloatEq(3.0));
-
-        v = eval("builtins.sub 4 2.0");
-        ASSERT_THAT(v, IsFloatEq(2.0));
-    }
-
-    TEST_F(PrimOpTest, mulInt) {
-        auto v = eval("builtins.mul 3 5");
-        ASSERT_THAT(v, IsIntEq(15));
-    }
-
-    TEST_F(PrimOpTest, mulFloat) {
-        auto v = eval("builtins.mul 3.0 5.0");
-        ASSERT_THAT(v, IsFloatEq(15.0));
-    }
-
-    TEST_F(PrimOpTest, mulFloatMixed) {
-        auto v = eval("builtins.mul 3 5.0");
-        ASSERT_THAT(v, IsFloatEq(15.0));
-
-        v = eval("builtins.mul 2.0 5");
-        ASSERT_THAT(v, IsFloatEq(10.0));
-    }
-
-    TEST_F(PrimOpTest, divInt) {
-        auto v = eval("builtins.div 5 (-1)");
-        ASSERT_THAT(v, IsIntEq(-5));
-    }
-
-    TEST_F(PrimOpTest, divIntZero) {
-        ASSERT_THROW(eval("builtins.div 5 0"), EvalError);
-    }
-
-    TEST_F(PrimOpTest, divFloat) {
-        auto v = eval("builtins.div 5.0 (-1)");
-        ASSERT_THAT(v, IsFloatEq(-5.0));
-    }
-
-    TEST_F(PrimOpTest, divFloatZero) {
-        ASSERT_THROW(eval("builtins.div 5.0 0.0"), EvalError);
-    }
-
-    TEST_F(PrimOpTest, bitOr) {
-        auto v = eval("builtins.bitOr 1 2");
-        ASSERT_THAT(v, IsIntEq(3));
-    }
-
-    TEST_F(PrimOpTest, bitXor) {
-        auto v = eval("builtins.bitXor 3 2");
-        ASSERT_THAT(v, IsIntEq(1));
-    }
-
-    TEST_F(PrimOpTest, lessThanFalse) {
-        auto v = eval("builtins.lessThan 3 1");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(PrimOpTest, lessThanTrue) {
-        auto v = eval("builtins.lessThan 1 3");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(PrimOpTest, toStringAttrsThrows) {
-        ASSERT_THROW(eval("builtins.toString {}"), EvalError);
-    }
-
-    TEST_F(PrimOpTest, toStringLambdaThrows) {
-        ASSERT_THROW(eval("builtins.toString (x: x)"), EvalError);
-    }
-
-    class ToStringPrimOpTest :
-        public PrimOpTest,
-        public testing::WithParamInterface<std::tuple<std::string, std::string_view>>
-        {};
-
-    TEST_P(ToStringPrimOpTest, toString) {
-        const auto [input, output] = GetParam();
-        auto v = eval(input);
-        ASSERT_THAT(v, IsStringEq(output));
-    }
-
-#define CASE(input, output) (std::make_tuple(std::string_view("builtins.toString " #input), std::string_view(output)))
-    INSTANTIATE_TEST_SUITE_P(
-            toString,
-            ToStringPrimOpTest,
-            testing::Values(
-                CASE("foo", "foo"),
-                CASE(1, "1"),
-                CASE([1 2 3], "1 2 3"),
-                CASE(.123, "0.123000"),
-                CASE(true, "1"),
-                CASE(false, ""),
-                CASE(null, ""),
-                CASE({ v = "bar"; __toString = self: self.v; }, "bar"),
-                CASE({ v = "bar"; __toString = self: self.v; outPath = "foo"; }, "bar"),
-                CASE({ outPath = "foo"; }, "foo"),
-                CASE(./test, "/test")
-            )
-    );
-#undef CASE
-
-    TEST_F(PrimOpTest, substring){
-        auto v = eval("builtins.substring 0 3 \"nixos\"");
-        ASSERT_THAT(v, IsStringEq("nix"));
-    }
-
-    TEST_F(PrimOpTest, substringSmallerString){
-        auto v = eval("builtins.substring 0 3 \"n\"");
-        ASSERT_THAT(v, IsStringEq("n"));
-    }
-
-    TEST_F(PrimOpTest, substringEmptyString){
-        auto v = eval("builtins.substring 1 3 \"\"");
-        ASSERT_THAT(v, IsStringEq(""));
-    }
-
-    TEST_F(PrimOpTest, stringLength) {
-        auto v = eval("builtins.stringLength \"123\"");
-        ASSERT_THAT(v, IsIntEq(3));
-    }
-    TEST_F(PrimOpTest, hashStringMd5) {
-        auto v = eval("builtins.hashString \"md5\" \"asdf\"");
-        ASSERT_THAT(v, IsStringEq("912ec803b2ce49e4a541068d495ab570"));
-    }
-
-    TEST_F(PrimOpTest, hashStringSha1) {
-        auto v = eval("builtins.hashString \"sha1\" \"asdf\"");
-        ASSERT_THAT(v, IsStringEq("3da541559918a808c2402bba5012f6c60b27661c"));
-    }
-
-    TEST_F(PrimOpTest, hashStringSha256) {
-        auto v = eval("builtins.hashString \"sha256\" \"asdf\"");
-        ASSERT_THAT(v, IsStringEq("f0e4c2f76c58916ec258f246851bea091d14d4247a2fc3e18694461b1816e13b"));
-    }
-
-    TEST_F(PrimOpTest, hashStringSha512) {
-        auto v = eval("builtins.hashString \"sha512\" \"asdf\"");
-        ASSERT_THAT(v, IsStringEq("401b09eab3c013d4ca54922bb802bec8fd5318192b0a75f201d8b3727429080fb337591abd3e44453b954555b7a0812e1081c39b740293f765eae731f5a65ed1"));
-    }
-
-    TEST_F(PrimOpTest, hashStringInvalidHashType) {
-        ASSERT_THROW(eval("builtins.hashString \"foobar\" \"asdf\""), Error);
-    }
-
-    TEST_F(PrimOpTest, nixPath) {
-        auto v = eval("builtins.nixPath");
-        ASSERT_EQ(v.type(), nList);
-        // We can't test much more as currently the EvalSettings are a global
-        // that we can't easily swap / replace
-    }
-
-    TEST_F(PrimOpTest, langVersion) {
-        auto v = eval("builtins.langVersion");
-        ASSERT_EQ(v.type(), nInt);
-    }
-
-    TEST_F(PrimOpTest, storeDir) {
-        auto v = eval("builtins.storeDir");
-        ASSERT_THAT(v, IsStringEq("/nix/store"));
-    }
-
-    TEST_F(PrimOpTest, nixVersion) {
-        auto v = eval("builtins.nixVersion");
-        ASSERT_THAT(v, IsStringEq(nixVersion));
-    }
-
-    TEST_F(PrimOpTest, currentSystem) {
-        auto v = eval("builtins.currentSystem");
-        ASSERT_THAT(v, IsStringEq(settings.thisSystem.get()));
-    }
-
-    TEST_F(PrimOpTest, derivation) {
-        auto v = eval("derivation");
-        ASSERT_EQ(v.type(), nFunction);
-        ASSERT_TRUE(v.isLambda());
-        ASSERT_NE(v.lambda.fun, nullptr);
-        ASSERT_TRUE(v.lambda.fun->hasFormals());
-    }
-
-    TEST_F(PrimOpTest, currentTime) {
-        auto v = eval("builtins.currentTime");
-        ASSERT_EQ(v.type(), nInt);
-        ASSERT_TRUE(v.integer > 0);
-    }
-
-    TEST_F(PrimOpTest, splitVersion) {
-        auto v = eval("builtins.splitVersion \"1.2.3git\"");
-        ASSERT_THAT(v, IsListOfSize(4));
-
-        const std::vector<std::string_view> strings = { "1", "2", "3", "git" };
-        for (const auto [n, p] : enumerate(v.listItems()))
-            ASSERT_THAT(*p, IsStringEq(strings[n]));
-    }
-
-    class CompareVersionsPrimOpTest :
-        public PrimOpTest,
-        public testing::WithParamInterface<std::tuple<std::string, const int>>
-        {};
-
-    TEST_P(CompareVersionsPrimOpTest, compareVersions) {
-        auto [expression, expectation] = GetParam();
-        auto v = eval(expression);
-        ASSERT_THAT(v, IsIntEq(expectation));
-    }
-
-#define CASE(a, b, expected) (std::make_tuple("builtins.compareVersions \"" #a "\" \"" #b "\"", expected))
-    INSTANTIATE_TEST_SUITE_P(
-            compareVersions,
-            CompareVersionsPrimOpTest,
-            testing::Values(
-                // The first two are weird cases. Intuition tells they should
-                // be the same but they aren't.
-                CASE(1.0, 1.0.0, -1),
-                CASE(1.0.0, 1.0, 1),
-                // the following are from the nix-env manual:
-                CASE(1.0, 2.3, -1),
-                CASE(2.1, 2.3, -1),
-                CASE(2.3, 2.3, 0),
-                CASE(2.5, 2.3, 1),
-                CASE(3.1, 2.3, 1),
-                CASE(2.3.1, 2.3, 1),
-                CASE(2.3.1, 2.3a, 1),
-                CASE(2.3pre1, 2.3, -1),
-                CASE(2.3pre3, 2.3pre12, -1),
-                CASE(2.3a, 2.3c, -1),
-                CASE(2.3pre1, 2.3c, -1),
-                CASE(2.3pre1, 2.3q, -1)
-            )
-    );
-#undef CASE
-
-
-  class ParseDrvNamePrimOpTest :
-      public PrimOpTest,
-      public testing::WithParamInterface<std::tuple<std::string, std::string_view, std::string_view>>
-      {};
-
-    TEST_P(ParseDrvNamePrimOpTest, parseDrvName) {
-        auto [input, expectedName, expectedVersion] = GetParam();
-        const auto expr = fmt("builtins.parseDrvName \"%1%\"", input);
-        auto v = eval(expr);
-        ASSERT_THAT(v, IsAttrsOfSize(2));
-
-        auto name = v.attrs->find(createSymbol("name"));
-        ASSERT_TRUE(name);
-        ASSERT_THAT(*name->value, IsStringEq(expectedName));
-
-        auto version = v.attrs->find(createSymbol("version"));
-        ASSERT_TRUE(version);
-        ASSERT_THAT(*version->value, IsStringEq(expectedVersion));
-    }
-
-    INSTANTIATE_TEST_SUITE_P(
-            parseDrvName,
-            ParseDrvNamePrimOpTest,
-            testing::Values(
-                std::make_tuple("nix-0.12pre12876", "nix", "0.12pre12876"),
-                std::make_tuple("a-b-c-1234pre5+git", "a-b-c", "1234pre5+git")
-            )
-    );
-
-    TEST_F(PrimOpTest, replaceStrings) {
-        // FIXME: add a test that verifies the string context is as expected
-        auto v = eval("builtins.replaceStrings [\"oo\" \"a\"] [\"a\" \"i\"] \"foobar\"");
-        ASSERT_EQ(v.type(), nString);
-        ASSERT_EQ(v.string.s, std::string_view("fabir"));
-    }
-
-    TEST_F(PrimOpTest, concatStringsSep) {
-        // FIXME: add a test that verifies the string context is as expected
-        auto v = eval("builtins.concatStringsSep \"%\" [\"foo\" \"bar\" \"baz\"]");
-        ASSERT_EQ(v.type(), nString);
-        ASSERT_EQ(std::string_view(v.string.s), "foo%bar%baz");
-    }
-
-    TEST_F(PrimOpTest, split1) {
-        // v = [ "" [ "a" ] "c" ]
-        auto v = eval("builtins.split \"(a)b\" \"abc\"");
-        ASSERT_THAT(v, IsListOfSize(3));
-
-        ASSERT_THAT(*v.listElems()[0], IsStringEq(""));
-
-        ASSERT_THAT(*v.listElems()[1], IsListOfSize(1));
-        ASSERT_THAT(*v.listElems()[1]->listElems()[0], IsStringEq("a"));
-
-        ASSERT_THAT(*v.listElems()[2], IsStringEq("c"));
-    }
-
-    TEST_F(PrimOpTest, split2) {
-        // v is expected to be a list [ "" [ "a" ] "b" [ "c"] "" ]
-        auto v = eval("builtins.split \"([ac])\" \"abc\"");
-        ASSERT_THAT(v, IsListOfSize(5));
-
-        ASSERT_THAT(*v.listElems()[0], IsStringEq(""));
-
-        ASSERT_THAT(*v.listElems()[1], IsListOfSize(1));
-        ASSERT_THAT(*v.listElems()[1]->listElems()[0], IsStringEq("a"));
-
-        ASSERT_THAT(*v.listElems()[2], IsStringEq("b"));
-
-        ASSERT_THAT(*v.listElems()[3], IsListOfSize(1));
-        ASSERT_THAT(*v.listElems()[3]->listElems()[0], IsStringEq("c"));
-
-        ASSERT_THAT(*v.listElems()[4], IsStringEq(""));
-    }
-
-    TEST_F(PrimOpTest, split3) {
-        auto v = eval("builtins.split \"(a)|(c)\" \"abc\"");
-        ASSERT_THAT(v, IsListOfSize(5));
-
-        // First list element
-        ASSERT_THAT(*v.listElems()[0], IsStringEq(""));
-
-        // 2nd list element is a list [ "" null ]
-        ASSERT_THAT(*v.listElems()[1], IsListOfSize(2));
-        ASSERT_THAT(*v.listElems()[1]->listElems()[0], IsStringEq("a"));
-        ASSERT_THAT(*v.listElems()[1]->listElems()[1], IsNull());
-
-        // 3rd element
-        ASSERT_THAT(*v.listElems()[2], IsStringEq("b"));
-
-        // 4th element is a list: [ null "c" ]
-        ASSERT_THAT(*v.listElems()[3], IsListOfSize(2));
-        ASSERT_THAT(*v.listElems()[3]->listElems()[0], IsNull());
-        ASSERT_THAT(*v.listElems()[3]->listElems()[1], IsStringEq("c"));
-
-        // 5th element is the empty string
-        ASSERT_THAT(*v.listElems()[4], IsStringEq(""));
-    }
-
-    TEST_F(PrimOpTest, split4) {
-        auto v = eval("builtins.split \"([[:upper:]]+)\" \" FOO \"");
-        ASSERT_THAT(v, IsListOfSize(3));
-        auto first = v.listElems()[0];
-        auto second = v.listElems()[1];
-        auto third = v.listElems()[2];
-
-        ASSERT_THAT(*first, IsStringEq(" "));
-
-        ASSERT_THAT(*second, IsListOfSize(1));
-        ASSERT_THAT(*second->listElems()[0], IsStringEq("FOO"));
-
-        ASSERT_THAT(*third, IsStringEq(" "));
-    }
-
-    TEST_F(PrimOpTest, match1) {
-        auto v = eval("builtins.match \"ab\" \"abc\"");
-        ASSERT_THAT(v, IsNull());
-    }
-
-    TEST_F(PrimOpTest, match2) {
-        auto v = eval("builtins.match \"abc\" \"abc\"");
-        ASSERT_THAT(v, IsListOfSize(0));
-    }
-
-    TEST_F(PrimOpTest, match3) {
-        auto v = eval("builtins.match \"a(b)(c)\" \"abc\"");
-        ASSERT_THAT(v, IsListOfSize(2));
-        ASSERT_THAT(*v.listElems()[0], IsStringEq("b"));
-        ASSERT_THAT(*v.listElems()[1], IsStringEq("c"));
-    }
-
-    TEST_F(PrimOpTest, match4) {
-        auto v = eval("builtins.match \"[[:space:]]+([[:upper:]]+)[[:space:]]+\" \"  FOO   \"");
-        ASSERT_THAT(v, IsListOfSize(1));
-        ASSERT_THAT(*v.listElems()[0], IsStringEq("FOO"));
-    }
-
-    TEST_F(PrimOpTest, attrNames) {
-        auto v = eval("builtins.attrNames { x = 1; y = 2; z = 3; a = 2; }");
-        ASSERT_THAT(v, IsListOfSize(4));
-
-        // ensure that the list is sorted
-        const std::vector<std::string_view> expected { "a", "x", "y", "z" };
-        for (const auto [n, elem] : enumerate(v.listItems()))
-            ASSERT_THAT(*elem, IsStringEq(expected[n]));
-    }
-} /* namespace nix */

src/libexpr/tests/trivial.cc

@@ -1,196 +0,0 @@
-#include "libexprtests.hh"
-
-namespace nix {
-    // Testing of trivial expressions
-    class TrivialExpressionTest : public LibExprTest {};
-
-    TEST_F(TrivialExpressionTest, true) {
-        auto v = eval("true");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(TrivialExpressionTest, false) {
-        auto v = eval("false");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(TrivialExpressionTest, null) {
-        auto v = eval("null");
-        ASSERT_THAT(v, IsNull());
-    }
-
-    TEST_F(TrivialExpressionTest, 1) {
-        auto v = eval("1");
-        ASSERT_THAT(v, IsIntEq(1));
-    }
-
-    TEST_F(TrivialExpressionTest, 1plus1) {
-        auto v = eval("1+1");
-        ASSERT_THAT(v, IsIntEq(2));
-    }
-
-    TEST_F(TrivialExpressionTest, minus1) {
-        auto v = eval("-1");
-        ASSERT_THAT(v, IsIntEq(-1));
-    }
-
-    TEST_F(TrivialExpressionTest, 1minus1) {
-        auto v = eval("1-1");
-        ASSERT_THAT(v, IsIntEq(0));
-    }
-
-    TEST_F(TrivialExpressionTest, lambdaAdd) {
-        auto v = eval("let add = a: b: a + b; in add 1 2");
-        ASSERT_THAT(v, IsIntEq(3));
-    }
-
-    TEST_F(TrivialExpressionTest, list) {
-        auto v = eval("[]");
-        ASSERT_THAT(v, IsListOfSize(0));
-    }
-
-    TEST_F(TrivialExpressionTest, attrs) {
-        auto v = eval("{}");
-        ASSERT_THAT(v, IsAttrsOfSize(0));
-    }
-
-    TEST_F(TrivialExpressionTest, float) {
-        auto v = eval("1.234");
-        ASSERT_THAT(v, IsFloatEq(1.234));
-    }
-
-    TEST_F(TrivialExpressionTest, updateAttrs) {
-        auto v = eval("{ a = 1; } // { b = 2; a = 3; }");
-        ASSERT_THAT(v, IsAttrsOfSize(2));
-        auto a = v.attrs->find(createSymbol("a"));
-        ASSERT_NE(a, nullptr);
-        ASSERT_THAT(*a->value, IsIntEq(3));
-
-        auto b = v.attrs->find(createSymbol("b"));
-        ASSERT_NE(b, nullptr);
-        ASSERT_THAT(*b->value, IsIntEq(2));
-    }
-
-    TEST_F(TrivialExpressionTest, hasAttrOpFalse) {
-        auto v = eval("{} ? a");
-        ASSERT_THAT(v, IsFalse());
-    }
-
-    TEST_F(TrivialExpressionTest, hasAttrOpTrue) {
-        auto v = eval("{ a = 123; } ? a");
-        ASSERT_THAT(v, IsTrue());
-    }
-
-    TEST_F(TrivialExpressionTest, withFound) {
-        auto v = eval("with { a = 23; }; a");
-        ASSERT_THAT(v, IsIntEq(23));
-    }
-
-    TEST_F(TrivialExpressionTest, withNotFound) {
-        ASSERT_THROW(eval("with {}; a"), Error);
-    }
-
-    TEST_F(TrivialExpressionTest, withOverride) {
-        auto v = eval("with { a = 23; }; with { a = 42; }; a");
-        ASSERT_THAT(v, IsIntEq(42));
-    }
-
-    TEST_F(TrivialExpressionTest, letOverWith) {
-        auto v = eval("let a = 23; in with { a = 1; }; a");
-        ASSERT_THAT(v, IsIntEq(23));
-    }
-
-    TEST_F(TrivialExpressionTest, multipleLet) {
-        auto v = eval("let a = 23; in let a = 42; in a");
-        ASSERT_THAT(v, IsIntEq(42));
-    }
-
-    TEST_F(TrivialExpressionTest, defaultFunctionArgs) {
-        auto v = eval("({ a ? 123 }: a) {}");
-        ASSERT_THAT(v, IsIntEq(123));
-    }
-
-    TEST_F(TrivialExpressionTest, defaultFunctionArgsOverride) {
-        auto v = eval("({ a ? 123 }: a) { a = 5; }");
-        ASSERT_THAT(v, IsIntEq(5));
-    }
-
-    TEST_F(TrivialExpressionTest, defaultFunctionArgsCaptureBack) {
-        auto v = eval("({ a ? 123 }@args: args) {}");
-        ASSERT_THAT(v, IsAttrsOfSize(0));
-    }
-
-    TEST_F(TrivialExpressionTest, defaultFunctionArgsCaptureFront) {
-        auto v = eval("(args@{ a ? 123 }: args) {}");
-        ASSERT_THAT(v, IsAttrsOfSize(0));
-    }
-
-    TEST_F(TrivialExpressionTest, assertThrows) {
-        ASSERT_THROW(eval("let x = arg: assert arg == 1; 123; in x 2"), Error);
-    }
-
-    TEST_F(TrivialExpressionTest, assertPassed) {
-        auto v = eval("let x = arg: assert arg == 1; 123; in x 1");
-        ASSERT_THAT(v, IsIntEq(123));
-    }
-
-    class AttrSetMergeTrvialExpressionTest :
-        public TrivialExpressionTest,
-        public testing::WithParamInterface<const char*>
-        {};
-
-    TEST_P(AttrSetMergeTrvialExpressionTest, attrsetMergeLazy) {
-        // Usually Nix rejects duplicate keys in an attrset but it does allow
-        // so if it is an attribute set that contains disjoint sets of keys.
-        // The below is equivalent to `{a.b = 1; a.c = 2; }`.
-        // The attribute set `a` will be a Thunk at first as the attribuets
-        // have to be merged (or otherwise computed) and that is done in a lazy
-        // manner.
-
-        auto expr = GetParam();
-        auto v = eval(expr);
-        ASSERT_THAT(v, IsAttrsOfSize(1));
-
-        auto a = v.attrs->find(createSymbol("a"));
-        ASSERT_NE(a, nullptr);
-
-        ASSERT_THAT(*a->value, IsThunk());
-        state.forceValue(*a->value, noPos);
-
-        ASSERT_THAT(*a->value, IsAttrsOfSize(2));
-
-        auto b = a->value->attrs->find(createSymbol("b"));
-        ASSERT_NE(b, nullptr);
-        ASSERT_THAT(*b->value, IsIntEq(1));
-
-        auto c = a->value->attrs->find(createSymbol("c"));
-        ASSERT_NE(c, nullptr);
-        ASSERT_THAT(*c->value, IsIntEq(2));
-    }
-
-    INSTANTIATE_TEST_SUITE_P(
-            attrsetMergeLazy,
-            AttrSetMergeTrvialExpressionTest,
-            testing::Values(
-                "{ a.b = 1; a.c = 2; }",
-                "{ a = { b = 1; }; a = { c = 2; }; }"
-            )
-    );
-
-    TEST_F(TrivialExpressionTest, functor) {
-        auto v = eval("{ __functor = self: arg: self.v + arg; v = 10; } 5");
-        ASSERT_THAT(v, IsIntEq(15));
-    }
-
-    TEST_F(TrivialExpressionTest, bindOr) {
-        auto v = eval("{ or = 1; }");
-        ASSERT_THAT(v, IsAttrsOfSize(1));
-        auto b = v.attrs->find(createSymbol("or"));
-        ASSERT_NE(b, nullptr);
-        ASSERT_THAT(*b->value, IsIntEq(1));
-    }
-
-    TEST_F(TrivialExpressionTest, orCantBeUsed) {
-        ASSERT_THROW(eval("let or = 1; in or"), Error);
-    }
-} /* namespace nix */

src/libexpr/value-to-json.cc

@@ -10,7 +10,7 @@
 namespace nix {
 
 void printValueAsJSON(EvalState & state, bool strict,
-    Value & v, const PosIdx pos, JSONPlaceholder & out, PathSet & context)
+    Value & v, const Pos & pos, JSONPlaceholder & out, PathSet & context)
 {
     checkInterrupt();
 
@@ -50,14 +50,14 @@ void printValueAsJSON(EvalState & state, bool strict,
                 auto obj(out.object());
                 StringSet names;
                 for (auto & j : *v.attrs)
-                    names.emplace(state.symbols[j.name]);
+                    names.insert(j.name);
                 for (auto & j : names) {
                     Attr & a(*v.attrs->find(state.symbols.create(j)));
                     auto placeholder(obj.placeholder(j));
-                    printValueAsJSON(state, strict, *a.value, a.pos, placeholder, context);
+                    printValueAsJSON(state, strict, *a.value, *a.pos, placeholder, context);
                 }
             } else
-                printValueAsJSON(state, strict, *i->value, i->pos, out, context);
+                printValueAsJSON(state, strict, *i->value, *i->pos, out, context);
             break;
         }
 
@@ -82,16 +82,14 @@ void printValueAsJSON(EvalState & state, bool strict,
         case nFunction:
             auto e = TypeError({
                 .msg = hintfmt("cannot convert %1% to JSON", showType(v)),
-                .errPos = state.positions[v.determinePos(pos)]
+                .errPos = v.determinePos(pos)
             });
-            e.addTrace(state.positions[pos], hintfmt("message for the trace"));
-            state.debugThrowLastTrace(e);
-            throw e;
+            throw e.addTrace(pos, hintfmt("message for the trace"));
     }
 }
 
 void printValueAsJSON(EvalState & state, bool strict,
-    Value & v, const PosIdx pos, std::ostream & str, PathSet & context)
+    Value & v, const Pos & pos, std::ostream & str, PathSet & context)
 {
     JSONPlaceholder out(str);
     printValueAsJSON(state, strict, v, pos, out, context);
@@ -100,7 +98,7 @@ void printValueAsJSON(EvalState & state, bool strict,
 void ExternalValueBase::printValueAsJSON(EvalState & state, bool strict,
     JSONPlaceholder & out, PathSet & context) const
 {
-    state.debugThrowLastTrace(TypeError("cannot convert %1% to JSON", showType()));
+    throw TypeError("cannot convert %1% to JSON", showType());
 }
 
 

src/libexpr/value-to-json.hh

@@ -11,9 +11,9 @@ namespace nix {
 class JSONPlaceholder;
 
 void printValueAsJSON(EvalState & state, bool strict,
-    Value & v, const PosIdx pos, JSONPlaceholder & out, PathSet & context);
+    Value & v, const Pos & pos, JSONPlaceholder & out, PathSet & context);
 
 void printValueAsJSON(EvalState & state, bool strict,
-    Value & v, const PosIdx pos, std::ostream & str, PathSet & context);
+    Value & v, const Pos & pos, std::ostream & str, PathSet & context);
 
 }

src/libexpr/value-to-xml.cc

@@ -9,7 +9,7 @@
 namespace nix {
 
 
-static XMLAttrs singletonAttrs(const std::string & name, const std::string & value)
+static XMLAttrs singletonAttrs(const string & name, const string & value)
 {
     XMLAttrs attrs;
     attrs[name] = value;
@@ -19,10 +19,10 @@ static XMLAttrs singletonAttrs(const std::string & name, const std::string & val
 
 static void printValueAsXML(EvalState & state, bool strict, bool location,
     Value & v, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
-    const PosIdx pos);
+    const Pos & pos);
 
 
-static void posToXML(EvalState & state, XMLAttrs & xmlAttrs, const Pos & pos)
+static void posToXML(XMLAttrs & xmlAttrs, const Pos & pos)
 {
     xmlAttrs["path"] = pos.file;
     xmlAttrs["line"] = (format("%1%") % pos.line).str();
@@ -36,25 +36,25 @@ static void showAttrs(EvalState & state, bool strict, bool location,
     StringSet names;
 
     for (auto & i : attrs)
-        names.emplace(state.symbols[i.name]);
+        names.insert(i.name);
 
     for (auto & i : names) {
         Attr & a(*attrs.find(state.symbols.create(i)));
 
         XMLAttrs xmlAttrs;
         xmlAttrs["name"] = i;
-        if (location && a.pos) posToXML(state, xmlAttrs, state.positions[a.pos]);
+        if (location && a.pos != ptr(&noPos)) posToXML(xmlAttrs, *a.pos);
 
         XMLOpenElement _(doc, "attr", xmlAttrs);
         printValueAsXML(state, strict, location,
-            *a.value, doc, context, drvsSeen, a.pos);
+            *a.value, doc, context, drvsSeen, *a.pos);
     }
 }
 
 
 static void printValueAsXML(EvalState & state, bool strict, bool location,
     Value & v, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
-    const PosIdx pos)
+    const Pos & pos)
 {
     checkInterrupt();
 
@@ -93,14 +93,14 @@ static void printValueAsXML(EvalState & state, bool strict, bool location,
                 Path drvPath;
                 a = v.attrs->find(state.sDrvPath);
                 if (a != v.attrs->end()) {
-                    if (strict) state.forceValue(*a->value, a->pos);
+                    if (strict) state.forceValue(*a->value, *a->pos);
                     if (a->value->type() == nString)
                         xmlAttrs["drvPath"] = drvPath = a->value->string.s;
                 }
 
                 a = v.attrs->find(state.sOutPath);
                 if (a != v.attrs->end()) {
-                    if (strict) state.forceValue(*a->value, a->pos);
+                    if (strict) state.forceValue(*a->value, *a->pos);
                     if (a->value->type() == nString)
                         xmlAttrs["outPath"] = a->value->string.s;
                 }
@@ -134,18 +134,18 @@ static void printValueAsXML(EvalState & state, bool strict, bool location,
                 break;
             }
             XMLAttrs xmlAttrs;
-            if (location) posToXML(state, xmlAttrs, state.positions[v.lambda.fun->pos]);
+            if (location) posToXML(xmlAttrs, v.lambda.fun->pos);
             XMLOpenElement _(doc, "function", xmlAttrs);
 
             if (v.lambda.fun->hasFormals()) {
                 XMLAttrs attrs;
-                if (v.lambda.fun->arg) attrs["name"] = state.symbols[v.lambda.fun->arg];
+                if (!v.lambda.fun->arg.empty()) attrs["name"] = v.lambda.fun->arg;
                 if (v.lambda.fun->formals->ellipsis) attrs["ellipsis"] = "1";
                 XMLOpenElement _(doc, "attrspat", attrs);
-                for (auto & i : v.lambda.fun->formals->lexicographicOrder(state.symbols))
-                    doc.writeEmptyElement("attr", singletonAttrs("name", state.symbols[i.name]));
+                for (auto & i : v.lambda.fun->formals->lexicographicOrder())
+                    doc.writeEmptyElement("attr", singletonAttrs("name", i.name));
             } else
-                doc.writeEmptyElement("varpat", singletonAttrs("name", state.symbols[v.lambda.fun->arg]));
+                doc.writeEmptyElement("varpat", singletonAttrs("name", v.lambda.fun->arg));
 
             break;
         }
@@ -166,14 +166,14 @@ static void printValueAsXML(EvalState & state, bool strict, bool location,
 
 void ExternalValueBase::printValueAsXML(EvalState & state, bool strict,
     bool location, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
-    const PosIdx pos) const
+    const Pos & pos) const
 {
     doc.writeEmptyElement("unevaluated");
 }
 
 
 void printValueAsXML(EvalState & state, bool strict, bool location,
-    Value & v, std::ostream & out, PathSet & context, const PosIdx pos)
+    Value & v, std::ostream & out, PathSet & context, const Pos & pos)
 {
     XMLWriter doc(true, out);
     XMLOpenElement root(doc, "expr");

src/libexpr/value-to-xml.hh

@@ -9,6 +9,6 @@
 namespace nix {
 
 void printValueAsXML(EvalState & state, bool strict, bool location,
-    Value & v, std::ostream & out, PathSet & context, const PosIdx pos);
+    Value & v, std::ostream & out, PathSet & context, const Pos & pos);
 
 }

src/libexpr/value.hh

@@ -56,10 +56,7 @@ struct Expr;
 struct ExprLambda;
 struct PrimOp;
 class Symbol;
-class PosIdx;
 struct Pos;
-class StorePath;
-class Store;
 class EvalState;
 class XMLWriter;
 class JSONPlaceholder;
@@ -67,8 +64,6 @@ class JSONPlaceholder;
 
 typedef int64_t NixInt;
 typedef double NixFloat;
-typedef std::pair<StorePath, std::string> NixStringContextElem;
-typedef std::vector<NixStringContextElem> NixStringContext;
 
 /* External values must descend from ExternalValueBase, so that
  * type-agnostic nix functions (e.g. showType) can be implemented
@@ -104,7 +99,7 @@ class ExternalValueBase
     /* Print the value as XML. Defaults to unevaluated */
     virtual void printValueAsXML(EvalState & state, bool strict, bool location,
         XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
-        const PosIdx pos) const;
+        const Pos & pos) const;
 
     virtual ~ExternalValueBase()
     {
@@ -119,14 +114,11 @@ struct Value
 private:
     InternalType internalType;
 
-    friend std::string showType(const Value & v);
-
-    void print(const SymbolTable & symbols, std::ostream & str, std::set<const void *> * seen) const;
+friend std::string showType(const Value & v);
+friend void printValue(std::ostream & str, std::set<const Value *> & active, const Value & v);
 
 public:
 
-    void print(const SymbolTable & symbols, std::ostream & str, bool showRepeated = false) const;
-
     // Functions needed to distinguish the type
     // These should be removed eventually, by putting the functionality that's
     // needed by callers into methods of this type
@@ -251,6 +243,11 @@ public:
 
     void mkStringMove(const char * s, const PathSet & context);
 
+    inline void mkString(const Symbol & s)
+    {
+        mkString(((const std::string &) s).c_str());
+    }
+
     inline void mkPath(const char * s)
     {
         clearValue();
@@ -364,14 +361,14 @@ public:
         return internalType == tList1 ? 1 : internalType == tList2 ? 2 : bigList.size;
     }
 
-    PosIdx determinePos(const PosIdx pos) const;
+    Pos determinePos(const Pos & pos) const;
 
     /* Check whether forcing this value requires a trivial amount of
        computation. In particular, function applications are
        non-trivial. */
     bool isTrivial() const;
 
-    NixStringContext getContext(const Store &);
+    std::vector<std::pair<Path, std::string>> getContext();
 
     auto listItems()
     {
@@ -404,9 +401,9 @@ public:
 
 
 #if HAVE_BOEHMGC
-typedef std::vector<Value *, traceable_allocator<Value *>> ValueVector;
-typedef std::map<Symbol, Value *, std::less<Symbol>, traceable_allocator<std::pair<const Symbol, Value *>>> ValueMap;
-typedef std::map<Symbol, ValueVector, std::less<Symbol>, traceable_allocator<std::pair<const Symbol, ValueVector>>> ValueVectorMap;
+typedef std::vector<Value *, traceable_allocator<Value *> > ValueVector;
+typedef std::map<Symbol, Value *, std::less<Symbol>, traceable_allocator<std::pair<const Symbol, Value *> > > ValueMap;
+typedef std::map<Symbol, ValueVector, std::less<Symbol>, traceable_allocator<std::pair<const Symbol, ValueVector> > > ValueVectorMap;
 #else
 typedef std::vector<Value *> ValueVector;
 typedef std::map<Symbol, Value *> ValueMap;

src/libfetchers/cache.cc

@@ -52,13 +52,13 @@ struct CacheImpl : Cache
         const Attrs & inAttrs,
         const Attrs & infoAttrs,
         const StorePath & storePath,
-        bool locked) override
+        bool immutable) override
     {
         _state.lock()->add.use()
             (attrsToJSON(inAttrs).dump())
             (attrsToJSON(infoAttrs).dump())
             (store->printStorePath(storePath))
-            (locked)
+            (immutable)
             (time(0)).exec();
     }
 
@@ -91,7 +91,7 @@ struct CacheImpl : Cache
 
         auto infoJSON = stmt.getStr(0);
         auto storePath = store->parseStorePath(stmt.getStr(1));
-        auto locked = stmt.getInt(2) != 0;
+        auto immutable = stmt.getInt(2) != 0;
         auto timestamp = stmt.getInt(3);
 
         store->addTempRoot(storePath);
@@ -105,7 +105,7 @@ struct CacheImpl : Cache
             inAttrsJSON, infoJSON, store->printStorePath(storePath));
 
         return Result {
-            .expired = !locked && (settings.tarballTtl.get() == 0 || timestamp + settings.tarballTtl < time(0)),
+            .expired = !immutable && (settings.tarballTtl.get() == 0 || timestamp + settings.tarballTtl < time(0)),
             .infoAttrs = jsonToAttrs(nlohmann::json::parse(infoJSON)),
             .storePath = std::move(storePath)
         };

src/libfetchers/cache.hh

@@ -13,7 +13,7 @@ struct Cache
         const Attrs & inAttrs,
         const Attrs & infoAttrs,
         const StorePath & storePath,
-        bool locked) = 0;
+        bool immutable) = 0;
 
     virtual std::optional<std::pair<Attrs, StorePath>> lookup(
         ref<Store> store,

src/libfetchers/fetch-settings.cc

@@ -1,13 +0,0 @@
-#include "fetch-settings.hh"
-
-namespace nix {
-
-FetchSettings::FetchSettings()
-{
-}
-
-FetchSettings fetchSettings;
-
-static GlobalConfig::Register rFetchSettings(&fetchSettings);
-
-}

src/libfetchers/fetch-settings.hh

@@ -1,93 +0,0 @@
-#pragma once
-
-#include "types.hh"
-#include "config.hh"
-#include "util.hh"
-
-#include <map>
-#include <limits>
-
-#include <sys/types.h>
-
-namespace nix {
-
-struct FetchSettings : public Config
-{
-    FetchSettings();
-
-    Setting<StringMap> accessTokens{this, {}, "access-tokens",
-        R"(
-          Access tokens used to access protected GitHub, GitLab, or
-          other locations requiring token-based authentication.
-
-          Access tokens are specified as a string made up of
-          space-separated `host=token` values.  The specific token
-          used is selected by matching the `host` portion against the
-          "host" specification of the input. The actual use of the
-          `token` value is determined by the type of resource being
-          accessed:
-
-          * Github: the token value is the OAUTH-TOKEN string obtained
-            as the Personal Access Token from the Github server (see
-            https://docs.github.com/en/developers/apps/building-oauth-apps/authorizing-oauth-apps).
-
-          * Gitlab: the token value is either the OAuth2 token or the
-            Personal Access Token (these are different types tokens
-            for gitlab, see
-            https://docs.gitlab.com/12.10/ee/api/README.html#authentication).
-            The `token` value should be `type:tokenstring` where
-            `type` is either `OAuth2` or `PAT` to indicate which type
-            of token is being specified.
-
-          Example `~/.config/nix/nix.conf`:
-
-          ```
-          access-tokens = github.com=23ac...b289 gitlab.mycompany.com=PAT:A123Bp_Cd..EfG gitlab.com=OAuth2:1jklw3jk
-          ```
-
-          Example `~/code/flake.nix`:
-
-          ```nix
-          input.foo = {
-            type = "gitlab";
-            host = "gitlab.mycompany.com";
-            owner = "mycompany";
-            repo = "pro";
-          };
-          ```
-
-          This example specifies three tokens, one each for accessing
-          github.com, gitlab.mycompany.com, and sourceforge.net.
-
-          The `input.foo` uses the "gitlab" fetcher, which might
-          requires specifying the token type along with the token
-          value.
-          )"};
-
-    Setting<bool> allowDirty{this, true, "allow-dirty",
-        "Whether to allow dirty Git/Mercurial trees."};
-
-    Setting<bool> warnDirty{this, true, "warn-dirty",
-        "Whether to warn about dirty Git/Mercurial trees."};
-
-    Setting<std::string> flakeRegistry{this, "https://github.com/NixOS/flake-registry/raw/master/flake-registry.json", "flake-registry",
-        "Path or URI of the global flake registry."};
-
-    Setting<bool> useRegistries{this, true, "use-registries",
-        "Whether to use flake registries to resolve flake references."};
-
-    Setting<bool> acceptFlakeConfig{this, false, "accept-flake-config",
-        "Whether to accept nix configuration from a flake without prompting."};
-
-    Setting<std::string> commitLockFileSummary{
-        this, "", "commit-lockfile-summary",
-        R"(
-          The commit summary to use when committing changed flake lock files. If
-          empty, the summary is generated based on the action performed.
-        )"};
-};
-
-// FIXME: don't use a global variable.
-extern FetchSettings fetchSettings;
-
-}

src/libfetchers/fetchers.cc

@@ -24,11 +24,11 @@ static void fixupInput(Input & input)
     input.getType();
     input.getRef();
     if (input.getRev())
-        input.locked = true;
+        input.immutable = true;
     input.getRevCount();
     input.getLastModified();
     if (input.getNarHash())
-        input.locked = true;
+        input.immutable = true;
 }
 
 Input Input::fromURL(const ParsedURL & url)
@@ -165,7 +165,7 @@ std::pair<Tree, Input> Input::fetch(ref<Store> store) const
                 input.to_string(), *prevRevCount);
     }
 
-    input.locked = true;
+    input.immutable = true;
 
     assert(input.hasAllInfo());
 
@@ -209,7 +209,7 @@ StorePath Input::computeStorePath(Store & store) const
 {
     auto narHash = getNarHash();
     if (!narHash)
-        throw Error("cannot compute store path for unlocked input '%s'", to_string());
+        throw Error("cannot compute store path for mutable input '%s'", to_string());
     return store.makeFixedOutputPath(FileIngestionMethod::Recursive, *narHash, getName());
 }
 
@@ -238,18 +238,9 @@ std::optional<std::string> Input::getRef() const
 
 std::optional<Hash> Input::getRev() const
 {
-    std::optional<Hash> hash = {};
-
-    if (auto s = maybeGetStrAttr(attrs, "rev")) {
-        try {
-            hash = Hash::parseAnyPrefixed(*s);
-        } catch (BadHash &e) {
-            // Default to sha1 for backwards compatibility with existing flakes
-            hash = Hash::parseAny(*s, htSHA1);
-        }
-    }
-
-    return hash;
+    if (auto s = maybeGetStrAttr(attrs, "rev"))
+        return Hash::parseAny(*s, htSHA1);
+    return {};
 }
 
 std::optional<uint64_t> Input::getRevCount() const