release: merge release 2.91.1 back to mainline

This merge commit returns to the previous state prior to the release but leaves the tag in the branch history.
Release created with releng/create_release.xsh

Change-Id: I29e738732bdd3cc8c9d1e3a5a3e5aa83dfec2a6f

.editorconfig

@@ -29,7 +29,3 @@ trim_trailing_whitespace = false
 indent_style = space
 indent_size = 2
 max_line_length = 0
-
-[meson.build]
-indent_style = space
-indent_size = 2

.github/ISSUE_TEMPLATE/missing_documentation.md

@@ -2,7 +2,7 @@
 name: Missing or incorrect documentation
 about: Help us improve the reference manual
 title: ''
-labels: docs
+labels: documentation
 assignees: ''
 
 ---
@@ -19,10 +19,10 @@ assignees: ''
 
 <!-- make sure this issue is not redundant or obsolete -->
 
-- [ ] checked [latest Lix manual] or its [source code]
+- [ ] checked [latest Lix manual] \([source]\)
 - [ ] checked [documentation issues] and [recent documentation changes] for possible duplicates
 
-[latest Lix manual]: https://docs.lix.systems/manual/lix/nightly
-[source code]: https://git.lix.systems/lix-project/lix/src/main/doc/manual/src
+[latest Nix manual]: https://docs.lix.systems/manual/lix/nightly
+[source]: https://git.lix.systems/lix-project/lix/src/main/doc/manual/src
 [documentation issues]: https://git.lix.systems/lix-project/lix/issues?labels=151&state=all
 [recent documentation changes]: https://gerrit.lix.systems/q/p:lix+path:%22%5Edoc/manual/.*%22

.gitignore

@@ -9,10 +9,6 @@ GTAGS
 # ccls
 /.ccls-cache
 
-# auto-generated compilation database
-compile_commands.json
-rust-project.json
-
 result
 result-*
 
@@ -33,9 +29,3 @@ buildtime.bin
 /.pre-commit-config.yaml
 /.nocontribmsg
 /release
-
-# Rust build files when using Cargo (not actually supported for building but it spews the files anyway)
-/target/
-
-# Python compiled files from the test suite
-*.pyc

Cargo.toml

@@ -1,6 +0,0 @@
-[workspace]
-resolver = "2"
-members = ["src/lix-doc"]
-
-[workspace.package]
-edition = "2021"

bench/bench.sh

@@ -1,5 +1,4 @@
-#!/usr/bin/env nix-shell
-#!nix-shell -i bash -p bash -p hyperfine
+#!/usr/bin/env bash
 
 set -euo pipefail
 shopt -s inherit_errexit
@@ -22,21 +21,16 @@ fi
 _exit=""
 trap "$_exit" EXIT
 
-flake_args=("--extra-experimental-features" "nix-command flakes")
-
 # XXX: yes this is very silly. flakes~!!
-nix build "${flake_args[@]}" --impure --expr '(builtins.getFlake "git+file:.").inputs.nixpkgs.outPath' -o bench/nixpkgs
+nix build --impure --expr '(builtins.getFlake "git+file:.").inputs.nixpkgs.outPath' -o bench/nixpkgs
 
-# We must ignore the global config, or else NIX_PATH won't work reliably.
-# See https://github.com/NixOS/nix/issues/9574
-export NIX_CONF_DIR='/var/empty'
 export NIX_REMOTE="$(mktemp -d)"
 _exit='rm -rfv "$NIX_REMOTE"; $_exit'
 export NIX_PATH="nixpkgs=bench/nixpkgs:nixos-config=bench/configuration.nix"
 
 builds=("$@")
 
-flake_args="${flake_args[*]@Q}"
+flake_args="--extra-experimental-features 'nix-command flakes'"
 
 hyperfineArgs=(
     --parameter-list BUILD "$(IFS=,; echo "${builds[*]}")"

doc/internal-api/doxygen.cfg.in

@@ -33,7 +33,32 @@ GENERATE_LATEX         = NO
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = @INPUT_PATHS@
+# FIXME Make this list more maintainable somehow. We could maybe generate this
+# in the Makefile, but we would need to change how `.in` files are preprocessed
+# so they can expand variables despite configure variables.
+
+INPUT                  = \
+  src/libcmd \
+  src/libexpr \
+  src/libexpr/flake \
+  tests/unit/libexpr \
+  tests/unit/libexpr/value \
+  tests/unit/libexpr/test \
+  tests/unit/libexpr/test/value \
+  src/libexpr/value \
+  src/libfetchers \
+  src/libmain \
+  src/libstore \
+  src/libstore/build \
+  src/libstore/builtins \
+  tests/unit/libstore \
+  tests/unit/libstore/test \
+  src/libutil \
+  tests/unit/libutil \
+  tests/unit/libutil/test \
+  src/nix \
+  src/nix-env \
+  src/nix-store
 
 # If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
 # in the source code. If set to NO, only conditional compilation will be
@@ -72,15 +97,3 @@ EXPAND_AS_DEFINED      = \
   DECLARE_WORKER_SERIALISER \
   DECLARE_SERVE_SERIALISER \
   LENGTH_PREFIXED_PROTO_HELPER
-
-# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
-# Stripping is only done if one of the specified strings matches the left-hand
-# part of the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the path to
-# strip.
-#
-# Note that you can specify absolute paths here, but also relative paths, which
-# will be relative from the directory where doxygen is started.
-# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-
-STRIP_FROM_PATH        = "@PROJECT_SOURCE_ROOT@"

doc/internal-api/meson.build

@@ -1,35 +1,3 @@
-internal_api_sources = [
-  'src/libcmd',
-  'src/libexpr',
-  'src/libexpr/flake',
-  'tests/unit/libexpr',
-  'tests/unit/libexpr/value',
-  'tests/unit/libexpr/test',
-  'tests/unit/libexpr/test/value',
-  'src/libexpr/value',
-  'src/libfetchers',
-  'src/libmain',
-  'src/libstore',
-  'src/libstore/build',
-  'src/libstore/builtins',
-  'tests/unit/libstore',
-  'tests/unit/libstore/test',
-  'src/libutil',
-  'tests/unit/libutil',
-  'tests/unit/libutil/test',
-  'src/nix',
-  'src/nix-env',
-  'src/nix-store',
-]
-
-# We feed Doxygen absolute paths so it can be invoked from any working directory.
-internal_api_sources_absolute = []
-foreach src : internal_api_sources
-  internal_api_sources_absolute += '"' + (meson.project_source_root() / src) + '"'
-endforeach
-
-internal_api_sources_oneline = ' \\\n  '.join(internal_api_sources_absolute)
-
 doxygen_cfg = configure_file(
   input : 'doxygen.cfg.in',
   output : 'doxygen.cfg',
@@ -37,16 +5,22 @@ doxygen_cfg = configure_file(
     'PACKAGE_VERSION': meson.project_version(),
     'RAPIDCHECK_HEADERS': rapidcheck_meson.get_variable('includedir'),
     'docdir' : meson.current_build_dir(),
-    'INPUT_PATHS' : internal_api_sources_oneline,
-    'PROJECT_SOURCE_ROOT' : meson.project_source_root(),
   },
 )
 
 internal_api_docs = custom_target(
   'internal-api-docs',
   command : [
+    bash,
+    # Meson can you please just give us a `workdir` argument to custom targets...
+    '-c',
+    # We have to prefix the doxygen_cfg path with the project build root
+    # because of the cd in front.
+    'cd @0@ && @1@ @2@/@INPUT0@'.format(
+      meson.project_source_root(),
       doxygen.full_path(),
-    '@INPUT0@',
+      meson.project_build_root(),
+    ),
   ],
   input : [
     doxygen_cfg,

doc/manual/change-authors.yml

@@ -85,10 +85,6 @@ kloenk:
   forgejo: kloenk
   github: kloenk
 
-lheckemann:
-  forgejo: lheckemann
-  github: lheckemann
-
 lovesegfault:
   github: lovesegfault
 
@@ -145,17 +141,9 @@ valentin:
   display_name: Valentin Gagarin
   github: fricklerhandwerk
 
-vigress8:
-  display_name: Vigress
-  forgejo: vigress8
-  github: vigress8
-
 winter:
   forgejo: winter
   github: winterqt
 
 yshui:
   github: yshui
-
-zimbatm:
-  github: zimbatm

doc/manual/generate-features.nix

@@ -1,18 +0,0 @@
-# Usually "experimental" or "deprecated"
-_kind:
-# "xp" or "dp"
-kindShort:
-
-with builtins;
-with import ./utils.nix;
-
-let
-  showFeature =
-    name: doc:
-    squash ''
-      ## [`${name}`]{#${kindShort}-feature-${name}}
-
-      ${doc}
-    '';
-in
-xps: (concatStringsSep "\n" (attrValues (mapAttrs showFeature xps)))

doc/manual/generate-xp-features-shortlist.nix

@@ -1,14 +1,9 @@
-# Usually "experimental" or "deprecated"
-kind:
-# "xp" or "dp"
-kindShort:
-
 with builtins;
 with import ./utils.nix;
 
 let
   showExperimentalFeature = name: doc: ''
-    - [`${name}`](@docroot@/contributing/${kind}-features.md#${kindShort}-feature-${name})
+    - [`${name}`](@docroot@/contributing/experimental-features.md#xp-feature-${name})
   '';
 in
 xps: indent "  " (concatStrings (attrValues (mapAttrs showExperimentalFeature xps)))

doc/manual/generate-xp-features.nix

@@ -0,0 +1,13 @@
+with builtins;
+with import ./utils.nix;
+
+let
+  showExperimentalFeature =
+    name: doc:
+    squash ''
+      ## [`${name}`]{#xp-feature-${name}}
+
+      ${doc}
+    '';
+in
+xps: (concatStringsSep "\n" (attrValues (mapAttrs showExperimentalFeature xps)))

doc/manual/meson.build

@@ -20,8 +20,6 @@ conf_file_json = custom_target(
   capture : true,
   output : 'conf-file.json',
   env : nix_env_for_docs,
-  # FIXME: put the actual lib targets in here? meson have introspection challenge 2024 though.
-  build_always_stale : true,
 )
 
 nix_conf_file_md_body = custom_target(
@@ -52,8 +50,6 @@ nix_exp_features_json = custom_target(
   command : [ nix, '__dump-xp-features' ],
   capture : true,
   output : 'xp-features.json',
-  # FIXME: put the actual lib targets in here? meson have introspection challenge 2024 though.
-  build_always_stale : true,
 )
 
 language_json = custom_target(
@@ -61,8 +57,6 @@ language_json = custom_target(
   output : 'language.json',
   capture : true,
   env : nix_env_for_docs,
-  # FIXME: put the actual lib targets in here? meson have introspection challenge 2024 though.
-  build_always_stale : true,
 )
 
 nix3_cli_json = custom_target(
@@ -70,8 +64,6 @@ nix3_cli_json = custom_target(
   capture : true,
   output : 'nix.json',
   env : nix_env_for_docs,
-  # FIXME: put the actual lib targets in here? meson have introspection challenge 2024 though.
-  build_always_stale : true,
 )
 
 generate_manual_deps = files(
@@ -80,9 +72,9 @@ generate_manual_deps = files(
 
 # Generates builtins.md and builtin-constants.md.
 subdir('src/language')
-# Generates new-cli pages, {experimental,deprecated}-features-shortlist.md, and conf-file.md.
+# Generates new-cli pages, experimental-features-shortlist.md, and conf-file.md.
 subdir('src/command-ref')
-# Generates {experimental,deprecated}-feature-descriptions.md.
+# Generates experimental-feature-descriptions.md.
 subdir('src/contributing')
 # Generates rl-next-generated.md.
 subdir('src/release-notes')
@@ -114,8 +106,6 @@ manual = custom_target(
     nix3_cli_files,
     experimental_features_shortlist_md,
     experimental_feature_descriptions_md,
-    deprecated_features_shortlist_md,
-    deprecated_feature_descriptions_md,
     conf_file_md,
     builtins_md,
     builtin_constants_md,
@@ -126,19 +116,20 @@ manual = custom_target(
     'manual',
     'markdown',
   ],
-  install : true,
-  install_dir : [
-    datadir / 'doc/nix',
-    false,
-  ],
   depfile : 'manual.d',
   env : {
     'RUST_LOG': 'info',
     'MDBOOK_SUBSTITUTE_SEARCH': meson.current_build_dir() / 'src',
   },
 )
+manual_html = manual[0]
 manual_md = manual[1]
 
+install_subdir(
+  manual_html.full_path(),
+  install_dir : datadir / 'doc/nix',
+)
+
 nix_nested_manpages = [
   [ 'nix-env',
     [

doc/manual/rl-next/allowsubstitutes-errors.md

@@ -1,21 +0,0 @@
----
-synopsis: "Build failures caused by `allowSubstitutes = false` while being the wrong system now produce a decent error"
-issues: [fj#484]
-cls: [1841]
-category: Fixes
-credits: jade
----
-
-Nix allows derivations to set `allowSubstitutes = false` in order to force them to be built locally without querying substituters for them.
-This is useful for derivations that are very fast to build (especially if they produce large output).
-However, this can shoot you in the foot if the derivation *has* to be substituted such as if the derivation is for another architecture, which is what `--always-allow-substitutes` is for.
-
-Perhaps such derivations that are known to be impossible to build locally should ignore `allowSubstitutes` (irrespective of remote builders) in the future, but this at least reports the failure and solution directly.
-
-```
-$ nix build -f fail.nix
-error: a 'unicornsandrainbows-linux' with features {} is required to build '/nix/store/...-meow.drv', but I am a 'x86_64-linux' with features {...}
-
-       Hint: the failing derivation has allowSubstitutes set to false, forcing it to be built rather than substituted.
-       Passing --always-allow-substitutes to force substitution may resolve this failure if the path is available in a substituter.
-```

doc/manual/rl-next/alt-left-and-alt-right-in-repl.md

@@ -1,10 +0,0 @@
----
-synopsis: "`Alt+Left` and `Alt+Right` go back/forwards by words in `nix repl`"
-issues: [fj#501]
-cls: [1883]
-category: Fixes
-credits: 9999years
----
-
-`nix repl` now recognizes `Alt+Left` and `Alt+Right` for navigating by words
-when entering input in `nix repl` on more terminals/platforms.

doc/manual/rl-next/content-encodings.md

@@ -1,15 +0,0 @@
----
-synopsis: "Drop support for `xz` and `bzip2` Content-Encoding"
-category: Miscellany
-cls: [2134]
-credits: horrors
----
-
-Lix no longer supports the non-standard HTTP Content-Encoding values `xz` and `bzip2`.
-We do not expect this to cause any problems in practice since these encodings *aren't*
-standard, and any server delivering them anyway without being asked to is already well
-and truly set on the path of causing inexplicable client breakages.
-
-Lix's ability to decompress files compressed with `xz` or `bzip2` is unaffected. We're
-only bringing Lix more in line with the HTTP standard; all post-transfer data handling
-remains as it was before.

doc/manual/rl-next/ctrl-c-improved.md

@@ -1,13 +0,0 @@
----
-synopsis: Ctrl-C stops Nix commands much more reliably and responsively
-issues: [7245, fj#393]
-cls: [2016]
-prs: [11618]
-category: Fixes
-credits: [roberth, 9999years]
----
-
-CTRL-C will now stop Nix commands much more reliably and responsively. While
-there are still some cases where a Nix command can be slow or unresponsive
-following a `SIGINT` (please report these as issues!), the vast majority of
-signals will now cause the Nix command to quit quickly and consistently.

doc/manual/rl-next/deprecated-features.md

@@ -1,17 +0,0 @@
----
-synopsis: Deprecated language features
-issues: [fj#437]
-cls: [1785, 1736, 1735, 1744]
-category: Breaking Changes
-credits: [piegames, horrors]
----
-
-A system for deprecation (and then the planned removal) of undesired language features has been put into place.
-It is controlled via feature flags much like experimental features, except that the deprecations are enabled default,
-and can be disabled via the flags for backwards compatibility (opt-out with `--extra-deprecated-features` or the Nix configuration file).
-
-- `url-literals`: **URL literals** have long been obsolete and discouraged of use, and now they are officially deprecated.
-  This means that all URLs must be properly put within quotes like all other strings.
-- `rec-set-overrides`: **__overrides** is an old arcane syntax which has not been in use for more than a decade.
-  It is soft-deprecated with a warning only, with the plan to turn that into an error in a future release.
-- `ancient-let`: **The old `let` syntax** (`let { body = …; … }`) is soft-deprecated with a warning as well. Use the regular `let … in` instead.

doc/manual/rl-next/download-protocols.md

@@ -1,10 +0,0 @@
----
-synopsis: "transfers no longer allow arbitrary url schemas"
-category: Breaking Changes
-cls: [2106]
-credits: horrors
----
-
-Lix no longer allows transfers using arbitrary url schemas. Only `http://`, `https://`, `ftp://`, `ftps://`, and `file://` urls are supported going forward. This affects `builtins.fetchurl`, `<nix/fetchurl.nix>`, transfers to and from binary caches, and all other uses of the internal file transfer code. Flake inputs using multi-protocol schemas (e.g. `git+ssh`) are not affected as those use external utilities to transfer data.
-
-The `s3://` scheme is not affected at all by this change and continues to work if S3 support is built into Lix.

doc/manual/rl-next/fetchGit-regression.md

@@ -1,23 +0,0 @@
----
-synopsis: restore backwards-compatibility of `builtins.fetchGit` with Nix 2.3
-issues: [5291, 5128]
-credits: [ma27]
-category: Fixes
----
-
-Compatibility with `builtins.fetchGit` from Nix 2.3 has been restored as follows:
-
-* Until now, each `ref` was prefixed with `refs/heads` unless it starts with `refs/` itself.
-
-  Now, this is not done if the `ref` looks like a commit hash.
-
-* Specifying `builtins.fetchGit { ref = "a-tag"; /* … */ }` was broken because `refs/heads` was appended.
-
-  Now, the fetcher doesn't turn a ref into `refs/heads/ref`, but into `refs/*/ref`. That way,
-  the value in `ref` can be either a tag or a branch.
-
-* The ref resolution happens the same way as in git:
-
-  * If `refs/ref` exists, it's used.
-  * If a tag `refs/tags/ref` exists, it's used.
-  * If a branch `refs/heads/ref` exists, it's used.

doc/manual/rl-next/http-proxy-for-s3.md

@@ -1,10 +0,0 @@
----
-synopsis: HTTP proxy environment variables are now respected for S3 binary cache stores
-issues: [fj#433]
-cls: [1788]
-category: Fixes
-credits: jade
----
-
-Due to "legacy reasons" (according to the AWS C++ SDK docs), the AWS SDK ignores system proxy configuration by default.
-We turned it back on.

doc/manual/rl-next/nix-fmt-default-argument.md

@@ -1,38 +0,0 @@
----
-synopsis: Removing the `.` default argument passed to the `nix fmt` formatter
-issues: []
-prs: [11438]
-cls: [1902]
-category: Breaking Changes
-credits: zimbatm
----
-
-The underlying formatter no longer receives the ". " default argument when `nix fmt` is called with no arguments.
-
-This change was necessary as the formatter wasn't able to distinguish between
-a user wanting to format the current folder with `nix fmt .` or the generic
-`nix fmt`.
-
-The default behaviour is now the responsibility of the formatter itself, and
-allows tools such as treefmt to format the whole tree instead of only the
-current directory and below.
-
-This may cause issues with some formatters: nixfmt, nixpkgs-fmt and alejandra currently format stdin when no arguments are passed.
-
-Here is a small wrapper example that will restore the previous behaviour for such a formatter:
-
-```nix
-{
-  outputs = { self, nixpkgs, systems }:
-    let
-      eachSystem = nixpkgs.lib.genAttrs (import systems) (system: nixpkgs.legacyPackages.${system});
-    in
-    {
-      formatter = eachSystem (pkgs:
-        pkgs.writeShellScriptBin "formatter" ''
-          if [[ $# = 0 ]]; set -- .; fi
-          exec "${pkgs.nixfmt-rfc-style}/bin/nixfmt "$@"
-        '');
-    };
-}
-```

doc/manual/rl-next/pytest-suite.md

@@ -1,10 +0,0 @@
----
-synopsis: "The beginnings of a new pytest-based functional test suite"
-category: Development
-cls: [2036, 2037]
-credits: jade
----
-
-The existing integration/functional test suite is based on a large volume of shell scripts.
-This often makes it somewhat challenging to debug at the best of times.
-The goal of the pytest test suite is to make tests have more obvious dependencies on files and to make tests more concise and easier to write, as well as making new testing methods like snapshot testing easy.

doc/manual/rl-next/readline-support-removed.md

@@ -1,17 +0,0 @@
----
-synopsis: readline support removed
-cls: [1885]
-category: Packaging
-credits: [9999years]
----
-
-Support for building Lix with [`readline`][readline] instead of
-[`editline`][editline] has been removed. `readline` support hasn't worked for a
-long time (attempting to use it would lead to build errors) and would make Lix
-subject to the GPL if it did work. In the future, we're hoping to replace
-`editline` with [`rustyline`][rustyline] for improved ergonomics in the `nix
-repl`.
-
-[readline]: https://en.wikipedia.org/wiki/GNU_Readline
-[editline]: https://github.com/troglobit/editline
-[rustyline]: https://github.com/kkawakam/rustyline

doc/manual/rl-next/relative-and-tilde-paths-in-config.md

@@ -1,30 +0,0 @@
----
-synopsis: Relative and tilde paths in configuration
-issues: [fj#482]
-cls: [1851, 1863, 1864]
-category: Features
-credits: [9999years]
----
-
-[Configuration settings](@docroot@/command-ref/conf-file.md) can now refer to
-files with paths relative to the file they're written in or relative to your
-home directory (with `~/`).
-
-This makes settings like
-[`repl-overlays`](@docroot@/command-ref/conf-file.md#conf-repl-overlays) and
-[`secret-key-files`](@docroot@/command-ref/conf-file.md#conf-repl-overlays)
-much easier to set, especially if you'd like to refer to files in an existing
-dotfiles repo cloned into your home directory.
-
-If you put `repl-overlays = repl.nix` in your `~/.config/nix/nix.conf`, it'll
-load `~/.config/nix/repl.nix`. Similarly, you can set `repl-overlays =
-~/.dotfiles/repl.nix` to load a file relative to your home directory.
-
-Configuration files can also
-[`include`](@docroot@/command-ref/conf-file.md#file-format) paths relative to
-your home directory.
-
-Only user configuration files (like `$XDG_CONFIG_HOME/nix/nix.conf` or the
-files listed in `$NIX_USER_CONF_FILES`) can use tilde paths relative to your
-home directory. Configuration listed in the `$NIX_CONFIG` environment variable
-may not use relative paths.

doc/manual/rl-next/remove-mono-coreutils-dependency.md

@@ -1,8 +0,0 @@
----
-synopsis: "Dependency on monolithic coreutils removed"
-category: Development
-cls: [2108]
-credits: vigress8
----
-
-Previously, the build erroneously depended on a `coreutils` binary, which requires `coreutils` to be built with a specific configuration. This was only used in one test and was not required to be a single binary. This dependency is removed now.

doc/manual/rl-next/report-differing-outputs.md

@@ -1,22 +0,0 @@
----
-synopsis: "Reproducibility check builds now report all differing outputs"
-cls: [2069]
-category: Improvements
-credits: [lheckemann]
----
-
-`nix-build --check` allows rerunning the build of an already-built derivation to check that it produces the same output again.
-
-If a multiple-output derivation with impure behaviour is built with `--check`, only the first output would be shown in the resulting error message (and kept for comparison):
-
-```
-error: derivation '/nix/store/4spy3nz1661zm15gkybsy1h5f36aliwx-python3.11-test-1.0.0.drv' may not be deterministic: output '/nix/store/ccqcp01zg18wp9iadzmzimqzdi3ll08d-python3.11-test
--1.0.0-dist' differs from '/nix/store/ccqcp01zg18wp9iadzmzimqzdi3ll08d-python3.11-test-1.0.0-dist.check'
-```
-
-Now, all differing outputs are kept and reported:
-```
-error: derivation '4spy3nz1661zm15gkybsy1h5f36aliwx-python3.11-test-1.0.0.drv' may not be deterministic: outputs differ
-         output differs: output '/nix/store/ccqcp01zg18wp9iadzmzimqzdi3ll08d-python3.11-test-1.0.0-dist' differs from '/nix/store/ccqcp01zg18wp9iadzmzimqzdi3ll08d-python3.11-test-1.0.0-dist.check'
-         output differs: output '/nix/store/yl59v08356i841c560alb0zmk7q16klb-python3.11-test-1.0.0' differs from '/nix/store/yl59v08356i841c560alb0zmk7q16klb-python3.11-test-1.0.0.check'
-```

doc/manual/rl-next/stack-traces.md

@@ -1,26 +0,0 @@
----
-synopsis: "Some Lix crashes now produce reporting instructions and a stack trace, then abort"
-cls: [1854]
-category: Improvements
-credits: jade
----
-
-Lix, being a C++ program, can crash in a few kinds of ways.
-It can obviously do a memory access violation, which will generate a core dump and thus be relatively debuggable.
-But, worse, it could throw an unhandled exception, and, in the past, we would just show the message but not where it comes from, in spite of this always being a bug, since we expect all such errors to be translated to a Lix specific error.
-Now the latter kind of bug should print reporting instructions, a rudimentary stack trace and (depending on system configuration) generate a core dump.
-
-Sample output:
-
-```
-Lix crashed. This is a bug. We would appreciate if you report it along with what caused it at https://git.lix.systems/lix-project/lix/issues with the following information included:
-
-Exception: std::runtime_error: test exception
-Stack trace:
- 0# nix::printStackTrace() in /home/jade/lix/lix3/build/src/nix/../libutil/liblixutil.so
- 1# 0x000073C9862331F2 in /home/jade/lix/lix3/build/src/nix/../libmain/liblixmain.so
- 2# 0x000073C985F2E21A in /nix/store/p44qan69linp3ii0xrviypsw2j4qdcp2-gcc-13.2.0-lib/lib/libstdc++.so.6
- 3# 0x000073C985F2E285 in /nix/store/p44qan69linp3ii0xrviypsw2j4qdcp2-gcc-13.2.0-lib/lib/libstdc++.so.6
- 4# nix::handleExceptions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::function<void ()>) in /home/jade/lix/lix3/build/src/nix/../libmain/liblixmain.so
- ...
-```

doc/manual/rl-next/verify-tls.md

@@ -1,10 +0,0 @@
----
-synopsis: "`<nix/fetchurl.nix>` now uses TLS verification"
-category: Fixes
-prs: [11585]
-credits: edolstra
----
-
-Previously `<nix/fetchurl.nix>` did not do TLS verification. This was because the Nix sandbox in the past did not have access to TLS certificates, and Nix checks the hash of the fetched file anyway. However, this can expose authentication data from `netrc` and URLs to man-in-the-middle attackers. In addition, Nix now in some cases (such as when using impure derivations) does *not* check the hash. Therefore we have now enabled TLS verification. This means that downloads by `<nix/fetchurl.nix>` will now fail if you're fetching from a HTTPS server that does not have a valid certificate.
-
-`<nix/fetchurl.nix>` is also known as the builtin derivation builder `builtin:fetchurl`. It's not to be confused with the evaluation-time function `builtins.fetchurl`, which was not affected by this issue.

doc/manual/src/SUMMARY.md

@@ -192,7 +192,6 @@
   - [Hacking](contributing/hacking.md)
   - [Testing](contributing/testing.md)
   - [Experimental Features](contributing/experimental-features.md)
-  - [Deprecated Features](contributing/deprecated-features.md)
   - [CLI guideline](contributing/cli-guideline.md)
   - [C++ style guide](contributing/cxx.md)
 - [Release Notes](release-notes/release-notes.md)

doc/manual/src/command-ref/meson.build

@@ -1,37 +1,23 @@
+xp_features_json = custom_target(
+  command : [nix, '__dump-xp-features'],
+  capture : true,
+  output : 'xp-features.json',
+)
+
 experimental_features_shortlist_md = custom_target(
   command : nix_eval_for_docs + [
     '--expr',
-    'import @INPUT0@ "experimental" "xp" (builtins.fromJSON (builtins.readFile @INPUT1@))',
+    'import @INPUT0@ (builtins.fromJSON (builtins.readFile @INPUT1@))',
   ],
   input : [
-    '../../generate-features-shortlist.nix',
-    nix_exp_features_json,
+    '../../generate-xp-features-shortlist.nix',
+    xp_features_json,
   ],
   capture : true,
   output : 'experimental-features-shortlist.md',
   env : nix_env_for_docs,
 )
 
-dp_features_json = custom_target(
-  command : [nix, '__dump-dp-features'],
-  capture : true,
-  output : 'dp-features.json',
-)
-
-deprecated_features_shortlist_md = custom_target(
-  command : nix_eval_for_docs + [
-    '--expr',
-    'import @INPUT0@ "deprecated" "dp" (builtins.fromJSON (builtins.readFile @INPUT1@))',
-  ],
-  input : [
-    '../../generate-features-shortlist.nix',
-    dp_features_json,
-  ],
-  capture : true,
-  output : 'deprecated-features-shortlist.md',
-  env : nix_env_for_docs,
-)
-
 # Intermediate step for manpage generation.
 # This splorks the output of generate-manpage.nix as JSON,
 # which gets written as a directory tree below.
@@ -74,7 +60,6 @@ conf_file_md = custom_target(
     '../../utils.nix',
     conf_file_json,
     experimental_features_shortlist_md,
-    deprecated_features_shortlist_md,
   ],
   output : 'conf-file.md',
   env : nix_env_for_docs,

doc/manual/src/contributing/deprecated-features.md

@@ -1,37 +0,0 @@
-This section describes the notion of *deprecated features*, and how it fits into the big picture of the development of Lix.
-
-# What are deprecated features?
-
-Deprecated features are disabled by default, with the intent to eventually remove them.
-Users must explicitly enable them to keep using them, by toggling the associated [deprecated feature flags](@docroot@/command-ref/conf-file.md#conf-deprecated-features).
-This allows backwards compatibility and a graceful transition away from undesired features.
-
-# Which features can be deprecated?
-
-Undesired features should be soft-deprecated by yielding a warning when used for a significant amount of time before the can be deprecated.
-Legacy obsolete feature with little to no usage may go through this process faster.
-Deprecated features should have a migration path to a preferred alternative.
-
-# Lifecycle of a deprecated feature
-
-This description is not normative, but a feature removal may roughly happen like this:
-
-1. Add a warning when the feature is being used.
-2. Disable the feature by default, putting it behind a deprecated feature flag.
-  - If disabling the feature started out as an opt-in experimental feature, turn that experimental flag into a no-op or remove it entirely.
-    For example, `--extra-experimental-features=no-url-literals` becomes `--extra-deprecated-features=url-literals`.
-3. Decide on a time frame for how long that feature will still be supported for backwards compatibility, and clearly communicate that in the error messages.
-  - Sometimes, automatic migration to alternatives is possible, and such should be provided if possible
-  - At least one NixOS release cycle should be the minimum
-4. Finally remove the feature entirely, only keeping the error message for those still using it.
-
-# Relation to language versioning
-
-Obviously, removing anything breaks backwards compatibility.
-In an ideal world, we'd have SemVer controls over the language and its features, cleanly allowing us to make breaking changes.
-See https://wiki.lix.systems/books/lix-contributors/page/language-versioning and [RFC 137](https://github.com/nixos/rfcs/pull/137) for efforts on that.
-However, we do not live in such an ideal world, and currently this goal is so far away, that "just disable it with some back-compat for a couple of years" is the most realistic solution, especially for comparatively minor changes.
-
-# Currently available deprecated features
-
-{{#include @generated@/contributing/deprecated-feature-descriptions.md}}

doc/manual/src/contributing/meson.build

@@ -4,25 +4,12 @@
 experimental_feature_descriptions_md = custom_target(
   command : nix_eval_for_docs + [
     '--expr',
-    'import @INPUT0@ "experimental" "xp" (builtins.fromJSON (builtins.readFile @INPUT1@))',
+    'import @INPUT0@ (builtins.fromJSON (builtins.readFile @INPUT1@))',
   ],
   input : [
-    '../../generate-features.nix',
-    nix_exp_features_json,
+    '../../generate-xp-features.nix',
+    xp_features_json,
   ],
   capture : true,
   output : 'experimental-feature-descriptions.md',
 )
-
-deprecated_feature_descriptions_md = custom_target(
-  command : nix_eval_for_docs + [
-    '--expr',
-    'import @INPUT0@ "deprecated" "dp" (builtins.fromJSON (builtins.readFile @INPUT1@))',
-  ],
-  input : [
-    '../../generate-features.nix',
-    dp_features_json,
-  ],
-  capture : true,
-  output : 'deprecated-feature-descriptions.md',
-)

doc/manual/src/installation/multi-user.md

@@ -36,10 +36,7 @@ All users of the Lix daemon may do the following to bring things into the Nix st
     - Input-addressed, so they are run in the sandbox with no network access, with the following exceptions:
 
       - The (poorly named, since it is not *just* about chroot) property `__noChroot` is set on the derivation and `sandbox` is set to `relaxed`.
-      - On macOS, the derivation property `__darwinAllowLocalNetworking` allows network access to localhost from input-addressed derivations regardless of the `sandbox` setting value.
-        This property exists with such semantics because macOS has no network namespace equivalent to isolate individual processes' localhost networking.
-      - On macOS, the derivation property `__sandboxProfile` accepts extra sandbox profile S-expressions, allowing derivations to bypass arbitrary parts of the sandbox without altogether disabling it.
-        This is only permitted when `sandbox` is set to `relaxed`.
+      - On macOS, the derivation property `__darwinAllowLocalNetworking` allows network access to localhost from input-addressed derivations regardless of the `sandbox` setting value. This property exists with such semantics because macOS has no network namespace equivalent to isolate individual processes' localhost networking.
     - Output-addressed, so they are run with network access but their result must match an expected hash.
 
   Trusted users may set any setting, including `sandbox = false`, so the sandbox state can be different at runtime from what is described in `nix.conf` for builds invoked with such settings.

doc/manual/src/language/values.md

@@ -77,6 +77,12 @@
   }
   ```
 
+  Finally, as a convenience, *URIs* as defined in appendix B of
+  [RFC 2396](http://www.ietf.org/rfc/rfc2396.txt) can be written *as
+  is*, without quotes. For instance, the string
+  `"http://example.org/foo.tar.bz2"` can also be written as
+  `http://example.org/foo.tar.bz2`.
+
 - <a id="type-number" href="#type-number">Number</a>
 
   Numbers, which can be *integers* (like `123`) or *floating point*

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

@@ -1,4 +1,16 @@
 # Lix 2.91 "Dragon's Breath" (2024-08-12)
+# Lix 2.91.1 (2024-10-18)
+
+## Fixes
+- `<nix/fetchurl.nix>` now uses TLS verification [#11585](https://github.com/NixOS/nix/pull/11585)
+
+  Previously `<nix/fetchurl.nix>` did not do TLS verification. This was because the Nix sandbox in the past did not have access to TLS certificates, and Nix checks the hash of the fetched file anyway. However, this can expose authentication data from `netrc` and URLs to man-in-the-middle attackers. In addition, Nix now in some cases (such as when using impure derivations) does *not* check the hash. Therefore we have now enabled TLS verification. This means that downloads by `<nix/fetchurl.nix>` will now fail if you're fetching from a HTTPS server that does not have a valid certificate.
+
+  `<nix/fetchurl.nix>` is also known as the builtin derivation builder `builtin:fetchurl`. It's not to be confused with the evaluation-time function `builtins.fetchurl`, which was not affected by this issue.
+
+  Many thanks to [Eelco Dolstra](https://github.com/edolstra) for this.
+
+
 
 
 # Lix 2.91.0 (2024-08-12)

flake.lock

@@ -19,11 +19,11 @@
     "nix2container": {
       "flake": false,
       "locked": {
-        "lastModified": 1724996935,
-        "narHash": "sha256-njRK9vvZ1JJsP8oV2OgkBrpJhgQezI03S7gzskCcHos=",
+        "lastModified": 1720642556,
+        "narHash": "sha256-qsnqk13UmREKmRT7c8hEnz26X3GFFyIQrqx4EaRc1Is=",
         "owner": "nlewo",
         "repo": "nix2container",
-        "rev": "fa6bb0a1159f55d071ba99331355955ae30b3401",
+        "rev": "3853e5caf9ad24103b13aa6e0e8bcebb47649fe4",
         "type": "github"
       },
       "original": {
@@ -34,11 +34,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1727184566,
-        "narHash": "sha256-mgdK8BcFsLSNhe780+cHbEUbZ3OruLa1T/xgQlL4Aj4=",
+        "lastModified": 1721931987,
+        "narHash": "sha256-1Zg8LY0T5EfXtv0Kf4M6SFnjH7Eto4VV+EKJ/YSnhiI=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "48c3030083c46042584531bc9d931020f1975677",
+        "rev": "e21630230c77140bc6478a21cd71e8bb73706fce",
         "type": "github"
       },
       "original": {
@@ -67,11 +67,11 @@
     "pre-commit-hooks": {
       "flake": false,
       "locked": {
-        "lastModified": 1726745158,
-        "narHash": "sha256-D5AegvGoEjt4rkKedmxlSEmC+nNLMBPWFxvmYnVLhjk=",
+        "lastModified": 1721042469,
+        "narHash": "sha256-6FPUl7HVtvRHCCBQne7Ylp4p+dpP3P/OYuzjztZ4s70=",
         "owner": "cachix",
         "repo": "git-hooks.nix",
-        "rev": "4e743a6920eab45e8ba0fbe49dc459f1423a4b74",
+        "rev": "f451c19376071a90d8c58ab1a953c6e9840527fd",
         "type": "github"
       },
       "original": {

flake.nix

@@ -99,10 +99,9 @@
       ];
 
       stdenvs = [
-        # see assertion in package.nix why these two are disabled
-        # "stdenv"
-        # "gccStdenv"
+        "gccStdenv"
         "clangStdenv"
+        "stdenv"
         "libcxxStdenv"
         "ccacheStdenv"
       ];
@@ -122,11 +121,7 @@
             name = "${stdenvName}Packages";
             value = f stdenvName;
           }) stdenvs
-        )
-        // {
-          # TODO delete this and reënable gcc stdenvs once gcc compiles kj coros correctly
-          stdenvPackages = f "clangStdenv";
-        };
+        );
 
       # Memoize nixpkgs for different platforms for efficiency.
       nixpkgsFor = forAllSystems (
@@ -217,7 +212,7 @@
 
       # A Nixpkgs overlay that overrides the 'nix' and
       # 'nix.perl-bindings' packages.
-      overlays.default = overlayFor (p: p.clangStdenv);
+      overlays.default = overlayFor (p: p.stdenv);
 
       hydraJobs = {
         # Binary package for various platforms.
@@ -269,8 +264,6 @@
             nix = pkgs.callPackage ./package.nix {
               inherit versionSuffix officialRelease buildUnreleasedNotes;
               inherit (pkgs) build-release-notes;
-              # Required since we don't support gcc stdenv
-              stdenv = pkgs.clangStdenv;
               internalApiDocs = true;
               busybox-sandbox-shell = pkgs.busybox-sandbox-shell;
             };
@@ -328,8 +321,6 @@
               inherit (nixpkgs) pkgs;
             in
             pkgs.callPackage ./package.nix {
-              # Required since we don't support gcc stdenv
-              stdenv = pkgs.clangStdenv;
               versionSuffix = "";
               lintInsteadOfBuild = true;
             };

lix-doc/Cargo.lock

@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
 [[package]]
 name = "countme"
 version = "3.0.1"
@@ -10,15 +16,15 @@ checksum = "7704b5fdd17b18ae31c4c1da5a2e0305a2bf17b5249300a9ee9ed7b72114c636"
 
 [[package]]
 name = "dissimilar"
-version = "1.0.9"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59f8e79d1fbf76bdfbde321e902714bf6c49df88a7dda6fc682fc2979226962d"
+checksum = "86e3bdc80eee6e16b2b6b0f87fbc98c04bee3455e35174c0de1a125d0688c632"
 
 [[package]]
 name = "expect-test"
-version = "1.5.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e0be0a561335815e06dab7c62e50353134c796e7a6155402a64bcff66b6a5e0"
+checksum = "30d9eafeadd538e68fb28016364c9732d78e420b9ff8853fa5e4058861e9f8d3"
 dependencies = [
  "dissimilar",
  "once_cell",
@@ -39,6 +45,15 @@ dependencies = [
  "rowan",
 ]
 
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.19.0"
@@ -56,12 +71,13 @@ dependencies = [
 
 [[package]]
 name = "rowan"
-version = "0.15.16"
+version = "0.15.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a542b0253fa46e632d27a1dc5cf7b930de4df8659dc6e720b647fc72147ae3d"
+checksum = "32a58fa8a7ccff2aec4f39cc45bf5f985cec7125ab271cf681c279fd00192b49"
 dependencies = [
  "countme",
  "hashbrown",
+ "memoffset",
  "rustc-hash",
  "text-size",
 ]

lix-doc/Cargo.toml

@@ -8,10 +8,13 @@ license = "BSD-2-Clause OR MIT"
 homepage = "https://github.com/lf-/nix-doc"
 repository = "https://github.com/lf-/nix-doc"
 
+[lib]
+crate_type = ["staticlib"]
+
 [dependencies]
 rnix = "0.11.0"
 # Necessary because rnix fails to export a critical trait (Rowan's AstNode).
-rowan = "0.15.16"
+rowan = "0.15.0"
 
 [dev-dependencies]
 expect-test = "1.1.0"

meson.build

@@ -30,14 +30,6 @@
 # FIXME: This hack should be removed when https://git.lix.systems/lix-project/lix/issues/359
 # is fixed.
 #
-# lix-doc is built with Meson in lix-doc/meson.build, and linked into libcmd in
-# src/libcmd/meson.build. When building outside the Nix sandbox, Meson will use the .wrap
-# files in subprojects/ to download and extract the dependency crates into subprojects/.
-# When building inside the Nix sandbox, Lix's derivation in package.nix uses a
-# fixed-output derivation to fetch those crates in advance instead, and then symlinks
-# them into subprojects/ with the same names that Meson uses when downloading them
-# itself -- perfect for --wrap-mode=nodownload, which mesonConfigurePhase uses.
-#
 # Unit tests are setup in tests/unit/meson.build, under the test suite "check".
 #
 # Functional tests are a bit more complicated. Generally they're defined in
@@ -46,13 +38,12 @@
 # be placed in specific directories' meson.build files to create the right directory tree
 # in the build directory.
 
-project('lix', 'cpp', 'rust',
-  meson_version : '>=1.4.0',
+project('lix', 'cpp',
   version : run_command('bash', '-c', 'echo -n $(jq -r .version < ./version.json)$VERSION_SUFFIX', check : true).stdout().strip(),
   default_options : [
-    'cpp_std=c++23',
-    'rust_std=2021',
-    'warning_level=2',
+    'cpp_std=c++2a',
+    # TODO(Qyriad): increase the warning level
+    'warning_level=1',
     'debug=true',
     'optimization=2',
     'errorlogs=true', # Please print logs for tests that fail
@@ -147,17 +138,6 @@ if should_pch
   # Unlike basically everything else that takes a file, Meson requires the arguments to
   # cpp_pch : to be strings and doesn't accept files(). So absolute path it is.
   cpp_pch = [meson.project_source_root() / 'src/pch/precompiled-headers.hh']
-
-  # Saves about 400s (30% at time of writing) from compile time on-cpu, mostly
-  # by removing instantiations of nlohmann from every single damned compilation
-  # unit.
-  # There is no equivalent in gcc.
-  if cxx.get_id() == 'clang'
-    add_project_arguments(
-      '-fpch-instantiate-templates',
-      language : 'cpp',
-    )
-  endif
 else
   cpp_pch = []
 endif
@@ -167,18 +147,10 @@ endif
 # frees one would expect when the objects are unique_ptrs. these problems
 # often show up as memory corruption when nesting generators (since we do
 # treat generators like owned memory) and will cause inexplicable crashs.
-#
-# gcc 13 does not compile capnp coroutine code correctly. a newer version
-# may fix this. (cf. https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102051)
-# we allow gcc 13 here anyway because CI uses it for clang-tidy, and when
-# the compiler crashes outright if won't produce any bad binaries either.
 assert(
   cxx.get_id() != 'gcc' or cxx.version().version_compare('>=13'),
-  'GCC is known to miscompile coroutines, use clang.'
+  'GCC 12 and earlier are known to miscompile lix coroutines, use GCC 13 or clang.'
 )
-if cxx.get_id() == 'gcc'
-  warning('GCC is known to crash while building coroutines, use clang.')
-endif
 
 
 # Translate some historical and Mesony CPU names to Lixy CPU names.
@@ -237,7 +209,6 @@ configdata += {
 }
 
 boost = dependency('boost', required : true, modules : ['container'], include_type : 'system')
-kj = dependency('kj-async', required : true, include_type : 'system')
 
 # cpuid only makes sense on x86_64
 cpuid_required = is_x64 ? get_option('cpuid') : false
@@ -351,6 +322,13 @@ pegtl = dependency(
 
 nlohmann_json = dependency('nlohmann_json', required : true, include_type : 'system')
 
+# lix-doc is a Rust project provided via buildInputs and unfortunately doesn't have any way to be detected.
+# Just declare it manually to resolve this.
+#
+# FIXME: build this with meson in the future after we drop Make (with which we
+# *absolutely* are not going to make it work)
+lix_doc = declare_dependency(link_args : [ '-llix_doc' ])
+
 if is_freebsd
   libprocstat = declare_dependency(link_args : [ '-lprocstat' ])
 endif
@@ -358,6 +336,7 @@ endif
 #
 # Build-time tools
 #
+coreutils = find_program('coreutils', native : true)
 dot = find_program('dot', required : false, native : true)
 pymod = import('python')
 python = pymod.find_installation('python3')
@@ -483,7 +462,6 @@ add_project_arguments(
   # TODO(Qyriad): Yes this is how the autoconf+Make system did it.
   # It would be nice for our headers to be idempotent instead.
   '-include', 'config.h',
-  '-Wno-unused-parameter',
   '-Wno-deprecated-declarations',
   '-Wimplicit-fallthrough',
   '-Werror=switch',
@@ -492,6 +470,12 @@ add_project_arguments(
   '-Wdeprecated-copy',
   '-Wignored-qualifiers',
   '-Werror=suggest-override',
+  # Enable assertions in libstdc++ by default. Harmless on libc++. Benchmarked
+  # at ~1% overhead in `nix search`.
+  #
+  # FIXME: remove when we get meson 1.4.0 which will default this to on for us:
+  # https://mesonbuild.com/Release-notes-for-1-4-0.html#ndebug-setting-now-controls-c-stdlib-assertions
+  '-D_GLIBCXX_ASSERTIONS=1',
   language : 'cpp',
 )
 
@@ -559,38 +543,11 @@ if cxx.get_id() in ['clang', 'gcc']
   )
 endif
 
-# Until Meson 1.5¹, we can't just give Meson a Cargo.lock file and be done with it.
-# Meson will *detect* what dependencies are needed from Cargo files; it just won't
-# fetch them. The Meson 1.5 feature essentially internally translates Cargo.lock entries
-# to .wrap files, and that translation is incredibly straightforward, so let's just
-# use a simple Python script to generate the .wrap files ourselves while we wait for
-# Meson 1.5. Weirdly, it seems Meson will only detect dependencies from other
-# dependency() calls, so we have to specify lix-doc's two top-level dependencies,
-# rnix and rowan, manually, and then their dependencies will be recursively translated
-# into more dependency() calls.
-#
-# When Meson translates a Cargo dependency, the string passed to `dependency()` follows
-# a fixed format, which is important as the .wrap files' basenames must match the string
-# passed to `dependency()` exactly.
-# In Meson 1.4, this format is `$packageName-rs`. Meson 1.5 changes this to
-# `$packageName-$shortenedVersionString-rs`, because of course it does, but we'll cross
-# that bridge when we get there...
-#
-# [1]: https://github.com/mesonbuild/meson/commit/9b8378985dbdc0112d11893dd42b33b7bc8d1e62
-# FIXME: remove (along with its generated wrap files) when we get rid of meson 1.4
-run_command(
-  python,
-  meson.project_source_root() / 'meson/cargo-lock-to-wraps.py',
-  meson.project_source_root() / 'Cargo.lock',
-  meson.project_source_root() / 'subprojects',
-  check : true,
-)
-
 if is_darwin
-  fs.copyfile(
-    'misc/launchd/org.nixos.nix-daemon.plist.in',
-    'org.nixos.nix-daemon.plist',
-    install : true,
+  configure_file(
+    input : 'misc/launchd/org.nixos.nix-daemon.plist.in',
+    output : 'org.nixos.nix-daemon.plist',
+    copy : true,
     install_dir : prefix / 'Library/LaunchDaemons',
   )
 endif
@@ -606,7 +563,6 @@ endif
 if enable_tests
   subdir('tests/unit')
   subdir('tests/functional')
-  subdir('tests/functional2')
 endif
 
 subdir('meson/clang-tidy')

meson/cargo-lock-to-wraps.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import tomllib
-import sys
-
-DOWNLOAD_URI_FORMAT = 'https://crates.io/api/v1/crates/{crate}/{version}/download'
-
-WRAP_TEMPLATE = """
-[wrap-file]
-method = cargo
-directory = {crate}-{version}
-source_url = {url}
-source_filename = {crate}-{version}.tar.gz
-source_hash = {hash}
-""".lstrip()
-
-parser = argparse.ArgumentParser()
-parser.add_argument('lockfile', help='path to the Cargo lockfile to generate wraps from')
-parser.add_argument('outdir', help="the 'subprojects' directory to write .wrap files to")
-
-args = parser.parse_args()
-
-with open(args.lockfile, 'rb') as f:
-    lock_toml = tomllib.load(f)
-
-for dependency in lock_toml['package']:
-    try:
-        hash = dependency['checksum']
-    except KeyError:
-        # The base package, e.g. lix-doc, won't have a checksum, and conveniently
-        # the base package is also not something we want a wrap file for.
-        # Doesn't that work out nicely?
-        continue
-
-    crate = dependency['name']
-    version = dependency['version']
-
-    url = DOWNLOAD_URI_FORMAT.format(crate=crate, version=version)
-
-    wrap_text = WRAP_TEMPLATE.format(crate=crate, version=version, url=url, hash=hash)
-    with open(f'{args.outdir}/{crate}-rs.wrap', 'w') as f:
-        f.write(wrap_text)

meson/clang-tidy/clang-tidy-runner.py

@@ -1,89 +0,0 @@
-#!/usr/bin/env python3
-"""
-Runs run-clang-tidy. A bit meta. Maybe it will replace run-clang-tidy one day
-because the run-clang-tidy UX is so questionable.
-"""
-
-# I hereby dedicate this script to fuck you meson.
-# I cannot simply write my code to invoke a subprocess in a meson file because
-# Meson corrupts backslashes in command line args to subprocesses.
-# This is allegedly for "Windows support", but last time I checked Windows
-# neither needs nor wants you to corrupt its command lines.
-# https://github.com/mesonbuild/meson/issues/1564
-
-import multiprocessing
-import subprocess
-import os
-import sys
-from pathlib import Path
-
-
-def default_concurrency():
-    return min(multiprocessing.cpu_count(),
-               int(os.environ.get("NIX_BUILD_CORES", "16")))
-
-
-def go(exe: str, plugin_path: Path, compile_commands_json_dir: Path, jobs: int,
-       paths: list[Path], werror: bool, fix: bool):
-    args = [
-        # XXX: This explicitly invokes it with python because of a nixpkgs bug
-        # where clang-unwrapped does not patch interpreters in run-clang-tidy.
-        # However, making clang-unwrapped depend on python is also silly, so idk.
-        sys.executable,
-        exe,
-        '-quiet',
-        '-load',
-        plugin_path,
-        '-p',
-        compile_commands_json_dir,
-        '-j',
-        str(jobs),
-        '-header-filter',
-        r'src/[^/]+/.*\.hh'
-    ]
-    if werror:
-        args += ['-warnings-as-errors', '*']
-    if fix:
-        args += ['-fix']
-    args += ['--']
-    args += paths
-    os.execvp(sys.executable, args)
-
-
-def main():
-    import argparse
-
-    ap = argparse.ArgumentParser(description='Runs run-clang-tidy for you')
-    ap.add_argument('--jobs',
-                    '-j',
-                    type=int,
-                    default=default_concurrency(),
-                    help='Parallel linting jobs to run')
-    ap.add_argument('--plugin-path',
-                    type=Path,
-                    help='Path to the Lix clang-tidy plugin')
-    # FIXME: maybe we should integrate this so it just fixes the compdb for you and throws it in a tempdir?
-    ap.add_argument(
-        '--compdb-path',
-        type=Path,
-        help=
-        'Path to the directory containing the fixed-up compilation database from clean_compdb'
-    )
-    ap.add_argument('--werror',
-                    action='store_true',
-                    help='Warnings get turned into errors')
-    ap.add_argument('--fix',
-                    action='store_true',
-                    help='Apply fixes for warnings')
-    ap.add_argument('--run-clang-tidy-path',
-                    default='run-clang-tidy',
-                    help='Path to run-clang-tidy')
-    ap.add_argument('paths', nargs='*', help='Source paths to check')
-    args = ap.parse_args()
-
-    go(args.run_clang_tidy_path, args.plugin_path, args.compdb_path, args.jobs,
-       args.paths, args.werror, args.fix)
-
-
-if __name__ == '__main__':
-    main()

meson/clang-tidy/clean_compdb.py

@@ -13,8 +13,8 @@ def process_compdb(compdb: list[dict]) -> list[dict]:
         out = []
         eat_next = False
         for i, arg in enumerate(args):
-            if arg in ['-fpch-preprocess', '-fpch-instantiate-templates']:
-                # -fpch-preprocess as used with gcc, -fpch-instantiate-templates as used by clang
+            if arg == '-fpch-preprocess':
+                # as used with gcc
                 continue
             elif arg == '-include-pch' or (arg == '-include' and args[i + 1] == 'precompiled-headers.hh'):
                 # -include-pch some-pch (clang), or -include some-pch (gcc)
@@ -30,14 +30,7 @@ def process_compdb(compdb: list[dict]) -> list[dict]:
         item['command'] = shlex.join(munch_command(shlex.split(item['command'])))
         return item
 
-    def cmdfilter(item: dict) -> bool:
-        file = item['file']
-        return (
-            not file.endswith('precompiled-headers.hh')
-            and not file.endswith('.rs')
-        )
-
-    return [chomp(x) for x in compdb if cmdfilter(x)]
+    return [chomp(x) for x in compdb if not x['file'].endswith('precompiled-headers.hh')]
 
 
 def main():

meson/clang-tidy/meson.build

@@ -58,17 +58,26 @@ build_all_generated_headers = custom_target(
 
 if lix_clang_tidy_so_found
   run_clang_tidy_args = [
-    meson.current_source_dir() / 'clang-tidy-runner.py',
-    '--run-clang-tidy-path', run_clang_tidy,
-    '--compdb-path', meson.current_build_dir(),
-    '--plugin-path', lix_clang_tidy_so,
+    '-load',
+    lix_clang_tidy_so,
+    '-p',
+    # We have to workaround a run-clang-tidy bug too, so we must give the
+    # directory name rather than the actual compdb file.
+    # https://github.com/llvm/llvm-project/issues/101440
+    meson.current_build_dir(),
+    '-quiet',
   ]
   run_target(
     'clang-tidy',
     command : [
+      # XXX: This explicitly invokes it with python because of a nixpkgs bug
+      # where clang-unwrapped does not patch interpreters in run-clang-tidy.
+      # However, making clang-unwrapped depend on python is also silly, so idk.
       python,
+      run_clang_tidy,
       run_clang_tidy_args,
-      '--werror',
+      '-warnings-as-errors',
+      '*',
     ],
     depends : [
       build_all_generated_headers,
@@ -78,8 +87,9 @@ if lix_clang_tidy_so_found
     'clang-tidy-fix',
     command : [
       python,
+      run_clang_tidy,
       run_clang_tidy_args,
-      '--fix',
+      '-fix',
     ],
     depends : [
       build_all_generated_headers,

misc/bash/meson.build

@@ -1,7 +1,8 @@
-fs.copyfile(
-  'completion.sh',
-  'nix',
+configure_file(
+  input : 'completion.sh',
+  output : 'nix',
   install : true,
   install_dir : datadir / 'bash-completion/completions',
   install_mode : 'rw-r--r--',
+  copy : true,
 )

misc/capnproto.nix

@@ -1,60 +0,0 @@
-# FIXME: upstream to nixpkgs (do NOT build with gcc due to gcc coroutine bugs)
-{
-  lib,
-  stdenv,
-  fetchFromGitHub,
-  cmake,
-  openssl,
-  zlib,
-}:
-assert stdenv.cc.isClang;
-stdenv.mkDerivation rec {
-  pname = "capnproto";
-  version = "1.0.2";
-
-  # release tarballs are missing some ekam rules
-  src = fetchFromGitHub {
-    owner = "capnproto";
-    repo = "capnproto";
-    rev = "v${version}";
-    sha256 = "sha256-LVdkqVBTeh8JZ1McdVNtRcnFVwEJRNjt0JV2l7RkuO8=";
-  };
-
-  nativeBuildInputs = [ cmake ];
-  propagatedBuildInputs = [
-    openssl
-    zlib
-  ];
-
-  # FIXME: separate the binaries from the stuff that user systems actually use
-  # This runs into a terrible UX issue in Lix and I just don't want to debug it
-  # right now for the couple MB of closure size:
-  # https://git.lix.systems/lix-project/lix/issues/551
-  # outputs = [ "bin" "dev" "out" ];
-
-  cmakeFlags = [
-    (lib.cmakeBool "BUILD_SHARED_LIBS" true)
-    # Take optimization flags from CXXFLAGS rather than cmake injecting them
-    (lib.cmakeFeature "CMAKE_BUILD_TYPE" "None")
-  ];
-
-  env = {
-    # Required to build the coroutine library
-    CXXFLAGS = "-std=c++20";
-  };
-
-  separateDebugInfo = true;
-
-  meta = with lib; {
-    homepage = "https://capnproto.org/";
-    description = "Cap'n Proto cerealization protocol";
-    longDescription = ''
-      Cap’n Proto is an insanely fast data interchange format and
-      capability-based RPC system. Think JSON, except binary. Or think Protocol
-      Buffers, except faster.
-    '';
-    license = licenses.mit;
-    platforms = platforms.all;
-    maintainers = lib.teams.lix.members;
-  };
-}

misc/fish/completion.fish

@@ -14,7 +14,7 @@ function _nix_complete
   # But the variable also misses the current token so it cancels out.
   set -l nix_arg_to_complete (count $nix_args)
 
-  env NIX_GET_COMPLETIONS=$nix_arg_to_complete $nix_args $current_token 2>/dev/null
+  env NIX_GET_COMPLETIONS=$nix_arg_to_complete $nix_args $current_token
 end
 
 function _nix_accepts_files

misc/fish/meson.build

@@ -1,7 +1,8 @@
-fs.copyfile(
-  'completion.fish',
-  'nix.fish',
+configure_file(
+  input : 'completion.fish',
+  output : 'nix.fish',
   install : true,
   install_dir : datadir / 'fish/vendor_completions.d',
   install_mode : 'rw-r--r--',
+  copy : true,
 )

misc/meson.build

@@ -5,4 +5,8 @@ subdir('zsh')
 subdir('systemd')
 subdir('flake-registry')
 
-runinpty = fs.copyfile('runinpty.py')
+runinpty = configure_file(
+  copy : true,
+  input : meson.current_source_dir() / 'runinpty.py',
+  output : 'runinpty.py',
+)

misc/zsh/meson.build

@@ -1,9 +1,10 @@
 foreach script : [ [ 'completion.zsh', '_nix' ], [ 'run-help-nix' ] ]
-  fs.copyfile(
-    script[0],
-    script.get(1, script[0]),
+  configure_file(
+    input : script[0],
+    output : script.get(1, script[0]),
     install : true,
     install_dir : datadir / 'zsh/site-functions',
     install_mode : 'rw-r--r--',
+    copy : true,
   )
 endforeach

nix-support/editline.patch

@@ -1,106 +0,0 @@
-From d0f2a5bc2300b96b2434c7838184c1dfd6a639f5 Mon Sep 17 00:00:00 2001
-From: Rebecca Turner <rbt@sent.as>
-Date: Sun, 8 Sep 2024 15:42:42 -0700
-Subject: [PATCH 1/2] Recognize Meta+Left and Meta+Right
-
-Recognize `Alt-Left` and `Alt-Right` for navigating by words in more
-terminals/shells/platforms.
-
-I'm not sure exactly where to find canonical documentation for these
-codes, but this seems to match what my terminal produces (macOS + iTerm2
-+ Fish + Tmux).
-
-It might also be nice to have some more support for editing the bindings
-for these characters; sequences of more than one character are not
-supported by `el_bind_key` and similar.
-
-Originally from: https://github.com/troglobit/editline/pull/70
-This patch is applied upstream: https://gerrit.lix.systems/c/lix/+/1883
-
----
- src/editline.c | 29 +++++++++++++++++++++++++++--
- 1 file changed, 27 insertions(+), 2 deletions(-)
-
-diff --git a/src/editline.c b/src/editline.c
-index 5ec9afb..d1cfbbc 100644
---- a/src/editline.c
-+++ b/src/editline.c
-@@ -1034,6 +1034,30 @@ static el_status_t meta(void)
-         return CSeof;
-
- #ifdef CONFIG_ANSI_ARROWS
-+    /* See: https://en.wikipedia.org/wiki/ANSI_escape_code */
-+    /* Recognize ANSI escapes for `Meta+Left` and `Meta+Right`. */
-+    if (c == '\e') {
-+        switch (tty_get()) {
-+        case '[':
-+        {
-+            switch (tty_get()) {
-+            /* \e\e[C = Meta+Left */
-+            case 'C': return fd_word();
-+            /* \e\e[D = Meta+Right */
-+            case 'D': return bk_word();
-+            default:
-+                break;
-+            }
-+
-+            return el_ring_bell();
-+        }
-+        default:
-+            break;
-+        }
-+
-+        return el_ring_bell();
-+    }
-+
-     /* Also include VT-100 arrows. */
-     if (c == '[' || c == 'O') {
-         switch (tty_get()) {
-@@ -1043,6 +1067,7 @@ static el_status_t meta(void)
-             char seq[4] = { 0 };
-             seq[0] = tty_get();
-
-+            /* \e[1~ */
-             if (seq[0] == '~')
-                 return beg_line(); /* Home */
-
-@@ -1050,9 +1075,9 @@ static el_status_t meta(void)
-                 seq[c] = tty_get();
-
-             if (!strncmp(seq, ";5C", 3))
--                return fd_word(); /* Ctrl+Right */
-+                return fd_word(); /* \e[1;5C = Ctrl+Right */
-             if (!strncmp(seq, ";5D", 3))
--                return bk_word(); /* Ctrl+Left */
-+                return bk_word(); /* \e[1;5D = Ctrl+Left */
-
-             break;
-         }
-
-From 4c4455353a0a88bee09d5f27c28f81f747682fed Mon Sep 17 00:00:00 2001
-From: Rebecca Turner <rbt@sent.as>
-Date: Mon, 9 Sep 2024 09:44:44 -0700
-Subject: [PATCH 2/2] Add support for \e[1;3C and \e[1;3D
-
----
- src/editline.c | 6 ++++--
- 1 file changed, 4 insertions(+), 2 deletions(-)
-
-diff --git a/src/editline.c b/src/editline.c
-index d1cfbbc..350b5cb 100644
---- a/src/editline.c
-+++ b/src/editline.c
-@@ -1074,9 +1074,11 @@ static el_status_t meta(void)
-             for (c = 1; c < 3; c++)
-                 seq[c] = tty_get();
-
--            if (!strncmp(seq, ";5C", 3))
-+            if (!strncmp(seq, ";5C", 3)
-+                || !strncmp(seq, ";3C", 3))
-                 return fd_word(); /* \e[1;5C = Ctrl+Right */
--            if (!strncmp(seq, ";5D", 3))
-+            if (!strncmp(seq, ";5D", 3)
-+                || !strncmp(seq, ";3D", 3))
-                 return bk_word(); /* \e[1;5D = Ctrl+Left */
-
-             break;

package.nix

@@ -15,7 +15,6 @@
   brotli,
   bzip2,
   callPackage,
-  capnproto-lix ? __forDefaults.capnproto-lix,
   cmake,
   curl,
   doxygen,
@@ -39,14 +38,11 @@
   mercurial,
   meson,
   ninja,
-  ncurses,
   openssl,
   pegtl,
   pkg-config,
   python3,
   rapidcheck,
-  rustPlatform,
-  rustc,
   sqlite,
   toml11,
   util-linuxMinimal ? utillinuxMinimal,
@@ -55,6 +51,9 @@
 
   busybox-sandbox-shell,
 
+  # internal fork of nix-doc providing :doc in the repl
+  lix-doc ? __forDefaults.lix-doc,
+
   pname ? "lix",
   versionSuffix ? "",
   officialRelease ? __forDefaults.versionJson.official_release,
@@ -83,37 +82,13 @@
     boehmgc-nix = boehmgc.override { enableLargeConfig = true; };
 
     editline-lix = editline.overrideAttrs (prev: {
-      patches = (prev.patches or [ ]) ++ [
-        # Recognize `Alt-Left` and `Alt-Right` for navigating by words in more
-        # terminals/shells/platforms.
-        #
-        # See: https://github.com/troglobit/editline/pull/70
-        ./nix-support/editline.patch
-      ];
-
-      configureFlags = (prev.configureFlags or [ ]) ++ [
-        # Enable SIGSTOP (Ctrl-Z) behavior.
-        (lib.enableFeature true "sigstop")
-        # Enable ANSI arrow keys.
-        (lib.enableFeature true "arrow-keys")
-        # Use termcap library to query terminal size.
-        (lib.enableFeature (ncurses != null) "termcap")
-      ];
-
-      buildInputs = (prev.buildInputs or [ ]) ++ [ ncurses ];
+      configureFlags = prev.configureFlags or [ ] ++ [ (lib.enableFeature true "sigstop") ];
     });
 
+    lix-doc = callPackage ./lix-doc/package.nix { };
     build-release-notes = callPackage ./maintainers/build-release-notes.nix { };
-
-    # needs derivation patching to add debuginfo and coroutine library support
-    # !! must build this with clang as it is affected by the gcc coroutine bugs
-    capnproto-lix = callPackage ./misc/capnproto.nix { inherit stdenv; };
   },
 }:
-
-# gcc miscompiles coroutines at least until 13.2, possibly longer
-assert stdenv.cc.isClang;
-
 let
   inherit (__forDefaults) canRunInstalled;
   inherit (lib) fileset;
@@ -166,13 +141,10 @@ let
     ./meson
     ./scripts/meson.build
     ./subprojects
-    # Required for meson to generate Cargo wraps
-    ./Cargo.lock
   ]);
 
   functionalTestFiles = fileset.unions [
     ./tests/functional
-    ./tests/functional2
     ./tests/unit
     (fileset.fileFilter (f: lib.strings.hasPrefix "nix-profile" f.name) ./scripts)
   ];
@@ -246,13 +218,9 @@ stdenv.mkDerivation (finalAttrs: {
   nativeBuildInputs =
     [
       python3
-      python3.pkgs.pytest
-      python3.pkgs.pytest-xdist
       meson
       ninja
       cmake
-      rustc
-      capnproto-lix
     ]
     ++ [
       (lib.getBin lowdown-unsandboxed)
@@ -274,10 +242,6 @@ stdenv.mkDerivation (finalAttrs: {
     ++ lib.optionals lintInsteadOfBuild [
       # required for a wrapped clang-tidy
       llvmPackages.clang-tools
-      # load-bearing order (just as below); the actual stdenv wrapped clang
-      # needs to precede the unwrapped clang in PATH such that calling `clang`
-      # can compile things.
-      stdenv.cc
       # required for run-clang-tidy
       llvmPackages.clang-unwrapped
     ];
@@ -296,8 +260,8 @@ stdenv.mkDerivation (finalAttrs: {
       lowdown
       libsodium
       toml11
+      lix-doc
       pegtl
-      capnproto-lix
     ]
     ++ lib.optionals hostPlatform.isLinux [
       libseccomp
@@ -326,15 +290,8 @@ stdenv.mkDerivation (finalAttrs: {
   env = {
     BOOST_INCLUDEDIR = "${lib.getDev boost}/include";
     BOOST_LIBRARYDIR = "${lib.getLib boost}/lib";
-
-    # Meson allows referencing a /usr/share/cargo/registry shaped thing for subproject sources.
-    # Turns out the Nix-generated Cargo dependencies are named the same as they
-    # would be in a Cargo registry cache.
-    MESON_PACKAGE_CACHE_DIR = finalAttrs.cargoDeps;
   };
 
-  cargoDeps = rustPlatform.importCargoLock { lockFile = ./Cargo.lock; };
-
   preConfigure =
     lib.optionalString (!finalAttrs.dontBuild && !hostPlatform.isStatic) ''
       # Copy libboost_context so we don't get all of Boost in our closure.
@@ -449,7 +406,6 @@ stdenv.mkDerivation (finalAttrs: {
       editline-lix
       build-release-notes
       pegtl
-      capnproto-lix
       ;
 
     # The collection of dependency logic for this derivation is complicated enough that
@@ -471,10 +427,6 @@ stdenv.mkDerivation (finalAttrs: {
         pre-commit-checks,
         contribNotice,
         check-syscalls,
-
-        # debuggers
-        gdb,
-        rr,
       }:
       let
         glibcFix = lib.optionalAttrs (buildPlatform.isLinux && glibcLocales != null) {
@@ -484,11 +436,6 @@ stdenv.mkDerivation (finalAttrs: {
 
         pythonPackages = (
           p: [
-            # FIXME: these have to be added twice due to the nix shell using a
-            # wrapped python instead of build inputs for its python inputs
-            p.pytest
-            p.pytest-xdist
-
             p.yapf
             p.python-frontmatter
             p.requests
@@ -559,8 +506,6 @@ stdenv.mkDerivation (finalAttrs: {
             ]
             ++ lib.optional (pre-commit-checks ? enabledPackages) pre-commit-checks.enabledPackages
             ++ lib.optional (lib.meta.availableOn buildPlatform clangbuildanalyzer) clangbuildanalyzer
-            ++ lib.optional (!stdenv.isDarwin) gdb
-            ++ lib.optional (lib.meta.availableOn buildPlatform rr) rr
             ++ finalAttrs.checkInputs;
 
           shellHook = ''

scripts/meson.build

@@ -8,7 +8,12 @@ configure_file(
   }
 )
 
-fs.copyfile('nix-profile.sh.in')
+# https://github.com/mesonbuild/meson/issues/860
+configure_file(
+  input : 'nix-profile.sh.in',
+  output : 'nix-profile.sh.in',
+  copy : true,
+)
 
 foreach rc : [ '.sh', '.fish', '-daemon.sh', '-daemon.fish' ]
   configure_file(

src/build-remote/build-remote.cc

@@ -1,7 +1,11 @@
+#include <cstdlib>
+#include <cstring>
 #include <algorithm>
 #include <set>
 #include <memory>
+#include <string_view>
 #include <tuple>
+#include <iomanip>
 #if __APPLE__
 #include <sys/time.h>
 #endif
@@ -14,14 +18,12 @@
 #include "build-result.hh"
 #include "store-api.hh"
 #include "derivations.hh"
-#include "strings.hh"
 #include "local-store.hh"
 #include "legacy.hh"
 #include "experimental-features.hh"
 #include "hash.hh"
-#include "build-remote.hh"
 
-namespace nix {
+using namespace nix;
 
 static void handleAlarm(int sig) {
 }
@@ -389,8 +391,4 @@ connected:
     }
 }
 
-void registerBuildRemote() {
-    LegacyCommands::add("build-remote", main_build_remote);
-}
-
-}
+static RegisterLegacyCommand r_build_remote("build-remote", main_build_remote);

src/legacy/build-remote.hh

@@ -1,8 +0,0 @@
-#pragma once
-/// @file
-
-namespace nix {
-
-void registerBuildRemote();
-
-}

src/legacy/meson.build

@@ -1,35 +0,0 @@
-legacy_include_directories = include_directories('.')
-
-legacy_sources = files(
-  # `build-remote` is not really legacy (it powers all remote builds), but it's
-  # not a `nix3` command.
-  'build-remote.cc',
-  'dotgraph.cc',
-  'graphml.cc',
-  'nix-build.cc',
-  'nix-channel.cc',
-  'nix-collect-garbage.cc',
-  'nix-copy-closure.cc',
-  'nix-env.cc',
-  'nix-env.hh',
-  'nix-instantiate.cc',
-  'nix-store.cc',
-  'user-env.cc',
-)
-
-legacy_headers = files(
-  'build-remote.hh',
-  'nix-build.hh',
-  'nix-channel.hh',
-  'nix-collect-garbage.hh',
-  'nix-copy-closure.hh',
-  'nix-instantiate.hh',
-  'nix-store.hh',
-)
-
-legacy_generated_headers = [
-  gen_header.process('buildenv.nix', preserve_path_from: meson.current_source_dir()),
-  gen_header.process('unpack-channel.nix', preserve_path_from: meson.current_source_dir()),
-]
-
-fs.copyfile('unpack-channel.nix')

src/legacy/nix-build.hh

@@ -1,8 +0,0 @@
-#pragma once
-/// @file
-
-namespace nix {
-
-void registerNixBuildAndNixShell();
-
-}

src/legacy/nix-channel.hh

@@ -1,8 +0,0 @@
-#pragma once
-/// @file
-
-namespace nix {
-
-void registerNixChannel();
-
-}

src/legacy/nix-collect-garbage.hh

@@ -1,8 +0,0 @@
-#pragma once
-/// @file
-
-namespace nix {
-
-void registerNixCollectGarbage();
-
-}

src/legacy/nix-copy-closure.hh

@@ -1,8 +0,0 @@
-#pragma once
-/// @file
-
-namespace nix {
-
-void registerNixCopyClosure();
-
-}

src/legacy/nix-env.hh

@@ -1,8 +0,0 @@
-#pragma once
-/// @file
-
-namespace nix {
-
-void registerNixEnv();
-
-}

src/legacy/nix-instantiate.hh

@@ -1,8 +0,0 @@
-#pragma once
-/// @file
-
-namespace nix {
-
-void registerNixInstantiate();
-
-}

src/legacy/nix-store.hh

@@ -1,8 +0,0 @@
-#pragma once
-/// @file
-
-namespace nix {
-
-void registerNixStore();
-
-}

src/libcmd/built-path.hh

@@ -20,15 +20,13 @@ struct SingleBuiltPathBuilt {
     DECLARE_CMP(SingleBuiltPathBuilt);
 };
 
-namespace built_path::detail {
-using SingleBuiltPathRaw = std::variant<
+using _SingleBuiltPathRaw = std::variant<
     DerivedPathOpaque,
     SingleBuiltPathBuilt
 >;
-}
 
-struct SingleBuiltPath : built_path::detail::SingleBuiltPathRaw {
-    using Raw = built_path::detail::SingleBuiltPathRaw;
+struct SingleBuiltPath : _SingleBuiltPathRaw {
+    using Raw = _SingleBuiltPathRaw;
     using Raw::Raw;
 
     using Opaque = DerivedPathOpaque;
@@ -67,19 +65,17 @@ struct BuiltPathBuilt {
     DECLARE_CMP(BuiltPathBuilt);
 };
 
-namespace built_path::detail {
-using BuiltPathRaw = std::variant<
+using _BuiltPathRaw = std::variant<
     DerivedPath::Opaque,
     BuiltPathBuilt
 >;
-}
 
 /**
  * A built path. Similar to a DerivedPath, but enriched with the corresponding
  * output path(s).
  */
-struct BuiltPath : built_path::detail::BuiltPathRaw {
-    using Raw = built_path::detail::BuiltPathRaw;
+struct BuiltPath : _BuiltPathRaw {
+    using Raw = _BuiltPathRaw;
     using Raw::Raw;
 
     using Opaque = DerivedPathOpaque;

src/libcmd/common-eval-args.cc

@@ -9,24 +9,8 @@
 #include "store-api.hh"
 #include "command.hh"
 
-#include <regex>
-
 namespace nix {
 
-static std::regex const identifierRegex("^[A-Za-z_][A-Za-z0-9_'-]*$");
-static void warnInvalidNixIdentifier(const std::string & name)
-{
-    std::smatch match;
-    if (!std::regex_match(name, match, identifierRegex)) {
-        warn("This Nix invocation specifies a value for argument '%s' which isn't a valid \
-Nix identifier. The project is considering to drop support for this \
-or to require quotes around args that aren't valid Nix identifiers. \
-If you depend on this behvior, please reach out in \
-https://git.lix.systems/lix-project/lix/issues/496 so we can discuss \
-your use-case.", name);
-    }
-}
-
 MixEvalArgs::MixEvalArgs()
 {
     addFlag({
@@ -34,10 +18,7 @@ MixEvalArgs::MixEvalArgs()
         .description = "Pass the value *expr* as the argument *name* to Nix functions.",
         .category = category,
         .labels = {"name", "expr"},
-        .handler = {[&](std::string name, std::string expr) {
-            warnInvalidNixIdentifier(name);
-            autoArgs[name] = 'E' + expr;
-        }}
+        .handler = {[&](std::string name, std::string expr) { autoArgs[name] = 'E' + expr; }}
     });
 
     addFlag({
@@ -45,10 +26,7 @@ MixEvalArgs::MixEvalArgs()
         .description = "Pass the string *string* as the argument *name* to Nix functions.",
         .category = category,
         .labels = {"name", "string"},
-        .handler = {[&](std::string name, std::string s) {
-            warnInvalidNixIdentifier(name);
-            autoArgs[name] = 'S' + s;
-        }},
+        .handler = {[&](std::string name, std::string s) { autoArgs[name] = 'S' + s; }},
     });
 
     addFlag({
@@ -137,7 +115,7 @@ MixEvalArgs::MixEvalArgs()
         .description = "Allow access to mutable paths and repositories.",
         .category = category,
         .handler = {[&]() {
-            evalSettings.pureEval.override(false);
+            evalSettings.pureEval = false;
         }},
     });
 

src/libcmd/editor-for.cc

@@ -1,7 +1,6 @@
 #include "editor-for.hh"
 #include "environment-variables.hh"
 #include "source-path.hh"
-#include "strings.hh"
 
 namespace nix {
 

src/libcmd/installables.cc

@@ -212,7 +212,7 @@ void SourceExprCommand::completeInstallable(AddCompletions & completions, std::s
         if (file) {
             completions.setType(AddCompletions::Type::Attrs);
 
-            evalSettings.pureEval.override(false);
+            evalSettings.pureEval = false;
             auto state = getEvalState();
             Expr & e = state->parseExprFromFile(
                 resolveExprPath(state->checkSourcePath(lookupFileArg(*state, *file)))
@@ -435,7 +435,7 @@ Installables SourceExprCommand::parseInstallables(
             throw UsageError("'--file' and '--expr' are exclusive");
 
         // FIXME: backward compatibility hack
-        if (file) evalSettings.pureEval.override(false);
+        if (file) evalSettings.pureEval = false;
 
         auto state = getEvalState();
         auto vFile = state->allocValue();

src/libcmd/legacy.cc

@@ -2,6 +2,6 @@
 
 namespace nix {
 
-LegacyCommands::Commands * LegacyCommands::commands = 0;
+RegisterLegacyCommand::Commands * RegisterLegacyCommand::commands = 0;
 
 }

src/libcmd/legacy.hh

@@ -9,12 +9,12 @@ namespace nix {
 
 typedef std::function<void(int, char * *)> MainFunction;
 
-struct LegacyCommands
+struct RegisterLegacyCommand
 {
     typedef std::map<std::string, MainFunction> Commands;
     static Commands * commands;
 
-    static void add(const std::string & name, MainFunction fun)
+    RegisterLegacyCommand(const std::string & name, MainFunction fun)
     {
         if (!commands) commands = new Commands;
         (*commands)[name] = fun;

src/libcmd/meson.build

@@ -50,7 +50,7 @@ libcmd = library(
     editline,
     lowdown,
     nlohmann_json,
-    liblix_doc,
+    lix_doc
   ],
   cpp_pch : cpp_pch,
   install : true,

src/libcmd/repl-interacter.cc

@@ -8,6 +8,10 @@
 #include <string_view>
 #include <cerrno>
 
+#ifdef READLINE
+#include <readline/history.h>
+#include <readline/readline.h>
+#else
 // editline < 1.15.2 don't wrap their API for C++ usage
 // (added in https://github.com/troglobit/editline/commit/91398ceb3427b730995357e9d120539fb9bb7461).
 // This results in linker errors due to to name-mangling of editline C symbols.
@@ -16,6 +20,7 @@
 extern "C" {
 #include <editline.h>
 }
+#endif
 
 #include "finally.hh"
 #include "repl-interacter.hh"
@@ -110,13 +115,17 @@ ReadlineLikeInteracter::Guard ReadlineLikeInteracter::init(detail::ReplCompleter
     } catch (SysError & e) {
         logWarning(e.info());
     }
+#ifndef READLINE
     el_hist_size = 1000;
+#endif
     read_history(historyFile.c_str());
     auto oldRepl = curRepl;
     curRepl = repl;
     Guard restoreRepl([oldRepl] { curRepl = oldRepl; });
+#ifndef READLINE
     rl_set_complete_func(completionCallback);
     rl_set_list_possib_func(listPossibleCallback);
+#endif
     return restoreRepl;
 }
 

src/libcmd/repl.cc

@@ -817,10 +817,10 @@ ProcessLineResult NixRepl::processLine(std::string line)
     else if (command == ":te" || command == ":trace-enable") {
         if (arg == "false" || (arg == "" && loggerSettings.showTrace)) {
             std::cout << "not showing error traces\n";
-            loggerSettings.showTrace.override(false);
+            loggerSettings.showTrace = false;
         } else if (arg == "true" || (arg == "" && !loggerSettings.showTrace)) {
             std::cout << "showing error traces\n";
-            loggerSettings.showTrace.override(true);
+            loggerSettings.showTrace = true;
         } else {
             throw Error("unexpected argument '%s' to %s", arg, command);
         };
@@ -926,7 +926,7 @@ void NixRepl::loadFiles()
 
 void NixRepl::loadReplOverlays()
 {
-    if (evalSettings.replOverlays.get().empty()) {
+    if (!evalSettings.replOverlays) {
         return;
     }
 

src/libexpr/eval-cache.cc

@@ -79,7 +79,7 @@ struct AttrDb
                 state->txn->commit();
             state->txn.reset();
         } catch (...) {
-            ignoreExceptionInDestructor();
+            ignoreException();
         }
     }
 
@@ -90,7 +90,7 @@ struct AttrDb
         try {
             return fun();
         } catch (SQLiteError &) {
-            ignoreExceptionExceptInterrupt();
+            ignoreException();
             failed = true;
             return 0;
         }
@@ -329,7 +329,7 @@ static std::shared_ptr<AttrDb> makeAttrDb(
     try {
         return std::make_shared<AttrDb>(cfg, fingerprint, symbols);
     } catch (SQLiteError &) {
-        ignoreExceptionExceptInterrupt();
+        ignoreException();
         return nullptr;
     }
 }

src/libexpr/eval-error.hh

@@ -1,8 +1,9 @@
 #pragma once
 ///@file
 
+#include <algorithm>
+
 #include "error.hh"
-#include "types.hh"
 #include "pos-idx.hh"
 
 namespace nix {

src/libexpr/eval-inline.hh

@@ -31,7 +31,7 @@ Value * EvalState::allocValue()
 #endif
 
     nrValues++;
-    return static_cast<Value *>(p);
+    return (Value *) p;
 }
 
 
@@ -54,10 +54,10 @@ Env & EvalState::allocEnv(size_t size)
         void * p = *env1AllocCache;
         *env1AllocCache = GC_NEXT(p);
         GC_NEXT(p) = nullptr;
-        env = static_cast<Env *>(p);
+        env = (Env *) p;
     } else
 #endif
-        env = static_cast<Env *>(gcAllocBytes(sizeof(Env) + size * sizeof(Value *)));
+        env = (Env *) gcAllocBytes(sizeof(Env) + size * sizeof(Value *));
 
     /* We assume that env->values has been cleared by the allocator; maybeThunk() and lookupVar fromWith expect this. */
 

src/libexpr/eval-settings.cc

@@ -47,7 +47,7 @@ static Strings parseNixPath(const std::string & s)
 EvalSettings::EvalSettings()
 {
     auto var = getEnv("NIX_PATH");
-    if (var) nixPath.setDefault(parseNixPath(*var));
+    if (var) nixPath = parseNixPath(*var);
 }
 
 Strings EvalSettings::getDefaultNixPath()

src/libexpr/eval-settings.hh

@@ -151,7 +151,7 @@ struct EvalSettings : Config
           This is useful for debugging warnings in third-party Nix code.
         )"};
 
-    PathsSetting<Paths> replOverlays{this, Paths(), "repl-overlays",
+    PathsSetting replOverlays{this, Paths(), "repl-overlays",
         R"(
           A list of files containing Nix expressions that can be used to add
           default bindings to [`nix
@@ -185,54 +185,6 @@ struct EvalSettings : Config
           else
           { }
           ```
-
-          Here's a more elaborate `repl-overlay`, which provides the following
-          variables:
-          - The original, unmodified variables are aliased to `original`.
-          - `legacyPackages.${system}` (if it exists) or `packages.${system}`
-            (otherwise) is aliased to `pkgs`.
-          - All attribute set variables with a `${system}` attribute are
-            abbreviated in the same manner; e.g. `devShells.${system}` is
-            shortened to `devShells`.
-
-          For example, the following attribute set:
-
-          ```nix
-          info: final: attrs: let
-            # Equivalent to nixpkgs `lib.optionalAttrs`.
-            optionalAttrs = predicate: attrs:
-              if predicate
-              then attrs
-              else {};
-
-            # If `attrs.${oldName}.${info.currentSystem}` exists, alias `${newName}` to
-            # it.
-            collapseRenamed = oldName: newName:
-              optionalAttrs (builtins.hasAttr oldName attrs
-                && builtins.hasAttr info.currentSystem attrs.${oldName})
-              {
-                ${newName} = attrs.${oldName}.${info.currentSystem};
-              };
-
-            # Alias `attrs.${oldName}.${info.currentSystem} to `${newName}`.
-            collapse = name: collapseRenamed name name;
-
-            # Alias all `attrs` keys with an `${info.currentSystem}` attribute.
-            collapseAll =
-              builtins.foldl'
-              (prev: name: prev // collapse name)
-              {}
-              (builtins.attrNames attrs);
-          in
-            # Preserve the original bindings as `original`.
-            (optionalAttrs (! attrs ? original)
-              {
-                original = attrs;
-              })
-            // (collapseRenamed "packages" "pkgs")
-            // (collapseRenamed "legacyPackages" "pkgs")
-            // collapseAll
-          ```
         )"};
 };
 

src/libexpr/eval.cc

@@ -19,7 +19,6 @@
 #include "gc-small-vector.hh"
 #include "fetch-to-store.hh"
 #include "flake/flakeref.hh"
-#include "exit.hh"
 
 #include <algorithm>
 #include <iostream>
@@ -250,7 +249,6 @@ EvalState::EvalState(
         .findFile = symbols.create("__findFile"),
         .nixPath = symbols.create("__nixPath"),
         .body = symbols.create("body"),
-        .overrides = symbols.create("__overrides"),
     }
     , repair(NoRepair)
     , emptyBindings(0)
@@ -2712,29 +2710,20 @@ Expr & EvalState::parseExprFromFile(const SourcePath & path, std::shared_ptr<Sta
 }
 
 
-Expr & EvalState::parseExprFromString(
-    std::string s_,
-    const SourcePath & basePath,
-    std::shared_ptr<StaticEnv> & staticEnv,
-    const FeatureSettings & featureSettings
-)
+Expr & EvalState::parseExprFromString(std::string s_, const SourcePath & basePath, std::shared_ptr<StaticEnv> & staticEnv, const ExperimentalFeatureSettings & xpSettings)
 {
     // NOTE this method (and parseStdin) must take care to *fully copy* their input
     // into their respective Pos::Origin until the parser stops overwriting its input
     // data.
     auto s = make_ref<std::string>(s_);
     s_.append("\0\0", 2);
-    return *parse(s_.data(), s_.size(), Pos::String{.source = s}, basePath, staticEnv, featureSettings);
+    return *parse(s_.data(), s_.size(), Pos::String{.source = s}, basePath, staticEnv, xpSettings);
 }
 
 
-Expr & EvalState::parseExprFromString(
-    std::string s,
-    const SourcePath & basePath,
-    const FeatureSettings & featureSettings
-)
+Expr & EvalState::parseExprFromString(std::string s, const SourcePath & basePath, const ExperimentalFeatureSettings & xpSettings)
 {
-    return parseExprFromString(std::move(s), basePath, staticBaseEnv, featureSettings);
+    return parseExprFromString(std::move(s), basePath, staticBaseEnv, xpSettings);
 }
 
 

src/libexpr/eval.hh

@@ -12,7 +12,6 @@
 #include "experimental-features.hh"
 #include "search-path.hh"
 #include "repl-exit-status.hh"
-#include "backed-string-view.hh"
 
 #include <map>
 #include <optional>
@@ -345,17 +344,8 @@ public:
     /**
      * Parse a Nix expression from the specified string.
      */
-    Expr & parseExprFromString(
-        std::string s,
-        const SourcePath & basePath,
-        std::shared_ptr<StaticEnv> & staticEnv,
-        const FeatureSettings & xpSettings = featureSettings
-    );
-    Expr & parseExprFromString(
-        std::string s,
-        const SourcePath & basePath,
-        const FeatureSettings & xpSettings = featureSettings
-    );
+    Expr & parseExprFromString(std::string s, const SourcePath & basePath, std::shared_ptr<StaticEnv> & staticEnv, const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
+    Expr & parseExprFromString(std::string s, const SourcePath & basePath, const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
 
     Expr & parseStdin();
 
@@ -579,7 +569,7 @@ private:
         Pos::Origin origin,
         const SourcePath & basePath,
         std::shared_ptr<StaticEnv> & staticEnv,
-        const FeatureSettings & xpSettings = featureSettings);
+        const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
 
     /**
      * Current Nix call stack depth, used with `max-call-depth` setting to throw stack overflow hopefully before we run out of system stack.
@@ -792,4 +782,4 @@ static constexpr std::string_view corepkgsPrefix{"/__corepkgs__/"};
 
 }
 
-#include "eval-inline.hh" // IWYU pragma: keep
+#include "eval-inline.hh"

src/libexpr/flake/flake.cc

@@ -342,21 +342,8 @@ static void updateOverrides(std::map<InputPath, FlakeInput> & overrideMap, const
     for (auto & [id, input] : overrides) {
         auto inputPath(inputPathPrefix);
         inputPath.push_back(id);
-
-        /* Given
-         *
-         * { inputs.hydra.inputs.nix-eval-jobs.inputs.lix.follows = "lix"; }
-         *
-         * then `nix-eval-jobs` doesn't have an override.
-         * It's neither replaced using follows nor by a different
-         * URL. Thus no need to add it to overrides and thus re-fetch
-         * it.
-         */
-        if (input.ref || input.follows) {
         // Do not override existing assignment from outer flake
         overrideMap.insert({inputPath, input});
-        }
-
         updateOverrides(overrideMap, input.overrides, inputPath);
     }
 }

src/libexpr/gc-alloc.hh

@@ -120,7 +120,6 @@ inline T * gcAllocType(size_t howMany = 1)
     // However, people can and do request zero sized allocations, so we need
     // to check that neither of our multiplicands were zero before complaining
     // about it.
-    // NOLINTNEXTLINE(bugprone-sizeof-expression): yeah we only seem to alloc pointers with this. the calculation *is* correct though!
     auto checkedSz = checked::Checked<size_t>(howMany) * sizeof(T);
     size_t sz = checkedSz.valueWrapping();
     if (checkedSz.overflowed()) {

src/libexpr/nixexpr.cc

@@ -11,7 +11,6 @@
 namespace nix {
 
 ExprBlackHole eBlackHole;
-Expr *eBlackHoleAddr = &eBlackHole;
 
 // FIXME: remove, because *symbols* are abstract and do not have a single
 //        textual representation; see printIdentifier()
@@ -21,14 +20,6 @@ std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
     return printIdentifier(str, s);
 }
 
-AttrName::AttrName(Symbol s) : symbol(s)
-{
-}
-
-AttrName::AttrName(std::unique_ptr<Expr> e) : expr(std::move(e))
-{
-}
-
 void Expr::show(const SymbolTable & symbols, std::ostream & str) const
 {
     abort();
@@ -247,24 +238,9 @@ void ExprConcatStrings::show(const SymbolTable & symbols, std::ostream & str) co
 {
     bool first = true;
     str << "(";
-    for (auto & [_pos, part] : es) {
-        if (first)
-            first = false;
-        else
-            str << " + ";
-
-        if (forceString && !dynamic_cast<ExprString *>(part.get())) {
-            /* Print as a string with an interpolation, to preserve the
-             * semantics of the value having to be a string.
-             * Interpolations are weird and someone should eventually
-             * move them out into their own AST node please.
-             */
-            str << "\"${";
-            part->show(symbols, str);
-            str << "}\"";
-        } else {
-            part->show(symbols, str);
-        }
+    for (auto & i : es) {
+        if (first) first = false; else str << " + ";
+        i.second->show(symbols, str);
     }
     str << ")";
 }

src/libexpr/nixexpr.hh

@@ -11,7 +11,6 @@
 #include "eval-error.hh"
 #include "pos-idx.hh"
 #include "pos-table.hh"
-#include "strings.hh"
 
 namespace nix {
 
@@ -30,8 +29,8 @@ struct AttrName
 {
     Symbol symbol;
     std::unique_ptr<Expr> expr;
-    AttrName(Symbol s);
-    AttrName(std::unique_ptr<Expr> e);
+    AttrName(Symbol s) : symbol(s) {};
+    AttrName(std::unique_ptr<Expr> e) : expr(std::move(e)) {};
 };
 
 typedef std::vector<AttrName> AttrPath;
@@ -49,7 +48,7 @@ protected:
 
 public:
     struct AstSymbols {
-        Symbol sub, lessThan, mul, div, or_, findFile, nixPath, body, overrides;
+        Symbol sub, lessThan, mul, div, or_, findFile, nixPath, body;
     };
 
 

src/libexpr/parser/grammar.hh

@@ -12,7 +12,7 @@
 // eolf rules in favor of reproducing the old flex lexer as faithfully as
 // possible, and deferring calculation of positions to downstream users.
 
-namespace nix::parser::grammar::v1 {
+namespace nix::parser::grammar {
 
 using namespace tao::pegtl;
 namespace p = tao::pegtl;
@@ -225,8 +225,7 @@ struct string : _string, seq<
 > {};
 
 struct _ind_string {
-    struct line_start : semantic, star<one<' '>> {};
-    template<typename... Inner>
+    template<bool Indented, typename... Inner>
     struct literal : semantic, seq<Inner...> {};
     struct interpolation : semantic, seq<
         p::string<'$', '{'>, seps,
@@ -234,53 +233,34 @@ struct _ind_string {
         must<one<'}'>>
     > {};
     struct escape : semantic, must<any> {};
-    /* Marker for non-empty lines */
-    struct has_content : semantic, seq<> {};
 };
 struct ind_string : _ind_string, seq<
     TAO_PEGTL_STRING("''"),
-    // Strip first line completely if empty
     opt<star<one<' '>>, one<'\n'>>,
-    list<
-        seq<
-            // Start a line with some indentation
-            // (we always match even the empty string if no indentation, as this creates the line)
-            _ind_string::line_start,
-            // The actual line
-            opt<
-                plus<
+    star<
         sor<
             _ind_string::literal<
+                true,
                 plus<
                     sor<
-                                    not_one<'$', '\'', '\n'>,
-                                    // TODO probably factor this out like the others for performance
-                                    seq<one<'$'>, not_one<'{', '\'', '\n'>>,
-                                    seq<one<'$'>, at<one<'\n'>>>,
-                                    seq<one<'\''>, not_one<'\'', '$', '\n'>>,
-                                    seq<one<'\''>, at<one<'\n'>>>
+                        not_one<'$', '\''>,
+                        seq<one<'$'>, not_one<'{', '\''>>,
+                        seq<one<'\''>, not_one<'\'', '$'>>
                     >
                 >
             >,
             _ind_string::interpolation,
-                        _ind_string::literal<one<'$'>>,
-                        _ind_string::literal<one<'\''>, not_at<one<'\''>>>,
-                        seq<one<'\''>, _ind_string::literal<p::string<'\'', '\''>>>,
+            _ind_string::literal<false, one<'$'>>,
+            _ind_string::literal<false, one<'\''>, not_at<one<'\''>>>,
+            seq<one<'\''>, _ind_string::literal<false, p::string<'\'', '\''>>>,
             seq<
                 p::string<'\'', '\''>,
                 sor<
-                                _ind_string::literal<one<'$'>>,
+                    _ind_string::literal<false, one<'$'>>,
                     seq<one<'\\'>, _ind_string::escape>
                 >
             >
-                    >,
-                    _ind_string::has_content
         >
-            >
-        >,
-        // End of line, LF. CR is just ignored and not treated as ending a line
-        // (for the purpose of indentation stripping)
-        _ind_string::literal<one<'\n'>>
     >,
     must<TAO_PEGTL_STRING("''")>
 > {};
@@ -372,10 +352,10 @@ struct formals : semantic, _formals, seq<
 
 struct _attr {
     struct simple : semantic, sor<t::identifier, t::kw_or> {};
-    struct string : semantic, seq<grammar::v1::string> {};
+    struct string : semantic, seq<grammar::string> {};
     struct expr : semantic, seq<
         TAO_PEGTL_STRING("${"), seps,
-        must<grammar::v1::expr>, seps,
+        must<grammar::expr>, seps,
         must<one<'}'>>
     > {};
 };
@@ -472,9 +452,9 @@ struct _expr {
     struct id : semantic, t::identifier {};
     struct int_ : semantic, t::integer {};
     struct float_ : semantic, t::floating {};
-    struct string : semantic, seq<grammar::v1::string> {};
-    struct ind_string : semantic, seq<grammar::v1::ind_string> {};
-    struct path : semantic, seq<grammar::v1::path> {};
+    struct string : semantic, seq<grammar::string> {};
+    struct ind_string : semantic, seq<grammar::ind_string> {};
+    struct path : semantic, seq<grammar::path> {};
     struct uri : semantic, t::uri {};
     struct ancient_let : semantic, _attrset<must, t::kw_let, seps> {};
     struct rec_set : semantic, _attrset<must, t::kw_rec, seps> {};
@@ -648,34 +628,34 @@ struct nothing : p::nothing<Rule> {
 
 template<typename Self, typename OpCtx, typename AttrPathT, typename ExprT>
 struct operator_semantics {
-    struct has_attr : grammar::v1::op::has_attr {
+    struct has_attr : grammar::op::has_attr {
         AttrPathT path;
     };
 
     struct OpEntry {
         OpCtx ctx;
         uint8_t prec;
-        grammar::v1::op::kind assoc;
+        grammar::op::kind assoc;
         std::variant<
-            grammar::v1::op::not_,
-            grammar::v1::op::unary_minus,
-            grammar::v1::op::implies,
-            grammar::v1::op::or_,
-            grammar::v1::op::and_,
-            grammar::v1::op::equals,
-            grammar::v1::op::not_equals,
-            grammar::v1::op::less_eq,
-            grammar::v1::op::greater_eq,
-            grammar::v1::op::update,
-            grammar::v1::op::concat,
-            grammar::v1::op::less,
-            grammar::v1::op::greater,
-            grammar::v1::op::plus,
-            grammar::v1::op::minus,
-            grammar::v1::op::mul,
-            grammar::v1::op::div,
-            grammar::v1::op::pipe_right,
-            grammar::v1::op::pipe_left,
+            grammar::op::not_,
+            grammar::op::unary_minus,
+            grammar::op::implies,
+            grammar::op::or_,
+            grammar::op::and_,
+            grammar::op::equals,
+            grammar::op::not_equals,
+            grammar::op::less_eq,
+            grammar::op::greater_eq,
+            grammar::op::update,
+            grammar::op::concat,
+            grammar::op::less,
+            grammar::op::greater,
+            grammar::op::plus,
+            grammar::op::minus,
+            grammar::op::mul,
+            grammar::op::div,
+            grammar::op::pipe_right,
+            grammar::op::pipe_left,
             has_attr
         > op;
     };
@@ -696,7 +676,7 @@ struct operator_semantics {
             auto & [ctx, precedence, kind, op] = ops.back();
             // NOTE this relies on associativity not being mixed within a precedence level.
             if ((precedence > toPrecedence)
-                || (kind != grammar::v1::op::kind::leftAssoc && precedence == toPrecedence))
+                || (kind != grammar::op::kind::leftAssoc && precedence == toPrecedence))
                 break;
             std::visit([&, ctx=std::move(ctx)] (auto & op) {
                 exprs.push_back(static_cast<Self &>(*this).applyOp(ctx, op, args...));
@@ -714,9 +694,9 @@ struct operator_semantics {
 
     void pushOp(OpCtx ctx, auto o, auto &... args)
     {
-        if (o.kind != grammar::v1::op::kind::unary)
+        if (o.kind != grammar::op::kind::unary)
             reduce(o.precedence, args...);
-        if (!ops.empty() && o.kind == grammar::v1::op::kind::nonAssoc) {
+        if (!ops.empty() && o.kind == grammar::op::kind::nonAssoc) {
             auto & [_pos, _prec, _kind, _o] = ops.back();
             if (_kind == o.kind && _prec == o.precedence)
                 Self::badOperator(ctx, args...);

src/libexpr/parser/parser-impl1.inc.cc

@@ -1,863 +0,0 @@
-// flip this define when doing parser development to enable some g checks.
-#if 0
-#include <tao/pegtl/contrib/analyze.hpp>
-#define ANALYZE_GRAMMAR \
-    ([] { \
-        const std::size_t issues = tao::pegtl::analyze<grammar::v1::root>(); \
-        assert(issues == 0); \
-    })()
-#else
-#define ANALYZE_GRAMMAR ((void) 0)
-#endif
-
-namespace p = tao::pegtl;
-
-namespace nix::parser::v1 {
-namespace {
-
-template<typename>
-inline constexpr const char * error_message = nullptr;
-
-#define error_message_for(...) \
-    template<> inline constexpr auto error_message<__VA_ARGS__>
-
-error_message_for(p::one<'{'>) = "expecting '{'";
-error_message_for(p::one<'}'>) = "expecting '}'";
-error_message_for(p::one<'"'>) = "expecting '\"'";
-error_message_for(p::one<';'>) = "expecting ';'";
-error_message_for(p::one<')'>) = "expecting ')'";
-error_message_for(p::one<']'>) = "expecting ']'";
-error_message_for(p::one<':'>) = "expecting ':'";
-error_message_for(p::string<'\'', '\''>) = "expecting \"''\"";
-error_message_for(p::any) = "expecting any character";
-error_message_for(grammar::v1::eof) = "expecting end of file";
-error_message_for(grammar::v1::seps) = "expecting separators";
-error_message_for(grammar::v1::path::forbid_prefix_triple_slash) = "too many slashes in path";
-error_message_for(grammar::v1::path::forbid_prefix_double_slash_no_interp) = "path has a trailing slash";
-error_message_for(grammar::v1::expr) = "expecting expression";
-error_message_for(grammar::v1::expr::unary) = "expecting expression";
-error_message_for(grammar::v1::binding::equal) = "expecting '='";
-error_message_for(grammar::v1::expr::lambda::arg) = "expecting identifier";
-error_message_for(grammar::v1::formals) = "expecting formals";
-error_message_for(grammar::v1::attrpath) = "expecting attribute path";
-error_message_for(grammar::v1::expr::select) = "expecting selection expression";
-error_message_for(grammar::v1::t::kw_then) = "expecting 'then'";
-error_message_for(grammar::v1::t::kw_else) = "expecting 'else'";
-error_message_for(grammar::v1::t::kw_in) = "expecting 'in'";
-
-struct SyntaxErrors
-{
-    template<typename Rule>
-    static constexpr auto message = error_message<Rule>;
-
-    template<typename Rule>
-    static constexpr bool raise_on_failure = false;
-};
-
-template<typename Rule>
-struct Control : p::must_if<SyntaxErrors>::control<Rule>
-{
-    template<typename ParseInput, typename... States>
-    [[noreturn]] static void raise(const ParseInput & in, States &&... st)
-    {
-        if (in.empty()) {
-            std::string expected;
-            if constexpr (constexpr auto msg = error_message<Rule>)
-                expected = fmt(", %s", msg);
-            throw p::parse_error("unexpected end of file" + expected, in);
-        }
-        p::must_if<SyntaxErrors>::control<Rule>::raise(in, st...);
-    }
-};
-
-struct ExprState
-    : grammar::v1::
-          operator_semantics<ExprState, PosIdx, AttrPath, std::pair<PosIdx, std::unique_ptr<Expr>>>
-{
-    std::unique_ptr<Expr> popExprOnly() {
-        return std::move(popExpr().second);
-    }
-
-    template<typename Op, typename... Args>
-    std::unique_ptr<Expr> applyUnary(Args &&... args) {
-        return std::make_unique<Op>(popExprOnly(), std::forward<Args>(args)...);
-    }
-
-    template<typename Op>
-    std::unique_ptr<Expr> applyBinary(PosIdx pos) {
-        auto right = popExprOnly(), left = popExprOnly();
-        return std::make_unique<Op>(pos, std::move(left), std::move(right));
-    }
-
-    std::unique_ptr<Expr> call(PosIdx pos, Symbol fn, bool flip = false)
-    {
-        std::vector<std::unique_ptr<Expr>> args(2);
-        args[flip ? 0 : 1] = popExprOnly();
-        args[flip ? 1 : 0] = popExprOnly();
-        return std::make_unique<ExprCall>(pos, std::make_unique<ExprVar>(fn), std::move(args));
-    }
-
-    std::unique_ptr<Expr> pipe(PosIdx pos, State & state, bool flip = false)
-    {
-        if (!state.featureSettings.isEnabled(Xp::PipeOperator))
-            throw ParseError({
-                .msg = HintFmt("Pipe operator is disabled"),
-                .pos = state.positions[pos]
-            });
-
-        // Reverse the order compared to normal function application: arg |> fn
-        std::unique_ptr<Expr> fn, arg;
-        if (flip) {
-            fn = popExprOnly();
-            arg = popExprOnly();
-        } else {
-            arg = popExprOnly();
-            fn = popExprOnly();
-        }
-        std::vector<std::unique_ptr<Expr>> args{1};
-        args[0] = std::move(arg);
-
-        return std::make_unique<ExprCall>(pos, std::move(fn), std::move(args));
-    }
-
-    std::unique_ptr<Expr> order(PosIdx pos, bool less, State & state)
-    {
-        return call(pos, state.s.lessThan, !less);
-    }
-
-    std::unique_ptr<Expr> concatStrings(PosIdx pos)
-    {
-        std::vector<std::pair<PosIdx, std::unique_ptr<Expr>>> args(2);
-        args[1] = popExpr();
-        args[0] = popExpr();
-        return std::make_unique<ExprConcatStrings>(pos, false, std::move(args));
-    }
-
-    std::unique_ptr<Expr> negate(PosIdx pos, State & state)
-    {
-        std::vector<std::unique_ptr<Expr>> args(2);
-        args[0] = std::make_unique<ExprInt>(0);
-        args[1] = popExprOnly();
-        return std::make_unique<ExprCall>(pos, std::make_unique<ExprVar>(state.s.sub), std::move(args));
-    }
-
-    std::pair<PosIdx, std::unique_ptr<Expr>> applyOp(PosIdx pos, auto & op, State & state) {
-        using Op = grammar::v1::op;
-
-        auto not_ = [] (auto e) {
-            return std::make_unique<ExprOpNot>(std::move(e));
-        };
-
-        return {
-            pos,
-            (overloaded {
-                [&] (Op::implies)     { return applyBinary<ExprOpImpl>(pos); },
-                [&] (Op::or_)         { return applyBinary<ExprOpOr>(pos); },
-                [&] (Op::and_)        { return applyBinary<ExprOpAnd>(pos); },
-                [&] (Op::equals)      { return applyBinary<ExprOpEq>(pos); },
-                [&] (Op::not_equals)  { return applyBinary<ExprOpNEq>(pos); },
-                [&] (Op::less)        { return order(pos, true, state); },
-                [&] (Op::greater_eq)  { return not_(order(pos, true, state)); },
-                [&] (Op::greater)     { return order(pos, false, state); },
-                [&] (Op::less_eq)     { return not_(order(pos, false, state)); },
-                [&] (Op::update)      { return applyBinary<ExprOpUpdate>(pos); },
-                [&] (Op::not_)        { return applyUnary<ExprOpNot>(); },
-                [&] (Op::plus)        { return concatStrings(pos); },
-                [&] (Op::minus)       { return call(pos, state.s.sub); },
-                [&] (Op::mul)         { return call(pos, state.s.mul); },
-                [&] (Op::div)         { return call(pos, state.s.div); },
-                [&] (Op::concat)      { return applyBinary<ExprOpConcatLists>(pos); },
-                [&] (has_attr & a)    { return applyUnary<ExprOpHasAttr>(std::move(a.path)); },
-                [&] (Op::unary_minus) { return negate(pos, state); },
-                [&] (Op::pipe_right)  { return pipe(pos, state, true); },
-                [&] (Op::pipe_left)   { return pipe(pos, state); },
-            })(op)
-        };
-    }
-
-    // always_inline is needed, otherwise pushOp slows down considerably
-    [[noreturn, gnu::always_inline]]
-    static void badOperator(PosIdx pos, State & state)
-    {
-        throw ParseError({
-            .msg = HintFmt("syntax error, unexpected operator"),
-            .pos = state.positions[pos]
-        });
-    }
-
-    template<typename Expr, typename... Args>
-    Expr & pushExpr(PosIdx pos, Args && ... args)
-    {
-        auto p = std::make_unique<Expr>(std::forward<Args>(args)...);
-        auto & result = *p;
-        exprs.emplace_back(pos, std::move(p));
-        return result;
-    }
-};
-
-struct SubexprState {
-private:
-    ExprState * up;
-
-public:
-    explicit SubexprState(ExprState & up, auto &...) : up(&up) {}
-    operator ExprState &() { return *up; }
-    ExprState * operator->() { return up; }
-};
-
-
-
-template<typename Rule>
-struct BuildAST : grammar::v1::nothing<Rule> {};
-
-struct LambdaState : SubexprState {
-    using SubexprState::SubexprState;
-
-    Symbol arg;
-    std::unique_ptr<Formals> formals;
-};
-
-struct FormalsState : SubexprState {
-    using SubexprState::SubexprState;
-
-    Formals formals{};
-    Formal formal{};
-};
-
-template<> struct BuildAST<grammar::v1::formal::name> {
-    static void apply(const auto & in, FormalsState & s, State & ps) {
-        s.formal = {
-            .pos = ps.at(in),
-            .name = ps.symbols.create(in.string_view()),
-        };
-    }
-};
-
-template<> struct BuildAST<grammar::v1::formal> {
-    static void apply0(FormalsState & s, State &) {
-        s.formals.formals.emplace_back(std::move(s.formal));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::formal::default_value> {
-    static void apply0(FormalsState & s, State & ps) {
-        s.formal.def = s->popExprOnly();
-    }
-};
-
-template<> struct BuildAST<grammar::v1::formals::ellipsis> {
-    static void apply0(FormalsState & s, State &) {
-        s.formals.ellipsis = true;
-    }
-};
-
-template<> struct BuildAST<grammar::v1::formals> : change_head<FormalsState> {
-    static void success0(FormalsState & f, LambdaState & s, State &) {
-        s.formals = std::make_unique<Formals>(std::move(f.formals));
-    }
-};
-
-struct AttrState : SubexprState {
-    using SubexprState::SubexprState;
-
-    std::vector<AttrName> attrs;
-
-    template <typename T>
-    void pushAttr(T && attr, PosIdx) { attrs.emplace_back(std::forward<T>(attr)); }
-};
-
-template<> struct BuildAST<grammar::v1::attr::simple> {
-    static void apply(const auto & in, auto & s, State & ps) {
-        s.pushAttr(ps.symbols.create(in.string_view()), ps.at(in));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::attr::string> {
-    static void apply(const auto & in, auto & s, State & ps) {
-        auto e = s->popExprOnly();
-        if (auto str = dynamic_cast<ExprString *>(e.get()))
-            s.pushAttr(ps.symbols.create(str->s), ps.at(in));
-        else
-            s.pushAttr(std::move(e), ps.at(in));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::attr::expr> : BuildAST<grammar::v1::attr::string> {};
-
-struct BindingsState : SubexprState {
-    using SubexprState::SubexprState;
-
-    ExprAttrs attrs;
-    AttrPath path;
-    std::unique_ptr<Expr> value;
-};
-
-struct InheritState : SubexprState {
-    using SubexprState::SubexprState;
-
-    std::vector<std::pair<AttrName, PosIdx>> attrs;
-    std::unique_ptr<Expr> from;
-    PosIdx fromPos;
-
-    template <typename T>
-    void pushAttr(T && attr, PosIdx pos) { attrs.emplace_back(std::forward<T>(attr), pos); }
-};
-
-template<> struct BuildAST<grammar::v1::inherit::from> {
-    static void apply(const auto & in, InheritState & s, State & ps) {
-        s.from = s->popExprOnly();
-        s.fromPos = ps.at(in);
-    }
-};
-
-template<> struct BuildAST<grammar::v1::inherit> : change_head<InheritState> {
-    static void success0(InheritState & s, BindingsState & b, State & ps) {
-        auto & attrs = b.attrs.attrs;
-        // TODO this should not reuse generic attrpath rules.
-        for (auto & [i, iPos] : s.attrs) {
-            if (i.symbol)
-                continue;
-            if (auto str = dynamic_cast<ExprString *>(i.expr.get()))
-                i = AttrName(ps.symbols.create(str->s));
-            else {
-                throw ParseError({
-                    .msg = HintFmt("dynamic attributes not allowed in inherit"),
-                    .pos = ps.positions[iPos]
-                });
-            }
-        }
-        if (s.from != nullptr) {
-            if (!b.attrs.inheritFromExprs)
-                b.attrs.inheritFromExprs = std::make_unique<std::vector<ref<Expr>>>();
-            auto fromExpr = ref<Expr>(std::move(s.from));
-            b.attrs.inheritFromExprs->push_back(fromExpr);
-            for (auto & [i, iPos] : s.attrs) {
-                if (attrs.find(i.symbol) != attrs.end())
-                    ps.dupAttr(i.symbol, iPos, attrs[i.symbol].pos);
-                auto inheritFrom = std::make_unique<ExprInheritFrom>(
-                    s.fromPos,
-                    b.attrs.inheritFromExprs->size() - 1,
-                    fromExpr
-                );
-                attrs.emplace(
-                    i.symbol,
-                    ExprAttrs::AttrDef(
-                        std::make_unique<ExprSelect>(iPos, std::move(inheritFrom), i.symbol),
-                        iPos,
-                        ExprAttrs::AttrDef::Kind::InheritedFrom));
-            }
-        } else {
-            for (auto & [i, iPos] : s.attrs) {
-                if (attrs.find(i.symbol) != attrs.end())
-                    ps.dupAttr(i.symbol, iPos, attrs[i.symbol].pos);
-                attrs.emplace(
-                    i.symbol,
-                    ExprAttrs::AttrDef(
-                        std::make_unique<ExprVar>(iPos, i.symbol),
-                        iPos,
-                        ExprAttrs::AttrDef::Kind::Inherited));
-            }
-        }
-    }
-};
-
-template<> struct BuildAST<grammar::v1::binding::path> : change_head<AttrState> {
-    static void success0(AttrState & a, BindingsState & s, State & ps) {
-        s.path = std::move(a.attrs);
-    }
-};
-
-template<> struct BuildAST<grammar::v1::binding::value> {
-    static void apply0(BindingsState & s, State & ps) {
-        s.value = s->popExprOnly();
-    }
-};
-
-template<> struct BuildAST<grammar::v1::binding> {
-    static void apply(const auto & in, BindingsState & s, State & ps) {
-        ps.addAttr(&s.attrs, std::move(s.path), std::move(s.value), ps.at(in));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::id> {
-    static void apply(const auto & in, ExprState & s, State & ps) {
-        if (in.string_view() == "__curPos")
-            s.pushExpr<ExprPos>(ps.at(in), ps.at(in));
-        else
-            s.pushExpr<ExprVar>(ps.at(in), ps.at(in), ps.symbols.create(in.string_view()));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::int_> {
-    static void apply(const auto & in, ExprState & s, State & ps) {
-        int64_t v;
-        if (std::from_chars(in.begin(), in.end(), v).ec != std::errc{}) {
-            throw ParseError({
-                .msg = HintFmt("invalid integer '%1%'", in.string_view()),
-                .pos = ps.positions[ps.at(in)],
-            });
-        }
-        s.pushExpr<ExprInt>(noPos, v);
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::float_> {
-    static void apply(const auto & in, ExprState & s, State & ps) {
-        // copy the input into a temporary string so we can call stod.
-        // can't use from_chars because libc++ (thus darwin) does not have it,
-        // and floats are not performance-sensitive anyway. if they were you'd
-        // be in much bigger trouble than this.
-        //
-        // we also get to do a locale-save dance because stod is locale-aware and
-        // something (a plugin?) may have called setlocale or uselocale.
-        static struct locale_hack {
-            locale_t posix;
-            locale_hack(): posix(newlocale(LC_ALL_MASK, "POSIX", 0))
-            {
-                if (posix == 0)
-                    throw SysError("could not get POSIX locale");
-            }
-        } locale;
-
-        auto tmp = in.string();
-        double v = [&] {
-            auto oldLocale = uselocale(locale.posix);
-            Finally resetLocale([=] { uselocale(oldLocale); });
-            try {
-                return std::stod(tmp);
-            } catch (...) {
-                throw ParseError({
-                    .msg = HintFmt("invalid float '%1%'", in.string_view()),
-                    .pos = ps.positions[ps.at(in)],
-                });
-            }
-        }();
-        s.pushExpr<ExprFloat>(noPos, v);
-    }
-};
-
-struct StringState : SubexprState {
-    using SubexprState::SubexprState;
-
-    std::string currentLiteral;
-    PosIdx currentPos;
-    std::vector<std::pair<nix::PosIdx, std::unique_ptr<Expr>>> parts;
-
-    void append(PosIdx pos, std::string_view s)
-    {
-        if (currentLiteral.empty())
-            currentPos = pos;
-        currentLiteral += s;
-    }
-
-    // FIXME this truncates strings on NUL for compat with the old parser. ideally
-    // we should use the decomposition the g gives us instead of iterating over
-    // the entire string again.
-    static void unescapeStr(std::string & str)
-    {
-        char * s = str.data();
-        char * t = s;
-        char c;
-        while ((c = *s++)) {
-            if (c == '\\') {
-                c = *s++;
-                if (c == 'n') *t = '\n';
-                else if (c == 'r') *t = '\r';
-                else if (c == 't') *t = '\t';
-                else *t = c;
-            }
-            else if (c == '\r') {
-                /* Normalise CR and CR/LF into LF. */
-                *t = '\n';
-                if (*s == '\n') s++; /* cr/lf */
-            }
-            else *t = c;
-            t++;
-        }
-        str.resize(t - str.data());
-    }
-
-    void endLiteral()
-    {
-        if (!currentLiteral.empty()) {
-            unescapeStr(currentLiteral);
-            parts.emplace_back(currentPos, std::make_unique<ExprString>(std::move(currentLiteral)));
-        }
-    }
-
-    std::unique_ptr<Expr> finish()
-    {
-        if (parts.empty()) {
-            unescapeStr(currentLiteral);
-            return std::make_unique<ExprString>(std::move(currentLiteral));
-        } else {
-            endLiteral();
-            auto pos = parts[0].first;
-            return std::make_unique<ExprConcatStrings>(pos, true, std::move(parts));
-        }
-    }
-};
-
-template<typename... Content> struct BuildAST<grammar::v1::string::literal<Content...>> {
-    static void apply(const auto & in, StringState & s, State & ps) {
-        s.append(ps.at(in), in.string_view());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::string::cr_lf> {
-    static void apply(const auto & in, StringState & s, State & ps) {
-        s.append(ps.at(in), in.string_view()); // FIXME compat with old parser
-    }
-};
-
-template<> struct BuildAST<grammar::v1::string::interpolation> {
-    static void apply(const auto & in, StringState & s, State & ps) {
-        s.endLiteral();
-        s.parts.emplace_back(ps.at(in), s->popExprOnly());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::string::escape> {
-    static void apply(const auto & in, StringState & s, State & ps) {
-        s.append(ps.at(in), "\\"); // FIXME compat with old parser
-        s.append(ps.at(in), in.string_view());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::string> : change_head<StringState> {
-    static void success0(StringState & s, ExprState & e, State &) {
-        e.exprs.emplace_back(noPos, s.finish());
-    }
-};
-
-struct IndStringState : SubexprState {
-    using SubexprState::SubexprState;
-
-    std::vector<IndStringLine> lines;
-};
-
-template<> struct BuildAST<grammar::v1::ind_string::line_start> {
-    static void apply(const auto & in, IndStringState & s, State & ps) {
-        s.lines.push_back(IndStringLine { in.string_view(), ps.at(in) });
-    }
-};
-
-template<typename... Content>
-struct BuildAST<grammar::v1::ind_string::literal<Content...>> {
-    static void apply(const auto & in, IndStringState & s, State & ps) {
-        s.lines.back().parts.emplace_back(ps.at(in), in.string_view());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::ind_string::interpolation> {
-    static void apply(const auto & in, IndStringState & s, State & ps) {
-        s.lines.back().parts.emplace_back(ps.at(in), s->popExprOnly());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::ind_string::escape> {
-    static void apply(const auto & in, IndStringState & s, State & ps) {
-        switch (*in.begin()) {
-        case 'n': s.lines.back().parts.emplace_back(ps.at(in), "\n"); break;
-        case 'r': s.lines.back().parts.emplace_back(ps.at(in), "\r"); break;
-        case 't': s.lines.back().parts.emplace_back(ps.at(in), "\t"); break;
-        default:  s.lines.back().parts.emplace_back(ps.at(in), in.string_view()); break;
-        }
-    }
-};
-
-template<> struct BuildAST<grammar::v1::ind_string::has_content> {
-    static void apply(const auto & in, IndStringState & s, State & ps) {
-        s.lines.back().hasContent = true;
-    }
-};
-
-template<> struct BuildAST<grammar::v1::ind_string> : change_head<IndStringState> {
-    static void success(const auto & in, IndStringState & s, ExprState & e, State & ps) {
-        e.exprs.emplace_back(noPos, ps.stripIndentation(ps.at(in), std::move(s.lines)));
-    }
-};
-
-template<typename... Content> struct BuildAST<grammar::v1::path::literal<Content...>> {
-    static void apply(const auto & in, StringState & s, State & ps) {
-        s.append(ps.at(in), in.string_view());
-        s.endLiteral();
-    }
-};
-
-template<> struct BuildAST<grammar::v1::path::interpolation> : BuildAST<grammar::v1::string::interpolation> {};
-
-template<> struct BuildAST<grammar::v1::path::anchor> {
-    static void apply(const auto & in, StringState & s, State & ps) {
-        Path path(absPath(in.string(), ps.basePath.path.abs()));
-        /* add back in the trailing '/' to the first segment */
-        if (in.string_view().ends_with('/') && in.size() > 1)
-            path += "/";
-        s.parts.emplace_back(ps.at(in), new ExprPath(std::move(path)));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::path::home_anchor> {
-    static void apply(const auto & in, StringState & s, State & ps) {
-        if (evalSettings.pureEval)
-            throw Error("the path '%s' can not be resolved in pure mode", in.string_view());
-        Path path(getHome() + in.string_view().substr(1));
-        s.parts.emplace_back(ps.at(in), new ExprPath(std::move(path)));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::path::searched_path> {
-    static void apply(const auto & in, StringState & s, State & ps) {
-        std::vector<std::unique_ptr<Expr>> args{2};
-        args[0] = std::make_unique<ExprVar>(ps.s.nixPath);
-        args[1] = std::make_unique<ExprString>(in.string());
-        s.parts.emplace_back(
-            ps.at(in),
-            std::make_unique<ExprCall>(
-                ps.at(in),
-                std::make_unique<ExprVar>(ps.s.findFile),
-                std::move(args)));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::path> : change_head<StringState> {
-    template<typename E>
-    static void check_slash(PosIdx end, StringState & s, State & ps) {
-        auto e = dynamic_cast<E *>(s.parts.back().second.get());
-        if (!e || !e->s.ends_with('/'))
-            return;
-        if (s.parts.size() > 1 || e->s != "/")
-            throw ParseError({
-                .msg = HintFmt("path has a trailing slash"),
-                .pos = ps.positions[end],
-            });
-    }
-
-    static void success(const auto & in, StringState & s, ExprState & e, State & ps) {
-        s.endLiteral();
-        check_slash<ExprPath>(ps.atEnd(in), s, ps);
-        check_slash<ExprString>(ps.atEnd(in), s, ps);
-        if (s.parts.size() == 1) {
-            e.exprs.emplace_back(noPos, std::move(s.parts.back().second));
-        } else {
-            e.pushExpr<ExprConcatStrings>(ps.at(in), ps.at(in), false, std::move(s.parts));
-        }
-    }
-};
-
-// strings and paths sare handled fully by the grammar-level rule for now
-template<> struct BuildAST<grammar::v1::expr::string> : p::maybe_nothing {};
-template<> struct BuildAST<grammar::v1::expr::ind_string> : p::maybe_nothing {};
-template<> struct BuildAST<grammar::v1::expr::path> : p::maybe_nothing {};
-
-template<> struct BuildAST<grammar::v1::expr::uri> {
-    static void apply(const auto & in, ExprState & s, State & ps) {
-       bool URLLiterals = ps.featureSettings.isEnabled(Dep::UrlLiterals);
-       if (!URLLiterals)
-           throw ParseError({
-               .msg = HintFmt("URL literals are deprecated, allow using them with %s", "--extra-deprecated-features url-literals"),
-               .pos = ps.positions[ps.at(in)]
-           });
-       s.pushExpr<ExprString>(ps.at(in), in.string());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::ancient_let> : change_head<BindingsState> {
-    static void success(const auto & in, BindingsState & b, ExprState & s, State & ps) {
-        // Added 2024-09-18. Turn into an error at some point in the future.
-        // See the documentation on deprecated features for more details.
-        if (!ps.featureSettings.isEnabled(Dep::AncientLet))
-            warn(
-                "%s found at %s. This feature is deprecated and will be removed in the future. Use %s to silence this warning.",
-                "let {",
-                ps.positions[ps.at(in)],
-                "--extra-deprecated-features ancient-let"
-            );
-
-        b.attrs.pos = ps.at(in);
-        b.attrs.recursive = true;
-        s.pushExpr<ExprSelect>(b.attrs.pos, b.attrs.pos, std::make_unique<ExprAttrs>(std::move(b.attrs)), ps.s.body);
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::rec_set> : change_head<BindingsState> {
-    static void success(const auto & in, BindingsState & b, ExprState & s, State & ps) {
-        // Before inserting new attrs, check for __override and throw an error
-        // (the error will initially be a warning to ease migration)
-        if (!featureSettings.isEnabled(Dep::RecSetOverrides) && b.attrs.attrs.contains(ps.s.overrides)) {
-            ps.overridesFound(ps.at(in));
-        }
-
-        b.attrs.pos = ps.at(in);
-        b.attrs.recursive = true;
-        s.pushExpr<ExprAttrs>(b.attrs.pos, std::move(b.attrs));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::set> : change_head<BindingsState> {
-    static void success(const auto & in, BindingsState & b, ExprState & s, State & ps) {
-        b.attrs.pos = ps.at(in);
-        s.pushExpr<ExprAttrs>(b.attrs.pos, std::move(b.attrs));
-    }
-};
-
-using ListState = std::vector<std::unique_ptr<Expr>>;
-
-template<> struct BuildAST<grammar::v1::expr::list> : change_head<ListState> {
-    static void success(const auto & in, ListState & ls, ExprState & s, State & ps) {
-        auto e = std::make_unique<ExprList>();
-        e->elems = std::move(ls);
-        s.exprs.emplace_back(ps.at(in), std::move(e));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::list::entry> : change_head<ExprState> {
-    static void success0(ExprState & e, ListState & s, State & ps) {
-        s.emplace_back(e.finish(ps).second);
-    }
-};
-
-struct SelectState : SubexprState {
-    using SubexprState::SubexprState;
-
-    PosIdx pos;
-    ExprSelect * e = nullptr;
-};
-
-template<> struct BuildAST<grammar::v1::expr::select::head> {
-    static void apply(const auto & in, SelectState & s, State & ps) {
-        s.pos = ps.at(in);
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::select::attr> : change_head<AttrState> {
-    static void success0(AttrState & a, SelectState & s, State &) {
-        s.e = &s->pushExpr<ExprSelect>(s.pos, s.pos, s->popExprOnly(), std::move(a.attrs), nullptr);
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::select::attr_or> {
-    static void apply0(SelectState & s, State &) {
-        s.e->def = s->popExprOnly();
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::select::as_app_or> {
-    static void apply(const auto & in, SelectState & s, State & ps) {
-        std::vector<std::unique_ptr<Expr>> args(1);
-        args[0] = std::make_unique<ExprVar>(ps.at(in), ps.s.or_);
-        s->pushExpr<ExprCall>(s.pos, s.pos, s->popExprOnly(), std::move(args));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::select> : change_head<SelectState> {
-    static void success0(const auto &...) {}
-};
-
-struct AppState : SubexprState {
-    using SubexprState::SubexprState;
-
-    PosIdx pos;
-    ExprCall * e = nullptr;
-};
-
-template<> struct BuildAST<grammar::v1::expr::app::select_or_fn> {
-    static void apply(const auto & in, AppState & s, State & ps) {
-        s.pos = ps.at(in);
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::app::first_arg> {
-    static void apply(auto & in, AppState & s, State & ps) {
-        auto arg = s->popExprOnly(), fn = s->popExprOnly();
-        if ((s.e = dynamic_cast<ExprCall *>(fn.get()))) {
-            // TODO remove.
-            // AST compat with old parser, semantics are the same.
-            // this can happen on occasions such as `<p> <p>` or `a or b or`,
-            // neither of which are super worth optimizing.
-            s.e->args.push_back(std::move(arg));
-            s->exprs.emplace_back(noPos, std::move(fn));
-        } else {
-            std::vector<std::unique_ptr<Expr>> args{1};
-            args[0] = std::move(arg);
-            s.e = &s->pushExpr<ExprCall>(s.pos, s.pos, std::move(fn), std::move(args));
-        }
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::app::another_arg> {
-    static void apply0(AppState & s, State & ps) {
-        s.e->args.push_back(s->popExprOnly());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::app> : change_head<AppState> {
-    static void success0(const auto &...) {}
-};
-
-template<typename Op> struct BuildAST<grammar::v1::expr::operator_<Op>> {
-    static void apply(const auto & in, ExprState & s, State & ps) {
-        s.pushOp(ps.at(in), Op{}, ps);
-    }
-};
-template<> struct BuildAST<grammar::v1::expr::operator_<grammar::v1::op::has_attr>> : change_head<AttrState> {
-    static void success(const auto & in, AttrState & a, ExprState & s, State & ps) {
-        s.pushOp(ps.at(in), ExprState::has_attr{{}, std::move(a.attrs)}, ps);
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::lambda::arg> {
-    static void apply(const auto & in, LambdaState & s, State & ps) {
-        s.arg = ps.symbols.create(in.string_view());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::lambda> : change_head<LambdaState> {
-    static void success(const auto & in, LambdaState & l, ExprState & s, State & ps) {
-        if (l.formals)
-            l.formals = ps.validateFormals(std::move(l.formals), ps.at(in), l.arg);
-        s.pushExpr<ExprLambda>(ps.at(in), ps.at(in), l.arg, std::move(l.formals), l->popExprOnly());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::assert_> {
-    static void apply(const auto & in, ExprState & s, State & ps) {
-        auto body = s.popExprOnly(), cond = s.popExprOnly();
-        s.pushExpr<ExprAssert>(ps.at(in), ps.at(in), std::move(cond), std::move(body));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::with> {
-    static void apply(const auto & in, ExprState & s, State & ps) {
-        auto body = s.popExprOnly(), scope = s.popExprOnly();
-        s.pushExpr<ExprWith>(ps.at(in), ps.at(in), std::move(scope), std::move(body));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::let> : change_head<BindingsState> {
-    static void success(const auto & in, BindingsState & b, ExprState & s, State & ps) {
-        if (!b.attrs.dynamicAttrs.empty())
-            throw ParseError({
-                .msg = HintFmt("dynamic attributes not allowed in let"),
-                .pos = ps.positions[ps.at(in)]
-            });
-
-        s.pushExpr<ExprLet>(ps.at(in), std::make_unique<ExprAttrs>(std::move(b.attrs)), b->popExprOnly());
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr::if_> {
-    static void apply(const auto & in, ExprState & s, State & ps) {
-        auto else_ = s.popExprOnly(), then = s.popExprOnly(), cond = s.popExprOnly();
-        s.pushExpr<ExprIf>(ps.at(in), ps.at(in), std::move(cond), std::move(then), std::move(else_));
-    }
-};
-
-template<> struct BuildAST<grammar::v1::expr> : change_head<ExprState> {
-    static void success0(ExprState & inner, ExprState & outer, State & ps) {
-        outer.exprs.push_back(inner.finish(ps));
-    }
-};
-
-}
-}

src/libexpr/parser/parser.cc

@@ -14,11 +14,841 @@
 #include <charconv>
 #include <memory>
 
-// Linter complains that this is a "suspicious include of file with '.cc' extension".
-// While that is correct and generally not great, it is one of the less bad options to pick
-// in terms of diff noise.
-// NOLINTNEXTLINE(bugprone-suspicious-include)
-#include "parser-impl1.inc.cc"
+// flip this define when doing parser development to enable some g checks.
+#if 0
+#include <tao/pegtl/contrib/analyze.hpp>
+#define ANALYZE_GRAMMAR \
+    ([] { \
+        const std::size_t issues = tao::pegtl::analyze<grammar::root>(); \
+        assert(issues == 0); \
+    })()
+#else
+#define ANALYZE_GRAMMAR ((void) 0)
+#endif
+
+namespace p = tao::pegtl;
+
+namespace nix::parser {
+namespace {
+
+template<typename>
+inline constexpr const char * error_message = nullptr;
+
+#define error_message_for(...) \
+    template<> inline constexpr auto error_message<__VA_ARGS__>
+
+error_message_for(p::one<'{'>) = "expecting '{'";
+error_message_for(p::one<'}'>) = "expecting '}'";
+error_message_for(p::one<'"'>) = "expecting '\"'";
+error_message_for(p::one<';'>) = "expecting ';'";
+error_message_for(p::one<')'>) = "expecting ')'";
+error_message_for(p::one<']'>) = "expecting ']'";
+error_message_for(p::one<':'>) = "expecting ':'";
+error_message_for(p::string<'\'', '\''>) = "expecting \"''\"";
+error_message_for(p::any) = "expecting any character";
+error_message_for(grammar::eof) = "expecting end of file";
+error_message_for(grammar::seps) = "expecting separators";
+error_message_for(grammar::path::forbid_prefix_triple_slash) = "too many slashes in path";
+error_message_for(grammar::path::forbid_prefix_double_slash_no_interp) = "path has a trailing slash";
+error_message_for(grammar::expr) = "expecting expression";
+error_message_for(grammar::expr::unary) = "expecting expression";
+error_message_for(grammar::binding::equal) = "expecting '='";
+error_message_for(grammar::expr::lambda::arg) = "expecting identifier";
+error_message_for(grammar::formals) = "expecting formals";
+error_message_for(grammar::attrpath) = "expecting attribute path";
+error_message_for(grammar::expr::select) = "expecting selection expression";
+error_message_for(grammar::t::kw_then) = "expecting 'then'";
+error_message_for(grammar::t::kw_else) = "expecting 'else'";
+error_message_for(grammar::t::kw_in) = "expecting 'in'";
+
+struct SyntaxErrors
+{
+    template<typename Rule>
+    static constexpr auto message = error_message<Rule>;
+
+    template<typename Rule>
+    static constexpr bool raise_on_failure = false;
+};
+
+template<typename Rule>
+struct Control : p::must_if<SyntaxErrors>::control<Rule>
+{
+    template<typename ParseInput, typename... States>
+    [[noreturn]] static void raise(const ParseInput & in, States &&... st)
+    {
+        if (in.empty()) {
+            std::string expected;
+            if constexpr (constexpr auto msg = error_message<Rule>)
+                expected = fmt(", %s", msg);
+            throw p::parse_error("unexpected end of file" + expected, in);
+        }
+        p::must_if<SyntaxErrors>::control<Rule>::raise(in, st...);
+    }
+};
+
+struct ExprState
+    : grammar::
+          operator_semantics<ExprState, PosIdx, AttrPath, std::pair<PosIdx, std::unique_ptr<Expr>>>
+{
+    std::unique_ptr<Expr> popExprOnly() {
+        return std::move(popExpr().second);
+    }
+
+    template<typename Op, typename... Args>
+    std::unique_ptr<Expr> applyUnary(Args &&... args) {
+        return std::make_unique<Op>(popExprOnly(), std::forward<Args>(args)...);
+    }
+
+    template<typename Op>
+    std::unique_ptr<Expr> applyBinary(PosIdx pos) {
+        auto right = popExprOnly(), left = popExprOnly();
+        return std::make_unique<Op>(pos, std::move(left), std::move(right));
+    }
+
+    std::unique_ptr<Expr> call(PosIdx pos, Symbol fn, bool flip = false)
+    {
+        std::vector<std::unique_ptr<Expr>> args(2);
+        args[flip ? 0 : 1] = popExprOnly();
+        args[flip ? 1 : 0] = popExprOnly();
+        return std::make_unique<ExprCall>(pos, std::make_unique<ExprVar>(fn), std::move(args));
+    }
+
+    std::unique_ptr<Expr> pipe(PosIdx pos, State & state, bool flip = false)
+    {
+        if (!state.xpSettings.isEnabled(Xp::PipeOperator))
+            throw ParseError({
+                .msg = HintFmt("Pipe operator is disabled"),
+                .pos = state.positions[pos]
+            });
+
+        // Reverse the order compared to normal function application: arg |> fn
+        std::unique_ptr<Expr> fn, arg;
+        if (flip) {
+            fn = popExprOnly();
+            arg = popExprOnly();
+        } else {
+            arg = popExprOnly();
+            fn = popExprOnly();
+        }
+        std::vector<std::unique_ptr<Expr>> args{1};
+        args[0] = std::move(arg);
+
+        return std::make_unique<ExprCall>(pos, std::move(fn), std::move(args));
+    }
+
+    std::unique_ptr<Expr> order(PosIdx pos, bool less, State & state)
+    {
+        return call(pos, state.s.lessThan, !less);
+    }
+
+    std::unique_ptr<Expr> concatStrings(PosIdx pos)
+    {
+        std::vector<std::pair<PosIdx, std::unique_ptr<Expr>>> args(2);
+        args[1] = popExpr();
+        args[0] = popExpr();
+        return std::make_unique<ExprConcatStrings>(pos, false, std::move(args));
+    }
+
+    std::unique_ptr<Expr> negate(PosIdx pos, State & state)
+    {
+        std::vector<std::unique_ptr<Expr>> args(2);
+        args[0] = std::make_unique<ExprInt>(0);
+        args[1] = popExprOnly();
+        return std::make_unique<ExprCall>(pos, std::make_unique<ExprVar>(state.s.sub), std::move(args));
+    }
+
+    std::pair<PosIdx, std::unique_ptr<Expr>> applyOp(PosIdx pos, auto & op, State & state) {
+        using Op = grammar::op;
+
+        auto not_ = [] (auto e) {
+            return std::make_unique<ExprOpNot>(std::move(e));
+        };
+
+        return {
+            pos,
+            (overloaded {
+                [&] (Op::implies)     { return applyBinary<ExprOpImpl>(pos); },
+                [&] (Op::or_)         { return applyBinary<ExprOpOr>(pos); },
+                [&] (Op::and_)        { return applyBinary<ExprOpAnd>(pos); },
+                [&] (Op::equals)      { return applyBinary<ExprOpEq>(pos); },
+                [&] (Op::not_equals)  { return applyBinary<ExprOpNEq>(pos); },
+                [&] (Op::less)        { return order(pos, true, state); },
+                [&] (Op::greater_eq)  { return not_(order(pos, true, state)); },
+                [&] (Op::greater)     { return order(pos, false, state); },
+                [&] (Op::less_eq)     { return not_(order(pos, false, state)); },
+                [&] (Op::update)      { return applyBinary<ExprOpUpdate>(pos); },
+                [&] (Op::not_)        { return applyUnary<ExprOpNot>(); },
+                [&] (Op::plus)        { return concatStrings(pos); },
+                [&] (Op::minus)       { return call(pos, state.s.sub); },
+                [&] (Op::mul)         { return call(pos, state.s.mul); },
+                [&] (Op::div)         { return call(pos, state.s.div); },
+                [&] (Op::concat)      { return applyBinary<ExprOpConcatLists>(pos); },
+                [&] (has_attr & a)    { return applyUnary<ExprOpHasAttr>(std::move(a.path)); },
+                [&] (Op::unary_minus) { return negate(pos, state); },
+                [&] (Op::pipe_right)  { return pipe(pos, state, true); },
+                [&] (Op::pipe_left)   { return pipe(pos, state); },
+            })(op)
+        };
+    }
+
+    // always_inline is needed, otherwise pushOp slows down considerably
+    [[noreturn, gnu::always_inline]]
+    static void badOperator(PosIdx pos, State & state)
+    {
+        throw ParseError({
+            .msg = HintFmt("syntax error, unexpected operator"),
+            .pos = state.positions[pos]
+        });
+    }
+
+    template<typename Expr, typename... Args>
+    Expr & pushExpr(PosIdx pos, Args && ... args)
+    {
+        auto p = std::make_unique<Expr>(std::forward<Args>(args)...);
+        auto & result = *p;
+        exprs.emplace_back(pos, std::move(p));
+        return result;
+    }
+};
+
+struct SubexprState {
+private:
+    ExprState * up;
+
+public:
+    explicit SubexprState(ExprState & up, auto &...) : up(&up) {}
+    operator ExprState &() { return *up; }
+    ExprState * operator->() { return up; }
+};
+
+
+
+template<typename Rule>
+struct BuildAST : grammar::nothing<Rule> {};
+
+struct LambdaState : SubexprState {
+    using SubexprState::SubexprState;
+
+    Symbol arg;
+    std::unique_ptr<Formals> formals;
+};
+
+struct FormalsState : SubexprState {
+    using SubexprState::SubexprState;
+
+    Formals formals{};
+    Formal formal{};
+};
+
+template<> struct BuildAST<grammar::formal::name> {
+    static void apply(const auto & in, FormalsState & s, State & ps) {
+        s.formal = {
+            .pos = ps.at(in),
+            .name = ps.symbols.create(in.string_view()),
+        };
+    }
+};
+
+template<> struct BuildAST<grammar::formal> {
+    static void apply0(FormalsState & s, State &) {
+        s.formals.formals.emplace_back(std::move(s.formal));
+    }
+};
+
+template<> struct BuildAST<grammar::formal::default_value> {
+    static void apply0(FormalsState & s, State & ps) {
+        s.formal.def = s->popExprOnly();
+    }
+};
+
+template<> struct BuildAST<grammar::formals::ellipsis> {
+    static void apply0(FormalsState & s, State &) {
+        s.formals.ellipsis = true;
+    }
+};
+
+template<> struct BuildAST<grammar::formals> : change_head<FormalsState> {
+    static void success0(FormalsState & f, LambdaState & s, State &) {
+        s.formals = std::make_unique<Formals>(std::move(f.formals));
+    }
+};
+
+struct AttrState : SubexprState {
+    using SubexprState::SubexprState;
+
+    std::vector<AttrName> attrs;
+
+    template <typename T>
+    void pushAttr(T && attr, PosIdx) { attrs.emplace_back(std::forward<T>(attr)); }
+};
+
+template<> struct BuildAST<grammar::attr::simple> {
+    static void apply(const auto & in, auto & s, State & ps) {
+        s.pushAttr(ps.symbols.create(in.string_view()), ps.at(in));
+    }
+};
+
+template<> struct BuildAST<grammar::attr::string> {
+    static void apply(const auto & in, auto & s, State & ps) {
+        auto e = s->popExprOnly();
+        if (auto str = dynamic_cast<ExprString *>(e.get()))
+            s.pushAttr(ps.symbols.create(str->s), ps.at(in));
+        else
+            s.pushAttr(std::move(e), ps.at(in));
+    }
+};
+
+template<> struct BuildAST<grammar::attr::expr> : BuildAST<grammar::attr::string> {};
+
+struct BindingsState : SubexprState {
+    using SubexprState::SubexprState;
+
+    ExprAttrs attrs;
+    AttrPath path;
+    std::unique_ptr<Expr> value;
+};
+
+struct InheritState : SubexprState {
+    using SubexprState::SubexprState;
+
+    std::vector<std::pair<AttrName, PosIdx>> attrs;
+    std::unique_ptr<Expr> from;
+    PosIdx fromPos;
+
+    template <typename T>
+    void pushAttr(T && attr, PosIdx pos) { attrs.emplace_back(std::forward<T>(attr), pos); }
+};
+
+template<> struct BuildAST<grammar::inherit::from> {
+    static void apply(const auto & in, InheritState & s, State & ps) {
+        s.from = s->popExprOnly();
+        s.fromPos = ps.at(in);
+    }
+};
+
+template<> struct BuildAST<grammar::inherit> : change_head<InheritState> {
+    static void success0(InheritState & s, BindingsState & b, State & ps) {
+        auto & attrs = b.attrs.attrs;
+        // TODO this should not reuse generic attrpath rules.
+        for (auto & [i, iPos] : s.attrs) {
+            if (i.symbol)
+                continue;
+            if (auto str = dynamic_cast<ExprString *>(i.expr.get()))
+                i = AttrName(ps.symbols.create(str->s));
+            else {
+                throw ParseError({
+                    .msg = HintFmt("dynamic attributes not allowed in inherit"),
+                    .pos = ps.positions[iPos]
+                });
+            }
+        }
+        if (s.from != nullptr) {
+            if (!b.attrs.inheritFromExprs)
+                b.attrs.inheritFromExprs = std::make_unique<std::vector<ref<Expr>>>();
+            auto fromExpr = ref<Expr>(std::move(s.from));
+            b.attrs.inheritFromExprs->push_back(fromExpr);
+            for (auto & [i, iPos] : s.attrs) {
+                if (attrs.find(i.symbol) != attrs.end())
+                    ps.dupAttr(i.symbol, iPos, attrs[i.symbol].pos);
+                auto inheritFrom = std::make_unique<ExprInheritFrom>(
+                    s.fromPos,
+                    b.attrs.inheritFromExprs->size() - 1,
+                    fromExpr
+                );
+                attrs.emplace(
+                    i.symbol,
+                    ExprAttrs::AttrDef(
+                        std::make_unique<ExprSelect>(iPos, std::move(inheritFrom), i.symbol),
+                        iPos,
+                        ExprAttrs::AttrDef::Kind::InheritedFrom));
+            }
+        } else {
+            for (auto & [i, iPos] : s.attrs) {
+                if (attrs.find(i.symbol) != attrs.end())
+                    ps.dupAttr(i.symbol, iPos, attrs[i.symbol].pos);
+                attrs.emplace(
+                    i.symbol,
+                    ExprAttrs::AttrDef(
+                        std::make_unique<ExprVar>(iPos, i.symbol),
+                        iPos,
+                        ExprAttrs::AttrDef::Kind::Inherited));
+            }
+        }
+    }
+};
+
+template<> struct BuildAST<grammar::binding::path> : change_head<AttrState> {
+    static void success0(AttrState & a, BindingsState & s, State & ps) {
+        s.path = std::move(a.attrs);
+    }
+};
+
+template<> struct BuildAST<grammar::binding::value> {
+    static void apply0(BindingsState & s, State & ps) {
+        s.value = s->popExprOnly();
+    }
+};
+
+template<> struct BuildAST<grammar::binding> {
+    static void apply(const auto & in, BindingsState & s, State & ps) {
+        ps.addAttr(&s.attrs, std::move(s.path), std::move(s.value), ps.at(in));
+    }
+};
+
+template<> struct BuildAST<grammar::expr::id> {
+    static void apply(const auto & in, ExprState & s, State & ps) {
+        if (in.string_view() == "__curPos")
+            s.pushExpr<ExprPos>(ps.at(in), ps.at(in));
+        else
+            s.pushExpr<ExprVar>(ps.at(in), ps.at(in), ps.symbols.create(in.string_view()));
+    }
+};
+
+template<> struct BuildAST<grammar::expr::int_> {
+    static void apply(const auto & in, ExprState & s, State & ps) {
+        int64_t v;
+        if (std::from_chars(in.begin(), in.end(), v).ec != std::errc{}) {
+            throw ParseError({
+                .msg = HintFmt("invalid integer '%1%'", in.string_view()),
+                .pos = ps.positions[ps.at(in)],
+            });
+        }
+        s.pushExpr<ExprInt>(noPos, v);
+    }
+};
+
+template<> struct BuildAST<grammar::expr::float_> {
+    static void apply(const auto & in, ExprState & s, State & ps) {
+        // copy the input into a temporary string so we can call stod.
+        // can't use from_chars because libc++ (thus darwin) does not have it,
+        // and floats are not performance-sensitive anyway. if they were you'd
+        // be in much bigger trouble than this.
+        //
+        // we also get to do a locale-save dance because stod is locale-aware and
+        // something (a plugin?) may have called setlocale or uselocale.
+        static struct locale_hack {
+            locale_t posix;
+            locale_hack(): posix(newlocale(LC_ALL_MASK, "POSIX", 0))
+            {
+                if (posix == 0)
+                    throw SysError("could not get POSIX locale");
+            }
+        } locale;
+
+        auto tmp = in.string();
+        double v = [&] {
+            auto oldLocale = uselocale(locale.posix);
+            Finally resetLocale([=] { uselocale(oldLocale); });
+            try {
+                return std::stod(tmp);
+            } catch (...) {
+                throw ParseError({
+                    .msg = HintFmt("invalid float '%1%'", in.string_view()),
+                    .pos = ps.positions[ps.at(in)],
+                });
+            }
+        }();
+        s.pushExpr<ExprFloat>(noPos, v);
+    }
+};
+
+struct StringState : SubexprState {
+    using SubexprState::SubexprState;
+
+    std::string currentLiteral;
+    PosIdx currentPos;
+    std::vector<std::pair<nix::PosIdx, std::unique_ptr<Expr>>> parts;
+
+    void append(PosIdx pos, std::string_view s)
+    {
+        if (currentLiteral.empty())
+            currentPos = pos;
+        currentLiteral += s;
+    }
+
+    // FIXME this truncates strings on NUL for compat with the old parser. ideally
+    // we should use the decomposition the g gives us instead of iterating over
+    // the entire string again.
+    static void unescapeStr(std::string & str)
+    {
+        char * s = str.data();
+        char * t = s;
+        char c;
+        while ((c = *s++)) {
+            if (c == '\\') {
+                c = *s++;
+                if (c == 'n') *t = '\n';
+                else if (c == 'r') *t = '\r';
+                else if (c == 't') *t = '\t';
+                else *t = c;
+            }
+            else if (c == '\r') {
+                /* Normalise CR and CR/LF into LF. */
+                *t = '\n';
+                if (*s == '\n') s++; /* cr/lf */
+            }
+            else *t = c;
+            t++;
+        }
+        str.resize(t - str.data());
+    }
+
+    void endLiteral()
+    {
+        if (!currentLiteral.empty()) {
+            unescapeStr(currentLiteral);
+            parts.emplace_back(currentPos, std::make_unique<ExprString>(std::move(currentLiteral)));
+        }
+    }
+
+    std::unique_ptr<Expr> finish()
+    {
+        if (parts.empty()) {
+            unescapeStr(currentLiteral);
+            return std::make_unique<ExprString>(std::move(currentLiteral));
+        } else {
+            endLiteral();
+            auto pos = parts[0].first;
+            return std::make_unique<ExprConcatStrings>(pos, true, std::move(parts));
+        }
+    }
+};
+
+template<typename... Content> struct BuildAST<grammar::string::literal<Content...>> {
+    static void apply(const auto & in, StringState & s, State & ps) {
+        s.append(ps.at(in), in.string_view());
+    }
+};
+
+template<> struct BuildAST<grammar::string::cr_lf> {
+    static void apply(const auto & in, StringState & s, State & ps) {
+        s.append(ps.at(in), in.string_view()); // FIXME compat with old parser
+    }
+};
+
+template<> struct BuildAST<grammar::string::interpolation> {
+    static void apply(const auto & in, StringState & s, State & ps) {
+        s.endLiteral();
+        s.parts.emplace_back(ps.at(in), s->popExprOnly());
+    }
+};
+
+template<> struct BuildAST<grammar::string::escape> {
+    static void apply(const auto & in, StringState & s, State & ps) {
+        s.append(ps.at(in), "\\"); // FIXME compat with old parser
+        s.append(ps.at(in), in.string_view());
+    }
+};
+
+template<> struct BuildAST<grammar::string> : change_head<StringState> {
+    static void success0(StringState & s, ExprState & e, State &) {
+        e.exprs.emplace_back(noPos, s.finish());
+    }
+};
+
+struct IndStringState : SubexprState {
+    using SubexprState::SubexprState;
+
+    std::vector<std::pair<PosIdx, std::variant<std::unique_ptr<Expr>, StringToken>>> parts;
+};
+
+template<bool Indented, typename... Content>
+struct BuildAST<grammar::ind_string::literal<Indented, Content...>> {
+    static void apply(const auto & in, IndStringState & s, State & ps) {
+        s.parts.emplace_back(ps.at(in), StringToken{in.string_view(), Indented});
+    }
+};
+
+template<> struct BuildAST<grammar::ind_string::interpolation> {
+    static void apply(const auto & in, IndStringState & s, State & ps) {
+        s.parts.emplace_back(ps.at(in), s->popExprOnly());
+    }
+};
+
+template<> struct BuildAST<grammar::ind_string::escape> {
+    static void apply(const auto & in, IndStringState & s, State & ps) {
+        switch (*in.begin()) {
+        case 'n': s.parts.emplace_back(ps.at(in), StringToken{"\n"}); break;
+        case 'r': s.parts.emplace_back(ps.at(in), StringToken{"\r"}); break;
+        case 't': s.parts.emplace_back(ps.at(in), StringToken{"\t"}); break;
+        default:  s.parts.emplace_back(ps.at(in), StringToken{in.string_view()}); break;
+        }
+    }
+};
+
+template<> struct BuildAST<grammar::ind_string> : change_head<IndStringState> {
+    static void success(const auto & in, IndStringState & s, ExprState & e, State & ps) {
+        e.exprs.emplace_back(noPos, ps.stripIndentation(ps.at(in), std::move(s.parts)));
+    }
+};
+
+template<typename... Content> struct BuildAST<grammar::path::literal<Content...>> {
+    static void apply(const auto & in, StringState & s, State & ps) {
+        s.append(ps.at(in), in.string_view());
+        s.endLiteral();
+    }
+};
+
+template<> struct BuildAST<grammar::path::interpolation> : BuildAST<grammar::string::interpolation> {};
+
+template<> struct BuildAST<grammar::path::anchor> {
+    static void apply(const auto & in, StringState & s, State & ps) {
+        Path path(absPath(in.string(), ps.basePath.path.abs()));
+        /* add back in the trailing '/' to the first segment */
+        if (in.string_view().ends_with('/') && in.size() > 1)
+            path += "/";
+        s.parts.emplace_back(ps.at(in), new ExprPath(std::move(path)));
+    }
+};
+
+template<> struct BuildAST<grammar::path::home_anchor> {
+    static void apply(const auto & in, StringState & s, State & ps) {
+        if (evalSettings.pureEval)
+            throw Error("the path '%s' can not be resolved in pure mode", in.string_view());
+        Path path(getHome() + in.string_view().substr(1));
+        s.parts.emplace_back(ps.at(in), new ExprPath(std::move(path)));
+    }
+};
+
+template<> struct BuildAST<grammar::path::searched_path> {
+    static void apply(const auto & in, StringState & s, State & ps) {
+        std::vector<std::unique_ptr<Expr>> args{2};
+        args[0] = std::make_unique<ExprVar>(ps.s.nixPath);
+        args[1] = std::make_unique<ExprString>(in.string());
+        s.parts.emplace_back(
+            ps.at(in),
+            std::make_unique<ExprCall>(
+                ps.at(in),
+                std::make_unique<ExprVar>(ps.s.findFile),
+                std::move(args)));
+    }
+};
+
+template<> struct BuildAST<grammar::path> : change_head<StringState> {
+    template<typename E>
+    static void check_slash(PosIdx end, StringState & s, State & ps) {
+        auto e = dynamic_cast<E *>(s.parts.back().second.get());
+        if (!e || !e->s.ends_with('/'))
+            return;
+        if (s.parts.size() > 1 || e->s != "/")
+            throw ParseError({
+                .msg = HintFmt("path has a trailing slash"),
+                .pos = ps.positions[end],
+            });
+    }
+
+    static void success(const auto & in, StringState & s, ExprState & e, State & ps) {
+        s.endLiteral();
+        check_slash<ExprPath>(ps.atEnd(in), s, ps);
+        check_slash<ExprString>(ps.atEnd(in), s, ps);
+        if (s.parts.size() == 1) {
+            e.exprs.emplace_back(noPos, std::move(s.parts.back().second));
+        } else {
+            e.pushExpr<ExprConcatStrings>(ps.at(in), ps.at(in), false, std::move(s.parts));
+        }
+    }
+};
+
+// strings and paths sare handled fully by the grammar-level rule for now
+template<> struct BuildAST<grammar::expr::string> : p::maybe_nothing {};
+template<> struct BuildAST<grammar::expr::ind_string> : p::maybe_nothing {};
+template<> struct BuildAST<grammar::expr::path> : p::maybe_nothing {};
+
+template<> struct BuildAST<grammar::expr::uri> {
+    static void apply(const auto & in, ExprState & s, State & ps) {
+       bool noURLLiterals = ps.xpSettings.isEnabled(Xp::NoUrlLiterals);
+       if (noURLLiterals)
+           throw ParseError({
+               .msg = HintFmt("URL literals are disabled"),
+               .pos = ps.positions[ps.at(in)]
+           });
+       s.pushExpr<ExprString>(ps.at(in), in.string());
+    }
+};
+
+template<> struct BuildAST<grammar::expr::ancient_let> : change_head<BindingsState> {
+    static void success(const auto & in, BindingsState & b, ExprState & s, State & ps) {
+        b.attrs.pos = ps.at(in);
+        b.attrs.recursive = true;
+        s.pushExpr<ExprSelect>(b.attrs.pos, b.attrs.pos, std::make_unique<ExprAttrs>(std::move(b.attrs)), ps.s.body);
+    }
+};
+
+template<> struct BuildAST<grammar::expr::rec_set> : change_head<BindingsState> {
+    static void success(const auto & in, BindingsState & b, ExprState & s, State & ps) {
+        b.attrs.pos = ps.at(in);
+        b.attrs.recursive = true;
+        s.pushExpr<ExprAttrs>(b.attrs.pos, std::move(b.attrs));
+    }
+};
+
+template<> struct BuildAST<grammar::expr::set> : change_head<BindingsState> {
+    static void success(const auto & in, BindingsState & b, ExprState & s, State & ps) {
+        b.attrs.pos = ps.at(in);
+        s.pushExpr<ExprAttrs>(b.attrs.pos, std::move(b.attrs));
+    }
+};
+
+using ListState = std::vector<std::unique_ptr<Expr>>;
+
+template<> struct BuildAST<grammar::expr::list> : change_head<ListState> {
+    static void success(const auto & in, ListState & ls, ExprState & s, State & ps) {
+        auto e = std::make_unique<ExprList>();
+        e->elems = std::move(ls);
+        s.exprs.emplace_back(ps.at(in), std::move(e));
+    }
+};
+
+template<> struct BuildAST<grammar::expr::list::entry> : change_head<ExprState> {
+    static void success0(ExprState & e, ListState & s, State & ps) {
+        s.emplace_back(e.finish(ps).second);
+    }
+};
+
+struct SelectState : SubexprState {
+    using SubexprState::SubexprState;
+
+    PosIdx pos;
+    ExprSelect * e = nullptr;
+};
+
+template<> struct BuildAST<grammar::expr::select::head> {
+    static void apply(const auto & in, SelectState & s, State & ps) {
+        s.pos = ps.at(in);
+    }
+};
+
+template<> struct BuildAST<grammar::expr::select::attr> : change_head<AttrState> {
+    static void success0(AttrState & a, SelectState & s, State &) {
+        s.e = &s->pushExpr<ExprSelect>(s.pos, s.pos, s->popExprOnly(), std::move(a.attrs), nullptr);
+    }
+};
+
+template<> struct BuildAST<grammar::expr::select::attr_or> {
+    static void apply0(SelectState & s, State &) {
+        s.e->def = s->popExprOnly();
+    }
+};
+
+template<> struct BuildAST<grammar::expr::select::as_app_or> {
+    static void apply(const auto & in, SelectState & s, State & ps) {
+        std::vector<std::unique_ptr<Expr>> args(1);
+        args[0] = std::make_unique<ExprVar>(ps.at(in), ps.s.or_);
+        s->pushExpr<ExprCall>(s.pos, s.pos, s->popExprOnly(), std::move(args));
+    }
+};
+
+template<> struct BuildAST<grammar::expr::select> : change_head<SelectState> {
+    static void success0(const auto &...) {}
+};
+
+struct AppState : SubexprState {
+    using SubexprState::SubexprState;
+
+    PosIdx pos;
+    ExprCall * e = nullptr;
+};
+
+template<> struct BuildAST<grammar::expr::app::select_or_fn> {
+    static void apply(const auto & in, AppState & s, State & ps) {
+        s.pos = ps.at(in);
+    }
+};
+
+template<> struct BuildAST<grammar::expr::app::first_arg> {
+    static void apply(auto & in, AppState & s, State & ps) {
+        auto arg = s->popExprOnly(), fn = s->popExprOnly();
+        if ((s.e = dynamic_cast<ExprCall *>(fn.get()))) {
+            // TODO remove.
+            // AST compat with old parser, semantics are the same.
+            // this can happen on occasions such as `<p> <p>` or `a or b or`,
+            // neither of which are super worth optimizing.
+            s.e->args.push_back(std::move(arg));
+            s->exprs.emplace_back(noPos, std::move(fn));
+        } else {
+            std::vector<std::unique_ptr<Expr>> args{1};
+            args[0] = std::move(arg);
+            s.e = &s->pushExpr<ExprCall>(s.pos, s.pos, std::move(fn), std::move(args));
+        }
+    }
+};
+
+template<> struct BuildAST<grammar::expr::app::another_arg> {
+    static void apply0(AppState & s, State & ps) {
+        s.e->args.push_back(s->popExprOnly());
+    }
+};
+
+template<> struct BuildAST<grammar::expr::app> : change_head<AppState> {
+    static void success0(const auto &...) {}
+};
+
+template<typename Op> struct BuildAST<grammar::expr::operator_<Op>> {
+    static void apply(const auto & in, ExprState & s, State & ps) {
+        s.pushOp(ps.at(in), Op{}, ps);
+    }
+};
+template<> struct BuildAST<grammar::expr::operator_<grammar::op::has_attr>> : change_head<AttrState> {
+    static void success(const auto & in, AttrState & a, ExprState & s, State & ps) {
+        s.pushOp(ps.at(in), ExprState::has_attr{{}, std::move(a.attrs)}, ps);
+    }
+};
+
+template<> struct BuildAST<grammar::expr::lambda::arg> {
+    static void apply(const auto & in, LambdaState & s, State & ps) {
+        s.arg = ps.symbols.create(in.string_view());
+    }
+};
+
+template<> struct BuildAST<grammar::expr::lambda> : change_head<LambdaState> {
+    static void success(const auto & in, LambdaState & l, ExprState & s, State & ps) {
+        if (l.formals)
+            l.formals = ps.validateFormals(std::move(l.formals), ps.at(in), l.arg);
+        s.pushExpr<ExprLambda>(ps.at(in), ps.at(in), l.arg, std::move(l.formals), l->popExprOnly());
+    }
+};
+
+template<> struct BuildAST<grammar::expr::assert_> {
+    static void apply(const auto & in, ExprState & s, State & ps) {
+        auto body = s.popExprOnly(), cond = s.popExprOnly();
+        s.pushExpr<ExprAssert>(ps.at(in), ps.at(in), std::move(cond), std::move(body));
+    }
+};
+
+template<> struct BuildAST<grammar::expr::with> {
+    static void apply(const auto & in, ExprState & s, State & ps) {
+        auto body = s.popExprOnly(), scope = s.popExprOnly();
+        s.pushExpr<ExprWith>(ps.at(in), ps.at(in), std::move(scope), std::move(body));
+    }
+};
+
+template<> struct BuildAST<grammar::expr::let> : change_head<BindingsState> {
+    static void success(const auto & in, BindingsState & b, ExprState & s, State & ps) {
+        if (!b.attrs.dynamicAttrs.empty())
+            throw ParseError({
+                .msg = HintFmt("dynamic attributes not allowed in let"),
+                .pos = ps.positions[ps.at(in)]
+            });
+
+        s.pushExpr<ExprLet>(ps.at(in), std::make_unique<ExprAttrs>(std::move(b.attrs)), b->popExprOnly());
+    }
+};
+
+template<> struct BuildAST<grammar::expr::if_> {
+    static void apply(const auto & in, ExprState & s, State & ps) {
+        auto else_ = s.popExprOnly(), then = s.popExprOnly(), cond = s.popExprOnly();
+        s.pushExpr<ExprIf>(ps.at(in), ps.at(in), std::move(cond), std::move(then), std::move(else_));
+    }
+};
+
+template<> struct BuildAST<grammar::expr> : change_head<ExprState> {
+    static void success0(ExprState & inner, ExprState & outer, State & ps) {
+        outer.exprs.push_back(inner.finish(ps));
+    }
+};
+
+}
+}
 
 namespace nix {
 
@@ -28,7 +858,7 @@ Expr * EvalState::parse(
     Pos::Origin origin,
     const SourcePath & basePath,
     std::shared_ptr<StaticEnv> & staticEnv,
-    const FeatureSettings & featureSettings)
+    const ExperimentalFeatureSettings & xpSettings)
 {
     parser::State s = {
         symbols,
@@ -36,8 +866,9 @@ Expr * EvalState::parse(
         basePath,
         positions.addOrigin(origin, length),
         exprSymbols,
-        featureSettings,
+        xpSettings
     };
+    parser::ExprState x;
 
     assert(length >= 2);
     assert(text[length - 1] == 0);
@@ -46,12 +877,7 @@ Expr * EvalState::parse(
 
     p::string_input<p::tracking_mode::lazy> inp{std::string_view{text, length}, "input"};
     try {
-        parser::v1::ExprState x;
-        p::parse<parser::grammar::v1::root, parser::v1::BuildAST, parser::v1::Control>(inp, x, s);
-
-        auto [_pos, result] = x.finish(s);
-        result->bindVars(*this, staticEnv);
-        return result.release();
+        p::parse<parser::grammar::root, parser::BuildAST, parser::Control>(inp, x, s);
     } catch (p::parse_error & e) {
         auto pos = e.positions().back();
         throw ParseError({
@@ -59,6 +885,10 @@ Expr * EvalState::parse(
             .pos = positions[s.positions.add(s.origin, pos.byte)]
         });
     }
+
+    auto [_pos, result] = x.finish(s);
+    result->bindVars(*this, staticEnv);
+    return result.release();
 }
 
 }

src/libexpr/parser/state.hh

@@ -2,25 +2,14 @@
 ///@file
 
 #include "eval.hh"
-#include "logging.hh"
 
 namespace nix::parser {
 
-struct IndStringLine {
-    // String containing only the leading whitespace of the line. May be empty.
-    std::string_view indentation;
-    // Position of the line start (before the indentation)
-    PosIdx pos;
-
-    // Whether the line contains anything besides indentation and line break
-    bool hasContent = false;
-
-    std::vector<
-        std::pair<
-            PosIdx,
-            std::variant<std::unique_ptr<Expr>, std::string_view>
-        >
-    > parts = {};
+struct StringToken
+{
+    std::string_view s;
+    bool hasIndentation;
+    operator std::string_view() const { return s; }
 };
 
 struct State
@@ -30,14 +19,14 @@ struct State
     SourcePath basePath;
     PosTable::Origin origin;
     const Expr::AstSymbols & s;
-    const FeatureSettings & featureSettings;
+    const ExperimentalFeatureSettings & xpSettings;
 
     void dupAttr(const AttrPath & attrPath, const PosIdx pos, const PosIdx prevPos);
     void dupAttr(Symbol attr, const PosIdx pos, const PosIdx prevPos);
-    void overridesFound(const PosIdx pos);
     void addAttr(ExprAttrs * attrs, AttrPath && attrPath, std::unique_ptr<Expr> e, const PosIdx pos);
     std::unique_ptr<Formals> validateFormals(std::unique_ptr<Formals> formals, PosIdx pos = noPos, Symbol arg = {});
-    std::unique_ptr<Expr> stripIndentation(const PosIdx pos, std::vector<IndStringLine> && line);
+    std::unique_ptr<Expr> stripIndentation(const PosIdx pos,
+        std::vector<std::pair<PosIdx, std::variant<std::unique_ptr<Expr>, StringToken>>> && es);
 
     // lazy positioning means we don't get byte offsets directly, in.position() would work
     // but also requires line and column (which is expensive)
@@ -69,17 +58,6 @@ inline void State::dupAttr(Symbol attr, const PosIdx pos, const PosIdx prevPos)
     });
 }
 
-inline void State::overridesFound(const PosIdx pos) {
-    // Added 2024-09-18. Turn into an error at some point in the future.
-    // See the documentation on deprecated features for more details.
-    warn(
-        "%s found at %s. This feature is deprecated and will be removed in the future. Use %s to silence this warning.",
-        "__overrides",
-        positions[pos],
-        "--extra-deprecated-features rec-set-overrides"
-    );
-}
-
 inline void State::addAttr(ExprAttrs * attrs, AttrPath && attrPath, std::unique_ptr<Expr> e, const PosIdx pos)
 {
     AttrPath::iterator i;
@@ -145,12 +123,6 @@ inline void State::addAttr(ExprAttrs * attrs, AttrPath && attrPath, std::unique_
                 dupAttr(attrPath, pos, j->second.pos);
             }
         } else {
-            // Before inserting new attrs, check for __override and throw an error
-            // (the error will initially be a warning to ease migration)
-            if (attrs->recursive && !featureSettings.isEnabled(Dep::RecSetOverrides) && i->symbol == s.overrides) {
-                overridesFound(pos);
-            }
-
             // This attr path is not defined. Let's create it.
             e->setName(i->symbol);
             attrs->attrs.emplace(std::piecewise_construct,
@@ -191,87 +163,98 @@ inline std::unique_ptr<Formals> State::validateFormals(std::unique_ptr<Formals>
     return formals;
 }
 
-inline std::unique_ptr<Expr> State::stripIndentation(
-    const PosIdx pos,
-    std::vector<IndStringLine> && lines)
+inline std::unique_ptr<Expr> State::stripIndentation(const PosIdx pos,
+    std::vector<std::pair<PosIdx, std::variant<std::unique_ptr<Expr>, StringToken>>> && es)
 {
-    /* If the only line is whitespace-only, directly return empty string.
-     * The rest of the code relies on the final string not being empty.
-     */
-    if (lines.size() == 1 && lines.front().parts.empty()) {
-        return std::make_unique<ExprString>("");
-    }
-
-    /* If the last line only contains whitespace, trim it to not cause excessive whitespace.
-     * (Other whitespace-only lines get stripped only of the common indentation, and excess
-     * whitespace becomes part of the string.)
-     */
-    if (lines.back().parts.empty()) {
-        lines.back().indentation = {};
-    }
+    if (es.empty()) return std::make_unique<ExprString>("");
 
     /* Figure out the minimum indentation.  Note that by design
-       whitespace-only lines are not taken into account. */
+       whitespace-only final lines are not taken into account.  (So
+       the " " in "\n ''" is ignored, but the " " in "\n foo''" is.) */
+    bool atStartOfLine = true; /* = seen only whitespace in the current line */
     size_t minIndent = 1000000;
-    for (auto & line : lines) {
-        if (line.hasContent) {
-            minIndent = std::min(minIndent, line.indentation.size());
+    size_t curIndent = 0;
+    for (auto & [i_pos, i] : es) {
+        auto * str = std::get_if<StringToken>(&i);
+        if (!str || !str->hasIndentation) {
+            /* Anti-quotations and escaped characters end the current start-of-line whitespace. */
+            if (atStartOfLine) {
+                atStartOfLine = false;
+                if (curIndent < minIndent) minIndent = curIndent;
+            }
+            continue;
+        }
+        for (size_t j = 0; j < str->s.size(); ++j) {
+            if (atStartOfLine) {
+                if (str->s[j] == ' ')
+                    curIndent++;
+                else if (str->s[j] == '\n') {
+                    /* Empty line, doesn't influence minimum
+                       indentation. */
+                    curIndent = 0;
+                } else {
+                    atStartOfLine = false;
+                    if (curIndent < minIndent) minIndent = curIndent;
+                }
+            } else if (str->s[j] == '\n') {
+                atStartOfLine = true;
+                curIndent = 0;
+            }
         }
     }
 
     /* Strip spaces from each line. */
-    for (auto & line : lines) {
-        line.indentation.remove_prefix(std::min(minIndent, line.indentation.size()));
-    }
-
-    /* Concat the parts together again */
-
-    std::vector<std::pair<PosIdx, std::unique_ptr<Expr>>> parts;
-    /* Accumulator for merging intermediates */
-    PosIdx merged_pos;
-    std::string merged = "";
-
-    auto push_merged = [&] (PosIdx i_pos, std::string_view str) {
-        if (merged.empty()) {
-            merged_pos = i_pos;
-        }
-        merged += str;
+    std::vector<std::pair<PosIdx, std::unique_ptr<Expr>>> es2;
+    atStartOfLine = true;
+    size_t curDropped = 0;
+    size_t n = es.size();
+    auto i = es.begin();
+    const auto trimExpr = [&] (std::unique_ptr<Expr> e) {
+        atStartOfLine = false;
+        curDropped = 0;
+        es2.emplace_back(i->first, std::move(e));
     };
-
-    auto flush_merged = [&] () {
-        if (!merged.empty()) {
-            parts.emplace_back(merged_pos, std::make_unique<ExprString>(std::string(merged)));
-            merged.clear();
+    const auto trimString = [&] (const StringToken t) {
+        std::string s2;
+        for (size_t j = 0; j < t.s.size(); ++j) {
+            if (atStartOfLine) {
+                if (t.s[j] == ' ') {
+                    if (curDropped++ >= minIndent)
+                        s2 += t.s[j];
                 }
+                else if (t.s[j] == '\n') {
+                    curDropped = 0;
+                    s2 += t.s[j];
+                } else {
+                    atStartOfLine = false;
+                    curDropped = 0;
+                    s2 += t.s[j];
+                }
+            } else {
+                s2 += t.s[j];
+                if (t.s[j] == '\n') atStartOfLine = true;
+            }
+        }
+
+        /* 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);
+        }
+
+        es2.emplace_back(i->first, std::make_unique<ExprString>(std::move(s2)));
     };
-
-    for (auto && [li, line] : enumerate(lines)) {
-        push_merged(line.pos, line.indentation);
-
-        for (auto & val : line.parts) {
-            auto &[i_pos, item] = val;
-
-            std::visit(overloaded{
-                [&](std::string_view str) {
-                    push_merged(i_pos, str);
-                },
-                [&](std::unique_ptr<Expr> expr) {
-                    flush_merged();
-                    parts.emplace_back(i_pos, std::move(expr));
-                },
-            }, std::move(item));
-        }
+    for (; i != es.end(); ++i, --n) {
+        std::visit(overloaded { trimExpr, trimString }, std::move(i->second));
     }
 
-    flush_merged();
-
-    /* If this is a single string, then don't do a concatenation.
-     * (If it's a single expression, still do the ConcatStrings to properly force it being a string.)
-     */
-    if (parts.size() == 1 && dynamic_cast<ExprString *>(parts[0].second.get())) {
-        return std::move(parts[0].second);
+    /* If this is a single string, then don't do a concatenation. */
+    if (es2.size() == 1 && dynamic_cast<ExprString *>(es2[0].second.get())) {
+        return std::move(es2[0].second);
     }
-    return std::make_unique<ExprConcatStrings>(pos, true, std::move(parts));
+    return std::make_unique<ExprConcatStrings>(pos, true, std::move(es2));
 }
 
 }

src/libexpr/primops/fetchTree.cc

@@ -394,8 +394,7 @@ static RegisterPrimOp primop_fetchGit({
         [Git reference]: https://git-scm.com/book/en/v2/Git-Internals-Git-References
 
         By default, the `ref` value is prefixed with `refs/heads/`.
-        As of 2.3.0, Nix will not prefix `refs/heads/` if `ref` starts with `refs/` or
-        if `ref` looks like a commit hash for backwards compatibility with CppNix 2.3.
+        As of 2.3.0, Nix will not prefix `refs/heads/` if `ref` starts with `refs/`.
 
       - `submodules` (default: `false`)
 

src/libexpr/value.hh

@@ -136,9 +136,7 @@ class ExternalValueBase
 
 std::ostream & operator << (std::ostream & str, const ExternalValueBase & v);
 
-/** This is just the address of eBlackHole. It exists because eBlackHole has an
- * incomplete type at usage sites so is not possible to cast. */
-extern Expr *eBlackHoleAddr;
+extern ExprBlackHole eBlackHole;
 
 struct NewValueAs
 {
@@ -198,7 +196,6 @@ private:
 public:
 
     // Discount `using NewValueAs::*;`
-// NOLINTNEXTLINE(bugprone-macro-parentheses)
 #define USING_VALUETYPE(name) using name = NewValueAs::name
     USING_VALUETYPE(integer_t);
     USING_VALUETYPE(floating_t);
@@ -476,7 +473,7 @@ public:
     /// Constructs an evil thunk, whose evaluation represents infinite recursion.
     explicit Value(blackhole_t)
         : internalType(tThunk)
-        , thunk({ .env = nullptr, .expr = eBlackHoleAddr })
+        , thunk({ .env = nullptr, .expr = reinterpret_cast<Expr *>(&eBlackHole) })
     { }
 
     Value(Value const & rhs) = default;
@@ -516,10 +513,7 @@ public:
     // type() == nThunk
     inline bool isThunk() const { return internalType == tThunk; };
     inline bool isApp() const { return internalType == tApp; };
-    inline bool isBlackhole() const
-    {
-        return internalType == tThunk && thunk.expr == eBlackHoleAddr;
-    }
+    inline bool isBlackhole() const;
 
     // type() == nFunction
     inline bool isLambda() const { return internalType == tLambda; };
@@ -675,6 +669,11 @@ public:
 
     void mkStringMove(const char * s, const NixStringContext & context);
 
+    inline void mkString(const Symbol & s)
+    {
+        mkString(((const std::string &) s).c_str());
+    }
+
     void mkPath(const SourcePath & path);
 
     inline void mkPath(const char * path)
@@ -733,11 +732,7 @@ public:
         lambda.fun = f;
     }
 
-    inline void mkBlackhole()
-    {
-        internalType = tThunk;
-        thunk.expr = eBlackHoleAddr;
-    }
+    inline void mkBlackhole();
 
     void mkPrimOp(PrimOp * p);
 
@@ -837,6 +832,18 @@ public:
     }
 };
 
+
+bool Value::isBlackhole() const
+{
+    return internalType == tThunk && thunk.expr == (Expr*) &eBlackHole;
+}
+
+void Value::mkBlackhole()
+{
+    internalType = tThunk;
+    thunk.expr = (Expr*) &eBlackHole;
+}
+
 using ValueVector = GcVector<Value *>;
 using ValueMap = GcMap<Symbol, Value *>;
 using ValueVectorMap = std::map<Symbol, ValueVector>;

src/libfetchers/fetch-settings.cc

@@ -7,33 +7,7 @@
 
 namespace nix {
 
-void to_json(nlohmann::json & j, const AcceptFlakeConfig & e)
-{
-    if (e == AcceptFlakeConfig::False) {
-        j = false;
-    } else if (e == AcceptFlakeConfig::Ask) {
-        j = "ask";
-    } else if (e == AcceptFlakeConfig::True) {
-        j = true;
-    } else {
-        abort();
-    }
-}
-
-void from_json(const nlohmann::json & j, AcceptFlakeConfig & e)
-{
-    if (j == false) {
-        e = AcceptFlakeConfig::False;
-    } else if (j == "ask") {
-        e = AcceptFlakeConfig::Ask;
-    } else if (j == true) {
-        e = AcceptFlakeConfig::True;
-    } else {
-        throw Error("Invalid accept-flake-config value '%s'", std::string(j));
-    }
-}
-
-template<> AcceptFlakeConfig BaseSetting<AcceptFlakeConfig>::parse(const std::string & str, const ApplyConfigOptions & options) const
+template<> AcceptFlakeConfig BaseSetting<AcceptFlakeConfig>::parse(const std::string & str) const
 {
     if (str == "true") return AcceptFlakeConfig::True;
     else if (str == "ask") return AcceptFlakeConfig::Ask;

src/libfetchers/fetch-settings.hh

@@ -13,9 +13,6 @@ namespace nix {
 
 enum class AcceptFlakeConfig { False, Ask, True };
 
-void to_json(nlohmann::json & j, const AcceptFlakeConfig & e);
-void from_json(const nlohmann::json & j, AcceptFlakeConfig & e);
-
 struct FetchSettings : public Config
 {
     FetchSettings();

src/libfetchers/fetchers.hh

@@ -7,8 +7,6 @@
 #include "path.hh"
 #include "attrs.hh"
 #include "url.hh"
-#include "ref.hh"
-#include "strings.hh"
 
 #include <memory>
 
@@ -209,7 +207,7 @@ DownloadFileResult downloadFile(
     const std::string & url,
     const std::string & name,
     bool locked,
-    Headers headers = {});
+    const Headers & headers = {});
 
 struct DownloadTarballResult
 {

src/libfetchers/git.cc

@@ -1,4 +1,3 @@
-#include "error.hh"
 #include "fetchers.hh"
 #include "cache.hh"
 #include "globals.hh"
@@ -258,28 +257,6 @@ std::pair<StorePath, Input> fetchFromWorkdir(ref<Store> store, Input & input, co
 }
 }  // end namespace
 
-static std::optional<Path> resolveRefToCachePath(
-    Input & input,
-    const Path & cacheDir,
-    std::vector<Path> & gitRefFileCandidates,
-    std::function<bool(const Path&)> condition)
-{
-    if (input.getRef()->starts_with("refs/")) {
-        Path fullpath = cacheDir + "/" + *input.getRef();
-        if (condition(fullpath)) {
-            return fullpath;
-        }
-    }
-
-    for (auto & candidate : gitRefFileCandidates) {
-        if (condition(candidate)) {
-            return candidate;
-        }
-    }
-
-    return std::nullopt;
-}
-
 struct GitInputScheme : InputScheme
 {
     std::optional<Input> inputFromURL(const ParsedURL & url, bool requireTree) const override
@@ -562,13 +539,10 @@ struct GitInputScheme : InputScheme
                 runProgram("git", true, { "-c", "init.defaultBranch=" + gitInitialBranch, "init", "--bare", repoDir });
             }
 
-            std::vector<Path> gitRefFileCandidates;
-            for (auto & infix : {"", "tags/", "heads/"}) {
-                Path p = cacheDir + "/refs/" + infix + *input.getRef();
-                gitRefFileCandidates.push_back(p);
-            }
-
-            Path localRefFile;
+            Path localRefFile =
+                input.getRef()->compare(0, 5, "refs/") == 0
+                ? cacheDir + "/" + *input.getRef()
+                : cacheDir + "/refs/heads/" + *input.getRef();
 
             bool doFetch;
             time_t now = time(0);
@@ -590,70 +564,29 @@ struct GitInputScheme : InputScheme
                 if (allRefs) {
                     doFetch = true;
                 } else {
-                    std::function<bool(const Path&)> condition;
-                    condition = [&now](const Path & path) {
                     /* If the local ref is older than ‘tarball-ttl’ seconds, do a
                        git fetch to update the local ref to the remote ref. */
                     struct stat st;
-                        return stat(path.c_str(), &st) == 0 &&
-                            isCacheFileWithinTtl(now, st);
-                    };
-                    if (auto result = resolveRefToCachePath(
-                        input,
-                        cacheDir,
-                        gitRefFileCandidates,
-                        condition
-                    )) {
-                        localRefFile = *result;
-                        doFetch = false;
-                    } else {
-                        doFetch = true;
-                    }
+                    doFetch = stat(localRefFile.c_str(), &st) != 0 ||
+                        !isCacheFileWithinTtl(now, st);
                 }
             }
 
-            // When having to fetch, we don't know `localRefFile` yet.
-            // Because git needs to figure out what we're fetching
-            // (i.e. is it a rev? a branch? a tag?)
             if (doFetch) {
                 Activity act(*logger, lvlTalkative, actUnknown, fmt("fetching Git repository '%s'", actualUrl));
 
-                auto ref = input.getRef();
-                std::string fetchRef;
-                if (allRefs) {
-                    fetchRef = "refs/*";
-                } else if (
-                    ref->starts_with("refs/")
-                    || *ref == "HEAD"
-                    || std::regex_match(*ref, revRegex))
-                {
-                    fetchRef = *ref;
-                } else {
-                    fetchRef = "refs/*/" + *ref;
-                }
-
-                try {
-                    Finally finally([&]() {
-                        if (auto p = resolveRefToCachePath(
-                            input,
-                            cacheDir,
-                            gitRefFileCandidates,
-                            pathExists
-                        )) {
-                            localRefFile = *p;
-                        }
-                    });
-
                 // FIXME: git stderr messes up our progress indicator, so
                 // we're using --quiet for now. Should process its stderr.
-                    runProgram("git", true, {
-                        "-C", repoDir,
-                        "--git-dir", gitDir,
-                        "fetch",
-                        "--quiet",
-                        "--force",
-                        "--", actualUrl, fmt("%s:%s", fetchRef, fetchRef)
-                    }, true);
+                try {
+                    auto ref = input.getRef();
+                    auto fetchRef = allRefs
+                        ? "refs/*"
+                        : ref->compare(0, 5, "refs/") == 0
+                            ? *ref
+                            : ref == "HEAD"
+                                ? *ref
+                                : "refs/heads/" + *ref;
+                    runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "fetch", "--quiet", "--force", "--", actualUrl, fmt("%s:%s", fetchRef, fetchRef) }, true);
                 } catch (Error & e) {
                     if (!pathExists(localRefFile)) throw;
                     warn("could not update local clone of Git repository '%s'; continuing with the most recent version", actualUrl);

src/libfetchers/tarball.cc

@@ -15,7 +15,7 @@ DownloadFileResult downloadFile(
     const std::string & url,
     const std::string & name,
     bool locked,
-    Headers headers)
+    const Headers & headers)
 {
     // FIXME: check store
 
@@ -40,14 +40,13 @@ DownloadFileResult downloadFile(
     if (cached && !cached->expired)
         return useCached();
 
+    FileTransferRequest request(url);
+    request.headers = headers;
     if (cached)
-        headers.emplace_back("If-None-Match", getStrAttr(cached->infoAttrs, "etag"));
+        request.expectedETag = getStrAttr(cached->infoAttrs, "etag");
     FileTransferResult res;
-    std::string data;
     try {
-        auto [meta, content] = getFileTransfer()->download(url, headers);
-        res = std::move(meta);
-        data = content->drain();
+        res = getFileTransfer()->transfer(request);
     } catch (FileTransferError & e) {
         if (cached) {
             warn("%s; using cached version", e.msg());
@@ -72,8 +71,8 @@ DownloadFileResult downloadFile(
         storePath = std::move(cached->storePath);
     } else {
         StringSink sink;
-        sink << dumpString(data);
-        auto hash = hashString(HashType::SHA256, data);
+        sink << dumpString(res.data);
+        auto hash = hashString(HashType::SHA256, res.data);
         ValidPathInfo info {
             *store,
             name,

src/libmain/crash-handler.cc

@@ -1,41 +0,0 @@
-#include "crash-handler.hh"
-#include "fmt.hh"
-
-#include <boost/core/demangle.hpp>
-#include <exception>
-
-namespace nix {
-
-namespace {
-void onTerminate()
-{
-    std::cerr << "Lix crashed. This is a bug. We would appreciate if you report it along with what caused it at https://git.lix.systems/lix-project/lix/issues with the following information included:\n\n";
-    try {
-        std::exception_ptr eptr = std::current_exception();
-        if (eptr) {
-            std::rethrow_exception(eptr);
-        } else {
-            std::cerr << "std::terminate() called without exception\n";
-        }
-    } catch (const std::exception & ex) {
-        std::cerr << "Exception: " << boost::core::demangle(typeid(ex).name()) << ": " << ex.what() << "\n";
-    } catch (...) {
-        std::cerr << "Unknown exception! Spooky.\n";
-    }
-
-    std::cerr << "Stack trace:\n";
-    nix::printStackTrace();
-
-    std::abort();
-}
-}
-
-void registerCrashHandler()
-{
-    // DO NOT use this for signals. Boost stacktrace is very much not
-    // async-signal-safe, and in a world with ASLR, addr2line is pointless.
-    //
-    // If you want signals, set up a minidump system and do it out-of-process.
-    std::set_terminate(onTerminate);
-}
-}