Use curly underlines for errors in default themes

Given that this curly underline will also be red, it should be widely
understood as error.

Since fish always renders immediately (and synchronously), typing "echo"
will briefly show an intermediate curly line.  Maybe fish should redraw
after a timer elapses? This is probably unrelated to this patch.

As mentioned in cc9849c279 (Curly underlines in set_color and fish_color_*,
2025-04-13), there are still some terminals that interpret "\e[4:3m" as
something other than curly underline.

Some of them interpret it as background/foreground color, and some terminal
multiplexers downgrade it to straight underlines (which often happens due
to a false positive).  I want to change this in multiplexers where possible
(see https://github.com/orgs/tmux/discussions/4477) but for now, disable
this feature in multiplexers (there are just a handful).

In a few years, those terminals will maybe agree with XTerm.  Until then,
use XTGETTCAP as a temporary stepping stone. We could also read the terminfo
database but that will give only very few true positives, and lots of false
negatives.  Better implement XTGETTCAP in the relevant terminals.

Note that if the universal variables use the "--track" flag (from the
grandparent commit), then

	rm -rf /tmp/newhome
	foot -e env $HOME=/tmp/newhome fish
	xterm -e env $HOME=/tmp/newhome fish

will "magically work". For foot, $fish_color_error will have --underline=curly.
For xterm, it will not, due to the call to "fish_config theme update".
But of course since it's a universal variable, running fish in xterm
would also downgrade the fish running in other terminals.

Add a "fish_config theme save --yes" flag because "status xtgettcap"
requires stdin to be a terminal.  I'd probably drop this requirement, and
make "status xtgettcap" always use fish's stdin and not its own.  That'd be
cheating because an external command can't do that but I don't think this
change would be hurting anyone.

.builds/alpine.yml

@@ -1,6 +1,7 @@
 image: alpine/edge
 packages:
   - cargo
+  - clang17-libclang
   - cmake
   - ninja
   - pcre2-dev
@@ -23,4 +24,4 @@ tasks:
           ninja
   - test: |
           cd fish-shell/build
-          ninja fish_run_tests
+          ninja test

.builds/arch.yml

@@ -20,4 +20,4 @@ tasks:
           ninja
   - test: |
           cd fish/build
-          ninja fish_run_tests
+          ninja test

.builds/freebsd.yml

@@ -5,10 +5,10 @@ packages:
   - gettext
   - gmake
   - llvm
+  - terminfo-db
   - ninja
   - pcre2
   - py311-pexpect
-  - py311-sphinx
   - python
   - rust
   - tmux
@@ -27,4 +27,4 @@ tasks:
           ninja
   - test: |
           cd fish-shell/build
-          ninja fish_run_tests
+          ninja test

.builds/openbsd.yml

@@ -1,30 +0,0 @@
-image: openbsd/latest
-packages:
-  - cmake
-  - gcc
-  - gettext
-  - gmake
-  - llvm
-  - ninja
-  - pcre2
-  - py3-pexpect
-  - py3-sphinx
-  - python
-  - rust
-  - tmux
-sources:
-  - https://github.com/fish-shell/fish-shell
-tasks:
-  - build: |
-          cd fish-shell
-          mkdir build
-          cd build
-          cmake -GNinja .. \
-            -DCMAKE_INSTALL_PREFIX=/usr \
-            -DCMAKE_INSTALL_DATADIR=share \
-            -DCMAKE_INSTALL_DOCDIR=share/doc/fish \
-            -DCMAKE_INSTALL_SYSCONFDIR=/etc
-          ninja
-  - test: |
-          cd fish-shell/build
-          ninja fish_run_tests

.cargo/config.toml

@@ -1,2 +1,8 @@
-[alias]
-xtask = "run --package xtask --"
+# This file is _not_ included in the tarballs for now
+# Binary builds on Linux packaging infrastructure need to overwrite it to make `cargo vendor` work
+# Releases and development builds made using OBS/Launchpad will _not_ reflect the contents of this
+# file
+
+[resolver]
+# Make cargo 1.84+ respect MSRV (rust-version in Cargo.toml)
+incompatible-rust-versions = "fallback"

.cirrus.yml

@@ -0,0 +1,91 @@
+env:
+    CIRRUS_CLONE_DEPTH: 100
+    CI: 1
+
+linux_task:
+    matrix:
+        - name: alpine
+          container: &step
+              image: ghcr.io/krobelus/fish-ci/alpine:latest
+              memory: 4GB
+        - name: jammy
+          container:
+              <<: *step
+              image: ghcr.io/krobelus/fish-ci/jammy:latest
+        # - name: jammy-asan
+        #   container:
+        #       <<: *step
+        #       image: ghcr.io/krobelus/fish-ci/jammy-asan:latest
+        # - name: focal-32bit
+        #   container:
+        #       <<: *step
+        #       image: ghcr.io/krobelus/fish-ci/focal-32bit:latest
+    tests_script:
+        # cirrus at times gives us 32 procs and 2 GB of RAM
+        # Unrestriced parallelism results in OOM
+        - lscpu || true
+        - (cat /proc/meminfo | grep MemTotal) || true
+        - mkdir build && cd build
+        - cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCTEST_PARALLEL_LEVEL=6 ..
+        - ninja -j 6 fish
+        - ninja fish_run_tests
+    only_if: $CIRRUS_REPO_OWNER == 'fish-shell'
+
+linux_arm_task:
+    matrix:
+        - name: focal-arm64
+          arm_container:
+              image: ghcr.io/fish-shell/fish-ci/focal-arm64
+        - name: jammy-armv7-32bit
+          arm_container:
+              image: ghcr.io/fish-shell/fish-ci/jammy-armv7-32bit
+    tests_script:
+        # cirrus at times gives us 32 procs and 2 GB of RAM
+        # Unrestriced parallelism results in OOM
+        - lscpu || true
+        - (cat /proc/meminfo | grep MemTotal) || true
+        - mkdir build && cd build
+        - cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCTEST_PARALLEL_LEVEL=6 ..
+        - ninja -j 6 fish
+        - file ./fish
+        - ninja fish_run_tests
+    # CI task disabled during RIIR transition
+    only_if: false && $CIRRUS_REPO_OWNER == 'fish-shell'
+
+freebsd_task:
+    matrix:
+        # - name: FreeBSD 14
+        #   freebsd_instance:
+        #       image_family: freebsd-14-0-snap
+        - name: FreeBSD 13
+          freebsd_instance:
+              image: freebsd-13-2-release-amd64
+        # - name: FreeBSD 12.3
+        #   freebsd_instance:
+        #       image: freebsd-12-3-release-amd64
+    tests_script:
+        - pkg install -y cmake-core devel/pcre2 devel/ninja misc/py-pexpect git-lite terminfo-db
+        # libclang.so is a required build dependency for rust-c++ ffi bridge
+        - pkg install -y llvm
+        # BSDs have the following behavior: root may open or access files even if
+        # the mode bits would otherwise disallow it. For example root may open()
+        # a file with write privileges even if the file has mode 400. This breaks
+        # our tests for e.g. cd and path. So create a new unprivileged user to run tests.
+        - pw user add -n fish-user -s /bin/csh -d /home/fish-user
+        - mkdir -p /home/fish-user
+        - chown -R fish-user /home/fish-user
+        - mkdir build && cd build
+        - chown -R fish-user ..
+        - sudo -u fish-user -s whoami
+        # FreeBSD's pkg currently has rust 1.66.0 while we need rust 1.70.0+. Use rustup to install
+        # the latest, but note that it only installs rust per-user.
+        - sudo -u fish-user -s fetch -qo - https://sh.rustup.rs > rustup.sh
+        - sudo -u fish-user -s sh ./rustup.sh -y --profile=minimal
+        # `sudo -s ...` does not invoke a login shell so we need a workaround to make sure the
+        # rustup environment is configured for subsequent `sudo -s ...` commands.
+        # For some reason, this doesn't do the job:
+        # - sudo -u fish-user sh -c 'echo source \$HOME/.cargo/env >> $HOME/.cshrc'
+        - sudo -u fish-user -s cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCTEST_PARALLEL_LEVEL=1 ..
+        - sudo -u fish-user sh -c '. $HOME/.cargo/env; ninja -j 6 fish'
+        - sudo -u fish-user sh -c '. $HOME/.cargo/env; ninja fish_run_tests'
+    only_if: $CIRRUS_REPO_OWNER == 'fish-shell'

.editorconfig

@@ -9,26 +9,20 @@ trim_trailing_whitespace = true
 insert_final_newline = true
 max_line_length = 100
 
-[{Makefile,{BSD,GNU}makefile}]
+[{Makefile,*.in}]
 indent_style = tab
 
 [*.{md,rst}]
-max_line_length = unset
+trim_trailing_whitespace = false
 
-[*.sh]
-indent_size = 4
+[*.{sh,ac}]
+indent_size = 2
 
-[build_tools/release.sh]
-max_line_length = 72
-
-[Vagrantfile]
+[Dockerfile]
 indent_size = 2
 
 [share/{completions,functions}/**.fish]
 max_line_length = unset
 
-[{COMMIT_EDITMSG,git-revise-todo,*.jjdescription}]
-max_line_length = 72
-
-[*.{toml,yml}]
-indent_size = 2
+[{COMMIT_EDITMSG,git-revise-todo}]
+max_line_length = 80

.gitattributes

@@ -1,5 +1,7 @@
 # normalize newlines
-* text=auto eol=lf
+* text=auto
+*.fish text
+*.bat eol=crlf
 
 # let git show off diff hunk headers, help git diff -L:
 # https://git-scm.com/docs/gitattributes
@@ -14,10 +16,15 @@
 .gitattributes export-ignore
 .gitignore export-ignore
 /build_tools/make_tarball.sh export-ignore
+/debian export-ignore
+/debian/* export-ignore
 /.github export-ignore
 /.github/* export-ignore
 /.builds export-ignore
 /.builds/* export-ignore
+# to make cargo vendor work correctly
+/.cargo/ export-ignore
+/.cargo/config.toml export-ignore
 
 # for linguist, which drives GitHub's language statistics
 alpine.js linguist-vendored

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github:
-  - krobelus

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,8 +1,11 @@
+## Description
 
+Talk about your changes here.
+
+Fixes issue #
 
 ## TODOs:
-<!-- Check off what what has been done so far. -->
-- [ ] If addressing an issue, a commit message mentions `Fixes issue #<issue-number>`
+<!-- Just check off what what we know been done so far. We can help you with this stuff. -->
 - [ ] Changes to fish usage are reflected in user documentation/manpages.
 - [ ] Tests have been added for regressions fixed
-- [ ] User-visible changes noted in CHANGELOG.rst <!-- Usually skipped for changes to completions -->
+- [ ] User-visible changes noted in CHANGELOG.rst <!-- Don't document changes for completions inside CHANGELOG.rst, there are lot of such edits -->

.github/actions/install-dependencies/action.yml

@@ -1,41 +0,0 @@
-name: Install dependencies for system tests
-
-inputs:
-  include_sphinx:
-    description: Whether to install Sphinx
-    required: true
-    default: false
-  include_pcre:
-    description: Whether to install the PCRE library
-    required: false
-    default: true
-
-permissions:
-  contents: read
-
-runs:
-  using: "composite"
-  steps:
-    - shell: bash
-      env:
-        include_pcre: ${{ inputs.include_pcre }}
-      run: |
-        set -x
-        : "optional dependencies"
-        sudo apt install \
-          gettext \
-          $(if $include_pcre; then echo libpcre2-dev; fi) \
-        ;
-        : "system test dependencies"
-        sudo apt install \
-          diffutils $(: "for diff") \
-          git \
-          gettext \
-          less \
-          $(if ${{ inputs.include_pcre }}; then echo libpcre2-dev; fi) \
-          python3-pexpect \
-          tmux \
-          wget \
-        ;
-    - uses: ./.github/actions/install-sphinx
-      if: ${{ inputs.include_sphinx == 'true' }}

.github/actions/install-sphinx/action.yml

@@ -1,20 +0,0 @@
-name: Install sphinx
-
-permissions:
-  contents: read
-
-runs:
-  using: "composite"
-  steps:
-    - shell: bash
-      run: |
-        set -x
-        sudo pip install uv --break-system-packages
-        command -v uv
-        # Check that pyproject.toml and the lock file are in sync.
-        uv lock --check --exclude-newer="$(awk -F'"' <uv.lock '/^exclude-newer[[:space:]]*=/ {print $2}')"
-        uv venv ~/.local --allow-existing
-        uv pip install --group=dev
-        # Smoke test.
-        python -c 'import sphinx; import sphinx_markdown_builder'
-        python3 -c 'import sphinx; import sphinx_markdown_builder'

.github/actions/rust-toolchain/action.yml

@@ -1,41 +0,0 @@
-name: Rust Toolchain
-
-inputs:
-  toolchain_channel:
-    description: Either "stable" or "msrv"
-    required: true
-  targets:
-    description: Comma-separated list of target triples to install for this toolchain
-    required: false
-  components:
-    description: Comma-separated list of components to be additionally installed
-    required: false
-
-permissions:
-  contents: read
-
-runs:
-  using: "composite"
-  steps:
-    - name: Set toolchain
-      env:
-        toolchain_channel: ${{ inputs.toolchain_channel }}
-      shell: bash
-      run: |
-        set -x
-        toolchain=$(
-          case "$toolchain_channel" in
-            (stable) echo 1.96 ;; # updatecli.d/rust.yml
-            (msrv)   echo 1.85 ;; # updatecli.d/rust.yml
-            (*)
-              printf >&2 "error: unsupported toolchain channel %s" "$toolchain_channel"
-              exit 1
-              ;;
-          esac
-        )
-        printf 'TOOLCHAIN=%s\n' "$toolchain" >>"$GITHUB_ENV"
-    - uses: dtolnay/rust-toolchain@master
-      with:
-        toolchain: ${{ env.TOOLCHAIN }}
-        targets: ${{ inputs.targets }}
-        components: ${{ inputs.components }}

.github/actions/rust-toolchain@oldest-supported/action.yml

@@ -1,21 +0,0 @@
-name: Oldest Supported Rust Toolchain
-
-inputs:
-  targets:
-    description: Comma-separated list of target triples to install for this toolchain
-    required: false
-  components:
-    description: Comma-separated list of components to be additionally installed
-    required: false
-
-permissions:
-  contents: read
-
-runs:
-  using: "composite"
-  steps:
-    - uses: ./.github/actions/rust-toolchain
-      with:
-        toolchain_channel: "msrv"
-        targets: ${{ inputs.targets }}
-        components: ${{ inputs.components }}

.github/actions/rust-toolchain@stable/action.yml

@@ -1,21 +0,0 @@
-name: Stable Rust Toolchain
-
-inputs:
-  targets:
-    description: Comma-separated list of target triples to install for this toolchain
-    required: false
-  components:
-    description: Comma-separated list of components to be additionally installed
-    required: false
-
-permissions:
-  contents: read
-
-runs:
-  using: "composite"
-  steps:
-    - uses: ./.github/actions/rust-toolchain
-      with:
-        toolchain_channel: "stable"
-        targets: ${{ inputs.targets }}
-        components: ${{ inputs.components }}

.github/workflows/autolabel_prs.yml

@@ -8,12 +8,16 @@ jobs:
   label-and-milestone:
     runs-on: ubuntu-latest
     steps:
+    # - name: Checkout repository
+    #   uses: actions/checkout@v2
+
     - name: Set label and milestone
       id: set-label-milestone
-      uses: actions/github-script@d746ffe35508b1917358783b479e04febd2b8f71 # v9.0.0, build_tools/update-dependencies.sh
+      uses: actions/github-script@v7
       with:
         script: |
           const completionsLabel = 'completions';
+          const completionsMilestone = 'fish next-3.x';
 
           // Get changed files in the pull request
           const prNumber = context.payload.pull_request.number;
@@ -37,4 +41,26 @@ jobs:
               labels: [completionsLabel],
             });
             console.log(`PR ${prNumber} assigned label "${completionsLabel}"`);
+
+            // Get the list of milestones
+            const { data: milestones } = await github.rest.issues.listMilestones({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+            });
+
+            // Find the milestone id
+            const milestone = milestones.find(milestone => milestone.title === completionsMilestone);
+
+            if (milestone) {
+              // Set the milestone for the PR
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: prNumber,
+                milestone: milestone.number
+              });
+              console.log(`PR ${prNumber} assigned milestone "${completionsMilestone}"`);
+            } else {
+              console.error(`Milestone "${completionsMilestone}" not found`);
+            }
           }

.github/workflows/development-builds.yml

@@ -1,32 +0,0 @@
-name: Linux development builds
-
-on:
-  push:
-    branches:
-      - buildscript
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    environment: linux-development
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-      - uses: astral-sh/setup-uv@v7
-      - name: Update package database
-        run: sudo apt-get update
-      - name: Install deps
-        run: sudo apt install debhelper devscripts dpkg-dev
-      - name: Create tarball and source packages
-        run: |
-          version=$(build_tools/git_version_gen.sh --stdout 2>/dev/null)
-          mkdir /tmp/gpg
-          echo "$SIGNING_GPG_KEY" > /tmp/gpg/signing-gpg-key
-          mkdir /tmp/fish-built
-          FISH_ARTEFACT_PATH=/tmp/fish-built ./build_tools/make_tarball.sh
-          FISH_ARTEFACT_PATH=/tmp/fish-built DEB_SIGN_KEYFILE=/tmp/gpg/signing-gpg-key ./build_tools/make_linux_packages.sh $version
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1, build_tools/update-dependencies.sh
-        with:
-          name: linux-source-packages
-          path: |
-            /tmp/fish-built
-            ! /tmp/fish-built/fish-*/* # don't include the unpacked source directory

.github/workflows/lint-dependencies.yml

@@ -1,24 +0,0 @@
-name: Lint Dependencies
-on:
-  push:
-    paths:
-      - '.github/workflows/lint-dependencies.yml'
-      - 'Cargo.lock'
-      - '**/Cargo.toml'
-      - 'deny.toml'
-  pull_request:
-    paths:
-      - '.github/workflows/lint-dependencies.yml'
-      - 'Cargo.lock'
-      - '**/Cargo.toml'
-      - 'deny.toml'
-jobs:
-  cargo-deny:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: EmbarkStudios/cargo-deny-action@8a45e1c7c9a95dfae3276e89a553705e40ae45a2 # v2.0.20, build_tools/update-dependencies.sh
-      with:
-        command: check licenses
-        arguments: --all-features --locked --exclude-dev
-        rust-version: 1.96 # updatecli.d/rust.yml

.github/workflows/lint.yml

@@ -1,94 +0,0 @@
-name: Lint
-
-on: [push, pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  format:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: ./.github/actions/rust-toolchain@stable
-      with:
-        components: rustfmt
-    - name: install dependencies
-      run: pip install ruff
-    - name: build fish
-      run: cargo build --bin fish_indent
-    - name: check format
-      run: PATH="target/debug:$PATH" cargo xtask format --all --check
-    - name: check rustfmt
-      run: find build.rs crates src -type f -name '*.rs' | xargs rustfmt --check
-
-  shellcheck:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: ./.github/actions/rust-toolchain@stable
-    - name: Update package database
-      run: sudo apt-get update
-    - name: Install shellcheck
-      run: sudo apt install shellcheck
-    - name: shellcheck
-      run: cargo xtask shellcheck
-
-  po_files_up_to_date:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: ./.github/actions/rust-toolchain@stable
-    - name: Install deps
-      uses: ./.github/actions/install-dependencies
-    - name: Check PO files
-      run: cargo xtask gettext check
-
-  clippy:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - rust_version: "stable"
-            features: ""
-          - rust_version: "stable"
-            features: "--no-default-features"
-          - rust_version: "stable"
-            features: "--all-features"
-          - rust_version: "msrv"
-            features: ""
-    steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: ./.github/actions/rust-toolchain
-      with:
-        toolchain_channel: ${{ matrix.rust_version }}
-        components: clippy
-    - name: Update package database
-      run: sudo apt-get update
-    - name: Install deps
-      run: |
-        sudo apt install gettext
-    - name: Patch Cargo.toml to deny unknown lints
-      run: |
-        if [ "${{ matrix.rust_version }}" = stable ]; then
-          sed -i /^rust.unknown_lints/d Cargo.toml
-        fi
-    - name: cargo clippy
-      run: cargo clippy --workspace --all-targets ${{ matrix.features }} -- --deny=warnings
-
-  rustdoc:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: ./.github/actions/rust-toolchain@stable
-    - name: Update package database
-      run: sudo apt-get update
-    - name: Install deps
-      run: |
-        sudo apt install gettext
-    - name: cargo doc
-      run: |
-        RUSTDOCFLAGS='-D warnings' cargo doc --workspace
-    - name: cargo doctest
-      run: |
-        cargo test --doc --workspace

.github/workflows/lockthreads.yml

@@ -12,13 +12,12 @@ permissions:
 
 jobs:
   lock:
-    if: github.repository_owner == 'fish-shell'
     permissions:
       issues: write  # for dessant/lock-threads to lock issues
       pull-requests: write  # for dessant/lock-threads to lock PRs
     runs-on: ubuntu-latest
     steps:
-      - uses: dessant/lock-threads@b2726a6ae6f1e1b06eb0ff28f7e4fb5e4246bbca # v6.0.2, build_tools/update-dependencies.sh
+      - uses: dessant/lock-threads@v4
         with:
           github-token: ${{ github.token }}
           issue-inactive-days: '365'

.github/workflows/mac_codesign.yml

@@ -0,0 +1,42 @@
+name: macOS build and codesign
+
+on:
+  workflow_dispatch: # Enables manual trigger from GitHub UI
+
+jobs:
+  build-and-code-sign:
+    runs-on: macos-latest
+    environment: macos-codesign
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Rust 1.73.0
+        uses: dtolnay/rust-toolchain@1.73.0
+        with:
+          targets: x86_64-apple-darwin
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-apple-darwin
+      - name: build-and-codesign
+        run: |
+          cargo install apple-codesign
+          mkdir -p "$FISH_ARTEFACT_PATH"
+          echo "$MAC_CODESIGN_APP_P12_BASE64" | base64 --decode > /tmp/app.p12
+          echo "$MAC_CODESIGN_INSTALLER_P12_BASE64" | base64 --decode > /tmp/installer.p12
+          echo "$MACOS_NOTARIZE_JSON" > /tmp/notarize.json
+          ./build_tools/make_pkg.sh -s -f /tmp/app.p12 -i /tmp/installer.p12 -p "$MAC_CODESIGN_PASSWORD" -n -j /tmp/notarize.json
+          rm /tmp/installer.p12 /tmp/app.p12 /tmp/notarize.json
+        env:
+          MAC_CODESIGN_APP_P12_BASE64: ${{ secrets.MAC_CODESIGN_APP_P12_BASE64 }}
+          MAC_CODESIGN_INSTALLER_P12_BASE64: ${{ secrets.MAC_CODESIGN_INSTALLER_P12_BASE64 }}
+          MAC_CODESIGN_PASSWORD: ${{ secrets.MAC_CODESIGN_PASSWORD }}
+          MACOS_NOTARIZE_JSON: ${{ secrets.MACOS_NOTARIZE_JSON }}
+          # macOS runners keep having issues loading Cargo.toml dependencies from git (GitHub) instead
+          # of crates.io, so give this a try. It's also sometimes significantly faster on all platforms.
+          CARGO_NET_GIT_FETCH_WITH_CLI: true
+          FISH_ARTEFACT_PATH: /tmp/fish-built
+      - uses: actions/upload-artifact@v4
+        with:
+          name: macOS Artefacts
+          path: /tmp/fish-built/*
+          if-no-files-found: error

.github/workflows/main.yml

@@ -1,9 +1,9 @@
-name: Test
+name: make fish_run_tests
 
 on: [push, pull_request]
 
 env:
-  FISH_TEST_MAX_CONCURRENCY: "4"
+  CTEST_PARALLEL_LEVEL: "4"
   CMAKE_BUILD_PARALLEL_LEVEL: "4"
 
 permissions:
@@ -11,16 +11,16 @@ permissions:
 
 jobs:
   ubuntu:
+
     runs-on: ubuntu-latest
+
     steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: ./.github/actions/rust-toolchain@oldest-supported
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@1.70
     - name: Install deps
-      uses: ./.github/actions/install-dependencies
-      with:
-        include_sphinx: true
-    - name: Generate a locale that uses a comma as decimal separator.
       run: |
+        sudo apt install gettext libpcre2-dev python3-pexpect tmux
+        # Generate a locale that uses a comma as decimal separator.
         sudo locale-gen fr_FR.UTF-8
     - name: cmake
       run: |
@@ -34,21 +34,18 @@ jobs:
         make -C build VERBOSE=1 fish_run_tests
 
   ubuntu-32bit-static-pcre2:
+
     runs-on: ubuntu-latest
+
     steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: ./.github/actions/rust-toolchain@oldest-supported
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@1.70
       with:
-        targets: "i586-unknown-linux-gnu"
-    - name: Update package database
-      run: sudo apt-get update
+        targets: "i586-unknown-linux-gnu" # rust-toolchain wants this comma-separated
     - name: Install deps
-      uses: ./.github/actions/install-dependencies
-      with:
-        include_pcre: false
-        include_sphinx: false
-    - name: Install g++-multilib
-      run: sudo apt install g++-multilib
+      run: |
+        sudo apt update
+        sudo apt install gettext python3-pexpect g++-multilib tmux
     - name: cmake
       env:
           CFLAGS: "-m32"
@@ -63,6 +60,7 @@ jobs:
         make -C build VERBOSE=1 fish_run_tests
 
   ubuntu-asan:
+
     runs-on: ubuntu-latest
     env:
         # Rust has two different memory sanitizers of interest; they can't be used at the same time:
@@ -72,30 +70,25 @@ jobs:
         #
         RUSTFLAGS: "-Zsanitizer=address"
         # RUSTFLAGS: "-Zsanitizer=memory -Zsanitizer-memory-track-origins"
+
     steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
+    - uses: actions/checkout@v4
     # All -Z options require running nightly
     - uses: dtolnay/rust-toolchain@nightly
       with:
         # ASAN uses `cargo build -Zbuild-std` which requires the rust-src component
         # this is comma-separated
         components: rust-src
-    - name: Update package database
-      run: sudo apt-get update
     - name: Install deps
-      uses: ./.github/actions/install-dependencies
-      with:
-        include_sphinx: false
-    - name: Install llvm
       run: |
-        sudo apt install llvm # for llvm-symbolizer
+        sudo apt install gettext libpcre2-dev python3-pexpect tmux
     - name: cmake
       env:
           CC: clang
       run: |
         mkdir build && cd build
         # Rust's ASAN requires the build system to explicitly pass a --target triple. We read that
-        # value from CMake variable Rust_CARGO_TARGET.
+        # value from CMake variable Rust_CARGO_TARGET (shared with corrosion).
         cmake .. -DASAN=1 -DRust_CARGO_TARGET=x86_64-unknown-linux-gnu -DCMAKE_BUILD_TYPE=Debug
     - name: make
       run: |
@@ -111,63 +104,63 @@ jobs:
           # UPDATE: this can cause spurious leak reports for __cxa_thread_atexit_impl() under glibc.
           LSAN_OPTIONS: verbosity=0:log_threads=0:use_tls=1:print_suppressions=0
       run: |
-        set -x
-        export ASAN_SYMBOLIZER_PATH=$(command -v /usr/bin/llvm-symbolizer* | sort -n | head -1)
+        llvm_version=$(clang --version | awk 'NR==1 { split($NF, version, "."); print version[1] }')
+        export ASAN_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer-$llvm_version
         export LSAN_OPTIONS="$LSAN_OPTIONS:suppressions=$PWD/build_tools/lsan_suppressions.txt"
         make -C build VERBOSE=1 fish_run_tests
 
+  # Our clang++ tsan builds are not recognizing safe rust patterns (such as the fact that Drop
+  # cannot be called while a thread is using the object in question). Rust has its own way of
+  # running TSAN, but for the duration of the port from C++ to Rust, we'll keep this disabled.
+
+  # ubuntu-threadsan:
+  #
+  #   runs-on: ubuntu-latest
+  #
+  #   steps:
+  #   - uses: actions/checkout@v4
+  #   - uses: dtolnay/rust-toolchain@1.70
+  #   - name: Install deps
+  #     run: |
+  #       sudo apt install gettext libpcre2-dev python3-pexpect tmux
+  #   - name: cmake
+  #     env:
+  #         FISH_CI_SAN: 1
+  #         CC: clang
+  #     run: |
+  #       mkdir build && cd build
+  #       cmake ..
+  #   - name: make
+  #     run: |
+  #       make
+  #   - name: make fish_run_tests
+  #     run: |
+  #       make -C build fish_run_tests
+
   macos:
+
     runs-on: macos-latest
+
     env:
       # macOS runners keep having issues loading Cargo.toml dependencies from git (GitHub) instead
       # of crates.io, so give this a try. It's also sometimes significantly faster on all platforms.
       CARGO_NET_GIT_FETCH_WITH_CLI: true
     steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: ./.github/actions/rust-toolchain@oldest-supported
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@1.70
     - name: Install deps
       run: |
         # --break-system-packages because homebrew has now declared itself "externally managed".
         # this is CI so we don't actually care.
         sudo pip3 install --break-system-packages pexpect
-        brew install gettext tmux
-    - uses: ./.github/actions/install-sphinx
+        brew install tmux
     - name: cmake
       run: |
         mkdir build && cd build
-        FISH_TEST_MAX_CONCURRENCY=1 \
-          cmake -DCMAKE_BUILD_TYPE=Debug ..
+        cmake -DWITH_GETTEXT=NO -DCMAKE_BUILD_TYPE=Debug ..
     - name: make
       run: |
         make -C build VERBOSE=1
     - name: make fish_run_tests
       run: |
         make -C build VERBOSE=1 fish_run_tests
-
-  windows:
-    runs-on: windows-latest
-    defaults:
-      run:
-        shell: msys2 {0}
-    steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-    - uses: msys2/setup-msys2@e9898307ac31d1a803454791be09ab9973336e1c # v2.31.1, build_tools/update-dependencies.sh
-      with:
-        update: true
-        msystem: MSYS
-      id: msys2
-    - name: Install deps
-      # Not using setup-msys2 `install` option to make it easier to copy/paste
-      run: |
-        pacman --noconfirm -S --needed git rust python3 diffutils tmux
-    - name: rebase
-      env:
-        MSYS2_LOCATION: ${{ steps.msys2.outputs.msys2-location }}
-      shell: cmd
-      run: |
-        "%MSYS2_LOCATION%\usr\bin\dash" /usr/bin/rebaseall -p -v
-    - name: check
-      env:
-        FISH_CHECK_LINT: false
-      run: |
-        cargo xtask check

.github/workflows/release.yml

@@ -1,196 +0,0 @@
-name: Create a new release
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version to release (tag name)'
-        required: true
-        type: string
-
-permissions:
-  contents: write
-
-jobs:
-  is-release-tag:
-    name: Pre-release checks
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-        with:
-          # Workaround for https://github.com/actions/checkout/issues/882
-          ref: ${{ inputs.version }}
-      - name: Check if the pushed tag looks like a release
-        run: |
-          set -x
-          commit_subject=$(git log -1 --format=%s)
-          tag=$(git describe)
-          [ "$commit_subject" = "Release $tag" ]
-
-
-  source-tarball:
-    needs: [is-release-tag]
-    name: Create the source tarball
-    runs-on: ubuntu-latest
-    outputs:
-      version: ${{ steps.version.outputs.version }}
-      tarball-name: ${{ steps.version.outputs.tarball-name }}
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-        with:
-          # Workaround for https://github.com/actions/checkout/issues/882
-          ref: ${{ inputs.version }}
-      - name: Update package database
-        run: sudo apt-get update
-      - name: Install dependencies
-        run: sudo apt install cmake gettext ninja-build python3-pip
-      - uses: ./.github/actions/install-sphinx
-      - name: Create tarball
-        run: |
-          set -x
-          mkdir /tmp/fish-built
-          FISH_ARTEFACT_PATH=/tmp/fish-built ./build_tools/make_tarball.sh
-          relnotes=/tmp/fish-built/release-notes.md
-          # Need history since the last release (i.e. tag) for stats.
-          git fetch --tags
-          git fetch --unshallow
-          gpg_public_key_url=https://github.com/${{ github.actor }}.gpg
-          curl -sS "$gpg_public_key_url" | grep 'PGP PUBLIC KEY BLOCK' -A5
-          FISH_GPG_PUBLIC_KEY_URL=$gpg_public_key_url \
-            sh -x ./build_tools/release-notes.sh >"$relnotes"
-          # Delete title
-          sed -n 1p "$relnotes" | grep -q "^## fish .*"
-          sed -n 2p "$relnotes" | grep -q '^$'
-          sed -i 1,2d "$relnotes"
-      - name: Upload tarball artifact
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1, build_tools/update-dependencies.sh
-        with:
-          name: source-tarball
-          path: |
-            /tmp/fish-built/fish-${{ inputs.version }}.tar.xz
-            /tmp/fish-built/release-notes.md
-          if-no-files-found: error
-
-  packages-for-linux:
-    needs: [is-release-tag]
-    name: Build single-file fish for Linux
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-        with:
-          # Workaround for https://github.com/actions/checkout/issues/882
-          ref: ${{ inputs.version }}
-      - name: Install Rust Stable
-        uses: ./.github/actions/rust-toolchain@stable
-        with:
-          targets: x86_64-unknown-linux-musl,aarch64-unknown-linux-musl
-      - name: Update package database
-        run: sudo apt-get update
-      - name: Install dependencies
-        run: sudo apt install crossbuild-essential-arm64 gettext musl-tools
-      - uses: ./.github/actions/install-sphinx
-      - name: Build statically-linked executables
-        run: |
-          set -x
-          cargo build --release --target x86_64-unknown-linux-musl --bin fish
-          CFLAGS="-D_FORTIFY_SOURCE=2" \
-            CC=aarch64-linux-gnu-gcc \
-            RUSTFLAGS="-C linker=aarch64-linux-gnu-gcc -C link-arg=-lgcc -C link-arg=-D_FORTIFY_SOURCE=0" \
-            cargo build --release --target aarch64-unknown-linux-musl --bin fish
-      - name: Compress
-        run: |
-          set -x
-          for arch in x86_64 aarch64; do
-            tar -cazf fish-$(git describe)-linux-$arch.tar.xz \
-              -C target/$arch-unknown-linux-musl/release fish
-          done
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1, build_tools/update-dependencies.sh
-        with:
-          name: Static builds for Linux
-          path: fish-${{ inputs.version }}-linux-*.tar.xz
-          if-no-files-found: error
-
-  create-draft-release:
-    needs:
-      - is-release-tag
-      - source-tarball
-      - packages-for-linux
-    name: Create release draft
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-        with:
-          # Workaround for https://github.com/actions/checkout/issues/882
-          ref: ${{ inputs.version }}
-      - name: Download all artifacts
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1, build_tools/update-dependencies.sh
-        with:
-          merge-multiple: true
-          path: /tmp/artifacts
-      - name: List artifacts
-        run: find /tmp/artifacts -type f
-      - name: Create draft release
-        uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0, build_tools/update-dependencies.sh
-        with:
-          tag_name: ${{ inputs.version }}
-          name: fish ${{ inputs.version }}
-          body_path: /tmp/artifacts/release-notes.md
-          draft: true
-          files: |
-            /tmp/artifacts/fish-${{ inputs.version }}.tar.xz
-            /tmp/artifacts/fish-${{ inputs.version }}-linux-*.tar.xz
-
-  packages-for-macos:
-    needs: [is-release-tag, create-draft-release]
-    name: Build packages for macOS
-    runs-on: macos-latest
-    environment: macos-codesign
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2, build_tools/update-dependencies.sh
-        with:
-          # Workaround for https://github.com/actions/checkout/issues/882
-          ref: ${{ inputs.version }}
-      - name: Install Rust
-        uses: ./.github/actions/rust-toolchain@stable
-        with:
-          targets: aarch64-apple-darwin,x86_64-apple-darwin
-      - name: Install dependencies
-        run: brew install gettext
-      - uses: ./.github/actions/install-sphinx
-      - name: Build and codesign
-        run: |
-          die() { echo >&2 "$*"; exit 1; }
-          [ -n "$MAC_CODESIGN_APP_P12_BASE64" ] || die "Missing MAC_CODESIGN_APP_P12_BASE64"
-          [ -n "$MAC_CODESIGN_INSTALLER_P12_BASE64" ] || die "Missing MAC_CODESIGN_INSTALLER_P12_BASE64"
-          [ -n "$MAC_CODESIGN_PASSWORD" ] || die "Missing MAC_CODESIGN_PASSWORD"
-          [ -n "$MACOS_NOTARIZE_JSON" ] || die "Missing MACOS_NOTARIZE_JSON"
-          set -x
-          export FISH_ARTEFACT_PATH=/tmp/fish-built
-          # macOS runners keep having issues loading Cargo.toml dependencies from git (GitHub) instead
-          # of crates.io, so give this a try. It's also sometimes significantly faster on all platforms.
-          export CARGO_NET_GIT_FETCH_WITH_CLI=true
-          cargo install apple-codesign
-          mkdir -p "$FISH_ARTEFACT_PATH"
-          echo "$MAC_CODESIGN_APP_P12_BASE64" | base64 --decode >/tmp/app.p12
-          echo "$MAC_CODESIGN_INSTALLER_P12_BASE64" | base64 --decode >/tmp/installer.p12
-          echo "$MACOS_NOTARIZE_JSON" >/tmp/notarize.json
-          ./build_tools/make_macos_pkg.sh -s -f /tmp/app.p12 \
-            -i /tmp/installer.p12 -p "$MAC_CODESIGN_PASSWORD" \
-            -n -j /tmp/notarize.json -- -c "-DWITH_DOCS=ON"
-          version=$(git describe)
-          [ -f "${FISH_ARTEFACT_PATH}/fish-$version.app.zip" ]
-          [ -f "${FISH_ARTEFACT_PATH}/fish-$version.pkg" ]
-          rm /tmp/installer.p12 /tmp/app.p12 /tmp/notarize.json
-        env:
-          MAC_CODESIGN_APP_P12_BASE64: ${{ secrets.MAC_CODESIGN_APP_P12_BASE64 }}
-          MAC_CODESIGN_INSTALLER_P12_BASE64: ${{ secrets.MAC_CODESIGN_INSTALLER_P12_BASE64 }}
-          MAC_CODESIGN_PASSWORD: ${{ secrets.MAC_CODESIGN_PASSWORD }}
-          MACOS_NOTARIZE_JSON: ${{ secrets.MACOS_NOTARIZE_JSON }}
-      - name: Add macOS packages to the release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          version=$(git describe)
-          gh release upload $version \
-            /tmp/fish-built/fish-$version.app.zip \
-            /tmp/fish-built/fish-$version.pkg

.github/workflows/rust_checks.yml

@@ -0,0 +1,41 @@
+name: Rust checks
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  rustfmt:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@stable
+    - name: cargo fmt
+      run: cargo fmt --check --all
+
+  clippy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@stable
+    - name: Install deps
+      run: |
+        sudo apt install gettext libpcre2-dev
+    - name: cmake
+      run: |
+        cmake -B build
+    - name: cargo clippy
+      # This used to have --deny=warnings, but that turns rust release day
+      # into automatic CI failure day, so we don't do that.
+      run: cargo clippy --workspace --all-targets
+
+  # Disabling for now because it also checks "advisories",
+  # making CI fail for reasons unrelated to the patch
+  # cargo-deny:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #   - uses: actions/checkout@v3
+  #   - uses: EmbarkStudios/cargo-deny-action@v1

.github/workflows/staticbuild.yml

@@ -0,0 +1,80 @@
+name: staticbuilds
+
+on:
+    # release:
+    #     types: [published]
+    # schedule:
+    # - cron: "14 13 * * *"
+    workflow_dispatch:
+
+env:
+  CTEST_PARALLEL_LEVEL: "1"
+  CMAKE_BUILD_PARALLEL_LEVEL: "4"
+
+jobs:
+  staticbuilds-linux:
+
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+
+    steps:
+    - uses: dtolnay/rust-toolchain@1.70
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Prepare
+      run: |
+           sudo apt install python3-sphinx
+           rustup target add x86_64-unknown-linux-musl
+           rustup target add aarch64-unknown-linux-musl
+           sudo apt install musl-tools crossbuild-essential-arm64 python3-pexpect tmux -y
+    - name: Build
+      run: |
+           CFLAGS="$CFLAGS -D_FORTIFY_SOURCE=2" CMAKE_WITH_GETTEXT=0 CC=aarch64-linux-gnu-gcc RUSTFLAGS="-C linker=aarch64-linux-gnu-gcc -C link-arg=-lgcc -C link-arg=-D_FORTIFY_SOURCE=0" cargo build --release --target aarch64-unknown-linux-musl --bin fish
+           cargo build --release --target x86_64-unknown-linux-musl
+    - name: Test
+      run: |
+           test -e tests/test_driver.py && tests/test_driver.py -f /tmp target/x86_64-unknown-linux-musl/release/
+    - name: Compress
+      run: |
+           tar -cazf fish-static-x86_64-$(git describe).tar.xz -C target/x86_64-unknown-linux-musl/release/ fish
+           tar -cazf fish-static-aarch64-$(git describe).tar.xz -C target/aarch64-unknown-linux-musl/release/ fish
+    - uses: actions/upload-artifact@v4
+      with:
+        name: fish-static-linux
+        path: |
+              fish-*.tar.xz
+        retention-days: 14
+  staticbuilds-macos:
+
+    runs-on: macos-latest
+
+    permissions:
+      contents: read
+
+    steps:
+    - uses: dtolnay/rust-toolchain@1.70
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Prepare
+      run: |
+           sudo pip3 install --break-system-packages sphinx
+           rustup target add x86_64-apple-darwin
+           rustup target add aarch64-apple-darwin
+    - name: Build
+      run: |
+           PCRE2_SYS_STATIC=1 cargo build --release --target aarch64-apple-darwin --bin fish
+           PCRE2_SYS_STATIC=1 cargo build --release --target x86_64-apple-darwin --bin fish
+    - name: Compress
+      run: |
+           tar -cazf fish-macos-aarch64.tar.xz -C target/aarch64-apple-darwin/release/ fish
+           tar -cazf fish-macos-x86_64.tar.xz -C target/x86_64-apple-darwin/release/ fish
+    - uses: actions/upload-artifact@v4
+      with:
+        name: fish-static-macos
+        path: |
+              fish-macos-*.tar.xz
+        retention-days: 14

.gitignore

@@ -7,6 +7,7 @@
 *.DS_Store
 *.a
 *.app
+*.d
 *.dll
 *.dylib
 *.exe
@@ -20,6 +21,7 @@
 *.o
 *.obj
 *.orig
+!tests/*.out
 *.out
 *.pch
 *.slo
@@ -35,31 +37,46 @@
 Desktop.ini
 Thumbs.db
 ehthumbs.db
-__pycache__/
 
+messages.pot
 .directory
 .fuse_hidden*
 
 
-# Artifacts from in-tree builds ("cmake .").
-/build.ninja
-/cargo/
-/CMakeCache.txt
-/CMakeFiles/
-/cmake_install.cmake
+# Directories that only contain transitory files from building and testing.
+/doc/
+/share/man/
+/share/doc/
+/test/
+/user_doc/
+
+# File names that can appear in the project root that represent artifacts from
+# building and testing.
+/FISH-BUILD-VERSION-FILE
+/command_list.txt
+/command_list_toc.txt
+/compile_commands.json
+/doc.h
 /fish
+/fish.pc
 /fish_indent
 /fish_key_reader
-/fish-localization-map-cache/
-/fish.pc
-/fish.pc.noversion
-/.ninja_log
+/fish_tests
+/lexicon.txt
+/lexicon_filter
+/toc.txt
+/version
+fish-build-version-witness.txt
+__pycache__
 
 # File names that can appear below the project root that represent artifacts
 # from building and testing.
+/doc_src/commands.hdr
+/doc_src/index.hdr
+/po/*.gmo
 /share/__fish_build_paths.fish
-/tests/.last-check-all-files
-/.venv/
+/share/pkgconfig
+/tests/*.tmp.*
 
 # xcode
 ## Build generated
@@ -67,22 +84,24 @@ __pycache__/
 *.xccheckout
 *.xcscmblueprin
 .vscode
-/build/
 /DerivedData/
+/build/
 /tags
-/xcuserdata/
+xcuserdata/
 
 # Generated by Cargo
 # will have compiled files and executables
-/target/
+debug/
+target/
+
 # These are backup files generated by rustfmt
 **/*.rs.bk
 
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
 # Generated by clangd
-/.cache/
+/.cache
 
 # JetBrains editors.
 .idea/
-
-# AI slop
-.claude/

.rustfmt.toml

@@ -1 +0,0 @@
-edition = "2024"

CHANGELOG.rst

@@ -1,627 +1,93 @@
-fish ?.?.? (released ???)
+fish 4.1.0 (released ???)
 =========================
 
-Deprecations and removed features
----------------------------------
-- The ``--command`` and ``--path`` options in :doc:`complete <cmds/complete>` no longer unescape their argument.
-
-Interactive improvements
-------------------------
-- On the first run after upgrading from an older version, fish will try harder to check if the current theme matches a historical default, in which case fish won't create ``~/.config/fish/conf.d/fish_frozen_theme.fish``.
-  This means that on systems where fish version 3.x was installed originally, fish 4.8 will avoid creating that file on upgrade (:issue:`12725`).
-- ``fish_hg_prompt``, ``fish_git_prompt`` and ``fish_fossil_prompt`` now strip control characters from VCS state read off disk, matching ``prompt_pwd``.
-- The sample informative and minimalist prompts now use ``prompt_pwd`` instead of printing ``$PWD`` directly.
-- :doc:`bind <cmds/bind>` shows the file where bindings were defined (:issue:`12504`).
-- Abbreviations with ``--position=anywhere`` can now be completed in argument position, not just in command position (:issue:`12630`).
-- Path component movement (:kbd:`ctrl-w`) skips escaped characters.
-
-Other improvements
-------------------
-- ``cd`` supports the ``-L`` and ``-P`` options, like other shells, to allow specifying whether symbolic links (symlinks) are resolved when changing directories (:issue:`7206`).
-- ``cd`` with a relative path will now retry using the real current directory, if ``$PWD`` has been moved or deleted (:issue:`12700`).
-- fish no longer creates universal variables by default; specifically the ``__fish_initialized`` variable is no longer created.
-  If you don't expect to need to downgrade to earlier versions, you can remove it with ``set --erase __fish_initialized``.
-- Nested brace expansions now strip unquoted leading and trailing spaces from entries consistently (:issue:`12794`).
-
-For distributors and developers
--------------------------------
-- Messages defined in Rust source code may now be localized using `Fluent <https://projectfluent.org/>`__. To make this easy to work with, we have added Fluent tooling based on the new `fluent-ftl-tools <https://codeberg.org/danielrainer/fluent-ftl-tools>`__ Rust crate, see :ref:`Contributing Translations <localization>` (:issue:`11928`).
-- With the exception of the ``$CMAKE_INSTALL_PREFIX/share/fish/man`` directory, fish no longer installs files to ``$CMAKE_INSTALL_PREFIX/share/fish``.
-  In particular, this means that both
-  ``$CMAKE_INSTALL_PREFIX/share/fish/completions`` and
-  ``$CMAKE_INSTALL_PREFIX/share/fish/functions``
-  should no longer exist.
-  These directories have been ignored since fish 4.2.
-  If another package installs fish scripts there, they should be corrected to install to
-  ``extra_completionsdir`` (typically ``$CMAKE_INSTALL_PREFIX/share/fish/vendor_completions.d``),
-  ``extra_functionsdir`` (typically ``$CMAKE_INSTALL_PREFIX/share/fish/vendor_functions.d``) or
-  ``extra_confdir`` (typically ``$CMAKE_INSTALL_PREFIX/share/fish/vendor_functions.d``) instead.
-  See also the output of ``for var in completions functions conf; pkgconf fish --variable="$var"dir; end``.
-
-Regression fixes:
------------------
-- (from 4.4.0) Vi mode ``c,W`` key binding wrongly deleted trailing spaces (:issue:`12790`).
-- (from 4.4.0) Vi mode ``x`` in :doc:`builtin read <cmds/read>` (:issue:`12724`).
-- (from 4.3.3) Repeated tab would sometimes insert smartcase completions redundantly.
-- (from 4.3.0) Pressing escape during command input would insert garbage text into the command line (:issue:`12379`).
-
-fish 4.7.1 (released May 08, 2026)
-==================================
-
-This release fixes a regression in 4.7.0 that caused the web config (``fish_config``) to fail to start (:issue:`12717`).
-
-fish 4.7.0 (released May 05, 2026)
-==================================
-
-Deprecations and removed features
----------------------------------
-- The default theme (i.e. the ``fish_color_*`` variables) is no longer set in non-interactive shells.
-
-Interactive improvements
-------------------------
-- :doc:`prompt_pwd <cmds/prompt_pwd>` now strips control characters.
-- Repaint events (as triggered by changes to color variables or by event handlers running ``commandline -f repaint``) no longer reset the completion pager and other transient UI states (:issue:`12683`).
-- :envvar:`fish_color_valid_path` now respects background and underline colors (:issue:`12622`).
-- :doc:`funced <cmds/funced>` will no longer lose work if there are parse errors multiple times without new changes to the file.
-- Fixed a case where directory completions were sorted in a surprising order (:issue:`12695`).
-- When at the command token, the :kbd:`alt-o` binding will now open read-only files too (:issue:`12671`).
-- Private mode in-memory history (``set fish_history``) is no longer shared with :doc:`builtin read <cmds/read>` (:issue:`12662`).
-
-Other improvements
-------------------
-- History is no longer corrupted with NUL bytes when fish receives SIGTERM or SIGHUP (:issue:`10300`).
-- :doc:`fish_update_completions <cmds/fish_update_completions>` now handles groff ``\X'...'`` device control escapes, fixing completion generation for man pages produced by help2man 1.50 and later (such as coreutils 9.10).
-- Removing history entries via the :doc:`web-based config <cmds/fish_config>` is more intuitive.
-- If :envvar:`XDG_DATA_DIRS` is empty, the default value is assumed, which means that fish will now also use configuration from paths like ``$PREFIX/share/fish/vendor_completions.d`` (:issue:`11349`).
-- Some internal file descriptors were moved to number 10 or higher, to reduce risk of clashes with those used by the user in scripts.
-- The wording of error messages has been made consistent, especially for builtin subcommands (:issue:`12556`).
-
-For distributors and developers
--------------------------------
-- When the default global config directory (``$PREFIX/etc/fish``) exists but has been overridden via ``-DCMAKE_INSTALL_SYSCONFDIR``, fish will now respect that override (:issue:`10748`).
-- ``build_tools/update_translations.fish`` has been replaced by ``cargo xtask gettext {check,new,update}`` (:issue:`12676`).
-- ``cargo xtask shellcheck`` to lint shell-scripts.
-
-Regression fixes:
------------------
-- (from 4.6) Vi mode ``dl`` (:issue:`12461`).
-- (from 4.6) Backspace after newline (:issue:`12583`).
-- (from 4.3.3) Long options were spuriously completed after typing short options (85e76ba3561).
-- (from 3.2) ``nosuchcommand || echo hello`` executes the right hand side again (:issue:`12654`).
-
-fish 4.6.0 (released March 28, 2026)
-====================================
-
 Notable improvements and fixes
 ------------------------------
-- New Spanish translations (:issue:`12489`).
-- New Japanese translations (:issue:`12499`).
+- Compound commands (``begin; echo 1; echo 2; end``) can now be now be abbreviated using braces (``{ echo1; echo 2 }``), like in other shells.
+- Fish now supports transient prompts: if :envvar:`fish_transient_prompt` is set to 1, fish will reexecute prompt functions with the ``--final-rendering`` argument before running a commandline (:issue:`11153`).
+- When tab completion results are truncated, any common directory name is omitted. E.g. if you complete "share/functions", and it includes the files "foo.fish" and "bar.fish",
+  the completion pager will now show "…/foo.fish" and "…/bar.fish". This will make the candidates shorter and allow for more to be shown at once (:issue:`11250`).
+- The self-installing configuration introduced in fish 4.0 has been changed.
+  Now fish built with embedded data will just read the data straight from its own binary or write it out when necessary, instead of requiring an installation step on start.
+  That means it is now possible to build fish as a single file and copy it to a compatible system, including as a different user, without extracting any files.
+  As before this is the default when building via `cargo`, and disabled when building via `cmake`, and for packagers we continue to recommend cmake.
+
+  Note: When fish is built like this, the `$__fish_data_dir` variable will be empty because that directory no longer has meaning. If you need to load files from there,
+  use `status get-file` or find alternatives (like loading completions for "foo" via `complete -C"foo "`).
+
+  We're considering making data embedding mandatory in future releases because it has a few advantages even for installation from a package (like making file conflicts with other packages impossible). (:issue:`11143`)
 
 Deprecations and removed features
 ---------------------------------
-- The default width for emoji is switched from 1 to 2, improving the experience for users connecting to old systems from modern desktops. Users of old desktops who notice that lines containing emoji are misaligned can set ``$fish_emoji_width`` back to 1 (:issue:`12562`).
-
-Interactive improvements
-------------------------
-- The tab completion pager now left-justifies the description of each column (:issue:`12546`).
-- fish now supports the ``SHELL_PROMPT_PREFIX``, ``SHELL_PROMPT_SUFFIX``, and ``SHELL_WELCOME`` environment variables. The prefix and suffix are automatically prepended and appended to the left prompt, and the welcome message is displayed on startup after the greeting.
-  These variables are set by systemd's ``run0`` for example (:issue:`10924`).
-
-Improved terminal support
--------------------------
-- ``set_color`` is able to turn off italics, reverse mode, strikethrough and underline individually (e.g. ``--italics=off``).
-- ``set_color`` learned the foreground (``--foreground`` or ``-f``) and reset (``--reset``) options.
-- An error caused by slow terminal responses at macOS startup has been addressed (:issue:`12571`).
-
-Other improvements
-------------------
-- Signals like ``SIGWINCH`` (as sent on terminal resize) no longer interrupt builtin output (:issue:`12496`).
-- For compatibility with Bash, fish now accepts ``|&`` as alternate spelling of ``&|``, for piping both standard output and standard error (:issue:`11516`).
-- ``fish_indent`` now preserves comments and newlines immediately preceding a brace block (``{ }``) (:issue:`12505`).
-- A crash when suspending certain pipelines with :kbd:`ctrl-z` has been fixed (:issue:`12301`).
-
-For distributors and developers
--------------------------------
-- ``cargo xtask`` subcommands no longer panic on test failures.
-
-Regression fixes:
------------------
-- (from 4.5.0) Intermediate ``⏎`` artifact when redrawing prompt (:issue:`12476`).
-- (from 4.4.0) ``history`` honors explicitly specified ``--color=`` again (:issue:`12512`).
-- (from 4.4.0) Vi mode ``dl`` and ``dh`` (:issue:`12461`).
-- (from 4.3.0) Error completing of commands starting with ``-`` (:issue:`12522`).
-
-fish 4.5.0 (released February 17, 2026)
-=======================================
-
-This is mostly a patch release for Vi mode regressions in 4.4.0 but other minor behavior changes are included as well.
-
-Interactive improvements
-------------------------
-- :kbd:`ctrl-l` no longer cancels history search (:issue:`12436`).
-- History search cursor positioning now works correctly with characters of arbitrary width.
-
-Deprecations and removed features
----------------------------------
-- fish no longer reads the terminfo database to alter behaviour based on the :envvar:`TERM` environment variable, and does not depend on ncurses or terminfo. The ``ignore-terminfo`` feature flag, introduced and enabled by default in fish 4.1, is now permanently enabled. fish may no longer work correctly on Data General Dasher D220 and Wyse WY-350 terminals, but should continue to work on all known terminal emulators released in the 21st century.
-
-Regression fixes:
------------------
-- (from 4.4.0) Vi mode ``d,f`` key binding did not work (:issue:`12417`).
-- (from 4.4.0) Vi mode ``c,w`` key binding wrongly deleted trailing spaces (:issue:`12443`).
-- (from 4.4.0) Vi mode crash on ``c,i,w`` after accepting autosuggestion (:issue:`12430`).
-- (from 4.4.0) ``fish_vi_key_bindings`` called with a mode argument produced an error (:issue:`12413`).
-- (from 4.0.0) Build on Illumos (:issue:`12410`).
-
-fish 4.4.0 (released February 03, 2026)
-=======================================
-
-Deprecations and removed features
----------------------------------
-- The default fossil prompt has been disabled (:issue:`12342`).
-
-Interactive improvements
-------------------------
-- The ``bind`` builtin lists mappings from all modes if ``--mode`` is not provided (:issue:`12214`).
-- Line-wise autosuggestions that don't start a command are no longer shown (739b82c34db, 58e7a50de8a).
-- Builtin ``history`` now assumes that :envvar:`PAGER` supports ANSI color sequences.
-- fish now clears the terminal's ``FLUSHO`` flag when acquiring control of the terminal, to fix an issue caused by pressing :kbd:`ctrl-o` on macOS (:issue:`12304`).
-
-New or improved bindings
-------------------------
-- Vi mode word movements (``w``, ``W``, ``e``, and ``E``) are now largely in line with Vim. The only exception is that underscores are treated as word separators (:issue:`12269`).
-- New special input functions to support these movements: ``forward-word-vi``, ``kill-word-vi``, ``forward-bigword-vi``, ``kill-bigword-vi``, ``forward-word-end``, ``backward-word-end``, ``forward-bigword-end``, ``backward-bigword-end``, ``kill-a-word``, ``kill-inner-word``, ``kill-a-bigword``, and ``kill-inner-bigword``.
-- Vi mode key bindings now support counts for movement and deletion commands (e.g. `d3w` or `3l`), via a new operator mode (:issue:`2192`).
-- New ``catppuccin-*`` color themes.
-
-Improved terminal support
--------------------------
-- ``set_color`` learned the strikethrough (``--strikethrough`` or ``-s``) modifier.
-
-For distributors and developers
--------------------------------
-- The CMake option ``WITH_GETTEXT`` has been renamed to ``WITH_MESSAGE_LOCALIZATION``, to reflect that it toggles localization independently of the backend used in the implementation.
-- New ``cargo xtask`` commands can replace some CMake workflows.
-
-Regression fixes:
------------------
-- (from 4.1.0) Crash when autosuggesting Unicode characters with nontrivial lowercase mapping (:issue:`12326`, 78f4541116e).
-- (from 4.3.0) Glitch on ``read --prompt-str ""`` (:issue:`12296`).
-
-fish 4.3.3 (released January 07, 2026)
-======================================
-
-This release fixes the following problems identified in fish 4.3.0:
-
-- Selecting a completion could insert only part of the token (:issue:`12249`).
-- Glitch with soft-wrapped autosuggestions and :doc:`fish_right_prompt <cmds/fish_right_prompt>` (:issue:`12255`).
-- Spurious echo in tmux when typing a command really fast (:issue:`12261`).
-- ``tomorrow`` theme always using the light variant (:issue:`12266`).
-- ``fish_config theme choose`` sometimes not shadowing themes set by e.g. webconfig (:issue:`12278`).
-- The sample prompts and themes are correctly installed (:issue:`12241`).
-- Last line of command output could be hidden when missing newline (:issue:`12246`).
-
-Other improvements include:
-
-- The ``abbr``, ``bind``, ``complete``, ``functions``, ``history`` and ``type`` commands now support a ``--color`` option to control syntax highlighting in their output. Valid values are ``auto`` (default), ``always``, or ``never``.
-- Existing file paths in redirection targets such as ``> file.txt`` are now highlighted using :envvar:`fish_color_valid_path`, indicating that ``file.txt`` will be clobbered (:issue:`12260`).
-
-fish 4.3.2 (released December 30, 2025)
-=======================================
-
-This release fixes the following problems identified in 4.3.0:
-
-- Pre-built macOS packages failed to start due to a ``Malformed Mach-O file`` error (:issue:`12224`).
-- ``extra_functionsdir`` (usually ``vendor_functions.d``) and friends were not used (:issue:`12226`).
-- Sample config file ``~/.config/fish/config.fish/`` and config directories ``~/.config/fish/conf.d/``, ``~/.config/fish/completions/`` and ``~/.config/fish/functions/`` were recreated on every startup instead of only the first time fish runs on a system (:issue:`12230`).
-- Spurious echo of ``^[[I`` in some scenarios (:issue:`12232`).
-- Infinite prompt redraw loop on some prompts (:issue:`12233`).
-- The removal of pre-built HTML docs from tarballs revealed that cross compilation is broken because we use ``${CMAKE_BINARY_DIR}/fish_indent`` for building HTML docs.
-  As a workaround, the new CMake build option ``FISH_INDENT_FOR_BUILDING_DOCS`` can be set to the path of a runnable ``fish_indent`` binary.
-
-fish 4.3.1 (released December 28, 2025)
-=======================================
-
-This release fixes the following problem identified in 4.3.0:
-
-- Possible crash after expanding an abbreviation (:issue:`12223`).
-
-fish 4.3.0 (released December 28, 2025)
-=======================================
-
-Deprecations and removed features
----------------------------------
-- fish no longer sets user-facing :ref:`universal variables <variables-universal>` by default, making the configuration easier to understand.
-  Specifically, the ``fish_color_*``, ``fish_pager_color_*`` and ``fish_key_bindings`` variables are now set in the global scope by default.
-  After upgrading to 4.3.0, fish will (once and never again) migrate these universals to globals set at startup in the
-  ``~/.config/fish/conf.d/fish_frozen_theme.fish`` and
-  ``~/.config/fish/conf.d/fish_frozen_key_bindings.fish`` files.
-  We suggest that you delete those files and :ref:`set your theme <syntax-highlighting>` in ``~/.config/fish/config.fish``.
-
-  - You can still configure fish to propagate theme changes instantly; see :ref:`here <syntax-highlighting-instant-update>` for an example.
-  - You can still opt into storing color variables in the universal scope
-    via ``fish_config theme save`` though unlike ``fish_config theme choose``,
-    it does not support dynamic theme switching based on the terminal's color theme (see below).
-- In addition to setting the variables which are explicitly defined in the given theme,
-  ``fish_config theme choose`` now clears only color variables that were set by earlier invocations of a ``fish_config theme choose`` command
-  (which is how fish's default theme is set).
-
-Scripting improvements
-----------------------
-- New :ref:`status language <status-language>` command allows showing and modifying language settings for fish messages without having to modify environment variables.
-- When using a noninteractive fish instance to compute completions, ``commandline --cursor`` works as expected instead of throwing an error (:issue:`11993`).
-- :envvar:`fish_trace` can now be set to ``all`` to also trace execution of key bindings, event handlers as well as prompt and title functions.
-
-Interactive improvements
-------------------------
-- When typing immediately after starting fish, the first prompt is now rendered correctly.
-- Completion accuracy was improved for file paths containing ``=`` or ``:`` (:issue:`5363`).
-- Prefix-matching completions are now shown even if they don't match the case typed by the user (:issue:`7944`).
-- On Cygwin/MSYS, command name completion will favor the non-exe name (``foo``) unless the user started typing the extension.
-- When using the exe name (``foo.exe``), fish will use the description and completions for ``foo`` if there are none for ``foo.exe``.
-- Autosuggestions now also show soft-wrapped portions (:issue:`12045`).
-
-New or improved bindings
-------------------------
-- :kbd:`ctrl-w` (``backward-kill-path-component``) also deletes escaped spaces (:issue:`2016`).
-- New special input functions ``backward-path-component``, ``forward-path-component`` and ``kill-path-component`` (:issue:`12127`).
-
-Improved terminal support
--------------------------
-- Themes can now be made color-theme-aware by including both ``[light]`` and ``[dark]`` sections in the :ref:`theme file <fish-config-theme-files>`.
-  Some default themes have been made color-theme-aware, meaning they dynamically adjust as your terminal's background color switches between light and dark colors (:issue:`11580`).
-- The working directory is now reported on every fresh prompt (via OSC 7), fixing scenarios where a child process (like ``ssh``) left behind a stale working directory (:issue:`12191`).
-- OSC 133 prompt markers now also mark the prompt end, which improves shell integration with terminals like iTerm2 (:issue:`11837`).
-- Operating-system-specific key bindings are now decided based on the :ref:`terminal's host OS <status-terminal-os>`.
-- New :ref:`feature flag <featureflags>` ``omit-term-workarounds`` can be turned on to prevent fish from trying to work around some incompatible terminals.
-
-For distributors and developers
--------------------------------
-- Tarballs no longer contain prebuilt documentation,
-  so building and installing documentation requires Sphinx.
-  To avoid users accidentally losing docs, the ``BUILD_DOCS`` and ``INSTALL_DOCS`` configuration options have been replaced with a new ``WITH_DOCS`` option.
-- ``fish_key_reader`` and ``fish_indent`` are now installed as hardlinks to ``fish``, to save some space.
-
-Regression fixes:
------------------
-- (from 4.1.0) Crash on incorrectly-set color variables (:issue:`12078`).
-- (from 4.1.0) Crash when autosuggesting Unicode characters with nontrivial lowercase mapping.
-- (from 4.2.0) Incorrect emoji width computation on macOS.
-- (from 4.2.0) Mouse clicks and :kbd:`ctrl-l` edge cases in multiline command lines (:issue:`12121`).
-- (from 4.2.0) Completions for Git remote names on some non-glibc systems.
-- (from 4.2.0) Expansion of ``~$USER``.
-
-fish 4.2.1 (released November 13, 2025)
-=======================================
-
-This release fixes the following problems identified in 4.2.0:
-
-- When building from a tarball without Sphinx (that is, with ``-DBUILD_DOCS=OFF`` or when ``sphinx-build`` is not found),
-  builtin man pages and help files were missing, which has been fixed (:issue:`12052`).
-- ``fish_config``'s theme selector (the "colors" tab) was broken, which has been fixed (:issue:`12053`).
-
-fish 4.2.0 (released November 10, 2025)
-=======================================
-
-Notable improvements and fixes
-------------------------------
-- History-based autosuggestions now include multi-line commands.
-- A :ref:`transient prompt <transient-prompt>` containing more lines than the final prompt will now be cleared properly (:issue:`11875`).
-- Taiwanese Chinese translations have been added.
-- French translations have been supplemented (:issue:`11842`).
-
-Deprecations and removed features
----------------------------------
-- fish now assumes UTF-8 for character encoding even if the system does not have a UTF-8 locale.
-  Input bytes which are not valid UTF-8 are still round-tripped correctly.
-  For example, file paths using legacy encodings can still be used,
-  but may be rendered differently on the command line.
-- On systems where no multi-byte locale is available,
-  fish will no longer fall back to using ASCII replacements for :ref:`Unicode characters <term-compat-unicode-codepoints>` such as "…".
-
-Interactive improvements
-------------------------
-- The title of the terminal tab can now be set separately from the window title by defining the :doc:`fish_tab_title <cmds/fish_tab_title>` function (:issue:`2692`).
-- fish now hides the portion of a multiline prompt that is scrolled out of view due to a huge command line. This prevents duplicate lines after repainting with partially visible prompt (:issue:`11911`).
-- :doc:`fish_config prompt <cmds/fish_config>`'s ``choose`` and ``save`` subcommands have been taught to reset :doc:`fish_mode_prompt <cmds/fish_mode_prompt>` in addition to the other prompt functions (:issue:`11937`).
-- fish no longer force-disables mouse capture (DECSET/DECRST 1000),
-  so you can use those commands
-  to let mouse clicks move the cursor or select completions items (:issue:`4918`).
-- The :kbd:`alt-p` binding no longer adds a redundant space to the command line.
-- When run as a login shell on macOS, fish now sets :envvar:`MANPATH` correctly when that variable was already present in the environment (:issue:`10684`).
-- A Windows-specific case of the :doc:`web-based config <cmds/fish_config>` failing to launch has been fixed (:issue:`11805`).
-- A MSYS2-specific workaround for Konsole and WezTerm has been added,
-  to prevent them from using the wrong working directory when opening new tabs (:issue:`11981`).
-
-For distributors and developers
--------------------------------
-- Release tags and source code tarballs are GPG-signed again (:issue:`11996`).
-- Documentation in release tarballs is now built with the latest version of Sphinx,
-  which means that pre-built man pages include :ref:`OSC 8 hyperlinks <term-compat-osc-8>`.
-- The Sphinx dependency is now specified in ``pyproject.toml``,
-  which allows you to use `uv <https://github.com/astral-sh/uv>`__ to provide Sphinx for building documentation (e.g. ``uv run cargo install --path .``).
-- The minimum supported Rust version (MSRV) has been updated to 1.85.
-- The standalone build mode has been made the default.
-  This means that the files in ``$CMAKE_INSTALL_PREFIX/share/fish`` will not be used anymore, except for HTML docs.
-  As a result, future upgrades will no longer break running shells
-  if one of fish's internal helper functions has been changed in the updated version.
-  For now, the data files are still installed redundantly,
-  to prevent upgrades from breaking already-running shells (:issue:`11921`).
-  To reverse this change (which should not be necessary),
-  patch out the ``embed-data`` feature from ``cmake/Rust.cmake``.
-  This option will be removed in future.
-- OpenBSD 7.8 revealed an issue with fish's approach for displaying builtin man pages, which has been fixed.
-
-Regression fixes:
------------------
-- (from 4.1.0) Fix the :doc:`web-based config <cmds/fish_config>` for Python 3.9 and older (:issue:`12039`).
-- (from 4.1.0) Correct wrong terminal modes set by ``fish -c 'read; cat`` (:issue:`12024`).
-- (from 4.1.0) On VTE-based terminals, stop redrawing the prompt on resize again, to avoid glitches.
-- (from 4.1.0) On MSYS2, fix saving/loading of universal variables (:issue:`11948`).
-- (from 4.1.0) Fix error using ``man`` for the commands ``!`` ``.`` ``:`` ``[`` ``{`` (:issue:`11955`).
-- (from 4.1.0) Fix build issues on illumos systems (:issue:`11982`).
-- (from 4.1.0) Fix crash on invalid :doc:`function <cmds/function>` command (:issue:`11912`).
-- (from 4.0.0) Fix build on SPARC and MIPS Linux by disabling ``SIGSTKFLT``.
-- (from 4.0.0) Fix crash when passing negative PIDs to builtin :doc:`wait <cmds/wait>` (:issue:`11929`).
-- (from 4.0.0) On Linux, fix :doc:`status fish-path <cmds/status>` output when fish has been reinstalled since it was started.
-
-fish 4.1.2 (released October 7, 2025)
-=====================================
-
-This release fixes the following regressions identified in 4.1.0:
-
-- Fixed spurious error output when completing remote file paths for ``scp`` (:issue:`11860`).
-- Fixed the :kbd:`alt-l` binding not formatting ``ls`` output correctly (one entry per line, no colors) (:issue:`11888`).
-- Fixed an issue where focus events (currently only enabled in ``tmux``) would cause multiline prompts to be redrawn in the wrong line (:issue:`11870`).
-- Stopped printing output that would cause a glitch on old versions of Midnight Commander (:issue:`11869`).
-- Added a fix for some configurations of Zellij where :kbd:`escape` key processing was delayed (:issue:`11868`).
-- Fixed a case where the :doc:`web-based configuration tool <cmds/fish_config>` would generate invalid configuration (:issue:`11861`).
-- Fixed a case where pasting into ``fish -c read`` would fail with a noisy error (:issue:`11836`).
-- Fixed a case where upgrading fish would break old versions of fish that were still running.
-
-  In general, fish still needs to be restarted after it is upgraded,
-  except for `standalone builds <https://github.com/fish-shell/fish-shell/?tab=readme-ov-file#building-fish-with-embedded-data-experimental>`__.
-
-fish 4.1.1 (released September 30, 2025)
-========================================
-
-This release fixes the following regressions identified in 4.1.0:
-
-- Many of our new Chinese translations were more confusing than helpful; they have been fixed or removed (:issue:`11833`).
-
-  Note that you can work around this type of issue by configuring fish's :doc:`message localization <cmds/_>`:
-  if your environment contains something like ``LANG=zh_CN.UTF-8``,
-  you can use ``set -g LC_MESSAGES en`` to use English messages inside fish.
-  This will not affect fish's child processes unless ``LC_MESSAGES`` was already exported.
-
-- Some :doc:`fish_config <cmds/fish_config>` subcommands for showing prompts and themes had been broken in standalone Linux builds (those using the ``embed-data`` cargo feature), which has been fixed (:issue:`11832`).
-- On Windows Terminal, we observed an issue where fish would fail to read the terminal's response to our new startup queries, causing noticeable lags and a misleading error message. A workaround has been added (:issue:`11841`).
-- A WezTerm `issue breaking shifted key input <https://github.com/wezterm/wezterm/issues/6087>`__ has resurfaced on some versions of WezTerm; our workaround has been extended to cover all versions for now (:issue:`11204`).
-- Fixed a crash in :doc:`the web-based configuration tool <cmds/fish_config>` when using the new underline styles (:issue:`11840`).
-
-fish 4.1.0 (released September 27, 2025)
-========================================
-
-Notable improvements and fixes
-------------------------------
-- Compound commands (``begin; echo 1; echo 2; end``) can now be written using braces (``{ echo1; echo 2 }``), like in other shells.
-- fish now supports transient prompts: if :envvar:`fish_transient_prompt` is set to 1, fish will reexecute prompt functions with the ``--final-rendering`` argument before running a commandline (:issue:`11153`).
-- Tab completion results are truncated up to the common directory path, instead of somewhere inside that path. E.g. if you complete "share/functions", and it includes the files "foo.fish" and "bar.fish",
-  the completion pager will now show "…/foo.fish" and "…/bar.fish" (:issue:`11250`).
-- Self-installing builds as created by e.g. ``cargo install`` no longer install other files, see :ref:`below <changelog-4.1-embedded>`.
-- Our gettext-based message-localization has been reworked,
-  adding translations to self-installing builds; see :ref:`below <changelog-4.1-gettext>`.
-
-Deprecations and removed features
----------------------------------
-- ``set_color --background=COLOR`` no longer implicitly activates bold mode.
-  If your theme is stored in universal variables (the historical default), some bold formatting might be lost.
-  To fix this, we suggest updating to the latest version of our theme, to explicitly activate bold mode,
-  for example use ``fish_config theme save "fish default"``.
-- ``{echo,echo}`` or ``{ echo, echo }`` are no longer interpreted as brace expansion tokens but as :doc:`compound commands <cmds/begin>`.
-- Terminfo-style key names (``bind -k nul``) are no longer supported. They had been superseded by fish's :doc:`own key names <cmds/bind>` since 4.0 (:issue:`11342`).
-- fish no longer reads the terminfo database, so its behavior is generally no longer affected by the :envvar:`TERM` environment variable (:issue:`11344`).
-  For the time being, this change can be reversed via the ``ignore-terminfo`` :ref:`feature flag <featureflags>`.
-  To do so, run the following once and restart fish::
+- Tokens like ``{ echo, echo }`` in command position are no longer interpreted as brace expansion but as compound command.
+- Terminfo-style key names (``bind -k``) are no longer supported. They had been superseded by the native notation since 4.0,
+  and currently they would map back to information from terminfo, which does not match what terminals would send with the kitty keyboard protocol (:issue:`11342`).
+- fish no longer reads the terminfo database, so its behavior is no longer affected by the :envvar:`TERM` environment variable (:issue:`11344`).
+  For the time being, this can be turned off via the "ignore-terminfo" feature flag::
 
     set -Ua fish_features no-ignore-terminfo
 
-- The ``--install`` option when fish is built as self-installing is removed, see :ref:`below <changelog-4.1-embedded>`.
-- ``set_color ff0000`` now outputs 24-bit RGB true-color even if :envvar:`COLORTERM` is unset.
-  One can override this by setting :envvar:`fish_term24bit` to 0 (:issue:`11372`).
-- fish now requires the terminal to respond to queries for the :ref:`Primary Device Attribute <term-compat-primary-da>`.
-  For now, this can be reversed via a :ref:`feature flag <featureflags>`,
-  by running (once) ``set -Ua fish_features no-query-term`` and restarting fish.
-- Users of GNU screen may experience :ref:`minor glitches <term-compat-dcs-gnu-screen>` when starting fish.
+- The ``--install`` option when fish is built as self-installable was removed. If you need to write out fish's data you can use the new ``status list-files`` and ``status get-file`` subcommands, but it should no longer be necessary. (:issue:`11143`)
+- RGB colors (``set_color ff0000``) now default to using 24-bit RGB true-color commands, even if $COLORTERM is unset, because that is often lost e.g. over ssh (:issue:`11372`)
+
+  - To go back to using the nearest match from the 256-color palette, use ``set fish_term24bit 0`` or set $COLORTERM to a value that is not "24bit" or "truecolor".
+    To make the nearest-match logic use the 16 color palette instead, use ``set fish_term256 0``.
+  - Inside macOS Terminal.app, fish makes an attempt to still use the palette colors.
+    If that doesn't work, use ``set fish_term24bit 0``.
+- ``set_color --background=COLOR`` no longer implicitly activates bold mode.
+  To mitigate this change on existing installations that use a default theme, update your theme with ``fish_config theme choose`` or ``fish_config theme save``.
 
 Scripting improvements
 ----------------------
-- The :doc:`argparse <cmds/argparse>` builtin has seen many improvements, see :ref:`below <changelog-4.1-argparse>`.
-- The :doc:`string pad <cmds/string-pad>` command now has a ``-C/--center`` option.
-- The :doc:`psub <cmds/psub>` command now allows combining ``--suffix`` with ``--fifo`` (:issue:`11729`).
-- The :doc:`read <cmds/read>` builtin has learned the ``--tokenize-raw`` option to tokenize without quote removal (:issue:`11084`).
 
 Interactive improvements
 ------------------------
-- Autosuggestions are now also provided in multi-line command lines. Like :kbd:`ctrl-r`, these operate only on the current line.
-- Autosuggestions used to not suggest multi-line command-lines from history; now autosuggestions include individual lines from multi-line command-lines.
-- The history pager search now preserves ordering between :kbd:`ctrl-s` forward and :kbd:`ctrl-r` backward searches.
-- Instead of highlighting events by flashing *all text to the left of the cursor*,
-  failing history token search (:kbd:`alt-.`) flashes the associated token,
-  failing tab-completion flashes the to-be-completed token (:issue:`11050`),
-  deleting an autosuggestion (:kbd:`shift-delete`) flashes the suggestion,
-  and all other scenarios flash the full command line.
-- Pasted commands are now stripped of any :code:`$\ ` command prefixes, to help pasting code snippets.
-- Builtin help options (e.g. ``abbr --help``) now use ``man`` directly, meaning that variables like :envvar:`MANWIDTH` are respected (:issue:`11786`).
-- ``funced`` will now edit copied functions directly, instead of the file where ``function --copy`` was invoked. (:issue:`11614`)
-- Added a simple ``fish_jj_prompt`` which reduces visual noise in the prompt inside `Jujutsu <https://jj-vcs.github.io/jj/latest/>`__ repositories that are colocated with Git.
+- Autosuggestions are now also provided in multi-line command lines. Like `ctrl-r`, autosuggestions operate only on the current line.
+- Autosuggestions used to not suggest multi-line commandlines from history; now autosuggestions include individual lines from multi-line command lines.
+- The history search now preserves ordering between :kbd:`ctrl-s` forward and :kbd:`ctrl-r` backward searches.
+- Left mouse click (as requested by `click_events <terminal-compatibility.html#click-events>`__) can now select pager items (:issue:`10932`).
+- Instead of flashing all the text to the left of the cursor, fish now flashes the matched token during history token search, the completed token during completion (:issue:`11050`), the autosuggestion when deleting it, and the full command line in all other cases.
+- Pasted commands are now stripped of any ``$`` prefix.
 
 New or improved bindings
 ^^^^^^^^^^^^^^^^^^^^^^^^
-- On non-macOS systems, :kbd:`alt-left`, :kbd:`alt-right`, :kbd:`alt-backspace` and :kbd:`alt-delete` no longer operate on punctuation-delimited words but on whole arguments, possibly including special characters like ``/`` and quoted spaces.
+- On non-macOS systems, :kbd:`alt-left`, :kbd:`alt-right`, :kbd:`alt-backspace`, :kbd:`alt-delete` no longer operate on punctuation-delimited words but on whole arguments, possibly including special characters like ``/`` and quoted spaces.
   On macOS, the corresponding :kbd:`ctrl-` prefixed keys operate on whole arguments.
-  Word operations are still available via the other respective modifier, just like in most web browsers.
+  Word operations are still available via the other respective modifier, same as in the browser.
 - :kbd:`ctrl-z` (undo) after executing a command will restore the previous cursor position instead of placing the cursor at the end of the command line.
-- The :kbd:`alt-s` binding will now also use ``run0`` if available.
-- Some mouse support has been added: the OSC 133 prompt marking feature has learned about kitty's ``click_events=1`` flag, which allows moving fish's cursor by clicking in the command line,
-  and selecting pager items (:issue:`10932`).
-- Before clearing the screen and redrawing, :kbd:`ctrl-l` now pushes all text located above the prompt to the terminal's scrollback,
-  via a new special input function :ref:`scrollback-push <special-input-functions-scrollback-push>`.
-  For compatibility with terminals that do not implement ECMA-48's :ref:`SCROLL UP <term-compat-indn>` command,
-  this function is only used if the terminal advertises support for that via :ref:`XTGETTCAP <term-compat-xtgettcap>`.
-- Vi mode has learned :kbd:`ctrl-a` (increment) and :kbd:`ctrl-x` (decrement) (:issue:`11570`).
+- The OSC 133 prompt marking feature has learned about kitty's ``click_events=1`` flag, which allows moving fish's cursor by clicking.
+- :kbd:`ctrl-l` now pushes all text located above the prompt to the terminal's scrollback, before clearing and redrawing the screen (via a new special input function ``scrollback-push``).
+  For compatibility with terminals that do not provide the scroll-forward command,
+  this is only enabled by default if the terminal advertises support for the ``indn`` capability via XTGETTCAP.
+- Bindings using shift with non-ASCII letters (such as :kbd:`ctrl-shift-ä`) are now supported.
+  If there is any modifier other than shift, this is the recommended notation (as opposed to :kbd:`ctrl-Ä`).
 
 Completions
 ^^^^^^^^^^^
-- ``git`` completions now show the remote URL as description when completing remotes.
-- ``systemctl`` completions no longer print escape codes if ``SYSTEMD_COLORS`` happens to be set (:issue:`11465`).
-- Added and improved many completion scripts, notably ``tmux``.
 
 Improved terminal support
 ^^^^^^^^^^^^^^^^^^^^^^^^^
-- Support for double, curly, dotted and dashed underlines, for use in ``fish_color_*`` variables and the :doc:`set_color builtin <cmds/set_color>` (:issue:`10957`).
+- Support for curly underlines in `fish_color_*` variables and :doc:`set_color <cmds/set_color>` (:issue:`10957`).
 - Underlines can now be colored independent of text (:issue:`7619`).
-- New documentation page :doc:`Terminal Compatibility <terminal-compatibility>` (also accessible via ``man fish-terminal-compatibility``) lists the terminal control sequences used by fish.
+- Errors are now highlighted with curly underlines in the default themes.
+  For compatibility with terminals that interpret the curly-underline escape sequence in an unexpected way,
+  the default themes enable this only if the terminal advertises support for the ``Su`` capability via XTGETTCAP.
+- New documentation page `Terminal Compatibility <terminal-compatibility.html>`_ (also accessible via ``man fish-terminal-compatibility``) lists required and optional terminal control sequences used by fish.
+- :doc:`status <cmds/status>` learned the ``xtgettcap`` subcommand, to query terminfo capabilities via XTGETTCAP commands.
+- :doc:`status <cmds/status>` learned the ``xtversion`` subcommand, to show the terminal's name and version (as reported by via the XTVERSION command).
 
 Other improvements
 ------------------
-- Updated Chinese and German translations.
+- ``fish_indent`` and ``fish_key_reader`` are now available as builtins, and if fish is called with that name it will act like the given tool (as a multi-call binary).
+  This allows truly distributing fish as a single file. (:issue:`10876`)
 - ``fish_indent --dump-parse-tree`` now emits simple metrics about the tree including its memory consumption.
-- We added some tools to improve development workflows, for example ``build_tools/{check,update_translations,release}.sh`` and ``tests/test_driver.py``.
-  In conjunction with ``cargo``, these enable almost all day-to-day development tasks without using CMake.
 
 For distributors
 ----------------
-- Builtin commands that support the ``--help`` option now require the ``man`` program.
-  The direct dependency on ``mandoc`` and ``nroff`` has been removed.
-- fish no longer uses gettext MO files, see :ref:`below <changelog-4.1-gettext>`.
-  If you have use cases which are incompatible with our new approach, please let us know.
-- The :doc:`fish_indent <cmds/fish_indent>` and :doc:`fish_key_reader <cmds/fish_key_reader>` programs are now also available as builtins.
-  If fish is invoked via e.g. a symlink with one of these names,
-  it will act like the given tool (i.e. it's a multi-call binary).
-  This allows truly distributing fish as a single file (:issue:`10876`).
-- The CMake build configuration has been simplified and no longer second-guesses rustup.
-  It will run rustc and cargo via :envvar:`PATH` or in ~/.cargo/bin/.
-  If that doesn't match your setup, set the Rust_COMPILER and Rust_CARGO CMake variables (:issue:`11328`).
-- Cygwin support has been reintroduced, since `Rust gained a Cygwin target <https://github.com/rust-lang/rust/pull/134999>`__ (:issue:`11238`).
-- CMake 3.15 is now required.
-
-.. _changelog-4.1-embedded:
-
-Changes to self-installing builds
----------------------------------
-
-The self-installing build type introduced in fish 4.0 has been changed (:issue:`11143`).
-Now fish built with embedded data will just read the data straight from its own binary or write it out to temporary files when necessary, instead of requiring an installation step on start.
-That means it is now possible to build fish as a single file and copy it to any system with a compatible CPU architecture, including as a different user, without extracting any files.
-As before, this is the default when building via ``cargo``, and disabled when building via CMake.
-For packagers we continue to recommend CMake.
-
-Note: When fish is built like this, the :envvar:`__fish_data_dir` variable will be empty because that directory no longer has meaning.
-You should generally not need these files.
-For example, if you want to make sure that completions for "foo" are loaded, use ``complete -C"foo " >/dev/null``  instead).
-The raw files are still exposed via :ref:`status subcommands <status-get-file>`, mainly for fish's internal use, but you can also use them as a last resort.
-
-Remaining benefits of a full installation (as currently done by CMake) are:
-
-- man pages like ``fish(1)`` in standard locations, easily accessible from outside fish.
-- a local copy of the HTML documentation, typically accessed via the :doc:`help <cmds/help>` function.
-  In builds with embedded data, ``help`` will redirect to e.g. `<https://fishshell.com/docs/current/>`__
-- ``fish_indent`` and ``fish_key_reader`` as separate files, making them easily accessible outside fish
-- an (empty) ``/etc/fish/config.fish`` as well as empty directories ``/etc/fish/{functions,completions,conf.d}``
-- ``$PREFIX/share/pkgconfig/fish.pc``, which defines directories for configuration-snippets, like ``vendor_completions.d``
-
-.. _changelog-4.1-gettext:
-
-Changes to gettext localization
--------------------------------
-
-We replaced several parts of the gettext functionality with custom implementations (:issue:`11726`).
-Most notably, message extraction, which should now work reliably, and the runtime implementation, where we no longer dynamically link to gettext, but instead use our own implementation, whose behavior is similar to GNU gettext, with some :doc:`minor deviations <cmds/_>`.
-Our implementation now fully respects fish variables, so locale variables do not have to be exported for fish localizations to work.
-They still have to be exported to inform other programs about language preferences.
-The :envvar:`LANGUAGE` environment variable is now treated as a path variable, meaning it is an implicitly colon-separated list.
-While we no longer have any runtime dependency on gettext, we still need gettext tools for building, most notably ``msgfmt``.
-When building without ``msgfmt`` available, localization will not work with the resulting executable.
-Localization data is no longer sourced at runtime from MO files on the file system, but instead built into the executable.
-This is always done, independently of the other data embedding, so all fish executables will have access to all message catalogs, regardless of the state of the file system.
-Disabling our new ``localize-messages`` cargo feature will cause fish to be built without localization support.
-CMake builds can continue to use the ``WITH_GETTEXT`` option, with the same semantics as the ``localize-messages`` feature.
-The current implementation does not provide any configuration options for controlling which language catalogs are built into the executable (other than disabling them all).
-As a workaround, you can delete files in the ``po`` directory before building to exclude unwanted languages.
-
-.. _changelog-4.1-argparse:
-
-Changes to the :doc:`argparse <cmds/argparse>` builtin
-------------------------------------------------------
-
-- ``argparse`` now saves recognised options, including option-arguments in :envvar:`argv_opts`, allowing them to be forwarded to other commands (:issue:`6466`).
-- ``argparse`` options can now be marked to be deleted from :envvar:`argv_opts` (by adding a ``&`` at the end of the option spec, before a ``!`` if present). There is now also a corresponding ``-d`` / ``--delete`` option to ``fish_opt``.
-- ``argparse --ignore-unknown`` now removes preceding known short options from groups containing unknown options (e.g. when parsing ``-abc``, if ``a`` is known but ``b`` is not, then :envvar:`argv` will contain ``-bc``).
-- ``argparse`` now has an ``-u`` / ``--move-unknown`` option that works like ``--ignore-unknown`` but preserves unknown options in :envvar:`argv`.
-- ``argparse`` now has an ``-S`` / ``--strict-longopts`` option that forbids abbreviating long options or passing them with a single dash (e.g. if there is a long option called ``foo``, ``--fo`` and ``--foo`` won't match it).
-- ``argparse`` now has a ``-U`` / ``--unknown-arguments`` option to specify how to parse unknown option's arguments.
-- ``argparse`` now allows specifying options that take multiple optional values by using ``=*`` in the option spec (:issue:`8432`).
-  In addition, ``fish_opt`` has been modified to support such options by using the ``--multiple-vals`` together with ``-o`` / ``--optional-val``; ``-m`` is also now acceptable as an abbreviation for ``--multiple-vals``.
-- ``fish_opt`` no longer requires you give a short flag name when defining options, provided you give it a long flag name with more than one character.
-- ``argparse`` option specifiers for long-only options can now start with ``/``, allowing the definition of long options with a single letter. Due to this change, the ``--long-only`` option to ``fish_opt`` is now no longer necessary and is deprecated.
-- ``fish_opt`` now has a ``-v`` / ``--validate`` option you can use to give a fish script to validate values of the option.
-
---------------
-
-fish 4.0.9 (released September 27, 2025)
-========================================
-
-This release fixes:
-
-- a regression in 4.0.6 causing shifted keys to not be inserted on some terminals (:issue:`11813`).
-- a regression in 4.0.6 causing the build to fail on systems where ``char`` is unsigned (:issue:`11804`).
-- a regression in 4.0.0 causing a crash on an invalid :doc:`bg <cmds/bg>` invocation.
-
---------------
-
-fish 4.0.8 (released September 18, 2025)
-========================================
-
-This release fixes a regression in 4.0.6 that caused user bindings to be shadowed by either fish's or a plugin's bindings (:issue:`11803`).
-
---------------
-
-fish 4.0.6 (released September 12, 2025)
-========================================
-
-This release of fish fixes a number of issues identified in fish 4.0.2:
-
-- fish now properly inherits $PATH under Windows WSL2 (:issue:`11354`).
-- Remote filesystems are detected properly again on non-Linux systems.
-- the :doc:`printf <cmds/printf>` builtin no longer miscalculates width of multi-byte characters (:issue:`11412`).
-- For many years, fish has been "relocatable" -- it was possible to move the entire ``CMAKE_INSTALL_PREFIX`` and fish would use paths relative to its binary.
-  Only gettext locale paths were still determined purely at compile time, which has been fixed.
-- the :doc:`commandline <cmds/commandline>` builtin failed to print the commandline set by a ``commandline -C`` invocation, which broke some completion scripts.
-  This has been corrected (:issue:`11423`).
-- To work around terminals that fail to parse Operating System Command (OSC) sequences, a temporary feature flag has been added.
-  It allows you to disable prompt marking (OSC 133) by running (once) ``set -Ua fish_features no-mark-prompt`` and restarting fish (:issue:`11749`).
-- The routines to save history and universal variables have seen some robustness improvements.
-- builtin :doc:`status current-command <cmds/status>` no longer prints a trailing blank line.
-- A crash displaying multi-line quoted command substitutions has been fixed (:issue:`11444`).
-- Commands like ``set fish_complete_path ...`` accidentally disabled completion autoloading, which has been corrected.
-- ``nmcli`` completions have been fixed to query network information dynamically instead of only when completing the first time.
-- Git completions no longer print an error when no `git-foo` executable is in :envvar:`PATH`.
-- Custom completions like ``complete foo -l long -xa ...`` that use the output of ``commandline -t``.
-  on a command-line like ``foo --long=`` have been invalidated by a change in 4.0; the completion scripts have been adjusted accordingly (:issue:`11508`).
-- Some completions were misinterpreted, which caused garbage to be displayed in the completion list. This has been fixed.
-- fish no longer interprets invalid control sequences from the terminal as if they were :kbd:`alt-[` or :kbd:`alt-o` key strokes.
-- :doc:`bind <cmds/bind>` has been taught about the :kbd:`printscreen` and :kbd:`menu` keys.
-- :kbd:`alt-delete` now deletes the word right of the cursor.
-- :kbd:`ctrl-alt-h` erases the last word again (:issue:`11548`).
-- :kbd:`alt-left` :kbd:`alt-right` were misinterpreted because they send unexpected sequences on some terminals; a workaround has been added.  (:issue:`11479`).
-- Key bindings like ``bind shift-A`` are no longer accepted; use ``bind shift-a`` or ``bind A``.
-- Key bindings like ``bind shift-a`` take precedence over ``bind A`` when the key event included the shift modifier.
-- Bindings using shift with non-ASCII letters (such as :kbd:`ctrl-shift-ä`) are now supported.
-- Bindings with modifiers such as ``bind ctrl-w`` work again on non-Latin keyboard layouts such as a Russian one.
-  This is implemented by allowing key events such as :kbd:`ctrl-ц` to match bindings of the corresponding Latin key, using the kitty keyboard protocol's base layout key (:issue:`11520`).
-- Vi mode: The cursor position after pasting via :kbd:`p` has been corrected.
-- Vi mode: Trying to replace the last character via :kbd:`r` no longer replaces the last-but-one character (:issue:`11484`).
+- ``fish_indent`` and ``fish_key_reader`` are still built as separate binaries for now, but can also be replaced with a symlink if you want to save disk space (:issue:`10876`).
+- The CMake system was simplified and no longer second-guesses rustup. It will run rustc and cargo via $PATH or in ~/.cargo/bin/.
+  If that doesn't match your setup, set the Rust_COMPILER and Rust_CARGO cmake variables (:issue:`11328`).
+- Cygwin support has been reintroduced, since rust gained a Cygwin target (https://github.com/rust-lang/rust/pull/134999, :issue:`11238`).
 
 --------------
 
@@ -634,7 +100,7 @@ This release of fish fixes a number of issues identified in fish 4.0.1:
 - The warning when the terminfo database can't be found has been downgraded to a log message. fish will act as if the terminal behaves like xterm-256color, which is correct for the vast majority of cases (:issue:`11277`, :issue:`11290`).
 - Key combinations using the super (Windows/command) key can now (actually) be bound using the :kbd:`super-` prefix (:issue:`11217`). This was listed in the release notes for 4.0.1 but did not work correctly.
 - :doc:`function <cmds/function>` is stricter about argument parsing, rather than allowing additional parameters to be silently ignored (:issue:`11295`).
-- Using parentheses in the :doc:`test <cmds/test>` builtin works correctly, following a regression in 4.0.0 where they were not recognized (:issue:`11387`).
+- Using parentheses in the :doc:`test <cmds/test>` builtin works correctly, following a regression in 4.0.0 where they were not recognized (:issue:`11387`). 
 - :kbd:`delete` in Vi mode when Num Lock is active will work correctly (:issue:`11303`).
 - Abbreviations cannot alter the command-line contents, preventing a crash (:issue:`11324`).
 - Improvements to various completions, including new completions for ``wl-randr`` (:issue:`11301`), performance improvements for ``cargo`` completions by avoiding network requests (:issue:`11347`), and other improvements for  ``btrfs`` (:issue:`11320`), ``cryptsetup`` (:issue:`11315`), ``git`` (:issue:`11319`, :issue:`11322`, :issue:`11323`), ``jj`` (:issue:`11046`), and ``systemd-analyze`` (:issue:`11314`).
@@ -684,7 +150,7 @@ Notable backwards-incompatible changes
 
 - As part of a larger binding rework, ``bind`` gained a new key notation.
   In most cases the old notation should keep working, but in rare cases you may have to change a ``bind`` invocation to use the new notation.
-  See :ref:`below <changelog-4.0-new-bindings>` for details.
+  See :ref:`below <changelog-new-bindings>` for details.
 - :kbd:`ctrl-c` now calls a new bind function called ``clear-commandline``. The old behavior, which leaves a "^C" marker, is available as ``cancel-commandline`` (:issue:`10935`)
 - ``random`` will produce different values from previous versions of fish when used with the same seed, and will work more sensibly with small seed numbers.
   The seed was never guaranteed to give the same result across systems,
@@ -706,7 +172,7 @@ Notable backwards-incompatible changes
 
 Notable improvements and fixes
 ------------------------------
-.. _changelog-4.0-new-bindings:
+.. _changelog-new-bindings:
 
 -  fish now requests XTerm's ``modifyOtherKeys`` keyboard encoding and `kitty keyboard protocol's <https://sw.kovidgoyal.net/kitty/keyboard-protocol/>`_ progressive enhancements (:issue:`10359`).
    Depending on terminal support, this allows to binding more key combinations, including arbitrary combinations of modifiers :kbd:`ctrl`, :kbd:`alt` and :kbd:`shift`, and distinguishing (for example) :kbd:`ctrl-i` from :kbd:`tab`.
@@ -837,7 +303,7 @@ Interactive improvements
 New or improved bindings
 ^^^^^^^^^^^^^^^^^^^^^^^^
 - When the cursor is on a command that resolves to an executable script, :kbd:`alt-o` will now open that script in your editor (:issue:`10266`).
-- During up-arrow history search, :kbd:`shift-delete` will delete the current search item and move to the next older item. Previously this was only supported in the history pager.
+- During up-arrow history search, :kbd:`shift-delete` will delete the current search item and move to the next older item. Previously this was only supported in the history pager. 
 - :kbd:`shift-delete` will also remove the currently-displayed autosuggestion from history, and remove it as a suggestion.
 - :kbd:`ctrl-Z` (also known as :kbd:`ctrl-shift-z`) is now bound to redo.
 - Some improvements to the :kbd:`alt-e` binding which edits the command line in an external editor:
@@ -849,7 +315,7 @@ New or improved bindings
 - Bindings like :kbd:`alt-l` that print output in between prompts now work correctly with multiline commandlines.
 - :kbd:`alt-d` on an empty command line lists the directory history again. This restores the behavior of version 2.1.
 - ``history-prefix-search-backward`` and ``-forward`` now maintain the cursor position, instead of moving the cursor to the end of the command line (:issue:`10430`).
-- The following keys have refined behavior if the terminal supports :ref:`the new keyboard encodings <changelog-4.0-new-bindings>`:
+- The following keys have refined behavior if the terminal supports :ref:`the new keyboard encodings <changelog-new-bindings>`:
 
   - :kbd:`shift-enter` now inserts a newline instead of executing the command line.
   - :kbd:`ctrl-backspace` now deletes the last word instead of only one character (:issue:`10741`).
@@ -908,7 +374,7 @@ Improved terminal support
 
 Other improvements
 ------------------
-- ``status`` gained a ``build-info`` subcommand, to print information on how fish was built, to help with debugging (:issue:`10896`).
+- ``status`` gained a ``buildinfo`` subcommand, to print information on how fish was built, to help with debugging (:issue:`10896`).
 - ``fish_indent`` will now collapse multiple empty lines into one (:issue:`10325`).
 - ``fish_indent`` now preserves the modification time of files if there were no changes (:issue:`10624`).
 - Performance in launching external processes has been improved for many cases (:issue:`10869`).
@@ -1223,7 +689,7 @@ Notable improvements and fixes
 
   which expands ``!!`` to the last history item, anywhere on the command line, mimicking other shells' history expansion.
 
-  See :doc:`the documentation <cmds/abbr>` for more.
+  See :ref:`the documentation <cmd-abbr>` for more.
 - ``path`` gained a new ``mtime`` subcommand to print the modification time stamp for files. For example, this can be used to handle cache file ages (:issue:`9057`)::
 
     > touch foo
@@ -1467,7 +933,7 @@ Deprecations and removed features
 
   Like ``stderr-nocaret``, they will eventually be made read-only.
 - Most ``string`` subcommands no longer append a newline to their input if the input didn't have one (:issue:`8473`, :issue:`3847`)
-- fish's escape sequence removal (like for ``string length --visible`` or to figure out how wide the prompt is) no longer has special support for non-standard color sequences like from Data General terminals, e.g. the Data General Dasher D220 from 1984. This removes a bunch of work in the common case, allowing ``string length --visible`` to be much faster with unknown escape sequences. We don't expect anyone to have ever used fish with such a terminal (:issue:`8769`).
+- Fish's escape sequence removal (like for ``string length --visible`` or to figure out how wide the prompt is) no longer has special support for non-standard color sequences like from Data General terminals, e.g. the Data General Dasher D220 from 1984. This removes a bunch of work in the common case, allowing ``string length --visible`` to be much faster with unknown escape sequences. We don't expect anyone to have ever used fish with such a terminal (:issue:`8769`).
 - Code to upgrade universal variables from fish before 3.0 has been removed. Users who upgrade directly from fish versions 2.7.1 or before will have to set their universal variables & abbreviations again. (:issue:`8781`)
 - The meaning of an empty color variable has changed (:issue:`8793`). Previously, when a variable was set but empty, it would be interpreted as the "normal" color. Now, empty color variables cause the same effect as unset variables - the general highlighting variable for that type is used instead. For example::
 
@@ -1478,14 +944,14 @@ Deprecations and removed features
 
   This makes it easier to make self-contained color schemes that don't accidentally use color that was set before.
   ``fish_config`` has been adjusted to set known color variables that a theme doesn't explicitly set to empty.
-- ``eval`` is now a reserved keyword, so it can't be used as a function name. This follows ``set`` and ``read``, and is necessary because it can't be cleanly shadowed by a function - at the very least ``eval set -l argv foo`` breaks. fish will ignore autoload files for it, so left over ``eval.fish`` from previous fish versions won't be loaded.
+- ``eval`` is now a reserved keyword, so it can't be used as a function name. This follows ``set`` and ``read``, and is necessary because it can't be cleanly shadowed by a function - at the very least ``eval set -l argv foo`` breaks. Fish will ignore autoload files for it, so left over ``eval.fish`` from previous fish versions won't be loaded.
 - The git prompt in informative mode now defaults to skipping counting untracked files, as this was extremely slow. To turn it on, set :envvar:`__fish_git_prompt_showuntrackedfiles` or set the git config value "bash.showuntrackedfiles" to ``true`` explicitly (which can be done for individual repositories). The "informative+vcs" sample prompt already skipped display of untracked files, but didn't do so in a way that skipped the computation, so it should be quite a bit faster in many cases (:issue:`8980`).
 - The ``__terlar_git_prompt`` function, used by the "Terlar" sample prompt, has been rebuilt as a configuration of the normal ``fish_git_prompt`` to ease maintenance, improve performance and add features (like reading per-repo git configuration). Some slight changes remain; users who absolutely must have the same behavior are encouraged to copy the old function (:issue:`9011`, :issue:`7918`, :issue:`8979`).
 
 Scripting improvements
 ----------------------
 - Quoted command substitution that directly follow a variable expansion (like ``echo "$var$(echo x)"``) no longer affect the variable expansion (:issue:`8849`).
-- fish now correctly expands command substitutions that are preceded by an escaped dollar (like ``echo \$(echo)``). This regressed in version 3.4.0.
+- Fish now correctly expands command substitutions that are preceded by an escaped dollar (like ``echo \$(echo)``). This regressed in version 3.4.0.
 - ``math`` can now handle underscores (``_``) as visual separators in numbers (:issue:`8611`, :issue:`8496`)::
 
     math 5 + 2_123_252
@@ -1505,7 +971,7 @@ Scripting improvements
 
 Interactive improvements
 ------------------------
-- fish now reports a special error if a command wasn't found and there is a non-executable file by that name in :envvar:`PATH` (:issue:`8804`).
+- Fish now reports a special error if a command wasn't found and there is a non-executable file by that name in :envvar:`PATH` (:issue:`8804`).
 - ``less`` and other interactive commands would occasionally be stopped when run in a pipeline with fish functions; this has been fixed (:issue:`8699`).
 - Case-changing autosuggestions generated mid-token now correctly append only the suffix, instead of duplicating the token (:issue:`8820`).
 - ``ulimit`` learned a number of new options for the resource limits available on Linux, FreeBSD ande NetBSD, and returns a specific warning if the limit specified is not available on the active operating system (:issue:`8823`, :issue:`8786`).
@@ -1515,9 +981,9 @@ Interactive improvements
 - Since fish 3.2.0, pressing :kbd:`ctrl-d` while a command is running would end up inserting a space into the next commandline, which has been fixed (:issue:`8871`).
 - A bug that caused multi-line prompts to be moved down a line when pasting or switching modes has been fixed (:issue:`3481`).
 - The Web-based configuration system no longer strips too many quotes in the abbreviation display (:issue:`8917`, :issue:`8918`).
-- fish started with ``--no-config`` will now use the default keybindings (:issue:`8493`)
+- Fish started with ``--no-config`` will now use the default keybindings (:issue:`8493`)
 - When fish inherits a :envvar:`USER` environment variable value that doesn't correspond to the current effective user ID, it will now correct it in all cases (:issue:`8879`, :issue:`8583`).
-- fish sets a new :envvar:`EUID` variable containing the current effective user id (:issue:`8866`).
+- Fish sets a new :envvar:`EUID` variable containing the current effective user id (:issue:`8866`).
 - ``history search`` no longer interprets the search term as an option (:issue:`8853`)
 - The status message when a job terminates should no longer be erased by a multiline prompt (:issue:`8817`)
 
@@ -1648,7 +1114,7 @@ Scripting improvements
     two
     'blue '
 
-- ``$fish_user_paths`` is now automatically deduplicated to fix a common user error of appending to it in config.fish when it is universal (:issue:`8117`). :doc:`fish_add_path <cmds/fish_add_path>` remains the recommended way to add to $PATH.
+- ``$fish_user_paths`` is now automatically deduplicated to fix a common user error of appending to it in config.fish when it is universal (:issue:`8117`). :ref:`fish_add_path <cmd-fish_add_path>` remains the recommended way to add to $PATH.
 - ``return`` can now be used outside functions. In scripts, it does the same thing as ``exit``. In interactive mode,it sets ``$status`` without exiting (:issue:`8148`).
 - An oversight prevented all syntax checks from running on commands given to ``fish -c`` (:issue:`8171`). This includes checks such as ``exec`` not being allowed in a pipeline, and ``$$`` not being a valid variable. Generally, another error was generated anyway.
 - ``fish_indent`` now correctly reformats tokens that end with a backslash followed by a newline (:issue:`8197`).
@@ -1778,7 +1244,7 @@ Improved terminal support
 
 Other improvements
 ------------------
-- fish's test suite now uses ``ctest``, and has become much faster to run. It is now also possible to run only specific tests with targets named ``test_$filename`` - ``make test_set.fish`` only runs the set.fish test. (:issue:`7851`)
+- Fish's test suite now uses ``ctest``, and has become much faster to run. It is now also possible to run only specific tests with targets named ``test_$filename`` - ``make test_set.fish`` only runs the set.fish test. (:issue:`7851`)
 - The HTML version of the documentation now includes copy buttons for code examples (:issue:`8218`).
 - The HTML version of the documentation and the web-based configuration tool now pick more modern system fonts instead of falling back to Arial and something like Courier New most of the time (:issue:`8632`).
 - The Debian & Ubuntu package linked from fishshell.com is now a single package, rather than split into ``fish`` and ``fish-common`` (:issue:`7845`).
@@ -3377,7 +2843,7 @@ Other fixes and improvements
    variables (:issue:`4200`, :issue:`4341`), executing functions, globs (:issue:`4579`),
    ``string`` reading from standard input (:issue:`4610`), and slicing history
    (in particular, ``$history[1]`` for the last executed command).
--  fish’s internal wcwidth function has been updated to deal with newer
+-  Fish’s internal wcwidth function has been updated to deal with newer
    Unicode, and the width of some characters can be configured via the
    ``fish_ambiguous_width`` (:issue:`5149`) and ``fish_emoji_width`` (:issue:`2652`)
    variables. Alternatively, a new build-time option INTERNAL_WCWIDTH
@@ -3414,7 +2880,7 @@ For distributors and developers
    standard sh instead.
 -  The ``hostname`` command is no longer required for fish to operate.
 
--
+–
 
 fish 2.7.1 (released December 23, 2017)
 =======================================
@@ -3426,7 +2892,7 @@ session (:issue:`4521`).
 If you are upgrading from version 2.6.0 or before, please also review
 the release notes for 2.7.0 and 2.7b1 (included below).
 
--
+–
 
 fish 2.7.0 (released November 23, 2017)
 =======================================
@@ -3438,7 +2904,7 @@ from version 2.6.0 or before, please also review the release notes for
 Xcode builds and macOS packages could not be produced with 2.7b1, but
 this is fixed in 2.7.0.
 
--
+–
 
 fish 2.7b1 (released October 31, 2017)
 ======================================
@@ -4133,13 +3599,13 @@ Backward-incompatible changes
 Other notable fixes and improvements
 ------------------------------------
 
--  fish no longer silences errors in config.fish (:issue:`2702`)
+-  Fish no longer silences errors in config.fish (:issue:`2702`)
 -  Directory autosuggestions will now descend as far as possible if
    there is only one child directory (:issue:`2531`)
 -  Add support for bright colors (:issue:`1464`)
 -  Allow Ctrl-J (``\cj``) to be bound separately from Ctrl-M
    (``\cm``) (:issue:`217`)
--  psub now has a “-s”/“-suffix” option to name the temporary file with
+-  psub now has a “-s”/“–suffix” option to name the temporary file with
    that suffix
 -  Enable 24-bit colors on select terminals (:issue:`2495`)
 -  Support for SVN status in the prompt (:issue:`2582`)
@@ -4163,13 +3629,13 @@ Other notable fixes and improvements
       systemd-analyze, localectl, timedatectl
    -  and more
 
--  fish no longer has a function called sgrep, freeing it for user
+-  Fish no longer has a function called sgrep, freeing it for user
    customization (:issue:`2245`)
 -  A rewrite of the completions for cd, fixing a few bugs (:issue:`2299`, :issue:`2300`,
    :issue:`562`)
 -  Linux VTs now run in a simplified mode to avoid issues (:issue:`2311`)
 -  The vi-bindings now inherit from the emacs bindings
--  fish will also execute ``fish_user_key_bindings`` when in vi-mode
+-  Fish will also execute ``fish_user_key_bindings`` when in vi-mode
 -  ``funced`` will now also check $VISUAL (:issue:`2268`)
 -  A new ``suspend`` function (:issue:`2269`)
 -  Subcommand completion now works better with split /usr (:issue:`2141`)
@@ -4238,7 +3704,7 @@ Other notable fixes and improvements
 
 -  New documentation design (:issue:`1662`), which requires a Doxygen version
    1.8.7 or newer to build.
--  fish now defines a default directory for other packages to provide
+-  Fish now defines a default directory for other packages to provide
    completions. By default this is
    ``/usr/share/fish/vendor-completions.d``; on systems with
    ``pkgconfig`` installed this path is discoverable with
@@ -4529,7 +3995,7 @@ Other Notable Fixes
 -  xsel is no longer built as part of fish. It will still be invoked if
    installed separately :issue:`633`
 -  \__fish_filter_mime no longer spews :issue:`628`
--  The -no-execute option to fish no longer falls over when reaching the
+-  The –no-execute option to fish no longer falls over when reaching the
    end of a block :issue:`624`
 -  fish_config knows how to find fish even if it’s not in the $PATH :issue:`621`
 -  A leading space now prevents writing to history, as is done in bash

CMakeLists.txt

@@ -15,6 +15,8 @@ endif()
 # Set up standard directories.
 include(GNUInstallDirs)
 
+include(cmake/gettext.cmake)
+
 # Set up PCRE2
 # This sets an environment variable that needs to be available before the Rust stanzas
 include(cmake/PCRE2.cmake)
@@ -24,26 +26,9 @@ include(cmake/Rust.cmake)
 # Work around issue where archive-built libs go in the wrong place.
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
 
-find_program(SPHINX_EXECUTABLE NAMES sphinx-build
-    HINTS
-    $ENV{SPHINX_DIR}
-    PATH_SUFFIXES bin
-    DOC "Sphinx documentation generator")
-
-
-# Tell Cargo where our build directory is so it can find Cargo.toml.
-set(VARS_FOR_CARGO
-    "FISH_CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR}"
-    "PREFIX=${CMAKE_INSTALL_PREFIX}"
-    "DOCDIR=${CMAKE_INSTALL_FULL_DOCDIR}"
-    "DATADIR=${CMAKE_INSTALL_FULL_DATADIR}"
-    "SYSCONFDIR=${CMAKE_INSTALL_FULL_SYSCONFDIR}"
-    "BINDIR=${CMAKE_INSTALL_FULL_BINDIR}"
-    "CARGO_TARGET_DIR=${FISH_RUST_BUILD_DIR}"
-    "CARGO_BUILD_RUSTC=${Rust_COMPILER}"
-    "${FISH_PCRE2_BUILDFLAG}"
-    "FISH_SPHINX=${SPHINX_EXECUTABLE}"
-)
+# Set up the machinery around FISH-BUILD-VERSION-FILE
+# This defines the FBVF variable.
+include(Version)
 
 # Let fish pick up when we're running out of the build directory without installing
 get_filename_component(REAL_CMAKE_BINARY_DIR "${CMAKE_BINARY_DIR}" REALPATH)
@@ -53,43 +38,40 @@ add_definitions(-DCMAKE_SOURCE_DIR="${REAL_CMAKE_SOURCE_DIR}")
 
 set(build_types Release RelWithDebInfo Debug "")
 if(NOT "${CMAKE_BUILD_TYPE}" IN_LIST build_types)
-    message(WARNING "Unsupported build type ${CMAKE_BUILD_TYPE}. If this doesn't build, try one of Release, RelWithDebInfo or Debug")
+  message(WARNING "Unsupported build type ${CMAKE_BUILD_TYPE}. If this doesn't build, try one of Release, RelWithDebInfo or Debug")
 endif()
 
-add_custom_target(
-    fish ALL
+# Define a function to build and link dependencies.
+function(CREATE_TARGET target)
+  add_custom_target(
+    ${target} ALL
     COMMAND
-        "${CMAKE_COMMAND}" -E
-            env ${VARS_FOR_CARGO}
-                ${Rust_CARGO}
-                    build --bin fish
-                    $<$<CONFIG:Release>:--release>
-                    $<$<CONFIG:RelWithDebInfo>:--profile=release-with-debug>
-                    --target ${Rust_CARGO_TARGET}
-                    --no-default-features
-                    --features=${FISH_CARGO_FEATURES}
-                    ${CARGO_FLAGS}
-        &&
-        "${CMAKE_COMMAND}" -E
-            copy "${rust_target_dir}/${rust_profile}/fish" "${CMAKE_CURRENT_BINARY_DIR}"
+      "${CMAKE_COMMAND}" -E
+        env ${VARS_FOR_CARGO}
+          ${Rust_CARGO}
+            build --bin ${target}
+            $<$<CONFIG:Release>:--release>
+            $<$<CONFIG:RelWithDebInfo>:--profile=release-with-debug>
+            --target ${Rust_CARGO_TARGET}
+            --no-default-features
+            ${CARGO_FLAGS}
+            ${FEATURES_ARG}
+      &&
+      "${CMAKE_COMMAND}" -E
+        copy "${rust_target_dir}/${rust_profile}/${target}" "${CMAKE_CURRENT_BINARY_DIR}"
     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
     USES_TERMINAL
-)
+  )
+endfunction(CREATE_TARGET)
 
-function(CREATE_LINK target)
-    add_custom_target(
-        ${target} ALL
-        DEPENDS fish
-        COMMAND ln -f fish ${target}
-        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
-    )
-endfunction(CREATE_LINK)
+# Define fish.
+create_target(fish)
 
 # Define fish_indent.
-create_link(fish_indent)
+create_target(fish_indent)
 
 # Define fish_key_reader.
-create_link(fish_key_reader)
+create_target(fish_key_reader)
 
 # Set up the docs.
 include(cmake/Docs.cmake)

CONTRIBUTING.rst

@@ -1,30 +1,23 @@
 ####################
-Contributing To fish
+Contributing To Fish
 ####################
 
 This document tells you how you can contribute to fish.
 
-fish is free and open source software, distributed under the terms of the GPLv2.
+Fish is free and open source software, distributed under the terms of the GPLv2.
 
 Contributions are welcome, and there are many ways to contribute!
 
 Whether you want to change some of the core Rust source, enhance or add a completion script or function,
 improve the documentation or translate something, this document will tell you how.
 
+Getting Set Up
+==============
 
-Mailing List
-============
-
-Send patches to the public mailing list: mailto:~krobelus/fish-shell@lists.sr.ht.
-Archives are available at https://lists.sr.ht/~krobelus/fish-shell/.
-
-GitHub
-======
-
-fish is available on GitHub, at https://github.com/fish-shell/fish-shell.
+Fish is developed on Github, at https://github.com/fish-shell/fish-shell.
 
 First, you'll need an account there, and you'll need a git clone of fish.
-Fork it on GitHub and then run::
+Fork it on Github and then run::
 
   git clone https://github.com/<USERNAME>/fish-shell.git
 
@@ -36,7 +29,7 @@ For that, you'll require:
 -  Rust - when in doubt, try rustup
 -  CMake
 -  PCRE2 (headers and libraries) - optional, this will be downloaded if missing
--  gettext (only the msgfmt tool) - optional, for translation support
+-  gettext (headers and libraries) - optional, for translation support
 -  Sphinx - optional, to build the documentation
 
 Of course not everything is required always - if you just want to contribute something to the documentation you'll just need Sphinx,
@@ -50,24 +43,7 @@ Guidelines
 In short:
 
 - Be conservative in what you need (keep to the agreed minimum supported Rust version, limit new dependencies)
-- Use automated tools to help you (``cargo xtask check``)
-
-Commit History
-==============
-
-We use a linear, `recipe-style <https://www.bitsnbites.eu/git-history-work-log-vs-recipe/>`__ history.
-Every commit should pass our checks.
-We do not want "fixup" commits in our history.
-If you notice an issue with a commit in a pull request, or get feedback suggesting changes,
-you should rewrite the commit history and fix the relevant commits directly,
-instead of adding new "fixup" commits.
-When a pull request is ready, we rebase it on top of the current master branch,
-so don't be shy about rewriting the history of commits which are not on master yet.
-Rebasing (not merging) your pull request on the latest version of master is also welcome, especially if it resolves conflicts.
-
-If you're using Git, consider using `jj <https://www.jj-vcs.dev/>`__ to make this easier.
-
-If a commit should close an issue, add a ``Fixes #<issue-number>`` line at the end of the commit description.
+- Use automated tools to help you (including ``make fish_run_tests`` and ``build_tools/style.fish``)
 
 Contributing completions
 ========================
@@ -88,7 +64,7 @@ Completion scripts should
 
 1. Use as few dependencies as possible - try to use fish's builtins like ``string`` instead of ``grep`` and ``awk``,
    use ``python`` to read json instead of ``jq`` (because it's already a soft dependency for fish's tools)
-2. If it uses a common unix tool, use POSIX-compatible invocations - ideally it would work on GNU/Linux, macOS, the BSDs and other systems
+2. If it uses a common unix tool, use posix-compatible invocations - ideally it would work on GNU/Linux, macOS, the BSDs and other systems
 3. Option and argument descriptions should be kept short.
    The shorter the description, the more likely it is that fish can use more columns.
 4. Function names should start with ``__fish``, and functions should be kept in the completion file unless they're used elsewhere.
@@ -105,42 +81,47 @@ Contributing documentation
 ==========================
 
 The documentation is stored in ``doc_src/``, and written in ReStructured Text and built with Sphinx.
-The builtins and various functions shipped with fish are documented in ``doc_src/cmds/``.
 
-To build an HTML version of the docs locally, run::
+To build it locally, run from the main fish-shell directory::
 
-    cargo xtask html-docs
+    sphinx-build -j 8 -b html -n doc_src/ /tmp/fish-doc/
 
-will output to ``target/fish-docs/html`` or, if you use CMake::
-
-    cmake --build build -t sphinx-docs
-
-will output to ``build/cargo/fish-docs/html/``. You can also run ``sphinx-build`` directly, which allows choosing the output directory::
-
-    sphinx-build -j auto -b html doc_src/ /tmp/fish-doc/
-
-will output HTML docs to ``/tmp/fish-doc``.
-
-After building them, you can open the HTML docs in a browser and see that it looks okay.
+which will build the docs as html in /tmp/fish-doc. You can open it in a browser and see that it looks okay.
 
+The builtins and various functions shipped with fish are documented in doc_src/cmds/.
 
 Code Style
 ==========
 
-For formatting, we use:
-
-- ``rustfmt`` for Rust
-- ``fish_indent`` (shipped with fish) for fish script
-- ``ruff format`` for Python
-
-To reformat files, there is an xtask
+To ensure your changes conform to the style rules run
 
 ::
 
-   cargo xtask format --all
-   cargo xtask format somefile.rs some.fish
+   build_tools/style.fish
 
-fish Script Style Guide
+before committing your change. That will run our autoformatters:
+
+- ``rustfmt`` for Rust
+- ``fish_indent`` (shipped with fish) for fish script
+- ``black`` for python
+
+If you’ve already committed your changes that’s okay since it will then
+check the files in the most recent commit. This can be useful after
+you’ve merged another person’s change and want to check that it’s style
+is acceptable. However, in that case it will run ``clang-format`` to
+ensure the entire file, not just the lines modified by the commit,
+conform to the style.
+
+If you want to check the style of the entire code base run
+
+::
+
+   build_tools/style.fish --all
+
+That command will refuse to restyle any files if you have uncommitted
+changes.
+
+Fish Script Style Guide
 -----------------------
 
 1. All fish scripts, such as those in the *share/functions* and *tests*
@@ -154,7 +135,7 @@ fish Script Style Guide
    for public vars or ``_fish`` for private vars to minimize the
    possibility of name clashes with user defined vars.
 
-Configuring Your Editor for fish Scripts
+Configuring Your Editor for Fish Scripts
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 If you use Vim: Install `vim-fish <https://github.com/dag/vim-fish>`__,
@@ -190,10 +171,10 @@ made to run fish_indent via e.g.
    (add-hook 'fish-mode-hook (lambda ()
        (add-hook 'before-save-hook 'fish_indent-before-save)))
 
-Minimum Supported Rust Version (MSRV) Policy
---------------------------------------------
+Rust Style Guide
+----------------
 
-We support at least the version of ``rustc`` available in Debian Stable.
+Use ``cargo fmt`` and ``cargo clippy``. Clippy warnings can be turned off if there's a good reason to.
 
 Testing
 =======
@@ -202,385 +183,190 @@ The source code for fish includes a large collection of tests. If you
 are making any changes to fish, running these tests is a good way to make
 sure the behaviour remains consistent and regressions are not
 introduced. Even if you don’t run the tests on your machine, they will
-still be run via GitHub Actions.
+still be run via Github Actions.
 
 You are strongly encouraged to add tests when changing the functionality
 of fish, especially if you are fixing a bug to help ensure there are no
 regressions in the future (i.e., we don’t reintroduce the bug).
 
-Unit tests live next to the implementation in Rust source files, in inline submodules (``mod tests {}``).
+The tests can be found in three places:
 
-System tests live in ``tests/``:
+- src/tests for unit tests.
+- tests/checks for script tests, run by `littlecheck <https://github.com/ridiculousfish/littlecheck>`__
+- tests/pexpects for interactive tests using `pexpect <https://pexpect.readthedocs.io/en/stable/>`__
 
-- ``tests/checks`` are run by `littlecheck <https://github.com/ridiculousfish/littlecheck>`__
-  and test noninteractive (script) behavior,
-  except for ``tests/checks/tmux-*`` which test interactive scenarios.
-- ``tests/pexpects`` tests interactive scenarios using `pexpect <https://pexpect.readthedocs.io/en/stable/>`__
+When in doubt, the bulk of the tests should be added as a littlecheck test in tests/checks, as they are the easiest to modify and run, and much faster and more dependable than pexpect tests. The syntax is fairly self-explanatory. It's a fish script with the expected output in ``# CHECK:`` or ``# CHECKERR:`` (for stderr) comments.
+If your littlecheck test has a specific dependency, use ``# REQUIRE: ...`` with a posix sh script.
 
-When in doubt, the bulk of the tests should be added as a littlecheck test in tests/checks, as they are the easiest to modify and run, and much faster and more dependable than pexpect tests.
-The syntax is fairly self-explanatory.
-It's a fish script with the expected output in ``# CHECK:`` or ``# CHECKERR:`` (for stderr) comments.
-If your littlecheck test has a specific dependency, use ``# REQUIRE: ...`` with a POSIX sh script.
+The pexpects are written in python and can simulate input and output to/from a terminal, so they are needed for anything that needs actual interactivity. The runner is in tests/pexpect_helper.py, in case you need to modify something there.
 
-The pexpect tests are written in Python and can simulate input and output to/from a terminal, so they are needed for anything that needs actual interactivity.
-The runner is in tests/pexpect_helper.py, in case you need to modify something there.
-
-These tests can be run via the tests/test_driver.py Python script, which will set up the environment.
+These tests can be run via the tests/test_driver.py python script, which will set up the environment.
 It sets up a temporary $HOME and also uses it as the current directory, so you do not need to create a temporary directory in them.
 
-If you need a command to do something weird to test something, maybe add it to the ``fish_test_helper`` binary (in ``tests/fish_test_helper.c``).
+If you need a command to do something weird to test something, maybe add it to the ``fish_test_helper`` binary (in tests/fish_test_helper.c), or see if it can already do it.
 
 Local testing
 -------------
 
-The tests can be run on your local system::
+The tests can be run on your local computer on all operating systems.
 
-    cargo build
-    # Run unit tests
-    cargo test
-    # Run system tests
-    tests/test_driver.py target/debug
-    # Run a specific system test.
-    tests/test_driver.py target/debug tests/checks/abbr.fish
+::
+
+   cmake path/to/fish-shell
+   make fish_run_tests
+
+Or you can run them on a fish, without involving cmake::
+
+  cargo build
+  cargo test # for the unit tests
+  tests/test_driver.py --cachedir=/tmp target/debug # for the script and interactive tests
 
 Here, the first argument to test_driver.py refers to a directory with ``fish``, ``fish_indent`` and ``fish_key_reader`` in it.
-In this example we're in the root of the workspace and have run ``cargo build`` without ``--release``, so it's a debug build.
+In this example we're in the root of the git repo and have run ``cargo build`` without ``--release``, so it's a debug build.
+The ``--cachedir /tmp`` argument means it will keep the fish_test_helper binary in /tmp instead of recompiling it for every test.
+This saves some time, but isn't strictly necessary.
 
-To run all tests and linters, use::
+Git hooks
+---------
 
-    cargo xtask check
+Since developers sometimes forget to run the tests, it can be helpful to
+use git hooks (see githooks(5)) to automate it.
 
-.. _localization:
+One possibility is a pre-push hook script like this one:
+
+.. code:: sh
+
+   #!/bin/sh
+   #### A pre-push hook for the fish-shell project
+   # This will run the tests when a push to master is detected, and will stop that if the tests fail
+   # Save this as .git/hooks/pre-push and make it executable
+
+   protected_branch='master'
+
+   # Git gives us lines like "refs/heads/frombranch SOMESHA1 refs/heads/tobranch SOMESHA1"
+   # We're only interested in the branches
+   while read from _ to _; do
+       if [ "x$to" = "xrefs/heads/$protected_branch" ]; then
+           isprotected=1
+       fi
+   done
+   if [ "x$isprotected" = x1 ]; then
+       echo "Running tests before push to master"
+       make fish_run_tests
+       RESULT=$?
+       if [ $RESULT -ne 0 ]; then
+           echo "Tests failed for a push to master, we can't let you do that" >&2
+           exit 1
+       fi
+   fi
+   exit 0
+
+This will check if the push is to the master branch and, if it is, only
+allow the push if running ``make fish_run_tests`` succeeds. In some circumstances
+it may be advisable to circumvent this check with
+``git push --no-verify``, but usually that isn’t necessary.
+
+To install the hook, place the code in a new file
+``.git/hooks/pre-push`` and make it executable.
+
+Coverity Scan
+-------------
+
+We use Coverity’s static analysis tool which offers free access to open
+source projects. While access to the tool itself is restricted,
+fish-shell organization members should know that they can login
+`here <https://scan.coverity.com/projects/fish-shell-fish-shell?tab=overview>`__
+with their GitHub account. Currently, tests are triggered upon merging
+the ``master`` branch into ``coverity_scan_master``. Even if you are not
+a fish developer, you can keep an eye on our statistics there.
 
 Contributing Translations
 =========================
 
-fish can localize messages present in its Rust source code,
-as well as messages in the various fish scripts present in this repository.
-The latter include a large amount of automatically identified messages,
-originating for example from fish function descriptions.
-When translating, prioritize the messages from the Rust source code.
+Fish uses the GNU gettext library to translate messages from English to
+other languages.
 
-fish uses two different localization systems:
-`GNU gettext <https://www.gnu.org/software/gettext/>`__ and `Fluent <https://projectfluent.org/>`__.
-The former is used for all messages from fish scripts.
-For messages from the Rust source code, we are in the process of replacing gettext with Fluent.
-At the moment, both are used side-by-side,
-with some messages localized with gettext and the others with Fluent.
+Creating and updating translations requires the Gettext tools, including
+``xgettext``, ``msgfmt`` and ``msgmerge``. Translation sources are
+stored in the ``po`` directory, named ``LANG.po``, where ``LANG`` is the
+two letter ISO 639-1 language code of the target language (eg ``de`` for
+German).
 
-We use custom tools for extracting messages from source files and for gettext localization at runtime.
-This means that we do not have a runtime dependency on the gettext library.
-It also means that some of gettext's features are not supported, such as message context and plurals.
-We expect all files to be UTF-8-encoded.
+To create a new translation:
 
-Translation sources for gettext are stored in the ``localization/po`` directory and named ``ll_CC.po``,
-whereas Fluent uses the ``localization/fluent`` directory and names of the shape ``ll_CC.ftl``,
-where ``ll`` is the two (or possibly three) letter ISO 639-1 language code of the target language
-(e.g. ``pt`` for Portuguese).
-``CC`` is an ISO 3166 country/territory code, (e.g. ``BR`` for Brazil).
-An example for a valid name is ``pt_BR.po`` for gettext and ``pt_BR.ftl`` for Fluent,
-indicating Brazilian Portuguese.
-These are the files you will interact with when adding translations.
+* generate a ``messages.pot`` file by running ``build_tools/fish_xgettext.fish`` from
+  the source tree
+* copy ``messages.pot`` to ``po/LANG.po``
 
-In some cases, we also use language identifiers without a county code, i.e. ``ll.po``/``ll.ftl``.
-Which variant is chosen involves various trade-offs for fallback behavior.
-If you want to add a new language or language variant, feel free to ask about this.
-Generally, if people who understand any variant of the language
-are expected to understand the version you add
-and there are no existing translations for another variant of the language,
-it probably makes sense to omit the country code,
-otherwise to use it for all variants of the language.
+To update a translation:
 
-Adding translations for a new language
---------------------------------------
+* generate a ``messages.pot`` file by running
+  ``build_tools/fish_xgettext.fish`` from the source tree
 
-Creating new translations for gettext requires the gettext tools.
-More specifically, you will need ``msguniq``, ``msgmerge``, and ``msgmerge``
-for creating translations for a new language.
-To create a PO file for a new language ``ll_CC``, run::
+* update the existing translation by running
+  ``msgmerge --update --no-fuzzy-matching po/LANG.po messages.pot``
 
-    cargo xtask gettext new ll_CC
-
-This will create a new PO file in ``localization/po/``
-containing all messages available for translation.
-If the file already exists, it will be updated.
-
-For Fluent, it is sufficient to create a new, empty file
-with the language-appropriate name in ``localization/fluent``.
-
-After modifying a translation file, you can recompile fish,
-and it will integrate the modifications you made.
-This requires that the ``msgfmt`` utility is installed (comes as part of ``gettext``).
-For messages localized with Fluent, recompiling fish is not necessary when you use a debug build.
-Then, restarting fish is sufficient for seeing updated translations.
-It is important that the ``localize-messages`` Cargo feature is enabled, which it is by default.
-You can explicitly enable it using::
-
-    cargo build --features=localize-messages
-
-Use environment variables to tell fish which language to use, e.g.::
-
-    LANG=pt_BR.utf8 fish
-
-or within the running fish shell::
-
-    set LANG pt_BR.utf8
-
-Alternatively, you can also use the built-in ``status language`` command, e.g.::
-
-    status language set pt_BR
-
-Use
-
-::
-
-    status language list-available
-
-to see a list of the available language identifiers.
-This might also be helpful for checking that your new translations are recognized as expected.
-Note that using environment variables enables fallback behavior,
-e.g. if you specify ``LANG=de_DE.utf8`` and we do not have a ``de_DE`` catalog but a ``de`` catalog,
-you will see messages from the latter.
-With ``status language``, only exact matches are supported,
-giving you more control over the fallback order.
-If ``status language`` is used, it overrides the environment variable configuration.
-
-For more options regarding how to choose languages via environment variables, see
-`the corresponding gettext documentation
-<https://www.gnu.org/software/gettext/manual/html_node/Locale-Environment-Variables.html>`__.
-One neat thing you can do is set a list of languages to check for translations in the order defined
-using the ``LANGUAGE`` variable, e.g.::
-
-    set LANGUAGE pt_BR de_DE
-
-or using::
-
-    status language set pt_BR de
-
-to try to translate messages to Portuguese, if that fails try German, and if that fails too you will
-see the default English version.
-
-Modifying existing translations
--------------------------------
-
-If you want to work on translations for a language which already has translations, it
-is sufficient to edit the existing files.
-No other changes are necessary.
-
-After recompiling fish, you should be able to see your translations in action. See the previous
-section for details.
-
-Editing PO files
-----------------
+The ``--no-fuzzy-matching`` is important as we have had terrible experiences with gettext's "fuzzy" translations in the past.
 
 Many tools are available for editing translation files, including
-command-line and graphical user interface programs. For simple use, you can use your text editor.
+command-line and graphical user interface programs. For simple use, you can just use your text editor.
 
-Open up the PO file, for example ``localization/po/sv.po``, and you'll see something like::
+Open up the po file, for example ``po/sv.po``, and you'll see something like::
 
-    msgid "%s: No suitable job\n"
-    msgstr ""
+  msgid "%ls: No suitable job\n"
+  msgstr "" 
 
-The ``msgid`` here is the "name" of the string to translate, typically the English string to translate.
-The second line (``msgstr``) is where your translation goes.
+The ``msgid`` here is the "name" of the string to translate, typically the english string to translate. The second line (``msgstr``) is where your translation goes.
 
 For example::
 
-    msgid "%s: No suitable job\n"
-    msgstr "%s: Inget passande jobb\n"
+  msgid "%ls: No suitable job\n"
+  msgstr "%ls: Inget passande jobb\n"
 
-Any ``%s`` or ``%d`` are placeholders that fish will use for formatting at runtime. It is important that they match - the translated string must have the same placeholders in the same order.
+Any ``%s`` / ``%ls`` or ``%d`` are placeholders that fish will use for formatting at runtime. It is important that they match - the translated string should have the same placeholders in the same order.
 
 Also any escaped characters, like that ``\n`` newline at the end, should be kept so the translation has the same behavior.
 
 Our tests run ``msgfmt --check-format /path/to/file``, so they would catch mismatched placeholders - otherwise fish would crash at runtime when the string is about to be used.
 
-Be cautious about blindly updating an existing translation file.
-``msgid`` strings should never be updated manually, only by running the appropriate script.
-
-Editing FTL files
------------------
-
-To get familiar with Fluent's FTL format,
-you can read `Fluent's guide <https://projectfluent.org/fluent/guide/>`__.
-
-The core principle is that each message has an ID.
-This ID is specified in the source code.
-At runtime, Fluent checks FTL files according to the user's language settings
-to try to map the ID to a localized message.
-All messages are localized into English because the source code only contains IDs, not proper messages.
-Check ``localization/fluent/en.ftl`` to see which IDs are in use and what the corresponding messages are.
-
-Some messages receive arguments, called variables in Fluent.
-In Fluent, each variable has a name, which allows reordering them,
-so they can appear in the order which makes most sense for the language.
-The general format of a variable in an FTL file is ``{ $variable_name }``.
-
-The Fluent ecosystem is not as mature as gettext, meaning there is less available tooling.
-Therefore, we provide some of our own tools.
-Running ``cargo xtask fluent`` provides an overview.
-
-For translators, the following can be useful::
-
-    cargo xtask fluent format
-
-to make FTL files conform to our expected format,
-
-::
-
-    cargo xtask fluent show-missing
-
-to show which message IDs do not have a translation yet, and
-
-::
-
-    cargo xtask fluent check
-
-to run checks on the FTL files, which can catch some mistakes.
-Each of these commands takes optional path arguments,
-so if you are working on a certain file like ``pt_BR.ftl``,
-you might want to use
-
-::
-
-    cargo xtask fluent check localization/fluent/pt_BR.ftl
-
-from the repository root directory,
-or, if you are in the ``localization/fluent`` directory,
-
-::
-
-    cargo xtask fluent check pt_BR.ftl
-
-If you want formatting in your editor,
-
-::
-
-    cargo --quiet xtask fluent format -
-
-might be useful, which reads FTL text from stdin and writes a formatted version to stdout,
-or a copy of stdin if formatting failed.
-Instead of invoking Cargo each time, you could also invoke the ``xtask`` binary if it exists.
-
-A simple format-on-write setup in Vim:
-
-.. code:: vim
-
-    function FormatFTL()
-        let cursor = getpos('.')
-        :%!cargo --quiet xtask fluent format -
-        call setpos('.', cursor)
-    endfunction
-
-    augroup ftl
-        autocmd!
-        autocmd! BufWritePre *.ftl :call FormatFTL()
-    augroup END
-
-or equivalently in Lua for NeoVim:
-
-.. code:: lua
-
-    local augroup_ftl = vim.api.nvim_create_augroup("ftl", { clear = true })
-    vim.api.nvim_create_autocmd("BufWritePre", {
-        group = augroup_ftl,
-        pattern = "*.ftl",
-        callback = function()
-            local cursor = vim.fn.getpos(".")
-            vim.cmd("%!cargo --quiet xtask fluent format -")
-            vim.fn.setpos(".", cursor)
-        end,
-    })
-
-There is also a `Vim plugin <https://github.com/projectfluent/fluent.vim>`__ for syntax highlighting.
-
-Modifications to strings in source files (gettext-only)
--------------------------------------------------------
-
-If a string changes in the sources, the old translations will no longer work.
-If you add/remove/change a translatable strings in a source file,
-run ``cargo xtask gettext update`` to propagate this to all translation files (``localization/po/*.po``).
-This is only relevant for developers modifying the source files of fish or fish scripts.
-Note translations for messages which are no longer present in the sources will be deleted from the PO files.
-If the source string changed in a way which should not affect translations,
-consider updating the ``msgid`` in the PO files such that translations are preserved.
+Be cautious about blindly updating an existing translation file. Trivial
+changes to an existing message (eg changing the punctuation) will cause
+existing translations to be removed, since the tools do literal string
+matching. Therefore, in general, you need to carefully review any
+recommended deletions.
 
 Setting Code Up For Translations
 --------------------------------
 
-All non-debug messages output for user consumption should be marked for translation.
-In Rust, this requires the use of the ``localize!`` macro for Fluent localization, e.g.:
-
-.. code:: rust
-
-    localize!(
-        "some-message-id" = "English version of the message. Must be a valid Fluent message definition. Example variables: { $var1 }, { $var2 }",
-        var1 = "some string",
-        var2 = 42,
-    );
-
-where the first key-value pair is the message's Fluent ID and the English version of the message.
-The remaining key-value pairs specify Fluent variables and their values.
-These must match the variables used in the message definition.
-
-For changing message IDs or associated variable names accross all FTL files, the
+All non-debug messages output for user consumption should be marked for
+translation. In Rust, this requires the use of the ``wgettext!`` or ``wgettext_fmt!``
+macros:
 
 ::
 
-    cargo xtask fluent rename
+   streams.out.append(wgettext_fmt!("%ls: There are no jobs\n", argv[0]));
 
-command can be helpful.
-The definitions in the Rust sources are the source of truth for the English version of the messages.
-Our tooling automatically generates a corresponding ``en.po`` file from these definitions,
-but that file is fully auto-generated and manual modifications to it are not supported.
-The `en.po` file exists to allow using Fluent tooling which expects such a file,
-and to be able to detect changes to the definitions in the Rust sources.
-Note that changes to the message definitions have consequences for translations.
-Our tooling automatically detects such changes.
-In some cases, they can be resolved automatically,
-e.g. when a message ID no longer exists, the translations will be deleted.
-If no automatic resolution is possible, annotations will be added to the affected translations,
-indicating that they need developer attention.
-As long as such annotations are present, our checks will not pass.
-To resolve them, use ``cargo xtask fluent resolve-outdated``,
-or, for languages into which you can translate,
-update the translation and remove the annotation manually.
-
-Legacy gettext localization uses the ``wgettext!`` or ``wgettext_fmt!`` macros.
-New code should use Fluent instead.
-
-.. code:: rust
-
-    streams.out.appendln(&wgettext_fmt!("%s: There are no jobs", argv[0]));
-
-For explicit localization in fish scripts,
-all messages must be enclosed in single or double quote characters
-for our message extraction script to find them.
-They must also be translated via a command substitution.
-This means that the following are **not** valid:
+All messages in fish script must be enclosed in single or double quote
+characters for our message extraction script to find them.
+They must also be translated via a command substitution. This means
+that the following are **not** valid:
 
 ::
 
-    echo (_ hello)
-    _ "goodbye"
+   echo (_ hello)
+   _ "goodbye"
 
 Above should be written like this instead:
 
 ::
 
-    echo (_ "hello")
-    echo (_ "goodbye")
+   echo (_ "hello")
+   echo (_ "goodbye")
 
 You can use either single or double quotes to enclose the
 message to be translated. You can also optionally include spaces after
 the opening parentheses or before the closing parentheses.
 
-Updating Dependencies
-=====================
-
-To update dependencies, run ``build_tools/update-dependencies.sh``.
-This currently requires `updatecli <https://github.com/updatecli/updatecli>`__ and a few other tools.
-
 Versioning
 ==========
 

Cargo.toml

@@ -1,100 +1,11 @@
 [workspace]
-members = ["crates/*"]
+resolver = "2"
+members = ["printf"]
 
 [workspace.package]
-edition = "2024"
 # To build revisions that use Corrosion (those before 2024-01), use CMake 3.19, Rustc 1.78 and Rustup 1.27.
-rust-version = "1.85"
-repository = "https://github.com/fish-shell/fish-shell"
-# see doc_src/license.rst for details
-# don't forget to update COPYING and debian/copyright too
-license = "GPL-2.0-only AND LGPL-2.0-or-later AND MIT AND PSF-2.0"
-
-[workspace.dependencies]
-anstyle = "1.0.13"
-anyhow = "1.0.102"
-assert_matches = "1.5.0"
-bitflags = "2.5.0"
-cc = "1.0.94"
-cfg-if = "1.0.3"
-clap = { version = "4.5.54", features = ["derive"] }
-clap_complete = { version = "4.6.4", features = ["unstable-dynamic"] }
-errno = "0.3.0"
-fish-build-helper = { path = "crates/build-helper" }
-fish-build-man-pages = { path = "crates/build-man-pages" }
-fish-color = { path = "crates/color" }
-fish-common = { path = "crates/common" }
-fish-fallback = { path = "crates/fallback" }
-fish-feature-flags = { path = "crates/feature-flags" }
-fish-fluent = { path = "crates/fluent" }
-fish-fluent-extraction = { path = "crates/fluent-extraction" }
-fish-gettext = { path = "crates/gettext" }
-fish-gettext-extraction = { path = "crates/gettext-extraction" }
-fish-gettext-maps = { path = "crates/gettext-maps" }
-fish-gettext-mo-file-parser = { path = "crates/gettext-mo-file-parser" }
-fish-localization = { path = "crates/localization" }
-fish-localization-extraction = { path = "crates/localization-extraction" }
-fish-printf = { path = "crates/printf", features = ["widestring"] }
-fish-tempfile = { path = "crates/tempfile" }
-fish-util = { path = "crates/util" }
-fish-wcstringutil = { path = "crates/wcstringutil" }
-fish-wgetopt = { path = "crates/wgetopt" }
-fish-widecharwidth = { path = "crates/widecharwidth" }
-fish-widestring = { path = "crates/widestring" }
-fluent = { git = "https://github.com/danielrainer/fluent-rs", rev = "cf712bced280b217b6307edabc2089b3e57204ab" }
-fluent-ftl-tools = { git = "https://codeberg.org/danielrainer/fluent-ftl-tools", rev = "5917664c8f2e4928ef1e480ff5c13bbe1e226066" }
-fluent-syntax = { git = "https://github.com/danielrainer/fluent-rs", rev = "cf712bced280b217b6307edabc2089b3e57204ab" }
-ignore = "0.4.25"
-itertools = "0.14.0"
-libc = "0.2.177"
-# lru pulls in hashbrown by default, which uses a faster (though less DoS resistant) hashing algo.
-# disabling default features uses the stdlib instead, but it doubles the time to rewrite the history
-# files as of 22 April 2024.
-lru = "0.18.0"
-nix = { version = "0.31.1", default-features = false, features = [
-  "event",
-  "fs",
-  "hostname",
-  "inotify",
-  "process",
-  "resource",
-  "signal",
-  "term",
-  "user",
-] }
-num-traits = "0.2.19"
-once_cell = "1.19.0"
-pcre2 = { git = "https://github.com/fish-shell/rust-pcre2", tag = "0.2.9-utf32", default-features = false, features = [
-  "utf32",
-] }
-phf = { version = "0.13", default-features = false }
-phf_shared = "0.13"
-phf_codegen = "0.13"
-portable-atomic = { version = "1", default-features = false, features = [
-  "fallback",
-] }
-proc-macro2 = "1.0"
-rand = { version = "0.10.1", default-features = false, features = [
-  "thread_rng",
-] }
-regex = "1.12.3"
-rsconf = "0.3.0"
-rust-embed = { version = "8.11.0", features = [
-  "deterministic-timestamps",
-  "include-exclude",
-  "interpolate-folder-path",
-] }
-rustc_version = "0.4.1"
-serial_test = { version = "3", default-features = false }
-strum_macros = "0.28.0"
-syn = { version = "2.0.117", default-features = false, features = ["parsing"] }
-unic-langid = "0.9.6"
-unicode-segmentation = "1.12.0"
-unicode-width = "0.2.0"
-unix_path = "1.0.1"
-walkdir = "2.5.0"
-widestring = "1.2.0"
-xterm-color = "1.0.1"
+rust-version = "1.70"
+edition = "2021"
 
 [profile.release]
 overflow-checks = true
@@ -106,80 +17,62 @@ debug = true
 
 [package]
 name = "fish"
-version = "4.7.1"
+version = "4.1.0-alpha0"
 edition.workspace = true
 rust-version.workspace = true
 default-run = "fish"
-license.workspace = true
+# see doc_src/license.rst for details
+# don't forget to update COPYING and debian/copyright too
+license = "GPL-2.0-only AND LGPL-2.0-or-later AND MIT AND PSF-2.0"
+repository = "https://github.com/fish-shell/fish-shell"
 homepage = "https://fishshell.com"
 readme = "README.rst"
 
 [dependencies]
-assert_matches.workspace = true
-bitflags.workspace = true
-cfg-if.workspace = true
-errno.workspace = true
-fish-build-helper.workspace = true
-fish-build-man-pages = { workspace = true, optional = true }
-fish-color.workspace = true
-fish-common.workspace = true
-fish-fallback.workspace = true
-fish-feature-flags.workspace = true
-fish-fluent.workspace = true
-fish-fluent-extraction = { workspace = true, optional = true }
-fish-gettext = { workspace = true, optional = true }
-fish-gettext-extraction = { workspace = true, optional = true }
-fish-localization = { workspace = true, optional = true }
-fish-printf.workspace = true
-fish-tempfile.workspace = true
-fish-util.workspace = true
-fish-wcstringutil.workspace = true
-fish-wgetopt.workspace = true
-fish-widecharwidth.workspace = true
-fish-widestring.workspace = true
-fluent.workspace = true
-itertools.workspace = true
-libc.workspace = true
-lru.workspace = true
-macro_rules_attribute = "0.2.2"
-nix.workspace = true
-num-traits.workspace = true
-once_cell.workspace = true
-pcre2.workspace = true
-rand.workspace = true
-strum_macros.workspace = true
-xterm-color.workspace = true
+pcre2 = { git = "https://github.com/fish-shell/rust-pcre2", tag = "0.2.9-utf32", default-features = false, features = [
+    "utf32",
+] }
+
+bitflags = "2.5.0"
+errno = "0.3.0"
+libc = "0.2"
+# lru pulls in hashbrown by default, which uses a faster (though less DoS resistant) hashing algo.
+# disabling default features uses the stdlib instead, but it doubles the time to rewrite the history
+# files as of 22 April 2024.
+lru = "0.13.0"
+nix = { version = "0.29.0", default-features = false, features = [
+    "event",
+    "inotify",
+    "resource",
+    "fs",
+] }
+num-traits = "0.2.19"
+once_cell = "1.19.0"
+fish-printf = { path = "./printf", features = ["widestring"] }
+
+# Don't use the "getrandom" feature as it requires "getentropy" which was not
+# available on macOS < 10.12. We can enable "getrandom" when we raise the
+# minimum supported version to 10.12.
+rand = { version = "0.8.5", default-features = false, features = ["small_rng"] }
+widestring = "1.2.0"
+# We need 0.9.0 specifically for some crash fixes.
+terminfo = "0.9.0"
+rust-embed = { version = "8.2.0", optional = true }
 
 [target.'cfg(not(target_has_atomic = "64"))'.dependencies]
-portable-atomic.workspace = true
-
-[target.'cfg(windows)'.dependencies]
-rust-embed = { workspace = true, features = [
-  "deterministic-timestamps",
-  "debug-embed",
-  "include-exclude",
-  "interpolate-folder-path",
-] }
-[target.'cfg(not(windows))'.dependencies]
-rust-embed = { workspace = true, features = [
-  "deterministic-timestamps",
-  "include-exclude",
-  "interpolate-folder-path",
+portable-atomic = { version = "1", default-features = false, features = [
+    "fallback",
 ] }
 
 [dev-dependencies]
-serial_test.workspace = true
+serial_test = { version = "3", default-features = false }
 
 [build-dependencies]
-cc.workspace = true
-fish-build-helper.workspace = true
-fish-gettext-mo-file-parser.workspace = true
-phf_codegen = { workspace = true, optional = true }
-rsconf.workspace = true
-rustc_version.workspace = true
+cc = "1.0.94"
+rsconf = "0.2.2"
 
 [target.'cfg(windows)'.build-dependencies]
-unix_path.workspace = true
+unix_path = "1.0.1"
 
 [lib]
 crate-type = ["rlib"]
@@ -198,65 +91,25 @@ name = "fish_key_reader"
 path = "src/bin/fish_key_reader.rs"
 
 [features]
-default = ["embed-manpages", "localize-messages"]
+default = ["embed-data"]
 benchmark = []
-embed-manpages = ["dep:fish-build-man-pages"]
-# This feature is used to enable extracting Fluent IDs from the source code for localization check.
-# For normal builds, it should be disabled.
-# It only needs to be enabled if checking Fluent Translation List (FTL) files is desired.
-fluent-extract = ["fish-fluent/fluent-extract", "dep:fish-fluent-extraction"]
-# This feature is used to enable extracting messages from the source code for localization.
-# It only needs to be enabled if updating these messages (and the corresponding PO files) is
-# desired. This happens for the `gettext` xtask, which is also invoked via `cargo xtask check`.
-# There should not be a need to enable this feature manually.
-gettext-extract = ["dep:fish-gettext-extraction"]
-# Enable gettext localization at runtime. Requires the `msgfmt` tool to generate catalog data at
-# build time.
-localize-messages = [
-  "fish-fluent/localize-messages",
-  "dep:fish-gettext",
-  "dep:fish-localization",
-]
+embed-data = ["dep:rust-embed"]
 
 # The following features are auto-detected by the build-script and should not be enabled manually.
+asan = []
 tsan = []
 
-[workspace.lints]
-rust.unknown_lints = { level = "allow", priority = -1 }
+[lints]
+rust.non_camel_case_types = "allow"
+rust.non_upper_case_globals = "allow"
+rust.unknown_lints = "allow"
 rust.unstable_name_collisions = "allow"
-rustdoc.private_intra_doc_links = "allow"
-
-[workspace.lints.clippy]
-assigning_clones = "warn"
-cloned_instead_of_copied = "warn"
-explicit_into_iter_loop = "warn"
-format_push_string = "warn"
-implicit_clone = "warn"
-len_without_is_empty = "allow"         # we're not a library crate
-let_and_return = "allow"
-manual_assert = "warn"
-manual_range_contains = "allow"
-map_unwrap_or = "warn"
-mut_mut = "warn"
-needless_lifetimes = "allow"
-new_without_default = "allow"
-option_map_unit_fn = "allow"
-ptr_offset_by_literal = "warn"
-redundant_clone = "warn"
-ref_option = "warn"
-semicolon_if_nothing_returned = "warn"
-stable_sort_primitive = "warn"
-str_to_string = "warn"
-unnecessary_semicolon = "warn"
-unused_trait_names = "warn"
+clippy.manual_range_contains = "allow"
+clippy.needless_return = "allow"
+clippy.needless_lifetimes = "allow"
 
 # We do not want to use the e?print(ln)?! macros.
 # These lints flag their use.
 # In the future, they might change to flag other methods of printing.
-print_stdout = "deny"
-print_stderr = "deny"
-# usage in tests is fine since it avoids interacting with TopicMonitor
-# and is configured in clippy.toml with `allow-print-in-tests`
-
-[lints]
-workspace = true
+clippy.print_stdout = "deny"
+clippy.print_stderr = "deny"

Dockerfile

@@ -0,0 +1,18 @@
+FROM centos:latest
+
+# Build dependency
+RUN yum update -y &&\
+  yum install -y epel-release &&\
+  yum install -y clang cmake3 gcc-c++ make &&\
+  yum clean all
+
+# Test dependency
+RUN yum install -y expect vim-common
+
+ADD . /src
+WORKDIR /src
+
+# Build fish
+RUN cmake3 . &&\
+  make &&\
+  make install

GNUmakefile

@@ -7,7 +7,7 @@
 CMAKE ?= cmake
 
 GENERATOR ?= $(shell (which ninja > /dev/null 2> /dev/null && echo Ninja) || \
-	echo 'Unix Makefiles')
+			 echo 'Unix Makefiles')
 prefix ?= /usr/local
 PREFIX ?= $(prefix)
 
@@ -34,7 +34,7 @@ all: .begin build/fish
 .PHONY: .begin
 .begin:
 	@which $(CMAKE) > /dev/null 2> /dev/null || \
-		(echo 'Please install CMake and then re-run the `make` command!' 1>&2 && false)
+		 (echo 'Please install CMake and then re-run the `make` command!' 1>&2 && false)
 
 .PHONY: build/fish
 build/fish: build/$(BUILDFILE)

README.rst

@@ -1,5 +1,9 @@
-`fish <https://fishshell.com/>`__ - the friendly interactive shell |Build Status|
-=================================================================================
+.. |Cirrus CI| image:: https://api.cirrus-ci.com/github/fish-shell/fish-shell.svg?branch=master
+      :target: https://cirrus-ci.com/github/fish-shell/fish-shell
+      :alt: Cirrus CI Build Status
+
+`fish <https://fishshell.com/>`__ - the friendly interactive shell |Build Status| |Cirrus CI|
+=============================================================================================
 
 fish is a smart and user-friendly command line shell for macOS, Linux,
 and the rest of the family. fish includes features like syntax
@@ -27,13 +31,13 @@ macOS
 
 fish can be installed:
 
--  using `Homebrew <https://brew.sh/>`__: ``brew install fish``
+-  using `Homebrew <http://brew.sh/>`__: ``brew install fish``
 -  using `MacPorts <https://www.macports.org/>`__:
    ``sudo port install fish``
 -  using the `installer from fishshell.com <https://fishshell.com/>`__
 -  as a `standalone app from fishshell.com <https://fishshell.com/>`__
 
-Note: The minimum supported macOS version is 10.12.
+Note: The minimum supported macOS version is 10.10 "Yosemite".
 
 Packages for Linux
 ~~~~~~~~~~~~~~~~~~
@@ -62,8 +66,7 @@ Windows
    for Linux with the instructions for the appropriate distribution
    listed above under “Packages for Linux”, or from source with the
    instructions below.
--  fish can also be installed on all versions of Windows using
-   `Cygwin <https://cygwin.com/>`__ or `MSYS2 <https://github.com/Berrysoft/fish-msys2>`__.
+-  fish (4.0 on and onwards) cannot be installed in Cygwin, due to a lack of Rust support.
 
 Building from source
 ~~~~~~~~~~~~~~~~~~~~
@@ -86,17 +89,19 @@ Running fish requires:
 
 -  some common \*nix system utilities (currently ``mktemp``), in
    addition to the basic POSIX utilities (``cat``, ``cut``, ``dirname``,
-   ``ls``, ``mkdir``, ``mkfifo``, ``rm``, ``sh``, ``sort``, ``tee``, ``tr``,
+   ``file``, ``ls``, ``mkdir``, ``mkfifo``, ``rm``, ``sort``, ``tee``, ``tr``,
    ``uname`` and ``sed`` at least, but the full coreutils plus ``find`` and
    ``awk`` is preferred)
+-  The gettext library, if compiled with
+   translation support
 
 The following optional features also have specific requirements:
 
 -  builtin commands that have the ``--help`` option or print usage
-   messages require ``man`` for display
+   messages require ``nroff`` or ``mandoc`` for
+   display
 -  automated completion generation from manual pages requires Python 3.5+
 -  the ``fish_config`` web configuration tool requires Python 3.5+ and a web browser
--  the :ref:`alt-o <shared-binds-alt-o>` binding requires the ``file`` program.
 -  system clipboard integration (with the default Ctrl-V and Ctrl-X
    bindings) require either the ``xsel``, ``xclip``,
    ``wl-copy``/``wl-paste`` or ``pbcopy``/``pbpaste`` utilities
@@ -108,22 +113,24 @@ The following optional features also have specific requirements:
 Building
 --------
 
+.. _dependencies-1:
+
 Dependencies
 ~~~~~~~~~~~~
 
 Compiling fish requires:
 
--  Rust (version 1.85 or later), including cargo
+-  Rust (version 1.70 or later)
 -  CMake (version 3.15 or later)
 -  a C compiler (for system feature detection and the test helper binary)
 -  PCRE2 (headers and libraries) - optional, this will be downloaded if missing
--  gettext (only the msgfmt tool) - optional, for translation support
+-  gettext (headers and libraries) - optional, for translation support
 -  an Internet connection, as other dependencies will be downloaded automatically
 
 Sphinx is also optionally required to build the documentation from a
 cloned git repository.
 
-Additionally, running the full test suite requires diff, git, Python 3.5+, pexpect, less, tmux and wget.
+Additionally, running the full test suite requires Python 3, tmux, and the pexpect package.
 
 Building from source with CMake
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -135,7 +142,7 @@ links above, and up-to-date `development builds of fish are available for many p
 
 To install into ``/usr/local``, run:
 
-.. code:: shell
+.. code:: bash
 
    mkdir build; cd build
    cmake ..
@@ -153,52 +160,40 @@ In addition to the normal CMake build options (like ``CMAKE_INSTALL_PREFIX``), f
 - Rust_COMPILER=path - the path to rustc. If not set, cmake will check $PATH and ~/.cargo/bin
 - Rust_CARGO=path - the path to cargo. If not set, cmake will check $PATH and ~/.cargo/bin
 - Rust_CARGO_TARGET=target - the target to pass to cargo. Set this for cross-compilation.
-- WITH_DOCS=ON|OFF - whether to build the documentation. By default, this is ON when Sphinx is installed.
-- FISH_INDENT_FOR_BUILDING_DOCS - useful for cross-compilation.
-  Set this to the path to the ``fish_indent`` executable to use for building HTML docs.
-  By default, ``${CMAKE_BINARY_DIR}/fish_indent`` will be used.
-  If that's not runnable on the compile host,
-  you can build a native one with ``cargo build --bin fish_indent`` and set this to ``$PWD/target/debug/fish_indent``.
+- BUILD_DOCS=ON|OFF - whether to build the documentation. This is automatically set to OFF when Sphinx isn't installed.
+- INSTALL_DOCS=ON|OFF - whether to install the docs. This is automatically set to on when BUILD_DOCS is or prebuilt documentation is available (like when building in-tree from a tarball).
 - FISH_USE_SYSTEM_PCRE2=ON|OFF - whether to use an installed pcre2. This is normally autodetected.
-- WITH_MESSAGE_LOCALIZATION=ON|OFF - whether to include translations.
+- MAC_CODESIGN_ID=String|OFF - the codesign ID to use on Mac, or "OFF" to disable codesigning.
+- WITH_GETTEXT=ON|OFF - whether to build with gettext support for translations.
 - extra_functionsdir, extra_completionsdir and extra_confdir - to compile in an additional directory to be searched for functions, completions and configuration snippets
 
-Building fish with Cargo
-~~~~~~~~~~~~~~~~~~~~~~~~
+Building fish with embedded data (experimental)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-You can also build fish with Cargo.
-This example uses `uv <https://github.com/astral-sh/uv>`__ to install Sphinx (which is used for man-pages and ``--help`` options).
-You can also install Sphinx another way and drop the ``uv run --no-managed-python`` prefix.
+You can also build fish with the data files embedded.
 
-.. code:: shell
+This will include all the datafiles like the included functions or web configuration tool in the main ``fish`` binary.
 
-    git clone https://github.com/fish-shell/fish-shell
-    cd fish-shell
+Fish will then read these right from its own binary, and print them out when needed. Some files, like the webconfig tool and the manpage completion generator, will be extracted to a temporary directory on-demand. You can list the files with ``status list-files`` and print one with ``status get-file path/to/file`` (e.g. ``status get-file functions/fish_prompt.fish`` to get the default prompt).
 
-    # Optional: check out a specific version rather than building the latest
-    # development version.
-    git checkout "$(git for-each-ref refs/tags/ | awk '$2 == "tag" { print $3 }' | tail -1)"
+To install fish with embedded files, just use ``cargo``, like::
 
-    uv run --no-managed-python \
-        cargo install --path .
+   cargo install --path /path/to/fish # if you have a git clone
+   cargo install --git https://github.com/fish-shell/fish-shell --tag 4.0.0 # to build from git with a specific version
+   cargo install --git https://github.com/fish-shell/fish-shell # to build the current development snapshot without cloning
 
-This will place standalone binaries in ``~/.cargo/bin/``, but you can move them wherever you want.
+This will place the binaries in ``~/.cargo/bin/``, but you can place them wherever you want.
 
-To disable translations, disable the ``localize-messages`` feature by passing ``--no-default-features --features=embed-manpages`` to cargo.
+This build won't have the HTML docs (``help`` will open the online version) or translations.
+
+It will try to build the man pages with sphinx-build. If that is not available and you would like to include man pages, you need to install it and retrigger the build script, e.g. by setting FISH_BUILD_DOCS=1::
+
+  FISH_BUILD_DOCS=1 cargo install --path .
+
+Setting it to "0" disables the inclusion of man pages.
 
 You can also link this build statically (but not against glibc) and move it to other computers.
 
-Here are the remaining advantages of a full installation, as currently done by CMake:
-
-- Man pages like ``fish(1)`` installed in standard locations, easily accessible from outside fish.
-- Separate files for builtins (e.g. ``$PREFIX/share/fish/man/man1/abbr.1``).
-- A local copy of the HTML documentation, typically accessed via the ``help`` fish function.
-  In Cargo builds, ``help`` will redirect to `<https://fishshell.com/docs/current/>`__
-- Ability to use our CMake options extra_functionsdir, extra_completionsdir and extra_confdir,
-  (also recorded in ``$PREFIX/share/pkgconfig/fish.pc``)
-  which are used by some package managers to house third-party completions.
-  Regardless of build system, fish uses ``$XDG_DATA_DIRS/{vendor_completion.d,vendor_conf.d,vendor_functions.d}``.
-
 Contributing Changes to the Code
 --------------------------------
 
@@ -217,5 +212,5 @@ There is also a fish tag on Stackoverflow, but it is typically a poor fit.
 Found a bug? Have an awesome idea? Please `open an
 issue <https://github.com/fish-shell/fish-shell/issues/new>`__.
 
-.. |Build Status| image:: https://github.com/fish-shell/fish-shell/actions/workflows/test.yml/badge.svg
-   :target: https://github.com/fish-shell/fish-shell/actions/workflows/test.yml
+.. |Build Status| image:: https://github.com/fish-shell/fish-shell/workflows/make%20test/badge.svg
+   :target: https://github.com/fish-shell/fish-shell/actions

SECURITY.md

@@ -1,35 +0,0 @@
-# Security Reporting
-
-If you wish to report a security vulnerability privately, we appreciate your diligence. Please follow the guidelines below to submit your report.
-
-## Reporting
-
-To report a security vulnerability, please provide the following information:
-
-1. **PROJECT**
-
-    - Include the URL of the project repository - Example: <https://github.com/fish-shell/fish-shell>
-
-2. **PUBLIC**
-
-    - Indicate whether this vulnerability has already been publicly discussed or disclosed.
-    - If so, provide relevant links.
-
-3. **DESCRIPTION**
-    - Provide a detailed description of the security vulnerability.
-    - Include as much information as possible to help us understand and address the issue.
-
-Send this information, along with any additional relevant details, to <rf@fishshell.com>.
-
-## Confidentiality
-
-We kindly ask you to keep the report confidential until a public announcement is made.
-
-## Notes
-
--   Vulnerabilities will be handled on a best-effort basis.
--   You may request an advance copy of the patched release, but we cannot guarantee early access before the public release.
--   You will be notified via email simultaneously with the public announcement.
--   We will respond within a few weeks to confirm whether your report has been accepted or rejected.
-
-Thank you for helping to improve the security of our project!

build.rs

@@ -1,55 +1,84 @@
-use fish_build_helper::{
-    env_var, fish_build_dir, target_os, target_os_is_apple, target_os_is_bsd, target_os_is_cygwin,
-    workspace_root,
-};
-use rsconf::Target;
-use std::path::{Path, PathBuf};
+#![allow(clippy::uninlined_format_args)]
+
+use rsconf::{LinkType, Target};
+use std::env;
+use std::error::Error;
+use std::path::Path;
 
 fn main() {
-    let is_nightly =
-        rustc_version::version_meta().unwrap().channel == rustc_version::Channel::Nightly;
-    rsconf::declare_cfg("nightly", is_nightly);
-
     setup_paths();
 
     // Add our default to enable tools that don't go through CMake, like "cargo test" and the
     // language server.
 
-    rsconf::set_env_value(
-        "FISH_RESOLVED_BUILD_DIR",
-        // If set by CMake, this might include symlinks. Since we want to compare this to the
-        // dir fish is executed in we need to canonicalize it.
-        fish_build_dir().canonicalize().unwrap().to_str().unwrap(),
-    );
-
+    // FISH_BUILD_DIR is set by CMake, if we are using it.
+    // OUT_DIR is set by Cargo when the build script is running (not compiling)
+    let default_build_dir = env::var("OUT_DIR").unwrap();
+    let build_dir = option_env!("FISH_BUILD_DIR").unwrap_or(&default_build_dir);
+    let build_dir = std::fs::canonicalize(build_dir).unwrap();
+    let build_dir = build_dir.to_str().unwrap();
+    rsconf::set_env_value("FISH_BUILD_DIR", build_dir);
     // We need to canonicalize (i.e. realpath) the manifest dir because we want to be able to
     // compare it directly as a string at runtime.
     rsconf::set_env_value(
         "CARGO_MANIFEST_DIR",
-        workspace_root().canonicalize().unwrap().to_str().unwrap(),
+        std::fs::canonicalize(env!("CARGO_MANIFEST_DIR"))
+            .unwrap()
+            .as_path()
+            .to_str()
+            .unwrap(),
     );
 
     // Some build info
-    rsconf::set_env_value("BUILD_TARGET_TRIPLE", &env_var("TARGET").unwrap());
-    rsconf::set_env_value("BUILD_HOST_TRIPLE", &env_var("HOST").unwrap());
-    rsconf::set_env_value("BUILD_PROFILE", &env_var("PROFILE").unwrap());
+    rsconf::set_env_value("BUILD_TARGET_TRIPLE", &env::var("TARGET").unwrap());
+    rsconf::set_env_value("BUILD_HOST_TRIPLE", &env::var("HOST").unwrap());
+    rsconf::set_env_value("BUILD_PROFILE", &env::var("PROFILE").unwrap());
 
+    let version = &get_version(&env::current_dir().unwrap());
     // Per https://doc.rust-lang.org/cargo/reference/build-scripts.html#inputs-to-the-build-script,
     // the source directory is the current working directory of the build script
-    rsconf::set_env_value("FISH_BUILD_VERSION", &get_version());
+    rsconf::set_env_value("FISH_BUILD_VERSION", version);
 
-    fish_build_helper::rebuild_if_embedded_path_changed("share");
+    std::env::set_var("FISH_BUILD_VERSION", version);
 
-    let build = cc::Build::new();
+    let cman = std::fs::canonicalize(env!("CARGO_MANIFEST_DIR")).unwrap();
+    let targetman = cman.as_path().join("target").join("man");
+
+    #[cfg(feature = "embed-data")]
+    #[cfg(not(clippy))]
+    {
+        build_man(&targetman);
+    }
+    #[cfg(any(not(feature = "embed-data"), clippy))]
+    {
+        let sec1dir = targetman.join("man1");
+        let _ = std::fs::create_dir_all(sec1dir.to_str().unwrap());
+    }
+
+    rsconf::rebuild_if_paths_changed(&["src", "printf", "Cargo.toml", "Cargo.lock", "build.rs"]);
+
+    // These are necessary if built with embedded functions,
+    // but only in release builds (because rust-embed in debug builds reads from the filesystem).
+    #[cfg(feature = "embed-data")]
+    #[cfg(not(debug_assertions))]
+    rsconf::rebuild_if_paths_changed(&["doc_src", "share"]);
+
+    cc::Build::new()
+        .file("src/libc.c")
+        .include(build_dir)
+        .compile("flibc.a");
+
+    let mut build = cc::Build::new();
+    // Add to the default library search path
+    build.flag_if_supported("-L/usr/local/lib/");
+    rsconf::add_library_search_path("/usr/local/lib");
     let mut target = Target::new_from(build).unwrap();
     // Keep verbose mode on until we've ironed out rust build script stuff
     target.set_verbose(true);
     detect_cfgs(&mut target);
 
     #[cfg(all(target_env = "gnu", target_feature = "crt-static"))]
-    compile_error!(
-        "Statically linking against glibc has unavoidable crashes and is unsupported. Use dynamic linking or link statically against musl."
-    );
+    compile_error!("Statically linking against glibc has unavoidable crashes and is unsupported. Use dynamic linking or link statically against musl.");
 }
 
 /// Check target system support for certain functionality dynamically when the build is invoked,
@@ -64,45 +93,127 @@ fn main() {
 /// `Cargo.toml`) behind a feature we just enabled.
 ///
 /// [0]: https://github.com/rust-lang/cargo/issues/5499
+#[rustfmt::skip]
 fn detect_cfgs(target: &mut Target) {
     for (name, handler) in [
-        // Ignore the first entry, it just sets up the type inference.
-        ("", &(|_: &Target| false) as &dyn Fn(&Target) -> bool),
-        ("apple", &(|_| target_os_is_apple())),
-        ("bsd", &(|_| target_os_is_bsd())),
-        ("cygwin", &(|_| target_os_is_cygwin())),
-        ("have_eventfd", &|target| {
-            // FIXME: NetBSD 10 has eventfd, but the libc crate does not expose it.
-            if target_os() == "netbsd" {
-                false
-            } else {
-                target.has_header("sys/eventfd.h")
-            }
-        }),
-        ("have_localeconv_l", &|target| {
-            target.has_symbol("localeconv_l")
-        }),
-        ("have_pipe2", &|target| target.has_symbol("pipe2")),
-        ("have_posix_spawn", &|target| {
-            if matches!(target_os().as_str(), "openbsd" | "android") {
-                // OpenBSD's posix_spawn returns status 127 instead of erroring with ENOEXEC when faced with a
-                // shebang-less script. Disable posix_spawn on OpenBSD.
-                //
-                // Android is broken for unclear reasons
-                false
-            } else {
-                target.has_header("spawn.h")
-            }
-        }),
+        // Ignore the first entry, it just sets up the type inference. Model new entries after the
+        // second line.
+        (
+            "",
+            &(|_: &Target| Ok(false)) as &dyn Fn(&Target) -> Result<bool, Box<dyn Error>>,
+        ),
+        ("apple", &detect_apple),
+        ("bsd", &detect_bsd),
+        ("cygwin", &detect_cygwin),
+        ("gettext", &have_gettext),
         ("small_main_stack", &has_small_stack),
-        ("using_cmake", &|_| {
-            option_env!("FISH_CMAKE_BINARY_DIR").is_some()
+        // See if libc supports the thread-safe localeconv_l(3) alternative to localeconv(3).
+        ("localeconv_l", &|target| {
+            Ok(target.has_symbol("localeconv_l"))
         }),
-        ("waitstatus_signal_ret", &|target| {
-            target.r#if("WEXITSTATUS(0x007f) == 0x7f", &["sys/wait.h"])
+        ("FISH_USE_POSIX_SPAWN", &|target| {
+            Ok(target.has_header("spawn.h"))
+        }),
+        ("HAVE_PIPE2", &|target| {
+            Ok(target.has_symbol("pipe2"))
+        }),
+        ("HAVE_EVENTFD", &|target| {
+            // FIXME: NetBSD 10 has eventfd, but the libc crate does not expose it.
+            if cfg!(target_os = "netbsd") {
+                 Ok(false)
+             } else {
+                 Ok(target.has_header("sys/eventfd.h"))
+            }
+        }),
+        ("HAVE_WAITSTATUS_SIGNAL_RET", &|target| {
+            Ok(target.r#if("WEXITSTATUS(0x007f) == 0x7f", &["sys/wait.h"]))
         }),
     ] {
-        rsconf::declare_cfg(name, handler(target));
+        match handler(target) {
+            Err(e) => {
+                rsconf::warn!("{}: {}", name, e);
+                rsconf::declare_cfg(name, false);
+            },
+            Ok(enabled) => rsconf::declare_cfg(name, enabled),
+        }
+    }
+}
+
+fn detect_apple(_: &Target) -> Result<bool, Box<dyn Error>> {
+    Ok(cfg!(any(target_os = "ios", target_os = "macos")))
+}
+
+#[allow(unexpected_cfgs)]
+fn detect_cygwin(_: &Target) -> Result<bool, Box<dyn Error>> {
+    Ok(cfg!(target_os = "cygwin"))
+}
+
+/// Detect if we're being compiled for a BSD-derived OS, allowing targeting code conditionally with
+/// `#[cfg(bsd)]`.
+///
+/// Rust offers fine-grained conditional compilation per-os for the popular operating systems, but
+/// doesn't necessarily include less-popular forks nor does it group them into families more
+/// specific than "windows" vs "unix" so we can conditionally compile code for BSD systems.
+fn detect_bsd(_: &Target) -> Result<bool, Box<dyn Error>> {
+    // Instead of using `uname`, we can inspect the TARGET env variable set by Cargo. This lets us
+    // support cross-compilation scenarios.
+    let mut target = std::env::var("TARGET").unwrap();
+    if !target.chars().all(|c| c.is_ascii_lowercase()) {
+        target = target.to_ascii_lowercase();
+    }
+    let is_bsd = target.ends_with("bsd") || target.ends_with("dragonfly");
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    ))]
+    assert!(is_bsd, "Target incorrectly detected as not BSD!");
+    Ok(is_bsd)
+}
+
+/// Detect libintl/gettext and its needed symbols to enable internationalization/localization
+/// support.
+fn have_gettext(target: &Target) -> Result<bool, Box<dyn Error>> {
+    // The following script correctly detects and links against gettext, but so long as we are using
+    // C++ and generate a static library linked into the C++ binary via CMake, we need to account
+    // for the CMake option WITH_GETTEXT being explicitly disabled.
+    rsconf::rebuild_if_env_changed("CMAKE_WITH_GETTEXT");
+    if let Some(with_gettext) = std::env::var_os("CMAKE_WITH_GETTEXT") {
+        if with_gettext.eq_ignore_ascii_case("0") {
+            return Ok(false);
+        }
+    }
+
+    // In order for fish to correctly operate, we need some way of notifying libintl to invalidate
+    // its localizations when the locale environment variables are modified. Without the libintl
+    // symbol _nl_msg_cat_cntr, we cannot use gettext even if we find it.
+    let mut libraries = Vec::new();
+    let mut found = 0;
+    let symbols = ["gettext", "_nl_msg_cat_cntr"];
+    for symbol in &symbols {
+        // Historically, libintl was required in order to use gettext() and co, but that
+        // functionality was subsumed by some versions of libc.
+        if target.has_symbol(symbol) {
+            // No need to link anything special for this symbol
+            found += 1;
+            continue;
+        }
+        for library in ["intl", "gettextlib"] {
+            if target.has_symbol_in(symbol, &[library]) {
+                libraries.push(library);
+                found += 1;
+                continue;
+            }
+        }
+    }
+    match found {
+        0 => Ok(false),
+        1 => Err(format!("gettext found but cannot be used without {}", symbols[1]).into()),
+        _ => {
+            rsconf::link_libraries(&libraries, LinkType::Default);
+            Ok(true)
+        }
     }
 }
 
@@ -112,94 +223,240 @@ fn detect_cfgs(target: &mut Target) {
 ///
 /// 0.5 MiB is small enough that we'd have to drastically reduce MAX_STACK_DEPTH to less than 10, so
 /// we instead use a workaround to increase the main thread size.
-fn has_small_stack(_: &Target) -> bool {
+fn has_small_stack(_: &Target) -> Result<bool, Box<dyn Error>> {
     #[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "netbsd")))]
-    return false;
+    return Ok(false);
 
     // NetBSD 10 also needs this but can't find pthread_get_stacksize_np.
     #[cfg(target_os = "netbsd")]
-    return true;
+    return Ok(true);
 
     #[cfg(any(target_os = "ios", target_os = "macos"))]
     {
         use core::ffi;
 
-        unsafe extern "C" {
-            unsafe fn pthread_get_stacksize_np(thread: *const ffi::c_void) -> usize;
-            unsafe fn pthread_self() -> *const ffi::c_void;
+        extern "C" {
+            fn pthread_get_stacksize_np(thread: *const ffi::c_void) -> usize;
+            fn pthread_self() -> *const ffi::c_void;
         }
 
         // build.rs is executed on the main thread, so we are getting the main thread's stack size.
         // Modern macOS versions default to an 8 MiB main stack but legacy OS X have a 0.5 MiB one.
         let stack_size = unsafe { pthread_get_stacksize_np(pthread_self()) };
         const TWO_MIB: usize = 2 * 1024 * 1024 - 1;
-        stack_size <= TWO_MIB
+        match stack_size {
+            0..=TWO_MIB => Ok(true),
+            _ => Ok(false),
+        }
     }
 }
 
 fn setup_paths() {
+    #[cfg(unix)]
+    use std::path::PathBuf;
     #[cfg(windows)]
     use unix_path::{Path, PathBuf};
 
-    fn overridable_path(
-        env_var_name: &str,
-        f: impl FnOnce(Option<String>) -> Option<PathBuf>,
-    ) -> Option<PathBuf> {
-        rsconf::rebuild_if_env_changed(env_var_name);
-        let maybe_path = f(env_var(env_var_name));
-        if let Some(path) = maybe_path.as_ref() {
-            rsconf::set_env_value(env_var_name, path.to_str().unwrap());
+    fn get_path(name: &str, default: &str, onvar: &Path) -> PathBuf {
+        let mut var = PathBuf::from(env::var(name).unwrap_or(default.to_string()));
+        if var.is_relative() {
+            var = onvar.join(var);
         }
-        maybe_path
+        var
     }
 
-    fn join_if_relative(parent_if_relative: &Path, path: String) -> PathBuf {
-        let path = PathBuf::from(path);
-        if path.is_relative() {
-            parent_if_relative.join(path)
-        } else {
-            path
-        }
+    let (prefix_from_home, prefix) = if let Ok(pre) = env::var("PREFIX") {
+        (false, PathBuf::from(pre))
+    } else {
+        (true, PathBuf::from(".local/"))
+    };
+
+    // If someone gives us a $PREFIX, we need it to be absolute.
+    // Otherwise we would try to get it from $HOME and that won't really work.
+    if !prefix_from_home && prefix.is_relative() {
+        panic!("Can't have relative prefix");
     }
 
-    let prefix = overridable_path("PREFIX", |env_prefix| {
-        Some(PathBuf::from(env_prefix.unwrap_or("/usr/local".to_owned())))
-    })
-    .unwrap();
+    rsconf::rebuild_if_env_changed("PREFIX");
+    rsconf::set_env_value("PREFIX", prefix.to_str().unwrap());
 
-    overridable_path("SYSCONFDIR", |env_sysconfdir| {
-        Some(join_if_relative(
-            &prefix,
-            env_sysconfdir.unwrap_or("/etc/".to_owned()),
-        ))
-    });
+    let datadir = get_path("DATADIR", "share/", &prefix);
+    rsconf::set_env_value("DATADIR", datadir.to_str().unwrap());
+    rsconf::rebuild_if_env_changed("DATADIR");
 
-    let datadir = overridable_path("DATADIR", |env_datadir| {
-        env_datadir.map(|p| join_if_relative(&prefix, p))
-    });
-    overridable_path("BINDIR", |env_bindir| {
-        env_bindir.map(|p| join_if_relative(&prefix, p))
-    });
-    overridable_path("DOCDIR", |env_docdir| {
-        env_docdir.map(|p| {
-            join_if_relative(
-                &datadir
-                    .expect("Setting DOCDIR without setting DATADIR is not currently supported"),
-                p,
-            )
-        })
-    });
+    let datadir_subdir = if prefix_from_home {
+        "fish/install"
+    } else {
+        "fish"
+    };
+    rsconf::set_env_value("DATADIR_SUBDIR", datadir_subdir);
+
+    let bindir = get_path("BINDIR", "bin/", &prefix);
+    rsconf::set_env_value("BINDIR", bindir.to_str().unwrap());
+    rsconf::rebuild_if_env_changed("BINDIR");
+
+    let sysconfdir = get_path(
+        "SYSCONFDIR",
+        // If we get our prefix from $HOME, we should use the system's /etc/
+        // ~/.local/share/etc/ makes no sense
+        if prefix_from_home { "/etc/" } else { "etc/" },
+        &datadir,
+    );
+    rsconf::set_env_value("SYSCONFDIR", sysconfdir.to_str().unwrap());
+    rsconf::rebuild_if_env_changed("SYSCONFDIR");
+
+    let localedir = get_path("LOCALEDIR", "locale/", &datadir);
+    rsconf::set_env_value("LOCALEDIR", localedir.to_str().unwrap());
+    rsconf::rebuild_if_env_changed("LOCALEDIR");
+
+    let docdir = get_path("DOCDIR", "doc/fish", &datadir);
+    rsconf::set_env_value("DOCDIR", docdir.to_str().unwrap());
+    rsconf::rebuild_if_env_changed("DOCDIR");
 }
 
-fn get_version() -> String {
+fn get_version(src_dir: &Path) -> String {
+    use std::fs::read_to_string;
     use std::process::Command;
-    String::from_utf8(
-        Command::new("build_tools/git_version_gen.sh")
-            .output()
-            .unwrap()
-            .stdout,
-    )
-    .unwrap()
-    .trim_ascii_end()
-    .to_owned()
+
+    if let Ok(var) = std::env::var("FISH_BUILD_VERSION") {
+        return var;
+    }
+
+    let path = src_dir.join("version");
+    if let Ok(strver) = read_to_string(path) {
+        return strver.to_string();
+    }
+
+    let args = &["describe", "--always", "--dirty=-dirty"];
+    if let Ok(output) = Command::new("git").args(args).output() {
+        let rev = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        if !rev.is_empty() {
+            // If it contains a ".", we have a proper version like "3.7",
+            // or "23.2.1-1234-gfab1234"
+            if rev.contains('.') {
+                return rev;
+            }
+            // If it doesn't, we probably got *just* the commit SHA,
+            // like "f1242abcdef".
+            // So we prepend the crate version so it at least looks like
+            // "3.8-gf1242abcdef"
+            // This lacks the commit *distance*, but that can't be helped without
+            // tags.
+            let version = env!("CARGO_PKG_VERSION").to_owned();
+            return version + "-g" + &rev;
+        }
+    }
+
+    // git did not tell us a SHA either because it isn't installed,
+    // or because it refused (safe.directory applies to `git describe`!)
+    // So we read the SHA ourselves.
+    fn get_git_hash() -> Result<String, Box<dyn std::error::Error>> {
+        let gitdir = Path::new(env!("CARGO_MANIFEST_DIR")).join(".git");
+        let jjdir = Path::new(env!("CARGO_MANIFEST_DIR")).join(".jj");
+        let commit_id = if gitdir.exists() {
+            // .git/HEAD contains ref: refs/heads/branch
+            let headpath = gitdir.join("HEAD");
+            let headstr = read_to_string(headpath)?;
+            let headref = headstr.split(' ').nth(1).unwrap().trim();
+
+            // .git/refs/heads/branch contains the SHA
+            let refpath = gitdir.join(headref);
+            // Shorten to 9 characters (what git describe does currently)
+            read_to_string(refpath)?
+        } else if jjdir.exists() {
+            let output = Command::new("jj")
+                .args([
+                    "log",
+                    "--revisions",
+                    "@",
+                    "--no-graph",
+                    "--ignore-working-copy",
+                    "--template",
+                    "commit_id",
+                ])
+                .output()
+                .unwrap();
+            String::from_utf8_lossy(&output.stdout).to_string()
+        } else {
+            return Err("did not find either of .git or .jj".into());
+        };
+        let refstr = &commit_id[0..9];
+        let refstr = refstr.trim();
+
+        let version = env!("CARGO_PKG_VERSION").to_owned();
+        Ok(version + "-g" + refstr)
+    }
+
+    get_git_hash().expect("Could not get a version. Either set $FISH_BUILD_VERSION or install git.")
+}
+
+#[cfg(feature = "embed-data")]
+// disable clippy because otherwise it would panic without sphinx
+#[cfg(not(clippy))]
+fn build_man(build_dir: &Path) {
+    use std::process::Command;
+    let mandir = build_dir;
+    let sec1dir = mandir.join("man1");
+    let docsrc_path = std::fs::canonicalize(env!("CARGO_MANIFEST_DIR"))
+        .unwrap()
+        .as_path()
+        .join("doc_src");
+    let docsrc = docsrc_path.to_str().unwrap();
+    let args = &[
+        "-j",
+        "auto",
+        "-q",
+        "-b",
+        "man",
+        "-c",
+        docsrc,
+        // doctree path - put this *above* the man1 dir to exclude it.
+        // this is ~6M
+        "-d",
+        mandir.to_str().unwrap(),
+        docsrc,
+        sec1dir.to_str().unwrap(),
+    ];
+    let _ = std::fs::create_dir_all(sec1dir.to_str().unwrap());
+
+    rsconf::rebuild_if_env_changed("FISH_BUILD_DOCS");
+    if env::var("FISH_BUILD_DOCS") == Ok("0".to_string()) {
+        println!("cargo:warning=Skipping man pages because $FISH_BUILD_DOCS is set to 0");
+        return;
+    }
+
+    // We run sphinx to build the man pages.
+    // Every error here is fatal so cargo doesn't cache the result
+    // - if we skipped the docs with sphinx not installed, installing it would not then build the docs.
+    // That means you need to explicitly set $FISH_BUILD_DOCS=0 (`FISH_BUILD_DOCS=0 cargo install --path .`),
+    // which is unfortunate - but the docs are pretty important because they're also used for --help.
+    match Command::new("sphinx-build").args(args).spawn() {
+        Err(x) if x.kind() == std::io::ErrorKind::NotFound => {
+            if env::var("FISH_BUILD_DOCS") == Ok("1".to_string()) {
+                panic!("Could not find sphinx-build to build man pages.\nInstall sphinx or disable building the docs by setting $FISH_BUILD_DOCS=0.");
+            }
+            println!("cargo:warning=Cannot find sphinx-build to build man pages.");
+            println!("cargo:warning=If you install it now you need to run `cargo clean` and rebuild, or set $FISH_BUILD_DOCS=1 explicitly.");
+        }
+        Err(x) => {
+            // Another error - permissions wrong etc
+            panic!("Error starting sphinx-build to build man pages: {:?}", x);
+        }
+        Ok(mut x) => match x.wait() {
+            Err(err) => {
+                panic!(
+                    "Error waiting for sphinx-build to build man pages: {:?}",
+                    err
+                );
+            }
+            Ok(out) => {
+                if out.success() {
+                    // Success!
+                    return;
+                } else {
+                    panic!("sphinx-build failed to build the man pages.");
+                }
+            }
+        },
+    }
 }

build_tools/check.sh

@@ -1,174 +0,0 @@
-#!/bin/sh
-
-{
-set -ex
-
-lint=true
-if [ "$FISH_CHECK_LINT" = false ]; then
-    lint=false
-fi
-
-case "$(uname)" in
-    MSYS*)
-        is_cygwin=true
-        cygwin_var=MSYS
-        ;;
-    CYGWIN*)
-        is_cygwin=true
-        cygwin_var=CYGWIN
-        ;;
-    *)
-        is_cygwin=false
-        ;;
-esac
-
-check_dependency_versions=false
-if [ "${FISH_CHECK_DEPENDENCY_VERSIONS:-false}" != false ]; then
-    check_dependency_versions=true
-fi
-
-green='\e[0;32m'
-yellow='\e[1;33m'
-reset='\e[m'
-
-if $check_dependency_versions; then
-    command -v curl
-    command -v jq
-    command -v rustup
-    command -v uv
-    sort --version-sort </dev/null
-    # To match existing behavior, only check Rust/dockerfiles for now.
-    # TODO: remove this from this script.
-    updatecli diff --config=updatecli.d/docker.yml --config=updatecli.d/rust.yml
-fi
-
-cargo_args=$FISH_CHECK_CARGO_ARGS
-target_triple=$FISH_CHECK_TARGET_TRIPLE
-if [ -n "$target_triple" ]; then
-    cargo_args="$cargo_args --target=$FISH_CHECK_TARGET_TRIPLE"
-fi
-
-cargo() {
-    subcmd=$1
-    shift
-    if [ -n "$FISH_CHECK_RUST_TOOLCHAIN" ]; then
-        # shellcheck disable=2086
-        command cargo "+$FISH_CHECK_RUST_TOOLCHAIN" "$subcmd" $cargo_args "$@"
-    else
-        # shellcheck disable=2086
-        command cargo "$subcmd" $cargo_args "$@"
-    fi
-}
-
-# shellcheck disable=2317,2329
-cleanup () {
-    if [ -n "$fluent_extraction_dir" ] && [ -e "$fluent_extraction_dir" ]; then
-        rm -r "$fluent_extraction_dir"
-    fi
-    if [ -n "$gettext_template_dir" ] && [ -e "$gettext_template_dir" ]; then
-        rm -r "$gettext_template_dir"
-    fi
-}
-
-trap cleanup EXIT INT TERM HUP
-
-if $lint; then
-    export RUSTFLAGS="--deny=warnings ${RUSTFLAGS}"
-    export RUSTDOCFLAGS="--deny=warnings ${RUSTDOCFLAGS}"
-fi
-
-workspace_root="$(dirname "$0")/.."
-target_dir=${CARGO_TARGET_DIR:-$workspace_root/target}
-if [ -n "$target_triple" ]; then
-    target_dir="$target_dir/$target_triple"
-fi
-# The directory containing the binaries produced by cargo/rustc.
-# Currently, all builds are debug builds.
-build_dir="$target_dir/debug"
-
-if [ -n "$FISH_TEST_MAX_CONCURRENCY" ]; then
-    export RUST_TEST_THREADS="$FISH_TEST_MAX_CONCURRENCY"
-    export CARGO_BUILD_JOBS="$FISH_TEST_MAX_CONCURRENCY"
-fi
-
-fluent_extraction_dir=$(mktemp -d)
-gettext_template_dir=$(mktemp -d)
-(
-    # shellcheck disable=2030
-    export FISH_FLUENT_EXTRACTION_DIR="$fluent_extraction_dir"
-    # shellcheck disable=2030
-    export FISH_GETTEXT_EXTRACTION_DIR="$gettext_template_dir"
-    cargo build --workspace --all-targets --features=fluent-extract,gettext-extract
-)
-if $lint; then
-    if command -v cargo-deny >/dev/null; then
-        cargo deny --all-features --locked --exclude-dev check licenses
-    fi
-
-    if command -v shellcheck >/dev/null || { test -n "$CI" && ! $is_cygwin; }; then
-        cargo xtask shellcheck
-    fi
-
-    PATH="$build_dir:$PATH" cargo xtask format --all --check
-    for features in "" --no-default-features --all-features; do
-        cargo clippy --workspace --all-targets $features
-    done
-
-    cargo xtask gettext --rust-extraction-dir="$gettext_template_dir" check
-fi
-
-# An outdated `en.ftl` or translations using variables not provided by the source could crash fish,
-# so don't treat this as a lint.
-cargo xtask fluent check --from-source="$fluent_extraction_dir"
-
-# When running `cargo test`, some binaries (e.g. `fish_gettext_extraction`)
-# are dynamically linked against Rust's `std-xxx.dll` instead of being
-# statically link as they usually are.
-# On Cygwin, `PATH`is not properly updated to point to the `std-xxx.dll`
-# location, so we have to do it manually.
-# See:
-# - https://github.com/rust-lang/rust/issues/149050
-# - https://github.com/msys2/MSYS2-packages/issues/5784
-(
-    if $is_cygwin; then
-        PATH="$PATH:$(rustc --print target-libdir)"
-        export PATH
-    fi
-    # shellcheck disable=2031
-    export FISH_FLUENT_EXTRACTION_DIR="$fluent_extraction_dir"
-    cargo test --no-default-features --workspace --all-targets
-)
-cargo test --doc --workspace
-
-if $lint; then
-    cargo doc --workspace --no-deps
-fi
-
-system_tests() {
-    "$workspace_root/tests/test_driver.py" "$build_dir" "$@"
-}
-
-if $is_cygwin; then
-    # shellcheck disable=2059
-    printf "=== Running ${green}integration tests ${yellow}with${green} symlinks${reset}\n"
-    (
-        export "$cygwin_var"=winsymlinks
-        system_tests
-    )
-
-    # shellcheck disable=2059
-    printf "=== Running ${green}integration tests ${yellow}without${green} symlinks${reset}\n"
-    (
-        # Only redo the tests that use `ln` to saves some time
-        export "$cygwin_var"=
-        # shellcheck disable=2046
-        system_tests $(grep -l -E '\bln\b' -r tests/checks/)
-    )
-else
-    # shellcheck disable=2059
-    printf "=== Running ${green}integration tests${reset}\n"
-    system_tests
-fi
-
-exit
-}

build_tools/diff_profiles.fish

@@ -5,13 +5,6 @@
 #
 # Usage: ./diff_profiles.fish profile1.log profile2.log > profile_diff.log
 
-if test (count $argv) -ne 2
-
-    echo "Incorrect number of arguments."
-    echo "Usage: "(status filename)" profile1.log profile2.log"
-    exit 1
-end
-
 set -l profile1 (cat $argv[1])
 set -l profile2 (cat $argv[2])
 
@@ -22,13 +15,13 @@ while set -l next_line_no (math $line_no + 1) && set -q profile1[$next_line_no]
     set -l line1 $profile1[$line_no]
     set -l line2 $profile2[$line_no]
 
-    if not string match -qr '^\s*\d+\s+\d+' $line1
+    if not string match -qr '^\d+\t\d+' $line1
         echo $line1
         continue
     end
 
-    set -l results1 (string match -r '^\s*(\d+)\s+(\d+)\s+(.*)' $line1)
-    set -l results2 (string match -r '^\s*(\d+)\s+(\d+)\s+(.*)' $line2)
+    set -l results1 (string match -r '^(\d+)\t(\d+)\s+(.*)' $line1)
+    set -l results2 (string match -r '^(\d+)\t(\d+)\s+(.*)' $line2)
 
     # times from both files
     set -l time1 $results1[2..3]
@@ -49,5 +42,5 @@ while set -l next_line_no (math $line_no + 1) && set -q profile1[$next_line_no]
     set diff[1] (math $time1[1] - $time2[1])
     set diff[2] (math $time1[2] - $time2[2])
 
-    printf '%10d %10d %s\n' $diff[1] $diff[2] $remainder1
+    echo $diff[1] $diff[2] $remainder1
 end

build_tools/extract_help_sections.fish

@@ -0,0 +1,23 @@
+#!/usr/bin/env fish
+# Build a list of all sections in the html sphinx docs, separately by page,
+# so it can be added to share/functions/help.fish
+# Use like
+#    fish extract_help_sections.fish user_doc/html/{fish_for_bash_users.html,faq.html,interactive.html,language.html,tutorial.html}
+# TODO: Currently `help` uses variable names we can't generate, so it needs to be touched up manually.
+# Also this could easily be broken by changes in sphinx, ideally we'd have a way to let it print the section titles.
+#
+
+for file in $argv
+    set -l varname (string replace -r '.*/(.*).html' '$1' -- $file | string escape --style=var)pages
+    # Technically we can use any id in the document as an anchor, but listing them all is probably too much.
+    # Sphinx stores section titles (in a slug-ized form) in the id,
+    # and stores explicit section links in a `span` tag like
+    # `<span id="identifiers"></span>`
+    # We extract both separately.
+    set -l sections (string replace -rf '.*class="headerlink" href="#([^"]*)".*' '$1' <$file)
+    # Sections titled "id5" and such are internal cruft and shouldn't be offered.
+    set -a sections (string replace -rf '.*span id="([^"]*)".*' '$1' <$file | string match -rv 'id\d+')
+
+    set sections (printf '%s\n' $sections | sort -u)
+    echo set -l $varname $sections
+end

build_tools/fish_xgettext.fish

@@ -0,0 +1,68 @@
+#!/usr/bin/env fish
+#
+# Tool to generate messages.pot
+
+# Create temporary directory for these operations. OS X `mktemp` is somewhat restricted, so this block
+# works around that - based on share/functions/funced.fish.
+set -q TMPDIR
+or set -l TMPDIR /tmp
+set -l tmpdir (mktemp -d $TMPDIR/fish.XXXXXX)
+or exit 1
+
+# This is a gigantic crime.
+# xgettext still does not support rust *at all*, so we use cargo-expand to get all our wgettext invocations.
+set -l expanded (cargo expand --lib; for f in fish{,_indent,_key_reader}; cargo expand --bin $f; end)
+
+# Extract any gettext call
+set -l strs (printf '%s\n' $expanded | grep -A1 wgettext_static_str |
+             grep 'widestring::internals::core::primitive::str =' |
+             string match -rg '"(.*)"' | string match -rv '^%ls$|^$' |
+             # escaping difference between gettext and cargo-expand: single-quotes
+             string replace -a "\'" "'" | sort -u)
+
+# Extract any constants
+set -a strs (string match -rv 'BUILD_VERSION:|PACKAGE_NAME' -- $expanded |
+             string match -rg 'const [A-Z_]*: &str = "(.*)"' | string replace -a "\'" "'")
+
+# We construct messages.pot ourselves instead of forcing this into msgmerge or whatever.
+# The escaping so far works out okay.
+for str in $strs
+    # grep -P needed for string escape to be compatible (PCRE-style),
+    # -H gives the filename, -n the line number.
+    # If you want to run this on non-GNU grep: Don't.
+    echo "#:" (grep -PHn -r -- (string escape --style=regex -- $str) src/ |
+    head -n1 | string replace -r ':\s.*' '')
+    echo "msgid \"$str\""
+    echo 'msgstr ""'
+end >messages.pot
+
+# This regex handles descriptions for `complete` and `function` statements. These messages are not
+# particularly important to translate. Hence the "implicit" label.
+set -l implicit_regex '(?:^| +)(?:complete|function).*? (?:-d|--description) (([\'"]).+?(?<!\\\\)\\2).*'
+
+# This regex handles explicit requests to translate a message. These are more important to translate
+# than messages which should be implicitly translated.
+set -l explicit_regex '.*\( *_ (([\'"]).+?(?<!\\\\)\\2) *\).*'
+
+mkdir -p $tmpdir/implicit/share/completions $tmpdir/implicit/share/functions
+mkdir -p $tmpdir/explicit/share/completions $tmpdir/explicit/share/functions
+
+for f in share/config.fish share/completions/*.fish share/functions/*.fish
+    # Extract explicit attempts to translate a message. That is, those that are of the form
+    # `(_ "message")`.
+    string replace --filter --regex $explicit_regex '$1' <$f | string unescape \
+        | string replace --all '"' '\\"' | string replace -r '(.*)' 'N_ "$1"' >$tmpdir/explicit/$f
+
+    # Handle `complete` / `function` description messages. The `| fish` is subtle. It basically
+    # avoids the need to use `source` with a command substitution that could affect the current
+    # shell.
+    string replace --filter --regex $implicit_regex '$1' <$f | string unescape \
+        | string replace --all '"' '\\"' | string replace -r '(.*)' 'N_ "$1"' >$tmpdir/implicit/$f
+end
+
+xgettext -j -k -kN_ -LShell --from-code=UTF-8 -cDescription --no-wrap -o messages.pot $tmpdir/{ex,im}plicit/share/*/*.fish
+
+# Remove the tmpdir from the location to avoid churn
+sed -i 's_^#: /.*/share/_#: share/_' messages.pot
+
+rm -r $tmpdir

build_tools/git_version_gen.sh

@@ -1,22 +1,70 @@
 #!/bin/sh
 # Originally from the git sources (GIT-VERSION-GEN)
+# Presumably (C) Junio C Hamano <junkio@cox.net>
+# Reused under GPL v2.0
+# Modified for fish by David Adam <zanchey@ucc.gu.uwa.edu.au>
 
 set -e
 
 # Find the fish directory as two levels up from script directory.
 FISH_BASE_DIR="$( cd "$( dirname "$( dirname "$0" )" )" && pwd )"
+DEF_VER=unknown
+git_permission_failed=0
 
-version=$(
-    awk <"$FISH_BASE_DIR/Cargo.toml" -F'"' '$1 == "version = " { print $2 }'
-)
-if git_version=$(
-    GIT_CEILING_DIRECTORIES=$FISH_BASE_DIR/.. \
-        git -C "$FISH_BASE_DIR" describe --always --dirty 2>/dev/null); then
-    if [ "$git_version" = "${git_version#"$version"}" ]; then
-        version=$version-g$git_version
+# First see if there is a version file (included in release tarballs),
+# then try git-describe, then default.
+if test -f version
+then
+	VN=$(cat version) || VN="$DEF_VER"
+else
+    if VN=$(git -C "$FISH_BASE_DIR" describe --always --dirty 2>/dev/null); then
+       :
     else
-        version=$git_version
+        if test $? = 128; then
+            # Current git versions return status 128
+            # when run in a repo owned by another user.
+            # Even for describe and everything.
+            # This occurs for `sudo make install`.
+            git_permission_failed=1
+        fi
+	    VN="$DEF_VER"
     fi
 fi
 
-echo "$version"
+# If the first param is --stdout, then output to stdout and exit.
+if test "$1" = '--stdout'
+then
+	echo $VN
+    exit 0
+fi
+
+# Set the output directory as either the first param or cwd.
+test -n "$1" && OUTPUT_DIR=$1/ || OUTPUT_DIR=
+FBVF="${OUTPUT_DIR}FISH-BUILD-VERSION-FILE"
+
+if test "$VN" = unknown && test -r "$FBVF" && test "$git_permission_failed" = 1
+then
+    # HACK: Git failed, so we keep the current version file.
+    # This helps in case you built fish as a normal user
+    # and then try to `sudo make install` it.
+    date +%s > "${OUTPUT_DIR}"fish-build-version-witness.txt
+    exit 0
+fi
+
+if test -r "$FBVF"
+then
+	VC=$(cat "$FBVF")
+else
+	VC="unset"
+fi
+
+# Maybe output the FBVF
+# It looks like "2.7.1-621-ga2f065e6"
+test "$VN" = "$VC" || {
+	echo >&2 "$VN"
+	echo "$VN" >"$FBVF"
+}
+
+# Output the fish-build-version-witness.txt
+# See https://cmake.org/cmake/help/v3.4/policy/CMP0058.html
+date +%s > "${OUTPUT_DIR}"fish-build-version-witness.txt

build_tools/lsan_suppressions.txt

@@ -1 +1,3 @@
-leak:fish_fluent::AVAILABLE_LANGUAGES
+# LSAN can detect leaks tracing back to __asan::AsanThread::ThreadStart (probably caused by our
+# threads not exiting before their TLS dtors are called). Just ignore it.
+leak:AsanThread

build_tools/make_linux_packages.sh

@@ -1,83 +0,0 @@
-#!/bin/sh
-
-# This script takes a source tarball (from build_tools/make_tarball.sh) and a vendor tarball (from
-# build_tools/make_vendor_tarball.sh, generated if not present), and produces:
-# * Appropriately-named symlinks to look like a Debian package
-# * Debian .changes and .dsc files with plain names ($version-1) and supported Ubuntu prefixes
-#   ($version-1~somedistro)
-# * An RPM spec file
-# By default, input and output files go in ~/fish_built, but this can be controlled with the
-# FISH_ARTEFACT_PATH environment variable.
-
-{
-
-set -e
-
-version=$1
-[ -n "$version" ] || { echo "Version number required as argument" >&2; exit 1; }
-
-
-[ -n "$DEB_SIGN_KEYID$DEB_SIGN_KEYFILE" ] ||
-    echo "Warning: neither DEB_SIGN_KEYID or DEB_SIGN_KEYFILE environment variables are set; you
-will need a signing key for the author of the most recent debian/changelog entry." >&2
-
-workpath=${FISH_ARTEFACT_PATH:-~/fish_built}
-source_tarball="$workpath"/fish-"$version".tar.xz
-vendor_tarball="$workpath"/fish-"$version"-vendor.tar.xz
-
-[ -e "$source_tarball" ] || { echo "Missing source tarball, expected at $source_tarball" >&2; exit 1; }
-cd "$workpath"
-
-# Unpack the sources
-tar xf "$source_tarball"
-sourcepath="$workpath"/fish-"$version"
-
-# Generate the vendor tarball if it is not already present
-[ -e "$vendor_tarball" ] || (cd "$sourcepath"; build_tools/make_vendor_tarball.sh;)
-
-# This step requires network access, so do it early in case it fails
-# sh has no real array support
-ubuntu_versions=$(uv run --script "$sourcepath"/build_tools/supported_ubuntu_versions.py)
-
-# Write the specfile
-[ -e "$workpath"/fish.spec ] && { echo "Cowardly refusing to overwite an existing fish.spec" >&2;
-exit 1; }
-rpmversion=$(echo "$version" |sed -e 's/-/+/' -e 's/-/./g')
-sed -e "s/@version@/$version/g" -e "s/@rpmversion@/$rpmversion/g" \
-    < "$sourcepath"/fish.spec.in > "$workpath"/fish.spec
-
-# Make the symlinks for Debian
-ln -s "$source_tarball" "$workpath"/fish_"$version".orig.tar.xz
-ln -s "$vendor_tarball" "$workpath"/fish_"$version".orig-cargo-vendor.tar.xz
-
-# Set up the Debian source tree
-cd "$sourcepath"
-mkdir cargo-vendor
-tar -C cargo-vendor -x -f "$vendor_tarball"
-cp -r contrib/debian debian
-
-# The vendor tarball contains a new .cargo/config.toml, which has the
-# vendoring overrides appended to it. dpkg-source will add this as a
-# patch using the flags in debian/
-cp cargo-vendor/.cargo/config.toml .cargo/config.toml
-
-# Update the Debian changelog
-# The release scripts do this for release builds - skip if it has already been done
-if head -n1 debian/changelog | grep --invert-match --quiet --fixed-strings "$version"; then
-    debchange --newversion "$version-1" --distribution unstable "Snapshot build"
-fi
-
-# Builds the "plain" Debian package
-# debuild runs lintian, which takes ten minutes to run over the vendor directories
-# just use dpkg-buildpackage directly
-dpkg-buildpackage --build=source -d
-
-# Build the Ubuntu packages
-# deb-reversion does not work on source packages, so do the whole thing ourselves
-for series in $ubuntu_versions; do
-    sed -i -e "1 s/$version-1)/$version-1~$series)/" -e "1 s/unstable/$series/" debian/changelog
-    dpkg-buildpackage --build=source -d
-    sed -i -e "1 s/$version-1~$series)/$version-1)/" -e "1 s/$series/unstable/" debian/changelog
-done
-
-}

build_tools/make_macos_pkg.sh

@@ -1,164 +0,0 @@
-#!/usr/bin/env bash
-
-# Script to produce an OS X installer .pkg and .app(.zip)
-
-usage() {
-    echo "Build macOS packages, optionally signing and notarizing them."
-    echo "Usage: $0 options"
-    echo "Options:"
-    echo "  -s                            Enables code signing"
-    echo "  -f <APP_KEY.p12>              Path to .p12 file for application signing"
-    echo "  -i <INSTALLER_KEY.p12>        Path to .p12 file for installer signing"
-    echo "  -p <PASSWORD>                 Password for the .p12 files (necessary to access the certificates)"
-    echo "  -e <entitlements file>        (Optional) Path to an entitlements XML file"
-    echo "  -n                            Enables notarization. This will fail if code signing is not also enabled."
-    echo "  -j <API_KEY.JSON>             Path to JSON file generated with \`rcodesign encode-app-store-connect-api-key\` (required for notarization)"
-    echo
-    exit 1
-}
-
-set -x
-set -e
-
-SIGN=
-NOTARIZE=
-
-ARM64_DEPLOY_TARGET='MACOSX_DEPLOYMENT_TARGET=11.0'
-X86_64_DEPLOY_TARGET='MACOSX_DEPLOYMENT_TARGET=10.12'
-cmake_args=()
-
-while getopts "c:sf:i:p:e:nj:" opt; do
-    case $opt in
-        c) cmake_args+=("$OPTARG");;
-        s) SIGN=1;;
-        f) P12_APP_FILE=$(realpath "$OPTARG");;
-        i) P12_INSTALL_FILE=$(realpath "$OPTARG");;
-        p) P12_PASSWORD="$OPTARG";;
-        e) ENTITLEMENTS_FILE=$(realpath "$OPTARG");;
-        n) NOTARIZE=1;;
-        j) API_KEY_FILE=$(realpath "$OPTARG");;
-        \?) usage;;
-    esac
-done
-
-if [ -n "$SIGN" ] && { [ -z "$P12_APP_FILE" ] || [ -z "$P12_INSTALL_FILE" ] || [ -z "$P12_PASSWORD" ]; }; then
-    usage
-fi
-
-if [ -n "$NOTARIZE" ] && [ -z "$API_KEY_FILE" ]; then
-    usage
-fi
-
-VERSION=$(build_tools/git_version_gen.sh)
-
-echo "Version is $VERSION"
-
-PKGDIR=$(mktemp -d)
-echo "$PKGDIR"
-
-SRC_DIR=$PWD
-OUTPUT_PATH=${FISH_ARTEFACT_PATH:-~/fish_built}
-
-mkdir -p "$PKGDIR/build_x86_64" "$PKGDIR/build_arm64" "$PKGDIR/root" "$PKGDIR/intermediates" "$PKGDIR/dst"
-
-do_cmake() {
-    cmake \
-        -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-        -DCMAKE_EXE_LINKER_FLAGS="-Wl,-ld_classic" \
-        -DCMAKE_OSX_ARCHITECTURES='arm64;x86_64' \
-        -DFISH_USE_SYSTEM_PCRE2=OFF \
-        "${cmake_args[@]}" \
-        "$@" \
-        "$SRC_DIR"
-}
-
-# Build and install for arm64.
-# Pass FISH_USE_SYSTEM_PCRE2=OFF because a system PCRE2 on macOS will not be signed by fish,
-# and will probably not be built universal, so the package will fail to validate/run on other systems.
-# Note CMAKE_OSX_ARCHITECTURES is still relevant for the Mac app.
-{ cd "$PKGDIR/build_arm64" \
-    && do_cmake -DRust_CARGO_TARGET=aarch64-apple-darwin \
-    && env $ARM64_DEPLOY_TARGET make VERBOSE=1 -j 12 \
-    && env DESTDIR="$PKGDIR/root/" $ARM64_DEPLOY_TARGET make install;
-}
-
-# Build for x86-64 but do not install; instead we will make a fat binary inside the root.
-{ cd "$PKGDIR/build_x86_64" \
-    && do_cmake -DRust_CARGO_TARGET=x86_64-apple-darwin \
-    && env $X86_64_DEPLOY_TARGET make VERBOSE=1 -j 12; }
-
-# Fatten it up.
-FILE=$PKGDIR/root/usr/local/bin/fish
-X86_FILE=$PKGDIR/build_x86_64/$(basename "$FILE")
-rcodesign macho-universal-create --output "$FILE" "$FILE" "$X86_FILE"
-chmod 755 "$FILE"
-
-if test -n "$SIGN"; then
-    echo "Signing executables"
-    ARGS=(
-        --p12-file "$P12_APP_FILE"
-        --p12-password "$P12_PASSWORD"
-        --code-signature-flags runtime
-        --for-notarization
-    )
-    if [ -n "$ENTITLEMENTS_FILE" ]; then
-        ARGS+=(--entitlements-xml-file "$ENTITLEMENTS_FILE")
-    fi
-    (set +x; rcodesign sign "${ARGS[@]}" "$PKGDIR"/root/usr/local/bin/fish)
-fi
-
-pkgbuild --scripts "$SRC_DIR/build_tools/osx_package_scripts" --root "$PKGDIR/root/" --identifier 'com.ridiculousfish.fish-shell-pkg' --version "$VERSION" "$PKGDIR/intermediates/fish.pkg"
-productbuild  --package-path "$PKGDIR/intermediates" --distribution "$SRC_DIR/build_tools/osx_distribution.xml" --resources "$SRC_DIR/build_tools/osx_package_resources/" "$OUTPUT_PATH/fish-$VERSION.pkg"
-
-if test -n "$SIGN"; then
-    echo "Signing installer"
-    ARGS=(
-        --p12-file "$P12_INSTALL_FILE"
-        --p12-password "$P12_PASSWORD"
-        --code-signature-flags runtime
-        --for-notarization
-    )
-    (set +x; rcodesign sign "${ARGS[@]}" "$OUTPUT_PATH/fish-$VERSION.pkg")
-fi
-
-# Make the app
-(cd "$PKGDIR/build_arm64" && env $ARM64_DEPLOY_TARGET make -j 12 fish_macapp)
-(cd "$PKGDIR/build_x86_64" && env $X86_64_DEPLOY_TARGET make -j 12 fish_macapp)
-
-# Make the app's /usr/local/bin/fish binary universal. Note fish.app/Contents/MacOS/fish already is, courtesy of CMake.
-cd "$PKGDIR/build_arm64"
-FILE=fish.app/Contents/Resources/base/usr/local/bin/fish
-X86_FILE=$PKGDIR/build_x86_64/fish.app/Contents/Resources/base/usr/local/bin/$(basename "$FILE")
-rcodesign macho-universal-create --output "$FILE" "$FILE" "$X86_FILE"
-# macho-universal-create screws up the permissions.
-chmod 755 "$FILE"
-
-if test -n "$SIGN"; then
-    echo "Signing app"
-    ARGS=(
-        --p12-file "$P12_APP_FILE"
-        --p12-password "$P12_PASSWORD"
-        --code-signature-flags runtime
-        --for-notarization
-    )
-    if [ -n "$ENTITLEMENTS_FILE" ]; then
-        ARGS+=(--entitlements-xml-file "$ENTITLEMENTS_FILE")
-    fi
-    (set +x; rcodesign sign "${ARGS[@]}" "fish.app")
-
-fi
-
-cp -R "fish.app" "$OUTPUT_PATH/fish-$VERSION.app"
-cd "$OUTPUT_PATH"
-
-# Maybe notarize.
-if test -n "$NOTARIZE"; then
-    echo "Notarizing"
-    rcodesign notarize --staple --wait --max-wait-seconds 1800 --api-key-file "$API_KEY_FILE" "$OUTPUT_PATH/fish-$VERSION.pkg"
-    rcodesign notarize --staple --wait --max-wait-seconds 1800 --api-key-file "$API_KEY_FILE" "$OUTPUT_PATH/fish-$VERSION.app"
-fi
-
-# Zip it up.
-zip -r "fish-$VERSION.app.zip" "fish-$VERSION.app" && rm -Rf "fish-$VERSION.app"
-
-rm -rf "$PKGDIR"

build_tools/make_pkg.sh

@@ -1 +0,0 @@
-make_macos_pkg.sh

build_tools/make_pkg.sh

@@ -0,0 +1,183 @@
+#!/usr/bin/env bash
+
+# Script to produce an OS X installer .pkg and .app(.zip)
+
+usage() {
+  echo "Build macOS packages, optionally signing and notarizing them."
+  echo "Usage: $0 options"
+  echo "Options:"
+  echo "  -s                            Enables code signing"
+  echo "  -f <APP_KEY.p12>              Path to .p12 file for application signing"
+  echo "  -i <INSTALLER_KEY.p12>        Path to .p12 file for installer signing"
+  echo "  -p <PASSWORD>                 Password for the .p12 files (necessary to access the certificates)"
+  echo "  -e <entitlements file>        (Optional) Path to an entitlements XML file"
+  echo "  -n                            Enables notarization. This will fail if code signing is not also enabled."
+  echo "  -j <API_KEY.JSON>             Path to JSON file generated with \`rcodesign encode-app-store-connect-api-key\` (required for notarization)"
+  echo
+  exit 1
+}
+
+set -x
+set -e
+
+SIGN=
+NOTARIZE=
+
+ARM64_DEPLOY_TARGET='MACOSX_DEPLOYMENT_TARGET=11.0'
+X86_64_DEPLOY_TARGET='MACOSX_DEPLOYMENT_TARGET=10.9'
+
+# As of this writing, the most recent Rust release supports macOS back to 10.12.
+# The first supported version of macOS on arm64 is 10.15, so any Rust is fine for arm64.
+# We wish to support back to 10.9 on x86-64; the last version of Rust to support that is
+# version 1.73.0.
+RUST_VERSION_X86_64=1.73.0
+
+while getopts "sf:i:p:e:nj:" opt; do
+  case $opt in
+    s) SIGN=1;;
+    f) P12_APP_FILE=$(realpath "$OPTARG");;
+    i) P12_INSTALL_FILE=$(realpath "$OPTARG");;
+    p) P12_PASSWORD="$OPTARG";;
+    e) ENTITLEMENTS_FILE=$(realpath "$OPTARG");;
+    n) NOTARIZE=1;;
+    j) API_KEY_FILE=$(realpath "$OPTARG");;
+    \?) usage;;
+  esac
+done
+
+if [ -n "$SIGN" ] && { [ -z "$P12_APP_FILE" ] || [ -z "$P12_INSTALL_FILE" ] || [ -z "$P12_PASSWORD" ]; }; then
+  usage
+fi
+
+if [ -n "$NOTARIZE" ] && [ -z "$API_KEY_FILE" ]; then
+  usage
+fi
+
+VERSION=$(git describe --always --dirty 2>/dev/null)
+if test -z "$VERSION" ; then
+  echo "Could not get version from git"
+  if test -f version; then
+    VERSION=$(cat version)
+  fi
+fi
+
+echo "Version is $VERSION"
+
+PKGDIR=$(mktemp -d)
+echo "$PKGDIR"
+
+SRC_DIR=$PWD
+OUTPUT_PATH=${FISH_ARTEFACT_PATH:-~/fish_built}
+
+mkdir -p "$PKGDIR/build_x86_64" "$PKGDIR/build_arm64" "$PKGDIR/root" "$PKGDIR/intermediates" "$PKGDIR/dst"
+
+# Build and install for arm64.
+# Pass FISH_USE_SYSTEM_PCRE2=OFF because a system PCRE2 on macOS will not be signed by fish,
+# and will probably not be built universal, so the package will fail to validate/run on other systems.
+# Note CMAKE_OSX_ARCHITECTURES is still relevant for the Mac app.
+{ cd "$PKGDIR/build_arm64" \
+  && cmake \
+        -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+        -DCMAKE_EXE_LINKER_FLAGS="-Wl,-ld_classic" \
+        -DWITH_GETTEXT=OFF \
+        -DRust_CARGO_TARGET=aarch64-apple-darwin \
+        -DCMAKE_OSX_ARCHITECTURES='arm64;x86_64' \
+        -DFISH_USE_SYSTEM_PCRE2=OFF \
+        "$SRC_DIR" \
+    && env $ARM64_DEPLOY_TARGET make VERBOSE=1 -j 12 \
+    && env DESTDIR="$PKGDIR/root/" $ARM64_DEPLOY_TARGET make install;
+}
+
+# Build for x86-64 but do not install; instead we will make some fat binaries inside the root.
+# Set RUST_VERSION_X86_64 to the last version of Rust that supports macOS 10.9.
+{ cd "$PKGDIR/build_x86_64" \
+  && cmake \
+        -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+        -DCMAKE_EXE_LINKER_FLAGS="-Wl,-ld_classic" \
+        -DWITH_GETTEXT=OFF \
+        -DRust_TOOLCHAIN="$RUST_VERSION_X86_64" \
+        -DRust_CARGO_TARGET=x86_64-apple-darwin \
+        -DCMAKE_OSX_ARCHITECTURES='arm64;x86_64' \
+        -DFISH_USE_SYSTEM_PCRE2=OFF "$SRC_DIR" \
+  && env $X86_64_DEPLOY_TARGET make VERBOSE=1 -j 12; }
+
+# Fatten them up.
+for FILE in "$PKGDIR"/root/usr/local/bin/*; do
+    X86_FILE="$PKGDIR/build_x86_64/$(basename "$FILE")"
+    rcodesign macho-universal-create --output "$FILE" "$FILE" "$X86_FILE"
+    chmod 755 "$FILE"
+done
+
+if test -n "$SIGN"; then
+    echo "Signing executables"
+    ARGS=(
+        --p12-file "$P12_APP_FILE"
+        --p12-password "$P12_PASSWORD"
+        --code-signature-flags runtime
+        --for-notarization
+    )
+    if [ -n "$ENTITLEMENTS_FILE" ]; then
+        ARGS+=(--entitlements-xml-file "$ENTITLEMENTS_FILE")
+    fi
+    for FILE in "$PKGDIR"/root/usr/local/bin/*; do
+        (set +x; rcodesign sign "${ARGS[@]}" "$FILE")
+    done
+fi
+
+pkgbuild --scripts "$SRC_DIR/build_tools/osx_package_scripts" --root "$PKGDIR/root/" --identifier 'com.ridiculousfish.fish-shell-pkg' --version "$VERSION" "$PKGDIR/intermediates/fish.pkg"
+productbuild  --package-path "$PKGDIR/intermediates" --distribution "$SRC_DIR/build_tools/osx_distribution.xml" --resources "$SRC_DIR/build_tools/osx_package_resources/" "$OUTPUT_PATH/fish-$VERSION.pkg"
+
+if test -n "$SIGN"; then
+    echo "Signing installer"
+    ARGS=(
+        --p12-file "$P12_INSTALL_FILE"
+        --p12-password "$P12_PASSWORD"
+        --code-signature-flags runtime
+        --for-notarization
+    )
+    (set +x; rcodesign sign "${ARGS[@]}" "$OUTPUT_PATH/fish-$VERSION.pkg")
+fi
+
+# Make the app
+(cd "$PKGDIR/build_arm64" && env $ARM64_DEPLOY_TARGET make -j 12 fish_macapp)
+(cd "$PKGDIR/build_x86_64" && env $X86_64_DEPLOY_TARGET make -j 12 fish_macapp)
+
+# Make the app's /usr/local/bin binaries universal. Note fish.app/Contents/MacOS/fish already is, courtesy of CMake.
+cd "$PKGDIR/build_arm64"
+for FILE in fish.app/Contents/Resources/base/usr/local/bin/*; do
+    X86_FILE="$PKGDIR/build_x86_64/fish.app/Contents/Resources/base/usr/local/bin/$(basename "$FILE")"
+    rcodesign macho-universal-create --output "$FILE" "$FILE" "$X86_FILE"
+
+    # macho-universal-create screws up the permissions.
+    chmod 755 "$FILE"
+done
+
+if test -n "$SIGN"; then
+    echo "Signing app"
+    ARGS=(
+        --p12-file "$P12_APP_FILE"
+        --p12-password "$P12_PASSWORD"
+        --code-signature-flags runtime
+        --for-notarization
+    )
+    if [ -n "$ENTITLEMENTS_FILE" ]; then
+        ARGS+=(--entitlements-xml-file "$ENTITLEMENTS_FILE")
+    fi
+    (set +x; rcodesign sign "${ARGS[@]}" "fish.app")
+
+fi
+
+cp -R "fish.app" "$OUTPUT_PATH/fish-$VERSION.app"
+cd "$OUTPUT_PATH"
+
+# Maybe notarize.
+if test -n "$NOTARIZE"; then
+    echo "Notarizing"
+    rcodesign notarize --staple --wait --max-wait-seconds 1800 --api-key-file "$API_KEY_FILE" "$OUTPUT_PATH/fish-$VERSION.pkg"
+    rcodesign notarize --staple --wait --max-wait-seconds 1800 --api-key-file "$API_KEY_FILE" "$OUTPUT_PATH/fish-$VERSION.app"
+fi
+
+# Zip it up.
+zip -r "fish-$VERSION.app.zip" "fish-$VERSION.app" && rm -Rf "fish-$VERSION.app"
+
+rm -rf "$PKGDIR"

build_tools/make_tarball.sh

@@ -1,42 +1,79 @@
 #!/bin/sh
 
 # Script to generate a tarball
+# We use git to output a tree. But we also want to build the user documentation
+# and put that in the tarball, so that nobody needs to have sphinx installed
+# to build it.
 # Outputs to $FISH_ARTEFACT_PATH or ~/fish_built by default
 
+# Exit on error
 set -e
 
-# Get the version
-VERSION=$(build_tools/git_version_gen.sh)
+# We wil generate a tarball with a prefix "fish-VERSION"
+# git can do that automatically for us via git-archive
+# but to get the documentation in, we need to make a symlink called "fish-VERSION"
+# and tar from that, so that the documentation gets the right prefix
 
-prefix=fish-$VERSION
-path=${FISH_ARTEFACT_PATH:-~/fish_built}/$prefix.tar.xz
+# Use Ninja if available, as it automatically paralellises
+BUILD_TOOL="make"
+BUILD_GENERATOR="Unix Makefiles"
+if command -v ninja >/dev/null; then
+  BUILD_TOOL="ninja"
+  BUILD_GENERATOR="Ninja"
+fi
 
-tmpdir=$(mktemp -d)
-manifest=$tmpdir/Cargo.toml
-lockfile=$tmpdir/Cargo.lock
+# We need GNU tar as that supports the --mtime and --transform options
+TAR=notfound
+for try in tar gtar gnutar; do
+  if $try -Pcf /dev/null --mtime now /dev/null >/dev/null 2>&1; then
+    TAR=$try
+    break
+  fi
+done
 
-sed "s/^version = \".*\"\$/version = \"$VERSION\"/g" Cargo.toml >"$manifest"
-awk -v version="$VERSION" '
-    /^name = "fish"$/ { ok=1 }
-    ok == 1 && /^version = ".*"$/ {
-        ok = 2;
-        $0 = "version = \"" version "\"";
-    }
-    {print}
-    ' \
-    Cargo.lock >"$lockfile"
+if [ "$TAR" = "notfound" ]; then
+  echo 'No suitable tar (supporting --mtime) found as tar/gtar/gnutar in PATH'
+  exit 1
+fi
 
-git archive \
-    --prefix="$prefix/" \
-    --add-virtual-file="$prefix/Cargo.toml:$(cat "$manifest")" \
-    --add-virtual-file="$prefix/Cargo.lock:$(cat "$lockfile")" \
-    HEAD |
-    xz >"$path"
+# Get the current directory, which we'll use for symlinks
+wd="$PWD"
 
-rm "$manifest"
-rm "$lockfile"
-rmdir "$tmpdir"
+# Get the version from git-describe
+VERSION=$(git describe --dirty 2>/dev/null)
+
+# The name of the prefix, which is the directory that you get when you untar
+prefix="fish-$VERSION"
+
+# The path where we will output the tar file
+# Defaults to ~/fish_built
+path=${FISH_ARTEFACT_PATH:-~/fish_built}/$prefix.tar
+
+# Clean up stuff we've written before
+rm -f "$path" "$path".xz
+
+# git starts the archive
+git archive --format=tar --prefix="$prefix"/ HEAD > "$path"
+
+# tarball out the documentation, generate a version file
+PREFIX_TMPDIR=$(mktemp -d)
+cd "$PREFIX_TMPDIR"
+echo "$VERSION" > version
+cmake -G "$BUILD_GENERATOR" -DCMAKE_BUILD_TYPE=Debug "$wd"
+$BUILD_TOOL doc
+
+TAR_APPEND="$TAR --append --file=$path --mtime=now --owner=0 --group=0 \
+  --mode=g+w,a+rX --transform s/^/$prefix\//"
+$TAR_APPEND --no-recursion user_doc
+$TAR_APPEND user_doc/html user_doc/man
+$TAR_APPEND version
+
+cd -
+rm -r "$PREFIX_TMPDIR"
+
+# xz it
+xz "$path"
 
 # Output what we did, and the sha256 hash
-echo "Tarball written to $path"
-openssl dgst -sha256 "$path"
+echo "Tarball written to $path".xz
+openssl dgst -sha256 "$path".xz

build_tools/make_vendor_tarball.sh

@@ -8,11 +8,25 @@
 # Exit on error
 set -e
 
+# We need GNU tar as that supports the --mtime and --transform options
+TAR=notfound
+for try in tar gtar gnutar; do
+  if $try -Pcf /dev/null --mtime now /dev/null >/dev/null 2>&1; then
+    TAR=$try
+    break
+  fi
+done
+
+if [ "$TAR" = "notfound" ]; then
+  echo 'No suitable tar (supporting --mtime) found as tar/gtar/gnutar in PATH'
+  exit 1
+fi
+
 # Get the current directory, which we'll use for telling Cargo where to find the sources
 wd="$PWD"
 
 # Get the version from git-describe
-VERSION=$(build_tools/git_version_gen.sh)
+VERSION=$(git describe --dirty 2>/dev/null)
 
 # The name of the prefix, which is the directory that you get when you untar
 prefix="fish-$VERSION"
@@ -28,14 +42,8 @@ rm -f "$path" "$path".xz
 PREFIX_TMPDIR=$(mktemp -d)
 cd "$PREFIX_TMPDIR"
 
-# Add .cargo/config.toml. This means that the caller may need to remove that file from the tarball.
-# See e4674cd7b5f (.cargo/config.toml: exclude from tarball, 2025-01-12)
-
 mkdir .cargo
-{
-    cat "$wd"/.cargo/config.toml
-    cargo vendor --manifest-path "$wd/Cargo.toml"
-} > .cargo/config.toml
+cargo vendor --manifest-path "$wd/Cargo.toml" > .cargo/config.toml
 
 tar cfvJ "$path".xz vendor .cargo
 

build_tools/osx_package_resources/welcome.html

@@ -1,28 +1,28 @@
 <html>
-    <head>
-        <style>
-            body {
-                font-family: system-ui, -apple-system, "Helvetica Neue", sans-serif;
-                font-size: 10pt;
-            }
-            code, tt {
-                font-family: ui-monospace, Menlo, monospace;
-            }
-        </style>
-    </head>
-    <body>
-    <p>
-        <strong>fish</strong> is a smart and user-friendly command line shell. For more information, visit <a href="https://fishshell.com">fishshell.com</a>.
-    </p>
-    <p>
-        <strong>fish</strong> will be installed into <tt>/usr/local/</tt>, and its path will be added to <wbr><tt>/etc/shells</tt> if necessary.
-    </p>
-    <p>
-        Your default shell will <em>not</em> be changed. To make <strong>fish</strong> your login shell after the installation, run:
-    </p>
-    <p>
-    <code>chsh -s /usr/local/bin/fish</code>
-    </p>
-    <p>Enjoy! Bugs can be reported on <a href="https://github.com/fish-shell/fish-shell/">GitHub</a>.</p>
-    </body>
+	<head>
+		<style>
+			body {
+				font-family: system-ui, -apple-system, "Helvetica Neue", sans-serif;
+				font-size: 10pt;
+			}
+			code, tt {
+				font-family: ui-monospace, Menlo, monospace;
+			}
+		</style>
+	</head>
+	<body>
+	<p>
+		<strong>fish</strong> is a smart and user-friendly command line shell. For more information, visit <a href="https://fishshell.com">fishshell.com</a>.
+	</p>
+	<p>
+		<strong>fish</strong> will be installed into <tt>/usr/local/</tt>, and its path will be added to <wbr><tt>/etc/shells</tt> if necessary.
+	</p>
+	<p>
+		Your default shell will <em>not</em> be changed. To make <strong>fish</strong> your login shell after the installation, run:
+	</p>
+	<p>
+	<code>chsh -s /usr/local/bin/fish</code>
+	</p>
+	<p>Enjoy! Bugs can be reported on <a href="https://github.org/fish-shell/fish-shell/">GitHub</a>.</p>
+	</body>
 </html>

build_tools/osx_package_scripts/add-shell

@@ -4,14 +4,14 @@
 
 if test $# -eq 0
 then
-    echo "usage: $0 shellname [shellname ...]"
-    exit 1
+	echo "usage: $0 shellname [shellname ...]"
+	exit 1
 fi
 
 scriptname=$(basename "$0")
 if [ "$(id -u)" -ne 0 ]; then
-    echo "${scriptname} must be run as root"
-    exit 1
+     echo "${scriptname} must be run as root"
+     exit 1
 fi
 
 file=/etc/shells

build_tools/osx_package_scripts/preinstall

@@ -2,6 +2,6 @@
 
 echo "Removing any previous installation"
 pkgutil --pkg-info "${INSTALL_PKG_SESSION_ID}" && pkgutil --only-files --files "${INSTALL_PKG_SESSION_ID}" | while read -r installed
-    do rm -v "${DSTVOLUME}${installed}"
+     do rm -v "${DSTVOLUME}${installed}"
 done
 echo "... removed"

build_tools/release-notes.sh

@@ -1,113 +0,0 @@
-#!/bin/sh
-
-set -e
-
-workspace_root=$(dirname "$0")/..
-
-relnotes_tmp=$(mktemp -d)
-mkdir -p "$relnotes_tmp/fake-workspace" "$relnotes_tmp/out"
-(
-    cd "$workspace_root"
-    cp -r doc_src CONTRIBUTING.rst README.rst "$relnotes_tmp/fake-workspace"
-)
-version=$(sed 's,^fish \(\S*\) .*,\1,; 1q' "$workspace_root/CHANGELOG.rst")
-add_stats=false
-# Skip on shallow clone (CI) for now.
-if test -z "$CI" || [ "$(git -C "$workspace_root" tag | wc -l)" -gt 1 ]; then {
-    previous_version=$(
-        cd "$workspace_root"
-        git for-each-ref --format='%(objecttype) %(refname:strip=2)' refs/tags |
-            awk '/tag/ {print $2}' | sort --version-sort |
-            grep -vxF "$(git describe)" | tail -1
-    )
-    minor_version=${version%.*}
-    previous_minor_version=${previous_version%.*}
-    if [ "$minor_version" != "$previous_minor_version" ]; then
-        add_stats=true
-    fi
-} fi
-{
-    sed -n 1,2p <"$workspace_root/CHANGELOG.rst"
-    if $add_stats; then {
-        ExtractCommitters() {
-            git log "$1" --format="%aN"
-            trailers='Co-authored-by|Signed-off-by'
-            git log "$1" --format="%b" | sed -En "/^($trailers):\s*/{s///;s/\s*<.*//;p}"
-        }
-        ListCommitters() {
-            comm "$@" "$relnotes_tmp/committers-then" "$relnotes_tmp/committers-now"
-        }
-        (
-            cd "$workspace_root"
-            ExtractCommitters "$previous_version" | sort -u >"$relnotes_tmp/committers-then"
-            ExtractCommitters "$previous_version".. | sort -u >"$relnotes_tmp/committers-now"
-            ListCommitters -13 >"$relnotes_tmp/committers-new"
-            ListCommitters -12 >"$relnotes_tmp/committers-returning"
-            num_commits=$(git log --no-merges --format=%H "$previous_version".. | wc -l)
-            num_authors=$(wc -l <"$relnotes_tmp/committers-now")
-            num_new_authors=$(wc -l <"$relnotes_tmp/committers-new")
-            printf %s \
-                "This release brings $num_commits new commits since $previous_version," \
-                " contributed by $num_authors authors, $num_new_authors of which are new faces."
-            echo
-            echo
-        )
-    } fi
-
-    printf '%s\n' "$(awk <"$workspace_root/CHANGELOG.rst" '
-        NR <= 2 || /^\.\. ignore / { next }
-        /^===/ { exit }
-        { print }
-    ' | sed '$d')" |
-        sed -e '$s/^----*$//' # Remove spurious transitions at the end of the document.
-
-    if $add_stats; then {
-        JoinEscaped() {
-            LC_CTYPE=C.UTF-8 sed 's/\S/\\&/g' |
-                awk '
-                    NR != 1 { printf ",\n" }
-                    { printf "%s", $0 }
-                    END { printf "\n" }
-                '
-        }
-        echo ""
-        echo "---"
-        echo ""
-        echo "Thanks to everyone who contributed through issue discussions, code reviews, or code changes."
-        echo
-        printf "Welcome our new committers: "
-        JoinEscaped <"$relnotes_tmp/committers-new"
-        echo
-        printf "Welcome back our returning committers: "
-        JoinEscaped <"$relnotes_tmp/committers-returning"
-    } fi
-    echo
-    echo "---"
-    echo
-    echo 'Download links:'
-    echo 'To download the source code for fish, we suggest the file named ``fish-'"$version"'.tar.xz``.'
-    # shellcheck disable=2016
-    echo 'The file downloaded from ``Source code (tar.gz)`` will not build correctly.'
-    # shellcheck disable=2016
-    echo 'A GPG signature using `this key <'"${FISH_GPG_PUBLIC_KEY_URL:-???}"'>`__ is available as ``fish-'"$version"'.tar.xz.asc``.'
-    echo
-    echo 'The files called ``fish-'"$version"'-linux-*.tar.xz`` contain'
-    # shellcheck disable=2016
-    echo '`standalone fish binaries <https://github.com/fish-shell/fish-shell/?tab=readme-ov-file#building-fish-with-cargo>`__'
-    echo 'for any Linux with the given CPU architecture.'
-} >"$relnotes_tmp/fake-workspace"/CHANGELOG.rst
-
-sphinx-build >&2 -j auto \
-    -W -E -b markdown -c "$workspace_root/doc_src" \
-    -d "$relnotes_tmp/doctree" "$relnotes_tmp/fake-workspace/doc_src" "$relnotes_tmp/out" \
-    -D markdown_http_base="https://fishshell.com/docs/$minor_version" \
-    -D markdown_uri_doc_suffix=".html" \
-    -D markdown_flavor=github \
-    "$@"
-
-# Skip changelog header
-sed -n 1p "$relnotes_tmp/out/relnotes.md" | grep -Fxq "# Release notes"
-sed -n 2p "$relnotes_tmp/out/relnotes.md" | grep -Fxq ''
-sed 1,2d "$relnotes_tmp/out/relnotes.md"
-
-rm -r "$relnotes_tmp"

build_tools/release.sh

@@ -1,317 +0,0 @@
-#!/bin/sh
-
-{
-
-set -ex
-
-version=$1
-repository_owner=fish-shell
-remote=origin
-if [ -n "$2" ]; then
-    set -u
-    repository_owner=$2
-    remote=$3
-    set +u
-    [ $# -eq 3 ]
-fi
-
-[ -n "$version" ]
-
-for tool in \
-    cmake \
-    bundle \
-    diff \
-    gh \
-    gpg \
-    jq \
-    ninja \
-    ruby \
-    tar \
-    timeout \
-    uv \
-    xz \
-; do
-    if ! command -v "$tool" >/dev/null; then
-        echo >&2 "$0: missing command: $1"
-        exit 1
-    fi
-done
-
-committer=$(git var GIT_AUTHOR_IDENT)
-committer=${committer% *} # strip timezone
-committer=${committer% *} # strip timestamp
-gpg --local-user="$committer" --sign </dev/null >/dev/null
-
-repo_root="$(dirname "$0")/.."
-fish_site=$repo_root/../fish-site
-fish_site_repo=git@github.com:$repository_owner/fish-site
-
-for path in . "$fish_site"
-do
-    if ! git -C "$path" diff HEAD --quiet ||
-        git ls-files --others --exclude-standard | grep .; then
-        echo >&2 "$0: index and worktree must be clean"
-        exit 1
-    fi
-done
-
-(
-    cd "$fish_site"
-    [ "$(git rev-parse HEAD)" = \
-        "$(git ls-remote "$fish_site_repo" refs/heads/master |
-            awk '{print $1}')" ]
-)
-
-if git tag | grep -qxF "$version"; then
-    echo >&2 "$0: tag $version already exists"
-    exit 1
-fi
-
-integration_branch=$(
-    git for-each-ref --points-at=HEAD 'refs/heads/Integration_*' \
-        --format='%(refname:strip=2)'
-)
-[ -n "$integration_branch" ] ||
-    git merge-base --is-ancestor "$remote"/master HEAD
-
-sed -n 1p CHANGELOG.rst | grep -q '^fish .*(released .*)$'
-sed -n 2p CHANGELOG.rst | grep -q '^===*$'
-
-changelog_title="fish $version (released $(date +'%B %d, %Y'))"
-sed -i \
-    -e "1c$changelog_title" \
-    -e "2c$(printf %s "$changelog_title" | sed s/./=/g)" \
-    CHANGELOG.rst
-
-CreateCommit() {
-    git commit -m "$1
-
-Created by ./build_tools/release.sh $version"
-}
-
-sed -i "s/^version = \".*\"/version = \"$1\"/g" Cargo.toml
-cargo fetch --offline # bumps the version in Cargo.lock
-if [ "$1" = "$version" ]; then
-    # debchange is a Debian script to manage the Debian changelog, but
-    # it's too annoying to install everywhere. Just do it by hand.
-    cat - contrib/debian/changelog > contrib/debian/changelog.new <<EOF
-fish (${version}-1) stable; urgency=medium
-
-  * Release of new version $version.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/$version for details.
-
- -- $committer  $(date -R)
-
-EOF
-    mv contrib/debian/changelog.new contrib/debian/changelog
-    git add contrib/debian/changelog
-fi
-git add CHANGELOG.rst Cargo.toml Cargo.lock
-CreateCommit "Release $version"
-
-# Tags must be full objects, not lightweight tags, for
-# git_version-gen.sh to work.
-git -c "user.signingKey=$committer" \
-    tag --sign --message="Release $version" "$version"
-
-git push "$remote" "$version"
-
-TIMEOUT=
-gh() {
-    command ${TIMEOUT:+timeout $TIMEOUT} \
-        gh --repo "$repository_owner/fish-shell" "$@"
-}
-
-gh workflow run release.yml --ref="$version" \
-    --raw-field="version=$version"
-
-run_id=
-while [ -z "$run_id" ] && sleep 5
-do
-    run_id=$(gh run list \
-                --json=databaseId --jq=.[].databaseId \
-                --workflow=release.yml --limit=1 \
-                --commit="$(git rev-parse "$version^{commit}")")
-done
-
-# Update fishshell.com
-tag_oid=$(git rev-parse "$version")
-tmpdir=$(mktemp -d)
-fish_tar_xz=fish-$version.tar.xz
-(
-    local_tarball=$tmpdir/local-tarball
-    mkdir "$local_tarball"
-    FISH_ARTEFACT_PATH=$local_tarball ./build_tools/make_tarball.sh
-    cd "$local_tarball"
-    tar xf "$fish_tar_xz"
-)
-# TODO This works on draft releases only if "gh" is configured to
-# have write access to the fish-shell repository. Unless we are fine
-# publishing the release at this point, we should at least fail if
-# "gh" doesn't have write access.
-while ! \
-    gh release download "$version" --dir="$tmpdir" \
-        --pattern="$fish_tar_xz"
-do
-    TIMEOUT=30 gh run watch "$run_id" ||:
-    sleep 5
-done
-actual_tag_oid=$(git ls-remote "$remote" |
-    awk '$2 == "refs/tags/'"$version"'" { print $1 }')
-[ "$tag_oid" = "$actual_tag_oid" ]
-
-(
-    cd "$tmpdir"
-    tar xf "$fish_tar_xz"
-    diff -ur "fish-$version" "local-tarball/fish-$version"
-    gpg --local-user="$committer" --sign --detach --armor \
-        "$fish_tar_xz"
-    gh release upload "$version" "$fish_tar_xz.asc"
-)
-
-(
-    cd "$tmpdir/local-tarball/fish-$version"
-    uv --no-managed-python venv
-    # shellcheck disable=1091
-    . .venv/bin/activate
-    cmake -GNinja -DCMAKE_BUILD_TYPE=Debug .
-    ninja doc
-)
-CopyDocs() {
-    rm -rf "$fish_site/site/docs/$1"
-    cp -r "$tmpdir/local-tarball/fish-$version/cargo/fish-docs/html" "$fish_site/site/docs/$1"
-    git -C "$fish_site" add "site/docs/$1"
-}
-minor_version=${version%.*}
-CopyDocs "$minor_version"
-latest_release=$(
-    releases=$(git tag | grep '^[0-9]*\.[0-9]*\.[0-9]*.*' |
-        sed '
-            # De-prioritize release candidates (1.2.3-rc0)
-            s/-/~/g
-        ' | LC_ALL=C sort --version-sort
-    )
-    printf %s\\n "$releases" | tail -1
-)
-if [ "$version" = "$latest_release" ]; then
-    CopyDocs current
-fi
-rm -rf "$tmpdir"
-(
-    cd "$fish_site"
-    make
-    git add -u
-    git add docs
-    if git ls-files --others --exclude-standard | grep .; then
-        exit 1
-    fi
-    git commit --message="$(printf %s "\
-        | Release $version (docs)
-        |
-        | Created by ../fish-shell/build_tools/release.sh
-    " | sed 's,^\s*| \?,,')"
-)
-
-gh_api_repo() {
-    path=$1
-    shift
-    command gh api \
-        -H "Accept: application/vnd.github+json" \
-        -H "X-GitHub-Api-Version: 2022-11-28" \
-        "/repos/$repository_owner/fish-shell/$path" \
-        "$@"
-}
-
-# Approve macos-codesign
-# TODO what if current user can't approve?
-gh_pending_deployments() {
-    gh_api_repo "actions/runs/$run_id/pending_deployments" "$@"
-}
-while {
-    environment_id=$(gh_pending_deployments | jq .[].environment.id)
-    [ -z "$environment_id" ]
-}
-do
-    sleep 5
-done
-echo '
-        {
-            "environment_ids": ['"$environment_id"'],
-            "state": "approved",
-            "comment": "Approved via ./build_tools/release.sh"
-        }
-    ' |
-gh_pending_deployments --method POST --input=-
-
-# Await completion.
-gh run watch "$run_id"
-
-while {
-    ! draft=$(gh release view "$version" --json=isDraft --jq=.isDraft) \
-    || [ "$draft" = true ]
-}
-do
-    sleep 20
-done
-
-milestone_version="$(
-    if echo "$version" | grep -q '\.0$'; then
-        echo "$minor_version"
-    else
-        echo "$version"
-    fi
-)"
-milestone_number() {
-    gh_api_repo milestones?state=open |
-        jq --arg name "fish $1" '
-            .[] | select(.title == $name) | .number
-        '
-}
-gh_api_repo milestones/"$(milestone_number "$milestone_version")" \
-    --method PATCH --raw-field state=closed
-next_minor_version=$(echo "$minor_version" |
-    awk -F. '{ printf "%s.%s", $1, $2+1 }')
-if [ -z "$(milestone_number "$next_minor_version")" ]; then
-    gh_api_repo milestones --method POST \
-        --raw-field title="fish $next_minor_version"
-fi
-
-(
-    cd "$fish_site"
-    make new-release
-    git add -u
-    git add docs
-    if git ls-files --others --exclude-standard | grep .; then
-        exit 1
-    fi
-    git commit --message="$(printf %s "\
-        | Release $version (release list update)
-        |
-        | Created by ../fish-shell/build_tools/release.sh
-    " | sed 's,^\s*| \?,,')"
-    # This takes care to support remote names that are different from
-    # fish-shell remote name. Also, support detached HEAD state.
-    git push "$fish_site_repo" HEAD:master
-    git fetch "$fish_site_repo" \
-        "$(git rev-parse HEAD):refs/remotes/origin/master"
-)
-
-if [ -n "$integration_branch" ]; then {
-    git push "$remote" "$version^{commit}:refs/heads/$integration_branch"
-} else {
-    changelog=$(cat - CHANGELOG.rst <<EOF
-fish ?.?.? (released ???)
-=========================
-
-EOF
-    )
-    printf %s\\n "$changelog" >CHANGELOG.rst
-    git add CHANGELOG.rst
-    CreateCommit "start new cycle"
-    git push "$remote" HEAD:master
-} fi
-
-exit
-
-}

build_tools/style.fish

@@ -0,0 +1,76 @@
+#!/usr/bin/env fish
+#
+# This runs C++ files and fish scripts (*.fish) through their respective code
+# formatting programs.
+#
+set -l fish_files
+set -l python_files
+set -l rust_files
+set -l all no
+
+if test "$argv[1]" = --all
+    set all yes
+    set -e argv[1]
+end
+
+if set -q argv[1]
+    echo "Unexpected arguments: '$argv'"
+    exit 1
+end
+
+if test $all = yes
+    set -l files (git status --porcelain --short --untracked-files=all | sed -e 's/^ *[^ ]* *//')
+    if set -q files[1]
+        echo
+        echo 'You have uncommitted changes. Are you sure you want to restyle?'
+        read -P 'y/N? ' -n1 -l ans
+        if not string match -qi y -- $ans
+            exit 1
+        end
+    end
+    set fish_files share/**.fish
+    set python_files {doc_src,share,tests}/**.py
+    set rust_files fish-rust/src/**.rs
+else
+    # Extract just the fish files.
+    set fish_files (string match -r '^.*\.fish$' -- $files)
+    set python_files (string match -r '^.*\.py$' -- $files)
+    set rust_files (string match -r '^.*\.rs$' -- $files)
+end
+
+set -l red (set_color red)
+set -l green (set_color green)
+set -l blue (set_color blue)
+set -l normal (set_color normal)
+
+# Run the fish reformatter if we have any fish files.
+if set -q fish_files[1]
+    if not type -q fish_indent
+        make fish_indent
+        set PATH . $PATH
+    end
+    echo === Running "$green"fish_indent"$normal"
+    fish_indent -w -- $fish_files
+end
+
+if set -q python_files[1]
+    if not type -q black
+        echo
+        echo Please install "`black`" to style python
+        echo
+    else
+        echo === Running "$blue"black"$normal"
+        black $python_files
+    end
+end
+
+if set -q rust_files[1]
+    if not type -q rustfmt
+        echo
+        echo Please install "`rustfmt`" to style rust
+        echo
+    else
+        echo === Running "$blue"rustfmt"$normal"
+        rustfmt $rust_files
+    end
+end

build_tools/supported_ubuntu_versions.py

@@ -1,22 +0,0 @@
-# /// script
-# requires-python = ">=3.5"
-# dependencies = [
-#     "launchpadlib",
-# ]
-# ///
-
-from launchpadlib.launchpad import Launchpad
-
-if __name__ == "__main__":
-    launchpad = Launchpad.login_anonymously(
-        "fish shell build script", "production", "~/.cache", version="devel"
-    )
-    ubu = launchpad.projects("ubuntu")
-    print(
-        "\n".join(
-            x["name"]
-            for x in ubu.series.entries
-            if x["supported"] == True
-            and x["name"] not in ("trusty", "xenial", "bionic", "focal")
-        )
-    )

build_tools/update-dependencies.sh

@@ -1,60 +0,0 @@
-#!/bin/sh
-
-set -ex
-
-command -v curl
-command -v jq
-command -v rustup
-command -v updatecli
-command -v uv
-sort --version-sort </dev/null
-
-# TODO This is copied from .github/actions/install-sphinx/action.yml
-uv lock --check --exclude-newer="$(awk -F'"' <uv.lock '/^exclude-newer[[:space:]]*=/ {print $2}')"
-
-update_gh_action() {
-    repo=$1
-    version=$(curl -fsS "https://api.github.com/repos/$repo/releases/latest" | jq -r .tag_name)
-    [ -n "$version" ]
-    tag_oid=$(git ls-remote "https://github.com/$repo.git" "refs/tags/$version" | cut -f1)
-    [ -n "$tag_oid" ]
-    find .github/workflows -name '*.yml' -type f -exec \
-        sed -i "s|uses: $repo@\S\+\( \+#.*\)\?|\
-uses: $repo@$tag_oid # $version, build_tools/update-dependencies.sh|g" {} +
-}
-update_gh_action actions/checkout
-update_gh_action actions/github-script
-update_gh_action actions/upload-artifact
-update_gh_action actions/download-artifact
-update_gh_action docker/login-action
-update_gh_action docker/build-push-action
-update_gh_action docker/metadata-action
-update_gh_action EmbarkStudios/cargo-deny-action
-update_gh_action dessant/lock-threads
-update_gh_action softprops/action-gh-release
-update_gh_action msys2/setup-msys2
-
-updatecli "${@:-apply}"
-
-# Python version constraints may have changed.
-uv lock --upgrade --exclude-newer="$(date --date='7 days ago' --iso-8601)"
-
-from_gh() {
-    repo=$1
-    branch=$2
-    path=$3
-    destination=$4
-    contents=$(curl -fsS https://raw.githubusercontent.com/"${repo}"/refs/heads/"${branch}"/"${path}")
-    printf '%s\n' "$contents" >"$destination"
-}
-
-from_gh ridiculousfish/widecharwidth master widechar_width.rs crates/widecharwidth/src/widechar_width.rs
-from_gh ridiculousfish/littlecheck master littlecheck/littlecheck.py tests/littlecheck.py
-from_gh catppuccin/fish main themes/catppuccin-frappe.theme share/themes/catppuccin-frappe.theme
-from_gh catppuccin/fish main themes/catppuccin-macchiato.theme share/themes/catppuccin-macchiato.theme
-from_gh catppuccin/fish main themes/catppuccin-mocha.theme share/themes/catppuccin-mocha.theme
-
-# Update Cargo.lock
-cargo update
-# Update Cargo.toml and Cargo.lock
-cargo +nightly -Zunstable-options update --breaking

build_tools/version-available-in-debian.sh

@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-channel=$1 # e.g. stable, testing
-package=$2 # e.g. rustc, sphinx
-
-codename=$(
-    curl -fsS https://ftp.debian.org/debian/dists/"${channel}"/Release |
-    grep '^Codename:' | cut -d' ' -f2)
-curl -fsS https://sources.debian.org/api/src/"${package}"/ |
-    jq -r --arg codename "${codename}" '
-        .versions[] | select(.suites[] == $codename) | .version' |
-    sed -E 's/^([0-9]+\.[0-9]+).*/\1/' |
-    sort --version-sort |
-    tail -1

clippy.toml

@@ -1,6 +0,0 @@
-allow-print-in-tests = true
-disallowed-methods = [
-    # Not allowed to use libc::setlocale() directly, need to use the wrappers
-    # in src/locale.rs which takes a lock for the duration of the call.
-    "libc::setlocale",
-]

cmake/Docs.cmake

@@ -1,60 +1,86 @@
+find_program(SPHINX_EXECUTABLE NAMES sphinx-build
+    HINTS
+    $ENV{SPHINX_DIR}
+    PATH_SUFFIXES bin
+    DOC "Sphinx documentation generator")
+
 include(FeatureSummary)
 
-set(SPHINX_OUTPUT_DIR "${FISH_RUST_BUILD_DIR}/fish-docs")
-
-set(FISH_INDENT_FOR_BUILDING_DOCS "" CACHE FILEPATH "Path to fish_indent executable for building HTML docs")
-
-if(FISH_INDENT_FOR_BUILDING_DOCS)
-    set(SPHINX_HTML_FISH_INDENT_DEP)
-else()
-    set(FISH_INDENT_FOR_BUILDING_DOCS "${CMAKE_CURRENT_BINARY_DIR}/fish_indent")
-    set(SPHINX_HTML_FISH_INDENT_DEP fish_indent)
-endif()
-
-set(VARS_FOR_CARGO_SPHINX_WRAPPER
-    "CARGO_TARGET_DIR=${FISH_RUST_BUILD_DIR}"
-    "FISH_SPHINX=${SPHINX_EXECUTABLE}"
-)
+set(SPHINX_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/doc_src")
+set(SPHINX_ROOT_DIR "${CMAKE_CURRENT_BINARY_DIR}/user_doc")
+set(SPHINX_BUILD_DIR "${SPHINX_ROOT_DIR}/build")
+set(SPHINX_HTML_DIR "${SPHINX_ROOT_DIR}/html")
+set(SPHINX_MANPAGE_DIR "${SPHINX_ROOT_DIR}/man")
 
+# sphinx-docs uses fish_indent for highlighting.
+# Prepend the output dir of fish_indent to PATH.
 add_custom_target(sphinx-docs
-    COMMAND env ${VARS_FOR_CARGO_SPHINX_WRAPPER}
-        ${Rust_CARGO} xtask html-docs --fish-indent=${FISH_INDENT_FOR_BUILDING_DOCS}
-    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-    DEPENDS ${SPHINX_HTML_FISH_INDENT_DEP}
+    mkdir -p ${SPHINX_HTML_DIR}/_static/
+    COMMAND env PATH="${CMAKE_BINARY_DIR}:$$PATH"
+        ${SPHINX_EXECUTABLE}
+        -j auto
+        -q -b html
+        -c "${SPHINX_SRC_DIR}"
+        -d "${SPHINX_ROOT_DIR}/.doctrees-html"
+        "${SPHINX_SRC_DIR}"
+        "${SPHINX_HTML_DIR}"
+    DEPENDS ${SPHINX_SRC_DIR}/fish_indent_lexer.py fish_indent
     COMMENT "Building HTML documentation with Sphinx")
 
+# sphinx-manpages needs the fish_indent binary for the version number
 add_custom_target(sphinx-manpages
-    COMMAND env ${VARS_FOR_CARGO_SPHINX_WRAPPER}
-        ${Rust_CARGO} xtask man-pages
-    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    env FISH_BUILD_VERSION_FILE=${CMAKE_CURRENT_BINARY_DIR}/${FBVF}
+        ${SPHINX_EXECUTABLE}
+        -j auto
+        -q -b man
+        -c "${SPHINX_SRC_DIR}"
+        -d "${SPHINX_ROOT_DIR}/.doctrees-man"
+        "${SPHINX_SRC_DIR}"
+        # TODO: This only works if we only have section 1 manpages.
+        "${SPHINX_MANPAGE_DIR}/man1"
+    DEPENDS CHECK-FISH-BUILD-VERSION-FILE
     COMMENT "Building man pages with Sphinx")
 
-if(NOT DEFINED WITH_DOCS) # Don't check for legacy options if the new one is defined, to help bisecting.
-    if(DEFINED BUILD_DOCS)
-        message(FATAL_ERROR "the BUILD_DOCS option is no longer supported, use -DWITH_DOCS=ON|OFF")
-    endif()
-    if(DEFINED INSTALL_DOCS)
-        message(FATAL_ERROR "the INSTALL_DOCS option is no longer supported, use -DWITH_DOCS=ON|OFF")
-    endif()
-endif()
-
 if(SPHINX_EXECUTABLE)
-    option(WITH_DOCS "build documentation (requires Sphinx)" ON)
-else()
-    option(WITH_DOCS "build documentation (requires Sphinx)" OFF)
-endif()
+    option(BUILD_DOCS "build documentation (requires Sphinx)" ON)
+else(SPHINX_EXECUTABLE)
+    option(BUILD_DOCS "build documentation (requires Sphinx)" OFF)
+endif(SPHINX_EXECUTABLE)
 
-if(WITH_DOCS AND NOT SPHINX_EXECUTABLE)
+if(BUILD_DOCS AND NOT SPHINX_EXECUTABLE)
     message(FATAL_ERROR "build documentation selected, but sphinx-build could not be found")
 endif()
 
-add_feature_info(Documentation WITH_DOCS "user manual and documentation")
-
-if(WITH_DOCS)
-    add_custom_target(doc ALL DEPENDS sphinx-docs sphinx-manpages)
-    # Group docs targets into a DocsTargets folder
-    set_property(
-        TARGET doc sphinx-docs sphinx-manpages
-        PROPERTY FOLDER cmake/DocTargets
-    )
+if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/user_doc/html
+   AND IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/user_doc/man)
+    set(HAVE_PREBUILT_DOCS TRUE)
+else()
+    set(HAVE_PREBUILT_DOCS FALSE)
 endif()
+
+if(BUILD_DOCS OR HAVE_PREBUILT_DOCS)
+    set(INSTALL_DOCS ON)
+else()
+    set(INSTALL_DOCS OFF)
+endif()
+
+add_feature_info(Documentation INSTALL_DOCS "user manual and documentation")
+
+if(BUILD_DOCS)
+    configure_file("${SPHINX_SRC_DIR}/conf.py" "${SPHINX_BUILD_DIR}/conf.py" @ONLY)
+    add_custom_target(doc ALL
+                      DEPENDS sphinx-docs sphinx-manpages)
+
+    # Group docs targets into a DocsTargets folder
+    set_property(TARGET doc sphinx-docs sphinx-manpages
+                 PROPERTY FOLDER cmake/DocTargets)
+
+elseif(HAVE_PREBUILT_DOCS)
+    if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
+        # Out of tree build - link the prebuilt documentation to the build tree
+        add_custom_target(link_doc ALL)
+        add_custom_command(TARGET link_doc
+            COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_CURRENT_SOURCE_DIR}/user_doc ${CMAKE_CURRENT_BINARY_DIR}/user_doc
+            POST_BUILD)
+    endif()
+endif(BUILD_DOCS)

cmake/FindRust.cmake

@@ -22,17 +22,17 @@ foreach(_VAR ${_Rust_USER_VARS})
 endforeach()
 
 if (NOT DEFINED Rust_CARGO_CACHED)
-    find_program(Rust_CARGO_CACHED cargo PATHS "$ENV{HOME}/.cargo/bin")
+  find_program(Rust_CARGO_CACHED cargo PATHS "$ENV{HOME}/.cargo/bin")
 endif()
 
 if (NOT EXISTS "${Rust_CARGO_CACHED}")
-    message(FATAL_ERROR "The cargo executable ${Rust_CARGO_CACHED} was not found. "
-        "Consider setting `Rust_CARGO_CACHED` to the absolute path of `cargo`."
-    )
+  message(FATAL_ERROR "The cargo executable ${Rust_CARGO_CACHED} was not found. "
+    "Consider setting `Rust_CARGO_CACHED` to the absolute path of `cargo`."
+  )
 endif()
 
 if (NOT DEFINED Rust_COMPILER_CACHED)
-    find_program(Rust_COMPILER_CACHED rustc PATHS "$ENV{HOME}/.cargo/bin")
+  find_program(Rust_COMPILER_CACHED rustc PATHS "$ENV{HOME}/.cargo/bin")
 endif()
 
 
@@ -45,31 +45,31 @@ endif()
 # Figure out the target by just using the host target.
 # If you want to cross-compile, you'll have to set Rust_CARGO_TARGET
 if(NOT Rust_CARGO_TARGET_CACHED)
-    execute_process(
-        COMMAND "${Rust_COMPILER_CACHED}" --version --verbose
-        OUTPUT_VARIABLE _RUSTC_VERSION_RAW
-        RESULT_VARIABLE _RUSTC_VERSION_RESULT
+  execute_process(
+    COMMAND "${Rust_COMPILER_CACHED}" --version --verbose
+    OUTPUT_VARIABLE _RUSTC_VERSION_RAW
+    RESULT_VARIABLE _RUSTC_VERSION_RESULT
+  )
+
+  if(NOT ( "${_RUSTC_VERSION_RESULT}" EQUAL "0" ))
+    message(FATAL_ERROR "Failed to get rustc version.\n"
+      "${Rust_COMPILER} --version failed with error: `${_RUSTC_VERSION_RESULT}`")
+  endif()
+
+  if (_RUSTC_VERSION_RAW MATCHES "host: ([a-zA-Z0-9_\\-]*)\n")
+    set(Rust_DEFAULT_HOST_TARGET "${CMAKE_MATCH_1}")
+  else()
+    message(FATAL_ERROR
+      "Failed to parse rustc host target. `rustc --version --verbose` evaluated to:\n${_RUSTC_VERSION_RAW}"
     )
+  endif()
 
-    if(NOT ( "${_RUSTC_VERSION_RESULT}" EQUAL "0" ))
-        message(FATAL_ERROR "Failed to get rustc version.\n"
-            "${Rust_COMPILER} --version failed with error: `${_RUSTC_VERSION_RESULT}`")
-    endif()
-
-    if (_RUSTC_VERSION_RAW MATCHES "host: ([a-zA-Z0-9_\\-]*)\n")
-        set(Rust_DEFAULT_HOST_TARGET "${CMAKE_MATCH_1}")
-    else()
-        message(FATAL_ERROR
-            "Failed to parse rustc host target. `rustc --version --verbose` evaluated to:\n${_RUSTC_VERSION_RAW}"
-        )
-    endif()
-
-    if(CMAKE_CROSSCOMPILING)
-        message(FATAL_ERROR "CMake is in cross-compiling mode."
-            "Manually set `Rust_CARGO_TARGET`."
-        )
-    endif()
-    set(Rust_CARGO_TARGET_CACHED "${Rust_DEFAULT_HOST_TARGET}" CACHE STRING "Target triple")
+  if(CMAKE_CROSSCOMPILING)
+    message(FATAL_ERROR "CMake is in cross-compiling mode."
+      "Manually set `Rust_CARGO_TARGET`."
+    )
+  endif()
+  set(Rust_CARGO_TARGET_CACHED "${Rust_DEFAULT_HOST_TARGET}" CACHE STRING "Target triple")
 endif()
 
 # Set the input variables as non-cache variables so that the variables are available after

cmake/Install.cmake

@@ -1,5 +1,7 @@
 set(CMAKE_INSTALL_MESSAGE NEVER)
 
+set(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fish ${CMAKE_CURRENT_BINARY_DIR}/fish_indent ${CMAKE_CURRENT_BINARY_DIR}/fish_key_reader)
+
 set(prefix ${CMAKE_INSTALL_PREFIX})
 set(bindir ${CMAKE_INSTALL_BINDIR})
 set(sysconfdir ${CMAKE_INSTALL_SYSCONFDIR})
@@ -14,37 +16,31 @@ set(rel_completionsdir "fish/vendor_completions.d")
 set(rel_functionsdir "fish/vendor_functions.d")
 set(rel_confdir "fish/vendor_conf.d")
 
-set(
-    extra_completionsdir "${datadir}/${rel_completionsdir}"
-    CACHE STRING "Path for extra completions"
-)
+set(extra_completionsdir
+    "${datadir}/${rel_completionsdir}"
+    CACHE STRING "Path for extra completions")
 
-set(
-    extra_functionsdir "${datadir}/${rel_functionsdir}"
-    CACHE STRING "Path for extra functions"
-)
+set(extra_functionsdir
+    "${datadir}/${rel_functionsdir}"
+    CACHE STRING "Path for extra functions")
 
-set(
-    extra_confdir "${datadir}/${rel_confdir}"
-    CACHE STRING "Path for extra configuration"
-)
+set(extra_confdir
+    "${datadir}/${rel_confdir}"
+    CACHE STRING "Path for extra configuration")
 
 
 # These are the man pages that go in system manpath; all manpages go in the fish-specific manpath.
-set(MANUALS
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish_indent.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish_key_reader.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-doc.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-tutorial.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-language.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-interactive.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-terminal-compatibility.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-completions.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-prompt-tutorial.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-for-bash-users.1
-    ${SPHINX_OUTPUT_DIR}/man/man1/fish-faq.1
-)
+set(MANUALS ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish_indent.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish_key_reader.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish-doc.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish-tutorial.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish-language.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish-interactive.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish-completions.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish-prompt-tutorial.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish-for-bash-users.1
+            ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/fish-faq.1)
 
 # Determine which man page we don't want to install.
 # On OS X, don't install a man page for open, since we defeat fish's open
@@ -52,119 +48,128 @@ set(MANUALS
 # On other operating systems, don't install a realpath man page, as they almost all have a realpath
 # command, while macOS does not.
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-    set(CONDEMNED_PAGE "open.1")
+  set(CONDEMNED_PAGE "open.1")
 else()
-    set(CONDEMNED_PAGE "realpath.1")
+  set(CONDEMNED_PAGE "realpath.1")
 endif()
 
 # Define a function to help us create directories.
 function(FISH_CREATE_DIRS)
-    foreach(dir ${ARGV})
-        install(DIRECTORY DESTINATION ${dir})
-    endforeach(dir)
+  foreach(dir ${ARGV})
+    install(DIRECTORY DESTINATION ${dir})
+  endforeach(dir)
 endfunction(FISH_CREATE_DIRS)
 
 function(FISH_TRY_CREATE_DIRS)
-    foreach(dir ${ARGV})
-        if(NOT IS_ABSOLUTE ${dir})
-            set(abs_dir "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${dir}")
-        else()
-            set(abs_dir "\$ENV{DESTDIR}${dir}")
-        endif()
-        install(SCRIPT CODE "
-            EXECUTE_PROCESS(COMMAND mkdir -p ${abs_dir} OUTPUT_QUIET ERROR_QUIET)
-            execute_process(COMMAND chmod 755 ${abs_dir} OUTPUT_QUIET ERROR_QUIET)
-        ")
-    endforeach()
+  foreach(dir ${ARGV})
+    if(NOT IS_ABSOLUTE ${dir})
+      set(abs_dir "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${dir}")
+    else()
+      set(abs_dir "\$ENV{DESTDIR}${dir}")
+    endif()
+    install(SCRIPT CODE "EXECUTE_PROCESS(COMMAND mkdir -p ${abs_dir} OUTPUT_QUIET ERROR_QUIET)
+                         execute_process(COMMAND chmod 755 ${abs_dir} OUTPUT_QUIET ERROR_QUIET)
+                        ")
+  endforeach()
 endfunction(FISH_TRY_CREATE_DIRS)
 
-install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fish
-    PERMISSIONS
-        OWNER_READ
-        OWNER_WRITE
-        OWNER_EXECUTE
-        GROUP_READ
-        GROUP_EXECUTE
-        WORLD_READ
-        WORLD_EXECUTE
-    DESTINATION ${bindir}
-)
-
-if(NOT IS_ABSOLUTE ${bindir})
-    set(abs_bindir "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${bindir}")
-else()
-    set(abs_bindir "\$ENV{DESTDIR}${bindir}")
-endif()
-install(CODE "file(CREATE_LINK ${abs_bindir}/fish ${abs_bindir}/fish_indent)")
-install(CODE "file(CREATE_LINK ${abs_bindir}/fish ${abs_bindir}/fish_key_reader)")
+install(PROGRAMS ${PROGRAMS}
+        PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ
+                    GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
+        DESTINATION ${bindir})
 
 fish_create_dirs(${sysconfdir}/fish/conf.d ${sysconfdir}/fish/completions
     ${sysconfdir}/fish/functions)
 install(FILES etc/config.fish DESTINATION ${sysconfdir}/fish/)
 
-fish_create_dirs(
-    ${rel_datadir}/fish
-    ${rel_datadir}/fish/man/man1
-)
+fish_create_dirs(${rel_datadir}/fish ${rel_datadir}/fish/completions
+                 ${rel_datadir}/fish/functions ${rel_datadir}/fish/groff
+                 ${rel_datadir}/fish/man/man1 ${rel_datadir}/fish/tools
+                 ${rel_datadir}/fish/tools/web_config
+                 ${rel_datadir}/fish/tools/web_config/js
+                 ${rel_datadir}/fish/tools/web_config/sample_prompts
+                 ${rel_datadir}/fish/tools/web_config/themes
+                 )
 
-# This file is embedded in the executable by rust-embed and never read from the filesystem
 configure_file(share/__fish_build_paths.fish.in share/__fish_build_paths.fish)
+install(FILES share/config.fish
+              ${CMAKE_CURRENT_BINARY_DIR}/share/__fish_build_paths.fish
+        DESTINATION ${rel_datadir}/fish)
 
 # Create only the vendor directories inside the prefix (#5029 / #6508)
-fish_create_dirs(
-    ${rel_datadir}/fish/vendor_completions.d
-    ${rel_datadir}/fish/vendor_functions.d
-    ${rel_datadir}/fish/vendor_conf.d
-)
+fish_create_dirs(${rel_datadir}/fish/vendor_completions.d ${rel_datadir}/fish/vendor_functions.d
+    ${rel_datadir}/fish/vendor_conf.d)
 
 fish_try_create_dirs(${rel_datadir}/pkgconfig)
 configure_file(fish.pc.in fish.pc.noversion @ONLY)
 
-add_custom_command(
-    OUTPUT fish.pc
+add_custom_command(OUTPUT fish.pc
     COMMAND sed '/Version/d' fish.pc.noversion > fish.pc
     COMMAND printf "Version: " >> fish.pc
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/build_tools/git_version_gen.sh >> fish.pc
+    COMMAND cat ${FBVF} >> fish.pc
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/fish.pc.noversion
-)
+    DEPENDS CHECK-FISH-BUILD-VERSION-FILE ${CMAKE_CURRENT_BINARY_DIR}/fish.pc.noversion)
 
 add_custom_target(build_fish_pc ALL DEPENDS fish.pc)
 
-install(
-    FILES ${CMAKE_CURRENT_BINARY_DIR}/fish.pc
-    DESTINATION ${rel_datadir}/pkgconfig
-)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/fish.pc
+        DESTINATION ${rel_datadir}/pkgconfig)
+
+install(DIRECTORY share/completions/
+        DESTINATION ${rel_datadir}/fish/completions
+        FILES_MATCHING PATTERN "*.fish")
+
+install(DIRECTORY share/functions/
+        DESTINATION ${rel_datadir}/fish/functions
+        FILES_MATCHING PATTERN "*.fish")
+
+install(DIRECTORY share/groff
+        DESTINATION ${rel_datadir}/fish)
 
 # CONDEMNED_PAGE is managed by the conditional above
 # Building the man pages is optional: if sphinx isn't installed, they're not built
-install(
-    DIRECTORY ${SPHINX_OUTPUT_DIR}/man/man1/
-    DESTINATION ${rel_datadir}/fish/man/man1
-    FILES_MATCHING
-    PATTERN "*.1"
-    PATTERN ${CONDEMNED_PAGE} EXCLUDE
-)
+install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/user_doc/man/man1/
+        DESTINATION ${rel_datadir}/fish/man/man1
+        FILES_MATCHING
+        PATTERN "*.1"
+        PATTERN ${CONDEMNED_PAGE} EXCLUDE)
+
+install(PROGRAMS share/tools/create_manpage_completions.py share/tools/deroff.py
+        DESTINATION ${rel_datadir}/fish/tools/)
+
+install(DIRECTORY share/tools/web_config
+        DESTINATION ${rel_datadir}/fish/tools/
+        FILES_MATCHING
+        PATTERN "*.png"
+        PATTERN "*.css"
+        PATTERN "*.html"
+        PATTERN "*.py"
+        PATTERN "*.js"
+        PATTERN "*.theme"
+        PATTERN "*.fish")
 
 # Building the man pages is optional: if Sphinx isn't installed, they're not built
 install(FILES ${MANUALS} DESTINATION ${mandir}/man1/ OPTIONAL)
-install(
-    DIRECTORY ${SPHINX_OUTPUT_DIR}/html/ # Trailing slash is important!
-    DESTINATION ${docdir} OPTIONAL
-)
+install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/user_doc/html/ # Trailing slash is important!
+        DESTINATION ${docdir} OPTIONAL)
 install(FILES CHANGELOG.rst DESTINATION ${docdir})
 
+# These files are built by cmake/gettext.cmake, but using GETTEXT_PROCESS_PO_FILES's
+# INSTALL_DESTINATION leads to them being installed as ${lang}.gmo, not fish.mo
+# The ${languages} array comes from cmake/gettext.cmake
+if(GETTEXT_FOUND)
+  foreach(lang ${languages})
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${lang}.gmo DESTINATION
+            ${CMAKE_INSTALL_LOCALEDIR}/${lang}/LC_MESSAGES/ RENAME fish.mo)
+  endforeach()
+endif()
+
 # Group install targets into a InstallTargets folder
-set_property(
-    TARGET build_fish_pc
-    PROPERTY FOLDER cmake/InstallTargets
-)
+set_property(TARGET build_fish_pc CHECK-FISH-BUILD-VERSION-FILE
+             PROPERTY FOLDER cmake/InstallTargets)
 
 # Make a target build_root that installs into the buildroot directory, for testing.
 set(BUILDROOT_DIR ${CMAKE_CURRENT_BINARY_DIR}/buildroot)
-add_custom_target(
-    build_root
-    COMMAND DESTDIR=${BUILDROOT_DIR} ${CMAKE_COMMAND}
-        --build ${CMAKE_CURRENT_BINARY_DIR} --target install
-)
+add_custom_target(build_root
+                  COMMAND DESTDIR=${BUILDROOT_DIR} ${CMAKE_COMMAND}
+                          --build ${CMAKE_CURRENT_BINARY_DIR} --target install)

cmake/MacApp.cmake

@@ -24,15 +24,15 @@ add_executable(fish_macapp EXCLUDE_FROM_ALL
 
 # Compute the version. Note this is done at generation time, not build time,
 # so cmake must be re-run after version changes for the app to be updated. But
-# generally this will be run by make_macos_pkg.sh which always re-runs cmake.
+# generally this will be run by make_pkg.sh which always re-runs cmake.
 execute_process(
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/build_tools/git_version_gen.sh
+    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/build_tools/git_version_gen.sh --stdout
     COMMAND cut -d- -f1
     OUTPUT_VARIABLE FISH_SHORT_VERSION
     OUTPUT_STRIP_TRAILING_WHITESPACE)
 
 
-# Note CMake appends .app, so the real output name will be fish.app.
+# Note CMake appends .app, so the real output name will be fish.app. 
 # This target does not include the 'base' resource.
 set_target_properties(fish_macapp PROPERTIES OUTPUT_NAME "fish")
 

cmake/PCRE2.cmake

@@ -1,10 +1,9 @@
 set(FISH_USE_SYSTEM_PCRE2 ON CACHE BOOL
-    "Try to use PCRE2 from the system, instead of the pcre2-sys version"
-)
+  "Try to use PCRE2 from the system, instead of the pcre2-sys version")
 
 if(FISH_USE_SYSTEM_PCRE2)
-    message(STATUS "Trying to use PCRE2 from the system")
+  message(STATUS "Trying to use PCRE2 from the system")
 else()
-    message(STATUS "Forcing static build of PCRE2")
-    set(FISH_PCRE2_BUILDFLAG "PCRE2_SYS_STATIC=1")
+  message(STATUS "Forcing static build of PCRE2")
+  set(FISH_PCRE2_BUILDFLAG "PCRE2_SYS_STATIC=1")
 endif(FISH_USE_SYSTEM_PCRE2)

cmake/Rust.cmake

@@ -1,15 +1,15 @@
-include(FeatureSummary)
 include(FindRust)
 find_package(Rust REQUIRED)
 
-set(FISH_RUST_BUILD_DIR "${CMAKE_BINARY_DIR}/cargo")
+set(FISH_RUST_BUILD_DIR "${CMAKE_BINARY_DIR}/cargo/build")
 
 if(DEFINED ASAN)
     list(APPEND CARGO_FLAGS "-Z" "build-std")
+    list(APPEND FISH_CRATE_FEATURES "asan")
 endif()
 if(DEFINED TSAN)
     list(APPEND CARGO_FLAGS "-Z" "build-std")
-    list(APPEND FISH_CARGO_FEATURES_LIST "tsan")
+    list(APPEND FISH_CRATE_FEATURES "tsan")
 endif()
 
 if (Rust_CARGO_TARGET)
@@ -19,18 +19,36 @@ else()
 endif()
 
 set(rust_profile $<IF:$<CONFIG:Debug>,debug,$<IF:$<CONFIG:RelWithDebInfo>,release-with-debug,release>>)
+set(rust_debugflags "$<$<CONFIG:Debug>:-g>$<$<CONFIG:RelWithDebInfo>:-g>")
 
-if (NOT DEFINED WITH_MESSAGE_LOCALIZATION) # Don't check for legacy options if the new one is defined, to help bisecting.
-    if(DEFINED WITH_GETTEXT)
-        message(FATAL_ERROR "the WITH_GETTEXT option is no longer supported, use -DWITH_MESSAGE_LOCALIZATION=ON|OFF")
-    endif()
-endif()
-option(WITH_MESSAGE_LOCALIZATION "Build with localization support. Requires `msgfmt` to work." ON)
-# Enable gettext feature unless explicitly disabled.
-if(NOT DEFINED WITH_MESSAGE_LOCALIZATION OR "${WITH_MESSAGE_LOCALIZATION}")
-    list(APPEND FISH_CARGO_FEATURES_LIST "localize-messages")
+
+# Temporary hack to propagate CMake flags/options to build.rs. We need to get CMake to evaluate the
+# truthiness of the strings if they are set.
+set(CMAKE_WITH_GETTEXT "1")
+if(DEFINED WITH_GETTEXT AND NOT "${WITH_GETTEXT}")
+    set(CMAKE_WITH_GETTEXT "0")
 endif()
 
-add_feature_info(Translation WITH_MESSAGE_LOCALIZATION "message localization (requires gettext)")
+if(FISH_CRATE_FEATURES)
+    set(FEATURES_ARG ${FISH_CRATE_FEATURES})
+    list(PREPEND FEATURES_ARG "--features")
+endif()
 
-list(JOIN FISH_CARGO_FEATURES_LIST , FISH_CARGO_FEATURES)
+# Tell Cargo where our build directory is so it can find Cargo.toml.
+set(VARS_FOR_CARGO
+    "FISH_BUILD_DIR=${CMAKE_BINARY_DIR}"
+    "PREFIX=${CMAKE_INSTALL_PREFIX}"
+    # Temporary hack to propagate CMake flags/options to build.rs.
+    "CMAKE_WITH_GETTEXT=${CMAKE_WITH_GETTEXT}"
+    # Cheesy so we can tell cmake was used to build
+    "CMAKE=1"
+    "DOCDIR=${CMAKE_INSTALL_FULL_DOCDIR}"
+    "DATADIR=${CMAKE_INSTALL_FULL_DATADIR}"
+    "SYSCONFDIR=${CMAKE_INSTALL_FULL_SYSCONFDIR}"
+    "BINDIR=${CMAKE_INSTALL_FULL_BINDIR}"
+    "LOCALEDIR=${CMAKE_INSTALL_FULL_LOCALEDIR}"
+    "CARGO_TARGET_DIR=${FISH_RUST_BUILD_DIR}"
+    "CARGO_BUILD_RUSTC=${Rust_COMPILER}"
+    "${FISH_PCRE2_BUILDFLAG}"
+    "RUSTFLAGS=$ENV{RUSTFLAGS} ${rust_debugflags}"
+)

cmake/Tests.cmake

@@ -1,49 +1,104 @@
+# This adds ctest support to the project
+enable_testing()
+
+# By default, ctest runs tests serially
+# Support CTEST_PARALLEL_LEVEL as an environment variable in addition to a CMake variable
+if(NOT CTEST_PARALLEL_LEVEL)
+  set(CTEST_PARALLEL_LEVEL $ENV{CTEST_PARALLEL_LEVEL})
+  if(NOT CTEST_PARALLEL_LEVEL)
+    include(ProcessorCount)
+    ProcessorCount(CORES)
+    math(EXPR halfcores "${CORES} / 2")
+    set(CTEST_PARALLEL_LEVEL ${halfcores})
+  endif()
+endif()
+
+
+# Put in a tests folder to reduce the top level targets in IDEs.
+set(CMAKE_FOLDER tests)
+
+# We will use 125 as a reserved exit code to indicate that a test has been skipped, i.e. it did not
+# pass but it should not be considered a failed test run, either.
+set(SKIP_RETURN_CODE 125)
+
+# Even though we are using CMake's ctest for testing, we still define our own `make fish_run_tests` target
+# rather than use its default for many reasons:
+#  * CMake doesn't run tests in-proc or even add each tests as an individual node in the ninja
+#    dependency tree, instead it just bundles all tests into a target called `test` that always just
+#    shells out to `ctest`, so there are no build-related benefits to not doing that ourselves.
+#  * CMake devs insist that it is appropriate for `make fish_run_tests` to never depend on `make all`, i.e.
+#    running `make fish_run_tests` does not require any of the binaries to be built before testing.
+#  * It is not possible to set top-level CTest options/settings such as CTEST_PARALLEL_LEVEL from
+#    within the CMake configuration file.
+#  * The only way to have a test depend on a binary is to add a fake test with a name like
+#    "build_fish" that executes CMake recursively to build the `fish` target.
+#  * Circling back to the point about individual tests not being actual Makefile targets, CMake does
+#    not offer any way to execute a named test via the `make`/`ninja`/whatever interface; the only
+#    way to manually invoke test `foo` is to to manually run `ctest` and specify a regex matching
+#    `foo` as an argument, e.g. `ctest -R ^foo$`... which is really crazy.
+
+# The top-level test target is "fish_run_tests".
+add_custom_target(fish_run_tests
+  COMMAND env CTEST_PARALLEL_LEVEL=${CTEST_PARALLEL_LEVEL} FISH_FORCE_COLOR=1
+          ${CMAKE_CTEST_COMMAND} --force-new-ctest-process # --verbose
+          --output-on-failure --progress
+  DEPENDS fish fish_indent fish_key_reader fish_test_helper
+  USES_TERMINAL
+)
+
+# CMake being CMake, you can't just add a DEPENDS argument to add_test to make it depend on any of
+# your binaries actually being built before `make fish_run_tests` is executed (requiring `make all` first),
+# and the only dependency a test can have is on another test. So we make building fish
+# prerequisites to our entire top-level `test` target.
+function(add_test_target NAME)
+  string(REPLACE "/" "-" NAME ${NAME})
+  add_custom_target("test_${NAME}" COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -R "^${NAME}$$"
+    DEPENDS fish fish_indent fish_key_reader fish_test_helper USES_TERMINAL)
+endfunction()
+
+add_executable(fish_test_helper tests/fish_test_helper.c)
+
 FILE(GLOB FISH_CHECKS CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/tests/checks/*.fish)
 foreach(CHECK ${FISH_CHECKS})
-    get_filename_component(CHECK_NAME ${CHECK} NAME)
-    add_custom_target(
-        test_${CHECK_NAME}
-        COMMAND ${CMAKE_SOURCE_DIR}/tests/test_driver.py ${CMAKE_CURRENT_BINARY_DIR}
-            checks/${CHECK_NAME}
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests
-        DEPENDS fish fish_indent fish_key_reader
-        USES_TERMINAL
-    )
+  get_filename_component(CHECK_NAME ${CHECK} NAME)
+  get_filename_component(CHECK ${CHECK} NAME_WE)
+  add_test(NAME ${CHECK_NAME}
+    COMMAND ${CMAKE_SOURCE_DIR}/tests/test_driver.py --cachedir=${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}
+                checks/${CHECK}.fish
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests
+  )
+  set_tests_properties(${CHECK_NAME} PROPERTIES SKIP_RETURN_CODE ${SKIP_RETURN_CODE})
+  set_tests_properties(${CHECK_NAME} PROPERTIES ENVIRONMENT FISH_FORCE_COLOR=1)
+  add_test_target("${CHECK_NAME}")
 endforeach(CHECK)
 
 FILE(GLOB PEXPECTS CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/tests/pexpects/*.py)
 foreach(PEXPECT ${PEXPECTS})
-    get_filename_component(PEXPECT ${PEXPECT} NAME)
-    add_custom_target(
-        test_${PEXPECT}
-        COMMAND ${CMAKE_SOURCE_DIR}/tests/test_driver.py ${CMAKE_CURRENT_BINARY_DIR}
-            pexpects/${PEXPECT}
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests
-        DEPENDS fish fish_indent fish_key_reader
-        USES_TERMINAL
-    )
+  get_filename_component(PEXPECT ${PEXPECT} NAME)
+  add_test(NAME ${PEXPECT}
+    COMMAND ${CMAKE_SOURCE_DIR}/tests/test_driver.py --cachedir=${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}
+                pexpects/${PEXPECT}
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests
+  )
+  set_tests_properties(${PEXPECT} PROPERTIES SKIP_RETURN_CODE ${SKIP_RETURN_CODE})
+  set_tests_properties(${PEXPECT} PROPERTIES ENVIRONMENT FISH_FORCE_COLOR=1)
+  add_test_target("${PEXPECT}")
 endforeach(PEXPECT)
 
-# Rust stuff.
 set(cargo_test_flags)
+# Rust stuff.
 if(DEFINED ASAN)
     # Rust w/ -Zsanitizer=address requires explicitly specifying the --target triple or else linker
     # errors pertaining to asan symbols will ensue.
     if(NOT DEFINED Rust_CARGO_TARGET)
-        message(
-            FATAL_ERROR
-            "ASAN requires defining the CMake variable Rust_CARGO_TARGET to the
-            intended target triple"
-        )
+        message(FATAL_ERROR "ASAN requires defining the CMake variable Rust_CARGO_TARGET to the
+            intended target triple")
     endif()
 endif()
 if(DEFINED TSAN)
     if(NOT DEFINED Rust_CARGO_TARGET)
-        message(
-            FATAL_ERROR
-            "TSAN requires defining the CMake variable Rust_CARGO_TARGET to the
-            intended target triple"
-        )
+        message(FATAL_ERROR "TSAN requires defining the CMake variable Rust_CARGO_TARGET to the
+            intended target triple")
     endif()
 endif()
 
@@ -52,25 +107,10 @@ if(DEFINED Rust_CARGO_TARGET)
     list(APPEND cargo_test_flags "--lib")
 endif()
 
-set(max_concurrency_flag)
-if(DEFINED ENV{FISH_TEST_MAX_CONCURRENCY})
-    list(APPEND max_concurrency_flag "--max-concurrency" $ENV{FISH_TEST_MAX_CONCURRENCY})
-endif()
-
-# The top-level test target is "fish_run_tests".
-add_custom_target(fish_run_tests
-    # TODO: This should be replaced with a unified solution, possibly build_tools/check.sh.
-    COMMAND ${CMAKE_SOURCE_DIR}/tests/test_driver.py ${max_concurrency_flag} ${CMAKE_CURRENT_BINARY_DIR}
-    COMMAND
-        env ${VARS_FOR_CARGO} ${Rust_CARGO}
-            test
-            --no-default-features
-            --features=${FISH_CARGO_FEATURES}
-            ${CARGO_FLAGS}
-            --workspace
-            --target-dir ${rust_target_dir}
-            ${cargo_test_flags}
+add_test(
+    NAME "cargo-test"
+    COMMAND env ${VARS_FOR_CARGO} cargo test --no-default-features ${CARGO_FLAGS} --workspace --target-dir ${rust_target_dir} ${cargo_test_flags}
     WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-    DEPENDS fish fish_indent fish_key_reader
-    USES_TERMINAL
 )
+set_tests_properties("cargo-test" PROPERTIES SKIP_RETURN_CODE ${SKIP_RETURN_CODE})
+add_test_target("cargo-test")

cmake/Version.cmake

@@ -0,0 +1,55 @@
+# This file adds commands to manage the FISH-BUILD-VERSION-FILE (hereafter
+# FBVF). This file exists in the build directory and is used to populate the
+# documentation and also the version string in fish_version.o (printed with
+# `echo $version` and also fish --version). The essential idea is that we are
+# going to invoke git_version_gen.sh, which will update the
+# FISH-BUILD-VERSION-FILE only if it needs to change; this is what makes
+# incremental rebuilds fast.
+#
+# This code is delicate, with the chief subtlety revolving around Ninja. A
+# natural and naive approach would tell the generated build system that FBVF is
+# a dependency of fish_version.o, and that git_version_gen.sh updates it. Make
+# will then invoke the script, check the timestamp on fish_version.o and FBVF,
+# see that FBVF is earlier, and then not rebuild fish_version.o. Ninja,
+# however, decides what to build up-front and will unconditionally rebuild
+# fish_version.o.
+#
+# To avoid this with Ninja, we want to hook into its 'restat' option which we
+# can do through the BYPRODUCTS feature of CMake. See
+# https://cmake.org/cmake/help/latest/policy/CMP0058.html
+#
+# Unfortunately BYPRODUCTS behaves strangely with the Makefile generator: it
+# marks FBVF as generated and then CMake itself will `touch` it on every build,
+# meaning that using BYPRODUCTS will cause fish_version.o to be rebuilt
+# unconditionally with the Makefile generator. Thus we want to use the
+# natural-and-naive approach for Makefiles.
+
+# **IMPORTANT** If you touch these build rules, please test both Ninja and
+# Makefile generators with both a clean and dirty git tree. Verify that both
+# generated build systems rebuild fish when the git tree goes from dirty to
+# clean (and vice versa), and verify they do NOT rebuild it when the git tree
+# stays the same (incremental builds must be fast).
+
+# Just a handy abbreviation.
+set(FBVF FISH-BUILD-VERSION-FILE)
+
+# TODO: find a cleaner way to do this.
+IF (${CMAKE_GENERATOR} STREQUAL Ninja)
+  set(FBVF-OUTPUT fish-build-version-witness.txt)
+  set(CFBVF-BYPRODUCTS ${FBVF})
+else(${CMAKE_GENERATOR} STREQUAL Ninja)
+  set(FBVF-OUTPUT ${FBVF})
+  set(CFBVF-BYPRODUCTS)
+endif(${CMAKE_GENERATOR} STREQUAL Ninja)
+
+# Set up the version targets
+add_custom_target(CHECK-FISH-BUILD-VERSION-FILE
+                  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/build_tools/git_version_gen.sh ${CMAKE_CURRENT_BINARY_DIR}
+                  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                  BYPRODUCTS ${CFBVF-BYPRODUCTS})
+
+add_custom_command(OUTPUT ${FBVF-OUTPUT}
+                    DEPENDS CHECK-FISH-BUILD-VERSION-FILE)
+
+# Abbreviation for the target.
+set(CFBVF CHECK-FISH-BUILD-VERSION-FILE)

cmake/gettext.cmake

@@ -0,0 +1,22 @@
+set(languages de en fr pl pt_BR sv zh_CN)
+
+include(FeatureSummary)
+
+option(WITH_GETTEXT "translate messages if gettext is available" ON)
+if(WITH_GETTEXT)
+  find_package(Gettext)
+endif()
+add_feature_info(gettext GETTEXT_FOUND "translate messages with gettext")
+
+# Define translations
+if(GETTEXT_FOUND)
+  # Group pofile targets into their own folder, as there's a lot of them.
+  set(CMAKE_FOLDER pofiles)
+  foreach(lang ${languages})
+    # Our translations aren't set up entirely as CMake expects, so installation is done in
+    # cmake/Install.cmake instead of using INSTALL_DESTINATION
+    gettext_process_po_files(${lang} ALL
+                             PO_FILES po/${lang}.po)
+  endforeach()
+  set(CMAKE_FOLDER)
+endif()

contrib/debian/changelog

@@ -1,528 +0,0 @@
-fish (4.7.1-1) stable; urgency=medium
-
-  * Release of new version 4.7.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.7.1 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Fri, 08 May 2026 00:02:14 +0800
-
-fish (4.7.0-1) stable; urgency=medium
-
-  * Release of new version 4.7.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.7.0 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Tue, 05 May 2026 15:24:27 +0800
-
-fish (4.6.0-1) stable; urgency=medium
-
-  * Release of new version 4.6.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.6.0 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Sat, 28 Mar 2026 12:56:37 +0800
-
-fish (4.5.0-1) stable; urgency=medium
-
-  * Release of new version 4.5.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.5.0 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Tue, 17 Feb 2026 11:32:33 +1100
-
-fish (4.4.0-1) stable; urgency=medium
-
-  * Release of new version 4.4.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.4.0 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Tue, 03 Feb 2026 12:11:51 +1100
-
-fish (4.3.3-1) stable; urgency=medium
-
-  * Release of new version 4.3.3.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.3.3 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Wed, 07 Jan 2026 08:34:20 +0100
-
-fish (4.3.2-1) stable; urgency=medium
-
-  * Release of new version 4.3.2.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.3.2 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Tue, 30 Dec 2025 17:21:04 +0100
-
-fish (4.3.1-1) stable; urgency=medium
-
-  * Release of new version 4.3.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.3.1 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Sun, 28 Dec 2025 16:54:44 +0100
-
-fish (4.3.0-1) stable; urgency=medium
-
-  * Release of new version 4.3.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.3.0 for details.
-
- -- Johannes Altmanninger <aclopte@gmail.com>  Sun, 28 Dec 2025 10:20:47 +0100
-
-fish (4.2.1-1) testing; urgency=medium
-
-  * Release of new version 4.2.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.2.1 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 13 Nov 2025 20:42:43 +0800
-
-fish (4.2.0-1) testing; urgency=medium
-
-  * Release of new version 4.2.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.2.0 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Mon, 10 Nov 2025 19:29:03 +0800
-
-fish (4.1.2-1) testing; urgency=medium
-
-  * Release of new version 4.1.2.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.1.2 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Wed, 08 Oct 2025 13:46:45 +0800
-
-fish (4.1.1-1) testing; urgency=medium
-
-  * Release of new version 4.1.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.1.1 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Fri, 03 Oct 2025 16:43:43 +0800
-
-fish (4.0.8-1) testing; urgency=medium
-
-  * Release of new version 4.0.8.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.0.8 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 18 Sep 2025 22:17:43 +0800
-
-fish (4.0.6-1) testing; urgency=medium
-
-  * Release of new version 4.0.6.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.0.6 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Wed, 17 Sep 2025 12:27:09 +0800
-
-fish (4.0.2-2) testing; urgency=medium
-
-  * Fix tests on Debian.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sun, 20 Apr 2025 23:08:14 +0800
-
-fish (4.0.2-1) testing; urgency=medium
-
-  * Release of new version 4.0.2.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.0.2 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sun, 20 Apr 2025 21:24:18 +0800
-
-fish (4.0.1-1) testing; urgency=medium
-
-  * Release of new version 4.0.1.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 13 Mar 2025 11:30:21 +0800
-
-fish (4.0.0-2) testing; urgency=medium
-
-  * Fix tests on Debian.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 27 Feb 2025 21:50:33 +0800
-
-fish (4.0.0-1) testing; urgency=medium
-
-  * Release of new version 4.0.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.0.0 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 27 Feb 2025 19:22:30 +0800
-
-fish (4.0.1-1) testing; urgency=medium
-
-  * Release of new beta version 4.0b1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/4.0b1 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 17 Dec 2024 23:42:25 +0800
-
-fish (3.7.1-1) testing; urgency=medium
-
-  * Release of new version 3.7.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.7.1 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 19 Mar 2024 13:26:22 +0800
-
-fish (3.7.0-1) testing; urgency=medium
-
-  * Release of new version 3.7.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.7.0 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Mon, 01 Jan 2024 23:32:55 +0800
-
-fish (3.6.4-1) testing; urgency=medium
-
-  * Release of new version 3.6.4.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.6.4 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 05 Dec 2023 22:34:09 +0800
-
-fish (3.6.3-1) testing; urgency=medium
-
-  * Release of new version 3.6.3.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.6.3 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 05 Dec 2023 00:11:12 +0800
-
-fish (3.6.2-1) testing; urgency=medium
-
-  * Release of new version 3.6.2.
-  * Includes a fix for CVE-2023-49284.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.6.2 for details.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Mon, 04 Dec 2023 23:16:42 +0800
-
-fish (3.6.1-1) testing; urgency=medium
-
-  * Release of new version 3.6.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.6.1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sat, 25 Mar 2023 17:22:12 +0800
-
-fish (3.6.0-1) testing; urgency=medium
-
-  * Release of new version 3.6.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.6.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sat, 07 Jan 2023 22:41:32 +0800
-
-fish (3.5.1-1) testing; urgency=medium
-
-  * Release of new version 3.5.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.5.1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Wed, 20 Jul 2022 21:54:09 +0800
-
-fish (3.5.0-1) testing; urgency=medium
-
-  * Release of new version 3.5.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.5.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 16 Jun 2022 19:45:33 +0800
-
-fish (3.4.0-1) testing; urgency=medium
-
-  * Release of new version 3.4.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.4.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sat, 12 Mar 2022 23:24:22 +0800
-
-fish (3.3.1-1) testing; urgency=medium
-
-  * Release of new version 3.3.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.3.1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 06 Jul 2021 23:22:36 +0800
-
-fish (3.3.0-1) testing; urgency=medium
-
-  * Release of new version 3.3.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.3.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Mon, 28 Jun 2021 23:06:36 +0800
-
-fish (3.2.2-1) testing; urgency=medium
-
-  * Release of new version 3.2.2.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.2.2 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Wed, 07 Apr 2021 21:10:54 +0800
-
-fish (3.2.1-1) testing; urgency=medium
-
-  * Release of new version 3.2.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.2.1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 18 Mar 2021 12:08:13 +0800
-
-fish (3.2.0-1) testing; urgency=medium
-
-  * Release of new version 3.2.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.2.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Mon, 01 Mar 2021 21:22:39 +0800
-
-fish (3.1.2-1) testing; urgency=medium
-
-  * Release of new version 3.1.2.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.1.2 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Wed, 29 Apr 2020 11:22:35 +0800
-
-fish (3.1.1-1) testing; urgency=medium
-
-  * Release of new version 3.1.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.1.1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Mon, 27 Apr 2020 22:45:35 +0800
-
-fish (3.1.0-1) testing; urgency=medium
-
-  * Release of new version 3.1.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.1.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Wed, 12 Feb 2020 22:34:53 +0800
-
-fish (3.1.1-1) testing; urgency=medium
-
-  * Release of new beta version 3.1b1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.1b1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sun, 26 Jan 2020 21:42:46 +0800
-
-fish (3.0.2-1) testing; urgency=medium
-
-  * Release of new version 3.0.2.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.0.2 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 19 Feb 2019 21:45:05 +0800
-
-fish (3.0.1-1) testing; urgency=medium
-
-  * Release of new version 3.0.1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.0.1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Mon, 11 Feb 2019 20:23:55 +0800
-
-fish (3.0.0-1) testing; urgency=medium
-
-  * Release of new version 3.0.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.0.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Fri, 28 Dec 2018 21:10:28 +0800
-
-fish (3.0.1-1) testing; urgency=medium
-
-  * Release of new beta version 3.0b1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/3.0b1 for
-  significant changes, which includes backward incompatibility.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 11 Dec 2018 22:59:15 +0800
-
-fish (2.7.1-1) testing; urgency=medium
-
-  * Release of new bug fix version 2.7.1. On all Linux platforms, this is
-    release will behave identically to 2.7.0.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sat, 23 Dec 2017 00:43:12 +0800
-
-fish (2.7.0-1) testing; urgency=medium
-
-  * Release of new version 2.7.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.7.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 23 Nov 2017 18:38:21 +0800
-
-fish (2.7.1-1) testing; urgency=medium
-
-  * Release of new beta version 2.7b1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.7b1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 31 Oct 2017 20:32:29 +0800
-
-fish (2.6.0-1) testing; urgency=medium
-
-  * Relase of new version 2.6.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.6.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sat, 03 Jun 2017 20:51:50 +0800
-
-fish (2.6b1-1) testing; urgency=medium
-
-  * Release of new beta version 2.6b1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.6b1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sun, 14 May 2017 10:47:39 +0800
-
-fish (2.5.0-1) testing; urgency=medium
-
-  * Release of new version 2.5.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.5.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Fri, 03 Feb 2017 09:52:57 +0800
-
-fish (2.5b1-1) testing; urgency=medium
-
-  * Release of new beta version 2.5b1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.5b1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sat, 14 Jan 2017 08:49:34 +0800
-
-fish (2.4.0-2) testing; urgency=medium
-
-  * Change recommendation of xdg-utils to suggestion (closes
-    https://github.com/fish-shell/fish-shell/issues/3534).
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Wed, 09 Nov 2016 22:56:16 +0800
-
-fish (2.4.0-1) testing; urgency=medium
-
-  * Release of new version 2.4.0.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.4.0 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 08 Nov 2016 11:29:57 +0800
-
-fish (2.4b1-1) testing; urgency=medium
-
-  * Release of new beta version 2.4b1.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.4b1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 18 Oct 2016 22:25:26 +0800
-
-fish (2.3.1-1) testing; urgency=medium
-
-  * Release of new version 2.3.1.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sun, 03 Jul 2016 21:21:51 +0800
-
-fish (2.3.0-1) testing; urgency=medium
-
-  * Release of new version 2.3.0.
-
-  See http://fishshell.com/release_notes.html for significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sat, 21 May 2016 06:59:54 +0800
-
-fish (2.3b2-1) testing; urgency=medium
-
-  * Release of new beta version 2.3b2.
-
-  See https://github.com/fish-shell/fish-shell/releases/tag/2.3b2 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 05 May 2016 06:22:37 +0800
-
-fish (2.3.1-1) testing; urgency=medium
-
-  * Release of new beta version 2.3b1.
-
-  See http://github.com/fish-shell/fish-shell/releases/tag/2.3b1 for
-  significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Tue, 19 Apr 2016 21:07:17 +0800
-
-fish (2.2.0-2) testing; urgency=medium
-
-  * Binary rebuild only to resynchronise repository state.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Mon, 15 Feb 2016 22:45:05 +0800
-
-fish (2.2.0-1) testing; urgency=medium
-
-  * Release of new version 2.2.0.
-
-    See http://fishshell.com/release_notes.html for significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sun, 12 Jul 2015 18:52:29 +0800
-
-fish (2.2b1-1) testing; urgency=low
-
-  * Release of new beta version 2.2b1.
-
-  See http://fishshell.com/staging/release_notes.html for significant
-  changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 07 May 2015 14:48:21 +0800
-
-fish (2.1.1-1) unstable; urgency=high
-
-  * Release of new version 2.1.1.
-
-    See http://fishshell.com/release_notes.html for significant changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sun, 07 Sep 2014 17:06:31 +0800
-
-fish (2.1.0-1) unstable; urgency=low
-
-  * Release of new version 2.1.0.
-
-    See http://fishshell.com/staging/release_notes.html for significant
-    changes.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Sat, 19 Oct 2013 14:35:23 +0800
-
-fish (2.0.0-0) unstable; urgency=low
-
-  * Initial release of fish 2.0.0.
-
- -- David Adam <zanchey@ucc.gu.uwa.edu.au>  Thu, 19 Jul 2012 23:17:58 +0800

contrib/debian/rules

@@ -1,28 +0,0 @@
-#!/usr/bin/make -f
-# -*- makefile -*-
-
-ifeq (,$(filter terse,$(DEB_BUILD_OPTIONS)))
-  export DH_VERBOSE=1
-  # VERBOSE to satisfy Debian policy 4.9, introduced in version 4.2.0
-  export CARGO_TERM_VERBOSE=true
-endif
-# The LTO profile sets CFLAGS/CXXFLAGS which confuse the compilation process; disable it
-# LTO is still performed by rustc based on Cargo.toml
-export DEB_BUILD_MAINT_OPTIONS=optimize=-lto
-
-%:
-	dh $@ --buildsystem=cmake --builddirectory=build
-
-# Setting the build system is still required, because otherwise the GNUmakefile gets picked up
-override_dh_auto_configure:
-	ln -s cargo-vendor/vendor vendor
-	dh_auto_configure -- -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-	  -DRust_CARGO=$$(command -v cargo-1.85 || command -v cargo) \
-	  -DRust_COMPILER=$$(command -v rustc-1.85 || command -v rustc)
-
-override_dh_clean:
-	dh_clean --exclude=Cargo.toml.orig
-	-unlink vendor
-
-override_dh_auto_test:
-	cd build && make fish_run_tests

contrib/debian/source/local-options

@@ -1,3 +0,0 @@
-# The vendor tarball drops a new version of .cargo/config into place. Representing this as a patch
-# in automated workflows is tricky, so for our purposes auto-commit is fine.
-auto-commit

contrib/shell.nix

@@ -1,33 +0,0 @@
-# Environment containing all dependencies needed for
-# - building fish,
-# - building documentation,
-# - running all tests,
-# - formatting and checking lints.
-#
-# enter interactive bash shell:
-#   nix-shell contrib/shell.nix
-#
-# using system nixpkgs (otherwise fetches pinned version):
-#   nix-shell contrib/shell.nix --arg pkgs 'import <nixpkgs> {}'
-#
-# run single command:
-#   nix-shell contrib/shell --run "cargo xtask check"
-{ pkgs ? (import (builtins.fetchTarball {
-  url = "https://github.com/NixOS/nixpkgs/archive/nixos-25.11.tar.gz";
-  sha256 = "1ia5kjykm9xmrpwbzhbaf4cpwi3yaxr7shl6amj8dajvgbyh2yh4";
-}) { }), ... }:
-pkgs.mkShell {
-  buildInputs = [
-    (pkgs.python3.withPackages (pyPkgs: [ pyPkgs.pexpect ]))
-    pkgs.cargo
-    pkgs.clippy
-    pkgs.cmake
-    pkgs.gettext
-    pkgs.pcre2
-    pkgs.procps # tests use pgrep/pkill
-    pkgs.ruff
-    pkgs.rustc
-    pkgs.rustfmt
-    pkgs.sphinx
-  ];
-}

crates/build-helper/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "fish-build-helper"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-rsconf.workspace = true
-
-[lints]
-workspace = true

crates/build-helper/src/lib.rs

@@ -1,122 +0,0 @@
-use std::{borrow::Cow, env, os::unix::ffi::OsStrExt as _, path::Path};
-
-pub fn env_var(name: &str) -> Option<String> {
-    let err = match env::var(name) {
-        Ok(p) => return Some(p),
-        Err(err) => err,
-    };
-    use env::VarError::*;
-    match err {
-        NotPresent => None,
-        NotUnicode(os_string) => {
-            panic!(
-                "Environment variable {name} is not valid Unicode: {:?}",
-                os_string.as_bytes()
-            )
-        }
-    }
-}
-
-pub fn workspace_root() -> &'static Path {
-    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    manifest_dir.ancestors().nth(2).unwrap()
-}
-
-fn cargo_target_dir() -> Cow<'static, Path> {
-    option_env!("CARGO_TARGET_DIR")
-        .map(|d| Cow::Borrowed(Path::new(d)))
-        .unwrap_or(Cow::Owned(workspace_root().join("target")))
-}
-
-pub fn fish_build_dir() -> Cow<'static, Path> {
-    option_env!("FISH_CMAKE_BINARY_DIR")
-        .map(|d| Cow::Borrowed(Path::new(d)))
-        .unwrap_or(cargo_target_dir())
-}
-
-pub fn fish_doc_dir() -> Cow<'static, Path> {
-    cargo_target_dir().join("fish-docs").into()
-}
-
-fn l10n_dir() -> Cow<'static, Path> {
-    workspace_root().join("localization").into()
-}
-
-pub fn ftl_dir() -> Cow<'static, Path> {
-    l10n_dir().join("fluent").into()
-}
-
-pub static DEFAULT_LANGUAGE: &str = "en";
-
-pub fn default_ftl_file() -> Cow<'static, Path> {
-    ftl_dir().join(format!("{DEFAULT_LANGUAGE}.ftl")).into()
-}
-
-pub fn po_dir() -> Cow<'static, Path> {
-    l10n_dir().join("po").into()
-}
-
-// TODO Move this to rsconf
-pub fn rebuild_if_path_changed<P: AsRef<Path>>(path: P) {
-    rsconf::rebuild_if_path_changed(path.as_ref().to_str().unwrap());
-}
-
-// TODO Move this to rsconf
-pub fn rebuild_if_paths_changed<P: AsRef<Path>, I: IntoIterator<Item = P>>(paths: I) {
-    for path in paths {
-        rsconf::rebuild_if_path_changed(path.as_ref().to_str().unwrap());
-    }
-}
-
-pub fn rebuild_if_embedded_path_changed<P: AsRef<Path>>(path: P) {
-    // Not necessary in debug builds, where rust-embed reads from the filesystem.
-    if cfg!(any(not(debug_assertions), windows)) {
-        rebuild_if_path_changed(path);
-    }
-}
-
-// Target OS for compiling our crates, as opposed to the build script.
-pub fn target_os() -> String {
-    env_var("CARGO_CFG_TARGET_OS").unwrap()
-}
-
-pub fn target_os_is_apple() -> bool {
-    matches!(target_os().as_str(), "ios" | "macos")
-}
-
-/// Detect if we're being compiled for a BSD-derived OS, allowing targeting code conditionally with
-/// `#[cfg(bsd)]`.
-///
-/// Rust offers fine-grained conditional compilation per-os for the popular operating systems, but
-/// doesn't necessarily include less-popular forks nor does it group them into families more
-/// specific than "windows" vs "unix" so we can conditionally compile code for BSD systems.
-pub fn target_os_is_bsd() -> bool {
-    let target_os = target_os();
-    let is_bsd = target_os.ends_with("bsd") || target_os == "dragonfly";
-    if matches!(
-        target_os.as_str(),
-        "dragonfly" | "freebsd" | "netbsd" | "openbsd"
-    ) {
-        assert!(is_bsd, "Target incorrectly detected as not BSD!");
-    }
-    is_bsd
-}
-
-pub fn target_os_is_cygwin() -> bool {
-    target_os() == "cygwin"
-}
-
-#[macro_export]
-macro_rules! as_os_strs {
-    [ $( $x:expr ),* $(,)? ] => {
-        {
-            use std::ffi::OsStr;
-            fn as_os_str<S: AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr {
-                s.as_ref()
-            }
-            [
-                $( as_os_str($x) ),*
-            ]
-        }
-    }
-}

crates/build-man-pages/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "fish-build-man-pages"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[build-dependencies]
-fish-build-helper.workspace = true
-rsconf.workspace = true
-
-[lints]
-workspace = true

crates/build-man-pages/build.rs

@@ -1,101 +0,0 @@
-use std::path::Path;
-
-use fish_build_helper::{as_os_strs, fish_doc_dir};
-
-fn main() {
-    let sec1_dir = fish_doc_dir().join("man").join("man1");
-    // Running `cargo clippy` on a clean build directory panics, because when rust-embed
-    // tries to embed a directory which does not exist it will panic.
-    let _ = std::fs::create_dir_all(&sec1_dir);
-    if !cfg!(clippy) {
-        build_man(&sec1_dir);
-    }
-}
-
-fn build_man(sec1_dir: &Path) {
-    use fish_build_helper::{env_var, workspace_root};
-    use std::process::{Command, Stdio};
-
-    let workspace_root = workspace_root();
-    let doc_src_dir = workspace_root.join("doc_src");
-    let doctrees_dir = fish_doc_dir().join(".doctrees-man");
-
-    fish_build_helper::rebuild_if_paths_changed([
-        &workspace_root.join("CHANGELOG.rst"),
-        &workspace_root.join("CONTRIBUTING.rst"),
-        &doc_src_dir,
-    ]);
-
-    let args = as_os_strs![
-        "-j",
-        "auto",
-        "-q",
-        "-b",
-        "man",
-        "-c",
-        &doc_src_dir,
-        // doctree path - put this *above* the man1 dir to exclude it.
-        // this is ~6M
-        "-d",
-        &doctrees_dir,
-        &doc_src_dir,
-        &sec1_dir,
-    ];
-
-    rsconf::rebuild_if_env_changed("FISH_BUILD_DOCS");
-    if env_var("FISH_BUILD_DOCS") == Some("0".to_owned()) {
-        rsconf::warn!("Skipping man pages because $FISH_BUILD_DOCS is set to 0");
-        return;
-    }
-
-    // We run sphinx to build the man pages.
-    // Every error here is fatal so cargo doesn't cache the result
-    // - if we skipped the docs with sphinx not installed, installing it would not then build the docs.
-    // That means you need to explicitly set $FISH_BUILD_DOCS=0 (`FISH_BUILD_DOCS=0 cargo install --path .`),
-    // which is unfortunate - but the docs are pretty important because they're also used for --help.
-    let sphinx_build = match Command::new(option_env!("FISH_SPHINX").unwrap_or("sphinx-build"))
-        .args(args)
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .spawn()
-    {
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
-            assert_ne!(
-                env_var("FISH_BUILD_DOCS"),
-                Some("1".to_owned()),
-                "Could not find sphinx-build required to build man pages.\n\
-                 Install Sphinx or disable building the docs by setting $FISH_BUILD_DOCS=0."
-            );
-            rsconf::warn!(
-                "Could not find sphinx-build required to build man pages. \
-                 If you install Sphinx now, you need to trigger a rebuild to include man pages. \
-                 For example by running `touch doc_src` followed by the build command."
-            );
-            return;
-        }
-        Err(e) => {
-            // Another error - permissions wrong etc
-            panic!("Error starting sphinx-build to build man pages: {:?}", e);
-        }
-        Ok(sphinx_build) => sphinx_build,
-    };
-
-    match sphinx_build.wait_with_output() {
-        Err(err) => {
-            panic!(
-                "Error waiting for sphinx-build to build man pages: {:?}",
-                err
-            );
-        }
-        Ok(out) => {
-            if !out.stderr.is_empty() {
-                rsconf::warn!("sphinx-build: {}", String::from_utf8_lossy(&out.stderr));
-            }
-            assert_eq!(&String::from_utf8_lossy(&out.stdout), "");
-            assert!(
-                out.status.success(),
-                "sphinx-build failed to build the man pages."
-            );
-        }
-    }
-}

crates/build-man-pages/src/lib.rs

@@ -1 +0,0 @@
-

crates/color/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "fish-color"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-fish-common.workspace = true
-fish-widestring.workspace = true
-
-[lints]
-workspace = true

crates/common/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "fish-common"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-bitflags.workspace = true
-fish-feature-flags.workspace = true
-fish-widestring.workspace = true
-libc.workspace = true
-nix.workspace = true
-
-[build-dependencies]
-fish-build-helper.workspace = true
-rsconf.workspace = true
-
-[lints]
-workspace = true

crates/common/build.rs

@@ -1,5 +0,0 @@
-use fish_build_helper::target_os_is_apple;
-
-fn main() {
-    rsconf::declare_cfg("apple", target_os_is_apple());
-}

crates/fallback/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "fish-fallback"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-fish-common.workspace = true
-fish-widecharwidth.workspace = true
-fish-widestring.workspace = true
-libc.workspace = true
-widestring.workspace = true
-
-[build-dependencies]
-fish-build-helper.workspace = true
-rsconf.workspace = true
-
-[lints]
-workspace = true

crates/fallback/build.rs

@@ -1,5 +0,0 @@
-use fish_build_helper::target_os_is_cygwin;
-
-fn main() {
-    rsconf::declare_cfg("cygwin", target_os_is_cygwin());
-}

crates/fallback/src/lib.rs

@@ -1,174 +0,0 @@
-//! This file only contains fallback implementations of functions which have been found to be missing
-//! or broken by the configuration scripts.
-//!
-//! Many of these functions are more or less broken and incomplete.
-
-use fish_widecharwidth::{WcLookupTable, WcWidth};
-use fish_widestring::prelude::*;
-use std::cmp;
-use std::sync::{
-    LazyLock,
-    atomic::{AtomicUsize, Ordering},
-};
-
-/// Width of ambiguous East Asian characters and, as of TR11, all private-use characters.
-/// 1 is the typical default, but we accept any non-negative override via `$fish_ambiguous_width`.
-pub static FISH_AMBIGUOUS_WIDTH: AtomicUsize = AtomicUsize::new(1);
-
-/// Width of emoji characters.
-///
-/// This must be configurable because the value changed between Unicode 8 and Unicode 9, `wcwidth()`
-/// is emoji-unaware, and terminal emulators do different things.
-///
-/// See issues like [#4539](https://github.com/fish-shell/fish-shell/issues/4539) and <https://github.com/neovim/neovim/issues/4976> for how painful this is.
-///
-/// Valid values are 1, and 2. 1 is the typical emoji width used in Unicode 8 while some newer
-/// terminals use a width of 2 since Unicode 9.
-// For some reason, this is declared here and exposed here, but is set in `env_dispatch`.
-pub static FISH_EMOJI_WIDTH: AtomicUsize = AtomicUsize::new(2);
-
-static WC_LOOKUP_TABLE: LazyLock<WcLookupTable> = LazyLock::new(WcLookupTable::new);
-
-pub fn fish_wcwidth(c: char) -> Option<usize> {
-    // Check for VS16 which selects emoji presentation. This "promotes" a character like U+2764
-    // (width 1) to an emoji (probably width 2). So treat it as width 1 so the sums work. See #2652.
-    // VS15 selects text presentation.
-    let variation_selector_16 = '\u{FE0F}';
-    let variation_selector_15 = '\u{FE0E}';
-    if c == variation_selector_16 {
-        return Some(1);
-    } else if c == variation_selector_15 {
-        return Some(0);
-    }
-
-    // Check for Emoji_Modifier property. Only the Fitzpatrick modifiers have this, in range
-    // 1F3FB..1F3FF. This is a hack because such an emoji appearing on its own would be drawn as
-    // width 2, but that's unlikely to be useful. See #8275.
-    if ('\u{1F3FB}'..='\u{1F3FF}').contains(&c) {
-        return Some(0);
-    }
-
-    let width = WC_LOOKUP_TABLE.classify(c);
-    Some(match width {
-        WcWidth::NonPrint => return None,
-        WcWidth::NonCharacter | WcWidth::Combining | WcWidth::Unassigned => 0,
-        WcWidth::Ambiguous | WcWidth::PrivateUse => {
-            // TR11: "All private-use characters are by default classified as Ambiguous".
-            FISH_AMBIGUOUS_WIDTH.load(Ordering::Relaxed)
-        }
-        WcWidth::One => 1,
-        WcWidth::Two => 2,
-        WcWidth::WidenedIn9 => FISH_EMOJI_WIDTH.load(Ordering::Relaxed),
-    })
-}
-
-pub fn fish_wcswidth(s: &wstr) -> Option<usize> {
-    fish_wcswidth_canonicalizing(s, std::convert::identity)
-}
-
-pub fn fish_wcswidth_canonicalizing(s: &wstr, canonicalize: fn(char) -> char) -> Option<usize> {
-    let chars = s.chars().map(canonicalize);
-    // ascii fast path
-    if chars.clone().all(|c| c.is_ascii() && !c.is_ascii_control()) {
-        return Some(s.len());
-    }
-
-    let mut result = 0;
-    for c in chars {
-        result += fish_wcwidth(c)?;
-    }
-    Some(result)
-}
-
-pub fn wcscasecmp(lhs: &wstr, rhs: &wstr) -> cmp::Ordering {
-    wcscasecmp_fuzzy(lhs, rhs, std::convert::identity)
-}
-
-/// Compare two wide strings in a case-insensitive fashion
-pub fn wcscasecmp_fuzzy(
-    lhs: &wstr,
-    rhs: &wstr,
-    extra_canonicalization: fn(char) -> char,
-) -> cmp::Ordering {
-    lowercase(lhs.chars())
-        .map(extra_canonicalization)
-        .cmp(lowercase(rhs.chars()).map(extra_canonicalization))
-}
-
-pub fn lowercase(chars: impl Iterator<Item = char>) -> impl Iterator<Item = char> {
-    lowercase_impl(chars, |c| c.to_lowercase())
-}
-pub fn lowercase_rev(chars: impl DoubleEndedIterator<Item = char>) -> impl Iterator<Item = char> {
-    lowercase_impl(chars.rev(), |c| c.to_lowercase().rev())
-}
-fn lowercase_impl<ToLowercase: Iterator<Item = char>>(
-    chars: impl Iterator<Item = char>,
-    to_lowercase: fn(char) -> ToLowercase,
-) -> impl Iterator<Item = char> {
-    /// This struct streams the underlying lowercase chars of a string without allocating.
-    struct ToLowerBuffer<Chars: Iterator<Item = char>, ToLowercase: Iterator<Item = char>> {
-        to_lowercase: fn(char) -> ToLowercase,
-        current: ToLowercase,
-        chars: Chars,
-    }
-
-    impl<Chars: Iterator<Item = char>, ToLowercase: Iterator<Item = char>> Iterator
-        for ToLowerBuffer<Chars, ToLowercase>
-    {
-        type Item = char;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            if let Some(c) = self.current.next() {
-                return Some(c);
-            }
-
-            self.current = (self.to_lowercase)(self.chars.next()?);
-            self.current.next()
-        }
-    }
-
-    impl<Chars: Iterator<Item = char>, ToLowercase: Iterator<Item = char>>
-        ToLowerBuffer<Chars, ToLowercase>
-    {
-        pub fn new(mut chars: Chars, to_lowercase: fn(char) -> ToLowercase) -> Self {
-            Self {
-                to_lowercase,
-                current: chars.next().map_or_else(
-                    || {
-                        let mut empty = to_lowercase('a');
-                        let _ = empty.next();
-                        debug_assert!(empty.next().is_none());
-                        empty
-                    },
-                    to_lowercase,
-                ),
-                chars,
-            }
-        }
-    }
-    ToLowerBuffer::new(chars, to_lowercase)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::wcscasecmp;
-    use fish_widestring::prelude::*;
-    use std::cmp::Ordering;
-
-    #[test]
-    fn test_wcscasecmp() {
-        // Comparison with empty
-        assert_eq!(wcscasecmp(L!("a"), L!("")), Ordering::Greater);
-        assert_eq!(wcscasecmp(L!(""), L!("a")), Ordering::Less);
-        assert_eq!(wcscasecmp(L!(""), L!("")), Ordering::Equal);
-
-        // Basic comparison
-        assert_eq!(wcscasecmp(L!("A"), L!("a")), Ordering::Equal);
-        assert_eq!(wcscasecmp(L!("B"), L!("a")), Ordering::Greater);
-        assert_eq!(wcscasecmp(L!("A"), L!("B")), Ordering::Less);
-
-        // Multi-byte comparison
-        assert_eq!(wcscasecmp(L!("İ"), L!("i\u{307}")), Ordering::Equal);
-        assert_eq!(wcscasecmp(L!("ia"), L!("İa")), Ordering::Less);
-    }
-}

crates/feature-flags/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "fish-feature-flags"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-fish-widestring.workspace = true
-
-[lints]
-workspace = true

crates/feature-flags/src/lib.rs

@@ -1,308 +0,0 @@
-//! Flags to enable upcoming features
-
-use fish_widestring::{L, WExt as _, wstr};
-use std::{
-    cell::RefCell,
-    sync::atomic::{AtomicBool, Ordering},
-};
-
-/// The list of flags.
-#[repr(u8)]
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum FeatureFlag {
-    /// Whether ^ is supported for stderr redirection.
-    StderrNoCaret,
-
-    /// Whether ? is supported as a glob.
-    QuestionMarkNoGlob,
-
-    /// Whether string replace -r double-unescapes the replacement.
-    StringReplaceBackslash,
-
-    /// Whether "&" is not-special if followed by a word character.
-    AmpersandNoBgInToken,
-    /// Whether "%self" is expanded to fish's pid
-    RemovePercentSelf,
-
-    /// Remove `test`'s one and zero arg mode (make `test -n` return false etc)
-    TestRequireArg,
-
-    /// Whether to write OSC 133 prompt markers
-    MarkPrompt,
-
-    /// Do not look up $TERM in terminfo database.
-    IgnoreTerminfo,
-
-    /// Whether we are allowed to query the TTY for extra information.
-    QueryTerm,
-
-    /// Do not try to work around incompatible terminal.
-    OmitTermWorkarounds,
-}
-
-struct Features {
-    // Values for the flags.
-    // These are atomic to "fix" a race reported by tsan where tests of feature flags and other
-    // tests which use them conceptually race.
-    values: [AtomicBool; METADATA.len()],
-}
-
-/// Metadata about feature flags.
-pub struct FeatureMetadata {
-    /// The flag itself.
-    pub flag: FeatureFlag,
-
-    /// User-presentable short name of the feature flag.
-    pub name: &'static wstr,
-
-    /// Comma-separated list of feature groups.
-    pub groups: &'static wstr,
-
-    /// User-presentable description of the feature flag.
-    pub description: &'static wstr,
-
-    /// Default flag value.
-    default_value: bool,
-
-    /// Whether the value can still be changed or not.
-    read_only: bool,
-}
-
-/// The metadata, indexed by flag.
-pub const METADATA: &[FeatureMetadata] = &[
-    FeatureMetadata {
-        flag: FeatureFlag::StderrNoCaret,
-        name: L!("stderr-nocaret"),
-        groups: L!("3.0"),
-        description: L!("^ no longer redirects stderr (historical, can no longer be changed)"),
-        default_value: true,
-        read_only: true,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::QuestionMarkNoGlob,
-        name: L!("qmark-noglob"),
-        groups: L!("3.0"),
-        description: L!("? no longer globs"),
-        default_value: true,
-        read_only: false,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::StringReplaceBackslash,
-        name: L!("regex-easyesc"),
-        groups: L!("3.1"),
-        description: L!("string replace -r needs fewer \\'s"),
-        default_value: true,
-        read_only: false,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::AmpersandNoBgInToken,
-        name: L!("ampersand-nobg-in-token"),
-        groups: L!("3.4"),
-        description: L!("& only backgrounds if followed by a separator"),
-        default_value: true,
-        read_only: false,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::RemovePercentSelf,
-        name: L!("remove-percent-self"),
-        groups: L!("4.0"),
-        description: L!("%self is no longer expanded (use $fish_pid)"),
-        default_value: false,
-        read_only: false,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::TestRequireArg,
-        name: L!("test-require-arg"),
-        groups: L!("4.0"),
-        description: L!("builtin test requires an argument"),
-        default_value: false,
-        read_only: false,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::MarkPrompt,
-        name: L!("mark-prompt"),
-        groups: L!("4.0"),
-        description: L!("write OSC 133 prompt markers to the terminal"),
-        default_value: true,
-        read_only: false,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::IgnoreTerminfo,
-        name: L!("ignore-terminfo"),
-        groups: L!("4.1"),
-        description: L!(
-            "do not look up $TERM in terminfo database (historical, can no longer be changed)"
-        ),
-        default_value: true,
-        read_only: true,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::QueryTerm,
-        name: L!("query-term"),
-        groups: L!("4.1"),
-        description: L!("query the TTY to enable extra functionality"),
-        default_value: true,
-        read_only: false,
-    },
-    FeatureMetadata {
-        flag: FeatureFlag::OmitTermWorkarounds,
-        name: L!("omit-term-workarounds"),
-        groups: L!("4.3"),
-        description: L!("skip workarounds for incompatible terminals"),
-        default_value: false,
-        read_only: false,
-    },
-];
-
-thread_local!(
-    static LOCAL_OVERRIDE_STACK: RefCell<Vec<(FeatureFlag, bool)>> =
-        const { RefCell::new(Vec::new()) };
-);
-
-/// The singleton shared feature set.
-static FEATURES: Features = Features::new();
-
-/// Perform a feature test on the global set of features.
-pub fn feature_test(flag: FeatureFlag) -> bool {
-    if let Some(value) = LOCAL_OVERRIDE_STACK.with(|stack| {
-        for &(overridden_feature, value) in stack.borrow().iter().rev() {
-            if flag == overridden_feature {
-                return Some(value);
-            }
-        }
-        None
-    }) {
-        return value;
-    }
-    FEATURES.test(flag)
-}
-
-/// Parses a comma-separated feature-flag string, updating ourselves with the values.
-/// Feature names or group names may be prefixed with "no-" to disable them.
-/// The special group name "all" may be used for those who like to live on the edge.
-/// Unknown features are silently ignored.
-pub fn set_from_string<'a>(str: impl Into<&'a wstr>) {
-    FEATURES.set_from_string(str.into());
-}
-
-impl Features {
-    const fn new() -> Self {
-        // TODO: feature(const_array): use std::array::from_fn()
-        use std::mem::{MaybeUninit, transmute};
-        let values = {
-            let mut data: [MaybeUninit<AtomicBool>; METADATA.len()] =
-                [const { MaybeUninit::uninit() }; METADATA.len()];
-
-            let mut i = 0;
-            while i < METADATA.len() {
-                data[i].write(AtomicBool::new(METADATA[i].default_value));
-                i += 1;
-            }
-
-            // SAFETY: `data` is guaranteed initialized by the loop
-            unsafe {
-                transmute::<[MaybeUninit<AtomicBool>; METADATA.len()], [AtomicBool; METADATA.len()]>(
-                    data,
-                )
-            }
-        };
-        Features { values }
-    }
-
-    fn test(&self, flag: FeatureFlag) -> bool {
-        self.values[flag as usize].load(Ordering::SeqCst)
-    }
-
-    fn set(&self, flag: FeatureFlag, value: bool) {
-        self.values[flag as usize].store(value, Ordering::SeqCst);
-    }
-
-    fn set_from_string(&self, str: &wstr) {
-        for entry in str.split(',') {
-            let entry = entry.trim();
-            if entry.is_empty() {
-                continue;
-            }
-
-            // A "no-" prefix inverts the sense.
-            let (name, value) = match entry.strip_prefix("no-") {
-                Some(suffix) => (suffix, false),
-                None => (entry, true),
-            };
-            // Look for a feature with this name. If we don't find it, assume it's a group name and set
-            // all features whose group contain it. Do nothing even if the string is unrecognized; this
-            // is to allow uniform invocations of fish (e.g. disable a feature that is only present in
-            // future versions).
-            // The special name 'all' may be used for those who like to live on the edge.
-            if let Some(md) = METADATA.iter().find(|md| md.name == name) {
-                // Only change it if it's not read-only.
-                // Don't complain if it is, this is typically set from a variable.
-                if !md.read_only {
-                    self.set(md.flag, value);
-                }
-            } else {
-                for md in METADATA {
-                    if (md.groups == name || name == L!("all")) && !md.read_only {
-                        self.set(md.flag, value);
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Run code with a feature overridden.
-/// This should only be used in tests.
-pub fn with_overridden_feature(flag: FeatureFlag, value: bool, test_fn: impl FnOnce()) {
-    LOCAL_OVERRIDE_STACK.with(|stack| {
-        stack.borrow_mut().push((flag, value));
-        test_fn();
-        stack.borrow_mut().pop();
-    });
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{FeatureFlag, Features, METADATA, feature_test, with_overridden_feature};
-    use fish_widestring::L;
-
-    #[test]
-    fn test_feature_flags() {
-        let f = Features::new();
-        f.set_from_string(L!("stderr-nocaret,nonsense"));
-        assert!(f.test(FeatureFlag::StderrNoCaret));
-        f.set_from_string(L!("stderr-nocaret,no-stderr-nocaret,nonsense"));
-        assert!(f.test(FeatureFlag::StderrNoCaret));
-
-        // Ensure every metadata is represented once.
-        let mut counts: [usize; METADATA.len()] = [0; METADATA.len()];
-        for md in METADATA {
-            counts[md.flag as usize] += 1;
-        }
-        for count in counts {
-            assert_eq!(count, 1);
-        }
-
-        assert_eq!(
-            METADATA[FeatureFlag::StderrNoCaret as usize].name,
-            L!("stderr-nocaret")
-        );
-    }
-
-    #[test]
-    fn test_overridden_feature() {
-        with_overridden_feature(FeatureFlag::QuestionMarkNoGlob, true, || {
-            assert!(feature_test(FeatureFlag::QuestionMarkNoGlob));
-        });
-
-        with_overridden_feature(FeatureFlag::QuestionMarkNoGlob, false, || {
-            assert!(!feature_test(FeatureFlag::QuestionMarkNoGlob));
-        });
-
-        with_overridden_feature(FeatureFlag::QuestionMarkNoGlob, false, || {
-            with_overridden_feature(FeatureFlag::QuestionMarkNoGlob, true, || {
-                assert!(feature_test(FeatureFlag::QuestionMarkNoGlob));
-            });
-        });
-    }
-}

crates/fluent-extraction/Cargo.toml

@@ -1,24 +0,0 @@
-[package]
-name = "fish-fluent-extraction"
-edition.workspace = true
-rust-version.workspace = true
-version = "0.0.0"
-repository.workspace = true
-license.workspace = true
-description = "proc-macro for extracting IDs for fluent translation"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-fish-tempfile.workspace = true
-fluent-ftl-tools.workspace = true
-fluent-syntax.workspace = true
-proc-macro2.workspace = true
-syn.workspace = true
-
-[build-dependencies]
-rsconf.workspace = true
-
-[lints]
-workspace = true

crates/fluent-extraction/build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    rsconf::rebuild_if_env_changed("FISH_FLUENT_EXTRACTION_DIR");
-}

crates/fluent-extraction/src/lib.rs

@@ -1,105 +0,0 @@
-extern crate proc_macro;
-use fluent_ftl_tools::{
-    HasEntries as _, format_resource, parse_str_as_syntax_resource, serialize_resource,
-};
-use proc_macro::TokenStream;
-use std::{
-    collections::HashSet,
-    ffi::{OsStr, OsString},
-    io::Write as _,
-    path::PathBuf,
-};
-use syn::{
-    Ident, LitStr, Token,
-    parse::{Parse, ParseStream},
-    parse_macro_input,
-};
-
-struct LocalizeDefinition {
-    message_id: String,
-    message_definition: String,
-    variables: Vec<String>,
-}
-
-impl Parse for LocalizeDefinition {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        let message_id = input.parse::<LitStr>()?.value();
-        input.parse::<Token![=]>()?;
-        let message_definition = input.parse::<LitStr>()?.value();
-        if !input.is_empty() {
-            input.parse::<Token![,]>()?;
-        }
-
-        fn parse_key(input: ParseStream) -> syn::Result<String> {
-            let key = input.parse::<Ident>()?;
-            Ok(format!("{key}"))
-        }
-        let variables = Vec::from_iter(input.parse_terminated(parse_key, Token![,])?);
-        Ok(Self {
-            message_id,
-            message_definition,
-            variables,
-        })
-    }
-}
-
-fn check(localize_definition: &LocalizeDefinition) -> String {
-    let message = format!(
-        "{} = {}",
-        localize_definition.message_id, localize_definition.message_definition
-    );
-    let resource = parse_str_as_syntax_resource(&message)
-        .unwrap_or_else(|err| panic!("Failed to parse Fluent message\n{message}\n\n{err}"));
-    let resource_entries = &resource.body;
-    assert_eq!(
-        resource_entries.len(),
-        1,
-        "Expected exactly one Fluent entry specified via macro."
-    );
-    assert!(
-        matches!(resource_entries[0], fluent_syntax::ast::Entry::Message(_)),
-        "Expected definition of Fluent message, but got {:?}",
-        resource_entries[0]
-    );
-    let formatted_resource = format_resource(resource.clone())
-        .unwrap_or_else(|err| panic!("Resource is not formatted correctly:\n{err}"));
-    let formatted_resource_string = serialize_resource(&formatted_resource);
-    let formatted_resource_string_trimmed = formatted_resource_string.trim();
-    assert!(
-        message == formatted_resource_string_trimmed,
-        "Message is not formatted correctly.\nActual:\n{message}\nExpected:\n{formatted_resource_string_trimmed}"
-    );
-    let mut expected_variables = HashSet::new();
-    for variable in &localize_definition.variables {
-        assert!(
-            expected_variables.insert(variable.as_str()),
-            "Variable {variable} is used as a key more than once."
-        );
-    }
-    resource.check_if_expected_variables_match_message(&expected_variables, &localize_definition.message_id).unwrap_or_else(|err| {
-        panic!("Variables used in macro key-value pairs do not match variables used in Fluent message:\n{err}");
-    });
-    message
-}
-
-fn extract(message: &str, dir_path: &OsStr) {
-    let dir = PathBuf::from(dir_path);
-    let (path, result) = fish_tempfile::create_file_with_retry(|| {
-        dir.join(fish_tempfile::random_filename(OsString::new()))
-    });
-    let mut file = result.unwrap_or_else(|e| {
-        panic!("Failed to create temporary file {path:?}:\n{e}");
-    });
-    file.write_all(message.as_bytes()).unwrap();
-    file.write_all(b"\n").unwrap();
-}
-
-#[proc_macro]
-pub fn fluent_extract(input: TokenStream) -> TokenStream {
-    if let Some(dir_path) = std::env::var_os("FISH_FLUENT_EXTRACTION_DIR") {
-        let localize_definition = parse_macro_input!(input as LocalizeDefinition);
-        let message = check(&localize_definition);
-        extract(&message, &dir_path);
-    }
-    TokenStream::new()
-}

crates/fluent/Cargo.toml

@@ -1,30 +0,0 @@
-[package]
-name = "fish-fluent"
-edition.workspace = true
-rust-version.workspace = true
-version = "0.0.0"
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-cfg-if.workspace = true
-fish-build-helper.workspace = true
-fish-localization.workspace = true
-fish-fluent-extraction = { workspace = true, optional = true }
-fluent.workspace = true
-rust-embed.workspace = true
-unic-langid.workspace = true
-widestring.workspace = true
-
-[build-dependencies]
-fish-build-helper.workspace = true
-
-[dev-dependencies]
-fluent-ftl-tools.workspace = true
-
-[features]
-fluent-extract = ["dep:fish-fluent-extraction"]
-localize-messages = []
-
-[lints]
-workspace = true

crates/fluent/build.rs

@@ -1,4 +0,0 @@
-fn main() {
-    use fish_build_helper::{ftl_dir, rebuild_if_embedded_path_changed};
-    rebuild_if_embedded_path_changed(ftl_dir());
-}

crates/fluent/src/lib.rs

@@ -1,360 +0,0 @@
-use std::{
-    borrow::Cow,
-    collections::{HashMap, HashSet},
-    fmt::Write as _,
-    sync::{LazyLock, Mutex},
-};
-
-use cfg_if::cfg_if;
-use fish_localization::{
-    DEFAULT_LANGUAGE, Language, LocalizationLanguage, define_localization_language_type,
-};
-use fluent::{
-    FluentArgs, FluentResource, FluentValue, concurrent::FluentBundle, types::FluentNumber,
-};
-use rust_embed::RustEmbed;
-
-#[cfg(feature = "fluent-extract")]
-pub extern crate fish_fluent_extraction;
-
-use unic_langid::LanguageIdentifier;
-
-type Bundle = &'static FluentBundle<FluentResource>;
-
-type NamedBundle = (Language<'static>, Bundle);
-pub type LocalizedMessage = Cow<'static, str>;
-
-static LANGUAGE_BUNDLES: LazyLock<Mutex<HashMap<Language, Bundle>>> =
-    LazyLock::new(|| Mutex::new(HashMap::new()));
-
-static DEFAULT_BUNDLE: LazyLock<NamedBundle> =
-    LazyLock::new(|| (DEFAULT_LANGUAGE, make_bundle(DEFAULT_LANGUAGE)));
-
-static LANGUAGE_BUNDLE_PRECEDENCE: LazyLock<Mutex<Vec<NamedBundle>>> =
-    LazyLock::new(|| Mutex::new(vec![*DEFAULT_BUNDLE]));
-
-cfg_if!(
-    if #[cfg(feature = "localize-messages")] {
-        #[derive(RustEmbed)]
-        #[folder = "../../localization/fluent/"]
-        #[include = "*.ftl"]
-        struct FtlFiles;
-    } else {
-        #[derive(RustEmbed)]
-        #[folder = "../../localization/fluent/"]
-        #[include = "en.ftl"]
-        struct FtlFiles;
-    }
-);
-
-define_localization_language_type! {FluentLocalizationLanguage}
-
-static AVAILABLE_LANGUAGES: LazyLock<HashSet<FluentLocalizationLanguage>> = LazyLock::new(|| {
-    HashSet::from_iter(FtlFiles::iter().map(|language| {
-        let suffix = ".ftl";
-        let language = Language(match language {
-            Cow::Borrowed(language) => language.strip_suffix(suffix).unwrap(),
-            Cow::Owned(mut language) => {
-                assert!(language.ends_with(suffix));
-                language.truncate(language.len() - suffix.len());
-                Box::leak(Box::new(language))
-            }
-        });
-        FluentLocalizationLanguage(language)
-    }))
-});
-
-pub fn get_available_languages() -> &'static HashSet<FluentLocalizationLanguage> {
-    &AVAILABLE_LANGUAGES
-}
-
-fn read_ftl_file(path: &str) -> String {
-    let file = FtlFiles::get(path)
-        .unwrap_or_else(|| panic!("Tried to get FTL file {path} which does not exist."));
-    String::from_utf8(Vec::from(file.data))
-        .unwrap_or_else(|e| panic!("Content of {path} is not valid UTF-8: {e}"))
-}
-
-fn make_bundle(language: Language<'static>) -> Bundle {
-    let langid: LanguageIdentifier = language
-        .parse()
-        .map_err(|e| format!("Failed to parse language identifier {language}: {e}"))
-        .unwrap();
-    let mut bundle = FluentBundle::new_concurrent(vec![langid]);
-    let file_data = read_ftl_file(&format!("{language}.ftl"));
-    // Error handling could use fluent_ftl_tools::display_parse_errors(), but that would require
-    // making the crate a regular dependency.
-    match FluentResource::try_new(file_data) {
-        Ok(res) => {
-            bundle
-                .add_resource(res)
-                .map_err(|e| {
-                    format!(
-                        "Failed to add FTL resources to the bundle for language {language}: {e:?}"
-                    )
-                })
-                .unwrap();
-            // Isolation marks can result in undesirable behavior if the terminal does not support
-            // them properly.
-            // Turn this off for now.
-            // If we add detection for terminal support, we could enable it conditionally.
-            // Without these marks, text order can be incorrect when right-to-left characters are
-            // involved.
-            // https://www.w3.org/International/questions/qa-bidi-unicode-controls
-            // https://github.com/fish-shell/fish-shell/pull/11928#discussion_r2488850606
-            bundle.set_use_isolating(false);
-            // Leak to create static reference.
-            Box::leak(Box::new(bundle))
-        }
-        Err((_resource, errors)) => {
-            let mut error_string = format!("Errors parsing FTL file for {language}:\n");
-            for error in errors {
-                let _ = writeln!(error_string, "{error}");
-            }
-            panic!("{error_string}");
-        }
-    }
-}
-
-/// Set the order in which languages should be tried for localization.
-/// The default language (en) will be added to the end of the list.
-/// If the provided list contains `en`, anything after it will be ignored, since we assume that every
-/// message can be localized in English, so there is no point in specifying further fallback
-/// options.
-/// This function also takes care of lazily loading and parsing data from the embedded FTL files,
-/// so no additional initialization is needed.
-pub fn set_language_precedence(precedence: &[FluentLocalizationLanguage]) {
-    let new_precedence = {
-        let mut bundles = LANGUAGE_BUNDLES.lock().unwrap();
-        // Only take the languages preceding the default language, since it is assumed that everything
-        // is translatable in the default language.
-        let mut new_precedence: Vec<_> = precedence
-            .iter()
-            .take_while(|&lang| Language::from(lang) != DEFAULT_LANGUAGE)
-            .map(|lang| {
-                let language = lang.into();
-                // If a bundle already exists for the language, use it.
-                // Otherwise create a new one and cache it.
-                let bundle = bundles.get(&language).copied().unwrap_or_else(|| {
-                    let bundle = make_bundle(language);
-                    bundles.insert(language, bundle);
-                    bundle
-                });
-                (language, bundle)
-            })
-            .collect();
-        // Add the default language at the end of the precedence list.
-        new_precedence.push(*DEFAULT_BUNDLE);
-        new_precedence
-    };
-    *LANGUAGE_BUNDLE_PRECEDENCE.lock().unwrap() = new_precedence;
-}
-
-pub fn get_language_precedence() -> Vec<Language<'static>> {
-    let language_precedence = LANGUAGE_BUNDLE_PRECEDENCE.lock().unwrap();
-    language_precedence.iter().map(|&(lang, _)| lang).collect()
-}
-
-/// Use the [`localize!`] macro instead of calling this directly.
-/// Panics on errors.
-pub fn format_localized(id: &str, args: &FluentArgs) -> LocalizedMessage {
-    let mut errors = vec![];
-    let bundle_precedence = LANGUAGE_BUNDLE_PRECEDENCE.lock().unwrap();
-    for (_, bundle) in bundle_precedence.iter() {
-        let Some(message) = bundle.get_message(id) else {
-            continue;
-        };
-        let pattern = message.value().expect("Message has no value.");
-        let value = bundle.format_pattern(pattern, Some(args), &mut errors);
-        // NOTE: Unused arguments are not considered errors.
-        if !errors.is_empty() {
-            let mut error_message = format!(
-                "Unexpected formatting errors occurred for message ID '{id}' in language '{}':\n",
-                bundle.locales[0].language
-            );
-            for error in errors {
-                let _ = writeln!(error_message, "{error}");
-            }
-            panic!("{error_message}");
-        }
-        return value;
-    }
-    panic!("Message '{id}' not available in any catalog.")
-}
-
-/// Call this to localize a message with Fluent.
-/// The first argument is a string literal, which defines a Fluent message ID.
-/// It is followed by a mandatory `=` and the English version of the message as a string literal.
-/// The message definition must be valid Fluent syntax. Specifically it must be permissible as the
-/// definition of a Fluent message.
-/// In the simplest case, it will just be a regular string.
-/// If Fluent variables should be used, they need to appear in the message definition, e.g.
-/// `{ $example_variable }`. Then, the variable must also be specified as a key-value pair in the
-/// arguments of the [`localize!`] macro, as demonstrated in the example below.
-/// The key is the Fluent variable name, which also needs to be a syntactically valid Rust
-/// identifier, and the value is whatever the variable should be replaced by when formatting the
-/// localized message.
-/// It is considered an error if the variables specified in the message definition do not match the
-/// variables specified via keys in subsequent arguments to the macro.
-/// The order of key-value pairs can be chosen and modified arbitrarily, and variables may appear
-/// more than once in the message definition.
-///
-/// ```
-/// # use fish_fluent::localize;
-/// # // Note that `localize!` usage in doc-texts is not checked.
-/// let example_message = localize!("test-with-args" = "Two arguments: { $first }, { $second }", first = "foo", second = 42);
-/// assert_eq!(example_message, "Two arguments: foo, 42");
-/// ```
-///
-/// Note that changing the message ID or the message definition has consequences for translations.
-/// If such a change is made, our tooling will automatically detect it and require the developer
-/// making the change to specify what should happen to translations.
-/// See `cargo xtask fluent resolve-outdated`.
-#[macro_export]
-macro_rules! localize {
-    ($id:literal = $message:literal $(, $key:ident = $value:expr)* $(,)?) => {
-        {
-            use $crate::ToFluentValue as _;
-            #[cfg(feature = "fluent-extract")]
-            fish_fluent_extraction::fluent_extract!($id = $message $(, $key)*);
-            let mut args = fluent::FluentArgs::new();
-            $(
-                args.set(stringify!($key), $value.to_fluent_value());
-            )*
-            $crate::format_localized($id, &args)
-        }
-    };
-}
-
-/// Define a function calling [`localize!`] and returning the result.
-/// This macro can be used when multiple locations need access to the same message.
-/// Do not use [`localize!`] with the same message ID more than once.
-/// Instead, define a function which takes the Fluent variables of the message as arguments and
-/// internally calls [`localize!`]. Then, use this function wherever the message is needed.
-/// This macro helps with avoiding some boilerplate. Its first argument is the name of the function
-/// which should be defined. Then, a key-value pair specifying the message ID and English definition
-/// follows, in the same format as for [`localize!`]. The remaining arguments are the names of
-/// Fluent variables which appear in the message definition. These will become the function's
-/// arguments names and they will be used in the internal [`localize!`] call.
-#[macro_export]
-macro_rules! localize_fn {
-    ($vis:vis $fn:ident, $id:literal = $message:literal $(, $key:ident )* $(,)?) => {
-        $vis fn $fn<'a>($($key: impl $crate::ToFluentValue<'a>),*) -> $crate::LocalizedMessage {
-            localize!(
-                $id = $message,
-                $($key = $key),*
-            )
-        }
-    };
-}
-
-/// Trait to account for types which don't have a `Into<FluentValue>` implementation, i.e.
-/// widestrings.
-/// Can be removed once we no longer use such types.
-pub trait ToFluentValue<'a> {
-    fn to_fluent_value(self) -> FluentValue<'a>;
-}
-
-macro_rules! impl_to_fluent_value_wrapper {
-    ($($t:ty),* $(,)?) => {
-        $(
-            impl<'a> ToFluentValue<'a> for $t {
-                fn to_fluent_value(self) -> FluentValue<'a> {
-                    self.into()
-                }
-            }
-        )*
-    };
-}
-impl_to_fluent_value_wrapper! {
-    FluentNumber,
-    String,
-    f32, f64,
-    i8, i16, i32, i64, i128, isize,
-    u8, u16, u32, u64, u128, usize,
-}
-
-macro_rules! impl_to_fluent_value_wrapper_ref {
-    ($($t:ty),* $(,)?) => {
-        $(
-            impl<'a> ToFluentValue<'a> for &'a $t {
-                fn to_fluent_value(self) -> FluentValue<'a> {
-                    self.into()
-                }
-            }
-        )*
-    };
-}
-impl_to_fluent_value_wrapper_ref! {
-    String, str,
-    f32, f64,
-    i8, i16, i32, i64, i128, isize,
-    u8, u16, u32, u64, u128, usize,
-}
-
-impl<'a, T: Into<FluentValue<'a>>> ToFluentValue<'a> for Option<T> {
-    fn to_fluent_value(self) -> FluentValue<'a> {
-        self.into()
-    }
-}
-
-impl<'a> ToFluentValue<'a> for char {
-    fn to_fluent_value(self) -> FluentValue<'a> {
-        self.to_string().into()
-    }
-}
-
-impl<'a> ToFluentValue<'a> for &char {
-    fn to_fluent_value(self) -> FluentValue<'a> {
-        self.to_string().into()
-    }
-}
-
-impl<'a> ToFluentValue<'a> for widestring::Utf32String {
-    fn to_fluent_value(self) -> FluentValue<'a> {
-        self.to_string().into()
-    }
-}
-
-impl<'a> ToFluentValue<'a> for &widestring::Utf32String {
-    fn to_fluent_value(self) -> FluentValue<'a> {
-        self.to_string().into()
-    }
-}
-
-impl<'a> ToFluentValue<'a> for &widestring::Utf32Str {
-    fn to_fluent_value(self) -> FluentValue<'a> {
-        self.to_string().into()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{DEFAULT_LANGUAGE, FtlFiles};
-    use crate::read_ftl_file;
-    use fluent_ftl_tools::consistency::check_all_resources;
-
-    #[test]
-    fn test_simple_message() {
-        let message_key_value = localize!(
-            "test-with-args" = "Two arguments: { $first }, { $second }",
-            first = "foo",
-            second = 42,
-        );
-        assert_eq!(message_key_value, "Two arguments: foo, 42");
-    }
-
-    #[test]
-    fn check_ftl_files() {
-        let default_resource_name = format!("{DEFAULT_LANGUAGE}.ftl");
-        let default_string = read_ftl_file(&default_resource_name);
-        let other_resources = FtlFiles::iter()
-            .map(|file_path| {
-                let file_string = read_ftl_file(&file_path);
-                (file_path.to_string(), file_string)
-            })
-            .collect::<Vec<_>>();
-        check_all_resources((&default_resource_name, default_string), other_resources)
-            .unwrap_or_else(|e| panic!("FTL resource checks failed:\n{e}"));
-    }
-}

crates/gettext-extraction/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "fish-gettext-extraction"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-description = "proc-macro for extracting strings for gettext translation"
-repository.workspace = true
-license.workspace = true
-
-[lib]
-proc-macro = true
-
-[dependencies]
-fish-tempfile.workspace = true
-proc-macro2.workspace = true
-
-[build-dependencies]
-rsconf.workspace = true
-
-[lints]
-workspace = true

crates/gettext-extraction/build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    rsconf::rebuild_if_env_changed("FISH_GETTEXT_EXTRACTION_DIR");
-}

crates/gettext-extraction/src/lib.rs

@@ -1,122 +0,0 @@
-extern crate proc_macro;
-use fish_tempfile::random_filename;
-use proc_macro::TokenStream;
-use std::{ffi::OsString, io::Write as _, path::PathBuf};
-
-fn unescape_multiline_rust_string(s: String) -> String {
-    if !s.contains('\n') {
-        return s;
-    }
-    let mut unescaped = String::new();
-    enum State {
-        Ground,
-        Escaped,
-        ContinuationLineLeadingWhitespace,
-    }
-    use State::*;
-    let mut state = Ground;
-    for c in s.chars() {
-        match state {
-            Ground => match c {
-                '\\' => state = Escaped,
-                _ => {
-                    unescaped.push(c);
-                }
-            },
-            Escaped => match c {
-                '\\' => {
-                    unescaped.push('\\');
-                    state = Ground;
-                }
-                '\n' => state = ContinuationLineLeadingWhitespace,
-                _ => panic!("Unsupported escape sequence '\\{c}' in message string '{s}'"),
-            },
-            ContinuationLineLeadingWhitespace => match c {
-                ' ' | '\t' => (),
-                _ => {
-                    unescaped.push(c);
-                    state = Ground;
-                }
-            },
-        }
-    }
-    unescaped
-}
-
-// Each entry is written to a fresh file to avoid race conditions arising when there are multiple
-// unsynchronized writers to the same file.
-fn write_po_entry_to_file(message: &TokenStream, dir: &OsString) {
-    let message_string = unescape_multiline_rust_string(message.to_string());
-    assert!(
-        !message_string.contains('\n'),
-        "Gettext strings may not contain unescaped newlines. Unescaped newline found in '{message_string}'"
-    );
-    let msgid_without_quotes = &message_string[1..(message_string.len() - 1)];
-    // We don't want leading or trailing whitespace in our messages.
-    let trimmed_msgid = msgid_without_quotes.trim();
-    assert_eq!(msgid_without_quotes, trimmed_msgid);
-    assert!(!trimmed_msgid.starts_with("\\n"));
-    assert!(!trimmed_msgid.ends_with("\\n"));
-    assert!(!trimmed_msgid.starts_with("\\t"));
-    assert!(!trimmed_msgid.ends_with("\\t"));
-    // Crude check for format strings. This might result in false positives.
-    let format_string_annotation = if message_string.contains('%') {
-        "#, c-format\n"
-    } else {
-        ""
-    };
-    let po_entry = format!("{format_string_annotation}msgid {message_string}\nmsgstr \"\"\n\n");
-
-    let dir = PathBuf::from(dir);
-    let (path, result) =
-        fish_tempfile::create_file_with_retry(|| dir.join(random_filename(OsString::new())));
-    let mut file = result.unwrap_or_else(|e| {
-        panic!("Failed to create temporary file {path:?}:\n{e}");
-    });
-    file.write_all(po_entry.as_bytes()).unwrap();
-}
-
-/// The `message` is passed through unmodified.
-/// If `FISH_GETTEXT_EXTRACTION_DIR` is defined in the environment,
-/// the message ID is written into a new file in this directory,
-/// so that it can then be used for generating gettext PO files.
-/// The `message` must be a string literal.
-///
-/// # Panics
-///
-/// This macro panics if the `FISH_GETTEXT_EXTRACTION_DIR` variable is set and `message` has an
-/// unexpected format.
-/// Note that for example `concat!(...)` cannot be passed to this macro, because expansion works
-/// outside in, meaning this macro would still see the `concat!` macro invocation, instead of a
-/// string literal.
-#[proc_macro]
-pub fn gettext_extract(message: TokenStream) -> TokenStream {
-    if let Some(dir_path) = std::env::var_os("FISH_GETTEXT_EXTRACTION_DIR") {
-        let pm2_message = proc_macro2::TokenStream::from(message.clone());
-        let mut token_trees = pm2_message.into_iter();
-        let first_token = token_trees
-            .next()
-            .expect("gettext_extract got empty token stream. Expected one token.");
-        assert!(
-            token_trees.next().is_none(),
-            "Invalid number of tokens passed to gettext_extract. Expected one token, but got more."
-        );
-        let proc_macro2::TokenTree::Group(group) = first_token else {
-            panic!("Expected group in gettext_extract, but got: {first_token:?}");
-        };
-        let mut group_tokens = group.stream().into_iter();
-        let first_group_token = group_tokens
-            .next()
-            .expect("gettext_extract expected one group token but got none.");
-        assert!(
-            group_tokens.next().is_none(),
-            "Invalid number of tokens in group passed to gettext_extract. Expected one token, but got more."
-        );
-        if let proc_macro2::TokenTree::Literal(_) = first_group_token {
-            write_po_entry_to_file(&message, &dir_path);
-        } else {
-            panic!("Expected literal in gettext_extract, but got: {first_group_token:?}");
-        }
-    }
-    message
-}

crates/gettext-maps/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "fish-gettext-maps"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-phf.workspace = true
-fish-localization.workspace = true
-
-[build-dependencies]
-fish-build-helper.workspace = true
-fish-gettext-mo-file-parser.workspace = true
-fish-localization.workspace = true
-phf_codegen.workspace = true
-rsconf.workspace = true
-
-[lints]
-workspace = true

crates/gettext-maps/build.rs

@@ -1,163 +0,0 @@
-use std::{
-    ffi::OsStr,
-    path::{Path, PathBuf},
-    process::Command,
-};
-
-use fish_build_helper::env_var;
-use fish_localization::Language;
-
-fn main() {
-    let cache_dir =
-        PathBuf::from(fish_build_helper::fish_build_dir()).join("fish-localization-map-cache");
-    embed_localizations(&cache_dir);
-
-    fish_build_helper::rebuild_if_path_changed(fish_build_helper::po_dir());
-}
-
-fn embed_localizations(cache_dir: &Path) {
-    use fish_gettext_mo_file_parser::parse_mo_file;
-    use std::{
-        fs::File,
-        io::{BufWriter, Write as _},
-    };
-
-    // Ensure that the directory is created, because clippy cannot compile the code if the
-    // directory does not exist.
-    std::fs::create_dir_all(cache_dir).unwrap();
-
-    let localization_map_path =
-        Path::new(&env_var("OUT_DIR").unwrap()).join("localization_maps.rs");
-    let mut localization_map_file = BufWriter::new(File::create(&localization_map_path).unwrap());
-
-    // This will become a map which maps from language identifiers to maps containing localizations
-    // for the respective language.
-    let mut catalogs = phf_codegen::Map::new();
-
-    match Command::new("msgfmt").arg("-h").output() {
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
-            rsconf::warn!(
-                "Could not find msgfmt required to build message catalogs. \
-                 Localization will not work. \
-                 If you install gettext now, you need to trigger a rebuild to include localization support. \
-                 For example by running `touch localization/po` followed by the build command."
-            );
-        }
-        Err(e) => {
-            panic!("Error when trying to run `msgfmt -h`: {e:?}");
-        }
-        Ok(output) => {
-            let has_check_format =
-                String::from_utf8_lossy(&output.stdout).contains("--check-format");
-            for dir_entry_result in fish_build_helper::po_dir().read_dir().unwrap() {
-                let dir_entry = dir_entry_result.unwrap();
-                let po_file_path = dir_entry.path();
-                if po_file_path.extension() != Some(OsStr::new("po")) {
-                    continue;
-                }
-                let language = po_file_path
-                    .file_stem()
-                    .expect("All entries in the po directory must be regular files.");
-                let language = language.to_str().unwrap();
-
-                // Each language gets its own static map for the mapping from message in the source code to
-                // the localized version.
-                let map_name = format!("LANG_MAP_{language}");
-
-                let cached_map_path = cache_dir.join(language);
-
-                // Include the file containing the map for this language in the main generated file.
-                writeln!(
-                    &mut localization_map_file,
-                    "include!(\"{}\");",
-                    cached_map_path.display()
-                )
-                .unwrap();
-                // Map from the language identifier to the map containing the localizations for this
-                // language.
-                catalogs.entry(
-                    Language(Box::leak(Box::new(language.to_owned()))),
-                    format!("&{map_name}"),
-                );
-
-                if let Ok(metadata) = std::fs::metadata(&cached_map_path) {
-                    // Cached map file exists, but might be outdated.
-                    let cached_map_mtime = metadata.modified().unwrap();
-                    let po_mtime = dir_entry.metadata().unwrap().modified().unwrap();
-                    if cached_map_mtime > po_mtime {
-                        // Cached map file is considered up-to-date.
-                        continue;
-                    }
-                }
-
-                // Generate the map file.
-
-                // Try to create new MO data and load it into `mo_data`.
-                let mut tmp_mo_file = None;
-                let output = {
-                    let mut cmd = &mut Command::new("msgfmt");
-                    if has_check_format {
-                        cmd = cmd.arg("--check-format");
-                    } else {
-                        tmp_mo_file = Some(cache_dir.join("messages.mo"));
-                    }
-                    cmd.arg(format!(
-                        "--output-file={}",
-                        tmp_mo_file
-                            .as_ref()
-                            .map_or("-", |path| path.to_str().unwrap())
-                    ))
-                    .arg(&po_file_path)
-                    .output()
-                    .unwrap()
-                };
-                assert!(
-                    output.status.success(),
-                    "msgfmt failed:\n{}",
-                    String::from_utf8(output.stderr).unwrap()
-                );
-                let mo_data =
-                    tmp_mo_file.map_or(output.stdout, |path| std::fs::read(path).unwrap());
-
-                // Extract map from MO data.
-                let language_localizations = parse_mo_file(&mo_data).unwrap();
-
-                // This file will contain the localization map for the current language.
-                let mut cached_map_file = File::create(&cached_map_path).unwrap();
-                let mut single_language_localization_map = phf_codegen::Map::new();
-
-                // The values will be written into the source code as is, meaning escape sequences and
-                // double quotes in the data will be interpreted by the Rust compiler, which is undesirable.
-                // Converting them to raw strings prevents this. (As long as no input data contains `"###`.)
-                fn to_raw_str(s: &str) -> String {
-                    assert!(!s.contains("\"###"));
-                    format!("r###\"{s}\"###")
-                }
-                for (msgid, msgstr) in language_localizations {
-                    single_language_localization_map.entry(
-                        String::from_utf8(msgid.into()).unwrap(),
-                        to_raw_str(&String::from_utf8(msgstr.into()).unwrap()),
-                    );
-                }
-                writeln!(&mut cached_map_file, "#[allow(non_upper_case_globals)]").unwrap();
-                write!(
-                    &mut cached_map_file,
-                    "static {}: phf::Map<&'static str, &'static str> = {}",
-                    map_name,
-                    single_language_localization_map.build()
-                )
-                .unwrap();
-                writeln!(&mut cached_map_file, ";").unwrap();
-            }
-        }
-    }
-
-    write!(
-        &mut localization_map_file,
-        "use fish_localization::Language;\n\
-         pub static CATALOGS: phf::Map<Language, &phf::Map<&str, &str>> = {}",
-        catalogs.build()
-    )
-    .unwrap();
-    writeln!(&mut localization_map_file, ";").unwrap();
-}

crates/gettext-maps/src/lib.rs

@@ -1 +0,0 @@
-include!(concat!(env!("OUT_DIR"), "/localization_maps.rs"));

crates/gettext-mo-file-parser/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "fish-gettext-mo-file-parser"
-version = "0.0.0"
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[lints]
-workspace = true

crates/gettext-mo-file-parser/src/lib.rs

@@ -1,134 +0,0 @@
-use std::collections::HashMap;
-
-const U32_SIZE: usize = size_of::<u32>();
-
-fn read_le_u32(bytes: &[u8]) -> u32 {
-    u32::from_le_bytes(bytes[..U32_SIZE].try_into().unwrap())
-}
-
-fn read_be_u32(bytes: &[u8]) -> u32 {
-    u32::from_be_bytes(bytes[..U32_SIZE].try_into().unwrap())
-}
-
-fn get_u32_reader_from_magic_number(magic_number: &[u8]) -> std::io::Result<fn(&[u8]) -> u32> {
-    match magic_number {
-        [0x95, 0x04, 0x12, 0xde] => Ok(read_be_u32),
-        [0xde, 0x12, 0x04, 0x95] => Ok(read_le_u32),
-        _ => Err(std::io::Error::new(
-            std::io::ErrorKind::InvalidData,
-            "First 4 bytes of MO file must correspond to magic number 0x950412de, either big or little endian.",
-        )),
-    }
-}
-
-/// Returns an error if an unknown major revision is detected.
-/// There are no relevant differences between supported revisions.
-fn check_if_revision_is_supported(revision: u32) -> std::io::Result<()> {
-    // From the reference:
-    // A program seeing an unexpected major revision number should stop reading the MO file entirely;
-    // whereas an unexpected minor revision number means that the file can be read
-    // but will not reveal its full contents,
-    // when parsed by a program that supports only smaller minor revision numbers.
-    let major_revision = revision >> 16;
-    match major_revision {
-        0 | 1 => {
-            // At time of writing, these are the only major revisions which exist.
-            // There is no documented difference and the GNU gettext code does not seem to
-            // differentiate between the two either.
-            // All features we care about are supported in minor revision 0,
-            // so we do not need to care about the minor revision.
-            Ok(())
-        }
-        _ => Err(std::io::Error::new(
-            std::io::ErrorKind::InvalidData,
-            "Major revision must be 0 or 1",
-        )),
-    }
-}
-
-fn as_usize(value: u32) -> usize {
-    const {
-        assert!(size_of::<u32>() <= size_of::<usize>());
-    }
-
-    // SAFETY: `usize` is guaranteed to be at least as wide as `u32` by the const assert above.
-    unsafe { usize::try_from(value).unwrap_unchecked() }
-}
-
-fn parse_strings(
-    file_content: &[u8],
-    num_strings: usize,
-    table_offset: usize,
-    read_u32: fn(&[u8]) -> u32,
-) -> std::io::Result<Vec<&[u8]>> {
-    let file_too_short_error = || {
-        Err(std::io::Error::new(
-            std::io::ErrorKind::InvalidData,
-            "MO file is too short.",
-        ))
-    };
-    if table_offset + num_strings * 2 * U32_SIZE > file_content.len() {
-        return file_too_short_error();
-    }
-    let mut strings = Vec::with_capacity(num_strings);
-    let mut offset = table_offset;
-    let mut get_next_u32 = || {
-        let val = read_u32(&file_content[offset..]);
-        offset += U32_SIZE;
-        val
-    };
-    for _ in 0..num_strings {
-        // not including NUL terminator
-        let string_length = as_usize(get_next_u32());
-        let string_offset = as_usize(get_next_u32());
-        let string_end = string_offset.checked_add(string_length).unwrap();
-        if string_end > file_content.len() {
-            return file_too_short_error();
-        }
-        // Contexts are stored by storing the concatenation of the context, a EOT byte, and the original string, instead of the original string.
-        // Contexts are not supported by this implementation.
-        // The format allows plural forms to appear behind singular forms, separated by a NUL byte,
-        // where `string_length` includes the length of both.
-        // This is not supported here.
-        // Do not include the NUL terminator in the slice.
-        strings.push(&file_content[string_offset..string_end]);
-    }
-    Ok(strings)
-}
-
-/// Parse a MO file.
-/// Format reference used: <https://www.gnu.org/software/gettext/manual/html_node/MO-Files.html>
-pub fn parse_mo_file(file_content: &[u8]) -> std::io::Result<HashMap<&[u8], &[u8]>> {
-    if file_content.len() < 7 * U32_SIZE {
-        return Err(std::io::Error::new(
-            std::io::ErrorKind::InvalidData,
-            "File too short to contain header.",
-        ));
-    }
-    // The first 4 bytes are a magic number, from which the endianness can be determined.
-    let read_u32 = get_u32_reader_from_magic_number(&file_content[0..U32_SIZE])?;
-    let mut offset = U32_SIZE;
-    let mut get_next_u32 = || {
-        let val = read_u32(&file_content[offset..]);
-        offset += U32_SIZE;
-        val
-    };
-    let file_format_revision = get_next_u32();
-    check_if_revision_is_supported(file_format_revision)?;
-    let num_strings = as_usize(get_next_u32());
-    let original_strings_offset = as_usize(get_next_u32());
-    let translation_strings_offset = as_usize(get_next_u32());
-    let original_strings =
-        parse_strings(file_content, num_strings, original_strings_offset, read_u32)?;
-    let translated_strings = parse_strings(
-        file_content,
-        num_strings,
-        translation_strings_offset,
-        read_u32,
-    )?;
-    let mut translation_map = HashMap::with_capacity(num_strings);
-    for i in 0..num_strings {
-        translation_map.insert(original_strings[i], translated_strings[i]);
-    }
-    Ok(translation_map)
-}