burn it all

Change-Id: I0db6eee7d6aae3e02ea0155c04a55a7142e456c3

.clang-format

@@ -0,0 +1,30 @@
+BasedOnStyle: LLVM
+IndentWidth: 4
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterStruct: true
+  AfterClass: true
+  AfterFunction: true
+  AfterUnion: true
+  SplitEmptyRecord: false
+PointerAlignment: Middle
+FixNamespaceComments: false
+SortIncludes: Never
+#IndentPPDirectives: BeforeHash
+SpaceAfterCStyleCast: true
+SpaceAfterTemplateKeyword: false
+AccessModifierOffset: -4
+AlignAfterOpenBracket: AlwaysBreak
+AlignEscapedNewlines: DontAlign
+ColumnLimit: 120
+BreakStringLiterals: false
+BitFieldColonSpacing: None
+AllowShortFunctionsOnASingleLine: Empty
+AlwaysBreakTemplateDeclarations: Yes
+BinPackParameters: false
+BreakConstructorInitializers: BeforeComma
+EmptyLineAfterAccessModifier: Leave # change to always/never later?
+EmptyLineBeforeAccessModifier: Leave
+#PackConstructorInitializers: BinPack
+BreakBeforeBinaryOperators: NonAssignment
+AlwaysBreakBeforeMultilineStrings: true

Makefile

@@ -41,6 +41,7 @@ makefiles += \
   tests/functional/ca/local.mk \
   tests/functional/dyn-drv/local.mk \
   tests/functional/test-libstoreconsumer/local.mk \
+  tests/functional/repl_characterization/local.mk \
   tests/functional/plugins/local.mk
 else
 makefiles += \

doc/manual/rl-next/debugger-on-trace.md

@@ -0,0 +1,9 @@
+---
+synopsis: Enter the `--debugger` when `builtins.trace` is called if `debugger-on-trace` is set
+prs: 9914
+---
+
+If the `debugger-on-trace` option is set and `--debugger` is given,
+`builtins.trace` calls will behave similarly to `builtins.break` and will enter
+the debug REPL. This is useful for determining where warnings are being emitted
+from.

doc/manual/rl-next/inherit-from-by-need.md

@@ -0,0 +1,7 @@
+---
+synopsis: "`inherit (x) ...` evaluates `x` only once"
+prs: 9847
+---
+
+`inherit (x) a b ...` now evaluates the expression `x` only once for all inherited attributes rather than once for each inherited attribute.
+This does not usually have a measurable impact, but side-effects (such as `builtins.trace`) would be duplicated and expensive expressions (such as derivations) could cause a measurable slowdown.

flake.nix

@@ -126,8 +126,8 @@
         dontBuild = true;
         doInstallCheck = true;
 
-        configureFlags = [
-          "RAPIDCHECK_HEADERS=${lib.getDev pkgs.rapidcheck}/extras/gtest/include"
+        configureFlags = prevAttrs.configureFlags ++ [
+          # We don't need the actual build here.
           "--disable-build"
         ];
 
@@ -135,9 +135,9 @@
           mkdir -p $out
         '';
 
-        installCheckPhase = (lib.optionalString pkgs.stdenv.hostPlatform.isDarwin ''
+        installCheckPhase = lib.optionalString pkgs.stdenv.hostPlatform.isDarwin ''
           export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
-        '') + ''
+        '' + ''
           mkdir -p src/nix-channel
           make installcheck -j$NIX_BUILD_CORES -l$NIX_BUILD_CORES
         '';
@@ -218,7 +218,13 @@
           '';
 
       overlayFor = getStdenv: final: prev:
-        {
+        let
+          currentStdenv = getStdenv final;
+          comDeps = with final; commonDeps {
+            inherit pkgs;
+            inherit (currentStdenv.hostPlatform) isStatic;
+          };
+        in {
           nixStable = prev.nix;
 
           # Forward from the previous stage as we don’t want it to pick the lowdown override
@@ -261,8 +267,8 @@
           };
 
           nix = final.callPackage ./package.nix {
-            inherit (final) stdenv;
             inherit versionSuffix fileset;
+            stdenv = currentStdenv;
             boehmgc = final.boehmgc-nix;
             busybox-sandbox-shell = final.busybox-sandbox-shell or final.default-busybox-sandbox-shell;
           };
@@ -297,44 +303,17 @@
           nix = pkgs.callPackage ./package.nix {
             inherit versionSuffix fileset officialRelease buildUnreleasedNotes;
             inherit (pkgs) changelog-d;
+            internalApiDocs = true;
             boehmgc = pkgs.boehmgc-nix;
             busybox-sandbox-shell = pkgs.busybox-sandbox-shell;
           };
         in
           nix.overrideAttrs (prev: {
-            pname = "nix-internal-api-docs";
-
-            outputs = [ "out" ];
-            separateDebugInfo = false;
-
-            nativeBuildInputs = prev.nativeBuildInputs ++ [ pkgs.doxygen ];
-
-            # Depropagate the build inputs for the docs build.
-            propagatedBuildInputs = [ ];
-            buildInputs = prev.buildInputs ++ [ pkgs.buildPackages.doxygen ] ++ [
-              pkgs.gtest
-              pkgs.rapidcheck
-            ] ++ prev.propagatedBuildInputs;
-
-            configureFlags = prev.configureFlags ++ [
-              "--enable-internal-api-docs"
-              "RAPIDCHECK_HEADERS=${lib.getDev pkgs.rapidcheck}/extras/gtest/include"
-            ];
-
-            installTargets = [ "internal-api-html" ];
-
-            # Convince the package.nix logic that we're building,
-            # but don't actually run the build phase.
-            env.dontBuild = true;
-
+            # This Hydra job is just for the internal API docs.
+            # We don't need the build artifacts here.
+            dontBuild = true;
             doCheck = false;
             doInstallCheck = false;
-
-            postInstall = ''
-              mkdir -p $out/nix-support
-              echo "doc internal-api-docs $out/share/doc/nix/internal-api/html" > $out/nix-support/hydra-build-products
-              rm $out/lib -rf
-            '';
           });
 
         # System tests.
@@ -349,7 +328,7 @@
                 type -p nix-env
                 # Note: we're filtering out nixos-install-tools because https://github.com/NixOS/nixpkgs/pull/153594#issuecomment-1020530593.
                 time nix-env --store dummy:// -f ${nixpkgs-regression} -qaP --drv-path | sort | grep -v nixos-install-tools > packages
-                [[ $(sha1sum < packages | cut -c1-40) = ff451c521e61e4fe72bdbe2d0ca5d1809affa733 ]]
+                [[ $(sha1sum < packages | cut -c1-40) = 402242fca90874112b34718b8199d844e8b03d12 ]]
                 mkdir $out
               '';
 
@@ -438,10 +417,9 @@
                 ++ lib.optional
                   (stdenv.cc.isClang && stdenv.hostPlatform == stdenv.buildPlatform)
                   pkgs.buildPackages.clang-tools;
-                src = null;
 
-              doInstallCheck = false;
-              doCheck = false;
+              src = null;
+
               installFlags = "sysconfdir=$(out)/etc";
               strictDeps = false;
 

meson.build

@@ -1,222 +0,0 @@
-project('lix', 'cpp',
-  version : run_command('bash', '-c', 'echo -n $(cat ./.version)$VERSION_SUFFIX', check : true).stdout().strip(),
-  default_options : [
-    'cpp_std=c++20',
-    'warning_level=1',
-    'debug=true',
-    'optimization=3',
-  ],
-)
-
-cxx = meson.get_compiler('cpp')
-
-host_system = host_machine.cpu_family() + '-' + host_machine.system()
-message('canonical Nix system name:', host_system)
-
-all_sources = { }
-all_deps = { }
-
-deps = [ ]
-configdata = { }
-
-#
-# Dependencies
-#
-
-boehm = dependency('bdw-gc', required : get_option('gc'))
-if boehm.found()
-  deps += boehm
-endif
-configdata += {
-  'HAVE_BOEHMGC': boehm.found().to_int(),
-}
-
-boost = dependency('boost', required : true, modules : ['context', 'coroutine', 'container'])
-deps += boost
-
-cpuid = dependency('libcpuid', 'cpuid', required : get_option('cpuid'))
-configdata += {
-  'HAVE_LIBCPUID': cpuid.found().to_int(),
-  }
-deps += cpuid
-
-seccomp = dependency('libseccomp', 'seccomp', required : get_option('seccomp-sandboxing'))
-configdata += {
-  'HAVE_SECCOMP': seccomp.found().to_int(),
-  }
-
-libarchive = dependency('libarchive', required : true)
-deps += libarchive
-
-brotli = [
-  dependency('libbrotlicommon', required : true),
-  dependency('libbrotlidec', required : true),
-  dependency('libbrotlienc', required : true),
-  ]
-deps += brotli
-
-openssl = dependency('libcrypto', 'openssl', required : true)
-deps += openssl
-
-aws_sdk = dependency('aws-cpp-sdk-core', required : true)
-if aws_sdk.found()
-  # The AWS pkg-config adds -std=c++11.
-  aws_sdk = aws_sdk.partial_dependency(
-    compile_args : false,
-    includes : true,
-    link_args : true,
-    links : true,
-    sources : true,
-  )
-  deps += aws_sdk
-  s = aws_sdk.version().split('.')
-  configdata += {
-    'AWS_VERSION_MAJOR': s[0].to_int(),
-    'AWS_VERSION_MINOR': s[1].to_int(),
-    'AWS_VERSION_PATCH': s[2].to_int(),
-  }
-  aws_sdk_transfer = dependency('aws-cpp-sdk-transfer', required : true).partial_dependency(
-    compile_args : false,
-    includes : true,
-    link_args : true,
-    links : true,
-    sources : true,
-  )
-endif
-aws_s3 = dependency('aws-cpp-sdk-s3', required : true)
-if aws_s3.found()
-  # The AWS pkg-config adds -std=c++11.
-  aws_s3 = aws_s3.partial_dependency(
-    compile_args : false,
-    includes : true,
-    link_args : true,
-    links : true,
-    sources : true,
-  )
-  deps += aws_s3
-endif
-
-sqlite = dependency('sqlite3', 'sqlite', version : '>=3.6.19', required : true)
-deps += sqlite
-
-sodium = dependency('sodium', 'libsodium', required : true)
-deps += sodium
-
-curl = dependency('libcurl', 'curl', required : true)
-deps += curl
-
-editline = dependency('libeditline', 'editline', version : '>=1.14', required : true)
-deps += editline
-
-lowdown = dependency('lowdown', version : '>=0.9.0', required : true)
-deps += lowdown
-
-#
-# Build-time tools
-#
-bash = find_program('bash')
-lsof = find_program('lsof')
-
-# This is how Nix does generated headers...
-# FIXME(Qyriad): do we really need to use the shell for this?
-gen_header = generator(
-  bash,
-  arguments : [
-    '-c',
-    'echo \'R"foo(\' | cat - @INPUT@ && echo \')foo"\'',
-  ],
-  capture : true,
-  output : '@PLAINNAME@.gen.hh',
-)
-
-#
-# Configuration
-#
-
-# FIXME(Qyriad): at least do this in the build directory
-run_command('ln', '-s', 'bla', 'tmp_link', check : true)
-can_link_symlink = run_command('ln', 'tmp_link', 'tmp_link2', check : false).returncode() == 0
-run_command('rm', '-f', 'tmp_link', 'tmp_link2', check : true)
-message('possible to create a link to a symlink:', can_link_symlink)
-configdata += { 'CAN_LINK_SYMLINK': can_link_symlink.to_int() }
-
-check_headers = [
-  # I can't use dictionaries here as they can only contain identifier-strings.
-  ['aws/s3/S3Client.h', aws_s3]
-]
-
-foreach headerspec : check_headers
-  key = headerspec[0]
-  value = headerspec[1]
-  define_name = 'HAVE_' + key.underscorify().to_upper()
-  define_value = cxx.check_header(key, dependencies : value).to_int()
-  configdata += { define_name: define_value }
-endforeach
-
-check_funcs = [
-  'lchown',
-  'lutimes',
-  'pipe2',
-  'posix_fallocate',
-  'statvfs',
-  'strsignal',
-  'sysconf',
-]
-
-foreach funcspec : check_funcs
-  define_name = 'HAVE_' + funcspec.underscorify().to_upper()
-  define_value = cxx.has_function(funcspec).to_int()
-  configdata += {
-    define_name: define_value,
-  }
-endforeach
-
-has_pubsetbuf = cxx.compiles('''
-  #include <iostream>
-  using namespace std;
-  static char buf[1024];
-  decltype(cerr.rdbuf()->pubsetbuf(buf, sizeof(buf))) _;
-''')
-message('have function "\x1b[1mstd::basic_streambuf::pubsetbuf\x1b[0m" :', has_pubsetbuf)
-configdata += {
-  'HAVE_PUBSETBUF': has_pubsetbuf.to_int(),
-}
-
-configdata += {
-  'ENABLE_S3': aws_s3.found().to_int(),
-}
-
-configure_file(
-  configuration : {
-    'PACKAGE_NAME': '"' + meson.project_name() + '"',
-    'PACKAGE_VERSION': '"' + meson.project_version() + '"',
-    'PACKAGE_TARNAME': '"' + meson.project_name() + '"',
-    'PACKAGE_STRING': '"' + meson.project_name() + ' ' + meson.project_version() + '"',
-    'HAVE_STRUCT_DIRENT_D_TYPE': 1, # FIXME: actually check this for solaris
-    'SYSTEM': '"' + host_system + '"',
-  } + configdata,
-  output : 'config.h',
-)
-
-add_project_arguments(
-  # TODO(Qyriad): Yes this is how the autoconf+Make system did it.
-  # I would love to remove this.
-  '-include', 'config.h',
-  # TODO(Qyriad): would love to remove these
-  '-Wno-deprecated-declarations',
-  '-Wno-unused-parameter',
-  '-Wno-missing-field-initializers',
-  '-Wno-deprecated-copy',
-  '-pthread',
-  #'-fPIC',
-  language : 'cpp',
-)
-
-# FIXME(Qyriad): only if not Darwin, Solaris, or FreeBSD
-# (...so only if Linux?)
-add_project_link_arguments(
-  '-Wl,--no-copy-dt-needed-entries',
-  language : 'cpp',
-)
-
-subdir('src')

meson.options

@@ -1,24 +0,0 @@
-# vim: filetype=meson
-option('gc', type : 'feature',
-  description : 'enable garbage collection in the Nix expression evaluator (requires Boehm GC)',
-)
-# TODO(Qyriad): is this feature maintained?
-option('embedded-sandbox-shell', type : 'feature',
-  description : 'include the sandbox shell in the Nix bindary',
-)
-
-option('cpuid', type : 'feature',
-  description : 'determine microarchitecture levels with libcpuid (only relevant on x86_64)',
-)
-
-option('seccomp-sandboxing', type : 'feature',
-  description : 'build support for seccomp sandboxing (recommended unless your arch doesn\'t support libseccomp, only relevant on Linux)',
-)
-
-option('store-dir', type : 'string', value : '/nix/store',
-  description : 'path of the Nix store',
-)
-
-option('sandbox-shell', type : 'string',
-  description : 'path to a statically-linked shell to use as /bin/sh in sandboxes (usually busybox)',
-)

mk/programs.mk

@@ -6,6 +6,9 @@ programs-list :=
 # - $(1)_NAME: the name of the program (e.g. ‘foo’); defaults to
 #   $(1).
 #
+# - $(1)_ENV: environment variables to set when running the program
+#   from the Makefile using the $(1)_RUN target.
+#
 # - $(1)_DIR: the directory where the (non-installed) program will be
 #   placed.
 #
@@ -87,6 +90,6 @@ define build-program
   # Phony target to run this program (typically as a dependency of 'check').
   .PHONY: $(1)_RUN
   $(1)_RUN: $$($(1)_PATH)
-	$(trace-test) $$(UNIT_TEST_ENV) $$($(1)_PATH)
+	$(trace-test) $$($(1)_ENV) $$($(1)_PATH)
 
 endef

package.nix

@@ -9,11 +9,11 @@
   nlohmann_json,
   bison,
   changelog-d,
-  cmake,
   boost,
   brotli,
   bzip2,
   curl,
+  doxygen,
   editline,
   fileset,
   flex,
@@ -24,13 +24,10 @@
   libcpuid,
   libseccomp,
   libsodium,
-  lsof,
   lowdown,
   mdbook,
   mdbook-linkcheck,
   mercurial,
-  meson,
-  ninja,
   openssl,
   pkg-config,
   rapidcheck,
@@ -46,6 +43,7 @@
   officialRelease ? true,
   # Set to true to build the release notes for the next release.
   buildUnreleasedNotes ? false,
+  internalApiDocs ? false,
 
   # Not a real argument, just the only way to approximate let-binding some
   # stuff for argument defaults.
@@ -66,6 +64,13 @@
     "RAPIDCHECK_HEADERS=${lib.getDev rapidcheck}/extras/gtest/include"
   ];
 
+  # The internal API docs need these for the build, but if we're not building
+  # Nix itself, then these don't need to be propagated.
+  maybePropagatedInputs = [
+    boehmgc
+    nlohmann_json
+  ];
+
   # .gitignore has already been processed, so any changes in it are irrelevant
   # at this point. It is not represented verbatim for test purposes because
   # that would interfere with repo semantics.
@@ -101,8 +106,7 @@ in stdenv.mkDerivation (finalAttrs: {
       configureFiles
       topLevelBuildFiles
       functionalTestFiles
-      ./unit-test-data
-    ] ++ lib.optionals finalAttrs.doBuild [
+    ] ++ lib.optionals (!finalAttrs.dontBuild || internalApiDocs) [
       ./boehmgc-coroutine-sp-fallback.diff
       ./doc
       ./misc
@@ -116,10 +120,9 @@ in stdenv.mkDerivation (finalAttrs: {
   VERSION_SUFFIX = versionSuffix;
 
   outputs = [ "out" ]
-    ++ lib.optionals finalAttrs.doBuild [ "dev" "doc" ];
+    ++ lib.optionals (!finalAttrs.dontBuild) [ "dev" "doc" ];
 
-  # dontBuild isn't specified most of the time, where it is implicitly false.
-  doBuild = !(finalAttrs.dontBuild or false);
+  dontBuild = false;
 
   nativeBuildInputs = [
     bison
@@ -136,12 +139,10 @@ in stdenv.mkDerivation (finalAttrs: {
     git
     mercurial
     jq
-    cmake
-    meson
-    ninja
-    lsof
   ] ++ lib.optional stdenv.hostPlatform.isLinux util-linuxMinimal
-    ++ lib.optional (!officialRelease && buildUnreleasedNotes) changelog-d;
+    ++ lib.optional (!officialRelease && buildUnreleasedNotes) changelog-d
+    ++ lib.optional internalApiDocs doxygen
+  ;
 
   buildInputs = [
     curl
@@ -160,6 +161,7 @@ in stdenv.mkDerivation (finalAttrs: {
     ++ lib.optional stdenv.hostPlatform.isx86_64 libcpuid
     # There have been issues building these dependencies
     ++ lib.optional (stdenv.hostPlatform == stdenv.buildPlatform) aws-sdk-cpp-nix
+    ++ lib.optionals (finalAttrs.dontBuild) maybePropagatedInputs
   ;
 
   checkInputs = [
@@ -167,38 +169,35 @@ in stdenv.mkDerivation (finalAttrs: {
     rapidcheck
   ];
 
-  propagatedBuildInputs = [
-    boehmgc
-    nlohmann_json
-  ];
+  propagatedBuildInputs = lib.optionals (!finalAttrs.dontBuild) maybePropagatedInputs;
 
   disallowedReferences = [
     boost
   ];
 
-  # Needed for Meson to find Boost.
-  # https://github.com/NixOS/nixpkgs/issues/86131.
-  env.BOOST_INCLUDEDIR = "${lib.getDev boost}/include";
-  env.BOOST_LIBRARYDIR = "${lib.getLib boost}/lib";
-
-  preConfigure = lib.optionalString (finalAttrs.doBuild && (! stdenv.hostPlatform.isStatic)) ''
-      # Copy libboost_context so we don't get all of Boost in our closure.
-      # https://github.com/NixOS/nixpkgs/issues/45462
-      mkdir -p $out/lib
-      cp -pd ${boost}/lib/{libboost_context*,libboost_thread*,libboost_system*} $out/lib
-      rm -f $out/lib/*.a
-      ${lib.optionalString stdenv.hostPlatform.isLinux ''
-        chmod u+w $out/lib/*.so.*
-        patchelf --set-rpath $out/lib:${stdenv.cc.cc.lib}/lib $out/lib/libboost_thread.so.*
-      ''}
-      ${lib.optionalString stdenv.hostPlatform.isDarwin ''
-        for LIB in $out/lib/*.dylib; do
-          chmod u+w $LIB
-          install_name_tool -id $LIB $LIB
-          install_name_tool -delete_rpath ${boost}/lib/ $LIB || true
-        done
-        install_name_tool -change ${boost}/lib/libboost_system.dylib $out/lib/libboost_system.dylib $out/lib/libboost_thread.dylib
-      ''}
+  preConfigure = lib.optionalString (!finalAttrs.dontBuild && !stdenv.hostPlatform.isStatic) ''
+    # Copy libboost_context so we don't get all of Boost in our closure.
+    # https://github.com/NixOS/nixpkgs/issues/45462
+    mkdir -p $out/lib
+    cp -pd ${boost}/lib/{libboost_context*,libboost_thread*,libboost_system*} $out/lib
+    rm -f $out/lib/*.a
+  '' + lib.optionalString (!finalAttrs.dontBuild && stdenv.hostPlatform.isLinux) ''
+    chmod u+w $out/lib/*.so.*
+    patchelf --set-rpath $out/lib:${stdenv.cc.cc.lib}/lib $out/lib/libboost_thread.so.*
+  '' + lib.optionalString (!finalAttrs.dontBuild && stdenv.hostPlatform.isDarwin) ''
+    for LIB in $out/lib/*.dylib; do
+      chmod u+w $LIB
+      install_name_tool -id $LIB $LIB
+      install_name_tool -delete_rpath ${boost}/lib/ $LIB || true
+    done
+    install_name_tool -change ${boost}/lib/libboost_system.dylib $out/lib/libboost_system.dylib $out/lib/libboost_thread.dylib
+  '' + ''
+    # Workaround https://github.com/NixOS/nixpkgs/issues/294890.
+    if [[ -n "''${doCheck:-}" ]]; then
+      appendToVar configureFlags "--enable-tests"
+    else
+      appendToVar configureFlags "--disable-tests"
+    fi
   '';
 
   configureFlags = lib.optionals stdenv.isLinux [
@@ -208,11 +207,13 @@ in stdenv.mkDerivation (finalAttrs: {
     "LDFLAGS=-fuse-ld=gold"
   ] ++ [ "--sysconfdir=/etc" ]
     ++ lib.optional stdenv.hostPlatform.isStatic "--enable-embedded-sandbox-shell"
-    ++ [ (lib.enableFeature finalAttrs.doCheck "tests") ]
-    ++ lib.optionals finalAttrs.doCheck testConfigureFlags
+    ++ lib.optionals (finalAttrs.doCheck || internalApiDocs) testConfigureFlags
     ++ lib.optional (!canRunInstalled) "--disable-doc-gen"
+    ++ [ (lib.enableFeature internalApiDocs "internal-api-docs") ]
   ;
 
+  installTargets = lib.optional internalApiDocs "internal-api-html";
+
   enableParallelBuilding = true;
 
   makeFlags = "profiledir=$(out)/etc/profile.d PRECOMPILE_HEADERS=1";
@@ -221,19 +222,20 @@ in stdenv.mkDerivation (finalAttrs: {
 
   installFlags = "sysconfdir=$(out)/etc";
 
-  postInstall = ''
-      mkdir -p $doc/nix-support
-      echo "doc manual $doc/share/doc/nix/manual" >> $doc/nix-support/hydra-build-products
-      ${lib.optionalString stdenv.hostPlatform.isStatic ''
-      mkdir -p $out/nix-support
-      echo "file binary-dist $out/bin/nix" >> $out/nix-support/hydra-build-products
-      ''}
-      ${lib.optionalString stdenv.isDarwin ''
-      install_name_tool \
-        -change ${boost}/lib/libboost_context.dylib \
-        $out/lib/libboost_context.dylib \
-        $out/lib/libnixutil.dylib
-      ''}
+  postInstall = lib.optionalString (!finalAttrs.dontBuild) ''
+    mkdir -p $doc/nix-support
+    echo "doc manual $doc/share/doc/nix/manual" >> $doc/nix-support/hydra-build-products
+  '' + lib.optionalString stdenv.hostPlatform.isStatic ''
+    mkdir -p $out/nix-support
+    echo "file binary-dist $out/bin/nix" >> $out/nix-support/hydra-build-products
+  '' + lib.optionalString stdenv.isDarwin ''
+    install_name_tool \
+      -change ${boost}/lib/libboost_context.dylib \
+      $out/lib/libboost_context.dylib \
+      $out/lib/libnixutil.dylib
+  '' + lib.optionalString internalApiDocs ''
+    mkdir -p $out/nix-support
+    echo "doc internal-api-docs $out/share/doc/nix/internal-api/html" >> "$out/nix-support/hydra-build-products"
   '';
 
   doInstallCheck = finalAttrs.doCheck;
@@ -244,7 +246,7 @@ in stdenv.mkDerivation (finalAttrs: {
     export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
   '';
 
-  separateDebugInfo = !stdenv.hostPlatform.isStatic && finalAttrs.doBuild;
+  separateDebugInfo = !stdenv.hostPlatform.isStatic && !finalAttrs.dontBuild;
 
   strictDeps = true;
 

src/libcmd/meson.build

@@ -1,35 +0,0 @@
-libcmd_sources = files(
-  'built-path.cc',
-  'command-installable-value.cc',
-  'command.cc',
-  'common-eval-args.cc',
-  'editor-for.cc',
-  'installable-attr-path.cc',
-  'installable-derived-path.cc',
-  'installable-flake.cc',
-  'installable-value.cc',
-  'installables.cc',
-  'legacy.cc',
-  'markdown.cc',
-  'repl.cc',
-)
-
-libcmd = library(
-  'nixcmd',
-  libcmd_sources,
-  dependencies : [
-    liblixutil,
-    liblixstore,
-    liblixexpr,
-    liblixfetchers,
-    liblixmain,
-    boehm,
-    editline,
-    lowdown,
-  ],
-)
-
-liblixcmd = declare_dependency(
-  include_directories : '.',
-  link_with : libcmd,
-)

src/libcmd/repl-interacter.cc

@@ -0,0 +1,208 @@
+#include <cstdio>
+#include <iostream>
+#include <string>
+
+#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.
+// For compatibility with these versions, we wrap the API here
+// (wrapping multiple times on newer versions is no problem).
+extern "C" {
+#include <editline.h>
+}
+#endif
+
+#include "signals.hh"
+#include "finally.hh"
+#include "repl-interacter.hh"
+#include "util.hh"
+#include "repl.hh"
+
+namespace nix {
+
+namespace {
+// Used to communicate to NixRepl::getLine whether a signal occurred in ::readline.
+volatile sig_atomic_t g_signal_received = 0;
+
+void sigintHandler(int signo)
+{
+    g_signal_received = signo;
+}
+};
+
+static detail::ReplCompleterMixin * curRepl; // ugly
+
+static char * completionCallback(char * s, int * match)
+{
+    auto possible = curRepl->completePrefix(s);
+    if (possible.size() == 1) {
+        *match = 1;
+        auto * res = strdup(possible.begin()->c_str() + strlen(s));
+        if (!res)
+            throw Error("allocation failure");
+        return res;
+    } else if (possible.size() > 1) {
+        auto checkAllHaveSameAt = [&](size_t pos) {
+            auto & first = *possible.begin();
+            for (auto & p : possible) {
+                if (p.size() <= pos || p[pos] != first[pos])
+                    return false;
+            }
+            return true;
+        };
+        size_t start = strlen(s);
+        size_t len = 0;
+        while (checkAllHaveSameAt(start + len))
+            ++len;
+        if (len > 0) {
+            *match = 1;
+            auto * res = strdup(std::string(*possible.begin(), start, len).c_str());
+            if (!res)
+                throw Error("allocation failure");
+            return res;
+        }
+    }
+
+    *match = 0;
+    return nullptr;
+}
+
+static int listPossibleCallback(char * s, char *** avp)
+{
+    auto possible = curRepl->completePrefix(s);
+
+    if (possible.size() > (INT_MAX / sizeof(char *)))
+        throw Error("too many completions");
+
+    int ac = 0;
+    char ** vp = nullptr;
+
+    auto check = [&](auto * p) {
+        if (!p) {
+            if (vp) {
+                while (--ac >= 0)
+                    free(vp[ac]);
+                free(vp);
+            }
+            throw Error("allocation failure");
+        }
+        return p;
+    };
+
+    vp = check((char **) malloc(possible.size() * sizeof(char *)));
+
+    for (auto & p : possible)
+        vp[ac++] = check(strdup(p.c_str()));
+
+    *avp = vp;
+
+    return ac;
+}
+
+ReadlineLikeInteracter::Guard ReadlineLikeInteracter::init(detail::ReplCompleterMixin * repl)
+{
+    // Allow nix-repl specific settings in .inputrc
+    rl_readline_name = "nix-repl";
+    try {
+        createDirs(dirOf(historyFile));
+    } 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;
+}
+
+static constexpr const char * promptForType(ReplPromptType promptType)
+{
+    switch (promptType) {
+    case ReplPromptType::ReplPrompt:
+        return "nix-repl> ";
+    case ReplPromptType::ContinuationPrompt:
+        return "          ";
+    }
+    assert(false);
+}
+
+bool ReadlineLikeInteracter::getLine(std::string & input, ReplPromptType promptType)
+{
+    struct sigaction act, old;
+    sigset_t savedSignalMask, set;
+
+    auto setupSignals = [&]() {
+        act.sa_handler = sigintHandler;
+        sigfillset(&act.sa_mask);
+        act.sa_flags = 0;
+        if (sigaction(SIGINT, &act, &old))
+            throw SysError("installing handler for SIGINT");
+
+        sigemptyset(&set);
+        sigaddset(&set, SIGINT);
+        if (sigprocmask(SIG_UNBLOCK, &set, &savedSignalMask))
+            throw SysError("unblocking SIGINT");
+    };
+    auto restoreSignals = [&]() {
+        if (sigprocmask(SIG_SETMASK, &savedSignalMask, nullptr))
+            throw SysError("restoring signals");
+
+        if (sigaction(SIGINT, &old, 0))
+            throw SysError("restoring handler for SIGINT");
+    };
+
+    setupSignals();
+    char * s = readline(promptForType(promptType));
+    Finally doFree([&]() { free(s); });
+    restoreSignals();
+
+    if (g_signal_received) {
+        g_signal_received = 0;
+        input.clear();
+        return true;
+    }
+
+    if (!s)
+        return false;
+    input += s;
+    input += '\n';
+    return true;
+}
+
+ReadlineLikeInteracter::~ReadlineLikeInteracter()
+{
+    write_history(historyFile.c_str());
+}
+
+AutomationInteracter::Guard AutomationInteracter::init(detail::ReplCompleterMixin *)
+{
+    return Guard([] {});
+}
+
+// ASCII ENQ character
+constexpr const char * automationPrompt = "\x05";
+
+bool AutomationInteracter::getLine(std::string & input, ReplPromptType promptType)
+{
+    std::cout << std::unitbuf;
+    std::cout << automationPrompt;
+    if (!std::getline(std::cin, input)) {
+        // reset failure bits on EOF
+        std::cin.clear();
+        return false;
+    }
+    return true;
+}
+
+};

src/libcmd/repl-interacter.hh

@@ -0,0 +1,57 @@
+#pragma once
+/// @file
+
+#include "finally.hh"
+#include "types.hh"
+#include <functional>
+#include <string>
+
+namespace nix {
+
+namespace detail {
+/** Provides the completion hooks for the repl, without exposing its complete
+ * internals. */
+struct ReplCompleterMixin {
+    virtual StringSet completePrefix(const std::string & prefix) = 0;
+};
+};
+
+enum class ReplPromptType {
+    ReplPrompt,
+    ContinuationPrompt,
+};
+
+class ReplInteracter
+{
+public:
+    using Guard = Finally<std::function<void()>>;
+
+    virtual Guard init(detail::ReplCompleterMixin * repl) = 0;
+    /** Returns a boolean of whether the interacter got EOF */
+    virtual bool getLine(std::string & input, ReplPromptType promptType) = 0;
+    virtual ~ReplInteracter(){};
+};
+
+class ReadlineLikeInteracter : public virtual ReplInteracter
+{
+    std::string historyFile;
+public:
+    ReadlineLikeInteracter(std::string historyFile)
+        : historyFile(historyFile)
+    {
+    }
+    virtual Guard init(detail::ReplCompleterMixin * repl) override;
+    virtual bool getLine(std::string & input, ReplPromptType promptType) override;
+    virtual ~ReadlineLikeInteracter() override;
+};
+
+class AutomationInteracter : public virtual ReplInteracter
+{
+public:
+    AutomationInteracter() = default;
+    virtual Guard init(detail::ReplCompleterMixin * repl) override;
+    virtual bool getLine(std::string & input, ReplPromptType promptType) override;
+    virtual ~AutomationInteracter() override = default;
+};
+
+};

src/libcmd/repl.cc

@@ -3,22 +3,8 @@
 #include <cstring>
 #include <climits>
 
-#include <setjmp.h>
-
-#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.
-// For compatibility with these versions, we wrap the API here
-// (wrapping multiple times on newer versions is no problem).
-extern "C" {
-#include <editline.h>
-}
-#endif
-
+#include "box_ptr.hh"
+#include "repl-interacter.hh"
 #include "repl.hh"
 
 #include "ansicolor.hh"
@@ -28,6 +14,7 @@ extern "C" {
 #include "eval-inline.hh"
 #include "eval-settings.hh"
 #include "attr-path.hh"
+#include "signals.hh"
 #include "store-api.hh"
 #include "log-store.hh"
 #include "common-eval-args.hh"
@@ -40,6 +27,7 @@ extern "C" {
 #include "finally.hh"
 #include "markdown.hh"
 #include "local-fs-store.hh"
+#include "signals.hh"
 #include "print.hh"
 
 #if HAVE_BOEHMGC
@@ -49,8 +37,30 @@ extern "C" {
 
 namespace nix {
 
+/**
+ * Returned by `NixRepl::processLine`.
+ */
+enum class ProcessLineResult {
+    /**
+     * The user exited with `:quit`. The REPL should exit. The surrounding
+     * program or evaluation (e.g., if the REPL was acting as the debugger)
+     * should also exit.
+     */
+    Quit,
+    /**
+     * The user exited with `:continue`. The REPL should exit, but the program
+     * should continue running.
+     */
+    Continue,
+    /**
+     * The user did not exit. The REPL should request another line of input.
+     */
+    PromptAgain,
+};
+
 struct NixRepl
     : AbstractNixRepl
+    , detail::ReplCompleterMixin
     #if HAVE_BOEHMGC
     , gc
     #endif
@@ -66,19 +76,18 @@ struct NixRepl
     int displ;
     StringSet varNames;
 
-    const Path historyFile;
+    box_ptr<ReplInteracter> interacter;
 
     NixRepl(const SearchPath & searchPath, nix::ref<Store> store,ref<EvalState> state,
             std::function<AnnotatedValues()> getValues);
-    virtual ~NixRepl();
+    virtual ~NixRepl() = default;
 
-    void mainLoop() override;
+    ReplExitStatus mainLoop() override;
     void initEnv() override;
 
-    StringSet completePrefix(const std::string & prefix);
-    bool getLine(std::string & input, const std::string & prompt);
+    virtual StringSet completePrefix(const std::string & prefix) override;
     StorePath getDerivationPath(Value & v);
-    bool processLine(std::string line);
+    ProcessLineResult processLine(std::string line);
 
     void loadFile(const Path & path);
     void loadFlake(const std::string & flakeRef);
@@ -98,7 +107,8 @@ struct NixRepl
             .ansiColors = true,
             .force = true,
             .derivationPaths = true,
-            .maxDepth = maxDepth
+            .maxDepth = maxDepth,
+            .prettyIndent = 2
         });
     }
 };
@@ -111,6 +121,12 @@ std::string removeWhitespace(std::string s)
     return s;
 }
 
+static box_ptr<ReplInteracter> makeInteracter() {
+    if (experimentalFeatureSettings.isEnabled(Xp::ReplAutomation))
+        return make_box_ptr<AutomationInteracter>();
+    else
+        return make_box_ptr<ReadlineLikeInteracter>(getDataDir() + "/nix/repl-history");
+}
 
 NixRepl::NixRepl(const SearchPath & searchPath, nix::ref<Store> store, ref<EvalState> state,
             std::function<NixRepl::AnnotatedValues()> getValues)
@@ -118,16 +134,10 @@ NixRepl::NixRepl(const SearchPath & searchPath, nix::ref<Store> store, ref<EvalS
     , debugTraceIndex(0)
     , getValues(getValues)
     , staticEnv(new StaticEnv(nullptr, state->staticBaseEnv.get()))
-    , historyFile(getDataDir() + "/nix/repl-history")
+    , interacter(makeInteracter())
 {
 }
 
-
-NixRepl::~NixRepl()
-{
-    write_history(historyFile.c_str());
-}
-
 void runNix(Path program, const Strings & args,
     const std::optional<std::string> & input = {})
 {
@@ -144,79 +154,6 @@ void runNix(Path program, const Strings & args,
     return;
 }
 
-static NixRepl * curRepl; // ugly
-
-static char * completionCallback(char * s, int *match) {
-  auto possible = curRepl->completePrefix(s);
-  if (possible.size() == 1) {
-    *match = 1;
-    auto *res = strdup(possible.begin()->c_str() + strlen(s));
-    if (!res) throw Error("allocation failure");
-    return res;
-  } else if (possible.size() > 1) {
-    auto checkAllHaveSameAt = [&](size_t pos) {
-      auto &first = *possible.begin();
-      for (auto &p : possible) {
-        if (p.size() <= pos || p[pos] != first[pos])
-          return false;
-      }
-      return true;
-    };
-    size_t start = strlen(s);
-    size_t len = 0;
-    while (checkAllHaveSameAt(start + len)) ++len;
-    if (len > 0) {
-      *match = 1;
-      auto *res = strdup(std::string(*possible.begin(), start, len).c_str());
-      if (!res) throw Error("allocation failure");
-      return res;
-    }
-  }
-
-  *match = 0;
-  return nullptr;
-}
-
-static int listPossibleCallback(char *s, char ***avp) {
-  auto possible = curRepl->completePrefix(s);
-
-  if (possible.size() > (INT_MAX / sizeof(char*)))
-    throw Error("too many completions");
-
-  int ac = 0;
-  char **vp = nullptr;
-
-  auto check = [&](auto *p) {
-    if (!p) {
-      if (vp) {
-        while (--ac >= 0)
-          free(vp[ac]);
-        free(vp);
-      }
-      throw Error("allocation failure");
-    }
-    return p;
-  };
-
-  vp = check((char **)malloc(possible.size() * sizeof(char*)));
-
-  for (auto & p : possible)
-    vp[ac++] = check(strdup(p.c_str()));
-
-  *avp = vp;
-
-  return ac;
-}
-
-namespace {
-    // Used to communicate to NixRepl::getLine whether a signal occurred in ::readline.
-    volatile sig_atomic_t g_signal_received = 0;
-
-    void sigintHandler(int signo) {
-        g_signal_received = signo;
-    }
-}
-
 static std::ostream & showDebugTrace(std::ostream & out, const PosTable & positions, const DebugTrace & dt)
 {
     if (dt.isError)
@@ -242,7 +179,7 @@ static std::ostream & showDebugTrace(std::ostream & out, const PosTable & positi
 
 static bool isFirstRepl = true;
 
-void NixRepl::mainLoop()
+ReplExitStatus NixRepl::mainLoop()
 {
     if (isFirstRepl) {
         std::string_view debuggerNotice = "";
@@ -256,24 +193,7 @@ void NixRepl::mainLoop()
 
     loadFiles();
 
-    // Allow nix-repl specific settings in .inputrc
-    rl_readline_name = "nix-repl";
-    try {
-        createDirs(dirOf(historyFile));
-    } catch (SysError & e) {
-        logWarning(e.info());
-    }
-#ifndef READLINE
-    el_hist_size = 1000;
-#endif
-    read_history(historyFile.c_str());
-    auto oldRepl = curRepl;
-    curRepl = this;
-    Finally restoreRepl([&] { curRepl = oldRepl; });
-#ifndef READLINE
-    rl_set_complete_func(completionCallback);
-    rl_set_list_possib_func(listPossibleCallback);
-#endif
+    auto _guard = interacter->init(static_cast<detail::ReplCompleterMixin *>(this));
 
     std::string input;
 
@@ -282,16 +202,26 @@ void NixRepl::mainLoop()
         logger->pause();
         // When continuing input from previous lines, don't print a prompt, just align to the same
         // number of chars as the prompt.
-        if (!getLine(input, input.empty() ? "nix-repl> " : "          ")) {
-            // ctrl-D should exit the debugger.
+        if (!interacter->getLine(input, input.empty() ? ReplPromptType::ReplPrompt : ReplPromptType::ContinuationPrompt)) {
+            // Ctrl-D should exit the debugger.
             state->debugStop = false;
-            state->debugQuit = true;
             logger->cout("");
-            break;
+            // TODO: Should Ctrl-D exit just the current debugger session or
+            // the entire program?
+            return ReplExitStatus::QuitAll;
         }
         logger->resume();
         try {
-            if (!removeWhitespace(input).empty() && !processLine(input)) return;
+            switch (processLine(input)) {
+                case ProcessLineResult::Quit:
+                    return ReplExitStatus::QuitAll;
+                case ProcessLineResult::Continue:
+                    return ReplExitStatus::Continue;
+                case ProcessLineResult::PromptAgain:
+                    break;
+                default:
+                    abort();
+            }
         } catch (ParseError & e) {
             if (e.msg().find("unexpected end of file") != std::string::npos) {
                 // For parse errors on incomplete input, we continue waiting for the next line of
@@ -321,51 +251,6 @@ void NixRepl::mainLoop()
     }
 }
 
-
-bool NixRepl::getLine(std::string & input, const std::string & prompt)
-{
-    struct sigaction act, old;
-    sigset_t savedSignalMask, set;
-
-    auto setupSignals = [&]() {
-        act.sa_handler = sigintHandler;
-        sigfillset(&act.sa_mask);
-        act.sa_flags = 0;
-        if (sigaction(SIGINT, &act, &old))
-            throw SysError("installing handler for SIGINT");
-
-        sigemptyset(&set);
-        sigaddset(&set, SIGINT);
-        if (sigprocmask(SIG_UNBLOCK, &set, &savedSignalMask))
-            throw SysError("unblocking SIGINT");
-    };
-    auto restoreSignals = [&]() {
-        if (sigprocmask(SIG_SETMASK, &savedSignalMask, nullptr))
-            throw SysError("restoring signals");
-
-        if (sigaction(SIGINT, &old, 0))
-            throw SysError("restoring handler for SIGINT");
-    };
-
-    setupSignals();
-    char * s = readline(prompt.c_str());
-    Finally doFree([&]() { free(s); });
-    restoreSignals();
-
-    if (g_signal_received) {
-        g_signal_received = 0;
-        input.clear();
-        return true;
-    }
-
-    if (!s)
-      return false;
-    input += s;
-    input += '\n';
-    return true;
-}
-
-
 StringSet NixRepl::completePrefix(const std::string & prefix)
 {
     StringSet completions;
@@ -478,10 +363,11 @@ void NixRepl::loadDebugTraceEnv(DebugTrace & dt)
     }
 }
 
-bool NixRepl::processLine(std::string line)
+ProcessLineResult NixRepl::processLine(std::string line)
 {
     line = trim(line);
-    if (line == "") return true;
+    if (line.empty())
+        return ProcessLineResult::PromptAgain;
 
     _isInterrupted = false;
 
@@ -576,13 +462,13 @@ bool NixRepl::processLine(std::string line)
     else if (state->debugRepl && (command == ":s" || command == ":step")) {
         // set flag to stop at next DebugTrace; exit repl.
         state->debugStop = true;
-        return false;
+        return ProcessLineResult::Continue;
     }
 
     else if (state->debugRepl && (command == ":c" || command == ":continue")) {
         // set flag to run to next breakpoint or end of program; exit repl.
         state->debugStop = false;
-        return false;
+        return ProcessLineResult::Continue;
     }
 
     else if (command == ":a" || command == ":add") {
@@ -725,8 +611,7 @@ bool NixRepl::processLine(std::string line)
 
     else if (command == ":q" || command == ":quit") {
         state->debugStop = false;
-        state->debugQuit = true;
-        return false;
+        return ProcessLineResult::Quit;
     }
 
     else if (command == ":doc") {
@@ -787,7 +672,7 @@ bool NixRepl::processLine(std::string line)
         }
     }
 
-    return true;
+    return ProcessLineResult::PromptAgain;
 }
 
 void NixRepl::loadFile(const Path & path)
@@ -918,7 +803,7 @@ std::unique_ptr<AbstractNixRepl> AbstractNixRepl::create(
 }
 
 
-void AbstractNixRepl::runSimple(
+ReplExitStatus AbstractNixRepl::runSimple(
     ref<EvalState> evalState,
     const ValMap & extraEnv)
 {
@@ -940,7 +825,7 @@ void AbstractNixRepl::runSimple(
     for (auto & [name, value] : extraEnv)
         repl->addVarToScope(repl->state->symbols.create(name), *value);
 
-    repl->mainLoop();
+    return repl->mainLoop();
 }
 
 }

src/libcmd/repl.hh

@@ -3,11 +3,6 @@
 
 #include "eval.hh"
 
-#if HAVE_BOEHMGC
-#define GC_INCLUDE_NEW
-#include <gc/gc_cpp.h>
-#endif
-
 namespace nix {
 
 struct AbstractNixRepl
@@ -28,13 +23,13 @@ struct AbstractNixRepl
         const SearchPath & searchPath, nix::ref<Store> store, ref<EvalState> state,
         std::function<AnnotatedValues()> getValues);
 
-    static void runSimple(
+    static ReplExitStatus runSimple(
         ref<EvalState> evalState,
         const ValMap & extraEnv);
 
     virtual void initEnv() = 0;
 
-    virtual void mainLoop() = 0;
+    virtual ReplExitStatus mainLoop() = 0;
 };
 
 }

src/libexpr/c/meson.build

@@ -1,31 +0,0 @@
-pkg = import('pkgconfig')
-
-libexprc_sources = files(
-  'nix_api_expr.cc',
-  'nix_api_external.cc',
-  'nix_api_value.cc',
-)
-
-all_sources += {
-  'libexprc': libexprc_sources
-}
-
-libexprc = library(
-  'nix-expr-c',
-  libexprc_sources,
-  dependencies : [
-    liblixutil,
-    liblixstore,
-    liblixexpr,
-    liblixutilc,
-    liblixstorec,
-    boehm,
-  ],
-)
-
-pkg.generate(libexprc, requires: [ 'nix-store-c' ])
-
-liblixexprc = declare_dependency(
-  include_directories : include_directories('.'),
-  link_with : libexprc,
-)

src/libexpr/c/nix_api_expr.cc

@@ -1,178 +0,0 @@
-#include <cstring>
-#include <iostream>
-#include <stdexcept>
-#include <string>
-
-#include "config.hh"
-#include "eval.hh"
-#include "globals.hh"
-#include "util.hh"
-
-#include "nix_api_expr.h"
-#include "nix_api_expr_internal.h"
-#include "nix_api_store.h"
-#include "nix_api_store_internal.h"
-#include "nix_api_util.h"
-#include "nix_api_util_internal.h"
-
-#ifdef HAVE_BOEHMGC
-#include <mutex>
-#define GC_INCLUDE_NEW 1
-#include "gc_cpp.h"
-#endif
-
-nix_err nix_libexpr_init(nix_c_context * context)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    {
-        auto ret = nix_libutil_init(context);
-        if (ret != NIX_OK)
-            return ret;
-    }
-    {
-        auto ret = nix_libstore_init(context);
-        if (ret != NIX_OK)
-            return ret;
-    }
-    try {
-        nix::initGC();
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_expr_eval_from_string(
-    nix_c_context * context, EvalState * state, const char * expr, const char * path, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        nix::Expr * parsedExpr = state->state.parseExprFromString(expr, state->state.rootPath(nix::CanonPath(path)));
-        state->state.eval(parsedExpr, *(nix::Value *) value);
-        state->state.forceValue(*(nix::Value *) value, nix::noPos);
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_value_call(nix_c_context * context, EvalState * state, Value * fn, Value * arg, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        state->state.callFunction(*(nix::Value *) fn, *(nix::Value *) arg, *(nix::Value *) value, nix::noPos);
-        state->state.forceValue(*(nix::Value *) value, nix::noPos);
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_value_force(nix_c_context * context, EvalState * state, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        state->state.forceValue(*(nix::Value *) value, nix::noPos);
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_value_force_deep(nix_c_context * context, EvalState * state, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        state->state.forceValueDeep(*(nix::Value *) value);
-    }
-    NIXC_CATCH_ERRS
-}
-
-EvalState * nix_state_create(nix_c_context * context, const char ** searchPath_c, Store * store)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        nix::Strings searchPath;
-        if (searchPath_c != nullptr)
-            for (size_t i = 0; searchPath_c[i] != nullptr; i++)
-                searchPath.push_back(searchPath_c[i]);
-
-        return new EvalState{nix::EvalState(nix::SearchPath::parse(searchPath), store->ptr)};
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-void nix_state_free(EvalState * state)
-{
-    delete state;
-}
-
-#ifdef HAVE_BOEHMGC
-std::unordered_map<
-    const void *,
-    unsigned int,
-    std::hash<const void *>,
-    std::equal_to<const void *>,
-    traceable_allocator<std::pair<const void * const, unsigned int>>>
-    nix_refcounts;
-
-std::mutex nix_refcount_lock;
-
-nix_err nix_gc_incref(nix_c_context * context, const void * p)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        std::scoped_lock lock(nix_refcount_lock);
-        auto f = nix_refcounts.find(p);
-        if (f != nix_refcounts.end()) {
-            f->second++;
-        } else {
-            nix_refcounts[p] = 1;
-        }
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_gc_decref(nix_c_context * context, const void * p)
-{
-
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        std::scoped_lock lock(nix_refcount_lock);
-        auto f = nix_refcounts.find(p);
-        if (f != nix_refcounts.end()) {
-            if (--f->second == 0)
-                nix_refcounts.erase(f);
-        } else
-            throw std::runtime_error("nix_gc_decref: object was not referenced");
-    }
-    NIXC_CATCH_ERRS
-}
-
-void nix_gc_now()
-{
-    GC_gcollect();
-}
-
-#else
-void nix_gc_incref(nix_c_context * context, const void *)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    return NIX_OK;
-}
-void nix_gc_decref(nix_c_context * context, const void *)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    return NIX_OK;
-}
-void nix_gc_now() {}
-#endif
-
-void nix_gc_register_finalizer(void * obj, void * cd, void (*finalizer)(void * obj, void * cd))
-{
-#ifdef HAVE_BOEHMGC
-    GC_REGISTER_FINALIZER(obj, finalizer, cd, 0, 0);
-#endif
-}

src/libexpr/c/nix_api_expr.h

@@ -1,213 +0,0 @@
-#ifndef NIX_API_EXPR_H
-#define NIX_API_EXPR_H
-/** @defgroup libexpr libexpr
- * @brief Bindings to the Nix language evaluator
- *
- * Example (without error handling):
- * @code{.c}
- * int main() {
- *    nix_libexpr_init(NULL);
- *
- *    Store* store = nix_store_open(NULL, "dummy", NULL);
- *    EvalState* state = nix_state_create(NULL, NULL, store); // empty nix path
- *    Value *value = nix_alloc_value(NULL, state);
- *
- *    nix_expr_eval_from_string(NULL, state, "builtins.nixVersion", ".", value);
- *    nix_value_force(NULL, state, value);
- *    printf("nix version: %s\n", nix_get_string(NULL, value));
- *
- *    nix_gc_decref(NULL, value);
- *    nix_state_free(state);
- *    nix_store_free(store);
- *    return 0;
- *    }
- * @endcode
- * @{
- */
-/** @file
- * @brief Main entry for the libexpr C bindings
- */
-
-#include "nix_api_store.h"
-#include "nix_api_util.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-// cffi start
-
-// Type definitions
-/**
- * @brief Represents a state of the Nix language evaluator.
- *
- * Multiple states can be created for multi-threaded
- * operation.
- * @struct EvalState
- * @see nix_state_create
- */
-typedef struct EvalState EvalState; // nix::EvalState
-/**
- * @brief Represents a value in the Nix language.
- *
- * Owned by the garbage collector.
- * @struct Value
- * @see value_manip
- */
-typedef void Value; // nix::Value
-
-// Function prototypes
-/**
- * @brief Initialize the Nix language evaluator.
- *
- * This function must be called at least once,
- * at some point before constructing a EvalState for the first time.
- * This function can be called multiple times, and is idempotent.
- *
- * @param[out] context Optional, stores error information
- * @return NIX_OK if the initialization was successful, an error code otherwise.
- */
-nix_err nix_libexpr_init(nix_c_context * context);
-
-/**
- * @brief Parses and evaluates a Nix expression from a string.
- *
- * @param[out] context Optional, stores error information
- * @param[in] state The state of the evaluation.
- * @param[in] expr The Nix expression to parse.
- * @param[in] path The file path to associate with the expression.
- * This is required for expressions that contain relative paths (such as `./.`) that are resolved relative to the given
- * directory.
- * @param[out] value The result of the evaluation. You must allocate this
- * yourself.
- * @return NIX_OK if the evaluation was successful, an error code otherwise.
- */
-nix_err nix_expr_eval_from_string(
-    nix_c_context * context, EvalState * state, const char * expr, const char * path, Value * value);
-
-/**
- * @brief Calls a Nix function with an argument.
- *
- * @param[out] context Optional, stores error information
- * @param[in] state The state of the evaluation.
- * @param[in] fn The Nix function to call.
- * @param[in] arg The argument to pass to the function.
- * @param[out] value The result of the function call.
- * @return NIX_OK if the function call was successful, an error code otherwise.
- */
-nix_err nix_value_call(nix_c_context * context, EvalState * state, Value * fn, Value * arg, Value * value);
-
-/**
- * @brief Forces the evaluation of a Nix value.
- *
- * The Nix interpreter is lazy, and not-yet-evaluated Values can be
- * of type NIX_TYPE_THUNK instead of their actual value.
- *
- * This function converts these Values into their final type.
- *
- * @note You don't need this function for basic API usage, since all functions
- * that return a value call it for you. The only place you will see a
- * NIX_TYPE_THUNK is in the arguments that are passed to a PrimOp function
- * you supplied to nix_alloc_primop.
- *
- * @param[out] context Optional, stores error information
- * @param[in] state The state of the evaluation.
- * @param[in,out] value The Nix value to force.
- * @post value is not of type NIX_TYPE_THUNK
- * @return NIX_OK if the force operation was successful, an error code
- * otherwise.
- */
-nix_err nix_value_force(nix_c_context * context, EvalState * state, Value * value);
-
-/**
- * @brief Forces the deep evaluation of a Nix value.
- *
- * Recursively calls nix_value_force
- *
- * @see nix_value_force
- * @warning Calling this function on a recursive data structure will cause a
- * stack overflow.
- * @param[out] context Optional, stores error information
- * @param[in] state The state of the evaluation.
- * @param[in,out] value The Nix value to force.
- * @return NIX_OK if the deep force operation was successful, an error code
- * otherwise.
- */
-nix_err nix_value_force_deep(nix_c_context * context, EvalState * state, Value * value);
-
-/**
- * @brief Create a new Nix language evaluator state.
- *
- * @param[out] context Optional, stores error information
- * @param[in] searchPath Array of strings corresponding to entries in NIX_PATH.
- * @param[in] store The Nix store to use.
- * @return A new Nix state or NULL on failure.
- */
-EvalState * nix_state_create(nix_c_context * context, const char ** searchPath, Store * store);
-
-/**
- * @brief Frees a Nix state.
- *
- * Does not fail.
- *
- * @param[in] state The state to free.
- */
-void nix_state_free(EvalState * state);
-
-/** @addtogroup GC
- * @brief Reference counting and garbage collector operations
- *
- * The Nix language evaluator uses a garbage collector. To ease C interop, we implement
- * a reference counting scheme, where objects will be deallocated
- * when there are no references from the Nix side, and the reference count kept
- * by the C API reaches `0`.
- *
- * Functions returning a garbage-collected object will automatically increase
- * the refcount for you. You should make sure to call `nix_gc_decref` when
- * you're done with a value returned by the evaluator.
- * @{
- */
-/**
- * @brief Increment the garbage collector reference counter for the given object.
- *
- * The Nix language evaluator C API keeps track of alive objects by reference counting.
- * When you're done with a refcounted pointer, call nix_gc_decref().
- *
- * @param[out] context Optional, stores error information
- * @param[in] object The object to keep alive
- */
-nix_err nix_gc_incref(nix_c_context * context, const void * object);
-/**
- * @brief Decrement the garbage collector reference counter for the given object
- *
- * @param[out] context Optional, stores error information
- * @param[in] object The object to stop referencing
- */
-nix_err nix_gc_decref(nix_c_context * context, const void * object);
-
-/**
- * @brief Trigger the garbage collector manually
- *
- * You should not need to do this, but it can be useful for debugging.
- */
-void nix_gc_now();
-
-/**
- * @brief Register a callback that gets called when the object is garbage
- * collected.
- * @note Objects can only have a single finalizer. This function overwrites existing values
- * silently.
- * @param[in] obj the object to watch
- * @param[in] cd the data to pass to the finalizer
- * @param[in] finalizer the callback function, called with obj and cd
- */
-void nix_gc_register_finalizer(void * obj, void * cd, void (*finalizer)(void * obj, void * cd));
-
-/** @} */
-// cffi end
-#ifdef __cplusplus
-}
-#endif
-
-/** @} */
-
-#endif // NIX_API_EXPR_H

src/libexpr/c/nix_api_expr_internal.h

@@ -1,64 +0,0 @@
-#ifndef NIX_API_EXPR_INTERNAL_H
-#define NIX_API_EXPR_INTERNAL_H
-
-#include "eval.hh"
-#include "attr-set.hh"
-#include "nix_api_value.h"
-
-class CListBuilder
-{
-private:
-    std::vector<nix::Value *> values;
-
-public:
-    CListBuilder(size_t capacity)
-    {
-        values.reserve(capacity);
-    }
-
-    void push_back(nix::Value * value)
-    {
-        values.push_back(value);
-    }
-
-    Value * finish(nix::EvalState * state, nix::Value * list)
-    {
-        state->mkList(*list, values.size());
-        for (size_t n = 0; n < list->listSize(); ++n) {
-            list->listElems()[n] = values[n];
-        }
-        return list;
-    }
-};
-
-struct EvalState
-{
-    nix::EvalState state;
-};
-
-struct BindingsBuilder
-{
-    nix::BindingsBuilder builder;
-};
-
-struct ListBuilder
-{
-    CListBuilder builder;
-};
-
-struct nix_string_return
-{
-    std::string str;
-};
-
-struct nix_printer
-{
-    std::ostream & s;
-};
-
-struct nix_string_context
-{
-    nix::NixStringContext & ctx;
-};
-
-#endif // NIX_API_EXPR_INTERNAL_H

src/libexpr/c/nix_api_external.cc

@@ -1,198 +0,0 @@
-#include "attr-set.hh"
-#include "config.hh"
-#include "eval.hh"
-#include "gc/gc.h"
-#include "globals.hh"
-#include "value.hh"
-
-#include "nix_api_expr.h"
-#include "nix_api_expr_internal.h"
-#include "nix_api_external.h"
-#include "nix_api_util.h"
-#include "nix_api_util_internal.h"
-#include "nix_api_value.h"
-#include "value/context.hh"
-
-#include <nlohmann/json.hpp>
-
-#ifdef HAVE_BOEHMGC
-#define GC_INCLUDE_NEW 1
-#include "gc_cpp.h"
-#endif
-
-void nix_set_string_return(nix_string_return * str, const char * c)
-{
-    str->str = c;
-}
-
-nix_err nix_external_print(nix_c_context * context, nix_printer * printer, const char * c)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        printer->s << c;
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_external_add_string_context(nix_c_context * context, nix_string_context * ctx, const char * c)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto r = nix::NixStringContextElem::parse(c);
-        ctx->ctx.insert(r);
-    }
-    NIXC_CATCH_ERRS
-}
-
-class NixCExternalValue : public nix::ExternalValueBase
-{
-    NixCExternalValueDesc & desc;
-    void * v;
-
-public:
-    NixCExternalValue(NixCExternalValueDesc & desc, void * v)
-        : desc(desc)
-        , v(v){};
-    void * get_ptr()
-    {
-        return v;
-    }
-    /**
-     * Print out the value
-     */
-    virtual std::ostream & print(std::ostream & str) const override
-    {
-        nix_printer p{str};
-        desc.print(v, &p);
-        return str;
-    }
-
-    /**
-     * Return a simple string describing the type
-     */
-    virtual std::string showType() const override
-    {
-        nix_string_return res;
-        desc.showType(v, &res);
-        return std::move(res.str);
-    }
-
-    /**
-     * Return a string to be used in builtins.typeOf
-     */
-    virtual std::string typeOf() const override
-    {
-        nix_string_return res;
-        desc.typeOf(v, &res);
-        return std::move(res.str);
-    }
-
-    /**
-     * Coerce the value to a string.
-     */
-    virtual std::string coerceToString(
-        nix::EvalState & state,
-        const nix::PosIdx & pos,
-        nix::NixStringContext & context,
-        bool copyMore,
-        bool copyToStore) const override
-    {
-        if (!desc.coerceToString) {
-            return nix::ExternalValueBase::coerceToString(state, pos, context, copyMore, copyToStore);
-        }
-        nix_string_context ctx{context};
-        nix_string_return res{""};
-        // todo: pos, errors
-        desc.coerceToString(v, &ctx, copyMore, copyToStore, &res);
-        if (res.str.empty()) {
-            return nix::ExternalValueBase::coerceToString(state, pos, context, copyMore, copyToStore);
-        }
-        return std::move(res.str);
-    }
-
-    /**
-     * Compare to another value of the same type.
-     */
-    virtual bool operator==(const ExternalValueBase & b) const override
-    {
-        if (!desc.equal) {
-            return false;
-        }
-        auto r = dynamic_cast<const NixCExternalValue *>(&b);
-        if (!r)
-            return false;
-        return desc.equal(v, r->v);
-    }
-
-    /**
-     * Print the value as JSON.
-     */
-    virtual nlohmann::json printValueAsJSON(
-        nix::EvalState & state, bool strict, nix::NixStringContext & context, bool copyToStore = true) const override
-    {
-        if (!desc.printValueAsJSON) {
-            return nix::ExternalValueBase::printValueAsJSON(state, strict, context, copyToStore);
-        }
-        nix_string_context ctx{context};
-        nix_string_return res{""};
-        desc.printValueAsJSON(v, (EvalState *) &state, strict, &ctx, copyToStore, &res);
-        if (res.str.empty()) {
-            return nix::ExternalValueBase::printValueAsJSON(state, strict, context, copyToStore);
-        }
-        return nlohmann::json::parse(res.str);
-    }
-
-    /**
-     * Print the value as XML.
-     */
-    virtual void printValueAsXML(
-        nix::EvalState & state,
-        bool strict,
-        bool location,
-        nix::XMLWriter & doc,
-        nix::NixStringContext & context,
-        nix::PathSet & drvsSeen,
-        const nix::PosIdx pos) const override
-    {
-        if (!desc.printValueAsXML) {
-            return nix::ExternalValueBase::printValueAsXML(state, strict, location, doc, context, drvsSeen, pos);
-        }
-        nix_string_context ctx{context};
-        desc.printValueAsXML(
-            v, (EvalState *) &state, strict, location, &doc, &ctx, &drvsSeen,
-            *reinterpret_cast<const uint32_t *>(&pos));
-    }
-
-    virtual ~NixCExternalValue() override{};
-};
-
-ExternalValue * nix_create_external_value(nix_c_context * context, NixCExternalValueDesc * desc, void * v)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto ret = new
-#ifdef HAVE_BOEHMGC
-            (GC)
-#endif
-                NixCExternalValue(*desc, v);
-        nix_gc_incref(nullptr, ret);
-        return (ExternalValue *) ret;
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-void * nix_get_external_value_content(nix_c_context * context, ExternalValue * b)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto r = dynamic_cast<NixCExternalValue *>((nix::ExternalValueBase *) b);
-        if (r)
-            return r->get_ptr();
-        return nullptr;
-    }
-    NIXC_CATCH_ERRS_NULL
-}

src/libexpr/c/nix_api_external.h

@@ -1,196 +0,0 @@
-#ifndef NIX_API_EXTERNAL_H
-#define NIX_API_EXTERNAL_H
-/** @ingroup libexpr
- * @addtogroup Externals
- * @brief Deal with external values
- * @{
- */
-/** @file
- * @brief libexpr C bindings dealing with external values
- */
-
-#include "nix_api_expr.h"
-#include "nix_api_util.h"
-#include "nix_api_value.h"
-#include "stdbool.h"
-#include "stddef.h"
-#include "stdint.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-// cffi start
-
-/**
- * @brief Represents a string owned by the Nix language evaluator.
- * @see nix_set_owned_string
- */
-typedef struct nix_string_return nix_string_return;
-/**
- * @brief Wraps a stream that can output multiple string pieces.
- */
-typedef struct nix_printer nix_printer;
-/**
- * @brief A list of string context items
- */
-typedef struct nix_string_context nix_string_context;
-
-/**
- * @brief Sets the contents of a nix_string_return
- *
- * Copies the passed string.
- * @param[out] str the nix_string_return to write to
- * @param[in]  c   The string to copy
- */
-void nix_set_string_return(nix_string_return * str, const char * c);
-
-/**
- * Print to the nix_printer
- *
- * @param[out] context Optional, stores error information
- * @param printer The nix_printer to print to
- * @param[in] str The string to print
- * @returns NIX_OK if everything worked
- */
-nix_err nix_external_print(nix_c_context * context, nix_printer * printer, const char * str);
-
-/**
- * Add string context to the nix_string_context object
- * @param[out] context Optional, stores error information
- * @param[out] string_context The nix_string_context to add to
- * @param[in] c The context string to add
- * @returns NIX_OK if everything worked
- */
-nix_err nix_external_add_string_context(nix_c_context * context, nix_string_context * string_context, const char * c);
-
-/**
- * @brief Definition for a class of external values
- *
- * Create and implement one of these, then pass it to nix_create_external_value
- * Make sure to keep it alive while the external value lives.
- *
- * Optional functions can be set to NULL
- *
- * @see nix_create_external_value
- */
-typedef struct NixCExternalValueDesc
-{
-    /**
-     * @brief Called when printing the external value
-     *
-     * @param[in] self the void* passed to nix_create_external_value
-     * @param[out] printer The printer to print to, pass to nix_external_print
-     */
-    void (*print)(void * self, nix_printer * printer);
-    /**
-     * @brief Called on :t
-     * @param[in] self the void* passed to nix_create_external_value
-     * @param[out] res the return value
-     */
-    void (*showType)(void * self, nix_string_return * res);
-    /**
-     * @brief Called on `builtins.typeOf`
-     * @param self the void* passed to nix_create_external_value
-     * @param[out] res the return value
-     */
-    void (*typeOf)(void * self, nix_string_return * res);
-    /**
-     * @brief Called on "${str}" and builtins.toString.
-     *
-     * The latter with coerceMore=true
-     * Optional, the default is to throw an error.
-     * @param[in] self the void* passed to nix_create_external_value
-     * @param[out] c writable string context for the resulting string
-     * @param[in] coerceMore boolean, try to coerce to strings in more cases
-     * instead of throwing an error
-     * @param[in] copyToStore boolean, whether to copy referenced paths to store
-     * or keep them as-is
-     * @param[out] res the return value. Not touching this, or setting it to the
-     * empty string, will make the conversion throw an error.
-     */
-    void (*coerceToString)(
-        void * self, nix_string_context * c, int coerceMore, int copyToStore, nix_string_return * res);
-    /**
-     * @brief Try to compare two external values
-     *
-     * Optional, the default is always false.
-     * If the other object was not a Nix C external value, this comparison will
-     * also return false
-     * @param[in] self the void* passed to nix_create_external_value
-     * @param[in] other the void* passed to the other object's
-     * nix_create_external_value
-     * @returns true if the objects are deemed to be equal
-     */
-    int (*equal)(void * self, void * other);
-    /**
-     * @brief Convert the external value to json
-     *
-     * Optional, the default is to throw an error
-     * @param[in] self the void* passed to nix_create_external_value
-     * @param[in] state The evaluator state
-     * @param[in] strict boolean Whether to force the value before printing
-     * @param[out] c writable string context for the resulting string
-     * @param[in] copyToStore whether to copy referenced paths to store or keep
-     * them as-is
-     * @param[out] res the return value. Gets parsed as JSON. Not touching this,
-     * or setting it to the empty string, will make the conversion throw an error.
-     */
-    void (*printValueAsJSON)(
-        void * self, EvalState *, bool strict, nix_string_context * c, bool copyToStore, nix_string_return * res);
-    /**
-     * @brief Convert the external value to XML
-     *
-     * Optional, the default is to throw an error
-     * @todo The mechanisms for this call are incomplete. There are no C
-     *       bindings to work with XML, pathsets and positions.
-     * @param[in] self the void* passed to nix_create_external_value
-     * @param[in] state The evaluator state
-     * @param[in] strict boolean Whether to force the value before printing
-     * @param[in] location boolean Whether to include position information in the
-     * xml
-     * @param[out] doc XML document to output to
-     * @param[out] c writable string context for the resulting string
-     * @param[in,out] drvsSeen a path set to avoid duplicating derivations
-     * @param[in] pos The position of the call.
-     */
-    void (*printValueAsXML)(
-        void * self,
-        EvalState *,
-        int strict,
-        int location,
-        void * doc,
-        nix_string_context * c,
-        void * drvsSeen,
-        int pos);
-} NixCExternalValueDesc;
-
-/**
- * @brief Create an external value, that can be given to nix_init_external
- *
- * Owned by the GC. Use nix_gc_decref when you're done with the pointer.
- *
- * @param[out] context Optional, stores error information
- * @param[in] desc a NixCExternalValueDesc, you should keep this alive as long
- * as the ExternalValue lives
- * @param[in] v the value to store
- * @returns external value, owned by the garbage collector
- * @see nix_init_external
- */
-ExternalValue * nix_create_external_value(nix_c_context * context, NixCExternalValueDesc * desc, void * v);
-
-/**
- * @brief Extract the pointer from a nix c external value.
- * @param[out] context Optional, stores error information
- * @param[in] b The external value
- * @returns The pointer, or null if the external value was not from nix c.
- * @see nix_get_external
- */
-void * nix_get_external_value_content(nix_c_context * context, ExternalValue * b);
-
-// cffi end
-#ifdef __cplusplus
-}
-#endif
-/** @} */
-
-#endif // NIX_API_EXTERNAL_H

src/libexpr/c/nix_api_value.cc

@@ -1,521 +0,0 @@
-#include "attr-set.hh"
-#include "config.hh"
-#include "eval.hh"
-#include "gc/gc.h"
-#include "globals.hh"
-#include "primops.hh"
-#include "value.hh"
-
-#include "nix_api_expr.h"
-#include "nix_api_expr_internal.h"
-#include "nix_api_util.h"
-#include "nix_api_util_internal.h"
-#include "nix_api_value.h"
-
-#ifdef HAVE_BOEHMGC
-#define GC_INCLUDE_NEW 1
-#include "gc_cpp.h"
-#endif
-
-// Helper function to throw an exception if value is null
-static const nix::Value & check_value_not_null(const Value * value)
-{
-    if (!value) {
-        throw std::runtime_error("Value is null");
-    }
-    return *((const nix::Value *) value);
-}
-
-static nix::Value & check_value_not_null(Value * value)
-{
-    if (!value) {
-        throw std::runtime_error("Value is null");
-    }
-    return *((nix::Value *) value);
-}
-
-/**
- * Helper function to convert calls from nix into C API.
- *
- * Deals with errors and converts arguments from C++ into C types.
- */
-static void nix_c_primop_wrapper(
-    PrimOpFun f, void * userdata, nix::EvalState & state, const nix::PosIdx pos, nix::Value ** args, nix::Value & v)
-{
-    nix_c_context ctx;
-    f(userdata, &ctx, (EvalState *) &state, (Value **) args, (Value *) &v);
-    /* TODO: In the future, this should throw different errors depending on the error code */
-    if (ctx.last_err_code != NIX_OK)
-        state.error<nix::EvalError>("Error from builtin function: %s", *ctx.last_err).atPos(pos).debugThrow();
-}
-
-PrimOp * nix_alloc_primop(
-    nix_c_context * context,
-    PrimOpFun fun,
-    int arity,
-    const char * name,
-    const char ** args,
-    const char * doc,
-    void * user_data)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        using namespace std::placeholders;
-        auto p = new
-#ifdef HAVE_BOEHMGC
-            (GC)
-#endif
-                nix::PrimOp{
-                    .name = name,
-                    .args = {},
-                    .arity = (size_t) arity,
-                    .doc = doc,
-                    .fun = std::bind(nix_c_primop_wrapper, fun, user_data, _1, _2, _3, _4)};
-        if (args)
-            for (size_t i = 0; args[i]; i++)
-                p->args.emplace_back(*args);
-        nix_gc_incref(nullptr, p);
-        return (PrimOp *) p;
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-nix_err nix_register_primop(nix_c_context * context, PrimOp * primOp)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        nix::RegisterPrimOp r(std::move(*((nix::PrimOp *) primOp)));
-    }
-    NIXC_CATCH_ERRS
-}
-
-Value * nix_alloc_value(nix_c_context * context, EvalState * state)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        Value * res = state->state.allocValue();
-        nix_gc_incref(nullptr, res);
-        return res;
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-ValueType nix_get_type(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        using namespace nix;
-        switch (v.type()) {
-        case nThunk:
-            return NIX_TYPE_THUNK;
-        case nInt:
-            return NIX_TYPE_INT;
-        case nFloat:
-            return NIX_TYPE_FLOAT;
-        case nBool:
-            return NIX_TYPE_BOOL;
-        case nString:
-            return NIX_TYPE_STRING;
-        case nPath:
-            return NIX_TYPE_PATH;
-        case nNull:
-            return NIX_TYPE_NULL;
-        case nAttrs:
-            return NIX_TYPE_ATTRS;
-        case nList:
-            return NIX_TYPE_LIST;
-        case nFunction:
-            return NIX_TYPE_FUNCTION;
-        case nExternal:
-            return NIX_TYPE_EXTERNAL;
-        }
-        return NIX_TYPE_NULL;
-    }
-    NIXC_CATCH_ERRS_RES(NIX_TYPE_NULL);
-}
-
-const char * nix_get_typename(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        auto s = nix::showType(v);
-        return strdup(s.c_str());
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-bool nix_get_bool(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nBool);
-        return v.boolean;
-    }
-    NIXC_CATCH_ERRS_RES(false);
-}
-
-const char * nix_get_string(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nString);
-        return v.string.s;
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-const char * nix_get_path_string(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nPath);
-        return v._path;
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-unsigned int nix_get_list_size(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nList);
-        return v.listSize();
-    }
-    NIXC_CATCH_ERRS_RES(0);
-}
-
-unsigned int nix_get_attrs_size(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nAttrs);
-        return v.attrs->size();
-    }
-    NIXC_CATCH_ERRS_RES(0);
-}
-
-double nix_get_float(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nFloat);
-        return v.fpoint;
-    }
-    NIXC_CATCH_ERRS_RES(NAN);
-}
-
-int64_t nix_get_int(nix_c_context * context, const Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nInt);
-        return v.integer;
-    }
-    NIXC_CATCH_ERRS_RES(0);
-}
-
-ExternalValue * nix_get_external(nix_c_context * context, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nExternal);
-        return (ExternalValue *) v.external;
-    }
-    NIXC_CATCH_ERRS_NULL;
-}
-
-Value * nix_get_list_byidx(nix_c_context * context, const Value * value, EvalState * state, unsigned int ix)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nList);
-        auto * p = v.listElems()[ix];
-        nix_gc_incref(nullptr, p);
-        state->state.forceValue(*p, nix::noPos);
-        return (Value *) p;
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-Value * nix_get_attr_byname(nix_c_context * context, const Value * value, EvalState * state, const char * name)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nAttrs);
-        nix::Symbol s = state->state.symbols.create(name);
-        auto attr = v.attrs->get(s);
-        if (attr) {
-            nix_gc_incref(nullptr, attr->value);
-            state->state.forceValue(*attr->value, nix::noPos);
-            return attr->value;
-        }
-        nix_set_err_msg(context, NIX_ERR_KEY, "missing attribute");
-        return nullptr;
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-bool nix_has_attr_byname(nix_c_context * context, const Value * value, EvalState * state, const char * name)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        assert(v.type() == nix::nAttrs);
-        nix::Symbol s = state->state.symbols.create(name);
-        auto attr = v.attrs->get(s);
-        if (attr)
-            return true;
-        return false;
-    }
-    NIXC_CATCH_ERRS_RES(false);
-}
-
-Value *
-nix_get_attr_byidx(nix_c_context * context, const Value * value, EvalState * state, unsigned int i, const char ** name)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        const nix::Attr & a = (*v.attrs)[i];
-        *name = ((const std::string &) (state->state.symbols[a.name])).c_str();
-        nix_gc_incref(nullptr, a.value);
-        state->state.forceValue(*a.value, nix::noPos);
-        return a.value;
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-const char * nix_get_attr_name_byidx(nix_c_context * context, const Value * value, EvalState * state, unsigned int i)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        const nix::Attr & a = (*v.attrs)[i];
-        return ((const std::string &) (state->state.symbols[a.name])).c_str();
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-nix_err nix_init_bool(nix_c_context * context, Value * value, bool b)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        v.mkBool(b);
-    }
-    NIXC_CATCH_ERRS
-}
-
-// todo string context
-nix_err nix_init_string(nix_c_context * context, Value * value, const char * str)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        v.mkString(std::string_view(str));
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_init_path_string(nix_c_context * context, EvalState * s, Value * value, const char * str)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        v.mkPath(s->state.rootPath(nix::CanonPath(str)));
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_init_float(nix_c_context * context, Value * value, double d)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        v.mkFloat(d);
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_init_int(nix_c_context * context, Value * value, int64_t i)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        v.mkInt(i);
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_init_null(nix_c_context * context, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        v.mkNull();
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_init_external(nix_c_context * context, Value * value, ExternalValue * val)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        auto r = (nix::ExternalValueBase *) val;
-        v.mkExternal(r);
-    }
-    NIXC_CATCH_ERRS
-}
-
-ListBuilder * nix_make_list_builder(nix_c_context * context, EvalState * state, size_t capacity)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto builder = CListBuilder(capacity);
-        return new
-#if HAVE_BOEHMGC
-            (NoGC)
-#endif
-                ListBuilder{std::move(builder)};
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-nix_err nix_list_builder_insert(nix_c_context * context, ListBuilder * list_builder, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        list_builder->builder.push_back((nix::Value *) value);
-    }
-    NIXC_CATCH_ERRS
-}
-
-void nix_list_builder_free(ListBuilder * bb)
-{
-#if HAVE_BOEHMGC
-    GC_FREE(bb);
-#else
-    delete bb;
-#endif
-}
-
-nix_err nix_make_list(nix_c_context * context, EvalState * s, ListBuilder * list_builder, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        list_builder->builder.finish(&(s->state), &v);
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_init_primop(nix_c_context * context, Value * value, PrimOp * p)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        v.mkPrimOp((nix::PrimOp *) p);
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_copy_value(nix_c_context * context, Value * value, Value * source)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        auto & s = check_value_not_null(source);
-        v = s;
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_make_attrs(nix_c_context * context, Value * value, BindingsBuilder * b)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        v.mkAttrs(b->builder);
-    }
-    NIXC_CATCH_ERRS
-}
-
-BindingsBuilder * nix_make_bindings_builder(nix_c_context * context, EvalState * state, size_t capacity)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto bb = state->state.buildBindings(capacity);
-        return new
-#if HAVE_BOEHMGC
-            (NoGC)
-#endif
-                BindingsBuilder{std::move(bb)};
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-nix_err nix_bindings_builder_insert(nix_c_context * context, BindingsBuilder * bb, const char * name, Value * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto & v = check_value_not_null(value);
-        nix::Symbol s = bb->builder.state.symbols.create(name);
-        bb->builder.insert(s, &v);
-    }
-    NIXC_CATCH_ERRS
-}
-
-void nix_bindings_builder_free(BindingsBuilder * bb)
-{
-#if HAVE_BOEHMGC
-    GC_FREE((nix::BindingsBuilder *) bb);
-#else
-    delete (nix::BindingsBuilder *) bb;
-#endif
-}

src/libexpr/c/nix_api_value.h

@@ -1,433 +0,0 @@
-#ifndef NIX_API_VALUE_H
-#define NIX_API_VALUE_H
-
-/** @addtogroup libexpr
- * @{
- */
-/** @file
- * @brief libexpr C bindings dealing with values
- */
-
-#include "nix_api_util.h"
-#include "stdbool.h"
-#include "stddef.h"
-#include "stdint.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-// cffi start
-
-// Type definitions
-typedef enum {
-    NIX_TYPE_THUNK,
-    NIX_TYPE_INT,
-    NIX_TYPE_FLOAT,
-    NIX_TYPE_BOOL,
-    NIX_TYPE_STRING,
-    NIX_TYPE_PATH,
-    NIX_TYPE_NULL,
-    NIX_TYPE_ATTRS,
-    NIX_TYPE_LIST,
-    NIX_TYPE_FUNCTION,
-    NIX_TYPE_EXTERNAL
-} ValueType;
-
-// forward declarations
-typedef void Value;
-typedef struct EvalState EvalState;
-// type defs
-/** @brief Stores an under-construction set of bindings
- * @ingroup value_manip
- *
- * Do not reuse.
- * @see nix_make_bindings_builder, nix_bindings_builder_free, nix_make_attrs
- * @see nix_bindings_builder_insert
- */
-typedef struct BindingsBuilder BindingsBuilder;
-
-/** @brief Stores an under-construction list
- * @ingroup value_manip
- *
- * Do not reuse.
- * @see nix_make_list_builder, nix_list_builder_free, nix_make_list
- * @see nix_list_builder_insert
- */
-typedef struct ListBuilder ListBuilder;
-
-/** @brief PrimOp function
- * @ingroup primops
- *
- * Owned by the GC
- * @see nix_alloc_primop, nix_init_primop
- */
-typedef struct PrimOp PrimOp;
-/** @brief External Value
- * @ingroup Externals
- *
- * Owned by the GC
- */
-typedef struct ExternalValue ExternalValue;
-
-/** @defgroup primops
- * @brief Create your own primops
- * @{
- */
-/** @brief Function pointer for primops
- * When you want to return an error, call nix_set_err_msg(context, NIX_ERR_UNKNOWN, "your error message here").
- *
- * @param[in] user_data Arbitrary data that was initially supplied to nix_alloc_primop
- * @param[out] context Stores error information.
- * @param[in] state Evaluator state
- * @param[in] args list of arguments. Note that these can be thunks and should be forced using nix_value_force before
- * use.
- * @param[out] ret return value
- * @see nix_alloc_primop, nix_init_primop
- */
-typedef void (*PrimOpFun)(void * user_data, nix_c_context * context, EvalState * state, Value ** args, Value * ret);
-
-/** @brief Allocate a PrimOp
- *
- * Owned by the garbage collector.
- * Use nix_gc_decref() when you're done with the returned PrimOp.
- *
- * @param[out] context Optional, stores error information
- * @param[in] fun callback
- * @param[in] arity expected number of function arguments
- * @param[in] name function name
- * @param[in] args array of argument names, NULL-terminated
- * @param[in] doc optional, documentation for this primop
- * @param[in] user_data optional, arbitrary data, passed to the callback when it's called
- * @return primop, or null in case of errors
- * @see nix_init_primop
- */
-PrimOp * nix_alloc_primop(
-    nix_c_context * context,
-    PrimOpFun fun,
-    int arity,
-    const char * name,
-    const char ** args,
-    const char * doc,
-    void * user_data);
-
-/** @brief add a primop to the `builtins` attribute set
- *
- * Only applies to States created after this call.
- *
- * Moves your PrimOp content into the global evaluator
- * registry, meaning your input PrimOp pointer is no longer usable.
- * You are free to remove your references to it,
- * after which it will be garbage collected.
- *
- * @param[out] context Optional, stores error information
- * @return primop, or null in case of errors
- *
- */
-nix_err nix_register_primop(nix_c_context * context, PrimOp * primOp);
-/** @} */
-
-// Function prototypes
-
-/** @brief Allocate a Nix value
- *
- * Owned by the GC. Use nix_gc_decref() when you're done with the pointer
- * @param[out] context Optional, stores error information
- * @param[in] state nix evaluator state
- * @return value, or null in case of errors
- *
- */
-
-Value * nix_alloc_value(nix_c_context * context, EvalState * state);
-/** @addtogroup value_manip Manipulating values
- * @brief Functions to inspect and change Nix language values, represented by Value.
- * @{
- */
-/** @name Getters
- */
-/**@{*/
-/** @brief Get value type
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return type of nix value
- */
-
-ValueType nix_get_type(nix_c_context * context, const Value * value);
-/** @brief Get type name of value as defined in the evaluator
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return type name, owned string
- * @todo way to free the result
- */
-
-const char * nix_get_typename(nix_c_context * context, const Value * value);
-
-/** @brief Get boolean value
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return true or false, error info via context
- */
-bool nix_get_bool(nix_c_context * context, const Value * value);
-/** @brief Get string
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return string
- * @return NULL in case of error.
- */
-const char * nix_get_string(nix_c_context * context, const Value * value);
-
-/** @brief Get path as string
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return string
- * @return NULL in case of error.
- */
-const char * nix_get_path_string(nix_c_context * context, const Value * value);
-
-/** @brief Get the length of a list
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return length of list, error info via context
- */
-unsigned int nix_get_list_size(nix_c_context * context, const Value * value);
-
-/** @brief Get the element count of an attrset
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return attrset element count, error info via context
- */
-unsigned int nix_get_attrs_size(nix_c_context * context, const Value * value);
-
-/** @brief Get float value in 64 bits
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return float contents, error info via context
- */
-double nix_get_float(nix_c_context * context, const Value * value);
-
-/** @brief Get int value
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return int contents, error info via context
- */
-int64_t nix_get_int(nix_c_context * context, const Value * value);
-
-/** @brief Get external reference
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @return reference to external, NULL in case of error
- */
-ExternalValue * nix_get_external(nix_c_context * context, Value *);
-
-/** @brief Get the ix'th element of a list
- *
- * Owned by the GC. Use nix_gc_decref when you're done with the pointer
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @param[in] state nix evaluator state
- * @param[in] ix list element to get
- * @return value, NULL in case of errors
- */
-Value * nix_get_list_byidx(nix_c_context * context, const Value * value, EvalState * state, unsigned int ix);
-
-/** @brief Get an attr by name
- *
- * Owned by the GC. Use nix_gc_decref when you're done with the pointer
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @param[in] state nix evaluator state
- * @param[in] name attribute name
- * @return value, NULL in case of errors
- */
-Value * nix_get_attr_byname(nix_c_context * context, const Value * value, EvalState * state, const char * name);
-
-/** @brief Check if an attribute name exists on a value
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @param[in] state nix evaluator state
- * @param[in] name attribute name
- * @return value, error info via context
- */
-bool nix_has_attr_byname(nix_c_context * context, const Value * value, EvalState * state, const char * name);
-
-/** @brief Get an attribute by index in the sorted bindings
- *
- * Also gives you the name.
- *
- * Owned by the GC. Use nix_gc_decref when you're done with the pointer
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @param[in] state nix evaluator state
- * @param[in] i attribute index
- * @param[out] name will store a pointer to the attribute name
- * @return value, NULL in case of errors
- */
-Value *
-nix_get_attr_byidx(nix_c_context * context, const Value * value, EvalState * state, unsigned int i, const char ** name);
-
-/** @brief Get an attribute name by index in the sorted bindings
- *
- * Useful when you want the name but want to avoid evaluation.
- *
- * Owned by the nix EvalState
- * @param[out] context Optional, stores error information
- * @param[in] value Nix value to inspect
- * @param[in] state nix evaluator state
- * @param[in] i attribute index
- * @return name, NULL in case of errors
- */
-const char * nix_get_attr_name_byidx(nix_c_context * context, const Value * value, EvalState * state, unsigned int i);
-
-/**@}*/
-/** @name Initializers
- *
- * Values are typically "returned" by initializing already allocated memory that serves as the return value.
- * For this reason, the construction of values is not tied their allocation.
- * Nix is a language with immutable values. Respect this property by only initializing Values once; and only initialize
- * Values that are meant to be initialized by you. Failing to adhere to these rules may lead to undefined behavior.
- */
-/**@{*/
-/** @brief Set boolean value
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] b the boolean value
- * @return error code, NIX_OK on success.
- */
-nix_err nix_init_bool(nix_c_context * context, Value * value, bool b);
-
-/** @brief Set a string
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] str the string, copied
- * @return error code, NIX_OK on success.
- */
-nix_err nix_init_string(nix_c_context * context, Value * value, const char * str);
-
-/** @brief Set a path
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] str the path string, copied
- * @return error code, NIX_OK on success.
- */
-nix_err nix_init_path_string(nix_c_context * context, EvalState * s, Value * value, const char * str);
-
-/** @brief Set a float
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] d the float, 64-bits
- * @return error code, NIX_OK on success.
- */
-nix_err nix_init_float(nix_c_context * context, Value * value, double d);
-
-/** @brief Set an int
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] i the int
- * @return error code, NIX_OK on success.
- */
-
-nix_err nix_init_int(nix_c_context * context, Value * value, int64_t i);
-/** @brief Set null
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @return error code, NIX_OK on success.
- */
-
-nix_err nix_init_null(nix_c_context * context, Value * value);
-/** @brief Set an external value
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] val the external value to set. Will be GC-referenced by the value.
- * @return error code, NIX_OK on success.
- */
-nix_err nix_init_external(nix_c_context * context, Value * value, ExternalValue * val);
-
-/** @brief Create a list from a list builder
- * @param[out] context Optional, stores error information
- * @param[in] list_builder list builder to use. Make sure to unref this afterwards.
- * @param[out] value Nix value to modify
- * @return error code, NIX_OK on success.
- */
-nix_err nix_make_list(nix_c_context * context, EvalState * s, ListBuilder * list_builder, Value * value);
-
-/** @brief Create a list builder
- * @param[out] context Optional, stores error information
- * @param[in] state nix evaluator state
- * @param[in] capacity how many bindings you'll add. Don't exceed.
- * @return owned reference to a list builder. Make sure to unref when you're done.
- */
-ListBuilder * nix_make_list_builder(nix_c_context * context, EvalState * state, size_t capacity);
-
-/** @brief Insert bindings into a builder
- * @param[out] context Optional, stores error information
- * @param[in] list_builder ListBuilder to insert into
- * @param[in] value value to insert
- * @return error code, NIX_OK on success.
- */
-nix_err nix_list_builder_insert(nix_c_context * context, ListBuilder * list_builder, Value * value);
-
-/** @brief Free a list builder
- *
- * Does not fail.
- * @param[in] builder the builder to free
- */
-void nix_list_builder_free(ListBuilder * builder);
-
-/** @brief Create an attribute set from a bindings builder
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] b bindings builder to use. Make sure to unref this afterwards.
- * @return error code, NIX_OK on success.
- */
-nix_err nix_make_attrs(nix_c_context * context, Value * value, BindingsBuilder * b);
-
-/** @brief Set primop
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] op primop, will be gc-referenced by the value
- * @see nix_alloc_primop
- * @return error code, NIX_OK on success.
- */
-nix_err nix_init_primop(nix_c_context * context, Value * value, PrimOp * op);
-/** @brief Copy from another value
- * @param[out] context Optional, stores error information
- * @param[out] value Nix value to modify
- * @param[in] source value to copy from
- * @return error code, NIX_OK on success.
- */
-nix_err nix_copy_value(nix_c_context * context, Value * value, Value * source);
-/**@}*/
-
-/** @brief Create a bindings builder
-* @param[out] context Optional, stores error information
-* @param[in] state nix evaluator state
-* @param[in] capacity how many bindings you'll add. Don't exceed.
-* @return owned reference to a bindings builder. Make sure to unref when you're
-done.
-*/
-BindingsBuilder * nix_make_bindings_builder(nix_c_context * context, EvalState * state, size_t capacity);
-
-/** @brief Insert bindings into a builder
- * @param[out] context Optional, stores error information
- * @param[in] builder BindingsBuilder to insert into
- * @param[in] name attribute name, copied into the symbol store
- * @param[in] value value to give the binding
- * @return error code, NIX_OK on success.
- */
-nix_err
-nix_bindings_builder_insert(nix_c_context * context, BindingsBuilder * builder, const char * name, Value * value);
-
-/** @brief Free a bindings builder
- *
- * Does not fail.
- * @param[in] builder the builder to free
- */
-void nix_bindings_builder_free(BindingsBuilder * builder);
-/**@}*/
-
-// cffi end
-#ifdef __cplusplus
-}
-#endif
-
-/** @} */
-#endif // NIX_API_VALUE_H

src/libexpr/eval-error.cc

@@ -28,15 +28,7 @@ template<class T>
 EvalErrorBuilder<T> & EvalErrorBuilder<T>::withTrace(PosIdx pos, const std::string_view text)
 {
     error.err.traces.push_front(
-        Trace{.pos = error.state.positions[pos], .hint = HintFmt(std::string(text)), .frame = false});
-    return *this;
-}
-
-template<class T>
-EvalErrorBuilder<T> & EvalErrorBuilder<T>::withFrameTrace(PosIdx pos, const std::string_view text)
-{
-    error.err.traces.push_front(
-        Trace{.pos = error.state.positions[pos], .hint = HintFmt(std::string(text)), .frame = true});
+        Trace{.pos = error.state.positions[pos], .hint = HintFmt(std::string(text))});
     return *this;
 }
 
@@ -63,9 +55,9 @@ EvalErrorBuilder<T> & EvalErrorBuilder<T>::withFrame(const Env & env, const Expr
 }
 
 template<class T>
-EvalErrorBuilder<T> & EvalErrorBuilder<T>::addTrace(PosIdx pos, HintFmt hint, bool frame)
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::addTrace(PosIdx pos, HintFmt hint)
 {
-    error.addTrace(error.state.positions[pos], hint, frame);
+    error.addTrace(error.state.positions[pos], hint);
     return *this;
 }
 

src/libexpr/eval-error.hh

@@ -90,7 +90,7 @@ public:
 
     [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & withFrame(const Env & e, const Expr & ex);
 
-    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & addTrace(PosIdx pos, HintFmt hint, bool frame = false);
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & addTrace(PosIdx pos, HintFmt hint);
 
     template<typename... Args>
     [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> &

src/libexpr/eval-settings.hh

@@ -114,6 +114,16 @@ struct EvalSettings : Config
 
     Setting<unsigned int> maxCallDepth{this, 10000, "max-call-depth",
         "The maximum function call depth to allow before erroring."};
+
+    Setting<bool> builtinsTraceDebugger{this, false, "debugger-on-trace",
+        R"(
+          If set to true and the `--debugger` flag is given,
+          [`builtins.trace`](@docroot@/language/builtins.md#builtins-trace) will
+          enter the debugger like
+          [`builtins.break`](@docroot@/language/builtins.md#builtins-break).
+
+          This is useful for debugging warnings in third-party Nix code.
+        )"};
 };
 
 extern EvalSettings evalSettings;

src/libexpr/eval.cc

@@ -3,6 +3,7 @@
 #include "hash.hh"
 #include "primops.hh"
 #include "print-options.hh"
+#include "shared.hh"
 #include "types.hh"
 #include "util.hh"
 #include "store-api.hh"
@@ -391,7 +392,6 @@ EvalState::EvalState(
     , buildStore(buildStore ? buildStore : store)
     , debugRepl(nullptr)
     , debugStop(false)
-    , debugQuit(false)
     , trylevel(0)
     , regexCache(makeRegexCache())
 #if HAVE_BOEHMGC
@@ -798,18 +798,30 @@ void EvalState::runDebugRepl(const Error * error, const Env & env, const Expr &
     auto se = getStaticEnv(expr);
     if (se) {
         auto vm = mapStaticEnvBindings(symbols, *se.get(), env);
-        (debugRepl)(ref<EvalState>(shared_from_this()), *vm);
+        auto exitStatus = (debugRepl)(ref<EvalState>(shared_from_this()), *vm);
+        switch (exitStatus) {
+            case ReplExitStatus::QuitAll:
+                if (error)
+                    throw *error;
+                throw Exit(0);
+            case ReplExitStatus::Continue:
+                break;
+            default:
+                abort();
+        }
     }
 }
 
-void EvalState::addErrorTrace(Error & e, const char * s, const std::string & s2) const
+template<typename... Args>
+void EvalState::addErrorTrace(Error & e, const Args & ... formatArgs) const
 {
-    e.addTrace(nullptr, s, s2);
+    e.addTrace(nullptr, HintFmt(formatArgs...));
 }
 
-void EvalState::addErrorTrace(Error & e, const PosIdx pos, const char * s, const std::string & s2, bool frame) const
+template<typename... Args>
+void EvalState::addErrorTrace(Error & e, const PosIdx pos, const Args & ... formatArgs) const
 {
-    e.addTrace(positions[pos], HintFmt(s, s2), frame);
+    e.addTrace(positions[pos], HintFmt(formatArgs...));
 }
 
 template<typename... Args>
@@ -1205,6 +1217,18 @@ void ExprPath::eval(EvalState & state, Env & env, Value & v)
 }
 
 
+Env * ExprAttrs::buildInheritFromEnv(EvalState & state, Env & up)
+{
+    Env & inheritEnv = state.allocEnv(inheritFromExprs->size());
+    inheritEnv.up = &up;
+
+    Displacement displ = 0;
+    for (auto from : *inheritFromExprs)
+        inheritEnv.values[displ++] = from->maybeThunk(state, up);
+
+    return &inheritEnv;
+}
+
 void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
 {
     v.mkAttrs(state.buildBindings(attrs.size() + dynamicAttrs.size()).finish());
@@ -1216,6 +1240,7 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
         Env & env2(state.allocEnv(attrs.size()));
         env2.up = &env;
         dynamicEnv = &env2;
+        Env * inheritEnv = inheritFromExprs ? buildInheritFromEnv(state, env2) : nullptr;
 
         AttrDefs::iterator overrides = attrs.find(state.sOverrides);
         bool hasOverrides = overrides != attrs.end();
@@ -1226,11 +1251,11 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
         Displacement displ = 0;
         for (auto & i : attrs) {
             Value * vAttr;
-            if (hasOverrides && !i.second.inherited) {
+            if (hasOverrides && i.second.kind != AttrDef::Kind::Inherited) {
                 vAttr = state.allocValue();
-                mkThunk(*vAttr, env2, i.second.e);
+                mkThunk(*vAttr, *i.second.chooseByKind(&env2, &env, inheritEnv), i.second.e);
             } else
-                vAttr = i.second.e->maybeThunk(state, i.second.inherited ? env : env2);
+                vAttr = i.second.e->maybeThunk(state, *i.second.chooseByKind(&env2, &env, inheritEnv));
             env2.values[displ++] = vAttr;
             v.attrs->push_back(Attr(i.first, vAttr, i.second.pos));
         }
@@ -1262,9 +1287,15 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
         }
     }
 
-    else
-        for (auto & i : attrs)
-            v.attrs->push_back(Attr(i.first, i.second.e->maybeThunk(state, env), i.second.pos));
+    else {
+        Env * inheritEnv = inheritFromExprs ? buildInheritFromEnv(state, env) : nullptr;
+        for (auto & i : attrs) {
+            v.attrs->push_back(Attr(
+                    i.first,
+                    i.second.e->maybeThunk(state, *i.second.chooseByKind(&env, &env, inheritEnv)),
+                    i.second.pos));
+        }
+    }
 
     /* Dynamic attrs apply *after* rec and __overrides. */
     for (auto & i : dynamicAttrs) {
@@ -1296,12 +1327,17 @@ void ExprLet::eval(EvalState & state, Env & env, Value & v)
     Env & env2(state.allocEnv(attrs->attrs.size()));
     env2.up = &env;
 
+    Env * inheritEnv = attrs->inheritFromExprs ? attrs->buildInheritFromEnv(state, env2) : nullptr;
+
     /* The recursive attributes are evaluated in the new environment,
        while the inherited attributes are evaluated in the original
        environment. */
     Displacement displ = 0;
-    for (auto & i : attrs->attrs)
-        env2.values[displ++] = i.second.e->maybeThunk(state, i.second.inherited ? env : env2);
+    for (auto & i : attrs->attrs) {
+        env2.values[displ++] = i.second.e->maybeThunk(
+            state,
+            *i.second.chooseByKind(&env2, &env, inheritEnv));
+    }
 
     auto dts = state.debugRepl
         ? makeDebugTraceStacker(
@@ -1596,9 +1632,8 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
                         "while calling %s",
                         lambda.name
                         ? concatStrings("'", symbols[lambda.name], "'")
-                        : "anonymous lambda",
-                        true);
-                    if (pos) addErrorTrace(e, pos, "from call site%s", "", true);
+                        : "anonymous lambda");
+                    if (pos) addErrorTrace(e, pos, "from call site");
                 }
                 throw;
             }

src/libexpr/eval.hh

@@ -11,6 +11,7 @@
 #include "experimental-features.hh"
 #include "input-accessor.hh"
 #include "search-path.hh"
+#include "repl-exit-status.hh"
 
 #include <map>
 #include <optional>
@@ -36,7 +37,7 @@ enum RepairFlag : bool;
 /**
  * Function that implements a primop.
  */
-typedef std::function<void (EvalState &, const PosIdx, Value **, Value &)> PrimOpFun;
+typedef void (* PrimOpFun) (EvalState & state, const PosIdx pos, Value * * args, Value & v);
 
 /**
  * Info about a primitive operation, and its implementation
@@ -207,9 +208,8 @@ public:
     /**
      * Debugger
      */
-    void (* debugRepl)(ref<EvalState> es, const ValMap & extraEnv);
+    ReplExitStatus (* debugRepl)(ref<EvalState> es, const ValMap & extraEnv);
     bool debugStop;
-    bool debugQuit;
     int trylevel;
     std::list<DebugTrace> debugTraces;
     std::map<const Expr*, const std::shared_ptr<const StaticEnv>> exprEnvs;
@@ -434,10 +434,12 @@ public:
     std::string_view forceString(Value & v, NixStringContext & context, const PosIdx pos, std::string_view errorCtx);
     std::string_view forceStringNoCtx(Value & v, const PosIdx pos, std::string_view errorCtx);
 
+    template<typename... Args>
     [[gnu::noinline]]
-    void addErrorTrace(Error & e, const char * s, const std::string & s2) const;
+    void addErrorTrace(Error & e, const Args & ... formatArgs) const;
+    template<typename... Args>
     [[gnu::noinline]]
-    void addErrorTrace(Error & e, const PosIdx pos, const char * s, const std::string & s2, bool frame = false) const;
+    void addErrorTrace(Error & e, const PosIdx pos, const Args & ... formatArgs) const;
 
 public:
     /**
@@ -753,7 +755,6 @@ struct DebugTraceStacker {
     DebugTraceStacker(EvalState & evalState, DebugTrace t);
     ~DebugTraceStacker()
     {
-        // assert(evalState.debugTraces.front() == trace);
         evalState.debugTraces.pop_front();
     }
     EvalState & evalState;

src/libexpr/get-drvs.cc

@@ -296,22 +296,16 @@ void DrvInfo::setMeta(const std::string & name, Value * v)
 typedef std::set<Bindings *> Done;
 
 
-/* Evaluate value `v'.  If it evaluates to a set of type `derivation',
-   then put information about it in `drvs' (unless it's already in `done').
-   The result boolean indicates whether it makes sense
+/* The result boolean indicates whether it makes sense
    for the caller to recursively search for derivations in `v'. */
 static bool getDerivation(EvalState & state, Value & v,
-    const std::string & attrPath, DrvInfos & drvs, Done & done,
+    const std::string & attrPath, DrvInfos & drvs,
     bool ignoreAssertionFailures)
 {
     try {
         state.forceValue(v, v.determinePos(noPos));
         if (!state.isDerivation(v)) return true;
 
-        /* Remove spurious duplicates (e.g., a set like `rec { x =
-           derivation {...}; y = x;}'. */
-        if (!done.insert(v.attrs).second) return false;
-
         DrvInfo drv(state, attrPath, v.attrs);
 
         drv.queryName();
@@ -330,9 +324,8 @@ static bool getDerivation(EvalState & state, Value & v,
 std::optional<DrvInfo> getDerivation(EvalState & state, Value & v,
     bool ignoreAssertionFailures)
 {
-    Done done;
     DrvInfos drvs;
-    getDerivation(state, v, "", drvs, done, ignoreAssertionFailures);
+    getDerivation(state, v, "", drvs, ignoreAssertionFailures);
     if (drvs.size() != 1) return {};
     return std::move(drvs.front());
 }
@@ -347,6 +340,9 @@ static std::string addToPath(const std::string & s1, const std::string & s2)
 static std::regex attrRegex("[A-Za-z_][A-Za-z0-9-_+]*");
 
 
+/* Evaluate value `v'.  If it evaluates to a set of type `derivation',
+   then put information about it in `drvs'. If it evaluates to a different
+   kind of set recurse (unless it's already in `done'). */
 static void getDerivations(EvalState & state, Value & vIn,
     const std::string & pathPrefix, Bindings & autoArgs,
     DrvInfos & drvs, Done & done,
@@ -356,10 +352,14 @@ static void getDerivations(EvalState & state, Value & vIn,
     state.autoCallFunction(autoArgs, vIn, v);
 
     /* Process the expression. */
-    if (!getDerivation(state, v, pathPrefix, drvs, done, ignoreAssertionFailures)) ;
+    if (!getDerivation(state, v, pathPrefix, drvs, ignoreAssertionFailures)) ;
 
     else if (v.type() == nAttrs) {
 
+        /* Dont consider sets we've already seen, e.g. y in
+           `rec { x.d = derivation {...}; y = x; }`. */
+        if (!done.insert(v.attrs).second) return;
+
         /* !!! undocumented hackery to support combining channels in
            nix-env.cc. */
         bool combineChannels = v.attrs->find(state.symbols.create("_combineChannels")) != v.attrs->end();
@@ -376,7 +376,7 @@ static void getDerivations(EvalState & state, Value & vIn,
             std::string pathPrefix2 = addToPath(pathPrefix, state.symbols[i->name]);
             if (combineChannels)
                 getDerivations(state, *i->value, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
-            else if (getDerivation(state, *i->value, pathPrefix2, drvs, done, ignoreAssertionFailures)) {
+            else if (getDerivation(state, *i->value, pathPrefix2, drvs, ignoreAssertionFailures)) {
                 /* If the value of this attribute is itself a set,
                    should we recurse into it?  => Only if it has a
                    `recurseForDerivations = true' attribute. */
@@ -390,9 +390,11 @@ static void getDerivations(EvalState & state, Value & vIn,
     }
 
     else if (v.type() == nList) {
+        // NOTE we can't really deduplicate here because small lists don't have stable addresses
+        // and can cause spurious duplicate detections due to v being on the stack.
         for (auto [n, elem] : enumerate(v.listItems())) {
             std::string pathPrefix2 = addToPath(pathPrefix, fmt("%d", n));
-            if (getDerivation(state, *elem, pathPrefix2, drvs, done, ignoreAssertionFailures))
+            if (getDerivation(state, *elem, pathPrefix2, drvs, ignoreAssertionFailures))
                 getDerivations(state, *elem, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
         }
     }

src/libexpr/meson.build

@@ -1,91 +0,0 @@
-bison = find_program('bison')
-flex = find_program('flex')
-
-parser_tab = custom_target(
-  input : 'parser.y',
-  output : [
-    'parser-tab.cc',
-    'parser-tab.hh',
-  ],
-  command : [
-    'bison',
-    '-v',
-    '-o',
-    '@OUTPUT0@',
-    '@INPUT@',
-    '-d',
-  ],
-)
-
-lexer_tab = custom_target(
-  input : [
-    'lexer.l',
-    parser_tab,
-  ],
-  output : [
-    'lexer-tab.cc',
-    'lexer-tab.hh',
-  ],
-  command : [
-    'flex',
-    '--outfile',
-    '@OUTPUT0@',
-    '--header-file=' + '@OUTPUT1@',
-    '@INPUT0@',
-  ],
-)
-
-libexpr_sources = files(
-  'attr-path.cc',
-  'attr-set.cc',
-  'eval-cache.cc',
-  'eval-error.cc',
-  'eval-settings.cc',
-  'eval.cc',
-  'function-trace.cc',
-  'get-drvs.cc',
-  'json-to-value.cc',
-  'nixexpr.cc',
-  'paths.cc',
-  'primops.cc',
-  'print-ambiguous.cc',
-  'print.cc',
-  'search-path.cc',
-  'value-to-json.cc',
-  'value-to-xml.cc',
-  'flake/config.cc',
-  'flake/flake.cc',
-  'flake/flakeref.cc',
-  'flake/lockfile.cc',
-  'primops/context.cc',
-  'primops/fetchClosure.cc',
-  'primops/fetchMercurial.cc',
-  'primops/fetchTree.cc',
-  'primops/fromTOML.cc',
-  'value/context.cc',
-)
-
-all_sources += {
-  'libexpr': libexpr_sources
-}
-
-libexpr = library(
-  'nixexpr',
-  libexpr_sources,
-  parser_tab,
-  lexer_tab,
-  dependencies : [
-    liblixutil,
-    liblixstore,
-    liblixfetchers,
-    boehm,
-    boost,
-  ],
-)
-
-liblixexpr = declare_dependency(
-  include_directories : include_directories('.'),
-  link_with : libexpr,
-)
-
-subdir('c')

src/libexpr/nixexpr.cc

@@ -68,10 +68,8 @@ void ExprOpHasAttr::show(const SymbolTable & symbols, std::ostream & str) const
     str << ") ? " << showAttrPath(symbols, attrPath) << ")";
 }
 
-void ExprAttrs::show(const SymbolTable & symbols, std::ostream & str) const
+void ExprAttrs::showBindings(const SymbolTable & symbols, std::ostream & str) const
 {
-    if (recursive) str << "rec ";
-    str << "{ ";
     typedef const decltype(attrs)::value_type * Attr;
     std::vector<Attr> sorted;
     for (auto & i : attrs) sorted.push_back(&i);
@@ -79,10 +77,37 @@ void ExprAttrs::show(const SymbolTable & symbols, std::ostream & str) const
         std::string_view sa = symbols[a->first], sb = symbols[b->first];
         return sa < sb;
     });
+    std::vector<Symbol> inherits;
+    std::map<ExprInheritFrom *, std::vector<Symbol>> inheritsFrom;
     for (auto & i : sorted) {
-        if (i->second.inherited)
-            str << "inherit " << symbols[i->first] << " " << "; ";
-        else {
+        switch (i->second.kind) {
+        case AttrDef::Kind::Plain:
+            break;
+        case AttrDef::Kind::Inherited:
+            inherits.push_back(i->first);
+            break;
+        case AttrDef::Kind::InheritedFrom: {
+            auto & select = dynamic_cast<ExprSelect &>(*i->second.e);
+            auto & from = dynamic_cast<ExprInheritFrom &>(*select.e);
+            inheritsFrom[&from].push_back(i->first);
+            break;
+        }
+        }
+    }
+    if (!inherits.empty()) {
+        str << "inherit";
+        for (auto sym : inherits) str << " " << symbols[sym];
+        str << "; ";
+    }
+    for (const auto & [from, syms] : inheritsFrom) {
+        str << "inherit (";
+        (*inheritFromExprs)[from->displ]->show(symbols, str);
+        str << ")";
+        for (auto sym : syms) str << " " << symbols[sym];
+        str << "; ";
+    }
+    for (auto & i : sorted) {
+        if (i->second.kind == AttrDef::Kind::Plain) {
             str << symbols[i->first] << " = ";
             i->second.e->show(symbols, str);
             str << "; ";
@@ -95,6 +120,13 @@ void ExprAttrs::show(const SymbolTable & symbols, std::ostream & str) const
         i.valueExpr->show(symbols, str);
         str << "; ";
     }
+}
+
+void ExprAttrs::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    if (recursive) str << "rec ";
+    str << "{ ";
+    showBindings(symbols, str);
     str << "}";
 }
 
@@ -150,15 +182,7 @@ void ExprCall::show(const SymbolTable & symbols, std::ostream & str) const
 void ExprLet::show(const SymbolTable & symbols, std::ostream & str) const
 {
     str << "(let ";
-    for (auto & i : attrs->attrs)
-        if (i.second.inherited) {
-            str << "inherit " << symbols[i.first] << "; ";
-        }
-        else {
-            str << symbols[i.first] << " = ";
-            i.second.e->show(symbols, str);
-            str << "; ";
-        }
+    attrs->showBindings(symbols, str);
     str << "in ";
     body->show(symbols, str);
     str << ")";
@@ -303,6 +327,12 @@ void ExprVar::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> &
     this->level = withLevel;
 }
 
+void ExprInheritFrom::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+}
+
 void ExprSelect::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
 {
     if (es.debugRepl)
@@ -326,22 +356,47 @@ void ExprOpHasAttr::bindVars(EvalState & es, const std::shared_ptr<const StaticE
             i.expr->bindVars(es, env);
 }
 
+std::shared_ptr<const StaticEnv> ExprAttrs::bindInheritSources(
+    EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (!inheritFromExprs)
+        return nullptr;
+
+    // the inherit (from) source values are inserted into an env of its own, which
+    // does not introduce any variable names.
+    // analysis must see an empty env, or an env that contains only entries with
+    // otherwise unused names to not interfere with regular names. the parser
+    // has already filled all exprs that access this env with appropriate level
+    // and displacement, and nothing else is allowed to access it. ideally we'd
+    // not even *have* an expr that grabs anything from this env since it's fully
+    // invisible, but the evaluator does not allow for this yet.
+    auto inner = std::make_shared<StaticEnv>(nullptr, env.get(), 0);
+    for (auto from : *inheritFromExprs)
+        from->bindVars(es, env);
+
+    return inner;
+}
+
 void ExprAttrs::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
 {
     if (es.debugRepl)
         es.exprEnvs.insert(std::make_pair(this, env));
 
     if (recursive) {
-        auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), recursive ? attrs.size() : 0);
+        auto newEnv = [&] () -> std::shared_ptr<const StaticEnv> {
+            auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), attrs.size());
 
-        Displacement displ = 0;
-        for (auto & i : attrs)
-            newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
+            Displacement displ = 0;
+            for (auto & i : attrs)
+                newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
+            return newEnv;
+        }();
 
         // No need to sort newEnv since attrs is in sorted order.
 
+        auto inheritFromEnv = bindInheritSources(es, newEnv);
         for (auto & i : attrs)
-            i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
+            i.second.e->bindVars(es, i.second.chooseByKind(newEnv, env, inheritFromEnv));
 
         for (auto & i : dynamicAttrs) {
             i.nameExpr->bindVars(es, newEnv);
@@ -349,8 +404,10 @@ void ExprAttrs::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv>
         }
     }
     else {
+        auto inheritFromEnv = bindInheritSources(es, env);
+
         for (auto & i : attrs)
-            i.second.e->bindVars(es, env);
+            i.second.e->bindVars(es, i.second.chooseByKind(env, env, inheritFromEnv));
 
         for (auto & i : dynamicAttrs) {
             i.nameExpr->bindVars(es, env);
@@ -407,16 +464,20 @@ void ExprCall::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> &
 
 void ExprLet::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
 {
-    auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), attrs->attrs.size());
+    auto newEnv = [&] () -> std::shared_ptr<const StaticEnv> {
+        auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), attrs->attrs.size());
 
-    Displacement displ = 0;
-    for (auto & i : attrs->attrs)
-        newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
+        Displacement displ = 0;
+        for (auto & i : attrs->attrs)
+            newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
+        return newEnv;
+    }();
 
     // No need to sort newEnv since attrs->attrs is in sorted order.
 
+    auto inheritFromEnv = attrs->bindInheritSources(es, newEnv);
     for (auto & i : attrs->attrs)
-        i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
+        i.second.e->bindVars(es, i.second.chooseByKind(newEnv, env, inheritFromEnv));
 
     if (es.debugRepl)
         es.exprEnvs.insert(std::make_pair(this, newEnv));

src/libexpr/nixexpr.hh

@@ -129,6 +129,23 @@ struct ExprVar : Expr
     COMMON_METHODS
 };
 
+/**
+ * A pseudo-expression for the purpose of evaluating the `from` expression in `inherit (from)` syntax.
+ * Unlike normal variable references, the displacement is set during parsing, and always refers to
+ * `ExprAttrs::inheritFromExprs` (by itself or in `ExprLet`), whose values are put into their own `Env`.
+ */
+struct ExprInheritFrom : ExprVar
+{
+    ExprInheritFrom(PosIdx pos, Displacement displ): ExprVar(pos, {})
+    {
+        this->level = 0;
+        this->displ = displ;
+        this->fromWith = nullptr;
+    }
+
+    void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env);
+};
+
 struct ExprSelect : Expr
 {
     PosIdx pos;
@@ -154,16 +171,40 @@ struct ExprAttrs : Expr
     bool recursive;
     PosIdx pos;
     struct AttrDef {
-        bool inherited;
+        enum class Kind {
+            /** `attr = expr;` */
+            Plain,
+            /** `inherit attr1 attrn;` */
+            Inherited,
+            /** `inherit (expr) attr1 attrn;` */
+            InheritedFrom,
+        };
+
+        Kind kind;
         Expr * e;
         PosIdx pos;
         Displacement displ; // displacement
-        AttrDef(Expr * e, const PosIdx & pos, bool inherited=false)
-            : inherited(inherited), e(e), pos(pos) { };
+        AttrDef(Expr * e, const PosIdx & pos, Kind kind = Kind::Plain)
+            : kind(kind), e(e), pos(pos) { };
         AttrDef() { };
+
+        template<typename T>
+        const T & chooseByKind(const T & plain, const T & inherited, const T & inheritedFrom) const
+        {
+            switch (kind) {
+            case Kind::Plain:
+                return plain;
+            case Kind::Inherited:
+                return inherited;
+            default:
+            case Kind::InheritedFrom:
+                return inheritedFrom;
+            }
+        }
     };
     typedef std::map<Symbol, AttrDef> AttrDefs;
     AttrDefs attrs;
+    std::unique_ptr<std::vector<Expr *>> inheritFromExprs;
     struct DynamicAttrDef {
         Expr * nameExpr, * valueExpr;
         PosIdx pos;
@@ -176,6 +217,11 @@ struct ExprAttrs : Expr
     ExprAttrs() : recursive(false) { };
     PosIdx getPos() const override { return pos; }
     COMMON_METHODS
+
+    std::shared_ptr<const StaticEnv> bindInheritSources(
+        EvalState & es, const std::shared_ptr<const StaticEnv> & env);
+    Env * buildInheritFromEnv(EvalState & state, Env & up);
+    void showBindings(const SymbolTable & symbols, std::ostream & str) const;
 };
 
 struct ExprList : Expr

src/libexpr/parser-state.hh

@@ -88,7 +88,7 @@ inline void ParserState::addAttr(ExprAttrs * attrs, AttrPath && attrPath, Expr *
         if (i->symbol) {
             ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
             if (j != attrs->attrs.end()) {
-                if (!j->second.inherited) {
+                if (j->second.kind != ExprAttrs::AttrDef::Kind::Inherited) {
                     ExprAttrs * attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
                     if (!attrs2) dupAttr(attrPath, pos, j->second.pos);
                     attrs = attrs2;
@@ -117,13 +117,24 @@ inline void ParserState::addAttr(ExprAttrs * attrs, AttrPath && attrPath, Expr *
             auto ae = dynamic_cast<ExprAttrs *>(e);
             auto jAttrs = dynamic_cast<ExprAttrs *>(j->second.e);
             if (jAttrs && ae) {
+                if (ae->inheritFromExprs && !jAttrs->inheritFromExprs)
+                    jAttrs->inheritFromExprs = std::make_unique<std::vector<Expr *>>();
                 for (auto & ad : ae->attrs) {
                     auto j2 = jAttrs->attrs.find(ad.first);
                     if (j2 != jAttrs->attrs.end()) // Attr already defined in iAttrs, error.
                         dupAttr(ad.first, j2->second.pos, ad.second.pos);
                     jAttrs->attrs.emplace(ad.first, ad.second);
+                    if (ad.second.kind == ExprAttrs::AttrDef::Kind::InheritedFrom) {
+                        auto & sel = dynamic_cast<ExprSelect &>(*ad.second.e);
+                        auto & from = dynamic_cast<ExprInheritFrom &>(*sel.e);
+                        from.displ += jAttrs->inheritFromExprs->size();
+                    }
                 }
                 jAttrs->dynamicAttrs.insert(jAttrs->dynamicAttrs.end(), ae->dynamicAttrs.begin(), ae->dynamicAttrs.end());
+                if (ae->inheritFromExprs) {
+                    jAttrs->inheritFromExprs->insert(jAttrs->inheritFromExprs->end(),
+                        ae->inheritFromExprs->begin(), ae->inheritFromExprs->end());
+                }
             } else {
                 dupAttr(attrPath, pos, j->second.pos);
             }

src/libexpr/parser.y

@@ -311,17 +311,27 @@ binds
           if ($$->attrs.find(i.symbol) != $$->attrs.end())
               state->dupAttr(i.symbol, state->at(@3), $$->attrs[i.symbol].pos);
           auto pos = state->at(@3);
-          $$->attrs.emplace(i.symbol, ExprAttrs::AttrDef(new ExprVar(CUR_POS, i.symbol), pos, true));
+          $$->attrs.emplace(
+              i.symbol,
+              ExprAttrs::AttrDef(new ExprVar(CUR_POS, i.symbol), pos, ExprAttrs::AttrDef::Kind::Inherited));
       }
       delete $3;
     }
   | binds INHERIT '(' expr ')' attrs ';'
     { $$ = $1;
-      /* !!! Should ensure sharing of the expression in $4. */
+      if (!$$->inheritFromExprs)
+          $$->inheritFromExprs = std::make_unique<std::vector<Expr *>>();
+      $$->inheritFromExprs->push_back($4);
+      auto from = new nix::ExprInheritFrom(state->at(@4), $$->inheritFromExprs->size() - 1);
       for (auto & i : *$6) {
           if ($$->attrs.find(i.symbol) != $$->attrs.end())
               state->dupAttr(i.symbol, state->at(@6), $$->attrs[i.symbol].pos);
-          $$->attrs.emplace(i.symbol, ExprAttrs::AttrDef(new ExprSelect(CUR_POS, $4, i.symbol), state->at(@6)));
+          $$->attrs.emplace(
+              i.symbol,
+              ExprAttrs::AttrDef(
+                  new ExprSelect(CUR_POS, from, i.symbol),
+                  state->at(@6),
+                  ExprAttrs::AttrDef::Kind::InheritedFrom));
       }
       delete $6;
     }

src/libexpr/primops.cc

@@ -754,15 +754,6 @@ static RegisterPrimOp primop_break({
 
             auto & dt = state.debugTraces.front();
             state.runDebugRepl(&error, dt.env, dt.expr);
-
-            if (state.debugQuit) {
-                // If the user elects to quit the repl, throw an exception.
-                throw Error(ErrorInfo{
-                    .level = lvlInfo,
-                    .msg = HintFmt("quit the debugger"),
-                    .pos = nullptr,
-                });
-            }
         }
 
         // Return the value we were passed.
@@ -814,7 +805,7 @@ static void prim_addErrorContext(EvalState & state, const PosIdx pos, Value * *
         auto message = state.coerceToString(pos, *args[0], context,
                 "while evaluating the error message passed to builtins.addErrorContext",
                 false, false).toOwned();
-        e.addTrace(nullptr, HintFmt(message), true);
+        e.addTrace(nullptr, HintFmt(message));
         throw;
     }
 }
@@ -873,7 +864,7 @@ static void prim_tryEval(EvalState & state, const PosIdx pos, Value * * args, Va
     /* increment state.trylevel, and decrement it when this function returns. */
     MaintainCount trylevel(state.trylevel);
 
-    void (* savedDebugRepl)(ref<EvalState> es, const ValMap & extraEnv) = nullptr;
+    ReplExitStatus (* savedDebugRepl)(ref<EvalState> es, const ValMap & extraEnv) = nullptr;
     if (state.debugRepl && evalSettings.ignoreExceptionsDuringTry)
     {
         /* to prevent starting the repl from exceptions withing a tryEval, null it. */
@@ -989,6 +980,10 @@ static void prim_trace(EvalState & state, const PosIdx pos, Value * * args, Valu
         printError("trace: %1%", args[0]->string.s);
     else
         printError("trace: %1%", ValuePrinter(state, *args[0]));
+    if (evalSettings.builtinsTraceDebugger && state.debugRepl && !state.debugTraces.empty()) {
+        const DebugTrace & last = state.debugTraces.front();
+        state.runDebugRepl(nullptr, last.env, last.expr);
+    }
     state.forceValue(*args[1], pos);
     v = *args[1];
 }
@@ -1000,6 +995,12 @@ static RegisterPrimOp primop_trace({
       Evaluate *e1* and print its abstract syntax representation on
       standard error. Then return *e2*. This function is useful for
       debugging.
+
+      If the
+      [`debugger-on-trace`](@docroot@/command-ref/conf-file.md#conf-debugger-on-trace)
+      option is set to `true` and the `--debugger` flag is given, the
+      interactive debugger will be started when `trace` is called (like
+      [`break`](@docroot@/language/builtins.md#builtins-break)).
     )",
     .fun = prim_trace,
 });
@@ -1068,7 +1069,7 @@ static void prim_derivationStrict(EvalState & state, const PosIdx pos, Value * *
         e.addTrace(nullptr, HintFmt(
                 "while evaluating derivation '%s'\n"
                 "  whose name attribute is located at %s",
-                drvName, pos), true);
+                drvName, pos));
         throw;
     }
 }
@@ -1226,8 +1227,7 @@ drvName, Bindings * attrs, Value & v)
 
         } catch (Error & e) {
             e.addTrace(state.positions[i->pos],
-                HintFmt("while evaluating attribute '%1%' of derivation '%2%'", key, drvName),
-                true);
+                HintFmt("while evaluating attribute '%1%' of derivation '%2%'", key, drvName));
             throw;
         }
     }
@@ -3279,11 +3279,8 @@ static void prim_sort(EvalState & state, const PosIdx pos, Value * * args, Value
            callFunction. */
         /* TODO: (layus) this is absurd. An optimisation like this
            should be outside the lambda creation */
-        if (args[0]->isPrimOp()) {
-            auto target = args[0]->primOp->fun.target<decltype(&prim_lessThan)>();
-            if (target && *target == prim_lessThan)
-                return CompareValues(state, noPos, "while evaluating the ordering function passed to builtins.sort")(a, b);
-        }
+        if (args[0]->isPrimOp() && args[0]->primOp->fun == prim_lessThan)
+            return CompareValues(state, noPos, "while evaluating the ordering function passed to builtins.sort")(a, b);
 
         Value * vs[] = {a, b};
         Value vBool;

src/libexpr/print-ambiguous.cc

@@ -1,6 +1,7 @@
 #include "print-ambiguous.hh"
 #include "print.hh"
 #include "eval.hh"
+#include "signals.hh"
 
 namespace nix {
 

src/libexpr/print-options.hh

@@ -17,24 +17,29 @@ struct PrintOptions
      * If true, output ANSI color sequences.
      */
     bool ansiColors = false;
+
     /**
      * If true, force values.
      */
     bool force = false;
+
     /**
      * If true and `force` is set, print derivations as
      * `«derivation /nix/store/...»` instead of as attribute sets.
      */
     bool derivationPaths = false;
+
     /**
      * If true, track which values have been printed and skip them on
      * subsequent encounters. Useful for self-referential values.
      */
     bool trackRepeated = true;
+
     /**
      * Maximum depth to evaluate to.
      */
     size_t maxDepth = std::numeric_limits<size_t>::max();
+
     /**
      * Maximum number of attributes in attribute sets to print.
      *
@@ -42,6 +47,7 @@ struct PrintOptions
      * attribute set encountered.
      */
     size_t maxAttrs = std::numeric_limits<size_t>::max();
+
     /**
      * Maximum number of list items to print.
      *
@@ -49,10 +55,26 @@ struct PrintOptions
      * list encountered.
      */
     size_t maxListItems = std::numeric_limits<size_t>::max();
+
     /**
      * Maximum string length to print.
      */
     size_t maxStringLength = std::numeric_limits<size_t>::max();
+
+    /**
+     * Indentation width for pretty-printing.
+     *
+     * If set to 0 (the default), values are not pretty-printed.
+     */
+    size_t prettyIndent = 0;
+
+    /**
+     * True if pretty-printing is enabled.
+     */
+    inline bool shouldPrettyPrint()
+    {
+        return prettyIndent > 0;
+    }
 };
 
 /**

src/libexpr/print.cc

@@ -5,6 +5,7 @@
 #include "ansicolor.hh"
 #include "store-api.hh"
 #include "english.hh"
+#include "signals.hh"
 #include "eval.hh"
 
 namespace nix {
@@ -151,6 +152,7 @@ struct ImportantFirstAttrNameCmp
 };
 
 typedef std::set<const void *> ValuesSeen;
+typedef std::vector<std::pair<std::string, Value *>> AttrVec;
 
 class Printer
 {
@@ -161,6 +163,37 @@ private:
     std::optional<ValuesSeen> seen;
     size_t attrsPrinted = 0;
     size_t listItemsPrinted = 0;
+    std::string indent;
+
+    void increaseIndent()
+    {
+        if (options.shouldPrettyPrint()) {
+            indent.append(options.prettyIndent, ' ');
+        }
+    }
+
+    void decreaseIndent()
+    {
+        if (options.shouldPrettyPrint()) {
+            assert(indent.size() >= options.prettyIndent);
+            indent.resize(indent.size() - options.prettyIndent);
+        }
+    }
+
+    /**
+     * Print a space (for separating items or attributes).
+     *
+     * If pretty-printing is enabled, a newline and the current `indent` is
+     * printed instead.
+     */
+    void printSpace(bool prettyPrint)
+    {
+        if (prettyPrint) {
+            output << "\n" << indent;
+        } else {
+            output << " ";
+        }
+    }
 
     void printRepeated()
     {
@@ -258,6 +291,28 @@ private:
         }
     }
 
+    bool shouldPrettyPrintAttrs(AttrVec & v)
+    {
+        if (!options.shouldPrettyPrint() || v.empty()) {
+            return false;
+        }
+
+        // Pretty-print attrsets with more than one item.
+        if (v.size() > 1) {
+            return true;
+        }
+
+        auto item = v[0].second;
+        if (!item) {
+            return true;
+        }
+
+        // Pretty-print single-item attrsets only if they contain nested
+        // structures.
+        auto itemType = item->type();
+        return itemType == nList || itemType == nAttrs || itemType == nThunk;
+    }
+
     void printAttrs(Value & v, size_t depth)
     {
         if (seen && !seen->insert(v.attrs).second) {
@@ -268,9 +323,10 @@ private:
         if (options.force && options.derivationPaths && state.isDerivation(v)) {
             printDerivation(v);
         } else if (depth < options.maxDepth) {
-            output << "{ ";
+            increaseIndent();
+            output << "{";
 
-            std::vector<std::pair<std::string, Value *>> sorted;
+            AttrVec sorted;
             for (auto & i : *v.attrs)
                 sorted.emplace_back(std::pair(state.symbols[i.name], i.value));
 
@@ -279,7 +335,11 @@ private:
             else
                 std::sort(sorted.begin(), sorted.end(), ImportantFirstAttrNameCmp());
 
+            auto prettyPrint = shouldPrettyPrintAttrs(sorted);
+
             for (auto & i : sorted) {
+                printSpace(prettyPrint);
+
                 if (attrsPrinted >= options.maxAttrs) {
                     printElided(sorted.size() - attrsPrinted, "attribute", "attributes");
                     break;
@@ -288,13 +348,38 @@ private:
                 printAttributeName(output, i.first);
                 output << " = ";
                 print(*i.second, depth + 1);
-                output << "; ";
+                output << ";";
                 attrsPrinted++;
             }
 
+            decreaseIndent();
+            printSpace(prettyPrint);
             output << "}";
-        } else
+        } else {
             output << "{ ... }";
+        }
+    }
+
+    bool shouldPrettyPrintList(std::span<Value * const> list)
+    {
+        if (!options.shouldPrettyPrint() || list.empty()) {
+            return false;
+        }
+
+        // Pretty-print lists with more than one item.
+        if (list.size() > 1) {
+            return true;
+        }
+
+        auto item = list[0];
+        if (!item) {
+            return true;
+        }
+
+        // Pretty-print single-item lists only if they contain nested
+        // structures.
+        auto itemType = item->type();
+        return itemType == nList || itemType == nAttrs || itemType == nThunk;
     }
 
     void printList(Value & v, size_t depth)
@@ -304,9 +389,14 @@ private:
             return;
         }
 
-        output << "[ ";
         if (depth < options.maxDepth) {
-            for (auto elem : v.listItems()) {
+            increaseIndent();
+            output << "[";
+            auto listItems = v.listItems();
+            auto prettyPrint = shouldPrettyPrintList(listItems);
+            for (auto elem : listItems) {
+                printSpace(prettyPrint);
+
                 if (listItemsPrinted >= options.maxListItems) {
                     printElided(v.listSize() - listItemsPrinted, "item", "items");
                     break;
@@ -317,13 +407,15 @@ private:
                 } else {
                     printNullptr();
                 }
-                output << " ";
                 listItemsPrinted++;
             }
+
+            decreaseIndent();
+            printSpace(prettyPrint);
+            output << "]";
+        } else {
+            output << "[ ... ]";
         }
-        else
-            output << "... ";
-        output << "]";
     }
 
     void printFunction(Value & v)
@@ -486,6 +578,7 @@ public:
     {
         attrsPrinted = 0;
         listItemsPrinted = 0;
+        indent.clear();
 
         if (options.trackRepeated) {
             seen.emplace();

src/libexpr/repl-exit-status.hh

@@ -0,0 +1,20 @@
+#pragma once
+
+namespace nix {
+
+/**
+ * Exit status returned from the REPL.
+ */
+enum class ReplExitStatus {
+    /**
+     * The user exited with `:quit`. The program (e.g., if the REPL was acting
+     * as the debugger) should exit.
+     */
+    QuitAll,
+    /**
+     * The user exited with `:continue`. The program should continue running.
+     */
+    Continue,
+};
+
+}

src/libexpr/search-path.cc

@@ -45,7 +45,7 @@ SearchPath::Elem SearchPath::Elem::parse(std::string_view rawElem)
 }
 
 
-SearchPath SearchPath::parse(const Strings & rawElems)
+SearchPath parseSearchPath(const Strings & rawElems)
 {
     SearchPath res;
     for (auto & rawElem : rawElems)

src/libexpr/value-to-json.cc

@@ -1,6 +1,7 @@
 #include "value-to-json.hh"
 #include "eval-inline.hh"
 #include "util.hh"
+#include "signals.hh"
 #include "store-api.hh"
 
 #include <cstdlib>

src/libexpr/value-to-xml.cc

@@ -2,6 +2,7 @@
 #include "xml-writer.hh"
 #include "eval-inline.hh"
 #include "util.hh"
+#include "signals.hh"
 
 #include <cstdlib>
 

src/libexpr/value.hh

@@ -384,7 +384,7 @@ public:
         return internalType == tList1 || internalType == tList2 ? smallList : bigList.elems;
     }
 
-    Value * const * listElems() const
+    const Value * const * listElems() const
     {
         return internalType == tList1 || internalType == tList2 ? smallList : bigList.elems;
     }

src/libfetchers/meson.build

@@ -1,28 +0,0 @@
-libfetchers_sources = files(
-  'attrs.cc',
-  'cache.cc',
-  'fetch-settings.cc',
-  'fetch-to-store.cc',
-  'fetchers.cc',
-  'git.cc',
-  'github.cc',
-  'indirect.cc',
-  'mercurial.cc',
-  'path.cc',
-  'registry.cc',
-  'tarball.cc',
-)
-
-libfetchers = library(
-  'nixfetchers',
-  libfetchers_sources,
-  dependencies : [
-    liblixstore,
-    liblixutil,
-  ],
-)
-
-liblixfetchers = declare_dependency(
-  include_directories : include_directories('.'),
-  link_with : libfetchers,
-)

src/libmain/meson.build

@@ -1,21 +0,0 @@
-libmain_sources = files(
-  'common-args.cc',
-  'loggers.cc',
-  'progress-bar.cc',
-  'shared.cc',
-  'stack.cc',
-)
-
-libmain = library(
-  'nixmain',
-  libmain_sources,
-  dependencies : [
-    liblixutil,
-    liblixstore,
-  ],
-)
-
-liblixmain = declare_dependency(
-  include_directories : include_directories('.'),
-  link_with : libmain,
-)

src/libmain/shared.cc

@@ -3,6 +3,7 @@
 #include "store-api.hh"
 #include "gc-store.hh"
 #include "util.hh"
+#include "signals.hh"
 #include "loggers.hh"
 #include "progress-bar.hh"
 
@@ -407,6 +408,4 @@ PrintFreed::~PrintFreed()
             showBytes(results.bytesFreed));
 }
 
-Exit::~Exit() { }
-
 }

src/libmain/shared.hh

@@ -6,6 +6,7 @@
 #include "common-args.hh"
 #include "path.hh"
 #include "derived-path.hh"
+#include "exit.hh"
 
 #include <signal.h>
 
@@ -14,15 +15,6 @@
 
 namespace nix {
 
-class Exit : public std::exception
-{
-public:
-    int status;
-    Exit() : status(0) { }
-    Exit(int status) : status(status) { }
-    virtual ~Exit();
-};
-
 int handleExceptions(const std::string & programName, std::function<void()> fun);
 
 /**

src/libstore/binary-cache-store.cc

@@ -10,6 +10,7 @@
 #include "nar-info-disk-cache.hh"
 #include "nar-accessor.hh"
 #include "thread-pool.hh"
+#include "signals.hh"
 #include "callback.hh"
 
 #include <chrono>

src/libstore/build/substitution-goal.cc

@@ -1,6 +1,7 @@
 #include "worker.hh"
 #include "substitution-goal.hh"
 #include "nar-info.hh"
+#include "signals.hh"
 #include "finally.hh"
 
 namespace nix {

src/libstore/build/worker.cc

@@ -3,6 +3,7 @@
 #include "substitution-goal.hh"
 #include "drv-output-substitution-goal.hh"
 #include "local-derivation-goal.hh"
+#include "signals.hh"
 #include "hook-instance.hh"
 
 #include <poll.h>

src/libstore/c/meson.build

@@ -1,26 +0,0 @@
-pkg = import('pkgconfig')
-
-libstorec_sources = files(
-  'nix_api_store.cc',
-)
-
-all_sources += {
-  'libstorec': libstorec_sources,
-}
-
-libstorec = library(
-  'nix-store-c',
-  libstorec_sources,
-  dependencies : [
-    liblixutil, # Internal.
-    liblixstore, # Internal.
-    liblixutilc, # Internal.
-  ],
-)
-
-pkg.generate(libstorec, requires : [ 'nix-util-c' ])
-
-liblixstorec = declare_dependency(
-  include_directories : include_directories('.'),
-  link_with : libstorec,
-)

src/libstore/c/nix_api_store.cc

@@ -1,136 +0,0 @@
-#include "nix_api_store.h"
-#include "nix_api_store_internal.h"
-#include "nix_api_util.h"
-#include "nix_api_util_internal.h"
-
-#include "path.hh"
-#include "store-api.hh"
-#include "build-result.hh"
-
-#include "globals.hh"
-
-nix_err nix_libstore_init(nix_c_context * context)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        nix::initLibStore();
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_init_plugins(nix_c_context * context)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        nix::initPlugins();
-    }
-    NIXC_CATCH_ERRS
-}
-
-Store * nix_store_open(nix_c_context * context, const char * uri, const char *** params)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        std::string uri_str = uri ? uri : "";
-
-        if (uri_str.empty())
-            return new Store{nix::openStore()};
-
-        if (!params)
-            return new Store{nix::openStore(uri_str)};
-
-        nix::Store::Params params_map;
-        for (size_t i = 0; params[i] != nullptr; i++) {
-            params_map[params[i][0]] = params[i][1];
-        }
-        return new Store{nix::openStore(uri_str, params_map)};
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-void nix_store_free(Store * store)
-{
-    delete store;
-}
-
-nix_err nix_store_get_uri(nix_c_context * context, Store * store, char * dest, unsigned int n)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto res = store->ptr->getUri();
-        return nix_export_std_string(context, res, dest, n);
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_store_get_version(nix_c_context * context, Store * store, char * dest, unsigned int n)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        auto res = store->ptr->getVersion();
-        if (!res)
-            res = "";
-        return nix_export_std_string(context, *res, dest, n);
-    }
-    NIXC_CATCH_ERRS
-}
-
-bool nix_store_is_valid_path(nix_c_context * context, Store * store, StorePath * path)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        return store->ptr->isValidPath(path->path);
-    }
-    NIXC_CATCH_ERRS_RES(false);
-}
-
-StorePath * nix_store_parse_path(nix_c_context * context, Store * store, const char * path)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        nix::StorePath s = store->ptr->parseStorePath(path);
-        return new StorePath{std::move(s)};
-    }
-    NIXC_CATCH_ERRS_NULL
-}
-
-nix_err nix_store_realise(
-    nix_c_context * context,
-    Store * store,
-    StorePath * path,
-    void * userdata,
-    void (*callback)(void * userdata, const char *, const char *))
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-
-        const std::vector<nix::DerivedPath> paths{nix::DerivedPath::Built{
-            .drvPath = nix::makeConstantStorePathRef(path->path), .outputs = nix::OutputsSpec::All{}}};
-
-        const auto nixStore = store->ptr;
-        auto results = nixStore->buildPathsWithResults(paths, nix::bmNormal, nixStore);
-
-        if (callback) {
-            for (const auto & result : results) {
-                for (const auto & [outputName, realisation] : result.builtOutputs) {
-                    auto op = store->ptr->printStorePath(realisation.outPath);
-                    callback(userdata, outputName.c_str(), op.c_str());
-                }
-            }
-        }
-    }
-    NIXC_CATCH_ERRS
-}
-
-void nix_store_path_free(StorePath * sp)
-{
-    delete sp;
-}

src/libstore/c/nix_api_store.h

@@ -1,146 +0,0 @@
-#ifndef NIX_API_STORE_H
-#define NIX_API_STORE_H
-/**
- * @defgroup libstore libstore
- * @brief C bindings for nix libstore
- *
- * libstore is used for talking to a Nix store
- * @{
- */
-/** @file
- * @brief Main entry for the libstore C bindings
- */
-
-#include "nix_api_util.h"
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-// cffi start
-
-/** @brief Reference to a Nix store */
-typedef struct Store Store;
-/** @brief Nix store path */
-typedef struct StorePath StorePath;
-
-/**
- * @brief Initializes the Nix store library
- *
- * This function should be called before creating a Store
- * This function can be called multiple times.
- *
- * @param[out] context Optional, stores error information
- * @return NIX_OK if the initialization was successful, an error code otherwise.
- */
-nix_err nix_libstore_init(nix_c_context * context);
-
-/**
- * @brief Loads the plugins specified in Nix's plugin-files setting.
- *
- * Call this once, after calling your desired init functions and setting
- * relevant settings.
- *
- * @param[out] context Optional, stores error information
- * @return NIX_OK if the initialization was successful, an error code otherwise.
- */
-nix_err nix_init_plugins(nix_c_context * context);
-
-/**
- * @brief Open a nix store
- * Store instances may share state and resources behind the scenes.
- * @param[out] context Optional, stores error information
- * @param[in] uri URI of the nix store, copied
- * @param[in] params optional, array of key-value pairs, {{"endpoint",
- * "https://s3.local"}}
- * @return a Store pointer, NULL in case of errors
- * @see nix_store_free
- */
-Store * nix_store_open(nix_c_context *, const char * uri, const char *** params);
-
-/**
- * @brief Deallocate a nix store and free any resources if not also held by other Store instances.
- *
- * Does not fail.
- *
- * @param[in] store the store to free
- */
-void nix_store_free(Store * store);
-
-/**
- * @brief get the URI of a nix store
- * @param[out] context Optional, stores error information
- * @param[in] store nix store reference
- * @param[out] dest The allocated area to write the string to.
- * @param[in] n Maximum size of the returned string.
- * @return error code, NIX_OK on success.
- */
-nix_err nix_store_get_uri(nix_c_context * context, Store * store, char * dest, unsigned int n);
-
-// returns: owned StorePath*
-/**
- * @brief Parse a Nix store path into a StorePath
- *
- * @note Don't forget to free this path using nix_store_path_free()!
- * @param[out] context Optional, stores error information
- * @param[in] store nix store reference
- * @param[in] path Path string to parse, copied
- * @return owned store path, NULL on error
- */
-StorePath * nix_store_parse_path(nix_c_context * context, Store * store, const char * path);
-
-/** @brief Deallocate a StorePath
- *
- * Does not fail.
- * @param[in] p the path to free
- */
-void nix_store_path_free(StorePath * p);
-
-/**
- * @brief Check if a StorePath is valid (i.e. that corresponding store object and its closure of references exists in
- * the store)
- * @param[out] context Optional, stores error information
- * @param[in] store Nix Store reference
- * @param[in] path Path to check
- * @return true or false, error info in context
- */
-bool nix_store_is_valid_path(nix_c_context * context, Store * store, StorePath * path);
-// nix_err nix_store_ensure(Store*, const char*);
-// nix_err nix_store_build_paths(Store*);
-/**
- * @brief Realise a Nix store path
- *
- * Blocking, calls callback once for each realised output
- *
- * @param[out] context Optional, stores error information
- * @param[in] store Nix Store reference
- * @param[in] path Path to build
- * @param[in] userdata data to pass to every callback invocation
- * @param[in] callback called for every realised output
- */
-nix_err nix_store_realise(
-    nix_c_context * context,
-    Store * store,
-    StorePath * path,
-    void * userdata,
-    void (*callback)(void * userdata, const char * outname, const char * out));
-
-/**
- * @brief get the version of a nix store.
- * If the store doesn't have a version (like the dummy store), returns an empty string.
- * @param[out] context Optional, stores error information
- * @param[in] store nix store reference
- * @param[out] dest The allocated area to write the string to.
- * @param[in] n Maximum size of the returned string.
- * @return error code, NIX_OK on success.
- */
-nix_err nix_store_get_version(nix_c_context *, Store * store, char * dest, unsigned int n);
-
-// cffi end
-#ifdef __cplusplus
-}
-#endif
-/**
- * @}
- */
-#endif // NIX_API_STORE_H

src/libstore/c/nix_api_store_internal.h

@@ -1,15 +0,0 @@
-#ifndef NIX_API_STORE_INTERNAL_H
-#define NIX_API_STORE_INTERNAL_H
-#include "store-api.hh"
-
-struct Store
-{
-    nix::ref<nix::Store> ptr;
-};
-
-struct StorePath
-{
-    nix::StorePath path;
-};
-
-#endif

src/libstore/filetransfer.cc

@@ -3,6 +3,7 @@
 #include "globals.hh"
 #include "store-api.hh"
 #include "s3.hh"
+#include "signals.hh"
 #include "compression.hh"
 #include "finally.hh"
 #include "callback.hh"

src/libstore/gc.cc

@@ -1,6 +1,7 @@
 #include "derivations.hh"
 #include "globals.hh"
 #include "local-store.hh"
+#include "signals.hh"
 #include "finally.hh"
 
 #include <functional>

src/libstore/globals.cc

@@ -342,7 +342,7 @@ void initPlugins()
             void *handle =
                 dlopen(file.c_str(), RTLD_LAZY | RTLD_LOCAL);
             if (!handle)
-                throw Error("could not dynamically open plugin file '%s': %s", file, dlerror());
+                warn("could not dynamically open plugin file '%s': %s", file, dlerror());
         }
     }
 

src/libstore/local-store.cc

@@ -8,6 +8,7 @@
 #include "references.hh"
 #include "callback.hh"
 #include "topo-sort.hh"
+#include "signals.hh"
 #include "finally.hh"
 #include "compression.hh"
 

src/libstore/meson.build

@@ -1,124 +0,0 @@
-schema_sql_gen = gen_header.process('schema.sql')
-ca_specific_schema_gen = gen_header.process('ca-specific-schema.sql')
-
-libstore_sources = files(
-  'binary-cache-store.cc',
-  'build-result.cc',
-  'common-protocol.cc',
-  'content-address.cc',
-  'crypto.cc',
-  'daemon.cc',
-  'derivations.cc',
-  'derived-path-map.cc',
-  'derived-path.cc',
-  'downstream-placeholder.cc',
-  'dummy-store.cc',
-  'export-import.cc',
-  'filetransfer.cc',
-  'gc.cc',
-  'globals.cc',
-  'http-binary-cache-store.cc',
-  'legacy-ssh-store.cc',
-  'local-binary-cache-store.cc',
-  'local-fs-store.cc',
-  'local-store.cc',
-  'lock.cc',
-  'log-store.cc',
-  'machines.cc',
-  'make-content-addressed.cc',
-  'misc.cc',
-  'names.cc',
-  'nar-accessor.cc',
-  'nar-info-disk-cache.cc',
-  'nar-info.cc',
-  'optimise-store.cc',
-  'outputs-spec.cc',
-  'parsed-derivations.cc',
-  'path-info.cc',
-  'path-references.cc',
-  'path-with-outputs.cc',
-  'path.cc',
-  'pathlocks.cc',
-  'profiles.cc',
-  'realisation.cc',
-  'remote-fs-accessor.cc',
-  'remote-store.cc',
-  's3-binary-cache-store.cc',
-  'serve-protocol.cc',
-  'sqlite.cc',
-  'ssh-store.cc',
-  'ssh.cc',
-  'store-api.cc',
-  'uds-remote-store.cc',
-  'worker-protocol.cc',
-  'build/derivation-goal.cc',
-  'build/drv-output-substitution-goal.cc',
-  'build/entry-points.cc',
-  'build/goal.cc',
-  'build/hook-instance.cc',
-  'build/local-derivation-goal.cc',
-  'build/personality.cc',
-  'build/substitution-goal.cc',
-  'build/worker.cc',
-  'builtins/buildenv.cc',
-  'builtins/fetchurl.cc',
-  'builtins/unpack-channel.cc',
-)
-
-all_sources += {
-  'libstore': libstore_sources,
-}
-
-prefix = get_option('prefix')
-
-cpp_str_defines = {
-  'LSOF': lsof.full_path(),
-  'NIX_PREFIX':    get_option('prefix'),
-  'NIX_STORE_DIR': get_option('store-dir'),
-  'NIX_DATA_DIR':  get_option('prefix') / 'share', # FIXME: make separately-configurable
-  #'NIX_STATE_DIR': get_option('prefix') / 'nix', # FIXME: same
-  'NIX_LOG_DIR':   get_option('prefix') / 'log' / 'nix', # FIXME: same
-  'NIX_CONF_DIR':  get_option('prefix') / 'etc', # FIXME: same
-  'NIX_BIN_DIR':   get_option('prefix') / 'bin', # FIXME: same
-  'NIX_MAN_DIR':   get_option('prefix') / 'share' / 'man', # FIXME: same
-}
-
-cpp_str_defines += {
-  'NIX_STATE_DIR': '/nix/var/nix',
-}
-
-cpp_args = []
-
-foreach name, value : cpp_str_defines
-  cpp_args += [
-    '-D' + name + '=' + '"' + value + '"'
-  ]
-endforeach
-
-libstore = library(
-  'nixstore',
-  schema_sql_gen,
-  ca_specific_schema_gen,
-  libstore_sources,
-  dependencies : [
-    libarchive,
-    liblixutil, # Internal.
-    seccomp,
-    sqlite,
-    sodium,
-    curl,
-    openssl,
-    aws_sdk,
-    aws_s3,
-    aws_sdk_transfer,
-  ],
-  cpp_args : cpp_args,
-)
-
-# Used by libfetchers.
-liblixstore = declare_dependency(
-  include_directories : include_directories('.'),
-  link_with : libstore,
-)
-
-subdir('c')

src/libstore/optimise-store.cc

@@ -1,6 +1,7 @@
 #include "util.hh"
 #include "local-store.hh"
 #include "globals.hh"
+#include "signals.hh"
 
 #include <cstdlib>
 #include <cstring>

src/libstore/pathlocks.cc

@@ -1,5 +1,6 @@
 #include "pathlocks.hh"
 #include "util.hh"
+#include "signals.hh"
 #include "sync.hh"
 
 #include <cerrno>

src/libstore/remote-store.cc

@@ -1,5 +1,6 @@
 #include "serialise.hh"
 #include "util.hh"
+#include "signals.hh"
 #include "path-with-outputs.hh"
 #include "gc-store.hh"
 #include "remote-fs-accessor.hh"

src/libstore/sqlite.cc

@@ -1,6 +1,7 @@
 #include "sqlite.hh"
 #include "globals.hh"
 #include "util.hh"
+#include "signals.hh"
 #include "url.hh"
 
 #include <sqlite3.h>

src/libstore/store-api.cc

@@ -11,6 +11,7 @@
 #include "archive.hh"
 #include "callback.hh"
 #include "remote-store.hh"
+#include "signals.hh"
 // FIXME this should not be here, see TODO below on
 // `addMultipleToStore`.
 #include "worker-protocol.hh"

src/libutil/archive.cc

@@ -14,6 +14,7 @@
 #include "archive.hh"
 #include "util.hh"
 #include "config.hh"
+#include "signals.hh"
 
 namespace nix {
 

src/libutil/box_ptr.hh

@@ -0,0 +1,121 @@
+#pragma once
+/// @file
+
+#include <concepts>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <assert.h>
+
+namespace nix {
+
+/** A pointer that's like Rust's Box: forwards comparisons to the inner class and is non-null */
+template<typename T>
+// FIXME: add custom deleter support
+class box_ptr
+{
+    std::unique_ptr<T> inner;
+
+    template<typename T2>
+    friend class box_ptr;
+
+    explicit box_ptr(std::unique_ptr<T> p)
+        : inner(std::move(p))
+    {
+        assert(inner != nullptr);
+    }
+
+public:
+    using pointer = typename std::unique_ptr<T>::pointer;
+
+    inline typename std::add_lvalue_reference<T>::type operator*() const noexcept
+    {
+        return *inner.get();
+    }
+
+    inline pointer operator->() const noexcept
+    {
+        return inner.get();
+    }
+
+    inline pointer get() const noexcept
+    {
+        return inner.get();
+    }
+
+    /**
+     * Create a box_ptr from a nonnull unique_ptr.
+     */
+    static inline box_ptr<T> unsafeFromNonnull(std::unique_ptr<T> p)
+    {
+        return box_ptr(std::move(p));
+    }
+
+    inline box_ptr<T> & operator=(box_ptr<T> && other) noexcept = default;
+
+    // No copy for you.
+    box_ptr<T> & operator=(const box_ptr<T> &) = delete;
+
+    // XXX: we have to set the other's insides to nullptr, since we cannot
+    // put a garbage object there, and we don't have any compiler
+    // enforcement to not touch moved-from values. sighh.
+    box_ptr(box_ptr<T> && other) = default;
+
+    /** Conversion operator */
+    template<typename Other>
+    // n.b. the requirements here are the same as libstdc++ unique_ptr's checks but with concepts
+    requires std::convertible_to<typename box_ptr<Other>::pointer, pointer> &&(!std::is_array_v<Other>)
+        box_ptr(box_ptr<Other> && other) noexcept
+        : inner(std::move(other.inner))
+    {
+        other.inner = nullptr;
+    }
+
+    box_ptr(box_ptr<T> & other) = delete;
+};
+
+template<typename T>
+requires std::equality_comparable<T>
+bool operator==(box_ptr<T> const & x, box_ptr<T> const & y)
+{
+    // Although there could be an optimization here that compares x == y, this
+    // is unsound for floats with NaN, or anything else that violates
+    // reflexivity.
+    return *x == *y;
+}
+
+template<typename T>
+requires std::equality_comparable<T>
+bool operator!=(box_ptr<T> const & x, box_ptr<T> const & y)
+{
+    return *x != *y;
+}
+
+#define MAKE_COMPARISON(OP) \
+    template<typename T> \
+    requires std::totally_ordered<T> \
+    bool operator OP(box_ptr<T> const & x, box_ptr<T> const & y) \
+    { \
+        return *x OP * y; \
+    }
+
+MAKE_COMPARISON(<);
+MAKE_COMPARISON(>);
+MAKE_COMPARISON(>=);
+MAKE_COMPARISON(<=);
+
+#undef MAKE_COMPARISON
+
+template<typename T>
+requires std::three_way_comparable<T> std::compare_three_way_result_t<T, T>
+operator<=>(box_ptr<T> const & x, box_ptr<T> const & y)
+{
+    return *x <=> *y;
+}
+
+template<typename T, typename... Args>
+inline box_ptr<T> make_box_ptr(Args &&... args)
+{
+    return box_ptr<T>::unsafeFromNonnull(std::make_unique<T>(std::forward<Args>(args)...));
+}
+};

src/libutil/c/meson.build

@@ -1,25 +0,0 @@
-pkg = import('pkgconfig')
-
-libutilc_sources = files(
-  'nix_api_util.cc',
-)
-
-all_sources += {
-  'libutilc': libutilc_sources,
-}
-
-libutilc = library(
-  'nix-util-c',
-  libutilc_sources,
-  dependencies : [
-    liblixutil,
-  ],
-  implicit_include_directories : true,
-)
-
-pkg.generate(libutilc)
-
-liblixutilc = declare_dependency(
-  include_directories : include_directories('.'),
-  link_with : libutilc
-)

src/libutil/c/nix_api_util.cc

@@ -1,151 +0,0 @@
-#include "nix_api_util.h"
-#include "config.hh"
-#include "error.hh"
-#include "nix_api_util_internal.h"
-#include "util.hh"
-
-#include <cxxabi.h>
-#include <typeinfo>
-
-nix_c_context * nix_c_context_create()
-{
-    return new nix_c_context();
-}
-
-void nix_c_context_free(nix_c_context * context)
-{
-    delete context;
-}
-
-nix_err nix_context_error(nix_c_context * context)
-{
-    if (context == nullptr) {
-        throw;
-    }
-    try {
-        throw;
-    } catch (nix::Error & e) {
-        /* Storing this exception is annoying, take what we need here */
-        context->last_err = e.what();
-        context->info = e.info();
-        int status;
-        const char * demangled = abi::__cxa_demangle(typeid(e).name(), 0, 0, &status);
-        if (demangled) {
-            context->name = demangled;
-            // todo: free(demangled);
-        } else {
-            context->name = typeid(e).name();
-        }
-        context->last_err_code = NIX_ERR_NIX_ERROR;
-        return context->last_err_code;
-    } catch (const std::exception & e) {
-        context->last_err = e.what();
-        context->last_err_code = NIX_ERR_UNKNOWN;
-        return context->last_err_code;
-    }
-    // unreachable
-}
-
-nix_err nix_set_err_msg(nix_c_context * context, nix_err err, const char * msg)
-{
-    if (context == nullptr) {
-        // todo last_err_code
-        throw nix::Error("Nix C api error: %s", msg);
-    }
-    context->last_err_code = err;
-    context->last_err = msg;
-    return err;
-}
-
-const char * nix_version_get()
-{
-    return PACKAGE_VERSION;
-}
-
-// Implementations
-nix_err nix_setting_get(nix_c_context * context, const char * key, char * value, int n)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        std::map<std::string, nix::AbstractConfig::SettingInfo> settings;
-        nix::globalConfig.getSettings(settings);
-        if (settings.contains(key))
-            return nix_export_std_string(context, settings[key].value, value, n);
-        else {
-            return nix_set_err_msg(context, NIX_ERR_KEY, "Setting not found");
-        }
-    }
-    NIXC_CATCH_ERRS
-}
-
-nix_err nix_setting_set(nix_c_context * context, const char * key, const char * value)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    if (nix::globalConfig.set(key, value))
-        return NIX_OK;
-    else {
-        return nix_set_err_msg(context, NIX_ERR_KEY, "Setting not found");
-    }
-}
-
-nix_err nix_libutil_init(nix_c_context * context)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    try {
-        nix::initLibUtil();
-        return NIX_OK;
-    }
-    NIXC_CATCH_ERRS
-}
-
-const char * nix_err_msg(nix_c_context * context, const nix_c_context * read_context, unsigned int * n)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    if (read_context->last_err) {
-        if (n)
-            *n = read_context->last_err->size();
-        return read_context->last_err->c_str();
-    }
-    nix_set_err_msg(context, NIX_ERR_UNKNOWN, "No error message");
-    return nullptr;
-}
-
-nix_err nix_err_name(nix_c_context * context, const nix_c_context * read_context, char * value, int n)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    if (read_context->last_err_code != NIX_ERR_NIX_ERROR) {
-        return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "Last error was not a nix error");
-    }
-    return nix_export_std_string(context, read_context->name, value, n);
-}
-
-nix_err nix_err_info_msg(nix_c_context * context, const nix_c_context * read_context, char * value, int n)
-{
-    if (context)
-        context->last_err_code = NIX_OK;
-    if (read_context->last_err_code != NIX_ERR_NIX_ERROR) {
-        return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "Last error was not a nix error");
-    }
-    return nix_export_std_string(context, read_context->info->msg.str(), value, n);
-}
-
-nix_err nix_err_code(const nix_c_context * read_context)
-{
-    return read_context->last_err_code;
-}
-
-// internal
-nix_err nix_export_std_string(nix_c_context * context, const std::string_view str, char * dest, unsigned int n)
-{
-    size_t i = str.copy(dest, n - 1);
-    dest[i] = 0;
-    if (i == n - 1) {
-        return nix_set_err_msg(context, NIX_ERR_OVERFLOW, "Provided buffer too short");
-    } else
-        return NIX_OK;
-}

src/libutil/c/nix_api_util.h

@@ -1,290 +0,0 @@
-#ifndef NIX_API_UTIL_H
-#define NIX_API_UTIL_H
-/**
- * @defgroup libutil libutil
- * @brief C bindings for nix libutil
- *
- * libutil is used for functionality shared between
- * different Nix modules.
- * @{
- */
-/** @file
- * @brief Main entry for the libutil C bindings
- *
- * Also contains error handling utilities
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-// cffi start
-
-/** @defgroup errors Handling errors
- * @brief Dealing with errors from the Nix side
- *
- * To handle errors that can be returned from the Nix API,
- * a nix_c_context can be passed to any function that potentially returns an
- * error.
- *
- * Error information will be stored in this context, and can be retrieved
- * using nix_err_code and nix_err_msg.
- *
- * Passing NULL instead will cause the API to throw C++ errors.
- *
- * Example:
- * @code{.c}
- * int main() {
- *     nix_c_context* ctx = nix_c_context_create();
- *     nix_libutil_init(ctx);
- *     if (nix_err_code(ctx) != NIX_OK) {
- *         printf("error: %s\n", nix_err_msg(NULL, ctx, NULL));
- *         return 1;
- *     }
- *     return 0;
- * }
- * @endcode
- *  @{
- */
-// Error codes
-/**
- * @brief Type for error codes in the NIX system
- *
- * This type can have one of several predefined constants:
- * - NIX_OK: No error occurred (0)
- * - NIX_ERR_UNKNOWN: An unknown error occurred (-1)
- * - NIX_ERR_OVERFLOW: An overflow error occurred (-2)
- * - NIX_ERR_KEY: A key error occurred (-3)
- * - NIX_ERR_NIX_ERROR: A generic Nix error occurred (-4)
- */
-typedef int nix_err;
-
-/**
- * @brief No error occurred.
- *
- * This error code is returned when no error has occurred during the function
- * execution.
- */
-#define NIX_OK 0
-
-/**
- * @brief An unknown error occurred.
- *
- * This error code is returned when an unknown error occurred during the
- * function execution.
- */
-#define NIX_ERR_UNKNOWN -1
-
-/**
- * @brief An overflow error occurred.
- *
- * This error code is returned when an overflow error occurred during the
- * function execution.
- */
-#define NIX_ERR_OVERFLOW -2
-
-/**
- * @brief A key error occurred.
- *
- * This error code is returned when a key error occurred during the function
- * execution.
- */
-#define NIX_ERR_KEY -3
-
-/**
- * @brief A generic Nix error occurred.
- *
- * This error code is returned when a generic Nix error occurred during the
- * function execution.
- */
-#define NIX_ERR_NIX_ERROR -4
-
-/**
- * @brief This object stores error state.
- * @struct nix_c_context
- *
- * Passed as a first parameter to functions that can fail, to store error
- * information.
- *
- * Optional wherever it can be used, passing NULL instead will throw a C++
- * exception.
- *
- * The struct is laid out so that it can also be cast to nix_err* to inspect
- * directly:
- * @code{.c}
- * assert(*(nix_err*)ctx == NIX_OK);
- * @endcode
- * @note These can be reused between different function calls,
- *  but make sure not to use them for multiple calls simultaneously (which can
- * happen in callbacks).
- */
-typedef struct nix_c_context nix_c_context;
-
-// Function prototypes
-
-/**
- * @brief Allocate a new nix_c_context.
- * @throws std::bad_alloc
- * @return allocated nix_c_context, owned by the caller. Free using
- * `nix_c_context_free`.
- */
-nix_c_context * nix_c_context_create();
-/**
- * @brief Free a nix_c_context. Does not fail.
- * @param[out] context The context to free, mandatory.
- */
-void nix_c_context_free(nix_c_context * context);
-/**
- *  @}
- */
-
-/**
- * @brief Initializes nix_libutil and its dependencies.
- *
- * This function can be called multiple times, but should be called at least
- * once prior to any other nix function.
- *
- * @param[out] context Optional, stores error information
- * @return NIX_OK if the initialization is successful, or an error code
- * otherwise.
- */
-nix_err nix_libutil_init(nix_c_context * context);
-
-/** @defgroup settings
- *  @{
- */
-/**
- * @brief Retrieves a setting from the nix global configuration.
- *
- * This function requires nix_libutil_init() to be called at least once prior to
- * its use.
- *
- * @param[out] context optional, Stores error information
- * @param[in] key The key of the setting to retrieve.
- * @param[out] value A pointer to a buffer where the value of the setting will
- * be stored.
- * @param[in] n The size of the buffer pointed to by value.
- * @return NIX_ERR_KEY if the setting is unknown, NIX_ERR_OVERFLOW if the
- * provided buffer is too short, or NIX_OK if the setting was retrieved
- * successfully.
- */
-nix_err nix_setting_get(nix_c_context * context, const char * key, char * value, int n);
-
-/**
- * @brief Sets a setting in the nix global configuration.
- *
- * Use "extra-<setting name>" to append to the setting's value.
- *
- * Settings only apply for new State%s. Call nix_plugins_init() when you are
- * done with the settings to load any plugins.
- *
- * @param[out] context optional, Stores error information
- * @param[in] key The key of the setting to set.
- * @param[in] value The value to set for the setting.
- * @return NIX_ERR_KEY if the setting is unknown, or NIX_OK if the setting was
- * set successfully.
- */
-nix_err nix_setting_set(nix_c_context * context, const char * key, const char * value);
-
-/**
- *  @}
- */
-// todo: nix_plugins_init()
-
-/**
- * @brief Retrieves the nix library version.
- *
- * Does not fail.
- * @return A static string representing the version of the nix library.
- */
-const char * nix_version_get();
-
-/** @addtogroup errors
- *  @{
- */
-/**
- * @brief Retrieves the most recent error message from a context.
- *
- * @pre This function should only be called after a previous nix function has
- * returned an error.
- *
- * @param[out] context optional, the context to store errors in if this function
- * fails
- * @param[in] ctx the context to retrieve the error message from
- * @param[out] n optional: a pointer to an unsigned int that is set to the
- * length of the error.
- * @return nullptr if no error message was ever set,
- *         a borrowed pointer to the error message otherwise.
- */
-const char * nix_err_msg(nix_c_context * context, const nix_c_context * ctx, unsigned int * n);
-
-/**
- * @brief Retrieves the error message from errorInfo in a context.
- *
- * Used to inspect nix Error messages.
- *
- * @pre This function should only be called after a previous nix function has
- * returned a NIX_ERR_NIX_ERROR
- *
- * @param[out] context optional, the context to store errors in if this function
- * fails
- * @param[in] read_context the context to retrieve the error message from
- * @param[out] value The allocated area to write the error string to.
- * @param[in] n Maximum size of the returned string.
- * @return NIX_OK if there were no errors, an error code otherwise.
- */
-nix_err nix_err_info_msg(nix_c_context * context, const nix_c_context * read_context, char * value, int n);
-
-/**
- * @brief Retrieves the error name from a context.
- *
- * Used to inspect nix Error messages.
- *
- * @pre This function should only be called after a previous nix function has
- * returned a NIX_ERR_NIX_ERROR
- *
- * @param context optional, the context to store errors in if this function
- * fails
- * @param[in] read_context the context to retrieve the error message from
- * @param[out] value The allocated area to write the error string to.
- * @param[in] n Maximum size of the returned string.
- * @return NIX_OK if there were no errors, an error code otherwise.
- */
-nix_err nix_err_name(nix_c_context * context, const nix_c_context * read_context, char * value, int n);
-
-/**
- * @brief Retrieves the most recent error code from a nix_c_context
- *
- * Equivalent to reading the first field of the context.
- *
- * Does not fail
- *
- * @param[in] read_context the context to retrieve the error message from
- * @return most recent error code stored in the context.
- */
-nix_err nix_err_code(const nix_c_context * read_context);
-
-/**
- * @brief Set an error message on a nix context.
- *
- * This should be used when you want to throw an error from a PrimOp callback.
- *
- * All other use is internal to the API.
- *
- * @param context context to write the error message to, or NULL
- * @param err The error code to set and return
- * @param msg The error message to set.
- * @returns the error code set
- */
-nix_err nix_set_err_msg(nix_c_context * context, nix_err err, const char * msg);
-
-/**
- *  @}
- */
-
-// cffi end
-#ifdef __cplusplus
-}
-#endif
-
-/** @} */
-#endif // NIX_API_UTIL_H

src/libutil/c/nix_api_util_internal.h

@@ -1,49 +0,0 @@
-#ifndef NIX_API_UTIL_INTERNAL_H
-#define NIX_API_UTIL_INTERNAL_H
-
-#include <string>
-#include <optional>
-
-#include "error.hh"
-#include "nix_api_util.h"
-
-struct nix_c_context
-{
-    nix_err last_err_code = NIX_OK;
-    std::optional<std::string> last_err = {};
-    std::optional<nix::ErrorInfo> info = {};
-    std::string name = "";
-};
-
-nix_err nix_context_error(nix_c_context * context);
-
-/**
- * Internal use only.
- *
- * Export a std::string across the C api boundary
- * @param context optional, the context to store errors in if this function
- * fails
- * @param str The string to export
- * @param value The allocated area to write the string to.
- * @param n Maximum size of the returned string.
- * @return NIX_OK if there were no errors, NIX_ERR_OVERFLOW if the string length
- * exceeds `n`.
- */
-nix_err nix_export_std_string(nix_c_context * context, const std::string_view str, char * dest, unsigned int n);
-
-#define NIXC_CATCH_ERRS \
-    catch (...) \
-    { \
-        return nix_context_error(context); \
-    } \
-    return NIX_OK;
-
-#define NIXC_CATCH_ERRS_RES(def) \
-    catch (...) \
-    { \
-        nix_context_error(context); \
-        return def; \
-    }
-#define NIXC_CATCH_ERRS_NULL NIXC_CATCH_ERRS_RES(nullptr)
-
-#endif // NIX_API_UTIL_INTERNAL_H

src/libutil/compression.cc

@@ -2,6 +2,7 @@
 #include "tarfile.hh"
 #include "util.hh"
 #include "finally.hh"
+#include "signals.hh"
 #include "logging.hh"
 
 #include <archive.h>

src/libutil/error.cc

@@ -10,9 +10,9 @@ namespace nix {
 
 const std::string nativeSystem = SYSTEM;
 
-void BaseError::addTrace(std::shared_ptr<Pos> && e, HintFmt hint, bool frame)
+void BaseError::addTrace(std::shared_ptr<Pos> && e, HintFmt hint)
 {
-    err.traces.push_front(Trace { .pos = std::move(e), .hint = hint, .frame = frame });
+    err.traces.push_front(Trace { .pos = std::move(e), .hint = hint });
 }
 
 void throwExceptionSelfCheck(){
@@ -60,8 +60,7 @@ inline bool operator<(const Trace& lhs, const Trace& rhs)
     // This formats a freshly formatted hint string and then throws it away, which
     // shouldn't be much of a problem because it only runs when pos is equal, and this function is
     // used for trace printing, which is infrequent.
-    return std::forward_as_tuple(lhs.hint.str(), lhs.frame)
-        < std::forward_as_tuple(rhs.hint.str(), rhs.frame);
+    return lhs.hint.str() < rhs.hint.str();
 }
 inline bool operator> (const Trace& lhs, const Trace& rhs) { return rhs < lhs; }
 inline bool operator<=(const Trace& lhs, const Trace& rhs) { return !(lhs > rhs); }
@@ -372,7 +371,6 @@ std::ostream & showErrorInfo(std::ostream & out, const ErrorInfo & einfo, bool s
     // prepended to each element of the trace
     auto ellipsisIndent = "  ";
 
-    bool frameOnly = false;
     if (!einfo.traces.empty()) {
         // Stack traces seen since we last printed a chunk of `duplicate frames
         // omitted`.
@@ -383,7 +381,6 @@ std::ostream & showErrorInfo(std::ostream & out, const ErrorInfo & einfo, bool s
 
         for (const auto & trace : einfo.traces) {
             if (trace.hint.str().empty()) continue;
-            if (frameOnly && !trace.frame) continue;
 
             if (!showTrace && count > 3) {
                 oss << "\n" << ANSI_WARNING "(stack trace truncated; use '--show-trace' to show the full trace)" ANSI_NORMAL << "\n";
@@ -399,7 +396,6 @@ std::ostream & showErrorInfo(std::ostream & out, const ErrorInfo & einfo, bool s
             printSkippedTracesMaybe(oss, ellipsisIndent, count, skippedTraces, tracesSeen);
 
             count++;
-            frameOnly = trace.frame;
 
             printTrace(oss, ellipsisIndent, count, trace);
         }

src/libutil/error.hh

@@ -64,7 +64,6 @@ void printCodeLines(std::ostream & out,
 struct Trace {
     std::shared_ptr<Pos> pos;
     HintFmt hint;
-    bool frame;
 };
 
 inline bool operator<(const Trace& lhs, const Trace& rhs);
@@ -162,7 +161,7 @@ public:
         addTrace(std::move(e), HintFmt(std::string(fs), args...));
     }
 
-    void addTrace(std::shared_ptr<Pos> && e, HintFmt hint, bool frame = false);
+    void addTrace(std::shared_ptr<Pos> && e, HintFmt hint);
 
     bool hasTrace() const { return !err.traces.empty(); }
 

src/libutil/exit.cc

@@ -0,0 +1,7 @@
+#include "exit.hh"
+
+namespace nix {
+
+Exit::~Exit() {}
+
+}

src/libutil/exit.hh

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <exception>
+
+namespace nix {
+
+/**
+ * Exit the program with a given exit code.
+ */
+class Exit : public std::exception
+{
+public:
+    int status;
+    Exit() : status(0) { }
+    explicit Exit(int status) : status(status) { }
+    virtual ~Exit();
+};
+
+}

src/libutil/experimental-features.cc

@@ -12,7 +12,19 @@ struct ExperimentalFeatureDetails
     std::string_view description;
 };
 
-constexpr std::array<ExperimentalFeatureDetails, 14> xpFeatureDetails = {{
+/**
+ * If two different PRs both add an experimental feature, and we just
+ * used a number for this, we *woudln't* get merge conflict and the
+ * counter will be incremented once instead of twice, causing a build
+ * failure.
+ *
+ * By instead defining this instead as 1 + the bottom experimental
+ * feature, we either have no issue at all if few features are not added
+ * at the end of the list, or a proper merge conflict if they are.
+ */
+constexpr size_t numXpFeatures = 1 + static_cast<size_t>(Xp::ReplAutomation);
+
+constexpr std::array<ExperimentalFeatureDetails, numXpFeatures> xpFeatureDetails = {{
     {
         .tag = Xp::CaDerivations,
         .name = "ca-derivations",
@@ -219,6 +231,13 @@ constexpr std::array<ExperimentalFeatureDetails, 14> xpFeatureDetails = {{
             Allow the use of the `read-only` parameter in [local store](@docroot@/command-ref/new-cli/nix3-help-stores.md#local-store) URIs.
         )",
     },
+    {
+        .tag = Xp::ReplAutomation,
+        .name = "repl-automation",
+        .description = R"(
+            Makes the repl not use readline/editline, print ENQ (U+0005) when ready for a command, and take commands followed by newline.
+        )",
+    },
 }};
 
 static_assert(

src/libutil/experimental-features.hh

@@ -31,6 +31,7 @@ enum struct ExperimentalFeature
     DynamicDerivations,
     ParseTomlTimestamps,
     ReadOnlyLocalStore,
+    ReplAutomation,
 };
 
 /**

src/libutil/filesystem.cc

@@ -4,6 +4,7 @@
 
 #include "finally.hh"
 #include "util.hh"
+#include "signals.hh"
 #include "types.hh"
 
 namespace fs = std::filesystem;

src/libutil/finally.hh

@@ -9,8 +9,15 @@ class Finally
 {
 private:
     Fn fun;
+    bool movedFrom = false;
 
 public:
     Finally(Fn fun) : fun(std::move(fun)) { }
-    ~Finally() { fun(); }
+    // Copying Finallys is definitely not a good idea and will cause them to be
+    // called twice.
+    Finally(Finally &other) = delete;
+    Finally(Finally &&other) : fun(std::move(other.fun)) {
+        other.movedFrom = true;
+    }
+    ~Finally() { if (!movedFrom) fun(); }
 };

src/libutil/meson.build

@@ -1,59 +0,0 @@
-libutil_sources = files(
-  'archive.cc',
-  'args.cc',
-  'canon-path.cc',
-  'cgroup.cc',
-  'compression.cc',
-  'compute-levels.cc',
-  'config.cc',
-  'english.cc',
-  'error.cc',
-  'experimental-features.cc',
-  'filesystem.cc',
-  'git.cc',
-  'hash.cc',
-  'hilite.cc',
-  'json-utils.cc',
-  'logging.cc',
-  'namespaces.cc',
-  'position.cc',
-  'references.cc',
-  'serialise.cc',
-  'source-path.cc',
-  'suggestions.cc',
-  'tarfile.cc',
-  'thread-pool.cc',
-  'url.cc',
-  'util.cc',
-  'xml-writer.cc',
-)
-
-all_sources += {
-  'libutil': libutil_sources,
-}
-
-libutil = library(
-  'nixutil',
-  libutil_sources,
-  dependencies : [
-    aws_sdk,
-    aws_s3,
-    boehm,
-    boost,
-    cpuid,
-    seccomp,
-    libarchive,
-    brotli,
-    openssl,
-  ],
-  implicit_include_directories : true,
-)
-
-# Used by libstore and libfetchers.
-liblixutil = declare_dependency(
-  include_directories : include_directories('.'),
-  link_with : libutil
-)
-
-subdir('c')
-

src/libutil/monitor-fd.hh

@@ -10,6 +10,8 @@
 #include <unistd.h>
 #include <signal.h>
 
+#include "signals.hh"
+
 namespace nix {
 
 

src/libutil/serialise.cc

@@ -1,5 +1,6 @@
 #include "serialise.hh"
 #include "util.hh"
+#include "signals.hh"
 
 #include <cstring>
 #include <cerrno>

src/libutil/signals.cc

@@ -0,0 +1,184 @@
+#include "signals.hh"
+#include "util.hh"
+#include "error.hh"
+#include "sync.hh"
+
+#include <thread>
+
+namespace nix {
+
+std::atomic<bool> _isInterrupted = false;
+
+static thread_local bool interruptThrown = false;
+thread_local std::function<bool()> interruptCheck;
+
+void setInterruptThrown()
+{
+    interruptThrown = true;
+}
+
+void _interrupted()
+{
+    /* Block user interrupts while an exception is being handled.
+       Throwing an exception while another exception is being handled
+       kills the program! */
+    if (!interruptThrown && !std::uncaught_exceptions()) {
+        interruptThrown = true;
+        throw Interrupted("interrupted by the user");
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////
+
+/* We keep track of interrupt callbacks using integer tokens, so we can iterate
+   safely without having to lock the data structure while executing arbitrary
+   functions.
+ */
+struct InterruptCallbacks {
+    typedef int64_t Token;
+
+    /* We use unique tokens so that we can't accidentally delete the wrong
+       handler because of an erroneous double delete. */
+    Token nextToken = 0;
+
+    /* Used as a list, see InterruptCallbacks comment. */
+    std::map<Token, std::function<void()>> callbacks;
+};
+
+static Sync<InterruptCallbacks> _interruptCallbacks;
+
+static void signalHandlerThread(sigset_t set)
+{
+    while (true) {
+        int signal = 0;
+        sigwait(&set, &signal);
+
+        if (signal == SIGINT || signal == SIGTERM || signal == SIGHUP)
+            triggerInterrupt();
+
+        else if (signal == SIGWINCH) {
+            updateWindowSize();
+        }
+    }
+}
+
+void triggerInterrupt()
+{
+    _isInterrupted = true;
+
+    {
+        InterruptCallbacks::Token i = 0;
+        while (true) {
+            std::function<void()> callback;
+            {
+                auto interruptCallbacks(_interruptCallbacks.lock());
+                auto lb = interruptCallbacks->callbacks.lower_bound(i);
+                if (lb == interruptCallbacks->callbacks.end())
+                    break;
+
+                callback = lb->second;
+                i = lb->first + 1;
+            }
+
+            try {
+                callback();
+            } catch (...) {
+                ignoreException();
+            }
+        }
+    }
+}
+
+static sigset_t savedSignalMask;
+static bool savedSignalMaskIsSet = false;
+
+void setChildSignalMask(sigset_t * sigs)
+{
+    assert(sigs); // C style function, but think of sigs as a reference
+
+#if _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _POSIX_SOURCE
+    sigemptyset(&savedSignalMask);
+    // There's no "assign" or "copy" function, so we rely on (math) idempotence
+    // of the or operator: a or a = a.
+    sigorset(&savedSignalMask, sigs, sigs);
+#else
+    // Without sigorset, our best bet is to assume that sigset_t is a type that
+    // can be assigned directly, such as is the case for a sigset_t defined as
+    // an integer type.
+    savedSignalMask = *sigs;
+#endif
+
+    savedSignalMaskIsSet = true;
+}
+
+void saveSignalMask() {
+    if (sigprocmask(SIG_BLOCK, nullptr, &savedSignalMask))
+        throw SysError("querying signal mask");
+
+    savedSignalMaskIsSet = true;
+}
+
+void startSignalHandlerThread()
+{
+    updateWindowSize();
+
+    saveSignalMask();
+
+    sigset_t set;
+    sigemptyset(&set);
+    sigaddset(&set, SIGINT);
+    sigaddset(&set, SIGTERM);
+    sigaddset(&set, SIGHUP);
+    sigaddset(&set, SIGPIPE);
+    sigaddset(&set, SIGWINCH);
+    if (pthread_sigmask(SIG_BLOCK, &set, nullptr))
+        throw SysError("blocking signals");
+
+    std::thread(signalHandlerThread, set).detach();
+}
+
+void restoreSignals()
+{
+    // If startSignalHandlerThread wasn't called, that means we're not running
+    // in a proper libmain process, but a process that presumably manages its
+    // own signal handlers. Such a process should call either
+    //  - initNix(), to be a proper libmain process
+    //  - startSignalHandlerThread(), to resemble libmain regarding signal
+    //    handling only
+    //  - saveSignalMask(), for processes that define their own signal handling
+    //    thread
+    // TODO: Warn about this? Have a default signal mask? The latter depends on
+    //       whether we should generally inherit signal masks from the caller.
+    //       I don't know what the larger unix ecosystem expects from us here.
+    if (!savedSignalMaskIsSet)
+        return;
+
+    if (sigprocmask(SIG_SETMASK, &savedSignalMask, nullptr))
+        throw SysError("restoring signals");
+}
+
+/* RAII helper to automatically deregister a callback. */
+struct InterruptCallbackImpl : InterruptCallback
+{
+    InterruptCallbacks::Token token;
+    ~InterruptCallbackImpl() override
+    {
+        auto interruptCallbacks(_interruptCallbacks.lock());
+        interruptCallbacks->callbacks.erase(token);
+    }
+};
+
+std::unique_ptr<InterruptCallback> createInterruptCallback(std::function<void()> callback)
+{
+    auto interruptCallbacks(_interruptCallbacks.lock());
+    auto token = interruptCallbacks->nextToken++;
+    interruptCallbacks->callbacks.emplace(token, callback);
+
+    auto res = std::make_unique<InterruptCallbackImpl>();
+    res->token = token;
+
+    return std::unique_ptr<InterruptCallback>(res.release());
+}
+
+};

src/libutil/signals.hh

@@ -0,0 +1,93 @@
+#pragma once
+/// @file
+
+#include "types.hh"
+#include "error.hh"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <signal.h>
+
+#include <atomic>
+#include <functional>
+#include <sstream>
+
+namespace nix {
+
+/* User interruption. */
+
+extern std::atomic<bool> _isInterrupted;
+
+extern thread_local std::function<bool()> interruptCheck;
+
+void setInterruptThrown();
+
+void _interrupted();
+
+void inline checkInterrupt()
+{
+    if (_isInterrupted || (interruptCheck && interruptCheck()))
+        _interrupted();
+}
+
+MakeError(Interrupted, BaseError);
+
+void restoreSignals();
+
+
+/**
+ * Start a thread that handles various signals. Also block those signals
+ * on the current thread (and thus any threads created by it).
+ * Saves the signal mask before changing the mask to block those signals.
+ * See saveSignalMask().
+ */
+void startSignalHandlerThread();
+
+/**
+ * Saves the signal mask, which is the signal mask that nix will restore
+ * before creating child processes.
+ * See setChildSignalMask() to set an arbitrary signal mask instead of the
+ * current mask.
+ */
+void saveSignalMask();
+
+/**
+ * Sets the signal mask. Like saveSignalMask() but for a signal set that doesn't
+ * necessarily match the current thread's mask.
+ * See saveSignalMask() to set the saved mask to the current mask.
+ */
+void setChildSignalMask(sigset_t *sigs);
+
+struct InterruptCallback
+{
+    virtual ~InterruptCallback() { };
+};
+
+/**
+ * Register a function that gets called on SIGINT (in a non-signal
+ * context).
+ */
+std::unique_ptr<InterruptCallback> createInterruptCallback(
+    std::function<void()> callback);
+
+void triggerInterrupt();
+
+/**
+ * A RAII class that causes the current thread to receive SIGUSR1 when
+ * the signal handler thread receives SIGINT. That is, this allows
+ * SIGINT to be multiplexed to multiple threads.
+ */
+struct ReceiveInterrupts
+{
+    pthread_t target;
+    std::unique_ptr<InterruptCallback> callback;
+
+    ReceiveInterrupts()
+        : target(pthread_self())
+        , callback(createInterruptCallback([&]() { pthread_kill(target, SIGUSR1); }))
+    { }
+};
+
+};

src/libutil/thread-pool.cc

@@ -1,4 +1,5 @@
 #include "thread-pool.hh"
+#include "signals.hh"
 
 namespace nix {
 

src/libutil/util.cc

@@ -3,6 +3,7 @@
 #include "finally.hh"
 #include "serialise.hh"
 #include "cgroup.hh"
+#include "signals.hh"
 
 #include <array>
 #include <cctype>
@@ -1361,31 +1362,6 @@ void closeOnExec(int fd)
 //////////////////////////////////////////////////////////////////////
 
 
-std::atomic<bool> _isInterrupted = false;
-
-static thread_local bool interruptThrown = false;
-thread_local std::function<bool()> interruptCheck;
-
-void setInterruptThrown()
-{
-    interruptThrown = true;
-}
-
-void _interrupted()
-{
-    /* Block user interrupts while an exception is being handled.
-       Throwing an exception while another exception is being handled
-       kills the program! */
-    if (!interruptThrown && !std::uncaught_exceptions()) {
-        interruptThrown = true;
-        throw Interrupted("interrupted by the user");
-    }
-}
-
-
-//////////////////////////////////////////////////////////////////////
-
-
 template<class C> C tokenizeString(std::string_view s, std::string_view separators)
 {
     C result;
@@ -1717,7 +1693,7 @@ std::pair<std::string_view, std::string_view> getLine(std::string_view s)
 static Sync<std::pair<unsigned short, unsigned short>> windowSize{{0, 0}};
 
 
-static void updateWindowSize()
+void updateWindowSize()
 {
     struct winsize ws;
     if (ioctl(2, TIOCGWINSZ, &ws) == 0) {
@@ -1734,133 +1710,6 @@ std::pair<unsigned short, unsigned short> getWindowSize()
 }
 
 
-/* We keep track of interrupt callbacks using integer tokens, so we can iterate
-   safely without having to lock the data structure while executing arbitrary
-   functions.
- */
-struct InterruptCallbacks {
-    typedef int64_t Token;
-
-    /* We use unique tokens so that we can't accidentally delete the wrong
-       handler because of an erroneous double delete. */
-    Token nextToken = 0;
-
-    /* Used as a list, see InterruptCallbacks comment. */
-    std::map<Token, std::function<void()>> callbacks;
-};
-
-static Sync<InterruptCallbacks> _interruptCallbacks;
-
-static void signalHandlerThread(sigset_t set)
-{
-    while (true) {
-        int signal = 0;
-        sigwait(&set, &signal);
-
-        if (signal == SIGINT || signal == SIGTERM || signal == SIGHUP)
-            triggerInterrupt();
-
-        else if (signal == SIGWINCH) {
-            updateWindowSize();
-        }
-    }
-}
-
-void triggerInterrupt()
-{
-    _isInterrupted = true;
-
-    {
-        InterruptCallbacks::Token i = 0;
-        while (true) {
-            std::function<void()> callback;
-            {
-                auto interruptCallbacks(_interruptCallbacks.lock());
-                auto lb = interruptCallbacks->callbacks.lower_bound(i);
-                if (lb == interruptCallbacks->callbacks.end())
-                    break;
-
-                callback = lb->second;
-                i = lb->first + 1;
-            }
-
-            try {
-                callback();
-            } catch (...) {
-                ignoreException();
-            }
-        }
-    }
-}
-
-static sigset_t savedSignalMask;
-static bool savedSignalMaskIsSet = false;
-
-void setChildSignalMask(sigset_t * sigs)
-{
-    assert(sigs); // C style function, but think of sigs as a reference
-
-#if _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _POSIX_SOURCE
-    sigemptyset(&savedSignalMask);
-    // There's no "assign" or "copy" function, so we rely on (math) idempotence
-    // of the or operator: a or a = a.
-    sigorset(&savedSignalMask, sigs, sigs);
-#else
-    // Without sigorset, our best bet is to assume that sigset_t is a type that
-    // can be assigned directly, such as is the case for a sigset_t defined as
-    // an integer type.
-    savedSignalMask = *sigs;
-#endif
-
-    savedSignalMaskIsSet = true;
-}
-
-void saveSignalMask() {
-    if (sigprocmask(SIG_BLOCK, nullptr, &savedSignalMask))
-        throw SysError("querying signal mask");
-
-    savedSignalMaskIsSet = true;
-}
-
-void startSignalHandlerThread()
-{
-    updateWindowSize();
-
-    saveSignalMask();
-
-    sigset_t set;
-    sigemptyset(&set);
-    sigaddset(&set, SIGINT);
-    sigaddset(&set, SIGTERM);
-    sigaddset(&set, SIGHUP);
-    sigaddset(&set, SIGPIPE);
-    sigaddset(&set, SIGWINCH);
-    if (pthread_sigmask(SIG_BLOCK, &set, nullptr))
-        throw SysError("blocking signals");
-
-    std::thread(signalHandlerThread, set).detach();
-}
-
-static void restoreSignals()
-{
-    // If startSignalHandlerThread wasn't called, that means we're not running
-    // in a proper libmain process, but a process that presumably manages its
-    // own signal handlers. Such a process should call either
-    //  - initNix(), to be a proper libmain process
-    //  - startSignalHandlerThread(), to resemble libmain regarding signal
-    //    handling only
-    //  - saveSignalMask(), for processes that define their own signal handling
-    //    thread
-    // TODO: Warn about this? Have a default signal mask? The latter depends on
-    //       whether we should generally inherit signal masks from the caller.
-    //       I don't know what the larger unix ecosystem expects from us here.
-    if (!savedSignalMaskIsSet)
-        return;
-
-    if (sigprocmask(SIG_SETMASK, &savedSignalMask, nullptr))
-        throw SysError("restoring signals");
-}
-
 rlim_t savedStackSize = 0;
 
 void setStackSize(rlim_t stackSize)
@@ -1951,30 +1800,6 @@ void restoreProcessContext(bool restoreMounts)
     }
 }
 
-/* RAII helper to automatically deregister a callback. */
-struct InterruptCallbackImpl : InterruptCallback
-{
-    InterruptCallbacks::Token token;
-    ~InterruptCallbackImpl() override
-    {
-        auto interruptCallbacks(_interruptCallbacks.lock());
-        interruptCallbacks->callbacks.erase(token);
-    }
-};
-
-std::unique_ptr<InterruptCallback> createInterruptCallback(std::function<void()> callback)
-{
-    auto interruptCallbacks(_interruptCallbacks.lock());
-    auto token = interruptCallbacks->nextToken++;
-    interruptCallbacks->callbacks.emplace(token, callback);
-
-    auto res = std::make_unique<InterruptCallbackImpl>();
-    res->token = token;
-
-    return std::unique_ptr<InterruptCallback>(res.release());
-}
-
-
 AutoCloseFD createUnixDomainSocket()
 {
     AutoCloseFD fdSocket = socket(PF_UNIX, SOCK_STREAM

src/libutil/util.hh

@@ -516,25 +516,6 @@ void closeMostFDs(const std::set<int> & exceptions);
 void closeOnExec(int fd);
 
 
-/* User interruption. */
-
-extern std::atomic<bool> _isInterrupted;
-
-extern thread_local std::function<bool()> interruptCheck;
-
-void setInterruptThrown();
-
-void _interrupted();
-
-void inline checkInterrupt()
-{
-    if (_isInterrupted || (interruptCheck && interruptCheck()))
-        _interrupted();
-}
-
-MakeError(Interrupted, BaseError);
-
-
 MakeError(FormatError, Error);
 
 
@@ -829,61 +810,6 @@ template<typename T>
 class Callback;
 
 
-/**
- * Start a thread that handles various signals. Also block those signals
- * on the current thread (and thus any threads created by it).
- * Saves the signal mask before changing the mask to block those signals.
- * See saveSignalMask().
- */
-void startSignalHandlerThread();
-
-/**
- * Saves the signal mask, which is the signal mask that nix will restore
- * before creating child processes.
- * See setChildSignalMask() to set an arbitrary signal mask instead of the
- * current mask.
- */
-void saveSignalMask();
-
-/**
- * Sets the signal mask. Like saveSignalMask() but for a signal set that doesn't
- * necessarily match the current thread's mask.
- * See saveSignalMask() to set the saved mask to the current mask.
- */
-void setChildSignalMask(sigset_t *sigs);
-
-struct InterruptCallback
-{
-    virtual ~InterruptCallback() { };
-};
-
-/**
- * Register a function that gets called on SIGINT (in a non-signal
- * context).
- */
-std::unique_ptr<InterruptCallback> createInterruptCallback(
-    std::function<void()> callback);
-
-void triggerInterrupt();
-
-/**
- * A RAII class that causes the current thread to receive SIGUSR1 when
- * the signal handler thread receives SIGINT. That is, this allows
- * SIGINT to be multiplexed to multiple threads.
- */
-struct ReceiveInterrupts
-{
-    pthread_t target;
-    std::unique_ptr<InterruptCallback> callback;
-
-    ReceiveInterrupts()
-        : target(pthread_self())
-        , callback(createInterruptCallback([&]() { pthread_kill(target, SIGUSR1); }))
-    { }
-};
-
-
-
 /**
  * A RAII helper that increments a counter on construction and
  * decrements it on destruction.
@@ -903,6 +829,8 @@ struct MaintainCount
  */
 std::pair<unsigned short, unsigned short> getWindowSize();
 
+void updateWindowSize();
+
 
 /**
  * Used in various places.

src/meson.build

@@ -1,65 +0,0 @@
-# Subcomponents: these link into artifacts themselves, and have interdependencies.
-
-subdir('libutil')
-# Load-bearing order. libstore depends on libutil.
-subdir('libstore')
-# libfetchers depends on libstore
-subdir('libfetchers')
-# libexpr depends on all of the above
-subdir('libexpr')
-# libmain depends on libutil and libstore
-subdir('libmain')
-# libcmd depends on everything
-subdir('libcmd')
-
-
-# The rest of the subdirectories aren't separate components,
-# just source files in another directory, so we process them here.
-
-build_remote_sources = files(
-  'build-remote/build-remote.cc',
-)
-nix_build_sources = files(
-  'nix-build/nix-build.cc',
-)
-nix_channel_sources = files(
-  'nix-channel/nix-channel.cc',
-)
-unpack_channel_gen = gen_header.process('nix-channel/unpack-channel.nix')
-nix_collect_garbage_sources = files(
-  'nix-collect-garbage/nix-collect-garbage.cc',
-)
-nix_copy_closure_sources = files(
-  'nix-copy-closure/nix-copy-closure.cc',
-)
-nix_env_buildenv_gen = gen_header.process('nix-env/buildenv.nix')
-nix_env_sources = files(
-  'nix-env/nix-env.cc',
-  'nix-env/user-env.cc',
-)
-nix_instantiate_sources = files(
-  'nix-instantiate/nix-instantiate.cc',
-)
-nix_store_sources = files(
-  'nix-store/dotgraph.cc',
-  'nix-store/graphml.cc',
-  'nix-store/nix-store.cc',
-)
-
-# Hurray for Meson list flattening!
-nix2_commands_sources = [
-  build_remote_sources,
-  nix_build_sources,
-  nix_channel_sources,
-  unpack_channel_gen,
-  nix_collect_garbage_sources,
-  nix_copy_closure_sources,
-  nix_env_buildenv_gen,
-  nix_env_sources,
-  nix_instantiate_sources,
-  nix_store_sources,
-]
-
-# Finally, the nix command itself, which all of the other commands are implmented in terms of
-# as a multicall binary.
-subdir('nix')

src/nix-collect-garbage/nix-collect-garbage.cc

@@ -5,6 +5,7 @@
 #include "shared.hh"
 #include "globals.hh"
 #include "legacy.hh"
+#include "signals.hh"
 
 #include <iostream>
 #include <cerrno>

src/nix-env/meson.build

@@ -1,4 +0,0 @@
-nix_env_sources = files(
-  'nix-env.cc',
-  'user-env.cc'
-)

src/nix/daemon.cc

@@ -12,6 +12,7 @@
 #include "derivations.hh"
 #include "finally.hh"
 #include "legacy.hh"
+#include "signals.hh"
 #include "daemon.hh"
 
 #include <algorithm>

src/nix/eval.cc

@@ -120,8 +120,17 @@ struct CmdEval : MixJSON, InstallableValueCommand, MixReadOnlyOption
         }
 
         else {
-            state->forceValueDeep(*v);
-            logger->cout("%s", ValuePrinter(*state, *v, PrintOptions { .force = true }));
+            logger->cout(
+                "%s",
+                ValuePrinter(
+                    *state,
+                    *v,
+                    PrintOptions {
+                        .force = true,
+                        .derivationPaths = true
+                    }
+                )
+            );
         }
     }
 };

src/nix/meson.build

@@ -1,68 +0,0 @@
-generate_manpage_gen = gen_header.process(meson.project_source_root() / 'doc/manual/generate-manpage.nix')
-
-utils_gen = gen_header.process(meson.project_source_root() / 'doc/manual/utils.nix')
-
-nix_sources = files(
-  'add-to-store.cc',
-  'app.cc',
-  'build.cc',
-  'bundle.cc',
-  'cat.cc',
-  'copy.cc',
-  'daemon.cc',
-  'derivation-add.cc',
-  'derivation-show.cc',
-  'derivation.cc',
-  'develop.cc',
-  'diff-closures.cc',
-  'doctor.cc',
-  'dump-path.cc',
-  'edit.cc',
-  'eval.cc',
-  'flake.cc',
-  'fmt.cc',
-  'hash.cc',
-  'log.cc',
-  'ls.cc',
-  'main.cc',
-  'make-content-addressed.cc',
-  'nar.cc',
-  'optimise-store.cc',
-  'path-from-hash-part.cc',
-  'path-info.cc',
-  'ping-store.cc',
-  'prefetch.cc',
-  'profile.cc',
-  'realisation.cc',
-  'registry.cc',
-  'repl.cc',
-  'run.cc',
-  'search.cc',
-  'show-config.cc',
-  'sigs.cc',
-  'store-copy-log.cc',
-  'store-delete.cc',
-  'store-gc.cc',
-  'store-repair.cc',
-  'store.cc',
-  'upgrade-nix.cc',
-  'verify.cc',
-  'why-depends.cc',
-)
-
-nix = executable(
-  'nix',
-  nix_sources,
-  generate_manpage_gen,
-  utils_gen,
-  nix2_commands_sources,
-  dependencies : [
-    liblixcmd,
-    liblixutil,
-    liblixstore,
-    liblixexpr,
-    liblixfetchers,
-    liblixmain,
-    boehm,
-  ],
-)

src/nix/optimise-store.cc

@@ -1,5 +1,6 @@
 #include "command.hh"
 #include "shared.hh"
+#include "signals.hh"
 #include "store-api.hh"
 
 #include <atomic>

src/nix/sigs.cc

@@ -2,6 +2,7 @@
 #include "shared.hh"
 #include "store-api.hh"
 #include "thread-pool.hh"
+#include "signals.hh"
 
 #include <atomic>
 

src/nix/verify.cc

@@ -3,6 +3,7 @@
 #include "store-api.hh"
 #include "sync.hh"
 #include "thread-pool.hh"
+#include "signals.hh"
 #include "references.hh"
 
 #include <atomic>

tests/functional/lang/eval-fail-bad-string-interpolation-4.err.exp

@@ -6,4 +6,4 @@ error:
              |   ^
            10|
 
-       error: cannot coerce a set to a string: { a = { a = { a = { a = "ha"; b = "ha"; c = "ha"; d = "ha"; e = "ha"; f = "ha"; g = "ha"; h = "ha"; j = "ha"; }; «4294967295 attributes elided»}; «4294967294 attributes elided»}; «4294967293 attributes elided»}
+       error: cannot coerce a set to a string: { a = { a = { a = { a = "ha"; b = "ha"; c = "ha"; d = "ha"; e = "ha"; f = "ha"; g = "ha"; h = "ha"; j = "ha"; }; «4294967295 attributes elided» }; «4294967294 attributes elided» }; «4294967293 attributes elided» }

tests/functional/lang/eval-fail-duplicate-traces.err.exp

@@ -41,4 +41,11 @@ error:
              |                ^
             5|     if n > 0
 
+       … while calling the 'throw' builtin
+         at /pwd/lang/eval-fail-duplicate-traces.nix:7:10:
+            6|     then throwAfter (n - 1)
+            7|     else throw "Uh oh!";
+             |          ^
+            8| in
+
        error: Uh oh!

tests/functional/lang/eval-fail-foldlStrict-strict-op-application.err.exp

@@ -27,4 +27,11 @@ error:
              |      ^
             6|
 
+       … while calling the 'throw' builtin
+         at /pwd/lang/eval-fail-foldlStrict-strict-op-application.nix:5:9:
+            4|   null
+            5|   [ (_: throw "Not the final value, but is still forced!") (_: 23) ]
+             |         ^
+            6|
+
        error: Not the final value, but is still forced!

tests/functional/lang/eval-fail-mutual-recursion.err.exp

@@ -54,4 +54,11 @@ error:
 
        (21 duplicate frames omitted)
 
+       … while calling the 'throw' builtin
+         at /pwd/lang/eval-fail-mutual-recursion.nix:34:10:
+           33|     then throwAfterB true 10
+           34|     else throw "Uh oh!";
+             |          ^
+           35| in
+
        error: Uh oh!

tests/functional/lang/eval-okay-inherit-from.err.exp

@@ -0,0 +1 @@
+trace: used