diff --git a/.editorconfig b/.editorconfig
index eadd72e499373..ef8ed24c52a50 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -9,6 +9,8 @@ end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
+
+[!src/llvm-project]
indent_style = space
indent_size = 4
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 663ace48e9e80..af071c706856e 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -23,3 +23,13 @@ b2d2184edea578109a48ec3d8decbee5948e8f35
# test directives migration
6e48b96692d63a79a14563f27fe5185f122434f8
ec2cc761bc7067712ecc7734502f703fe3b024c8
+# format use declarations
+84ac80f1921afc243d71fd0caaa4f2838c294102
+# bless mir-opt tests to add `copy`
+99cb0c6bc399fb94a0ddde7e9b38e9c00d523bad
+# reformat with rustfmt edition 2024
+c682aa162b0d41e21cc6748f4fecfe01efb69d1f
+# reformat with updated edition 2024
+1fcae03369abb4c2cc180cd5a49e1f4440a81300
+# Breaking up of compiletest runtest.rs
+60600a6fa403216bfd66e04f948b1822f6450af7
diff --git a/.gitattributes b/.gitattributes
index d29c15fe712f3..8700d5d6dcff1 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -5,6 +5,7 @@
*.h rust
*.rs rust diff=rust
*.fixed linguist-language=Rust
+*.pp linguist-language=Rust
*.mir linguist-language=Rust
src/etc/installer/gfx/* binary
src/vendor/** -text
diff --git a/.github/ISSUE_TEMPLATE/blank_issue.md b/.github/ISSUE_TEMPLATE/blank_issue.md
deleted file mode 100644
index 9aef3ebe637a1..0000000000000
--- a/.github/ISSUE_TEMPLATE/blank_issue.md
+++ /dev/null
@@ -1,4 +0,0 @@
----
-name: Blank Issue
-about: Create a blank issue.
----
diff --git a/.github/ISSUE_TEMPLATE/bootstrap.md b/.github/ISSUE_TEMPLATE/bootstrap.md
new file mode 100644
index 0000000000000..344ea30e1fc0b
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bootstrap.md
@@ -0,0 +1,70 @@
+---
+name: Bootstrap (Rust Build System) Report
+about: Issues encountered on bootstrap build system
+labels: C-bug, T-bootstrap
+---
+
+<!--
+Thank you for submitting a bootstrap report! Please provide detailed information to help us reproduce and diagnose the issue.
+-->
+
+### Summary
+
+<!--
+Provide a brief description of the problem you are experiencing.
+-->
+
+### Command used
+
+```sh
+<command>
+```
+
+### Expected behaviour
+
+<!--
+Describe what you expected to happen.
+-->
+
+### Actual behaviour
+
+<!--
+Describe what actually happened.
+-->
+
+### Bootstrap configuration (bootstrap.toml)
+```toml
+<config>
+```
+
+### Operating system
+
+<!--
+e.g., Ubuntu 22.04, macOS 12, Windows 10
+-->
+
+### HEAD
+
+<!--
+Output of `git rev-parse HEAD` command, or content of the `git-commit-hash` file if using a tarball source.
+-->
+
+### Additional context
+<!--
+Include any other relevant information (e.g., if you have custom patches or modifications on the project).
+-->
+
+
+<!--
+Include the complete build log in the section below.
+Enable backtrace and verbose mode if possible for more detailed information e.g., with `RUST_BACKTRACE=1 ./x build -v`.
+-->
+<details><summary>Build Log</summary>
+<p>
+
+```txt
+<log>
+```
+
+</p>
+</details>
diff --git a/.github/ISSUE_TEMPLATE/library_tracking_issue.md b/.github/ISSUE_TEMPLATE/library_tracking_issue.md
index 934312662beb6..d56da9d5d025a 100644
--- a/.github/ISSUE_TEMPLATE/library_tracking_issue.md
+++ b/.github/ISSUE_TEMPLATE/library_tracking_issue.md
@@ -2,7 +2,7 @@
name: Library Tracking Issue
about: A tracking issue for an unstable library feature.
title: Tracking Issue for XXX
-labels: C-tracking-issue, T-libs-api
+labels: C-tracking-issue, T-libs-api, S-tracking-unimplemented
---
<!--
Thank you for creating a tracking issue!
@@ -49,6 +49,8 @@ For larger features, more steps might be involved.
If the feature is changed later, please add those PRs here as well.
-->
+(Remember to update the `S-tracking-*` label when checking boxes.)
+
- [ ] Implementation: #...
- [ ] Final comment period (FCP)[^1]
- [ ] Stabilization PR
diff --git a/.github/ISSUE_TEMPLATE/tracking_issue.md b/.github/ISSUE_TEMPLATE/tracking_issue.md
index 598628936112e..aedc15a54c274 100644
--- a/.github/ISSUE_TEMPLATE/tracking_issue.md
+++ b/.github/ISSUE_TEMPLATE/tracking_issue.md
@@ -41,12 +41,15 @@ for larger features an implementation could be broken up into multiple PRs.
- [ ] Implement the RFC (cc @rust-lang/XXX -- can anyone write up mentoring
instructions?)
- [ ] Adjust documentation ([see instructions on rustc-dev-guide][doc-guide])
-- [ ] Formatting for new syntax has been added to the [Style Guide] ([nightly-style-procedure])
+- [ ] Style updates for any new syntax ([nightly-style-procedure])
+ - [ ] Style team decision on new formatting
+ - [ ] Formatting for new syntax has been added to the [Style Guide]
+ - [ ] (non-blocking) Formatting has been implemented in `rustfmt`
- [ ] Stabilization PR ([see instructions on rustc-dev-guide][stabilization-guide])
[stabilization-guide]: https://rustc-dev-guide.rust-lang.org/stabilization_guide.html#stabilization-pr
[doc-guide]: https://rustc-dev-guide.rust-lang.org/stabilization_guide.html#documentation-prs
-[nightly-style-procedure]: https://github.com/rust-lang/style-team/blob/master/nightly-style-procedure.md
+[nightly-style-procedure]: https://github.com/rust-lang/style-team/blob/main/nightly-style-procedure.md
[Style Guide]: https://github.com/rust-lang/rust/tree/master/src/doc/style-guide
### Unresolved Questions
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index fd54a153a1609..93388ddd24075 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -7,6 +7,6 @@ tracking issue or there are none, feel free to ignore this.
This PR will get automatically assigned to a reviewer. In case you would like
a specific user to review your work, you can assign it to them by using
- r? <reviewer name>
+ r? <reviewer name>
-->
<!-- homu-ignore:end -->
diff --git a/.github/renovate.json5 b/.github/renovate.json5
new file mode 100644
index 0000000000000..87f5f103ddfca
--- /dev/null
+++ b/.github/renovate.json5
@@ -0,0 +1,14 @@
+{
+ "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+ // Let Renovatebot keep an opened issue that tracks our dependencies
+ "dependencyDashboard": true,
+ // Disable "normal" package updates
+ "enabledManagers": [],
+ // Update lockfiles once per week
+ "lockFileMaintenance": {
+ "enabled": true,
+ "schedule": [
+ "before 5am on Tuesday"
+ ]
+ }
+}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8032154a7365b..93316b9cff7b1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,8 +1,8 @@
# This file defines our primary CI workflow that runs on pull requests
# and also on pushes to special branches (auto, try).
#
-# The actual definition of the executed jobs is calculated by a Python
-# script located at src/ci/github-actions/calculate-job-matrix.py, which
+# The actual definition of the executed jobs is calculated by the
+# `src/ci/citool` crate, which
# uses job definition data from src/ci/github-actions/jobs.yml.
# You should primarily modify the `jobs.yml` file if you want to modify
# what jobs are executed in CI.
@@ -46,33 +46,44 @@ jobs:
# If you want to modify CI jobs, take a look at src/ci/github-actions/jobs.yml.
calculate_matrix:
name: Calculate job matrix
- runs-on: ubuntu-latest
+ runs-on: ubuntu-24.04
outputs:
jobs: ${{ steps.jobs.outputs.jobs }}
run_type: ${{ steps.jobs.outputs.run_type }}
steps:
- name: Checkout the source code
uses: actions/checkout@v4
+ # Cache citool to make its build faster, as it's in the critical path.
+ # The rust-cache doesn't bleed into the main `job`, so it should not affect any other
+ # Rust compilation.
+ - name: Cache citool
+ uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
+ with:
+ workspaces: src/ci/citool
- name: Calculate the CI job matrix
env:
COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
- run: python3 src/ci/github-actions/calculate-job-matrix.py >> $GITHUB_OUTPUT
+ run: |
+ cd src/ci/citool
+ CARGO_INCREMENTAL=0 cargo test
+ CARGO_INCREMENTAL=0 cargo run calculate-job-matrix >> $GITHUB_OUTPUT
id: jobs
job:
- name: ${{ matrix.name }}
+ name: ${{ matrix.full_name }}
needs: [ calculate_matrix ]
runs-on: "${{ matrix.os }}"
- defaults:
- run:
- shell: ${{ contains(matrix.os, 'windows') && 'msys2 {0}' || 'bash' }}
- timeout-minutes: 240
+ timeout-minutes: 360
env:
- CI_JOB_NAME: ${{ matrix.image }}
+ CI_JOB_NAME: ${{ matrix.name }}
+ CI_JOB_DOC_URL: ${{ matrix.doc_url }}
+ GITHUB_WORKFLOW_RUN_ID: ${{ github.run_id }}
+ GITHUB_REPOSITORY: ${{ github.repository }}
CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
# commit of PR sha or commit sha. `GITHUB_SHA` is not accurate for PRs.
HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
DOCKER_TOKEN: ${{ secrets.GITHUB_TOKEN }}
SCCACHE_BUCKET: rust-lang-ci-sccache2
+ SCCACHE_REGION: us-west-1
CACHE_DOMAIN: ci-caches.rust-lang.org
continue-on-error: ${{ matrix.continue_on_error || false }}
strategy:
@@ -80,21 +91,16 @@ jobs:
# Check the `calculate_matrix` job to see how is the matrix defined.
include: ${{ fromJSON(needs.calculate_matrix.outputs.jobs) }}
steps:
- - if: contains(matrix.os, 'windows')
- uses: msys2/setup-msys2@v2.22.0
- with:
- # i686 jobs use mingw32. x86_64 and cross-compile jobs use mingw64.
- msystem: ${{ contains(matrix.name, 'i686') && 'mingw32' || 'mingw64' }}
- # don't try to download updates for already installed packages
- update: false
- # don't try to use the msys that comes built-in to the github runner,
- # so we can control what is installed (i.e. not python)
- release: true
- # Inherit the full path from the Windows environment, with MSYS2's */bin/
- # dirs placed in front. This lets us run Windows-native Python etc.
- path-type: inherit
- install: >
- make
+ - name: Install cargo in AWS CodeBuild
+ if: matrix.codebuild
+ run: |
+ # Check if cargo is installed
+ if ! command -v cargo &> /dev/null; then
+ echo "Cargo not found, installing Rust..."
+ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile=minimal
+ # Make cargo available in PATH
+ echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+ fi
- name: disable git crlf conversion
run: git config --global core.autocrlf false
@@ -104,6 +110,14 @@ jobs:
with:
fetch-depth: 2
+ # Free up disk space on Linux by removing preinstalled components that
+ # we do not need. We do this to enable some of the less resource
+ # intensive jobs to run on free runners, which however also have
+ # less disk space.
+ - name: free up disk space
+ run: src/ci/scripts/free-disk-space.sh
+ if: matrix.free_disk
+
# Rust Log Analyzer can't currently detect the PR number of a GitHub
# Actions build on its own, so a hint in the log message is needed to
# point it in the right direction.
@@ -162,6 +176,8 @@ jobs:
run: src/ci/scripts/install-ninja.sh
- name: enable ipv6 on Docker
+ # Don't run on codebuild because systemctl is not available
+ if: ${{ !matrix.codebuild }}
run: src/ci/scripts/enable-docker-ipv6.sh
# Disable automatic line ending conversion (again). On Windows, when we're
@@ -181,9 +197,33 @@ jobs:
- name: ensure the stable version number is correct
run: src/ci/scripts/verify-stable-version-number.sh
+ # Show the environment just before we run the build
+ # This makes it easier to diagnose problems with the above install scripts.
+ - name: show the current environment
+ run: src/ci/scripts/dump-environment.sh
+
+ # Pre-build citool before the following step uninstalls rustup
+ # Build it into the build directory, to avoid modifying sources
+ - name: build citool
+ run: |
+ cd src/ci/citool
+ CARGO_INCREMENTAL=0 CARGO_TARGET_DIR=../../../build/citool cargo build
+
- name: run the build
- # Redirect stderr to stdout to avoid reordering the two streams in the GHA logs.
- run: src/ci/scripts/run-build-from-ci.sh 2>&1
+ run: |
+ set +e
+ # Redirect stderr to stdout to avoid reordering the two streams in the GHA logs.
+ src/ci/scripts/run-build-from-ci.sh 2>&1
+ STATUS=$?
+ set -e
+
+ if [[ "$STATUS" -ne 0 && -n "$CI_JOB_DOC_URL" ]]; then
+ echo "****************************************************************************"
+ echo "To find more information about this job, visit the following URL:"
+ echo "$CI_JOB_DOC_URL"
+ echo "****************************************************************************"
+ fi
+ exit ${STATUS}
env:
AWS_ACCESS_KEY_ID: ${{ env.CACHES_AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets[format('AWS_SECRET_ACCESS_KEY_{0}', env.CACHES_AWS_ACCESS_KEY_ID)] }}
@@ -191,6 +231,11 @@ jobs:
- name: create github artifacts
run: src/ci/scripts/create-doc-artifacts.sh
+ - name: print disk usage
+ run: |
+ echo "disk usage:"
+ df -h
+
- name: upload artifacts to github
uses: actions/upload-artifact@v4
with:
@@ -212,11 +257,43 @@ jobs:
# erroring about invalid credentials instead.
if: github.event_name == 'push' || env.DEPLOY == '1' || env.DEPLOY_ALT == '1'
+ - name: postprocess metrics into the summary
+ # This step is not critical, and if some I/O problem happens, we don't want
+ # to cancel the build.
+ continue-on-error: true
+ run: |
+ if [ -f build/metrics.json ]; then
+ METRICS=build/metrics.json
+ elif [ -f obj/build/metrics.json ]; then
+ METRICS=obj/build/metrics.json
+ else
+ echo "No metrics.json found"
+ exit 0
+ fi
+
+ # Get closest bors merge commit
+ PARENT_COMMIT=`git rev-list --author='bors <bors@rust-lang.org>' -n1 --first-parent HEAD^1`
+
+ ./build/citool/debug/citool postprocess-metrics \
+ --job-name ${CI_JOB_NAME} \
+ --parent ${PARENT_COMMIT} \
+ ${METRICS} >> ${GITHUB_STEP_SUMMARY}
+
+ - name: upload job metrics to DataDog
+ # This step is not critical, and if some I/O problem happens, we don't want
+ # to cancel the build.
+ continue-on-error: true
+ if: needs.calculate_matrix.outputs.run_type != 'pr'
+ env:
+ DATADOG_API_KEY: ${{ secrets.DATADOG_API_KEY }}
+ DD_GITHUB_JOB_NAME: ${{ matrix.full_name }}
+ run: ./build/citool/debug/citool upload-build-metrics build/cpu-usage.csv
+
# This job isused to tell bors the final status of the build, as there is no practical way to detect
# when a workflow is successful listening to webhooks only in our current bors implementation (homu).
outcome:
name: bors build finished
- runs-on: ubuntu-latest
+ runs-on: ubuntu-24.04
needs: [ calculate_matrix, job ]
# !cancelled() executes the job regardless of whether the previous jobs passed or failed
if: ${{ !cancelled() && contains(fromJSON('["auto", "try"]'), needs.calculate_matrix.outputs.run_type) }}
diff --git a/.github/workflows/dependencies.yml b/.github/workflows/dependencies.yml
index 03584aed08d94..98d8c14f7d185 100644
--- a/.github/workflows/dependencies.yml
+++ b/.github/workflows/dependencies.yml
@@ -27,7 +27,7 @@ jobs:
not-waiting-on-bors:
if: github.repository_owner == 'rust-lang'
name: skip if S-waiting-on-bors
- runs-on: ubuntu-latest
+ runs-on: ubuntu-24.04
steps:
- env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -47,7 +47,7 @@ jobs:
if: github.repository_owner == 'rust-lang'
name: update dependencies
needs: not-waiting-on-bors
- runs-on: ubuntu-latest
+ runs-on: ubuntu-24.04
steps:
- name: checkout the source code
uses: actions/checkout@v4
@@ -61,14 +61,27 @@ jobs:
rustup toolchain install --no-self-update --profile minimal $TOOLCHAIN
rustup default $TOOLCHAIN
- - name: cargo update
+ - name: cargo update compiler & tools
# Remove first line that always just says "Updating crates.io index"
- run: cargo update 2>&1 | sed '/crates.io index/d' | tee -a cargo_update.log
+ run: |
+ echo -e "\ncompiler & tools dependencies:" >> cargo_update.log
+ cargo update 2>&1 | sed '/crates.io index/d' | tee -a cargo_update.log
+ - name: cargo update library
+ run: |
+ echo -e "\nlibrary dependencies:" >> cargo_update.log
+ cargo update --manifest-path library/Cargo.toml 2>&1 | sed '/crates.io index/d' | tee -a cargo_update.log
+ - name: cargo update rustbook
+ run: |
+ echo -e "\nrustbook dependencies:" >> cargo_update.log
+ cargo update --manifest-path src/tools/rustbook/Cargo.toml 2>&1 | sed '/crates.io index/d' | tee -a cargo_update.log
- name: upload Cargo.lock artifact for use in PR
uses: actions/upload-artifact@v4
with:
name: Cargo-lock
- path: Cargo.lock
+ path: |
+ Cargo.lock
+ library/Cargo.lock
+ src/tools/rustbook/Cargo.lock
retention-days: 1
- name: upload cargo-update log artifact for use in PR
uses: actions/upload-artifact@v4
@@ -81,7 +94,7 @@ jobs:
if: github.repository_owner == 'rust-lang'
name: amend PR
needs: update
- runs-on: ubuntu-latest
+ runs-on: ubuntu-24.04
permissions:
contents: write
pull-requests: write
@@ -113,7 +126,7 @@ jobs:
git config user.name github-actions
git config user.email github-actions@github.com
git switch --force-create cargo_update
- git add ./Cargo.lock
+ git add ./Cargo.lock ./library/Cargo.lock ./src/tools/rustbook/Cargo.lock
git commit --no-verify --file=commit.txt
- name: push
diff --git a/.github/workflows/ghcr.yml b/.github/workflows/ghcr.yml
new file mode 100644
index 0000000000000..c2c0c11f0083d
--- /dev/null
+++ b/.github/workflows/ghcr.yml
@@ -0,0 +1,75 @@
+# Mirror DockerHub images used by the Rust project to ghcr.io.
+# Images are available at https://github.com/orgs/rust-lang/packages.
+#
+# In some CI jobs, we pull images from ghcr.io instead of Docker Hub because
+# Docker Hub has a rate limit, while ghcr.io doesn't.
+# Those images are pushed to ghcr.io by this job.
+#
+# While Docker Hub rate limit *shouldn't* be an issue on GitHub Actions,
+# it certainly is for AWS codebuild.
+#
+# Note that authenticating to DockerHub or other registries isn't possible
+# for PR jobs, because forks can't access secrets.
+# That's why we use ghcr.io: it has no rate limit and it doesn't require authentication.
+
+name: GHCR image mirroring
+
+on:
+ workflow_dispatch:
+ schedule:
+ # Run daily at midnight UTC
+ - cron: '0 0 * * *'
+
+jobs:
+ mirror:
+ name: DockerHub mirror
+ runs-on: ubuntu-24.04
+ if: github.repository == 'rust-lang/rust'
+ permissions:
+ # Needed to write to the ghcr.io registry
+ packages: write
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ persist-credentials: false
+
+ - name: Log in to registry
+ run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.repository_owner }} --password-stdin
+
+ # Download crane in the current directory.
+ # We use crane because it copies the docker image for all the architectures available in
+ # DockerHub for the image.
+ # Learn more about crane at
+ # https://github.com/google/go-containerregistry/blob/main/cmd/crane/README.md
+ - name: Download crane
+ run: |
+ curl -sL "https://github.com/google/go-containerregistry/releases/download/${VERSION}/go-containerregistry_${OS}_${ARCH}.tar.gz" | tar -xzf -
+ env:
+ VERSION: v0.20.2
+ OS: Linux
+ ARCH: x86_64
+
+ - name: Mirror DockerHub
+ run: |
+ # List of DockerHub images to mirror to ghcr.io
+ images=(
+ # Mirrored because used by the mingw-check-tidy, which doesn't cache Docker images
+ "ubuntu:22.04"
+ # Mirrored because used by all linux CI jobs, including mingw-check-tidy
+ "moby/buildkit:buildx-stable-1"
+ # Mirrored because used when CI is running inside a Docker container
+ "alpine:3.4"
+ # Mirrored because used by dist-x86_64-linux
+ "centos:7"
+ )
+
+ # Mirror each image from DockerHub to ghcr.io
+ for img in "${images[@]}"; do
+ echo "Mirroring ${img}..."
+ # Remove namespace from the image if any.
+ # E.g. "moby/buildkit:buildx-stable-1" becomes "buildkit:buildx-stable-1"
+ dest_image=$(echo "${img}" | cut -d'/' -f2-)
+ ./crane copy \
+ "docker.io/${img}" \
+ "ghcr.io/${{ github.repository_owner }}/${dest_image}"
+ done
diff --git a/.github/workflows/post-merge.yml b/.github/workflows/post-merge.yml
new file mode 100644
index 0000000000000..94553608a2f48
--- /dev/null
+++ b/.github/workflows/post-merge.yml
@@ -0,0 +1,46 @@
+# Workflow that runs after a merge to master, analyses changes in test executions
+# and posts the result to the merged PR.
+
+name: Post merge analysis
+
+on:
+ push:
+ branches:
+ - master
+
+jobs:
+ analysis:
+ runs-on: ubuntu-24.04
+ if: github.repository == 'rust-lang/rust'
+ permissions:
+ pull-requests: write
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ # Make sure that we have enough commits to find the parent merge commit.
+ # Since all merges should be through merge commits, fetching two commits
+ # should be enough to get the parent bors merge commit.
+ fetch-depth: 2
+ - name: Perform analysis and send PR
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: |
+ # Get closest bors merge commit
+ PARENT_COMMIT=`git rev-list --author='bors <bors@rust-lang.org>' -n1 --first-parent HEAD^1`
+ echo "Parent: ${PARENT_COMMIT}"
+
+ # Find PR for the current commit
+ HEAD_PR=`gh pr list --search "${{ github.sha }}" --state merged --json number --jq '.[0].number'`
+ echo "HEAD: ${{ github.sha }} (#${HEAD_PR})"
+
+ cd src/ci/citool
+
+ printf "<details>\n<summary>What is this?</summary>\n" >> output.log
+ printf "This is an experimental post-merge analysis report that shows differences in test outcomes between the merged PR and its parent PR.\n" >> output.log
+ printf "</details>\n\n" >> output.log
+
+ cargo run --release post-merge-report ${PARENT_COMMIT} ${{ github.sha }} >> output.log
+
+ cat output.log
+
+ gh pr comment ${HEAD_PR} -F output.log
diff --git a/.gitignore b/.gitignore
index f1ca6a79b5c5c..a549b6e6e56c3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
# This file should only ignore things that are generated during a `x.py` build,
# generated by common IDEs, and optional files controlled by the user that
-# affect the build (such as config.toml).
+# affect the build (such as bootstrap.toml).
# In particular, things like `mir_dump` should not be listed here; they are only
# created during manual debugging and many people like to clean up instead of
# having git ignore such leftovers. You can use `.git/info/exclude` to
@@ -19,9 +19,13 @@ Session.vim
*.iml
.vscode
.project
+.vim/
+.helix/
+.zed/
.favorites.json
.settings/
.vs/
+.dir-locals.el
## Tool
.valgrindrc
@@ -30,6 +34,7 @@ Session.vim
!/tests/run-make/thumb-none-qemu/example/.cargo
## Configuration
+/bootstrap.toml
/config.toml
/Makefile
config.mk
@@ -42,18 +47,24 @@ no_llvm_build
/inst/
/llvm/
/mingw-build/
-build/
-!/compiler/rustc_mir_build/src/build/
+/build
/build-rust-analyzer/
/dist/
/unicode-downloads
/target
+/library/target
/src/bootstrap/target
+/src/ci/citool/target
/src/tools/x/target
-/inc-fat/
+# Created by `x vendor`
+/vendor
# Created by default with `src/ci/docker/run.sh`
/obj/
-/rustc-ice*
+# Created by nix dev shell / .envrc
+src/tools/nix-dev-shell/flake.lock
+
+## ICE reports
+rustc-ice-*.txt
## Temporary files
*~
@@ -76,8 +87,18 @@ __pycache__/
node_modules
package-lock.json
package.json
+/src/doc/rustc-dev-guide/mermaid.min.js
## Rustdoc GUI tests
tests/rustdoc-gui/src/**.lock
+## direnv
+/.envrc
+/.direnv/
+
+## nix
+/flake.nix
+flake.lock
+/default.nix
+
# Before adding new lines, see the comment at the top.
diff --git a/.gitmodules b/.gitmodules
index 9ad207a0d5226..d09d81ccadcb0 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -22,10 +22,6 @@
path = library/stdarch
url = https://github.com/rust-lang/stdarch.git
shallow = true
-[submodule "src/doc/rustc-dev-guide"]
- path = src/doc/rustc-dev-guide
- url = https://github.com/rust-lang/rustc-dev-guide.git
- shallow = true
[submodule "src/doc/edition-guide"]
path = src/doc/edition-guide
url = https://github.com/rust-lang/edition-guide.git
@@ -33,7 +29,7 @@
[submodule "src/llvm-project"]
path = src/llvm-project
url = https://github.com/rust-lang/llvm-project.git
- branch = rustc/18.1-2024-05-19
+ branch = rustc/20.1-2025-02-13
shallow = true
[submodule "src/doc/embedded-book"]
path = src/doc/embedded-book
@@ -47,3 +43,11 @@
path = src/tools/rustc-perf
url = https://github.com/rust-lang/rustc-perf.git
shallow = true
+[submodule "src/tools/enzyme"]
+ path = src/tools/enzyme
+ url = https://github.com/rust-lang/Enzyme.git
+ shallow = true
+[submodule "src/gcc"]
+ path = src/gcc
+ url = https://github.com/rust-lang/gcc.git
+ shallow = true
diff --git a/.ignore b/.ignore
index 40d1513978fc6..b0c640fee3dac 100644
--- a/.ignore
+++ b/.ignore
@@ -1,2 +1,3 @@
-# Make vscode *not* count `config.toml` as ignored, so it is included in search
+# Make vscode *not* count `bootstrap.toml` and `config.toml` as ignored, so it is included in search
+!/bootstrap.toml
!/config.toml
diff --git a/.mailmap b/.mailmap
index 33673244be6d0..c3ce111bfe3b4 100644
--- a/.mailmap
+++ b/.mailmap
@@ -31,6 +31,7 @@ Alexis Beingessner <a.beingessner@gmail.com>
Alfie John <alfie@alfie.wtf> Alfie John <alfiej@fastmail.fm>
Alona Enraght-Moony <code@alona.page> <nixon.emoony@gmail.com>
Alona Enraght-Moony <code@alona.page> <nixon@caminus.local>
+Alona Enraght-Moony <code@alona.page> <contact@alona.page>
Amanda Stjerna <mail@amandastjerna.se> <albin.stjerna@gmail.com>
Amanda Stjerna <mail@amandastjerna.se> <amanda.stjerna@it.uu.se>
Amos Onn <amosonn@gmail.com>
@@ -47,6 +48,7 @@ Andrew Poelstra <asp11@sfu.ca> <apoelstra@wpsoftware.net>
Anhad Singh <andypythonappdeveloper@gmail.com>
Antoine Plaskowski <antoine.plaskowski@epitech.eu>
Anton Löfgren <anton.lofgren@gmail.com> <alofgren@op5.com>
+apiraino <apiraino@users.noreply.github.com> <apiraino@protonmail.com>
Araam Borhanian <avborhanian@gmail.com>
Araam Borhanian <avborhanian@gmail.com> <dobbybabee@gmail.com>
Areski Belaid <areski@gmail.com> areski <areski@gmail.com>
@@ -61,7 +63,10 @@ Austin Seipp <mad.one@gmail.com> <as@hacks.yi.org>
Ayaz Hafiz <ayaz.hafiz.1@gmail.com>
Aydin Kim <ladinjin@hanmail.net> aydin.kim <aydin.kim@samsung.com>
Ayush Mishra <ayushmishra2005@gmail.com>
+Ashley Mannix <kodraus@hey.com> <ashleymannix@live.com.au>
asrar <aszenz@gmail.com>
+b-naber <bn263@gmx.de>
+b-naber <bn263@gmx.de> <b_naber@gmx.de>
BaoshanPang <pangbw@gmail.com>
Barosl Lee <vcs@barosl.com> Barosl LEE <github@barosl.com>
Bastian Kersting <bastian@cmbt.de>
@@ -74,6 +79,8 @@ Ben Striegel <ben.striegel@gmail.com>
Benjamin Jackman <ben@jackman.biz>
Benoît Cortier <benoit.cortier@fried-world.eu>
Bheesham Persaud <bheesham123@hotmail.com> Bheesham Persaud <bheesham.persaud@live.ca>
+bjorn3 <17426603+bjorn3@users.noreply.github.com> <bjorn3@users.noreply.github.com>
+bjorn3 <17426603+bjorn3@users.noreply.github.com> <bjorn3_gh@protonmail.com>
Björn Steinbrink <bsteinbr@gmail.com> <B.Steinbrink@gmx.de>
blake2-ppc <ulrik.sverdrup@gmail.com> <blake2-ppc>
blyxyas <blyxyas@gmail.com> Alejandra González <blyxyas@gmail.com>
@@ -81,6 +88,8 @@ boolean_coercion <booleancoercion@gmail.com>
Boris Egorov <jightuse@gmail.com> <egorov@linux.com>
bors <bors@rust-lang.org> bors[bot] <26634292+bors[bot]@users.noreply.github.com>
bors <bors@rust-lang.org> bors[bot] <bors[bot]@users.noreply.github.com>
+BoxyUwU <rust@boxyuwu.dev>
+BoxyUwU <rust@boxyuwu.dev> <supbscripter@gmail.com>
Braden Nelson <moonheart08@users.noreply.github.com>
Brandon Sanderson <singingboyo@gmail.com> Brandon Sanderson <singingboyo@hotmail.com>
Brett Cannon <brett@python.org> Brett Cannon <brettcannon@users.noreply.github.com>
@@ -94,6 +103,8 @@ Caleb Cartwright <caleb.cartwright@outlook.com>
Caleb Jones <code@calebjones.net>
Noah Lev <camelidcamel@gmail.com>
Noah Lev <camelidcamel@gmail.com> <37223377+camelid@users.noreply.github.com>
+Catherine <catherine3.flores@gmail.com>
+Catherine <catherine3.flores@gmail.com> <catherine.3.flores@gmail.com>
cameron1024 <cameron.studdstreet@gmail.com>
Camille Gillot <gillot.camille@gmail.com>
Carl-Anton Ingmarsson <mail@carlanton.se> <ca.ingmarsson@gmail.com>
@@ -129,11 +140,13 @@ Clement Miao <clementmiao@gmail.com>
Clément Renault <renault.cle@gmail.com>
Cliff Dyer <jcd@sdf.org>
Clinton Ryan <clint.ryan3@gmail.com>
+Taylor Cramer <cramertaylorj@gmail.com> <cramertj@google.com>
ember arlynx <ember@lunar.town> <corey@octayn.net>
Crazycolorz5 <Crazycolorz5@gmail.com>
csmoe <35686186+csmoe@users.noreply.github.com>
Cyryl Płotnicki <cyplo@cyplo.net>
Damien Schoof <damien.schoof@gmail.com>
+Dan Gohman <dev@sunfishcode.online> <sunfish@mozilla.com>
Dan Robertson <danlrobertson89@gmail.com>
Daniel Campoverde <alx741@riseup.net>
Daniel J Rollins <drollins@financialforce.com>
@@ -146,6 +159,7 @@ David Klein <david.klein@baesystemsdetica.com>
David Manescu <david.manescu@gmail.com> <dman2626@uni.sydney.edu.au>
David Ross <daboross@daboross.net>
David Wood <david@davidtw.co> <david.wood@huawei.com>
+David Wood <david@davidtw.co> <david.wood2@arm.com>
Deadbeef <ent3rm4n@gmail.com>
Deadbeef <ent3rm4n@gmail.com> <fee1-dead-beef@protonmail.com>
dependabot[bot] <dependabot[bot]@users.noreply.github.com> <27856297+dependabot-preview[bot]@users.noreply.github.com>
@@ -169,20 +183,29 @@ Dzmitry Malyshau <kvarkus@gmail.com>
E. Dunham <edunham@mozilla.com> edunham <edunham@mozilla.com>
Ed Barnard <eabarnard@gmail.com>
Eduard-Mihai Burtescu <edy.burt@gmail.com>
+Eduard-Mihai Burtescu <edy.burt@gmail.com> <eddyb@lyken.rs>
Eduardo Bautista <me@eduardobautista.com> <=>
Eduardo Bautista <me@eduardobautista.com> <mail@eduardobautista.com>
Eduardo Broto <ebroto@tutanota.com>
Edward Shen <code@eddie.sh> <xes@meta.com>
+Jacob Finkelman <eh2406@wayne.edu>
+Jacob Finkelman <eh2406@wayne.edu> <YeomanYaacov@gmail.com>
+Jacob Finkelman <eh2406@wayne.edu> <jfinkelm@amazon.com>
+Jacob Finkelman <eh2406@wayne.edu> <finkelman@semcog.org>
+Jacob Finkelman <eh2406@wayne.edu> <Eh2406@users.noreply.github.com>
Elliott Slaughter <elliottslaughter@gmail.com> <eslaughter@mozilla.com>
Elly Fong-Jones <elly@leptoquark.net>
Eric Holk <eric.holk@gmail.com> <eholk@cs.indiana.edu>
Eric Holk <eric.holk@gmail.com> <eholk@mozilla.com>
+Eric Holk <eric.holk@gmail.com> <eric@theincredibleholk.org>
+Eric Holk <eric.holk@gmail.com> <ericholk@microsoft.com>
Eric Holmes <eric@ejholmes.net>
Eric Reed <ecreed@cs.washington.edu> <ereed@mozilla.com>
Erick Tryzelaar <erick.tryzelaar@gmail.com> <etryzelaar@iqt.org>
Erik Desjardins <erikdesjardins@users.noreply.github.com>
Erik Jensen <erikjensen@rkjnsn.net>
Erin Power <xampprocky@gmail.com>
+Erin Power <xampprocky@gmail.com> <xampprocky@icloud.com>
Erin Power <xampprocky@gmail.com> <theaaronepower@gmail.com>
Erin Power <xampprocky@gmail.com> <Aaronepower@users.noreply.github.com>
Esteban Küber <esteban@kuber.com.ar>
@@ -195,9 +218,11 @@ F001 <changchun.fan@qq.com>
Fabian Kössel <fkjogu@users.noreply.github.com>
Falco Hirschenberger <falco.hirschenberger@gmail.com> <hirschen@itwm.fhg.de>
Felix S. Klock II <pnkfelix@pnkfx.org> Felix S Klock II <pnkfelix@pnkfx.org>
+Felix S. Klock II <pnkfelix@pnkfx.org> <pnkfelix@mozilla.com>
Félix Saparelli <felix@passcod.name>
Flaper Fesp <flaper87@gmail.com>
Florian Berger <fbergr@gmail.com>
+Florian Gilcher <florian.gilcher@asquera.de> <flo@andersground.net>
Florian Wilkens <mrfloya_github@outlook.com> Florian Wilkens <floya@live.de>
François Mockers <mockersf@gmail.com>
Frank Steffahn <fdsteffahn@gmail.com> <frank.steffahn@stu.uni-kiel.de>
@@ -232,6 +257,8 @@ Herman J. Radtke III <herman@hermanradtke.com> Herman J. Radtke III <hermanradtk
Hirochika Matsumoto <git@hkmatsumoto.com> <matsujika@gmail.com>
Hrvoje Nikšić <hniksic@gmail.com>
Hsiang-Cheng Yang <rick68@users.noreply.github.com>
+Huon Wilson <dbau.pp@gmail.com>
+Huon Wilson <dbau.pp@gmail.com> <wilson.huon@gmail.com>
Ian Jackson <ijackson@chiark.greenend.org.uk> <ian.jackson@citrix.com>
Ian Jackson <ijackson@chiark.greenend.org.uk> <ijackson+github@slimy.greenend.org.uk>
Ian Jackson <ijackson@chiark.greenend.org.uk> <iwj@xenproject.org>
@@ -242,10 +269,15 @@ Irina Popa <irinagpopa@gmail.com>
Ivan Ivaschenko <defuz.net@gmail.com>
ivan tkachenko <me@ratijas.tk>
J. J. Weber <jjweber@gmail.com>
-Jack Huey <jack.huey@umassmed.edu>
+Jack Huey <jack.huey@umassmed.edu> <jackh726@gmail.com>
Jacob <jacob.macritchie@gmail.com>
+Jacob Hoffman-Andrews <rust@hoffman-andrews.com> <github@hoffman-andrews.com>
Jacob Greenfield <xales@naveria.com>
Jacob Pratt <jacob@jhpratt.dev> <the.z.cuber@gmail.com>
+Jacob Pratt <jacob@jhpratt.dev> <jacopratt@tesla.com>
+Jake Goulding <jake.goulding@integer32.com>
+Jake Goulding <jake.goulding@integer32.com> <jake.goulding@gmail.com>
+Jake Goulding <jake.goulding@integer32.com> <shepmaster@mac.com>
Jake Vossen <jake@vossen.dev>
Jakob Degen <jakob.e.degen@gmail.com> <jakob@degen.com>
Jakob Lautrup Nysom <jako3047@gmail.com>
@@ -253,12 +285,17 @@ Jakub Adam Wieczorek <jakub.adam.wieczorek@gmail.com>
Jakub Adam Wieczorek <jakub.adam.wieczorek@gmail.com> <jakub.bukaj@yahoo.com>
Jakub Adam Wieczorek <jakub.adam.wieczorek@gmail.com> <jakub@jakub.cc>
Jakub Adam Wieczorek <jakub.adam.wieczorek@gmail.com> <jakubw@jakubw.net>
+Jakub Beránek <berykubik@gmail.com> <jakub.beranek@vsb.cz>
James [Undefined] <tpzker@thepuzzlemaker.info>
James Deng <cnjamesdeng@gmail.com> <cnJamesDeng@gmail.com>
James Hinshelwood <jameshinshelwood1@gmail.com> <james.hinshelwood@bigpayme.com>
James Miller <bladeon@gmail.com> <james@aatch.net>
James Perry <james.austin.perry@gmail.com>
James Sanderson <zofrex@gmail.com>
+Jamie Hill-Daniel <jamie@hill-daniel.co.uk> <clubby789@gmail.com>
+Jana Dönszelmann <jana@donsz.nl>
+Jana Dönszelmann <jana@donsz.nl> <jonathan@donsz.nl>
+Jana Dönszelmann <jana@donsz.nl> <jonabent@gmail.com>
Jan-Erik Rediger <janerik@fnordig.de> <badboy@archlinux.us>
Jaro Fietz <jaro.fietz@gmx.de>
Jason Fager <jfager@gmail.com>
@@ -277,6 +314,8 @@ Jerry Hardee <hardeejj9@gmail.com>
Jesús Rubio <jesusprubio@gmail.com>
Jethro Beekman <github@jbeekman.nl>
Jian Zeng <knight42@mail.ustc.edu.cn>
+Jieyou Xu <jieyouxu@outlook.com>
+Jieyou Xu <jieyouxu@outlook.com> <39484203+jieyouxu@users.noreply.github.com>
Jihyun Yu <j.yu@navercorp.com> <yjh0502@gmail.com>
Jihyun Yu <j.yu@navercorp.com> jihyun <jihyun@nablecomm.com>
Jihyun Yu <j.yu@navercorp.com> Jihyun Yu <jihyun@nclab.kaist.ac.kr>
@@ -287,6 +326,7 @@ John Clements <clements@racket-lang.org> <clements@brinckerhoff.org>
John Hodge <acessdev@gmail.com> John Hodge <tpg@mutabah.net>
John Hörnvall <trolledwoods@gmail.com>
John Kåre Alsaker <john.kare.alsaker@gmail.com>
+John Kåre Alsaker <john.kare.alsaker@gmail.com> <zoxc32@gmail.com>
John Talling <inrustwetrust@users.noreply.github.com>
John Van Enk <vanenkj@gmail.com>
Jonas Tepe <jonasprogrammer@gmail.com>
@@ -309,9 +349,13 @@ Josh Driver <keeperofdakeys@gmail.com>
Josh Holmer <jholmer.in@gmail.com>
Josh Stone <cuviper@gmail.com> <jistone@redhat.com>
Josh Stone <cuviper@gmail.com> <jistone@fedoraproject.org>
+Julia Ryan <juliaryan3.14@gmail.com> <josephryan3.14@gmail.com>
+Jubilee Young <workingjubilee@gmail.com> <46493976+workingjubilee@users.noreply.github.com>
+Jubilee Young <workingjubilee@gmail.com>
Julian Knodt <julianknodt@gmail.com>
jumbatm <jumbatm@gmail.com> <30644300+jumbatm@users.noreply.github.com>
Junyoung Cho <june0.cho@samsung.com>
+Jynn Nelson <github@jyn.dev> <rust@jyn.dev>
Jynn Nelson <github@jyn.dev> <jyn514@gmail.com>
Jynn Nelson <github@jyn.dev> <joshua@yottadb.com>
Jynn Nelson <github@jyn.dev> <jyn.nelson@redjack.com>
@@ -362,21 +406,27 @@ Lukas Lueg <lukas.lueg@gmail.com>
Luke Metz <luke.metz@students.olin.edu>
Luqman Aden <me@luqman.ca> <laden@csclub.uwaterloo.ca>
Luqman Aden <me@luqman.ca> <laden@mozilla.com>
+Luqman Aden <me@luqman.ca> <rust@luqman.ca>
Lzu Tao <taolzu@gmail.com>
Maik Klein <maikklein@googlemail.com>
+Maja Kądziołka <maya@compilercrim.es> <github@compilercrim.es>
+Maja Kądziołka <maya@compilercrim.es> <kuba@kadziolka.net>
Malo Jaffré <jaffre.malo@gmail.com>
Manish Goregaokar <manishsmail@gmail.com>
Mara Bos <m-ou.se@m-ou.se>
Marcell Pardavi <marcell.pardavi@gmail.com>
+Marco Ieni <11428655+MarcoIeni@users.noreply.github.com>
Marcus Klaas de Vries <mail@marcusklaas.nl>
Margaret Meyerhofer <mmeyerho@andrew.cmu.edu> <mmeyerho@andrew>
Mark Mansi <markm@cs.wisc.edu>
+Mark Mansi <markm@cs.wisc.edu> <m.mim95@gmail.com>
Mark Rousskov <mark.simulacrum@gmail.com>
Mark Sinclair <mark.edward.x@gmail.com>
Mark Sinclair <mark.edward.x@gmail.com> =Mark Sinclair <=125axel125@gmail.com>
Markus Legner <markus@legner.ch>
Markus Westerlind <marwes91@gmail.com> Markus <marwes91@gmail.com>
Martin Carton <cartonmartin+git@gmail.com>
+Martin Carton <cartonmartin+git@gmail.com> <cartonmartin@gmail.com>
Martin Habovštiak <martin.habovstiak@gmail.com>
Martin Hafskjold Thoresen <martinhath@gmail.com>
Martin Nordholts <martin.nordholts@codetale.se> <enselic@gmail.com>
@@ -401,8 +451,10 @@ Melody Horn <melody@boringcactus.com> <mathphreak@gmail.com>
Mendes <pedro.mendes.26@gmail.com>
mental <m3nta1@yahoo.com>
mibac138 <5672750+mibac138@users.noreply.github.com>
+Michael Howell <michael@notriddle.com> <notriddle+rust-mod@protonmail.com>
Michael Williams <m.t.williams@live.com>
Michael Woerister <michaelwoerister@posteo> <michaelwoerister@gmail>
+Michael Woerister <michaelwoerister@posteo> <michaelwoerister@gmail.com>
Michael Woerister <michaelwoerister@posteo> <michaelwoerister@users.noreply.github.com>
Michael Woerister <michaelwoerister@posteo> <michaelwoerister@posteo.net>
Michael Zhang <hmperson1@gmail.com>
@@ -416,6 +468,8 @@ Ms2ger <ms2ger@gmail.com> <Ms2ger@gmail.com>
msizanoen1 <qtmlabs@protonmail.com>
Mukilan Thiagarajan <mukilanthiagarajan@gmail.com>
Nadrieril Feneanar <Nadrieril@users.noreply.github.com>
+Nadrieril Feneanar <Nadrieril@users.noreply.github.com> <nadrieril+rust@gmail.com>
+Nadrieril Feneanar <Nadrieril@users.noreply.github.com> <nadrieril+git@gmail.com>
NAKASHIMA, Makoto <makoto.nksm+github@gmail.com> <makoto.nksm@gmail.com>
NAKASHIMA, Makoto <makoto.nksm+github@gmail.com> <makoto.nksm+github@gmail.com>
Nathan Ringo <remexre@gmail.com>
@@ -431,13 +485,23 @@ Nicholas Bishop <nbishop@nbishop.net> <nicholasbishop@gmail.com>
Nicholas Bishop <nbishop@nbishop.net> <nicholasbishop@google.com>
Nicholas Nethercote <n.nethercote@gmail.com> <nnethercote@apple.com>
Nicholas Nethercote <n.nethercote@gmail.com> <nnethercote@mozilla.com>
+Nick Cameron <nrc@ncameron.org> <ncameron@mozilla.com>
+Nick Fitzgerald <fitzgen@gmail.com> <nfitzgerald@mozilla.com>
Nick Platt <platt.nicholas@gmail.com>
Niclas Schwarzlose <15schnic@gmail.com>
Nicolas Abram <abramlujan@gmail.com>
Nicole Mazzuca <npmazzuca@gmail.com>
-Nilstrieb <48135649+Nilstrieb@users.noreply.github.com> nils <48135649+Nilstrieb@users.noreply.github.com>
+Niko Matsakis <rust@nikomatsakis.com>
+Niko Matsakis <rust@nikomatsakis.com> <niko@alum.mit.edu>
+Noratrieb <48135649+Noratrieb@users.noreply.github.com>
+Noratrieb <48135649+Noratrieb@users.noreply.github.com> <48135649+Nilstrieb@users.noreply.github.com>
+Noratrieb <48135649+Noratrieb@users.noreply.github.com> <nilstrieb@gmail.com>
+Noratrieb <48135649+Noratrieb@users.noreply.github.com> <rust@noratrieb.dev>
+Noratrieb <48135649+Noratrieb@users.noreply.github.com> <nora@noratrieb.dev>
Nif Ward <nif.ward@gmail.com>
Nika Layzell <nika@thelayzells.com> <michael@thelayzells.com>
+Nikita Popov <nikita.ppv@gmail.com>
+Nikita Popov <nikita.ppv@gmail.com> <npopov@redhat.com>
NODA Kai <nodakai@gmail.com>
Oğuz Ağcayazı <oguz.agcayazi@gmail.com> <oguz.agcayazi@gmail.com>
Oğuz Ağcayazı <oguz.agcayazi@gmail.com> <ouz.agz@gmail.com>
@@ -454,6 +518,7 @@ Oliver Scherer <oli-obk@users.noreply.github.com> <github6541940@oli-obk.de>
Oliver Scherer <oli-obk@users.noreply.github.com> <public.oliver.schneider@kit.edu>
Oliver Scherer <oli-obk@users.noreply.github.com> <oliver.schneider@kit.edu>
Oliver Scherer <oli-obk@users.noreply.github.com> <obk8176014uqher834@olio-obk.de>
+Oliver Scherer <oli-obk@users.noreply.github.com> <rustc-contact@oli-obk.de>
Oliver Scherer <oli-obk@users.noreply.github.com>
Onur Özkan <onurozkan.dev@outlook.com> <work@onurozkan.dev>
Onur Özkan <onurozkan.dev@outlook.com>
@@ -490,18 +555,23 @@ Raphaël Huchet <rap2hpoutre@users.noreply.github.com>
rChaser53 <tayoshizawa29@gmail.com>
Rémy Rakic <remy.rakic@gmail.com>
Rémy Rakic <remy.rakic@gmail.com> <remy.rakic+github@gmail.com>
+Rémy Rakic <remy.rakic@gmail.com> <remy.rakic+rust@gmail.com>
Renato Riccieri Santos Zannon <renato@rrsz.com.br>
Richard Diamond <wichard@vitalitystudios.com> <wichard@hahbee.co>
Ricky Hosfelt <ricky@hosfelt.io>
Ritiek Malhotra <ritiekmalhotra123@gmail.com>
Rob Arnold <robarnold@cs.cmu.edu>
Rob Arnold <robarnold@cs.cmu.edu> Rob Arnold <robarnold@68-26-94-7.pools.spcsdns.net>
+Robert Collins <robertc@robertcollins.net> <robertc+rust@robertcollins.net>
Robert Foss <dev@robertfoss.se> robertfoss <dev@robertfoss.se>
Robert Gawdzik <rgawdzik@hotmail.com> Robert Gawdzik ☢ <rgawdzik@hotmail.com>
Robert Habermeier <rphmeier@gmail.com>
Robert Millar <robert.millar@cantab.net>
Roc Yu <rocyu@protonmail.com>
Rohit Joshi <rohitjoshi@users.noreply.github.com> Rohit Joshi <rohit.joshi@capitalone.com>
+Ross Smyth <18294397+RossSmyth@users.noreply.github.com>
+Ross Smyth <18294397+RossSmyth@users.noreply.github.com> <crs2017@gmail.com>
+Ross Smyth <18294397+RossSmyth@users.noreply.github.com> <rsmyth@electrocraft.com>
Roxane Fruytier <roxane.fruytier@hotmail.com>
Rui <xiongmao86dev@sina.com>
Russell Johnston <rpjohnst@gmail.com>
@@ -519,6 +589,7 @@ Samuel Tardieu <sam@rfc1149.net>
Santiago Pastorino <spastorino@gmail.com>
Santiago Pastorino <spastorino@gmail.com> <santiago@wyeworks.com>
Scott McMurray <scottmcm@users.noreply.github.com>
+Scott McMurray <scottmcm@users.noreply.github.com> <smcmurray@acm.org>
Scott Olson <scott@solson.me> Scott Olson <scott@scott-olson.org>
Sean Gillespie <sean.william.g@gmail.com> swgillespie <sean.william.g@gmail.com>
Seiichi Uchida <seuchida@gmail.com>
@@ -530,8 +601,17 @@ Shyam Sundar B <shyambaskaran@outlook.com>
Simon Barber-Dueck <sbarberdueck@gmail.com> Simon BD <simon@server>
Simon Sapin <simon@exyr.org> <simon.sapin@exyr.org>
Simonas Kazlauskas <git@kazlauskas.me> Simonas Kazlauskas <github@kazlauskas.me>
+Simonas Kazlauskas <git@kazlauskas.me> <simonas+t-compiler@kazlauskas.me>
Siva Prasad <sivaauturic@gmail.com>
+Skgland <3877590+Skgland@users.noreply.github.com>
+Skgland <3877590+Skgland@users.noreply.github.com> <bb-github@t-online.de>
+Skgland <3877590+Skgland@users.noreply.github.com> <bennet.blessmann+github@googlemail.com>
Smittyvb <me@smitop.com>
+Sophia June Turner <547158+sophiajt@users.noreply.github.com>
+Sophia June Turner <547158+sophiajt@users.noreply.github.com> <547158+jntrnr@users.noreply.github.com>
+Sophia June Turner <547158+sophiajt@users.noreply.github.com> <jonathandturner@users.noreply.github.com>
+Sophia June Turner <547158+sophiajt@users.noreply.github.com> <jturner@mozilla.com>
+Sophia June Turner <547158+sophiajt@users.noreply.github.com> <jonathan.d.turner@gmail.com>
Srinivas Reddy Thatiparthy <thatiparthysreenivas@gmail.com>
Stanislav Tkach <stanislav.tkach@gmail.com>
startling <tdixon51793@gmail.com>
@@ -550,6 +630,8 @@ Tatsuyuki Ishi <ishitatsuyuki@gmail.com>
Tau Gärtli <git@tau.garden> <ruben.schmidmeister@icloud.com>
Tero Hänninen <lgvz@users.noreply.github.com> Tero Hänninen <tejohann@kapsi.fi>
The8472 <git@infinite-source.de>
+The8472 <git@infinite-source.de> <the8472.rs@infinite-source.de>
+The8472 <git@infinite-source.de> <the8472@users.noreply.github.com>
Theo Belaire <theo.belaire@gmail.com> Theo Belaire <tyr.god.of.war.42@gmail.com>
Theodore Luo Wang <wangtheo662@gmail.com>
Thiago Pontes <email@thiago.me> thiagopnts <thiagopnts@gmail.com>
@@ -562,8 +644,10 @@ Tim Diekmann <t.diekmann.3dv@gmail.com>
Tim Hutt <tdhutt@gmail.com>
Tim JIANG <p90eri@gmail.com>
Tim Joseph Dumol <tim@timdumol.com>
+Tim Neumann <mail@timnn.me> <timnn@google.com>
Timothy Maloney <tmaloney@pdx.edu>
Tomas Koutsky <tomas@stepnivlk.net>
+Tomasz Miąsko <tomasz.miasko@gmail.com>
Torsten Weber <TorstenWeber12@gmail.com>
Torsten Weber <TorstenWeber12@gmail.com> <torstenweber12@gmail.com>
Trevor Gross <tmgross@umich.edu> <t.gross35@gmail.com>
@@ -583,11 +667,14 @@ Valerii Lashmanov <vflashm@gmail.com>
Vitali Haravy <HumaneProgrammer@gmail.com> Vitali Haravy <humaneprogrammer@gmail.com>
Vitaly Shukela <vi0oss@gmail.com>
Waffle Lapkin <waffle.lapkin@gmail.com>
-Waffle Lapkin <waffle.lapkin@tasking.com>
+Waffle Lapkin <waffle.lapkin@gmail.com> <waffle.lapkin@tasking.com>
+Weihang Lo <me@weihanglo.tw>
+Weihang Lo <me@weihanglo.tw> <weihanglo@users.noreply.github.com>
Wesley Wiser <wwiser@gmail.com> <wesleywiser@microsoft.com>
whitequark <whitequark@whitequark.org>
William Ting <io@williamting.com> <william.h.ting@gmail.com>
-Wim Looman <wim@nemo157.com>
+Wim Looman <wim@nemo157.com> <rust-lang@nemo157.com>
+Wim Looman <wim@nemo157.com> <git@nemo157.com>
Without Boats <woboats@gmail.com>
Without Boats <woboats@gmail.com> <boats@mozilla.com>
Xinye Tao <xy.tao@outlook.com>
diff --git a/.reuse/dep5 b/.reuse/dep5
deleted file mode 100644
index 5706ea0b2046b..0000000000000
--- a/.reuse/dep5
+++ /dev/null
@@ -1,124 +0,0 @@
-# WARNING: this metadata is currently incomplete, do not rely on it yet.
-
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-
-# Note that we're explicitly listing the individual files at the root of the
-# repository rather than just having `Files: *`. This is explicitly done to
-# help downstream forks of the Rust compiler: this way, the files they add
-# won't be automatically marked as authored by the Rust project.
-Files: compiler/*
- library/*
- tests/*
- src/*
- .github/*
- Cargo.lock
- Cargo.toml
- CODE_OF_CONDUCT.md
- config.example.toml
- configure
- CONTRIBUTING.md
- COPYRIGHT
- INSTALL.md
- LICENSE-APACHE
- LICENSE-MIT
- README.md
- RELEASES.md
- rustfmt.toml
- rust-bors.toml
- triagebot.toml
- x
- x.ps1
- x.py
- .clang-format
- .editorconfig
- .git-blame-ignore-revs
- .gitattributes
- .gitignore
- .gitmodules
- .mailmap
- .ignore
-Copyright: The Rust Project Developers (see https://thanks.rust-lang.org)
-License: MIT or Apache-2.0
-
-Files: compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
-Copyright: 2003-2019 University of Illinois at Urbana-Champaign.
- The Rust Project Developers (see https://thanks.rust-lang.org)
-License: Apache-2.0 WITH LLVM-exception AND (Apache-2.0 OR MIT)
-
-Files: library/core/src/unicode/unicode_data.rs
-Copyright: 1991-2022 Unicode, Inc. All rights reserved.
-License: Unicode-DFS-2016
-
-Files: library/std/src/sync/mpmc/*
-Copyright: 2019 The Crossbeam Project Developers
- The Rust Project Developers (see https://thanks.rust-lang.org)
-License: MIT OR Apache-2.0
-
-Files: library/std/src/sys/sync/mutex/fuchsia.rs
-Copyright: 2016 The Fuchsia Authors
- The Rust Project Developers (see https://thanks.rust-lang.org)
-License: BSD-2-Clause AND (MIT OR Apache-2.0)
-
-Files: src/test/rustdoc/auxiliary/enum-primitive.rs
-Copyright: 2015 Anders Kaseorg <andersk@mit.edu>
-License: MIT
-
-Files: src/librustdoc/html/static/fonts/FiraSans*
-Copyright: 2014, Mozilla Foundation
- 2014, Telefonica S.A.
-License: OFL-1.1
-
-Files: src/librustdoc/html/static/fonts/NanumBarun*
-Copyright: 2010 NAVER Corporation
-License: OFL-1.1
-
-Files: src/librustdoc/html/static/fonts/SourceCodePro*
- src/librustdoc/html/static/fonts/SourceSerif4*
-Copyright: 2010, 2012, 2014-2023, Adobe Systems Incorporated
-License: OFL-1.1
-
-Files: src/librustdoc/html/static/css/normalize.css
-Copyright: Nicolas Gallagher and Jonathan Neal
-License: MIT
-
-Files: src/librustdoc/html/static/css/rustdoc.css
-Copyright: 2016 Ike Ku, Jessica Stokes and Leon Guan
- The Rust Project Developers (see https://thanks.rust-lang.org)
-License: MIT OR Apache-2.0
-
-Files: src/doc/rustc-dev-guide/mermaid.min.js
-Copyright: 2014-2021 Knut Sveidqvist
-License: MIT
-
-Files: library/backtrace/*
-Copyright: 2014 Alex Crichton
- The Rust Project Developers (see https://thanks.rust-lang.org)
-License: MIT OR Apache-2.0
-
-Files: src/doc/embedded-book/*
-Copyright: Rust on Embedded Devices Working Group
- The Rust Project Developers (see https://thanks.rust-lang.org)
-License: MIT OR Apache-2.0 OR CC-BY-SA-4.0
-
-Files: src/doc/rust-by-example/*
-Copyright: 2014 Jorge Aparicio
- The Rust Project Developers (see https://thanks.rust-lang.org)
-License: MIT OR Apache-2.0
-
-# Reuse cannot process the LLVM source tree, and so the copyrights for the LLVM
-# submodule are written out here manually. The collect-licence-metadata tool
-# has a specific exception coded within it to ignore ./src/llvm-project so
-# any time LLVM is updated, please revisit this section. The copyrights are
-# taken from the relevant LLVM sub-folders: llvm, lld, lldb, compiler-rt and libunwind.
-#
-# The git hash for the CREDITS.TXT file is taken from the current git submodule
-# commit for ./src/llvm-project.
-#
-# The copyright years were compiled by looking at all the relevant
-# ./src/llvm-project/*/LICENSE.txt files
-
-Files: src/llvm-project/*
-Copyright: 2003-2019 by the contributors listed in [CREDITS.TXT](https://github.com/rust-lang/llvm-project/blob/7738295178045041669876bf32b0543ec8319a5c/llvm/CREDITS.TXT)
- 2010 Apple Inc
- 2003-2019 University of Illinois at Urbana-Champaign.
-License: NCSA AND Apache-2.0 WITH LLVM-exception
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index eeff563d8ecdf..e155e253784aa 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -12,6 +12,15 @@ Documentation for contributing to the compiler or tooling is located in the [Gui
Development][rustc-dev-guide], commonly known as the [rustc-dev-guide]. Documentation for the
standard library in the [Standard library developers Guide][std-dev-guide], commonly known as the [std-dev-guide].
+## Making changes to subtrees and submodules
+
+For submodules, changes need to be made against the repository corresponding the
+submodule, and not the main `rust-lang/rust` repository.
+
+For subtrees, prefer sending a PR against the subtree's repository if it does
+not need to be made against the main `rust-lang/rust` repository (e.g. a
+rustc-dev-guide change that does not accompany a compiler change).
+
## About the [rustc-dev-guide]
The [rustc-dev-guide] is meant to help document how rustc –the Rust compiler– works,
diff --git a/COPYRIGHT b/COPYRIGHT
index 05993830a0fb4..4dad74f234eaa 100644
--- a/COPYRIGHT
+++ b/COPYRIGHT
@@ -3,6 +3,7 @@ Short version for non-lawyers:
The Rust Project is dual-licensed under Apache 2.0 and MIT
terms.
+It is Copyright (c) The Rust Project Contributors.
Longer version:
@@ -11,381 +12,23 @@ copyright assignment is required to contribute to the Rust project.
Some files include explicit copyright notices and/or license notices.
For full authorship information, see the version control history or
-https://thanks.rust-lang.org
-
-Except as otherwise noted (below and/or in individual files), Rust is
-licensed under the Apache License, Version 2.0 <LICENSE-APACHE> or
-<http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-<LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
-
-
-The Rust Project includes packages written by third parties.
-The following third party packages are included, and carry
-their own copyright notices and license terms:
-
-* LLVM, located in src/llvm-project, is licensed under the following
- terms.
-
- ==============================================================================
- The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:
- ==============================================================================
-
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-
-
- ---- LLVM Exceptions to the Apache 2.0 License ----
-
- As an exception, if, as a result of your compiling your source code, portions
- of this Software are embedded into an Object form of such source code, you
- may redistribute such embedded portions in such Object form without complying
- with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
-
- In addition, if you combine or link compiled forms of this Software with
- software that is licensed under the GPLv2 ("Combined Software") and if a
- court of competent jurisdiction determines that the patent provision (Section
- 3), the indemnity provision (Section 9) or other Section of the License
- conflicts with the conditions of the GPLv2, you may retroactively and
- prospectively choose to deem waived or otherwise exclude such Section(s) of
- the License, but only in their entirety and only with respect to the Combined
- Software.
-
- ==============================================================================
- Software from third parties included in the LLVM Project:
- ==============================================================================
- The LLVM Project contains third party software which is under different license
- terms. All such code will be identified clearly using at least one of two
- mechanisms:
- 1) It will be in a separate directory tree with its own `LICENSE.txt` or
- `LICENSE` file at the top containing the specific license and restrictions
- which apply to that software, or
- 2) It will contain specific license and restriction terms at the top of every
- file.
-
- ==============================================================================
- Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy):
- ==============================================================================
- University of Illinois/NCSA
- Open Source License
-
- Copyright (c) 2003-2019 University of Illinois at Urbana-Champaign.
- All rights reserved.
-
- Developed by:
-
- LLVM Team
-
- University of Illinois at Urbana-Champaign
-
- http://llvm.org
-
- Permission is hereby granted, free of charge, to any person obtaining a copy of
- this software and associated documentation files (the "Software"), to deal with
- the Software without restriction, including without limitation the rights to
- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is furnished to do
- so, subject to the following conditions:
-
- * Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimers.
-
- * Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimers in the
- documentation and/or other materials provided with the distribution.
-
- * Neither the names of the LLVM Team, University of Illinois at
- Urbana-Champaign, nor the names of its contributors may be used to
- endorse or promote products derived from this Software without specific
- prior written permission.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
- SOFTWARE.
-
-* Portions of the FFI code for interacting with the native ABI
- is derived from the Clay programming language, which carries
- the following license.
-
- Copyright (C) 2008-2010 Tachyon Technologies.
- All rights reserved.
-
- Redistribution and use in source and binary forms, with
- or without modification, are permitted provided that the
- following conditions are met:
-
- 1. Redistributions of source code must retain the above
- copyright notice, this list of conditions and the
- following disclaimer.
-
- 2. Redistributions in binary form must reproduce the
- above copyright notice, this list of conditions and
- the following disclaimer in the documentation and/or
- other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR
- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- DEVELOPERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
- USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- OF SUCH DAMAGE.
-
-* Portions of internationalization code use code or data from Unicode, which
- carry the following license:
-
- UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
-
- See Terms of Use <https://www.unicode.org/copyright.html>
- for definitions of Unicode Inc.’s Data Files and Software.
-
- NOTICE TO USER: Carefully read the following legal agreement.
- BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
- DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
- YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
- TERMS AND CONDITIONS OF THIS AGREEMENT.
- IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
- THE DATA FILES OR SOFTWARE.
-
- COPYRIGHT AND PERMISSION NOTICE
-
- Copyright © 1991-2022 Unicode, Inc. All rights reserved.
- Distributed under the Terms of Use in https://www.unicode.org/copyright.html.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of the Unicode data files and any associated documentation
- (the "Data Files") or Unicode software and any associated documentation
- (the "Software") to deal in the Data Files or Software
- without restriction, including without limitation the rights to use,
- copy, modify, merge, publish, distribute, and/or sell copies of
- the Data Files or Software, and to permit persons to whom the Data Files
- or Software are furnished to do so, provided that either
- (a) this copyright and permission notice appear with all copies
- of the Data Files or Software, or
- (b) this copyright and permission notice appear in associated
- Documentation.
-
- THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
- ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT OF THIRD PARTY RIGHTS.
- IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
- NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
- DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- PERFORMANCE OF THE DATA FILES OR SOFTWARE.
-
- Except as contained in this notice, the name of a copyright holder
- shall not be used in advertising or otherwise to promote the sale,
- use or other dealings in these Data Files or Software without prior
- written authorization of the copyright holder.
+<https://thanks.rust-lang.org>
+
+Except as otherwise noted, Rust is licensed under the Apache License, Version
+2.0 <LICENSE-APACHE> or <http://www.apache.org/licenses/LICENSE-2.0> or the MIT
+license <LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+We track licenses for third-party materials in two ways:
+
+* We use [REUSE](https://reuse.software) to track license information for
+ in-tree source files - both those authored by the Rust project and those
+ authored by third parties. See `REUSE.toml`, and our cached output of the
+ `reuse` tool which is committed to `license-metadata.json`.
+* We use `cargo` to track license information for out-of-tree dependencies.
+
+These two sources of information are collected by the tool `generate-copyright`
+into a file called `COPYRIGHT.html`, which is shipped with each binary release
+of Rust. Please refer to that file for detailed information as to the components of
+any given Rust release. We also produce a `COPYRIGHT-library.html` file which only
+covers the subset of source code used in the Rust Standard Library, as opposed
+to the toolchain as a whole.
diff --git a/Cargo.lock b/Cargo.lock
index cafc623c185a6..4adee6166f7b7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
-version = 3
+version = 4
[[package]]
name = "addr2line"
@@ -11,27 +11,17 @@ dependencies = [
"gimli 0.28.1",
]
-[[package]]
-name = "addr2line"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
-dependencies = [
- "compiler_builtins",
- "gimli 0.29.0",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
[[package]]
name = "adler"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
+
+[[package]]
+name = "adler2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
[[package]]
name = "aes"
@@ -44,18 +34,6 @@ dependencies = [
"cpufeatures",
]
-[[package]]
-name = "ahash"
-version = "0.8.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
-dependencies = [
- "cfg-if",
- "once_cell",
- "version_check",
- "zerocopy",
-]
-
[[package]]
name = "aho-corasick"
version = "1.1.3"
@@ -65,34 +43,11 @@ dependencies = [
"memchr",
]
-[[package]]
-name = "alloc"
-version = "0.0.0"
-dependencies = [
- "compiler_builtins",
- "core",
- "rand",
- "rand_xorshift",
-]
-
[[package]]
name = "allocator-api2"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
-
-[[package]]
-name = "ammonia"
-version = "4.0.0"
+version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ab99eae5ee58501ab236beb6f20f6ca39be615267b014899c89b2f0bc18a459"
-dependencies = [
- "html5ever",
- "maplit",
- "once_cell",
- "tendril",
- "url",
-]
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
[[package]]
name = "android-tzdata"
@@ -115,44 +70,25 @@ version = "0.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ccaf7e9dfbb6ab22c82e473cd1a8a7bd313c19a5b7e40970f3d89ef5a5c9e81e"
dependencies = [
- "unicode-width",
+ "unicode-width 0.1.14",
"yansi-term",
]
[[package]]
name = "annotate-snippets"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d9b665789884a7e8fb06c84b295e923b03ca51edbb7d08f91a6a50322ecbfe6"
-dependencies = [
- "anstyle",
- "unicode-width",
-]
-
-[[package]]
-name = "annotate-snippets"
-version = "0.11.4"
+version = "0.11.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24e35ed54e5ea7997c14ed4c70ba043478db1112e98263b3b035907aa197d991"
+checksum = "710e8eae58854cdc1790fcb56cca04d712a17be849eeb81da2a724bf4bae2bc4"
dependencies = [
"anstyle",
- "unicode-width",
-]
-
-[[package]]
-name = "ansi_term"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
-dependencies = [
- "winapi",
+ "unicode-width 0.2.0",
]
[[package]]
name = "anstream"
-version = "0.6.14"
+version = "0.6.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
dependencies = [
"anstyle",
"anstyle-parse",
@@ -165,151 +101,135 @@ dependencies = [
[[package]]
name = "anstyle"
-version = "1.0.7"
+version = "1.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
[[package]]
name = "anstyle-lossy"
-version = "1.1.1"
+version = "1.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fcff6599f06e21b0165c85052ccd6e67dc388ddd1c516a9dc5f55dc8cacf004"
+checksum = "934ff8719effd2023a48cf63e69536c1c3ced9d3895068f6f5cc9a4ff845e59b"
dependencies = [
"anstyle",
]
[[package]]
name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
dependencies = [
"utf8parse",
]
[[package]]
name = "anstyle-query"
-version = "1.1.0"
+version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
name = "anstyle-svg"
-version = "0.1.4"
+version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbbf0bf947d663010f0b4132f28ca08da9151f3b9035fa7578a38de521c1d1aa"
+checksum = "d3607949e9f6de49ea4bafe12f5e4fd73613ebf24795e48587302a8cc0e4bb35"
dependencies = [
"anstream",
"anstyle",
"anstyle-lossy",
"html-escape",
- "unicode-width",
+ "unicode-width 0.2.0",
]
[[package]]
name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
dependencies = [
"anstyle",
- "windows-sys 0.52.0",
+ "once_cell",
+ "windows-sys 0.59.0",
]
[[package]]
name = "anyhow"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
-dependencies = [
- "backtrace",
-]
-
-[[package]]
-name = "ar"
-version = "0.9.0"
+version = "1.0.97"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d67af77d68a931ecd5cbd8a3b5987d63a1d1d1278f7f6a60ae33db485cdebb69"
+checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
[[package]]
name = "ar_archive_writer"
-version = "0.2.0"
+version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0c269894b6fe5e9d7ada0cf69b5bf847ff35bc25fc271f08e1d080fce80339a"
+checksum = "01667f6f40216b9a0b2945e05fed5f1ad0ab6470e69cb9378001e37b1c0668e4"
dependencies = [
- "object 0.32.2",
+ "object 0.36.7",
]
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
[[package]]
name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
[[package]]
name = "askama"
-version = "0.12.1"
+version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b79091df18a97caea757e28cd2d5fda49c6cd4bd01ddffd7ff01ace0c0ad2c28"
+checksum = "9a4e46abb203e00ef226442d452769233142bbfdd79c3941e84c8e61c4112543"
dependencies = [
"askama_derive",
- "askama_escape",
+ "itoa",
+ "percent-encoding",
+ "serde",
+ "serde_json",
]
[[package]]
name = "askama_derive"
-version = "0.12.5"
+version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19fe8d6cb13c4714962c072ea496f3392015f0989b1a2847bb4b2d9effd71d83"
+checksum = "54398906821fd32c728135f7b351f0c7494ab95ae421d41b6f5a020e158f28a6"
dependencies = [
"askama_parser",
"basic-toml",
- "mime",
- "mime_guess",
+ "memchr",
"proc-macro2",
"quote",
+ "rustc-hash 2.1.1",
"serde",
- "syn 2.0.67",
+ "serde_derive",
+ "syn 2.0.100",
]
-[[package]]
-name = "askama_escape"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "619743e34b5ba4e9703bba34deac3427c72507c7159f5fd030aea8cac0cfe341"
-
[[package]]
name = "askama_parser"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acb1161c6b64d1c3d83108213c2a2533a342ac225aabd0bda218278c2ddb00c0"
-dependencies = [
- "nom",
-]
-
-[[package]]
-name = "assert_cmd"
-version = "2.0.14"
+version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed72493ac66d5804837f480ab3766c72bdfab91a65e565fc54fa9e42db0073a8"
+checksum = "cf315ce6524c857bb129ff794935cf6d42c82a6cff60526fe2a63593de4d0d4f"
dependencies = [
- "anstyle",
- "bstr",
- "doc-comment",
- "predicates",
- "predicates-core",
- "predicates-tree",
- "wait-timeout",
+ "memchr",
+ "serde",
+ "serde_derive",
+ "winnow 0.7.6",
]
[[package]]
name = "autocfg"
-version = "1.3.0"
+version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
[[package]]
name = "backtrace"
@@ -317,11 +237,11 @@ version = "0.3.71"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
dependencies = [
- "addr2line 0.21.0",
+ "addr2line",
"cc",
"cfg-if",
"libc",
- "miniz_oxide",
+ "miniz_oxide 0.7.4",
"object 0.32.2",
"rustc-demangle",
]
@@ -334,9 +254,9 @@ checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
[[package]]
name = "basic-toml"
-version = "0.1.9"
+version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "823388e228f614e9558c6804262db37960ec8821856535f5c3f59913140558f8"
+checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a"
dependencies = [
"serde",
]
@@ -352,15 +272,22 @@ dependencies = [
[[package]]
name = "bitflags"
-version = "1.3.2"
+version = "2.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
[[package]]
-name = "bitflags"
-version = "2.5.0"
+name = "blake3"
+version = "1.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "389a099b34312839e16420d499a9cad9650541715937ffbdd40d36f49e77eeb3"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+]
[[package]]
name = "block-buffer"
@@ -373,12 +300,12 @@ dependencies = [
[[package]]
name = "bstr"
-version = "1.6.0"
+version = "1.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
dependencies = [
"memchr",
- "regex-automata 0.3.7",
+ "regex-automata 0.4.9",
"serde",
]
@@ -420,9 +347,9 @@ dependencies = [
[[package]]
name = "bumpalo"
-version = "3.16.0"
+version = "3.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
[[package]]
name = "bytecount"
@@ -430,23 +357,17 @@ version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5ce89b21cab1437276d2650d57e971f9d548a2d9037cc231abdc0562b97498ce"
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
[[package]]
name = "bytes"
-version = "1.6.0"
+version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
[[package]]
name = "camino"
-version = "1.1.7"
+version = "1.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239"
+checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
dependencies = [
"serde",
]
@@ -455,10 +376,10 @@ dependencies = [
name = "cargo-miri"
version = "0.1.0"
dependencies = [
- "cargo_metadata 0.18.1",
+ "cargo_metadata 0.19.2",
"directories",
"rustc-build-sysroot",
- "rustc_tools_util",
+ "rustc_tools_util 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc_version",
"serde",
"serde_json",
@@ -466,39 +387,39 @@ dependencies = [
[[package]]
name = "cargo-platform"
-version = "0.1.8"
+version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
dependencies = [
"serde",
]
[[package]]
name = "cargo_metadata"
-version = "0.15.4"
+version = "0.18.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
+checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037"
dependencies = [
"camino",
"cargo-platform",
"semver",
"serde",
"serde_json",
- "thiserror",
+ "thiserror 1.0.69",
]
[[package]]
name = "cargo_metadata"
-version = "0.18.1"
+version = "0.19.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
dependencies = [
"camino",
"cargo-platform",
"semver",
"serde",
"serde_json",
- "thiserror",
+ "thiserror 2.0.12",
]
[[package]]
@@ -507,44 +428,43 @@ version = "0.1.0"
[[package]]
name = "cc"
-version = "1.0.99"
+version = "1.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c51067fd44124faa7f870b4b1c969379ad32b2ba805aa959430ceaa384f695"
+checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
+dependencies = [
+ "shlex",
+]
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
[[package]]
name = "cfg_aliases"
-version = "0.1.1"
+version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
[[package]]
name = "chrono"
-version = "0.4.38"
+version = "0.4.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "1a7964611d71df112cb1730f2ee67324fcf4d0fc6606acbbe9bfe06df124637c"
dependencies = [
"android-tzdata",
"iana-time-zone",
"num-traits",
"serde",
- "windows-targets 0.52.5",
+ "windows-link",
]
[[package]]
name = "chrono-tz"
-version = "0.9.0"
+version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93698b29de5e97ad0ae26447b344c482a7284c737d9ddc5f9e52b74a336671bb"
+checksum = "efdce149c370f133a071ca8ef6ea340b7b88748ab0810097a9e2976eaa34b4f3"
dependencies = [
"chrono",
"chrono-tz-build",
@@ -553,12 +473,11 @@ dependencies = [
[[package]]
name = "chrono-tz-build"
-version = "0.3.0"
+version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c088aee841df9c3041febbb73934cfc39708749bf96dc827e3359cd39ef11b1"
+checksum = "8f10f8c9340e31fc120ff885fcdb54a0b48e474bbd77cab557f0c30a3e569402"
dependencies = [
"parse-zoneinfo",
- "phf",
"phf_codegen",
]
@@ -574,9 +493,9 @@ dependencies = [
[[package]]
name = "clap"
-version = "4.5.7"
+version = "4.5.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5db83dced34638ad474f39f250d7fea9598bdd239eaced1bdf45d597da0f433f"
+checksum = "2df961d8c8a0d08aa9945718ccf584145eee3f3aa06cddbeac12933781102e04"
dependencies = [
"clap_builder",
"clap_derive",
@@ -594,51 +513,44 @@ dependencies = [
[[package]]
name = "clap_builder"
-version = "4.5.7"
+version = "4.5.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7e204572485eb3fbf28f871612191521df159bc3e15a9f5064c66dba3a8c05f"
+checksum = "132dbda40fb6753878316a489d5a1242a8ef2f0d9e47ba01c951ea8aa7d013a5"
dependencies = [
"anstream",
"anstyle",
"clap_lex",
"strsim",
- "terminal_size",
-]
-
-[[package]]
-name = "clap_complete"
-version = "4.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbca90c87c2a04da41e95d1856e8bcd22f159bdbfa147314d2ce5218057b0e58"
-dependencies = [
- "clap",
]
[[package]]
name = "clap_derive"
-version = "4.5.5"
+version = "4.5.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c780290ccf4fb26629baa7a1081e68ced113f1d3ec302fa5948f1c381ebf06c6"
+checksum = "09176aae279615badda0765c0c0b3f6ed53f4709118af73cf4655d85d1530cd7"
dependencies = [
"heck 0.5.0",
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "clap_lex"
-version = "0.7.1"
+version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70"
+checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
[[package]]
name = "clippy"
-version = "0.1.81"
+version = "0.1.88"
dependencies = [
"anstream",
+ "askama",
+ "cargo_metadata 0.18.1",
"clippy_config",
"clippy_lints",
+ "clippy_lints_internal",
"clippy_utils",
"color-print",
"filetime",
@@ -646,24 +558,27 @@ dependencies = [
"if_chain",
"itertools",
"parking_lot",
+ "pulldown-cmark 0.11.3",
"quote",
"regex",
- "rustc_tools_util",
+ "rustc_tools_util 0.4.2",
"serde",
- "syn 2.0.67",
+ "serde_json",
+ "syn 2.0.100",
"tempfile",
"termize",
"tokio",
"toml 0.7.8",
- "ui_test 0.23.0",
+ "ui_test",
"walkdir",
]
[[package]]
name = "clippy_config"
-version = "0.1.81"
+version = "0.1.88"
dependencies = [
- "rustc-semver",
+ "clippy_utils",
+ "itertools",
"serde",
"toml 0.7.8",
"walkdir",
@@ -674,32 +589,28 @@ name = "clippy_dev"
version = "0.0.1"
dependencies = [
"aho-corasick",
+ "chrono",
"clap",
"indoc",
"itertools",
- "opener 0.6.1",
+ "opener",
"shell-escape",
"walkdir",
]
[[package]]
name = "clippy_lints"
-version = "0.1.81"
+version = "0.1.88"
dependencies = [
"arrayvec",
"cargo_metadata 0.18.1",
"clippy_config",
"clippy_utils",
- "declare_clippy_lint",
"itertools",
"quine-mc_cluskey",
- "regex",
- "regex-syntax 0.8.4",
- "rustc-semver",
+ "regex-syntax 0.8.5",
"semver",
"serde",
- "serde_json",
- "tempfile",
"toml 0.7.8",
"unicode-normalization",
"unicode-script",
@@ -707,15 +618,24 @@ dependencies = [
"walkdir",
]
+[[package]]
+name = "clippy_lints_internal"
+version = "0.0.1"
+dependencies = [
+ "clippy_config",
+ "clippy_utils",
+ "regex",
+ "rustc-semver",
+]
+
[[package]]
name = "clippy_utils"
-version = "0.1.81"
+version = "0.1.88"
dependencies = [
"arrayvec",
- "clippy_config",
"itertools",
- "rustc-semver",
"rustc_apfloat",
+ "serde",
]
[[package]]
@@ -745,23 +665,23 @@ dependencies = [
[[package]]
name = "color-print"
-version = "0.3.6"
+version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ee543c60ff3888934877a5671f45494dd27ed4ba25c6670b9a7576b7ed7a8c0"
+checksum = "3aa954171903797d5623e047d9ab69d91b493657917bdfb8c2c80ecaf9cdb6f4"
dependencies = [
"color-print-proc-macro",
]
[[package]]
name = "color-print-proc-macro"
-version = "0.3.6"
+version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77ff1a80c5f3cb1ca7c06ffdd71b6a6dd6d8f896c42141fbd43f50ed28dcdb93"
+checksum = "692186b5ebe54007e45a59aea47ece9eb4108e141326c304cdc91699a7118a22"
dependencies = [
"nom",
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
@@ -778,18 +698,18 @@ dependencies = [
[[package]]
name = "colorchoice"
-version = "1.0.1"
+version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
[[package]]
name = "colored"
-version = "2.1.0"
+version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8"
+checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
dependencies = [
"lazy_static",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -798,23 +718,13 @@ version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55b672471b4e9f9e95499ea597ff64941a309b2cdbffcc46f2cc5e2d971fd335"
-[[package]]
-name = "compiler_builtins"
-version = "0.1.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f11973008a8cf741fe6d22f339eba21fd0ca81e2760a769ba8243ed6c21edd7e"
-dependencies = [
- "cc",
- "rustc-std-workspace-core",
-]
-
[[package]]
name = "compiletest"
version = "0.0.0"
dependencies = [
"anstyle-svg",
- "anyhow",
"build_helper",
+ "camino",
"colored",
"diff",
"getopts",
@@ -824,8 +734,10 @@ dependencies = [
"libc",
"miow",
"miropt-test-tools",
+ "rayon",
"regex",
- "rustfix 0.8.1",
+ "rustfix",
+ "semver",
"serde",
"serde_json",
"tracing",
@@ -837,30 +749,28 @@ dependencies = [
[[package]]
name = "console"
-version = "0.15.8"
+version = "0.15.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
dependencies = [
"encode_unicode",
- "lazy_static",
"libc",
- "unicode-width",
- "windows-sys 0.52.0",
+ "once_cell",
+ "unicode-width 0.2.0",
+ "windows-sys 0.59.0",
]
[[package]]
-name = "core"
-version = "0.0.0"
-dependencies = [
- "rand",
- "rand_xorshift",
-]
+name = "constant_time_eq"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
[[package]]
name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
[[package]]
name = "coverage-dump"
@@ -869,16 +779,16 @@ dependencies = [
"anyhow",
"leb128",
"md-5",
- "miniz_oxide",
+ "miniz_oxide 0.7.4",
"regex",
"rustc-demangle",
]
[[package]]
name = "cpufeatures"
-version = "0.2.12"
+version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
dependencies = [
"libc",
]
@@ -894,18 +804,18 @@ dependencies = [
[[package]]
name = "crossbeam-channel"
-version = "0.5.13"
+version = "0.5.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
dependencies = [
"crossbeam-utils",
]
[[package]]
name = "crossbeam-deque"
-version = "0.8.5"
+version = "0.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
dependencies = [
"crossbeam-epoch",
"crossbeam-utils",
@@ -922,9 +832,9 @@ dependencies = [
[[package]]
name = "crossbeam-utils"
-version = "0.8.20"
+version = "0.8.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
[[package]]
name = "crypto-common"
@@ -938,19 +848,19 @@ dependencies = [
[[package]]
name = "ctrlc"
-version = "3.4.4"
+version = "3.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "672465ae37dc1bc6380a6547a8883d5dd397b0f1faaad4f265726cc7042a5345"
+checksum = "697b5419f348fd5ae2478e8018cb016c00a5881c7f46c717de98ffd135a5651c"
dependencies = [
"nix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
name = "curl"
-version = "0.4.46"
+version = "0.4.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e2161dd6eba090ff1594084e95fd67aeccf04382ffea77999ea94ed42ec67b6"
+checksum = "d9fb4d13a1be2b58f14d60adba57c9834b78c62fd86c3e76a148f732686e9265"
dependencies = [
"curl-sys",
"libc",
@@ -963,9 +873,9 @@ dependencies = [
[[package]]
name = "curl-sys"
-version = "0.4.72+curl-8.6.0"
+version = "0.4.80+curl-8.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29cbdc8314c447d11e8fd156dcdd031d9e02a7a976163e396b548c03153bc9ea"
+checksum = "55f7df2eac63200c3ab25bde3b2268ef2ee56af3d238e76d61f01c3c49bff734"
dependencies = [
"cc",
"libc",
@@ -978,9 +888,9 @@ dependencies = [
[[package]]
name = "darling"
-version = "0.20.9"
+version = "0.20.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
dependencies = [
"darling_core",
"darling_macro",
@@ -988,27 +898,27 @@ dependencies = [
[[package]]
name = "darling_core"
-version = "0.20.9"
+version = "0.20.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
dependencies = [
"fnv",
"ident_case",
"proc-macro2",
"quote",
"strsim",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "darling_macro"
-version = "0.20.9"
+version = "0.20.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
dependencies = [
"darling_core",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
@@ -1029,74 +939,45 @@ dependencies = [
]
[[package]]
-name = "declare_clippy_lint"
-version = "0.1.81"
-dependencies = [
- "itertools",
- "quote",
- "syn 2.0.67",
-]
-
-[[package]]
-name = "deranged"
-version = "0.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
-dependencies = [
- "powerfmt",
-]
-
-[[package]]
-name = "derivative"
-version = "2.2.0"
+name = "derive-where"
+version = "1.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+checksum = "62d671cc41a825ebabc75757b62d3d168c577f9149b2d49ece1dad1f72119d25"
dependencies = [
"proc-macro2",
"quote",
- "syn 1.0.109",
+ "syn 2.0.100",
]
[[package]]
name = "derive_builder"
-version = "0.20.0"
+version = "0.20.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0350b5cb0331628a5916d6c5c0b72e97393b8b6b03b47a9284f4e7f5a405ffd7"
+checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
dependencies = [
"derive_builder_macro",
]
[[package]]
name = "derive_builder_core"
-version = "0.20.0"
+version = "0.20.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d48cda787f839151732d396ac69e3473923d54312c070ee21e9effcaa8ca0b1d"
+checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
dependencies = [
"darling",
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "derive_builder_macro"
-version = "0.20.0"
+version = "0.20.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "206868b8242f27cecce124c19fd88157fbd0dd334df2587f36417bafbc85097b"
+checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
dependencies = [
"derive_builder_core",
- "syn 2.0.67",
-]
-
-[[package]]
-name = "derive_more"
-version = "0.99.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
@@ -1108,7 +989,7 @@ dependencies = [
"darling",
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
@@ -1117,12 +998,6 @@ version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
-[[package]]
-name = "difflib"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
-
[[package]]
name = "digest"
version = "0.10.7"
@@ -1135,11 +1010,11 @@ dependencies = [
[[package]]
name = "directories"
-version = "5.0.1"
+version = "6.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a49173b84e034382284f27f1af4dcbbd231ffa358c0fe316541a7337f376a35"
+checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
dependencies = [
- "dirs-sys",
+ "dirs-sys 0.5.0",
]
[[package]]
@@ -1148,7 +1023,7 @@ version = "5.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
dependencies = [
- "dirs-sys",
+ "dirs-sys 0.4.1",
]
[[package]]
@@ -1169,10 +1044,22 @@ checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
dependencies = [
"libc",
"option-ext",
- "redox_users",
+ "redox_users 0.4.6",
"windows-sys 0.48.0",
]
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users 0.5.0",
+ "windows-sys 0.59.0",
+]
+
[[package]]
name = "dirs-sys-next"
version = "0.1.2"
@@ -1180,7 +1067,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
dependencies = [
"libc",
- "redox_users",
+ "redox_users 0.4.6",
"winapi",
]
@@ -1192,81 +1079,50 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "dissimilar"
-version = "1.0.9"
+version = "1.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59f8e79d1fbf76bdfbde321e902714bf6c49df88a7dda6fc682fc2979226962d"
+checksum = "8975ffdaa0ef3661bfe02dbdcc06c9f829dfafe6a3c474de366a8d5e44276921"
[[package]]
-name = "dlmalloc"
-version = "0.2.6"
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "elsa"
+version = "1.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3264b043b8e977326c1ee9e723da2c1f8d09a99df52cacf00b4dbce5ac54414d"
+checksum = "9abf33c656a7256451ebb7d0082c5a471820c31269e49d807c538c252352186e"
dependencies = [
- "cfg-if",
- "compiler_builtins",
- "libc",
- "rustc-std-workspace-core",
- "windows-sys 0.52.0",
+ "stable_deref_trait",
]
[[package]]
-name = "doc-comment"
-version = "0.3.3"
+name = "ena"
+version = "0.14.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+checksum = "3d248bdd43ce613d87415282f69b9bb99d947d290b10962dd6c56233312c2ad5"
+dependencies = [
+ "log",
+]
[[package]]
-name = "either"
-version = "1.12.0"
+name = "encode_unicode"
+version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b"
-
-[[package]]
-name = "elasticlunr-rs"
-version = "3.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41e83863a500656dfa214fee6682de9c5b9f03de6860fec531235ed2ae9f6571"
-dependencies = [
- "regex",
- "serde",
- "serde_derive",
- "serde_json",
-]
-
-[[package]]
-name = "elsa"
-version = "1.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "848fe615fbb0a74d9ae68dcaa510106d32e37d9416207bbea4bd008bd89c47ed"
-dependencies = [
- "stable_deref_trait",
-]
-
-[[package]]
-name = "ena"
-version = "0.14.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d248bdd43ce613d87415282f69b9bb99d947d290b10962dd6c56233312c2ad5"
-dependencies = [
- "log",
-]
-
-[[package]]
-name = "encode_unicode"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
[[package]]
name = "env_filter"
-version = "0.1.0"
+version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a009aa4810eb158359dda09d0c87378e4bbb89b5a801f016885a4707ba24f7ea"
+checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
dependencies = [
"log",
"regex",
@@ -1274,45 +1130,38 @@ dependencies = [
[[package]]
name = "env_logger"
-version = "0.11.3"
+version = "0.11.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b35839ba51819680ba087cd351788c9a3c476841207e0b8cee0b04722343b9"
+checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
dependencies = [
"anstream",
"anstyle",
"env_filter",
- "humantime",
+ "jiff",
"log",
]
[[package]]
name = "equivalent"
-version = "1.0.1"
+version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
[[package]]
name = "errno"
-version = "0.3.9"
+version = "0.3.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
dependencies = [
"libc",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "error_index_generator"
-version = "0.0.0"
-dependencies = [
- "mdbook",
+ "windows-sys 0.59.0",
]
[[package]]
name = "expect-test"
-version = "1.5.0"
+version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e0be0a561335815e06dab7c62e50353134c796e7a6155402a64bcff66b6a5e0"
+checksum = "63af43ff4431e848fb47472a920f14fa71c24de13255a5692e93d4e90302acb0"
dependencies = [
"dissimilar",
"once_cell",
@@ -1336,40 +1185,41 @@ checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
[[package]]
name = "fastrand"
-version = "2.1.0"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
[[package]]
-name = "field-offset"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
+name = "features-status-dump"
+version = "0.1.0"
dependencies = [
- "memoffset",
- "rustc_version",
+ "anyhow",
+ "clap",
+ "serde",
+ "serde_json",
+ "tidy",
]
[[package]]
name = "filetime"
-version = "0.2.23"
+version = "0.2.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
+checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
dependencies = [
"cfg-if",
"libc",
- "redox_syscall 0.4.1",
- "windows-sys 0.52.0",
+ "libredox",
+ "windows-sys 0.59.0",
]
[[package]]
name = "flate2"
-version = "1.0.30"
+version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
+checksum = "7ced92e76e966ca2fd84c8f7aa01a4aea65b0eb6648d72f7c8f3e2764a67fece"
dependencies = [
"crc32fast",
- "miniz_oxide",
+ "miniz_oxide 0.8.8",
]
[[package]]
@@ -1382,7 +1232,7 @@ dependencies = [
"fluent-syntax",
"intl-memoizer",
"intl_pluralrules",
- "rustc-hash",
+ "rustc-hash 1.1.0",
"self_cell 0.10.3",
"smallvec",
"unic-langid",
@@ -1403,7 +1253,7 @@ version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a530c4694a6a8d528794ee9bbd8ba0122e779629ac908d15ad5a7ae7763a33d"
dependencies = [
- "thiserror",
+ "thiserror 1.0.69",
]
[[package]]
@@ -1412,6 +1262,12 @@ version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
[[package]]
name = "form_urlencoded"
version = "1.2.1"
@@ -1421,16 +1277,6 @@ dependencies = [
"percent-encoding",
]
-[[package]]
-name = "fortanix-sgx-abi"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57cafc2274c10fab234f176b25903ce17e690fca7597090d50880e047a0389c5"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
-
[[package]]
name = "fs-err"
version = "2.11.0"
@@ -1458,9 +1304,9 @@ dependencies = [
[[package]]
name = "futures"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
dependencies = [
"futures-channel",
"futures-core",
@@ -1473,9 +1319,9 @@ dependencies = [
[[package]]
name = "futures-channel"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
dependencies = [
"futures-core",
"futures-sink",
@@ -1483,15 +1329,15 @@ dependencies = [
[[package]]
name = "futures-core"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
[[package]]
name = "futures-executor"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
dependencies = [
"futures-core",
"futures-task",
@@ -1500,38 +1346,38 @@ dependencies = [
[[package]]
name = "futures-io"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
[[package]]
name = "futures-macro"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "futures-sink"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
[[package]]
name = "futures-task"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
[[package]]
name = "futures-util"
-version = "0.3.30"
+version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
dependencies = [
"futures-channel",
"futures-core",
@@ -1550,8 +1396,11 @@ name = "generate-copyright"
version = "0.1.0"
dependencies = [
"anyhow",
+ "askama",
+ "cargo_metadata 0.18.1",
"serde",
"serde_json",
+ "thiserror 1.0.69",
]
[[package]]
@@ -1577,9 +1426,7 @@ version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
dependencies = [
- "rustc-std-workspace-core",
- "rustc-std-workspace-std",
- "unicode-width",
+ "unicode-width 0.1.14",
]
[[package]]
@@ -1590,7 +1437,19 @@ checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
dependencies = [
"cfg-if",
"libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
]
[[package]]
@@ -1598,43 +1457,35 @@ name = "gimli"
version = "0.28.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
-dependencies = [
- "compiler_builtins",
- "fallible-iterator",
- "indexmap",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
- "stable_deref_trait",
-]
[[package]]
name = "gimli"
-version = "0.29.0"
+version = "0.31.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
+ "fallible-iterator",
+ "indexmap",
+ "stable_deref_trait",
]
[[package]]
name = "glob"
-version = "0.3.1"
+version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
[[package]]
name = "globset"
-version = "0.4.13"
+version = "0.4.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "759c97c1e17c55525b57192c06a267cda0ac5210b222d6b82189a2338fa1c13d"
+checksum = "54a1028dfc5f5df5da8a56a73e6c153c9a9708ec57232470703592a3f18e49f5"
dependencies = [
"aho-corasick",
"bstr",
- "fnv",
"log",
- "regex",
+ "regex-automata 0.4.9",
+ "regex-syntax 0.8.5",
]
[[package]]
@@ -1646,31 +1497,16 @@ dependencies = [
"serde",
]
-[[package]]
-name = "handlebars"
-version = "5.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d08485b96a0e6393e9e4d1b8d48cf74ad6c063cd905eb33f42c1ce3f0377539b"
-dependencies = [
- "log",
- "pest",
- "pest_derive",
- "serde",
- "serde_json",
- "thiserror",
-]
-
[[package]]
name = "hashbrown"
-version = "0.14.5"
+version = "0.15.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+checksum = "84b26c544d002229e640969970a2e74021aadf6e2f96372b9c58eff97de08eb3"
dependencies = [
- "ahash",
"allocator-api2",
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
+ "equivalent",
+ "foldhash",
+ "serde",
]
[[package]]
@@ -1691,17 +1527,6 @@ version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
-[[package]]
-name = "hermit-abi"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
[[package]]
name = "hex"
version = "0.4.3"
@@ -1710,11 +1535,11 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
[[package]]
name = "home"
-version = "0.5.9"
+version = "0.5.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -1736,16 +1561,14 @@ dependencies = [
[[package]]
name = "html5ever"
-version = "0.27.0"
+version = "0.29.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c13771afe0e6e846f1e67d038d4cb29998a6779f93c809212e4e9c32efd244d4"
+checksum = "3b7410cae13cbc75623c98ac4cbfd1f0bedddf3227afc24f370cf0f50a44a11c"
dependencies = [
"log",
"mac",
"markup5ever",
- "proc-macro2",
- "quote",
- "syn 2.0.67",
+ "match_token",
]
[[package]]
@@ -1759,22 +1582,23 @@ dependencies = [
[[package]]
name = "humantime"
-version = "2.1.0"
+version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+checksum = "9b112acc8b3adf4b107a8ec20977da0273a8c386765a3ec0229bd500a1443f9f"
[[package]]
name = "iana-time-zone"
-version = "0.1.60"
+version = "0.1.63"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
dependencies = [
"android_system_properties",
"core-foundation-sys",
"iana-time-zone-haiku",
"js-sys",
+ "log",
"wasm-bindgen",
- "windows-core",
+ "windows-core 0.61.0",
]
[[package]]
@@ -1786,6 +1610,18 @@ dependencies = [
"cc",
]
+[[package]]
+name = "icu_collections"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
[[package]]
name = "icu_list"
version = "1.5.0"
@@ -1802,9 +1638,9 @@ dependencies = [
[[package]]
name = "icu_list_data"
-version = "1.5.0"
+version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1825170d2c6679cb20dbd96a589d034e49f698aed9a2ef4fafc9a0101ed298f"
+checksum = "52b1a7fbdbf3958f1be8354cb59ac73f165b7b7082d447ff2090355c9a069120"
[[package]]
name = "icu_locid"
@@ -1835,9 +1671,54 @@ dependencies = [
[[package]]
name = "icu_locid_transform_data"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7515e6d781098bf9f7205ab3fc7e9709d34554ae0b21ddbcb5febfa4bc7df11d"
+
+[[package]]
+name = "icu_normalizer"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
+checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e8338228bdc8ab83303f16b797e177953730f601a96c25d10cb3ab0daa0cb7"
+
+[[package]]
+name = "icu_properties"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locid_transform",
+ "icu_properties_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85fb8799753b75aee8d2a21d7c14d9f38921b54b3dbda10f5a3c7a7b82dba5e2"
[[package]]
name = "icu_provider"
@@ -1877,9 +1758,15 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
+[[package]]
+name = "id-arena"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"
+
[[package]]
name = "ident_case"
version = "1.0.1"
@@ -1888,12 +1775,23 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
[[package]]
name = "idna"
-version = "0.5.0"
+version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
]
[[package]]
@@ -1904,17 +1802,16 @@ checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
[[package]]
name = "ignore"
-version = "0.4.20"
+version = "0.4.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbe7873dab538a9a44ad79ede1faf5f30d49f9a5c883ddbab48bce81b64b7492"
+checksum = "6d89fd380afde86567dfba715db065673989d6253f42b88179abd3eae47bda4b"
dependencies = [
+ "crossbeam-deque",
"globset",
- "lazy_static",
"log",
"memchr",
- "regex",
+ "regex-automata 0.4.9",
"same-file",
- "thread_local",
"walkdir",
"winapi-util",
]
@@ -1927,27 +1824,26 @@ checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683"
[[package]]
name = "indexmap"
-version = "2.2.6"
+version = "2.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
dependencies = [
"equivalent",
"hashbrown",
- "rustc-rayon",
"serde",
]
[[package]]
name = "indicatif"
-version = "0.17.8"
+version = "0.17.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3"
+checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"
dependencies = [
"console",
- "instant",
"number_prefix",
"portable-atomic",
- "unicode-width",
+ "unicode-width 0.2.0",
+ "web-time",
]
[[package]]
@@ -1958,9 +1854,9 @@ checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306"
[[package]]
name = "inout"
-version = "0.1.3"
+version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
dependencies = [
"generic-array",
]
@@ -1978,15 +1874,6 @@ dependencies = [
"xz2",
]
-[[package]]
-name = "instant"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
-dependencies = [
- "cfg-if",
-]
-
[[package]]
name = "intl-memoizer"
version = "0.5.2"
@@ -2008,9 +1895,9 @@ dependencies = [
[[package]]
name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
[[package]]
name = "itertools"
@@ -2023,35 +1910,51 @@ dependencies = [
[[package]]
name = "itoa"
-version = "1.0.11"
+version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
[[package]]
-name = "jemalloc-sys"
-version = "0.5.4+5.3.0-patched"
+name = "jiff"
+version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac6c1946e1cea1788cbfde01c993b52a10e2da07f4bac608228d1bed20bfebf2"
+checksum = "1f33145a5cbea837164362c7bd596106eb7c5198f97d1ba6f6ebb3223952e488"
dependencies = [
- "cc",
- "libc",
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43ce13c40ec6956157a3635d97a1ee2df323b263f09ea14165131289cb0f5c19"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
]
[[package]]
name = "jobserver"
-version = "0.1.31"
+version = "0.1.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
dependencies = [
+ "getrandom 0.3.2",
"libc",
]
[[package]]
name = "js-sys"
-version = "0.3.69"
+version = "0.3.77"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
dependencies = [
+ "once_cell",
"wasm-bindgen",
]
@@ -2061,7 +1964,7 @@ version = "0.1.0"
dependencies = [
"fs-err",
"getopts",
- "jsonpath_lib",
+ "jsonpath-rust",
"regex",
"serde_json",
"shlex",
@@ -2074,21 +1977,23 @@ dependencies = [
"anyhow",
"clap",
"fs-err",
- "rustc-hash",
+ "rustc-hash 2.1.1",
"rustdoc-json-types",
"serde",
"serde_json",
]
[[package]]
-name = "jsonpath_lib"
-version = "0.3.0"
+name = "jsonpath-rust"
+version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaa63191d68230cccb81c5aa23abd53ed64d83337cacbb25a7b8c7979523774f"
+checksum = "6a37c2c87b8d16e788ce359660fead0ea5f4ed29ff400d55be74a4e01d1817d9"
dependencies = [
- "log",
- "serde",
+ "pest",
+ "pest_derive",
+ "regex",
"serde_json",
+ "thiserror 2.0.12",
]
[[package]]
@@ -2103,20 +2008,29 @@ version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
[[package]]
name = "levenshtein"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "db13adb97ab515a3691f56e4dbab09283d0b86cb45abd991d8634a9d6f501760"
+[[package]]
+name = "lexopt"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa0e2a1fcbe2f6be6c42e342259976206b383122fc152e872795338b5a3f3a7"
+
[[package]]
name = "libc"
-version = "0.2.155"
+version = "0.2.172"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
-dependencies = [
- "rustc-std-workspace-core",
-]
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
[[package]]
name = "libdbus-sys"
@@ -2130,9 +2044,9 @@ dependencies = [
[[package]]
name = "libffi"
-version = "3.2.0"
+version = "4.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce826c243048e3d5cec441799724de52e2d42f820468431fc3fceee2341871e2"
+checksum = "4a9434b6fc77375fb624698d5f8c49d7e80b10d59eb1219afda27d1f824d4074"
dependencies = [
"libc",
"libffi-sys",
@@ -2140,28 +2054,28 @@ dependencies = [
[[package]]
name = "libffi-sys"
-version = "2.3.0"
+version = "3.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f36115160c57e8529781b4183c2bb51fdc1f6d6d1ed345591d84be7703befb3c"
+checksum = "ead36a2496acfc8edd6cc32352110e9478ac5b9b5f5b9856ebd3d28019addb84"
dependencies = [
"cc",
]
[[package]]
name = "libloading"
-version = "0.8.3"
+version = "0.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
+checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
dependencies = [
"cfg-if",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
]
[[package]]
name = "libm"
-version = "0.2.8"
+version = "0.2.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
[[package]]
name = "libredox"
@@ -2169,15 +2083,16 @@ version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
"libc",
+ "redox_syscall",
]
[[package]]
name = "libz-sys"
-version = "1.1.18"
+version = "1.1.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c15da26e5af7e25c90b37a2d75cdbf940cf4a55316de9d84c679c9b8bfabf82e"
+checksum = "8b70e7a7df205e92a1a4cd9aaae7898dac0aa555503cc0a649494d0d60e7651d"
dependencies = [
"cc",
"libc",
@@ -2185,21 +2100,6 @@ dependencies = [
"vcpkg",
]
-[[package]]
-name = "line-wrap"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd1bc4d24ad230d21fb898d1116b1801d7adfc449d42026475862ab48b11e70e"
-
-[[package]]
-name = "linereader"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d921fea6860357575519aca014c6e22470585accdd543b370c404a8a72d0dd1d"
-dependencies = [
- "memchr",
-]
-
[[package]]
name = "linkchecker"
version = "0.1.0"
@@ -2208,12 +2108,6 @@ dependencies = [
"regex",
]
-[[package]]
-name = "linked-hash-map"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
-
[[package]]
name = "lint-docs"
version = "0.1.0"
@@ -2225,15 +2119,15 @@ dependencies = [
[[package]]
name = "linux-raw-sys"
-version = "0.4.14"
+version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
[[package]]
name = "litemap"
-version = "0.7.3"
+version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "643cb0b8d4fcc284004d5fd0d67ccf61dfffadb7f75e1e71bc420f4688a3a704"
+checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856"
[[package]]
name = "lld-wrapper"
@@ -2245,7 +2139,7 @@ version = "0.0.1"
dependencies = [
"anyhow",
"clap",
- "thiserror",
+ "thiserror 1.0.69",
"tracing",
"tracing-subscriber",
]
@@ -2262,9 +2156,9 @@ dependencies = [
[[package]]
name = "log"
-version = "0.4.21"
+version = "0.4.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
[[package]]
name = "lzma-sys"
@@ -2283,17 +2177,11 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
-[[package]]
-name = "maplit"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
-
[[package]]
name = "markup5ever"
-version = "0.12.1"
+version = "0.14.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16ce3abbeba692c8b8441d036ef91aea6df8da2c6b6e21c7e14d3c18e526be45"
+checksum = "c7a7213d12e1864c0f002f52c2923d4556935a43dec5e71355c2760e0f6e7a18"
dependencies = [
"log",
"phf",
@@ -2303,6 +2191,17 @@ dependencies = [
"tendril",
]
+[[package]]
+name = "match_token"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88a9689d8d44bf9964484516275f5cd4c9b59457a6940c1d5d0ecbb94510a36b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
+]
+
[[package]]
name = "matchers"
version = "0.1.0"
@@ -2323,102 +2222,24 @@ dependencies = [
]
[[package]]
-name = "mdbook"
-version = "0.4.40"
+name = "measureme"
+version = "12.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b45a38e19bd200220ef07c892b0157ad3d2365e5b5a267ca01ad12182491eea5"
-dependencies = [
- "ammonia",
- "anyhow",
- "chrono",
- "clap",
- "clap_complete",
- "elasticlunr-rs",
- "env_logger",
- "handlebars",
- "log",
- "memchr",
- "once_cell",
- "opener 0.7.1",
- "pulldown-cmark 0.10.3",
- "regex",
- "serde",
- "serde_json",
- "shlex",
- "tempfile",
- "toml 0.5.11",
- "topological-sort",
-]
-
-[[package]]
-name = "mdbook-i18n-helpers"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c8f972ab672d366c3dad77ea5aa7bae68db2d25fbeb889849f97469d7b658e4"
-dependencies = [
- "anyhow",
- "chrono",
- "mdbook",
- "polib",
- "pulldown-cmark 0.10.3",
- "pulldown-cmark-to-cmark",
- "regex",
- "semver",
- "serde_json",
- "syntect",
- "textwrap",
-]
-
-[[package]]
-name = "mdbook-trpl-listing"
-version = "0.1.0"
-dependencies = [
- "assert_cmd",
- "clap",
- "mdbook",
- "pulldown-cmark 0.10.3",
- "pulldown-cmark-to-cmark",
- "serde_json",
- "thiserror",
- "toml 0.8.14",
- "xmlparser",
-]
-
-[[package]]
-name = "mdbook-trpl-note"
-version = "1.0.0"
-dependencies = [
- "assert_cmd",
- "clap",
- "mdbook",
- "pulldown-cmark 0.10.3",
- "pulldown-cmark-to-cmark",
- "serde_json",
-]
-
-[[package]]
-name = "measureme"
-version = "11.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfa4a40f09af7aa6faef38285402a78847d0d72bf8827006cd2a332e1e6e4a8d"
+checksum = "570a507d8948a66a97f42cbbaf8a6bb9516a51017d4ee949502ad7a10a864395"
dependencies = [
"log",
"memmap2",
"parking_lot",
"perf-event-open-sys",
- "rustc-hash",
+ "rustc-hash 1.1.0",
"smallvec",
]
[[package]]
name = "memchr"
-version = "2.5.0"
+version = "2.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
[[package]]
name = "memmap2"
@@ -2429,36 +2250,11 @@ dependencies = [
"libc",
]
-[[package]]
-name = "memoffset"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "mime"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
-
-[[package]]
-name = "mime_guess"
-version = "2.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
-dependencies = [
- "mime",
- "unicase",
-]
-
[[package]]
name = "minifier"
-version = "0.3.0"
+version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95bbbf96b9ac3482c2a25450b67a15ed851319bc5fabf3b40742ea9066e84282"
+checksum = "9bfdc64e2f805f3d12965f10522000bae36e88d2cfea44112331f467d4f4bf68"
[[package]]
name = "minimal-lexical"
@@ -2473,9 +2269,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
dependencies = [
"adler",
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a"
+dependencies = [
+ "adler2",
]
[[package]]
@@ -2492,23 +2294,24 @@ name = "miri"
version = "0.1.0"
dependencies = [
"aes",
+ "bitflags",
"chrono",
"chrono-tz",
"colored",
- "ctrlc",
"directories",
- "getrandom",
- "jemalloc-sys",
+ "getrandom 0.3.2",
"libc",
"libffi",
"libloading",
"measureme",
- "rand",
+ "rand 0.9.0",
"regex",
"rustc_version",
"smallvec",
"tempfile",
- "ui_test 0.21.2",
+ "tikv-jemalloc-sys",
+ "ui_test",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -2523,11 +2326,11 @@ checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
[[package]]
name = "nix"
-version = "0.28.0"
+version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
"cfg-if",
"cfg_aliases",
"libc",
@@ -2545,46 +2348,95 @@ dependencies = [
[[package]]
name = "normpath"
-version = "1.2.0"
+version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5831952a9476f2fed74b77d74182fa5ddc4d21c72ec45a333b250e3ed0272804"
+checksum = "c8911957c4b1549ac0dc74e30db9c8b0e66ddcd6d7acc33098f4c63a64a6d7ed"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
-name = "ntapi"
-version = "0.4.1"
+name = "nu-ansi-term"
+version = "0.46.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
dependencies = [
+ "overload",
"winapi",
]
[[package]]
name = "nu-ansi-term"
-version = "0.46.0"
+version = "0.50.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399"
dependencies = [
- "overload",
- "winapi",
+ "windows-sys 0.52.0",
]
[[package]]
-name = "nu-ansi-term"
-version = "0.50.0"
+name = "num"
+version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd2800e1520bdc966782168a627aa5d1ad92e33b984bf7c7615d31280c83ff14"
+checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
dependencies = [
- "windows-sys 0.48.0",
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
]
[[package]]
-name = "num-conv"
-version = "0.1.0"
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
[[package]]
name = "num-traits"
@@ -2601,7 +2453,7 @@ version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
dependencies = [
- "hermit-abi 0.3.9",
+ "hermit-abi",
"libc",
]
@@ -2612,41 +2464,46 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
[[package]]
-name = "object"
-version = "0.32.2"
+name = "objc2-core-foundation"
+version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+checksum = "1c10c2894a6fed806ade6027bcd50662746363a9589d3ec9d9bef30a4e4bc166"
dependencies = [
- "crc32fast",
- "flate2",
- "hashbrown",
- "indexmap",
- "memchr",
- "ruzstd 0.5.0",
- "wasmparser",
+ "bitflags",
+]
+
+[[package]]
+name = "objc2-io-kit"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71c1c64d6120e51cd86033f67176b1cb66780c2efe34dec55176f77befd93c0a"
+dependencies = [
+ "libc",
+ "objc2-core-foundation",
]
[[package]]
name = "object"
-version = "0.34.0"
+version = "0.32.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7090bae93f8585aad99e595b7073c5de9ba89fbd6b4e9f0cdd7a10177273ac8"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
dependencies = [
- "flate2",
"memchr",
- "ruzstd 0.6.0",
]
[[package]]
name = "object"
-version = "0.36.0"
+version = "0.36.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "576dfe1fc8f9df304abb159d767a29d0476f7750fbf8aa7ad07816004a207434"
+checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
dependencies = [
- "compiler_builtins",
+ "crc32fast",
+ "flate2",
+ "hashbrown",
+ "indexmap",
"memchr",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
+ "ruzstd",
+ "wasmparser 0.222.1",
]
[[package]]
@@ -2660,66 +2517,33 @@ dependencies = [
[[package]]
name = "once_cell"
-version = "1.19.0"
+version = "1.21.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
-
-[[package]]
-name = "onig"
-version = "6.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c4b31c8722ad9171c6d77d3557db078cab2bd50afcc9d09c8b315c59df8ca4f"
-dependencies = [
- "bitflags 1.3.2",
- "libc",
- "once_cell",
- "onig_sys",
-]
-
-[[package]]
-name = "onig_sys"
-version = "69.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b829e3d7e9cc74c7e315ee8edb185bf4190da5acde74afd7fc59c35b1f086e7"
-dependencies = [
- "cc",
- "pkg-config",
-]
-
-[[package]]
-name = "opener"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c62dcb6174f9cb326eac248f07e955d5d559c272730b6c03e396b443b562788"
-dependencies = [
- "bstr",
- "normpath",
- "winapi",
-]
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
[[package]]
name = "opener"
-version = "0.7.1"
+version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8df34be653210fbe9ffaff41d3b92721c56ce82dfee58ee684f9afb5e3a90c0"
+checksum = "d0812e5e4df08da354c851a3376fead46db31c2214f849d3de356d774d057681"
dependencies = [
"bstr",
"dbus",
"normpath",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
name = "openssl-probe"
-version = "0.1.5"
+version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
[[package]]
name = "openssl-sys"
-version = "0.9.102"
+version = "0.9.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2"
+checksum = "8288979acd84749c744a9014b4382d42b8f7b2592847b5afb2ed29e5d16ede07"
dependencies = [
"cc",
"libc",
@@ -2775,30 +2599,7 @@ version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2ad9b889f1b12e0b9ee24db044b5129150d5eada288edc800f789928dc8c0e3"
dependencies = [
- "unicode-width",
-]
-
-[[package]]
-name = "panic_abort"
-version = "0.0.0"
-dependencies = [
- "alloc",
- "cfg-if",
- "compiler_builtins",
- "core",
- "libc",
-]
-
-[[package]]
-name = "panic_unwind"
-version = "0.0.0"
-dependencies = [
- "alloc",
- "cfg-if",
- "compiler_builtins",
- "core",
- "libc",
- "unwind",
+ "unicode-width 0.1.14",
]
[[package]]
@@ -2809,7 +2610,7 @@ checksum = "9ad43c07024ef767f9160710b3a6773976194758c7919b17e63b863db0bdf7fb"
dependencies = [
"bytecount",
"fnv",
- "unicode-width",
+ "unicode-width 0.1.14",
]
[[package]]
@@ -2830,9 +2631,9 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
dependencies = [
"cfg-if",
"libc",
- "redox_syscall 0.5.2",
+ "redox_syscall",
"smallvec",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
]
[[package]]
@@ -2846,9 +2647,9 @@ dependencies = [
[[package]]
name = "pathdiff"
-version = "0.2.1"
+version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
[[package]]
name = "percent-encoding"
@@ -2867,20 +2668,20 @@ dependencies = [
[[package]]
name = "pest"
-version = "2.7.10"
+version = "2.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "560131c633294438da9f7c4b08189194b20946c8274c6b9e38881a7874dc8ee8"
+checksum = "198db74531d58c70a361c42201efde7e2591e976d518caf7662a47dc5720e7b6"
dependencies = [
"memchr",
- "thiserror",
+ "thiserror 2.0.12",
"ucd-trie",
]
[[package]]
name = "pest_derive"
-version = "2.7.10"
+version = "2.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26293c9193fbca7b1a3bf9b79dc1e388e927e6cacaa78b4a3ab705a1d3d41459"
+checksum = "d725d9cfd79e87dccc9341a2ef39d1b6f6353d68c4b33c177febbe1a402c97c5"
dependencies = [
"pest",
"pest_generator",
@@ -2888,22 +2689,22 @@ dependencies = [
[[package]]
name = "pest_generator"
-version = "2.7.10"
+version = "2.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ec22af7d3fb470a85dd2ca96b7c577a1eb4ef6f1683a9fe9a8c16e136c04687"
+checksum = "db7d01726be8ab66ab32f9df467ae8b1148906685bbe75c82d1e65d7f5b3f841"
dependencies = [
"pest",
"pest_meta",
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "pest_meta"
-version = "2.7.10"
+version = "2.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a240022f37c361ec1878d646fc5b7d7c4d28d5946e1a80ad5a7a4f4ca0bdcd"
+checksum = "7f9f832470494906d1fca5329f8ab5791cc60beb230c74815dff541cbd2b5ca0"
dependencies = [
"once_cell",
"pest",
@@ -2912,66 +2713,47 @@ dependencies = [
[[package]]
name = "phf"
-version = "0.11.2"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
dependencies = [
- "phf_shared 0.11.2",
+ "phf_shared",
]
[[package]]
name = "phf_codegen"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
-dependencies = [
- "phf_generator 0.11.2",
- "phf_shared 0.11.2",
-]
-
-[[package]]
-name = "phf_generator"
-version = "0.10.0"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
dependencies = [
- "phf_shared 0.10.0",
- "rand",
+ "phf_generator",
+ "phf_shared",
]
[[package]]
name = "phf_generator"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
-dependencies = [
- "phf_shared 0.11.2",
- "rand",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.10.0"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
dependencies = [
- "siphasher",
+ "phf_shared",
+ "rand 0.8.5",
]
[[package]]
name = "phf_shared"
-version = "0.11.2"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
dependencies = [
"siphasher",
]
[[package]]
name = "pin-project-lite"
-version = "0.2.14"
+version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
[[package]]
name = "pin-utils"
@@ -2981,32 +2763,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
-version = "0.3.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
-
-[[package]]
-name = "plist"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9d34169e64b3c7a80c8621a48adaf44e0cf62c78a9b25dd9dd35f1881a17cf9"
-dependencies = [
- "base64",
- "indexmap",
- "line-wrap",
- "quick-xml",
- "serde",
- "time",
-]
-
-[[package]]
-name = "polib"
-version = "0.2.0"
+version = "0.3.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b393b155cf9be86249cba1b56cc81be0e6212c66d94ac0d76d37a1761f3bb1b"
-dependencies = [
- "linereader",
-]
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
[[package]]
name = "polonius-engine"
@@ -3016,26 +2775,32 @@ checksum = "c4e8e505342045d397d0b6674dcb82d6faf5cf40484d30eeb88fc82ef14e903f"
dependencies = [
"datafrog",
"log",
- "rustc-hash",
+ "rustc-hash 1.1.0",
]
[[package]]
name = "portable-atomic"
-version = "1.6.0"
+version = "1.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
[[package]]
-name = "powerfmt"
-version = "0.2.0"
+name = "portable-atomic-util"
+version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
[[package]]
name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
[[package]]
name = "precomputed-hash"
@@ -3043,40 +2808,13 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
-[[package]]
-name = "predicates"
-version = "3.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b87bfd4605926cdfefc1c3b5f8fe560e3feca9d5552cf68c466d3d8236c7e8"
-dependencies = [
- "anstyle",
- "difflib",
- "predicates-core",
-]
-
-[[package]]
-name = "predicates-core"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
-
-[[package]]
-name = "predicates-tree"
-version = "1.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
-dependencies = [
- "predicates-core",
- "termtree",
-]
-
[[package]]
name = "prettydiff"
-version = "0.6.4"
+version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ff1fec61082821f8236cf6c0c14e8172b62ce8a72a0eedc30d3b247bb68dc11"
+checksum = "abec3fb083c10660b3854367697da94c674e9e82aa7511014dc958beeb7215e9"
dependencies = [
- "ansi_term",
+ "owo-colors",
"pad",
]
@@ -3088,35 +2826,18 @@ checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
[[package]]
name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.94"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
dependencies = [
"unicode-ident",
]
-[[package]]
-name = "proc_macro"
-version = "0.0.0"
-dependencies = [
- "core",
- "std",
-]
-
-[[package]]
-name = "profiler_builtins"
-version = "0.0.0"
-dependencies = [
- "cc",
- "compiler_builtins",
- "core",
-]
-
[[package]]
name = "psm"
-version = "0.1.21"
+version = "0.1.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5787f7cda34e3033a72192c018bc5883100330f362ef279a8cbccfce8bb4e874"
+checksum = "f58e5423e24c18cc840e1c98370b3993c6649cd1678b4d24318bcf0a083cbe88"
dependencies = [
"cc",
]
@@ -3127,72 +2848,35 @@ version = "0.9.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
"memchr",
"unicase",
]
[[package]]
name = "pulldown-cmark"
-version = "0.10.3"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76979bea66e7875e7509c4ec5300112b316af87fa7a252ca91c448b32dfe3993"
+checksum = "679341d22c78c6c649893cbd6c3278dcbe9fc4faa62fea3a9296ae2b50c14625"
dependencies = [
- "bitflags 2.5.0",
- "getopts",
+ "bitflags",
"memchr",
- "pulldown-cmark-escape 0.10.1",
+ "pulldown-cmark-escape",
"unicase",
]
[[package]]
-name = "pulldown-cmark"
+name = "pulldown-cmark-escape"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8746739f11d39ce5ad5c2520a9b75285310dbfe78c541ccf832d38615765aec0"
-dependencies = [
- "bitflags 2.5.0",
- "memchr",
- "pulldown-cmark-escape 0.11.0",
- "unicase",
-]
+checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae"
[[package]]
-name = "pulldown-cmark-escape"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd348ff538bc9caeda7ee8cad2d1d48236a1f443c1fa3913c6a02fe0043b1dd3"
-
-[[package]]
-name = "pulldown-cmark-escape"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae"
-
-[[package]]
-name = "pulldown-cmark-to-cmark"
-version = "13.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f609795c8d835f79dcfcf768415b9fb57ef1b74891e99f86e73f43a7a257163b"
-dependencies = [
- "pulldown-cmark 0.10.3",
-]
-
-[[package]]
-name = "punycode"
-version = "0.4.1"
+name = "punycode"
+version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e9e1dcb320d6839f6edb64f7a4a59d39b30480d4d1765b56873f7c858538a5fe"
-[[package]]
-name = "quick-xml"
-version = "0.31.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33"
-dependencies = [
- "memchr",
-]
-
[[package]]
name = "quine-mc_cluskey"
version = "0.2.4"
@@ -3201,43 +2885,39 @@ checksum = "07589615d719a60c8dd8a4622e7946465dfef20d1a428f969e3443e7386d5f45"
[[package]]
name = "quote"
-version = "1.0.36"
+version = "1.0.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
dependencies = [
"proc-macro2",
]
[[package]]
name = "r-efi"
-version = "4.5.0"
+version = "5.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9e935efc5854715dfc0a4c9ef18dc69dee0ec3bf9cc3ab740db831c0fdd86a3"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
[[package]]
-name = "r-efi-alloc"
-version = "1.0.0"
+name = "rand"
+version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31d6f09fe2b6ad044bc3d2c34ce4979796581afd2f1ebc185837e02421e02fd7"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
- "compiler_builtins",
- "r-efi",
- "rustc-std-workspace-core",
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
]
[[package]]
name = "rand"
-version = "0.8.5"
+version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
+ "zerocopy",
]
[[package]]
@@ -3247,7 +2927,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
"ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
]
[[package]]
@@ -3256,25 +2946,25 @@ version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
]
[[package]]
-name = "rand_xorshift"
-version = "0.3.0"
+name = "rand_core"
+version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
dependencies = [
- "rand_core",
+ "getrandom 0.3.2",
]
[[package]]
name = "rand_xoshiro"
-version = "0.6.0"
+version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
+checksum = "f703f4665700daf5512dcca5f43afa6af89f09db47fb56be587f80636bda2d41"
dependencies = [
- "rand_core",
+ "rand_core 0.9.3",
]
[[package]]
@@ -3299,43 +2989,45 @@ dependencies = [
[[package]]
name = "redox_syscall"
-version = "0.4.1"
+version = "0.5.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3"
dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
]
[[package]]
-name = "redox_syscall"
-version = "0.5.2"
+name = "redox_users"
+version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
dependencies = [
- "bitflags 2.5.0",
+ "getrandom 0.2.15",
+ "libredox",
+ "thiserror 1.0.69",
]
[[package]]
name = "redox_users"
-version = "0.4.5"
+version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
+checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
"libredox",
- "thiserror",
+ "thiserror 2.0.12",
]
[[package]]
name = "regex"
-version = "1.9.4"
+version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
dependencies = [
"aho-corasick",
"memchr",
- "regex-automata 0.3.7",
- "regex-syntax 0.7.5",
+ "regex-automata 0.4.9",
+ "regex-syntax 0.8.5",
]
[[package]]
@@ -3358,13 +3050,13 @@ dependencies = [
[[package]]
name = "regex-automata"
-version = "0.3.7"
+version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
dependencies = [
"aho-corasick",
"memchr",
- "regex-syntax 0.7.5",
+ "regex-syntax 0.8.5",
]
[[package]]
@@ -3381,15 +3073,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
[[package]]
name = "regex-syntax"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
[[package]]
name = "remote-test-client"
@@ -3407,44 +3093,26 @@ dependencies = [
"walkdir",
]
-[[package]]
-name = "rls"
-version = "2.0.0"
-dependencies = [
- "serde_json",
-]
-
[[package]]
name = "run_make_support"
version = "0.2.0"
dependencies = [
- "ar",
"bstr",
"build_helper",
- "gimli 0.28.1",
- "object 0.34.0",
+ "gimli 0.31.1",
+ "libc",
+ "object 0.36.7",
"regex",
+ "serde_json",
"similar",
- "wasmparser",
-]
-
-[[package]]
-name = "rustbook"
-version = "0.1.0"
-dependencies = [
- "clap",
- "env_logger",
- "mdbook",
- "mdbook-i18n-helpers",
- "mdbook-trpl-listing",
- "mdbook-trpl-note",
+ "wasmparser 0.219.2",
]
[[package]]
name = "rustc-build-sysroot"
-version = "0.5.2"
+version = "0.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa3ca63cc537c1cb69e4c2c0afc5fda2ccd36ac84c97d5a4ae05e69b1c834afb"
+checksum = "d6d984a9db43148467059309bd1e5ad577085162f695d9fe2cf3543aeb25cd38"
dependencies = [
"anyhow",
"rustc_version",
@@ -3457,10 +3125,6 @@ name = "rustc-demangle"
version = "0.1.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
[[package]]
name = "rustc-hash"
@@ -3468,45 +3132,38 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "rustc-literal-escaper"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0041b6238913c41fe704213a4a9329e2f685a156d1781998128b4149c230ad04"
+
[[package]]
name = "rustc-main"
version = "0.0.0"
dependencies = [
- "jemalloc-sys",
"rustc_codegen_ssa",
"rustc_driver",
"rustc_driver_impl",
"rustc_smir",
"stable_mir",
-]
-
-[[package]]
-name = "rustc-perf-wrapper"
-version = "0.1.0"
-dependencies = [
- "clap",
-]
-
-[[package]]
-name = "rustc-rayon"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb81aadc8837ca6ecebe0fe1353f15df83b3b3cc2cf7a8afd571bc22aa121710"
-dependencies = [
- "either",
- "rustc-rayon-core",
+ "tikv-jemalloc-sys",
]
[[package]]
name = "rustc-rayon-core"
-version = "0.5.0"
+version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67668daaf00e359c126f6dcb40d652d89b458a008c8afa727a42a2d20fca0b7f"
+checksum = "2f42932dcd3bcbe484b38a3ccf79b7906fac41c02d408b5b1bac26da3416efdb"
dependencies = [
- "crossbeam-channel",
"crossbeam-deque",
"crossbeam-utils",
- "num_cpus",
]
[[package]]
@@ -3517,52 +3174,45 @@ checksum = "5be1bdc7edf596692617627bbfeaba522131b18e06ca4df2b6b689e3c5d5ce84"
[[package]]
name = "rustc-stable-hash"
-version = "0.1.0"
+version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5c9f15eec8235d7cb775ee6f81891db79b98fd54ba1ad8fae565b88ef1ae4e2"
+checksum = "781442f29170c5c93b7185ad559492601acdc71d5bb0706f5868094f45cfcd08"
[[package]]
name = "rustc-std-workspace-alloc"
-version = "1.99.0"
-dependencies = [
- "alloc",
-]
+version = "1.0.1"
[[package]]
name = "rustc-std-workspace-core"
-version = "1.99.0"
-dependencies = [
- "core",
-]
+version = "1.0.1"
[[package]]
name = "rustc-std-workspace-std"
-version = "1.99.0"
-dependencies = [
- "std",
-]
+version = "1.0.1"
[[package]]
name = "rustc_abi"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
- "rand",
+ "bitflags",
+ "rand 0.9.0",
"rand_xoshiro",
"rustc_data_structures",
+ "rustc_hashes",
"rustc_index",
"rustc_macros",
"rustc_serialize",
+ "rustc_span",
"tracing",
]
[[package]]
name = "rustc_apfloat"
-version = "0.2.0+llvm-462a31f5a5ab"
+version = "0.2.2+llvm-462a31f5a5ab"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "465187772033a5ee566f69fe008df03628fce549a0899aae76f0a0c2e34696be"
+checksum = "121e2195ff969977a4e2b5c9965ea867fce7e4cb5aee5b09dee698a7932d574f"
dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
"smallvec",
]
@@ -3577,12 +3227,12 @@ dependencies = [
name = "rustc_ast"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
"memchr",
+ "rustc-literal-escaper",
"rustc_ast_ir",
"rustc_data_structures",
"rustc_index",
- "rustc_lexer",
"rustc_macros",
"rustc_serialize",
"rustc_span",
@@ -3598,17 +3248,19 @@ dependencies = [
"rustc_data_structures",
"rustc_macros",
"rustc_serialize",
- "rustc_span",
]
[[package]]
name = "rustc_ast_lowering"
version = "0.0.0"
dependencies = [
+ "rustc_abi",
"rustc_ast",
"rustc_ast_pretty",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
+ "rustc_feature",
"rustc_fluent_macro",
"rustc_hir",
"rustc_index",
@@ -3627,9 +3279,10 @@ name = "rustc_ast_passes"
version = "0.0.0"
dependencies = [
"itertools",
+ "rustc_abi",
"rustc_ast",
"rustc_ast_pretty",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_feature",
@@ -3638,7 +3291,6 @@ dependencies = [
"rustc_parse",
"rustc_session",
"rustc_span",
- "rustc_target",
"thin-vec",
]
@@ -3654,21 +3306,36 @@ dependencies = [
]
[[package]]
-name = "rustc_attr"
+name = "rustc_attr_data_structures"
version = "0.0.0"
dependencies = [
"rustc_abi",
"rustc_ast",
"rustc_ast_pretty",
"rustc_data_structures",
+ "rustc_macros",
+ "rustc_serialize",
+ "rustc_span",
+ "thin-vec",
+]
+
+[[package]]
+name = "rustc_attr_parsing"
+version = "0.0.0"
+dependencies = [
+ "rustc_abi",
+ "rustc_ast",
+ "rustc_ast_pretty",
+ "rustc_attr_data_structures",
"rustc_errors",
"rustc_feature",
"rustc_fluent_macro",
+ "rustc_hir",
"rustc_lexer",
"rustc_macros",
- "rustc_serialize",
"rustc_session",
"rustc_span",
+ "thin-vec",
]
[[package]]
@@ -3689,6 +3356,7 @@ dependencies = [
"either",
"itertools",
"polonius-engine",
+ "rustc_abi",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
@@ -3702,7 +3370,6 @@ dependencies = [
"rustc_mir_dataflow",
"rustc_session",
"rustc_span",
- "rustc_target",
"rustc_trait_selection",
"rustc_traits",
"smallvec",
@@ -3715,12 +3382,13 @@ version = "0.0.0"
dependencies = [
"rustc_ast",
"rustc_ast_pretty",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_expand",
"rustc_feature",
"rustc_fluent_macro",
+ "rustc_hir",
"rustc_index",
"rustc_lexer",
"rustc_lint_defs",
@@ -3739,19 +3407,22 @@ dependencies = [
name = "rustc_codegen_llvm"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
+ "gimli 0.31.1",
"itertools",
"libc",
"measureme",
- "object 0.32.2",
+ "object 0.36.7",
"rustc-demangle",
+ "rustc_abi",
"rustc_ast",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_codegen_ssa",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
"rustc_fs_util",
+ "rustc_hashes",
"rustc_hir",
"rustc_index",
"rustc_llvm",
@@ -3776,43 +3447,44 @@ version = "0.0.0"
dependencies = [
"ar_archive_writer",
"arrayvec",
- "bitflags 2.5.0",
+ "bitflags",
+ "bstr",
"cc",
"either",
"itertools",
- "jobserver",
"libc",
- "object 0.32.2",
+ "object 0.36.7",
"pathdiff",
"regex",
+ "rustc_abi",
"rustc_arena",
"rustc_ast",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
"rustc_fs_util",
+ "rustc_hashes",
"rustc_hir",
"rustc_incremental",
"rustc_index",
"rustc_macros",
"rustc_metadata",
"rustc_middle",
- "rustc_monomorphize",
"rustc_query_system",
"rustc_serialize",
"rustc_session",
"rustc_span",
"rustc_symbol_mangling",
"rustc_target",
- "rustc_type_ir",
+ "rustc_trait_selection",
"serde_json",
"smallvec",
"tempfile",
"thin-vec",
"thorin-dwp",
"tracing",
- "wasm-encoder",
+ "wasm-encoder 0.219.2",
"windows",
]
@@ -3821,9 +3493,10 @@ name = "rustc_const_eval"
version = "0.0.0"
dependencies = [
"either",
+ "rustc_abi",
"rustc_apfloat",
"rustc_ast",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
@@ -3837,7 +3510,6 @@ dependencies = [
"rustc_span",
"rustc_target",
"rustc_trait_selection",
- "rustc_type_ir",
"tracing",
]
@@ -3846,10 +3518,11 @@ name = "rustc_data_structures"
version = "0.0.0"
dependencies = [
"arrayvec",
- "bitflags 2.5.0",
+ "bitflags",
"either",
"elsa",
"ena",
+ "hashbrown",
"indexmap",
"jobserver",
"libc",
@@ -3857,11 +3530,12 @@ dependencies = [
"memmap2",
"parking_lot",
"portable-atomic",
- "rustc-hash",
- "rustc-rayon",
+ "rustc-hash 2.1.1",
+ "rustc-rayon-core",
"rustc-stable-hash",
"rustc_arena",
"rustc_graphviz",
+ "rustc_hashes",
"rustc_index",
"rustc_macros",
"rustc_serialize",
@@ -3885,12 +3559,14 @@ name = "rustc_driver_impl"
version = "0.0.0"
dependencies = [
"ctrlc",
+ "jiff",
"libc",
+ "rustc_abi",
"rustc_ast",
"rustc_ast_lowering",
"rustc_ast_passes",
"rustc_ast_pretty",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_borrowck",
"rustc_builtin_macros",
"rustc_codegen_ssa",
@@ -3904,6 +3580,7 @@ dependencies = [
"rustc_hir_pretty",
"rustc_hir_typeck",
"rustc_incremental",
+ "rustc_index",
"rustc_infer",
"rustc_interface",
"rustc_lint",
@@ -3929,7 +3606,6 @@ dependencies = [
"rustc_ty_utils",
"serde_json",
"shlex",
- "time",
"tracing",
"windows",
]
@@ -3961,16 +3637,20 @@ dependencies = [
name = "rustc_errors"
version = "0.0.0"
dependencies = [
- "annotate-snippets 0.10.2",
+ "annotate-snippets 0.11.5",
"derive_setters",
+ "rustc_abi",
"rustc_ast",
"rustc_ast_pretty",
+ "rustc_attr_data_structures",
"rustc_data_structures",
"rustc_error_codes",
"rustc_error_messages",
"rustc_fluent_macro",
+ "rustc_hashes",
"rustc_hir",
"rustc_index",
+ "rustc_lexer",
"rustc_lint_defs",
"rustc_macros",
"rustc_serialize",
@@ -3982,7 +3662,6 @@ dependencies = [
"termcolor",
"termize",
"tracing",
- "unicode-width",
"windows",
]
@@ -3993,11 +3672,12 @@ dependencies = [
"rustc_ast",
"rustc_ast_passes",
"rustc_ast_pretty",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_feature",
"rustc_fluent_macro",
+ "rustc_hir",
"rustc_lexer",
"rustc_lint_defs",
"rustc_macros",
@@ -4016,43 +3696,59 @@ version = "0.0.0"
dependencies = [
"rustc_data_structures",
"rustc_span",
+ "serde",
+ "serde_json",
]
[[package]]
name = "rustc_fluent_macro"
version = "0.0.0"
dependencies = [
- "annotate-snippets 0.10.2",
+ "annotate-snippets 0.11.5",
"fluent-bundle",
"fluent-syntax",
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
"unic-langid",
]
[[package]]
name = "rustc_fs_util"
version = "0.0.0"
+dependencies = [
+ "tempfile",
+]
[[package]]
name = "rustc_graphviz"
version = "0.0.0"
+[[package]]
+name = "rustc_hashes"
+version = "0.0.0"
+dependencies = [
+ "rustc-stable-hash",
+]
+
[[package]]
name = "rustc_hir"
version = "0.0.0"
dependencies = [
"odht",
+ "rustc_abi",
"rustc_arena",
"rustc_ast",
+ "rustc_attr_data_structures",
"rustc_data_structures",
+ "rustc_hashes",
"rustc_index",
"rustc_macros",
"rustc_serialize",
"rustc_span",
"rustc_target",
"smallvec",
+ "thin-vec",
"tracing",
]
@@ -4061,15 +3757,15 @@ name = "rustc_hir_analysis"
version = "0.0.0"
dependencies = [
"itertools",
+ "rustc_abi",
"rustc_arena",
"rustc_ast",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_feature",
"rustc_fluent_macro",
"rustc_hir",
- "rustc_hir_pretty",
"rustc_index",
"rustc_infer",
"rustc_lint_defs",
@@ -4077,9 +3773,7 @@ dependencies = [
"rustc_middle",
"rustc_session",
"rustc_span",
- "rustc_target",
"rustc_trait_selection",
- "rustc_type_ir",
"smallvec",
"tracing",
]
@@ -4088,11 +3782,12 @@ dependencies = [
name = "rustc_hir_pretty"
version = "0.0.0"
dependencies = [
+ "rustc_abi",
"rustc_ast",
"rustc_ast_pretty",
+ "rustc_attr_data_structures",
"rustc_hir",
"rustc_span",
- "rustc_target",
]
[[package]]
@@ -4100,9 +3795,9 @@ name = "rustc_hir_typeck"
version = "0.0.0"
dependencies = [
"itertools",
+ "rustc_abi",
"rustc_ast",
- "rustc_ast_ir",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
@@ -4118,7 +3813,6 @@ dependencies = [
"rustc_span",
"rustc_target",
"rustc_trait_selection",
- "rustc_type_ir",
"smallvec",
"tracing",
]
@@ -4127,13 +3821,14 @@ dependencies = [
name = "rustc_incremental"
version = "0.0.0"
dependencies = [
- "rand",
+ "rand 0.9.0",
"rustc_ast",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
"rustc_fs_util",
"rustc_graphviz",
+ "rustc_hashes",
"rustc_hir",
"rustc_macros",
"rustc_middle",
@@ -4148,7 +3843,6 @@ dependencies = [
name = "rustc_index"
version = "0.0.0"
dependencies = [
- "arrayvec",
"rustc_index_macros",
"rustc_macros",
"rustc_serialize",
@@ -4161,14 +3855,13 @@ version = "0.0.0"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "rustc_infer"
version = "0.0.0"
dependencies = [
- "rustc_ast_ir",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
@@ -4176,11 +3869,10 @@ dependencies = [
"rustc_index",
"rustc_macros",
"rustc_middle",
- "rustc_next_trait_solver",
"rustc_span",
- "rustc_target",
"rustc_type_ir",
"smallvec",
+ "thin-vec",
"tracing",
]
@@ -4188,13 +3880,13 @@ dependencies = [
name = "rustc_interface"
version = "0.0.0"
dependencies = [
- "rustc-rayon",
"rustc-rayon-core",
+ "rustc_abi",
"rustc_ast",
"rustc_ast_lowering",
"rustc_ast_passes",
"rustc_ast_pretty",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_borrowck",
"rustc_builtin_macros",
"rustc_codegen_llvm",
@@ -4223,7 +3915,6 @@ dependencies = [
"rustc_query_impl",
"rustc_query_system",
"rustc_resolve",
- "rustc_serialize",
"rustc_session",
"rustc_span",
"rustc_symbol_mangling",
@@ -4239,6 +3930,7 @@ name = "rustc_lexer"
version = "0.0.0"
dependencies = [
"expect-test",
+ "memchr",
"unicode-properties",
"unicode-xid",
]
@@ -4247,15 +3939,15 @@ dependencies = [
name = "rustc_lint"
version = "0.0.0"
dependencies = [
+ "rustc_abi",
"rustc_ast",
"rustc_ast_pretty",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_feature",
"rustc_fluent_macro",
"rustc_hir",
- "rustc_hir_pretty",
"rustc_index",
"rustc_infer",
"rustc_macros",
@@ -4265,7 +3957,7 @@ dependencies = [
"rustc_span",
"rustc_target",
"rustc_trait_selection",
- "rustc_type_ir",
+ "smallvec",
"tracing",
"unicode-security",
]
@@ -4274,6 +3966,7 @@ dependencies = [
name = "rustc_lint_defs"
version = "0.0.0"
dependencies = [
+ "rustc_abi",
"rustc_ast",
"rustc_data_structures",
"rustc_error_messages",
@@ -4281,7 +3974,6 @@ dependencies = [
"rustc_macros",
"rustc_serialize",
"rustc_span",
- "rustc_target",
"serde",
]
@@ -4297,7 +3989,6 @@ dependencies = [
name = "rustc_log"
version = "0.0.0"
dependencies = [
- "rustc_span",
"tracing",
"tracing-core",
"tracing-subscriber",
@@ -4310,7 +4001,7 @@ version = "0.0.0"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
"synstructure",
]
@@ -4318,11 +4009,13 @@ dependencies = [
name = "rustc_metadata"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
+ "libc",
"libloading",
"odht",
+ "rustc_abi",
"rustc_ast",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_expand",
@@ -4338,9 +4031,6 @@ dependencies = [
"rustc_session",
"rustc_span",
"rustc_target",
- "rustc_type_ir",
- "snap",
- "tempfile",
"tracing",
]
@@ -4348,27 +4038,28 @@ dependencies = [
name = "rustc_middle"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
- "derivative",
+ "bitflags",
"either",
- "field-offset",
"gsgdt",
"polonius-engine",
"rustc-rayon-core",
+ "rustc_abi",
"rustc_apfloat",
"rustc_arena",
"rustc_ast",
"rustc_ast_ir",
- "rustc_attr",
+ "rustc_attr_data_structures",
"rustc_data_structures",
"rustc_error_messages",
"rustc_errors",
"rustc_feature",
"rustc_fluent_macro",
"rustc_graphviz",
+ "rustc_hashes",
"rustc_hir",
"rustc_hir_pretty",
"rustc_index",
+ "rustc_lint_defs",
"rustc_macros",
"rustc_query_system",
"rustc_serialize",
@@ -4386,6 +4077,7 @@ name = "rustc_mir_build"
version = "0.0.0"
dependencies = [
"itertools",
+ "rustc_abi",
"rustc_apfloat",
"rustc_arena",
"rustc_ast",
@@ -4401,7 +4093,6 @@ dependencies = [
"rustc_pattern_analysis",
"rustc_session",
"rustc_span",
- "rustc_target",
"rustc_trait_selection",
"tracing",
]
@@ -4412,6 +4103,7 @@ version = "0.0.0"
dependencies = [
"polonius-engine",
"regex",
+ "rustc_abi",
"rustc_ast",
"rustc_data_structures",
"rustc_errors",
@@ -4422,7 +4114,6 @@ dependencies = [
"rustc_macros",
"rustc_middle",
"rustc_span",
- "rustc_target",
"smallvec",
"tracing",
]
@@ -4433,9 +4124,10 @@ version = "0.0.0"
dependencies = [
"either",
"itertools",
+ "rustc_abi",
"rustc_arena",
"rustc_ast",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_const_eval",
"rustc_data_structures",
"rustc_errors",
@@ -4459,6 +4151,9 @@ dependencies = [
name = "rustc_monomorphize"
version = "0.0.0"
dependencies = [
+ "rustc_abi",
+ "rustc_ast",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
@@ -4467,6 +4162,7 @@ dependencies = [
"rustc_middle",
"rustc_session",
"rustc_span",
+ "rustc_symbol_mangling",
"rustc_target",
"serde",
"serde_json",
@@ -4477,13 +4173,10 @@ dependencies = [
name = "rustc_next_trait_solver"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
- "derivative",
- "rustc_ast_ir",
+ "derive-where",
"rustc_data_structures",
"rustc_index",
"rustc_macros",
- "rustc_serialize",
"rustc_type_ir",
"rustc_type_ir_macros",
"tracing",
@@ -4493,13 +4186,15 @@ dependencies = [
name = "rustc_parse"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
+ "rustc-literal-escaper",
"rustc_ast",
"rustc_ast_pretty",
"rustc_data_structures",
"rustc_errors",
"rustc_feature",
"rustc_fluent_macro",
+ "rustc_index",
"rustc_lexer",
"rustc_macros",
"rustc_session",
@@ -4508,13 +4203,14 @@ dependencies = [
"thin-vec",
"tracing",
"unicode-normalization",
- "unicode-width",
+ "unicode-width 0.2.0",
]
[[package]]
name = "rustc_parse_format"
version = "0.0.0"
dependencies = [
+ "rustc-literal-escaper",
"rustc_index",
"rustc_lexer",
]
@@ -4523,9 +4219,11 @@ dependencies = [
name = "rustc_passes"
version = "0.0.0"
dependencies = [
+ "rustc_abi",
"rustc_ast",
+ "rustc_ast_lowering",
"rustc_ast_pretty",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_expand",
@@ -4533,7 +4231,6 @@ dependencies = [
"rustc_fluent_macro",
"rustc_hir",
"rustc_index",
- "rustc_lexer",
"rustc_macros",
"rustc_middle",
"rustc_privacy",
@@ -4548,7 +4245,8 @@ dependencies = [
name = "rustc_pattern_analysis"
version = "0.0.0"
dependencies = [
- "rustc-hash",
+ "rustc-hash 2.1.1",
+ "rustc_abi",
"rustc_apfloat",
"rustc_arena",
"rustc_data_structures",
@@ -4560,7 +4258,6 @@ dependencies = [
"rustc_middle",
"rustc_session",
"rustc_span",
- "rustc_target",
"smallvec",
"tracing",
"tracing-subscriber",
@@ -4572,7 +4269,7 @@ name = "rustc_privacy"
version = "0.0.0"
dependencies = [
"rustc_ast",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
@@ -4589,10 +4286,9 @@ dependencies = [
name = "rustc_query_impl"
version = "0.0.0"
dependencies = [
- "field-offset",
"measureme",
"rustc_data_structures",
- "rustc_errors",
+ "rustc_hashes",
"rustc_hir",
"rustc_index",
"rustc_middle",
@@ -4600,7 +4296,6 @@ dependencies = [
"rustc_serialize",
"rustc_session",
"rustc_span",
- "thin-vec",
"tracing",
]
@@ -4608,22 +4303,24 @@ dependencies = [
name = "rustc_query_system"
version = "0.0.0"
dependencies = [
+ "hashbrown",
"parking_lot",
"rustc-rayon-core",
+ "rustc_abi",
"rustc_ast",
+ "rustc_attr_data_structures",
"rustc_data_structures",
"rustc_errors",
"rustc_feature",
"rustc_fluent_macro",
+ "rustc_hashes",
"rustc_hir",
"rustc_index",
"rustc_macros",
"rustc_serialize",
"rustc_session",
"rustc_span",
- "rustc_target",
"smallvec",
- "thin-vec",
"tracing",
]
@@ -4631,19 +4328,19 @@ dependencies = [
name = "rustc_resolve"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
- "pulldown-cmark 0.11.0",
+ "bitflags",
+ "itertools",
+ "pulldown-cmark 0.11.3",
"rustc_arena",
"rustc_ast",
"rustc_ast_pretty",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_expand",
"rustc_feature",
"rustc_fluent_macro",
"rustc_hir",
- "rustc_index",
"rustc_macros",
"rustc_metadata",
"rustc_middle",
@@ -4659,7 +4356,8 @@ dependencies = [
name = "rustc_sanitizers"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
+ "rustc_abi",
"rustc_data_structures",
"rustc_hir",
"rustc_middle",
@@ -4675,6 +4373,7 @@ name = "rustc_serialize"
version = "0.0.0"
dependencies = [
"indexmap",
+ "rustc_hashes",
"rustc_macros",
"smallvec",
"tempfile",
@@ -4685,15 +4384,18 @@ dependencies = [
name = "rustc_session"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
"getopts",
"libc",
+ "rand 0.9.0",
+ "rustc_abi",
"rustc_ast",
"rustc_data_structures",
"rustc_errors",
"rustc_feature",
"rustc_fluent_macro",
"rustc_fs_util",
+ "rustc_hashes",
"rustc_hir",
"rustc_lint_defs",
"rustc_macros",
@@ -4711,16 +4413,15 @@ name = "rustc_smir"
version = "0.0.0"
dependencies = [
"rustc_abi",
- "rustc_ast",
- "rustc_ast_pretty",
"rustc_data_structures",
"rustc_hir",
+ "rustc_hir_pretty",
"rustc_middle",
"rustc_session",
"rustc_span",
"rustc_target",
"scoped-tls",
- "stable_mir",
+ "serde",
"tracing",
]
@@ -4728,12 +4429,14 @@ dependencies = [
name = "rustc_span"
version = "0.0.0"
dependencies = [
- "derivative",
+ "blake3",
+ "derive-where",
"indexmap",
"itoa",
"md-5",
"rustc_arena",
"rustc_data_structures",
+ "rustc_hashes",
"rustc_index",
"rustc_macros",
"rustc_serialize",
@@ -4741,7 +4444,7 @@ dependencies = [
"sha1",
"sha2",
"tracing",
- "unicode-width",
+ "unicode-width 0.2.0",
]
[[package]]
@@ -4750,13 +4453,14 @@ version = "0.0.0"
dependencies = [
"punycode",
"rustc-demangle",
+ "rustc_abi",
"rustc_data_structures",
"rustc_errors",
+ "rustc_hashes",
"rustc_hir",
"rustc_middle",
"rustc_session",
"rustc_span",
- "rustc_target",
"tracing",
]
@@ -4764,13 +4468,11 @@ dependencies = [
name = "rustc_target"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
- "object 0.32.2",
+ "bitflags",
+ "object 0.36.7",
"rustc_abi",
"rustc_data_structures",
- "rustc_feature",
"rustc_fs_util",
- "rustc_index",
"rustc_macros",
"rustc_serialize",
"rustc_span",
@@ -4780,18 +4482,22 @@ dependencies = [
[[package]]
name = "rustc_tools_util"
-version = "0.3.0"
+version = "0.4.2"
+
+[[package]]
+name = "rustc_tools_util"
+version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ba09476327c4b70ccefb6180f046ef588c26a24cf5d269a9feba316eb4f029f"
+checksum = "a3b75158011a63889ba12084cf1224baad7bcad50f6ee7c842f772b74aa148ed"
[[package]]
name = "rustc_trait_selection"
version = "0.0.0"
dependencies = [
"itertools",
+ "rustc_abi",
"rustc_ast",
- "rustc_ast_ir",
- "rustc_attr",
+ "rustc_attr_parsing",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
@@ -4801,14 +4507,11 @@ dependencies = [
"rustc_middle",
"rustc_next_trait_solver",
"rustc_parse_format",
- "rustc_query_system",
- "rustc_serialize",
"rustc_session",
"rustc_span",
- "rustc_target",
"rustc_transmute",
- "rustc_type_ir",
"smallvec",
+ "thin-vec",
"tracing",
]
@@ -4830,14 +4533,12 @@ name = "rustc_transmute"
version = "0.0.0"
dependencies = [
"itertools",
- "rustc_ast_ir",
+ "rustc_abi",
"rustc_data_structures",
"rustc_hir",
- "rustc_infer",
- "rustc_macros",
"rustc_middle",
"rustc_span",
- "rustc_target",
+ "smallvec",
"tracing",
]
@@ -4846,10 +4547,11 @@ name = "rustc_ty_utils"
version = "0.0.0"
dependencies = [
"itertools",
- "rustc_ast_ir",
+ "rustc_abi",
"rustc_data_structures",
"rustc_errors",
"rustc_fluent_macro",
+ "rustc_hashes",
"rustc_hir",
"rustc_index",
"rustc_infer",
@@ -4859,7 +4561,6 @@ dependencies = [
"rustc_span",
"rustc_target",
"rustc_trait_selection",
- "rustc_type_ir",
"tracing",
]
@@ -4867,9 +4568,11 @@ dependencies = [
name = "rustc_type_ir"
version = "0.0.0"
dependencies = [
- "bitflags 2.5.0",
- "derivative",
+ "bitflags",
+ "derive-where",
+ "ena",
"indexmap",
+ "rustc-hash 1.1.0",
"rustc_ast_ir",
"rustc_data_structures",
"rustc_index",
@@ -4878,6 +4581,7 @@ dependencies = [
"rustc_span",
"rustc_type_ir_macros",
"smallvec",
+ "thin-vec",
"tracing",
]
@@ -4887,15 +4591,15 @@ version = "0.0.0"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
"synstructure",
]
[[package]]
name = "rustc_version"
-version = "0.4.0"
+version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
dependencies = [
"semver",
]
@@ -4912,16 +4616,19 @@ dependencies = [
"itertools",
"minifier",
"pulldown-cmark 0.9.6",
+ "pulldown-cmark-escape",
"regex",
"rustdoc-json-types",
"serde",
"serde_json",
+ "sha2",
"smallvec",
"tempfile",
"threadpool",
"tracing",
"tracing-subscriber",
"tracing-tree",
+ "unicode-segmentation",
]
[[package]]
@@ -4929,6 +4636,7 @@ name = "rustdoc-gui-test"
version = "0.1.0"
dependencies = [
"build_helper",
+ "camino",
"compiletest",
"getopts",
"walkdir",
@@ -4939,7 +4647,7 @@ name = "rustdoc-json-types"
version = "0.1.0"
dependencies = [
"bincode",
- "rustc-hash",
+ "rustc-hash 2.1.1",
"serde",
"serde_json",
]
@@ -4955,18 +4663,6 @@ dependencies = [
"rustdoc",
]
-[[package]]
-name = "rustfix"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd2853d9e26988467753bd9912c3a126f642d05d229a4b53f5752ee36c56481"
-dependencies = [
- "anyhow",
- "log",
- "serde",
- "serde_json",
-]
-
[[package]]
name = "rustfix"
version = "0.8.1"
@@ -4975,7 +4671,7 @@ checksum = "81864b097046da5df3758fdc6e4822bbb70afa06317e8ca45ea1b51cb8c5e5a4"
dependencies = [
"serde",
"serde_json",
- "thiserror",
+ "thiserror 1.0.69",
"tracing",
]
@@ -4986,12 +4682,12 @@ dependencies = [
"proc-macro2",
"quote",
"serde",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "rustfmt-nightly"
-version = "1.7.1"
+version = "1.8.0"
dependencies = [
"annotate-snippets 0.9.2",
"anyhow",
@@ -5009,61 +4705,48 @@ dependencies = [
"serde",
"serde_json",
"term",
- "thiserror",
+ "thiserror 1.0.69",
"toml 0.7.8",
"tracing",
"tracing-subscriber",
"unicode-properties",
"unicode-segmentation",
- "unicode-width",
+ "unicode-width 0.1.14",
]
[[package]]
name = "rustix"
-version = "0.38.34"
+version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf"
dependencies = [
- "bitflags 2.5.0",
+ "bitflags",
"errno",
"libc",
"linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
name = "rustversion"
-version = "1.0.17"
+version = "1.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
-
-[[package]]
-name = "ruzstd"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58c4eb8a81997cf040a091d1f7e1938aeab6749d3a0dfa73af43cdc32393483d"
-dependencies = [
- "byteorder",
- "derive_more",
- "twox-hash",
-]
+checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
[[package]]
name = "ruzstd"
-version = "0.6.0"
+version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5174a470eeb535a721ae9fdd6e291c2411a906b96592182d05217591d5c5cf7b"
+checksum = "fad02996bfc73da3e301efe90b1837be9ed8f4a462b6ed410aa35d00381de89f"
dependencies = [
- "byteorder",
- "derive_more",
"twox-hash",
]
[[package]]
name = "ryu"
-version = "1.0.18"
+version = "1.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
[[package]]
name = "same-file"
@@ -5076,11 +4759,11 @@ dependencies = [
[[package]]
name = "schannel"
-version = "0.1.23"
+version = "0.1.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
+checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -5101,61 +4784,61 @@ version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e14e4d63b804dc0c7ec4a1e52bcb63f02c7ac94476755aa579edac21e01f915d"
dependencies = [
- "self_cell 1.0.4",
+ "self_cell 1.2.0",
]
[[package]]
name = "self_cell"
-version = "1.0.4"
+version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d369a96f978623eb3dc28807c4852d6cc617fed53da5d3c400feff1ef34a714a"
+checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
[[package]]
name = "semver"
-version = "1.0.23"
+version = "1.0.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0"
dependencies = [
"serde",
]
[[package]]
name = "serde"
-version = "1.0.203"
+version = "1.0.219"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
-version = "1.0.203"
+version = "1.0.219"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "serde_json"
-version = "1.0.117"
+version = "1.0.140"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
+checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
dependencies = [
- "indexmap",
"itoa",
+ "memchr",
"ryu",
"serde",
]
[[package]]
name = "serde_spanned"
-version = "0.6.6"
+version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0"
+checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
dependencies = [
"serde",
]
@@ -5205,15 +4888,15 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
[[package]]
name = "similar"
-version = "2.5.0"
+version = "2.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
[[package]]
name = "siphasher"
-version = "0.3.11"
+version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
[[package]]
name = "slab"
@@ -5226,21 +4909,15 @@ dependencies = [
[[package]]
name = "smallvec"
-version = "1.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
-
-[[package]]
-name = "snap"
-version = "1.1.1"
+version = "1.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
+checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
[[package]]
name = "socket2"
-version = "0.5.7"
+version = "0.5.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
+checksum = "4f5fd57c80058a56cf5c777ab8a126398ece8e442983605d280a44ce79d0edef"
dependencies = [
"libc",
"windows-sys 0.52.0",
@@ -5248,9 +4925,9 @@ dependencies = [
[[package]]
name = "spanned"
-version = "0.2.1"
+version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed14ba8b4b82241bd5daba2c49185d4a0581a0058355fe96537338f002b8605d"
+checksum = "86af297923fbcfd107c20a189a6e9c872160df71a7190ae4a7a6c5dce4b2feb6"
dependencies = [
"bstr",
"color-eyre",
@@ -5264,7 +4941,7 @@ checksum = "53d7ac03c67c572d85049d6db815e20a4a19b41b3d5cca732ac582342021ad77"
dependencies = [
"nom",
"serde",
- "thiserror",
+ "thiserror 1.0.69",
"tracing",
]
@@ -5281,7 +4958,7 @@ dependencies = [
"spdx-expression",
"strum",
"strum_macros",
- "thiserror",
+ "thiserror 1.0.69",
"uuid",
]
@@ -5295,20 +4972,20 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
name = "stable_mir"
version = "0.1.0-preview"
dependencies = [
- "scoped-tls",
+ "rustc_smir",
]
[[package]]
name = "stacker"
-version = "0.1.15"
+version = "0.1.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c886bd4480155fd3ef527d45e9ac8dd7118a898a46530b7b94c3e21866259fce"
+checksum = "601f9201feb9b09c00266478bf459952b9ef9a6b94edb2f21eba14ab681a60a9"
dependencies = [
"cc",
"cfg-if",
"libc",
"psm",
- "winapi",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -5317,68 +4994,27 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-[[package]]
-name = "std"
-version = "0.0.0"
-dependencies = [
- "addr2line 0.22.0",
- "alloc",
- "cfg-if",
- "compiler_builtins",
- "core",
- "dlmalloc",
- "fortanix-sgx-abi",
- "hashbrown",
- "hermit-abi 0.4.0",
- "libc",
- "miniz_oxide",
- "object 0.36.0",
- "panic_abort",
- "panic_unwind",
- "profiler_builtins",
- "r-efi",
- "r-efi-alloc",
- "rand",
- "rand_xorshift",
- "rustc-demangle",
- "std_detect",
- "unwind",
- "wasi",
-]
-
-[[package]]
-name = "std_detect"
-version = "0.1.5"
-dependencies = [
- "cfg-if",
- "compiler_builtins",
- "libc",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
[[package]]
name = "string_cache"
-version = "0.8.7"
+version = "0.8.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b"
+checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
dependencies = [
"new_debug_unreachable",
- "once_cell",
"parking_lot",
- "phf_shared 0.10.0",
+ "phf_shared",
"precomputed-hash",
"serde",
]
[[package]]
name = "string_cache_codegen"
-version = "0.5.2"
+version = "0.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bb30289b722be4ff74a408c3cc27edeaad656e06cb1fe8fa9231fa59c728988"
+checksum = "c711928715f1fe0fe509c53b43e993a9a557babc2d0a3567d0a3006f1ac931a0"
dependencies = [
- "phf_generator 0.10.0",
- "phf_shared 0.10.0",
+ "phf_generator",
+ "phf_shared",
"proc-macro2",
"quote",
]
@@ -5429,9 +5065,9 @@ dependencies = [
[[package]]
name = "syn"
-version = "2.0.67"
+version = "2.0.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff8655ed1d86f3af4ee3fd3263786bc14245ad17c4c7e85ba7187fb3ae028c90"
+checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
dependencies = [
"proc-macro2",
"quote",
@@ -5446,54 +5082,21 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
-]
-
-[[package]]
-name = "syntect"
-version = "5.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "874dcfa363995604333cf947ae9f751ca3af4522c60886774c4963943b4746b1"
-dependencies = [
- "bincode",
- "bitflags 1.3.2",
- "flate2",
- "fnv",
- "once_cell",
- "onig",
- "plist",
- "regex-syntax 0.8.4",
- "serde",
- "serde_derive",
- "serde_json",
- "thiserror",
- "walkdir",
- "yaml-rust",
+ "syn 2.0.100",
]
[[package]]
name = "sysinfo"
-version = "0.30.12"
+version = "0.35.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "732ffa00f53e6b2af46208fba5718d9662a421049204e156328b66791ffa15ae"
+checksum = "b897c8ea620e181c7955369a31be5f48d9a9121cb59fd33ecef9ff2a34323422"
dependencies = [
- "cfg-if",
- "core-foundation-sys",
"libc",
- "ntapi",
- "once_cell",
+ "objc2-core-foundation",
+ "objc2-io-kit",
"windows",
]
-[[package]]
-name = "sysroot"
-version = "0.0.0"
-dependencies = [
- "proc_macro",
- "std",
- "test",
-]
-
[[package]]
name = "tabled"
version = "0.15.0"
@@ -5501,14 +5104,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c998b0c8b921495196a48aabaf1901ff28be0760136e31604f7967b0792050e"
dependencies = [
"papergrid",
- "unicode-width",
+ "unicode-width 0.1.14",
]
[[package]]
name = "tar"
-version = "0.4.41"
+version = "0.4.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb797dad5fb5b76fcf519e702f4a589483b5ef06567f160c392832c1f5e44909"
+checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
dependencies = [
"filetime",
"libc",
@@ -5517,14 +5120,15 @@ dependencies = [
[[package]]
name = "tempfile"
-version = "3.10.1"
+version = "3.19.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
dependencies = [
- "cfg-if",
"fastrand",
+ "getrandom 0.3.2",
+ "once_cell",
"rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -5558,16 +5162,6 @@ dependencies = [
"winapi-util",
]
-[[package]]
-name = "terminal_size"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
-dependencies = [
- "rustix",
- "windows-sys 0.48.0",
-]
-
[[package]]
name = "termize"
version = "0.1.1"
@@ -5579,62 +5173,71 @@ dependencies = [
]
[[package]]
-name = "termtree"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
-
-[[package]]
-name = "test"
-version = "0.0.0"
+name = "test-float-parse"
+version = "0.1.0"
dependencies = [
- "core",
- "getopts",
- "libc",
- "std",
+ "indicatif",
+ "num",
+ "rand 0.9.0",
+ "rand_chacha 0.9.0",
+ "rayon",
]
[[package]]
-name = "textwrap"
-version = "0.16.1"
+name = "thin-vec"
+version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23d434d3f8967a09480fb04132ebe0a3e088c173e6d0ee7897abbdf4eab0f8b9"
+checksum = "144f754d318415ac792f9d69fc87abbbfc043ce2ef041c60f16ad828f638717d"
[[package]]
-name = "thin-vec"
-version = "0.2.13"
+name = "thiserror"
+version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a38c90d48152c236a3ab59271da4f4ae63d678c5d7ad6b7714d7cb9760be5e4b"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
[[package]]
name = "thiserror"
-version = "1.0.61"
+version = "2.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.12",
]
[[package]]
name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
]
[[package]]
name = "thorin-dwp"
-version = "0.7.0"
+version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4db52ee8fec06e119b692ef3dd2c4cf621a99204c1b8c47407870ed050305b9b"
+checksum = "9e9c1e705f82a260173f3eec93f2ff6d7807f23ad5a8cc2e7316a891733ea7a1"
dependencies = [
- "gimli 0.28.1",
+ "gimli 0.31.1",
"hashbrown",
- "object 0.32.2",
+ "object 0.36.7",
"tracing",
]
@@ -5662,15 +5265,17 @@ name = "tidy"
version = "0.1.0"
dependencies = [
"build_helper",
- "cargo_metadata 0.15.4",
+ "cargo_metadata 0.19.2",
"fluent-syntax",
"ignore",
"miropt-test-tools",
"regex",
- "rustc-hash",
+ "rustc-hash 2.1.1",
"semver",
+ "serde",
"similar",
"termcolor",
+ "toml 0.7.8",
"walkdir",
]
@@ -5679,34 +5284,13 @@ name = "tier-check"
version = "0.1.0"
[[package]]
-name = "time"
-version = "0.3.36"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
-dependencies = [
- "deranged",
- "itoa",
- "num-conv",
- "powerfmt",
- "serde",
- "time-core",
- "time-macros",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
-
-[[package]]
-name = "time-macros"
-version = "0.2.18"
+name = "tikv-jemalloc-sys"
+version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
dependencies = [
- "num-conv",
- "time-core",
+ "cc",
+ "libc",
]
[[package]]
@@ -5721,9 +5305,9 @@ dependencies = [
[[package]]
name = "tinyvec"
-version = "1.6.0"
+version = "1.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
dependencies = [
"tinyvec_macros",
]
@@ -5736,9 +5320,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
[[package]]
name = "tokio"
-version = "1.38.0"
+version = "1.44.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
+checksum = "e6b88822cbe49de4185e3a4cbf8321dd487cf5fe0c5c65695fef6346371e9c48"
dependencies = [
"backtrace",
"bytes",
@@ -5763,26 +5347,14 @@ dependencies = [
"serde",
"serde_spanned",
"toml_datetime",
- "toml_edit 0.19.15",
-]
-
-[[package]]
-name = "toml"
-version = "0.8.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f49eb2ab21d2f26bd6db7bf383edc527a7ebaee412d17af4d40fdccd442f335"
-dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit 0.22.14",
+ "toml_edit",
]
[[package]]
name = "toml_datetime"
-version = "0.6.6"
+version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
dependencies = [
"serde",
]
@@ -5800,25 +5372,6 @@ dependencies = [
"winnow 0.5.40",
]
-[[package]]
-name = "toml_edit"
-version = "0.22.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f21c7aaf97f1bd9ca9d4f9e73b0a6c74bd5afef56f2bc931943a6e1c37e04e38"
-dependencies = [
- "indexmap",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow 0.6.13",
-]
-
-[[package]]
-name = "topological-sort"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea68304e134ecd095ac6c3574494fc62b909f416c4fca77e440530221e549d3d"
-
[[package]]
name = "tracing"
version = "0.1.37"
@@ -5833,13 +5386,13 @@ dependencies = [
[[package]]
name = "tracing-attributes"
-version = "0.1.27"
+version = "0.1.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
@@ -5854,9 +5407,9 @@ dependencies = [
[[package]]
name = "tracing-error"
-version = "0.2.0"
+version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d686ec1c0f384b1277f097b2f279a2ecc11afe8c133c1aabf036a27cb4cd206e"
+checksum = "8b1581020d7a273442f5b45074a6a57d5757ad0a47dac0e9f0bd57b81936f3db"
dependencies = [
"tracing",
"tracing-subscriber",
@@ -5898,7 +5451,7 @@ version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b56c62d2c80033cb36fae448730a2f2ef99410fe3ecbffc916681a32f6807dbe"
dependencies = [
- "nu-ansi-term 0.50.0",
+ "nu-ansi-term 0.50.1",
"tracing-core",
"tracing-log",
"tracing-subscriber",
@@ -5911,7 +5464,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
dependencies = [
"cfg-if",
- "rand",
+ "rand 0.8.5",
"static_assertions",
]
@@ -5921,14 +5474,14 @@ version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "deb68604048ff8fa93347f02441e4487594adc20bb8a084f9e564d2b827a0a9f"
dependencies = [
- "rustc-hash",
+ "rustc-hash 1.1.0",
]
[[package]]
name = "typenum"
-version = "1.17.0"
+version = "1.18.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
[[package]]
name = "ucd-parse"
@@ -5941,44 +5494,17 @@ dependencies = [
[[package]]
name = "ucd-trie"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
-
-[[package]]
-name = "ui_test"
-version = "0.21.2"
+version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaf4bf7c184b8dfc7a4d3b90df789b1eb992ee42811cd115f32a7a1eb781058d"
-dependencies = [
- "annotate-snippets 0.9.2",
- "anyhow",
- "bstr",
- "cargo-platform",
- "cargo_metadata 0.15.4",
- "color-eyre",
- "colored",
- "comma",
- "crossbeam-channel",
- "indicatif",
- "lazy_static",
- "levenshtein",
- "prettydiff",
- "regex",
- "rustc_version",
- "rustfix 0.6.1",
- "serde",
- "serde_json",
- "tempfile",
-]
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
[[package]]
name = "ui_test"
-version = "0.23.0"
+version = "0.29.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29e5f4ffcbab82453958fbf59990e981b8e8a177dcd60c2bd8f9b52c3036a6e1"
+checksum = "1211b1111c752c73b33073d2958072be08825fd97c9ab4d83444da361a06634b"
dependencies = [
- "annotate-snippets 0.11.4",
+ "annotate-snippets 0.11.5",
"anyhow",
"bstr",
"cargo-platform",
@@ -5988,16 +5514,14 @@ dependencies = [
"comma",
"crossbeam-channel",
"indicatif",
- "lazy_static",
"levenshtein",
"prettydiff",
"regex",
"rustc_version",
- "rustfix 0.8.1",
+ "rustfix",
"serde",
"serde_json",
"spanned",
- "tempfile",
]
[[package]]
@@ -6039,64 +5563,48 @@ checksum = "1ed7f4237ba393424195053097c1516bd4590dc82b84f2f97c5c69e12704555b"
dependencies = [
"proc-macro-hack",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
"unic-langid-impl",
]
[[package]]
name = "unicase"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
-dependencies = [
- "version_check",
-]
-
-[[package]]
-name = "unicode-bdd"
-version = "0.1.0"
-dependencies = [
- "ucd-parse",
-]
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.15"
+version = "2.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
[[package]]
name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
[[package]]
name = "unicode-normalization"
-version = "0.1.23"
+version = "0.1.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
dependencies = [
"tinyvec",
]
[[package]]
name = "unicode-properties"
-version = "0.1.1"
+version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4259d9d4425d9f0661581b804cb85fe66a4c631cadd8f490d1c13a35d5d9291"
+checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0"
[[package]]
name = "unicode-script"
-version = "0.5.6"
+version = "0.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad8d71f5726e5f285a935e9fe8edfd53f0491eb6e9a5774097fdabee7cd8c9cd"
+checksum = "9fb421b350c9aff471779e262955939f565ec18b86c15364e6bdf0d662ca7c1f"
[[package]]
name = "unicode-security"
-version = "0.1.1"
+version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee9e13753df674873f3c4693b240ae5c03245ddc157dfccf7c26db9329af3a11"
+checksum = "2e4ddba1535dd35ed8b61c52166b7155d7f4e4b8847cec6f48e71dc66d8b5e50"
dependencies = [
"unicode-normalization",
"unicode-script",
@@ -6104,26 +5612,34 @@ dependencies = [
[[package]]
name = "unicode-segmentation"
-version = "1.11.0"
+version = "1.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
[[package]]
-name = "unicode-width"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
+name = "unicode-table-generator"
+version = "0.1.0"
dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
- "rustc-std-workspace-std",
+ "ucd-parse",
]
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+
[[package]]
name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
[[package]]
name = "unified-diff"
@@ -6143,36 +5659,14 @@ dependencies = [
]
[[package]]
-name = "unwind"
-version = "0.0.0"
+name = "url"
+version = "2.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
dependencies = [
- "cfg-if",
- "compiler_builtins",
- "core",
- "libc",
- "unwinding",
-]
-
-[[package]]
-name = "unwinding"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37a19a21a537f635c16c7576f22d0f2f7d63353c1337ad4ce0d8001c7952a25b"
-dependencies = [
- "compiler_builtins",
- "gimli 0.28.1",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "url"
-version = "2.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
-dependencies = [
- "form_urlencoded",
- "idna",
- "percent-encoding",
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
]
[[package]]
@@ -6181,12 +5675,24 @@ version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
[[package]]
name = "utf8-width"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "86bd8d4e895da8537e5315b8254664e6b769c4ff3db18321b297a1e7004392e3"
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
[[package]]
name = "utf8parse"
version = "0.2.2"
@@ -6195,18 +5701,18 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uuid"
-version = "1.8.0"
+version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
dependencies = [
- "getrandom",
+ "getrandom 0.3.2",
]
[[package]]
name = "valuable"
-version = "0.1.0"
+version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
[[package]]
name = "vcpkg"
@@ -6216,18 +5722,9 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
[[package]]
name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
-
-[[package]]
-name = "wait-timeout"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
-dependencies = [
- "libc",
-]
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
[[package]]
name = "walkdir"
@@ -6244,42 +5741,53 @@ name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
+ "wit-bindgen-rt",
]
+[[package]]
+name = "wasi-preview1-component-adapter-provider"
+version = "31.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86fabda09a0d89ffd1615b297b4a5d4b4d99df9598aeb24685837e63019e927b"
+
[[package]]
name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
dependencies = [
"cfg-if",
+ "once_cell",
+ "rustversion",
"wasm-bindgen-macro",
]
[[package]]
name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
dependencies = [
"bumpalo",
"log",
- "once_cell",
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
@@ -6287,40 +5795,147 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-component-ld"
+version = "0.5.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a60a07a994a3538b57d8c5f8caba19f4793fb4c7156276e5e90e90acbb829e20"
+dependencies = [
+ "anyhow",
+ "clap",
+ "lexopt",
+ "libc",
+ "tempfile",
+ "wasi-preview1-component-adapter-provider",
+ "wasmparser 0.229.0",
+ "wat",
+ "windows-sys 0.59.0",
+ "winsplit",
+ "wit-component",
+ "wit-parser",
+]
+
+[[package]]
+name = "wasm-component-ld-wrapper"
+version = "0.1.0"
+dependencies = [
+ "wasm-component-ld",
+]
[[package]]
name = "wasm-encoder"
-version = "0.200.0"
+version = "0.219.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9e3fb0c8fbddd78aa6095b850dfeedbc7506cf5f81e633f69cf8f2333ab84b9"
+checksum = "8aa79bcd666a043b58f5fa62b221b0b914dd901e6f620e8ab7371057a797f3e1"
dependencies = [
"leb128",
+ "wasmparser 0.219.2",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.229.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38ba1d491ecacb085a2552025c10a675a6fddcbd03b1fc9b36c536010ce265d2"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.229.0",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.229.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78fdb7d29a79191ab363dc90c1ddd3a1e880ffd5348d92d48482393a9e6c5f4d"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder 0.229.0",
+ "wasmparser 0.229.0",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.219.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5220ee4c6ffcc0cb9d7c47398052203bc902c8ef3985b0c8134118440c0b2921"
+dependencies = [
+ "bitflags",
+ "indexmap",
]
[[package]]
name = "wasmparser"
-version = "0.118.2"
+version = "0.222.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77f1154f1ab868e2a01d9834a805faca7bf8b50d041b4ca714d005d0dab1c50c"
+checksum = "fa210fd1788e6b37a1d1930f3389c48e1d6ebd1a013d34fa4b7f9e3e3bf03146"
dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.229.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc3b1f053f5d41aa55640a1fa9b6d1b8a9e4418d118ce308d20e24ff3575a8c"
+dependencies = [
+ "bitflags",
+ "hashbrown",
"indexmap",
"semver",
+ "serde",
+]
+
+[[package]]
+name = "wast"
+version = "229.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63fcaff613c12225696bb163f79ca38ffb40e9300eff0ff4b8aa8b2f7eadf0d9"
+dependencies = [
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width 0.2.0",
+ "wasm-encoder 0.229.0",
+]
+
+[[package]]
+name = "wat"
+version = "1.229.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4189bad08b70455a9e9e67dc126d2dcf91fac143a80f1046747a5dde6d4c33e0"
+dependencies = [
+ "wast",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
]
[[package]]
@@ -6341,11 +5956,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-util"
-version = "0.1.8"
+version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -6356,42 +5971,116 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "windows"
-version = "0.52.0"
+version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+checksum = "7f919aee0a93304be7f62e8e5027811bbba96bcb1de84d6618be56e43f8a32a1"
dependencies = [
- "windows-core",
- "windows-targets 0.52.5",
+ "windows-core 0.59.0",
+ "windows-targets 0.53.0",
]
[[package]]
name = "windows-bindgen"
-version = "0.58.0"
+version = "0.61.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91cd28d93c692351f3a6e5615567c56756e330bee1c99c6bdd57bfc5ab15f589"
+checksum = "ac1c59c20569610dd9ed784d5f003fb493ec57b4cf39d974eb03a84bb7156c90"
dependencies = [
- "proc-macro2",
"rayon",
"serde",
"serde_json",
- "syn 2.0.67",
- "windows-metadata",
]
[[package]]
name = "windows-core"
-version = "0.52.0"
+version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+checksum = "810ce18ed2112484b0d4e15d022e5f598113e220c53e373fb31e67e21670c1ce"
dependencies = [
- "windows-targets 0.52.5",
+ "windows-implement 0.59.0",
+ "windows-interface",
+ "windows-result",
+ "windows-strings 0.3.1",
+ "windows-targets 0.53.0",
]
[[package]]
-name = "windows-metadata"
-version = "0.58.0"
+name = "windows-core"
+version = "0.61.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e837f3c3012cfe9e7086302a93f441a7999439be1ad4c530d55d2f6d2921809"
+checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
+dependencies = [
+ "windows-implement 0.60.0",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings 0.4.0",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83577b051e2f49a058c308f17f273b570a6a758386fc291b5f6a934dd84e48c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+
+[[package]]
+name = "windows-result"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87fa48cc5d406560701792be122a10132491cff9d0aeb23583cc2dcafc847319"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
+dependencies = [
+ "windows-link",
+]
[[package]]
name = "windows-sys"
@@ -6408,7 +6097,16 @@ version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
dependencies = [
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
]
[[package]]
@@ -6428,18 +6126,34 @@ dependencies = [
[[package]]
name = "windows-targets"
-version = "0.52.5"
+version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
dependencies = [
- "windows_aarch64_gnullvm 0.52.5",
- "windows_aarch64_msvc 0.52.5",
- "windows_i686_gnu 0.52.5",
- "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.5",
- "windows_x86_64_gnu 0.52.5",
- "windows_x86_64_gnullvm 0.52.5",
- "windows_x86_64_msvc 0.52.5",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1e4c7e8ceaaf9cb7d7507c974735728ab453b67ef8f18febdd7c11fe59dca8b"
+dependencies = [
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
]
[[package]]
@@ -6450,9 +6164,15 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
[[package]]
name = "windows_aarch64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
[[package]]
name = "windows_aarch64_msvc"
@@ -6462,9 +6182,15 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
[[package]]
name = "windows_aarch64_msvc"
-version = "0.52.5"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
[[package]]
name = "windows_i686_gnu"
@@ -6474,15 +6200,27 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
[[package]]
name = "windows_i686_gnu"
-version = "0.52.5"
+version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
[[package]]
name = "windows_i686_gnullvm"
-version = "0.52.5"
+version = "0.53.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
[[package]]
name = "windows_i686_msvc"
@@ -6492,9 +6230,15 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
[[package]]
name = "windows_i686_msvc"
-version = "0.52.5"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
[[package]]
name = "windows_x86_64_gnu"
@@ -6504,9 +6248,15 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
[[package]]
name = "windows_x86_64_gnu"
-version = "0.52.5"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
[[package]]
name = "windows_x86_64_gnullvm"
@@ -6516,9 +6266,15 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
[[package]]
name = "windows_x86_64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
[[package]]
name = "windows_x86_64_msvc"
@@ -6528,9 +6284,15 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
[[package]]
name = "windows_x86_64_msvc"
-version = "0.52.5"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
[[package]]
name = "winnow"
@@ -6543,36 +6305,91 @@ dependencies = [
[[package]]
name = "winnow"
-version = "0.6.13"
+version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b5e5f6c299a3c7890b876a2a587f3115162487e704907d9b6cd29473052ba1"
+checksum = "63d3fcd9bba44b03821e7d699eeee959f3126dcc4aa8e4ae18ec617c2a5cea10"
dependencies = [
"memchr",
]
+[[package]]
+name = "winsplit"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ab703352da6a72f35c39a533526393725640575bb211f61987a2748323ad956"
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.229.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f550067740e223bfe6c4878998e81cdbe2529dd9a793dc49248dd6613394e8b"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder 0.229.0",
+ "wasm-metadata",
+ "wasmparser 0.229.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.229.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "459c6ba62bf511d6b5f2a845a2a736822e38059c1cfa0b644b467bbbfae4efa6"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.229.0",
+]
+
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
[[package]]
name = "writeable"
version = "0.5.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
+[[package]]
+name = "x"
+version = "0.1.1"
+
[[package]]
name = "xattr"
-version = "1.3.1"
+version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f"
+checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e"
dependencies = [
"libc",
- "linux-raw-sys",
"rustix",
]
-[[package]]
-name = "xmlparser"
-version = "0.13.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
-
[[package]]
name = "xz2"
version = "0.1.7"
@@ -6582,15 +6399,6 @@ dependencies = [
"lzma-sys",
]
-[[package]]
-name = "yaml-rust"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
-dependencies = [
- "linked-hash-map",
-]
-
[[package]]
name = "yansi-term"
version = "0.1.2"
@@ -6602,9 +6410,9 @@ dependencies = [
[[package]]
name = "yoke"
-version = "0.7.4"
+version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c5b1314b079b0930c31e3af543d8ee1757b1951ae1e1565ec704403a7240ca5"
+checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
dependencies = [
"serde",
"stable_deref_trait",
@@ -6614,62 +6422,62 @@ dependencies = [
[[package]]
name = "yoke-derive"
-version = "0.7.4"
+version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95"
+checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
"synstructure",
]
[[package]]
name = "zerocopy"
-version = "0.7.34"
+version = "0.8.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae87e3fcd617500e5d106f0380cf7b77f3c6092aae37191433159dda23cfb087"
+checksum = "2586fea28e186957ef732a5f8b3be2da217d65c5969d4b1e17f973ebbe876879"
dependencies = [
"zerocopy-derive",
]
[[package]]
name = "zerocopy-derive"
-version = "0.7.34"
+version = "0.8.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
+checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
[[package]]
name = "zerofrom"
-version = "0.1.4"
+version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ec111ce797d0e0784a1116d0ddcdbea84322cd79e5d5ad173daeba4f93ab55"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
dependencies = [
"zerofrom-derive",
]
[[package]]
name = "zerofrom-derive"
-version = "0.1.4"
+version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
"synstructure",
]
[[package]]
name = "zerovec"
-version = "0.10.2"
+version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2cc8827d6c0994478a15c53f374f46fbd41bea663d809b14744bc42e6b109c"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
dependencies = [
"yoke",
"zerofrom",
@@ -6678,11 +6486,11 @@ dependencies = [
[[package]]
name = "zerovec-derive"
-version = "0.10.2"
+version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97cf56601ee5052b4417d90c8755c6683473c926039908196cf35d99f893ebe7"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.67",
+ "syn 2.0.100",
]
diff --git a/Cargo.toml b/Cargo.toml
index 93c520b0d689d..16ff0f61593ae 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,50 +1,53 @@
[workspace]
-resolver = "1"
+resolver = "2"
members = [
+# tidy-alphabetical-start
"compiler/rustc",
- "library/std",
- "library/sysroot",
+ "src/build_helper",
+ "src/etc/test-float-parse",
+ "src/rustc-std-workspace/rustc-std-workspace-alloc",
+ "src/rustc-std-workspace/rustc-std-workspace-core",
+ "src/rustc-std-workspace/rustc-std-workspace-std",
"src/rustdoc-json-types",
- "src/tools/build_helper",
+ "src/tools/build-manifest",
+ "src/tools/bump-stage0",
"src/tools/cargotest",
"src/tools/clippy",
"src/tools/clippy/clippy_dev",
+ "src/tools/collect-license-metadata",
"src/tools/compiletest",
- "src/tools/run-make-support",
- "src/tools/error_index_generator",
+ "src/tools/coverage-dump",
+ "src/tools/features-status-dump",
+ "src/tools/generate-copyright",
+ "src/tools/generate-windows-sys",
+ "src/tools/html-checker",
+ "src/tools/jsondocck",
+ "src/tools/jsondoclint",
"src/tools/linkchecker",
"src/tools/lint-docs",
+ "src/tools/lld-wrapper",
+ "src/tools/llvm-bitcode-linker",
+ "src/tools/miri",
+ "src/tools/miri/cargo-miri",
"src/tools/miropt-test-tools",
- "src/tools/rustbook",
- "src/tools/unstable-book-gen",
- "src/tools/tidy",
- "src/tools/tier-check",
- "src/tools/build-manifest",
+ "src/tools/opt-dist",
"src/tools/remote-test-client",
"src/tools/remote-test-server",
+ "src/tools/replace-version-placeholder",
+ "src/tools/run-make-support",
"src/tools/rust-installer",
"src/tools/rustdoc",
- "src/tools/rls",
- "src/tools/rustfmt",
- "src/tools/miri",
- "src/tools/miri/cargo-miri",
+ "src/tools/rustdoc-gui-test",
"src/tools/rustdoc-themes",
- "src/tools/unicode-table-generator",
- "src/tools/jsondocck",
- "src/tools/jsondoclint",
- "src/tools/llvm-bitcode-linker",
- "src/tools/html-checker",
- "src/tools/bump-stage0",
- "src/tools/replace-version-placeholder",
- "src/tools/lld-wrapper",
- "src/tools/collect-license-metadata",
- "src/tools/generate-copyright",
+ "src/tools/rustfmt",
"src/tools/suggest-tests",
- "src/tools/generate-windows-sys",
- "src/tools/rustdoc-gui-test",
- "src/tools/opt-dist",
- "src/tools/coverage-dump",
- "src/tools/rustc-perf-wrapper",
+ "src/tools/tidy",
+ "src/tools/tier-check",
+ "src/tools/unicode-table-generator",
+ "src/tools/unstable-book-gen",
+ "src/tools/wasm-component-ld",
+ "src/tools/x",
+# tidy-alphabetical-end
]
exclude = [
@@ -55,28 +58,8 @@ exclude = [
"tests/rustdoc-gui",
# HACK(eddyb) This hardcodes the fact that our CI uses `/checkout/obj`.
"obj",
- # The `x` binary is a thin wrapper that calls `x.py`, which initializes
- # submodules, before which workspace members cannot be invoked because
- # not all `Cargo.toml` files are available, so we exclude the `x` binary,
- # so it can be invoked before the current checkout is set up.
- "src/tools/x",
- # stdarch has its own Cargo workspace
- "library/stdarch",
]
-[profile.release.package.compiler_builtins]
-# For compiler-builtins we always use a high number of codegen units.
-# The goal here is to place every single intrinsic into its own object
-# file to avoid symbol clashes with the system libgcc if possible. Note
-# that this number doesn't actually produce this many object files, we
-# just don't create more than this number of object files.
-#
-# It's a bit of a bummer that we have to pass this here, unfortunately.
-# Ideally this would be specified through an env var to Cargo so Cargo
-# knows how many CGUs are for this specific crate, but for now
-# per-crate configuration isn't specifiable in the environment.
-codegen-units = 10000
-
[profile.release.package.rustc-rayon-core]
# The rustc fork of Rayon has deadlock detection code which intermittently
# causes overflows in the CI (see https://github.com/rust-lang/rust/issues/90227)
@@ -84,19 +67,6 @@ codegen-units = 10000
# FIXME: This workaround should be removed once #90227 is fixed.
overflow-checks = false
-# These dependencies of the standard library implement symbolication for
-# backtraces on most platforms. Their debuginfo causes both linking to be slower
-# (more data to chew through) and binaries to be larger without really all that
-# much benefit. This section turns them all to down to have no debuginfo which
-# helps to improve link times a little bit.
-[profile.release.package]
-addr2line.debug = 0
-adler.debug = 0
-gimli.debug = 0
-miniz_oxide.debug = 0
-object.debug = 0
-rustc-demangle.debug = 0
-
# These are very thin wrappers around executing lld with the right binary name.
# Basically nothing within them can go wrong without having been explicitly logged anyway.
# We ship these in every rustc tarball and even after compression they add up
@@ -104,10 +74,18 @@ rustc-demangle.debug = 0
[profile.release.package.lld-wrapper]
debug = 0
strip = true
+[profile.release.package.wasm-component-ld-wrapper]
+debug = 0
+strip = true
+
+# Bigint libraries are slow without optimization, speed up testing
+[profile.dev.package.test-float-parse]
+opt-level = 3
-[patch.crates-io]
-# See comments in `library/rustc-std-workspace-core/README.md` for what's going on
-# here
-rustc-std-workspace-core = { path = 'library/rustc-std-workspace-core' }
-rustc-std-workspace-alloc = { path = 'library/rustc-std-workspace-alloc' }
-rustc-std-workspace-std = { path = 'library/rustc-std-workspace-std' }
+# Speed up the binary as much as possible
+[profile.release.package.test-float-parse]
+opt-level = 3
+codegen-units = 1
+# FIXME: LTO cannot be enabled for binaries in a workspace
+# <https://github.com/rust-lang/cargo/issues/9330>
+# lto = true
diff --git a/INSTALL.md b/INSTALL.md
index ded0b59fc6cd3..98eb825cd10f6 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -6,9 +6,9 @@ If you just want to install Rust, check out the [README.md](README.md) instead.*
The Rust build system uses a Python script called `x.py` to build the compiler,
which manages the bootstrapping process. It lives at the root of the project.
-It also uses a file named `config.toml` to determine various configuration
+It also uses a file named `bootstrap.toml` to determine various configuration
settings for the build. You can see a full list of options in
-`config.example.toml`.
+`bootstrap.example.toml`.
The `x.py` command can be run directly on most Unix systems in the following
format:
@@ -75,13 +75,50 @@ See [the rustc-dev-guide for more info][sysllvm].
2. Configure the build settings:
+ If you're unsure which build configurations to use and need a good default, you
+ can run the interactive `x.py setup` command. This will guide you through selecting
+ a config profile, setting up the LSP, configuring a Git hook, etc.
+
+ With `configure` script, you can handle multiple configurations in a single
+ command which is useful to create complex/advanced config files. For example:
+
```sh
- ./configure
+ ./configure --build=aarch64-unknown-linux-gnu \
+ --enable-full-tools \
+ --enable-profiler \
+ --enable-sanitizers \
+ --enable-compiler-docs \
+ --set target.aarch64-unknown-linux-gnu.linker=clang \
+ --set target.aarch64-unknown-linux-gnu.ar=/rustroot/bin/llvm-ar \
+ --set target.aarch64-unknown-linux-gnu.ranlib=/rustroot/bin/llvm-ranlib \
+ --set llvm.link-shared=true \
+ --set llvm.thin-lto=true \
+ --set llvm.libzstd=true \
+ --set llvm.ninja=false \
+ --set rust.debug-assertions=false \
+ --set rust.jemalloc \
+ --set rust.use-lld=true \
+ --set rust.lto=thin \
+ --set rust.codegen-units=1
+ ```
+
+ If you plan to use `x.py install` to create an installation, you can either
+ set `DESTDIR` environment variable to your custom directory path:
+
+ ```bash
+ export DESTDIR=<path>
```
- If you plan to use `x.py install` to create an installation, it is
- recommended that you set the `prefix` value in the `[install]` section to a
- directory: `./configure --set install.prefix=<path>`
+ or set `prefix` and `sysconfdir` in the `[install]` section to your custom
+ directory path:
+
+ ```sh
+ ./configure --set install.prefix=<path> --set install.sysconfdir=<path>
+ ```
+
+ When the `DESTDIR` environment variable is present, the `prefix` and
+ `sysconfdir` values are combined with the path from the `DESTDIR`
+ environment variable.
3. Build and install:
@@ -101,7 +138,7 @@ See [the rustc-dev-guide for more info][sysllvm].
This project provides a configure script and makefile (the latter of which just
invokes `x.py`). `./configure` is the recommended way to programmatically
-generate a `config.toml`. `make` is not recommended (we suggest using `x.py`
+generate a `bootstrap.toml`. `make` is not recommended (we suggest using `x.py`
directly), but it is supported and we try not to break it unnecessarily.
```sh
@@ -109,7 +146,7 @@ directly), but it is supported and we try not to break it unnecessarily.
make && sudo make install
```
-`configure` generates a `config.toml` which can also be used with normal `x.py`
+`configure` generates a `bootstrap.toml` which can also be used with normal `x.py`
invocations.
## Building on Windows
@@ -196,9 +233,13 @@ itself back on after some time).
### MSVC
-MSVC builds of Rust additionally require an installation of Visual Studio 2017
-(or later) so `rustc` can use its linker. The simplest way is to get
-[Visual Studio], check the "C++ build tools" and "Windows 10 SDK" workload.
+MSVC builds of Rust additionally requires an installation of:
+
+- Visual Studio 2022 (or later) build tools so `rustc` can use its linker. Older
+ Visual Studio versions such as 2019 *may* work but aren't actively tested.
+- A recent Windows 10 or 11 SDK.
+
+The simplest way is to get [Visual Studio], check the "C++ build tools".
[Visual Studio]: https://visualstudio.microsoft.com/downloads/
@@ -237,7 +278,7 @@ Windows build triples are:
- `x86_64-pc-windows-msvc`
The build triple can be specified by either specifying `--build=<triple>` when
-invoking `x.py` commands, or by creating a `config.toml` file (as described in
+invoking `x.py` commands, or by creating a `bootstrap.toml` file (as described in
[Building on a Unix-like system](#building-on-a-unix-like-system)), and passing
`--set build.build=<triple>` to `./configure`.
diff --git a/LICENSE-MIT b/LICENSE-MIT
index 31aa79387f27e..a2070c4be7acd 100644
--- a/LICENSE-MIT
+++ b/LICENSE-MIT
@@ -1,3 +1,5 @@
+Copyright (c) The Rust Project Contributors
+
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
diff --git a/LICENSES/CC-BY-3.0.txt b/LICENSES/CC-BY-3.0.txt
deleted file mode 100644
index bd32fa8477bdb..0000000000000
--- a/LICENSES/CC-BY-3.0.txt
+++ /dev/null
@@ -1,319 +0,0 @@
-Creative Commons Legal Code
-
-Attribution 3.0 Unported
-
- CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
- LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN
- ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
- INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
- REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR
- DAMAGES RESULTING FROM ITS USE.
-
-License
-
-THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE
-COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY
-COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS
-AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.
-
-BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE
-TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY
-BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS
-CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND
-CONDITIONS.
-
-1. Definitions
-
- a. "Adaptation" means a work based upon the Work, or upon the Work and
- other pre-existing works, such as a translation, adaptation,
- derivative work, arrangement of music or other alterations of a
- literary or artistic work, or phonogram or performance and includes
- cinematographic adaptations or any other form in which the Work may be
- recast, transformed, or adapted including in any form recognizably
- derived from the original, except that a work that constitutes a
- Collection will not be considered an Adaptation for the purpose of
- this License. For the avoidance of doubt, where the Work is a musical
- work, performance or phonogram, the synchronization of the Work in
- timed-relation with a moving image ("synching") will be considered an
- Adaptation for the purpose of this License.
- b. "Collection" means a collection of literary or artistic works, such as
- encyclopedias and anthologies, or performances, phonograms or
- broadcasts, or other works or subject matter other than works listed
- in Section 1(f) below, which, by reason of the selection and
- arrangement of their contents, constitute intellectual creations, in
- which the Work is included in its entirety in unmodified form along
- with one or more other contributions, each constituting separate and
- independent works in themselves, which together are assembled into a
- collective whole. A work that constitutes a Collection will not be
- considered an Adaptation (as defined above) for the purposes of this
- License.
- c. "Distribute" means to make available to the public the original and
- copies of the Work or Adaptation, as appropriate, through sale or
- other transfer of ownership.
- d. "Licensor" means the individual, individuals, entity or entities that
- offer(s) the Work under the terms of this License.
- e. "Original Author" means, in the case of a literary or artistic work,
- the individual, individuals, entity or entities who created the Work
- or if no individual or entity can be identified, the publisher; and in
- addition (i) in the case of a performance the actors, singers,
- musicians, dancers, and other persons who act, sing, deliver, declaim,
- play in, interpret or otherwise perform literary or artistic works or
- expressions of folklore; (ii) in the case of a phonogram the producer
- being the person or legal entity who first fixes the sounds of a
- performance or other sounds; and, (iii) in the case of broadcasts, the
- organization that transmits the broadcast.
- f. "Work" means the literary and/or artistic work offered under the terms
- of this License including without limitation any production in the
- literary, scientific and artistic domain, whatever may be the mode or
- form of its expression including digital form, such as a book,
- pamphlet and other writing; a lecture, address, sermon or other work
- of the same nature; a dramatic or dramatico-musical work; a
- choreographic work or entertainment in dumb show; a musical
- composition with or without words; a cinematographic work to which are
- assimilated works expressed by a process analogous to cinematography;
- a work of drawing, painting, architecture, sculpture, engraving or
- lithography; a photographic work to which are assimilated works
- expressed by a process analogous to photography; a work of applied
- art; an illustration, map, plan, sketch or three-dimensional work
- relative to geography, topography, architecture or science; a
- performance; a broadcast; a phonogram; a compilation of data to the
- extent it is protected as a copyrightable work; or a work performed by
- a variety or circus performer to the extent it is not otherwise
- considered a literary or artistic work.
- g. "You" means an individual or entity exercising rights under this
- License who has not previously violated the terms of this License with
- respect to the Work, or who has received express permission from the
- Licensor to exercise rights under this License despite a previous
- violation.
- h. "Publicly Perform" means to perform public recitations of the Work and
- to communicate to the public those public recitations, by any means or
- process, including by wire or wireless means or public digital
- performances; to make available to the public Works in such a way that
- members of the public may access these Works from a place and at a
- place individually chosen by them; to perform the Work to the public
- by any means or process and the communication to the public of the
- performances of the Work, including by public digital performance; to
- broadcast and rebroadcast the Work by any means including signs,
- sounds or images.
- i. "Reproduce" means to make copies of the Work by any means including
- without limitation by sound or visual recordings and the right of
- fixation and reproducing fixations of the Work, including storage of a
- protected performance or phonogram in digital form or other electronic
- medium.
-
-2. Fair Dealing Rights. Nothing in this License is intended to reduce,
-limit, or restrict any uses free from copyright or rights arising from
-limitations or exceptions that are provided for in connection with the
-copyright protection under copyright law or other applicable laws.
-
-3. License Grant. Subject to the terms and conditions of this License,
-Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
-perpetual (for the duration of the applicable copyright) license to
-exercise the rights in the Work as stated below:
-
- a. to Reproduce the Work, to incorporate the Work into one or more
- Collections, and to Reproduce the Work as incorporated in the
- Collections;
- b. to create and Reproduce Adaptations provided that any such Adaptation,
- including any translation in any medium, takes reasonable steps to
- clearly label, demarcate or otherwise identify that changes were made
- to the original Work. For example, a translation could be marked "The
- original work was translated from English to Spanish," or a
- modification could indicate "The original work has been modified.";
- c. to Distribute and Publicly Perform the Work including as incorporated
- in Collections; and,
- d. to Distribute and Publicly Perform Adaptations.
- e. For the avoidance of doubt:
-
- i. Non-waivable Compulsory License Schemes. In those jurisdictions in
- which the right to collect royalties through any statutory or
- compulsory licensing scheme cannot be waived, the Licensor
- reserves the exclusive right to collect such royalties for any
- exercise by You of the rights granted under this License;
- ii. Waivable Compulsory License Schemes. In those jurisdictions in
- which the right to collect royalties through any statutory or
- compulsory licensing scheme can be waived, the Licensor waives the
- exclusive right to collect such royalties for any exercise by You
- of the rights granted under this License; and,
- iii. Voluntary License Schemes. The Licensor waives the right to
- collect royalties, whether individually or, in the event that the
- Licensor is a member of a collecting society that administers
- voluntary licensing schemes, via that society, from any exercise
- by You of the rights granted under this License.
-
-The above rights may be exercised in all media and formats whether now
-known or hereafter devised. The above rights include the right to make
-such modifications as are technically necessary to exercise the rights in
-other media and formats. Subject to Section 8(f), all rights not expressly
-granted by Licensor are hereby reserved.
-
-4. Restrictions. The license granted in Section 3 above is expressly made
-subject to and limited by the following restrictions:
-
- a. You may Distribute or Publicly Perform the Work only under the terms
- of this License. You must include a copy of, or the Uniform Resource
- Identifier (URI) for, this License with every copy of the Work You
- Distribute or Publicly Perform. You may not offer or impose any terms
- on the Work that restrict the terms of this License or the ability of
- the recipient of the Work to exercise the rights granted to that
- recipient under the terms of the License. You may not sublicense the
- Work. You must keep intact all notices that refer to this License and
- to the disclaimer of warranties with every copy of the Work You
- Distribute or Publicly Perform. When You Distribute or Publicly
- Perform the Work, You may not impose any effective technological
- measures on the Work that restrict the ability of a recipient of the
- Work from You to exercise the rights granted to that recipient under
- the terms of the License. This Section 4(a) applies to the Work as
- incorporated in a Collection, but this does not require the Collection
- apart from the Work itself to be made subject to the terms of this
- License. If You create a Collection, upon notice from any Licensor You
- must, to the extent practicable, remove from the Collection any credit
- as required by Section 4(b), as requested. If You create an
- Adaptation, upon notice from any Licensor You must, to the extent
- practicable, remove from the Adaptation any credit as required by
- Section 4(b), as requested.
- b. If You Distribute, or Publicly Perform the Work or any Adaptations or
- Collections, You must, unless a request has been made pursuant to
- Section 4(a), keep intact all copyright notices for the Work and
- provide, reasonable to the medium or means You are utilizing: (i) the
- name of the Original Author (or pseudonym, if applicable) if supplied,
- and/or if the Original Author and/or Licensor designate another party
- or parties (e.g., a sponsor institute, publishing entity, journal) for
- attribution ("Attribution Parties") in Licensor's copyright notice,
- terms of service or by other reasonable means, the name of such party
- or parties; (ii) the title of the Work if supplied; (iii) to the
- extent reasonably practicable, the URI, if any, that Licensor
- specifies to be associated with the Work, unless such URI does not
- refer to the copyright notice or licensing information for the Work;
- and (iv) , consistent with Section 3(b), in the case of an Adaptation,
- a credit identifying the use of the Work in the Adaptation (e.g.,
- "French translation of the Work by Original Author," or "Screenplay
- based on original Work by Original Author"). The credit required by
- this Section 4 (b) may be implemented in any reasonable manner;
- provided, however, that in the case of a Adaptation or Collection, at
- a minimum such credit will appear, if a credit for all contributing
- authors of the Adaptation or Collection appears, then as part of these
- credits and in a manner at least as prominent as the credits for the
- other contributing authors. For the avoidance of doubt, You may only
- use the credit required by this Section for the purpose of attribution
- in the manner set out above and, by exercising Your rights under this
- License, You may not implicitly or explicitly assert or imply any
- connection with, sponsorship or endorsement by the Original Author,
- Licensor and/or Attribution Parties, as appropriate, of You or Your
- use of the Work, without the separate, express prior written
- permission of the Original Author, Licensor and/or Attribution
- Parties.
- c. Except as otherwise agreed in writing by the Licensor or as may be
- otherwise permitted by applicable law, if You Reproduce, Distribute or
- Publicly Perform the Work either by itself or as part of any
- Adaptations or Collections, You must not distort, mutilate, modify or
- take other derogatory action in relation to the Work which would be
- prejudicial to the Original Author's honor or reputation. Licensor
- agrees that in those jurisdictions (e.g. Japan), in which any exercise
- of the right granted in Section 3(b) of this License (the right to
- make Adaptations) would be deemed to be a distortion, mutilation,
- modification or other derogatory action prejudicial to the Original
- Author's honor and reputation, the Licensor will waive or not assert,
- as appropriate, this Section, to the fullest extent permitted by the
- applicable national law, to enable You to reasonably exercise Your
- right under Section 3(b) of this License (right to make Adaptations)
- but not otherwise.
-
-5. Representations, Warranties and Disclaimer
-
-UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR
-OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY
-KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE,
-INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY,
-FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF
-LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS,
-WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION
-OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.
-
-6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE
-LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR
-ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES
-ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS
-BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-7. Termination
-
- a. This License and the rights granted hereunder will terminate
- automatically upon any breach by You of the terms of this License.
- Individuals or entities who have received Adaptations or Collections
- from You under this License, however, will not have their licenses
- terminated provided such individuals or entities remain in full
- compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will
- survive any termination of this License.
- b. Subject to the above terms and conditions, the license granted here is
- perpetual (for the duration of the applicable copyright in the Work).
- Notwithstanding the above, Licensor reserves the right to release the
- Work under different license terms or to stop distributing the Work at
- any time; provided, however that any such election will not serve to
- withdraw this License (or any other license that has been, or is
- required to be, granted under the terms of this License), and this
- License will continue in full force and effect unless terminated as
- stated above.
-
-8. Miscellaneous
-
- a. Each time You Distribute or Publicly Perform the Work or a Collection,
- the Licensor offers to the recipient a license to the Work on the same
- terms and conditions as the license granted to You under this License.
- b. Each time You Distribute or Publicly Perform an Adaptation, Licensor
- offers to the recipient a license to the original Work on the same
- terms and conditions as the license granted to You under this License.
- c. If any provision of this License is invalid or unenforceable under
- applicable law, it shall not affect the validity or enforceability of
- the remainder of the terms of this License, and without further action
- by the parties to this agreement, such provision shall be reformed to
- the minimum extent necessary to make such provision valid and
- enforceable.
- d. No term or provision of this License shall be deemed waived and no
- breach consented to unless such waiver or consent shall be in writing
- and signed by the party to be charged with such waiver or consent.
- e. This License constitutes the entire agreement between the parties with
- respect to the Work licensed here. There are no understandings,
- agreements or representations with respect to the Work not specified
- here. Licensor shall not be bound by any additional provisions that
- may appear in any communication from You. This License may not be
- modified without the mutual written agreement of the Licensor and You.
- f. The rights granted under, and the subject matter referenced, in this
- License were drafted utilizing the terminology of the Berne Convention
- for the Protection of Literary and Artistic Works (as amended on
- September 28, 1979), the Rome Convention of 1961, the WIPO Copyright
- Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996
- and the Universal Copyright Convention (as revised on July 24, 1971).
- These rights and subject matter take effect in the relevant
- jurisdiction in which the License terms are sought to be enforced
- according to the corresponding provisions of the implementation of
- those treaty provisions in the applicable national law. If the
- standard suite of rights granted under applicable copyright law
- includes additional rights not granted under this License, such
- additional rights are deemed to be included in the License; this
- License is not intended to restrict the license of any rights under
- applicable law.
-
-
-Creative Commons Notice
-
- Creative Commons is not a party to this License, and makes no warranty
- whatsoever in connection with the Work. Creative Commons will not be
- liable to You or any party on any legal theory for any damages
- whatsoever, including without limitation any general, special,
- incidental or consequential damages arising in connection to this
- license. Notwithstanding the foregoing two (2) sentences, if Creative
- Commons has expressly identified itself as the Licensor hereunder, it
- shall have all rights and obligations of Licensor.
-
- Except for the limited purpose of indicating to the public that the
- Work is licensed under the CCPL, Creative Commons does not authorize
- the use by either party of the trademark "Creative Commons" or any
- related trademark or logo of Creative Commons without the prior
- written consent of Creative Commons. Any permitted use will be in
- compliance with Creative Commons' then-current trademark usage
- guidelines, as may be published on its website or otherwise made
- available upon request from time to time. For the avoidance of doubt,
- this trademark restriction does not form part of this License.
-
- Creative Commons may be contacted at https://creativecommons.org/.
\ No newline at end of file
diff --git a/LICENSES/CC0-1.0.txt b/LICENSES/CC0-1.0.txt
deleted file mode 100644
index 0e259d42c9967..0000000000000
--- a/LICENSES/CC0-1.0.txt
+++ /dev/null
@@ -1,121 +0,0 @@
-Creative Commons Legal Code
-
-CC0 1.0 Universal
-
- CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
- LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
- ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
- INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
- REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
- PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
- THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
- HEREUNDER.
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator
-and subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for
-the purpose of contributing to a commons of creative, cultural and
-scientific works ("Commons") that the public can reliably and without fear
-of later claims of infringement build upon, modify, incorporate in other
-works, reuse and redistribute as freely as possible in any form whatsoever
-and for any purposes, including without limitation commercial purposes.
-These owners may contribute to the Commons to promote the ideal of a free
-culture and the further production of creative, cultural and scientific
-works, or to gain reputation or greater distribution for their Work in
-part through the use and efforts of others.
-
-For these and/or other purposes and motivations, and without any
-expectation of additional consideration or compensation, the person
-associating CC0 with a Work (the "Affirmer"), to the extent that he or she
-is an owner of Copyright and Related Rights in the Work, voluntarily
-elects to apply CC0 to the Work and publicly distribute the Work under its
-terms, with knowledge of his or her Copyright and Related Rights in the
-Work and the meaning and intended legal effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not
-limited to, the following:
-
- i. the right to reproduce, adapt, distribute, perform, display,
- communicate, and translate a Work;
- ii. moral rights retained by the original author(s) and/or performer(s);
-iii. publicity and privacy rights pertaining to a person's image or
- likeness depicted in a Work;
- iv. rights protecting against unfair competition in regards to a Work,
- subject to the limitations in paragraph 4(a), below;
- v. rights protecting the extraction, dissemination, use and reuse of data
- in a Work;
- vi. database rights (such as those arising under Directive 96/9/EC of the
- European Parliament and of the Council of 11 March 1996 on the legal
- protection of databases, and under any national implementation
- thereof, including any amended or successor version of such
- directive); and
-vii. other similar, equivalent or corresponding rights throughout the
- world based on applicable law or treaty, and any national
- implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention
-of, applicable law, Affirmer hereby overtly, fully, permanently,
-irrevocably and unconditionally waives, abandons, and surrenders all of
-Affirmer's Copyright and Related Rights and associated claims and causes
-of action, whether now known or unknown (including existing as well as
-future claims and causes of action), in the Work (i) in all territories
-worldwide, (ii) for the maximum duration provided by applicable law or
-treaty (including future time extensions), (iii) in any current or future
-medium and for any number of copies, and (iv) for any purpose whatsoever,
-including without limitation commercial, advertising or promotional
-purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
-member of the public at large and to the detriment of Affirmer's heirs and
-successors, fully intending that such Waiver shall not be subject to
-revocation, rescission, cancellation, termination, or any other legal or
-equitable action to disrupt the quiet enjoyment of the Work by the public
-as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason
-be judged legally invalid or ineffective under applicable law, then the
-Waiver shall be preserved to the maximum extent permitted taking into
-account Affirmer's express Statement of Purpose. In addition, to the
-extent the Waiver is so judged Affirmer hereby grants to each affected
-person a royalty-free, non transferable, non sublicensable, non exclusive,
-irrevocable and unconditional license to exercise Affirmer's Copyright and
-Related Rights in the Work (i) in all territories worldwide, (ii) for the
-maximum duration provided by applicable law or treaty (including future
-time extensions), (iii) in any current or future medium and for any number
-of copies, and (iv) for any purpose whatsoever, including without
-limitation commercial, advertising or promotional purposes (the
-"License"). The License shall be deemed effective as of the date CC0 was
-applied by Affirmer to the Work. Should any part of the License for any
-reason be judged legally invalid or ineffective under applicable law, such
-partial invalidity or ineffectiveness shall not invalidate the remainder
-of the License, and in such case Affirmer hereby affirms that he or she
-will not (i) exercise any of his or her remaining Copyright and Related
-Rights in the Work or (ii) assert any associated claims and causes of
-action with respect to the Work, in either case contrary to Affirmer's
-express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
- a. No trademark or patent rights held by Affirmer are waived, abandoned,
- surrendered, licensed or otherwise affected by this document.
- b. Affirmer offers the Work as-is and makes no representations or
- warranties of any kind concerning the Work, express, implied,
- statutory or otherwise, including without limitation warranties of
- title, merchantability, fitness for a particular purpose, non
- infringement, or the absence of latent or other defects, accuracy, or
- the present or absence of errors, whether or not discoverable, all to
- the greatest extent permissible under applicable law.
- c. Affirmer disclaims responsibility for clearing rights of other persons
- that may apply to the Work or any use thereof, including without
- limitation any person's Copyright and Related Rights in the Work.
- Further, Affirmer disclaims responsibility for obtaining any necessary
- consents, permissions or other rights required for any use of the
- Work.
- d. Affirmer understands and acknowledges that Creative Commons is not a
- party to this document and has no duty or obligation with respect to
- this CC0 or use of the Work.
diff --git a/LICENSES/GCC-exception-3.1.txt b/LICENSES/GCC-exception-3.1.txt
new file mode 100644
index 0000000000000..eecede4d0707e
--- /dev/null
+++ b/LICENSES/GCC-exception-3.1.txt
@@ -0,0 +1,30 @@
+GCC RUNTIME LIBRARY EXCEPTION
+
+Version 3.1, 31 March 2009
+
+Copyright © 2009 Free Software Foundation, Inc. <https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
+
+This GCC Runtime Library Exception ("Exception") is an additional permission under section 7 of the GNU General Public License, version 3 ("GPLv3"). It applies to a given file (the "Runtime Library") that bears a notice placed by the copyright holder of the file stating that the file is governed by GPLv3 along with this Exception.
+
+When you use GCC to compile a program, GCC may combine portions of certain GCC header files and runtime libraries with the compiled program. The purpose of this Exception is to allow compilation of non-GPL (including proprietary) programs to use, in this way, the header files and runtime libraries covered by this Exception.
+0. Definitions.
+
+A file is an "Independent Module" if it either requires the Runtime Library for execution after a Compilation Process, or makes use of an interface provided by the Runtime Library, but is not otherwise based on the Runtime Library.
+
+"GCC" means a version of the GNU Compiler Collection, with or without modifications, governed by version 3 (or a specified later version) of the GNU General Public License (GPL) with the option of using any subsequent versions published by the FSF.
+
+"GPL-compatible Software" is software whose conditions of propagation, modification and use would permit combination with GCC in accord with the license of GCC.
+
+"Target Code" refers to output from any compiler for a real or virtual target processor architecture, in executable form or suitable for input to an assembler, loader, linker and/or execution phase. Notwithstanding that, Target Code does not include data in any format that is used as a compiler intermediate representation, or used for producing a compiler intermediate representation.
+
+The "Compilation Process" transforms code entirely represented in non-intermediate languages designed for human-written code, and/or in Java Virtual Machine byte code, into Target Code. Thus, for example, use of source code generators and preprocessors need not be considered part of the Compilation Process, since the Compilation Process can be understood as starting with the output of the generators or preprocessors.
+
+A Compilation Process is "Eligible" if it is done using GCC, alone or with other GPL-compatible software, or if it is done without using any work based on GCC. For example, using non-GPL-compatible Software to optimize any GCC intermediate representations would not qualify as an Eligible Compilation Process.
+1. Grant of Additional Permission.
+
+You have permission to propagate a work of Target Code formed by combining the Runtime Library with Independent Modules, even if such propagation would otherwise violate the terms of GPLv3, provided that all Target Code was generated by Eligible Compilation Processes. You may then convey such a combination under terms of your choice, consistent with the licensing of the Independent Modules.
+2. No Weakening of GCC Copyleft.
+
+The availability of this Exception does not imply any general presumption that third-party software is unaffected by the copyleft requirements of the license of GCC.
diff --git a/LICENSES/GPL-2.0-only.txt b/LICENSES/GPL-2.0-only.txt
new file mode 100644
index 0000000000000..492485e09b411
--- /dev/null
+++ b/LICENSES/GPL-2.0-only.txt
@@ -0,0 +1,133 @@
+GNU GENERAL PUBLIC LICENSE
+
+Version 2, June 1991
+
+Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+Preamble
+
+The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.
+
+To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.
+
+For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.
+
+We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.
+
+Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.
+
+Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.
+
+The precise terms and conditions for copying, distribution and modification follow.
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.
+
+1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.
+ b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.
+ c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.
+
+3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
+ b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
+ c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.
+
+If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.
+
+4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
+
+5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.
+
+6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.
+
+7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.
+
+This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.
+
+8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.
+
+9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.
+
+10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.
+
+NO WARRANTY
+
+11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+END OF TERMS AND CONDITIONS
+How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.
+
+one line to give the program's name and an idea of what it does.
+Copyright (C) yyyy name of author
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this when it starts in an interactive mode:
+
+Gnomovision version 69, Copyright (C) year name of author
+Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
+type `show w'. This is free software, and you are welcome
+to redistribute it under certain conditions; type `show c'
+for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names:
+
+Yoyodyne, Inc., hereby disclaims all copyright
+interest in the program `Gnomovision'
+(which makes passes at compilers) written
+by James Hacker.
+
+signature of Ty Coon, 1 April 1989
+Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License.
diff --git a/LICENSES/GPL-3.0-or-later.txt b/LICENSES/GPL-3.0-or-later.txt
new file mode 100644
index 0000000000000..37b6b8e91b85e
--- /dev/null
+++ b/LICENSES/GPL-3.0-or-later.txt
@@ -0,0 +1,202 @@
+GNU GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright © 2007 Free Software Foundation, Inc. <https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
+
+Preamble
+
+The GNU General Public License is a free, copyleft license for software and other kinds of works.
+
+The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.
+
+For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.
+
+Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.
+
+Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and modification follow.
+
+TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based on the Program.
+
+ To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.
+ 1. Source Code.
+ The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work.
+
+ A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.
+
+ The Corresponding Source for a work in source code form is that same work.
+ 2. Basic Permissions.
+ All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary.
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+ No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.
+
+ When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.
+ 4. Conveying Verbatim Copies.
+ You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.
+ 5. Conveying Modified Source Versions.
+ You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:
+ a) The work must carry prominent notices stating that you modified it, and giving a relevant date.
+ b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices".
+ c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.
+ d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.
+
+ A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.
+ 6. Conveying Non-Source Forms.
+ You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:
+ a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.
+ b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.
+ c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.
+ d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.
+ e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.
+
+ If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).
+
+ The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.
+ 7. Additional Terms.
+ "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:
+ a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or
+ b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or
+ c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or
+ d) Limiting the use for publicity purposes of names of licensors or authors of the material; or
+ e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or
+ f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.
+
+ All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.
+ 8. Termination.
+ You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).
+
+ However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.
+ 9. Acceptance Not Required for Having Copies.
+ You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.
+ 10. Automatic Licensing of Downstream Recipients.
+ Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.
+ 11. Patents.
+ A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.
+ 12. No Surrender of Others' Freedom.
+ If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.
+ 13. Use with the GNU Affero General Public License.
+ Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.
+ 14. Revised Versions of this License.
+ The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.
+
+ Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.
+ 15. Disclaimer of Warranty.
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+ 16. Limitation of Liability.
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.
+
+END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.
+
+<one line to give the program's name and a brief idea of what it does.>
+Copyright (C) <year> <name of author>
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:
+
+<program> Copyright (C) <year> <name of author>
+This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box".
+
+You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read <https: //www.gnu.org/licenses/why-not-lgpl.html>.
diff --git a/LICENSES/ISC.txt b/LICENSES/ISC.txt
new file mode 100644
index 0000000000000..6f41c8c63b96e
--- /dev/null
+++ b/LICENSES/ISC.txt
@@ -0,0 +1,7 @@
+ISC License
+
+<copyright notice>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/LICENSES/Unicode-3.0.txt b/LICENSES/Unicode-3.0.txt
new file mode 100644
index 0000000000000..ee8e69b233293
--- /dev/null
+++ b/LICENSES/Unicode-3.0.txt
@@ -0,0 +1,39 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2024 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
diff --git a/LICENSES/Unicode-DFS-2016.txt b/LICENSES/Unicode-DFS-2016.txt
deleted file mode 100644
index 71fd6ac5e12e1..0000000000000
--- a/LICENSES/Unicode-DFS-2016.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
-
-Unicode Data Files include all data files under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and http://www.unicode.org/utility/trac/browser/.
-
-Unicode Data Files do not include PDF online code charts under the directory http://www.unicode.org/Public/.
-
-Software includes any source code published in the Unicode Standard or under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and http://www.unicode.org/utility/trac/browser/.
-
-NOTICE TO USER: Carefully read the following legal agreement. BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"), YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
-
-COPYRIGHT AND PERMISSION NOTICE
-
-Copyright © 1991-2016 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in http://www.unicode.org/copyright.html.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of the Unicode data files and any associated documentation (the "Data Files") or Unicode software and any associated documentation (the "Software") to deal in the Data Files or Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Data Files or Software, and to permit persons to whom the Data Files or Software are furnished to do so, provided that either
-
- (a) this copyright and permission notice appear with all copies of the Data Files or Software, or
- (b) this copyright and permission notice appear in associated Documentation.
-
-THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE.
-
-Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in these Data Files or Software without prior written authorization of the copyright holder.
diff --git a/README.md b/README.md
index 3690a9c93c528..611260470f12b 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@ standard library, and documentation.
## Why Rust?
-- **Performance:** Fast and memory-efficient, suitable for critical services, embedded devices, and easily integrate with other languages.
+- **Performance:** Fast and memory-efficient, suitable for critical services, embedded devices, and easily integrated with other languages.
- **Reliability:** Our rich type system and ownership model ensure memory and thread safety, reducing bugs at compile-time.
@@ -67,11 +67,11 @@ See [LICENSE-APACHE](LICENSE-APACHE), [LICENSE-MIT](LICENSE-MIT), and
trademarks and logos (the "Rust Trademarks").
If you want to use these names or brands, please read the
-[media guide][media-guide].
+[Rust language trademark policy][trademark-policy].
Third-party logos may be subject to third-party copyrights and trademarks. See
[Licenses][policies-licenses] for details.
-[rust-foundation]: https://foundation.rust-lang.org/
-[media-guide]: https://foundation.rust-lang.org/policies/logo-policy-and-media-guide/
+[rust-foundation]: https://rustfoundation.org/
+[trademark-policy]: https://rustfoundation.org/policy/rust-trademark-policy/
[policies-licenses]: https://www.rust-lang.org/policies/licenses
diff --git a/RELEASES.md b/RELEASES.md
index 9e658568dc9a1..0948eb85192e5 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,4 +1,932 @@
-Version 1.80 (2024-07-25)
+Version 1.86.0 (2025-04-03)
+==========================
+
+<a id="1.86.0-Language"></a>
+
+Language
+--------
+- [Stabilize upcasting trait objects to supertraits.](https://github.com/rust-lang/rust/pull/134367)
+- [Allow safe functions to be marked with the `#[target_feature]` attribute.](https://github.com/rust-lang/rust/pull/134090)
+- [The `missing_abi` lint now warns-by-default.](https://github.com/rust-lang/rust/pull/132397)
+- Rust now lints about double negations, to catch cases that might have intended to be a prefix decrement operator (`--x`) as written in other languages. This was previously a clippy lint, `clippy::double_neg`, and is [now available directly in Rust as `double_negations`.](https://github.com/rust-lang/rust/pull/126604)
+- [More pointers are now detected as definitely not-null based on their alignment in const eval.](https://github.com/rust-lang/rust/pull/133700)
+- [Empty `repr()` attribute applied to invalid items are now correctly rejected.](https://github.com/rust-lang/rust/pull/133925)
+- [Inner attributes `#![test]` and `#![rustfmt::skip]` are no longer accepted in more places than intended.](https://github.com/rust-lang/rust/pull/134276)
+
+<a id="1.86.0-Compiler"></a>
+
+Compiler
+--------
+- [Debug-assert that raw pointers are non-null on access.](https://github.com/rust-lang/rust/pull/134424)
+- [Change `-O` to mean `-C opt-level=3` instead of `-C opt-level=2` to match Cargo's defaults.](https://github.com/rust-lang/rust/pull/135439)
+- [Fix emission of `overflowing_literals` under certain macro environments.](https://github.com/rust-lang/rust/pull/136393)
+
+<a id="1.86.0-Platform-Support"></a>
+
+Platform Support
+----------------
+- [Replace `i686-unknown-redox` target with `i586-unknown-redox`.](https://github.com/rust-lang/rust/pull/136698)
+- [Increase baseline CPU of `i686-unknown-hurd-gnu` to Pentium 4.](https://github.com/rust-lang/rust/pull/136700)
+- New tier 3 targets:
+ - [`{aarch64-unknown,x86_64-pc}-nto-qnx710_iosock`](https://github.com/rust-lang/rust/pull/133631).
+ For supporting Neutrino QNX 7.1 with `io-socket` network stack.
+ - [`{aarch64-unknown,x86_64-pc}-nto-qnx800`](https://github.com/rust-lang/rust/pull/133631).
+ For supporting Neutrino QNX 8.0 (`no_std`-only).
+ - [`{x86_64,i686}-win7-windows-gnu`](https://github.com/rust-lang/rust/pull/134609).
+ Intended for backwards compatibility with Windows 7. `{x86_64,i686}-win7-windows-msvc` are the Windows MSVC counterparts that already exist as Tier 3 targets.
+ - [`amdgcn-amd-amdhsa`](https://github.com/rust-lang/rust/pull/134740).
+ - [`x86_64-pc-cygwin`](https://github.com/rust-lang/rust/pull/134999).
+ - [`{mips,mipsel}-mti-none-elf`](https://github.com/rust-lang/rust/pull/135074).
+ Initial bare-metal support.
+ - [`m68k-unknown-none-elf`](https://github.com/rust-lang/rust/pull/135085).
+ - [`armv7a-nuttx-{eabi,eabihf}`, `aarch64-unknown-nuttx`, and `thumbv7a-nuttx-{eabi,eabihf}`](https://github.com/rust-lang/rust/pull/135757).
+
+Refer to Rust's [platform support page][platform-support-doc]
+for more information on Rust's tiered platform support.
+
+<a id="1.86.0-Libraries"></a>
+
+Libraries
+---------
+- The type of `FromBytesWithNulError` in `CStr::from_bytes_with_nul(bytes: &[u8]) -> Result<&Self, FromBytesWithNulError>` was [changed from an opaque struct to an enum](https://github.com/rust-lang/rust/pull/134143), allowing users to examine why the conversion failed.
+- [Remove `RustcDecodable` and `RustcEncodable`.](https://github.com/rust-lang/rust/pull/134272)
+- [Deprecate libtest's `--logfile` option.](https://github.com/rust-lang/rust/pull/134283)
+- [On recent versions of Windows, `std::fs::remove_file` will now remove read-only files.](https://github.com/rust-lang/rust/pull/134679)
+
+<a id="1.86.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`{float}::next_down`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.next_down)
+- [`{float}::next_up`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.next_up)
+- [`<[_]>::get_disjoint_mut`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.get_disjoint_mut)
+- [`<[_]>::get_disjoint_unchecked_mut`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.get_disjoint_unchecked_mut)
+- [`slice::GetDisjointMutError`](https://doc.rust-lang.org/stable/std/slice/enum.GetDisjointMutError.html)
+- [`HashMap::get_disjoint_mut`](https://doc.rust-lang.org/std/collections/hash_map/struct.HashMap.html#method.get_disjoint_mut)
+- [`HashMap::get_disjoint_unchecked_mut`](https://doc.rust-lang.org/std/collections/hash_map/struct.HashMap.html#method.get_disjoint_unchecked_mut)
+- [`NonZero::count_ones`](https://doc.rust-lang.org/stable/std/num/struct.NonZero.html#method.count_ones)
+- [`Vec::pop_if`](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.pop_if)
+- [`sync::Once::wait`](https://doc.rust-lang.org/stable/std/sync/struct.Once.html#method.wait)
+- [`sync::Once::wait_force`](https://doc.rust-lang.org/stable/std/sync/struct.Once.html#method.wait_force)
+- [`sync::OnceLock::wait`](https://doc.rust-lang.org/stable/std/sync/struct.OnceLock.html#method.wait)
+
+These APIs are now stable in const contexts:
+
+- [`hint::black_box`](https://doc.rust-lang.org/stable/std/hint/fn.black_box.html)
+- [`io::Cursor::get_mut`](https://doc.rust-lang.org/stable/std/io/struct.Cursor.html#method.get_mut)
+- [`io::Cursor::set_position`](https://doc.rust-lang.org/stable/std/io/struct.Cursor.html#method.set_position)
+- [`str::is_char_boundary`](https://doc.rust-lang.org/stable/std/primitive.str.html#method.is_char_boundary)
+- [`str::split_at`](https://doc.rust-lang.org/stable/std/primitive.str.html#method.split_at)
+- [`str::split_at_checked`](https://doc.rust-lang.org/stable/std/primitive.str.html#method.split_at_checked)
+- [`str::split_at_mut`](https://doc.rust-lang.org/stable/std/primitive.str.html#method.split_at_mut)
+- [`str::split_at_mut_checked`](https://doc.rust-lang.org/stable/std/primitive.str.html#method.split_at_mut_checked)
+
+<a id="1.86.0-Cargo"></a>
+
+Cargo
+-----
+- [When merging, replace rather than combine configuration keys that refer to a program path and its arguments.](https://github.com/rust-lang/cargo/pull/15066/)
+- [Error if both `--package` and `--workspace` are passed but the requested package is missing.](https://github.com/rust-lang/cargo/pull/15071/) This was previously silently ignored, which was considered a bug since missing packages should be reported.
+- [Deprecate the token argument in `cargo login` to avoid shell history leaks.](https://github.com/rust-lang/cargo/pull/15057/)
+- [Simplify the implementation of `SourceID` comparisons.](https://github.com/rust-lang/cargo/pull/14980/) This may potentially change behavior if the canonicalized URL compares differently in alternative registries.
+
+<a id="1.86.0-Rustdoc"></a>
+
+Rustdoc
+-----
+- [Add a sans-serif font setting.](https://github.com/rust-lang/rust/pull/133636)
+
+<a id="1.86.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [The `wasm_c_abi` future compatibility warning is now a hard error.](https://github.com/rust-lang/rust/pull/133951)
+ Users of `wasm-bindgen` should upgrade to at least version 0.2.89, otherwise compilation will fail.
+- [Remove long-deprecated no-op attributes `#![no_start]` and `#![crate_id]`.](https://github.com/rust-lang/rust/pull/134300)
+- [The future incompatibility lint `cenum_impl_drop_cast` has been made into a hard error.](https://github.com/rust-lang/rust/pull/135964) This means it is now an error to cast a field-less enum to an integer if the enum implements `Drop`.
+- [SSE2 is now required for "i686" 32-bit x86 hard-float targets; disabling it causes a warning that will become a hard error eventually.](https://github.com/rust-lang/rust/pull/137037)
+ To compile for pre-SSE2 32-bit x86, use a "i586" target instead.
+
+<a id="1.86.0-Internal-Changes"></a>
+
+Internal Changes
+----------------
+
+These changes do not affect any public interfaces of Rust, but they represent
+significant improvements to the performance or internals of rustc and related
+tools.
+
+- [Build the rustc on AArch64 Linux with ThinLTO + PGO.](https://github.com/rust-lang/rust/pull/133807)
+ The ARM 64-bit compiler (AArch64) on Linux is now optimized with ThinLTO and PGO, similar to the optimizations we have already performed for the x86-64 compiler on Linux. This should make it up to 30% faster.
+
+
+Version 1.85.1 (2025-03-18)
+==========================
+
+<a id="1.85.1"></a>
+
+- [Fix the doctest-merging feature of the 2024 Edition.](https://github.com/rust-lang/rust/pull/137899/)
+- [Relax some `target_feature` checks when generating docs.](https://github.com/rust-lang/rust/pull/137632/)
+- [Fix errors in `std::fs::rename` on Windows 10, version 1607.](https://github.com/rust-lang/rust/pull/137528/)
+- [Downgrade bootstrap `cc` to fix custom targets.](https://github.com/rust-lang/rust/pull/137460/)
+- [Skip submodule updates when building Rust from a source tarball.](https://github.com/rust-lang/rust/pull/137338/)
+
+Version 1.85.0 (2025-02-20)
+==========================
+
+<a id="1.85.0-Language"></a>
+
+Language
+--------
+- [The 2024 Edition is now stable.](https://github.com/rust-lang/rust/pull/133349)
+ See [the edition guide](https://doc.rust-lang.org/nightly/edition-guide/rust-2024/index.html) for more details.
+- [Stabilize async closures](https://github.com/rust-lang/rust/pull/132706)
+ See [RFC 3668](https://rust-lang.github.io/rfcs/3668-async-closures.html) for more details.
+- [Stabilize `#[diagnostic::do_not_recommend]`](https://github.com/rust-lang/rust/pull/132056)
+- [Add `unpredictable_function_pointer_comparisons` lint to warn against function pointer comparisons](https://github.com/rust-lang/rust/pull/118833)
+- [Lint on combining `#[no_mangle]` and `#[export_name]` attributes.](https://github.com/rust-lang/rust/pull/131558)
+
+<a id="1.85.0-Compiler"></a>
+
+Compiler
+--------
+- [The unstable flag `-Zpolymorphize` has been removed](https://github.com/rust-lang/rust/pull/133883), see https://github.com/rust-lang/compiler-team/issues/810 for some background.
+
+<a id="1.85.0-Platform-Support"></a>
+
+Platform Support
+----------------
+- [Promote `powerpc64le-unknown-linux-musl` to tier 2 with host tools](https://github.com/rust-lang/rust/pull/133801)
+
+Refer to Rust's [platform support page][platform-support-doc]
+for more information on Rust's tiered platform support.
+
+<a id="1.85.0-Libraries"></a>
+
+Libraries
+---------
+- [Panics in the standard library now have a leading `library/` in their path](https://github.com/rust-lang/rust/pull/132390)
+- [`std::env::home_dir()` on Windows now ignores the non-standard `$HOME` environment variable](https://github.com/rust-lang/rust/pull/132515)
+
+ It will be un-deprecated in a subsequent release.
+- [Add `AsyncFn*` to the prelude in all editions.](https://github.com/rust-lang/rust/pull/132611)
+
+<a id="1.85.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`BuildHasherDefault::new`](https://doc.rust-lang.org/stable/std/hash/struct.BuildHasherDefault.html#method.new)
+- [`ptr::fn_addr_eq`](https://doc.rust-lang.org/std/ptr/fn.fn_addr_eq.html)
+- [`io::ErrorKind::QuotaExceeded`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.QuotaExceeded)
+- [`io::ErrorKind::CrossesDevices`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.CrossesDevices)
+- [`{float}::midpoint`](https://doc.rust-lang.org/core/primitive.f32.html#method.midpoint)
+- [Unsigned `{integer}::midpoint`](https://doc.rust-lang.org/std/primitive.u64.html#method.midpoint)
+- [`NonZeroU*::midpoint`](https://doc.rust-lang.org/std/num/type.NonZeroU32.html#method.midpoint)
+- [impl `std::iter::Extend` for tuples with arity 1 through 12](https://doc.rust-lang.org/stable/std/iter/trait.Extend.html#impl-Extend%3C(A,)%3E-for-(EA,))
+- [`FromIterator<(A, ...)>` for tuples with arity 1 through 12](https://doc.rust-lang.org/stable/std/iter/trait.FromIterator.html#impl-FromIterator%3C(EA,)%3E-for-(A,))
+- [`std::task::Waker::noop`](https://doc.rust-lang.org/stable/std/task/struct.Waker.html#method.noop)
+
+These APIs are now stable in const contexts:
+
+- [`mem::size_of_val`](https://doc.rust-lang.org/stable/std/mem/fn.size_of_val.html)
+- [`mem::align_of_val`](https://doc.rust-lang.org/stable/std/mem/fn.align_of_val.html)
+- [`Layout::for_value`](https://doc.rust-lang.org/stable/std/alloc/struct.Layout.html#method.for_value)
+- [`Layout::align_to`](https://doc.rust-lang.org/stable/std/alloc/struct.Layout.html#method.align_to)
+- [`Layout::pad_to_align`](https://doc.rust-lang.org/stable/std/alloc/struct.Layout.html#method.pad_to_align)
+- [`Layout::extend`](https://doc.rust-lang.org/stable/std/alloc/struct.Layout.html#method.extend)
+- [`Layout::array`](https://doc.rust-lang.org/stable/std/alloc/struct.Layout.html#method.array)
+- [`std::mem::swap`](https://doc.rust-lang.org/stable/std/mem/fn.swap.html)
+- [`std::ptr::swap`](https://doc.rust-lang.org/stable/std/ptr/fn.swap.html)
+- [`NonNull::new`](https://doc.rust-lang.org/stable/std/ptr/struct.NonNull.html#method.new)
+- [`HashMap::with_hasher`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html#method.with_hasher)
+- [`HashSet::with_hasher`](https://doc.rust-lang.org/stable/std/collections/struct.HashSet.html#method.with_hasher)
+- [`BuildHasherDefault::new`](https://doc.rust-lang.org/stable/std/hash/struct.BuildHasherDefault.html#method.new)
+- [`<float>::recip`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.recip)
+- [`<float>::to_degrees`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.to_degrees)
+- [`<float>::to_radians`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.to_radians)
+- [`<float>::max`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.max)
+- [`<float>::min`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.min)
+- [`<float>::clamp`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.clamp)
+- [`<float>::abs`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.abs)
+- [`<float>::signum`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.signum)
+- [`<float>::copysign`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.copysign)
+- [`MaybeUninit::write`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#method.write)
+
+<a id="1.85.0-Cargo"></a>
+
+Cargo
+-----
+- [Add future-incompatibility warning against keywords in cfgs and add raw-idents](https://github.com/rust-lang/cargo/pull/14671/)
+- [Stabilize higher precedence trailing flags](https://github.com/rust-lang/cargo/pull/14900/)
+- [Pass `CARGO_CFG_FEATURE` to build scripts](https://github.com/rust-lang/cargo/pull/14902/)
+
+<a id="1.85.0-Rustdoc"></a>
+
+Rustdoc
+-----
+- [Doc comment on impl blocks shows the first line, even when the impl block is collapsed](https://github.com/rust-lang/rust/pull/132155)
+
+<a id="1.85.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [`rustc` no longer treats the `test` cfg as a well known check-cfg](https://github.com/rust-lang/rust/pull/131729), instead it is up to the build systems and users of `--check-cfg`[^check-cfg] to set it as a well known cfg using `--check-cfg=cfg(test)`.
+
+ This is done to enable build systems like Cargo to set it conditionally, as not all source files are suitable for unit tests.
+ [Cargo (for now) unconditionally sets the `test` cfg as a well known cfg](https://github.com/rust-lang/cargo/pull/14963).
+ [^check-cfg]: https://doc.rust-lang.org/nightly/rustc/check-cfg.html
+- [Disable potentially incorrect type inference if there are trivial and non-trivial where-clauses](https://github.com/rust-lang/rust/pull/132325)
+- `std::env::home_dir()` has been deprecated for years, because it can give surprising results in some Windows configurations if the `HOME` environment variable is set (which is not the normal configuration on Windows). We had previously avoided changing its behavior, out of concern for compatibility with code depending on this non-standard configuration. Given how long this function has been deprecated, we're now fixing its behavior as a bugfix. A subsequent release will remove the deprecation for this function.
+- [Make `core::ffi::c_char` signedness more closely match that of the platform-default `char`](https://github.com/rust-lang/rust/pull/132975)
+
+ This changed `c_char` from an `i8` to `u8` or vice versa on many Tier 2 and 3
+ targets (mostly Arm and RISC-V embedded targets). The new definition may
+ result in compilation failures but fixes compatibility issues with C.
+
+ The `libc` crate matches this change as of its 0.2.169 release.
+- [When compiling a nested `macro_rules` macro from an external crate, the content of the inner `macro_rules` is now built with the edition of the external crate, not the local crate.](https://github.com/rust-lang/rust/pull/133274)
+- [Increase `sparcv9-sun-solaris` and `x86_64-pc-solaris` Solaris baseline to 11.4.](https://github.com/rust-lang/rust/pull/133293)
+- [Show `abi_unsupported_vector_types` lint in future breakage reports](https://github.com/rust-lang/rust/pull/133374)
+- [Error if multiple super-trait instantiations of `dyn Trait` need associated types to be specified but only one is provided](https://github.com/rust-lang/rust/pull/133392)
+- [Change `powerpc64-ibm-aix` default `codemodel` to large](https://github.com/rust-lang/rust/pull/133811)
+
+<a id="1.85.0-Internal-Changes"></a>
+
+Internal Changes
+----------------
+
+These changes do not affect any public interfaces of Rust, but they represent
+significant improvements to the performance or internals of rustc and related
+tools.
+
+- [Build `x86_64-unknown-linux-gnu` with LTO for C/C++ code (e.g., `jemalloc`)](https://github.com/rust-lang/rust/pull/134690)
+
+Version 1.84.1 (2025-01-30)
+==========================
+
+<a id="1.84.1"></a>
+
+- [Fix ICE 132920 in duplicate-crate diagnostics.](https://github.com/rust-lang/rust/pull/133304/)
+- [Fix errors for overlapping impls in incremental rebuilds.](https://github.com/rust-lang/rust/pull/133828/)
+- [Fix slow compilation related to the next-generation trait solver.](https://github.com/rust-lang/rust/pull/135618/)
+- [Fix debuginfo when LLVM's location discriminator value limit is exceeded.](https://github.com/rust-lang/rust/pull/135643/)
+- Fixes for building Rust from source:
+ - [Only try to distribute `llvm-objcopy` if llvm tools are enabled.](https://github.com/rust-lang/rust/pull/134240/)
+ - [Add Profile Override for Non-Git Sources.](https://github.com/rust-lang/rust/pull/135433/)
+ - [Resolve symlinks of LLVM tool binaries before copying them.](https://github.com/rust-lang/rust/pull/135585/)
+ - [Make it possible to use ci-rustc on tarball sources.](https://github.com/rust-lang/rust/pull/135722/)
+
+Version 1.84.0 (2025-01-09)
+==========================
+
+<a id="1.84.0-Language"></a>
+
+Language
+--------
+- [Allow `#[deny]` inside `#[forbid]` as a no-op](https://github.com/rust-lang/rust/pull/121560/)
+- [Show a warning when `-Ctarget-feature` is used to toggle features that can lead to unsoundness due to ABI mismatches](https://github.com/rust-lang/rust/pull/129884)
+- [Use the next-generation trait solver in coherence](https://github.com/rust-lang/rust/pull/130654)
+- [Allow coercions to drop the principal of trait objects](https://github.com/rust-lang/rust/pull/131857)
+- [Support `/` as the path separator for `include!()` in all cases on Windows](https://github.com/rust-lang/rust/pull/125205)
+- [Taking a raw ref (`raw (const|mut)`) of a deref of a pointer (`*ptr`) is now safe](https://github.com/rust-lang/rust/pull/129248)
+- [Stabilize s390x inline assembly](https://github.com/rust-lang/rust/pull/131258)
+- [Stabilize Arm64EC inline assembly](https://github.com/rust-lang/rust/pull/131781)
+- [Lint against creating pointers to immediately dropped temporaries](https://github.com/rust-lang/rust/pull/128985)
+- [Execute drop glue when unwinding in an `extern "C"` function](https://github.com/rust-lang/rust/pull/129582)
+
+<a id="1.84.0-Compiler"></a>
+
+Compiler
+--------
+- [Add `--print host-tuple` flag to print the host target tuple and affirm the "target tuple" terminology over "target triple"](https://github.com/rust-lang/rust/pull/125579)
+- [Declaring functions with a calling convention not supported on the current target now triggers a hard error](https://github.com/rust-lang/rust/pull/129935)
+- [Set up indirect access to external data for `loongarch64-unknown-linux-{musl,ohos}`](https://github.com/rust-lang/rust/pull/131583)
+- [Enable XRay instrumentation for LoongArch Linux targets](https://github.com/rust-lang/rust/pull/131818)
+- [Extend the `unexpected_cfgs` lint to also warn in external macros](https://github.com/rust-lang/rust/pull/132577)
+- [Stabilize WebAssembly `multivalue`, `reference-types`, and `tail-call` target features](https://github.com/rust-lang/rust/pull/131080)
+- [Added Tier 2 support for the `wasm32v1-none` target](https://github.com/rust-lang/rust/pull/131487)
+
+<a id="1.84.0-Libraries"></a>
+
+Libraries
+---------
+- [Implement `From<&mut {slice}>` for `Box/Rc/Arc<{slice}>`](https://github.com/rust-lang/rust/pull/129329)
+- [Move `<float>::copysign`, `<float>::abs`, `<float>::signum` to `core`](https://github.com/rust-lang/rust/pull/131304)
+- [Add `LowerExp` and `UpperExp` implementations to `NonZero`](https://github.com/rust-lang/rust/pull/131377)
+- [Implement `FromStr` for `CString` and `TryFrom<CString>` for `String`](https://github.com/rust-lang/rust/pull/130608)
+- [`std::os::darwin` has been made public](https://github.com/rust-lang/rust/pull/123723)
+
+<a id="1.84.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`Ipv6Addr::is_unique_local`](https://doc.rust-lang.org/stable/core/net/struct.Ipv6Addr.html#method.is_unique_local)
+- [`Ipv6Addr::is_unicast_link_local`](https://doc.rust-lang.org/stable/core/net/struct.Ipv6Addr.html#method.is_unicast_link_local)
+- [`core::ptr::with_exposed_provenance`](https://doc.rust-lang.org/stable/core/ptr/fn.with_exposed_provenance.html)
+- [`core::ptr::with_exposed_provenance_mut`](https://doc.rust-lang.org/stable/core/ptr/fn.with_exposed_provenance_mut.html)
+- [`<ptr>::addr`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.addr)
+- [`<ptr>::expose_provenance`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.expose_provenance)
+- [`<ptr>::with_addr`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.with_addr)
+- [`<ptr>::map_addr`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.map_addr)
+- [`<int>::isqrt`](https://doc.rust-lang.org/stable/core/primitive.i32.html#method.isqrt)
+- [`<int>::checked_isqrt`](https://doc.rust-lang.org/stable/core/primitive.i32.html#method.checked_isqrt)
+- [`<uint>::isqrt`](https://doc.rust-lang.org/stable/core/primitive.u32.html#method.isqrt)
+- [`NonZero::isqrt`](https://doc.rust-lang.org/stable/core/num/struct.NonZero.html#impl-NonZero%3Cu128%3E/method.isqrt)
+- [`core::ptr::without_provenance`](https://doc.rust-lang.org/stable/core/ptr/fn.without_provenance.html)
+- [`core::ptr::without_provenance_mut`](https://doc.rust-lang.org/stable/core/ptr/fn.without_provenance_mut.html)
+- [`core::ptr::dangling`](https://doc.rust-lang.org/stable/core/ptr/fn.dangling.html)
+- [`core::ptr::dangling_mut`](https://doc.rust-lang.org/stable/core/ptr/fn.dangling_mut.html)
+- [`Pin::as_deref_mut`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.as_deref_mut)
+
+These APIs are now stable in const contexts
+
+- [`AtomicBool::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicBool.html#method.from_ptr)
+- [`AtomicPtr::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicPtr.html#method.from_ptr)
+- [`AtomicU8::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicU8.html#method.from_ptr)
+- [`AtomicU16::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicU16.html#method.from_ptr)
+- [`AtomicU32::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicU32.html#method.from_ptr)
+- [`AtomicU64::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicU64.html#method.from_ptr)
+- [`AtomicUsize::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicUsize.html#method.from_ptr)
+- [`AtomicI8::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicI8.html#method.from_ptr)
+- [`AtomicI16::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicI16.html#method.from_ptr)
+- [`AtomicI32::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicI32.html#method.from_ptr)
+- [`AtomicI64::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicI64.html#method.from_ptr)
+- [`AtomicIsize::from_ptr`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicIsize.html#method.from_ptr)
+- [`<ptr>::is_null`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.is_null-1)
+- [`<ptr>::as_ref`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.as_ref-1)
+- [`<ptr>::as_mut`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.as_mut)
+- [`Pin::new`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.new)
+- [`Pin::new_unchecked`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.new_unchecked)
+- [`Pin::get_ref`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.get_ref)
+- [`Pin::into_ref`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.into_ref)
+- [`Pin::get_mut`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.get_mut)
+- [`Pin::get_unchecked_mut`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.get_unchecked_mut)
+- [`Pin::static_ref`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.static_ref)
+- [`Pin::static_mut`](https://doc.rust-lang.org/stable/core/pin/struct.Pin.html#method.static_mut)
+
+<a id="1.84.0-Cargo"></a>
+
+Cargo
+-----
+- [Stabilize MSRV-aware resolver config](https://github.com/rust-lang/cargo/pull/14639/)
+- [Stabilize resolver v3](https://github.com/rust-lang/cargo/pull/14754/)
+
+<a id="1.84-Rustdoc"></a>
+
+Rustdoc
+-------
+
+- [rustdoc-search: improve type-driven search](https://github.com/rust-lang/rust/pull/127589)
+
+<a id="1.84.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [Enable by default the `LSX` target feature for LoongArch Linux targets](https://github.com/rust-lang/rust/pull/132140)
+- [The unstable `-Zprofile` flag (“gcov-style” coverage instrumentation) has been removed.](https://github.com/rust-lang/rust/pull/131829) This does not affect the stable flags for coverage instrumentation (`-Cinstrument-coverage`) and profile-guided optimization (`-Cprofile-generate`, `-Cprofile-use`), which are unrelated and remain available.
+- Support for the target named `wasm32-wasi` has been removed as the target is now named `wasm32-wasip1`. This completes the [transition](https://github.com/rust-lang/compiler-team/issues/607) [plan](https://github.com/rust-lang/compiler-team/issues/695) for this target following [the introduction of `wasm32-wasip1`](https://github.com/rust-lang/rust/pull/120468) in Rust 1.78. Compiler warnings on [use of `wasm32-wasi`](https://github.com/rust-lang/rust/pull/126662) introduced in Rust 1.81 are now gone as well as the target is removed.
+- [The syntax `&pin (mut|const) T` is now parsed as a type which in theory could affect macro expansion results in some edge cases](https://github.com/rust-lang/rust/pull/130635#issuecomment-2375462821)
+- [Legacy syntax for calling `std::arch` functions is no longer permitted to declare items or bodies (such as closures, inline consts, or async blocks).](https://github.com/rust-lang/rust/pull/130443#issuecomment-2445678945)
+- [Declaring functions with a calling convention not supported on the current target now triggers a hard error](https://github.com/rust-lang/rust/pull/129935)
+- [The next-generation trait solver is now enabled for coherence, fixing multiple soundness issues](https://github.com/rust-lang/rust/pull/130654)
+
+Version 1.83.0 (2024-11-28)
+==========================
+
+<a id="1.83.0-Language"></a>
+
+Language
+--------
+- [Stabilize `&mut`, `*mut`, `&Cell`, and `*const Cell` in const.](https://github.com/rust-lang/rust/pull/129195)
+- [Allow creating references to statics in `const` initializers.](https://github.com/rust-lang/rust/pull/129759)
+- [Implement raw lifetimes and labels (`'r#ident`).](https://github.com/rust-lang/rust/pull/126452)
+- [Define behavior when atomic and non-atomic reads race.](https://github.com/rust-lang/rust/pull/128778)
+- [Non-exhaustive structs may now be empty.](https://github.com/rust-lang/rust/pull/128934)
+- [Disallow implicit coercions from places of type `!`](https://github.com/rust-lang/rust/pull/129392)
+- [`const extern` functions can now be defined for other calling conventions.](https://github.com/rust-lang/rust/pull/129753)
+- [Stabilize `expr_2021` macro fragment specifier in all editions.](https://github.com/rust-lang/rust/pull/129972)
+- [The `non_local_definitions` lint now fires on less code and warns by default.](https://github.com/rust-lang/rust/pull/127117)
+
+
+<a id="1.83.0-Compiler"></a>
+
+Compiler
+--------
+- [Deprecate unsound `-Csoft-float` flag.](https://github.com/rust-lang/rust/pull/129897)
+- Add many new tier 3 targets:
+ - [`aarch64_unknown_nto_qnx700`](https://github.com/rust-lang/rust/pull/127897)
+ - [`arm64e-apple-tvos`](https://github.com/rust-lang/rust/pull/130614)
+ - [`armv7-rtems-eabihf`](https://github.com/rust-lang/rust/pull/127021)
+ - [`loongarch64-unknown-linux-ohos`](https://github.com/rust-lang/rust/pull/130750)
+ - [`riscv32-wrs-vxworks` and `riscv64-wrs-vxworks`](https://github.com/rust-lang/rust/pull/130549)
+ - [`riscv32{e|em|emc}-unknown-none-elf`](https://github.com/rust-lang/rust/pull/130555)
+ - [`x86_64-unknown-hurd-gnu`](https://github.com/rust-lang/rust/pull/128345)
+ - [`x86_64-unknown-trusty`](https://github.com/rust-lang/rust/pull/130453)
+
+Refer to Rust's [platform support page][platform-support-doc]
+for more information on Rust's tiered platform support.
+
+
+<a id="1.83.0-Libraries"></a>
+
+Libraries
+---------
+- [Implement `PartialEq` for `ExitCode`.](https://github.com/rust-lang/rust/pull/127633)
+- [Document that `catch_unwind` can deal with foreign exceptions without UB, although the exact behavior is unspecified.](https://github.com/rust-lang/rust/pull/128321)
+- [Implement `Default` for `HashMap`/`HashSet` iterators that don't already have it.](https://github.com/rust-lang/rust/pull/128711)
+- [Bump Unicode to version 16.0.0.](https://github.com/rust-lang/rust/pull/130183)
+- [Change documentation of `ptr::add`/`sub` to not claim equivalence with `offset`.](https://github.com/rust-lang/rust/pull/130229)
+
+
+<a id="1.83.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`BufRead::skip_until`](https://doc.rust-lang.org/stable/std/io/trait.BufRead.html#method.skip_until)
+- [`ControlFlow::break_value`](https://doc.rust-lang.org/stable/core/ops/enum.ControlFlow.html#method.break_value)
+- [`ControlFlow::continue_value`](https://doc.rust-lang.org/stable/core/ops/enum.ControlFlow.html#method.continue_value)
+- [`ControlFlow::map_break`](https://doc.rust-lang.org/stable/core/ops/enum.ControlFlow.html#method.map_break)
+- [`ControlFlow::map_continue`](https://doc.rust-lang.org/stable/core/ops/enum.ControlFlow.html#method.map_continue)
+- [`DebugList::finish_non_exhaustive`](https://doc.rust-lang.org/stable/core/fmt/struct.DebugList.html#method.finish_non_exhaustive)
+- [`DebugMap::finish_non_exhaustive`](https://doc.rust-lang.org/stable/core/fmt/struct.DebugMap.html#method.finish_non_exhaustive)
+- [`DebugSet::finish_non_exhaustive`](https://doc.rust-lang.org/stable/core/fmt/struct.DebugSet.html#method.finish_non_exhaustive)
+- [`DebugTuple::finish_non_exhaustive`](https://doc.rust-lang.org/stable/core/fmt/struct.DebugTuple.html#method.finish_non_exhaustive)
+- [`ErrorKind::ArgumentListTooLong`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.ArgumentListTooLong)
+- [`ErrorKind::Deadlock`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.Deadlock)
+- [`ErrorKind::DirectoryNotEmpty`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.DirectoryNotEmpty)
+- [`ErrorKind::ExecutableFileBusy`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.ExecutableFileBusy)
+- [`ErrorKind::FileTooLarge`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.FileTooLarge)
+- [`ErrorKind::HostUnreachable`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.HostUnreachable)
+- [`ErrorKind::IsADirectory`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.IsADirectory)
+- [`ErrorKind::NetworkDown`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.NetworkDown)
+- [`ErrorKind::NetworkUnreachable`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.NetworkUnreachable)
+- [`ErrorKind::NotADirectory`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.NotADirectory)
+- [`ErrorKind::NotSeekable`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.NotSeekable)
+- [`ErrorKind::ReadOnlyFilesystem`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.ReadOnlyFilesystem)
+- [`ErrorKind::ResourceBusy`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.ResourceBusy)
+- [`ErrorKind::StaleNetworkFileHandle`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.StaleNetworkFileHandle)
+- [`ErrorKind::StorageFull`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.StorageFull)
+- [`ErrorKind::TooManyLinks`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#variant.TooManyLinks)
+- [`Option::get_or_insert_default`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.get_or_insert_default)
+- [`Waker::data`](https://doc.rust-lang.org/stable/core/task/struct.Waker.html#method.data)
+- [`Waker::new`](https://doc.rust-lang.org/stable/core/task/struct.Waker.html#method.new)
+- [`Waker::vtable`](https://doc.rust-lang.org/stable/core/task/struct.Waker.html#method.vtable)
+- [`char::MIN`](https://doc.rust-lang.org/stable/core/primitive.char.html#associatedconstant.MIN)
+- [`hash_map::Entry::insert_entry`](https://doc.rust-lang.org/stable/std/collections/hash_map/enum.Entry.html#method.insert_entry)
+- [`hash_map::VacantEntry::insert_entry`](https://doc.rust-lang.org/stable/std/collections/hash_map/struct.VacantEntry.html#method.insert_entry)
+
+These APIs are now stable in const contexts:
+
+- [`Cell::into_inner`](https://doc.rust-lang.org/stable/core/cell/struct.Cell.html#method.into_inner)
+- [`Duration::as_secs_f32`](https://doc.rust-lang.org/stable/core/time/struct.Duration.html#method.as_secs_f32)
+- [`Duration::as_secs_f64`](https://doc.rust-lang.org/stable/core/time/struct.Duration.html#method.as_secs_f64)
+- [`Duration::div_duration_f32`](https://doc.rust-lang.org/stable/core/time/struct.Duration.html#method.div_duration_f32)
+- [`Duration::div_duration_f64`](https://doc.rust-lang.org/stable/core/time/struct.Duration.html#method.div_duration_f64)
+- [`MaybeUninit::as_mut_ptr`](https://doc.rust-lang.org/stable/core/mem/union.MaybeUninit.html#method.as_mut_ptr)
+- [`NonNull::as_mut`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.as_mut)
+- [`NonNull::copy_from`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.copy_from)
+- [`NonNull::copy_from_nonoverlapping`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.copy_from_nonoverlapping)
+- [`NonNull::copy_to`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.copy_to)
+- [`NonNull::copy_to_nonoverlapping`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.copy_to_nonoverlapping)
+- [`NonNull::slice_from_raw_parts`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.slice_from_raw_parts)
+- [`NonNull::write`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.write)
+- [`NonNull::write_bytes`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.write_bytes)
+- [`NonNull::write_unaligned`](https://doc.rust-lang.org/stable/core/ptr/struct.NonNull.html#method.write_unaligned)
+- [`OnceCell::into_inner`](https://doc.rust-lang.org/stable/core/cell/struct.OnceCell.html#method.into_inner)
+- [`Option::as_mut`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.as_mut)
+- [`Option::expect`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.expect)
+- [`Option::replace`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.replace)
+- [`Option::take`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.take)
+- [`Option::unwrap`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.unwrap)
+- [`Option::unwrap_unchecked`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.unwrap_unchecked)
+- [`Option::<&_>::copied`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.copied)
+- [`Option::<&mut _>::copied`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.copied-1)
+- [`Option::<Option<_>>::flatten`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.flatten)
+- [`Option::<Result<_, _>>::transpose`](https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.transpose)
+- [`RefCell::into_inner`](https://doc.rust-lang.org/stable/core/cell/struct.RefCell.html#method.into_inner)
+- [`Result::as_mut`](https://doc.rust-lang.org/stable/core/result/enum.Result.html#method.as_mut)
+- [`Result::<&_, _>::copied`](https://doc.rust-lang.org/stable/core/result/enum.Result.html#method.copied)
+- [`Result::<&mut _, _>::copied`](https://doc.rust-lang.org/stable/core/result/enum.Result.html#method.copied-1)
+- [`Result::<Option<_>, _>::transpose`](https://doc.rust-lang.org/stable/core/result/enum.Result.html#method.transpose)
+- [`UnsafeCell::get_mut`](https://doc.rust-lang.org/stable/core/cell/struct.UnsafeCell.html#method.get_mut)
+- [`UnsafeCell::into_inner`](https://doc.rust-lang.org/stable/core/cell/struct.UnsafeCell.html#method.into_inner)
+- [`array::from_mut`](https://doc.rust-lang.org/stable/core/array/fn.from_mut.html)
+- [`char::encode_utf8`](https://doc.rust-lang.org/stable/core/primitive.char.html#method.encode_utf8)
+- [`{float}::classify`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.classify)
+- [`{float}::is_finite`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.is_finite)
+- [`{float}::is_infinite`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.is_infinite)
+- [`{float}::is_nan`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.is_nan)
+- [`{float}::is_normal`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.is_normal)
+- [`{float}::is_sign_negative`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.is_sign_negative)
+- [`{float}::is_sign_positive`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.is_sign_positive)
+- [`{float}::is_subnormal`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.is_subnormal)
+- [`{float}::from_bits`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.from_bits)
+- [`{float}::from_be_bytes`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.from_be_bytes)
+- [`{float}::from_le_bytes`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.from_le_bytes)
+- [`{float}::from_ne_bytes`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.from_ne_bytes)
+- [`{float}::to_bits`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.to_bits)
+- [`{float}::to_be_bytes`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.to_be_bytes)
+- [`{float}::to_le_bytes`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.to_le_bytes)
+- [`{float}::to_ne_bytes`](https://doc.rust-lang.org/stable/core/primitive.f64.html#method.to_ne_bytes)
+- [`mem::replace`](https://doc.rust-lang.org/stable/core/mem/fn.replace.html)
+- [`ptr::replace`](https://doc.rust-lang.org/stable/core/ptr/fn.replace.html)
+- [`ptr::slice_from_raw_parts_mut`](https://doc.rust-lang.org/stable/core/ptr/fn.slice_from_raw_parts_mut.html)
+- [`ptr::write`](https://doc.rust-lang.org/stable/core/ptr/fn.write.html)
+- [`ptr::write_unaligned`](https://doc.rust-lang.org/stable/core/ptr/fn.write_unaligned.html)
+- [`<*const _>::copy_to`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.copy_to)
+- [`<*const _>::copy_to_nonoverlapping`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.copy_to_nonoverlapping)
+- [`<*mut _>::copy_from`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.copy_from)
+- [`<*mut _>::copy_from_nonoverlapping`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.copy_from_nonoverlapping)
+- [`<*mut _>::copy_to`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.copy_to-1)
+- [`<*mut _>::copy_to_nonoverlapping`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.copy_to_nonoverlapping-1)
+- [`<*mut _>::write`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.write)
+- [`<*mut _>::write_bytes`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.write_bytes)
+- [`<*mut _>::write_unaligned`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.write_unaligned)
+- [`slice::from_mut`](https://doc.rust-lang.org/stable/core/slice/fn.from_mut.html)
+- [`slice::from_raw_parts_mut`](https://doc.rust-lang.org/stable/core/slice/fn.from_raw_parts_mut.html)
+- [`<[_]>::first_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.first_mut)
+- [`<[_]>::last_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.last_mut)
+- [`<[_]>::first_chunk_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.first_chunk_mut)
+- [`<[_]>::last_chunk_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.last_chunk_mut)
+- [`<[_]>::split_at_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.split_at_mut)
+- [`<[_]>::split_at_mut_checked`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.split_at_mut_checked)
+- [`<[_]>::split_at_mut_unchecked`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.split_at_mut_unchecked)
+- [`<[_]>::split_first_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.split_first_mut)
+- [`<[_]>::split_last_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.split_last_mut)
+- [`<[_]>::split_first_chunk_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.split_first_chunk_mut)
+- [`<[_]>::split_last_chunk_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.split_last_chunk_mut)
+- [`str::as_bytes_mut`](https://doc.rust-lang.org/stable/core/primitive.str.html#method.as_bytes_mut)
+- [`str::as_mut_ptr`](https://doc.rust-lang.org/stable/core/primitive.str.html#method.as_mut_ptr)
+- [`str::from_utf8_unchecked_mut`](https://doc.rust-lang.org/stable/core/str/fn.from_utf8_unchecked_mut.html)
+
+
+<a id="1.83.0-Cargo"></a>
+
+Cargo
+-----
+- [Introduced a new `CARGO_MANIFEST_PATH` environment variable, similar to `CARGO_MANIFEST_DIR` but pointing directly to the manifest file.](https://github.com/rust-lang/cargo/pull/14404/)
+- [Added `package.autolib` to the manifest, allowing `[lib]` auto-discovery to be disabled.](https://github.com/rust-lang/cargo/pull/14591/)
+- [Declare support level for each crate in Cargo's Charter / crate docs.](https://github.com/rust-lang/cargo/pull/14600/)
+- [Declare new Intentional Artifacts as 'small' changes.](https://github.com/rust-lang/cargo/pull/14599/)
+
+
+<a id="1.83-Rustdoc"></a>
+
+Rustdoc
+-------
+
+- [The sidebar / hamburger menu table of contents now includes the `# headers` from the main item's doc comment](https://github.com/rust-lang/rust/pull/120736). This is similar to a third-party feature provided by the rustdoc-search-enhancements browser extension.
+
+
+<a id="1.83.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [Warn against function pointers using unsupported ABI strings.](https://github.com/rust-lang/rust/pull/128784)
+- [Check well-formedness of the source type's signature in fn pointer casts.](https://github.com/rust-lang/rust/pull/129021) This partly closes a soundness hole that comes when casting a function item to function pointer
+- [Use equality instead of subtyping when resolving type dependent paths.](https://github.com/rust-lang/rust/pull/129073)
+- Linking on macOS now correctly includes Rust's default deployment target. Due to a linker bug, you might have to pass `MACOSX_DEPLOYMENT_TARGET` or fix your `#[link]` attributes to point to the correct frameworks. See <https://github.com/rust-lang/rust/pull/129369>.
+- [Rust will now correctly raise an error for `repr(Rust)` written on non-`struct`/`enum`/`union` items, since it previous did not have any effect.](https://github.com/rust-lang/rust/pull/129422)
+- The future incompatibility lint `deprecated_cfg_attr_crate_type_name` [has been made into a hard error](https://github.com/rust-lang/rust/pull/129670). It was used to deny usage of `#![crate_type]` and `#![crate_name]` attributes in `#![cfg_attr]`, which required a hack in the compiler to be able to change the used crate type and crate name after cfg expansion.
+ Users can use `--crate-type` instead of `#![cfg_attr(..., crate_type = "...")]` and `--crate-name` instead of `#![cfg_attr(..., crate_name = "...")]` when running `rustc`/`cargo rustc` on the command line.
+ Use of those two attributes outside of `#![cfg_attr]` continue to be fully supported.
+- Until now, paths into the sysroot were always prefixed with `/rustc/$hash` in diagnostics, codegen, backtrace, e.g.
+ ```
+ thread 'main' panicked at 'hello world', map-panic.rs:2:50
+ stack backtrace:
+ 0: std::panicking::begin_panic
+ at /rustc/a55dd71d5fb0ec5a6a3a9e8c27b2127ba491ce52/library/std/src/panicking.rs:616:12
+ 1: map_panic::main::{{closure}}
+ at ./map-panic.rs:2:50
+ 2: core::option::Option<T>::map
+ at /rustc/a55dd71d5fb0ec5a6a3a9e8c27b2127ba491ce52/library/core/src/option.rs:929:29
+ 3: map_panic::main
+ at ./map-panic.rs:2:30
+ 4: core::ops::function::FnOnce::call_once
+ at /rustc/a55dd71d5fb0ec5a6a3a9e8c27b2127ba491ce52/library/core/src/ops/function.rs:248:5
+ note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
+ ```
+ [RFC 3127 said](https://rust-lang.github.io/rfcs/3127-trim-paths.html#changing-handling-of-sysroot-path-in-rustc)
+ > We want to change this behaviour such that, when `rust-src` source files can be discovered, the virtual path is discarded and therefore the local path will be embedded, unless there is a `--remap-path-prefix` that causes this local path to be remapped in the usual way.
+
+ [#129687](https://github.com/rust-lang/rust/pull/129687) implements this behaviour, when `rust-src` is present at compile time, `rustc` replaces `/rustc/$hash` with a real path into the local `rust-src` component with best effort.
+ To sanitize this, users must explicitly supply `--remap-path-prefix=<path to rust-src>=foo` or not have the `rust-src` component installed.
+ - The allow-by-default `missing_docs` lint used to disable itself when invoked through `rustc --test`/`cargo test`, resulting in `#[expect(missing_docs)]` emitting false positives due to the expectation being wrongly unfulfilled. This behavior [has now been removed](https://github.com/rust-lang/rust/pull/130025), which allows `#[expect(missing_docs)]` to be fulfilled in all scenarios, but will also report new `missing_docs` diagnostics for publicly reachable `#[cfg(test)]` items, [integration test](https://doc.rust-lang.org/cargo/reference/cargo-targets.html#integration-tests) crate-level documentation, and publicly reachable items in integration tests.
+- [The `armv8r-none-eabihf` target now uses the Armv8-R required set of floating-point features.](https://github.com/rust-lang/rust/pull/130295)
+- [Fix a soundness bug where rustc wouldn't detect unconstrained higher-ranked lifetimes in a `dyn Trait`'s associated types that occur due to supertraits.](https://github.com/rust-lang/rust/pull/130367)
+- [Update the minimum external LLVM version to 18.](https://github.com/rust-lang/rust/pull/130487)
+- [Remove `aarch64-fuchsia` and `x86_64-fuchsia` target aliases in favor of `aarch64-unknown-fuchsia` and `x86_64-unknown-fuchsia` respectively.](https://github.com/rust-lang/rust/pull/130657)
+- [The ABI-level exception class of a Rust panic is now encoded with native-endian bytes, so it is legible in hex dumps.](https://github.com/rust-lang/rust/pull/130897)
+- [Visual Studio 2013 is no longer supported for MSVC targets.](https://github.com/rust-lang/rust/pull/131070)
+- [The sysroot no longer contains the `std` dynamic library in its top-level `lib/` dir.](https://github.com/rust-lang/rust/pull/131188)
+
+
+Version 1.82.0 (2024-10-17)
+==========================
+
+<a id="1.82.0-Language"></a>
+
+Language
+--------
+- [Don't make statement nonterminals match pattern nonterminals](https://github.com/rust-lang/rust/pull/120221/)
+- [Patterns matching empty types can now be omitted in common cases](https://github.com/rust-lang/rust/pull/122792)
+- [Enforce supertrait outlives obligations when using trait impls](https://github.com/rust-lang/rust/pull/124336)
+- [`addr_of(_mut)!` macros and the newly stabilized `&raw (const|mut)` are now safe to use with all static items](https://github.com/rust-lang/rust/pull/125834)
+- [size_of_val_raw: for length 0 this is safe to call](https://github.com/rust-lang/rust/pull/126152/)
+- [Reorder trait bound modifiers *after* `for<...>` binder in trait bounds](https://github.com/rust-lang/rust/pull/127054/)
+- [Stabilize `+ use<'lt>` opaque type precise capturing (RFC 3617)](https://github.com/rust-lang/rust/pull/127672)
+- [Stabilize `&raw const` and `&raw mut` operators (RFC 2582)](https://github.com/rust-lang/rust/pull/127679)
+- [Stabilize unsafe extern blocks (RFC 3484)](https://github.com/rust-lang/rust/pull/127921)
+- [Stabilize nested field access in `offset_of!`](https://github.com/rust-lang/rust/pull/128284)
+- [Do not require `T` to be live when dropping `[T; 0]`](https://github.com/rust-lang/rust/pull/128438)
+- [Stabilize `const` operands in inline assembly](https://github.com/rust-lang/rust/pull/128570)
+- [Stabilize floating-point arithmetic in `const fn`](https://github.com/rust-lang/rust/pull/128596)
+- [Stabilize explicit opt-in to unsafe attributes](https://github.com/rust-lang/rust/pull/128771)
+- [Document NaN bit patterns guarantees](https://github.com/rust-lang/rust/pull/129559)
+
+
+<a id="1.82.0-Compiler"></a>
+
+Compiler
+--------
+- [Promote riscv64gc-unknown-linux-musl to tier 2](https://github.com/rust-lang/rust/pull/122049)
+- [Promote Mac Catalyst targets `aarch64-apple-ios-macabi` and `x86_64-apple-ios-macabi` to Tier 2, and ship them with rustup](https://github.com/rust-lang/rust/pull/126450)
+- [Add tier 3 NuttX based targets for RISC-V and ARM](https://github.com/rust-lang/rust/pull/127755)
+- [Add tier 3 powerpc-unknown-linux-muslspe target](https://github.com/rust-lang/rust/pull/127905)
+- [Improved diagnostics to explain why a pattern is unreachable](https://github.com/rust-lang/rust/pull/128034)
+- [The compiler now triggers the unreachable code warning properly for async functions that don't return/are `-> !`](https://github.com/rust-lang/rust/pull/128443)
+- [Promote `aarch64-apple-darwin` to Tier 1](https://github.com/rust-lang/rust/pull/128592)
+- [Add Trusty OS target `aarch64-unknown-trusty` and `armv7-unknown-trusty` as tier 3 targets](https://github.com/rust-lang/rust/pull/129490)
+- [Promote `wasm32-wasip2` to Tier 2.](https://github.com/rust-lang/rust/pull/126967/)
+
+
+<a id="1.82.0-Libraries"></a>
+
+Libraries
+---------
+- [Generalize `{Rc,Arc}::make_mut()` to `Path`, `OsStr`, and `CStr`.](https://github.com/rust-lang/rust/pull/126877)
+
+<a id="1.82.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`std::thread::Builder::spawn_unchecked`](https://doc.rust-lang.org/stable/std/thread/struct.Builder.html#method.spawn_unchecked)
+- [`std::str::CharIndices::offset`](https://doc.rust-lang.org/nightly/std/str/struct.CharIndices.html#method.offset)
+- [`std::option::Option::is_none_or`](https://doc.rust-lang.org/nightly/std/option/enum.Option.html#method.is_none_or)
+- [`[T]::is_sorted`](https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted)
+- [`[T]::is_sorted_by`](https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted_by)
+- [`[T]::is_sorted_by_key`](https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted_by_key)
+- [`Iterator::is_sorted`](https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted)
+- [`Iterator::is_sorted_by`](https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted_by)
+- [`Iterator::is_sorted_by_key`](https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted_by_key)
+- [`std::future::Ready::into_inner`](https://doc.rust-lang.org/nightly/std/future/struct.Ready.html#method.into_inner)
+- [`std::iter::repeat_n`](https://doc.rust-lang.org/nightly/std/iter/fn.repeat_n.html)
+- [`impl<T: Clone> DoubleEndedIterator for Take<Repeat<T>>`](https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-DoubleEndedIterator-for-Take%3CRepeat%3CT%3E%3E)
+- [`impl<T: Clone> ExactSizeIterator for Take<Repeat<T>>`](https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-ExactSizeIterator-for-Take%3CRepeat%3CT%3E%3E)
+- [`impl<T: Clone> ExactSizeIterator for Take<RepeatWith<T>>`](https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-ExactSizeIterator-for-Take%3CRepeatWith%3CF%3E%3E)
+- [`impl Default for std::collections::binary_heap::Iter`](https://doc.rust-lang.org/nightly/std/collections/binary_heap/struct.Iter.html#impl-Default-for-Iter%3C'_,+T%3E)
+- [`impl Default for std::collections::btree_map::RangeMut`](https://doc.rust-lang.org/nightly/std/collections/btree_map/struct.RangeMut.html#impl-Default-for-RangeMut%3C'_,+K,+V%3E)
+- [`impl Default for std::collections::btree_map::ValuesMut`](https://doc.rust-lang.org/nightly/std/collections/btree_map/struct.ValuesMut.html#impl-Default-for-ValuesMut%3C'_,+K,+V%3E)
+- [`impl Default for std::collections::vec_deque::Iter`](https://doc.rust-lang.org/nightly/std/collections/vec_deque/struct.Iter.html#impl-Default-for-Iter%3C'_,+T%3E)
+- [`impl Default for std::collections::vec_deque::IterMut`](https://doc.rust-lang.org/nightly/std/collections/vec_deque/struct.IterMut.html#impl-Default-for-IterMut%3C'_,+T%3E)
+- [`Rc<T>::new_uninit`](https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new_uninit)
+- [`Rc<MaybeUninit<T>>::assume_init`](https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.assume_init)
+- [`Rc<[T]>::new_uninit_slice`](https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new_uninit_slice)
+- [`Rc<[MaybeUninit<T>]>::assume_init`](https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.assume_init-1)
+- [`Arc<T>::new_uninit`](https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.new_uninit)
+- [`Arc<MaybeUninit<T>>::assume_init`](https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.assume_init)
+- [`Arc<[T]>::new_uninit_slice`](https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.new_uninit_slice)
+- [`Arc<[MaybeUninit<T>]>::assume_init`](https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.assume_init-1)
+- [`Box<T>::new_uninit`](https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.new_uninit)
+- [`Box<MaybeUninit<T>>::assume_init`](https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.assume_init)
+- [`Box<[T]>::new_uninit_slice`](https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.new_uninit_slice)
+- [`Box<[MaybeUninit<T>]>::assume_init`](https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.assume_init-1)
+- [`core::arch::x86_64::_bextri_u64`](https://doc.rust-lang.org/stable/core/arch/x86_64/fn._bextri_u64.html)
+- [`core::arch::x86_64::_bextri_u32`](https://doc.rust-lang.org/stable/core/arch/x86_64/fn._bextri_u32.html)
+- [`core::arch::x86::_mm_broadcastsi128_si256`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_broadcastsi128_si256.html)
+- [`core::arch::x86::_mm256_stream_load_si256`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm256_stream_load_si256.html)
+- [`core::arch::x86::_tzcnt_u16`](https://doc.rust-lang.org/stable/core/arch/x86/fn._tzcnt_u16.html)
+- [`core::arch::x86::_mm_extracti_si64`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_extracti_si64.html)
+- [`core::arch::x86::_mm_inserti_si64`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_inserti_si64.html)
+- [`core::arch::x86::_mm_storeu_si16`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si16.html)
+- [`core::arch::x86::_mm_storeu_si32`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si32.html)
+- [`core::arch::x86::_mm_storeu_si64`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si64.html)
+- [`core::arch::x86::_mm_loadu_si16`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_loadu_si16.html)
+- [`core::arch::x86::_mm_loadu_si32`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_loadu_si32.html)
+- [`core::arch::wasm32::u8x16_relaxed_swizzle`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u8x16_relaxed_swizzle.html)
+- [`core::arch::wasm32::i8x16_relaxed_swizzle`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i8x16_relaxed_swizzle.html)
+- [`core::arch::wasm32::i32x4_relaxed_trunc_f32x4`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_trunc_f32x4.html)
+- [`core::arch::wasm32::u32x4_relaxed_trunc_f32x4`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_trunc_f32x4.html)
+- [`core::arch::wasm32::i32x4_relaxed_trunc_f64x2_zero`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_trunc_f64x2_zero.html)
+- [`core::arch::wasm32::u32x4_relaxed_trunc_f64x2_zero`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_trunc_f64x2_zero.html)
+- [`core::arch::wasm32::f32x4_relaxed_madd`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_madd.html)
+- [`core::arch::wasm32::f32x4_relaxed_nmadd`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_nmadd.html)
+- [`core::arch::wasm32::f64x2_relaxed_madd`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_madd.html)
+- [`core::arch::wasm32::f64x2_relaxed_nmadd`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_nmadd.html)
+- [`core::arch::wasm32::i8x16_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i8x16_relaxed_laneselect.html)
+- [`core::arch::wasm32::u8x16_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u8x16_relaxed_laneselect.html)
+- [`core::arch::wasm32::i16x8_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_laneselect.html)
+- [`core::arch::wasm32::u16x8_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_laneselect.html)
+- [`core::arch::wasm32::i32x4_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_laneselect.html)
+- [`core::arch::wasm32::u32x4_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_laneselect.html)
+- [`core::arch::wasm32::i64x2_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i64x2_relaxed_laneselect.html)
+- [`core::arch::wasm32::u64x2_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u64x2_relaxed_laneselect.html)
+- [`core::arch::wasm32::f32x4_relaxed_min`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_min.html)
+- [`core::arch::wasm32::f32x4_relaxed_max`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_max.html)
+- [`core::arch::wasm32::f64x2_relaxed_min`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_min.html)
+- [`core::arch::wasm32::f64x2_relaxed_max`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_max.html)
+- [`core::arch::wasm32::i16x8_relaxed_q15mulr`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_q15mulr.html)
+- [`core::arch::wasm32::u16x8_relaxed_q15mulr`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_q15mulr.html)
+- [`core::arch::wasm32::i16x8_relaxed_dot_i8x16_i7x16`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_dot_i8x16_i7x16.html)
+- [`core::arch::wasm32::u16x8_relaxed_dot_i8x16_i7x16`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_dot_i8x16_i7x16.html)
+- [`core::arch::wasm32::i32x4_relaxed_dot_i8x16_i7x16_add`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_dot_i8x16_i7x16_add.html)
+- [`core::arch::wasm32::u32x4_relaxed_dot_i8x16_i7x16_add`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_dot_i8x16_i7x16_add.html)
+
+These APIs are now stable in const contexts:
+
+- [`std::task::Waker::from_raw`](https://doc.rust-lang.org/nightly/std/task/struct.Waker.html#method.from_raw)
+- [`std::task::Context::from_waker`](https://doc.rust-lang.org/nightly/std/task/struct.Context.html#method.from_waker)
+- [`std::task::Context::waker`](https://doc.rust-lang.org/nightly/std/task/struct.Context.html#method.waker)
+- [`{integer}::from_str_radix`](https://doc.rust-lang.org/nightly/std/primitive.u32.html#method.from_str_radix)
+- [`std::num::ParseIntError::kind`](https://doc.rust-lang.org/nightly/std/num/struct.ParseIntError.html#method.kind)
+
+<a id="1.82.0-Cargo"></a>
+
+Cargo
+-----
+- [feat: Add `info` cargo subcommand](https://github.com/rust-lang/cargo/pull/14141/)
+
+<a id="1.82.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+ - We now [disallow setting some built-in cfgs via the command-line](https://github.com/rust-lang/rust/pull/126158) with the newly added [`explicit_builtin_cfgs_in_flags`](https://doc.rust-lang.org/rustc/lints/listing/deny-by-default.html#explicit-builtin-cfgs-in-flags) lint in order to prevent incoherent state, eg. `windows` cfg active but target is Linux based. The appropriate [`rustc` flag](https://doc.rust-lang.org/rustc/command-line-arguments.html) should be used instead.
+- The standard library has a new implementation of `binary_search` which is significantly improves performance ([#128254](https://github.com/rust-lang/rust/pull/128254)). However when a sorted slice has multiple values which compare equal, the new implementation may select a different value among the equal ones than the old implementation.
+- [illumos/Solaris now sets `MSG_NOSIGNAL` when writing to sockets](https://github.com/rust-lang/rust/pull/128259). This avoids killing the process with SIGPIPE when writing to a closed socket, which matches the existing behavior on other UNIX targets.
+- [Removes a problematic hack that always passed the --whole-archive linker flag for tests, which may cause linker errors for code accidentally relying on it.](https://github.com/rust-lang/rust/pull/128400)
+- The WebAssembly target features `multivalue` and `reference-types` are now
+ both enabled by default. These two features both have subtle changes implied
+ for generated WebAssembly binaries. For the `multivalue` feature, WebAssembly
+ target support has changed when upgrading to LLVM 19. Support for generating
+ functions with multiple returns no longer works and
+ `-Ctarget-feature=+multivalue` has a different meaning than it did in LLVM 18
+ and prior. There is no longer any supported means to generate a module that has
+ a function with multiple returns in WebAssembly from Rust source code. For the
+ `reference-types` feature the encoding of immediates in the `call_indirect`, a
+ commonly used instruction by the WebAssembly backend, has changed. Validators
+ and parsers which don't understand the `reference-types` proposal will no
+ longer accept modules produced by LLVM due to this change in encoding of
+ immediates. Additionally these features being enabled are encoded in the
+ `target_features` custom section and may affect downstream tooling such as
+ `wasm-opt` consuming the module. Generating a WebAssembly module that disables
+ default features requires `-Zbuild-std` support from Cargo and more information
+ can be found at
+ [rust-lang/rust#128511](https://github.com/rust-lang/rust/pull/128511).
+- [Rust now raises unsafety errors for union patterns in parameter-position](https://github.com/rust-lang/rust/pull/130531)
+
+
+<a id="1.82.0-Internal-Changes"></a>
+
+Internal Changes
+----------------
+
+These changes do not affect any public interfaces of Rust, but they represent
+significant improvements to the performance or internals of rustc and related
+tools.
+
+- [Update to LLVM 19](https://github.com/rust-lang/rust/pull/127513)
+
+Version 1.81.0 (2024-09-05)
+==========================
+
+<a id="1.81.0-Language"></a>
+
+Language
+--------
+
+- [Abort on uncaught panics in `extern "C"` functions.](https://github.com/rust-lang/rust/pull/116088/)
+- [Fix ambiguous cases of multiple `&` in elided self lifetimes.](https://github.com/rust-lang/rust/pull/117967/)
+- [Stabilize `#[expect]` for lints (RFC 2383),](https://github.com/rust-lang/rust/pull/120924/) like `#[allow]` with a warning if the lint is _not_ fulfilled.
+- [Change method resolution to constrain hidden types instead of rejecting method candidates.](https://github.com/rust-lang/rust/pull/123962/)
+- [Bump `elided_lifetimes_in_associated_constant` to deny.](https://github.com/rust-lang/rust/pull/124211/)
+- [`offset_from`: always allow pointers to point to the same address.](https://github.com/rust-lang/rust/pull/124921/)
+- [Allow constraining opaque types during subtyping in the trait system.](https://github.com/rust-lang/rust/pull/125447/)
+- [Allow constraining opaque types during various unsizing casts.](https://github.com/rust-lang/rust/pull/125610/)
+- [Deny keyword lifetimes pre-expansion.](https://github.com/rust-lang/rust/pull/126762/)
+
+<a id="1.81.0-Compiler"></a>
+
+Compiler
+--------
+
+- [Make casts of pointers to trait objects stricter.](https://github.com/rust-lang/rust/pull/120248/)
+- [Check alias args for well-formedness even if they have escaping bound vars.](https://github.com/rust-lang/rust/pull/123737/)
+- [Deprecate no-op codegen option `-Cinline-threshold=...`.](https://github.com/rust-lang/rust/pull/124712/)
+- [Re-implement a type-size based limit.](https://github.com/rust-lang/rust/pull/125507/)
+- [Properly account for alignment in `transmute` size checks.](https://github.com/rust-lang/rust/pull/125740/)
+- [Remove the `box_pointers` lint.](https://github.com/rust-lang/rust/pull/126018/)
+- [Ensure the interpreter checks bool/char for validity when they are used in a cast.](https://github.com/rust-lang/rust/pull/126265/)
+- [Improve coverage instrumentation for functions containing nested items.](https://github.com/rust-lang/rust/pull/127199/)
+- Target changes:
+ - [Add Tier 3 `no_std` Xtensa targets:](https://github.com/rust-lang/rust/pull/125141/) `xtensa-esp32-none-elf`, `xtensa-esp32s2-none-elf`, `xtensa-esp32s3-none-elf`
+ - [Add Tier 3 `std` Xtensa targets:](https://github.com/rust-lang/rust/pull/126380/) `xtensa-esp32-espidf`, `xtensa-esp32s2-espidf`, `xtensa-esp32s3-espidf`
+ - [Add Tier 3 i686 Redox OS target:](https://github.com/rust-lang/rust/pull/126192/) `i686-unknown-redox`
+ - [Promote `arm64ec-pc-windows-msvc` to Tier 2.](https://github.com/rust-lang/rust/pull/126039/)
+ - [Promote `loongarch64-unknown-linux-musl` to Tier 2 with host tools.](https://github.com/rust-lang/rust/pull/126298/)
+ - [Enable full tools and profiler for LoongArch Linux targets.](https://github.com/rust-lang/rust/pull/127078/)
+ - [Unconditionally warn on usage of `wasm32-wasi`.](https://github.com/rust-lang/rust/pull/126662/) (see compatibility note below)
+ - Refer to Rust's [platform support page][platform-support-doc] for more information on Rust's tiered platform support.
+
+<a id="1.81.0-Libraries"></a>
+
+Libraries
+---------
+
+- [Split core's `PanicInfo` and std's `PanicInfo`.](https://github.com/rust-lang/rust/pull/115974/) (see compatibility note below)
+- [Generalize `{Rc,Arc}::make_mut()` to unsized types.](https://github.com/rust-lang/rust/pull/116113/)
+- [Replace sort implementations with stable `driftsort` and unstable `ipnsort`.](https://github.com/rust-lang/rust/pull/124032/) All `slice::sort*` and `slice::select_nth*` methods are expected to see significant performance improvements. See the [research project](https://github.com/Voultapher/sort-research-rs) for more details.
+- [Document behavior of `create_dir_all` with respect to empty paths.](https://github.com/rust-lang/rust/pull/125112/)
+- [Fix interleaved output in the default panic hook when multiple threads panic simultaneously.](https://github.com/rust-lang/rust/pull/127397/)
+- Fix `Command`'s batch files argument escaping not working when file name has trailing whitespace or periods (CVE-2024-43402).
+
+<a id="1.81.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`core::error`](https://doc.rust-lang.org/stable/core/error/index.html)
+- [`hint::assert_unchecked`](https://doc.rust-lang.org/stable/core/hint/fn.assert_unchecked.html)
+- [`fs::exists`](https://doc.rust-lang.org/stable/std/fs/fn.exists.html)
+- [`AtomicBool::fetch_not`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.AtomicBool.html#method.fetch_not)
+- [`Duration::abs_diff`](https://doc.rust-lang.org/stable/core/time/struct.Duration.html#method.abs_diff)
+- [`IoSlice::advance`](https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html#method.advance)
+- [`IoSlice::advance_slices`](https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html#method.advance_slices)
+- [`IoSliceMut::advance`](https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.advance)
+- [`IoSliceMut::advance_slices`](https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.advance_slices)
+- [`PanicHookInfo`](https://doc.rust-lang.org/stable/std/panic/struct.PanicHookInfo.html)
+- [`PanicInfo::message`](https://doc.rust-lang.org/stable/core/panic/struct.PanicInfo.html#method.message)
+- [`PanicMessage`](https://doc.rust-lang.org/stable/core/panic/struct.PanicMessage.html)
+
+These APIs are now stable in const contexts:
+
+- [`char::from_u32_unchecked`](https://doc.rust-lang.org/stable/core/char/fn.from_u32_unchecked.html) (function)
+- [`char::from_u32_unchecked`](https://doc.rust-lang.org/stable/core/primitive.char.html#method.from_u32_unchecked) (method)
+- [`CStr::count_bytes`](https://doc.rust-lang.org/stable/core/ffi/c_str/struct.CStr.html#method.count_bytes)
+- [`CStr::from_ptr`](https://doc.rust-lang.org/stable/core/ffi/c_str/struct.CStr.html#method.from_ptr)
+
+<a id="1.81.0-Cargo"></a>
+
+Cargo
+-----
+
+- [Generated `.cargo_vcs_info.json` is always included, even when `--allow-dirty` is passed.](https://github.com/rust-lang/cargo/pull/13960/)
+- [Disallow `package.license-file` and `package.readme` pointing to non-existent files during packaging.](https://github.com/rust-lang/cargo/pull/13921/)
+- [Disallow passing `--release`/`--debug` flag along with the `--profile` flag.](https://github.com/rust-lang/cargo/pull/13971/)
+- [Remove `lib.plugin` key support in `Cargo.toml`. Rust plugin support has been deprecated for four years and was removed in 1.75.0.](https://github.com/rust-lang/cargo/pull/13902/)
+
+<a id="1.81.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+
+* Usage of the `wasm32-wasi` target will now issue a compiler warning and request users switch to the `wasm32-wasip1` target instead. Both targets are the same, `wasm32-wasi` is only being renamed, and this [change to the WASI target](https://blog.rust-lang.org/2024/04/09/updates-to-rusts-wasi-targets.html) is being done to enable removing `wasm32-wasi` in January 2025.
+
+* We have renamed `std::panic::PanicInfo` to `std::panic::PanicHookInfo`. The old name will continue to work as an alias, but will result in a deprecation warning starting in Rust 1.82.0.
+
+ `core::panic::PanicInfo` will remain unchanged, however, as this is now a *different type*.
+
+ The reason is that these types have different roles: `std::panic::PanicHookInfo` is the argument to the [panic hook](https://doc.rust-lang.org/stable/std/panic/fn.set_hook.html) in std context (where panics can have an arbitrary payload), while `core::panic::PanicInfo` is the argument to the [`#[panic_handler]`](https://doc.rust-lang.org/nomicon/panic-handler.html) in no_std context (where panics always carry a formatted *message*). Separating these types allows us to add more useful methods to these types, such as `std::panic::PanicHookInfo::payload_as_str()` and `core::panic::PanicInfo::message()`.
+
+* The new sort implementations may panic if a type's implementation of [`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html) (or the given comparison function) does not implement a [total order](https://en.wikipedia.org/wiki/Total_order) as the trait requires. `Ord`'s supertraits (`PartialOrd`, `Eq`, and `PartialEq`) must also be consistent. The previous implementations would not "notice" any problem, but the new implementations have a good chance of detecting inconsistencies, throwing a panic rather than returning knowingly unsorted data.
+* [In very rare cases, a change in the internal evaluation order of the trait
+ solver may result in new fatal overflow errors.](https://github.com/rust-lang/rust/pull/126128)
+
+
+<a id="1.81.0-Internal-Changes"></a>
+
+Internal Changes
+----------------
+
+These changes do not affect any public interfaces of Rust, but they represent
+significant improvements to the performance or internals of rustc and related
+tools.
+
+- [Add a Rust-for Linux `auto` CI job to check kernel builds.](https://github.com/rust-lang/rust/pull/125209/)
+
+Version 1.80.1 (2024-08-08)
+===========================
+
+<a id="1.80.1"></a>
+
+- [Fix miscompilation in the jump threading MIR optimization when comparing floats](https://github.com/rust-lang/rust/pull/128271)
+- [Revert changes to the `dead_code` lint from 1.80.0](https://github.com/rust-lang/rust/pull/128618)
+
+Version 1.80.0 (2024-07-25)
==========================
<a id="1.80-Language"></a>
@@ -52,7 +980,7 @@ Stabilized APIs
- [`impl Default for Arc<CStr>`](https://doc.rust-lang.org/beta/alloc/sync/struct.Arc.html#impl-Default-for-Arc%3CCStr%3E)
- [`impl Default for Arc<[T]>`](https://doc.rust-lang.org/beta/alloc/sync/struct.Arc.html#impl-Default-for-Arc%3C%5BT%5D%3E)
- [`impl IntoIterator for Box<[T]>`](https://doc.rust-lang.org/beta/alloc/boxed/struct.Box.html#impl-IntoIterator-for-Box%3C%5BI%5D,+A%3E)
-- [`impl FromIterator<String> for Box<str>`](https://doc.rust-lang.org/beta/alloc/boxed/struct.Box.html#impl-FromIterator%3CString%3E-for-Box%3Cstr%3E)
+- [`impl FromIterator<String> for Box<str>`](https://doc.rust-lang.org/beta/alloc/boxed/struct.Box.html#impl-FromIterator%3CString%3E-for-Box%3Cstr%3E)
- [`impl FromIterator<char> for Box<str>`](https://doc.rust-lang.org/beta/alloc/boxed/struct.Box.html#impl-FromIterator%3Cchar%3E-for-Box%3Cstr%3E)
- [`LazyCell`](https://doc.rust-lang.org/beta/core/cell/struct.LazyCell.html)
- [`LazyLock`](https://doc.rust-lang.org/beta/std/sync/struct.LazyLock.html)
@@ -67,7 +995,7 @@ Stabilized APIs
- [`NonNull::byte_add`](https://doc.rust-lang.org/beta/std/ptr/struct.NonNull.html#method.byte_add)
- [`NonNull::sub`](https://doc.rust-lang.org/beta/std/ptr/struct.NonNull.html#method.sub)
- [`NonNull::byte_sub`](https://doc.rust-lang.org/beta/std/ptr/struct.NonNull.html#method.byte_sub)
-- [`NonNull:offset_from`](https://doc.rust-lang.org/beta/std/ptr/struct.NonNull.html#method.offset_from)
+- [`NonNull::offset_from`](https://doc.rust-lang.org/beta/std/ptr/struct.NonNull.html#method.offset_from)
- [`NonNull::byte_offset_from`](https://doc.rust-lang.org/beta/std/ptr/struct.NonNull.html#method.byte_offset_from)
- [`NonNull::read`](https://doc.rust-lang.org/beta/std/ptr/struct.NonNull.html#method.read)
- [`NonNull::read_volatile`](https://doc.rust-lang.org/beta/std/ptr/struct.NonNull.html#method.read_volatile)
@@ -91,9 +1019,9 @@ Stabilized APIs
- [`str::trim_ascii`](https://doc.rust-lang.org/beta/std/primitive.str.html#method.trim_ascii)
- [`str::trim_ascii_start`](https://doc.rust-lang.org/beta/std/primitive.str.html#method.trim_ascii_start)
- [`str::trim_ascii_end`](https://doc.rust-lang.org/beta/std/primitive.str.html#method.trim_ascii_end)
-- [`<[AsciiChar]>::trim_ascii`](https://doc.rust-lang.org/beta/core/primitive.slice.html#method.trim_ascii)
-- [`<[AsciiChar]>::trim_ascii_start`](https://doc.rust-lang.org/beta/core/primitive.slice.html#method.trim_ascii_start)
-- [`<[AsciiChar]>::trim_ascii_end`](https://doc.rust-lang.org/beta/core/primitive.slice.html#method.trim_ascii_end)
+- [`<[u8]>::trim_ascii`](https://doc.rust-lang.org/beta/core/primitive.slice.html#method.trim_ascii)
+- [`<[u8]>::trim_ascii_start`](https://doc.rust-lang.org/beta/core/primitive.slice.html#method.trim_ascii_start)
+- [`<[u8]>::trim_ascii_end`](https://doc.rust-lang.org/beta/core/primitive.slice.html#method.trim_ascii_end)
- [`Ipv4Addr::BITS`](https://doc.rust-lang.org/beta/core/net/struct.Ipv4Addr.html#associatedconstant.BITS)
- [`Ipv4Addr::to_bits`](https://doc.rust-lang.org/beta/core/net/struct.Ipv4Addr.html#method.to_bits)
- [`Ipv4Addr::from_bits`](https://doc.rust-lang.org/beta/core/net/struct.Ipv4Addr.html#method.from_bits)
@@ -143,6 +1071,8 @@ Compatibility Notes
- [Turn `proc_macro_back_compat` lint into a hard error.](https://github.com/rust-lang/rust/pull/125596/)
- [Detect unused structs even when implementing private traits](https://github.com/rust-lang/rust/pull/122382/)
- [`std::sync::ReentrantLockGuard<T>` is no longer `Sync` if `T: !Sync`](https://github.com/rust-lang/rust/pull/125527) which means [`std::io::StdoutLock` and `std::io::StderrLock` are no longer Sync](https://github.com/rust-lang/rust/issues/127340)
+- [Type inference will fail in some cases due to new implementations of `FromIterator for Box<str>`.](https://github.com/rust-lang/rust/pull/99969/)
+ Notably, this breaks versions of the `time` crate before 0.3.35, due to no longer inferring the implementation for `Box<[_]>`.
<a id="1.80-Internal-Changes"></a>
@@ -368,13 +1298,6 @@ Cargo
- [Support `target.<triple>.rustdocflags` officially](https://github.com/rust-lang/cargo/pull/13197/)
- [Stabilize global cache data tracking](https://github.com/rust-lang/cargo/pull/13492/)
-<a id="1.78.0-Misc"></a>
-
-Misc
-----
-
-- [rustdoc: add `--test-builder-wrapper` arg to support wrappers such as RUSTC_WRAPPER when building doctests](https://github.com/rust-lang/rust/pull/114651/)
-
<a id="1.78.0-Compatibility-Notes"></a>
Compatibility Notes
@@ -1289,7 +2212,7 @@ Compiler
- [Detect uninhabited types early in const eval](https://github.com/rust-lang/rust/pull/109435/)
- [Switch to LLD as default linker for {arm,thumb}v4t-none-eabi](https://github.com/rust-lang/rust/pull/109721/)
- [Add tier 3 target `loongarch64-unknown-linux-gnu`](https://github.com/rust-lang/rust/pull/96971)
-- [Add tier 3 target for `i586-pc-nto-qnx700` (QNX Neutrino RTOS, version 7.0)](https://github.com/rust-lang/rust/pull/109173/),
+- [Add tier 3 target for `i586-pc-nto-qnx700` (QNX Neutrino RTOS, version 7.0)](https://github.com/rust-lang/rust/pull/109173/),
- [Insert alignment checks for pointer dereferences as debug assertions](https://github.com/rust-lang/rust/pull/98112)
This catches undefined behavior at runtime, and may cause existing code to fail.
@@ -1493,10 +2416,10 @@ Compatibility Notes
- [Cargo denies `CARGO_HOME` in the `[env]` configuration table. Cargo itself doesn't pick up this value, but recursive calls to cargo would, which was not intended.](https://github.com/rust-lang/cargo/pull/11644/)
- [Debuginfo for build dependencies is now off if not explicitly set. This is expected to improve the overall build time.](https://github.com/rust-lang/cargo/pull/11252/)
- [The Rust distribution no longer always includes rustdoc](https://github.com/rust-lang/rust/pull/106886)
- If `tools = [...]` is set in config.toml, we will respect a missing rustdoc in that list. By
+ If `tools = [...]` is set in bootstrap.toml, we will respect a missing rustdoc in that list. By
default rustdoc remains included. To retain the prior behavior explicitly add `"rustdoc"` to the
list.
-
+
<a id="1.69.0-Internal-Changes"></a>
Internal Changes
@@ -1540,7 +2463,7 @@ Language
--------
- [Stabilize default_alloc_error_handler](https://github.com/rust-lang/rust/pull/102318/)
- This allows usage of `alloc` on stable without requiring the
+ This allows usage of `alloc` on stable without requiring the
definition of a handler for allocation failure. Defining custom handlers is still unstable.
- [Stabilize `efiapi` calling convention.](https://github.com/rust-lang/rust/pull/105795/)
- [Remove implicit promotion for types with drop glue](https://github.com/rust-lang/rust/pull/105085/)
@@ -4479,7 +5402,7 @@ related tools.
- [Building `rustc` from source now uses `ninja` by default over `make`.][74922]
You can continue building with `make` by setting `ninja=false` in
- your `config.toml`.
+ your `bootstrap.toml`.
- [cg_llvm: `fewer_names` in `uncached_llvm_type`][76030]
- [Made `ensure_sufficient_stack()` non-generic][76680]
diff --git a/REUSE.toml b/REUSE.toml
new file mode 100644
index 0000000000000..816c6d730c824
--- /dev/null
+++ b/REUSE.toml
@@ -0,0 +1,205 @@
+version = 1
+
+# Reuse annotations file.
+#
+# This file controls how reuse-tool finds copyright and license notices within
+# source files. As the tool has a habit of picking up random uses of the word
+# 'Copyright' within source code, and because it will complain that other files
+# do not contain any specific copyright and license notifications, we usually
+# just set a blanket license and copyright notice for a whole sub-tree at a
+# time.
+#
+# See https://reuse.software and https://github.com/fsfe/reuse-tool for more
+# details. We currently use reuse-tool version 4.0.3.
+
+[[annotations]]
+path = [
+ "compiler/**",
+ "library/**",
+ "tests/**",
+ "src/**",
+ ".github/**",
+ "Cargo.lock",
+ "Cargo.toml",
+ "CODE_OF_CONDUCT.md",
+ "bootstrap.example.toml",
+ "configure",
+ "CONTRIBUTING.md",
+ "COPYRIGHT",
+ "INSTALL.md",
+ "LICENSE-APACHE",
+ "license-metadata.json",
+ "LICENSE-MIT",
+ "README.md",
+ "RELEASES.md",
+ "REUSE.toml",
+ "rustfmt.toml",
+ "rust-bors.toml",
+ "triagebot.toml",
+ "x",
+ "x.ps1",
+ "x.py",
+ ".clang-format",
+ ".editorconfig",
+ ".git-blame-ignore-revs",
+ ".gitattributes",
+ ".gitignore",
+ ".gitmodules",
+ ".mailmap",
+ ".ignore",
+]
+precedence = "override"
+SPDX-FileCopyrightText = "The Rust Project Developers (see https://thanks.rust-lang.org)"
+SPDX-License-Identifier = "MIT or Apache-2.0"
+
+[[annotations]]
+path = "compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "2003-2019 University of Illinois at Urbana-Champaign.",
+ "The Rust Project Developers (see https://thanks.rust-lang.org)",
+]
+SPDX-License-Identifier = "Apache-2.0 WITH LLVM-exception AND (Apache-2.0 OR MIT)"
+
+[[annotations]]
+path = "library/core/src/unicode/unicode_data.rs"
+precedence = "override"
+SPDX-FileCopyrightText = "1991-2024 Unicode, Inc."
+SPDX-License-Identifier = "Unicode-3.0"
+
+[[annotations]]
+path = "library/std/src/sync/mpmc/**"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "2019 The Crossbeam Project Developers",
+ "The Rust Project Developers (see https://thanks.rust-lang.org)",
+]
+SPDX-License-Identifier = "MIT OR Apache-2.0"
+
+[[annotations]]
+path = "library/std/src/sys/sync/mutex/fuchsia.rs"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "2016 The Fuchsia Authors",
+ "The Rust Project Developers (see https://thanks.rust-lang.org)",
+]
+SPDX-License-Identifier = "BSD-2-Clause AND (MIT OR Apache-2.0)"
+
+[[annotations]]
+path = "src/test/rustdoc/auxiliary/enum-primitive.rs"
+precedence = "override"
+SPDX-FileCopyrightText = "2015 Anders Kaseorg <andersk@mit.edu>"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "src/librustdoc/html/static/fonts/Fira**"
+precedence = "override"
+SPDX-FileCopyrightText = ["2014, Mozilla Foundation", "2014, Telefonica S.A."]
+SPDX-License-Identifier = "OFL-1.1"
+
+[[annotations]]
+path = "src/librustdoc/html/static/fonts/NanumBarun**"
+precedence = "override"
+SPDX-FileCopyrightText = "2010 NAVER Corporation"
+SPDX-License-Identifier = "OFL-1.1"
+
+[[annotations]]
+path = [
+ "src/librustdoc/html/static/fonts/SourceCodePro**",
+ "src/librustdoc/html/static/fonts/SourceSerif4**",
+]
+precedence = "override"
+SPDX-FileCopyrightText = "2010, 2012, 2014-2023, Adobe Systems Incorporated"
+SPDX-License-Identifier = "OFL-1.1"
+
+[[annotations]]
+path = "src/librustdoc/html/static/css/normalize.css"
+precedence = "override"
+SPDX-FileCopyrightText = "Nicolas Gallagher and Jonathan Neal"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "src/librustdoc/html/static/css/rustdoc.css"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "2016 Ike Ku, Jessica Stokes and Leon Guan",
+ "The Rust Project Developers (see https://thanks.rust-lang.org)",
+]
+SPDX-License-Identifier = "MIT OR Apache-2.0"
+
+[[annotations]]
+path = "src/doc/rustc-dev-guide/mermaid.min.js"
+precedence = "override"
+SPDX-FileCopyrightText = "2014-2021 Knut Sveidqvist"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "library/backtrace/**"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "2014 Alex Crichton",
+ "The Rust Project Developers (see https://thanks.rust-lang.org)",
+]
+SPDX-License-Identifier = "MIT OR Apache-2.0"
+
+[[annotations]]
+path = "src/doc/embedded-book/**"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "Rust on Embedded Devices Working Group",
+ "The Rust Project Developers (see https://thanks.rust-lang.org)",
+]
+SPDX-License-Identifier = "MIT OR Apache-2.0 OR CC-BY-SA-4.0"
+
+[[annotations]]
+path = "src/doc/rust-by-example/**"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "2014 Jorge Aparicio",
+ "The Rust Project Developers (see https://thanks.rust-lang.org)",
+]
+SPDX-License-Identifier = "MIT OR Apache-2.0"
+
+[[annotations]]
+path = "src/llvm-project/**"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "2003-2019 by the contributors listed in CREDITS.TXT (https://github.com/rust-lang/llvm-project/blob/7738295178045041669876bf32b0543ec8319a5c/llvm/CREDITS.TXT)",
+ "2010 Apple Inc",
+ "2003-2019 University of Illinois at Urbana-Champaign.",
+]
+SPDX-License-Identifier = "NCSA AND Apache-2.0 WITH LLVM-exception"
+
+[[annotations]]
+path = "src/gcc/**"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "Copyright (C) 1997-2024 Free Software Foundation, Inc.",
+]
+SPDX-License-Identifier = "GPL-3.0-or-later"
+
+[[annotations]]
+path = "src/gcc/gcc/testsuite/**"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "Copyright (C) 2000-2024 Free Software Foundation, Inc.",
+]
+SPDX-License-Identifier = "GPL-2.0-only"
+
+[[annotations]]
+path = "src/gcc/gcc/testsuite/c-c++-common/analyzer/*.c"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "Copyright (c) 2007-2011 Atheros Communications Inc.",
+ "Copyright (c) 2011-2012,2017 Qualcomm Atheros, Inc.",
+ "Copyright (c) 2016-2017 Erik Stromdahl <erik.stromdahl@gmail.com>",
+]
+SPDX-License-Identifier = "ISC"
+
+[[annotations]]
+path = "src/gcc/libstdc++-v3/config/os/aix/os_defines.h"
+precedence = "override"
+SPDX-FileCopyrightText = [
+ "Copyright (C) 2000-2024 Free Software Foundation, Inc.",
+]
+SPDX-License-Identifier = "GCC-exception-3.1"
diff --git a/bootstrap.example.toml b/bootstrap.example.toml
new file mode 100644
index 0000000000000..1371fd6442f96
--- /dev/null
+++ b/bootstrap.example.toml
@@ -0,0 +1,1016 @@
+# Sample TOML configuration file for building Rust.
+#
+# To configure bootstrap, run `./configure` or `./x.py setup`.
+# See https://rustc-dev-guide.rust-lang.org/building/how-to-build-and-run.html#create-a-bootstraptoml for more information.
+#
+# All options are commented out by default in this file, and they're commented
+# out with their default values. The build system by default looks for
+# `bootstrap.toml` in the current directory of a build for build configuration, but
+# a custom configuration file can also be specified with `--config` to the build
+# system.
+
+# =============================================================================
+# Global Settings
+# =============================================================================
+
+# Use different pre-set defaults than the global defaults.
+#
+# See `src/bootstrap/defaults` for more information.
+# Note that this has no default value (x.py uses the defaults in `bootstrap.example.toml`).
+#profile = <none>
+
+# Inherits configuration values from different configuration files (a.k.a. config extensions).
+# Supports absolute paths, and uses the current directory (where the bootstrap was invoked)
+# as the base if the given path is not absolute.
+#
+# The overriding logic follows a right-to-left order. For example, in `include = ["a.toml", "b.toml"]`,
+# extension `b.toml` overrides `a.toml`. Also, parent extensions always overrides the inner ones.
+#include = []
+
+# Keeps track of major changes made to this configuration.
+#
+# This value also represents ID of the PR that caused major changes. Meaning,
+# you can visit github.com/rust-lang/rust/pull/{change-id} to check for more details.
+#
+# A 'major change' includes any of the following
+# - A new option
+# - A change in the default values
+#
+# If the change-id does not match the version currently in use, x.py will
+# display the changes made to the bootstrap.
+# To suppress these warnings, you can set change-id = "ignore".
+#change-id = <latest change id in src/bootstrap/src/utils/change_tracker.rs>
+
+# =============================================================================
+# Tweaking how LLVM is compiled
+# =============================================================================
+[llvm]
+
+# Whether to use Rust CI built LLVM instead of locally building it.
+#
+# Unless you're developing for a target where Rust CI doesn't build a compiler
+# toolchain or changing LLVM locally, you probably want to leave this enabled.
+#
+# Set this to `true` to download if CI llvm available otherwise it builds
+# from `src/llvm-project`.
+#
+# Set this to `"if-unchanged"` to download only if the llvm-project has not
+# been modified. You can also use this if you are unsure whether you're on a
+# tier 1 target. All tier 1 targets are currently supported.
+
+# Currently, we only support this when building LLVM for the build triple.
+#
+# Note that many of the LLVM options are not currently supported for
+# downloading. Currently only the "assertions" option can be toggled.
+#download-ci-llvm = true
+
+# Indicates whether the LLVM build is a Release or Debug build
+#optimize = true
+
+# Indicates whether LLVM should be built with ThinLTO. Note that this will
+# only succeed if you use clang, lld, llvm-ar, and llvm-ranlib in your C/C++
+# toolchain (see the `cc`, `cxx`, `linker`, `ar`, and `ranlib` options below).
+# More info at: https://clang.llvm.org/docs/ThinLTO.html#clang-bootstrap
+#thin-lto = false
+
+# Indicates whether an LLVM Release build should include debug info
+#release-debuginfo = false
+
+# Indicates whether the LLVM assertions are enabled or not
+# NOTE: When assertions are disabled, bugs in the integration between rustc and LLVM can lead to
+# unsoundness (segfaults, etc.) in the rustc process itself, not just in the generated code.
+#assertions = false
+
+# Indicates whether the LLVM testsuite is enabled in the build or not. Does
+# not execute the tests as part of the build as part of x.py build et al,
+# just makes it possible to do `ninja check-llvm` in the staged LLVM build
+# directory when doing LLVM development as part of Rust development.
+#tests = false
+
+# Indicates whether the LLVM plugin is enabled or not
+#plugins = false
+
+# Whether to build Enzyme as AutoDiff backend.
+#enzyme = false
+
+# Whether to build LLVM with support for it's gpu offload runtime.
+#offload = false
+
+# When true, link libstdc++ statically into the rustc_llvm.
+# This is useful if you don't want to use the dynamic version of that
+# library provided by LLVM.
+#static-libstdcpp = false
+
+# Enable LLVM to use zstd for compression.
+#libzstd = false
+
+# Whether to use Ninja to build LLVM. This runs much faster than make.
+#ninja = true
+
+# LLVM targets to build support for.
+# Note: this is NOT related to Rust compilation targets. However, as Rust is
+# dependent on LLVM for code generation, turning targets off here WILL lead to
+# the resulting rustc being unable to compile for the disabled architectures.
+#
+# To add support for new targets, see https://rustc-dev-guide.rust-lang.org/building/new-target.html.
+#targets = "AArch64;AMDGPU;ARM;BPF;Hexagon;LoongArch;MSP430;Mips;NVPTX;PowerPC;RISCV;Sparc;SystemZ;WebAssembly;X86"
+
+# LLVM experimental targets to build support for. These targets are specified in
+# the same format as above, but since these targets are experimental, they are
+# not built by default and the experimental Rust compilation targets that depend
+# on them will not work unless the user opts in to building them.
+#experimental-targets = "AVR;M68k;CSKY"
+
+# Cap the number of parallel linker invocations when compiling LLVM.
+# This can be useful when building LLVM with debug info, which significantly
+# increases the size of binaries and consequently the memory required by
+# each linker process.
+# If set to 0, linker invocations are treated like any other job and
+# controlled by bootstrap's -j parameter.
+#link-jobs = 0
+
+# Whether to build LLVM as a dynamically linked library (as opposed to statically linked).
+# Under the hood, this passes `--shared` to llvm-config.
+# NOTE: To avoid performing LTO multiple times, we suggest setting this to `true` when `thin-lto` is enabled.
+#link-shared = llvm.thin-lto
+
+# When building llvm, this configures what is being appended to the version.
+# To use LLVM version as is, provide an empty string.
+#version-suffix = if rust.channel == "dev" { "-rust-dev" } else { "-rust-$version-$channel" }
+
+# On MSVC you can compile LLVM with clang-cl, but the test suite doesn't pass
+# with clang-cl, so this is special in that it only compiles LLVM with clang-cl.
+# Note that this takes a /path/to/clang-cl, not a boolean.
+#clang-cl = cc
+
+# Pass extra compiler and linker flags to the LLVM CMake build.
+#cflags = ""
+#cxxflags = ""
+#ldflags = ""
+
+# Use libc++ when building LLVM instead of libstdc++. This is the default on
+# platforms already use libc++ as the default C++ library, but this option
+# allows you to use libc++ even on platforms when it's not. You need to ensure
+# that your host compiler ships with libc++.
+#use-libcxx = false
+
+# The value specified here will be passed as `-DLLVM_USE_LINKER` to CMake.
+#use-linker = <none> (path)
+
+# Whether or not to specify `-DLLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN=YES`
+#allow-old-toolchain = false
+
+# Whether to include the Polly optimizer.
+#polly = false
+
+# Whether to build the clang compiler.
+#clang = false
+
+# Whether to enable llvm compilation warnings.
+#enable-warnings = false
+
+# Custom CMake defines to set when building LLVM.
+#build-config = {}
+
+# =============================================================================
+# Tweaking how GCC is compiled
+# =============================================================================
+[gcc]
+# Download GCC from CI instead of building it locally.
+# Note that this will attempt to download GCC even if there are local
+# modifications to the `src/gcc` submodule.
+# Currently, this is only supported for the `x86_64-unknown-linux-gnu` target.
+#download-ci-gcc = false
+
+# =============================================================================
+# General build configuration options
+# =============================================================================
+[build]
+
+# The default stage to use for the `check` subcommand
+#check-stage = 0
+
+# The default stage to use for the `doc` subcommand
+#doc-stage = 0
+
+# The default stage to use for the `build` subcommand
+#build-stage = 1
+
+# The default stage to use for the `test` subcommand
+#test-stage = 1
+
+# The default stage to use for the `dist` subcommand
+#dist-stage = 2
+
+# The default stage to use for the `install` subcommand
+#install-stage = 2
+
+# The default stage to use for the `bench` subcommand
+#bench-stage = 2
+
+# A descriptive string to be appended to version output (e.g., `rustc --version`),
+# which is also used in places like debuginfo `DW_AT_producer`. This may be useful for
+# supplementary build information, like distro-specific package versions.
+#
+# The Rust compiler will differentiate between versions of itself, including
+# based on this string, which means that if you wish to be compatible with
+# upstream Rust you need to set this to "". However, note that if you set this to "" but
+# are not actually compatible -- for example if you've backported patches that change
+# behavior -- this may lead to miscompilations or other bugs.
+#description = ""
+
+# Build triple for the pre-compiled snapshot compiler. If `rustc` is set, this must match its host
+# triple (see `rustc --version --verbose`; cross-compiling the rust build system itself is NOT
+# supported). If `rustc` is unset, this must be a platform with pre-compiled host tools
+# (https://doc.rust-lang.org/nightly/rustc/platform-support.html). The current platform must be
+# able to run binaries of this build triple.
+#
+# If `rustc` is present in path, this defaults to the host it was compiled for.
+# Otherwise, `x.py` will try to infer it from the output of `uname`.
+# If `uname` is not found in PATH, we assume this is `x86_64-pc-windows-msvc`.
+# This may be changed in the future.
+#build = "x86_64-unknown-linux-gnu" (as an example)
+
+# Which triples to produce a compiler toolchain for. Each of these triples will be bootstrapped from
+# the build triple themselves. In other words, this is the list of triples for which to build a
+# compiler that can RUN on that triple.
+#
+# Defaults to just the `build` triple.
+#host = [build.build] (list of triples)
+
+# Which triples to build libraries (core/alloc/std/test/proc_macro) for. Each of these triples will
+# be bootstrapped from the build triple themselves. In other words, this is the list of triples for
+# which to build a library that can CROSS-COMPILE to that triple.
+#
+# Defaults to `host`. If you set this explicitly, you likely want to add all
+# host triples to this list as well in order for those host toolchains to be
+# able to compile programs for their native target.
+#target = build.host (list of triples)
+
+# Use this directory to store build artifacts. Paths are relative to the current directory, not to
+# the root of the repository.
+#build-dir = "build"
+
+# Instead of downloading the src/stage0 version of Cargo specified, use
+# this Cargo binary instead to build all Rust code
+# If you set this, you likely want to set `rustc` as well.
+#cargo = "/path/to/cargo"
+
+# Instead of downloading the src/stage0 version of the compiler
+# specified, use this rustc binary instead as the stage0 snapshot compiler.
+# If you set this, you likely want to set `cargo` as well.
+#rustc = "/path/to/rustc"
+
+# Instead of downloading the src/stage0 version of rustfmt specified,
+# use this rustfmt binary instead as the stage0 snapshot rustfmt.
+#rustfmt = "/path/to/rustfmt"
+
+# Instead of downloading the src/stage0 version of cargo-clippy specified,
+# use this cargo-clippy binary instead as the stage0 snapshot cargo-clippy.
+#
+# Note that this option should be used with the same toolchain as the `rustc` option above.
+# Otherwise, clippy is likely to fail due to a toolchain conflict.
+#cargo-clippy = "/path/to/cargo-clippy"
+
+# Whether to build documentation by default. If false, rustdoc and
+# friends will still be compiled but they will not be used to generate any
+# documentation.
+#
+# You can still build documentation when this is disabled by explicitly passing paths,
+# e.g. `x doc library`.
+#docs = true
+
+# Flag to specify whether CSS, JavaScript, and HTML are minified when
+# docs are generated. JSON is always minified, because it's enormous,
+# and generated in already-minified form from the beginning.
+#docs-minification = true
+
+# Flag to specify whether private items should be included in the library docs.
+#library-docs-private-items = false
+
+# Indicate whether to build compiler documentation by default.
+# You can still build documentation when this is disabled by explicitly passing a path: `x doc compiler`.
+#compiler-docs = false
+
+# Indicate whether git submodules are managed and updated automatically.
+#submodules = true
+
+# The path to (or name of) the GDB executable to use. This is only used for
+# executing the debuginfo test suite.
+#gdb = "gdb"
+
+# The path to (or name of) the LLDB executable to use. This is only used for
+# executing the debuginfo test suite.
+#lldb = "lldb"
+
+# The node.js executable to use. Note that this is only used for the emscripten
+# target when running tests, otherwise this can be omitted.
+#nodejs = "node"
+
+# The npm executable to use. Note that this is used for rustdoc-gui tests,
+# otherwise this can be omitted.
+#
+# Under Windows this should be `npm.cmd` or path to it (verified on nodejs v18.06), or
+# error will be emitted.
+#npm = "npm"
+
+# Python interpreter to use for various tasks throughout the build, notably
+# rustdoc tests, the lldb python interpreter, and some dist bits and pieces.
+#
+# Defaults to the Python interpreter used to execute x.py.
+#python = "python"
+
+# The path to the REUSE executable to use. Note that REUSE is not required in
+# most cases, as our tooling relies on a cached (and shrunk) copy of the
+# REUSE output present in the git repository and in our source tarballs.
+#
+# REUSE is only needed if your changes caused the overall licensing of the
+# repository to change, and the cached copy has to be regenerated.
+#
+# Defaults to the "reuse" command in the system path.
+#reuse = "reuse"
+
+# Force Cargo to check that Cargo.lock describes the precise dependency
+# set that all the Cargo.toml files create, instead of updating it.
+#locked-deps = false
+
+# Indicate whether the vendored sources are used for Rust dependencies or not.
+#
+# Vendoring requires additional setup. We recommend using the pre-generated source tarballs if you
+# want to use vendoring. See https://forge.rust-lang.org/infra/other-installation-methods.html#source-code.
+#vendor = if "is a tarball source" && "vendor" dir exists && ".cargo/config.toml" file exists { true } else { false }
+
+# Typically the build system will build the Rust compiler twice. The second
+# compiler, however, will simply use its own libraries to link against. If you
+# would rather to perform a full bootstrap, compiling the compiler three times,
+# then you can set this option to true.
+#
+# This is only useful for verifying that rustc generates reproducible builds.
+#full-bootstrap = false
+
+# Set the bootstrap/download cache path. It is useful when building rust
+# repeatedly in a CI environment.
+#bootstrap-cache-path = /path/to/shared/cache
+
+# Enable a build of the extended Rust tool set which is not only the compiler
+# but also tools such as Cargo. This will also produce "combined installers"
+# which are used to install Rust and Cargo together.
+# The `tools` (check `bootstrap.example.toml` to see its default value) option specifies
+# which tools should be built if `extended = true`.
+#
+# This is disabled by default.
+#extended = false
+
+# Set of tools to be included in the installation.
+#
+# If `extended = false`, the only one of these built by default is rustdoc.
+#
+# If `extended = true`, they are all included.
+#
+# If any enabled tool fails to build, the installation fails.
+#tools = [
+# "cargo",
+# "clippy",
+# "rustdoc",
+# "rustfmt",
+# "rust-analyzer",
+# "rust-analyzer-proc-macro-srv",
+# "analysis",
+# "src",
+# "wasm-component-ld",
+# "miri", "cargo-miri" # for dev/nightly channels
+#]
+
+# Verbosity level: 0 == not verbose, 1 == verbose, 2 == very verbose, 3 == print environment variables on each rustc invocation
+#verbose = 0
+
+# Build the sanitizer runtimes
+#sanitizers = false
+
+# Build the profiler runtime (required when compiling with options that depend
+# on this runtime, such as `-C profile-generate` or `-C instrument-coverage`).
+#profiler = false
+
+# Use the optimized LLVM C intrinsics for `compiler_builtins`, rather than Rust intrinsics.
+# Requires the LLVM submodule to be managed by bootstrap (i.e. not external) so that `compiler-rt`
+# sources are available.
+#
+# Setting this to `false` generates slower code, but removes the requirement for a C toolchain in
+# order to run `x check`.
+#optimized-compiler-builtins = if rust.channel == "dev" { false } else { true }
+
+# Indicates whether the native libraries linked into Cargo will be statically
+# linked or not.
+#cargo-native-static = false
+
+# Run the build with low priority, by setting the process group's "nice" value
+# to +10 on Unix platforms, and by using a "low priority" job object on Windows.
+#low-priority = false
+
+# Arguments passed to the `./configure` script, used during distcheck. You
+# probably won't fill this in but rather it's filled in by the `./configure`
+# script. Useful for debugging.
+#configure-args = []
+
+# Indicates that a local rebuild is occurring instead of a full bootstrap,
+# essentially skipping stage0 as the local compiler is recompiling itself again.
+# Useful for modifying only the stage2 compiler without having to pass `--keep-stage 0` each time.
+#local-rebuild = false
+
+# Print out how long each bootstrap step took (mostly intended for CI and
+# tracking over time)
+#print-step-timings = false
+
+# Print out resource usage data for each bootstrap step, as defined by the Unix
+# struct rusage. (Note that this setting is completely unstable: the data it
+# captures, what platforms it supports, the format of its associated output, and
+# this setting's very existence, are all subject to change.)
+#print-step-rusage = false
+
+# Always patch binaries for usage with Nix toolchains. If `true` then binaries
+# will be patched unconditionally. If `false` or unset, binaries will be patched
+# only if the current distribution is NixOS. This option is useful when using
+# a Nix toolchain on non-NixOS distributions.
+#patch-binaries-for-nix = false
+
+# Collect information and statistics about the current build, and write it to
+# disk. Enabling this has no impact on the resulting build output. The
+# schema of the file generated by the build metrics feature is unstable, and
+# this is not intended to be used during local development.
+#metrics = false
+
+# Specify the location of the Android NDK. Used when targeting Android.
+#android-ndk = "/path/to/android-ndk-r26d"
+
+# Number of parallel jobs to be used for building and testing. If set to `0` or
+# omitted, it will be automatically determined. This is the `-j`/`--jobs` flag
+# passed to cargo invocations.
+#jobs = 0
+
+# What custom diff tool to use for displaying compiletest tests.
+#compiletest-diff-tool = <none>
+
+# Whether to use the precompiled stage0 libtest with compiletest.
+#compiletest-use-stage0-libtest = true
+
+# Indicates whether ccache is used when building certain artifacts (e.g. LLVM).
+# Set to `true` to use the first `ccache` in PATH, or set an absolute path to use
+# a specific version.
+#ccache = false
+
+# List of paths to exclude from the build and test processes.
+# For example, exclude = ["tests/ui", "src/tools/tidy"].
+#exclude = []
+
+# =============================================================================
+# General install configuration options
+# =============================================================================
+[install]
+
+# Where to install the generated toolchain. Must be an absolute path.
+#prefix = "/usr/local"
+
+# Where to install system configuration files.
+# If this is a relative path, it will get installed in `prefix` above
+#sysconfdir = "/etc"
+
+# Where to install documentation in `prefix` above
+#docdir = "share/doc/rust"
+
+# Where to install binaries in `prefix` above
+#bindir = "bin"
+
+# Where to install libraries in `prefix` above
+#libdir = "lib"
+
+# Where to install man pages in `prefix` above
+#mandir = "share/man"
+
+# Where to install data in `prefix` above
+#datadir = "share"
+
+# =============================================================================
+# Options for compiling Rust code itself
+# =============================================================================
+[rust]
+
+# Whether or not to optimize when compiling the compiler and standard library,
+# and what level of optimization to use.
+# WARNING: Building with optimize = false is NOT SUPPORTED. Due to bootstrapping,
+# building without optimizations takes much longer than optimizing. Further, some platforms
+# fail to build without this optimization (c.f. #65352).
+# The valid options are:
+# true - Enable optimizations (same as 3).
+# false - Disable optimizations.
+# 0 - Disable optimizations.
+# 1 - Basic optimizations.
+# 2 - Some optimizations.
+# 3 - All optimizations.
+# "s" - Optimize for binary size.
+# "z" - Optimize for binary size, but also turn off loop vectorization.
+#optimize = true
+
+# Indicates that the build should be configured for debugging Rust. A
+# `debug`-enabled compiler and standard library will be somewhat
+# slower (due to e.g. checking of debug assertions) but should remain
+# usable.
+#
+# Note: If this value is set to `true`, it will affect a number of
+# configuration options below as well, if they have been left
+# unconfigured in this file.
+#
+# Note: changes to the `debug` setting do *not* affect `optimize`
+# above. In theory, a "maximally debuggable" environment would
+# set `optimize` to `false` above to assist the introspection
+# facilities of debuggers like lldb and gdb. To recreate such an
+# environment, explicitly set `optimize` to `false` and `debug`
+# to `true`. In practice, everyone leaves `optimize` set to
+# `true`, because an unoptimized rustc with debugging
+# enabled becomes *unusably slow* (e.g. rust-lang/rust#24840
+# reported a 25x slowdown) and bootstrapping the supposed
+# "maximally debuggable" environment (notably libstd) takes
+# hours to build.
+#
+#debug = false
+
+# Whether to download the stage 1 and 2 compilers from CI. This is useful if you
+# are working on tools, doc-comments, or library (you will be able to build the
+# standard library without needing to build the compiler).
+#
+# Set this to "if-unchanged" if you are working on `src/tools`, `tests` or
+# `library` (on CI, `library` changes triggers in-tree compiler build) to speed
+# up the build process if you don't need to build a compiler from the latest
+# commit from `master`.
+#
+# Set this to `true` to always download or `false` to always use the in-tree
+# compiler.
+#download-rustc = false
+
+# Number of codegen units to use for each compiler invocation. A value of 0
+# means "the number of cores on this machine", and 1+ is passed through to the
+# compiler.
+#
+# Uses the rustc defaults: https://doc.rust-lang.org/rustc/codegen-options/index.html#codegen-units
+#codegen-units = if incremental { 256 } else { 16 }
+
+# Sets the number of codegen units to build the standard library with,
+# regardless of what the codegen-unit setting for the rest of the compiler is.
+# NOTE: building with anything other than 1 is known to occasionally have bugs.
+#codegen-units-std = codegen-units
+
+# Whether or not debug assertions are enabled for the compiler and standard library.
+# These can help find bugs at the cost of a small runtime slowdown.
+#
+# Defaults to rust.debug value
+#debug-assertions = rust.debug (boolean)
+
+# Whether or not debug assertions are enabled for the standard library.
+# Overrides the `debug-assertions` option, if defined.
+#
+# Defaults to rust.debug-assertions value
+#debug-assertions-std = rust.debug-assertions (boolean)
+
+# Whether or not debug assertions are enabled for the tools built by bootstrap.
+# Overrides the `debug-assertions` option, if defined.
+#
+# Defaults to rust.debug-assertions value
+#debug-assertions-tools = rust.debug-assertions (boolean)
+
+# Whether or not to leave debug! and trace! calls in the rust binary.
+#
+# Defaults to rust.debug-assertions value
+#
+# If you see a message from `tracing` saying "some trace filter directives would enable traces that
+# are disabled statically" because `max_level_info` is enabled, set this value to `true`.
+#debug-logging = rust.debug-assertions (boolean)
+
+# Whether or not to build rustc, tools and the libraries with randomized type layout
+#randomize-layout = false
+
+# Whether or not overflow checks are enabled for the compiler and standard
+# library.
+#
+# Defaults to rust.debug value
+#overflow-checks = rust.debug (boolean)
+
+# Whether or not overflow checks are enabled for the standard library.
+# Overrides the `overflow-checks` option, if defined.
+#
+# Defaults to rust.overflow-checks value
+#overflow-checks-std = rust.overflow-checks (boolean)
+
+# Debuginfo level for most of Rust code, corresponds to the `-C debuginfo=N` option of `rustc`.
+# See https://doc.rust-lang.org/rustc/codegen-options/index.html#debuginfo for available options.
+#
+# Can be overridden for specific subsets of Rust code (rustc, std or tools).
+# Debuginfo for tests run with compiletest is not controlled by this option
+# and needs to be enabled separately with `debuginfo-level-tests`.
+#
+# Note that debuginfo-level = 2 generates several gigabytes of debuginfo
+# and will slow down the linking process significantly.
+#debuginfo-level = if rust.debug { 1 } else { 0 }
+
+# Debuginfo level for the compiler.
+#debuginfo-level-rustc = rust.debuginfo-level
+
+# Debuginfo level for the standard library.
+#debuginfo-level-std = rust.debuginfo-level
+
+# Debuginfo level for the tools.
+#debuginfo-level-tools = rust.debuginfo-level
+
+# Debuginfo level for the test suites run with compiletest.
+# FIXME(#61117): Some tests fail when this option is enabled.
+#debuginfo-level-tests = 0
+
+# Should rustc and the standard library be built with split debuginfo? Default
+# is platform dependent.
+#
+# This field is deprecated, use `target.<triple>.split-debuginfo` instead.
+#
+# The value specified here is only used when targeting the `build.build` triple,
+# and is overridden by `target.<triple>.split-debuginfo` if specified.
+#
+#split-debuginfo = see target.<triple>.split-debuginfo
+
+# Whether or not `panic!`s generate backtraces (RUST_BACKTRACE)
+#backtrace = true
+
+# Whether to always use incremental compilation when building rustc
+#incremental = false
+
+# The default linker that will be hard-coded into the generated
+# compiler for targets that don't specify a default linker explicitly
+# in their target specifications. Note that this is not the linker
+# used to link said compiler. It can also be set per-target (via the
+# `[target.<triple>]` block), which may be useful in a cross-compilation
+# setting.
+#
+# See https://doc.rust-lang.org/rustc/codegen-options/index.html#linker for more information.
+#default-linker = <none> (path)
+
+# The "channel" for the Rust build to produce. The stable/beta channels only
+# allow using stable features, whereas the nightly and dev channels allow using
+# nightly features.
+#
+# You can set the channel to "auto-detect" to load the channel name from `src/ci/channel`.
+#
+# If using tarball sources, default value is "auto-detect", otherwise, it's "dev".
+#channel = if "is a tarball source" { "auto-detect" } else { "dev" }
+
+# The root location of the musl installation directory. The library directory
+# will also need to contain libunwind.a for an unwinding implementation. Note
+# that this option only makes sense for musl targets that produce statically
+# linked binaries.
+#
+# Defaults to /usr on musl hosts. Has no default otherwise.
+#musl-root = <platform specific> (path)
+
+# By default the `rustc` executable is built with `-Wl,-rpath` flags on Unix
+# platforms to ensure that the compiler is usable by default from the build
+# directory (as it links to a number of dynamic libraries). This may not be
+# desired in distributions, for example.
+#rpath = true
+
+# Indicates whether symbols should be stripped using `-Cstrip=symbols`.
+#strip = false
+
+# Forces frame pointers to be used with `-Cforce-frame-pointers`.
+# This can be helpful for profiling at a small performance cost.
+#frame-pointers = false
+
+# Indicates whether stack protectors should be used
+# via the unstable option `-Zstack-protector`.
+#
+# Valid options are : `none`(default),`basic`,`strong`, or `all`.
+# `strong` and `basic` options may be buggy and are not recommended, see rust-lang/rust#114903.
+#stack-protector = "none"
+
+# Prints each test name as it is executed, to help debug issues in the test harness itself.
+#verbose-tests = if is_verbose { true } else { false }
+
+# Flag indicating whether tests are compiled with optimizations (the -O flag).
+#optimize-tests = true
+
+# Flag indicating whether codegen tests will be run or not. If you get an error
+# saying that the FileCheck executable is missing, you may want to disable this.
+# Also see the target's llvm-filecheck option.
+#codegen-tests = true
+
+# Flag indicating whether git info will be retrieved from .git automatically.
+# Having the git information can cause a lot of rebuilds during development.
+#omit-git-hash = if rust.channel == "dev" { true } else { false }
+
+# Whether to create a source tarball by default when running `x dist`.
+#
+# You can still build a source tarball when this is disabled by explicitly passing `x dist rustc-src`.
+#dist-src = true
+
+# After building or testing an optional component (e.g. the nomicon or reference), append the
+# result (broken, compiling, testing) into this JSON file.
+#save-toolstates = <none> (path)
+
+# This is an array of the codegen backends that will be compiled for the rustc
+# that's being compiled. The default is to only build the LLVM codegen backend,
+# and currently the only standard options supported are `"llvm"`, `"cranelift"`
+# and `"gcc"`. The first backend in this list will be used as default by rustc
+# when no explicit backend is specified.
+#codegen-backends = ["llvm"]
+
+# Indicates whether LLD will be compiled and made available in the sysroot for rustc to execute, and
+# whether to set it as rustc's default linker on `x86_64-unknown-linux-gnu`. This will also only be
+# when *not* building an external LLVM (so only when using `download-ci-llvm` or building LLVM from
+# the in-tree source): setting `llvm-config` in the `[target.x86_64-unknown-linux-gnu]` section will
+# make this default to false.
+#lld = false in all cases, except on `x86_64-unknown-linux-gnu` as described above, where it is true
+
+# Indicates whether LLD will be used to link Rust crates during bootstrap on
+# supported platforms.
+# If set to `true` or `"external"`, a global `lld` binary that has to be in $PATH
+# will be used.
+# If set to `"self-contained"`, rust-lld from the snapshot compiler will be used.
+#
+# On MSVC, LLD will not be used if we're cross linking.
+#
+# Explicitly setting the linker for a target will override this option when targeting MSVC.
+#use-lld = false
+
+# Indicates whether some LLVM tools, like llvm-objdump, will be made available in the
+# sysroot.
+#llvm-tools = true
+
+# Indicates whether the `self-contained` llvm-bitcode-linker, will be made available
+# in the sysroot. It is required for running nvptx tests.
+#llvm-bitcode-linker = false
+
+# Whether to deny warnings in crates
+#deny-warnings = true
+
+# Print backtrace on internal compiler errors during bootstrap
+#backtrace-on-ice = false
+
+# Whether to verify generated LLVM IR
+#verify-llvm-ir = false
+
+# Compile the compiler with a non-default ThinLTO import limit. This import
+# limit controls the maximum size of functions imported by ThinLTO. Decreasing
+# will make code compile faster at the expense of lower runtime performance.
+#thin-lto-import-instr-limit = if incremental { 10 } else { LLVM default (currently 100) }
+
+# Map debuginfo paths to `/rust/$sha/...`.
+# Useful for reproducible builds. Generally only set for releases
+#remap-debuginfo = false
+
+# Link the compiler and LLVM against `jemalloc` instead of the default libc allocator.
+# This option is only tested on Linux and OSX. It can also be configured per-target in the
+# [target.<tuple>] section.
+#jemalloc = false
+
+# Run tests in various test suites with the "nll compare mode" in addition to
+# running the tests in normal mode. Largely only used on CI and during local
+# development of NLL
+#test-compare-mode = false
+
+# Global default for llvm-libunwind for all targets. See the target-specific
+# documentation for llvm-libunwind below. Note that the target-specific
+# option will override this if set.
+#llvm-libunwind = 'no'
+
+# Enable Windows Control Flow Guard checks in the standard library.
+# This only applies from stage 1 onwards, and only for Windows targets.
+#control-flow-guard = false
+
+# Enable Windows EHCont Guard checks in the standard library.
+# This only applies from stage 1 onwards, and only for Windows targets.
+#ehcont-guard = false
+
+# Enable symbol-mangling-version v0. This can be helpful when profiling rustc,
+# as generics will be preserved in symbols (rather than erased into opaque T).
+# When no setting is given, the new scheme will be used when compiling the
+# compiler and its tools and the legacy scheme will be used when compiling the
+# standard library.
+# If an explicit setting is given, it will be used for all parts of the codebase.
+#new-symbol-mangling = true|false (see comment)
+
+# Select LTO mode that will be used for compiling rustc. By default, thin local LTO
+# (LTO within a single crate) is used (like for any Rust crate). You can also select
+# "thin" or "fat" to apply Thin/Fat LTO to the `rustc_driver` dylib, or "off" to disable
+# LTO entirely.
+#lto = "thin-local"
+
+# Build compiler with the optimization enabled and -Zvalidate-mir, currently only for `std`
+#validate-mir-opts = 3
+
+# Configure `std` features used during bootstrap.
+#
+# Default features will be expanded in the following cases:
+# - If `rust.llvm-libunwind` or `target.llvm-libunwind` is enabled:
+# - "llvm-libunwind" will be added for in-tree LLVM builds.
+# - "system-llvm-libunwind" will be added for system LLVM builds.
+# - If `rust.backtrace` is enabled, "backtrace" will be added.
+# - If `rust.profiler` or `target.profiler` is enabled, "profiler" will be added.
+# - If building for a zkvm target, "compiler-builtins-mem" will be added.
+#
+# Since libstd also builds libcore and liballoc as dependencies and all their features are mirrored
+# as libstd features, this option can also be used to configure features such as optimize_for_size.
+#std-features = ["panic_unwind"]
+
+# =============================================================================
+# Options for specific targets
+#
+# Each of the following options is scoped to the specific target triple in
+# question and is used for determining how to compile each target.
+# =============================================================================
+[target.x86_64-unknown-linux-gnu]
+
+# C compiler to be used to compile C code. Note that the
+# default value is platform specific, and if not specified it may also depend on
+# what platform is crossing to what platform.
+# See `src/bootstrap/src/utils/cc_detect.rs` for details.
+#cc = "cc" (path)
+
+# C++ compiler to be used to compile C++ code (e.g. LLVM and our LLVM shims).
+# This is only used for host targets.
+# See `src/bootstrap/src/utils/cc_detect.rs` for details.
+#cxx = "c++" (path)
+
+# Archiver to be used to assemble static libraries compiled from C/C++ code.
+# Note: an absolute path should be used, otherwise LLVM build will break.
+#ar = "ar" (path)
+
+# Ranlib to be used to assemble static libraries compiled from C/C++ code.
+# Note: an absolute path should be used, otherwise LLVM build will break.
+#ranlib = "ranlib" (path)
+
+# Linker to be used to bootstrap Rust code. Note that the
+# default value is platform specific, and if not specified it may also depend on
+# what platform is crossing to what platform.
+# Setting this will override the `use-lld` option for Rust code when targeting MSVC.
+#linker = "cc" (path)
+
+# Should rustc and the standard library be built with split debuginfo? Default
+# is platform dependent.
+#
+# Valid values are the same as those accepted by `-C split-debuginfo`
+# (`off`/`unpacked`/`packed`).
+#
+# On Linux, split debuginfo is disabled by default.
+#
+# On Apple platforms, unpacked split debuginfo is used by default. Unpacked
+# debuginfo does not run `dsymutil`, which packages debuginfo from disparate
+# object files into a single `.dSYM` file. `dsymutil` adds time to builds for
+# no clear benefit, and also makes it more difficult for debuggers to find
+# debug info. The compiler currently defaults to running `dsymutil` to preserve
+# its historical default, but when compiling the compiler itself, we skip it by
+# default since we know it's safe to do so in that case.
+#
+# On Windows platforms, packed debuginfo is the only supported option,
+# producing a `.pdb` file.
+#split-debuginfo = if linux { off } else if windows { packed } else if apple { unpacked }
+
+# Path to the `llvm-config` binary of the installation of a custom LLVM to link
+# against. Note that if this is specified we don't compile LLVM at all for this
+# target.
+#llvm-config = <none> (path)
+
+# Override detection of whether this is a Rust-patched LLVM. This would be used
+# in conjunction with either an llvm-config or build.submodules = false.
+#llvm-has-rust-patches = if llvm-config { false } else { true }
+
+# Normally the build system can find LLVM's FileCheck utility, but if
+# not, you can specify an explicit file name for it.
+#llvm-filecheck = "/path/to/llvm-version/bin/FileCheck"
+
+# Use LLVM libunwind as the implementation for Rust's unwinder.
+# Accepted values are 'in-tree' (formerly true), 'system' or 'no' (formerly false).
+# This option only applies for Linux and Fuchsia targets.
+# On Linux target, if crt-static is not enabled, 'no' means dynamic link to
+# `libgcc_s.so`, 'in-tree' means static link to the in-tree build of llvm libunwind
+# and 'system' means dynamic link to `libunwind.so`. If crt-static is enabled,
+# the behavior is depend on the libc. On musl target, 'no' and 'in-tree' both
+# means static link to the in-tree build of llvm libunwind, and 'system' means
+# static link to `libunwind.a` provided by system. Due to the limitation of glibc,
+# it must link to `libgcc_eh.a` to get a working output, and this option have no effect.
+#llvm-libunwind = 'no' if Linux, 'in-tree' if Fuchsia
+
+# Build the sanitizer runtimes for this target.
+# This option will override the same option under [build] section.
+#sanitizers = build.sanitizers (bool)
+
+# When true, build the profiler runtime for this target (required when compiling
+# with options that depend on this runtime, such as `-C profile-generate` or
+# `-C instrument-coverage`). This may also be given a path to an existing build
+# of the profiling runtime library from LLVM's compiler-rt.
+# This option will override the same option under [build] section.
+#profiler = build.profiler (bool)
+
+# This option supports enable `rpath` in each target independently,
+# and will override the same option under [rust] section. It only works on Unix platforms
+#rpath = rust.rpath (bool)
+
+# Force static or dynamic linkage of the standard library for this target. If
+# this target is a host for rustc, this will also affect the linkage of the
+# compiler itself. This is useful for building rustc on targets that normally
+# only use static libraries. If unset, the target's default linkage is used.
+#crt-static = <platform-specific> (bool)
+
+# The root location of the musl installation directory. The library directory
+# will also need to contain libunwind.a for an unwinding implementation. Note
+# that this option only makes sense for musl targets that produce statically
+# linked binaries.
+#musl-root = build.musl-root (path)
+
+# The full path to the musl libdir.
+#musl-libdir = musl-root/lib
+
+# The root location of the `wasm32-wasip1` sysroot. Only used for WASI
+# related targets. Make sure to create a `[target.wasm32-wasip1]`
+# section and move this field there (or equivalent for the target being built).
+#wasi-root = <none> (path)
+
+# Used in testing for configuring where the QEMU images are located, you
+# probably don't want to use this.
+#qemu-rootfs = <none> (path)
+
+# Skip building the `std` library for this target. Enabled by default for
+# target triples containing `-none`, `nvptx`, `switch`, or `-uefi`.
+#no-std = <platform-specific> (bool)
+
+# This is an array of the codegen backends that will be
+# compiled for this target, overriding the global rust.codegen-backends option.
+# See that option for more info.
+#codegen-backends = rust.codegen-backends (array)
+
+# This is a "runner" to pass to `compiletest` when executing tests. Tests will
+# execute this tool where the binary-to-test is passed as an argument. Can
+# be useful for situations such as when WebAssembly is being tested and a
+# runtime needs to be configured. This value is similar to
+# Cargo's `CARGO_$target_RUNNER` configuration.
+#
+# This configuration is a space-separated list of arguments so `foo bar` would
+# execute the program `foo` with the first argument as `bar` and the second
+# argument as the test binary.
+#runner = <none> (string)
+
+# Use the optimized LLVM C intrinsics for `compiler_builtins`, rather than Rust intrinsics
+# on this target.
+# Requires the LLVM submodule to be managed by bootstrap (i.e. not external) so that `compiler-rt`
+# sources are available.
+#
+# Setting this to `false` generates slower code, but removes the requirement for a C toolchain in
+# order to run `x check`.
+#optimized-compiler-builtins = build.optimized-compiler-builtins (bool)
+
+# Link the compiler and LLVM against `jemalloc` instead of the default libc allocator.
+# This overrides the global `rust.jemalloc` option. See that option for more info.
+#jemalloc = rust.jemalloc (bool)
+
+# =============================================================================
+# Distribution options
+#
+# These options are related to distribution, mostly for the Rust project itself.
+# You probably won't need to concern yourself with any of these options
+# =============================================================================
+[dist]
+
+# This is the folder of artifacts that the build system will sign. All files in
+# this directory will be signed with the default gpg key using the system `gpg`
+# binary. The `asc` and `sha256` files will all be output into the standard dist
+# output folder (currently `build/dist`)
+#
+# This folder should be populated ahead of time before the build system is
+# invoked.
+#sign-folder = <none> (path)
+
+# The remote address that all artifacts will eventually be uploaded to. The
+# build system generates manifests which will point to these urls, and for the
+# manifests to be correct they'll have to have the right URLs encoded.
+#
+# Note that this address should not contain a trailing slash as file names will
+# be appended to it.
+#upload-addr = <none> (URL)
+
+# Whether to build a plain source tarball to upload
+# We disable that on Windows not to override the one already uploaded on S3
+# as the one built on Windows will contain backslashes in paths causing problems
+# on linux
+#src-tarball = true
+
+# List of compression formats to use when generating dist tarballs. The list of
+# formats is provided to rust-installer, which must support all of them.
+#
+# This list must be non-empty.
+#compression-formats = ["gz", "xz"]
+
+# How much time should be spent compressing the tarballs. The better the
+# compression profile, the longer compression will take.
+#
+# Available options: fast, balanced, best
+#compression-profile = "fast"
+
+# Copy the linker, DLLs, and various libraries from MinGW into the Rust toolchain.
+# Only applies when the host or target is pc-windows-gnu.
+#include-mingw-linker = true
+
+# Whether to vendor dependencies for the dist tarball.
+#vendor = if "is a tarball source" || "is a git repository" { true } else { false }
diff --git a/compiler/rustc/Cargo.toml b/compiler/rustc/Cargo.toml
index 3cb56a7d3121c..f4caa3ef769d5 100644
--- a/compiler/rustc/Cargo.toml
+++ b/compiler/rustc/Cargo.toml
@@ -1,7 +1,7 @@
[package]
name = "rustc-main"
version = "0.0.0"
-edition = "2021"
+edition = "2024"
[dependencies]
# tidy-alphabetical-start
@@ -20,15 +20,15 @@ rustc_smir = { path = "../rustc_smir" }
stable_mir = { path = "../stable_mir" }
# tidy-alphabetical-end
-[dependencies.jemalloc-sys]
-version = "0.5.0"
+[dependencies.tikv-jemalloc-sys]
+version = "0.6.0"
optional = true
features = ['unprefixed_malloc_on_supported_platforms']
[features]
# tidy-alphabetical-start
-jemalloc = ['jemalloc-sys']
+jemalloc = ['dep:tikv-jemalloc-sys']
llvm = ['rustc_driver_impl/llvm']
max_level_info = ['rustc_driver_impl/max_level_info']
-rustc_use_parallel_compiler = ['rustc_driver_impl/rustc_use_parallel_compiler']
+rustc_randomized_layouts = ['rustc_driver_impl/rustc_randomized_layouts']
# tidy-alphabetical-end
diff --git a/compiler/rustc/src/main.rs b/compiler/rustc/src/main.rs
index 7ba58406ef1ad..ca1bb59e59d60 100644
--- a/compiler/rustc/src/main.rs
+++ b/compiler/rustc/src/main.rs
@@ -1,3 +1,8 @@
+// We need this feature as it changes `dylib` linking behavior and allows us to link to `rustc_driver`.
+#![feature(rustc_private)]
+// Several crates are depended upon but unused so that they are present in the sysroot
+#![expect(unused_crate_dependencies)]
+
// A note about jemalloc: rustc uses jemalloc when built for CI and
// distribution. The obvious way to do this is with the `#[global_allocator]`
// mechanism. However, for complicated reasons (see
@@ -34,10 +39,12 @@
fn main() {
// See the comment at the top of this file for an explanation of this.
- #[cfg(feature = "jemalloc-sys")]
+ #[cfg(feature = "jemalloc")]
{
use std::os::raw::{c_int, c_void};
+ use tikv_jemalloc_sys as jemalloc_sys;
+
#[used]
static _F1: unsafe extern "C" fn(usize, usize) -> *mut c_void = jemalloc_sys::calloc;
#[used]
@@ -58,7 +65,7 @@ fn main() {
// linking, so we need to explicitly depend on the function.
#[cfg(target_os = "macos")]
{
- extern "C" {
+ unsafe extern "C" {
fn _rjem_je_zone_register();
}
diff --git a/compiler/rustc_abi/Cargo.toml b/compiler/rustc_abi/Cargo.toml
index 5031e7a6705f0..5f9afc46a1ace 100644
--- a/compiler/rustc_abi/Cargo.toml
+++ b/compiler/rustc_abi/Cargo.toml
@@ -1,17 +1,19 @@
[package]
name = "rustc_abi"
version = "0.0.0"
-edition = "2021"
+edition = "2024"
[dependencies]
# tidy-alphabetical-start
bitflags = "2.4.1"
-rand = { version = "0.8.4", default-features = false, optional = true }
-rand_xoshiro = { version = "0.6.0", optional = true }
-rustc_data_structures = { path = "../rustc_data_structures", optional = true }
+rand = { version = "0.9.0", default-features = false, optional = true }
+rand_xoshiro = { version = "0.7.0", optional = true }
+rustc_data_structures = { path = "../rustc_data_structures", optional = true }
+rustc_hashes = { path = "../rustc_hashes" }
rustc_index = { path = "../rustc_index", default-features = false }
rustc_macros = { path = "../rustc_macros", optional = true }
-rustc_serialize = { path = "../rustc_serialize", optional = true }
+rustc_serialize = { path = "../rustc_serialize", optional = true }
+rustc_span = { path = "../rustc_span", optional = true }
tracing = "0.1"
# tidy-alphabetical-end
@@ -21,10 +23,11 @@ default = ["nightly", "randomize"]
# rust-analyzer depends on this crate and we therefore require it to built on a stable toolchain
# without depending on rustc_data_structures, rustc_macros and rustc_serialize
nightly = [
- "rustc_data_structures",
+ "dep:rustc_data_structures",
+ "dep:rustc_macros",
+ "dep:rustc_serialize",
+ "dep:rustc_span",
"rustc_index/nightly",
- "rustc_macros",
- "rustc_serialize",
]
-randomize = ["rand", "rand_xoshiro", "nightly"]
+randomize = ["dep:rand", "dep:rand_xoshiro", "nightly"]
# tidy-alphabetical-end
diff --git a/compiler/rustc_abi/src/callconv.rs b/compiler/rustc_abi/src/callconv.rs
new file mode 100644
index 0000000000000..a21e1aee9b08a
--- /dev/null
+++ b/compiler/rustc_abi/src/callconv.rs
@@ -0,0 +1,186 @@
+#[cfg(feature = "nightly")]
+use crate::{BackendRepr, FieldsShape, Primitive, Size, TyAbiInterface, TyAndLayout, Variants};
+
+mod reg;
+
+pub use reg::{Reg, RegKind};
+
+/// Return value from the `homogeneous_aggregate` test function.
+#[derive(Copy, Clone, Debug)]
+pub enum HomogeneousAggregate {
+ /// Yes, all the "leaf fields" of this struct are passed in the
+ /// same way (specified in the `Reg` value).
+ Homogeneous(Reg),
+
+ /// There are no leaf fields at all.
+ NoData,
+}
+
+/// Error from the `homogeneous_aggregate` test function, indicating
+/// there are distinct leaf fields passed in different ways,
+/// or this is uninhabited.
+#[derive(Copy, Clone, Debug)]
+pub struct Heterogeneous;
+
+impl HomogeneousAggregate {
+ /// If this is a homogeneous aggregate, returns the homogeneous
+ /// unit, else `None`.
+ pub fn unit(self) -> Option<Reg> {
+ match self {
+ HomogeneousAggregate::Homogeneous(reg) => Some(reg),
+ HomogeneousAggregate::NoData => None,
+ }
+ }
+
+ /// Try to combine two `HomogeneousAggregate`s, e.g. from two fields in
+ /// the same `struct`. Only succeeds if only one of them has any data,
+ /// or both units are identical.
+ fn merge(self, other: HomogeneousAggregate) -> Result<HomogeneousAggregate, Heterogeneous> {
+ match (self, other) {
+ (x, HomogeneousAggregate::NoData) | (HomogeneousAggregate::NoData, x) => Ok(x),
+
+ (HomogeneousAggregate::Homogeneous(a), HomogeneousAggregate::Homogeneous(b)) => {
+ if a != b {
+ return Err(Heterogeneous);
+ }
+ Ok(self)
+ }
+ }
+ }
+}
+
+#[cfg(feature = "nightly")]
+impl<'a, Ty> TyAndLayout<'a, Ty> {
+ /// Returns `Homogeneous` if this layout is an aggregate containing fields of
+ /// only a single type (e.g., `(u32, u32)`). Such aggregates are often
+ /// special-cased in ABIs.
+ ///
+ /// Note: We generally ignore 1-ZST fields when computing this value (see #56877).
+ ///
+ /// This is public so that it can be used in unit tests, but
+ /// should generally only be relevant to the ABI details of
+ /// specific targets.
+ pub fn homogeneous_aggregate<C>(&self, cx: &C) -> Result<HomogeneousAggregate, Heterogeneous>
+ where
+ Ty: TyAbiInterface<'a, C> + Copy,
+ {
+ match self.backend_repr {
+ // The primitive for this algorithm.
+ BackendRepr::Scalar(scalar) => {
+ let kind = match scalar.primitive() {
+ Primitive::Int(..) | Primitive::Pointer(_) => RegKind::Integer,
+ Primitive::Float(_) => RegKind::Float,
+ };
+ Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
+ }
+
+ BackendRepr::SimdVector { .. } => {
+ assert!(!self.is_zst());
+ Ok(HomogeneousAggregate::Homogeneous(Reg {
+ kind: RegKind::Vector,
+ size: self.size,
+ }))
+ }
+
+ BackendRepr::ScalarPair(..) | BackendRepr::Memory { sized: true } => {
+ // Helper for computing `homogeneous_aggregate`, allowing a custom
+ // starting offset (used below for handling variants).
+ let from_fields_at =
+ |layout: Self,
+ start: Size|
+ -> Result<(HomogeneousAggregate, Size), Heterogeneous> {
+ let is_union = match layout.fields {
+ FieldsShape::Primitive => {
+ unreachable!("aggregates can't have `FieldsShape::Primitive`")
+ }
+ FieldsShape::Array { count, .. } => {
+ assert_eq!(start, Size::ZERO);
+
+ let result = if count > 0 {
+ layout.field(cx, 0).homogeneous_aggregate(cx)?
+ } else {
+ HomogeneousAggregate::NoData
+ };
+ return Ok((result, layout.size));
+ }
+ FieldsShape::Union(_) => true,
+ FieldsShape::Arbitrary { .. } => false,
+ };
+
+ let mut result = HomogeneousAggregate::NoData;
+ let mut total = start;
+
+ for i in 0..layout.fields.count() {
+ let field = layout.field(cx, i);
+ if field.is_1zst() {
+ // No data here and no impact on layout, can be ignored.
+ // (We might be able to also ignore all aligned ZST but that's less clear.)
+ continue;
+ }
+
+ if !is_union && total != layout.fields.offset(i) {
+ // This field isn't just after the previous one we considered, abort.
+ return Err(Heterogeneous);
+ }
+
+ result = result.merge(field.homogeneous_aggregate(cx)?)?;
+
+ // Keep track of the offset (without padding).
+ let size = field.size;
+ if is_union {
+ total = total.max(size);
+ } else {
+ total += size;
+ }
+ }
+
+ Ok((result, total))
+ };
+
+ let (mut result, mut total) = from_fields_at(*self, Size::ZERO)?;
+
+ match &self.variants {
+ Variants::Single { .. } | Variants::Empty => {}
+ Variants::Multiple { variants, .. } => {
+ // Treat enum variants like union members.
+ // HACK(eddyb) pretend the `enum` field (discriminant)
+ // is at the start of every variant (otherwise the gap
+ // at the start of all variants would disqualify them).
+ //
+ // NB: for all tagged `enum`s (which include all non-C-like
+ // `enum`s with defined FFI representation), this will
+ // match the homogeneous computation on the equivalent
+ // `struct { tag; union { variant1; ... } }` and/or
+ // `union { struct { tag; variant1; } ... }`
+ // (the offsets of variant fields should be identical
+ // between the two for either to be a homogeneous aggregate).
+ let variant_start = total;
+ for variant_idx in variants.indices() {
+ let (variant_result, variant_total) =
+ from_fields_at(self.for_variant(cx, variant_idx), variant_start)?;
+
+ result = result.merge(variant_result)?;
+ total = total.max(variant_total);
+ }
+ }
+ }
+
+ // There needs to be no padding.
+ if total != self.size {
+ Err(Heterogeneous)
+ } else {
+ match result {
+ HomogeneousAggregate::Homogeneous(_) => {
+ assert_ne!(total, Size::ZERO);
+ }
+ HomogeneousAggregate::NoData => {
+ assert_eq!(total, Size::ZERO);
+ }
+ }
+ Ok(result)
+ }
+ }
+ BackendRepr::Memory { sized: false } => Err(Heterogeneous),
+ }
+ }
+}
diff --git a/compiler/rustc_abi/src/callconv/reg.rs b/compiler/rustc_abi/src/callconv/reg.rs
new file mode 100644
index 0000000000000..8cf140dbaad4e
--- /dev/null
+++ b/compiler/rustc_abi/src/callconv/reg.rs
@@ -0,0 +1,63 @@
+#[cfg(feature = "nightly")]
+use rustc_macros::HashStable_Generic;
+
+use crate::{Align, HasDataLayout, Size};
+
+#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub enum RegKind {
+ Integer,
+ Float,
+ Vector,
+}
+
+#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub struct Reg {
+ pub kind: RegKind,
+ pub size: Size,
+}
+
+macro_rules! reg_ctor {
+ ($name:ident, $kind:ident, $bits:expr) => {
+ pub fn $name() -> Reg {
+ Reg { kind: RegKind::$kind, size: Size::from_bits($bits) }
+ }
+ };
+}
+
+impl Reg {
+ reg_ctor!(i8, Integer, 8);
+ reg_ctor!(i16, Integer, 16);
+ reg_ctor!(i32, Integer, 32);
+ reg_ctor!(i64, Integer, 64);
+ reg_ctor!(i128, Integer, 128);
+
+ reg_ctor!(f32, Float, 32);
+ reg_ctor!(f64, Float, 64);
+}
+
+impl Reg {
+ pub fn align<C: HasDataLayout>(&self, cx: &C) -> Align {
+ let dl = cx.data_layout();
+ match self.kind {
+ RegKind::Integer => match self.size.bits() {
+ 1 => dl.i1_align.abi,
+ 2..=8 => dl.i8_align.abi,
+ 9..=16 => dl.i16_align.abi,
+ 17..=32 => dl.i32_align.abi,
+ 33..=64 => dl.i64_align.abi,
+ 65..=128 => dl.i128_align.abi,
+ _ => panic!("unsupported integer: {self:?}"),
+ },
+ RegKind::Float => match self.size.bits() {
+ 16 => dl.f16_align.abi,
+ 32 => dl.f32_align.abi,
+ 64 => dl.f64_align.abi,
+ 128 => dl.f128_align.abi,
+ _ => panic!("unsupported float: {self:?}"),
+ },
+ RegKind::Vector => dl.llvmlike_vector_align(self.size).abi,
+ }
+ }
+}
diff --git a/compiler/rustc_abi/src/extern_abi.rs b/compiler/rustc_abi/src/extern_abi.rs
new file mode 100644
index 0000000000000..55f4845d21670
--- /dev/null
+++ b/compiler/rustc_abi/src/extern_abi.rs
@@ -0,0 +1,241 @@
+use std::cmp::Ordering;
+use std::fmt;
+use std::hash::{Hash, Hasher};
+
+#[cfg(feature = "nightly")]
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableOrd};
+#[cfg(feature = "nightly")]
+use rustc_macros::{Decodable, Encodable};
+
+#[cfg(test)]
+mod tests;
+
+use ExternAbi as Abi;
+
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "nightly", derive(Encodable, Decodable))]
+pub enum ExternAbi {
+ // Some of the ABIs come first because every time we add a new ABI, we have to re-bless all the
+ // hashing tests. These are used in many places, so giving them stable values reduces test
+ // churn. The specific values are meaningless.
+ Rust,
+ C {
+ unwind: bool,
+ },
+ Cdecl {
+ unwind: bool,
+ },
+ Stdcall {
+ unwind: bool,
+ },
+ Fastcall {
+ unwind: bool,
+ },
+ Vectorcall {
+ unwind: bool,
+ },
+ Thiscall {
+ unwind: bool,
+ },
+ Aapcs {
+ unwind: bool,
+ },
+ Win64 {
+ unwind: bool,
+ },
+ SysV64 {
+ unwind: bool,
+ },
+ PtxKernel,
+ Msp430Interrupt,
+ X86Interrupt,
+ /// An entry-point function called by the GPU's host
+ // FIXME: should not be callable from Rust on GPU targets, is for host's use only
+ GpuKernel,
+ EfiApi,
+ AvrInterrupt,
+ AvrNonBlockingInterrupt,
+ CCmseNonSecureCall,
+ CCmseNonSecureEntry,
+ System {
+ unwind: bool,
+ },
+ RustCall,
+ /// *Not* a stable ABI, just directly use the Rust types to describe the ABI for LLVM. Even
+ /// normally ABI-compatible Rust types can become ABI-incompatible with this ABI!
+ Unadjusted,
+ /// For things unlikely to be called, where reducing register pressure in
+ /// `extern "Rust"` callers is worth paying extra cost in the callee.
+ /// Stronger than just `#[cold]` because `fn` pointers might be incompatible.
+ RustCold,
+ RiscvInterruptM,
+ RiscvInterruptS,
+}
+
+macro_rules! abi_impls {
+ ($e_name:ident = {
+ $($variant:ident $({ unwind: $uw:literal })? =><= $tok:literal,)*
+ }) => {
+ impl $e_name {
+ pub const ALL_VARIANTS: &[Self] = &[
+ $($e_name::$variant $({ unwind: $uw })*,)*
+ ];
+ pub const fn as_str(&self) -> &'static str {
+ match self {
+ $($e_name::$variant $( { unwind: $uw } )* => $tok,)*
+ }
+ }
+ }
+
+ impl ::core::str::FromStr for $e_name {
+ type Err = AbiFromStrErr;
+ fn from_str(s: &str) -> Result<$e_name, Self::Err> {
+ match s {
+ $($tok => Ok($e_name::$variant $({ unwind: $uw })*),)*
+ _ => Err(AbiFromStrErr::Unknown),
+ }
+ }
+ }
+ }
+}
+
+#[derive(Debug)]
+pub enum AbiFromStrErr {
+ Unknown,
+}
+
+abi_impls! {
+ ExternAbi = {
+ C { unwind: false } =><= "C",
+ CCmseNonSecureCall =><= "C-cmse-nonsecure-call",
+ CCmseNonSecureEntry =><= "C-cmse-nonsecure-entry",
+ C { unwind: true } =><= "C-unwind",
+ Rust =><= "Rust",
+ Aapcs { unwind: false } =><= "aapcs",
+ Aapcs { unwind: true } =><= "aapcs-unwind",
+ AvrInterrupt =><= "avr-interrupt",
+ AvrNonBlockingInterrupt =><= "avr-non-blocking-interrupt",
+ Cdecl { unwind: false } =><= "cdecl",
+ Cdecl { unwind: true } =><= "cdecl-unwind",
+ EfiApi =><= "efiapi",
+ Fastcall { unwind: false } =><= "fastcall",
+ Fastcall { unwind: true } =><= "fastcall-unwind",
+ GpuKernel =><= "gpu-kernel",
+ Msp430Interrupt =><= "msp430-interrupt",
+ PtxKernel =><= "ptx-kernel",
+ RiscvInterruptM =><= "riscv-interrupt-m",
+ RiscvInterruptS =><= "riscv-interrupt-s",
+ RustCall =><= "rust-call",
+ RustCold =><= "rust-cold",
+ Stdcall { unwind: false } =><= "stdcall",
+ Stdcall { unwind: true } =><= "stdcall-unwind",
+ System { unwind: false } =><= "system",
+ System { unwind: true } =><= "system-unwind",
+ SysV64 { unwind: false } =><= "sysv64",
+ SysV64 { unwind: true } =><= "sysv64-unwind",
+ Thiscall { unwind: false } =><= "thiscall",
+ Thiscall { unwind: true } =><= "thiscall-unwind",
+ Unadjusted =><= "unadjusted",
+ Vectorcall { unwind: false } =><= "vectorcall",
+ Vectorcall { unwind: true } =><= "vectorcall-unwind",
+ Win64 { unwind: false } =><= "win64",
+ Win64 { unwind: true } =><= "win64-unwind",
+ X86Interrupt =><= "x86-interrupt",
+ }
+}
+
+impl Ord for ExternAbi {
+ fn cmp(&self, rhs: &Self) -> Ordering {
+ self.as_str().cmp(rhs.as_str())
+ }
+}
+
+impl PartialOrd for ExternAbi {
+ fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
+ Some(self.cmp(rhs))
+ }
+}
+
+impl PartialEq for ExternAbi {
+ fn eq(&self, rhs: &Self) -> bool {
+ self.cmp(rhs) == Ordering::Equal
+ }
+}
+
+impl Eq for ExternAbi {}
+
+impl Hash for ExternAbi {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.as_str().hash(state);
+ // double-assurance of a prefix breaker
+ u32::from_be_bytes(*b"ABI\0").hash(state);
+ }
+}
+
+#[cfg(feature = "nightly")]
+impl<C> HashStable<C> for ExternAbi {
+ #[inline]
+ fn hash_stable(&self, _: &mut C, hasher: &mut StableHasher) {
+ Hash::hash(self, hasher);
+ }
+}
+
+#[cfg(feature = "nightly")]
+impl StableOrd for ExternAbi {
+ const CAN_USE_UNSTABLE_SORT: bool = true;
+
+ // because each ABI is hashed like a string, there is no possible instability
+ const THIS_IMPLEMENTATION_HAS_BEEN_TRIPLE_CHECKED: () = ();
+}
+
+impl ExternAbi {
+ /// An ABI "like Rust"
+ ///
+ /// These ABIs are fully controlled by the Rust compiler, which means they
+ /// - support unwinding with `-Cpanic=unwind`, unlike `extern "C"`
+ /// - often diverge from the C ABI
+ /// - are subject to change between compiler versions
+ pub fn is_rustic_abi(self) -> bool {
+ use ExternAbi::*;
+ matches!(self, Rust | RustCall | RustCold)
+ }
+
+ pub fn supports_varargs(self) -> bool {
+ // * C and Cdecl obviously support varargs.
+ // * C can be based on Aapcs, SysV64 or Win64, so they must support varargs.
+ // * EfiApi is based on Win64 or C, so it also supports it.
+ //
+ // * Stdcall does not, because it would be impossible for the callee to clean
+ // up the arguments. (callee doesn't know how many arguments are there)
+ // * Same for Fastcall, Vectorcall and Thiscall.
+ // * Other calling conventions are related to hardware or the compiler itself.
+ match self {
+ Self::C { .. }
+ | Self::Cdecl { .. }
+ | Self::Aapcs { .. }
+ | Self::Win64 { .. }
+ | Self::SysV64 { .. }
+ | Self::EfiApi => true,
+ _ => false,
+ }
+ }
+}
+
+pub fn all_names() -> Vec<&'static str> {
+ ExternAbi::ALL_VARIANTS.iter().map(|abi| abi.as_str()).collect()
+}
+
+impl ExternAbi {
+ /// Default ABI chosen for `extern fn` declarations without an explicit ABI.
+ pub const FALLBACK: Abi = Abi::C { unwind: false };
+
+ pub fn name(self) -> &'static str {
+ self.as_str()
+ }
+}
+
+impl fmt::Display for ExternAbi {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "\"{}\"", self.as_str())
+ }
+}
diff --git a/compiler/rustc_abi/src/extern_abi/tests.rs b/compiler/rustc_abi/src/extern_abi/tests.rs
new file mode 100644
index 0000000000000..fc546a6570f0a
--- /dev/null
+++ b/compiler/rustc_abi/src/extern_abi/tests.rs
@@ -0,0 +1,31 @@
+use std::assert_matches::assert_matches;
+use std::str::FromStr;
+
+use super::*;
+
+#[allow(non_snake_case)]
+#[test]
+fn lookup_Rust() {
+ let abi = ExternAbi::from_str("Rust");
+ assert!(abi.is_ok() && abi.unwrap().as_str() == "Rust");
+}
+
+#[test]
+fn lookup_cdecl() {
+ let abi = ExternAbi::from_str("cdecl");
+ assert!(abi.is_ok() && abi.unwrap().as_str() == "cdecl");
+}
+
+#[test]
+fn lookup_baz() {
+ let abi = ExternAbi::from_str("baz");
+ assert_matches!(abi, Err(AbiFromStrErr::Unknown));
+}
+
+#[test]
+fn guarantee_lexicographic_ordering() {
+ let abis = ExternAbi::ALL_VARIANTS;
+ let mut sorted_abis = abis.to_vec();
+ sorted_abis.sort_unstable();
+ assert_eq!(abis, sorted_abis);
+}
diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index 197dd7f9c9e59..42250aa173bbd 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -1,19 +1,27 @@
-use std::borrow::{Borrow, Cow};
-use std::cmp;
use std::fmt::{self, Write};
-use std::iter;
-use std::ops::Bound;
-use std::ops::Deref;
+use std::ops::{Bound, Deref};
+use std::{cmp, iter};
+use rustc_hashes::Hash64;
use rustc_index::Idx;
+use rustc_index::bit_set::BitMatrix;
use tracing::debug;
use crate::{
- Abi, AbiAndPrefAlign, Align, FieldsShape, IndexSlice, IndexVec, Integer, LayoutS, Niche,
- NonZeroUsize, Primitive, ReprOptions, Scalar, Size, StructKind, TagEncoding, TargetDataLayout,
+ AbiAndPrefAlign, Align, BackendRepr, FieldsShape, HasDataLayout, IndexSlice, IndexVec, Integer,
+ LayoutData, Niche, NonZeroUsize, Primitive, ReprOptions, Scalar, Size, StructKind, TagEncoding,
Variants, WrappingRange,
};
+mod coroutine;
+mod simple;
+
+#[cfg(feature = "nightly")]
+mod ty;
+
+#[cfg(feature = "nightly")]
+pub use ty::{FIRST_VARIANT, FieldIdx, Layout, TyAbiInterface, TyAndLayout, VariantIdx};
+
// A variant is absent if it's uninhabited and only has ZST fields.
// Present uninhabited variants only require space for their fields,
// but *not* an encoding of the discriminant (e.g., a tag value).
@@ -23,74 +31,224 @@ fn absent<'a, FieldIdx, VariantIdx, F>(fields: &IndexSlice<FieldIdx, F>) -> bool
where
FieldIdx: Idx,
VariantIdx: Idx,
- F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug,
{
- let uninhabited = fields.iter().any(|f| f.abi.is_uninhabited());
+ let uninhabited = fields.iter().any(|f| f.is_uninhabited());
// We cannot ignore alignment; that might lead us to entirely discard a variant and
// produce an enum that is less aligned than it should be!
let is_1zst = fields.iter().all(|f| f.is_1zst());
uninhabited && is_1zst
}
-pub trait LayoutCalculator {
- type TargetDataLayoutRef: Borrow<TargetDataLayout>;
+/// Determines towards which end of a struct layout optimizations will try to place the best niches.
+enum NicheBias {
+ Start,
+ End,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum LayoutCalculatorError<F> {
+ /// An unsized type was found in a location where a sized type was expected.
+ ///
+ /// This is not always a compile error, for example if there is a `[T]: Sized`
+ /// bound in a where clause.
+ ///
+ /// Contains the field that was unexpectedly unsized.
+ UnexpectedUnsized(F),
+
+ /// A type was too large for the target platform.
+ SizeOverflow,
+
+ /// A union had no fields.
+ EmptyUnion,
+
+ /// The fields or variants have irreconcilable reprs
+ ReprConflict,
+
+ /// The length of an SIMD type is zero
+ ZeroLengthSimdType,
+
+ /// The length of an SIMD type exceeds the maximum number of lanes
+ OversizedSimdType { max_lanes: u64 },
+
+ /// An element type of an SIMD type isn't a primitive
+ NonPrimitiveSimdType(F),
+}
+
+impl<F> LayoutCalculatorError<F> {
+ pub fn without_payload(&self) -> LayoutCalculatorError<()> {
+ use LayoutCalculatorError::*;
+ match *self {
+ UnexpectedUnsized(_) => UnexpectedUnsized(()),
+ SizeOverflow => SizeOverflow,
+ EmptyUnion => EmptyUnion,
+ ReprConflict => ReprConflict,
+ ZeroLengthSimdType => ZeroLengthSimdType,
+ OversizedSimdType { max_lanes } => OversizedSimdType { max_lanes },
+ NonPrimitiveSimdType(_) => NonPrimitiveSimdType(()),
+ }
+ }
+
+ /// Format an untranslated diagnostic for this type
+ ///
+ /// Intended for use by rust-analyzer, as neither it nor `rustc_abi` depend on fluent infra.
+ pub fn fallback_fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ use LayoutCalculatorError::*;
+ f.write_str(match self {
+ UnexpectedUnsized(_) => "an unsized type was found where a sized type was expected",
+ SizeOverflow => "size overflow",
+ EmptyUnion => "type is a union with no fields",
+ ReprConflict => "type has an invalid repr",
+ ZeroLengthSimdType | OversizedSimdType { .. } | NonPrimitiveSimdType(_) => {
+ "invalid simd type definition"
+ }
+ })
+ }
+}
+
+type LayoutCalculatorResult<FieldIdx, VariantIdx, F> =
+ Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>;
- fn delayed_bug(&self, txt: impl Into<Cow<'static, str>>);
- fn current_data_layout(&self) -> Self::TargetDataLayoutRef;
+#[derive(Clone, Copy, Debug)]
+pub struct LayoutCalculator<Cx> {
+ pub cx: Cx,
+}
+
+impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
+ pub fn new(cx: Cx) -> Self {
+ Self { cx }
+ }
- fn scalar_pair<FieldIdx: Idx, VariantIdx: Idx>(
+ pub fn array_like<FieldIdx: Idx, VariantIdx: Idx, F>(
&self,
- a: Scalar,
- b: Scalar,
- ) -> LayoutS<FieldIdx, VariantIdx> {
- let dl = self.current_data_layout();
- let dl = dl.borrow();
- let b_align = b.align(dl);
- let align = a.align(dl).max(b_align).max(dl.aggregate_align);
- let b_offset = a.size(dl).align_to(b_align.abi);
- let size = (b_offset + b.size(dl)).align_to(align.abi);
-
- // HACK(nox): We iter on `b` and then `a` because `max_by_key`
- // returns the last maximum.
- let largest_niche = Niche::from_scalar(dl, b_offset, b)
- .into_iter()
- .chain(Niche::from_scalar(dl, Size::ZERO, a))
- .max_by_key(|niche| niche.available(dl));
-
- LayoutS {
+ element: &LayoutData<FieldIdx, VariantIdx>,
+ count_if_sized: Option<u64>, // None for slices
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ let count = count_if_sized.unwrap_or(0);
+ let size =
+ element.size.checked_mul(count, &self.cx).ok_or(LayoutCalculatorError::SizeOverflow)?;
+
+ Ok(LayoutData {
+ variants: Variants::Single { index: VariantIdx::new(0) },
+ fields: FieldsShape::Array { stride: element.size, count },
+ backend_repr: BackendRepr::Memory { sized: count_if_sized.is_some() },
+ largest_niche: element.largest_niche.filter(|_| count != 0),
+ uninhabited: element.uninhabited && count != 0,
+ align: element.align,
+ size,
+ max_repr_align: None,
+ unadjusted_abi_align: element.align.abi,
+ randomization_seed: element.randomization_seed.wrapping_add(Hash64::new(count)),
+ })
+ }
+
+ pub fn simd_type<
+ FieldIdx: Idx,
+ VariantIdx: Idx,
+ F: AsRef<LayoutData<FieldIdx, VariantIdx>> + fmt::Debug,
+ >(
+ &self,
+ element: F,
+ count: u64,
+ repr_packed: bool,
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ let elt = element.as_ref();
+ if count == 0 {
+ return Err(LayoutCalculatorError::ZeroLengthSimdType);
+ } else if count > crate::MAX_SIMD_LANES {
+ return Err(LayoutCalculatorError::OversizedSimdType {
+ max_lanes: crate::MAX_SIMD_LANES,
+ });
+ }
+
+ let BackendRepr::Scalar(e_repr) = elt.backend_repr else {
+ return Err(LayoutCalculatorError::NonPrimitiveSimdType(element));
+ };
+
+ // Compute the size and alignment of the vector
+ let dl = self.cx.data_layout();
+ let size =
+ elt.size.checked_mul(count, dl).ok_or_else(|| LayoutCalculatorError::SizeOverflow)?;
+ let (repr, align) = if repr_packed && !count.is_power_of_two() {
+ // Non-power-of-two vectors have padding up to the next power-of-two.
+ // If we're a packed repr, remove the padding while keeping the alignment as close
+ // to a vector as possible.
+ (
+ BackendRepr::Memory { sized: true },
+ AbiAndPrefAlign {
+ abi: Align::max_aligned_factor(size),
+ pref: dl.llvmlike_vector_align(size).pref,
+ },
+ )
+ } else {
+ (BackendRepr::SimdVector { element: e_repr, count }, dl.llvmlike_vector_align(size))
+ };
+ let size = size.align_to(align.abi);
+
+ Ok(LayoutData {
variants: Variants::Single { index: VariantIdx::new(0) },
fields: FieldsShape::Arbitrary {
- offsets: [Size::ZERO, b_offset].into(),
- memory_index: [0, 1].into(),
+ offsets: [Size::ZERO].into(),
+ memory_index: [0].into(),
},
- abi: Abi::ScalarPair(a, b),
- largest_niche,
- align,
+ backend_repr: repr,
+ largest_niche: elt.largest_niche,
+ uninhabited: false,
size,
+ align,
max_repr_align: None,
- unadjusted_abi_align: align.abi,
- }
+ unadjusted_abi_align: elt.align.abi,
+ randomization_seed: elt.randomization_seed.wrapping_add(Hash64::new(count)),
+ })
}
- fn univariant<
+ /// Compute the layout for a coroutine.
+ ///
+ /// This uses dedicated code instead of [`Self::layout_of_struct_or_enum`], as coroutine
+ /// fields may be shared between multiple variants (see the [`coroutine`] module for details).
+ pub fn coroutine<
+ 'a,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug + Copy,
+ VariantIdx: Idx,
+ FieldIdx: Idx,
+ LocalIdx: Idx,
+ >(
+ &self,
+ local_layouts: &IndexSlice<LocalIdx, F>,
+ prefix_layouts: IndexVec<FieldIdx, F>,
+ variant_fields: &IndexSlice<VariantIdx, IndexVec<FieldIdx, LocalIdx>>,
+ storage_conflicts: &BitMatrix<LocalIdx, LocalIdx>,
+ tag_to_layout: impl Fn(Scalar) -> F,
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ coroutine::layout(
+ self,
+ local_layouts,
+ prefix_layouts,
+ variant_fields,
+ storage_conflicts,
+ tag_to_layout,
+ )
+ }
+
+ pub fn univariant<
'a,
FieldIdx: Idx,
VariantIdx: Idx,
- F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug + Copy,
>(
&self,
- dl: &TargetDataLayout,
fields: &IndexSlice<FieldIdx, F>,
repr: &ReprOptions,
kind: StructKind,
- ) -> Option<LayoutS<FieldIdx, VariantIdx>> {
- let layout = univariant(self, dl, fields, repr, kind, NicheBias::Start);
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ let dl = self.cx.data_layout();
+ let layout = self.univariant_biased(fields, repr, kind, NicheBias::Start);
// Enums prefer niches close to the beginning or the end of the variants so that other
// (smaller) data-carrying variants can be packed into the space after/before the niche.
// If the default field ordering does not give us a niche at the front then we do a second
// run and bias niches to the right and then check which one is closer to one of the
// struct's edges.
- if let Some(layout) = &layout {
+ if let Ok(layout) = &layout {
// Don't try to calculate an end-biased layout for unsizable structs,
// otherwise we could end up with different layouts for
// Foo<Type> and Foo<dyn Trait> which would break unsizing.
@@ -104,7 +262,8 @@ pub trait LayoutCalculator {
// field (e.g. a trailing bool) and there is tail padding. But it's non-trivial
// to get the unpadded size so we try anyway.
if fields.len() > 1 && head_space != 0 && tail_space > 0 {
- let alt_layout = univariant(self, dl, fields, repr, kind, NicheBias::End)
+ let alt_layout = self
+ .univariant_biased(fields, repr, kind, NicheBias::End)
.expect("alt layout should always work");
let alt_niche = alt_layout
.largest_niche
@@ -132,12 +291,12 @@ pub trait LayoutCalculator {
alt_tail_space,
layout.fields.count(),
prefer_alt_layout,
- format_field_niches(layout, fields, dl),
- format_field_niches(&alt_layout, fields, dl),
+ self.format_field_niches(layout, fields),
+ self.format_field_niches(&alt_layout, fields),
);
if prefer_alt_layout {
- return Some(alt_layout);
+ return Ok(alt_layout);
}
}
}
@@ -146,43 +305,23 @@ pub trait LayoutCalculator {
layout
}
- fn layout_of_never_type<FieldIdx: Idx, VariantIdx: Idx>(
- &self,
- ) -> LayoutS<FieldIdx, VariantIdx> {
- let dl = self.current_data_layout();
- let dl = dl.borrow();
- LayoutS {
- variants: Variants::Single { index: VariantIdx::new(0) },
- fields: FieldsShape::Primitive,
- abi: Abi::Uninhabited,
- largest_niche: None,
- align: dl.i8_align,
- size: Size::ZERO,
- max_repr_align: None,
- unadjusted_abi_align: dl.i8_align.abi,
- }
- }
-
- fn layout_of_struct_or_enum<
+ pub fn layout_of_struct_or_enum<
'a,
FieldIdx: Idx,
VariantIdx: Idx,
- F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug + Copy,
>(
&self,
repr: &ReprOptions,
variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>,
is_enum: bool,
- is_unsafe_cell: bool,
+ is_special_no_niche: bool,
scalar_valid_range: (Bound<u128>, Bound<u128>),
discr_range_of_repr: impl Fn(i128, i128) -> (Integer, bool),
discriminants: impl Iterator<Item = (VariantIdx, i128)>,
dont_niche_optimize_enum: bool,
always_sized: bool,
- ) -> Option<LayoutS<FieldIdx, VariantIdx>> {
- let dl = self.current_data_layout();
- let dl = dl.borrow();
-
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
let (present_first, present_second) = {
let mut present_variants = variants
.iter_enumerated()
@@ -193,7 +332,7 @@ pub trait LayoutCalculator {
Some(present_first) => present_first,
// Uninhabited because it has no variants, or only absent ones.
None if is_enum => {
- return Some(self.layout_of_never_type());
+ return Ok(LayoutData::never_type(&self.cx));
}
// If it's a struct, still compute a layout so that we can still compute the
// field offsets.
@@ -205,15 +344,13 @@ pub trait LayoutCalculator {
// or for optimizing univariant enums
(present_second.is_none() && !repr.inhibit_enum_layout_opt())
{
- layout_of_struct(
- self,
+ self.layout_of_struct(
repr,
variants,
is_enum,
- is_unsafe_cell,
+ is_special_no_niche,
scalar_valid_range,
always_sized,
- dl,
present_first,
)
} else {
@@ -221,37 +358,34 @@ pub trait LayoutCalculator {
// structs. (We have also handled univariant enums
// that allow representation optimization.)
assert!(is_enum);
- layout_of_enum(
- self,
+ self.layout_of_enum(
repr,
variants,
discr_range_of_repr,
discriminants,
dont_niche_optimize_enum,
- dl,
)
}
}
- fn layout_of_union<
+ pub fn layout_of_union<
'a,
FieldIdx: Idx,
VariantIdx: Idx,
- F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug + Copy,
>(
&self,
repr: &ReprOptions,
variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>,
- ) -> Option<LayoutS<FieldIdx, VariantIdx>> {
- let dl = self.current_data_layout();
- let dl = dl.borrow();
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ let dl = self.cx.data_layout();
let mut align = if repr.pack.is_some() { dl.i8_align } else { dl.aggregate_align };
let mut max_repr_align = repr.align;
- // If all the non-ZST fields have the same ABI and union ABI optimizations aren't
- // disabled, we can use that common ABI for the union as a whole.
+ // If all the non-ZST fields have the same repr and union repr optimizations aren't
+ // disabled, we can use that common repr for the union as a whole.
struct AbiMismatch;
- let mut common_non_zst_abi_and_align = if repr.inhibits_union_abi_opt() {
+ let mut common_non_zst_repr_and_align = if repr.inhibits_union_abi_opt() {
// Can't optimize
Err(AbiMismatch)
} else {
@@ -259,10 +393,11 @@ pub trait LayoutCalculator {
};
let mut size = Size::ZERO;
- let only_variant = &variants[VariantIdx::new(0)];
+ let only_variant_idx = VariantIdx::new(0);
+ let only_variant = &variants[only_variant_idx];
for field in only_variant {
if field.is_unsized() {
- self.delayed_bug("unsized field in union".to_string());
+ return Err(LayoutCalculatorError::UnexpectedUnsized(*field));
}
align = align.max(field.align);
@@ -274,18 +409,18 @@ pub trait LayoutCalculator {
continue;
}
- if let Ok(common) = common_non_zst_abi_and_align {
+ if let Ok(common) = common_non_zst_repr_and_align {
// Discard valid range information and allow undef
- let field_abi = field.abi.to_union();
+ let field_abi = field.backend_repr.to_union();
if let Some((common_abi, common_align)) = common {
if common_abi != field_abi {
// Different fields have different ABI: disable opt
- common_non_zst_abi_and_align = Err(AbiMismatch);
+ common_non_zst_repr_and_align = Err(AbiMismatch);
} else {
// Fields with the same non-Aggregate ABI should also
// have the same alignment
- if !matches!(common_abi, Abi::Aggregate { .. }) {
+ if !matches!(common_abi, BackendRepr::Memory { .. }) {
assert_eq!(
common_align, field.align.abi,
"non-Aggregate field with matching ABI but differing alignment"
@@ -294,7 +429,7 @@ pub trait LayoutCalculator {
}
} else {
// First non-ZST field: record its ABI and alignment
- common_non_zst_abi_and_align = Ok(Some((field_abi, field.align.abi)));
+ common_non_zst_repr_and_align = Ok(Some((field_abi, field.align.abi)));
}
}
}
@@ -313,1005 +448,1060 @@ pub trait LayoutCalculator {
// If all non-ZST fields have the same ABI, we may forward that ABI
// for the union as a whole, unless otherwise inhibited.
- let abi = match common_non_zst_abi_and_align {
- Err(AbiMismatch) | Ok(None) => Abi::Aggregate { sized: true },
- Ok(Some((abi, _))) => {
- if abi.inherent_align(dl).map(|a| a.abi) != Some(align.abi) {
- // Mismatched alignment (e.g. union is #[repr(packed)]): disable opt
- Abi::Aggregate { sized: true }
- } else {
- abi
+ let backend_repr = match common_non_zst_repr_and_align {
+ Err(AbiMismatch) | Ok(None) => BackendRepr::Memory { sized: true },
+ Ok(Some((repr, _))) => match repr {
+ // Mismatched alignment (e.g. union is #[repr(packed)]): disable opt
+ BackendRepr::Scalar(_) | BackendRepr::ScalarPair(_, _)
+ if repr.scalar_align(dl).unwrap() != align.abi =>
+ {
+ BackendRepr::Memory { sized: true }
}
- }
+ // Vectors require at least element alignment, else disable the opt
+ BackendRepr::SimdVector { element, count: _ }
+ if element.align(dl).abi > align.abi =>
+ {
+ BackendRepr::Memory { sized: true }
+ }
+ // the alignment tests passed and we can use this
+ BackendRepr::Scalar(..)
+ | BackendRepr::ScalarPair(..)
+ | BackendRepr::SimdVector { .. }
+ | BackendRepr::Memory { .. } => repr,
+ },
};
- Some(LayoutS {
- variants: Variants::Single { index: VariantIdx::new(0) },
- fields: FieldsShape::Union(NonZeroUsize::new(only_variant.len())?),
- abi,
+ let Some(union_field_count) = NonZeroUsize::new(only_variant.len()) else {
+ return Err(LayoutCalculatorError::EmptyUnion);
+ };
+
+ let combined_seed = only_variant
+ .iter()
+ .map(|v| v.randomization_seed)
+ .fold(repr.field_shuffle_seed, |acc, seed| acc.wrapping_add(seed));
+
+ Ok(LayoutData {
+ variants: Variants::Single { index: only_variant_idx },
+ fields: FieldsShape::Union(union_field_count),
+ backend_repr,
largest_niche: None,
+ uninhabited: false,
align,
size: size.align_to(align.abi),
max_repr_align,
unadjusted_abi_align,
+ randomization_seed: combined_seed,
})
}
-}
-/// single-variant enums are just structs, if you think about it
-fn layout_of_struct<'a, LC, FieldIdx: Idx, VariantIdx: Idx, F>(
- layout_calc: &LC,
- repr: &ReprOptions,
- variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>,
- is_enum: bool,
- is_unsafe_cell: bool,
- scalar_valid_range: (Bound<u128>, Bound<u128>),
- always_sized: bool,
- dl: &TargetDataLayout,
- present_first: VariantIdx,
-) -> Option<LayoutS<FieldIdx, VariantIdx>>
-where
- LC: LayoutCalculator + ?Sized,
- F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
-{
- // Struct, or univariant enum equivalent to a struct.
- // (Typechecking will reject discriminant-sizing attrs.)
-
- let v = present_first;
- let kind = if is_enum || variants[v].is_empty() || always_sized {
- StructKind::AlwaysSized
- } else {
- StructKind::MaybeUnsized
- };
-
- let mut st = layout_calc.univariant(dl, &variants[v], repr, kind)?;
- st.variants = Variants::Single { index: v };
-
- if is_unsafe_cell {
- let hide_niches = |scalar: &mut _| match scalar {
- Scalar::Initialized { value, valid_range } => {
- *valid_range = WrappingRange::full(value.size(dl))
- }
- // Already doesn't have any niches
- Scalar::Union { .. } => {}
+ /// single-variant enums are just structs, if you think about it
+ fn layout_of_struct<
+ 'a,
+ FieldIdx: Idx,
+ VariantIdx: Idx,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug + Copy,
+ >(
+ &self,
+ repr: &ReprOptions,
+ variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>,
+ is_enum: bool,
+ is_special_no_niche: bool,
+ scalar_valid_range: (Bound<u128>, Bound<u128>),
+ always_sized: bool,
+ present_first: VariantIdx,
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ // Struct, or univariant enum equivalent to a struct.
+ // (Typechecking will reject discriminant-sizing attrs.)
+
+ let dl = self.cx.data_layout();
+ let v = present_first;
+ let kind = if is_enum || variants[v].is_empty() || always_sized {
+ StructKind::AlwaysSized
+ } else {
+ StructKind::MaybeUnsized
};
- match &mut st.abi {
- Abi::Uninhabited => {}
- Abi::Scalar(scalar) => hide_niches(scalar),
- Abi::ScalarPair(a, b) => {
- hide_niches(a);
- hide_niches(b);
+
+ let mut st = self.univariant(&variants[v], repr, kind)?;
+ st.variants = Variants::Single { index: v };
+
+ if is_special_no_niche {
+ let hide_niches = |scalar: &mut _| match scalar {
+ Scalar::Initialized { value, valid_range } => {
+ *valid_range = WrappingRange::full(value.size(dl))
+ }
+ // Already doesn't have any niches
+ Scalar::Union { .. } => {}
+ };
+ match &mut st.backend_repr {
+ BackendRepr::Scalar(scalar) => hide_niches(scalar),
+ BackendRepr::ScalarPair(a, b) => {
+ hide_niches(a);
+ hide_niches(b);
+ }
+ BackendRepr::SimdVector { element, count: _ } => hide_niches(element),
+ BackendRepr::Memory { sized: _ } => {}
}
- Abi::Vector { element, count: _ } => hide_niches(element),
- Abi::Aggregate { sized: _ } => {}
+ st.largest_niche = None;
+ return Ok(st);
}
- st.largest_niche = None;
- return Some(st);
- }
- let (start, end) = scalar_valid_range;
- match st.abi {
- Abi::Scalar(ref mut scalar) | Abi::ScalarPair(ref mut scalar, _) => {
- // Enlarging validity ranges would result in missed
- // optimizations, *not* wrongly assuming the inner
- // value is valid. e.g. unions already enlarge validity ranges,
- // because the values may be uninitialized.
- //
- // Because of that we only check that the start and end
- // of the range is representable with this scalar type.
-
- let max_value = scalar.size(dl).unsigned_int_max();
- if let Bound::Included(start) = start {
- // FIXME(eddyb) this might be incorrect - it doesn't
- // account for wrap-around (end < start) ranges.
- assert!(start <= max_value, "{start} > {max_value}");
- scalar.valid_range_mut().start = start;
- }
- if let Bound::Included(end) = end {
- // FIXME(eddyb) this might be incorrect - it doesn't
- // account for wrap-around (end < start) ranges.
- assert!(end <= max_value, "{end} > {max_value}");
- scalar.valid_range_mut().end = end;
- }
+ let (start, end) = scalar_valid_range;
+ match st.backend_repr {
+ BackendRepr::Scalar(ref mut scalar) | BackendRepr::ScalarPair(ref mut scalar, _) => {
+ // Enlarging validity ranges would result in missed
+ // optimizations, *not* wrongly assuming the inner
+ // value is valid. e.g. unions already enlarge validity ranges,
+ // because the values may be uninitialized.
+ //
+ // Because of that we only check that the start and end
+ // of the range is representable with this scalar type.
+
+ let max_value = scalar.size(dl).unsigned_int_max();
+ if let Bound::Included(start) = start {
+ // FIXME(eddyb) this might be incorrect - it doesn't
+ // account for wrap-around (end < start) ranges.
+ assert!(start <= max_value, "{start} > {max_value}");
+ scalar.valid_range_mut().start = start;
+ }
+ if let Bound::Included(end) = end {
+ // FIXME(eddyb) this might be incorrect - it doesn't
+ // account for wrap-around (end < start) ranges.
+ assert!(end <= max_value, "{end} > {max_value}");
+ scalar.valid_range_mut().end = end;
+ }
- // Update `largest_niche` if we have introduced a larger niche.
- let niche = Niche::from_scalar(dl, Size::ZERO, *scalar);
- if let Some(niche) = niche {
- match st.largest_niche {
- Some(largest_niche) => {
- // Replace the existing niche even if they're equal,
- // because this one is at a lower offset.
- if largest_niche.available(dl) <= niche.available(dl) {
- st.largest_niche = Some(niche);
+ // Update `largest_niche` if we have introduced a larger niche.
+ let niche = Niche::from_scalar(dl, Size::ZERO, *scalar);
+ if let Some(niche) = niche {
+ match st.largest_niche {
+ Some(largest_niche) => {
+ // Replace the existing niche even if they're equal,
+ // because this one is at a lower offset.
+ if largest_niche.available(dl) <= niche.available(dl) {
+ st.largest_niche = Some(niche);
+ }
}
+ None => st.largest_niche = Some(niche),
}
- None => st.largest_niche = Some(niche),
}
}
+ _ => assert!(
+ start == Bound::Unbounded && end == Bound::Unbounded,
+ "nonscalar layout for layout_scalar_valid_range type: {st:#?}",
+ ),
}
- _ => assert!(
- start == Bound::Unbounded && end == Bound::Unbounded,
- "nonscalar layout for layout_scalar_valid_range type: {st:#?}",
- ),
- }
-
- Some(st)
-}
-fn layout_of_enum<'a, LC, FieldIdx: Idx, VariantIdx: Idx, F>(
- layout_calc: &LC,
- repr: &ReprOptions,
- variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>,
- discr_range_of_repr: impl Fn(i128, i128) -> (Integer, bool),
- discriminants: impl Iterator<Item = (VariantIdx, i128)>,
- dont_niche_optimize_enum: bool,
- dl: &TargetDataLayout,
-) -> Option<LayoutS<FieldIdx, VariantIdx>>
-where
- LC: LayoutCalculator + ?Sized,
- F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
-{
- // Until we've decided whether to use the tagged or
- // niche filling LayoutS, we don't want to intern the
- // variant layouts, so we can't store them in the
- // overall LayoutS. Store the overall LayoutS
- // and the variant LayoutSs here until then.
- struct TmpLayout<FieldIdx: Idx, VariantIdx: Idx> {
- layout: LayoutS<FieldIdx, VariantIdx>,
- variants: IndexVec<VariantIdx, LayoutS<FieldIdx, VariantIdx>>,
+ Ok(st)
}
- let calculate_niche_filling_layout = || -> Option<TmpLayout<FieldIdx, VariantIdx>> {
- if dont_niche_optimize_enum {
- return None;
+ fn layout_of_enum<
+ 'a,
+ FieldIdx: Idx,
+ VariantIdx: Idx,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug + Copy,
+ >(
+ &self,
+ repr: &ReprOptions,
+ variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>,
+ discr_range_of_repr: impl Fn(i128, i128) -> (Integer, bool),
+ discriminants: impl Iterator<Item = (VariantIdx, i128)>,
+ dont_niche_optimize_enum: bool,
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ // Until we've decided whether to use the tagged or
+ // niche filling LayoutS, we don't want to intern the
+ // variant layouts, so we can't store them in the
+ // overall LayoutS. Store the overall LayoutS
+ // and the variant LayoutSs here until then.
+ struct TmpLayout<FieldIdx: Idx, VariantIdx: Idx> {
+ layout: LayoutData<FieldIdx, VariantIdx>,
+ variants: IndexVec<VariantIdx, LayoutData<FieldIdx, VariantIdx>>,
}
- if variants.len() < 2 {
- return None;
+ let dl = self.cx.data_layout();
+ // bail if the enum has an incoherent repr that cannot be computed
+ if repr.packed() {
+ return Err(LayoutCalculatorError::ReprConflict);
}
- let mut align = dl.aggregate_align;
- let mut max_repr_align = repr.align;
- let mut unadjusted_abi_align = align.abi;
-
- let mut variant_layouts = variants
- .iter_enumerated()
- .map(|(j, v)| {
- let mut st = layout_calc.univariant(dl, v, repr, StructKind::AlwaysSized)?;
- st.variants = Variants::Single { index: j };
+ let calculate_niche_filling_layout = || -> Option<TmpLayout<FieldIdx, VariantIdx>> {
+ if dont_niche_optimize_enum {
+ return None;
+ }
- align = align.max(st.align);
- max_repr_align = max_repr_align.max(st.max_repr_align);
- unadjusted_abi_align = unadjusted_abi_align.max(st.unadjusted_abi_align);
+ if variants.len() < 2 {
+ return None;
+ }
- Some(st)
- })
- .collect::<Option<IndexVec<VariantIdx, _>>>()?;
+ let mut align = dl.aggregate_align;
+ let mut max_repr_align = repr.align;
+ let mut unadjusted_abi_align = align.abi;
- let largest_variant_index = variant_layouts
- .iter_enumerated()
- .max_by_key(|(_i, layout)| layout.size.bytes())
- .map(|(i, _layout)| i)?;
+ let mut variant_layouts = variants
+ .iter_enumerated()
+ .map(|(j, v)| {
+ let mut st = self.univariant(v, repr, StructKind::AlwaysSized).ok()?;
+ st.variants = Variants::Single { index: j };
- let all_indices = variants.indices();
- let needs_disc =
- |index: VariantIdx| index != largest_variant_index && !absent(&variants[index]);
- let niche_variants = all_indices.clone().find(|v| needs_disc(*v)).unwrap()
- ..=all_indices.rev().find(|v| needs_disc(*v)).unwrap();
+ align = align.max(st.align);
+ max_repr_align = max_repr_align.max(st.max_repr_align);
+ unadjusted_abi_align = unadjusted_abi_align.max(st.unadjusted_abi_align);
- let count =
- (niche_variants.end().index() as u128 - niche_variants.start().index() as u128) + 1;
+ Some(st)
+ })
+ .collect::<Option<IndexVec<VariantIdx, _>>>()?;
- // Find the field with the largest niche
- let (field_index, niche, (niche_start, niche_scalar)) = variants[largest_variant_index]
- .iter()
- .enumerate()
- .filter_map(|(j, field)| Some((j, field.largest_niche?)))
- .max_by_key(|(_, niche)| niche.available(dl))
- .and_then(|(j, niche)| Some((j, niche, niche.reserve(dl, count)?)))?;
- let niche_offset =
- niche.offset + variant_layouts[largest_variant_index].fields.offset(field_index);
- let niche_size = niche.value.size(dl);
- let size = variant_layouts[largest_variant_index].size.align_to(align.abi);
-
- let all_variants_fit = variant_layouts.iter_enumerated_mut().all(|(i, layout)| {
- if i == largest_variant_index {
- return true;
- }
+ let largest_variant_index = variant_layouts
+ .iter_enumerated()
+ .max_by_key(|(_i, layout)| layout.size.bytes())
+ .map(|(i, _layout)| i)?;
+
+ let all_indices = variants.indices();
+ let needs_disc =
+ |index: VariantIdx| index != largest_variant_index && !absent(&variants[index]);
+ let niche_variants = all_indices.clone().find(|v| needs_disc(*v)).unwrap()
+ ..=all_indices.rev().find(|v| needs_disc(*v)).unwrap();
+
+ let count =
+ (niche_variants.end().index() as u128 - niche_variants.start().index() as u128) + 1;
+
+ // Use the largest niche in the largest variant.
+ let niche = variant_layouts[largest_variant_index].largest_niche?;
+ let (niche_start, niche_scalar) = niche.reserve(dl, count)?;
+ let niche_offset = niche.offset;
+ let niche_size = niche.value.size(dl);
+ let size = variant_layouts[largest_variant_index].size.align_to(align.abi);
+
+ let all_variants_fit = variant_layouts.iter_enumerated_mut().all(|(i, layout)| {
+ if i == largest_variant_index {
+ return true;
+ }
- layout.largest_niche = None;
+ layout.largest_niche = None;
- if layout.size <= niche_offset {
- // This variant will fit before the niche.
- return true;
- }
+ if layout.size <= niche_offset {
+ // This variant will fit before the niche.
+ return true;
+ }
- // Determine if it'll fit after the niche.
- let this_align = layout.align.abi;
- let this_offset = (niche_offset + niche_size).align_to(this_align);
+ // Determine if it'll fit after the niche.
+ let this_align = layout.align.abi;
+ let this_offset = (niche_offset + niche_size).align_to(this_align);
- if this_offset + layout.size > size {
- return false;
- }
+ if this_offset + layout.size > size {
+ return false;
+ }
- // It'll fit, but we need to make some adjustments.
- match layout.fields {
- FieldsShape::Arbitrary { ref mut offsets, .. } => {
- for offset in offsets.iter_mut() {
- *offset += this_offset;
+ // It'll fit, but we need to make some adjustments.
+ match layout.fields {
+ FieldsShape::Arbitrary { ref mut offsets, .. } => {
+ for offset in offsets.iter_mut() {
+ *offset += this_offset;
+ }
+ }
+ FieldsShape::Primitive | FieldsShape::Array { .. } | FieldsShape::Union(..) => {
+ panic!("Layout of fields should be Arbitrary for variants")
}
}
- FieldsShape::Primitive | FieldsShape::Array { .. } | FieldsShape::Union(..) => {
- panic!("Layout of fields should be Arbitrary for variants")
- }
- }
- // It can't be a Scalar or ScalarPair because the offset isn't 0.
- if !layout.abi.is_uninhabited() {
- layout.abi = Abi::Aggregate { sized: true };
- }
- layout.size += this_offset;
+ // It can't be a Scalar or ScalarPair because the offset isn't 0.
+ if !layout.is_uninhabited() {
+ layout.backend_repr = BackendRepr::Memory { sized: true };
+ }
+ layout.size += this_offset;
- true
- });
+ true
+ });
- if !all_variants_fit {
- return None;
- }
+ if !all_variants_fit {
+ return None;
+ }
- let largest_niche = Niche::from_scalar(dl, niche_offset, niche_scalar);
+ let largest_niche = Niche::from_scalar(dl, niche_offset, niche_scalar);
- let others_zst = variant_layouts
- .iter_enumerated()
- .all(|(i, layout)| i == largest_variant_index || layout.size == Size::ZERO);
- let same_size = size == variant_layouts[largest_variant_index].size;
- let same_align = align == variant_layouts[largest_variant_index].align;
-
- let abi = if variant_layouts.iter().all(|v| v.abi.is_uninhabited()) {
- Abi::Uninhabited
- } else if same_size && same_align && others_zst {
- match variant_layouts[largest_variant_index].abi {
- // When the total alignment and size match, we can use the
- // same ABI as the scalar variant with the reserved niche.
- Abi::Scalar(_) => Abi::Scalar(niche_scalar),
- Abi::ScalarPair(first, second) => {
- // Only the niche is guaranteed to be initialised,
- // so use union layouts for the other primitive.
- if niche_offset == Size::ZERO {
- Abi::ScalarPair(niche_scalar, second.to_union())
- } else {
- Abi::ScalarPair(first.to_union(), niche_scalar)
+ let others_zst = variant_layouts
+ .iter_enumerated()
+ .all(|(i, layout)| i == largest_variant_index || layout.size == Size::ZERO);
+ let same_size = size == variant_layouts[largest_variant_index].size;
+ let same_align = align == variant_layouts[largest_variant_index].align;
+
+ let uninhabited = variant_layouts.iter().all(|v| v.is_uninhabited());
+ let abi = if same_size && same_align && others_zst {
+ match variant_layouts[largest_variant_index].backend_repr {
+ // When the total alignment and size match, we can use the
+ // same ABI as the scalar variant with the reserved niche.
+ BackendRepr::Scalar(_) => BackendRepr::Scalar(niche_scalar),
+ BackendRepr::ScalarPair(first, second) => {
+ // Only the niche is guaranteed to be initialised,
+ // so use union layouts for the other primitive.
+ if niche_offset == Size::ZERO {
+ BackendRepr::ScalarPair(niche_scalar, second.to_union())
+ } else {
+ BackendRepr::ScalarPair(first.to_union(), niche_scalar)
+ }
}
+ _ => BackendRepr::Memory { sized: true },
}
- _ => Abi::Aggregate { sized: true },
- }
- } else {
- Abi::Aggregate { sized: true }
- };
+ } else {
+ BackendRepr::Memory { sized: true }
+ };
- let layout = LayoutS {
- variants: Variants::Multiple {
- tag: niche_scalar,
- tag_encoding: TagEncoding::Niche {
- untagged_variant: largest_variant_index,
- niche_variants,
- niche_start,
+ let combined_seed = variant_layouts
+ .iter()
+ .map(|v| v.randomization_seed)
+ .fold(repr.field_shuffle_seed, |acc, seed| acc.wrapping_add(seed));
+
+ let layout = LayoutData {
+ variants: Variants::Multiple {
+ tag: niche_scalar,
+ tag_encoding: TagEncoding::Niche {
+ untagged_variant: largest_variant_index,
+ niche_variants,
+ niche_start,
+ },
+ tag_field: 0,
+ variants: IndexVec::new(),
},
- tag_field: 0,
- variants: IndexVec::new(),
- },
- fields: FieldsShape::Arbitrary {
- offsets: [niche_offset].into(),
- memory_index: [0].into(),
- },
- abi,
- largest_niche,
- size,
- align,
- max_repr_align,
- unadjusted_abi_align,
- };
+ fields: FieldsShape::Arbitrary {
+ offsets: [niche_offset].into(),
+ memory_index: [0].into(),
+ },
+ backend_repr: abi,
+ largest_niche,
+ uninhabited,
+ size,
+ align,
+ max_repr_align,
+ unadjusted_abi_align,
+ randomization_seed: combined_seed,
+ };
- Some(TmpLayout { layout, variants: variant_layouts })
- };
+ Some(TmpLayout { layout, variants: variant_layouts })
+ };
- let niche_filling_layout = calculate_niche_filling_layout();
+ let niche_filling_layout = calculate_niche_filling_layout();
- let (mut min, mut max) = (i128::MAX, i128::MIN);
- let discr_type = repr.discr_type();
- let bits = Integer::from_attr(dl, discr_type).size().bits();
- for (i, mut val) in discriminants {
- if !repr.c() && variants[i].iter().any(|f| f.abi.is_uninhabited()) {
- continue;
- }
- if discr_type.is_signed() {
- // sign extend the raw representation to be an i128
- val = (val << (128 - bits)) >> (128 - bits);
- }
- if val < min {
- min = val;
+ let (mut min, mut max) = (i128::MAX, i128::MIN);
+ let discr_type = repr.discr_type();
+ let bits = Integer::from_attr(dl, discr_type).size().bits();
+ for (i, mut val) in discriminants {
+ if !repr.c() && variants[i].iter().any(|f| f.is_uninhabited()) {
+ continue;
+ }
+ if discr_type.is_signed() {
+ // sign extend the raw representation to be an i128
+ val = (val << (128 - bits)) >> (128 - bits);
+ }
+ if val < min {
+ min = val;
+ }
+ if val > max {
+ max = val;
+ }
}
- if val > max {
- max = val;
+ // We might have no inhabited variants, so pretend there's at least one.
+ if (min, max) == (i128::MAX, i128::MIN) {
+ min = 0;
+ max = 0;
}
- }
- // We might have no inhabited variants, so pretend there's at least one.
- if (min, max) == (i128::MAX, i128::MIN) {
- min = 0;
- max = 0;
- }
- assert!(min <= max, "discriminant range is {min}...{max}");
- let (min_ity, signed) = discr_range_of_repr(min, max); //Integer::repr_discr(tcx, ty, &repr, min, max);
-
- let mut align = dl.aggregate_align;
- let mut max_repr_align = repr.align;
- let mut unadjusted_abi_align = align.abi;
-
- let mut size = Size::ZERO;
-
- // We're interested in the smallest alignment, so start large.
- let mut start_align = Align::from_bytes(256).unwrap();
- assert_eq!(Integer::for_align(dl, start_align), None);
-
- // repr(C) on an enum tells us to make a (tag, union) layout,
- // so we need to grow the prefix alignment to be at least
- // the alignment of the union. (This value is used both for
- // determining the alignment of the overall enum, and the
- // determining the alignment of the payload after the tag.)
- let mut prefix_align = min_ity.align(dl).abi;
- if repr.c() {
- for fields in variants {
- for field in fields {
- prefix_align = prefix_align.max(field.align.abi);
+ assert!(min <= max, "discriminant range is {min}...{max}");
+ let (min_ity, signed) = discr_range_of_repr(min, max); //Integer::repr_discr(tcx, ty, &repr, min, max);
+
+ let mut align = dl.aggregate_align;
+ let mut max_repr_align = repr.align;
+ let mut unadjusted_abi_align = align.abi;
+
+ let mut size = Size::ZERO;
+
+ // We're interested in the smallest alignment, so start large.
+ let mut start_align = Align::from_bytes(256).unwrap();
+ assert_eq!(Integer::for_align(dl, start_align), None);
+
+ // repr(C) on an enum tells us to make a (tag, union) layout,
+ // so we need to grow the prefix alignment to be at least
+ // the alignment of the union. (This value is used both for
+ // determining the alignment of the overall enum, and the
+ // determining the alignment of the payload after the tag.)
+ let mut prefix_align = min_ity.align(dl).abi;
+ if repr.c() {
+ for fields in variants {
+ for field in fields {
+ prefix_align = prefix_align.max(field.align.abi);
+ }
}
}
- }
- // Create the set of structs that represent each variant.
- let mut layout_variants = variants
- .iter_enumerated()
- .map(|(i, field_layouts)| {
- let mut st = layout_calc.univariant(
- dl,
- field_layouts,
- repr,
- StructKind::Prefixed(min_ity.size(), prefix_align),
- )?;
- st.variants = Variants::Single { index: i };
- // Find the first field we can't move later
- // to make room for a larger discriminant.
- for field_idx in st.fields.index_by_increasing_offset() {
- let field = &field_layouts[FieldIdx::new(field_idx)];
- if !field.is_1zst() {
- start_align = start_align.min(field.align.abi);
- break;
+ // Create the set of structs that represent each variant.
+ let mut layout_variants = variants
+ .iter_enumerated()
+ .map(|(i, field_layouts)| {
+ let mut st = self.univariant(
+ field_layouts,
+ repr,
+ StructKind::Prefixed(min_ity.size(), prefix_align),
+ )?;
+ st.variants = Variants::Single { index: i };
+ // Find the first field we can't move later
+ // to make room for a larger discriminant.
+ for field_idx in st.fields.index_by_increasing_offset() {
+ let field = &field_layouts[FieldIdx::new(field_idx)];
+ if !field.is_1zst() {
+ start_align = start_align.min(field.align.abi);
+ break;
+ }
}
- }
- size = cmp::max(size, st.size);
- align = align.max(st.align);
- max_repr_align = max_repr_align.max(st.max_repr_align);
- unadjusted_abi_align = unadjusted_abi_align.max(st.unadjusted_abi_align);
- Some(st)
- })
- .collect::<Option<IndexVec<VariantIdx, _>>>()?;
+ size = cmp::max(size, st.size);
+ align = align.max(st.align);
+ max_repr_align = max_repr_align.max(st.max_repr_align);
+ unadjusted_abi_align = unadjusted_abi_align.max(st.unadjusted_abi_align);
+ Ok(st)
+ })
+ .collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
- // Align the maximum variant size to the largest alignment.
- size = size.align_to(align.abi);
+ // Align the maximum variant size to the largest alignment.
+ size = size.align_to(align.abi);
- // FIXME(oli-obk): deduplicate and harden these checks
- if size.bytes() >= dl.obj_size_bound() {
- return None;
- }
+ // FIXME(oli-obk): deduplicate and harden these checks
+ if size.bytes() >= dl.obj_size_bound() {
+ return Err(LayoutCalculatorError::SizeOverflow);
+ }
- let typeck_ity = Integer::from_attr(dl, repr.discr_type());
- if typeck_ity < min_ity {
- // It is a bug if Layout decided on a greater discriminant size than typeck for
- // some reason at this point (based on values discriminant can take on). Mostly
- // because this discriminant will be loaded, and then stored into variable of
- // type calculated by typeck. Consider such case (a bug): typeck decided on
- // byte-sized discriminant, but layout thinks we need a 16-bit to store all
- // discriminant values. That would be a bug, because then, in codegen, in order
- // to store this 16-bit discriminant into 8-bit sized temporary some of the
- // space necessary to represent would have to be discarded (or layout is wrong
- // on thinking it needs 16 bits)
- panic!(
- "layout decided on a larger discriminant type ({min_ity:?}) than typeck ({typeck_ity:?})"
- );
- // However, it is fine to make discr type however large (as an optimisation)
- // after this point – we’ll just truncate the value we load in codegen.
- }
+ let typeck_ity = Integer::from_attr(dl, repr.discr_type());
+ if typeck_ity < min_ity {
+ // It is a bug if Layout decided on a greater discriminant size than typeck for
+ // some reason at this point (based on values discriminant can take on). Mostly
+ // because this discriminant will be loaded, and then stored into variable of
+ // type calculated by typeck. Consider such case (a bug): typeck decided on
+ // byte-sized discriminant, but layout thinks we need a 16-bit to store all
+ // discriminant values. That would be a bug, because then, in codegen, in order
+ // to store this 16-bit discriminant into 8-bit sized temporary some of the
+ // space necessary to represent would have to be discarded (or layout is wrong
+ // on thinking it needs 16 bits)
+ panic!(
+ "layout decided on a larger discriminant type ({min_ity:?}) than typeck ({typeck_ity:?})"
+ );
+ // However, it is fine to make discr type however large (as an optimisation)
+ // after this point – we’ll just truncate the value we load in codegen.
+ }
+
+ // Check to see if we should use a different type for the
+ // discriminant. We can safely use a type with the same size
+ // as the alignment of the first field of each variant.
+ // We increase the size of the discriminant to avoid LLVM copying
+ // padding when it doesn't need to. This normally causes unaligned
+ // load/stores and excessive memcpy/memset operations. By using a
+ // bigger integer size, LLVM can be sure about its contents and
+ // won't be so conservative.
+
+ // Use the initial field alignment
+ let mut ity = if repr.c() || repr.int.is_some() {
+ min_ity
+ } else {
+ Integer::for_align(dl, start_align).unwrap_or(min_ity)
+ };
- // Check to see if we should use a different type for the
- // discriminant. We can safely use a type with the same size
- // as the alignment of the first field of each variant.
- // We increase the size of the discriminant to avoid LLVM copying
- // padding when it doesn't need to. This normally causes unaligned
- // load/stores and excessive memcpy/memset operations. By using a
- // bigger integer size, LLVM can be sure about its contents and
- // won't be so conservative.
-
- // Use the initial field alignment
- let mut ity = if repr.c() || repr.int.is_some() {
- min_ity
- } else {
- Integer::for_align(dl, start_align).unwrap_or(min_ity)
- };
-
- // If the alignment is not larger than the chosen discriminant size,
- // don't use the alignment as the final size.
- if ity <= min_ity {
- ity = min_ity;
- } else {
- // Patch up the variants' first few fields.
- let old_ity_size = min_ity.size();
- let new_ity_size = ity.size();
- for variant in &mut layout_variants {
- match variant.fields {
- FieldsShape::Arbitrary { ref mut offsets, .. } => {
- for i in offsets {
- if *i <= old_ity_size {
- assert_eq!(*i, old_ity_size);
- *i = new_ity_size;
+ // If the alignment is not larger than the chosen discriminant size,
+ // don't use the alignment as the final size.
+ if ity <= min_ity {
+ ity = min_ity;
+ } else {
+ // Patch up the variants' first few fields.
+ let old_ity_size = min_ity.size();
+ let new_ity_size = ity.size();
+ for variant in &mut layout_variants {
+ match variant.fields {
+ FieldsShape::Arbitrary { ref mut offsets, .. } => {
+ for i in offsets {
+ if *i <= old_ity_size {
+ assert_eq!(*i, old_ity_size);
+ *i = new_ity_size;
+ }
+ }
+ // We might be making the struct larger.
+ if variant.size <= old_ity_size {
+ variant.size = new_ity_size;
}
}
- // We might be making the struct larger.
- if variant.size <= old_ity_size {
- variant.size = new_ity_size;
+ FieldsShape::Primitive | FieldsShape::Array { .. } | FieldsShape::Union(..) => {
+ panic!("encountered a non-arbitrary layout during enum layout")
}
}
- FieldsShape::Primitive | FieldsShape::Array { .. } | FieldsShape::Union(..) => {
- panic!("encountered a non-arbitrary layout during enum layout")
- }
}
}
- }
- let tag_mask = ity.size().unsigned_int_max();
- let tag = Scalar::Initialized {
- value: Primitive::Int(ity, signed),
- valid_range: WrappingRange {
- start: (min as u128 & tag_mask),
- end: (max as u128 & tag_mask),
- },
- };
- let mut abi = Abi::Aggregate { sized: true };
-
- if layout_variants.iter().all(|v| v.abi.is_uninhabited()) {
- abi = Abi::Uninhabited;
- } else if tag.size(dl) == size {
- // Make sure we only use scalar layout when the enum is entirely its
- // own tag (i.e. it has no padding nor any non-ZST variant fields).
- abi = Abi::Scalar(tag);
- } else {
- // Try to use a ScalarPair for all tagged enums.
- // That's possible only if we can find a common primitive type for all variants.
- let mut common_prim = None;
- let mut common_prim_initialized_in_all_variants = true;
- for (field_layouts, layout_variant) in iter::zip(variants, &layout_variants) {
- let FieldsShape::Arbitrary { ref offsets, .. } = layout_variant.fields else {
- panic!("encountered a non-arbitrary layout during enum layout");
- };
- // We skip *all* ZST here and later check if we are good in terms of alignment.
- // This lets us handle some cases involving aligned ZST.
- let mut fields = iter::zip(field_layouts, offsets).filter(|p| !p.0.is_zst());
- let (field, offset) = match (fields.next(), fields.next()) {
- (None, None) => {
- common_prim_initialized_in_all_variants = false;
- continue;
- }
- (Some(pair), None) => pair,
- _ => {
- common_prim = None;
- break;
- }
- };
- let prim = match field.abi {
- Abi::Scalar(scalar) => {
- common_prim_initialized_in_all_variants &=
- matches!(scalar, Scalar::Initialized { .. });
- scalar.primitive()
- }
- _ => {
- common_prim = None;
- break;
- }
- };
- if let Some((old_prim, common_offset)) = common_prim {
- // All variants must be at the same offset
- if offset != common_offset {
- common_prim = None;
- break;
- }
- // This is pretty conservative. We could go fancier
- // by realising that (u8, u8) could just cohabit with
- // u16 or even u32.
- let new_prim = match (old_prim, prim) {
- // Allow all identical primitives.
- (x, y) if x == y => x,
- // Allow integers of the same size with differing signedness.
- // We arbitrarily choose the signedness of the first variant.
- (p @ Primitive::Int(x, _), Primitive::Int(y, _)) if x == y => p,
- // Allow integers mixed with pointers of the same layout.
- // We must represent this using a pointer, to avoid
- // roundtripping pointers through ptrtoint/inttoptr.
- (p @ Primitive::Pointer(_), i @ Primitive::Int(..))
- | (i @ Primitive::Int(..), p @ Primitive::Pointer(_))
- if p.size(dl) == i.size(dl) && p.align(dl) == i.align(dl) =>
- {
- p
+ let tag_mask = ity.size().unsigned_int_max();
+ let tag = Scalar::Initialized {
+ value: Primitive::Int(ity, signed),
+ valid_range: WrappingRange {
+ start: (min as u128 & tag_mask),
+ end: (max as u128 & tag_mask),
+ },
+ };
+ let mut abi = BackendRepr::Memory { sized: true };
+
+ let uninhabited = layout_variants.iter().all(|v| v.is_uninhabited());
+ if tag.size(dl) == size {
+ // Make sure we only use scalar layout when the enum is entirely its
+ // own tag (i.e. it has no padding nor any non-ZST variant fields).
+ abi = BackendRepr::Scalar(tag);
+ } else {
+ // Try to use a ScalarPair for all tagged enums.
+ // That's possible only if we can find a common primitive type for all variants.
+ let mut common_prim = None;
+ let mut common_prim_initialized_in_all_variants = true;
+ for (field_layouts, layout_variant) in iter::zip(variants, &layout_variants) {
+ let FieldsShape::Arbitrary { ref offsets, .. } = layout_variant.fields else {
+ panic!("encountered a non-arbitrary layout during enum layout");
+ };
+ // We skip *all* ZST here and later check if we are good in terms of alignment.
+ // This lets us handle some cases involving aligned ZST.
+ let mut fields = iter::zip(field_layouts, offsets).filter(|p| !p.0.is_zst());
+ let (field, offset) = match (fields.next(), fields.next()) {
+ (None, None) => {
+ common_prim_initialized_in_all_variants = false;
+ continue;
}
+ (Some(pair), None) => pair,
_ => {
common_prim = None;
break;
}
};
- // We may be updating the primitive here, for example from int->ptr.
- common_prim = Some((new_prim, common_offset));
- } else {
- common_prim = Some((prim, offset));
+ let prim = match field.backend_repr {
+ BackendRepr::Scalar(scalar) => {
+ common_prim_initialized_in_all_variants &=
+ matches!(scalar, Scalar::Initialized { .. });
+ scalar.primitive()
+ }
+ _ => {
+ common_prim = None;
+ break;
+ }
+ };
+ if let Some((old_prim, common_offset)) = common_prim {
+ // All variants must be at the same offset
+ if offset != common_offset {
+ common_prim = None;
+ break;
+ }
+ // This is pretty conservative. We could go fancier
+ // by realising that (u8, u8) could just cohabit with
+ // u16 or even u32.
+ let new_prim = match (old_prim, prim) {
+ // Allow all identical primitives.
+ (x, y) if x == y => x,
+ // Allow integers of the same size with differing signedness.
+ // We arbitrarily choose the signedness of the first variant.
+ (p @ Primitive::Int(x, _), Primitive::Int(y, _)) if x == y => p,
+ // Allow integers mixed with pointers of the same layout.
+ // We must represent this using a pointer, to avoid
+ // roundtripping pointers through ptrtoint/inttoptr.
+ (p @ Primitive::Pointer(_), i @ Primitive::Int(..))
+ | (i @ Primitive::Int(..), p @ Primitive::Pointer(_))
+ if p.size(dl) == i.size(dl) && p.align(dl) == i.align(dl) =>
+ {
+ p
+ }
+ _ => {
+ common_prim = None;
+ break;
+ }
+ };
+ // We may be updating the primitive here, for example from int->ptr.
+ common_prim = Some((new_prim, common_offset));
+ } else {
+ common_prim = Some((prim, offset));
+ }
}
- }
- if let Some((prim, offset)) = common_prim {
- let prim_scalar = if common_prim_initialized_in_all_variants {
- let size = prim.size(dl);
- assert!(size.bits() <= 128);
- Scalar::Initialized { value: prim, valid_range: WrappingRange::full(size) }
- } else {
- // Common prim might be uninit.
- Scalar::Union { value: prim }
- };
- let pair = layout_calc.scalar_pair::<FieldIdx, VariantIdx>(tag, prim_scalar);
- let pair_offsets = match pair.fields {
- FieldsShape::Arbitrary { ref offsets, ref memory_index } => {
- assert_eq!(memory_index.raw, [0, 1]);
- offsets
+ if let Some((prim, offset)) = common_prim {
+ let prim_scalar = if common_prim_initialized_in_all_variants {
+ let size = prim.size(dl);
+ assert!(size.bits() <= 128);
+ Scalar::Initialized { value: prim, valid_range: WrappingRange::full(size) }
+ } else {
+ // Common prim might be uninit.
+ Scalar::Union { value: prim }
+ };
+ let pair =
+ LayoutData::<FieldIdx, VariantIdx>::scalar_pair(&self.cx, tag, prim_scalar);
+ let pair_offsets = match pair.fields {
+ FieldsShape::Arbitrary { ref offsets, ref memory_index } => {
+ assert_eq!(memory_index.raw, [0, 1]);
+ offsets
+ }
+ _ => panic!("encountered a non-arbitrary layout during enum layout"),
+ };
+ if pair_offsets[FieldIdx::new(0)] == Size::ZERO
+ && pair_offsets[FieldIdx::new(1)] == *offset
+ && align == pair.align
+ && size == pair.size
+ {
+ // We can use `ScalarPair` only when it matches our
+ // already computed layout (including `#[repr(C)]`).
+ abi = pair.backend_repr;
}
- _ => panic!("encountered a non-arbitrary layout during enum layout"),
- };
- if pair_offsets[FieldIdx::new(0)] == Size::ZERO
- && pair_offsets[FieldIdx::new(1)] == *offset
- && align == pair.align
- && size == pair.size
- {
- // We can use `ScalarPair` only when it matches our
- // already computed layout (including `#[repr(C)]`).
- abi = pair.abi;
}
}
- }
- // If we pick a "clever" (by-value) ABI, we might have to adjust the ABI of the
- // variants to ensure they are consistent. This is because a downcast is
- // semantically a NOP, and thus should not affect layout.
- if matches!(abi, Abi::Scalar(..) | Abi::ScalarPair(..)) {
- for variant in &mut layout_variants {
- // We only do this for variants with fields; the others are not accessed anyway.
- // Also do not overwrite any already existing "clever" ABIs.
- if variant.fields.count() > 0 && matches!(variant.abi, Abi::Aggregate { .. }) {
- variant.abi = abi;
- // Also need to bump up the size and alignment, so that the entire value fits
- // in here.
- variant.size = cmp::max(variant.size, size);
- variant.align.abi = cmp::max(variant.align.abi, align.abi);
+ // If we pick a "clever" (by-value) ABI, we might have to adjust the ABI of the
+ // variants to ensure they are consistent. This is because a downcast is
+ // semantically a NOP, and thus should not affect layout.
+ if matches!(abi, BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..)) {
+ for variant in &mut layout_variants {
+ // We only do this for variants with fields; the others are not accessed anyway.
+ // Also do not overwrite any already existing "clever" ABIs.
+ if variant.fields.count() > 0
+ && matches!(variant.backend_repr, BackendRepr::Memory { .. })
+ {
+ variant.backend_repr = abi;
+ // Also need to bump up the size and alignment, so that the entire value fits
+ // in here.
+ variant.size = cmp::max(variant.size, size);
+ variant.align.abi = cmp::max(variant.align.abi, align.abi);
+ }
}
}
- }
- let largest_niche = Niche::from_scalar(dl, Size::ZERO, tag);
-
- let tagged_layout = LayoutS {
- variants: Variants::Multiple {
- tag,
- tag_encoding: TagEncoding::Direct,
- tag_field: 0,
- variants: IndexVec::new(),
- },
- fields: FieldsShape::Arbitrary { offsets: [Size::ZERO].into(), memory_index: [0].into() },
- largest_niche,
- abi,
- align,
- size,
- max_repr_align,
- unadjusted_abi_align,
- };
-
- let tagged_layout = TmpLayout { layout: tagged_layout, variants: layout_variants };
-
- let mut best_layout = match (tagged_layout, niche_filling_layout) {
- (tl, Some(nl)) => {
- // Pick the smaller layout; otherwise,
- // pick the layout with the larger niche; otherwise,
- // pick tagged as it has simpler codegen.
- use cmp::Ordering::*;
- let niche_size = |tmp_l: &TmpLayout<FieldIdx, VariantIdx>| {
- tmp_l.layout.largest_niche.map_or(0, |n| n.available(dl))
- };
- match (tl.layout.size.cmp(&nl.layout.size), niche_size(&tl).cmp(&niche_size(&nl))) {
- (Greater, _) => nl,
- (Equal, Less) => nl,
- _ => tl,
- }
- }
- (tl, None) => tl,
- };
+ let largest_niche = Niche::from_scalar(dl, Size::ZERO, tag);
- // Now we can intern the variant layouts and store them in the enum layout.
- best_layout.layout.variants = match best_layout.layout.variants {
- Variants::Multiple { tag, tag_encoding, tag_field, .. } => {
- Variants::Multiple { tag, tag_encoding, tag_field, variants: best_layout.variants }
- }
- Variants::Single { .. } => {
- panic!("encountered a single-variant enum during multi-variant layout")
- }
- };
- Some(best_layout.layout)
-}
+ let combined_seed = layout_variants
+ .iter()
+ .map(|v| v.randomization_seed)
+ .fold(repr.field_shuffle_seed, |acc, seed| acc.wrapping_add(seed));
-/// Determines towards which end of a struct layout optimizations will try to place the best niches.
-enum NicheBias {
- Start,
- End,
-}
+ let tagged_layout = LayoutData {
+ variants: Variants::Multiple {
+ tag,
+ tag_encoding: TagEncoding::Direct,
+ tag_field: 0,
+ variants: IndexVec::new(),
+ },
+ fields: FieldsShape::Arbitrary {
+ offsets: [Size::ZERO].into(),
+ memory_index: [0].into(),
+ },
+ largest_niche,
+ uninhabited,
+ backend_repr: abi,
+ align,
+ size,
+ max_repr_align,
+ unadjusted_abi_align,
+ randomization_seed: combined_seed,
+ };
-fn univariant<
- 'a,
- FieldIdx: Idx,
- VariantIdx: Idx,
- F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
->(
- this: &(impl LayoutCalculator + ?Sized),
- dl: &TargetDataLayout,
- fields: &IndexSlice<FieldIdx, F>,
- repr: &ReprOptions,
- kind: StructKind,
- niche_bias: NicheBias,
-) -> Option<LayoutS<FieldIdx, VariantIdx>> {
- let pack = repr.pack;
- let mut align = if pack.is_some() { dl.i8_align } else { dl.aggregate_align };
- let mut max_repr_align = repr.align;
- let mut inverse_memory_index: IndexVec<u32, FieldIdx> = fields.indices().collect();
- let optimize = !repr.inhibit_struct_field_reordering();
- if optimize && fields.len() > 1 {
+ let tagged_layout = TmpLayout { layout: tagged_layout, variants: layout_variants };
+
+ let mut best_layout = match (tagged_layout, niche_filling_layout) {
+ (tl, Some(nl)) => {
+ // Pick the smaller layout; otherwise,
+ // pick the layout with the larger niche; otherwise,
+ // pick tagged as it has simpler codegen.
+ use cmp::Ordering::*;
+ let niche_size = |tmp_l: &TmpLayout<FieldIdx, VariantIdx>| {
+ tmp_l.layout.largest_niche.map_or(0, |n| n.available(dl))
+ };
+ match (tl.layout.size.cmp(&nl.layout.size), niche_size(&tl).cmp(&niche_size(&nl))) {
+ (Greater, _) => nl,
+ (Equal, Less) => nl,
+ _ => tl,
+ }
+ }
+ (tl, None) => tl,
+ };
+
+ // Now we can intern the variant layouts and store them in the enum layout.
+ best_layout.layout.variants = match best_layout.layout.variants {
+ Variants::Multiple { tag, tag_encoding, tag_field, .. } => {
+ Variants::Multiple { tag, tag_encoding, tag_field, variants: best_layout.variants }
+ }
+ Variants::Single { .. } | Variants::Empty => {
+ panic!("encountered a single-variant or empty enum during multi-variant layout")
+ }
+ };
+ Ok(best_layout.layout)
+ }
+
+ fn univariant_biased<
+ 'a,
+ FieldIdx: Idx,
+ VariantIdx: Idx,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug + Copy,
+ >(
+ &self,
+ fields: &IndexSlice<FieldIdx, F>,
+ repr: &ReprOptions,
+ kind: StructKind,
+ niche_bias: NicheBias,
+ ) -> LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ let dl = self.cx.data_layout();
+ let pack = repr.pack;
+ let mut align = if pack.is_some() { dl.i8_align } else { dl.aggregate_align };
+ let mut max_repr_align = repr.align;
+ let mut inverse_memory_index: IndexVec<u32, FieldIdx> = fields.indices().collect();
+ let optimize_field_order = !repr.inhibit_struct_field_reordering();
let end = if let StructKind::MaybeUnsized = kind { fields.len() - 1 } else { fields.len() };
let optimizing = &mut inverse_memory_index.raw[..end];
let fields_excluding_tail = &fields.raw[..end];
+ // unsizable tail fields are excluded so that we use the same seed for the sized and unsized layouts.
+ let field_seed = fields_excluding_tail
+ .iter()
+ .fold(Hash64::ZERO, |acc, f| acc.wrapping_add(f.randomization_seed));
+
+ if optimize_field_order && fields.len() > 1 {
+ // If `-Z randomize-layout` was enabled for the type definition we can shuffle
+ // the field ordering to try and catch some code making assumptions about layouts
+ // we don't guarantee.
+ if repr.can_randomize_type_layout() && cfg!(feature = "randomize") {
+ #[cfg(feature = "randomize")]
+ {
+ use rand::SeedableRng;
+ use rand::seq::SliceRandom;
+ // `ReprOptions.field_shuffle_seed` is a deterministic seed we can use to randomize field
+ // ordering.
+ let mut rng = rand_xoshiro::Xoshiro128StarStar::seed_from_u64(
+ field_seed.wrapping_add(repr.field_shuffle_seed).as_u64(),
+ );
+
+ // Shuffle the ordering of the fields.
+ optimizing.shuffle(&mut rng);
+ }
+ // Otherwise we just leave things alone and actually optimize the type's fields
+ } else {
+ // To allow unsizing `&Foo<Type>` -> `&Foo<dyn Trait>`, the layout of the struct must
+ // not depend on the layout of the tail.
+ let max_field_align =
+ fields_excluding_tail.iter().map(|f| f.align.abi.bytes()).max().unwrap_or(1);
+ let largest_niche_size = fields_excluding_tail
+ .iter()
+ .filter_map(|f| f.largest_niche)
+ .map(|n| n.available(dl))
+ .max()
+ .unwrap_or(0);
+
+ // Calculates a sort key to group fields by their alignment or possibly some
+ // size-derived pseudo-alignment.
+ let alignment_group_key = |layout: &F| {
+ // The two branches here return values that cannot be meaningfully compared with
+ // each other. However, we know that consistently for all executions of
+ // `alignment_group_key`, one or the other branch will be taken, so this is okay.
+ if let Some(pack) = pack {
+ // Return the packed alignment in bytes.
+ layout.align.abi.min(pack).bytes()
+ } else {
+ // Returns `log2(effective-align)`. The calculation assumes that size is an
+ // integer multiple of align, except for ZSTs.
+ let align = layout.align.abi.bytes();
+ let size = layout.size.bytes();
+ let niche_size = layout.largest_niche.map(|n| n.available(dl)).unwrap_or(0);
+ // Group [u8; 4] with align-4 or [u8; 6] with align-2 fields.
+ let size_as_align = align.max(size).trailing_zeros();
+ let size_as_align = if largest_niche_size > 0 {
+ match niche_bias {
+ // Given `A(u8, [u8; 16])` and `B(bool, [u8; 16])` we want to bump the
+ // array to the front in the first case (for aligned loads) but keep
+ // the bool in front in the second case for its niches.
+ NicheBias::Start => {
+ max_field_align.trailing_zeros().min(size_as_align)
+ }
+ // When moving niches towards the end of the struct then for
+ // A((u8, u8, u8, bool), (u8, bool, u8)) we want to keep the first tuple
+ // in the align-1 group because its bool can be moved closer to the end.
+ NicheBias::End if niche_size == largest_niche_size => {
+ align.trailing_zeros()
+ }
+ NicheBias::End => size_as_align,
+ }
+ } else {
+ size_as_align
+ };
+ size_as_align as u64
+ }
+ };
+
+ match kind {
+ StructKind::AlwaysSized | StructKind::MaybeUnsized => {
+ // Currently `LayoutS` only exposes a single niche so sorting is usually
+ // sufficient to get one niche into the preferred position. If it ever
+ // supported multiple niches then a more advanced pick-and-pack approach could
+ // provide better results. But even for the single-niche cache it's not
+ // optimal. E.g. for A(u32, (bool, u8), u16) it would be possible to move the
+ // bool to the front but it would require packing the tuple together with the
+ // u16 to build a 4-byte group so that the u32 can be placed after it without
+ // padding. This kind of packing can't be achieved by sorting.
+ optimizing.sort_by_key(|&x| {
+ let f = &fields[x];
+ let field_size = f.size.bytes();
+ let niche_size = f.largest_niche.map_or(0, |n| n.available(dl));
+ let niche_size_key = match niche_bias {
+ // large niche first
+ NicheBias::Start => !niche_size,
+ // large niche last
+ NicheBias::End => niche_size,
+ };
+ let inner_niche_offset_key = match niche_bias {
+ NicheBias::Start => f.largest_niche.map_or(0, |n| n.offset.bytes()),
+ NicheBias::End => f.largest_niche.map_or(0, |n| {
+ !(field_size - n.value.size(dl).bytes() - n.offset.bytes())
+ }),
+ };
+
+ (
+ // Then place largest alignments first.
+ cmp::Reverse(alignment_group_key(f)),
+ // Then prioritize niche placement within alignment group according to
+ // `niche_bias_start`.
+ niche_size_key,
+ // Then among fields with equally-sized niches prefer the ones
+ // closer to the start/end of the field.
+ inner_niche_offset_key,
+ )
+ });
+ }
+
+ StructKind::Prefixed(..) => {
+ // Sort in ascending alignment so that the layout stays optimal
+ // regardless of the prefix.
+ // And put the largest niche in an alignment group at the end
+ // so it can be used as discriminant in jagged enums
+ optimizing.sort_by_key(|&x| {
+ let f = &fields[x];
+ let niche_size = f.largest_niche.map_or(0, |n| n.available(dl));
+ (alignment_group_key(f), niche_size)
+ });
+ }
+ }
- // If `-Z randomize-layout` was enabled for the type definition we can shuffle
- // the field ordering to try and catch some code making assumptions about layouts
- // we don't guarantee.
- if repr.can_randomize_type_layout() && cfg!(feature = "randomize") {
- #[cfg(feature = "randomize")]
- {
- use rand::{seq::SliceRandom, SeedableRng};
- // `ReprOptions.field_shuffle_seed` is a deterministic seed we can use to randomize field
- // ordering.
- let mut rng =
- rand_xoshiro::Xoshiro128StarStar::seed_from_u64(repr.field_shuffle_seed);
-
- // Shuffle the ordering of the fields.
- optimizing.shuffle(&mut rng);
+ // FIXME(Kixiron): We can always shuffle fields within a given alignment class
+ // regardless of the status of `-Z randomize-layout`
}
- // Otherwise we just leave things alone and actually optimize the type's fields
- } else {
- // To allow unsizing `&Foo<Type>` -> `&Foo<dyn Trait>`, the layout of the struct must
- // not depend on the layout of the tail.
- let max_field_align =
- fields_excluding_tail.iter().map(|f| f.align.abi.bytes()).max().unwrap_or(1);
- let largest_niche_size = fields_excluding_tail
- .iter()
- .filter_map(|f| f.largest_niche)
- .map(|n| n.available(dl))
- .max()
- .unwrap_or(0);
-
- // Calculates a sort key to group fields by their alignment or possibly some
- // size-derived pseudo-alignment.
- let alignment_group_key = |layout: &F| {
- // The two branches here return values that cannot be meaningfully compared with
- // each other. However, we know that consistently for all executions of
- // `alignment_group_key`, one or the other branch will be taken, so this is okay.
- if let Some(pack) = pack {
- // Return the packed alignment in bytes.
- layout.align.abi.min(pack).bytes()
+ }
+ // inverse_memory_index holds field indices by increasing memory offset.
+ // That is, if field 5 has offset 0, the first element of inverse_memory_index is 5.
+ // We now write field offsets to the corresponding offset slot;
+ // field 5 with offset 0 puts 0 in offsets[5].
+ // At the bottom of this function, we invert `inverse_memory_index` to
+ // produce `memory_index` (see `invert_mapping`).
+ let mut unsized_field = None::<&F>;
+ let mut offsets = IndexVec::from_elem(Size::ZERO, fields);
+ let mut offset = Size::ZERO;
+ let mut largest_niche = None;
+ let mut largest_niche_available = 0;
+ if let StructKind::Prefixed(prefix_size, prefix_align) = kind {
+ let prefix_align =
+ if let Some(pack) = pack { prefix_align.min(pack) } else { prefix_align };
+ align = align.max(AbiAndPrefAlign::new(prefix_align));
+ offset = prefix_size.align_to(prefix_align);
+ }
+ for &i in &inverse_memory_index {
+ let field = &fields[i];
+ if let Some(unsized_field) = unsized_field {
+ return Err(LayoutCalculatorError::UnexpectedUnsized(*unsized_field));
+ }
+
+ if field.is_unsized() {
+ if let StructKind::MaybeUnsized = kind {
+ unsized_field = Some(field);
} else {
- // Returns `log2(effective-align)`. The calculation assumes that size is an
- // integer multiple of align, except for ZSTs.
- let align = layout.align.abi.bytes();
- let size = layout.size.bytes();
- let niche_size = layout.largest_niche.map(|n| n.available(dl)).unwrap_or(0);
- // Group [u8; 4] with align-4 or [u8; 6] with align-2 fields.
- let size_as_align = align.max(size).trailing_zeros();
- let size_as_align = if largest_niche_size > 0 {
- match niche_bias {
- // Given `A(u8, [u8; 16])` and `B(bool, [u8; 16])` we want to bump the
- // array to the front in the first case (for aligned loads) but keep
- // the bool in front in the second case for its niches.
- NicheBias::Start => max_field_align.trailing_zeros().min(size_as_align),
- // When moving niches towards the end of the struct then for
- // A((u8, u8, u8, bool), (u8, bool, u8)) we want to keep the first tuple
- // in the align-1 group because its bool can be moved closer to the end.
- NicheBias::End if niche_size == largest_niche_size => {
- align.trailing_zeros()
- }
- NicheBias::End => size_as_align,
- }
- } else {
- size_as_align
- };
- size_as_align as u64
+ return Err(LayoutCalculatorError::UnexpectedUnsized(*field));
}
- };
+ }
- match kind {
- StructKind::AlwaysSized | StructKind::MaybeUnsized => {
- // Currently `LayoutS` only exposes a single niche so sorting is usually
- // sufficient to get one niche into the preferred position. If it ever
- // supported multiple niches then a more advanced pick-and-pack approach could
- // provide better results. But even for the single-niche cache it's not
- // optimal. E.g. for A(u32, (bool, u8), u16) it would be possible to move the
- // bool to the front but it would require packing the tuple together with the
- // u16 to build a 4-byte group so that the u32 can be placed after it without
- // padding. This kind of packing can't be achieved by sorting.
- optimizing.sort_by_key(|&x| {
- let f = &fields[x];
- let field_size = f.size.bytes();
- let niche_size = f.largest_niche.map_or(0, |n| n.available(dl));
- let niche_size_key = match niche_bias {
- // large niche first
- NicheBias::Start => !niche_size,
- // large niche last
- NicheBias::End => niche_size,
- };
- let inner_niche_offset_key = match niche_bias {
- NicheBias::Start => f.largest_niche.map_or(0, |n| n.offset.bytes()),
- NicheBias::End => f.largest_niche.map_or(0, |n| {
- !(field_size - n.value.size(dl).bytes() - n.offset.bytes())
- }),
- };
+ // Invariant: offset < dl.obj_size_bound() <= 1<<61
+ let field_align = if let Some(pack) = pack {
+ field.align.min(AbiAndPrefAlign::new(pack))
+ } else {
+ field.align
+ };
+ offset = offset.align_to(field_align.abi);
+ align = align.max(field_align);
+ max_repr_align = max_repr_align.max(field.max_repr_align);
- (
- // Then place largest alignments first.
- cmp::Reverse(alignment_group_key(f)),
- // Then prioritize niche placement within alignment group according to
- // `niche_bias_start`.
- niche_size_key,
- // Then among fields with equally-sized niches prefer the ones
- // closer to the start/end of the field.
- inner_niche_offset_key,
- )
- });
- }
+ debug!("univariant offset: {:?} field: {:#?}", offset, field);
+ offsets[i] = offset;
- StructKind::Prefixed(..) => {
- // Sort in ascending alignment so that the layout stays optimal
- // regardless of the prefix.
- // And put the largest niche in an alignment group at the end
- // so it can be used as discriminant in jagged enums
- optimizing.sort_by_key(|&x| {
- let f = &fields[x];
- let niche_size = f.largest_niche.map_or(0, |n| n.available(dl));
- (alignment_group_key(f), niche_size)
- });
+ if let Some(mut niche) = field.largest_niche {
+ let available = niche.available(dl);
+ // Pick up larger niches.
+ let prefer_new_niche = match niche_bias {
+ NicheBias::Start => available > largest_niche_available,
+ // if there are several niches of the same size then pick the last one
+ NicheBias::End => available >= largest_niche_available,
+ };
+ if prefer_new_niche {
+ largest_niche_available = available;
+ niche.offset += offset;
+ largest_niche = Some(niche);
}
}
- // FIXME(Kixiron): We can always shuffle fields within a given alignment class
- // regardless of the status of `-Z randomize-layout`
- }
- }
- // inverse_memory_index holds field indices by increasing memory offset.
- // That is, if field 5 has offset 0, the first element of inverse_memory_index is 5.
- // We now write field offsets to the corresponding offset slot;
- // field 5 with offset 0 puts 0 in offsets[5].
- // At the bottom of this function, we invert `inverse_memory_index` to
- // produce `memory_index` (see `invert_mapping`).
- let mut sized = true;
- let mut offsets = IndexVec::from_elem(Size::ZERO, fields);
- let mut offset = Size::ZERO;
- let mut largest_niche = None;
- let mut largest_niche_available = 0;
- if let StructKind::Prefixed(prefix_size, prefix_align) = kind {
- let prefix_align =
- if let Some(pack) = pack { prefix_align.min(pack) } else { prefix_align };
- align = align.max(AbiAndPrefAlign::new(prefix_align));
- offset = prefix_size.align_to(prefix_align);
- }
- for &i in &inverse_memory_index {
- let field = &fields[i];
- if !sized {
- this.delayed_bug(format!(
- "univariant: field #{} comes after unsized field",
- offsets.len(),
- ));
+ offset =
+ offset.checked_add(field.size, dl).ok_or(LayoutCalculatorError::SizeOverflow)?;
}
- if field.is_unsized() {
- sized = false;
+ // The unadjusted ABI alignment does not include repr(align), but does include repr(pack).
+ // See documentation on `LayoutS::unadjusted_abi_align`.
+ let unadjusted_abi_align = align.abi;
+ if let Some(repr_align) = repr.align {
+ align = align.max(AbiAndPrefAlign::new(repr_align));
}
+ // `align` must not be modified after this point, or `unadjusted_abi_align` could be inaccurate.
+ let align = align;
- // Invariant: offset < dl.obj_size_bound() <= 1<<61
- let field_align = if let Some(pack) = pack {
- field.align.min(AbiAndPrefAlign::new(pack))
+ debug!("univariant min_size: {:?}", offset);
+ let min_size = offset;
+ // As stated above, inverse_memory_index holds field indices by increasing offset.
+ // This makes it an already-sorted view of the offsets vec.
+ // To invert it, consider:
+ // If field 5 has offset 0, offsets[0] is 5, and memory_index[5] should be 0.
+ // Field 5 would be the first element, so memory_index is i:
+ // Note: if we didn't optimize, it's already right.
+ let memory_index = if optimize_field_order {
+ inverse_memory_index.invert_bijective_mapping()
} else {
- field.align
+ debug_assert!(inverse_memory_index.iter().copied().eq(fields.indices()));
+ inverse_memory_index.into_iter().map(|it| it.index() as u32).collect()
};
- offset = offset.align_to(field_align.abi);
- align = align.max(field_align);
- max_repr_align = max_repr_align.max(field.max_repr_align);
-
- debug!("univariant offset: {:?} field: {:#?}", offset, field);
- offsets[i] = offset;
-
- if let Some(mut niche) = field.largest_niche {
- let available = niche.available(dl);
- // Pick up larger niches.
- let prefer_new_niche = match niche_bias {
- NicheBias::Start => available > largest_niche_available,
- // if there are several niches of the same size then pick the last one
- NicheBias::End => available >= largest_niche_available,
- };
- if prefer_new_niche {
- largest_niche_available = available;
- niche.offset += offset;
- largest_niche = Some(niche);
- }
+ let size = min_size.align_to(align.abi);
+ // FIXME(oli-obk): deduplicate and harden these checks
+ if size.bytes() >= dl.obj_size_bound() {
+ return Err(LayoutCalculatorError::SizeOverflow);
}
+ let mut layout_of_single_non_zst_field = None;
+ let sized = unsized_field.is_none();
+ let mut abi = BackendRepr::Memory { sized };
- offset = offset.checked_add(field.size, dl)?;
- }
+ let optimize_abi = !repr.inhibit_newtype_abi_optimization();
- // The unadjusted ABI alignment does not include repr(align), but does include repr(pack).
- // See documentation on `LayoutS::unadjusted_abi_align`.
- let unadjusted_abi_align = align.abi;
- if let Some(repr_align) = repr.align {
- align = align.max(AbiAndPrefAlign::new(repr_align));
- }
- // `align` must not be modified after this point, or `unadjusted_abi_align` could be inaccurate.
- let align = align;
-
- debug!("univariant min_size: {:?}", offset);
- let min_size = offset;
- // As stated above, inverse_memory_index holds field indices by increasing offset.
- // This makes it an already-sorted view of the offsets vec.
- // To invert it, consider:
- // If field 5 has offset 0, offsets[0] is 5, and memory_index[5] should be 0.
- // Field 5 would be the first element, so memory_index is i:
- // Note: if we didn't optimize, it's already right.
- let memory_index = if optimize {
- inverse_memory_index.invert_bijective_mapping()
- } else {
- debug_assert!(inverse_memory_index.iter().copied().eq(fields.indices()));
- inverse_memory_index.into_iter().map(|it| it.index() as u32).collect()
- };
- let size = min_size.align_to(align.abi);
- // FIXME(oli-obk): deduplicate and harden these checks
- if size.bytes() >= dl.obj_size_bound() {
- return None;
- }
- let mut layout_of_single_non_zst_field = None;
- let mut abi = Abi::Aggregate { sized };
- // Try to make this a Scalar/ScalarPair.
- if sized && size.bytes() > 0 {
- // We skip *all* ZST here and later check if we are good in terms of alignment.
- // This lets us handle some cases involving aligned ZST.
- let mut non_zst_fields = fields.iter_enumerated().filter(|&(_, f)| !f.is_zst());
-
- match (non_zst_fields.next(), non_zst_fields.next(), non_zst_fields.next()) {
- // We have exactly one non-ZST field.
- (Some((i, field)), None, None) => {
- layout_of_single_non_zst_field = Some(field);
-
- // Field fills the struct and it has a scalar or scalar pair ABI.
- if offsets[i].bytes() == 0 && align.abi == field.align.abi && size == field.size {
- match field.abi {
- // For plain scalars, or vectors of them, we can't unpack
- // newtypes for `#[repr(C)]`, as that affects C ABIs.
- Abi::Scalar(_) | Abi::Vector { .. } if optimize => {
- abi = field.abi;
- }
- // But scalar pairs are Rust-specific and get
- // treated as aggregates by C ABIs anyway.
- Abi::ScalarPair(..) => {
- abi = field.abi;
+ // Try to make this a Scalar/ScalarPair.
+ if sized && size.bytes() > 0 {
+ // We skip *all* ZST here and later check if we are good in terms of alignment.
+ // This lets us handle some cases involving aligned ZST.
+ let mut non_zst_fields = fields.iter_enumerated().filter(|&(_, f)| !f.is_zst());
+
+ match (non_zst_fields.next(), non_zst_fields.next(), non_zst_fields.next()) {
+ // We have exactly one non-ZST field.
+ (Some((i, field)), None, None) => {
+ layout_of_single_non_zst_field = Some(field);
+
+ // Field fills the struct and it has a scalar or scalar pair ABI.
+ if offsets[i].bytes() == 0 && align.abi == field.align.abi && size == field.size
+ {
+ match field.backend_repr {
+ // For plain scalars, or vectors of them, we can't unpack
+ // newtypes for `#[repr(C)]`, as that affects C ABIs.
+ BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. }
+ if optimize_abi =>
+ {
+ abi = field.backend_repr;
+ }
+ // But scalar pairs are Rust-specific and get
+ // treated as aggregates by C ABIs anyway.
+ BackendRepr::ScalarPair(..) => {
+ abi = field.backend_repr;
+ }
+ _ => {}
}
- _ => {}
}
}
- }
- // Two non-ZST fields, and they're both scalars.
- (Some((i, a)), Some((j, b)), None) => {
- match (a.abi, b.abi) {
- (Abi::Scalar(a), Abi::Scalar(b)) => {
- // Order by the memory placement, not source order.
- let ((i, a), (j, b)) = if offsets[i] < offsets[j] {
- ((i, a), (j, b))
- } else {
- ((j, b), (i, a))
- };
- let pair = this.scalar_pair::<FieldIdx, VariantIdx>(a, b);
- let pair_offsets = match pair.fields {
- FieldsShape::Arbitrary { ref offsets, ref memory_index } => {
- assert_eq!(memory_index.raw, [0, 1]);
- offsets
- }
- FieldsShape::Primitive
- | FieldsShape::Array { .. }
- | FieldsShape::Union(..) => {
- panic!("encountered a non-arbitrary layout during enum layout")
+ // Two non-ZST fields, and they're both scalars.
+ (Some((i, a)), Some((j, b)), None) => {
+ match (a.backend_repr, b.backend_repr) {
+ (BackendRepr::Scalar(a), BackendRepr::Scalar(b)) => {
+ // Order by the memory placement, not source order.
+ let ((i, a), (j, b)) = if offsets[i] < offsets[j] {
+ ((i, a), (j, b))
+ } else {
+ ((j, b), (i, a))
+ };
+ let pair =
+ LayoutData::<FieldIdx, VariantIdx>::scalar_pair(&self.cx, a, b);
+ let pair_offsets = match pair.fields {
+ FieldsShape::Arbitrary { ref offsets, ref memory_index } => {
+ assert_eq!(memory_index.raw, [0, 1]);
+ offsets
+ }
+ FieldsShape::Primitive
+ | FieldsShape::Array { .. }
+ | FieldsShape::Union(..) => {
+ panic!("encountered a non-arbitrary layout during enum layout")
+ }
+ };
+ if offsets[i] == pair_offsets[FieldIdx::new(0)]
+ && offsets[j] == pair_offsets[FieldIdx::new(1)]
+ && align == pair.align
+ && size == pair.size
+ {
+ // We can use `ScalarPair` only when it matches our
+ // already computed layout (including `#[repr(C)]`).
+ abi = pair.backend_repr;
}
- };
- if offsets[i] == pair_offsets[FieldIdx::new(0)]
- && offsets[j] == pair_offsets[FieldIdx::new(1)]
- && align == pair.align
- && size == pair.size
- {
- // We can use `ScalarPair` only when it matches our
- // already computed layout (including `#[repr(C)]`).
- abi = pair.abi;
}
+ _ => {}
}
- _ => {}
}
- }
- _ => {}
+ _ => {}
+ }
}
- }
- if fields.iter().any(|f| f.abi.is_uninhabited()) {
- abi = Abi::Uninhabited;
+ let uninhabited = fields.iter().any(|f| f.is_uninhabited());
+
+ let unadjusted_abi_align = if repr.transparent() {
+ match layout_of_single_non_zst_field {
+ Some(l) => l.unadjusted_abi_align,
+ None => {
+ // `repr(transparent)` with all ZST fields.
+ align.abi
+ }
+ }
+ } else {
+ unadjusted_abi_align
+ };
+
+ let seed = field_seed.wrapping_add(repr.field_shuffle_seed);
+
+ Ok(LayoutData {
+ variants: Variants::Single { index: VariantIdx::new(0) },
+ fields: FieldsShape::Arbitrary { offsets, memory_index },
+ backend_repr: abi,
+ largest_niche,
+ uninhabited,
+ align,
+ size,
+ max_repr_align,
+ unadjusted_abi_align,
+ randomization_seed: seed,
+ })
}
- let unadjusted_abi_align = if repr.transparent() {
- match layout_of_single_non_zst_field {
- Some(l) => l.unadjusted_abi_align,
- None => {
- // `repr(transparent)` with all ZST fields.
- align.abi
+ fn format_field_niches<
+ 'a,
+ FieldIdx: Idx,
+ VariantIdx: Idx,
+ F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + fmt::Debug,
+ >(
+ &self,
+ layout: &LayoutData<FieldIdx, VariantIdx>,
+ fields: &IndexSlice<FieldIdx, F>,
+ ) -> String {
+ let dl = self.cx.data_layout();
+ let mut s = String::new();
+ for i in layout.fields.index_by_increasing_offset() {
+ let offset = layout.fields.offset(i);
+ let f = &fields[FieldIdx::new(i)];
+ write!(s, "[o{}a{}s{}", offset.bytes(), f.align.abi.bytes(), f.size.bytes()).unwrap();
+ if let Some(n) = f.largest_niche {
+ write!(
+ s,
+ " n{}b{}s{}",
+ n.offset.bytes(),
+ n.available(dl).ilog2(),
+ n.value.size(dl).bytes()
+ )
+ .unwrap();
}
+ write!(s, "] ").unwrap();
}
- } else {
- unadjusted_abi_align
- };
-
- Some(LayoutS {
- variants: Variants::Single { index: VariantIdx::new(0) },
- fields: FieldsShape::Arbitrary { offsets, memory_index },
- abi,
- largest_niche,
- align,
- size,
- max_repr_align,
- unadjusted_abi_align,
- })
-}
-
-fn format_field_niches<
- 'a,
- FieldIdx: Idx,
- VariantIdx: Idx,
- F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
->(
- layout: &LayoutS<FieldIdx, VariantIdx>,
- fields: &IndexSlice<FieldIdx, F>,
- dl: &TargetDataLayout,
-) -> String {
- let mut s = String::new();
- for i in layout.fields.index_by_increasing_offset() {
- let offset = layout.fields.offset(i);
- let f = &fields[FieldIdx::new(i)];
- write!(s, "[o{}a{}s{}", offset.bytes(), f.align.abi.bytes(), f.size.bytes()).unwrap();
- if let Some(n) = f.largest_niche {
- write!(
- s,
- " n{}b{}s{}",
- n.offset.bytes(),
- n.available(dl).ilog2(),
- n.value.size(dl).bytes()
- )
- .unwrap();
- }
- write!(s, "] ").unwrap();
+ s
}
- s
}
diff --git a/compiler/rustc_abi/src/layout/coroutine.rs b/compiler/rustc_abi/src/layout/coroutine.rs
new file mode 100644
index 0000000000000..27e704d538c83
--- /dev/null
+++ b/compiler/rustc_abi/src/layout/coroutine.rs
@@ -0,0 +1,320 @@
+//! Coroutine layout logic.
+//!
+//! When laying out coroutines, we divide our saved local fields into two
+//! categories: overlap-eligible and overlap-ineligible.
+//!
+//! Those fields which are ineligible for overlap go in a "prefix" at the
+//! beginning of the layout, and always have space reserved for them.
+//!
+//! Overlap-eligible fields are only assigned to one variant, so we lay
+//! those fields out for each variant and put them right after the
+//! prefix.
+//!
+//! Finally, in the layout details, we point to the fields from the
+//! variants they are assigned to. It is possible for some fields to be
+//! included in multiple variants. No field ever "moves around" in the
+//! layout; its offset is always the same.
+//!
+//! Also included in the layout are the upvars and the discriminant.
+//! These are included as fields on the "outer" layout; they are not part
+//! of any variant.
+
+use std::iter;
+
+use rustc_index::bit_set::{BitMatrix, DenseBitSet};
+use rustc_index::{Idx, IndexSlice, IndexVec};
+use tracing::{debug, trace};
+
+use crate::{
+ BackendRepr, FieldsShape, HasDataLayout, Integer, LayoutData, Primitive, ReprOptions, Scalar,
+ StructKind, TagEncoding, Variants, WrappingRange,
+};
+
+/// Overlap eligibility and variant assignment for each CoroutineSavedLocal.
+#[derive(Clone, Debug, PartialEq)]
+enum SavedLocalEligibility<VariantIdx, FieldIdx> {
+ Unassigned,
+ Assigned(VariantIdx),
+ Ineligible(Option<FieldIdx>),
+}
+
+/// Compute the eligibility and assignment of each local.
+fn coroutine_saved_local_eligibility<VariantIdx: Idx, FieldIdx: Idx, LocalIdx: Idx>(
+ nb_locals: usize,
+ variant_fields: &IndexSlice<VariantIdx, IndexVec<FieldIdx, LocalIdx>>,
+ storage_conflicts: &BitMatrix<LocalIdx, LocalIdx>,
+) -> (DenseBitSet<LocalIdx>, IndexVec<LocalIdx, SavedLocalEligibility<VariantIdx, FieldIdx>>) {
+ use SavedLocalEligibility::*;
+
+ let mut assignments: IndexVec<LocalIdx, _> = IndexVec::from_elem_n(Unassigned, nb_locals);
+
+ // The saved locals not eligible for overlap. These will get
+ // "promoted" to the prefix of our coroutine.
+ let mut ineligible_locals = DenseBitSet::new_empty(nb_locals);
+
+ // Figure out which of our saved locals are fields in only
+ // one variant. The rest are deemed ineligible for overlap.
+ for (variant_index, fields) in variant_fields.iter_enumerated() {
+ for local in fields {
+ match assignments[*local] {
+ Unassigned => {
+ assignments[*local] = Assigned(variant_index);
+ }
+ Assigned(idx) => {
+ // We've already seen this local at another suspension
+ // point, so it is no longer a candidate.
+ trace!(
+ "removing local {:?} in >1 variant ({:?}, {:?})",
+ local, variant_index, idx
+ );
+ ineligible_locals.insert(*local);
+ assignments[*local] = Ineligible(None);
+ }
+ Ineligible(_) => {}
+ }
+ }
+ }
+
+ // Next, check every pair of eligible locals to see if they
+ // conflict.
+ for local_a in storage_conflicts.rows() {
+ let conflicts_a = storage_conflicts.count(local_a);
+ if ineligible_locals.contains(local_a) {
+ continue;
+ }
+
+ for local_b in storage_conflicts.iter(local_a) {
+ // local_a and local_b are storage live at the same time, therefore they
+ // cannot overlap in the coroutine layout. The only way to guarantee
+ // this is if they are in the same variant, or one is ineligible
+ // (which means it is stored in every variant).
+ if ineligible_locals.contains(local_b) || assignments[local_a] == assignments[local_b] {
+ continue;
+ }
+
+ // If they conflict, we will choose one to make ineligible.
+ // This is not always optimal; it's just a greedy heuristic that
+ // seems to produce good results most of the time.
+ let conflicts_b = storage_conflicts.count(local_b);
+ let (remove, other) =
+ if conflicts_a > conflicts_b { (local_a, local_b) } else { (local_b, local_a) };
+ ineligible_locals.insert(remove);
+ assignments[remove] = Ineligible(None);
+ trace!("removing local {:?} due to conflict with {:?}", remove, other);
+ }
+ }
+
+ // Count the number of variants in use. If only one of them, then it is
+ // impossible to overlap any locals in our layout. In this case it's
+ // always better to make the remaining locals ineligible, so we can
+ // lay them out with the other locals in the prefix and eliminate
+ // unnecessary padding bytes.
+ {
+ let mut used_variants = DenseBitSet::new_empty(variant_fields.len());
+ for assignment in &assignments {
+ if let Assigned(idx) = assignment {
+ used_variants.insert(*idx);
+ }
+ }
+ if used_variants.count() < 2 {
+ for assignment in assignments.iter_mut() {
+ *assignment = Ineligible(None);
+ }
+ ineligible_locals.insert_all();
+ }
+ }
+
+ // Write down the order of our locals that will be promoted to the prefix.
+ {
+ for (idx, local) in ineligible_locals.iter().enumerate() {
+ assignments[local] = Ineligible(Some(FieldIdx::new(idx)));
+ }
+ }
+ debug!("coroutine saved local assignments: {:?}", assignments);
+
+ (ineligible_locals, assignments)
+}
+
+/// Compute the full coroutine layout.
+pub(super) fn layout<
+ 'a,
+ F: core::ops::Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + core::fmt::Debug + Copy,
+ VariantIdx: Idx,
+ FieldIdx: Idx,
+ LocalIdx: Idx,
+>(
+ calc: &super::LayoutCalculator<impl HasDataLayout>,
+ local_layouts: &IndexSlice<LocalIdx, F>,
+ mut prefix_layouts: IndexVec<FieldIdx, F>,
+ variant_fields: &IndexSlice<VariantIdx, IndexVec<FieldIdx, LocalIdx>>,
+ storage_conflicts: &BitMatrix<LocalIdx, LocalIdx>,
+ tag_to_layout: impl Fn(Scalar) -> F,
+) -> super::LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+ use SavedLocalEligibility::*;
+
+ let (ineligible_locals, assignments) =
+ coroutine_saved_local_eligibility(local_layouts.len(), variant_fields, storage_conflicts);
+
+ // Build a prefix layout, including "promoting" all ineligible
+ // locals as part of the prefix. We compute the layout of all of
+ // these fields at once to get optimal packing.
+ let tag_index = prefix_layouts.len();
+
+ // `variant_fields` already accounts for the reserved variants, so no need to add them.
+ let max_discr = (variant_fields.len() - 1) as u128;
+ let discr_int = Integer::fit_unsigned(max_discr);
+ let tag = Scalar::Initialized {
+ value: Primitive::Int(discr_int, /* signed = */ false),
+ valid_range: WrappingRange { start: 0, end: max_discr },
+ };
+
+ let promoted_layouts = ineligible_locals.iter().map(|local| local_layouts[local]);
+ prefix_layouts.push(tag_to_layout(tag));
+ prefix_layouts.extend(promoted_layouts);
+ let prefix =
+ calc.univariant(&prefix_layouts, &ReprOptions::default(), StructKind::AlwaysSized)?;
+
+ let (prefix_size, prefix_align) = (prefix.size, prefix.align);
+
+ // Split the prefix layout into the "outer" fields (upvars and
+ // discriminant) and the "promoted" fields. Promoted fields will
+ // get included in each variant that requested them in
+ // CoroutineLayout.
+ debug!("prefix = {:#?}", prefix);
+ let (outer_fields, promoted_offsets, promoted_memory_index) = match prefix.fields {
+ FieldsShape::Arbitrary { mut offsets, memory_index } => {
+ let mut inverse_memory_index = memory_index.invert_bijective_mapping();
+
+ // "a" (`0..b_start`) and "b" (`b_start..`) correspond to
+ // "outer" and "promoted" fields respectively.
+ let b_start = FieldIdx::new(tag_index + 1);
+ let offsets_b = IndexVec::from_raw(offsets.raw.split_off(b_start.index()));
+ let offsets_a = offsets;
+
+ // Disentangle the "a" and "b" components of `inverse_memory_index`
+ // by preserving the order but keeping only one disjoint "half" each.
+ // FIXME(eddyb) build a better abstraction for permutations, if possible.
+ let inverse_memory_index_b: IndexVec<u32, FieldIdx> = inverse_memory_index
+ .iter()
+ .filter_map(|&i| i.index().checked_sub(b_start.index()).map(FieldIdx::new))
+ .collect();
+ inverse_memory_index.raw.retain(|&i| i.index() < b_start.index());
+ let inverse_memory_index_a = inverse_memory_index;
+
+ // Since `inverse_memory_index_{a,b}` each only refer to their
+ // respective fields, they can be safely inverted
+ let memory_index_a = inverse_memory_index_a.invert_bijective_mapping();
+ let memory_index_b = inverse_memory_index_b.invert_bijective_mapping();
+
+ let outer_fields =
+ FieldsShape::Arbitrary { offsets: offsets_a, memory_index: memory_index_a };
+ (outer_fields, offsets_b, memory_index_b)
+ }
+ _ => unreachable!(),
+ };
+
+ let mut size = prefix.size;
+ let mut align = prefix.align;
+ let variants = variant_fields
+ .iter_enumerated()
+ .map(|(index, variant_fields)| {
+ // Only include overlap-eligible fields when we compute our variant layout.
+ let variant_only_tys = variant_fields
+ .iter()
+ .filter(|local| match assignments[**local] {
+ Unassigned => unreachable!(),
+ Assigned(v) if v == index => true,
+ Assigned(_) => unreachable!("assignment does not match variant"),
+ Ineligible(_) => false,
+ })
+ .map(|local| local_layouts[*local]);
+
+ let mut variant = calc.univariant(
+ &variant_only_tys.collect::<IndexVec<_, _>>(),
+ &ReprOptions::default(),
+ StructKind::Prefixed(prefix_size, prefix_align.abi),
+ )?;
+ variant.variants = Variants::Single { index };
+
+ let FieldsShape::Arbitrary { offsets, memory_index } = variant.fields else {
+ unreachable!();
+ };
+
+ // Now, stitch the promoted and variant-only fields back together in
+ // the order they are mentioned by our CoroutineLayout.
+ // Because we only use some subset (that can differ between variants)
+ // of the promoted fields, we can't just pick those elements of the
+ // `promoted_memory_index` (as we'd end up with gaps).
+ // So instead, we build an "inverse memory_index", as if all of the
+ // promoted fields were being used, but leave the elements not in the
+ // subset as `invalid_field_idx`, which we can filter out later to
+ // obtain a valid (bijective) mapping.
+ let invalid_field_idx = promoted_memory_index.len() + memory_index.len();
+ let mut combined_inverse_memory_index =
+ IndexVec::from_elem_n(FieldIdx::new(invalid_field_idx), invalid_field_idx);
+
+ let mut offsets_and_memory_index = iter::zip(offsets, memory_index);
+ let combined_offsets = variant_fields
+ .iter_enumerated()
+ .map(|(i, local)| {
+ let (offset, memory_index) = match assignments[*local] {
+ Unassigned => unreachable!(),
+ Assigned(_) => {
+ let (offset, memory_index) = offsets_and_memory_index.next().unwrap();
+ (offset, promoted_memory_index.len() as u32 + memory_index)
+ }
+ Ineligible(field_idx) => {
+ let field_idx = field_idx.unwrap();
+ (promoted_offsets[field_idx], promoted_memory_index[field_idx])
+ }
+ };
+ combined_inverse_memory_index[memory_index] = i;
+ offset
+ })
+ .collect();
+
+ // Remove the unused slots and invert the mapping to obtain the
+ // combined `memory_index` (also see previous comment).
+ combined_inverse_memory_index.raw.retain(|&i| i.index() != invalid_field_idx);
+ let combined_memory_index = combined_inverse_memory_index.invert_bijective_mapping();
+
+ variant.fields = FieldsShape::Arbitrary {
+ offsets: combined_offsets,
+ memory_index: combined_memory_index,
+ };
+
+ size = size.max(variant.size);
+ align = align.max(variant.align);
+ Ok(variant)
+ })
+ .collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
+
+ size = size.align_to(align.abi);
+
+ let uninhabited = prefix.uninhabited || variants.iter().all(|v| v.is_uninhabited());
+ let abi = BackendRepr::Memory { sized: true };
+
+ Ok(LayoutData {
+ variants: Variants::Multiple {
+ tag,
+ tag_encoding: TagEncoding::Direct,
+ tag_field: tag_index,
+ variants,
+ },
+ fields: outer_fields,
+ backend_repr: abi,
+ // Suppress niches inside coroutines. If the niche is inside a field that is aliased (due to
+ // self-referentiality), getting the discriminant can cause aliasing violations.
+ // `UnsafeCell` blocks niches for the same reason, but we don't yet have `UnsafePinned` that
+ // would do the same for us here.
+ // See <https://github.com/rust-lang/rust/issues/63818>, <https://github.com/rust-lang/miri/issues/3780>.
+ // FIXME: Remove when <https://github.com/rust-lang/rust/issues/125735> is implemented and aliased coroutine fields are wrapped in `UnsafePinned`.
+ largest_niche: None,
+ uninhabited,
+ size,
+ align,
+ max_repr_align: None,
+ unadjusted_abi_align: align.abi,
+ randomization_seed: Default::default(),
+ })
+}
diff --git a/compiler/rustc_abi/src/layout/simple.rs b/compiler/rustc_abi/src/layout/simple.rs
new file mode 100644
index 0000000000000..0d0706defc2e5
--- /dev/null
+++ b/compiler/rustc_abi/src/layout/simple.rs
@@ -0,0 +1,148 @@
+use std::num::NonZero;
+
+use rustc_hashes::Hash64;
+use rustc_index::{Idx, IndexVec};
+
+use crate::{
+ BackendRepr, FieldsShape, HasDataLayout, LayoutData, Niche, Primitive, Scalar, Size, Variants,
+};
+
+/// "Simple" layout constructors that cannot fail.
+impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
+ pub fn unit<C: HasDataLayout>(cx: &C, sized: bool) -> Self {
+ let dl = cx.data_layout();
+ LayoutData {
+ variants: Variants::Single { index: VariantIdx::new(0) },
+ fields: FieldsShape::Arbitrary {
+ offsets: IndexVec::new(),
+ memory_index: IndexVec::new(),
+ },
+ backend_repr: BackendRepr::Memory { sized },
+ largest_niche: None,
+ uninhabited: false,
+ align: dl.i8_align,
+ size: Size::ZERO,
+ max_repr_align: None,
+ unadjusted_abi_align: dl.i8_align.abi,
+ randomization_seed: Hash64::new(0),
+ }
+ }
+
+ pub fn never_type<C: HasDataLayout>(cx: &C) -> Self {
+ let dl = cx.data_layout();
+ // This is also used for uninhabited enums, so we use `Variants::Empty`.
+ LayoutData {
+ variants: Variants::Empty,
+ fields: FieldsShape::Primitive,
+ backend_repr: BackendRepr::Memory { sized: true },
+ largest_niche: None,
+ uninhabited: true,
+ align: dl.i8_align,
+ size: Size::ZERO,
+ max_repr_align: None,
+ unadjusted_abi_align: dl.i8_align.abi,
+ randomization_seed: Hash64::ZERO,
+ }
+ }
+
+ pub fn scalar<C: HasDataLayout>(cx: &C, scalar: Scalar) -> Self {
+ let largest_niche = Niche::from_scalar(cx, Size::ZERO, scalar);
+ let size = scalar.size(cx);
+ let align = scalar.align(cx);
+
+ let range = scalar.valid_range(cx);
+
+ // All primitive types for which we don't have subtype coercions should get a distinct seed,
+ // so that types wrapping them can use randomization to arrive at distinct layouts.
+ //
+ // Some type information is already lost at this point, so as an approximation we derive
+ // the seed from what remains. For example on 64-bit targets usize and u64 can no longer
+ // be distinguished.
+ let randomization_seed = size
+ .bytes()
+ .wrapping_add(
+ match scalar.primitive() {
+ Primitive::Int(_, true) => 1,
+ Primitive::Int(_, false) => 2,
+ Primitive::Float(_) => 3,
+ Primitive::Pointer(_) => 4,
+ } << 32,
+ )
+ // distinguishes references from pointers
+ .wrapping_add((range.start as u64).rotate_right(16))
+ // distinguishes char from u32 and bool from u8
+ .wrapping_add((range.end as u64).rotate_right(16));
+
+ LayoutData {
+ variants: Variants::Single { index: VariantIdx::new(0) },
+ fields: FieldsShape::Primitive,
+ backend_repr: BackendRepr::Scalar(scalar),
+ largest_niche,
+ uninhabited: false,
+ size,
+ align,
+ max_repr_align: None,
+ unadjusted_abi_align: align.abi,
+ randomization_seed: Hash64::new(randomization_seed),
+ }
+ }
+
+ pub fn scalar_pair<C: HasDataLayout>(cx: &C, a: Scalar, b: Scalar) -> Self {
+ let dl = cx.data_layout();
+ let b_align = b.align(dl);
+ let align = a.align(dl).max(b_align).max(dl.aggregate_align);
+ let b_offset = a.size(dl).align_to(b_align.abi);
+ let size = (b_offset + b.size(dl)).align_to(align.abi);
+
+ // HACK(nox): We iter on `b` and then `a` because `max_by_key`
+ // returns the last maximum.
+ let largest_niche = Niche::from_scalar(dl, b_offset, b)
+ .into_iter()
+ .chain(Niche::from_scalar(dl, Size::ZERO, a))
+ .max_by_key(|niche| niche.available(dl));
+
+ let combined_seed = a.size(dl).bytes().wrapping_add(b.size(dl).bytes());
+
+ LayoutData {
+ variants: Variants::Single { index: VariantIdx::new(0) },
+ fields: FieldsShape::Arbitrary {
+ offsets: [Size::ZERO, b_offset].into(),
+ memory_index: [0, 1].into(),
+ },
+ backend_repr: BackendRepr::ScalarPair(a, b),
+ largest_niche,
+ uninhabited: false,
+ align,
+ size,
+ max_repr_align: None,
+ unadjusted_abi_align: align.abi,
+ randomization_seed: Hash64::new(combined_seed),
+ }
+ }
+
+ /// Returns a dummy layout for an uninhabited variant.
+ ///
+ /// Uninhabited variants get pruned as part of the layout calculation,
+ /// so this can be used after the fact to reconstitute a layout.
+ pub fn uninhabited_variant<C: HasDataLayout>(cx: &C, index: VariantIdx, fields: usize) -> Self {
+ let dl = cx.data_layout();
+ LayoutData {
+ variants: Variants::Single { index },
+ fields: match NonZero::new(fields) {
+ Some(fields) => FieldsShape::Union(fields),
+ None => FieldsShape::Arbitrary {
+ offsets: IndexVec::new(),
+ memory_index: IndexVec::new(),
+ },
+ },
+ backend_repr: BackendRepr::Memory { sized: true },
+ largest_niche: None,
+ uninhabited: true,
+ align: dl.i8_align,
+ size: Size::ZERO,
+ max_repr_align: None,
+ unadjusted_abi_align: dl.i8_align.abi,
+ randomization_seed: Hash64::ZERO,
+ }
+ }
+}
diff --git a/compiler/rustc_abi/src/layout/ty.rs b/compiler/rustc_abi/src/layout/ty.rs
new file mode 100644
index 0000000000000..4f43c0e6f8e96
--- /dev/null
+++ b/compiler/rustc_abi/src/layout/ty.rs
@@ -0,0 +1,295 @@
+use std::fmt;
+use std::ops::Deref;
+
+use rustc_data_structures::intern::Interned;
+use rustc_macros::HashStable_Generic;
+
+use crate::{
+ AbiAndPrefAlign, Align, BackendRepr, FieldsShape, Float, HasDataLayout, LayoutData, Niche,
+ PointeeInfo, Primitive, Scalar, Size, TargetDataLayout, Variants,
+};
+
+// Explicitly import `Float` to avoid ambiguity with `Primitive::Float`.
+
+rustc_index::newtype_index! {
+ /// The *source-order* index of a field in a variant.
+ ///
+ /// This is how most code after type checking refers to fields, rather than
+ /// using names (as names have hygiene complications and more complex lookup).
+ ///
+ /// Particularly for `repr(Rust)` types, this may not be the same as *layout* order.
+ /// (It is for `repr(C)` `struct`s, however.)
+ ///
+ /// For example, in the following types,
+ /// ```rust
+ /// # enum Never {}
+ /// # #[repr(u16)]
+ /// enum Demo1 {
+ /// Variant0 { a: Never, b: i32 } = 100,
+ /// Variant1 { c: u8, d: u64 } = 10,
+ /// }
+ /// struct Demo2 { e: u8, f: u16, g: u8 }
+ /// ```
+ /// `b` is `FieldIdx(1)` in `VariantIdx(0)`,
+ /// `d` is `FieldIdx(1)` in `VariantIdx(1)`, and
+ /// `f` is `FieldIdx(1)` in `VariantIdx(0)`.
+ #[derive(HashStable_Generic)]
+ #[encodable]
+ #[orderable]
+ pub struct FieldIdx {}
+}
+
+rustc_index::newtype_index! {
+ /// The *source-order* index of a variant in a type.
+ ///
+ /// For enums, these are always `0..variant_count`, regardless of any
+ /// custom discriminants that may have been defined, and including any
+ /// variants that may end up uninhabited due to field types. (Some of the
+ /// variants may not be present in a monomorphized ABI [`Variants`], but
+ /// those skipped variants are always counted when determining the *index*.)
+ ///
+ /// `struct`s, `tuples`, and `unions`s are considered to have a single variant
+ /// with variant index zero, aka [`FIRST_VARIANT`].
+ #[derive(HashStable_Generic)]
+ #[encodable]
+ #[orderable]
+ pub struct VariantIdx {
+ /// Equivalent to `VariantIdx(0)`.
+ const FIRST_VARIANT = 0;
+ }
+}
+#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic)]
+#[rustc_pass_by_value]
+pub struct Layout<'a>(pub Interned<'a, LayoutData<FieldIdx, VariantIdx>>);
+
+impl<'a> fmt::Debug for Layout<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // See comment on `<LayoutS as Debug>::fmt` above.
+ self.0.0.fmt(f)
+ }
+}
+
+impl<'a> Deref for Layout<'a> {
+ type Target = &'a LayoutData<FieldIdx, VariantIdx>;
+ fn deref(&self) -> &&'a LayoutData<FieldIdx, VariantIdx> {
+ &self.0.0
+ }
+}
+
+impl<'a> Layout<'a> {
+ pub fn fields(self) -> &'a FieldsShape<FieldIdx> {
+ &self.0.0.fields
+ }
+
+ pub fn variants(self) -> &'a Variants<FieldIdx, VariantIdx> {
+ &self.0.0.variants
+ }
+
+ pub fn backend_repr(self) -> BackendRepr {
+ self.0.0.backend_repr
+ }
+
+ pub fn largest_niche(self) -> Option<Niche> {
+ self.0.0.largest_niche
+ }
+
+ pub fn align(self) -> AbiAndPrefAlign {
+ self.0.0.align
+ }
+
+ pub fn size(self) -> Size {
+ self.0.0.size
+ }
+
+ pub fn max_repr_align(self) -> Option<Align> {
+ self.0.0.max_repr_align
+ }
+
+ pub fn unadjusted_abi_align(self) -> Align {
+ self.0.0.unadjusted_abi_align
+ }
+
+ /// Whether the layout is from a type that implements [`std::marker::PointerLike`].
+ ///
+ /// Currently, that means that the type is pointer-sized, pointer-aligned,
+ /// and has a initialized (non-union), scalar ABI.
+ pub fn is_pointer_like(self, data_layout: &TargetDataLayout) -> bool {
+ self.size() == data_layout.pointer_size
+ && self.align().abi == data_layout.pointer_align.abi
+ && matches!(self.backend_repr(), BackendRepr::Scalar(Scalar::Initialized { .. }))
+ }
+}
+
+/// The layout of a type, alongside the type itself.
+/// Provides various type traversal APIs (e.g., recursing into fields).
+///
+/// Note that the layout is NOT guaranteed to always be identical
+/// to that obtained from `layout_of(ty)`, as we need to produce
+/// layouts for which Rust types do not exist, such as enum variants
+/// or synthetic fields of enums (i.e., discriminants) and wide pointers.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic)]
+pub struct TyAndLayout<'a, Ty> {
+ pub ty: Ty,
+ pub layout: Layout<'a>,
+}
+
+impl<'a, Ty: fmt::Display> fmt::Debug for TyAndLayout<'a, Ty> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // Print the type in a readable way, not its debug representation.
+ f.debug_struct("TyAndLayout")
+ .field("ty", &format_args!("{}", self.ty))
+ .field("layout", &self.layout)
+ .finish()
+ }
+}
+
+impl<'a, Ty> Deref for TyAndLayout<'a, Ty> {
+ type Target = &'a LayoutData<FieldIdx, VariantIdx>;
+ fn deref(&self) -> &&'a LayoutData<FieldIdx, VariantIdx> {
+ &self.layout.0.0
+ }
+}
+
+impl<'a, Ty> AsRef<LayoutData<FieldIdx, VariantIdx>> for TyAndLayout<'a, Ty> {
+ fn as_ref(&self) -> &LayoutData<FieldIdx, VariantIdx> {
+ &*self.layout.0.0
+ }
+}
+
+/// Trait that needs to be implemented by the higher-level type representation
+/// (e.g. `rustc_middle::ty::Ty`), to provide `rustc_target::abi` functionality.
+pub trait TyAbiInterface<'a, C>: Sized + std::fmt::Debug {
+ fn ty_and_layout_for_variant(
+ this: TyAndLayout<'a, Self>,
+ cx: &C,
+ variant_index: VariantIdx,
+ ) -> TyAndLayout<'a, Self>;
+ fn ty_and_layout_field(this: TyAndLayout<'a, Self>, cx: &C, i: usize) -> TyAndLayout<'a, Self>;
+ fn ty_and_layout_pointee_info_at(
+ this: TyAndLayout<'a, Self>,
+ cx: &C,
+ offset: Size,
+ ) -> Option<PointeeInfo>;
+ fn is_adt(this: TyAndLayout<'a, Self>) -> bool;
+ fn is_never(this: TyAndLayout<'a, Self>) -> bool;
+ fn is_tuple(this: TyAndLayout<'a, Self>) -> bool;
+ fn is_unit(this: TyAndLayout<'a, Self>) -> bool;
+ fn is_transparent(this: TyAndLayout<'a, Self>) -> bool;
+}
+
+impl<'a, Ty> TyAndLayout<'a, Ty> {
+ pub fn for_variant<C>(self, cx: &C, variant_index: VariantIdx) -> Self
+ where
+ Ty: TyAbiInterface<'a, C>,
+ {
+ Ty::ty_and_layout_for_variant(self, cx, variant_index)
+ }
+
+ pub fn field<C>(self, cx: &C, i: usize) -> Self
+ where
+ Ty: TyAbiInterface<'a, C>,
+ {
+ Ty::ty_and_layout_field(self, cx, i)
+ }
+
+ pub fn pointee_info_at<C>(self, cx: &C, offset: Size) -> Option<PointeeInfo>
+ where
+ Ty: TyAbiInterface<'a, C>,
+ {
+ Ty::ty_and_layout_pointee_info_at(self, cx, offset)
+ }
+
+ pub fn is_single_fp_element<C>(self, cx: &C) -> bool
+ where
+ Ty: TyAbiInterface<'a, C>,
+ C: HasDataLayout,
+ {
+ match self.backend_repr {
+ BackendRepr::Scalar(scalar) => {
+ matches!(scalar.primitive(), Primitive::Float(Float::F32 | Float::F64))
+ }
+ BackendRepr::Memory { .. } => {
+ if self.fields.count() == 1 && self.fields.offset(0).bytes() == 0 {
+ self.field(cx, 0).is_single_fp_element(cx)
+ } else {
+ false
+ }
+ }
+ _ => false,
+ }
+ }
+
+ pub fn is_single_vector_element<C>(self, cx: &C, expected_size: Size) -> bool
+ where
+ Ty: TyAbiInterface<'a, C>,
+ C: HasDataLayout,
+ {
+ match self.backend_repr {
+ BackendRepr::SimdVector { .. } => self.size == expected_size,
+ BackendRepr::Memory { .. } => {
+ if self.fields.count() == 1 && self.fields.offset(0).bytes() == 0 {
+ self.field(cx, 0).is_single_vector_element(cx, expected_size)
+ } else {
+ false
+ }
+ }
+ _ => false,
+ }
+ }
+
+ pub fn is_adt<C>(self) -> bool
+ where
+ Ty: TyAbiInterface<'a, C>,
+ {
+ Ty::is_adt(self)
+ }
+
+ pub fn is_never<C>(self) -> bool
+ where
+ Ty: TyAbiInterface<'a, C>,
+ {
+ Ty::is_never(self)
+ }
+
+ pub fn is_tuple<C>(self) -> bool
+ where
+ Ty: TyAbiInterface<'a, C>,
+ {
+ Ty::is_tuple(self)
+ }
+
+ pub fn is_unit<C>(self) -> bool
+ where
+ Ty: TyAbiInterface<'a, C>,
+ {
+ Ty::is_unit(self)
+ }
+
+ pub fn is_transparent<C>(self) -> bool
+ where
+ Ty: TyAbiInterface<'a, C>,
+ {
+ Ty::is_transparent(self)
+ }
+
+ /// Finds the one field that is not a 1-ZST.
+ /// Returns `None` if there are multiple non-1-ZST fields or only 1-ZST-fields.
+ pub fn non_1zst_field<C>(&self, cx: &C) -> Option<(usize, Self)>
+ where
+ Ty: TyAbiInterface<'a, C> + Copy,
+ {
+ let mut found = None;
+ for field_idx in 0..self.fields.count() {
+ let field = self.field(cx, field_idx);
+ if field.is_1zst() {
+ continue;
+ }
+ if found.is_some() {
+ // More than one non-1-ZST field.
+ return None;
+ }
+ found = Some((field_idx, field));
+ }
+ found
+ }
+}
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 78332d66f0366..59b74d2922145 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1,40 +1,83 @@
// tidy-alphabetical-start
#![cfg_attr(feature = "nightly", allow(internal_features))]
#![cfg_attr(feature = "nightly", doc(rust_logo))]
+#![cfg_attr(feature = "nightly", feature(assert_matches))]
+#![cfg_attr(feature = "nightly", feature(rustc_attrs))]
#![cfg_attr(feature = "nightly", feature(rustdoc_internals))]
#![cfg_attr(feature = "nightly", feature(step_trait))]
// tidy-alphabetical-end
+/*! ABI handling for rustc
+
+## What is an "ABI"?
+
+Literally, "application binary interface", which means it is everything about how code interacts,
+at the machine level, with other code. This means it technically covers all of the following:
+- object binary format for e.g. relocations or offset tables
+- in-memory layout of types
+- procedure calling conventions
+
+When we discuss "ABI" in the context of rustc, we are probably discussing calling conventions.
+To describe those `rustc_abi` also covers type layout, as it must for values passed on the stack.
+Despite `rustc_abi` being about calling conventions, it is good to remember these usages exist.
+You will encounter all of them and more if you study target-specific codegen enough!
+Even in general conversation, when someone says "the Rust ABI is unstable", it may allude to
+either or both of
+- `repr(Rust)` types have a mostly-unspecified layout
+- `extern "Rust" fn(A) -> R` has an unspecified calling convention
+
+## Crate Goal
+
+ABI is a foundational concept, so the `rustc_abi` crate serves as an equally foundational crate.
+It cannot carry all details relevant to an ABI: those permeate code generation and linkage.
+Instead, `rustc_abi` is intended to provide the interface for reasoning about the binary interface.
+It should contain traits and types that other crates then use in their implementation.
+For example, a platform's `extern "C" fn` calling convention will be implemented in `rustc_target`
+but `rustc_abi` contains the types for calculating layout and describing register-passing.
+This makes it easier to describe things in the same way across targets, codegen backends, and
+even other Rust compilers, such as rust-analyzer!
+
+*/
+
use std::fmt;
+#[cfg(feature = "nightly")]
+use std::iter::Step;
use std::num::{NonZeroUsize, ParseIntError};
use std::ops::{Add, AddAssign, Mul, RangeInclusive, Sub};
use std::str::FromStr;
use bitflags::bitflags;
-use rustc_index::{Idx, IndexSlice, IndexVec};
-
#[cfg(feature = "nightly")]
use rustc_data_structures::stable_hasher::StableOrd;
+use rustc_hashes::Hash64;
+use rustc_index::{Idx, IndexSlice, IndexVec};
#[cfg(feature = "nightly")]
-use rustc_macros::HashStable_Generic;
-#[cfg(feature = "nightly")]
-use rustc_macros::{Decodable_Generic, Encodable_Generic};
-#[cfg(feature = "nightly")]
-use std::iter::Step;
+use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_Generic};
+mod callconv;
mod layout;
#[cfg(test)]
mod tests;
-pub use layout::LayoutCalculator;
+mod extern_abi;
+
+pub use callconv::{Heterogeneous, HomogeneousAggregate, Reg, RegKind};
+pub use extern_abi::{ExternAbi, all_names};
+#[cfg(feature = "nightly")]
+pub use layout::{FIRST_VARIANT, FieldIdx, Layout, TyAbiInterface, TyAndLayout, VariantIdx};
+pub use layout::{LayoutCalculator, LayoutCalculatorError};
/// Requirements for a `StableHashingContext` to be used in this crate.
/// This is a hack to allow using the `HashStable_Generic` derive macro
/// instead of implementing everything in `rustc_middle`.
+#[cfg(feature = "nightly")]
pub trait HashStableContext {}
#[derive(Clone, Copy, PartialEq, Eq, Default)]
-#[cfg_attr(feature = "nightly", derive(Encodable_Generic, Decodable_Generic, HashStable_Generic))]
+#[cfg_attr(
+ feature = "nightly",
+ derive(Encodable_NoContext, Decodable_NoContext, HashStable_Generic)
+)]
pub struct ReprFlags(u8);
bitflags! {
@@ -43,14 +86,17 @@ bitflags! {
const IS_SIMD = 1 << 1;
const IS_TRANSPARENT = 1 << 2;
// Internal only for now. If true, don't reorder fields.
+ // On its own it does not prevent ABI optimizations.
const IS_LINEAR = 1 << 3;
- // If true, the type's layout can be randomized using
- // the seed stored in `ReprOptions.field_shuffle_seed`
+ // If true, the type's crate has opted into layout randomization.
+ // Other flags can still inhibit reordering and thus randomization.
+ // The seed stored in `ReprOptions.field_shuffle_seed`.
const RANDOMIZE_LAYOUT = 1 << 4;
// Any of these flags being set prevent field reordering optimisation.
- const IS_UNOPTIMISABLE = ReprFlags::IS_C.bits()
+ const FIELD_ORDER_UNOPTIMIZABLE = ReprFlags::IS_C.bits()
| ReprFlags::IS_SIMD.bits()
| ReprFlags::IS_LINEAR.bits();
+ const ABI_UNOPTIMIZABLE = ReprFlags::IS_C.bits() | ReprFlags::IS_SIMD.bits();
}
}
@@ -63,7 +109,10 @@ impl std::fmt::Debug for ReprFlags {
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(feature = "nightly", derive(Encodable_Generic, Decodable_Generic, HashStable_Generic))]
+#[cfg_attr(
+ feature = "nightly",
+ derive(Encodable_NoContext, Decodable_NoContext, HashStable_Generic)
+)]
pub enum IntegerType {
/// Pointer-sized integer type, i.e. `isize` and `usize`. The field shows signedness, e.g.
/// `Pointer(true)` means `isize`.
@@ -84,7 +133,10 @@ impl IntegerType {
/// Represents the repr options provided by the user.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
-#[cfg_attr(feature = "nightly", derive(Encodable_Generic, Decodable_Generic, HashStable_Generic))]
+#[cfg_attr(
+ feature = "nightly",
+ derive(Encodable_NoContext, Decodable_NoContext, HashStable_Generic)
+)]
pub struct ReprOptions {
pub int: Option<IntegerType>,
pub align: Option<Align>,
@@ -97,7 +149,7 @@ pub struct ReprOptions {
/// hash without loss, but it does pay the price of being larger.
/// Everything's a tradeoff, a 64-bit seed should be sufficient for our
/// purposes (primarily `-Z randomize-layout`)
- pub field_shuffle_seed: u64,
+ pub field_shuffle_seed: Hash64,
}
impl ReprOptions {
@@ -139,10 +191,14 @@ impl ReprOptions {
self.c() || self.int.is_some()
}
+ pub fn inhibit_newtype_abi_optimization(&self) -> bool {
+ self.flags.intersects(ReprFlags::ABI_UNOPTIMIZABLE)
+ }
+
/// Returns `true` if this `#[repr()]` guarantees a fixed field order,
/// e.g. `repr(C)` or `repr(<int>)`.
pub fn inhibit_struct_field_reordering(&self) -> bool {
- self.flags.intersects(ReprFlags::IS_UNOPTIMISABLE) || self.int.is_some()
+ self.flags.intersects(ReprFlags::FIELD_ORDER_UNOPTIMIZABLE) || self.int.is_some()
}
/// Returns `true` if this type is valid for reordering and `-Z randomize-layout`
@@ -157,6 +213,13 @@ impl ReprOptions {
}
}
+/// The maximum supported number of lanes in a SIMD vector.
+///
+/// This value is selected based on backend support:
+/// * LLVM does not appear to have a vector width limit.
+/// * Cranelift stores the base-2 log of the lane count in a 4 bit integer.
+pub const MAX_SIMD_LANES: u64 = 1 << 0xF;
+
/// Parsed [Data layout](https://llvm.org/docs/LangRef.html#data-layout)
/// for a target, which contains everything needed to compute layouts.
#[derive(Debug, PartialEq, Eq)]
@@ -281,19 +344,19 @@ impl TargetDataLayout {
[p] if p.starts_with('P') => {
dl.instruction_address_space = parse_address_space(&p[1..], "P")?
}
- ["a", ref a @ ..] => dl.aggregate_align = parse_align(a, "a")?,
- ["f16", ref a @ ..] => dl.f16_align = parse_align(a, "f16")?,
- ["f32", ref a @ ..] => dl.f32_align = parse_align(a, "f32")?,
- ["f64", ref a @ ..] => dl.f64_align = parse_align(a, "f64")?,
- ["f128", ref a @ ..] => dl.f128_align = parse_align(a, "f128")?,
+ ["a", a @ ..] => dl.aggregate_align = parse_align(a, "a")?,
+ ["f16", a @ ..] => dl.f16_align = parse_align(a, "f16")?,
+ ["f32", a @ ..] => dl.f32_align = parse_align(a, "f32")?,
+ ["f64", a @ ..] => dl.f64_align = parse_align(a, "f64")?,
+ ["f128", a @ ..] => dl.f128_align = parse_align(a, "f128")?,
// FIXME(erikdesjardins): we should be parsing nonzero address spaces
// this will require replacing TargetDataLayout::{pointer_size,pointer_align}
// with e.g. `fn pointer_size_in(AddressSpace)`
- [p @ "p", s, ref a @ ..] | [p @ "p0", s, ref a @ ..] => {
+ [p @ "p", s, a @ ..] | [p @ "p0", s, a @ ..] => {
dl.pointer_size = parse_size(s, p)?;
dl.pointer_align = parse_align(a, p)?;
}
- [s, ref a @ ..] if s.starts_with('i') => {
+ [s, a @ ..] if s.starts_with('i') => {
let Ok(bits) = s[1..].parse::<u64>() else {
parse_size(&s[1..], "i")?; // For the user error.
continue;
@@ -314,7 +377,7 @@ impl TargetDataLayout {
dl.i128_align = a;
}
}
- [s, ref a @ ..] if s.starts_with('v') => {
+ [s, a @ ..] if s.starts_with('v') => {
let v_size = parse_size(&s[1..], "v")?;
let a = parse_align(a, s)?;
if let Some(v) = dl.vector_align.iter_mut().find(|v| v.0 == v_size) {
@@ -330,23 +393,21 @@ impl TargetDataLayout {
Ok(dl)
}
- /// Returns exclusive upper bound on object size.
+ /// Returns **exclusive** upper bound on object size in bytes.
///
/// The theoretical maximum object size is defined as the maximum positive `isize` value.
/// This ensures that the `offset` semantics remain well-defined by allowing it to correctly
/// index every address within an object along with one byte past the end, along with allowing
/// `isize` to store the difference between any two pointers into an object.
///
- /// The upper bound on 64-bit currently needs to be lower because LLVM uses a 64-bit integer
- /// to represent object size in bits. It would need to be 1 << 61 to account for this, but is
- /// currently conservatively bounded to 1 << 47 as that is enough to cover the current usable
- /// address space on 64-bit ARMv8 and x86_64.
+ /// LLVM uses a 64-bit integer to represent object size in *bits*, but we care only for bytes,
+ /// so we adopt such a more-constrained size bound due to its technical limitations.
#[inline]
pub fn obj_size_bound(&self) -> u64 {
match self.pointer_size.bits() {
16 => 1 << 15,
32 => 1 << 31,
- 64 => 1 << 47,
+ 64 => 1 << 61,
bits => panic!("obj_size_bound: unknown pointer bit size {bits}"),
}
}
@@ -362,16 +423,21 @@ impl TargetDataLayout {
}
}
+ /// psABI-mandated alignment for a vector type, if any
#[inline]
- pub fn vector_align(&self, vec_size: Size) -> AbiAndPrefAlign {
- for &(size, align) in &self.vector_align {
- if size == vec_size {
- return align;
- }
- }
- // Default to natural alignment, which is what LLVM does.
- // That is, use the size, rounded up to a power of 2.
- AbiAndPrefAlign::new(Align::from_bytes(vec_size.bytes().next_power_of_two()).unwrap())
+ fn cabi_vector_align(&self, vec_size: Size) -> Option<AbiAndPrefAlign> {
+ self.vector_align
+ .iter()
+ .find(|(size, _align)| *size == vec_size)
+ .map(|(_size, align)| *align)
+ }
+
+ /// an alignment resembling the one LLVM would pick for a vector
+ #[inline]
+ pub fn llvmlike_vector_align(&self, vec_size: Size) -> AbiAndPrefAlign {
+ self.cabi_vector_align(vec_size).unwrap_or(AbiAndPrefAlign::new(
+ Align::from_bytes(vec_size.bytes().next_power_of_two()).unwrap(),
+ ))
}
}
@@ -386,6 +452,14 @@ impl HasDataLayout for TargetDataLayout {
}
}
+// used by rust-analyzer
+impl HasDataLayout for &TargetDataLayout {
+ #[inline]
+ fn data_layout(&self) -> &TargetDataLayout {
+ (**self).data_layout()
+ }
+}
+
/// Endianness of the target, which must match cfg(target-endian).
#[derive(Copy, Clone, PartialEq, Eq)]
pub enum Endian {
@@ -422,7 +496,10 @@ impl FromStr for Endian {
/// Size of a type in bytes.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "nightly", derive(Encodable_Generic, Decodable_Generic, HashStable_Generic))]
+#[cfg_attr(
+ feature = "nightly",
+ derive(Encodable_NoContext, Decodable_NoContext, HashStable_Generic)
+)]
pub struct Size {
raw: u64,
}
@@ -517,7 +594,7 @@ impl Size {
/// Truncates `value` to `self` bits and then sign-extends it to 128 bits
/// (i.e., if it is negative, fill with 1's on the left).
#[inline]
- pub fn sign_extend(self, value: u128) -> u128 {
+ pub fn sign_extend(self, value: u128) -> i128 {
let size = self.bits();
if size == 0 {
// Truncated until nothing is left.
@@ -527,7 +604,7 @@ impl Size {
let shift = 128 - size;
// Shift the unsigned value to the left, then shift back to the right as signed
// (essentially fills with sign bit on the left).
- (((value << shift) as i128) >> shift) as u128
+ ((value << shift) as i128) >> shift
}
/// Truncates `value` to `self` bits.
@@ -545,7 +622,7 @@ impl Size {
#[inline]
pub fn signed_int_min(&self) -> i128 {
- self.sign_extend(1_u128 << (self.bits() - 1)) as i128
+ self.sign_extend(1_u128 << (self.bits() - 1))
}
#[inline]
@@ -611,7 +688,7 @@ impl AddAssign for Size {
#[cfg(feature = "nightly")]
impl Step for Size {
#[inline]
- fn steps_between(start: &Self, end: &Self) -> Option<usize> {
+ fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>) {
u64::steps_between(&start.bytes(), &end.bytes())
}
@@ -627,7 +704,7 @@ impl Step for Size {
#[inline]
unsafe fn forward_unchecked(start: Self, count: usize) -> Self {
- Self::from_bytes(u64::forward_unchecked(start.bytes(), count))
+ Self::from_bytes(unsafe { u64::forward_unchecked(start.bytes(), count) })
}
#[inline]
@@ -642,13 +719,16 @@ impl Step for Size {
#[inline]
unsafe fn backward_unchecked(start: Self, count: usize) -> Self {
- Self::from_bytes(u64::backward_unchecked(start.bytes(), count))
+ Self::from_bytes(unsafe { u64::backward_unchecked(start.bytes(), count) })
}
}
/// Alignment of a type in bytes (always a power of two).
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "nightly", derive(Encodable_Generic, Decodable_Generic, HashStable_Generic))]
+#[cfg_attr(
+ feature = "nightly",
+ derive(Encodable_NoContext, Decodable_NoContext, HashStable_Generic)
+)]
pub struct Align {
pow2: u8,
}
@@ -737,7 +817,7 @@ impl Align {
}
#[inline]
- pub fn bytes(self) -> u64 {
+ pub const fn bytes(self) -> u64 {
1 << self.pow2
}
@@ -747,7 +827,7 @@ impl Align {
}
#[inline]
- pub fn bits(self) -> u64 {
+ pub const fn bits(self) -> u64 {
self.bytes() * 8
}
@@ -756,24 +836,31 @@ impl Align {
self.bits().try_into().unwrap()
}
- /// Computes the best alignment possible for the given offset
- /// (the largest power of two that the offset is a multiple of).
+ /// Obtain the greatest factor of `size` that is an alignment
+ /// (the largest power of two the Size is a multiple of).
///
- /// N.B., for an offset of `0`, this happens to return `2^64`.
+ /// Note that all numbers are factors of 0
#[inline]
- pub fn max_for_offset(offset: Size) -> Align {
- Align { pow2: offset.bytes().trailing_zeros() as u8 }
+ pub fn max_aligned_factor(size: Size) -> Align {
+ Align { pow2: size.bytes().trailing_zeros() as u8 }
}
- /// Lower the alignment, if necessary, such that the given offset
- /// is aligned to it (the offset is a multiple of the alignment).
+ /// Reduces Align to an aligned factor of `size`.
#[inline]
- pub fn restrict_for_offset(self, offset: Size) -> Align {
- self.min(Align::max_for_offset(offset))
+ pub fn restrict_for_offset(self, size: Size) -> Align {
+ self.min(Align::max_aligned_factor(size))
}
}
/// A pair of alignments, ABI-mandated and preferred.
+///
+/// The "preferred" alignment is an LLVM concept that is virtually meaningless to Rust code:
+/// it is not exposed semantically to programmers nor can they meaningfully affect it.
+/// The only concern for us is that preferred alignment must not be less than the mandated alignment
+/// and thus in practice the two values are almost always identical.
+///
+/// An example of a rare thing actually affected by preferred alignment is aligning of statics.
+/// It is of effectively no consequence for layout in structs and on the stack.
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
pub struct AbiAndPrefAlign {
@@ -800,7 +887,10 @@ impl AbiAndPrefAlign {
/// Integers, also used for enum discriminants.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-#[cfg_attr(feature = "nightly", derive(Encodable_Generic, Decodable_Generic, HashStable_Generic))]
+#[cfg_attr(
+ feature = "nightly",
+ derive(Encodable_NoContext, Decodable_NoContext, HashStable_Generic)
+)]
pub enum Integer {
I8,
I16,
@@ -810,6 +900,28 @@ pub enum Integer {
}
impl Integer {
+ pub fn int_ty_str(self) -> &'static str {
+ use Integer::*;
+ match self {
+ I8 => "i8",
+ I16 => "i16",
+ I32 => "i32",
+ I64 => "i64",
+ I128 => "i128",
+ }
+ }
+
+ pub fn uint_ty_str(self) -> &'static str {
+ use Integer::*;
+ match self {
+ I8 => "u8",
+ I16 => "u16",
+ I32 => "u32",
+ I64 => "u64",
+ I128 => "u128",
+ }
+ }
+
#[inline]
pub fn size(self) -> Size {
use Integer::*;
@@ -1161,6 +1273,15 @@ impl Scalar {
Scalar::Union { .. } => true,
}
}
+
+ /// Returns `true` if this is a signed integer scalar
+ #[inline]
+ pub fn is_signed(&self) -> bool {
+ match self.primitive() {
+ Primitive::Int(_, signed) => signed,
+ _ => false,
+ }
+ }
}
// NOTE: This struct is generic over the FieldIdx for rust-analyzer usage.
@@ -1252,7 +1373,7 @@ impl<FieldIdx: Idx> FieldsShape<FieldIdx> {
/// Gets source indices of the fields by increasing offsets.
#[inline]
- pub fn index_by_increasing_offset(&self) -> impl ExactSizeIterator<Item = usize> + '_ {
+ pub fn index_by_increasing_offset(&self) -> impl ExactSizeIterator<Item = usize> {
let mut inverse_small = [0u8; 64];
let mut inverse_big = IndexVec::new();
let use_small = self.count() <= inverse_small.len();
@@ -1298,31 +1419,41 @@ impl AddressSpace {
pub const DATA: Self = AddressSpace(0);
}
-/// Describes how values of the type are passed by target ABIs,
-/// in terms of categories of C types there are ABI rules for.
+/// The way we represent values to the backend
+///
+/// Previously this was conflated with the "ABI" a type is given, as in the platform-specific ABI.
+/// In reality, this implies little about that, but is mostly used to describe the syntactic form
+/// emitted for the backend, as most backends handle SSA values and blobs of memory differently.
+/// The psABI may need consideration in doing so, but this enum does not constitute a promise for
+/// how the value will be lowered to the calling convention, in itself.
+///
+/// Generally, a codegen backend will prefer to handle smaller values as a scalar or short vector,
+/// and larger values will usually prefer to be represented as memory.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
-pub enum Abi {
- Uninhabited,
+pub enum BackendRepr {
Scalar(Scalar),
ScalarPair(Scalar, Scalar),
- Vector {
+ SimdVector {
element: Scalar,
count: u64,
},
- Aggregate {
+ // FIXME: I sometimes use memory, sometimes use an IR aggregate!
+ Memory {
/// If true, the size is exact, otherwise it's only a lower bound.
sized: bool,
},
}
-impl Abi {
+impl BackendRepr {
/// Returns `true` if the layout corresponds to an unsized type.
#[inline]
pub fn is_unsized(&self) -> bool {
match *self {
- Abi::Uninhabited | Abi::Scalar(_) | Abi::ScalarPair(..) | Abi::Vector { .. } => false,
- Abi::Aggregate { sized } => !sized,
+ BackendRepr::Scalar(_)
+ | BackendRepr::ScalarPair(..)
+ | BackendRepr::SimdVector { .. } => false,
+ BackendRepr::Memory { sized } => !sized,
}
}
@@ -1331,76 +1462,73 @@ impl Abi {
!self.is_unsized()
}
- /// Returns `true` if this is a single signed integer scalar
+ /// Returns `true` if this is a single signed integer scalar.
+ /// Sanity check: panics if this is not a scalar type (see PR #70189).
#[inline]
pub fn is_signed(&self) -> bool {
match self {
- Abi::Scalar(scal) => match scal.primitive() {
- Primitive::Int(_, signed) => signed,
- _ => false,
- },
+ BackendRepr::Scalar(scal) => scal.is_signed(),
_ => panic!("`is_signed` on non-scalar ABI {self:?}"),
}
}
- /// Returns `true` if this is an uninhabited type
- #[inline]
- pub fn is_uninhabited(&self) -> bool {
- matches!(*self, Abi::Uninhabited)
- }
-
/// Returns `true` if this is a scalar type
#[inline]
pub fn is_scalar(&self) -> bool {
- matches!(*self, Abi::Scalar(_))
+ matches!(*self, BackendRepr::Scalar(_))
}
/// Returns `true` if this is a bool
#[inline]
pub fn is_bool(&self) -> bool {
- matches!(*self, Abi::Scalar(s) if s.is_bool())
+ matches!(*self, BackendRepr::Scalar(s) if s.is_bool())
}
- /// Returns the fixed alignment of this ABI, if any is mandated.
- pub fn inherent_align<C: HasDataLayout>(&self, cx: &C) -> Option<AbiAndPrefAlign> {
- Some(match *self {
- Abi::Scalar(s) => s.align(cx),
- Abi::ScalarPair(s1, s2) => s1.align(cx).max(s2.align(cx)),
- Abi::Vector { element, count } => {
- cx.data_layout().vector_align(element.size(cx) * count)
- }
- Abi::Uninhabited | Abi::Aggregate { .. } => return None,
- })
+ /// The psABI alignment for a `Scalar` or `ScalarPair`
+ ///
+ /// `None` for other variants.
+ pub fn scalar_align<C: HasDataLayout>(&self, cx: &C) -> Option<Align> {
+ match *self {
+ BackendRepr::Scalar(s) => Some(s.align(cx).abi),
+ BackendRepr::ScalarPair(s1, s2) => Some(s1.align(cx).max(s2.align(cx)).abi),
+ // The align of a Vector can vary in surprising ways
+ BackendRepr::SimdVector { .. } | BackendRepr::Memory { .. } => None,
+ }
}
- /// Returns the fixed size of this ABI, if any is mandated.
- pub fn inherent_size<C: HasDataLayout>(&self, cx: &C) -> Option<Size> {
- Some(match *self {
- Abi::Scalar(s) => {
- // No padding in scalars.
- s.size(cx)
- }
- Abi::ScalarPair(s1, s2) => {
- // May have some padding between the pair.
+ /// The psABI size for a `Scalar` or `ScalarPair`
+ ///
+ /// `None` for other variants
+ pub fn scalar_size<C: HasDataLayout>(&self, cx: &C) -> Option<Size> {
+ match *self {
+ // No padding in scalars.
+ BackendRepr::Scalar(s) => Some(s.size(cx)),
+ // May have some padding between the pair.
+ BackendRepr::ScalarPair(s1, s2) => {
let field2_offset = s1.size(cx).align_to(s2.align(cx).abi);
- (field2_offset + s2.size(cx)).align_to(self.inherent_align(cx)?.abi)
- }
- Abi::Vector { element, count } => {
- // No padding in vectors, except possibly for trailing padding
- // to make the size a multiple of align (e.g. for vectors of size 3).
- (element.size(cx) * count).align_to(self.inherent_align(cx)?.abi)
+ let size = (field2_offset + s2.size(cx)).align_to(
+ self.scalar_align(cx)
+ // We absolutely must have an answer here or everything is FUBAR.
+ .unwrap(),
+ );
+ Some(size)
}
- Abi::Uninhabited | Abi::Aggregate { .. } => return None,
- })
+ // The size of a Vector can vary in surprising ways
+ BackendRepr::SimdVector { .. } | BackendRepr::Memory { .. } => None,
+ }
}
/// Discard validity range information and allow undef.
pub fn to_union(&self) -> Self {
match *self {
- Abi::Scalar(s) => Abi::Scalar(s.to_union()),
- Abi::ScalarPair(s1, s2) => Abi::ScalarPair(s1.to_union(), s2.to_union()),
- Abi::Vector { element, count } => Abi::Vector { element: element.to_union(), count },
- Abi::Uninhabited | Abi::Aggregate { .. } => Abi::Aggregate { sized: true },
+ BackendRepr::Scalar(s) => BackendRepr::Scalar(s.to_union()),
+ BackendRepr::ScalarPair(s1, s2) => {
+ BackendRepr::ScalarPair(s1.to_union(), s2.to_union())
+ }
+ BackendRepr::SimdVector { element, count } => {
+ BackendRepr::SimdVector { element: element.to_union(), count }
+ }
+ BackendRepr::Memory { .. } => BackendRepr::Memory { sized: true },
}
}
@@ -1408,12 +1536,12 @@ impl Abi {
match (self, other) {
// Scalar, Vector, ScalarPair have `Scalar` in them where we ignore validity ranges.
// We do *not* ignore the sign since it matters for some ABIs (e.g. s390x).
- (Abi::Scalar(l), Abi::Scalar(r)) => l.primitive() == r.primitive(),
+ (BackendRepr::Scalar(l), BackendRepr::Scalar(r)) => l.primitive() == r.primitive(),
(
- Abi::Vector { element: element_l, count: count_l },
- Abi::Vector { element: element_r, count: count_r },
+ BackendRepr::SimdVector { element: element_l, count: count_l },
+ BackendRepr::SimdVector { element: element_r, count: count_r },
) => element_l.primitive() == element_r.primitive() && count_l == count_r,
- (Abi::ScalarPair(l1, l2), Abi::ScalarPair(r1, r2)) => {
+ (BackendRepr::ScalarPair(l1, l2), BackendRepr::ScalarPair(r1, r2)) => {
l1.primitive() == r1.primitive() && l2.primitive() == r2.primitive()
}
// Everything else must be strictly identical.
@@ -1426,8 +1554,14 @@ impl Abi {
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
pub enum Variants<FieldIdx: Idx, VariantIdx: Idx> {
+ /// A type with no valid variants. Must be uninhabited.
+ Empty,
+
/// Single enum variants, structs/tuples, unions, and all non-ADTs.
- Single { index: VariantIdx },
+ Single {
+ /// Always `0` for types that cannot have multiple variants.
+ index: VariantIdx,
+ },
/// Enum-likes with more than one variant: each variant comes with
/// a *discriminant* (usually the same as the variant index but the user can
@@ -1439,7 +1573,7 @@ pub enum Variants<FieldIdx: Idx, VariantIdx: Idx> {
tag: Scalar,
tag_encoding: TagEncoding<VariantIdx>,
tag_field: usize,
- variants: IndexVec<VariantIdx, LayoutS<FieldIdx, VariantIdx>>,
+ variants: IndexVec<VariantIdx, LayoutData<FieldIdx, VariantIdx>>,
},
}
@@ -1456,14 +1590,22 @@ pub enum TagEncoding<VariantIdx: Idx> {
/// The variant `untagged_variant` contains a niche at an arbitrary
/// offset (field `tag_field` of the enum), which for a variant with
/// discriminant `d` is set to
- /// `(d - niche_variants.start).wrapping_add(niche_start)`.
+ /// `(d - niche_variants.start).wrapping_add(niche_start)`
+ /// (this is wrapping arithmetic using the type of the niche field).
///
/// For example, `Option<(usize, &T)>` is represented such that
/// `None` has a null pointer for the second tuple field, and
/// `Some` is the identity function (with a non-null reference).
+ ///
+ /// Other variants that are not `untagged_variant` and that are outside the `niche_variants`
+ /// range cannot be represented; they must be uninhabited.
Niche {
untagged_variant: VariantIdx,
+ /// This range *may* contain `untagged_variant`; that is then just a "dead value" and
+ /// not used to encode anything.
niche_variants: RangeInclusive<VariantIdx>,
+ /// This is inbounds of the type of the niche field
+ /// (not sign-extended, i.e., all bits beyond the niche field size are 0).
niche_start: u128,
},
}
@@ -1557,7 +1699,7 @@ impl Niche {
// NOTE: This struct is generic over the FieldIdx and VariantIdx for rust-analyzer usage.
#[derive(PartialEq, Eq, Hash, Clone)]
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
-pub struct LayoutS<FieldIdx: Idx, VariantIdx: Idx> {
+pub struct LayoutData<FieldIdx: Idx, VariantIdx: Idx> {
/// Says where the fields are located within the layout.
pub fields: FieldsShape<FieldIdx>,
@@ -1570,18 +1712,23 @@ pub struct LayoutS<FieldIdx: Idx, VariantIdx: Idx> {
/// must be taken into account.
pub variants: Variants<FieldIdx, VariantIdx>,
- /// The `abi` defines how this data is passed between functions, and it defines
- /// value restrictions via `valid_range`.
+ /// The `backend_repr` defines how this data will be represented to the codegen backend,
+ /// and encodes value restrictions via `valid_range`.
///
/// Note that this is entirely orthogonal to the recursive structure defined by
/// `variants` and `fields`; for example, `ManuallyDrop<Result<isize, isize>>` has
- /// `Abi::ScalarPair`! So, even with non-`Aggregate` `abi`, `fields` and `variants`
+ /// `IrForm::ScalarPair`! So, even with non-`Memory` `backend_repr`, `fields` and `variants`
/// have to be taken into account to find all fields of this layout.
- pub abi: Abi,
+ pub backend_repr: BackendRepr,
/// The leaf scalar with the largest number of invalid values
/// (i.e. outside of its `valid_range`), if it exists.
pub largest_niche: Option<Niche>,
+ /// Is this type known to be uninhabted?
+ ///
+ /// This is separate from BackendRepr because uninhabited return types can affect ABI,
+ /// especially in the case of by-pointer struct returns, which allocate stack even when unused.
+ pub uninhabited: bool,
pub align: AbiAndPrefAlign,
pub size: Size,
@@ -1595,27 +1742,36 @@ pub struct LayoutS<FieldIdx: Idx, VariantIdx: Idx> {
/// Only used on aarch64-linux, where the argument passing ABI ignores the requested alignment
/// in some cases.
pub unadjusted_abi_align: Align,
+
+ /// The randomization seed based on this type's own repr and its fields.
+ ///
+ /// Since randomization is toggled on a per-crate basis even crates that do not have randomization
+ /// enabled should still calculate a seed so that downstream uses can use it to distinguish different
+ /// types.
+ ///
+ /// For every T and U for which we do not guarantee that a repr(Rust) `Foo<T>` can be coerced or
+ /// transmuted to `Foo<U>` we aim to create probalistically distinct seeds so that Foo can choose
+ /// to reorder its fields based on that information. The current implementation is a conservative
+ /// approximation of this goal.
+ pub randomization_seed: Hash64,
}
-impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx> {
- pub fn scalar<C: HasDataLayout>(cx: &C, scalar: Scalar) -> Self {
- let largest_niche = Niche::from_scalar(cx, Size::ZERO, scalar);
- let size = scalar.size(cx);
- let align = scalar.align(cx);
- LayoutS {
- variants: Variants::Single { index: VariantIdx::new(0) },
- fields: FieldsShape::Primitive,
- abi: Abi::Scalar(scalar),
- largest_niche,
- size,
- align,
- max_repr_align: None,
- unadjusted_abi_align: align.abi,
+impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
+ /// Returns `true` if this is an aggregate type (including a ScalarPair!)
+ pub fn is_aggregate(&self) -> bool {
+ match self.backend_repr {
+ BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. } => false,
+ BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => true,
}
}
+
+ /// Returns `true` if this is an uninhabited type
+ pub fn is_uninhabited(&self) -> bool {
+ self.uninhabited
+ }
}
-impl<FieldIdx: Idx, VariantIdx: Idx> fmt::Debug for LayoutS<FieldIdx, VariantIdx>
+impl<FieldIdx: Idx, VariantIdx: Idx> fmt::Debug for LayoutData<FieldIdx, VariantIdx>
where
FieldsShape<FieldIdx>: fmt::Debug,
Variants<FieldIdx, VariantIdx>: fmt::Debug,
@@ -1624,25 +1780,29 @@ where
// This is how `Layout` used to print before it become
// `Interned<LayoutS>`. We print it like this to avoid having to update
// expected output in a lot of tests.
- let LayoutS {
+ let LayoutData {
size,
align,
- abi,
+ backend_repr,
fields,
largest_niche,
+ uninhabited,
variants,
max_repr_align,
unadjusted_abi_align,
+ randomization_seed,
} = self;
f.debug_struct("Layout")
.field("size", size)
.field("align", align)
- .field("abi", abi)
+ .field("backend_repr", backend_repr)
.field("fields", fields)
.field("largest_niche", largest_niche)
+ .field("uninhabited", uninhabited)
.field("variants", variants)
.field("max_repr_align", max_repr_align)
.field("unadjusted_abi_align", unadjusted_abi_align)
+ .field("randomization_seed", randomization_seed)
.finish()
}
}
@@ -1658,27 +1818,35 @@ pub enum PointerKind {
Box { unpin: bool, global: bool },
}
-/// Note that this information is advisory only, and backends are free to ignore it.
-/// It can only be used to encode potential optimizations, but no critical information.
+/// Encodes extra information we have about a pointer.
+/// Note that this information is advisory only, and backends are free to ignore it:
+/// if the information is wrong, that can cause UB, but if the information is absent,
+/// that must always be okay.
#[derive(Copy, Clone, Debug)]
pub struct PointeeInfo {
- pub size: Size,
- pub align: Align,
/// If this is `None`, then this is a raw pointer, so size and alignment are not guaranteed to
/// be reliable.
pub safe: Option<PointerKind>,
+ /// If `safe` is `Some`, then the pointer is either null or dereferenceable for this many bytes.
+ /// On a function argument, "dereferenceable" here means "dereferenceable for the entire duration
+ /// of this function call", i.e. it is UB for the memory that this pointer points to be freed
+ /// while this function is still running.
+ /// The size can be zero if the pointer is not dereferenceable.
+ pub size: Size,
+ /// If `safe` is `Some`, then the pointer is aligned as indicated.
+ pub align: Align,
}
-impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx> {
+impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
/// Returns `true` if the layout corresponds to an unsized type.
#[inline]
pub fn is_unsized(&self) -> bool {
- self.abi.is_unsized()
+ self.backend_repr.is_unsized()
}
#[inline]
pub fn is_sized(&self) -> bool {
- self.abi.is_sized()
+ self.backend_repr.is_sized()
}
/// Returns `true` if the type is sized and a 1-ZST (meaning it has size 0 and alignment 1).
@@ -1691,24 +1859,27 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx> {
/// Note that this does *not* imply that the type is irrelevant for layout! It can still have
/// non-trivial alignment constraints. You probably want to use `is_1zst` instead.
pub fn is_zst(&self) -> bool {
- match self.abi {
- Abi::Scalar(_) | Abi::ScalarPair(..) | Abi::Vector { .. } => false,
- Abi::Uninhabited => self.size.bytes() == 0,
- Abi::Aggregate { sized } => sized && self.size.bytes() == 0,
+ match self.backend_repr {
+ BackendRepr::Scalar(_)
+ | BackendRepr::ScalarPair(..)
+ | BackendRepr::SimdVector { .. } => false,
+ BackendRepr::Memory { sized } => sized && self.size.bytes() == 0,
}
}
/// Checks if these two `Layout` are equal enough to be considered "the same for all function
/// call ABIs". Note however that real ABIs depend on more details that are not reflected in the
- /// `Layout`; the `PassMode` need to be compared as well.
+ /// `Layout`; the `PassMode` need to be compared as well. Also note that we assume
+ /// aggregates are passed via `PassMode::Indirect` or `PassMode::Cast`; more strict
+ /// checks would otherwise be required.
pub fn eq_abi(&self, other: &Self) -> bool {
// The one thing that we are not capturing here is that for unsized types, the metadata must
// also have the same ABI, and moreover that the same metadata leads to the same size. The
// 2nd point is quite hard to check though.
self.size == other.size
&& self.is_sized() == other.is_sized()
- && self.abi.eq_up_to_validity(&other.abi)
- && self.abi.is_bool() == other.abi.is_bool()
+ && self.backend_repr.eq_up_to_validity(&other.backend_repr)
+ && self.backend_repr.is_bool() == other.backend_repr.is_bool()
&& self.align.abi == other.align.abi
&& self.max_repr_align == other.max_repr_align
&& self.unadjusted_abi_align == other.unadjusted_abi_align
diff --git a/compiler/rustc_arena/Cargo.toml b/compiler/rustc_arena/Cargo.toml
index 382ab2b077547..bbcd8ea6d389d 100644
--- a/compiler/rustc_arena/Cargo.toml
+++ b/compiler/rustc_arena/Cargo.toml
@@ -1,7 +1,7 @@
[package]
name = "rustc_arena"
version = "0.0.0"
-edition = "2021"
+edition = "2024"
[dependencies]
# tidy-alphabetical-start
diff --git a/compiler/rustc_arena/src/lib.rs b/compiler/rustc_arena/src/lib.rs
index 810cb7a9f4598..d3b7e679d171b 100644
--- a/compiler/rustc_arena/src/lib.rs
+++ b/compiler/rustc_arena/src/lib.rs
@@ -21,21 +21,20 @@
#![feature(decl_macro)]
#![feature(dropck_eyepatch)]
#![feature(maybe_uninit_slice)]
-#![feature(new_uninit)]
+#![feature(never_type)]
#![feature(rustc_attrs)]
#![feature(rustdoc_internals)]
-#![feature(strict_provenance)]
+#![feature(unwrap_infallible)]
// tidy-alphabetical-end
-use smallvec::SmallVec;
-
use std::alloc::Layout;
use std::cell::{Cell, RefCell};
use std::marker::PhantomData;
use std::mem::{self, MaybeUninit};
use std::ptr::{self, NonNull};
-use std::slice;
-use std::{cmp, intrinsics};
+use std::{cmp, intrinsics, slice};
+
+use smallvec::SmallVec;
/// This calls the passed function while ensuring it won't be inlined into the caller.
#[inline(never)]
@@ -80,7 +79,7 @@ impl<T> ArenaChunk<T> {
// been initialized.
unsafe {
let slice = self.storage.as_mut();
- ptr::drop_in_place(MaybeUninit::slice_assume_init_mut(&mut slice[..len]));
+ slice[..len].assume_init_drop();
}
}
}
@@ -95,7 +94,7 @@ impl<T> ArenaChunk<T> {
#[inline]
fn end(&mut self) -> *mut T {
unsafe {
- if mem::size_of::<T>() == 0 {
+ if size_of::<T>() == 0 {
// A pointer as large as possible for zero-sized elements.
ptr::without_provenance_mut(!0)
} else {
@@ -153,7 +152,7 @@ impl<T> TypedArena<T> {
}
unsafe {
- if mem::size_of::<T>() == 0 {
+ if size_of::<T>() == 0 {
self.ptr.set(self.ptr.get().wrapping_byte_add(1));
let ptr = ptr::NonNull::<T>::dangling().as_ptr();
// Don't drop the object. This `write` is equivalent to `forget`.
@@ -175,13 +174,13 @@ impl<T> TypedArena<T> {
// FIXME: this should *likely* use `offset_from`, but more
// investigation is needed (including running tests in miri).
let available_bytes = self.end.get().addr() - self.ptr.get().addr();
- let additional_bytes = additional.checked_mul(mem::size_of::<T>()).unwrap();
+ let additional_bytes = additional.checked_mul(size_of::<T>()).unwrap();
available_bytes >= additional_bytes
}
#[inline]
fn alloc_raw_slice(&self, len: usize) -> *mut T {
- assert!(mem::size_of::<T>() != 0);
+ assert!(size_of::<T>() != 0);
assert!(len != 0);
// Ensure the current chunk can fit `len` objects.
@@ -203,6 +202,18 @@ impl<T> TypedArena<T> {
/// storing the elements in the arena.
#[inline]
pub fn alloc_from_iter<I: IntoIterator<Item = T>>(&self, iter: I) -> &mut [T] {
+ self.try_alloc_from_iter(iter.into_iter().map(Ok::<T, !>)).into_ok()
+ }
+
+ /// Allocates the elements of this iterator into a contiguous slice in the `TypedArena`.
+ ///
+ /// Note: for reasons of reentrancy and panic safety we collect into a `SmallVec<[_; 8]>` before
+ /// storing the elements in the arena.
+ #[inline]
+ pub fn try_alloc_from_iter<E>(
+ &self,
+ iter: impl IntoIterator<Item = Result<T, E>>,
+ ) -> Result<&mut [T], E> {
// Despite the similarlty with `DroplessArena`, we cannot reuse their fast case. The reason
// is subtle: these arenas are reentrant. In other words, `iter` may very well be holding a
// reference to `self` and adding elements to the arena during iteration.
@@ -215,20 +226,21 @@ impl<T> TypedArena<T> {
// So we collect all the elements beforehand, which takes care of reentrancy and panic
// safety. This function is much less hot than `DroplessArena::alloc_from_iter`, so it
// doesn't need to be hyper-optimized.
- assert!(mem::size_of::<T>() != 0);
+ assert!(size_of::<T>() != 0);
- let mut vec: SmallVec<[_; 8]> = iter.into_iter().collect();
+ let vec: Result<SmallVec<[T; 8]>, E> = iter.into_iter().collect();
+ let mut vec = vec?;
if vec.is_empty() {
- return &mut [];
+ return Ok(&mut []);
}
// Move the content to the arena by copying and then forgetting it.
let len = vec.len();
let start_ptr = self.alloc_raw_slice(len);
- unsafe {
+ Ok(unsafe {
vec.as_ptr().copy_to_nonoverlapping(start_ptr, len);
vec.set_len(0);
slice::from_raw_parts_mut(start_ptr, len)
- }
+ })
}
/// Grows the arena.
@@ -238,7 +250,7 @@ impl<T> TypedArena<T> {
unsafe {
// We need the element size to convert chunk sizes (ranging from
// PAGE to HUGE_PAGE bytes) to element counts.
- let elem_size = cmp::max(1, mem::size_of::<T>());
+ let elem_size = cmp::max(1, size_of::<T>());
let mut chunks = self.chunks.borrow_mut();
let mut new_cap;
if let Some(last_chunk) = chunks.last_mut() {
@@ -248,7 +260,7 @@ impl<T> TypedArena<T> {
// FIXME: this should *likely* use `offset_from`, but more
// investigation is needed (including running tests in miri).
let used_bytes = self.ptr.get().addr() - last_chunk.start().addr();
- last_chunk.entries = used_bytes / mem::size_of::<T>();
+ last_chunk.entries = used_bytes / size_of::<T>();
}
// If the previous chunk's len is less than HUGE_PAGE
@@ -278,7 +290,7 @@ impl<T> TypedArena<T> {
let end = self.ptr.get().addr();
// We then calculate the number of elements to be dropped in the last chunk,
// which is the filled area's length.
- let diff = if mem::size_of::<T>() == 0 {
+ let diff = if size_of::<T>() == 0 {
// `T` is ZST. It can't have a drop flag, so the value here doesn't matter. We get
// the number of zero-sized values in the last and only chunk, just out of caution.
// Recall that `end` was incremented for each allocated value.
@@ -286,7 +298,7 @@ impl<T> TypedArena<T> {
} else {
// FIXME: this should *likely* use `offset_from`, but more
// investigation is needed (including running tests in miri).
- (end - start) / mem::size_of::<T>()
+ (end - start) / size_of::<T>()
};
// Pass that to the `destroy` method.
unsafe {
@@ -331,7 +343,7 @@ fn align_up(val: usize, align: usize) -> usize {
// Pointer alignment is common in compiler types, so keep `DroplessArena` aligned to them
// to optimize away alignment code.
-const DROPLESS_ALIGNMENT: usize = mem::align_of::<usize>();
+const DROPLESS_ALIGNMENT: usize = align_of::<usize>();
/// An arena that can hold objects of multiple different types that impl `Copy`
/// and/or satisfy `!mem::needs_drop`.
@@ -449,7 +461,7 @@ impl DroplessArena {
#[inline]
pub fn alloc<T>(&self, object: T) -> &mut T {
assert!(!mem::needs_drop::<T>());
- assert!(mem::size_of::<T>() != 0);
+ assert!(size_of::<T>() != 0);
let mem = self.alloc_raw(Layout::new::<T>()) as *mut T;
@@ -473,7 +485,7 @@ impl DroplessArena {
T: Copy,
{
assert!(!mem::needs_drop::<T>());
- assert!(mem::size_of::<T>() != 0);
+ assert!(size_of::<T>() != 0);
assert!(!slice.is_empty());
let mem = self.alloc_raw(Layout::for_value::<[T]>(slice)) as *mut T;
@@ -548,7 +560,7 @@ impl DroplessArena {
// Warning: this function is reentrant: `iter` could hold a reference to `&self` and
// allocate additional elements while we're iterating.
let iter = iter.into_iter();
- assert!(mem::size_of::<T>() != 0);
+ assert!(size_of::<T>() != 0);
assert!(!mem::needs_drop::<T>());
let size_hint = iter.size_hint();
@@ -569,26 +581,33 @@ impl DroplessArena {
// `drop`.
unsafe { self.write_from_iter(iter, len, mem) }
}
- (_, _) => {
- outline(move || -> &mut [T] {
- // Takes care of reentrancy.
- let mut vec: SmallVec<[_; 8]> = iter.collect();
- if vec.is_empty() {
- return &mut [];
- }
- // Move the content to the arena by copying it and then forgetting
- // the content of the SmallVec
- unsafe {
- let len = vec.len();
- let start_ptr =
- self.alloc_raw(Layout::for_value::<[T]>(vec.as_slice())) as *mut T;
- vec.as_ptr().copy_to_nonoverlapping(start_ptr, len);
- vec.set_len(0);
- slice::from_raw_parts_mut(start_ptr, len)
- }
- })
- }
+ (_, _) => outline(move || self.try_alloc_from_iter(iter.map(Ok::<T, !>)).into_ok()),
+ }
+ }
+
+ #[inline]
+ pub fn try_alloc_from_iter<T, E>(
+ &self,
+ iter: impl IntoIterator<Item = Result<T, E>>,
+ ) -> Result<&mut [T], E> {
+ // Despite the similarlty with `alloc_from_iter`, we cannot reuse their fast case, as we
+ // cannot know the minimum length of the iterator in this case.
+ assert!(size_of::<T>() != 0);
+
+ // Takes care of reentrancy.
+ let vec: Result<SmallVec<[T; 8]>, E> = iter.into_iter().collect();
+ let mut vec = vec?;
+ if vec.is_empty() {
+ return Ok(&mut []);
}
+ // Move the content to the arena by copying and then forgetting it.
+ let len = vec.len();
+ Ok(unsafe {
+ let start_ptr = self.alloc_raw(Layout::for_value::<[T]>(vec.as_slice())) as *mut T;
+ vec.as_ptr().copy_to_nonoverlapping(start_ptr, len);
+ vec.set_len(0);
+ slice::from_raw_parts_mut(start_ptr, len)
+ })
}
}
@@ -615,34 +634,34 @@ pub macro declare_arena([$($a:tt $name:ident: $ty:ty,)*]) {
pub trait ArenaAllocatable<'tcx, C = rustc_arena::IsNotCopy>: Sized {
#[allow(clippy::mut_from_ref)]
- fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut Self;
+ fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut Self;
#[allow(clippy::mut_from_ref)]
- fn allocate_from_iter<'a>(
- arena: &'a Arena<'tcx>,
+ fn allocate_from_iter(
+ arena: &'tcx Arena<'tcx>,
iter: impl ::std::iter::IntoIterator<Item = Self>,
- ) -> &'a mut [Self];
+ ) -> &'tcx mut [Self];
}
// Any type that impls `Copy` can be arena-allocated in the `DroplessArena`.
impl<'tcx, T: Copy> ArenaAllocatable<'tcx, rustc_arena::IsCopy> for T {
#[inline]
#[allow(clippy::mut_from_ref)]
- fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut Self {
+ fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut Self {
arena.dropless.alloc(self)
}
#[inline]
#[allow(clippy::mut_from_ref)]
- fn allocate_from_iter<'a>(
- arena: &'a Arena<'tcx>,
+ fn allocate_from_iter(
+ arena: &'tcx Arena<'tcx>,
iter: impl ::std::iter::IntoIterator<Item = Self>,
- ) -> &'a mut [Self] {
+ ) -> &'tcx mut [Self] {
arena.dropless.alloc_from_iter(iter)
}
}
$(
impl<'tcx> ArenaAllocatable<'tcx, rustc_arena::IsNotCopy> for $ty {
#[inline]
- fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut Self {
+ fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut Self {
if !::std::mem::needs_drop::<Self>() {
arena.dropless.alloc(self)
} else {
@@ -652,10 +671,10 @@ pub macro declare_arena([$($a:tt $name:ident: $ty:ty,)*]) {
#[inline]
#[allow(clippy::mut_from_ref)]
- fn allocate_from_iter<'a>(
- arena: &'a Arena<'tcx>,
+ fn allocate_from_iter(
+ arena: &'tcx Arena<'tcx>,
iter: impl ::std::iter::IntoIterator<Item = Self>,
- ) -> &'a mut [Self] {
+ ) -> &'tcx mut [Self] {
if !::std::mem::needs_drop::<Self>() {
arena.dropless.alloc_from_iter(iter)
} else {
@@ -668,7 +687,7 @@ pub macro declare_arena([$($a:tt $name:ident: $ty:ty,)*]) {
impl<'tcx> Arena<'tcx> {
#[inline]
#[allow(clippy::mut_from_ref)]
- pub fn alloc<T: ArenaAllocatable<'tcx, C>, C>(&self, value: T) -> &mut T {
+ pub fn alloc<T: ArenaAllocatable<'tcx, C>, C>(&'tcx self, value: T) -> &mut T {
value.allocate_on(self)
}
@@ -692,7 +711,7 @@ pub macro declare_arena([$($a:tt $name:ident: $ty:ty,)*]) {
#[allow(clippy::mut_from_ref)]
pub fn alloc_from_iter<T: ArenaAllocatable<'tcx, C>, C>(
- &self,
+ &'tcx self,
iter: impl ::std::iter::IntoIterator<Item = T>,
) -> &mut [T] {
T::allocate_from_iter(self, iter)
diff --git a/compiler/rustc_arena/src/tests.rs b/compiler/rustc_arena/src/tests.rs
index 49a070badc6de..bfde8abd5893a 100644
--- a/compiler/rustc_arena/src/tests.rs
+++ b/compiler/rustc_arena/src/tests.rs
@@ -1,8 +1,10 @@
extern crate test;
-use super::TypedArena;
use std::cell::Cell;
+
use test::Bencher;
+use super::TypedArena;
+
#[allow(dead_code)]
#[derive(Debug, Eq, PartialEq)]
struct Point {
@@ -30,7 +32,7 @@ impl<T> TypedArena<T> {
}
#[test]
-pub fn test_unused() {
+fn test_unused() {
let arena: TypedArena<Point> = TypedArena::default();
assert!(arena.chunks.borrow().is_empty());
}
@@ -73,7 +75,7 @@ fn test_arena_alloc_nested() {
}
#[test]
-pub fn test_copy() {
+fn test_copy() {
let arena = TypedArena::default();
#[cfg(not(miri))]
const N: usize = 100000;
@@ -85,13 +87,13 @@ pub fn test_copy() {
}
#[bench]
-pub fn bench_copy(b: &mut Bencher) {
+fn bench_copy(b: &mut Bencher) {
let arena = TypedArena::default();
b.iter(|| arena.alloc(Point { x: 1, y: 2, z: 3 }))
}
#[bench]
-pub fn bench_copy_nonarena(b: &mut Bencher) {
+fn bench_copy_nonarena(b: &mut Bencher) {
b.iter(|| {
let _: Box<_> = Box::new(Point { x: 1, y: 2, z: 3 });
})
@@ -104,7 +106,7 @@ struct Noncopy {
}
#[test]
-pub fn test_noncopy() {
+fn test_noncopy() {
let arena = TypedArena::default();
#[cfg(not(miri))]
const N: usize = 100000;
@@ -116,7 +118,7 @@ pub fn test_noncopy() {
}
#[test]
-pub fn test_typed_arena_zero_sized() {
+fn test_typed_arena_zero_sized() {
let arena = TypedArena::default();
#[cfg(not(miri))]
const N: usize = 100000;
@@ -128,7 +130,7 @@ pub fn test_typed_arena_zero_sized() {
}
#[test]
-pub fn test_typed_arena_clear() {
+fn test_typed_arena_clear() {
let mut arena = TypedArena::default();
for _ in 0..10 {
arena.clear();
@@ -143,7 +145,7 @@ pub fn test_typed_arena_clear() {
}
#[bench]
-pub fn bench_typed_arena_clear(b: &mut Bencher) {
+fn bench_typed_arena_clear(b: &mut Bencher) {
let mut arena = TypedArena::default();
b.iter(|| {
arena.alloc(Point { x: 1, y: 2, z: 3 });
@@ -152,7 +154,7 @@ pub fn bench_typed_arena_clear(b: &mut Bencher) {
}
#[bench]
-pub fn bench_typed_arena_clear_100(b: &mut Bencher) {
+fn bench_typed_arena_clear_100(b: &mut Bencher) {
let mut arena = TypedArena::default();
b.iter(|| {
for _ in 0..100 {
@@ -228,7 +230,7 @@ fn test_typed_arena_drop_small_count() {
}
#[bench]
-pub fn bench_noncopy(b: &mut Bencher) {
+fn bench_noncopy(b: &mut Bencher) {
let arena = TypedArena::default();
b.iter(|| {
arena.alloc(Noncopy { string: "hello world".to_string(), array: vec![1, 2, 3, 4, 5] })
@@ -236,7 +238,7 @@ pub fn bench_noncopy(b: &mut Bencher) {
}
#[bench]
-pub fn bench_noncopy_nonarena(b: &mut Bencher) {
+fn bench_noncopy_nonarena(b: &mut Bencher) {
b.iter(|| {
let _: Box<_> =
Box::new(Noncopy { string: "hello world".to_string(), array: vec![1, 2, 3, 4, 5] });
diff --git a/compiler/rustc_ast/Cargo.toml b/compiler/rustc_ast/Cargo.toml
index d33f9666b484c..b2d3b90fc4494 100644
--- a/compiler/rustc_ast/Cargo.toml
+++ b/compiler/rustc_ast/Cargo.toml
@@ -1,17 +1,16 @@
[package]
name = "rustc_ast"
version = "0.0.0"
-edition = "2021"
+edition = "2024"
[dependencies]
-# FIXME: bumping memchr to 2.7.1 causes linker errors in MSVC thin-lto
# tidy-alphabetical-start
bitflags = "2.4.1"
-memchr = "=2.5.0"
+memchr = "2.7.4"
+rustc-literal-escaper = "0.0.2"
rustc_ast_ir = { path = "../rustc_ast_ir" }
rustc_data_structures = { path = "../rustc_data_structures" }
rustc_index = { path = "../rustc_index" }
-rustc_lexer = { path = "../rustc_lexer" }
rustc_macros = { path = "../rustc_macros" }
rustc_serialize = { path = "../rustc_serialize" }
rustc_span = { path = "../rustc_span" }
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 75c656973f963..114b9835b98cf 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -18,28 +18,28 @@
//! - [`Attribute`]: Metadata associated with item.
//! - [`UnOp`], [`BinOp`], and [`BinOpKind`]: Unary and binary operators.
-pub use crate::format::*;
-pub use crate::util::parser::ExprPrecedence;
-pub use rustc_span::AttrId;
+use std::borrow::Cow;
+use std::sync::Arc;
+use std::{cmp, fmt};
+
pub use GenericArgs::*;
pub use UnsafeSource::*;
-
-use crate::ptr::P;
-use crate::token::{self, CommentKind, Delimiter};
-use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
-pub use rustc_ast_ir::{Movability, Mutability};
+pub use rustc_ast_ir::{Movability, Mutability, Pinnedness};
use rustc_data_structures::packed::Pu128;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::tagged_ptr::Tag;
use rustc_macros::{Decodable, Encodable, HashStable_Generic};
-use rustc_span::source_map::{respan, Spanned};
-use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::{ErrorGuaranteed, Span, DUMMY_SP};
-use std::cmp;
-use std::fmt;
-use std::mem;
-use thin_vec::{thin_vec, ThinVec};
+pub use rustc_span::AttrId;
+use rustc_span::source_map::{Spanned, respan};
+use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, sym};
+use thin_vec::{ThinVec, thin_vec};
+
+pub use crate::format::*;
+use crate::ptr::P;
+use crate::token::{self, CommentKind, Delimiter};
+use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
+use crate::util::parser::{ExprPrecedence, Fixity};
/// A "Label" is an identifier of some point in sources,
/// e.g. in the following code:
@@ -100,7 +100,7 @@ pub struct Path {
impl PartialEq<Symbol> for Path {
#[inline]
fn eq(&self, symbol: &Symbol) -> bool {
- self.segments.len() == 1 && { self.segments[0].ident.name == *symbol }
+ matches!(&self.segments[..], [segment] if segment.ident.name == *symbol)
}
}
@@ -120,14 +120,34 @@ impl Path {
Path { segments: thin_vec![PathSegment::from_ident(ident)], span: ident.span, tokens: None }
}
+ pub fn is_ident(&self, name: Symbol) -> bool {
+ if let [segment] = self.segments.as_ref()
+ && segment.args.is_none()
+ && segment.ident.name == name
+ {
+ true
+ } else {
+ false
+ }
+ }
+
pub fn is_global(&self) -> bool {
- !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot
+ self.segments.first().is_some_and(|segment| segment.ident.name == kw::PathRoot)
}
- /// If this path is a single identifier with no arguments, does not ensure
- /// that the path resolves to a const param, the caller should check this.
- pub fn is_potential_trivial_const_arg(&self) -> bool {
- self.segments.len() == 1 && self.segments[0].args.is_none()
+ /// Check if this path is potentially a trivial const arg, i.e., one that can _potentially_
+ /// be represented without an anon const in the HIR.
+ ///
+ /// If `allow_mgca_arg` is true (as should be the case in most situations when
+ /// `#![feature(min_generic_const_args)]` is enabled), then this always returns true
+ /// because all paths are valid.
+ ///
+ /// Otherwise, it returns true iff the path has exactly one segment, and it has no generic args
+ /// (i.e., it is _potentially_ a const parameter).
+ #[tracing::instrument(level = "debug", ret)]
+ pub fn is_potential_trivial_const_arg(&self, allow_mgca_arg: bool) -> bool {
+ allow_mgca_arg
+ || self.segments.len() == 1 && self.segments.iter().all(|seg| seg.args.is_none())
}
}
@@ -242,15 +262,15 @@ impl AngleBracketedArg {
}
}
-impl Into<P<GenericArgs>> for AngleBracketedArgs {
- fn into(self) -> P<GenericArgs> {
- P(GenericArgs::AngleBracketed(self))
+impl From<AngleBracketedArgs> for P<GenericArgs> {
+ fn from(val: AngleBracketedArgs) -> Self {
+ P(GenericArgs::AngleBracketed(val))
}
}
-impl Into<P<GenericArgs>> for ParenthesizedArgs {
- fn into(self) -> P<GenericArgs> {
- P(GenericArgs::Parenthesized(self))
+impl From<ParenthesizedArgs> for P<GenericArgs> {
+ fn from(val: ParenthesizedArgs) -> Self {
+ P(GenericArgs::Parenthesized(val))
}
}
@@ -288,7 +308,8 @@ impl ParenthesizedArgs {
}
}
-pub use crate::node_id::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID};
+use crate::AstDeref;
+pub use crate::node_id::{CRATE_NODE_ID, DUMMY_NODE_ID, NodeId};
/// Modifiers on a trait bound like `~const`, `?` and `!`.
#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug)]
@@ -308,7 +329,7 @@ impl TraitBoundModifiers {
#[derive(Clone, Encodable, Decodable, Debug)]
pub enum GenericBound {
- Trait(PolyTraitRef, TraitBoundModifiers),
+ Trait(PolyTraitRef),
Outlives(Lifetime),
/// Precise capturing syntax: `impl Sized + use<'a>`
Use(ThinVec<PreciseCapturingArg>, Span),
@@ -388,22 +409,15 @@ impl GenericParam {
/// Represents lifetime, type and const parameters attached to a declaration of
/// a function, enum, trait, etc.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Default)]
pub struct Generics {
pub params: ThinVec<GenericParam>,
pub where_clause: WhereClause,
pub span: Span,
}
-impl Default for Generics {
- /// Creates an instance of `Generics`.
- fn default() -> Generics {
- Generics { params: ThinVec::new(), where_clause: Default::default(), span: DUMMY_SP }
- }
-}
-
/// A where-clause in a definition.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Default)]
pub struct WhereClause {
/// `true` if we ate a `where` token.
///
@@ -414,15 +428,25 @@ pub struct WhereClause {
pub span: Span,
}
-impl Default for WhereClause {
- fn default() -> WhereClause {
- WhereClause { has_where_token: false, predicates: ThinVec::new(), span: DUMMY_SP }
+impl WhereClause {
+ pub fn is_empty(&self) -> bool {
+ !self.has_where_token && self.predicates.is_empty()
}
}
/// A single predicate in a where-clause.
#[derive(Clone, Encodable, Decodable, Debug)]
-pub enum WherePredicate {
+pub struct WherePredicate {
+ pub attrs: AttrVec,
+ pub kind: WherePredicateKind,
+ pub id: NodeId,
+ pub span: Span,
+ pub is_placeholder: bool,
+}
+
+/// Predicate kind in where-clause.
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub enum WherePredicateKind {
/// A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`).
BoundPredicate(WhereBoundPredicate),
/// A lifetime predicate (e.g., `'a: 'b + 'c`).
@@ -431,22 +455,11 @@ pub enum WherePredicate {
EqPredicate(WhereEqPredicate),
}
-impl WherePredicate {
- pub fn span(&self) -> Span {
- match self {
- WherePredicate::BoundPredicate(p) => p.span,
- WherePredicate::RegionPredicate(p) => p.span,
- WherePredicate::EqPredicate(p) => p.span,
- }
- }
-}
-
/// A type bound.
///
/// E.g., `for<'c> Foo: Send + Clone + 'c`.
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct WhereBoundPredicate {
- pub span: Span,
/// Any generics from a `for` binding.
pub bound_generic_params: ThinVec<GenericParam>,
/// The type being bounded.
@@ -460,7 +473,6 @@ pub struct WhereBoundPredicate {
/// E.g., `'a: 'b + 'c`.
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct WhereRegionPredicate {
- pub span: Span,
pub lifetime: Lifetime,
pub bounds: GenericBounds,
}
@@ -470,7 +482,6 @@ pub struct WhereRegionPredicate {
/// E.g., `T = int`.
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct WhereEqPredicate {
- pub span: Span,
pub lhs_ty: P<Ty>,
pub rhs_ty: P<Ty>,
}
@@ -511,7 +522,7 @@ pub enum MetaItemKind {
/// List meta item.
///
/// E.g., `#[derive(..)]`, where the field represents the `..`.
- List(ThinVec<NestedMetaItem>),
+ List(ThinVec<MetaItemInner>),
/// Name value meta item.
///
@@ -523,7 +534,7 @@ pub enum MetaItemKind {
///
/// E.g., each of `Clone`, `Copy` in `#[derive(Clone, Copy)]`.
#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
-pub enum NestedMetaItem {
+pub enum MetaItemInner {
/// A full MetaItem, for recursive meta items.
MetaItem(MetaItem),
@@ -545,14 +556,6 @@ pub struct Block {
pub rules: BlockCheckMode,
pub span: Span,
pub tokens: Option<LazyAttrTokenStream>,
- /// The following *isn't* a parse error, but will cause multiple errors in following stages.
- /// ```compile_fail
- /// let x = {
- /// foo: var
- /// };
- /// ```
- /// #34255
- pub could_be_bare_literal: bool,
}
/// A match pattern.
@@ -571,6 +574,7 @@ impl Pat {
/// This is intended for use by diagnostics.
pub fn to_ty(&self) -> Option<P<Ty>> {
let kind = match &self.kind {
+ PatKind::Missing => unreachable!(),
// In a type expression `_` is an inference variable.
PatKind::Wild => TyKind::Infer,
// An IDENT pattern with no binding mode would be valid as path to a type. E.g. `u32`.
@@ -585,7 +589,9 @@ impl Pat {
}
// A slice/array pattern `[P]` can be reparsed as `[T]`, an unsized array,
// when `P` can be reparsed as a type `T`.
- PatKind::Slice(pats) if pats.len() == 1 => pats[0].to_ty().map(TyKind::Slice)?,
+ PatKind::Slice(pats) if let [pat] = pats.as_slice() => {
+ pat.to_ty().map(TyKind::Slice)?
+ }
// A tuple pattern `(P0, .., Pn)` can be reparsed as `(T0, .., Tn)`
// assuming `T0` to `Tn` are all syntactically valid as types.
PatKind::Tuple(pats) => {
@@ -624,15 +630,18 @@ impl Pat {
| PatKind::Or(s) => s.iter().for_each(|p| p.walk(it)),
// Trivial wrappers over inner patterns.
- PatKind::Box(s) | PatKind::Deref(s) | PatKind::Ref(s, _) | PatKind::Paren(s) => {
- s.walk(it)
- }
+ PatKind::Box(s)
+ | PatKind::Deref(s)
+ | PatKind::Ref(s, _)
+ | PatKind::Paren(s)
+ | PatKind::Guard(s, _) => s.walk(it),
// These patterns do not contain subpatterns, skip.
- PatKind::Wild
+ PatKind::Missing
+ | PatKind::Wild
| PatKind::Rest
| PatKind::Never
- | PatKind::Lit(_)
+ | PatKind::Expr(_)
| PatKind::Range(..)
| PatKind::Ident(..)
| PatKind::Path(..)
@@ -680,6 +689,7 @@ impl Pat {
/// Return a name suitable for diagnostics.
pub fn descr(&self) -> Option<String> {
match &self.kind {
+ PatKind::Missing => unreachable!(),
PatKind::Wild => Some("_".to_string()),
PatKind::Ident(BindingMode::NONE, ident, None) => Some(format!("{ident}")),
PatKind::Ref(pat, mutbl) => pat.descr().map(|d| format!("&{}{d}", mutbl.prefix_str())),
@@ -773,6 +783,9 @@ pub enum RangeSyntax {
// Adding a new variant? Please update `test_pat` in `tests/ui/macros/stringify.rs`.
#[derive(Clone, Encodable, Decodable, Debug)]
pub enum PatKind {
+ /// A missing pattern, e.g. for an anonymous param in a bare fn like `fn f(u32)`.
+ Missing,
+
/// Represents a wildcard pattern (`_`).
Wild,
@@ -810,8 +823,8 @@ pub enum PatKind {
/// A reference pattern (e.g., `&mut (a, b)`).
Ref(P<Pat>, Mutability),
- /// A literal.
- Lit(P<Expr>),
+ /// A literal, const block or path.
+ Expr(P<Expr>),
/// A range pattern (e.g., `1...2`, `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
Range(Option<P<Expr>>, Option<P<Expr>>, Spanned<RangeEnd>),
@@ -836,6 +849,9 @@ pub enum PatKind {
// A never pattern `!`.
Never,
+ /// A guard pattern (e.g., `x if guard(x)`).
+ Guard(P<Pat>, P<Expr>),
+
/// Parentheses in patterns used for grouping (i.e., `(PAT)`).
Paren(P<Pat>),
@@ -851,6 +867,8 @@ pub enum PatKind {
pub enum PatFieldsRest {
/// `module::StructName { field, ..}`
Rest,
+ /// `module::StructName { field, syntax error }`
+ Recovered(ErrorGuaranteed),
/// `module::StructName { field }`
None,
}
@@ -939,8 +957,37 @@ impl BinOpKind {
matches!(self, BinOpKind::And | BinOpKind::Or)
}
+ pub fn precedence(&self) -> ExprPrecedence {
+ use BinOpKind::*;
+ match *self {
+ Mul | Div | Rem => ExprPrecedence::Product,
+ Add | Sub => ExprPrecedence::Sum,
+ Shl | Shr => ExprPrecedence::Shift,
+ BitAnd => ExprPrecedence::BitAnd,
+ BitXor => ExprPrecedence::BitXor,
+ BitOr => ExprPrecedence::BitOr,
+ Lt | Gt | Le | Ge | Eq | Ne => ExprPrecedence::Compare,
+ And => ExprPrecedence::LAnd,
+ Or => ExprPrecedence::LOr,
+ }
+ }
+
+ pub fn fixity(&self) -> Fixity {
+ use BinOpKind::*;
+ match self {
+ Eq | Ne | Lt | Le | Gt | Ge => Fixity::None,
+ Add | Sub | Mul | Div | Rem | And | Or | BitXor | BitAnd | BitOr | Shl | Shr => {
+ Fixity::Left
+ }
+ }
+ }
+
pub fn is_comparison(self) -> bool {
- crate::util::parser::AssocOp::from_ast_binop(self).is_comparison()
+ use BinOpKind::*;
+ match self {
+ Eq | Ne | Lt | Le | Gt | Ge => true,
+ Add | Sub | Mul | Div | Rem | And | Or | BitXor | BitAnd | BitOr | Shl | Shr => false,
+ }
}
/// Returns `true` if the binary operator takes its arguments by value.
@@ -951,6 +998,75 @@ impl BinOpKind {
pub type BinOp = Spanned<BinOpKind>;
+// Sometimes `BinOpKind` and `AssignOpKind` need the same treatment. The
+// operations covered by `AssignOpKind` are a subset of those covered by
+// `BinOpKind`, so it makes sense to convert `AssignOpKind` to `BinOpKind`.
+impl From<AssignOpKind> for BinOpKind {
+ fn from(op: AssignOpKind) -> BinOpKind {
+ match op {
+ AssignOpKind::AddAssign => BinOpKind::Add,
+ AssignOpKind::SubAssign => BinOpKind::Sub,
+ AssignOpKind::MulAssign => BinOpKind::Mul,
+ AssignOpKind::DivAssign => BinOpKind::Div,
+ AssignOpKind::RemAssign => BinOpKind::Rem,
+ AssignOpKind::BitXorAssign => BinOpKind::BitXor,
+ AssignOpKind::BitAndAssign => BinOpKind::BitAnd,
+ AssignOpKind::BitOrAssign => BinOpKind::BitOr,
+ AssignOpKind::ShlAssign => BinOpKind::Shl,
+ AssignOpKind::ShrAssign => BinOpKind::Shr,
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
+pub enum AssignOpKind {
+ /// The `+=` operator (addition)
+ AddAssign,
+ /// The `-=` operator (subtraction)
+ SubAssign,
+ /// The `*=` operator (multiplication)
+ MulAssign,
+ /// The `/=` operator (division)
+ DivAssign,
+ /// The `%=` operator (modulus)
+ RemAssign,
+ /// The `^=` operator (bitwise xor)
+ BitXorAssign,
+ /// The `&=` operator (bitwise and)
+ BitAndAssign,
+ /// The `|=` operator (bitwise or)
+ BitOrAssign,
+ /// The `<<=` operator (shift left)
+ ShlAssign,
+ /// The `>>=` operator (shift right)
+ ShrAssign,
+}
+
+impl AssignOpKind {
+ pub fn as_str(&self) -> &'static str {
+ use AssignOpKind::*;
+ match self {
+ AddAssign => "+=",
+ SubAssign => "-=",
+ MulAssign => "*=",
+ DivAssign => "/=",
+ RemAssign => "%=",
+ BitXorAssign => "^=",
+ BitAndAssign => "&=",
+ BitOrAssign => "|=",
+ ShlAssign => "<<=",
+ ShrAssign => ">>=",
+ }
+ }
+
+ /// AssignOps are always by value.
+ pub fn is_by_value(self) -> bool {
+ true
+ }
+}
+
+pub type AssignOp = Spanned<AssignOpKind>;
+
/// Unary operator.
///
/// Note that `&data` is not an operator, it's an `AddrOf` expression.
@@ -1070,6 +1186,7 @@ pub enum MacStmtStyle {
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct Local {
pub id: NodeId,
+ pub super_: Option<Span>,
pub pat: P<Pat>,
pub ty: Option<P<Ty>>,
pub kind: LocalKind,
@@ -1179,37 +1296,81 @@ pub struct Expr {
}
impl Expr {
- /// Is this expr either `N`, or `{ N }`.
+ /// Check if this expression is potentially a trivial const arg, i.e., one that can _potentially_
+ /// be represented without an anon const in the HIR.
///
- /// If this is not the case, name resolution does not resolve `N` when using
- /// `min_const_generics` as more complex expressions are not supported.
+ /// This will unwrap at most one block level (curly braces). After that, if the expression
+ /// is a path, it mostly dispatches to [`Path::is_potential_trivial_const_arg`].
+ /// See there for more info about `allow_mgca_arg`.
///
- /// Does not ensure that the path resolves to a const param, the caller should check this.
- pub fn is_potential_trivial_const_arg(&self) -> bool {
- let this = if let ExprKind::Block(block, None) = &self.kind
- && block.stmts.len() == 1
- && let StmtKind::Expr(expr) = &block.stmts[0].kind
+ /// The only additional thing to note is that when `allow_mgca_arg` is false, this function
+ /// will only allow paths with no qself, before dispatching to the `Path` function of
+ /// the same name.
+ ///
+ /// Does not ensure that the path resolves to a const param/item, the caller should check this.
+ /// This also does not consider macros, so it's only correct after macro-expansion.
+ pub fn is_potential_trivial_const_arg(&self, allow_mgca_arg: bool) -> bool {
+ let this = self.maybe_unwrap_block();
+ if allow_mgca_arg {
+ matches!(this.kind, ExprKind::Path(..))
+ } else {
+ if let ExprKind::Path(None, path) = &this.kind
+ && path.is_potential_trivial_const_arg(allow_mgca_arg)
+ {
+ true
+ } else {
+ false
+ }
+ }
+ }
+
+ /// Returns an expression with (when possible) *one* outter brace removed
+ pub fn maybe_unwrap_block(&self) -> &Expr {
+ if let ExprKind::Block(block, None) = &self.kind
+ && let [stmt] = block.stmts.as_slice()
+ && let StmtKind::Expr(expr) = &stmt.kind
{
expr
} else {
self
- };
+ }
+ }
- if let ExprKind::Path(None, path) = &this.kind
- && path.is_potential_trivial_const_arg()
- {
- true
- } else {
- false
+ /// Determines whether this expression is a macro call optionally wrapped in braces . If
+ /// `already_stripped_block` is set then we do not attempt to peel off a layer of braces.
+ ///
+ /// Returns the [`NodeId`] of the macro call and whether a layer of braces has been peeled
+ /// either before, or part of, this function.
+ pub fn optionally_braced_mac_call(
+ &self,
+ already_stripped_block: bool,
+ ) -> Option<(bool, NodeId)> {
+ match &self.kind {
+ ExprKind::Block(block, None)
+ if let [stmt] = &*block.stmts
+ && !already_stripped_block =>
+ {
+ match &stmt.kind {
+ StmtKind::MacCall(_) => Some((true, stmt.id)),
+ StmtKind::Expr(expr) if let ExprKind::MacCall(_) = &expr.kind => {
+ Some((true, expr.id))
+ }
+ _ => None,
+ }
+ }
+ ExprKind::MacCall(_) => Some((already_stripped_block, self.id)),
+ _ => None,
}
}
pub fn to_bound(&self) -> Option<GenericBound> {
match &self.kind {
- ExprKind::Path(None, path) => Some(GenericBound::Trait(
- PolyTraitRef::new(ThinVec::new(), path.clone(), self.span),
+ ExprKind::Path(None, path) => Some(GenericBound::Trait(PolyTraitRef::new(
+ ThinVec::new(),
+ path.clone(),
TraitBoundModifiers::NONE,
- )),
+ self.span,
+ ))),
_ => None,
}
}
@@ -1248,7 +1409,9 @@ impl Expr {
expr.to_ty().map(|ty| TyKind::Array(ty, expr_len.clone()))?
}
- ExprKind::Array(exprs) if exprs.len() == 1 => exprs[0].to_ty().map(TyKind::Slice)?,
+ ExprKind::Array(exprs) if let [expr] = exprs.as_slice() => {
+ expr.to_ty().map(TyKind::Slice)?
+ }
ExprKind::Tup(exprs) => {
let tys = exprs.iter().map(|expr| expr.to_ty()).collect::<Option<ThinVec<_>>>()?;
@@ -1276,51 +1439,77 @@ impl Expr {
}
pub fn precedence(&self) -> ExprPrecedence {
- match self.kind {
- ExprKind::Array(_) => ExprPrecedence::Array,
- ExprKind::ConstBlock(_) => ExprPrecedence::ConstBlock,
- ExprKind::Call(..) => ExprPrecedence::Call,
- ExprKind::MethodCall(..) => ExprPrecedence::MethodCall,
- ExprKind::Tup(_) => ExprPrecedence::Tup,
- ExprKind::Binary(op, ..) => ExprPrecedence::Binary(op.node),
- ExprKind::Unary(..) => ExprPrecedence::Unary,
- ExprKind::Lit(_) | ExprKind::IncludedBytes(..) => ExprPrecedence::Lit,
- ExprKind::Type(..) | ExprKind::Cast(..) => ExprPrecedence::Cast,
- ExprKind::Let(..) => ExprPrecedence::Let,
- ExprKind::If(..) => ExprPrecedence::If,
- ExprKind::While(..) => ExprPrecedence::While,
- ExprKind::ForLoop { .. } => ExprPrecedence::ForLoop,
- ExprKind::Loop(..) => ExprPrecedence::Loop,
- ExprKind::Match(_, _, MatchKind::Prefix) => ExprPrecedence::Match,
- ExprKind::Match(_, _, MatchKind::Postfix) => ExprPrecedence::PostfixMatch,
- ExprKind::Closure(..) => ExprPrecedence::Closure,
- ExprKind::Block(..) => ExprPrecedence::Block,
- ExprKind::TryBlock(..) => ExprPrecedence::TryBlock,
- ExprKind::Gen(..) => ExprPrecedence::Gen,
- ExprKind::Await(..) => ExprPrecedence::Await,
- ExprKind::Assign(..) => ExprPrecedence::Assign,
- ExprKind::AssignOp(..) => ExprPrecedence::AssignOp,
- ExprKind::Field(..) => ExprPrecedence::Field,
- ExprKind::Index(..) => ExprPrecedence::Index,
+ match &self.kind {
+ ExprKind::Closure(closure) => {
+ match closure.fn_decl.output {
+ FnRetTy::Default(_) => ExprPrecedence::Jump,
+ FnRetTy::Ty(_) => ExprPrecedence::Unambiguous,
+ }
+ }
+
+ ExprKind::Break(..)
+ | ExprKind::Ret(..)
+ | ExprKind::Yield(..)
+ | ExprKind::Yeet(..)
+ | ExprKind::Become(..) => ExprPrecedence::Jump,
+
+ // `Range` claims to have higher precedence than `Assign`, but `x .. x = x` fails to
+ // parse, instead of parsing as `(x .. x) = x`. Giving `Range` a lower precedence
+ // ensures that `pprust` will add parentheses in the right places to get the desired
+ // parse.
ExprKind::Range(..) => ExprPrecedence::Range,
- ExprKind::Underscore => ExprPrecedence::Path,
- ExprKind::Path(..) => ExprPrecedence::Path,
- ExprKind::AddrOf(..) => ExprPrecedence::AddrOf,
- ExprKind::Break(..) => ExprPrecedence::Break,
- ExprKind::Continue(..) => ExprPrecedence::Continue,
- ExprKind::Ret(..) => ExprPrecedence::Ret,
- ExprKind::InlineAsm(..) => ExprPrecedence::InlineAsm,
- ExprKind::OffsetOf(..) => ExprPrecedence::OffsetOf,
- ExprKind::MacCall(..) => ExprPrecedence::Mac,
- ExprKind::Struct(..) => ExprPrecedence::Struct,
- ExprKind::Repeat(..) => ExprPrecedence::Repeat,
- ExprKind::Paren(..) => ExprPrecedence::Paren,
- ExprKind::Try(..) => ExprPrecedence::Try,
- ExprKind::Yield(..) => ExprPrecedence::Yield,
- ExprKind::Yeet(..) => ExprPrecedence::Yeet,
- ExprKind::FormatArgs(..) => ExprPrecedence::FormatArgs,
- ExprKind::Become(..) => ExprPrecedence::Become,
- ExprKind::Err(_) | ExprKind::Dummy => ExprPrecedence::Err,
+
+ // Binop-like expr kinds, handled by `AssocOp`.
+ ExprKind::Binary(op, ..) => op.node.precedence(),
+ ExprKind::Cast(..) => ExprPrecedence::Cast,
+
+ ExprKind::Assign(..) |
+ ExprKind::AssignOp(..) => ExprPrecedence::Assign,
+
+ // Unary, prefix
+ ExprKind::AddrOf(..)
+ // Here `let pats = expr` has `let pats =` as a "unary" prefix of `expr`.
+ // However, this is not exactly right. When `let _ = a` is the LHS of a binop we
+ // need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
+ // but we need to print `(let _ = a) < b` as-is with parens.
+ | ExprKind::Let(..)
+ | ExprKind::Unary(..) => ExprPrecedence::Prefix,
+
+ // Never need parens
+ ExprKind::Array(_)
+ | ExprKind::Await(..)
+ | ExprKind::Use(..)
+ | ExprKind::Block(..)
+ | ExprKind::Call(..)
+ | ExprKind::ConstBlock(_)
+ | ExprKind::Continue(..)
+ | ExprKind::Field(..)
+ | ExprKind::ForLoop { .. }
+ | ExprKind::FormatArgs(..)
+ | ExprKind::Gen(..)
+ | ExprKind::If(..)
+ | ExprKind::IncludedBytes(..)
+ | ExprKind::Index(..)
+ | ExprKind::InlineAsm(..)
+ | ExprKind::Lit(_)
+ | ExprKind::Loop(..)
+ | ExprKind::MacCall(..)
+ | ExprKind::Match(..)
+ | ExprKind::MethodCall(..)
+ | ExprKind::OffsetOf(..)
+ | ExprKind::Paren(..)
+ | ExprKind::Path(..)
+ | ExprKind::Repeat(..)
+ | ExprKind::Struct(..)
+ | ExprKind::Try(..)
+ | ExprKind::TryBlock(..)
+ | ExprKind::Tup(_)
+ | ExprKind::Type(..)
+ | ExprKind::Underscore
+ | ExprKind::UnsafeBinderCast(..)
+ | ExprKind::While(..)
+ | ExprKind::Err(_)
+ | ExprKind::Dummy => ExprPrecedence::Unambiguous,
}
}
@@ -1364,6 +1553,15 @@ pub enum RangeLimits {
Closed,
}
+impl RangeLimits {
+ pub fn as_str(&self) -> &'static str {
+ match self {
+ RangeLimits::HalfOpen => "..",
+ RangeLimits::Closed => "..=",
+ }
+ }
+}
+
/// A method call (e.g. `x.foo::<Bar, Baz>(a, b, c)`).
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct MethodCall {
@@ -1435,6 +1633,9 @@ pub enum ExprKind {
/// An `if` block, with an optional `else` block.
///
/// `if expr { block } else { expr }`
+ ///
+ /// If present, the "else" expr is always `ExprKind::Block` (for `else`) or
+ /// `ExprKind::If` (for `else if`).
If(P<Expr>, P<Block>, Option<P<Expr>>),
/// A while loop, with an optional label.
///
@@ -1445,7 +1646,13 @@ pub enum ExprKind {
/// `'label: for await? pat in iter { block }`
///
/// This is desugared to a combination of `loop` and `match` expressions.
- ForLoop { pat: P<Pat>, iter: P<Expr>, body: P<Block>, label: Option<Label>, kind: ForLoopKind },
+ ForLoop {
+ pat: P<Pat>,
+ iter: P<Expr>,
+ body: P<Block>,
+ label: Option<Label>,
+ kind: ForLoopKind,
+ },
/// Conditionless loop (can be exited with `break`, `continue`, or `return`).
///
/// `'label: loop { block }`
@@ -1464,6 +1671,8 @@ pub enum ExprKind {
Gen(CaptureBy, P<Block>, GenBlockKind, Span),
/// An await expression (`my_future.await`). Span is of await keyword.
Await(P<Expr>, Span),
+ /// A use expression (`x.use`). Span is of use keyword.
+ Use(P<Expr>, Span),
/// A try block (`try { ... }`).
TryBlock(P<Block>),
@@ -1474,7 +1683,7 @@ pub enum ExprKind {
/// An assignment with an operator.
///
/// E.g., `a += 1`.
- AssignOp(BinOp, P<Expr>, P<Expr>),
+ AssignOp(AssignOp, P<Expr>, P<Expr>),
/// Access of a named (e.g., `obj.foo`) or unnamed (e.g., `obj.0`) struct field.
Field(P<Expr>, Ident),
/// An indexing operation (e.g., `foo[2]`).
@@ -1530,7 +1739,7 @@ pub enum ExprKind {
Try(P<Expr>),
/// A `yield`, with an optional value to be yielded.
- Yield(Option<P<Expr>>),
+ Yield(YieldKind),
/// A `do yeet` (aka `throw`/`fail`/`bail`/`raise`/whatever),
/// with an optional value to be returned.
@@ -1545,11 +1754,13 @@ pub enum ExprKind {
/// Added for optimization purposes to avoid the need to escape
/// large binary blobs - should always behave like [`ExprKind::Lit`]
/// with a `ByteStr` literal.
- IncludedBytes(Lrc<[u8]>),
+ IncludedBytes(Arc<[u8]>),
/// A `format_args!()` expression.
FormatArgs(P<FormatArgs>),
+ UnsafeBinderCast(UnsafeBinderCastKind, P<Expr>, Option<P<Ty>>),
+
/// Placeholder for an expression that wasn't syntactically well formed in some way.
Err(ErrorGuaranteed),
@@ -1588,6 +1799,16 @@ impl GenBlockKind {
}
}
+/// Whether we're unwrapping or wrapping an unsafe binder
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Encodable, Decodable, HashStable_Generic)]
+pub enum UnsafeBinderCastKind {
+ // e.g. `&i32` -> `unsafe<'a> &'a i32`
+ Wrap,
+ // e.g. `unsafe<'a> &'a i32` -> `&i32`
+ Unwrap,
+}
+
/// The explicit `Self` type in a "qualified path". The actual
/// path, including the trait and the associated item, is stored
/// separately. `position` represents the index of the associated
@@ -1621,8 +1842,17 @@ pub enum CaptureBy {
/// The span of the `move` keyword.
move_kw: Span,
},
- /// `move` keyword was not specified.
+ /// `move` or `use` keywords were not specified.
Ref,
+ /// `use |x| y + x`.
+ ///
+ /// Note that if you have a regular closure like `|| x.use`, this will *not* result
+ /// in a `Use` capture. Instead, the `ExprUseVisitor` will look at the type
+ /// of `x` and treat `x.use` as either a copy/clone/move as appropriate.
+ Use {
+ /// The span of the `use` keyword.
+ use_kw: Span,
+ },
}
/// Closure lifetime binder, `for<'a, 'b>` in `for<'a, 'b> |_: &'a (), _: &'b ()|`.
@@ -1672,21 +1902,11 @@ pub enum AttrArgs {
/// Delimited arguments: `#[attr()/[]/{}]`.
Delimited(DelimArgs),
/// Arguments of a key-value attribute: `#[attr = "value"]`.
- Eq(
+ Eq {
/// Span of the `=` token.
- Span,
- /// The "value".
- AttrArgsEq,
- ),
-}
-
-// The RHS of an `AttrArgs::Eq` starts out as an expression. Once macro
-// expansion is completed, all cases end up either as a meta item literal,
-// which is the form used after lowering to HIR, or as an error.
-#[derive(Clone, Encodable, Decodable, Debug)]
-pub enum AttrArgsEq {
- Ast(P<Expr>),
- Hir(MetaItemLit),
+ eq_span: Span,
+ expr: P<Expr>,
+ },
}
impl AttrArgs {
@@ -1694,10 +1914,7 @@ impl AttrArgs {
match self {
AttrArgs::Empty => None,
AttrArgs::Delimited(args) => Some(args.dspan.entire()),
- AttrArgs::Eq(eq_span, AttrArgsEq::Ast(expr)) => Some(eq_span.to(expr.span)),
- AttrArgs::Eq(_, AttrArgsEq::Hir(lit)) => {
- unreachable!("in literal form when getting span: {:?}", lit);
- }
+ AttrArgs::Eq { eq_span, expr } => Some(eq_span.to(expr.span)),
}
}
@@ -1707,36 +1924,13 @@ impl AttrArgs {
match self {
AttrArgs::Empty => TokenStream::default(),
AttrArgs::Delimited(args) => args.tokens.clone(),
- AttrArgs::Eq(_, AttrArgsEq::Ast(expr)) => TokenStream::from_ast(expr),
- AttrArgs::Eq(_, AttrArgsEq::Hir(lit)) => {
- unreachable!("in literal form when getting inner tokens: {:?}", lit)
- }
- }
- }
-}
-
-impl<CTX> HashStable<CTX> for AttrArgs
-where
- CTX: crate::HashStableContext,
-{
- fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
- mem::discriminant(self).hash_stable(ctx, hasher);
- match self {
- AttrArgs::Empty => {}
- AttrArgs::Delimited(args) => args.hash_stable(ctx, hasher),
- AttrArgs::Eq(_eq_span, AttrArgsEq::Ast(expr)) => {
- unreachable!("hash_stable {:?}", expr);
- }
- AttrArgs::Eq(eq_span, AttrArgsEq::Hir(lit)) => {
- eq_span.hash_stable(ctx, hasher);
- lit.hash_stable(ctx, hasher);
- }
+ AttrArgs::Eq { expr, .. } => TokenStream::from_ast(expr),
}
}
}
/// Delimited arguments, as used in `#[attr()/[]/{}]` or `mac!()/[]/{}`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
pub struct DelimArgs {
pub dspan: DelimSpan,
pub delim: Delimiter, // Note: `Delimiter::Invisible` never occurs
@@ -1751,18 +1945,6 @@ impl DelimArgs {
}
}
-impl<CTX> HashStable<CTX> for DelimArgs
-where
- CTX: crate::HashStableContext,
-{
- fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
- let DelimArgs { dspan, delim, tokens } = self;
- dspan.hash_stable(ctx, hasher);
- delim.hash_stable(ctx, hasher);
- tokens.hash_stable(ctx, hasher);
- }
-}
-
/// Represents a macro definition.
#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
pub struct MacroDef {
@@ -1791,6 +1973,44 @@ pub enum MatchKind {
Postfix,
}
+/// The kind of yield expression
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub enum YieldKind {
+ /// yield expr { ... }
+ Prefix(Option<P<Expr>>),
+ /// expr.yield { ... }
+ Postfix(P<Expr>),
+}
+
+impl YieldKind {
+ /// Returns the expression inside the yield expression, if any.
+ ///
+ /// For postfix yields, this is guaranteed to be `Some`.
+ pub const fn expr(&self) -> Option<&P<Expr>> {
+ match self {
+ YieldKind::Prefix(expr) => expr.as_ref(),
+ YieldKind::Postfix(expr) => Some(expr),
+ }
+ }
+
+ /// Returns a mutable reference to the expression being yielded, if any.
+ pub const fn expr_mut(&mut self) -> Option<&mut P<Expr>> {
+ match self {
+ YieldKind::Prefix(expr) => expr.as_mut(),
+ YieldKind::Postfix(expr) => Some(expr),
+ }
+ }
+
+ /// Returns true if both yields are prefix or both are postfix.
+ pub const fn same_kind(&self, other: &Self) -> bool {
+ match (self, other) {
+ (YieldKind::Prefix(_), YieldKind::Prefix(_)) => true,
+ (YieldKind::Postfix(_), YieldKind::Postfix(_)) => true,
+ _ => false,
+ }
+ }
+}
+
/// A literal in a meta item.
#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
pub struct MetaItemLit {
@@ -1862,9 +2082,9 @@ pub enum LitKind {
Str(Symbol, StrStyle),
/// A byte string (`b"foo"`). Not stored as a symbol because it might be
/// non-utf8, and symbols only allow utf8 strings.
- ByteStr(Lrc<[u8]>, StrStyle),
+ ByteStr(Arc<[u8]>, StrStyle),
/// A C String (`c"foo"`). Guaranteed to only have `\0` at the end.
- CStr(Lrc<[u8]>, StrStyle),
+ CStr(Arc<[u8]>, StrStyle),
/// A byte char (`b'f'`).
Byte(u8),
/// A character literal (`'a'`).
@@ -2125,6 +2345,14 @@ impl Ty {
}
final_ty
}
+
+ pub fn is_maybe_parenthesised_infer(&self) -> bool {
+ match &self.kind {
+ TyKind::Infer => true,
+ TyKind::Paren(inner) => inner.ast_deref().is_maybe_parenthesised_infer(),
+ _ => false,
+ }
+ }
}
#[derive(Clone, Encodable, Decodable, Debug)]
@@ -2138,6 +2366,12 @@ pub struct BareFnTy {
pub decl_span: Span,
}
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub struct UnsafeBinderTy {
+ pub generic_params: ThinVec<GenericParam>,
+ pub inner_ty: P<Ty>,
+}
+
/// The various kinds of type recognized by the compiler.
//
// Adding a new variant? Please update `test_ty` in `tests/ui/macros/stringify.rs`.
@@ -2151,16 +2385,18 @@ pub enum TyKind {
Ptr(MutTy),
/// A reference (`&'a T` or `&'a mut T`).
Ref(Option<Lifetime>, MutTy),
+ /// A pinned reference (`&'a pin const T` or `&'a pin mut T`).
+ ///
+ /// Desugars into `Pin<&'a T>` or `Pin<&'a mut T>`.
+ PinnedRef(Option<Lifetime>, MutTy),
/// A bare function (e.g., `fn(usize) -> bool`).
BareFn(P<BareFnTy>),
+ /// An unsafe existential lifetime binder (e.g., `unsafe<'a> &'a ()`).
+ UnsafeBinder(P<UnsafeBinderTy>),
/// The never type (`!`).
Never,
/// A tuple (`(A, B, C, D,...)`).
Tup(ThinVec<P<Ty>>),
- /// An anonymous struct type i.e. `struct { foo: Type }`.
- AnonStruct(NodeId, ThinVec<FieldDef>),
- /// An anonymous union type i.e. `union { bar: Type }`.
- AnonUnion(NodeId, ThinVec<FieldDef>),
/// A path (`module::module::...::Type`), optionally
/// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
///
@@ -2191,7 +2427,7 @@ pub enum TyKind {
CVarArgs,
/// Pattern types like `pattern_type!(u32 is 1..=)`, which is the same as `NonZero<u32>`,
/// just as part of the type system.
- Pat(P<Ty>, P<Pat>),
+ Pat(P<Ty>, P<TyPat>),
/// Sometimes we need a dummy value when no error has occurred.
Dummy,
/// Placeholder for a kind that has failed to be defined.
@@ -2217,18 +2453,59 @@ impl TyKind {
None
}
}
+}
- pub fn is_anon_adt(&self) -> bool {
- matches!(self, TyKind::AnonStruct(..) | TyKind::AnonUnion(..))
- }
+/// A pattern type pattern.
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub struct TyPat {
+ pub id: NodeId,
+ pub kind: TyPatKind,
+ pub span: Span,
+ pub tokens: Option<LazyAttrTokenStream>,
+}
+
+/// All the different flavors of pattern that Rust recognizes.
+//
+// Adding a new variant? Please update `test_pat` in `tests/ui/macros/stringify.rs`.
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub enum TyPatKind {
+ /// A range pattern (e.g., `1...2`, `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
+ Range(Option<P<AnonConst>>, Option<P<AnonConst>>, Spanned<RangeEnd>),
+
+ Or(ThinVec<P<TyPat>>),
+
+ /// Placeholder for a pattern that wasn't syntactically well formed in some way.
+ Err(ErrorGuaranteed),
}
/// Syntax used to declare a trait object.
#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[repr(u8)]
pub enum TraitObjectSyntax {
- Dyn,
- DynStar,
- None,
+ // SAFETY: When adding new variants make sure to update the `Tag` impl.
+ Dyn = 0,
+ DynStar = 1,
+ None = 2,
+}
+
+/// SAFETY: `TraitObjectSyntax` only has 3 data-less variants which means
+/// it can be represented with a `u2`. We use `repr(u8)` to guarantee the
+/// discriminants of the variants are no greater than `3`.
+unsafe impl Tag for TraitObjectSyntax {
+ const BITS: u32 = 2;
+
+ fn into_usize(self) -> usize {
+ self as u8 as usize
+ }
+
+ unsafe fn from_usize(tag: usize) -> Self {
+ match tag {
+ 0 => TraitObjectSyntax::Dyn,
+ 1 => TraitObjectSyntax::DynStar,
+ 2 => TraitObjectSyntax::None,
+ _ => unreachable!(),
+ }
+ }
}
#[derive(Clone, Encodable, Decodable, Debug)]
@@ -2264,6 +2541,47 @@ bitflags::bitflags! {
}
}
+impl InlineAsmOptions {
+ pub const COUNT: usize = Self::all().bits().count_ones() as usize;
+
+ pub const GLOBAL_OPTIONS: Self = Self::ATT_SYNTAX.union(Self::RAW);
+ pub const NAKED_OPTIONS: Self = Self::ATT_SYNTAX.union(Self::RAW);
+
+ pub fn human_readable_names(&self) -> Vec<&'static str> {
+ let mut options = vec![];
+
+ if self.contains(InlineAsmOptions::PURE) {
+ options.push("pure");
+ }
+ if self.contains(InlineAsmOptions::NOMEM) {
+ options.push("nomem");
+ }
+ if self.contains(InlineAsmOptions::READONLY) {
+ options.push("readonly");
+ }
+ if self.contains(InlineAsmOptions::PRESERVES_FLAGS) {
+ options.push("preserves_flags");
+ }
+ if self.contains(InlineAsmOptions::NORETURN) {
+ options.push("noreturn");
+ }
+ if self.contains(InlineAsmOptions::NOSTACK) {
+ options.push("nostack");
+ }
+ if self.contains(InlineAsmOptions::ATT_SYNTAX) {
+ options.push("att_syntax");
+ }
+ if self.contains(InlineAsmOptions::RAW) {
+ options.push("raw");
+ }
+ if self.contains(InlineAsmOptions::MAY_UNWIND) {
+ options.push("may_unwind");
+ }
+
+ options
+ }
+}
+
impl std::fmt::Debug for InlineAsmOptions {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
bitflags::parser::to_writer(self, f)
@@ -2272,7 +2590,7 @@ impl std::fmt::Debug for InlineAsmOptions {
#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Hash, HashStable_Generic)]
pub enum InlineAsmTemplatePiece {
- String(String),
+ String(Cow<'static, str>),
Placeholder { operand_idx: usize, modifier: Option<char>, span: Span },
}
@@ -2373,11 +2691,48 @@ impl InlineAsmOperand {
}
}
+#[derive(Clone, Copy, Encodable, Decodable, Debug, HashStable_Generic)]
+pub enum AsmMacro {
+ /// The `asm!` macro
+ Asm,
+ /// The `global_asm!` macro
+ GlobalAsm,
+ /// The `naked_asm!` macro
+ NakedAsm,
+}
+
+impl AsmMacro {
+ pub const fn macro_name(self) -> &'static str {
+ match self {
+ AsmMacro::Asm => "asm",
+ AsmMacro::GlobalAsm => "global_asm",
+ AsmMacro::NakedAsm => "naked_asm",
+ }
+ }
+
+ pub const fn is_supported_option(self, option: InlineAsmOptions) -> bool {
+ match self {
+ AsmMacro::Asm => true,
+ AsmMacro::GlobalAsm => InlineAsmOptions::GLOBAL_OPTIONS.contains(option),
+ AsmMacro::NakedAsm => InlineAsmOptions::NAKED_OPTIONS.contains(option),
+ }
+ }
+
+ pub const fn diverges(self, options: InlineAsmOptions) -> bool {
+ match self {
+ AsmMacro::Asm => options.contains(InlineAsmOptions::NORETURN),
+ AsmMacro::GlobalAsm => true,
+ AsmMacro::NakedAsm => true,
+ }
+ }
+}
+
/// Inline assembly.
///
/// E.g., `asm!("NOP");`.
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct InlineAsm {
+ pub asm_macro: AsmMacro,
pub template: Vec<InlineAsmTemplatePiece>,
pub template_strs: Box<[(Symbol, Option<Symbol>, Span)]>,
pub operands: Vec<(InlineAsmOperand, Span)>,
@@ -2408,10 +2763,26 @@ pub enum SelfKind {
Value(Mutability),
/// `&'lt self`, `&'lt mut self`
Region(Option<Lifetime>, Mutability),
+ /// `&'lt pin const self`, `&'lt pin mut self`
+ Pinned(Option<Lifetime>, Mutability),
/// `self: TYPE`, `mut self: TYPE`
Explicit(P<Ty>, Mutability),
}
+impl SelfKind {
+ pub fn to_ref_suggestion(&self) -> String {
+ match self {
+ SelfKind::Region(None, mutbl) => mutbl.ref_prefix_str().to_string(),
+ SelfKind::Region(Some(lt), mutbl) => format!("&{lt} {}", mutbl.prefix_str()),
+ SelfKind::Pinned(None, mutbl) => format!("&pin {}", mutbl.ptr_str()),
+ SelfKind::Pinned(Some(lt), mutbl) => format!("&{lt} pin {}", mutbl.ptr_str()),
+ SelfKind::Value(_) | SelfKind::Explicit(_, _) => {
+ unreachable!("if we had an explicit self, we wouldn't be here")
+ }
+ }
+ }
+}
+
pub type ExplicitSelf = Spanned<SelfKind>;
impl Param {
@@ -2424,6 +2795,11 @@ impl Param {
TyKind::Ref(lt, MutTy { ref ty, mutbl }) if ty.kind.is_implicit_self() => {
Some(respan(self.pat.span, SelfKind::Region(lt, mutbl)))
}
+ TyKind::PinnedRef(lt, MutTy { ref ty, mutbl })
+ if ty.kind.is_implicit_self() =>
+ {
+ Some(respan(self.pat.span, SelfKind::Pinned(lt, mutbl)))
+ }
_ => Some(respan(
self.pat.span.to(self.ty.span),
SelfKind::Explicit(self.ty.clone(), mutbl),
@@ -2464,6 +2840,15 @@ impl Param {
tokens: None,
}),
),
+ SelfKind::Pinned(lt, mutbl) => (
+ mutbl,
+ P(Ty {
+ id: DUMMY_NODE_ID,
+ kind: TyKind::PinnedRef(lt, MutTy { ty: infer_ty, mutbl }),
+ span,
+ tokens: None,
+ }),
+ ),
};
Param {
attrs,
@@ -2546,12 +2931,12 @@ impl CoroutineKind {
}
}
- pub fn is_async(self) -> bool {
- matches!(self, CoroutineKind::Async { .. })
- }
-
- pub fn is_gen(self) -> bool {
- matches!(self, CoroutineKind::Gen { .. })
+ pub fn as_str(self) -> &'static str {
+ match self {
+ CoroutineKind::Async { .. } => "async",
+ CoroutineKind::Gen { .. } => "gen",
+ CoroutineKind::AsyncGen { .. } => "async gen",
+ }
}
pub fn closure_id(self) -> NodeId {
@@ -2608,7 +2993,7 @@ impl fmt::Debug for ImplPolarity {
}
/// The polarity of a trait bound.
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug, Hash)]
#[derive(HashStable_Generic)]
pub enum BoundPolarity {
/// `Type: Trait`
@@ -2630,7 +3015,7 @@ impl BoundPolarity {
}
/// The constness of a trait bound.
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug, Hash)]
#[derive(HashStable_Generic)]
pub enum BoundConstness {
/// `Type: Trait`
@@ -2703,7 +3088,7 @@ pub enum ModKind {
/// or with definition outlined to a separate file `mod foo;` and already loaded from it.
/// The inner span is from the first token past `{` to the last token until `}`,
/// or from the first to the last token in the loaded file.
- Loaded(ThinVec<P<Item>>, Inline, ModSpans),
+ Loaded(ThinVec<P<Item>>, Inline, ModSpans, Result<(), ErrorGuaranteed>),
/// Module with definition outlined to a separate file `mod foo;` but not yet loaded from it.
Unloaded,
}
@@ -2721,6 +3106,8 @@ pub struct ModSpans {
/// E.g., `extern { .. }` or `extern "C" { .. }`.
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct ForeignMod {
+ /// Span of the `extern` keyword.
+ pub extern_span: Span,
/// `unsafe` keyword accepted syntactically for macro DSLs, but not
/// semantically by Rust.
pub safety: Safety,
@@ -2848,7 +3235,7 @@ impl NormalAttr {
}
}
-#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Encodable, Decodable, Debug)]
pub struct AttrItem {
pub unsafety: Safety,
pub path: Path,
@@ -2857,6 +3244,17 @@ pub struct AttrItem {
pub tokens: Option<LazyAttrTokenStream>,
}
+impl AttrItem {
+ pub fn is_valid_for_outer_style(&self) -> bool {
+ self.path == sym::cfg_attr
+ || self.path == sym::cfg
+ || self.path == sym::forbid
+ || self.path == sym::warn
+ || self.path == sym::allow
+ || self.path == sym::deny
+ }
+}
+
/// `TraitRef`s appear in impls.
///
/// Resolution maps each `TraitRef`'s `ref_id` to its defining trait; that's all
@@ -2874,6 +3272,9 @@ pub struct PolyTraitRef {
/// The `'a` in `for<'a> Foo<&'a T>`.
pub bound_generic_params: ThinVec<GenericParam>,
+ // Optional constness, asyncness, or polarity.
+ pub modifiers: TraitBoundModifiers,
+
/// The `Foo<&'a T>` in `<'a> Foo<&'a T>`.
pub trait_ref: TraitRef,
@@ -2881,9 +3282,15 @@ pub struct PolyTraitRef {
}
impl PolyTraitRef {
- pub fn new(generic_params: ThinVec<GenericParam>, path: Path, span: Span) -> Self {
+ pub fn new(
+ generic_params: ThinVec<GenericParam>,
+ path: Path,
+ modifiers: TraitBoundModifiers,
+ span: Span,
+ ) -> Self {
PolyTraitRef {
bound_generic_params: generic_params,
+ modifiers,
trait_ref: TraitRef { path, ref_id: DUMMY_NODE_ID },
span,
}
@@ -2919,9 +3326,11 @@ pub struct FieldDef {
pub id: NodeId,
pub span: Span,
pub vis: Visibility,
+ pub safety: Safety,
pub ident: Option<Ident>,
pub ty: P<Ty>,
+ pub default: Option<AnonConst>,
pub is_placeholder: bool,
}
@@ -2974,9 +3383,6 @@ pub struct Item<K = ItemKind> {
pub id: NodeId,
pub span: Span,
pub vis: Visibility,
- /// The name of the item.
- /// It might be a dummy name in case of anonymous items.
- pub ident: Ident,
pub kind: K,
@@ -2998,23 +3404,23 @@ impl Item {
pub fn opt_generics(&self) -> Option<&Generics> {
match &self.kind {
- ItemKind::ExternCrate(_)
+ ItemKind::ExternCrate(..)
| ItemKind::Use(_)
- | ItemKind::Mod(_, _)
+ | ItemKind::Mod(..)
| ItemKind::ForeignMod(_)
| ItemKind::GlobalAsm(_)
| ItemKind::MacCall(_)
| ItemKind::Delegation(_)
| ItemKind::DelegationMac(_)
- | ItemKind::MacroDef(_) => None,
+ | ItemKind::MacroDef(..) => None,
ItemKind::Static(_) => None,
ItemKind::Const(i) => Some(&i.generics),
ItemKind::Fn(i) => Some(&i.generics),
ItemKind::TyAlias(i) => Some(&i.generics),
- ItemKind::TraitAlias(generics, _)
- | ItemKind::Enum(_, generics)
- | ItemKind::Struct(_, generics)
- | ItemKind::Union(_, generics) => Some(&generics),
+ ItemKind::TraitAlias(_, generics, _)
+ | ItemKind::Enum(_, _, generics)
+ | ItemKind::Struct(_, _, generics)
+ | ItemKind::Union(_, _, generics) => Some(&generics),
ItemKind::Trait(i) => Some(&i.generics),
ItemKind::Impl(i) => Some(&i.generics),
}
@@ -3032,7 +3438,7 @@ pub enum Extern {
///
/// E.g. `extern fn foo() {}`.
///
- /// This is just `extern "C"` (see `rustc_target::spec::abi::Abi::FALLBACK`).
+ /// This is just `extern "C"` (see `rustc_abi::ExternAbi::FALLBACK`).
Implicit(Span),
/// An explicit extern keyword was used with an explicit ABI.
///
@@ -3091,6 +3497,7 @@ impl Default for FnHeader {
pub struct Trait {
pub safety: Safety,
pub is_auto: IsAuto,
+ pub ident: Ident,
pub generics: Generics,
pub bounds: GenericBounds,
pub items: ThinVec<P<AssocItem>>,
@@ -3136,6 +3543,7 @@ pub struct TyAliasWhereClauses {
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct TyAlias {
pub defaultness: Defaultness,
+ pub ident: Ident,
pub generics: Generics,
pub where_clauses: TyAliasWhereClauses,
pub bounds: GenericBounds,
@@ -3155,11 +3563,20 @@ pub struct Impl {
pub items: ThinVec<P<AssocItem>>,
}
+#[derive(Clone, Encodable, Decodable, Debug, Default)]
+pub struct FnContract {
+ pub requires: Option<P<Expr>>,
+ pub ensures: Option<P<Expr>>,
+}
+
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct Fn {
pub defaultness: Defaultness,
+ pub ident: Ident,
pub generics: Generics,
pub sig: FnSig,
+ pub contract: Option<P<FnContract>>,
+ pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
pub body: Option<P<Block>>,
}
@@ -3169,6 +3586,7 @@ pub struct Delegation {
pub id: NodeId,
pub qself: Option<P<QSelf>>,
pub path: Path,
+ pub ident: Ident,
pub rename: Option<Ident>,
pub body: Option<P<Block>>,
/// The item was expanded from a glob delegation item.
@@ -3186,18 +3604,22 @@ pub struct DelegationMac {
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct StaticItem {
+ pub ident: Ident,
pub ty: P<Ty>,
pub safety: Safety,
pub mutability: Mutability,
pub expr: Option<P<Expr>>,
+ pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
}
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct ConstItem {
pub defaultness: Defaultness,
+ pub ident: Ident,
pub generics: Generics,
pub ty: P<Ty>,
pub expr: Option<P<Expr>>,
+ pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
}
// Adding a new variant? Please update `test_item` in `tests/ui/macros/stringify.rs`.
@@ -3206,7 +3628,7 @@ pub enum ItemKind {
/// An `extern crate` item, with the optional *original* crate name if the crate was renamed.
///
/// E.g., `extern crate foo` or `extern crate foo_bar as foo`.
- ExternCrate(Option<Symbol>),
+ ExternCrate(Option<Symbol>, Ident),
/// A use declaration item (`use`).
///
/// E.g., `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`.
@@ -3228,7 +3650,7 @@ pub enum ItemKind {
/// E.g., `mod foo;` or `mod foo { .. }`.
/// `unsafe` keyword on modules is accepted syntactically for macro DSLs, but not
/// semantically by Rust.
- Mod(Safety, ModKind),
+ Mod(Safety, Ident, ModKind),
/// An external module (`extern`).
///
/// E.g., `extern {}` or `extern "C" {}`.
@@ -3242,15 +3664,15 @@ pub enum ItemKind {
/// An enum definition (`enum`).
///
/// E.g., `enum Foo<A, B> { C<A>, D<B> }`.
- Enum(EnumDef, Generics),
+ Enum(Ident, EnumDef, Generics),
/// A struct definition (`struct`).
///
/// E.g., `struct Foo<A> { x: A }`.
- Struct(VariantData, Generics),
+ Struct(Ident, VariantData, Generics),
/// A union definition (`union`).
///
/// E.g., `union Foo<A, B> { x: A, y: B }`.
- Union(VariantData, Generics),
+ Union(Ident, VariantData, Generics),
/// A trait declaration (`trait`).
///
/// E.g., `trait Foo { .. }`, `trait Foo<T> { .. }` or `auto trait Foo {}`.
@@ -3258,7 +3680,7 @@ pub enum ItemKind {
/// Trait alias.
///
/// E.g., `trait Foo = Bar + Quux;`.
- TraitAlias(Generics, GenericBounds),
+ TraitAlias(Ident, Generics, GenericBounds),
/// An implementation.
///
/// E.g., `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`.
@@ -3269,7 +3691,7 @@ pub enum ItemKind {
MacCall(P<MacCall>),
/// A macro definition.
- MacroDef(MacroDef),
+ MacroDef(Ident, MacroDef),
/// A single delegation item (`reuse`).
///
@@ -3281,6 +3703,31 @@ pub enum ItemKind {
}
impl ItemKind {
+ pub fn ident(&self) -> Option<Ident> {
+ match *self {
+ ItemKind::ExternCrate(_, ident)
+ | ItemKind::Static(box StaticItem { ident, .. })
+ | ItemKind::Const(box ConstItem { ident, .. })
+ | ItemKind::Fn(box Fn { ident, .. })
+ | ItemKind::Mod(_, ident, _)
+ | ItemKind::TyAlias(box TyAlias { ident, .. })
+ | ItemKind::Enum(ident, ..)
+ | ItemKind::Struct(ident, ..)
+ | ItemKind::Union(ident, ..)
+ | ItemKind::Trait(box Trait { ident, .. })
+ | ItemKind::TraitAlias(ident, ..)
+ | ItemKind::MacroDef(ident, _)
+ | ItemKind::Delegation(box Delegation { ident, .. }) => Some(ident),
+
+ ItemKind::Use(_)
+ | ItemKind::ForeignMod(_)
+ | ItemKind::GlobalAsm(_)
+ | ItemKind::Impl(_)
+ | ItemKind::MacCall(_)
+ | ItemKind::DelegationMac(_) => None,
+ }
+ }
+
/// "a" or "an"
pub fn article(&self) -> &'static str {
use ItemKind::*;
@@ -3321,11 +3768,11 @@ impl ItemKind {
Self::Fn(box Fn { generics, .. })
| Self::TyAlias(box TyAlias { generics, .. })
| Self::Const(box ConstItem { generics, .. })
- | Self::Enum(_, generics)
- | Self::Struct(_, generics)
- | Self::Union(_, generics)
+ | Self::Enum(_, _, generics)
+ | Self::Struct(_, _, generics)
+ | Self::Union(_, _, generics)
| Self::Trait(box Trait { generics, .. })
- | Self::TraitAlias(generics, _)
+ | Self::TraitAlias(_, generics, _)
| Self::Impl(box Impl { generics, .. }) => Some(generics),
_ => None,
}
@@ -3361,6 +3808,17 @@ pub enum AssocItemKind {
}
impl AssocItemKind {
+ pub fn ident(&self) -> Option<Ident> {
+ match *self {
+ AssocItemKind::Const(box ConstItem { ident, .. })
+ | AssocItemKind::Fn(box Fn { ident, .. })
+ | AssocItemKind::Type(box TyAlias { ident, .. })
+ | AssocItemKind::Delegation(box Delegation { ident, .. }) => Some(ident),
+
+ AssocItemKind::MacCall(_) | AssocItemKind::DelegationMac(_) => None,
+ }
+ }
+
pub fn defaultness(&self) -> Defaultness {
match *self {
Self::Const(box ConstItem { defaultness, .. })
@@ -3407,19 +3865,31 @@ impl TryFrom<ItemKind> for AssocItemKind {
pub enum ForeignItemKind {
/// A foreign static item (`static FOO: u8`).
Static(Box<StaticItem>),
- /// An foreign function.
+ /// A foreign function.
Fn(Box<Fn>),
- /// An foreign type.
+ /// A foreign type.
TyAlias(Box<TyAlias>),
/// A macro expanding to foreign items.
MacCall(P<MacCall>),
}
+impl ForeignItemKind {
+ pub fn ident(&self) -> Option<Ident> {
+ match *self {
+ ForeignItemKind::Static(box StaticItem { ident, .. })
+ | ForeignItemKind::Fn(box Fn { ident, .. })
+ | ForeignItemKind::TyAlias(box TyAlias { ident, .. }) => Some(ident),
+
+ ForeignItemKind::MacCall(_) => None,
+ }
+ }
+}
+
impl From<ForeignItemKind> for ItemKind {
fn from(foreign_item_kind: ForeignItemKind) -> ItemKind {
match foreign_item_kind {
ForeignItemKind::Static(box static_foreign_item) => {
- ItemKind::Static(Box::new(static_foreign_item.into()))
+ ItemKind::Static(Box::new(static_foreign_item))
}
ForeignItemKind::Fn(fn_kind) => ItemKind::Fn(fn_kind),
ForeignItemKind::TyAlias(ty_alias_kind) => ItemKind::TyAlias(ty_alias_kind),
@@ -3433,9 +3903,7 @@ impl TryFrom<ItemKind> for ForeignItemKind {
fn try_from(item_kind: ItemKind) -> Result<ForeignItemKind, ItemKind> {
Ok(match item_kind {
- ItemKind::Static(box static_item) => {
- ForeignItemKind::Static(Box::new(static_item.into()))
- }
+ ItemKind::Static(box static_item) => ForeignItemKind::Static(Box::new(static_item)),
ItemKind::Fn(fn_kind) => ForeignItemKind::Fn(fn_kind),
ItemKind::TyAlias(ty_alias_kind) => ForeignItemKind::TyAlias(ty_alias_kind),
ItemKind::MacCall(a) => ForeignItemKind::MacCall(a),
@@ -3449,26 +3917,27 @@ pub type ForeignItem = Item<ForeignItemKind>;
// Some nodes are used a lot. Make sure they don't unintentionally get bigger.
#[cfg(target_pointer_width = "64")]
mod size_asserts {
- use super::*;
use rustc_data_structures::static_assert_size;
+
+ use super::*;
// tidy-alphabetical-start
- static_assert_size!(AssocItem, 88);
+ static_assert_size!(AssocItem, 80);
static_assert_size!(AssocItemKind, 16);
static_assert_size!(Attribute, 32);
static_assert_size!(Block, 32);
static_assert_size!(Expr, 72);
static_assert_size!(ExprKind, 40);
- static_assert_size!(Fn, 160);
- static_assert_size!(ForeignItem, 88);
+ static_assert_size!(Fn, 184);
+ static_assert_size!(ForeignItem, 80);
static_assert_size!(ForeignItemKind, 16);
static_assert_size!(GenericArg, 24);
static_assert_size!(GenericBound, 88);
static_assert_size!(Generics, 40);
static_assert_size!(Impl, 136);
- static_assert_size!(Item, 136);
- static_assert_size!(ItemKind, 64);
+ static_assert_size!(Item, 144);
+ static_assert_size!(ItemKind, 80);
static_assert_size!(LitKind, 24);
- static_assert_size!(Local, 80);
+ static_assert_size!(Local, 96);
static_assert_size!(MetaItemLit, 40);
static_assert_size!(Param, 40);
static_assert_size!(Pat, 72);
diff --git a/compiler/rustc_ast/src/ast_traits.rs b/compiler/rustc_ast/src/ast_traits.rs
index 7754ca0a0f503..7f98e7ba8a615 100644
--- a/compiler/rustc_ast/src/ast_traits.rs
+++ b/compiler/rustc_ast/src/ast_traits.rs
@@ -2,17 +2,17 @@
//! typically those used in AST fragments during macro expansion.
//! The traits are not implemented exhaustively, only when actually necessary.
-use crate::ptr::P;
-use crate::token::Nonterminal;
-use crate::tokenstream::LazyAttrTokenStream;
-use crate::{Arm, Crate, ExprField, FieldDef, GenericParam, Param, PatField, Variant};
-use crate::{AssocItem, Expr, ForeignItem, Item, NodeId};
-use crate::{AttrItem, AttrKind, Block, Pat, Path, Ty, Visibility};
-use crate::{AttrVec, Attribute, Stmt, StmtKind};
-
use std::fmt;
use std::marker::PhantomData;
+use crate::ptr::P;
+use crate::tokenstream::LazyAttrTokenStream;
+use crate::{
+ Arm, AssocItem, AttrItem, AttrKind, AttrVec, Attribute, Block, Crate, Expr, ExprField,
+ FieldDef, ForeignItem, GenericParam, Item, NodeId, Param, Pat, PatField, Path, Stmt, StmtKind,
+ Ty, Variant, Visibility, WherePredicate,
+};
+
/// A utility trait to reduce boilerplate.
/// Standard `Deref(Mut)` cannot be reused due to coherence.
pub trait AstDeref {
@@ -78,6 +78,7 @@ impl_has_node_id!(
Stmt,
Ty,
Variant,
+ WherePredicate,
);
impl<T: AstDeref<Target: HasNodeId>> HasNodeId for T {
@@ -126,7 +127,16 @@ macro_rules! impl_has_tokens_none {
}
impl_has_tokens!(AssocItem, AttrItem, Block, Expr, ForeignItem, Item, Pat, Path, Ty, Visibility);
-impl_has_tokens_none!(Arm, ExprField, FieldDef, GenericParam, Param, PatField, Variant);
+impl_has_tokens_none!(
+ Arm,
+ ExprField,
+ FieldDef,
+ GenericParam,
+ Param,
+ PatField,
+ Variant,
+ WherePredicate
+);
impl<T: AstDeref<Target: HasTokens>> HasTokens for T {
fn tokens(&self) -> Option<&LazyAttrTokenStream> {
@@ -152,7 +162,7 @@ impl HasTokens for StmtKind {
StmtKind::Let(local) => local.tokens.as_ref(),
StmtKind::Item(item) => item.tokens(),
StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens(),
- StmtKind::Empty => return None,
+ StmtKind::Empty => None,
StmtKind::MacCall(mac) => mac.tokens.as_ref(),
}
}
@@ -161,7 +171,7 @@ impl HasTokens for StmtKind {
StmtKind::Let(local) => Some(&mut local.tokens),
StmtKind::Item(item) => item.tokens_mut(),
StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens_mut(),
- StmtKind::Empty => return None,
+ StmtKind::Empty => None,
StmtKind::MacCall(mac) => Some(&mut mac.tokens),
}
}
@@ -195,35 +205,6 @@ impl HasTokens for Attribute {
}
}
-impl HasTokens for Nonterminal {
- fn tokens(&self) -> Option<&LazyAttrTokenStream> {
- match self {
- Nonterminal::NtItem(item) => item.tokens(),
- Nonterminal::NtStmt(stmt) => stmt.tokens(),
- Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens(),
- Nonterminal::NtPat(pat) => pat.tokens(),
- Nonterminal::NtTy(ty) => ty.tokens(),
- Nonterminal::NtMeta(attr_item) => attr_item.tokens(),
- Nonterminal::NtPath(path) => path.tokens(),
- Nonterminal::NtVis(vis) => vis.tokens(),
- Nonterminal::NtBlock(block) => block.tokens(),
- }
- }
- fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>> {
- match self {
- Nonterminal::NtItem(item) => item.tokens_mut(),
- Nonterminal::NtStmt(stmt) => stmt.tokens_mut(),
- Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens_mut(),
- Nonterminal::NtPat(pat) => pat.tokens_mut(),
- Nonterminal::NtTy(ty) => ty.tokens_mut(),
- Nonterminal::NtMeta(attr_item) => attr_item.tokens_mut(),
- Nonterminal::NtPath(path) => path.tokens_mut(),
- Nonterminal::NtVis(vis) => vis.tokens_mut(),
- Nonterminal::NtBlock(block) => block.tokens_mut(),
- }
- }
-}
-
/// A trait for AST nodes having (or not having) attributes.
pub trait HasAttrs {
/// This is `true` if this `HasAttrs` might support 'custom' (proc-macro) inner
@@ -288,6 +269,7 @@ impl_has_attrs!(
Param,
PatField,
Variant,
+ WherePredicate,
);
impl_has_attrs_none!(Attribute, AttrItem, Block, Pat, Path, Ty, Visibility);
diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index d2c7b1c0753da..f165c4ddcdd4d 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -1,24 +1,25 @@
//! Functions dealing with attributes and meta items.
+use std::fmt::Debug;
+use std::sync::atomic::{AtomicU32, Ordering};
+
+use rustc_index::bit_set::GrowableBitSet;
+use rustc_span::{Ident, Span, Symbol, sym};
+use smallvec::{SmallVec, smallvec};
+use thin_vec::{ThinVec, thin_vec};
+
use crate::ast::{
- AttrArgs, AttrArgsEq, AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Attribute, Safety,
+ AttrArgs, AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Attribute, DUMMY_NODE_ID, DelimArgs,
+ Expr, ExprKind, LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, NormalAttr, Path,
+ PathSegment, Safety,
};
-use crate::ast::{DelimArgs, Expr, ExprKind, LitKind, MetaItemLit};
-use crate::ast::{MetaItem, MetaItemKind, NestedMetaItem, NormalAttr};
-use crate::ast::{Path, PathSegment, DUMMY_NODE_ID};
use crate::ptr::P;
-use crate::token::{self, CommentKind, Delimiter, Token};
-use crate::tokenstream::{DelimSpan, Spacing, TokenTree};
-use crate::tokenstream::{LazyAttrTokenStream, TokenStream};
+use crate::token::{self, CommentKind, Delimiter, InvisibleOrigin, MetaVarKind, Token};
+use crate::tokenstream::{
+ DelimSpan, LazyAttrTokenStream, Spacing, TokenStream, TokenStreamIter, TokenTree,
+};
use crate::util::comments;
use crate::util::literal::escape_string_symbol;
-use rustc_index::bit_set::GrowableBitSet;
-use rustc_span::symbol::{sym, Ident, Symbol};
-use rustc_span::Span;
-use smallvec::{smallvec, SmallVec};
-use std::iter;
-use std::sync::atomic::{AtomicU32, Ordering};
-use thin_vec::{thin_vec, ThinVec};
pub struct MarkedAttrs(GrowableBitSet<AttrId>);
@@ -66,11 +67,27 @@ impl Attribute {
AttrKind::DocComment(..) => panic!("unexpected doc comment"),
}
}
+}
+
+impl AttributeExt for Attribute {
+ fn id(&self) -> AttrId {
+ self.id
+ }
+
+ fn value_span(&self) -> Option<Span> {
+ match &self.kind {
+ AttrKind::Normal(normal) => match &normal.item.args {
+ AttrArgs::Eq { expr, .. } => Some(expr.span),
+ _ => None,
+ },
+ AttrKind::DocComment(..) => None,
+ }
+ }
/// Returns `true` if it is a sugared doc comment (`///` or `//!` for example).
/// So `#[doc = "doc"]` (which is a doc comment) and `#[doc(...)]` (which is not
/// a doc comment) will return `false`.
- pub fn is_doc_comment(&self) -> bool {
+ fn is_doc_comment(&self) -> bool {
match self.kind {
AttrKind::Normal(..) => false,
AttrKind::DocComment(..) => true,
@@ -78,7 +95,7 @@ impl Attribute {
}
/// For a single-segment attribute, returns its name; otherwise, returns `None`.
- pub fn ident(&self) -> Option<Ident> {
+ fn ident(&self) -> Option<Ident> {
match &self.kind {
AttrKind::Normal(normal) => {
if let [ident] = &*normal.item.path.segments {
@@ -91,28 +108,14 @@ impl Attribute {
}
}
- pub fn name_or_empty(&self) -> Symbol {
- self.ident().unwrap_or_else(Ident::empty).name
- }
-
- pub fn path(&self) -> SmallVec<[Symbol; 1]> {
+ fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
match &self.kind {
- AttrKind::Normal(normal) => {
- normal.item.path.segments.iter().map(|s| s.ident.name).collect()
- }
- AttrKind::DocComment(..) => smallvec![sym::doc],
+ AttrKind::Normal(p) => Some(p.item.path.segments.iter().map(|i| i.ident).collect()),
+ AttrKind::DocComment(_, _) => None,
}
}
- #[inline]
- pub fn has_name(&self, name: Symbol) -> bool {
- match &self.kind {
- AttrKind::Normal(normal) => normal.item.path == name,
- AttrKind::DocComment(..) => false,
- }
- }
-
- pub fn path_matches(&self, name: &[Symbol]) -> bool {
+ fn path_matches(&self, name: &[Symbol]) -> bool {
match &self.kind {
AttrKind::Normal(normal) => {
normal.item.path.segments.len() == name.len()
@@ -128,7 +131,11 @@ impl Attribute {
}
}
- pub fn is_word(&self) -> bool {
+ fn span(&self) -> Span {
+ self.span
+ }
+
+ fn is_word(&self) -> bool {
if let AttrKind::Normal(normal) = &self.kind {
matches!(normal.item.args, AttrArgs::Empty)
} else {
@@ -136,14 +143,36 @@ impl Attribute {
}
}
- pub fn meta_item_list(&self) -> Option<ThinVec<NestedMetaItem>> {
+ /// Returns a list of meta items if the attribute is delimited with parenthesis:
+ ///
+ /// ```text
+ /// #[attr(a, b = "c")] // Returns `Some()`.
+ /// #[attr = ""] // Returns `None`.
+ /// #[attr] // Returns `None`.
+ /// ```
+ fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
match &self.kind {
AttrKind::Normal(normal) => normal.item.meta_item_list(),
AttrKind::DocComment(..) => None,
}
}
- pub fn value_str(&self) -> Option<Symbol> {
+ /// Returns the string value in:
+ ///
+ /// ```text
+ /// #[attribute = "value"]
+ /// ^^^^^^^
+ /// ```
+ ///
+ /// It returns `None` in any other cases, including doc comments if they
+ /// are not under the form `#[doc = "..."]`.
+ ///
+ /// It also returns `None` for:
+ ///
+ /// ```text
+ /// #[attr("value")]
+ /// ```
+ fn value_str(&self) -> Option<Symbol> {
match &self.kind {
AttrKind::Normal(normal) => normal.item.value_str(),
AttrKind::DocComment(..) => None,
@@ -155,7 +184,7 @@ impl Attribute {
/// * `/** doc */` returns `Some(("doc", CommentKind::Block))`.
/// * `#[doc = "doc"]` returns `Some(("doc", CommentKind::Line))`.
/// * `#[doc(...)]` returns `None`.
- pub fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
+ fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
match &self.kind {
AttrKind::DocComment(kind, data) => Some((*data, *kind)),
AttrKind::Normal(normal) if normal.item.path == sym::doc => {
@@ -169,7 +198,7 @@ impl Attribute {
/// * `///doc` returns `Some("doc")`.
/// * `#[doc = "doc"]` returns `Some("doc")`.
/// * `#[doc(...)]` returns `None`.
- pub fn doc_str(&self) -> Option<Symbol> {
+ fn doc_str(&self) -> Option<Symbol> {
match &self.kind {
AttrKind::DocComment(.., data) => Some(*data),
AttrKind::Normal(normal) if normal.item.path == sym::doc => normal.item.value_str(),
@@ -177,14 +206,14 @@ impl Attribute {
}
}
- pub fn may_have_doc_links(&self) -> bool {
- self.doc_str().is_some_and(|s| comments::may_have_doc_links(s.as_str()))
+ fn style(&self) -> AttrStyle {
+ self.style
}
+}
- pub fn is_proc_macro_attr(&self) -> bool {
- [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
- .iter()
- .any(|kind| self.has_name(*kind))
+impl Attribute {
+ pub fn may_have_doc_links(&self) -> bool {
+ self.doc_str().is_some_and(|s| comments::may_have_doc_links(s.as_str()))
}
/// Extracts the MetaItem from inside this Attribute.
@@ -223,18 +252,35 @@ impl AttrItem {
self.args.span().map_or(self.path.span, |args_span| self.path.span.to(args_span))
}
- fn meta_item_list(&self) -> Option<ThinVec<NestedMetaItem>> {
+ pub fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
match &self.args {
AttrArgs::Delimited(args) if args.delim == Delimiter::Parenthesis => {
MetaItemKind::list_from_tokens(args.tokens.clone())
}
- AttrArgs::Delimited(_) | AttrArgs::Eq(..) | AttrArgs::Empty => None,
+ AttrArgs::Delimited(_) | AttrArgs::Eq { .. } | AttrArgs::Empty => None,
}
}
+ /// Returns the string value in:
+ ///
+ /// ```text
+ /// #[attribute = "value"]
+ /// ^^^^^^^
+ /// ```
+ ///
+ /// It returns `None` in any other cases like:
+ ///
+ /// ```text
+ /// #[attr("value")]
+ /// ```
fn value_str(&self) -> Option<Symbol> {
match &self.args {
- AttrArgs::Eq(_, args) => args.value_str(),
+ AttrArgs::Eq { expr, .. } => match expr.kind {
+ ExprKind::Lit(token_lit) => {
+ LitKind::from_token_lit(token_lit).ok().and_then(|lit| lit.str())
+ }
+ _ => None,
+ },
AttrArgs::Delimited(_) | AttrArgs::Empty => None,
}
}
@@ -253,28 +299,14 @@ impl AttrItem {
}
}
-impl AttrArgsEq {
- fn value_str(&self) -> Option<Symbol> {
- match self {
- AttrArgsEq::Ast(expr) => match expr.kind {
- ExprKind::Lit(token_lit) => {
- LitKind::from_token_lit(token_lit).ok().and_then(|lit| lit.str())
- }
- _ => None,
- },
- AttrArgsEq::Hir(lit) => lit.kind.str(),
- }
- }
-}
-
impl MetaItem {
/// For a single-segment meta item, returns its name; otherwise, returns `None`.
pub fn ident(&self) -> Option<Ident> {
- if self.path.segments.len() == 1 { Some(self.path.segments[0].ident) } else { None }
+ if let [PathSegment { ident, .. }] = self.path.segments[..] { Some(ident) } else { None }
}
- pub fn name_or_empty(&self) -> Symbol {
- self.ident().unwrap_or_else(Ident::empty).name
+ pub fn name(&self) -> Option<Symbol> {
+ self.ident().map(|ident| ident.name)
}
pub fn has_name(&self, name: Symbol) -> bool {
@@ -285,7 +317,7 @@ impl MetaItem {
matches!(self.kind, MetaItemKind::Word)
}
- pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> {
+ pub fn meta_item_list(&self) -> Option<&[MetaItemInner]> {
match &self.kind {
MetaItemKind::List(l) => Some(&**l),
_ => None,
@@ -315,6 +347,18 @@ impl MetaItem {
Some(self.name_value_literal()?.span)
}
+ /// Returns the string value in:
+ ///
+ /// ```text
+ /// #[attribute = "value"]
+ /// ^^^^^^^
+ /// ```
+ ///
+ /// It returns `None` in any other cases like:
+ ///
+ /// ```text
+ /// #[attr("value")]
+ /// ```
pub fn value_str(&self) -> Option<Symbol> {
match &self.kind {
MetaItemKind::NameValue(v) => v.kind.str(),
@@ -322,12 +366,9 @@ impl MetaItem {
}
}
- fn from_tokens<'a, I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItem>
- where
- I: Iterator<Item = &'a TokenTree>,
- {
+ fn from_tokens(iter: &mut TokenStreamIter<'_>) -> Option<MetaItem> {
// FIXME: Share code with `parse_path`.
- let tt = tokens.next().map(|tt| TokenTree::uninterpolate(tt));
+ let tt = iter.next().map(|tt| TokenTree::uninterpolate(tt));
let path = match tt.as_deref() {
Some(&TokenTree::Token(
Token { kind: ref kind @ (token::Ident(..) | token::PathSep), span },
@@ -335,9 +376,9 @@ impl MetaItem {
)) => 'arm: {
let mut segments = if let &token::Ident(name, _) = kind {
if let Some(TokenTree::Token(Token { kind: token::PathSep, .. }, _)) =
- tokens.peek()
+ iter.peek()
{
- tokens.next();
+ iter.next();
thin_vec![PathSegment::from_ident(Ident::new(name, span))]
} else {
break 'arm Path::from_ident(Ident::new(name, span));
@@ -347,16 +388,16 @@ impl MetaItem {
};
loop {
if let Some(&TokenTree::Token(Token { kind: token::Ident(name, _), span }, _)) =
- tokens.next().map(|tt| TokenTree::uninterpolate(tt)).as_deref()
+ iter.next().map(|tt| TokenTree::uninterpolate(tt)).as_deref()
{
segments.push(PathSegment::from_ident(Ident::new(name, span)));
} else {
return None;
}
if let Some(TokenTree::Token(Token { kind: token::PathSep, .. }, _)) =
- tokens.peek()
+ iter.peek()
{
- tokens.next();
+ iter.next();
} else {
break;
}
@@ -364,21 +405,24 @@ impl MetaItem {
let span = span.with_hi(segments.last().unwrap().ident.span.hi());
Path { span, segments, tokens: None }
}
- Some(TokenTree::Token(Token { kind: token::Interpolated(nt), .. }, _)) => match &**nt {
- token::Nonterminal::NtMeta(item) => return item.meta(item.path.span),
- token::Nonterminal::NtPath(path) => (**path).clone(),
- _ => return None,
- },
- Some(TokenTree::Token(
- Token { kind: token::OpenDelim(_) | token::CloseDelim(_), .. },
- _,
+ Some(TokenTree::Delimited(
+ _span,
+ _spacing,
+ Delimiter::Invisible(InvisibleOrigin::MetaVar(
+ MetaVarKind::Meta { .. } | MetaVarKind::Path,
+ )),
+ _stream,
)) => {
+ // This path is currently unreachable in the test suite.
+ unreachable!()
+ }
+ Some(TokenTree::Token(Token { kind, .. }, _)) if kind.is_delim() => {
panic!("Should be `AttrTokenTree::Delimited`, not delim tokens: {:?}", tt);
}
_ => return None,
};
- let list_closing_paren_pos = tokens.peek().map(|tt| tt.span().hi());
- let kind = MetaItemKind::from_tokens(tokens)?;
+ let list_closing_paren_pos = iter.peek().map(|tt| tt.span().hi());
+ let kind = MetaItemKind::from_tokens(iter)?;
let hi = match &kind {
MetaItemKind::NameValue(lit) => lit.span.hi(),
MetaItemKind::List(..) => list_closing_paren_pos.unwrap_or(path.span.hi()),
@@ -393,13 +437,14 @@ impl MetaItem {
}
impl MetaItemKind {
- fn list_from_tokens(tokens: TokenStream) -> Option<ThinVec<NestedMetaItem>> {
- let mut tokens = tokens.trees().peekable();
+ // public because it can be called in the hir
+ pub fn list_from_tokens(tokens: TokenStream) -> Option<ThinVec<MetaItemInner>> {
+ let mut iter = tokens.iter();
let mut result = ThinVec::new();
- while tokens.peek().is_some() {
- let item = NestedMetaItem::from_tokens(&mut tokens)?;
+ while iter.peek().is_some() {
+ let item = MetaItemInner::from_tokens(&mut iter)?;
result.push(item);
- match tokens.next() {
+ match iter.next() {
None | Some(TokenTree::Token(Token { kind: token::Comma, .. }, _)) => {}
_ => return None,
}
@@ -407,12 +452,10 @@ impl MetaItemKind {
Some(result)
}
- fn name_value_from_tokens<'a>(
- tokens: &mut impl Iterator<Item = &'a TokenTree>,
- ) -> Option<MetaItemKind> {
- match tokens.next() {
- Some(TokenTree::Delimited(.., Delimiter::Invisible, inner_tokens)) => {
- MetaItemKind::name_value_from_tokens(&mut inner_tokens.trees())
+ fn name_value_from_tokens(iter: &mut TokenStreamIter<'_>) -> Option<MetaItemKind> {
+ match iter.next() {
+ Some(TokenTree::Delimited(.., Delimiter::Invisible(_), inner_tokens)) => {
+ MetaItemKind::name_value_from_tokens(&mut inner_tokens.iter())
}
Some(TokenTree::Token(token, _)) => {
MetaItemLit::from_token(token).map(MetaItemKind::NameValue)
@@ -421,19 +464,17 @@ impl MetaItemKind {
}
}
- fn from_tokens<'a>(
- tokens: &mut iter::Peekable<impl Iterator<Item = &'a TokenTree>>,
- ) -> Option<MetaItemKind> {
- match tokens.peek() {
+ fn from_tokens(iter: &mut TokenStreamIter<'_>) -> Option<MetaItemKind> {
+ match iter.peek() {
Some(TokenTree::Delimited(.., Delimiter::Parenthesis, inner_tokens)) => {
let inner_tokens = inner_tokens.clone();
- tokens.next();
+ iter.next();
MetaItemKind::list_from_tokens(inner_tokens).map(MetaItemKind::List)
}
Some(TokenTree::Delimited(..)) => None,
Some(TokenTree::Token(Token { kind: token::Eq, .. }, _)) => {
- tokens.next();
- MetaItemKind::name_value_from_tokens(tokens)
+ iter.next();
+ MetaItemKind::name_value_from_tokens(iter)
}
_ => Some(MetaItemKind::Word),
}
@@ -446,7 +487,7 @@ impl MetaItemKind {
MetaItemKind::list_from_tokens(tokens.clone()).map(MetaItemKind::List)
}
AttrArgs::Delimited(..) => None,
- AttrArgs::Eq(_, AttrArgsEq::Ast(expr)) => match expr.kind {
+ AttrArgs::Eq { expr, .. } => match expr.kind {
ExprKind::Lit(token_lit) => {
// Turn failures to `None`, we'll get parse errors elsewhere.
MetaItemLit::from_token_lit(token_lit, expr.span)
@@ -455,26 +496,26 @@ impl MetaItemKind {
}
_ => None,
},
- AttrArgs::Eq(_, AttrArgsEq::Hir(lit)) => Some(MetaItemKind::NameValue(lit.clone())),
}
}
}
-impl NestedMetaItem {
+impl MetaItemInner {
pub fn span(&self) -> Span {
match self {
- NestedMetaItem::MetaItem(item) => item.span,
- NestedMetaItem::Lit(lit) => lit.span,
+ MetaItemInner::MetaItem(item) => item.span,
+ MetaItemInner::Lit(lit) => lit.span,
}
}
- /// For a single-segment meta item, returns its name; otherwise, returns `None`.
+ /// For a single-segment meta item, returns its identifier; otherwise, returns `None`.
pub fn ident(&self) -> Option<Ident> {
self.meta_item().and_then(|meta_item| meta_item.ident())
}
- pub fn name_or_empty(&self) -> Symbol {
- self.ident().unwrap_or_else(Ident::empty).name
+ /// For a single-segment meta item, returns its name; otherwise, returns `None`.
+ pub fn name(&self) -> Option<Symbol> {
+ self.ident().map(|ident| ident.name)
}
/// Returns `true` if this list item is a MetaItem with a name of `name`.
@@ -488,7 +529,7 @@ impl NestedMetaItem {
}
/// Gets a list of inner meta items from a list `MetaItem` type.
- pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> {
+ pub fn meta_item_list(&self) -> Option<&[MetaItemInner]> {
self.meta_item().and_then(|meta_item| meta_item.meta_item_list())
}
@@ -519,18 +560,36 @@ impl NestedMetaItem {
self.meta_item().and_then(|meta_item| meta_item.value_str())
}
- /// Returns the `MetaItemLit` if `self` is a `NestedMetaItem::Literal`s.
+ /// Returns the `MetaItemLit` if `self` is a `MetaItemInner::Literal`s.
pub fn lit(&self) -> Option<&MetaItemLit> {
match self {
- NestedMetaItem::Lit(lit) => Some(lit),
+ MetaItemInner::Lit(lit) => Some(lit),
+ _ => None,
+ }
+ }
+
+ /// Returns the bool if `self` is a boolean `MetaItemInner::Literal`.
+ pub fn boolean_literal(&self) -> Option<bool> {
+ match self {
+ MetaItemInner::Lit(MetaItemLit { kind: LitKind::Bool(b), .. }) => Some(*b),
+ _ => None,
+ }
+ }
+
+ /// Returns the `MetaItem` if `self` is a `MetaItemInner::MetaItem` or if it's
+ /// `MetaItemInner::Lit(MetaItemLit { kind: LitKind::Bool(_), .. })`.
+ pub fn meta_item_or_bool(&self) -> Option<&MetaItemInner> {
+ match self {
+ MetaItemInner::MetaItem(_item) => Some(self),
+ MetaItemInner::Lit(MetaItemLit { kind: LitKind::Bool(_), .. }) => Some(self),
_ => None,
}
}
- /// Returns the `MetaItem` if `self` is a `NestedMetaItem::MetaItem`.
+ /// Returns the `MetaItem` if `self` is a `MetaItemInner::MetaItem`.
pub fn meta_item(&self) -> Option<&MetaItem> {
match self {
- NestedMetaItem::MetaItem(item) => Some(item),
+ MetaItemInner::MetaItem(item) => Some(item),
_ => None,
}
}
@@ -540,22 +599,19 @@ impl NestedMetaItem {
self.meta_item().is_some()
}
- fn from_tokens<'a, I>(tokens: &mut iter::Peekable<I>) -> Option<NestedMetaItem>
- where
- I: Iterator<Item = &'a TokenTree>,
- {
- match tokens.peek() {
+ fn from_tokens(iter: &mut TokenStreamIter<'_>) -> Option<MetaItemInner> {
+ match iter.peek() {
Some(TokenTree::Token(token, _)) if let Some(lit) = MetaItemLit::from_token(token) => {
- tokens.next();
- return Some(NestedMetaItem::Lit(lit));
+ iter.next();
+ return Some(MetaItemInner::Lit(lit));
}
- Some(TokenTree::Delimited(.., Delimiter::Invisible, inner_tokens)) => {
- tokens.next();
- return NestedMetaItem::from_tokens(&mut inner_tokens.trees().peekable());
+ Some(TokenTree::Delimited(.., Delimiter::Invisible(_), inner_tokens)) => {
+ iter.next();
+ return MetaItemInner::from_tokens(&mut inner_tokens.iter());
}
_ => {}
}
- MetaItem::from_tokens(tokens).map(NestedMetaItem::MetaItem)
+ MetaItem::from_tokens(iter).map(MetaItemInner::MetaItem)
}
}
@@ -569,7 +625,7 @@ pub fn mk_doc_comment(
Attribute { kind: AttrKind::DocComment(comment_kind, data), id: g.mk_attr_id(), style, span }
}
-pub fn mk_attr(
+fn mk_attr(
g: &AttrIdGenerator,
style: AttrStyle,
unsafety: Safety,
@@ -646,26 +702,187 @@ pub fn mk_attr_name_value_str(
tokens: None,
});
let path = Path::from_ident(Ident::new(name, span));
- let args = AttrArgs::Eq(span, AttrArgsEq::Ast(expr));
+ let args = AttrArgs::Eq { eq_span: span, expr };
mk_attr(g, style, unsafety, path, args, span)
}
-pub fn filter_by_name(attrs: &[Attribute], name: Symbol) -> impl Iterator<Item = &Attribute> {
+pub fn filter_by_name<A: AttributeExt>(attrs: &[A], name: Symbol) -> impl Iterator<Item = &A> {
attrs.iter().filter(move |attr| attr.has_name(name))
}
-pub fn find_by_name(attrs: &[Attribute], name: Symbol) -> Option<&Attribute> {
+pub fn find_by_name<A: AttributeExt>(attrs: &[A], name: Symbol) -> Option<&A> {
filter_by_name(attrs, name).next()
}
-pub fn first_attr_value_str_by_name(attrs: &[Attribute], name: Symbol) -> Option<Symbol> {
+pub fn first_attr_value_str_by_name(attrs: &[impl AttributeExt], name: Symbol) -> Option<Symbol> {
find_by_name(attrs, name).and_then(|attr| attr.value_str())
}
-pub fn contains_name(attrs: &[Attribute], name: Symbol) -> bool {
+pub fn contains_name(attrs: &[impl AttributeExt], name: Symbol) -> bool {
find_by_name(attrs, name).is_some()
}
-pub fn list_contains_name(items: &[NestedMetaItem], name: Symbol) -> bool {
+pub fn list_contains_name(items: &[MetaItemInner], name: Symbol) -> bool {
items.iter().any(|item| item.has_name(name))
}
+
+impl MetaItemLit {
+ pub fn value_str(&self) -> Option<Symbol> {
+ LitKind::from_token_lit(self.as_token_lit()).ok().and_then(|lit| lit.str())
+ }
+}
+
+pub trait AttributeExt: Debug {
+ fn id(&self) -> AttrId;
+
+ /// For a single-segment attribute (i.e., `#[attr]` and not `#[path::atrr]`),
+ /// return the name of the attribute; otherwise, returns `None`.
+ fn name(&self) -> Option<Symbol> {
+ self.ident().map(|ident| ident.name)
+ }
+
+ /// Get the meta item list, `#[attr(meta item list)]`
+ fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>>;
+
+ /// Gets the value literal, as string, when using `#[attr = value]`
+ fn value_str(&self) -> Option<Symbol>;
+
+ /// Gets the span of the value literal, as string, when using `#[attr = value]`
+ fn value_span(&self) -> Option<Span>;
+
+ /// For a single-segment attribute, returns its ident; otherwise, returns `None`.
+ fn ident(&self) -> Option<Ident>;
+
+ /// Checks whether the path of this attribute matches the name.
+ ///
+ /// Matches one segment of the path to each element in `name`
+ fn path_matches(&self, name: &[Symbol]) -> bool;
+
+ /// Returns `true` if it is a sugared doc comment (`///` or `//!` for example).
+ /// So `#[doc = "doc"]` (which is a doc comment) and `#[doc(...)]` (which is not
+ /// a doc comment) will return `false`.
+ fn is_doc_comment(&self) -> bool;
+
+ #[inline]
+ fn has_name(&self, name: Symbol) -> bool {
+ self.ident().map(|x| x.name == name).unwrap_or(false)
+ }
+
+ #[inline]
+ fn has_any_name(&self, names: &[Symbol]) -> bool {
+ names.iter().any(|&name| self.has_name(name))
+ }
+
+ /// get the span of the entire attribute
+ fn span(&self) -> Span;
+
+ fn is_word(&self) -> bool;
+
+ fn path(&self) -> SmallVec<[Symbol; 1]> {
+ self.ident_path()
+ .map(|i| i.into_iter().map(|i| i.name).collect())
+ .unwrap_or(smallvec![sym::doc])
+ }
+
+ /// Returns None for doc comments
+ fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>>;
+
+ /// Returns the documentation if this is a doc comment or a sugared doc comment.
+ /// * `///doc` returns `Some("doc")`.
+ /// * `#[doc = "doc"]` returns `Some("doc")`.
+ /// * `#[doc(...)]` returns `None`.
+ fn doc_str(&self) -> Option<Symbol>;
+
+ fn is_proc_macro_attr(&self) -> bool {
+ [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
+ .iter()
+ .any(|kind| self.has_name(*kind))
+ }
+
+ /// Returns the documentation and its kind if this is a doc comment or a sugared doc comment.
+ /// * `///doc` returns `Some(("doc", CommentKind::Line))`.
+ /// * `/** doc */` returns `Some(("doc", CommentKind::Block))`.
+ /// * `#[doc = "doc"]` returns `Some(("doc", CommentKind::Line))`.
+ /// * `#[doc(...)]` returns `None`.
+ fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)>;
+
+ fn style(&self) -> AttrStyle;
+}
+
+// FIXME(fn_delegation): use function delegation instead of manually forwarding
+
+impl Attribute {
+ pub fn id(&self) -> AttrId {
+ AttributeExt::id(self)
+ }
+
+ pub fn name(&self) -> Option<Symbol> {
+ AttributeExt::name(self)
+ }
+
+ pub fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
+ AttributeExt::meta_item_list(self)
+ }
+
+ pub fn value_str(&self) -> Option<Symbol> {
+ AttributeExt::value_str(self)
+ }
+
+ pub fn value_span(&self) -> Option<Span> {
+ AttributeExt::value_span(self)
+ }
+
+ pub fn ident(&self) -> Option<Ident> {
+ AttributeExt::ident(self)
+ }
+
+ pub fn path_matches(&self, name: &[Symbol]) -> bool {
+ AttributeExt::path_matches(self, name)
+ }
+
+ pub fn is_doc_comment(&self) -> bool {
+ AttributeExt::is_doc_comment(self)
+ }
+
+ #[inline]
+ pub fn has_name(&self, name: Symbol) -> bool {
+ AttributeExt::has_name(self, name)
+ }
+
+ #[inline]
+ pub fn has_any_name(&self, names: &[Symbol]) -> bool {
+ AttributeExt::has_any_name(self, names)
+ }
+
+ pub fn span(&self) -> Span {
+ AttributeExt::span(self)
+ }
+
+ pub fn is_word(&self) -> bool {
+ AttributeExt::is_word(self)
+ }
+
+ pub fn path(&self) -> SmallVec<[Symbol; 1]> {
+ AttributeExt::path(self)
+ }
+
+ pub fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
+ AttributeExt::ident_path(self)
+ }
+
+ pub fn doc_str(&self) -> Option<Symbol> {
+ AttributeExt::doc_str(self)
+ }
+
+ pub fn is_proc_macro_attr(&self) -> bool {
+ AttributeExt::is_proc_macro_attr(self)
+ }
+
+ pub fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
+ AttributeExt::doc_str_and_comment_kind(self)
+ }
+
+ pub fn style(&self) -> AttrStyle {
+ AttributeExt::style(self)
+ }
+}
diff --git a/compiler/rustc_ast/src/entry.rs b/compiler/rustc_ast/src/entry.rs
index dd231e286d591..12cbb3b2a15f7 100644
--- a/compiler/rustc_ast/src/entry.rs
+++ b/compiler/rustc_ast/src/entry.rs
@@ -1,6 +1,6 @@
-use crate::{attr, Attribute};
-use rustc_span::symbol::sym;
-use rustc_span::Symbol;
+use rustc_span::{Symbol, sym};
+
+use crate::attr::{self, AttributeExt};
#[derive(Debug)]
pub enum EntryPointType {
@@ -18,12 +18,6 @@ pub enum EntryPointType {
/// fn main() {}
/// ```
RustcMainAttr,
- /// This is a function with the `#[start]` attribute.
- /// ```ignore (clashes with test entrypoint)
- /// #[start]
- /// fn main() {}
- /// ```
- Start,
/// This function is **not** an entrypoint but simply named `main` (not at the root).
/// This is only used for diagnostics.
/// ```
@@ -36,26 +30,22 @@ pub enum EntryPointType {
}
pub fn entry_point_type(
- attrs: &[Attribute],
+ attrs: &[impl AttributeExt],
at_root: bool,
name: Option<Symbol>,
) -> EntryPointType {
- if attr::contains_name(attrs, sym::start) {
- EntryPointType::Start
- } else if attr::contains_name(attrs, sym::rustc_main) {
+ if attr::contains_name(attrs, sym::rustc_main) {
EntryPointType::RustcMainAttr
- } else {
- if let Some(name) = name
- && name == sym::main
- {
- if at_root {
- // This is a top-level function so it can be `main`.
- EntryPointType::MainNamed
- } else {
- EntryPointType::OtherMain
- }
+ } else if let Some(name) = name
+ && name == sym::main
+ {
+ if at_root {
+ // This is a top-level function so it can be `main`.
+ EntryPointType::MainNamed
} else {
- EntryPointType::None
+ EntryPointType::OtherMain
}
+ } else {
+ EntryPointType::None
}
}
diff --git a/compiler/rustc_ast/src/expand/allocator.rs b/compiler/rustc_ast/src/expand/allocator.rs
index 1723501d0fec0..dd8d5ae624a3c 100644
--- a/compiler/rustc_ast/src/expand/allocator.rs
+++ b/compiler/rustc_ast/src/expand/allocator.rs
@@ -1,5 +1,5 @@
use rustc_macros::HashStable_Generic;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::{Symbol, sym};
#[derive(Clone, Debug, Copy, Eq, PartialEq, HashStable_Generic)]
pub enum AllocatorKind {
diff --git a/compiler/rustc_ast/src/expand/autodiff_attrs.rs b/compiler/rustc_ast/src/expand/autodiff_attrs.rs
new file mode 100644
index 0000000000000..2f918faaf752b
--- /dev/null
+++ b/compiler/rustc_ast/src/expand/autodiff_attrs.rs
@@ -0,0 +1,289 @@
+//! This crate handles the user facing autodiff macro. For each `#[autodiff(...)]` attribute,
+//! we create an [`AutoDiffItem`] which contains the source and target function names. The source
+//! is the function to which the autodiff attribute is applied, and the target is the function
+//! getting generated by us (with a name given by the user as the first autodiff arg).
+
+use std::fmt::{self, Display, Formatter};
+use std::str::FromStr;
+
+use crate::expand::{Decodable, Encodable, HashStable_Generic};
+use crate::ptr::P;
+use crate::{Ty, TyKind};
+
+/// Forward and Reverse Mode are well known names for automatic differentiation implementations.
+/// Enzyme does support both, but with different semantics, see DiffActivity. The First variants
+/// are a hack to support higher order derivatives. We need to compute first order derivatives
+/// before we compute second order derivatives, otherwise we would differentiate our placeholder
+/// functions. The proper solution is to recognize and resolve this DAG of autodiff invocations,
+/// as it's already done in the C++ and Julia frontend of Enzyme.
+///
+/// Documentation for using [reverse](https://enzyme.mit.edu/rust/rev.html) and
+/// [forward](https://enzyme.mit.edu/rust/fwd.html) mode is available online.
+#[derive(Clone, Copy, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+pub enum DiffMode {
+ /// No autodiff is applied (used during error handling).
+ Error,
+ /// The primal function which we will differentiate.
+ Source,
+ /// The target function, to be created using forward mode AD.
+ Forward,
+ /// The target function, to be created using reverse mode AD.
+ Reverse,
+}
+
+/// Dual and Duplicated (and their Only variants) are getting lowered to the same Enzyme Activity.
+/// However, under forward mode we overwrite the previous shadow value, while for reverse mode
+/// we add to the previous shadow value. To not surprise users, we picked different names.
+/// Dual numbers is also a quite well known name for forward mode AD types.
+#[derive(Clone, Copy, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+pub enum DiffActivity {
+ /// Implicit or Explicit () return type, so a special case of Const.
+ None,
+ /// Don't compute derivatives with respect to this input/output.
+ Const,
+ /// Reverse Mode, Compute derivatives for this scalar input/output.
+ Active,
+ /// Reverse Mode, Compute derivatives for this scalar output, but don't compute
+ /// the original return value.
+ ActiveOnly,
+ /// Forward Mode, Compute derivatives for this input/output and *overwrite* the shadow argument
+ /// with it.
+ Dual,
+ /// Forward Mode, Compute derivatives for this input/output and *overwrite* the shadow argument
+ /// with it. It expects the shadow argument to be `width` times larger than the original
+ /// input/output.
+ Dualv,
+ /// Forward Mode, Compute derivatives for this input/output and *overwrite* the shadow argument
+ /// with it. Drop the code which updates the original input/output for maximum performance.
+ DualOnly,
+ /// Forward Mode, Compute derivatives for this input/output and *overwrite* the shadow argument
+ /// with it. Drop the code which updates the original input/output for maximum performance.
+ /// It expects the shadow argument to be `width` times larger than the original input/output.
+ DualvOnly,
+ /// Reverse Mode, Compute derivatives for this &T or *T input and *add* it to the shadow argument.
+ Duplicated,
+ /// Reverse Mode, Compute derivatives for this &T or *T input and *add* it to the shadow argument.
+ /// Drop the code which updates the original input for maximum performance.
+ DuplicatedOnly,
+ /// All Integers must be Const, but these are used to mark the integer which represents the
+ /// length of a slice/vec. This is used for safety checks on slices.
+ /// The integer (if given) specifies the size of the slice element in bytes.
+ FakeActivitySize(Option<u32>),
+}
+
+impl DiffActivity {
+ pub fn is_dual_or_const(&self) -> bool {
+ use DiffActivity::*;
+ matches!(self, |Dual| DualOnly | Dualv | DualvOnly | Const)
+ }
+}
+/// We generate one of these structs for each `#[autodiff(...)]` attribute.
+#[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+pub struct AutoDiffItem {
+ /// The name of the function getting differentiated
+ pub source: String,
+ /// The name of the function being generated
+ pub target: String,
+ pub attrs: AutoDiffAttrs,
+}
+
+#[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+pub struct AutoDiffAttrs {
+ /// Conceptually either forward or reverse mode AD, as described in various autodiff papers and
+ /// e.g. in the [JAX
+ /// Documentation](https://jax.readthedocs.io/en/latest/_tutorials/advanced-autodiff.html#how-it-s-made-two-foundational-autodiff-functions).
+ pub mode: DiffMode,
+ /// A user-provided, batching width. If not given, we will default to 1 (no batching).
+ /// Calling a differentiated, non-batched function through a loop 100 times is equivalent to:
+ /// - Calling the function 50 times with a batch size of 2
+ /// - Calling the function 25 times with a batch size of 4,
+ /// etc. A batched function takes more (or longer) arguments, and might be able to benefit from
+ /// cache locality, better re-usal of primal values, and other optimizations.
+ /// We will (before LLVM's vectorizer runs) just generate most LLVM-IR instructions `width`
+ /// times, so this massively increases code size. As such, values like 1024 are unlikely to
+ /// work. We should consider limiting this to u8 or u16, but will leave it at u32 for
+ /// experiments for now and focus on documenting the implications of a large width.
+ pub width: u32,
+ pub ret_activity: DiffActivity,
+ pub input_activity: Vec<DiffActivity>,
+}
+
+impl AutoDiffAttrs {
+ pub fn has_primal_ret(&self) -> bool {
+ matches!(self.ret_activity, DiffActivity::Active | DiffActivity::Dual)
+ }
+}
+
+impl DiffMode {
+ pub fn is_rev(&self) -> bool {
+ matches!(self, DiffMode::Reverse)
+ }
+ pub fn is_fwd(&self) -> bool {
+ matches!(self, DiffMode::Forward)
+ }
+}
+
+impl Display for DiffMode {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ match self {
+ DiffMode::Error => write!(f, "Error"),
+ DiffMode::Source => write!(f, "Source"),
+ DiffMode::Forward => write!(f, "Forward"),
+ DiffMode::Reverse => write!(f, "Reverse"),
+ }
+ }
+}
+
+/// Active(Only) is valid in reverse-mode AD for scalar float returns (f16/f32/...).
+/// Dual(Only) is valid in forward-mode AD for scalar float returns (f16/f32/...).
+/// Const is valid for all cases and means that we don't compute derivatives wrt. this output.
+/// That usually means we have a &mut or *mut T output and compute derivatives wrt. that arg,
+/// but this is too complex to verify here. Also it's just a logic error if users get this wrong.
+pub fn valid_ret_activity(mode: DiffMode, activity: DiffActivity) -> bool {
+ if activity == DiffActivity::None {
+ // Only valid if primal returns (), but we can't check that here.
+ return true;
+ }
+ match mode {
+ DiffMode::Error => false,
+ DiffMode::Source => false,
+ DiffMode::Forward => activity.is_dual_or_const(),
+ DiffMode::Reverse => {
+ activity == DiffActivity::Const
+ || activity == DiffActivity::Active
+ || activity == DiffActivity::ActiveOnly
+ }
+ }
+}
+
+/// For indirections (ptr/ref) we can't use Active, since Active allocates a shadow value
+/// for the given argument, but we generally can't know the size of such a type.
+/// For scalar types (f16/f32/f64/f128) we can use Active and we can't use Duplicated,
+/// since Duplicated expects a mutable ref/ptr and we would thus end up with a shadow value
+/// who is an indirect type, which doesn't match the primal scalar type. We can't prevent
+/// users here from marking scalars as Duplicated, due to type aliases.
+pub fn valid_ty_for_activity(ty: &P<Ty>, activity: DiffActivity) -> bool {
+ use DiffActivity::*;
+ // It's always allowed to mark something as Const, since we won't compute derivatives wrt. it.
+ // Dual variants also support all types.
+ if activity.is_dual_or_const() {
+ return true;
+ }
+ // FIXME(ZuseZ4) We should make this more robust to also
+ // handle type aliases. Once that is done, we can be more restrictive here.
+ if matches!(activity, Active | ActiveOnly) {
+ return true;
+ }
+ matches!(ty.kind, TyKind::Ptr(_) | TyKind::Ref(..))
+ && matches!(activity, Duplicated | DuplicatedOnly)
+}
+pub fn valid_input_activity(mode: DiffMode, activity: DiffActivity) -> bool {
+ use DiffActivity::*;
+ return match mode {
+ DiffMode::Error => false,
+ DiffMode::Source => false,
+ DiffMode::Forward => activity.is_dual_or_const(),
+ DiffMode::Reverse => {
+ matches!(activity, Active | ActiveOnly | Duplicated | DuplicatedOnly | Const)
+ }
+ };
+}
+
+impl Display for DiffActivity {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ match self {
+ DiffActivity::None => write!(f, "None"),
+ DiffActivity::Const => write!(f, "Const"),
+ DiffActivity::Active => write!(f, "Active"),
+ DiffActivity::ActiveOnly => write!(f, "ActiveOnly"),
+ DiffActivity::Dual => write!(f, "Dual"),
+ DiffActivity::Dualv => write!(f, "Dualv"),
+ DiffActivity::DualOnly => write!(f, "DualOnly"),
+ DiffActivity::DualvOnly => write!(f, "DualvOnly"),
+ DiffActivity::Duplicated => write!(f, "Duplicated"),
+ DiffActivity::DuplicatedOnly => write!(f, "DuplicatedOnly"),
+ DiffActivity::FakeActivitySize(s) => write!(f, "FakeActivitySize({:?})", s),
+ }
+ }
+}
+
+impl FromStr for DiffMode {
+ type Err = ();
+
+ fn from_str(s: &str) -> Result<DiffMode, ()> {
+ match s {
+ "Error" => Ok(DiffMode::Error),
+ "Source" => Ok(DiffMode::Source),
+ "Forward" => Ok(DiffMode::Forward),
+ "Reverse" => Ok(DiffMode::Reverse),
+ _ => Err(()),
+ }
+ }
+}
+impl FromStr for DiffActivity {
+ type Err = ();
+
+ fn from_str(s: &str) -> Result<DiffActivity, ()> {
+ match s {
+ "None" => Ok(DiffActivity::None),
+ "Active" => Ok(DiffActivity::Active),
+ "ActiveOnly" => Ok(DiffActivity::ActiveOnly),
+ "Const" => Ok(DiffActivity::Const),
+ "Dual" => Ok(DiffActivity::Dual),
+ "Dualv" => Ok(DiffActivity::Dualv),
+ "DualOnly" => Ok(DiffActivity::DualOnly),
+ "DualvOnly" => Ok(DiffActivity::DualvOnly),
+ "Duplicated" => Ok(DiffActivity::Duplicated),
+ "DuplicatedOnly" => Ok(DiffActivity::DuplicatedOnly),
+ _ => Err(()),
+ }
+ }
+}
+
+impl AutoDiffAttrs {
+ pub fn has_ret_activity(&self) -> bool {
+ self.ret_activity != DiffActivity::None
+ }
+ pub fn has_active_only_ret(&self) -> bool {
+ self.ret_activity == DiffActivity::ActiveOnly
+ }
+
+ pub const fn error() -> Self {
+ AutoDiffAttrs {
+ mode: DiffMode::Error,
+ width: 0,
+ ret_activity: DiffActivity::None,
+ input_activity: Vec::new(),
+ }
+ }
+ pub fn source() -> Self {
+ AutoDiffAttrs {
+ mode: DiffMode::Source,
+ width: 0,
+ ret_activity: DiffActivity::None,
+ input_activity: Vec::new(),
+ }
+ }
+
+ pub fn is_active(&self) -> bool {
+ self.mode != DiffMode::Error
+ }
+
+ pub fn is_source(&self) -> bool {
+ self.mode == DiffMode::Source
+ }
+ pub fn apply_autodiff(&self) -> bool {
+ !matches!(self.mode, DiffMode::Error | DiffMode::Source)
+ }
+
+ pub fn into_item(self, source: String, target: String) -> AutoDiffItem {
+ AutoDiffItem { source, target, attrs: self }
+ }
+}
+
+impl fmt::Display for AutoDiffItem {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "Differentiating {} -> {}", self.source, self.target)?;
+ write!(f, " with attributes: {:?}", self.attrs)
+ }
+}
diff --git a/compiler/rustc_ast/src/expand/mod.rs b/compiler/rustc_ast/src/expand/mod.rs
index 37caadd04143e..323a8fab6d592 100644
--- a/compiler/rustc_ast/src/expand/mod.rs
+++ b/compiler/rustc_ast/src/expand/mod.rs
@@ -1,21 +1,24 @@
//! Definitions shared by macros / syntax extensions and e.g. `rustc_middle`.
use rustc_macros::{Decodable, Encodable, HashStable_Generic};
-use rustc_span::{def_id::DefId, symbol::Ident};
+use rustc_span::Ident;
+use rustc_span::def_id::DefId;
use crate::MetaItem;
pub mod allocator;
+pub mod autodiff_attrs;
+pub mod typetree;
#[derive(Debug, Clone, Encodable, Decodable, HashStable_Generic)]
pub struct StrippedCfgItem<ModId = DefId> {
pub parent_module: ModId,
- pub name: Ident,
+ pub ident: Ident,
pub cfg: MetaItem,
}
impl<ModId> StrippedCfgItem<ModId> {
pub fn map_mod_id<New>(self, f: impl FnOnce(ModId) -> New) -> StrippedCfgItem<New> {
- StrippedCfgItem { parent_module: f(self.parent_module), name: self.name, cfg: self.cfg }
+ StrippedCfgItem { parent_module: f(self.parent_module), ident: self.ident, cfg: self.cfg }
}
}
diff --git a/compiler/rustc_ast/src/expand/typetree.rs b/compiler/rustc_ast/src/expand/typetree.rs
new file mode 100644
index 0000000000000..9a2dd2e85e0d6
--- /dev/null
+++ b/compiler/rustc_ast/src/expand/typetree.rs
@@ -0,0 +1,90 @@
+//! This module contains the definition of the `TypeTree` and `Type` structs.
+//! They are thin Rust wrappers around the TypeTrees used by Enzyme as the LLVM based autodiff
+//! backend. The Enzyme TypeTrees currently have various limitations and should be rewritten, so the
+//! Rust frontend obviously has the same limitations. The main motivation of TypeTrees is to
+//! represent how a type looks like "in memory". Enzyme can deduce this based on usage patterns in
+//! the user code, but this is extremely slow and not even always sufficient. As such we lower some
+//! information from rustc to help Enzyme. For a full explanation of their design it is necessary to
+//! analyze the implementation in Enzyme core itself. As a rough summary, `-1` in Enzyme speech means
+//! everywhere. That is `{0:-1: Float}` means at index 0 you have a ptr, if you dereference it it
+//! will be floats everywhere. Thus `* f32`. If you have `{-1:int}` it means int's everywhere,
+//! e.g. [i32; N]. `{0:-1:-1 float}` then means one pointer at offset 0, if you dereference it there
+//! will be only pointers, if you dereference these new pointers they will point to array of floats.
+//! Generally, it allows byte-specific descriptions.
+//! FIXME: This description might be partly inaccurate and should be extended, along with
+//! adding documentation to the corresponding Enzyme core code.
+//! FIXME: Rewrite the TypeTree logic in Enzyme core to reduce the need for the rustc frontend to
+//! provide typetree information.
+//! FIXME: We should also re-evaluate where we create TypeTrees from Rust types, since MIR
+//! representations of some types might not be accurate. For example a vector of floats might be
+//! represented as a vector of u8s in MIR in some cases.
+
+use std::fmt;
+
+use crate::expand::{Decodable, Encodable, HashStable_Generic};
+
+#[derive(Clone, Copy, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+pub enum Kind {
+ Anything,
+ Integer,
+ Pointer,
+ Half,
+ Float,
+ Double,
+ Unknown,
+}
+
+#[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+pub struct TypeTree(pub Vec<Type>);
+
+impl TypeTree {
+ pub fn new() -> Self {
+ Self(Vec::new())
+ }
+ pub fn all_ints() -> Self {
+ Self(vec![Type { offset: -1, size: 1, kind: Kind::Integer, child: TypeTree::new() }])
+ }
+ pub fn int(size: usize) -> Self {
+ let mut ints = Vec::with_capacity(size);
+ for i in 0..size {
+ ints.push(Type {
+ offset: i as isize,
+ size: 1,
+ kind: Kind::Integer,
+ child: TypeTree::new(),
+ });
+ }
+ Self(ints)
+ }
+}
+
+#[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+pub struct FncTree {
+ pub args: Vec<TypeTree>,
+ pub ret: TypeTree,
+}
+
+#[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+pub struct Type {
+ pub offset: isize,
+ pub size: usize,
+ pub kind: Kind,
+ pub child: TypeTree,
+}
+
+impl Type {
+ pub fn add_offset(self, add: isize) -> Self {
+ let offset = match self.offset {
+ -1 => add,
+ x => add + x,
+ };
+
+ Self { size: self.size, kind: self.kind, child: self.child, offset }
+ }
+}
+
+impl fmt::Display for Type {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ <Self as fmt::Debug>::fmt(self, f)
+ }
+}
diff --git a/compiler/rustc_ast/src/format.rs b/compiler/rustc_ast/src/format.rs
index 49910e2283dda..b611ddea1d9f1 100644
--- a/compiler/rustc_ast/src/format.rs
+++ b/compiler/rustc_ast/src/format.rs
@@ -1,9 +1,10 @@
-use crate::ptr::P;
-use crate::Expr;
use rustc_data_structures::fx::FxHashMap;
use rustc_macros::{Decodable, Encodable};
-use rustc_span::symbol::{Ident, Symbol};
-use rustc_span::Span;
+use rustc_span::{Ident, Span, Symbol};
+
+use crate::Expr;
+use crate::ptr::P;
+use crate::token::LitKind;
// Definitions:
//
@@ -45,6 +46,10 @@ pub struct FormatArgs {
pub span: Span,
pub template: Vec<FormatArgsPiece>,
pub arguments: FormatArguments,
+ /// The raw, un-split format string literal, with no escaping or processing.
+ ///
+ /// Generally only useful for lints that care about the raw bytes the user wrote.
+ pub uncooked_fmt_str: (LitKind, Symbol),
}
/// A piece of a format template string.
@@ -261,7 +266,7 @@ pub enum FormatAlignment {
#[derive(Clone, Encodable, Decodable, Debug, PartialEq, Eq)]
pub enum FormatCount {
/// `{:5}` or `{:.5}`
- Literal(usize),
+ Literal(u16),
/// `{:.*}`, `{:.5$}`, or `{:a$}`, etc.
Argument(FormatArgPosition),
}
diff --git a/compiler/rustc_ast/src/lib.rs b/compiler/rustc_ast/src/lib.rs
index 846a108091fcc..e572ec99dabf3 100644
--- a/compiler/rustc_ast/src/lib.rs
+++ b/compiler/rustc_ast/src/lib.rs
@@ -6,19 +6,21 @@
// tidy-alphabetical-start
#![allow(internal_features)]
+#![cfg_attr(bootstrap, feature(let_chains))]
#![doc(
html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/",
test(attr(deny(warnings)))
)]
#![doc(rust_logo)]
+#![feature(array_windows)]
#![feature(associated_type_defaults)]
#![feature(box_patterns)]
#![feature(if_let_guard)]
-#![feature(let_chains)]
#![feature(negative_impls)]
#![feature(never_type)]
#![feature(rustdoc_internals)]
#![feature(stmt_expr_attributes)]
+#![recursion_limit = "256"]
// tidy-alphabetical-end
pub mod util {
@@ -46,17 +48,7 @@ pub mod visit;
pub use self::ast::*;
pub use self::ast_traits::{AstDeref, AstNodeWrapper, HasAttrs, HasNodeId, HasTokens};
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-
/// Requirements for a `StableHashingContext` to be used in this crate.
/// This is a hack to allow using the `HashStable_Generic` derive macro
/// instead of implementing everything in `rustc_middle`.
-pub trait HashStableContext: rustc_span::HashStableContext {
- fn hash_attr(&mut self, _: &ast::Attribute, hasher: &mut StableHasher);
-}
-
-impl<AstCtx: crate::HashStableContext> HashStable<AstCtx> for ast::Attribute {
- fn hash_stable(&self, hcx: &mut AstCtx, hasher: &mut StableHasher) {
- hcx.hash_attr(self, hasher)
- }
-}
+pub trait HashStableContext: rustc_span::HashStableContext {}
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
index 1c1163551db5f..e49886721e364 100644
--- a/compiler/rustc_ast/src/mut_visit.rs
+++ b/compiler/rustc_ast/src/mut_visit.rs
@@ -7,22 +7,21 @@
//! a `MutVisitor` renaming item names in a module will miss all of those
//! that are created by the expansion of a macro.
-use crate::ast::*;
-use crate::ptr::P;
-use crate::token::{self, Token};
-use crate::tokenstream::*;
+use std::ops::DerefMut;
+use std::panic;
use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_data_structures::sync::Lrc;
use rustc_span::source_map::Spanned;
-use rustc_span::symbol::Ident;
-use rustc_span::Span;
-use smallvec::{smallvec, Array, SmallVec};
-use std::ops::DerefMut;
-use std::panic;
+use rustc_span::{Ident, Span};
+use smallvec::{Array, SmallVec, smallvec};
use thin_vec::ThinVec;
+use crate::ast::*;
+use crate::ptr::P;
+use crate::tokenstream::*;
+use crate::visit::{AssocCtxt, BoundKind, FnCtxt};
+
pub trait ExpectOne<A: Array> {
fn expect_one(self, err: &'static str) -> A::Item;
}
@@ -34,16 +33,19 @@ impl<A: Array> ExpectOne<A> for SmallVec<A> {
}
}
-pub trait NoopVisitItemKind {
- fn noop_visit(&mut self, visitor: &mut impl MutVisitor);
+pub trait WalkItemKind {
+ type Ctxt;
+ fn walk(
+ &mut self,
+ span: Span,
+ id: NodeId,
+ visibility: &mut Visibility,
+ ctxt: Self::Ctxt,
+ visitor: &mut impl MutVisitor,
+ );
}
pub trait MutVisitor: Sized {
- /// Mutable token visiting only exists for the `macro_rules` token marker and should not be
- /// used otherwise. Token visitor would be entirely separate from the regular visitor if
- /// the marker didn't have to visit AST fragments in nonterminal tokens.
- const VISIT_TOKENS: bool = false;
-
// Methods in this trait have one of three forms:
//
// fn visit_t(&mut self, t: &mut T); // common
@@ -78,79 +80,108 @@ pub trait MutVisitor: Sized {
// forget to add handling for it.
fn visit_crate(&mut self, c: &mut Crate) {
- noop_visit_crate(c, self)
+ walk_crate(self, c)
}
- fn visit_meta_list_item(&mut self, list_item: &mut NestedMetaItem) {
- noop_visit_meta_list_item(list_item, self);
+ fn visit_meta_list_item(&mut self, list_item: &mut MetaItemInner) {
+ walk_meta_list_item(self, list_item);
}
fn visit_meta_item(&mut self, meta_item: &mut MetaItem) {
- noop_visit_meta_item(meta_item, self);
+ walk_meta_item(self, meta_item);
}
fn visit_use_tree(&mut self, use_tree: &mut UseTree) {
- noop_visit_use_tree(use_tree, self);
+ walk_use_tree(self, use_tree);
+ }
+
+ fn visit_foreign_item(&mut self, ni: &mut P<ForeignItem>) {
+ walk_item(self, ni);
}
fn flat_map_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {
- noop_flat_map_item(ni, self)
+ walk_flat_map_foreign_item(self, ni)
+ }
+
+ fn visit_item(&mut self, i: &mut P<Item>) {
+ walk_item(self, i);
}
fn flat_map_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> {
- noop_flat_map_item(i, self)
+ walk_flat_map_item(self, i)
}
fn visit_fn_header(&mut self, header: &mut FnHeader) {
- noop_visit_fn_header(header, self);
+ walk_fn_header(self, header);
+ }
+
+ fn visit_field_def(&mut self, fd: &mut FieldDef) {
+ walk_field_def(self, fd);
}
fn flat_map_field_def(&mut self, fd: FieldDef) -> SmallVec<[FieldDef; 1]> {
- noop_flat_map_field_def(fd, self)
+ walk_flat_map_field_def(self, fd)
+ }
+
+ fn visit_assoc_item(&mut self, i: &mut P<AssocItem>, ctxt: AssocCtxt) {
+ walk_assoc_item(self, i, ctxt)
}
- fn flat_map_trait_item(&mut self, i: P<AssocItem>) -> SmallVec<[P<AssocItem>; 1]> {
- noop_flat_map_item(i, self)
+ fn flat_map_assoc_item(
+ &mut self,
+ i: P<AssocItem>,
+ ctxt: AssocCtxt,
+ ) -> SmallVec<[P<AssocItem>; 1]> {
+ walk_flat_map_assoc_item(self, i, ctxt)
}
- fn flat_map_impl_item(&mut self, i: P<AssocItem>) -> SmallVec<[P<AssocItem>; 1]> {
- noop_flat_map_item(i, self)
+ fn visit_contract(&mut self, c: &mut P<FnContract>) {
+ walk_contract(self, c);
}
fn visit_fn_decl(&mut self, d: &mut P<FnDecl>) {
- noop_visit_fn_decl(d, self);
+ walk_fn_decl(self, d);
+ }
+
+ /// `Span` and `NodeId` are mutated at the caller site.
+ fn visit_fn(&mut self, fk: FnKind<'_>, _: Span, _: NodeId) {
+ walk_fn(self, fk)
}
fn visit_coroutine_kind(&mut self, a: &mut CoroutineKind) {
- noop_visit_coroutine_kind(a, self);
+ walk_coroutine_kind(self, a);
}
fn visit_closure_binder(&mut self, b: &mut ClosureBinder) {
- noop_visit_closure_binder(b, self);
+ walk_closure_binder(self, b);
}
fn visit_block(&mut self, b: &mut P<Block>) {
- noop_visit_block(b, self);
+ walk_block(self, b);
}
fn flat_map_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> {
- noop_flat_map_stmt(s, self)
+ walk_flat_map_stmt(self, s)
+ }
+
+ fn visit_arm(&mut self, arm: &mut Arm) {
+ walk_arm(self, arm);
}
fn flat_map_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> {
- noop_flat_map_arm(arm, self)
+ walk_flat_map_arm(self, arm)
}
fn visit_pat(&mut self, p: &mut P<Pat>) {
- noop_visit_pat(p, self);
+ walk_pat(self, p);
}
fn visit_anon_const(&mut self, c: &mut AnonConst) {
- noop_visit_anon_const(c, self);
+ walk_anon_const(self, c);
}
fn visit_expr(&mut self, e: &mut P<Expr>) {
- noop_visit_expr(e, self);
+ walk_expr(self, e);
}
/// This method is a hack to workaround unstable of `stmt_expr_attributes`.
@@ -160,155 +191,200 @@ pub trait MutVisitor: Sized {
}
fn filter_map_expr(&mut self, e: P<Expr>) -> Option<P<Expr>> {
- noop_filter_map_expr(e, self)
+ noop_filter_map_expr(self, e)
}
fn visit_generic_arg(&mut self, arg: &mut GenericArg) {
- noop_visit_generic_arg(arg, self);
+ walk_generic_arg(self, arg);
}
fn visit_ty(&mut self, t: &mut P<Ty>) {
- noop_visit_ty(t, self);
+ walk_ty(self, t);
+ }
+
+ fn visit_ty_pat(&mut self, t: &mut P<TyPat>) {
+ walk_ty_pat(self, t);
}
fn visit_lifetime(&mut self, l: &mut Lifetime) {
- noop_visit_lifetime(l, self);
+ walk_lifetime(self, l);
}
fn visit_assoc_item_constraint(&mut self, c: &mut AssocItemConstraint) {
- noop_visit_assoc_item_constraint(c, self);
+ walk_assoc_item_constraint(self, c);
}
fn visit_foreign_mod(&mut self, nm: &mut ForeignMod) {
- noop_visit_foreign_mod(nm, self);
+ walk_foreign_mod(self, nm);
+ }
+
+ fn visit_variant(&mut self, v: &mut Variant) {
+ walk_variant(self, v);
}
fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
- noop_flat_map_variant(v, self)
+ walk_flat_map_variant(self, v)
}
fn visit_ident(&mut self, i: &mut Ident) {
- noop_visit_ident(i, self);
+ walk_ident(self, i);
+ }
+
+ fn visit_modifiers(&mut self, m: &mut TraitBoundModifiers) {
+ walk_modifiers(self, m);
}
fn visit_path(&mut self, p: &mut Path) {
- noop_visit_path(p, self);
+ walk_path(self, p);
+ }
+
+ fn visit_path_segment(&mut self, p: &mut PathSegment) {
+ walk_path_segment(self, p)
}
fn visit_qself(&mut self, qs: &mut Option<P<QSelf>>) {
- noop_visit_qself(qs, self);
+ walk_qself(self, qs);
}
fn visit_generic_args(&mut self, p: &mut GenericArgs) {
- noop_visit_generic_args(p, self);
+ walk_generic_args(self, p);
}
fn visit_angle_bracketed_parameter_data(&mut self, p: &mut AngleBracketedArgs) {
- noop_visit_angle_bracketed_parameter_data(p, self);
+ walk_angle_bracketed_parameter_data(self, p);
}
fn visit_parenthesized_parameter_data(&mut self, p: &mut ParenthesizedArgs) {
- noop_visit_parenthesized_parameter_data(p, self);
+ walk_parenthesized_parameter_data(self, p);
}
fn visit_local(&mut self, l: &mut P<Local>) {
- noop_visit_local(l, self);
+ walk_local(self, l);
}
fn visit_mac_call(&mut self, mac: &mut MacCall) {
- noop_visit_mac(mac, self);
+ walk_mac(self, mac);
}
fn visit_macro_def(&mut self, def: &mut MacroDef) {
- noop_visit_macro_def(def, self);
+ walk_macro_def(self, def);
}
fn visit_label(&mut self, label: &mut Label) {
- noop_visit_label(label, self);
+ walk_label(self, label);
}
fn visit_attribute(&mut self, at: &mut Attribute) {
- noop_visit_attribute(at, self);
+ walk_attribute(self, at);
+ }
+
+ fn visit_param(&mut self, param: &mut Param) {
+ walk_param(self, param);
}
fn flat_map_param(&mut self, param: Param) -> SmallVec<[Param; 1]> {
- noop_flat_map_param(param, self)
+ walk_flat_map_param(self, param)
}
fn visit_generics(&mut self, generics: &mut Generics) {
- noop_visit_generics(generics, self);
+ walk_generics(self, generics);
}
fn visit_trait_ref(&mut self, tr: &mut TraitRef) {
- noop_visit_trait_ref(tr, self);
+ walk_trait_ref(self, tr);
}
fn visit_poly_trait_ref(&mut self, p: &mut PolyTraitRef) {
- noop_visit_poly_trait_ref(p, self);
+ walk_poly_trait_ref(self, p);
}
fn visit_variant_data(&mut self, vdata: &mut VariantData) {
- noop_visit_variant_data(vdata, self);
+ walk_variant_data(self, vdata);
+ }
+
+ fn visit_generic_param(&mut self, param: &mut GenericParam) {
+ walk_generic_param(self, param)
}
fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> {
- noop_flat_map_generic_param(param, self)
+ walk_flat_map_generic_param(self, param)
}
- fn visit_param_bound(&mut self, tpb: &mut GenericBound) {
- noop_visit_param_bound(tpb, self);
+ fn visit_param_bound(&mut self, tpb: &mut GenericBound, _ctxt: BoundKind) {
+ walk_param_bound(self, tpb);
}
fn visit_precise_capturing_arg(&mut self, arg: &mut PreciseCapturingArg) {
- noop_visit_precise_capturing_arg(arg, self);
+ walk_precise_capturing_arg(self, arg);
}
fn visit_mt(&mut self, mt: &mut MutTy) {
- noop_visit_mt(mt, self);
+ walk_mt(self, mt);
+ }
+
+ fn visit_expr_field(&mut self, f: &mut ExprField) {
+ walk_expr_field(self, f);
}
fn flat_map_expr_field(&mut self, f: ExprField) -> SmallVec<[ExprField; 1]> {
- noop_flat_map_expr_field(f, self)
+ walk_flat_map_expr_field(self, f)
}
fn visit_where_clause(&mut self, where_clause: &mut WhereClause) {
- noop_visit_where_clause(where_clause, self);
+ walk_where_clause(self, where_clause);
+ }
+
+ fn flat_map_where_predicate(
+ &mut self,
+ where_predicate: WherePredicate,
+ ) -> SmallVec<[WherePredicate; 1]> {
+ walk_flat_map_where_predicate(self, where_predicate)
}
- fn visit_where_predicate(&mut self, where_predicate: &mut WherePredicate) {
- noop_visit_where_predicate(where_predicate, self);
+ fn visit_where_predicate_kind(&mut self, kind: &mut WherePredicateKind) {
+ walk_where_predicate_kind(self, kind)
}
fn visit_vis(&mut self, vis: &mut Visibility) {
- noop_visit_vis(vis, self);
+ walk_vis(self, vis);
}
fn visit_id(&mut self, _id: &mut NodeId) {
// Do nothing.
}
+ // Span visiting is no longer used, but we keep it for now,
+ // in case it's needed for something like #127241.
fn visit_span(&mut self, _sp: &mut Span) {
// Do nothing.
}
+ fn visit_pat_field(&mut self, fp: &mut PatField) {
+ walk_pat_field(self, fp)
+ }
+
fn flat_map_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> {
- noop_flat_map_pat_field(fp, self)
+ walk_flat_map_pat_field(self, fp)
}
fn visit_inline_asm(&mut self, asm: &mut InlineAsm) {
- noop_visit_inline_asm(asm, self)
+ walk_inline_asm(self, asm)
}
fn visit_inline_asm_sym(&mut self, sym: &mut InlineAsmSym) {
- noop_visit_inline_asm_sym(sym, self)
+ walk_inline_asm_sym(self, sym)
}
fn visit_format_args(&mut self, fmt: &mut FormatArgs) {
- noop_visit_format_args(fmt, self)
+ walk_format_args(self, fmt)
}
fn visit_capture_by(&mut self, capture_by: &mut CaptureBy) {
- noop_visit_capture_by(capture_by, self)
+ walk_capture_by(self, capture_by)
+ }
+
+ fn visit_fn_ret_ty(&mut self, fn_ret_ty: &mut FnRetTy) {
+ walk_fn_ret_ty(self, fn_ret_ty)
}
}
@@ -356,7 +432,7 @@ where
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_attrs<T: MutVisitor>(attrs: &mut AttrVec, vis: &mut T) {
+fn visit_attrs<T: MutVisitor>(vis: &mut T, attrs: &mut AttrVec) {
for attr in attrs.iter_mut() {
vis.visit_attribute(attr);
}
@@ -364,68 +440,58 @@ fn visit_attrs<T: MutVisitor>(attrs: &mut AttrVec, vis: &mut T) {
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
#[allow(unused)]
-fn visit_exprs<T: MutVisitor>(exprs: &mut Vec<P<Expr>>, vis: &mut T) {
+fn visit_exprs<T: MutVisitor>(vis: &mut T, exprs: &mut Vec<P<Expr>>) {
exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr))
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_thin_exprs<T: MutVisitor>(exprs: &mut ThinVec<P<Expr>>, vis: &mut T) {
+fn visit_thin_exprs<T: MutVisitor>(vis: &mut T, exprs: &mut ThinVec<P<Expr>>) {
exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr))
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_bounds<T: MutVisitor>(bounds: &mut GenericBounds, vis: &mut T) {
- visit_vec(bounds, |bound| vis.visit_param_bound(bound));
-}
-
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_fn_sig<T: MutVisitor>(FnSig { header, decl, span }: &mut FnSig, vis: &mut T) {
- vis.visit_fn_header(header);
- vis.visit_fn_decl(decl);
- vis.visit_span(span);
+fn visit_bounds<T: MutVisitor>(vis: &mut T, bounds: &mut GenericBounds, ctxt: BoundKind) {
+ visit_vec(bounds, |bound| vis.visit_param_bound(bound, ctxt));
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_attr_args<T: MutVisitor>(args: &mut AttrArgs, vis: &mut T) {
+fn visit_attr_args<T: MutVisitor>(vis: &mut T, args: &mut AttrArgs) {
match args {
AttrArgs::Empty => {}
- AttrArgs::Delimited(args) => visit_delim_args(args, vis),
- AttrArgs::Eq(eq_span, AttrArgsEq::Ast(expr)) => {
+ AttrArgs::Delimited(args) => visit_delim_args(vis, args),
+ AttrArgs::Eq { eq_span, expr } => {
vis.visit_expr(expr);
vis.visit_span(eq_span);
}
- AttrArgs::Eq(_eq_span, AttrArgsEq::Hir(lit)) => {
- unreachable!("in literal form when visiting mac args eq: {:?}", lit)
- }
}
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_delim_args<T: MutVisitor>(args: &mut DelimArgs, vis: &mut T) {
- let DelimArgs { dspan, delim: _, tokens } = args;
- visit_tts(tokens, vis);
- visit_delim_span(dspan, vis);
-}
-
-pub fn visit_delim_span<T: MutVisitor>(DelimSpan { open, close }: &mut DelimSpan, vis: &mut T) {
+fn visit_delim_args<T: MutVisitor>(vis: &mut T, args: &mut DelimArgs) {
+ let DelimArgs { dspan, delim: _, tokens: _ } = args;
+ let DelimSpan { open, close } = dspan;
vis.visit_span(open);
vis.visit_span(close);
}
-pub fn noop_flat_map_pat_field<T: MutVisitor>(
- mut fp: PatField,
- vis: &mut T,
-) -> SmallVec<[PatField; 1]> {
- let PatField { attrs, id, ident, is_placeholder: _, is_shorthand: _, pat, span } = &mut fp;
+pub fn walk_pat_field<T: MutVisitor>(vis: &mut T, fp: &mut PatField) {
+ let PatField { attrs, id, ident, is_placeholder: _, is_shorthand: _, pat, span } = fp;
vis.visit_id(id);
- visit_attrs(attrs, vis);
+ visit_attrs(vis, attrs);
vis.visit_ident(ident);
vis.visit_pat(pat);
vis.visit_span(span);
+}
+
+pub fn walk_flat_map_pat_field<T: MutVisitor>(
+ vis: &mut T,
+ mut fp: PatField,
+) -> SmallVec<[PatField; 1]> {
+ vis.visit_pat_field(&mut fp);
smallvec![fp]
}
-fn noop_visit_use_tree<T: MutVisitor>(use_tree: &mut UseTree, vis: &mut T) {
+fn walk_use_tree<T: MutVisitor>(vis: &mut T, use_tree: &mut UseTree) {
let UseTree { prefix, kind, span } = use_tree;
vis.visit_path(prefix);
match kind {
@@ -442,20 +508,24 @@ fn noop_visit_use_tree<T: MutVisitor>(use_tree: &mut UseTree, vis: &mut T) {
vis.visit_span(span);
}
-pub fn noop_flat_map_arm<T: MutVisitor>(mut arm: Arm, vis: &mut T) -> SmallVec<[Arm; 1]> {
- let Arm { attrs, pat, guard, body, span, id, is_placeholder: _ } = &mut arm;
+pub fn walk_arm<T: MutVisitor>(vis: &mut T, arm: &mut Arm) {
+ let Arm { attrs, pat, guard, body, span, id, is_placeholder: _ } = arm;
vis.visit_id(id);
- visit_attrs(attrs, vis);
+ visit_attrs(vis, attrs);
vis.visit_pat(pat);
visit_opt(guard, |guard| vis.visit_expr(guard));
visit_opt(body, |body| vis.visit_expr(body));
vis.visit_span(span);
+}
+
+pub fn walk_flat_map_arm<T: MutVisitor>(vis: &mut T, mut arm: Arm) -> SmallVec<[Arm; 1]> {
+ vis.visit_arm(&mut arm);
smallvec![arm]
}
-fn noop_visit_assoc_item_constraint<T: MutVisitor>(
- AssocItemConstraint { id, ident, gen_args, kind, span }: &mut AssocItemConstraint,
+fn walk_assoc_item_constraint<T: MutVisitor>(
vis: &mut T,
+ AssocItemConstraint { id, ident, gen_args, kind, span }: &mut AssocItemConstraint,
) {
vis.visit_id(id);
vis.visit_ident(ident);
@@ -467,13 +537,13 @@ fn noop_visit_assoc_item_constraint<T: MutVisitor>(
Term::Ty(ty) => vis.visit_ty(ty),
Term::Const(c) => vis.visit_anon_const(c),
},
- AssocItemConstraintKind::Bound { bounds } => visit_bounds(bounds, vis),
+ AssocItemConstraintKind::Bound { bounds } => visit_bounds(vis, bounds, BoundKind::Bound),
}
vis.visit_span(span);
}
-pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
- let Ty { id, kind, span, tokens } = ty.deref_mut();
+pub fn walk_ty<T: MutVisitor>(vis: &mut T, ty: &mut P<Ty>) {
+ let Ty { id, kind, span, tokens: _ } = ty.deref_mut();
vis.visit_id(id);
match kind {
TyKind::Err(_guar) => {}
@@ -481,22 +551,27 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
}
TyKind::Slice(ty) => vis.visit_ty(ty),
TyKind::Ptr(mt) => vis.visit_mt(mt),
- TyKind::Ref(lt, mt) => {
- visit_opt(lt, |lt| noop_visit_lifetime(lt, vis));
+ TyKind::Ref(lt, mt) | TyKind::PinnedRef(lt, mt) => {
+ visit_opt(lt, |lt| vis.visit_lifetime(lt));
vis.visit_mt(mt);
}
TyKind::BareFn(bft) => {
let BareFnTy { safety, ext: _, generic_params, decl, decl_span } = bft.deref_mut();
- visit_safety(safety, vis);
+ visit_safety(vis, safety);
generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
vis.visit_fn_decl(decl);
vis.visit_span(decl_span);
}
+ TyKind::UnsafeBinder(binder) => {
+ let UnsafeBinderTy { generic_params, inner_ty } = binder.deref_mut();
+ generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
+ vis.visit_ty(inner_ty);
+ }
TyKind::Tup(tys) => visit_thin_vec(tys, |ty| vis.visit_ty(ty)),
TyKind::Paren(ty) => vis.visit_ty(ty),
TyKind::Pat(ty, pat) => {
vis.visit_ty(ty);
- vis.visit_pat(pat);
+ vis.visit_ty_pat(pat);
}
TyKind::Path(qself, path) => {
vis.visit_qself(qself);
@@ -508,58 +583,75 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
}
TyKind::Typeof(expr) => vis.visit_anon_const(expr),
TyKind::TraitObject(bounds, _syntax) => {
- visit_vec(bounds, |bound| vis.visit_param_bound(bound))
+ visit_vec(bounds, |bound| vis.visit_param_bound(bound, BoundKind::TraitObject))
}
TyKind::ImplTrait(id, bounds) => {
vis.visit_id(id);
- visit_vec(bounds, |bound| vis.visit_param_bound(bound));
+ visit_vec(bounds, |bound| vis.visit_param_bound(bound, BoundKind::Impl));
}
TyKind::MacCall(mac) => vis.visit_mac_call(mac),
- TyKind::AnonStruct(id, fields) | TyKind::AnonUnion(id, fields) => {
- vis.visit_id(id);
- fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
+ }
+ vis.visit_span(span);
+}
+
+pub fn walk_ty_pat<T: MutVisitor>(vis: &mut T, ty: &mut P<TyPat>) {
+ let TyPat { id, kind, span, tokens: _ } = ty.deref_mut();
+ vis.visit_id(id);
+ match kind {
+ TyPatKind::Range(start, end, _include_end) => {
+ visit_opt(start, |c| vis.visit_anon_const(c));
+ visit_opt(end, |c| vis.visit_anon_const(c));
}
+ TyPatKind::Or(variants) => visit_thin_vec(variants, |p| vis.visit_ty_pat(p)),
+ TyPatKind::Err(_) => {}
}
- visit_lazy_tts(tokens, vis);
vis.visit_span(span);
}
-fn noop_visit_foreign_mod<T: MutVisitor>(foreign_mod: &mut ForeignMod, vis: &mut T) {
- let ForeignMod { safety, abi: _, items } = foreign_mod;
- visit_safety(safety, vis);
+fn walk_foreign_mod<T: MutVisitor>(vis: &mut T, foreign_mod: &mut ForeignMod) {
+ let ForeignMod { extern_span: _, safety, abi: _, items } = foreign_mod;
+ visit_safety(vis, safety);
items.flat_map_in_place(|item| vis.flat_map_foreign_item(item));
}
-pub fn noop_flat_map_variant<T: MutVisitor>(
- mut variant: Variant,
- visitor: &mut T,
-) -> SmallVec<[Variant; 1]> {
- let Variant { ident, vis, attrs, id, data, disr_expr, span, is_placeholder: _ } = &mut variant;
+pub fn walk_variant<T: MutVisitor>(visitor: &mut T, variant: &mut Variant) {
+ let Variant { ident, vis, attrs, id, data, disr_expr, span, is_placeholder: _ } = variant;
visitor.visit_id(id);
- visit_attrs(attrs, visitor);
+ visit_attrs(visitor, attrs);
visitor.visit_vis(vis);
visitor.visit_ident(ident);
visitor.visit_variant_data(data);
visit_opt(disr_expr, |disr_expr| visitor.visit_anon_const(disr_expr));
visitor.visit_span(span);
+}
+
+pub fn walk_flat_map_variant<T: MutVisitor>(
+ vis: &mut T,
+ mut variant: Variant,
+) -> SmallVec<[Variant; 1]> {
+ vis.visit_variant(&mut variant);
smallvec![variant]
}
-fn noop_visit_ident<T: MutVisitor>(Ident { name: _, span }: &mut Ident, vis: &mut T) {
+fn walk_ident<T: MutVisitor>(vis: &mut T, Ident { name: _, span }: &mut Ident) {
vis.visit_span(span);
}
-fn noop_visit_path<T: MutVisitor>(Path { segments, span, tokens }: &mut Path, vis: &mut T) {
- for PathSegment { ident, id, args } in segments {
- vis.visit_id(id);
- vis.visit_ident(ident);
- visit_opt(args, |args| vis.visit_generic_args(args));
+fn walk_path_segment<T: MutVisitor>(vis: &mut T, segment: &mut PathSegment) {
+ let PathSegment { ident, id, args } = segment;
+ vis.visit_id(id);
+ vis.visit_ident(ident);
+ visit_opt(args, |args| vis.visit_generic_args(args));
+}
+
+fn walk_path<T: MutVisitor>(vis: &mut T, Path { segments, span, tokens: _ }: &mut Path) {
+ for segment in segments {
+ vis.visit_path_segment(segment);
}
- visit_lazy_tts(tokens, vis);
vis.visit_span(span);
}
-fn noop_visit_qself<T: MutVisitor>(qself: &mut Option<P<QSelf>>, vis: &mut T) {
+fn walk_qself<T: MutVisitor>(vis: &mut T, qself: &mut Option<P<QSelf>>) {
visit_opt(qself, |qself| {
let QSelf { ty, path_span, position: _ } = &mut **qself;
vis.visit_ty(ty);
@@ -567,7 +659,7 @@ fn noop_visit_qself<T: MutVisitor>(qself: &mut Option<P<QSelf>>, vis: &mut T) {
})
}
-fn noop_visit_generic_args<T: MutVisitor>(generic_args: &mut GenericArgs, vis: &mut T) {
+fn walk_generic_args<T: MutVisitor>(vis: &mut T, generic_args: &mut GenericArgs) {
match generic_args {
GenericArgs::AngleBracketed(data) => vis.visit_angle_bracketed_parameter_data(data),
GenericArgs::Parenthesized(data) => vis.visit_parenthesized_parameter_data(data),
@@ -575,7 +667,7 @@ fn noop_visit_generic_args<T: MutVisitor>(generic_args: &mut GenericArgs, vis: &
}
}
-fn noop_visit_generic_arg<T: MutVisitor>(arg: &mut GenericArg, vis: &mut T) {
+fn walk_generic_arg<T: MutVisitor>(vis: &mut T, arg: &mut GenericArg) {
match arg {
GenericArg::Lifetime(lt) => vis.visit_lifetime(lt),
GenericArg::Type(ty) => vis.visit_ty(ty),
@@ -583,10 +675,7 @@ fn noop_visit_generic_arg<T: MutVisitor>(arg: &mut GenericArg, vis: &mut T) {
}
}
-fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>(
- data: &mut AngleBracketedArgs,
- vis: &mut T,
-) {
+fn walk_angle_bracketed_parameter_data<T: MutVisitor>(vis: &mut T, data: &mut AngleBracketedArgs) {
let AngleBracketedArgs { args, span } = data;
visit_thin_vec(args, |arg| match arg {
AngleBracketedArg::Arg(arg) => vis.visit_generic_arg(arg),
@@ -595,21 +684,19 @@ fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>(
vis.visit_span(span);
}
-fn noop_visit_parenthesized_parameter_data<T: MutVisitor>(
- args: &mut ParenthesizedArgs,
- vis: &mut T,
-) {
+fn walk_parenthesized_parameter_data<T: MutVisitor>(vis: &mut T, args: &mut ParenthesizedArgs) {
let ParenthesizedArgs { inputs, output, span, inputs_span } = args;
visit_thin_vec(inputs, |input| vis.visit_ty(input));
- noop_visit_fn_ret_ty(output, vis);
+ vis.visit_fn_ret_ty(output);
vis.visit_span(span);
vis.visit_span(inputs_span);
}
-fn noop_visit_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) {
- let Local { id, pat, ty, kind, span, colon_sp, attrs, tokens } = local.deref_mut();
+fn walk_local<T: MutVisitor>(vis: &mut T, local: &mut P<Local>) {
+ let Local { id, super_, pat, ty, kind, span, colon_sp, attrs, tokens: _ } = local.deref_mut();
+ visit_opt(super_, |sp| vis.visit_span(sp));
vis.visit_id(id);
- visit_attrs(attrs, vis);
+ visit_attrs(vis, attrs);
vis.visit_pat(pat);
visit_opt(ty, |ty| vis.visit_ty(ty));
match kind {
@@ -622,48 +709,43 @@ fn noop_visit_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) {
vis.visit_block(els);
}
}
- visit_lazy_tts(tokens, vis);
visit_opt(colon_sp, |sp| vis.visit_span(sp));
vis.visit_span(span);
}
-fn noop_visit_attribute<T: MutVisitor>(attr: &mut Attribute, vis: &mut T) {
+fn walk_attribute<T: MutVisitor>(vis: &mut T, attr: &mut Attribute) {
let Attribute { kind, id: _, style: _, span } = attr;
match kind {
AttrKind::Normal(normal) => {
- let NormalAttr {
- item: AttrItem { unsafety: _, path, args, tokens },
- tokens: attr_tokens,
- } = &mut **normal;
+ let NormalAttr { item: AttrItem { unsafety: _, path, args, tokens: _ }, tokens: _ } =
+ &mut **normal;
vis.visit_path(path);
- visit_attr_args(args, vis);
- visit_lazy_tts(tokens, vis);
- visit_lazy_tts(attr_tokens, vis);
+ visit_attr_args(vis, args);
}
AttrKind::DocComment(_kind, _sym) => {}
}
vis.visit_span(span);
}
-fn noop_visit_mac<T: MutVisitor>(mac: &mut MacCall, vis: &mut T) {
+fn walk_mac<T: MutVisitor>(vis: &mut T, mac: &mut MacCall) {
let MacCall { path, args } = mac;
vis.visit_path(path);
- visit_delim_args(args, vis);
+ visit_delim_args(vis, args);
}
-fn noop_visit_macro_def<T: MutVisitor>(macro_def: &mut MacroDef, vis: &mut T) {
+fn walk_macro_def<T: MutVisitor>(vis: &mut T, macro_def: &mut MacroDef) {
let MacroDef { body, macro_rules: _ } = macro_def;
- visit_delim_args(body, vis);
+ visit_delim_args(vis, body);
}
-fn noop_visit_meta_list_item<T: MutVisitor>(li: &mut NestedMetaItem, vis: &mut T) {
+fn walk_meta_list_item<T: MutVisitor>(vis: &mut T, li: &mut MetaItemInner) {
match li {
- NestedMetaItem::MetaItem(mi) => vis.visit_meta_item(mi),
- NestedMetaItem::Lit(_lit) => {}
+ MetaItemInner::MetaItem(mi) => vis.visit_meta_item(mi),
+ MetaItemInner::Lit(_lit) => {}
}
}
-fn noop_visit_meta_item<T: MutVisitor>(mi: &mut MetaItem, vis: &mut T) {
+fn walk_meta_item<T: MutVisitor>(vis: &mut T, mi: &mut MetaItem) {
let MetaItem { unsafety: _, path: _, kind, span } = mi;
match kind {
MetaItemKind::Word => {}
@@ -673,160 +755,22 @@ fn noop_visit_meta_item<T: MutVisitor>(mi: &mut MetaItem, vis: &mut T) {
vis.visit_span(span);
}
-pub fn noop_flat_map_param<T: MutVisitor>(mut param: Param, vis: &mut T) -> SmallVec<[Param; 1]> {
- let Param { attrs, id, pat, span, ty, is_placeholder: _ } = &mut param;
+pub fn walk_param<T: MutVisitor>(vis: &mut T, param: &mut Param) {
+ let Param { attrs, id, pat, span, ty, is_placeholder: _ } = param;
vis.visit_id(id);
- visit_attrs(attrs, vis);
+ visit_attrs(vis, attrs);
vis.visit_pat(pat);
vis.visit_ty(ty);
vis.visit_span(span);
- smallvec![param]
}
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_attr_tt<T: MutVisitor>(tt: &mut AttrTokenTree, vis: &mut T) {
- match tt {
- AttrTokenTree::Token(token, _spacing) => {
- visit_token(token, vis);
- }
- AttrTokenTree::Delimited(dspan, _spacing, _delim, tts) => {
- visit_attr_tts(tts, vis);
- visit_delim_span(dspan, vis);
- }
- AttrTokenTree::AttrsTarget(AttrsTarget { attrs, tokens }) => {
- visit_attrs(attrs, vis);
- visit_lazy_tts_opt_mut(Some(tokens), vis);
- }
- }
-}
-
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_tt<T: MutVisitor>(tt: &mut TokenTree, vis: &mut T) {
- match tt {
- TokenTree::Token(token, _spacing) => {
- visit_token(token, vis);
- }
- TokenTree::Delimited(dspan, _spacing, _delim, tts) => {
- visit_tts(tts, vis);
- visit_delim_span(dspan, vis);
- }
- }
-}
-
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_tts<T: MutVisitor>(TokenStream(tts): &mut TokenStream, vis: &mut T) {
- if T::VISIT_TOKENS && !tts.is_empty() {
- let tts = Lrc::make_mut(tts);
- visit_vec(tts, |tree| visit_tt(tree, vis));
- }
-}
-
-fn visit_attr_tts<T: MutVisitor>(AttrTokenStream(tts): &mut AttrTokenStream, vis: &mut T) {
- if T::VISIT_TOKENS && !tts.is_empty() {
- let tts = Lrc::make_mut(tts);
- visit_vec(tts, |tree| visit_attr_tt(tree, vis));
- }
-}
-
-fn visit_lazy_tts_opt_mut<T: MutVisitor>(lazy_tts: Option<&mut LazyAttrTokenStream>, vis: &mut T) {
- if T::VISIT_TOKENS {
- if let Some(lazy_tts) = lazy_tts {
- let mut tts = lazy_tts.to_attr_token_stream();
- visit_attr_tts(&mut tts, vis);
- *lazy_tts = LazyAttrTokenStream::new(tts);
- }
- }
-}
-
-fn visit_lazy_tts<T: MutVisitor>(lazy_tts: &mut Option<LazyAttrTokenStream>, vis: &mut T) {
- visit_lazy_tts_opt_mut(lazy_tts.as_mut(), vis);
-}
-
-/// Applies ident visitor if it's an ident; applies other visits to interpolated nodes.
-/// In practice the ident part is not actually used by specific visitors right now,
-/// but there's a test below checking that it works.
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-pub fn visit_token<T: MutVisitor>(t: &mut Token, vis: &mut T) {
- let Token { kind, span } = t;
- match kind {
- token::Ident(name, _ /*raw*/) | token::Lifetime(name) => {
- let mut ident = Ident::new(*name, *span);
- vis.visit_ident(&mut ident);
- *name = ident.name;
- *span = ident.span;
- return; // Avoid visiting the span for the second time.
- }
- token::NtIdent(ident, _is_raw) => {
- vis.visit_ident(ident);
- }
- token::NtLifetime(ident) => {
- vis.visit_ident(ident);
- }
- token::Interpolated(nt) => {
- let nt = Lrc::make_mut(nt);
- visit_nonterminal(nt, vis);
- }
- _ => {}
- }
- vis.visit_span(span);
-}
-
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-/// Applies the visitor to elements of interpolated nodes.
-//
-// N.B., this can occur only when applying a visitor to partially expanded
-// code, where parsed pieces have gotten implanted ito *other* macro
-// invocations. This is relevant for macro hygiene, but possibly not elsewhere.
-//
-// One problem here occurs because the types for flat_map_item, flat_map_stmt,
-// etc., allow the visitor to return *multiple* items; this is a problem for the
-// nodes here, because they insist on having exactly one piece. One solution
-// would be to mangle the MutVisitor trait to include one-to-many and
-// one-to-one versions of these entry points, but that would probably confuse a
-// lot of people and help very few. Instead, I'm just going to put in dynamic
-// checks. I think the performance impact of this will be pretty much
-// nonexistent. The danger is that someone will apply a `MutVisitor` to a
-// partially expanded node, and will be confused by the fact that their
-// `flat_map_item` or `flat_map_stmt` isn't getting called on `NtItem` or `NtStmt`
-// nodes. Hopefully they'll wind up reading this comment, and doing something
-// appropriate.
-//
-// BTW, design choice: I considered just changing the type of, e.g., `NtItem` to
-// contain multiple items, but decided against it when I looked at
-// `parse_item_or_view_item` and tried to figure out what I would do with
-// multiple items there....
-fn visit_nonterminal<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T) {
- match nt {
- token::NtItem(item) => visit_clobber(item, |item| {
- // This is probably okay, because the only visitors likely to
- // peek inside interpolated nodes will be renamings/markings,
- // which map single items to single items.
- vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item")
- }),
- token::NtBlock(block) => vis.visit_block(block),
- token::NtStmt(stmt) => visit_clobber(stmt, |stmt| {
- // See reasoning above.
- stmt.map(|stmt| {
- vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
- })
- }),
- token::NtPat(pat) => vis.visit_pat(pat),
- token::NtExpr(expr) => vis.visit_expr(expr),
- token::NtTy(ty) => vis.visit_ty(ty),
- token::NtLiteral(expr) => vis.visit_expr(expr),
- token::NtMeta(item) => {
- let AttrItem { unsafety: _, path, args, tokens } = item.deref_mut();
- vis.visit_path(path);
- visit_attr_args(args, vis);
- visit_lazy_tts(tokens, vis);
- }
- token::NtPath(path) => vis.visit_path(path),
- token::NtVis(visib) => vis.visit_vis(visib),
- }
+pub fn walk_flat_map_param<T: MutVisitor>(vis: &mut T, mut param: Param) -> SmallVec<[Param; 1]> {
+ vis.visit_param(&mut param);
+ smallvec![param]
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_defaultness<T: MutVisitor>(defaultness: &mut Defaultness, vis: &mut T) {
+fn visit_defaultness<T: MutVisitor>(vis: &mut T, defaultness: &mut Defaultness) {
match defaultness {
Defaultness::Default(span) => vis.visit_span(span),
Defaultness::Final => {}
@@ -834,7 +778,7 @@ fn visit_defaultness<T: MutVisitor>(defaultness: &mut Defaultness, vis: &mut T)
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_safety<T: MutVisitor>(safety: &mut Safety, vis: &mut T) {
+fn visit_safety<T: MutVisitor>(vis: &mut T, safety: &mut Safety) {
match safety {
Safety::Unsafe(span) => vis.visit_span(span),
Safety::Safe(span) => vis.visit_span(span),
@@ -843,7 +787,7 @@ fn visit_safety<T: MutVisitor>(safety: &mut Safety, vis: &mut T) {
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_polarity<T: MutVisitor>(polarity: &mut ImplPolarity, vis: &mut T) {
+fn visit_polarity<T: MutVisitor>(vis: &mut T, polarity: &mut ImplPolarity) {
match polarity {
ImplPolarity::Positive => {}
ImplPolarity::Negative(span) => vis.visit_span(span),
@@ -851,14 +795,14 @@ fn visit_polarity<T: MutVisitor>(polarity: &mut ImplPolarity, vis: &mut T) {
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_constness<T: MutVisitor>(constness: &mut Const, vis: &mut T) {
+fn visit_constness<T: MutVisitor>(vis: &mut T, constness: &mut Const) {
match constness {
Const::Yes(span) => vis.visit_span(span),
Const::No => {}
}
}
-fn noop_visit_closure_binder<T: MutVisitor>(binder: &mut ClosureBinder, vis: &mut T) {
+fn walk_closure_binder<T: MutVisitor>(vis: &mut T, binder: &mut ClosureBinder) {
match binder {
ClosureBinder::NotPresent => {}
ClosureBinder::For { span: _, generic_params } => {
@@ -867,7 +811,7 @@ fn noop_visit_closure_binder<T: MutVisitor>(binder: &mut ClosureBinder, vis: &mu
}
}
-fn noop_visit_coroutine_kind<T: MutVisitor>(coroutine_kind: &mut CoroutineKind, vis: &mut T) {
+fn walk_coroutine_kind<T: MutVisitor>(vis: &mut T, coroutine_kind: &mut CoroutineKind) {
match coroutine_kind {
CoroutineKind::Async { span, closure_id, return_impl_trait_id }
| CoroutineKind::Gen { span, closure_id, return_impl_trait_id }
@@ -879,23 +823,73 @@ fn noop_visit_coroutine_kind<T: MutVisitor>(coroutine_kind: &mut CoroutineKind,
}
}
-fn noop_visit_fn_decl<T: MutVisitor>(decl: &mut P<FnDecl>, vis: &mut T) {
+fn walk_fn<T: MutVisitor>(vis: &mut T, kind: FnKind<'_>) {
+ match kind {
+ FnKind::Fn(
+ _ctxt,
+ _vis,
+ Fn {
+ defaultness,
+ ident,
+ generics,
+ contract,
+ body,
+ sig: FnSig { header, decl, span },
+ define_opaque,
+ },
+ ) => {
+ // Visibility is visited as a part of the item.
+ visit_defaultness(vis, defaultness);
+ vis.visit_ident(ident);
+ vis.visit_fn_header(header);
+ vis.visit_generics(generics);
+ vis.visit_fn_decl(decl);
+ if let Some(contract) = contract {
+ vis.visit_contract(contract);
+ }
+ if let Some(body) = body {
+ vis.visit_block(body);
+ }
+ vis.visit_span(span);
+
+ walk_define_opaques(vis, define_opaque);
+ }
+ FnKind::Closure(binder, coroutine_kind, decl, body) => {
+ vis.visit_closure_binder(binder);
+ coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind));
+ vis.visit_fn_decl(decl);
+ vis.visit_expr(body);
+ }
+ }
+}
+
+fn walk_contract<T: MutVisitor>(vis: &mut T, contract: &mut P<FnContract>) {
+ let FnContract { requires, ensures } = contract.deref_mut();
+ if let Some(pred) = requires {
+ vis.visit_expr(pred);
+ }
+ if let Some(pred) = ensures {
+ vis.visit_expr(pred);
+ }
+}
+
+fn walk_fn_decl<T: MutVisitor>(vis: &mut T, decl: &mut P<FnDecl>) {
let FnDecl { inputs, output } = decl.deref_mut();
inputs.flat_map_in_place(|param| vis.flat_map_param(param));
- noop_visit_fn_ret_ty(output, vis);
+ vis.visit_fn_ret_ty(output);
}
-fn noop_visit_fn_ret_ty<T: MutVisitor>(fn_ret_ty: &mut FnRetTy, vis: &mut T) {
+fn walk_fn_ret_ty<T: MutVisitor>(vis: &mut T, fn_ret_ty: &mut FnRetTy) {
match fn_ret_ty {
FnRetTy::Default(span) => vis.visit_span(span),
FnRetTy::Ty(ty) => vis.visit_ty(ty),
}
}
-fn noop_visit_param_bound<T: MutVisitor>(pb: &mut GenericBound, vis: &mut T) {
+fn walk_param_bound<T: MutVisitor>(vis: &mut T, pb: &mut GenericBound) {
match pb {
- GenericBound::Trait(ty, _modifier) => vis.visit_poly_trait_ref(ty),
- GenericBound::Outlives(lifetime) => noop_visit_lifetime(lifetime, vis),
+ GenericBound::Trait(trait_ref) => vis.visit_poly_trait_ref(trait_ref),
+ GenericBound::Outlives(lifetime) => walk_lifetime(vis, lifetime),
GenericBound::Use(args, span) => {
for arg in args {
vis.visit_precise_capturing_arg(arg);
@@ -905,7 +899,7 @@ fn noop_visit_param_bound<T: MutVisitor>(pb: &mut GenericBound, vis: &mut T) {
}
}
-fn noop_visit_precise_capturing_arg<T: MutVisitor>(arg: &mut PreciseCapturingArg, vis: &mut T) {
+fn walk_precise_capturing_arg<T: MutVisitor>(vis: &mut T, arg: &mut PreciseCapturingArg) {
match arg {
PreciseCapturingArg::Lifetime(lt) => {
vis.visit_lifetime(lt);
@@ -917,15 +911,12 @@ fn noop_visit_precise_capturing_arg<T: MutVisitor>(arg: &mut PreciseCapturingArg
}
}
-pub fn noop_flat_map_generic_param<T: MutVisitor>(
- mut param: GenericParam,
- vis: &mut T,
-) -> SmallVec<[GenericParam; 1]> {
- let GenericParam { id, ident, attrs, bounds, kind, colon_span, is_placeholder: _ } = &mut param;
+pub fn walk_generic_param<T: MutVisitor>(vis: &mut T, param: &mut GenericParam) {
+ let GenericParam { id, ident, attrs, bounds, kind, colon_span, is_placeholder: _ } = param;
vis.visit_id(id);
- visit_attrs(attrs, vis);
+ visit_attrs(vis, attrs);
vis.visit_ident(ident);
- visit_vec(bounds, |bound| noop_visit_param_bound(bound, vis));
+ visit_vec(bounds, |bound| vis.visit_param_bound(bound, BoundKind::Bound));
match kind {
GenericParamKind::Lifetime => {}
GenericParamKind::Type { default } => {
@@ -939,26 +930,33 @@ pub fn noop_flat_map_generic_param<T: MutVisitor>(
if let Some(colon_span) = colon_span {
vis.visit_span(colon_span);
}
+}
+
+pub fn walk_flat_map_generic_param<T: MutVisitor>(
+ vis: &mut T,
+ mut param: GenericParam,
+) -> SmallVec<[GenericParam; 1]> {
+ vis.visit_generic_param(&mut param);
smallvec![param]
}
-fn noop_visit_label<T: MutVisitor>(Label { ident }: &mut Label, vis: &mut T) {
+fn walk_label<T: MutVisitor>(vis: &mut T, Label { ident }: &mut Label) {
vis.visit_ident(ident);
}
-fn noop_visit_lifetime<T: MutVisitor>(Lifetime { id, ident }: &mut Lifetime, vis: &mut T) {
+fn walk_lifetime<T: MutVisitor>(vis: &mut T, Lifetime { id, ident }: &mut Lifetime) {
vis.visit_id(id);
vis.visit_ident(ident);
}
-fn noop_visit_generics<T: MutVisitor>(generics: &mut Generics, vis: &mut T) {
+fn walk_generics<T: MutVisitor>(vis: &mut T, generics: &mut Generics) {
let Generics { params, where_clause, span } = generics;
params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
vis.visit_where_clause(where_clause);
vis.visit_span(span);
}
-fn noop_visit_ty_alias_where_clauses<T: MutVisitor>(tawcs: &mut TyAliasWhereClauses, vis: &mut T) {
+fn walk_ty_alias_where_clauses<T: MutVisitor>(vis: &mut T, tawcs: &mut TyAliasWhereClauses) {
let TyAliasWhereClauses { before, after, split: _ } = tawcs;
let TyAliasWhereClause { has_where_token: _, span: span_before } = before;
let TyAliasWhereClause { has_where_token: _, span: span_after } = after;
@@ -966,37 +964,46 @@ fn noop_visit_ty_alias_where_clauses<T: MutVisitor>(tawcs: &mut TyAliasWhereClau
vis.visit_span(span_after);
}
-fn noop_visit_where_clause<T: MutVisitor>(wc: &mut WhereClause, vis: &mut T) {
+fn walk_where_clause<T: MutVisitor>(vis: &mut T, wc: &mut WhereClause) {
let WhereClause { has_where_token: _, predicates, span } = wc;
- visit_thin_vec(predicates, |predicate| vis.visit_where_predicate(predicate));
+ predicates.flat_map_in_place(|predicate| vis.flat_map_where_predicate(predicate));
+ vis.visit_span(span);
+}
+
+pub fn walk_flat_map_where_predicate<T: MutVisitor>(
+ vis: &mut T,
+ mut pred: WherePredicate,
+) -> SmallVec<[WherePredicate; 1]> {
+ let WherePredicate { attrs, kind, id, span, is_placeholder: _ } = &mut pred;
+ vis.visit_id(id);
+ visit_attrs(vis, attrs);
+ vis.visit_where_predicate_kind(kind);
vis.visit_span(span);
+ smallvec![pred]
}
-fn noop_visit_where_predicate<T: MutVisitor>(pred: &mut WherePredicate, vis: &mut T) {
- match pred {
- WherePredicate::BoundPredicate(bp) => {
- let WhereBoundPredicate { span, bound_generic_params, bounded_ty, bounds } = bp;
+pub fn walk_where_predicate_kind<T: MutVisitor>(vis: &mut T, kind: &mut WherePredicateKind) {
+ match kind {
+ WherePredicateKind::BoundPredicate(bp) => {
+ let WhereBoundPredicate { bound_generic_params, bounded_ty, bounds } = bp;
bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
vis.visit_ty(bounded_ty);
- visit_vec(bounds, |bound| vis.visit_param_bound(bound));
- vis.visit_span(span);
+ visit_vec(bounds, |bound| vis.visit_param_bound(bound, BoundKind::Bound));
}
- WherePredicate::RegionPredicate(rp) => {
- let WhereRegionPredicate { span, lifetime, bounds } = rp;
- noop_visit_lifetime(lifetime, vis);
- visit_vec(bounds, |bound| noop_visit_param_bound(bound, vis));
- vis.visit_span(span);
+ WherePredicateKind::RegionPredicate(rp) => {
+ let WhereRegionPredicate { lifetime, bounds } = rp;
+ vis.visit_lifetime(lifetime);
+ visit_vec(bounds, |bound| vis.visit_param_bound(bound, BoundKind::Bound));
}
- WherePredicate::EqPredicate(ep) => {
- let WhereEqPredicate { span, lhs_ty, rhs_ty } = ep;
+ WherePredicateKind::EqPredicate(ep) => {
+ let WhereEqPredicate { lhs_ty, rhs_ty } = ep;
vis.visit_ty(lhs_ty);
vis.visit_ty(rhs_ty);
- vis.visit_span(span);
}
}
}
-fn noop_visit_variant_data<T: MutVisitor>(vdata: &mut VariantData, vis: &mut T) {
+fn walk_variant_data<T: MutVisitor>(vis: &mut T, vdata: &mut VariantData) {
match vdata {
VariantData::Struct { fields, recovered: _ } => {
fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
@@ -1009,83 +1016,136 @@ fn noop_visit_variant_data<T: MutVisitor>(vdata: &mut VariantData, vis: &mut T)
}
}
-fn noop_visit_trait_ref<T: MutVisitor>(TraitRef { path, ref_id }: &mut TraitRef, vis: &mut T) {
+fn walk_trait_ref<T: MutVisitor>(vis: &mut T, TraitRef { path, ref_id }: &mut TraitRef) {
vis.visit_id(ref_id);
vis.visit_path(path);
}
-fn noop_visit_poly_trait_ref<T: MutVisitor>(p: &mut PolyTraitRef, vis: &mut T) {
- let PolyTraitRef { bound_generic_params, trait_ref, span } = p;
+fn walk_poly_trait_ref<T: MutVisitor>(vis: &mut T, p: &mut PolyTraitRef) {
+ let PolyTraitRef { bound_generic_params, modifiers, trait_ref, span } = p;
+ vis.visit_modifiers(modifiers);
bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
vis.visit_trait_ref(trait_ref);
vis.visit_span(span);
}
-pub fn noop_flat_map_field_def<T: MutVisitor>(
- mut fd: FieldDef,
- visitor: &mut T,
-) -> SmallVec<[FieldDef; 1]> {
- let FieldDef { span, ident, vis, id, ty, attrs, is_placeholder: _ } = &mut fd;
+fn walk_modifiers<V: MutVisitor>(vis: &mut V, m: &mut TraitBoundModifiers) {
+ let TraitBoundModifiers { constness, asyncness, polarity } = m;
+ match constness {
+ BoundConstness::Never => {}
+ BoundConstness::Always(span) | BoundConstness::Maybe(span) => vis.visit_span(span),
+ }
+ match asyncness {
+ BoundAsyncness::Normal => {}
+ BoundAsyncness::Async(span) => vis.visit_span(span),
+ }
+ match polarity {
+ BoundPolarity::Positive => {}
+ BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => vis.visit_span(span),
+ }
+}
+
+pub fn walk_field_def<T: MutVisitor>(visitor: &mut T, fd: &mut FieldDef) {
+ let FieldDef { span, ident, vis, id, ty, attrs, is_placeholder: _, safety, default } = fd;
visitor.visit_id(id);
- visit_attrs(attrs, visitor);
+ visit_attrs(visitor, attrs);
visitor.visit_vis(vis);
+ visit_safety(visitor, safety);
visit_opt(ident, |ident| visitor.visit_ident(ident));
visitor.visit_ty(ty);
+ visit_opt(default, |default| visitor.visit_anon_const(default));
visitor.visit_span(span);
- smallvec![fd]
}
-pub fn noop_flat_map_expr_field<T: MutVisitor>(
- mut f: ExprField,
+pub fn walk_flat_map_field_def<T: MutVisitor>(
vis: &mut T,
-) -> SmallVec<[ExprField; 1]> {
- let ExprField { ident, expr, span, is_shorthand: _, attrs, id, is_placeholder: _ } = &mut f;
+ mut fd: FieldDef,
+) -> SmallVec<[FieldDef; 1]> {
+ vis.visit_field_def(&mut fd);
+ smallvec![fd]
+}
+
+pub fn walk_expr_field<T: MutVisitor>(vis: &mut T, f: &mut ExprField) {
+ let ExprField { ident, expr, span, is_shorthand: _, attrs, id, is_placeholder: _ } = f;
vis.visit_id(id);
- visit_attrs(attrs, vis);
+ visit_attrs(vis, attrs);
vis.visit_ident(ident);
vis.visit_expr(expr);
vis.visit_span(span);
+}
+
+pub fn walk_flat_map_expr_field<T: MutVisitor>(
+ vis: &mut T,
+ mut f: ExprField,
+) -> SmallVec<[ExprField; 1]> {
+ vis.visit_expr_field(&mut f);
smallvec![f]
}
-fn noop_visit_mt<T: MutVisitor>(MutTy { ty, mutbl: _ }: &mut MutTy, vis: &mut T) {
+fn walk_mt<T: MutVisitor>(vis: &mut T, MutTy { ty, mutbl: _ }: &mut MutTy) {
vis.visit_ty(ty);
}
-pub fn noop_visit_block<T: MutVisitor>(block: &mut P<Block>, vis: &mut T) {
- let Block { id, stmts, rules: _, span, tokens, could_be_bare_literal: _ } = block.deref_mut();
+pub fn walk_block<T: MutVisitor>(vis: &mut T, block: &mut P<Block>) {
+ let Block { id, stmts, rules: _, span, tokens: _ } = block.deref_mut();
vis.visit_id(id);
stmts.flat_map_in_place(|stmt| vis.flat_map_stmt(stmt));
- visit_lazy_tts(tokens, vis);
vis.visit_span(span);
}
-pub fn noop_visit_item_kind(kind: &mut impl NoopVisitItemKind, vis: &mut impl MutVisitor) {
- kind.noop_visit(vis)
-}
-
-impl NoopVisitItemKind for ItemKind {
- fn noop_visit(&mut self, vis: &mut impl MutVisitor) {
+pub fn walk_item_kind<K: WalkItemKind>(
+ kind: &mut K,
+ span: Span,
+ id: NodeId,
+ visibility: &mut Visibility,
+ ctxt: K::Ctxt,
+ vis: &mut impl MutVisitor,
+) {
+ kind.walk(span, id, visibility, ctxt, vis)
+}
+
+impl WalkItemKind for ItemKind {
+ type Ctxt = ();
+ fn walk(
+ &mut self,
+ span: Span,
+ id: NodeId,
+ visibility: &mut Visibility,
+ _ctxt: Self::Ctxt,
+ vis: &mut impl MutVisitor,
+ ) {
match self {
- ItemKind::ExternCrate(_orig_name) => {}
+ ItemKind::ExternCrate(_orig_name, ident) => vis.visit_ident(ident),
ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree),
- ItemKind::Static(box StaticItem { ty, safety: _, mutability: _, expr }) => {
+ ItemKind::Static(box StaticItem {
+ ident,
+ ty,
+ safety: _,
+ mutability: _,
+ expr,
+ define_opaque,
+ }) => {
+ vis.visit_ident(ident);
vis.visit_ty(ty);
visit_opt(expr, |expr| vis.visit_expr(expr));
+ walk_define_opaques(vis, define_opaque);
}
ItemKind::Const(item) => {
- visit_const_item(item, vis);
+ walk_const_item(vis, item);
}
- ItemKind::Fn(box Fn { defaultness, generics, sig, body }) => {
- visit_defaultness(defaultness, vis);
- vis.visit_generics(generics);
- visit_fn_sig(sig, vis);
- visit_opt(body, |body| vis.visit_block(body));
+ ItemKind::Fn(func) => {
+ vis.visit_fn(FnKind::Fn(FnCtxt::Free, visibility, &mut *func), span, id);
}
- ItemKind::Mod(safety, mod_kind) => {
- visit_safety(safety, vis);
+ ItemKind::Mod(safety, ident, mod_kind) => {
+ visit_safety(vis, safety);
+ vis.visit_ident(ident);
match mod_kind {
- ModKind::Loaded(items, _inline, ModSpans { inner_span, inject_use_span }) => {
+ ModKind::Loaded(
+ items,
+ _inline,
+ ModSpans { inner_span, inject_use_span },
+ _,
+ ) => {
items.flat_map_in_place(|item| vis.flat_map_item(item));
vis.visit_span(inner_span);
vis.visit_span(inject_use_span);
@@ -1095,18 +1155,29 @@ impl NoopVisitItemKind for ItemKind {
}
ItemKind::ForeignMod(nm) => vis.visit_foreign_mod(nm),
ItemKind::GlobalAsm(asm) => vis.visit_inline_asm(asm),
- ItemKind::TyAlias(box TyAlias { defaultness, generics, where_clauses, bounds, ty }) => {
- visit_defaultness(defaultness, vis);
+ ItemKind::TyAlias(box TyAlias {
+ defaultness,
+ ident,
+ generics,
+ where_clauses,
+ bounds,
+ ty,
+ }) => {
+ visit_defaultness(vis, defaultness);
+ vis.visit_ident(ident);
vis.visit_generics(generics);
- visit_bounds(bounds, vis);
+ visit_bounds(vis, bounds, BoundKind::Bound);
visit_opt(ty, |ty| vis.visit_ty(ty));
- noop_visit_ty_alias_where_clauses(where_clauses, vis);
+ walk_ty_alias_where_clauses(vis, where_clauses);
}
- ItemKind::Enum(EnumDef { variants }, generics) => {
+ ItemKind::Enum(ident, EnumDef { variants }, generics) => {
+ vis.visit_ident(ident);
vis.visit_generics(generics);
variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
}
- ItemKind::Struct(variant_data, generics) | ItemKind::Union(variant_data, generics) => {
+ ItemKind::Struct(ident, variant_data, generics)
+ | ItemKind::Union(ident, variant_data, generics) => {
+ vis.visit_ident(ident);
vis.visit_generics(generics);
vis.visit_variant_data(variant_data);
}
@@ -1120,31 +1191,39 @@ impl NoopVisitItemKind for ItemKind {
self_ty,
items,
}) => {
- visit_defaultness(defaultness, vis);
- visit_safety(safety, vis);
+ visit_defaultness(vis, defaultness);
+ visit_safety(vis, safety);
vis.visit_generics(generics);
- visit_constness(constness, vis);
- visit_polarity(polarity, vis);
+ visit_constness(vis, constness);
+ visit_polarity(vis, polarity);
visit_opt(of_trait, |trait_ref| vis.visit_trait_ref(trait_ref));
vis.visit_ty(self_ty);
- items.flat_map_in_place(|item| vis.flat_map_impl_item(item));
+ items.flat_map_in_place(|item| {
+ vis.flat_map_assoc_item(item, AssocCtxt::Impl { of_trait: of_trait.is_some() })
+ });
}
- ItemKind::Trait(box Trait { safety, is_auto: _, generics, bounds, items }) => {
- visit_safety(safety, vis);
+ ItemKind::Trait(box Trait { safety, is_auto: _, ident, generics, bounds, items }) => {
+ visit_safety(vis, safety);
+ vis.visit_ident(ident);
vis.visit_generics(generics);
- visit_bounds(bounds, vis);
- items.flat_map_in_place(|item| vis.flat_map_trait_item(item));
+ visit_bounds(vis, bounds, BoundKind::Bound);
+ items.flat_map_in_place(|item| vis.flat_map_assoc_item(item, AssocCtxt::Trait));
}
- ItemKind::TraitAlias(generics, bounds) => {
+ ItemKind::TraitAlias(ident, generics, bounds) => {
+ vis.visit_ident(ident);
vis.visit_generics(generics);
- visit_bounds(bounds, vis);
+ visit_bounds(vis, bounds, BoundKind::Bound);
}
ItemKind::MacCall(m) => vis.visit_mac_call(m),
- ItemKind::MacroDef(def) => vis.visit_macro_def(def),
+ ItemKind::MacroDef(ident, def) => {
+ vis.visit_ident(ident);
+ vis.visit_macro_def(def)
+ }
ItemKind::Delegation(box Delegation {
id,
qself,
path,
+ ident,
rename,
body,
from_glob: _,
@@ -1152,6 +1231,7 @@ impl NoopVisitItemKind for ItemKind {
vis.visit_id(id);
vis.visit_qself(qself);
vis.visit_path(path);
+ vis.visit_ident(ident);
if let Some(rename) = rename {
vis.visit_ident(rename);
}
@@ -1178,36 +1258,44 @@ impl NoopVisitItemKind for ItemKind {
}
}
-impl NoopVisitItemKind for AssocItemKind {
- fn noop_visit(&mut self, visitor: &mut impl MutVisitor) {
+impl WalkItemKind for AssocItemKind {
+ type Ctxt = AssocCtxt;
+ fn walk(
+ &mut self,
+ span: Span,
+ id: NodeId,
+ visibility: &mut Visibility,
+ ctxt: Self::Ctxt,
+ visitor: &mut impl MutVisitor,
+ ) {
match self {
AssocItemKind::Const(item) => {
- visit_const_item(item, visitor);
+ walk_const_item(visitor, item);
}
- AssocItemKind::Fn(box Fn { defaultness, generics, sig, body }) => {
- visit_defaultness(defaultness, visitor);
- visitor.visit_generics(generics);
- visit_fn_sig(sig, visitor);
- visit_opt(body, |body| visitor.visit_block(body));
+ AssocItemKind::Fn(func) => {
+ visitor.visit_fn(FnKind::Fn(FnCtxt::Assoc(ctxt), visibility, &mut *func), span, id);
}
AssocItemKind::Type(box TyAlias {
defaultness,
+ ident,
generics,
where_clauses,
bounds,
ty,
}) => {
- visit_defaultness(defaultness, visitor);
+ visit_defaultness(visitor, defaultness);
+ visitor.visit_ident(ident);
visitor.visit_generics(generics);
- visit_bounds(bounds, visitor);
+ visit_bounds(visitor, bounds, BoundKind::Bound);
visit_opt(ty, |ty| visitor.visit_ty(ty));
- noop_visit_ty_alias_where_clauses(where_clauses, visitor);
+ walk_ty_alias_where_clauses(visitor, where_clauses);
}
AssocItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
AssocItemKind::Delegation(box Delegation {
id,
qself,
path,
+ ident,
rename,
body,
from_glob: _,
@@ -1215,6 +1303,7 @@ impl NoopVisitItemKind for AssocItemKind {
visitor.visit_id(id);
visitor.visit_qself(qself);
visitor.visit_path(path);
+ visitor.visit_ident(ident);
if let Some(rename) = rename {
visitor.visit_ident(rename);
}
@@ -1241,91 +1330,134 @@ impl NoopVisitItemKind for AssocItemKind {
}
}
-fn visit_const_item<T: MutVisitor>(
- ConstItem { defaultness, generics, ty, expr }: &mut ConstItem,
- visitor: &mut T,
-) {
- visit_defaultness(defaultness, visitor);
- visitor.visit_generics(generics);
- visitor.visit_ty(ty);
- visit_opt(expr, |expr| visitor.visit_expr(expr));
+fn walk_const_item<T: MutVisitor>(vis: &mut T, item: &mut ConstItem) {
+ let ConstItem { defaultness, ident, generics, ty, expr, define_opaque } = item;
+ visit_defaultness(vis, defaultness);
+ vis.visit_ident(ident);
+ vis.visit_generics(generics);
+ vis.visit_ty(ty);
+ visit_opt(expr, |expr| vis.visit_expr(expr));
+ walk_define_opaques(vis, define_opaque);
}
-fn noop_visit_fn_header<T: MutVisitor>(header: &mut FnHeader, vis: &mut T) {
+fn walk_fn_header<T: MutVisitor>(vis: &mut T, header: &mut FnHeader) {
let FnHeader { safety, coroutine_kind, constness, ext: _ } = header;
- visit_constness(constness, vis);
+ visit_constness(vis, constness);
coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind));
- visit_safety(safety, vis);
+ visit_safety(vis, safety);
}
-pub fn noop_visit_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) {
+pub fn walk_crate<T: MutVisitor>(vis: &mut T, krate: &mut Crate) {
let Crate { attrs, items, spans, id, is_placeholder: _ } = krate;
vis.visit_id(id);
- visit_attrs(attrs, vis);
+ visit_attrs(vis, attrs);
items.flat_map_in_place(|item| vis.flat_map_item(item));
let ModSpans { inner_span, inject_use_span } = spans;
vis.visit_span(inner_span);
vis.visit_span(inject_use_span);
}
-// Mutates one item into possibly many items.
-pub fn noop_flat_map_item<K: NoopVisitItemKind>(
- mut item: P<Item<K>>,
+pub fn walk_item(visitor: &mut impl MutVisitor, item: &mut P<Item<impl WalkItemKind<Ctxt = ()>>>) {
+ walk_item_ctxt(visitor, item, ())
+}
+
+pub fn walk_assoc_item(visitor: &mut impl MutVisitor, item: &mut P<AssocItem>, ctxt: AssocCtxt) {
+ walk_item_ctxt(visitor, item, ctxt)
+}
+
+fn walk_item_ctxt<K: WalkItemKind>(
visitor: &mut impl MutVisitor,
-) -> SmallVec<[P<Item<K>>; 1]> {
- let Item { ident, attrs, id, kind, vis, span, tokens } = item.deref_mut();
+ item: &mut P<Item<K>>,
+ ctxt: K::Ctxt,
+) {
+ let Item { attrs, id, kind, vis, span, tokens: _ } = item.deref_mut();
visitor.visit_id(id);
- visit_attrs(attrs, visitor);
+ visit_attrs(visitor, attrs);
visitor.visit_vis(vis);
- visitor.visit_ident(ident);
- kind.noop_visit(visitor);
- visit_lazy_tts(tokens, visitor);
+ kind.walk(*span, *id, vis, ctxt, visitor);
visitor.visit_span(span);
+}
+
+pub fn walk_flat_map_item(vis: &mut impl MutVisitor, mut item: P<Item>) -> SmallVec<[P<Item>; 1]> {
+ vis.visit_item(&mut item);
smallvec![item]
}
-impl NoopVisitItemKind for ForeignItemKind {
- fn noop_visit(&mut self, visitor: &mut impl MutVisitor) {
+pub fn walk_flat_map_foreign_item(
+ vis: &mut impl MutVisitor,
+ mut item: P<ForeignItem>,
+) -> SmallVec<[P<ForeignItem>; 1]> {
+ vis.visit_foreign_item(&mut item);
+ smallvec![item]
+}
+
+pub fn walk_flat_map_assoc_item(
+ vis: &mut impl MutVisitor,
+ mut item: P<AssocItem>,
+ ctxt: AssocCtxt,
+) -> SmallVec<[P<AssocItem>; 1]> {
+ vis.visit_assoc_item(&mut item, ctxt);
+ smallvec![item]
+}
+
+impl WalkItemKind for ForeignItemKind {
+ type Ctxt = ();
+ fn walk(
+ &mut self,
+ span: Span,
+ id: NodeId,
+ visibility: &mut Visibility,
+ _ctxt: Self::Ctxt,
+ visitor: &mut impl MutVisitor,
+ ) {
match self {
- ForeignItemKind::Static(box StaticItem { ty, mutability: _, expr, safety: _ }) => {
+ ForeignItemKind::Static(box StaticItem {
+ ident,
+ ty,
+ mutability: _,
+ expr,
+ safety: _,
+ define_opaque,
+ }) => {
+ visitor.visit_ident(ident);
visitor.visit_ty(ty);
visit_opt(expr, |expr| visitor.visit_expr(expr));
+ walk_define_opaques(visitor, define_opaque);
}
- ForeignItemKind::Fn(box Fn { defaultness, generics, sig, body }) => {
- visit_defaultness(defaultness, visitor);
- visitor.visit_generics(generics);
- visit_fn_sig(sig, visitor);
- visit_opt(body, |body| visitor.visit_block(body));
+ ForeignItemKind::Fn(func) => {
+ visitor.visit_fn(FnKind::Fn(FnCtxt::Foreign, visibility, &mut *func), span, id);
}
ForeignItemKind::TyAlias(box TyAlias {
defaultness,
+ ident,
generics,
where_clauses,
bounds,
ty,
}) => {
- visit_defaultness(defaultness, visitor);
+ visit_defaultness(visitor, defaultness);
+ visitor.visit_ident(ident);
visitor.visit_generics(generics);
- visit_bounds(bounds, visitor);
+ visit_bounds(visitor, bounds, BoundKind::Bound);
visit_opt(ty, |ty| visitor.visit_ty(ty));
- noop_visit_ty_alias_where_clauses(where_clauses, visitor);
+ walk_ty_alias_where_clauses(visitor, where_clauses);
}
ForeignItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
}
}
}
-pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
- let Pat { id, kind, span, tokens } = pat.deref_mut();
+pub fn walk_pat<T: MutVisitor>(vis: &mut T, pat: &mut P<Pat>) {
+ let Pat { id, kind, span, tokens: _ } = pat.deref_mut();
vis.visit_id(id);
match kind {
PatKind::Err(_guar) => {}
- PatKind::Wild | PatKind::Rest | PatKind::Never => {}
+ PatKind::Missing | PatKind::Wild | PatKind::Rest | PatKind::Never => {}
PatKind::Ident(_binding_mode, ident, sub) => {
vis.visit_ident(ident);
visit_opt(sub, |sub| vis.visit_pat(sub));
}
- PatKind::Lit(e) => vis.visit_expr(e),
+ PatKind::Expr(e) => vis.visit_expr(e),
PatKind::TupleStruct(qself, path, elems) => {
vis.visit_qself(qself);
vis.visit_path(path);
@@ -1348,24 +1480,28 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
visit_opt(e2, |e| vis.visit_expr(e));
vis.visit_span(span);
}
+ PatKind::Guard(p, e) => {
+ vis.visit_pat(p);
+ vis.visit_expr(e);
+ }
PatKind::Tuple(elems) | PatKind::Slice(elems) | PatKind::Or(elems) => {
visit_thin_vec(elems, |elem| vis.visit_pat(elem))
}
PatKind::Paren(inner) => vis.visit_pat(inner),
PatKind::MacCall(mac) => vis.visit_mac_call(mac),
}
- visit_lazy_tts(tokens, vis);
vis.visit_span(span);
}
-fn noop_visit_anon_const<T: MutVisitor>(AnonConst { id, value }: &mut AnonConst, vis: &mut T) {
+fn walk_anon_const<T: MutVisitor>(vis: &mut T, AnonConst { id, value }: &mut AnonConst) {
vis.visit_id(id);
vis.visit_expr(value);
}
-fn noop_visit_inline_asm<T: MutVisitor>(asm: &mut InlineAsm, vis: &mut T) {
+fn walk_inline_asm<T: MutVisitor>(vis: &mut T, asm: &mut InlineAsm) {
// FIXME: Visit spans inside all this currently ignored stuff.
let InlineAsm {
+ asm_macro: _,
template: _,
template_strs: _,
operands,
@@ -1393,18 +1529,18 @@ fn noop_visit_inline_asm<T: MutVisitor>(asm: &mut InlineAsm, vis: &mut T) {
}
}
-fn noop_visit_inline_asm_sym<T: MutVisitor>(
- InlineAsmSym { id, qself, path }: &mut InlineAsmSym,
+fn walk_inline_asm_sym<T: MutVisitor>(
vis: &mut T,
+ InlineAsmSym { id, qself, path }: &mut InlineAsmSym,
) {
vis.visit_id(id);
vis.visit_qself(qself);
vis.visit_path(path);
}
-fn noop_visit_format_args<T: MutVisitor>(fmt: &mut FormatArgs, vis: &mut T) {
+fn walk_format_args<T: MutVisitor>(vis: &mut T, fmt: &mut FormatArgs) {
// FIXME: visit the template exhaustively.
- let FormatArgs { span, template: _, arguments } = fmt;
+ let FormatArgs { span, template: _, arguments, uncooked_fmt_str: _ } = fmt;
for FormatArgument { kind, expr } in arguments.all_args_mut() {
match kind {
FormatArgumentKind::Named(ident) | FormatArgumentKind::Captured(ident) => {
@@ -1417,14 +1553,11 @@ fn noop_visit_format_args<T: MutVisitor>(fmt: &mut FormatArgs, vis: &mut T) {
vis.visit_span(span);
}
-pub fn noop_visit_expr<T: MutVisitor>(
- Expr { kind, id, span, attrs, tokens }: &mut Expr,
- vis: &mut T,
-) {
+pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, tokens: _ }: &mut Expr) {
vis.visit_id(id);
- visit_attrs(attrs, vis);
+ visit_attrs(vis, attrs);
match kind {
- ExprKind::Array(exprs) => visit_thin_exprs(exprs, vis),
+ ExprKind::Array(exprs) => visit_thin_exprs(vis, exprs),
ExprKind::ConstBlock(anon_const) => {
vis.visit_anon_const(anon_const);
}
@@ -1432,10 +1565,10 @@ pub fn noop_visit_expr<T: MutVisitor>(
vis.visit_expr(expr);
vis.visit_anon_const(count);
}
- ExprKind::Tup(exprs) => visit_thin_exprs(exprs, vis),
+ ExprKind::Tup(exprs) => visit_thin_exprs(vis, exprs),
ExprKind::Call(f, args) => {
vis.visit_expr(f);
- visit_thin_exprs(args, vis);
+ visit_thin_exprs(vis, args);
}
ExprKind::MethodCall(box MethodCall {
seg: PathSegment { ident, id, args: seg_args },
@@ -1447,12 +1580,13 @@ pub fn noop_visit_expr<T: MutVisitor>(
vis.visit_id(id);
vis.visit_ident(ident);
visit_opt(seg_args, |args| vis.visit_generic_args(args));
- visit_thin_exprs(call_args, vis);
+ visit_thin_exprs(vis, call_args);
vis.visit_span(span);
}
- ExprKind::Binary(_binop, lhs, rhs) => {
+ ExprKind::Binary(binop, lhs, rhs) => {
vis.visit_expr(lhs);
vis.visit_expr(rhs);
+ vis.visit_span(&mut binop.span);
}
ExprKind::Unary(_unop, ohs) => vis.visit_expr(ohs),
ExprKind::Cast(expr, ty) => {
@@ -1505,12 +1639,9 @@ pub fn noop_visit_expr<T: MutVisitor>(
fn_decl_span,
fn_arg_span,
}) => {
- vis.visit_closure_binder(binder);
- visit_constness(constness, vis);
- coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind));
+ visit_constness(vis, constness);
vis.visit_capture_by(capture_clause);
- vis.visit_fn_decl(fn_decl);
- vis.visit_expr(body);
+ vis.visit_fn(FnKind::Closure(binder, coroutine_kind, fn_decl, body), *span, *id);
vis.visit_span(fn_decl_span);
vis.visit_span(fn_arg_span);
}
@@ -1526,6 +1657,10 @@ pub fn noop_visit_expr<T: MutVisitor>(
vis.visit_expr(expr);
vis.visit_span(await_kw_span);
}
+ ExprKind::Use(expr, use_kw_span) => {
+ vis.visit_expr(expr);
+ vis.visit_span(use_kw_span);
+ }
ExprKind::Assign(el, er, span) => {
vis.visit_expr(el);
vis.visit_expr(er);
@@ -1590,47 +1725,56 @@ pub fn noop_visit_expr<T: MutVisitor>(
ExprKind::Paren(expr) => {
vis.visit_expr(expr);
}
- ExprKind::Yield(expr) => {
- visit_opt(expr, |expr| vis.visit_expr(expr));
+ ExprKind::Yield(kind) => {
+ let expr = kind.expr_mut();
+ if let Some(expr) = expr {
+ vis.visit_expr(expr);
+ }
}
ExprKind::Try(expr) => vis.visit_expr(expr),
ExprKind::TryBlock(body) => vis.visit_block(body),
ExprKind::Lit(_token) => {}
ExprKind::IncludedBytes(_bytes) => {}
+ ExprKind::UnsafeBinderCast(_kind, expr, ty) => {
+ vis.visit_expr(expr);
+ if let Some(ty) = ty {
+ vis.visit_ty(ty);
+ }
+ }
ExprKind::Err(_guar) => {}
ExprKind::Dummy => {}
}
- visit_lazy_tts(tokens, vis);
vis.visit_span(span);
}
-pub fn noop_filter_map_expr<T: MutVisitor>(mut e: P<Expr>, vis: &mut T) -> Option<P<Expr>> {
+pub fn noop_filter_map_expr<T: MutVisitor>(vis: &mut T, mut e: P<Expr>) -> Option<P<Expr>> {
Some({
vis.visit_expr(&mut e);
e
})
}
-pub fn noop_flat_map_stmt<T: MutVisitor>(
- Stmt { kind, mut span, mut id }: Stmt,
+pub fn walk_flat_map_stmt<T: MutVisitor>(
vis: &mut T,
+ Stmt { kind, span, mut id }: Stmt,
) -> SmallVec<[Stmt; 1]> {
vis.visit_id(&mut id);
- let stmts: SmallVec<_> = noop_flat_map_stmt_kind(kind, vis)
+ let mut stmts: SmallVec<[Stmt; 1]> = walk_flat_map_stmt_kind(vis, kind)
.into_iter()
.map(|kind| Stmt { id, kind, span })
.collect();
- if stmts.len() > 1 {
- panic!(
+ match &mut stmts[..] {
+ [] => {}
+ [stmt] => vis.visit_span(&mut stmt.span),
+ _ => panic!(
"cloning statement `NodeId`s is prohibited by default, \
the visitor should implement custom statement visiting"
- );
+ ),
}
- vis.visit_span(&mut span);
stmts
}
-fn noop_flat_map_stmt_kind<T: MutVisitor>(kind: StmtKind, vis: &mut T) -> SmallVec<[StmtKind; 1]> {
+fn walk_flat_map_stmt_kind<T: MutVisitor>(vis: &mut T, kind: StmtKind) -> SmallVec<[StmtKind; 1]> {
match kind {
StmtKind::Let(mut local) => smallvec![StmtKind::Let({
vis.visit_local(&mut local);
@@ -1641,17 +1785,16 @@ fn noop_flat_map_stmt_kind<T: MutVisitor>(kind: StmtKind, vis: &mut T) -> SmallV
StmtKind::Semi(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect(),
StmtKind::Empty => smallvec![StmtKind::Empty],
StmtKind::MacCall(mut mac) => {
- let MacCallStmt { mac: mac_, style: _, attrs, tokens } = mac.deref_mut();
- visit_attrs(attrs, vis);
+ let MacCallStmt { mac: mac_, style: _, attrs, tokens: _ } = mac.deref_mut();
+ visit_attrs(vis, attrs);
vis.visit_mac_call(mac_);
- visit_lazy_tts(tokens, vis);
smallvec![StmtKind::MacCall(mac)]
}
}
}
-fn noop_visit_vis<T: MutVisitor>(visibility: &mut Visibility, vis: &mut T) {
- let Visibility { kind, span, tokens } = visibility;
+fn walk_vis<T: MutVisitor>(vis: &mut T, visibility: &mut Visibility) {
+ let Visibility { kind, span, tokens: _ } = visibility;
match kind {
VisibilityKind::Public | VisibilityKind::Inherited => {}
VisibilityKind::Restricted { path, id, shorthand: _ } => {
@@ -1659,16 +1802,30 @@ fn noop_visit_vis<T: MutVisitor>(visibility: &mut Visibility, vis: &mut T) {
vis.visit_path(path);
}
}
- visit_lazy_tts(tokens, vis);
vis.visit_span(span);
}
-fn noop_visit_capture_by<T: MutVisitor>(capture_by: &mut CaptureBy, vis: &mut T) {
+fn walk_capture_by<T: MutVisitor>(vis: &mut T, capture_by: &mut CaptureBy) {
match capture_by {
CaptureBy::Ref => {}
CaptureBy::Value { move_kw } => {
vis.visit_span(move_kw);
}
+ CaptureBy::Use { use_kw } => {
+ vis.visit_span(use_kw);
+ }
+ }
+}
+
+fn walk_define_opaques<T: MutVisitor>(
+ vis: &mut T,
+ define_opaque: &mut Option<ThinVec<(NodeId, Path)>>,
+) {
+ if let Some(define_opaque) = define_opaque {
+ for (id, path) in define_opaque {
+ vis.visit_id(id);
+ vis.visit_path(path)
+ }
}
}
@@ -1703,8 +1860,7 @@ impl DummyAstNode for Item {
span: Default::default(),
tokens: Default::default(),
},
- ident: Ident::empty(),
- kind: ItemKind::ExternCrate(None),
+ kind: ItemKind::ExternCrate(None, Ident::dummy()),
tokens: Default::default(),
}
}
@@ -1767,3 +1923,17 @@ impl<N: DummyAstNode, T: DummyAstNode> DummyAstNode for crate::ast_traits::AstNo
crate::ast_traits::AstNodeWrapper::new(N::dummy(), T::dummy())
}
}
+
+#[derive(Debug)]
+pub enum FnKind<'a> {
+ /// E.g., `fn foo()`, `fn foo(&self)`, or `extern "Abi" fn foo()`.
+ Fn(FnCtxt, &'a mut Visibility, &'a mut Fn),
+
+ /// E.g., `|x, y| body`.
+ Closure(
+ &'a mut ClosureBinder,
+ &'a mut Option<CoroutineKind>,
+ &'a mut P<FnDecl>,
+ &'a mut P<Expr>,
+ ),
+}
diff --git a/compiler/rustc_ast/src/node_id.rs b/compiler/rustc_ast/src/node_id.rs
index 1cd2449530901..adca1844b61f8 100644
--- a/compiler/rustc_ast/src/node_id.rs
+++ b/compiler/rustc_ast/src/node_id.rs
@@ -1,6 +1,7 @@
-use rustc_span::LocalExpnId;
use std::fmt;
+use rustc_span::LocalExpnId;
+
rustc_index::newtype_index! {
/// Identifies an AST node.
///
diff --git a/compiler/rustc_ast/src/ptr.rs b/compiler/rustc_ast/src/ptr.rs
index 34c539ea16b48..dd923305cdfd9 100644
--- a/compiler/rustc_ast/src/ptr.rs
+++ b/compiler/rustc_ast/src/ptr.rs
@@ -21,9 +21,8 @@ use std::fmt::{self, Debug, Display};
use std::ops::{Deref, DerefMut};
use std::{slice, vec};
-use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
-
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
/// An owned smart pointer.
///
/// See the [module level documentation][crate::ptr] for details.
@@ -159,9 +158,9 @@ impl<T> From<Vec<T>> for P<[T]> {
}
}
-impl<T> Into<Vec<T>> for P<[T]> {
- fn into(self) -> Vec<T> {
- self.into_vec()
+impl<T> From<P<[T]>> for Vec<T> {
+ fn from(val: P<[T]>) -> Self {
+ val.into_vec()
}
}
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index efe1956615216..54781e8235e2f 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -1,24 +1,19 @@
-pub use BinOpToken::*;
+use std::borrow::Cow;
+use std::fmt;
+
pub use LitKind::*;
-pub use Nonterminal::*;
pub use NtExprKind::*;
pub use NtPatKind::*;
pub use TokenKind::*;
-
-use crate::ast;
-use crate::ptr::P;
-use crate::util::case::Case;
-
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_data_structures::sync::Lrc;
use rustc_macros::{Decodable, Encodable, HashStable_Generic};
-use rustc_span::symbol::{kw, sym};
+use rustc_span::edition::Edition;
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, kw, sym};
#[allow(clippy::useless_attribute)] // FIXME: following use of `hidden_glob_reexports` incorrectly triggers `useless_attribute` lint.
#[allow(hidden_glob_reexports)]
-use rustc_span::symbol::{Ident, Symbol};
-use rustc_span::{edition::Edition, ErrorGuaranteed, Span, DUMMY_SP};
-use std::borrow::Cow;
-use std::fmt;
+use rustc_span::{Ident, Symbol};
+
+use crate::ast;
+use crate::util::case::Case;
#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
pub enum CommentKind {
@@ -26,26 +21,99 @@ pub enum CommentKind {
Block,
}
-#[derive(Clone, PartialEq, Encodable, Decodable, Hash, Debug, Copy)]
-#[derive(HashStable_Generic)]
-pub enum BinOpToken {
- Plus,
- Minus,
- Star,
- Slash,
- Percent,
- Caret,
- And,
- Or,
- Shl,
- Shr,
+// This type must not implement `Hash` due to the unusual `PartialEq` impl below.
+#[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic)]
+pub enum InvisibleOrigin {
+ // From the expansion of a metavariable in a declarative macro.
+ MetaVar(MetaVarKind),
+
+ // Converted from `proc_macro::Delimiter` in
+ // `proc_macro::Delimiter::to_internal`, i.e. returned by a proc macro.
+ ProcMacro,
+}
+
+impl InvisibleOrigin {
+ // Should the parser skip these invisible delimiters? Ideally this function
+ // will eventually disappear and no invisible delimiters will be skipped.
+ #[inline]
+ pub fn skip(&self) -> bool {
+ match self {
+ InvisibleOrigin::MetaVar(_) => false,
+ InvisibleOrigin::ProcMacro => true,
+ }
+ }
+}
+
+impl PartialEq for InvisibleOrigin {
+ #[inline]
+ fn eq(&self, _other: &InvisibleOrigin) -> bool {
+ // When we had AST-based nonterminals we couldn't compare them, and the
+ // old `Nonterminal` type had an `eq` that always returned false,
+ // resulting in this restriction:
+ // https://doc.rust-lang.org/nightly/reference/macros-by-example.html#forwarding-a-matched-fragment
+ // This `eq` emulates that behaviour. We could consider lifting this
+ // restriction now but there are still cases involving invisible
+ // delimiters that make it harder than it first appears.
+ false
+ }
+}
+
+/// Annoyingly similar to `NonterminalKind`, but the slight differences are important.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, HashStable_Generic)]
+pub enum MetaVarKind {
+ Item,
+ Block,
+ Stmt,
+ Pat(NtPatKind),
+ Expr {
+ kind: NtExprKind,
+ // This field is needed for `Token::can_begin_literal_maybe_minus`.
+ can_begin_literal_maybe_minus: bool,
+ // This field is needed for `Token::can_begin_string_literal`.
+ can_begin_string_literal: bool,
+ },
+ Ty {
+ is_path: bool,
+ },
+ Ident,
+ Lifetime,
+ Literal,
+ Meta {
+ /// Will `AttrItem::meta` succeed on this, if reparsed?
+ has_meta_form: bool,
+ },
+ Path,
+ Vis,
+ TT,
+}
+
+impl fmt::Display for MetaVarKind {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let sym = match self {
+ MetaVarKind::Item => sym::item,
+ MetaVarKind::Block => sym::block,
+ MetaVarKind::Stmt => sym::stmt,
+ MetaVarKind::Pat(PatParam { inferred: true } | PatWithOr) => sym::pat,
+ MetaVarKind::Pat(PatParam { inferred: false }) => sym::pat_param,
+ MetaVarKind::Expr { kind: Expr2021 { inferred: true } | Expr, .. } => sym::expr,
+ MetaVarKind::Expr { kind: Expr2021 { inferred: false }, .. } => sym::expr_2021,
+ MetaVarKind::Ty { .. } => sym::ty,
+ MetaVarKind::Ident => sym::ident,
+ MetaVarKind::Lifetime => sym::lifetime,
+ MetaVarKind::Literal => sym::literal,
+ MetaVarKind::Meta { .. } => sym::meta,
+ MetaVarKind::Path => sym::path,
+ MetaVarKind::Vis => sym::vis,
+ MetaVarKind::TT => sym::tt,
+ };
+ write!(f, "{sym}")
+ }
}
/// Describes how a sequence of token trees is delimited.
/// Cannot use `proc_macro::Delimiter` directly because this
/// structure should implement some additional traits.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-#[derive(Encodable, Decodable, Hash, HashStable_Generic)]
+#[derive(Copy, Clone, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
pub enum Delimiter {
/// `( ... )`
Parenthesis,
@@ -58,7 +126,49 @@ pub enum Delimiter {
/// "macro variable" `$var`. It is important to preserve operator priorities in cases like
/// `$var * 3` where `$var` is `1 + 2`.
/// Invisible delimiters might not survive roundtrip of a token stream through a string.
- Invisible,
+ Invisible(InvisibleOrigin),
+}
+
+impl Delimiter {
+ // Should the parser skip these delimiters? Only happens for certain kinds
+ // of invisible delimiters. Ideally this function will eventually disappear
+ // and no invisible delimiters will be skipped.
+ #[inline]
+ pub fn skip(&self) -> bool {
+ match self {
+ Delimiter::Parenthesis | Delimiter::Bracket | Delimiter::Brace => false,
+ Delimiter::Invisible(origin) => origin.skip(),
+ }
+ }
+
+ // This exists because `InvisibleOrigin`s should be compared. It is only used for assertions.
+ pub fn eq_ignoring_invisible_origin(&self, other: &Delimiter) -> bool {
+ match (self, other) {
+ (Delimiter::Parenthesis, Delimiter::Parenthesis) => true,
+ (Delimiter::Brace, Delimiter::Brace) => true,
+ (Delimiter::Bracket, Delimiter::Bracket) => true,
+ (Delimiter::Invisible(_), Delimiter::Invisible(_)) => true,
+ _ => false,
+ }
+ }
+
+ pub fn as_open_token_kind(&self) -> TokenKind {
+ match *self {
+ Delimiter::Parenthesis => OpenParen,
+ Delimiter::Brace => OpenBrace,
+ Delimiter::Bracket => OpenBracket,
+ Delimiter::Invisible(origin) => OpenInvisible(origin),
+ }
+ }
+
+ pub fn as_close_token_kind(&self) -> TokenKind {
+ match *self {
+ Delimiter::Parenthesis => CloseParen,
+ Delimiter::Brace => CloseBrace,
+ Delimiter::Bracket => CloseBracket,
+ Delimiter::Invisible(origin) => CloseInvisible(origin),
+ }
+ }
}
// Note that the suffix is *not* considered when deciding the `LitKind` in this
@@ -107,16 +217,17 @@ impl Lit {
}
}
- /// Keep this in sync with `Token::can_begin_literal_maybe_minus` excluding unary negation.
+ /// Keep this in sync with `Token::can_begin_literal_maybe_minus` and
+ /// `Parser::eat_token_lit` (excluding unary negation).
pub fn from_token(token: &Token) -> Option<Lit> {
match token.uninterpolate().kind {
Ident(name, IdentIsRaw::No) if name.is_bool_lit() => Some(Lit::new(Bool, name, None)),
Literal(token_lit) => Some(token_lit),
- Interpolated(ref nt)
- if let NtExpr(expr) | NtLiteral(expr) = &**nt
- && let ast::ExprKind::Lit(token_lit) = expr.kind =>
- {
- Some(token_lit)
+ OpenInvisible(InvisibleOrigin::MetaVar(
+ MetaVarKind::Literal | MetaVarKind::Expr { .. },
+ )) => {
+ // Unreachable with the current test suite.
+ panic!("from_token metavar");
}
_ => None,
}
@@ -245,9 +356,7 @@ impl From<IdentIsRaw> for bool {
}
}
-// SAFETY: due to the `Clone` impl below, all fields of all variants other than
-// `Interpolated` must impl `Copy`.
-#[derive(PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
pub enum TokenKind {
/* Expression-operator symbols. */
/// `=`
@@ -269,11 +378,49 @@ pub enum TokenKind {
/// `||`
OrOr,
/// `!`
- Not,
+ Bang,
/// `~`
Tilde,
- BinOp(BinOpToken),
- BinOpEq(BinOpToken),
+ // `+`
+ Plus,
+ // `-`
+ Minus,
+ // `*`
+ Star,
+ // `/`
+ Slash,
+ // `%`
+ Percent,
+ // `^`
+ Caret,
+ // `&`
+ And,
+ // `|`
+ Or,
+ // `<<`
+ Shl,
+ // `>>`
+ Shr,
+ // `+=`
+ PlusEq,
+ // `-=`
+ MinusEq,
+ // `*=`
+ StarEq,
+ // `/=`
+ SlashEq,
+ // `%=`
+ PercentEq,
+ // `^=`
+ CaretEq,
+ // `&=`
+ AndEq,
+ // `|=`
+ OrEq,
+ // `<<=`
+ ShlEq,
+ // `>>=`
+ ShrEq,
/* Structural symbols */
/// `@`
@@ -308,18 +455,31 @@ pub enum TokenKind {
Question,
/// Used by proc macros for representing lifetimes, not generated by lexer right now.
SingleQuote,
- /// An opening delimiter (e.g., `{`).
- OpenDelim(Delimiter),
- /// A closing delimiter (e.g., `}`).
- CloseDelim(Delimiter),
+ /// `(`
+ OpenParen,
+ /// `)`
+ CloseParen,
+ /// `{`
+ OpenBrace,
+ /// `}`
+ CloseBrace,
+ /// `[`
+ OpenBracket,
+ /// `]`
+ CloseBracket,
+ /// Invisible opening delimiter, produced by a macro.
+ OpenInvisible(InvisibleOrigin),
+ /// Invisible closing delimiter, produced by a macro.
+ CloseInvisible(InvisibleOrigin),
/* Literals */
Literal(Lit),
/// Identifier token.
/// Do not forget about `NtIdent` when you want to match on identifiers.
- /// It's recommended to use `Token::(ident,uninterpolate,uninterpolated_span)` to
- /// treat regular and interpolated identifiers in the same way.
+ /// It's recommended to use `Token::{ident,uninterpolate}` and
+ /// `Parser::token_uninterpolated_span` to treat regular and interpolated
+ /// identifiers in the same way.
Ident(Symbol, IdentIsRaw),
/// This identifier (and its span) is the identifier passed to the
/// declarative macro. The span in the surrounding `Token` is the span of
@@ -328,28 +488,14 @@ pub enum TokenKind {
/// Lifetime identifier token.
/// Do not forget about `NtLifetime` when you want to match on lifetime identifiers.
- /// It's recommended to use `Token::(lifetime,uninterpolate,uninterpolated_span)` to
- /// treat regular and interpolated lifetime identifiers in the same way.
- Lifetime(Symbol),
+ /// It's recommended to use `Token::{ident,uninterpolate}` and
+ /// `Parser::token_uninterpolated_span` to treat regular and interpolated
+ /// identifiers in the same way.
+ Lifetime(Symbol, IdentIsRaw),
/// This identifier (and its span) is the lifetime passed to the
/// declarative macro. The span in the surrounding `Token` is the span of
/// the `lifetime` metavariable in the macro's RHS.
- NtLifetime(Ident),
-
- /// An embedded AST node, as produced by a macro. This only exists for
- /// historical reasons. We'd like to get rid of it, for multiple reasons.
- /// - It's conceptually very strange. Saying a token can contain an AST
- /// node is like saying, in natural language, that a word can contain a
- /// sentence.
- /// - It requires special handling in a bunch of places in the parser.
- /// - It prevents `Token` from implementing `Copy`.
- /// It adds complexity and likely slows things down. Please don't add new
- /// occurrences of this token kind!
- ///
- /// The span in the surrounding `Token` is that of the metavariable in the
- /// macro's RHS. The span within the Nonterminal is that of the fragment
- /// passed to the macro at the call site.
- Interpolated(Lrc<Nonterminal>),
+ NtLifetime(Ident, IdentIsRaw),
/// A doc comment token.
/// `Symbol` is the doc comment's data excluding its "quotes" (`///`, `/**`, etc)
@@ -360,20 +506,7 @@ pub enum TokenKind {
Eof,
}
-impl Clone for TokenKind {
- fn clone(&self) -> Self {
- // `TokenKind` would impl `Copy` if it weren't for `Interpolated`. So
- // for all other variants, this implementation of `clone` is just like
- // a copy. This is faster than the `derive(Clone)` version which has a
- // separate path for every variant.
- match self {
- Interpolated(nt) => Interpolated(nt.clone()),
- _ => unsafe { std::ptr::read(self) },
- }
- }
-}
-
-#[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
pub struct Token {
pub kind: TokenKind,
pub span: Span,
@@ -384,53 +517,90 @@ impl TokenKind {
Literal(Lit::new(kind, symbol, suffix))
}
- /// An approximation to proc-macro-style single-character operators used by rustc parser.
- /// If the operator token can be broken into two tokens, the first of which is single-character,
- /// then this function performs that operation, otherwise it returns `None`.
- pub fn break_two_token_op(&self) -> Option<(TokenKind, TokenKind)> {
- Some(match *self {
- Le => (Lt, Eq),
- EqEq => (Eq, Eq),
- Ne => (Not, Eq),
- Ge => (Gt, Eq),
- AndAnd => (BinOp(And), BinOp(And)),
- OrOr => (BinOp(Or), BinOp(Or)),
- BinOp(Shl) => (Lt, Lt),
- BinOp(Shr) => (Gt, Gt),
- BinOpEq(Plus) => (BinOp(Plus), Eq),
- BinOpEq(Minus) => (BinOp(Minus), Eq),
- BinOpEq(Star) => (BinOp(Star), Eq),
- BinOpEq(Slash) => (BinOp(Slash), Eq),
- BinOpEq(Percent) => (BinOp(Percent), Eq),
- BinOpEq(Caret) => (BinOp(Caret), Eq),
- BinOpEq(And) => (BinOp(And), Eq),
- BinOpEq(Or) => (BinOp(Or), Eq),
- BinOpEq(Shl) => (Lt, Le),
- BinOpEq(Shr) => (Gt, Ge),
- DotDot => (Dot, Dot),
- DotDotDot => (Dot, DotDot),
- PathSep => (Colon, Colon),
- RArrow => (BinOp(Minus), Gt),
- LArrow => (Lt, BinOp(Minus)),
- FatArrow => (Eq, Gt),
+ /// An approximation to proc-macro-style single-character operators used by
+ /// rustc parser. If the operator token can be broken into two tokens, the
+ /// first of which has `n` (1 or 2) chars, then this function performs that
+ /// operation, otherwise it returns `None`.
+ pub fn break_two_token_op(&self, n: u32) -> Option<(TokenKind, TokenKind)> {
+ assert!(n == 1 || n == 2);
+ Some(match (self, n) {
+ (Le, 1) => (Lt, Eq),
+ (EqEq, 1) => (Eq, Eq),
+ (Ne, 1) => (Bang, Eq),
+ (Ge, 1) => (Gt, Eq),
+ (AndAnd, 1) => (And, And),
+ (OrOr, 1) => (Or, Or),
+ (Shl, 1) => (Lt, Lt),
+ (Shr, 1) => (Gt, Gt),
+ (PlusEq, 1) => (Plus, Eq),
+ (MinusEq, 1) => (Minus, Eq),
+ (StarEq, 1) => (Star, Eq),
+ (SlashEq, 1) => (Slash, Eq),
+ (PercentEq, 1) => (Percent, Eq),
+ (CaretEq, 1) => (Caret, Eq),
+ (AndEq, 1) => (And, Eq),
+ (OrEq, 1) => (Or, Eq),
+ (ShlEq, 1) => (Lt, Le), // `<` + `<=`
+ (ShlEq, 2) => (Shl, Eq), // `<<` + `=`
+ (ShrEq, 1) => (Gt, Ge), // `>` + `>=`
+ (ShrEq, 2) => (Shr, Eq), // `>>` + `=`
+ (DotDot, 1) => (Dot, Dot),
+ (DotDotDot, 1) => (Dot, DotDot), // `.` + `..`
+ (DotDotDot, 2) => (DotDot, Dot), // `..` + `.`
+ (DotDotEq, 2) => (DotDot, Eq),
+ (PathSep, 1) => (Colon, Colon),
+ (RArrow, 1) => (Minus, Gt),
+ (LArrow, 1) => (Lt, Minus),
+ (FatArrow, 1) => (Eq, Gt),
_ => return None,
})
}
/// Returns tokens that are likely to be typed accidentally instead of the current token.
/// Enables better error recovery when the wrong token is found.
- pub fn similar_tokens(&self) -> Option<Vec<TokenKind>> {
+ pub fn similar_tokens(&self) -> &[TokenKind] {
+ match self {
+ Comma => &[Dot, Lt, Semi],
+ Semi => &[Colon, Comma],
+ Colon => &[Semi],
+ FatArrow => &[Eq, RArrow, Ge, Gt],
+ _ => &[],
+ }
+ }
+
+ pub fn should_end_const_arg(&self) -> bool {
+ matches!(self, Gt | Ge | Shr | ShrEq)
+ }
+
+ pub fn is_delim(&self) -> bool {
+ self.open_delim().is_some() || self.close_delim().is_some()
+ }
+
+ pub fn open_delim(&self) -> Option<Delimiter> {
match *self {
- Comma => Some(vec![Dot, Lt, Semi]),
- Semi => Some(vec![Colon, Comma]),
- Colon => Some(vec![Semi]),
- FatArrow => Some(vec![Eq, RArrow, Ge, Gt]),
+ OpenParen => Some(Delimiter::Parenthesis),
+ OpenBrace => Some(Delimiter::Brace),
+ OpenBracket => Some(Delimiter::Bracket),
+ OpenInvisible(origin) => Some(Delimiter::Invisible(origin)),
_ => None,
}
}
- pub fn should_end_const_arg(&self) -> bool {
- matches!(self, Gt | Ge | BinOp(Shr) | BinOpEq(Shr))
+ pub fn close_delim(&self) -> Option<Delimiter> {
+ match *self {
+ CloseParen => Some(Delimiter::Parenthesis),
+ CloseBrace => Some(Delimiter::Brace),
+ CloseBracket => Some(Delimiter::Bracket),
+ CloseInvisible(origin) => Some(Delimiter::Invisible(origin)),
+ _ => None,
+ }
+ }
+
+ pub fn is_close_delim_or_eof(&self) -> bool {
+ match self {
+ CloseParen | CloseBrace | CloseBracket | CloseInvisible(_) | Eof => true,
+ _ => false,
+ }
}
}
@@ -449,64 +619,58 @@ impl Token {
Token::new(Ident(ident.name, ident.is_raw_guess().into()), ident.span)
}
- /// For interpolated tokens, returns a span of the fragment to which the interpolated
- /// token refers. For all other tokens this is just a regular span.
- /// It is particularly important to use this for identifiers and lifetimes
- /// for which spans affect name resolution and edition checks.
- /// Note that keywords are also identifiers, so they should use this
- /// if they keep spans or perform edition checks.
- pub fn uninterpolated_span(&self) -> Span {
- match self.kind {
- NtIdent(ident, _) | NtLifetime(ident) => ident.span,
- Interpolated(ref nt) => nt.use_span(),
- _ => self.span,
- }
- }
-
pub fn is_range_separator(&self) -> bool {
[DotDot, DotDotDot, DotDotEq].contains(&self.kind)
}
pub fn is_punct(&self) -> bool {
match self.kind {
- Eq | Lt | Le | EqEq | Ne | Ge | Gt | AndAnd | OrOr | Not | Tilde | BinOp(_)
- | BinOpEq(_) | At | Dot | DotDot | DotDotDot | DotDotEq | Comma | Semi | Colon
- | PathSep | RArrow | LArrow | FatArrow | Pound | Dollar | Question | SingleQuote => {
- true
- }
-
- OpenDelim(..) | CloseDelim(..) | Literal(..) | DocComment(..) | Ident(..)
- | NtIdent(..) | Lifetime(..) | NtLifetime(..) | Interpolated(..) | Eof => false,
+ Eq | Lt | Le | EqEq | Ne | Ge | Gt | AndAnd | OrOr | Bang | Tilde | Plus | Minus
+ | Star | Slash | Percent | Caret | And | Or | Shl | Shr | PlusEq | MinusEq | StarEq
+ | SlashEq | PercentEq | CaretEq | AndEq | OrEq | ShlEq | ShrEq | At | Dot | DotDot
+ | DotDotDot | DotDotEq | Comma | Semi | Colon | PathSep | RArrow | LArrow
+ | FatArrow | Pound | Dollar | Question | SingleQuote => true,
+
+ OpenParen | CloseParen | OpenBrace | CloseBrace | OpenBracket | CloseBracket
+ | OpenInvisible(_) | CloseInvisible(_) | Literal(..) | DocComment(..) | Ident(..)
+ | NtIdent(..) | Lifetime(..) | NtLifetime(..) | Eof => false,
}
}
pub fn is_like_plus(&self) -> bool {
- matches!(self.kind, BinOp(Plus) | BinOpEq(Plus))
+ matches!(self.kind, Plus | PlusEq)
}
/// Returns `true` if the token can appear at the start of an expression.
+ ///
+ /// **NB**: Take care when modifying this function, since it will change
+ /// the stable set of tokens that are allowed to match an expr nonterminal.
pub fn can_begin_expr(&self) -> bool {
match self.uninterpolate().kind {
Ident(name, is_raw) =>
ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
- OpenDelim(..) | // tuple, array or block
+ OpenParen | // tuple
+ OpenBrace | // block
+ OpenBracket | // array
Literal(..) | // literal
- Not | // operator not
- BinOp(Minus) | // unary minus
- BinOp(Star) | // dereference
- BinOp(Or) | OrOr | // closure
- BinOp(And) | // reference
+ Bang | // operator not
+ Minus | // unary minus
+ Star | // dereference
+ Or | OrOr | // closure
+ And | // reference
AndAnd | // double reference
// DotDotDot is no longer supported, but we need some way to display the error
DotDot | DotDotDot | DotDotEq | // range notation
- Lt | BinOp(Shl) | // associated path
- PathSep | // global path
+ Lt | Shl | // associated path
+ PathSep | // global path
Lifetime(..) | // labeled loop
Pound => true, // expression attributes
- Interpolated(ref nt) => matches!(&**nt, NtLiteral(..) |
- NtExpr(..) |
- NtBlock(..) |
- NtPath(..)),
+ OpenInvisible(InvisibleOrigin::MetaVar(
+ MetaVarKind::Block |
+ MetaVarKind::Expr { .. } |
+ MetaVarKind::Literal |
+ MetaVarKind::Path
+ )) => true,
_ => false,
}
}
@@ -514,23 +678,30 @@ impl Token {
/// Returns `true` if the token can appear at the start of a pattern.
///
/// Shamelessly borrowed from `can_begin_expr`, only used for diagnostics right now.
- pub fn can_begin_pattern(&self) -> bool {
- match self.uninterpolate().kind {
- Ident(name, is_raw) =>
- ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
- | OpenDelim(Delimiter::Bracket | Delimiter::Parenthesis) // tuple or array
- | Literal(..) // literal
- | BinOp(Minus) // unary minus
- | BinOp(And) // reference
- | AndAnd // double reference
- // DotDotDot is no longer supported
- | DotDot | DotDotDot | DotDotEq // ranges
- | Lt | BinOp(Shl) // associated path
- | PathSep => true, // global path
- Interpolated(ref nt) => matches!(&**nt, NtLiteral(..) |
- NtPat(..) |
- NtBlock(..) |
- NtPath(..)),
+ pub fn can_begin_pattern(&self, pat_kind: NtPatKind) -> bool {
+ match &self.uninterpolate().kind {
+ // box, ref, mut, and other identifiers (can stricten)
+ Ident(..) | NtIdent(..) |
+ OpenParen | // tuple pattern
+ OpenBracket | // slice pattern
+ And | // reference
+ Minus | // negative literal
+ AndAnd | // double reference
+ Literal(_) | // literal
+ DotDot | // range pattern (future compat)
+ DotDotDot | // range pattern (future compat)
+ PathSep | // path
+ Lt | // path (UFCS constant)
+ Shl => true, // path (double UFCS)
+ Or => matches!(pat_kind, PatWithOr), // leading vert `|` or-pattern
+ OpenInvisible(InvisibleOrigin::MetaVar(
+ MetaVarKind::Expr { .. } |
+ MetaVarKind::Literal |
+ MetaVarKind::Meta { .. } |
+ MetaVarKind::Pat(_) |
+ MetaVarKind::Path |
+ MetaVarKind::Ty { .. }
+ )) => true,
_ => false,
}
}
@@ -538,19 +709,22 @@ impl Token {
/// Returns `true` if the token can appear at the start of a type.
pub fn can_begin_type(&self) -> bool {
match self.uninterpolate().kind {
- Ident(name, is_raw) =>
+ Ident(name, is_raw) =>
ident_can_begin_type(name, self.span, is_raw), // type name or keyword
- OpenDelim(Delimiter::Parenthesis) | // tuple
- OpenDelim(Delimiter::Bracket) | // array
- Not | // never
- BinOp(Star) | // raw pointer
- BinOp(And) | // reference
- AndAnd | // double reference
- Question | // maybe bound in trait object
- Lifetime(..) | // lifetime bound in trait object
- Lt | BinOp(Shl) | // associated path
- PathSep => true, // global path
- Interpolated(ref nt) => matches!(&**nt, NtTy(..) | NtPath(..)),
+ OpenParen | // tuple
+ OpenBracket | // array
+ Bang | // never
+ Star | // raw pointer
+ And | // reference
+ AndAnd | // double reference
+ Question | // maybe bound in trait object
+ Lifetime(..) | // lifetime bound in trait object
+ Lt | Shl | // associated path
+ PathSep => true, // global path
+ OpenInvisible(InvisibleOrigin::MetaVar(
+ MetaVarKind::Ty { .. } |
+ MetaVarKind::Path
+ )) => true,
// For anonymous structs or unions, which only appear in specific positions
// (type of struct fields or union fields), we don't consider them as regular types
_ => false,
@@ -560,9 +734,11 @@ impl Token {
/// Returns `true` if the token can appear at the start of a const param.
pub fn can_begin_const_arg(&self) -> bool {
match self.kind {
- OpenDelim(Delimiter::Brace) | Literal(..) | BinOp(Minus) => true,
+ OpenBrace | Literal(..) | Minus => true,
Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
- Interpolated(ref nt) => matches!(&**nt, NtExpr(..) | NtBlock(..) | NtLiteral(..)),
+ OpenInvisible(InvisibleOrigin::MetaVar(
+ MetaVarKind::Expr { .. } | MetaVarKind::Block | MetaVarKind::Literal,
+ )) => true,
_ => false,
}
}
@@ -603,20 +779,17 @@ impl Token {
///
/// In other words, would this token be a valid start of `parse_literal_maybe_minus`?
///
- /// Keep this in sync with and `Lit::from_token`, excluding unary negation.
+ /// Keep this in sync with `Lit::from_token` and `Parser::eat_token_lit`
+ /// (excluding unary negation).
pub fn can_begin_literal_maybe_minus(&self) -> bool {
match self.uninterpolate().kind {
- Literal(..) | BinOp(Minus) => true,
+ Literal(..) | Minus => true,
Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
- Interpolated(ref nt) => match &**nt {
- NtLiteral(_) => true,
- NtExpr(e) => match &e.kind {
- ast::ExprKind::Lit(_) => true,
- ast::ExprKind::Unary(ast::UnOp::Neg, e) => {
- matches!(&e.kind, ast::ExprKind::Lit(_))
- }
- _ => false,
- },
+ OpenInvisible(InvisibleOrigin::MetaVar(mv_kind)) => match mv_kind {
+ MetaVarKind::Literal => true,
+ MetaVarKind::Expr { can_begin_literal_maybe_minus, .. } => {
+ can_begin_literal_maybe_minus
+ }
_ => false,
},
_ => false,
@@ -626,12 +799,9 @@ impl Token {
pub fn can_begin_string_literal(&self) -> bool {
match self.uninterpolate().kind {
Literal(..) => true,
- Interpolated(ref nt) => match &**nt {
- NtLiteral(_) => true,
- NtExpr(e) => match &e.kind {
- ast::ExprKind::Lit(_) => true,
- _ => false,
- },
+ OpenInvisible(InvisibleOrigin::MetaVar(mv_kind)) => match mv_kind {
+ MetaVarKind::Literal => true,
+ MetaVarKind::Expr { can_begin_string_literal, .. } => can_begin_string_literal,
_ => false,
},
_ => false,
@@ -645,7 +815,9 @@ impl Token {
pub fn uninterpolate(&self) -> Cow<'_, Token> {
match self.kind {
NtIdent(ident, is_raw) => Cow::Owned(Token::new(Ident(ident.name, is_raw), ident.span)),
- NtLifetime(ident) => Cow::Owned(Token::new(Lifetime(ident.name), ident.span)),
+ NtLifetime(ident, is_raw) => {
+ Cow::Owned(Token::new(Lifetime(ident.name, is_raw), ident.span))
+ }
_ => Cow::Borrowed(self),
}
}
@@ -663,11 +835,11 @@ impl Token {
/// Returns a lifetime identifier if this token is a lifetime.
#[inline]
- pub fn lifetime(&self) -> Option<Ident> {
+ pub fn lifetime(&self) -> Option<(Ident, IdentIsRaw)> {
// We avoid using `Token::uninterpolate` here because it's slow.
match self.kind {
- Lifetime(name) => Some(Ident::new(name, self.span)),
- NtLifetime(ident) => Some(ident),
+ Lifetime(name, is_raw) => Some((Ident::new(name, self.span), is_raw)),
+ NtLifetime(ident, is_raw) => Some((ident, is_raw)),
_ => None,
}
}
@@ -688,39 +860,23 @@ impl Token {
self.ident().is_some_and(|(ident, _)| ident.name == name)
}
- /// Returns `true` if the token is an interpolated path.
- fn is_whole_path(&self) -> bool {
- if let Interpolated(nt) = &self.kind
- && let NtPath(..) = &**nt
- {
- return true;
- }
-
- false
- }
-
- /// Would `maybe_whole_expr` in `parser.rs` return `Ok(..)`?
- /// That is, is this a pre-parsed expression dropped into the token stream
+ /// Is this a pre-parsed expression dropped into the token stream
/// (which happens while parsing the result of macro expansion)?
- pub fn is_whole_expr(&self) -> bool {
- if let Interpolated(nt) = &self.kind
- && let NtExpr(_) | NtLiteral(_) | NtPath(_) | NtBlock(_) = &**nt
- {
- return true;
- }
-
- false
+ pub fn is_metavar_expr(&self) -> bool {
+ matches!(
+ self.is_metavar_seq(),
+ Some(
+ MetaVarKind::Expr { .. }
+ | MetaVarKind::Literal
+ | MetaVarKind::Path
+ | MetaVarKind::Block
+ )
+ )
}
- /// Is the token an interpolated block (`$b:block`)?
- pub fn is_whole_block(&self) -> bool {
- if let Interpolated(nt) = &self.kind
- && let NtBlock(..) = &**nt
- {
- return true;
- }
-
- false
+ /// Are we at a block from a metavar (`$b:block`)?
+ pub fn is_metavar_block(&self) -> bool {
+ matches!(self.is_metavar_seq(), Some(MetaVarKind::Block))
}
/// Returns `true` if the token is either the `mut` or `const` keyword.
@@ -729,13 +885,13 @@ impl Token {
}
pub fn is_qpath_start(&self) -> bool {
- self == &Lt || self == &BinOp(Shl)
+ self == &Lt || self == &Shl
}
pub fn is_path_start(&self) -> bool {
self == &PathSep
|| self.is_qpath_start()
- || self.is_whole_path()
+ || matches!(self.is_metavar_seq(), Some(MetaVarKind::Path))
|| self.is_path_segment_keyword()
|| self.is_ident() && !self.is_reserved_ident()
}
@@ -745,12 +901,14 @@ impl Token {
self.is_non_raw_ident_where(|id| id.name == kw)
}
- /// Returns `true` if the token is a given keyword, `kw` or if `case` is `Insensitive` and this token is an identifier equal to `kw` ignoring the case.
+ /// Returns `true` if the token is a given keyword, `kw` or if `case` is `Insensitive` and this
+ /// token is an identifier equal to `kw` ignoring the case.
pub fn is_keyword_case(&self, kw: Symbol, case: Case) -> bool {
self.is_keyword(kw)
|| (case == Case::Insensitive
&& self.is_non_raw_ident_where(|id| {
- id.name.as_str().to_lowercase() == kw.as_str().to_lowercase()
+ // Do an ASCII case-insensitive match, because all keywords are ASCII.
+ id.name.as_str().eq_ignore_ascii_case(kw.as_str())
}))
}
@@ -804,60 +962,93 @@ impl Token {
}
}
+ /// Is this an invisible open delimiter at the start of a token sequence
+ /// from an expanded metavar?
+ pub fn is_metavar_seq(&self) -> Option<MetaVarKind> {
+ match self.kind {
+ OpenInvisible(InvisibleOrigin::MetaVar(kind)) => Some(kind),
+ _ => None,
+ }
+ }
+
pub fn glue(&self, joint: &Token) -> Option<Token> {
- let kind = match self.kind {
- Eq => match joint.kind {
- Eq => EqEq,
- Gt => FatArrow,
- _ => return None,
- },
- Lt => match joint.kind {
- Eq => Le,
- Lt => BinOp(Shl),
- Le => BinOpEq(Shl),
- BinOp(Minus) => LArrow,
- _ => return None,
- },
- Gt => match joint.kind {
- Eq => Ge,
- Gt => BinOp(Shr),
- Ge => BinOpEq(Shr),
- _ => return None,
- },
- Not => match joint.kind {
- Eq => Ne,
- _ => return None,
- },
- BinOp(op) => match joint.kind {
- Eq => BinOpEq(op),
- BinOp(And) if op == And => AndAnd,
- BinOp(Or) if op == Or => OrOr,
- Gt if op == Minus => RArrow,
- _ => return None,
- },
- Dot => match joint.kind {
- Dot => DotDot,
- DotDot => DotDotDot,
- _ => return None,
- },
- DotDot => match joint.kind {
- Dot => DotDotDot,
- Eq => DotDotEq,
- _ => return None,
- },
- Colon => match joint.kind {
- Colon => PathSep,
- _ => return None,
- },
- SingleQuote => match joint.kind {
- Ident(name, IdentIsRaw::No) => Lifetime(Symbol::intern(&format!("'{name}"))),
- _ => return None,
- },
+ let kind = match (&self.kind, &joint.kind) {
+ (Eq, Eq) => EqEq,
+ (Eq, Gt) => FatArrow,
+ (Eq, _) => return None,
+
+ (Lt, Eq) => Le,
+ (Lt, Lt) => Shl,
+ (Lt, Le) => ShlEq,
+ (Lt, Minus) => LArrow,
+ (Lt, _) => return None,
+
+ (Gt, Eq) => Ge,
+ (Gt, Gt) => Shr,
+ (Gt, Ge) => ShrEq,
+ (Gt, _) => return None,
+
+ (Bang, Eq) => Ne,
+ (Bang, _) => return None,
+
+ (Plus, Eq) => PlusEq,
+ (Plus, _) => return None,
+
+ (Minus, Eq) => MinusEq,
+ (Minus, Gt) => RArrow,
+ (Minus, _) => return None,
+
+ (Star, Eq) => StarEq,
+ (Star, _) => return None,
+
+ (Slash, Eq) => SlashEq,
+ (Slash, _) => return None,
+
+ (Percent, Eq) => PercentEq,
+ (Percent, _) => return None,
+
+ (Caret, Eq) => CaretEq,
+ (Caret, _) => return None,
- Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | BinOpEq(..) | At | DotDotDot
- | DotDotEq | Comma | Semi | PathSep | RArrow | LArrow | FatArrow | Pound | Dollar
- | Question | OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..) | NtIdent(..)
- | Lifetime(..) | NtLifetime(..) | Interpolated(..) | DocComment(..) | Eof => {
+ (And, Eq) => AndEq,
+ (And, And) => AndAnd,
+ (And, _) => return None,
+
+ (Or, Eq) => OrEq,
+ (Or, Or) => OrOr,
+ (Or, _) => return None,
+
+ (Shl, Eq) => ShlEq,
+ (Shl, _) => return None,
+
+ (Shr, Eq) => ShrEq,
+ (Shr, _) => return None,
+
+ (Dot, Dot) => DotDot,
+ (Dot, DotDot) => DotDotDot,
+ (Dot, _) => return None,
+
+ (DotDot, Dot) => DotDotDot,
+ (DotDot, Eq) => DotDotEq,
+ (DotDot, _) => return None,
+
+ (Colon, Colon) => PathSep,
+ (Colon, _) => return None,
+
+ (SingleQuote, Ident(name, is_raw)) => {
+ Lifetime(Symbol::intern(&format!("'{name}")), *is_raw)
+ }
+ (SingleQuote, _) => return None,
+
+ (
+ Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | PlusEq | MinusEq | StarEq | SlashEq
+ | PercentEq | CaretEq | AndEq | OrEq | ShlEq | ShrEq | At | DotDotDot | DotDotEq
+ | Comma | Semi | PathSep | RArrow | LArrow | FatArrow | Pound | Dollar | Question
+ | OpenParen | CloseParen | OpenBrace | CloseBrace | OpenBracket | CloseBracket
+ | OpenInvisible(_) | CloseInvisible(_) | Literal(..) | Ident(..) | NtIdent(..)
+ | Lifetime(..) | NtLifetime(..) | DocComment(..) | Eof,
+ _,
+ ) => {
return None;
}
};
@@ -873,7 +1064,7 @@ impl PartialEq<TokenKind> for Token {
}
}
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, HashStable_Generic)]
pub enum NtPatKind {
// Matches or-patterns. Was written using `pat` in edition 2021 or later.
PatWithOr,
@@ -883,7 +1074,7 @@ pub enum NtPatKind {
PatParam { inferred: bool },
}
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, HashStable_Generic)]
pub enum NtExprKind {
// Matches expressions using the post-edition 2024. Was written using
// `expr` in edition 2024 or later.
@@ -894,23 +1085,7 @@ pub enum NtExprKind {
Expr2021 { inferred: bool },
}
-#[derive(Clone, Encodable, Decodable)]
-/// For interpolation during macro expansion.
-pub enum Nonterminal {
- NtItem(P<ast::Item>),
- NtBlock(P<ast::Block>),
- NtStmt(P<ast::Stmt>),
- NtPat(P<ast::Pat>),
- NtExpr(P<ast::Expr>),
- NtTy(P<ast::Ty>),
- NtLiteral(P<ast::Expr>),
- /// Stuff inside brackets for attributes
- NtMeta(P<ast::AttrItem>),
- NtPath(P<ast::Path>),
- NtVis(P<ast::Visibility>),
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, HashStable_Generic)]
pub enum NonterminalKind {
Item,
Block,
@@ -993,82 +1168,15 @@ impl fmt::Display for NonterminalKind {
}
}
-impl Nonterminal {
- pub fn use_span(&self) -> Span {
- match self {
- NtItem(item) => item.span,
- NtBlock(block) => block.span,
- NtStmt(stmt) => stmt.span,
- NtPat(pat) => pat.span,
- NtExpr(expr) | NtLiteral(expr) => expr.span,
- NtTy(ty) => ty.span,
- NtMeta(attr_item) => attr_item.span(),
- NtPath(path) => path.span,
- NtVis(vis) => vis.span,
- }
- }
-
- pub fn descr(&self) -> &'static str {
- match self {
- NtItem(..) => "item",
- NtBlock(..) => "block",
- NtStmt(..) => "statement",
- NtPat(..) => "pattern",
- NtExpr(..) => "expression",
- NtLiteral(..) => "literal",
- NtTy(..) => "type",
- NtMeta(..) => "attribute",
- NtPath(..) => "path",
- NtVis(..) => "visibility",
- }
- }
-}
-
-impl PartialEq for Nonterminal {
- fn eq(&self, _rhs: &Self) -> bool {
- // FIXME: Assume that all nonterminals are not equal, we can't compare them
- // correctly based on data from AST. This will prevent them from matching each other
- // in macros. The comparison will become possible only when each nonterminal has an
- // attached token stream from which it was parsed.
- false
- }
-}
-
-impl fmt::Debug for Nonterminal {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- match *self {
- NtItem(..) => f.pad("NtItem(..)"),
- NtBlock(..) => f.pad("NtBlock(..)"),
- NtStmt(..) => f.pad("NtStmt(..)"),
- NtPat(..) => f.pad("NtPat(..)"),
- NtExpr(..) => f.pad("NtExpr(..)"),
- NtTy(..) => f.pad("NtTy(..)"),
- NtLiteral(..) => f.pad("NtLiteral(..)"),
- NtMeta(..) => f.pad("NtMeta(..)"),
- NtPath(..) => f.pad("NtPath(..)"),
- NtVis(..) => f.pad("NtVis(..)"),
- }
- }
-}
-
-impl<CTX> HashStable<CTX> for Nonterminal
-where
- CTX: crate::HashStableContext,
-{
- fn hash_stable(&self, _hcx: &mut CTX, _hasher: &mut StableHasher) {
- panic!("interpolated tokens should not be present in the HIR")
- }
-}
-
// Some types are used a lot. Make sure they don't unintentionally get bigger.
#[cfg(target_pointer_width = "64")]
mod size_asserts {
- use super::*;
use rustc_data_structures::static_assert_size;
+
+ use super::*;
// tidy-alphabetical-start
static_assert_size!(Lit, 12);
static_assert_size!(LitKind, 2);
- static_assert_size!(Nonterminal, 16);
static_assert_size!(Token, 24);
static_assert_size!(TokenKind, 16);
// tidy-alphabetical-end
diff --git a/compiler/rustc_ast/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs
index a92ef575777c7..636c26bcde04b 100644
--- a/compiler/rustc_ast/src/tokenstream.rs
+++ b/compiler/rustc_ast/src/tokenstream.rs
@@ -13,19 +13,22 @@
//! and a borrowed `TokenStream` is sufficient to build an owned `TokenStream` without taking
//! ownership of the original.
-use crate::ast::{AttrStyle, StmtKind};
-use crate::ast_traits::{HasAttrs, HasTokens};
-use crate::token::{self, Delimiter, Nonterminal, Token, TokenKind};
-use crate::{AttrVec, Attribute};
+use std::borrow::Cow;
+use std::ops::Range;
+use std::sync::Arc;
+use std::{cmp, fmt, iter, mem};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_data_structures::sync::{self, Lrc};
+use rustc_data_structures::sync;
use rustc_macros::{Decodable, Encodable, HashStable_Generic};
use rustc_serialize::{Decodable, Encodable};
-use rustc_span::{sym, Span, SpanDecoder, SpanEncoder, Symbol, DUMMY_SP};
+use rustc_span::{DUMMY_SP, Span, SpanDecoder, SpanEncoder, Symbol, sym};
+use thin_vec::ThinVec;
-use std::borrow::Cow;
-use std::{cmp, fmt, iter};
+use crate::ast::AttrStyle;
+use crate::ast_traits::{HasAttrs, HasTokens};
+use crate::token::{self, Delimiter, Token, TokenKind};
+use crate::{AttrVec, Attribute};
/// Part of a `TokenStream`.
#[derive(Debug, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)]
@@ -38,7 +41,6 @@ pub enum TokenTree {
}
// Ensure all fields of `TokenTree` are `DynSend` and `DynSync`.
-#[cfg(parallel_compiler)]
fn _dummy()
where
Token: sync::DynSend + sync::DynSync,
@@ -100,31 +102,36 @@ where
CTX: crate::HashStableContext,
{
fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
- for sub_tt in self.trees() {
+ for sub_tt in self.iter() {
sub_tt.hash_stable(hcx, hasher);
}
}
}
-pub trait ToAttrTokenStream: sync::DynSend + sync::DynSync {
- fn to_attr_token_stream(&self) -> AttrTokenStream;
-}
-
-impl ToAttrTokenStream for AttrTokenStream {
- fn to_attr_token_stream(&self) -> AttrTokenStream {
- self.clone()
- }
-}
-
-/// A lazy version of [`TokenStream`], which defers creation
-/// of an actual `TokenStream` until it is needed.
-/// `Box` is here only to reduce the structure size.
+/// A lazy version of [`AttrTokenStream`], which defers creation of an actual
+/// `AttrTokenStream` until it is needed.
#[derive(Clone)]
-pub struct LazyAttrTokenStream(Lrc<Box<dyn ToAttrTokenStream>>);
+pub struct LazyAttrTokenStream(Arc<LazyAttrTokenStreamInner>);
impl LazyAttrTokenStream {
- pub fn new(inner: impl ToAttrTokenStream + 'static) -> LazyAttrTokenStream {
- LazyAttrTokenStream(Lrc::new(Box::new(inner)))
+ pub fn new_direct(stream: AttrTokenStream) -> LazyAttrTokenStream {
+ LazyAttrTokenStream(Arc::new(LazyAttrTokenStreamInner::Direct(stream)))
+ }
+
+ pub fn new_pending(
+ start_token: (Token, Spacing),
+ cursor_snapshot: TokenCursor,
+ num_calls: u32,
+ break_last_token: u32,
+ node_replacements: ThinVec<NodeReplacement>,
+ ) -> LazyAttrTokenStream {
+ LazyAttrTokenStream(Arc::new(LazyAttrTokenStreamInner::Pending {
+ start_token,
+ cursor_snapshot,
+ num_calls,
+ break_last_token,
+ node_replacements,
+ }))
}
pub fn to_attr_token_stream(&self) -> AttrTokenStream {
@@ -156,12 +163,255 @@ impl<CTX> HashStable<CTX> for LazyAttrTokenStream {
}
}
+/// A token range within a `Parser`'s full token stream.
+#[derive(Clone, Debug)]
+pub struct ParserRange(pub Range<u32>);
+
+/// A token range within an individual AST node's (lazy) token stream, i.e.
+/// relative to that node's first token. Distinct from `ParserRange` so the two
+/// kinds of range can't be mixed up.
+#[derive(Clone, Debug)]
+pub struct NodeRange(pub Range<u32>);
+
+/// Indicates a range of tokens that should be replaced by an `AttrsTarget`
+/// (replacement) or be replaced by nothing (deletion). This is used in two
+/// places during token collection.
+///
+/// 1. Replacement. During the parsing of an AST node that may have a
+/// `#[derive]` attribute, when we parse a nested AST node that has `#[cfg]`
+/// or `#[cfg_attr]`, we replace the entire inner AST node with
+/// `FlatToken::AttrsTarget`. This lets us perform eager cfg-expansion on an
+/// `AttrTokenStream`.
+///
+/// 2. Deletion. We delete inner attributes from all collected token streams,
+/// and instead track them through the `attrs` field on the AST node. This
+/// lets us manipulate them similarly to outer attributes. When we create a
+/// `TokenStream`, the inner attributes are inserted into the proper place
+/// in the token stream.
+///
+/// Each replacement starts off in `ParserReplacement` form but is converted to
+/// `NodeReplacement` form when it is attached to a single AST node, via
+/// `LazyAttrTokenStreamImpl`.
+pub type ParserReplacement = (ParserRange, Option<AttrsTarget>);
+
+/// See the comment on `ParserReplacement`.
+pub type NodeReplacement = (NodeRange, Option<AttrsTarget>);
+
+impl NodeRange {
+ // Converts a range within a parser's tokens to a range within a
+ // node's tokens beginning at `start_pos`.
+ //
+ // For example, imagine a parser with 50 tokens in its token stream, a
+ // function that spans `ParserRange(20..40)` and an inner attribute within
+ // that function that spans `ParserRange(30..35)`. We would find the inner
+ // attribute's range within the function's tokens by subtracting 20, which
+ // is the position of the function's start token. This gives
+ // `NodeRange(10..15)`.
+ pub fn new(ParserRange(parser_range): ParserRange, start_pos: u32) -> NodeRange {
+ assert!(!parser_range.is_empty());
+ assert!(parser_range.start >= start_pos);
+ NodeRange((parser_range.start - start_pos)..(parser_range.end - start_pos))
+ }
+}
+
+enum LazyAttrTokenStreamInner {
+ // The token stream has already been produced.
+ Direct(AttrTokenStream),
+
+ // From a value of this type we can reconstruct the `TokenStream` seen by
+ // the `f` callback passed to a call to `Parser::collect_tokens`, by
+ // replaying the getting of the tokens. This saves us producing a
+ // `TokenStream` if it is never needed, e.g. a captured `macro_rules!`
+ // argument that is never passed to a proc macro. In practice, token stream
+ // creation happens rarely compared to calls to `collect_tokens` (see some
+ // statistics in #78736) so we are doing as little up-front work as
+ // possible.
+ //
+ // This also makes `Parser` very cheap to clone, since there is no
+ // intermediate collection buffer to clone.
+ Pending {
+ start_token: (Token, Spacing),
+ cursor_snapshot: TokenCursor,
+ num_calls: u32,
+ break_last_token: u32,
+ node_replacements: ThinVec<NodeReplacement>,
+ },
+}
+
+impl LazyAttrTokenStreamInner {
+ fn to_attr_token_stream(&self) -> AttrTokenStream {
+ match self {
+ LazyAttrTokenStreamInner::Direct(stream) => stream.clone(),
+ LazyAttrTokenStreamInner::Pending {
+ start_token,
+ cursor_snapshot,
+ num_calls,
+ break_last_token,
+ node_replacements,
+ } => {
+ // The token produced by the final call to `{,inlined_}next` was not
+ // actually consumed by the callback. The combination of chaining the
+ // initial token and using `take` produces the desired result - we
+ // produce an empty `TokenStream` if no calls were made, and omit the
+ // final token otherwise.
+ let mut cursor_snapshot = cursor_snapshot.clone();
+ let tokens = iter::once(FlatToken::Token(*start_token))
+ .chain(iter::repeat_with(|| FlatToken::Token(cursor_snapshot.next())))
+ .take(*num_calls as usize);
+
+ if node_replacements.is_empty() {
+ make_attr_token_stream(tokens, *break_last_token)
+ } else {
+ let mut tokens: Vec<_> = tokens.collect();
+ let mut node_replacements = node_replacements.to_vec();
+ node_replacements.sort_by_key(|(range, _)| range.0.start);
+
+ #[cfg(debug_assertions)]
+ for [(node_range, tokens), (next_node_range, next_tokens)] in
+ node_replacements.array_windows()
+ {
+ assert!(
+ node_range.0.end <= next_node_range.0.start
+ || node_range.0.end >= next_node_range.0.end,
+ "Node ranges should be disjoint or nested: ({:?}, {:?}) ({:?}, {:?})",
+ node_range,
+ tokens,
+ next_node_range,
+ next_tokens,
+ );
+ }
+
+ // Process the replace ranges, starting from the highest start
+ // position and working our way back. If have tokens like:
+ //
+ // `#[cfg(FALSE)] struct Foo { #[cfg(FALSE)] field: bool }`
+ //
+ // Then we will generate replace ranges for both
+ // the `#[cfg(FALSE)] field: bool` and the entire
+ // `#[cfg(FALSE)] struct Foo { #[cfg(FALSE)] field: bool }`
+ //
+ // By starting processing from the replace range with the greatest
+ // start position, we ensure that any (outer) replace range which
+ // encloses another (inner) replace range will fully overwrite the
+ // inner range's replacement.
+ for (node_range, target) in node_replacements.into_iter().rev() {
+ assert!(
+ !node_range.0.is_empty(),
+ "Cannot replace an empty node range: {:?}",
+ node_range.0
+ );
+
+ // Replace the tokens in range with zero or one `FlatToken::AttrsTarget`s,
+ // plus enough `FlatToken::Empty`s to fill up the rest of the range. This
+ // keeps the total length of `tokens` constant throughout the replacement
+ // process, allowing us to do all replacements without adjusting indices.
+ let target_len = target.is_some() as usize;
+ tokens.splice(
+ (node_range.0.start as usize)..(node_range.0.end as usize),
+ target.into_iter().map(|target| FlatToken::AttrsTarget(target)).chain(
+ iter::repeat(FlatToken::Empty)
+ .take(node_range.0.len() - target_len),
+ ),
+ );
+ }
+ make_attr_token_stream(tokens.into_iter(), *break_last_token)
+ }
+ }
+ }
+ }
+}
+
+/// A helper struct used when building an `AttrTokenStream` from
+/// a `LazyAttrTokenStream`. Both delimiter and non-delimited tokens
+/// are stored as `FlatToken::Token`. A vector of `FlatToken`s
+/// is then 'parsed' to build up an `AttrTokenStream` with nested
+/// `AttrTokenTree::Delimited` tokens.
+#[derive(Debug, Clone)]
+enum FlatToken {
+ /// A token - this holds both delimiter (e.g. '{' and '}')
+ /// and non-delimiter tokens
+ Token((Token, Spacing)),
+ /// Holds the `AttrsTarget` for an AST node. The `AttrsTarget` is inserted
+ /// directly into the constructed `AttrTokenStream` as an
+ /// `AttrTokenTree::AttrsTarget`.
+ AttrsTarget(AttrsTarget),
+ /// A special 'empty' token that is ignored during the conversion
+ /// to an `AttrTokenStream`. This is used to simplify the
+ /// handling of replace ranges.
+ Empty,
+}
+
/// An `AttrTokenStream` is similar to a `TokenStream`, but with extra
/// information about the tokens for attribute targets. This is used
/// during expansion to perform early cfg-expansion, and to process attributes
/// during proc-macro invocations.
#[derive(Clone, Debug, Default, Encodable, Decodable)]
-pub struct AttrTokenStream(pub Lrc<Vec<AttrTokenTree>>);
+pub struct AttrTokenStream(pub Arc<Vec<AttrTokenTree>>);
+
+/// Converts a flattened iterator of tokens (including open and close delimiter tokens) into an
+/// `AttrTokenStream`, creating an `AttrTokenTree::Delimited` for each matching pair of open and
+/// close delims.
+fn make_attr_token_stream(
+ iter: impl Iterator<Item = FlatToken>,
+ break_last_token: u32,
+) -> AttrTokenStream {
+ #[derive(Debug)]
+ struct FrameData {
+ // This is `None` for the first frame, `Some` for all others.
+ open_delim_sp: Option<(Delimiter, Span, Spacing)>,
+ inner: Vec<AttrTokenTree>,
+ }
+ // The stack always has at least one element. Storing it separately makes for shorter code.
+ let mut stack_top = FrameData { open_delim_sp: None, inner: vec![] };
+ let mut stack_rest = vec![];
+ for flat_token in iter {
+ match flat_token {
+ FlatToken::Token((token @ Token { kind, span }, spacing)) => {
+ if let Some(delim) = kind.open_delim() {
+ stack_rest.push(mem::replace(
+ &mut stack_top,
+ FrameData { open_delim_sp: Some((delim, span, spacing)), inner: vec![] },
+ ));
+ } else if let Some(delim) = kind.close_delim() {
+ let frame_data = mem::replace(&mut stack_top, stack_rest.pop().unwrap());
+ let (open_delim, open_sp, open_spacing) = frame_data.open_delim_sp.unwrap();
+ assert!(
+ open_delim.eq_ignoring_invisible_origin(&delim),
+ "Mismatched open/close delims: open={open_delim:?} close={span:?}"
+ );
+ let dspan = DelimSpan::from_pair(open_sp, span);
+ let dspacing = DelimSpacing::new(open_spacing, spacing);
+ let stream = AttrTokenStream::new(frame_data.inner);
+ let delimited = AttrTokenTree::Delimited(dspan, dspacing, delim, stream);
+ stack_top.inner.push(delimited);
+ } else {
+ stack_top.inner.push(AttrTokenTree::Token(token, spacing))
+ }
+ }
+ FlatToken::AttrsTarget(target) => {
+ stack_top.inner.push(AttrTokenTree::AttrsTarget(target))
+ }
+ FlatToken::Empty => {}
+ }
+ }
+
+ if break_last_token > 0 {
+ let last_token = stack_top.inner.pop().unwrap();
+ if let AttrTokenTree::Token(last_token, spacing) = last_token {
+ let (unglued, _) = last_token.kind.break_two_token_op(break_last_token).unwrap();
+
+ // Tokens are always ASCII chars, so we can use byte arithmetic here.
+ let mut first_span = last_token.span.shrink_to_lo();
+ first_span =
+ first_span.with_hi(first_span.lo() + rustc_span::BytePos(break_last_token));
+
+ stack_top.inner.push(AttrTokenTree::Token(Token::new(unglued, first_span), spacing));
+ } else {
+ panic!("Unexpected last token {last_token:?}")
+ }
+ }
+ AttrTokenStream::new(stack_top.inner)
+}
/// Like `TokenTree`, but for `AttrTokenStream`.
#[derive(Clone, Debug, Encodable, Decodable)]
@@ -176,7 +426,7 @@ pub enum AttrTokenTree {
impl AttrTokenStream {
pub fn new(tokens: Vec<AttrTokenTree>) -> AttrTokenStream {
- AttrTokenStream(Lrc::new(tokens))
+ AttrTokenStream(Arc::new(tokens))
}
/// Converts this `AttrTokenStream` to a plain `Vec<TokenTree>`. During
@@ -233,35 +483,52 @@ fn attrs_and_tokens_to_token_trees(
// Insert inner attribute tokens.
if !inner_attrs.is_empty() {
- let mut found = false;
- // Check the last two trees (to account for a trailing semi)
- for tree in res.iter_mut().rev().take(2) {
- if let TokenTree::Delimited(span, spacing, delim, delim_tokens) = tree {
- // Inner attributes are only supported on extern blocks, functions,
- // impls, and modules. All of these have their inner attributes
- // placed at the beginning of the rightmost outermost braced group:
- // e.g. fn foo() { #![my_attr] }
- //
- // Therefore, we can insert them back into the right location
- // without needing to do any extra position tracking.
- //
- // Note: Outline modules are an exception - they can
- // have attributes like `#![my_attr]` at the start of a file.
- // Support for custom attributes in this position is not
- // properly implemented - we always synthesize fake tokens,
- // so we never reach this code.
+ let found = insert_inner_attrs(inner_attrs, res);
+ assert!(found, "Failed to find trailing delimited group in: {res:?}");
+ }
+
+ // Inner attributes are only supported on blocks, functions, impls, and
+ // modules. All of these have their inner attributes placed at the
+ // beginning of the rightmost outermost braced group:
+ // e.g. `fn foo() { #![my_attr] }`. (Note: the braces may be within
+ // invisible delimiters.)
+ //
+ // Therefore, we can insert them back into the right location without
+ // needing to do any extra position tracking.
+ //
+ // Note: Outline modules are an exception - they can have attributes like
+ // `#![my_attr]` at the start of a file. Support for custom attributes in
+ // this position is not properly implemented - we always synthesize fake
+ // tokens, so we never reach this code.
+ fn insert_inner_attrs(inner_attrs: &[Attribute], tts: &mut Vec<TokenTree>) -> bool {
+ for tree in tts.iter_mut().rev() {
+ if let TokenTree::Delimited(span, spacing, Delimiter::Brace, stream) = tree {
+ // Found it: the rightmost, outermost braced group.
let mut tts = vec![];
for inner_attr in inner_attrs {
tts.extend(inner_attr.token_trees());
}
- tts.extend(delim_tokens.0.iter().cloned());
+ tts.extend(stream.0.iter().cloned());
let stream = TokenStream::new(tts);
- *tree = TokenTree::Delimited(*span, *spacing, *delim, stream);
- found = true;
- break;
+ *tree = TokenTree::Delimited(*span, *spacing, Delimiter::Brace, stream);
+ return true;
+ } else if let TokenTree::Delimited(span, spacing, Delimiter::Invisible(src), stream) =
+ tree
+ {
+ // Recurse inside invisible delimiters.
+ let mut vec: Vec<_> = stream.iter().cloned().collect();
+ if insert_inner_attrs(inner_attrs, &mut vec) {
+ *tree = TokenTree::Delimited(
+ *span,
+ *spacing,
+ Delimiter::Invisible(*src),
+ TokenStream::new(vec),
+ );
+ return true;
+ }
}
}
- assert!(found, "Failed to find trailing delimited group in: {res:?}");
+ false
}
}
@@ -288,13 +555,8 @@ pub struct AttrsTarget {
}
/// A `TokenStream` is an abstract sequence of tokens, organized into [`TokenTree`]s.
-///
-/// The goal is for procedural macros to work with `TokenStream`s and `TokenTree`s
-/// instead of a representation of the abstract syntax tree.
-/// Today's `TokenTree`s can still contain AST via `token::Interpolated` for
-/// backwards compatibility.
#[derive(Clone, Debug, Default, Encodable, Decodable)]
-pub struct TokenStream(pub(crate) Lrc<Vec<TokenTree>>);
+pub struct TokenStream(pub(crate) Arc<Vec<TokenTree>>);
/// Indicates whether a token can join with the following token to form a
/// compound token. Used for conversions to `proc_macro::Spacing`. Also used to
@@ -407,13 +669,13 @@ impl Eq for TokenStream {}
impl PartialEq<TokenStream> for TokenStream {
fn eq(&self, other: &TokenStream) -> bool {
- self.trees().eq(other.trees())
+ self.iter().eq(other.iter())
}
}
impl TokenStream {
pub fn new(tts: Vec<TokenTree>) -> TokenStream {
- TokenStream(Lrc::new(tts))
+ TokenStream(Arc::new(tts))
}
pub fn is_empty(&self) -> bool {
@@ -424,24 +686,24 @@ impl TokenStream {
self.0.len()
}
- pub fn trees(&self) -> RefTokenTreeCursor<'_> {
- RefTokenTreeCursor::new(self)
+ pub fn get(&self, index: usize) -> Option<&TokenTree> {
+ self.0.get(index)
}
- pub fn into_trees(self) -> TokenTreeCursor {
- TokenTreeCursor::new(self)
+ pub fn iter(&self) -> TokenStreamIter<'_> {
+ TokenStreamIter::new(self)
}
/// Compares two `TokenStream`s, checking equality without regarding span information.
pub fn eq_unspanned(&self, other: &TokenStream) -> bool {
- let mut t1 = self.trees();
- let mut t2 = other.trees();
- for (t1, t2) in iter::zip(&mut t1, &mut t2) {
- if !t1.eq_unspanned(t2) {
+ let mut iter1 = self.iter();
+ let mut iter2 = other.iter();
+ for (tt1, tt2) in iter::zip(&mut iter1, &mut iter2) {
+ if !tt1.eq_unspanned(tt2) {
return false;
}
}
- t1.next().is_none() && t2.next().is_none()
+ iter1.next().is_none() && iter2.next().is_none()
}
/// Create a token stream containing a single token with alone spacing. The
@@ -459,73 +721,6 @@ impl TokenStream {
TokenStream::new(tts)
}
- pub fn from_nonterminal_ast(nt: &Nonterminal) -> TokenStream {
- match nt {
- Nonterminal::NtItem(item) => TokenStream::from_ast(item),
- Nonterminal::NtBlock(block) => TokenStream::from_ast(block),
- Nonterminal::NtStmt(stmt) if let StmtKind::Empty = stmt.kind => {
- // FIXME: Properly collect tokens for empty statements.
- TokenStream::token_alone(token::Semi, stmt.span)
- }
- Nonterminal::NtStmt(stmt) => TokenStream::from_ast(stmt),
- Nonterminal::NtPat(pat) => TokenStream::from_ast(pat),
- Nonterminal::NtTy(ty) => TokenStream::from_ast(ty),
- Nonterminal::NtMeta(attr) => TokenStream::from_ast(attr),
- Nonterminal::NtPath(path) => TokenStream::from_ast(path),
- Nonterminal::NtVis(vis) => TokenStream::from_ast(vis),
- Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => TokenStream::from_ast(expr),
- }
- }
-
- fn flatten_token(token: &Token, spacing: Spacing) -> TokenTree {
- match token.kind {
- token::NtIdent(ident, is_raw) => {
- TokenTree::Token(Token::new(token::Ident(ident.name, is_raw), ident.span), spacing)
- }
- token::NtLifetime(ident) => TokenTree::Delimited(
- DelimSpan::from_single(token.span),
- DelimSpacing::new(Spacing::JointHidden, spacing),
- Delimiter::Invisible,
- TokenStream::token_alone(token::Lifetime(ident.name), ident.span),
- ),
- token::Interpolated(ref nt) => TokenTree::Delimited(
- DelimSpan::from_single(token.span),
- DelimSpacing::new(Spacing::JointHidden, spacing),
- Delimiter::Invisible,
- TokenStream::from_nonterminal_ast(&nt).flattened(),
- ),
- _ => TokenTree::Token(token.clone(), spacing),
- }
- }
-
- fn flatten_token_tree(tree: &TokenTree) -> TokenTree {
- match tree {
- TokenTree::Token(token, spacing) => TokenStream::flatten_token(token, *spacing),
- TokenTree::Delimited(span, spacing, delim, tts) => {
- TokenTree::Delimited(*span, *spacing, *delim, tts.flattened())
- }
- }
- }
-
- #[must_use]
- pub fn flattened(&self) -> TokenStream {
- fn can_skip(stream: &TokenStream) -> bool {
- stream.trees().all(|tree| match tree {
- TokenTree::Token(token, _) => !matches!(
- token.kind,
- token::NtIdent(..) | token::NtLifetime(..) | token::Interpolated(..)
- ),
- TokenTree::Delimited(.., inner) => can_skip(inner),
- })
- }
-
- if can_skip(self) {
- return self.clone();
- }
-
- self.trees().map(|tree| TokenStream::flatten_token_tree(tree)).collect()
- }
-
// If `vec` is not empty, try to glue `tt` onto its last token. The return
// value indicates if gluing took place.
fn try_glue_to_last(vec: &mut Vec<TokenTree>, tt: &TokenTree) -> bool {
@@ -545,7 +740,7 @@ impl TokenStream {
/// Push `tt` onto the end of the stream, possibly gluing it to the last
/// token. Uses `make_mut` to maximize efficiency.
pub fn push_tree(&mut self, tt: TokenTree) {
- let vec_mut = Lrc::make_mut(&mut self.0);
+ let vec_mut = Arc::make_mut(&mut self.0);
if Self::try_glue_to_last(vec_mut, &tt) {
// nothing else to do
@@ -558,7 +753,7 @@ impl TokenStream {
/// token tree to the last token. (No other token trees will be glued.)
/// Uses `make_mut` to maximize efficiency.
pub fn push_stream(&mut self, stream: TokenStream) {
- let vec_mut = Lrc::make_mut(&mut self.0);
+ let vec_mut = Arc::make_mut(&mut self.0);
let stream_iter = stream.0.iter().cloned();
@@ -578,7 +773,7 @@ impl TokenStream {
}
/// Desugar doc comments like `/// foo` in the stream into `#[doc =
- /// r"foo"]`. Modifies the `TokenStream` via `Lrc::make_mut`, but as little
+ /// r"foo"]`. Modifies the `TokenStream` via `Arc::make_mut`, but as little
/// as possible.
pub fn desugar_doc_comments(&mut self) {
if let Some(desugared_stream) = desugar_inner(self.clone()) {
@@ -597,7 +792,7 @@ impl TokenStream {
) => {
let desugared = desugared_tts(attr_style, data, span);
let desugared_len = desugared.len();
- Lrc::make_mut(&mut stream.0).splice(i..i + 1, desugared);
+ Arc::make_mut(&mut stream.0).splice(i..i + 1, desugared);
modified = true;
i += desugared_len;
}
@@ -608,7 +803,7 @@ impl TokenStream {
if let Some(desugared_delim_stream) = desugar_inner(delim_stream.clone()) {
let new_tt =
TokenTree::Delimited(sp, spacing, delim, desugared_delim_stream);
- Lrc::make_mut(&mut stream.0)[i] = new_tt;
+ Arc::make_mut(&mut stream.0)[i] = new_tt;
modified = true;
}
i += 1;
@@ -656,7 +851,7 @@ impl TokenStream {
if attr_style == AttrStyle::Inner {
vec![
TokenTree::token_joint(token::Pound, span),
- TokenTree::token_joint_hidden(token::Not, span),
+ TokenTree::token_joint_hidden(token::Bang, span),
body,
]
} else {
@@ -666,25 +861,26 @@ impl TokenStream {
}
}
-/// By-reference iterator over a [`TokenStream`], that produces `&TokenTree`
-/// items.
#[derive(Clone)]
-pub struct RefTokenTreeCursor<'t> {
+pub struct TokenStreamIter<'t> {
stream: &'t TokenStream,
index: usize,
}
-impl<'t> RefTokenTreeCursor<'t> {
+impl<'t> TokenStreamIter<'t> {
fn new(stream: &'t TokenStream) -> Self {
- RefTokenTreeCursor { stream, index: 0 }
+ TokenStreamIter { stream, index: 0 }
}
- pub fn look_ahead(&self, n: usize) -> Option<&TokenTree> {
- self.stream.0.get(self.index + n)
+ // Peeking could be done via `Peekable`, but most iterators need peeking,
+ // and this is simple and avoids the need to use `peekable` and `Peekable`
+ // at all the use sites.
+ pub fn peek(&self) -> Option<&'t TokenTree> {
+ self.stream.0.get(self.index)
}
}
-impl<'t> Iterator for RefTokenTreeCursor<'t> {
+impl<'t> Iterator for TokenStreamIter<'t> {
type Item = &'t TokenTree;
fn next(&mut self) -> Option<&'t TokenTree> {
@@ -695,36 +891,101 @@ impl<'t> Iterator for RefTokenTreeCursor<'t> {
}
}
-/// Owning by-value iterator over a [`TokenStream`], that produces `&TokenTree`
-/// items.
-///
-/// Doesn't impl `Iterator` because Rust doesn't permit an owning iterator to
-/// return `&T` from `next`; the need for an explicit lifetime in the `Item`
-/// associated type gets in the way. Instead, use `next_ref` (which doesn't
-/// involve associated types) for getting individual elements, or
-/// `RefTokenTreeCursor` if you really want an `Iterator`, e.g. in a `for`
-/// loop.
#[derive(Clone, Debug)]
pub struct TokenTreeCursor {
- pub stream: TokenStream,
+ stream: TokenStream,
+ /// Points to the current token tree in the stream. In `TokenCursor::curr`,
+ /// this can be any token tree. In `TokenCursor::stack`, this is always a
+ /// `TokenTree::Delimited`.
index: usize,
}
impl TokenTreeCursor {
- fn new(stream: TokenStream) -> Self {
+ #[inline]
+ pub fn new(stream: TokenStream) -> Self {
TokenTreeCursor { stream, index: 0 }
}
#[inline]
- pub fn next_ref(&mut self) -> Option<&TokenTree> {
- self.stream.0.get(self.index).map(|tree| {
- self.index += 1;
- tree
- })
+ pub fn curr(&self) -> Option<&TokenTree> {
+ self.stream.get(self.index)
}
pub fn look_ahead(&self, n: usize) -> Option<&TokenTree> {
- self.stream.0.get(self.index + n)
+ self.stream.get(self.index + n)
+ }
+
+ #[inline]
+ pub fn bump(&mut self) {
+ self.index += 1;
+ }
+}
+
+/// A `TokenStream` cursor that produces `Token`s. It's a bit odd that
+/// we (a) lex tokens into a nice tree structure (`TokenStream`), and then (b)
+/// use this type to emit them as a linear sequence. But a linear sequence is
+/// what the parser expects, for the most part.
+#[derive(Clone, Debug)]
+pub struct TokenCursor {
+ // Cursor for the current (innermost) token stream. The index within the
+ // cursor can point to any token tree in the stream (or one past the end).
+ // The delimiters for this token stream are found in `self.stack.last()`;
+ // if that is `None` we are in the outermost token stream which never has
+ // delimiters.
+ pub curr: TokenTreeCursor,
+
+ // Token streams surrounding the current one. The index within each cursor
+ // always points to a `TokenTree::Delimited`.
+ pub stack: Vec<TokenTreeCursor>,
+}
+
+impl TokenCursor {
+ pub fn next(&mut self) -> (Token, Spacing) {
+ self.inlined_next()
+ }
+
+ /// This always-inlined version should only be used on hot code paths.
+ #[inline(always)]
+ pub fn inlined_next(&mut self) -> (Token, Spacing) {
+ loop {
+ // FIXME: we currently don't return `Delimiter::Invisible` open/close delims. To fix
+ // #67062 we will need to, whereupon the `delim != Delimiter::Invisible` conditions
+ // below can be removed.
+ if let Some(tree) = self.curr.curr() {
+ match tree {
+ &TokenTree::Token(token, spacing) => {
+ debug_assert!(!token.kind.is_delim());
+ let res = (token, spacing);
+ self.curr.bump();
+ return res;
+ }
+ &TokenTree::Delimited(sp, spacing, delim, ref tts) => {
+ let trees = TokenTreeCursor::new(tts.clone());
+ self.stack.push(mem::replace(&mut self.curr, trees));
+ if !delim.skip() {
+ return (Token::new(delim.as_open_token_kind(), sp.open), spacing.open);
+ }
+ // No open delimiter to return; continue on to the next iteration.
+ }
+ };
+ } else if let Some(parent) = self.stack.pop() {
+ // We have exhausted this token stream. Move back to its parent token stream.
+ let Some(&TokenTree::Delimited(span, spacing, delim, _)) = parent.curr() else {
+ panic!("parent should be Delimited")
+ };
+ self.curr = parent;
+ self.curr.bump(); // move past the `Delimited`
+ if !delim.skip() {
+ return (Token::new(delim.as_close_token_kind(), span.close), spacing.close);
+ }
+ // No close delimiter to return; continue on to the next iteration.
+ } else {
+ // We have exhausted the outermost token stream. The use of
+ // `Spacing::Alone` is arbitrary and immaterial, because the
+ // `Eof` token's spacing is never used.
+ return (Token::new(token::Eof, DUMMY_SP), Spacing::Alone);
+ }
+ }
}
}
@@ -767,12 +1028,14 @@ impl DelimSpacing {
// Some types are used a lot. Make sure they don't unintentionally get bigger.
#[cfg(target_pointer_width = "64")]
mod size_asserts {
- use super::*;
use rustc_data_structures::static_assert_size;
+
+ use super::*;
// tidy-alphabetical-start
static_assert_size!(AttrTokenStream, 8);
static_assert_size!(AttrTokenTree, 32);
static_assert_size!(LazyAttrTokenStream, 8);
+ static_assert_size!(LazyAttrTokenStreamInner, 88);
static_assert_size!(Option<LazyAttrTokenStream>, 8); // must be small, used in many AST nodes
static_assert_size!(TokenStream, 8);
static_assert_size!(TokenTree, 32);
diff --git a/compiler/rustc_ast/src/util/classify.rs b/compiler/rustc_ast/src/util/classify.rs
index 1a80a9ccdbf54..989ebe14bf8fc 100644
--- a/compiler/rustc_ast/src/util/classify.rs
+++ b/compiler/rustc_ast/src/util/classify.rs
@@ -108,6 +108,7 @@ pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
Assign(e, _, _)
| AssignOp(_, e, _)
| Await(e, _)
+ | Use(e, _)
| Binary(_, e, _)
| Call(e, _)
| Cast(e, _)
@@ -152,6 +153,7 @@ pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
| Underscore
| Yeet(..)
| Yield(..)
+ | UnsafeBinderCast(..)
| Err(..)
| Dummy => return false,
}
@@ -180,11 +182,14 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
| Range(_, Some(e), _)
| Ret(Some(e))
| Unary(_, e)
- | Yield(Some(e))
| Yeet(Some(e))
| Become(e) => {
expr = e;
}
+ Yield(kind) => match kind.expr() {
+ Some(e) => expr = e,
+ None => break None,
+ },
Closure(closure) => {
expr = &closure.body;
}
@@ -215,7 +220,6 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
Break(_, None)
| Range(_, None, _)
| Ret(None)
- | Yield(None)
| Array(_)
| Call(_, _)
| MethodCall(_)
@@ -223,6 +227,7 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
| Lit(_)
| Type(_, _)
| Await(_, _)
+ | Use(_, _)
| Field(_, _)
| Index(_, _, _)
| Underscore
@@ -232,8 +237,11 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
| Paren(_)
| Try(_)
| Yeet(None)
+ | UnsafeBinderCast(..)
| Err(_)
- | Dummy => break None,
+ | Dummy => {
+ break None;
+ }
}
}
}
@@ -247,10 +255,16 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
break (mac.args.delim == Delimiter::Brace).then_some(mac);
}
- ast::TyKind::Ptr(mut_ty) | ast::TyKind::Ref(_, mut_ty) => {
+ ast::TyKind::Ptr(mut_ty)
+ | ast::TyKind::Ref(_, mut_ty)
+ | ast::TyKind::PinnedRef(_, mut_ty) => {
ty = &mut_ty.ty;
}
+ ast::TyKind::UnsafeBinder(binder) => {
+ ty = &binder.inner_ty;
+ }
+
ast::TyKind::BareFn(fn_ty) => match &fn_ty.decl.output {
ast::FnRetTy::Default(_) => break None,
ast::FnRetTy::Ty(ret) => ty = ret,
@@ -263,7 +277,7 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
ast::TyKind::TraitObject(bounds, _) | ast::TyKind::ImplTrait(_, bounds) => {
match bounds.last() {
- Some(ast::GenericBound::Trait(bound, _)) => {
+ Some(ast::GenericBound::Trait(bound)) => {
match path_return_type(&bound.trait_ref.path) {
Some(trailing_ty) => ty = trailing_ty,
None => break None,
@@ -287,12 +301,6 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
| ast::TyKind::Pat(..)
| ast::TyKind::Dummy
| ast::TyKind::Err(..) => break None,
-
- // These end in brace, but cannot occur in a let-else statement.
- // They are only parsed as fields of a data structure. For the
- // purpose of denying trailing braces in the expression of a
- // let-else, we can disregard these.
- ast::TyKind::AnonStruct(..) | ast::TyKind::AnonUnion(..) => break None,
}
}
}
diff --git a/compiler/rustc_ast/src/util/comments.rs b/compiler/rustc_ast/src/util/comments.rs
index cbc1afc6bf1e8..e12818623d8ec 100644
--- a/compiler/rustc_ast/src/util/comments.rs
+++ b/compiler/rustc_ast/src/util/comments.rs
@@ -1,6 +1,7 @@
-use crate::token::CommentKind;
use rustc_span::{BytePos, Symbol};
+use crate::token::CommentKind;
+
#[cfg(test)]
mod tests;
@@ -38,7 +39,7 @@ pub fn beautify_doc_string(data: Symbol, kind: CommentKind) -> Symbol {
let mut i = 0;
let mut j = lines.len();
// first line of all-stars should be omitted
- if !lines.is_empty() && lines[0].chars().all(|c| c == '*') {
+ if lines.first().is_some_and(|line| line.chars().all(|c| c == '*')) {
i += 1;
}
@@ -96,7 +97,7 @@ pub fn beautify_doc_string(data: Symbol, kind: CommentKind) -> Symbol {
return None;
}
}
- if lines.is_empty() { None } else { Some(lines[0][..i].into()) }
+ Some(lines.first()?[..i].to_string())
}
let data_s = data.as_str();
diff --git a/compiler/rustc_ast/src/util/comments/tests.rs b/compiler/rustc_ast/src/util/comments/tests.rs
index 11d50603a1011..7a87ccea62a7e 100644
--- a/compiler/rustc_ast/src/util/comments/tests.rs
+++ b/compiler/rustc_ast/src/util/comments/tests.rs
@@ -1,6 +1,9 @@
-use super::*;
+#![allow(rustc::symbol_intern_string_literal)]
+
use rustc_span::create_default_session_globals_then;
+use super::*;
+
#[test]
fn test_block_doc_comment_1() {
create_default_session_globals_then(|| {
diff --git a/compiler/rustc_ast/src/util/literal.rs b/compiler/rustc_ast/src/util/literal.rs
index cb73b7908c2e7..b8526cf9d9529 100644
--- a/compiler/rustc_ast/src/util/literal.rs
+++ b/compiler/rustc_ast/src/util/literal.rs
@@ -1,15 +1,16 @@
//! Code related to parsing literals.
-use crate::ast::{self, LitKind, MetaItemLit, StrStyle};
-use crate::token::{self, Token};
-use rustc_lexer::unescape::{
- byte_from_char, unescape_byte, unescape_char, unescape_mixed, unescape_unicode, MixedUnit, Mode,
-};
-use rustc_span::symbol::{kw, sym, Symbol};
-use rustc_span::Span;
use std::{ascii, fmt, str};
+
+use rustc_literal_escaper::{
+ MixedUnit, Mode, byte_from_char, unescape_byte, unescape_char, unescape_mixed, unescape_unicode,
+};
+use rustc_span::{Span, Symbol, kw, sym};
use tracing::debug;
+use crate::ast::{self, LitKind, MetaItemLit, StrStyle};
+use crate::token::{self, Token};
+
// Escapes a string, represented as a symbol. Reuses the original symbol,
// avoiding interning, if no changes are required.
pub fn escape_string_symbol(symbol: Symbol) -> Symbol {
@@ -120,7 +121,7 @@ impl LitKind {
}
token::ByteStrRaw(n) => {
// Raw strings have no escapes so we can convert the symbol
- // directly to a `Lrc<u8>`.
+ // directly to a `Arc<u8>`.
let buf = symbol.as_str().to_owned().into_bytes();
LitKind::ByteStr(buf.into(), StrStyle::Raw(n))
}
@@ -141,7 +142,7 @@ impl LitKind {
}
token::CStrRaw(n) => {
// Raw strings have no escapes so we can convert the symbol
- // directly to a `Lrc<u8>` after appending the terminating NUL
+ // directly to a `Arc<u8>` after appending the terminating NUL
// char.
let mut buf = symbol.as_str().to_owned().into_bytes();
buf.push(0);
diff --git a/compiler/rustc_ast/src/util/parser.rs b/compiler/rustc_ast/src/util/parser.rs
index ad92bf2cd4071..1e5f414fae1c7 100644
--- a/compiler/rustc_ast/src/util/parser.rs
+++ b/compiler/rustc_ast/src/util/parser.rs
@@ -1,58 +1,21 @@
-use crate::ast::{self, BinOpKind};
-use crate::token::{self, BinOpToken, Token};
-use rustc_span::symbol::kw;
+use rustc_span::kw;
-/// Associative operator with precedence.
-///
-/// This is the enum which specifies operator precedence and fixity to the parser.
+use crate::ast::{self, AssignOpKind, BinOpKind, RangeLimits};
+use crate::token::{self, Token};
+
+/// Associative operator.
#[derive(Copy, Clone, PartialEq, Debug)]
pub enum AssocOp {
- /// `+`
- Add,
- /// `-`
- Subtract,
- /// `*`
- Multiply,
- /// `/`
- Divide,
- /// `%`
- Modulus,
- /// `&&`
- LAnd,
- /// `||`
- LOr,
- /// `^`
- BitXor,
- /// `&`
- BitAnd,
- /// `|`
- BitOr,
- /// `<<`
- ShiftLeft,
- /// `>>`
- ShiftRight,
- /// `==`
- Equal,
- /// `<`
- Less,
- /// `<=`
- LessEqual,
- /// `!=`
- NotEqual,
- /// `>`
- Greater,
- /// `>=`
- GreaterEqual,
+ /// A binary op.
+ Binary(BinOpKind),
+ /// `?=` where ? is one of the assignable BinOps
+ AssignOp(AssignOpKind),
/// `=`
Assign,
- /// `?=` where ? is one of the BinOpToken
- AssignOp(BinOpToken),
/// `as`
- As,
- /// `..` range
- DotDot,
- /// `..=` range
- DotDotEq,
+ Cast,
+ /// `..` or `..=` range
+ Range(RangeLimits),
}
#[derive(PartialEq, Debug)]
@@ -66,82 +29,57 @@ pub enum Fixity {
}
impl AssocOp {
- /// Creates a new AssocOP from a token
+ /// Creates a new AssocOp from a token.
pub fn from_token(t: &Token) -> Option<AssocOp> {
use AssocOp::*;
match t.kind {
- token::BinOpEq(k) => Some(AssignOp(k)),
token::Eq => Some(Assign),
- token::BinOp(BinOpToken::Star) => Some(Multiply),
- token::BinOp(BinOpToken::Slash) => Some(Divide),
- token::BinOp(BinOpToken::Percent) => Some(Modulus),
- token::BinOp(BinOpToken::Plus) => Some(Add),
- token::BinOp(BinOpToken::Minus) => Some(Subtract),
- token::BinOp(BinOpToken::Shl) => Some(ShiftLeft),
- token::BinOp(BinOpToken::Shr) => Some(ShiftRight),
- token::BinOp(BinOpToken::And) => Some(BitAnd),
- token::BinOp(BinOpToken::Caret) => Some(BitXor),
- token::BinOp(BinOpToken::Or) => Some(BitOr),
- token::Lt => Some(Less),
- token::Le => Some(LessEqual),
- token::Ge => Some(GreaterEqual),
- token::Gt => Some(Greater),
- token::EqEq => Some(Equal),
- token::Ne => Some(NotEqual),
- token::AndAnd => Some(LAnd),
- token::OrOr => Some(LOr),
- token::DotDot => Some(DotDot),
- token::DotDotEq => Some(DotDotEq),
+ token::Plus => Some(Binary(BinOpKind::Add)),
+ token::Minus => Some(Binary(BinOpKind::Sub)),
+ token::Star => Some(Binary(BinOpKind::Mul)),
+ token::Slash => Some(Binary(BinOpKind::Div)),
+ token::Percent => Some(Binary(BinOpKind::Rem)),
+ token::Caret => Some(Binary(BinOpKind::BitXor)),
+ token::And => Some(Binary(BinOpKind::BitAnd)),
+ token::Or => Some(Binary(BinOpKind::BitOr)),
+ token::Shl => Some(Binary(BinOpKind::Shl)),
+ token::Shr => Some(Binary(BinOpKind::Shr)),
+ token::PlusEq => Some(AssignOp(AssignOpKind::AddAssign)),
+ token::MinusEq => Some(AssignOp(AssignOpKind::SubAssign)),
+ token::StarEq => Some(AssignOp(AssignOpKind::MulAssign)),
+ token::SlashEq => Some(AssignOp(AssignOpKind::DivAssign)),
+ token::PercentEq => Some(AssignOp(AssignOpKind::RemAssign)),
+ token::CaretEq => Some(AssignOp(AssignOpKind::BitXorAssign)),
+ token::AndEq => Some(AssignOp(AssignOpKind::BitAndAssign)),
+ token::OrEq => Some(AssignOp(AssignOpKind::BitOrAssign)),
+ token::ShlEq => Some(AssignOp(AssignOpKind::ShlAssign)),
+ token::ShrEq => Some(AssignOp(AssignOpKind::ShrAssign)),
+ token::Lt => Some(Binary(BinOpKind::Lt)),
+ token::Le => Some(Binary(BinOpKind::Le)),
+ token::Ge => Some(Binary(BinOpKind::Ge)),
+ token::Gt => Some(Binary(BinOpKind::Gt)),
+ token::EqEq => Some(Binary(BinOpKind::Eq)),
+ token::Ne => Some(Binary(BinOpKind::Ne)),
+ token::AndAnd => Some(Binary(BinOpKind::And)),
+ token::OrOr => Some(Binary(BinOpKind::Or)),
+ token::DotDot => Some(Range(RangeLimits::HalfOpen)),
// DotDotDot is no longer supported, but we need some way to display the error
- token::DotDotDot => Some(DotDotEq),
+ token::DotDotEq | token::DotDotDot => Some(Range(RangeLimits::Closed)),
// `<-` should probably be `< -`
- token::LArrow => Some(Less),
- _ if t.is_keyword(kw::As) => Some(As),
+ token::LArrow => Some(Binary(BinOpKind::Lt)),
+ _ if t.is_keyword(kw::As) => Some(Cast),
_ => None,
}
}
- /// Creates a new AssocOp from ast::BinOpKind.
- pub fn from_ast_binop(op: BinOpKind) -> Self {
- use AssocOp::*;
- match op {
- BinOpKind::Lt => Less,
- BinOpKind::Gt => Greater,
- BinOpKind::Le => LessEqual,
- BinOpKind::Ge => GreaterEqual,
- BinOpKind::Eq => Equal,
- BinOpKind::Ne => NotEqual,
- BinOpKind::Mul => Multiply,
- BinOpKind::Div => Divide,
- BinOpKind::Rem => Modulus,
- BinOpKind::Add => Add,
- BinOpKind::Sub => Subtract,
- BinOpKind::Shl => ShiftLeft,
- BinOpKind::Shr => ShiftRight,
- BinOpKind::BitAnd => BitAnd,
- BinOpKind::BitXor => BitXor,
- BinOpKind::BitOr => BitOr,
- BinOpKind::And => LAnd,
- BinOpKind::Or => LOr,
- }
- }
-
/// Gets the precedence of this operator
- pub fn precedence(&self) -> usize {
+ pub fn precedence(&self) -> ExprPrecedence {
use AssocOp::*;
match *self {
- As => 14,
- Multiply | Divide | Modulus => 13,
- Add | Subtract => 12,
- ShiftLeft | ShiftRight => 11,
- BitAnd => 10,
- BitXor => 9,
- BitOr => 8,
- Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => 7,
- LAnd => 6,
- LOr => 5,
- DotDot | DotDotEq => 4,
- Assign | AssignOp(_) => 2,
+ Cast => ExprPrecedence::Cast,
+ Binary(bin_op) => bin_op.precedence(),
+ Range(_) => ExprPrecedence::Range,
+ Assign | AssignOp(_) => ExprPrecedence::Assign,
}
}
@@ -151,21 +89,17 @@ impl AssocOp {
// NOTE: it is a bug to have an operators that has same precedence but different fixities!
match *self {
Assign | AssignOp(_) => Fixity::Right,
- As | Multiply | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd
- | BitXor | BitOr | Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual
- | LAnd | LOr => Fixity::Left,
- DotDot | DotDotEq => Fixity::None,
+ Binary(binop) => binop.fixity(),
+ Cast => Fixity::Left,
+ Range(_) => Fixity::None,
}
}
pub fn is_comparison(&self) -> bool {
use AssocOp::*;
match *self {
- Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => true,
- Assign | AssignOp(_) | As | Multiply | Divide | Modulus | Add | Subtract
- | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr | DotDot | DotDotEq => {
- false
- }
+ Binary(binop) => binop.is_comparison(),
+ Assign | AssignOp(_) | Cast | Range(_) => false,
}
}
@@ -173,34 +107,7 @@ impl AssocOp {
use AssocOp::*;
match *self {
Assign | AssignOp(_) => true,
- Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | As | Multiply
- | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor
- | BitOr | LAnd | LOr | DotDot | DotDotEq => false,
- }
- }
-
- pub fn to_ast_binop(&self) -> Option<BinOpKind> {
- use AssocOp::*;
- match *self {
- Less => Some(BinOpKind::Lt),
- Greater => Some(BinOpKind::Gt),
- LessEqual => Some(BinOpKind::Le),
- GreaterEqual => Some(BinOpKind::Ge),
- Equal => Some(BinOpKind::Eq),
- NotEqual => Some(BinOpKind::Ne),
- Multiply => Some(BinOpKind::Mul),
- Divide => Some(BinOpKind::Div),
- Modulus => Some(BinOpKind::Rem),
- Add => Some(BinOpKind::Add),
- Subtract => Some(BinOpKind::Sub),
- ShiftLeft => Some(BinOpKind::Shl),
- ShiftRight => Some(BinOpKind::Shr),
- BitAnd => Some(BinOpKind::BitAnd),
- BitXor => Some(BinOpKind::BitXor),
- BitOr => Some(BinOpKind::BitOr),
- LAnd => Some(BinOpKind::And),
- LOr => Some(BinOpKind::Or),
- Assign | AssignOp(_) | As | DotDot | DotDotEq => None,
+ Cast | Binary(_) | Range(_) => false,
}
}
@@ -210,156 +117,64 @@ impl AssocOp {
/// parentheses while having a high degree of confidence on the correctness of the suggestion.
pub fn can_continue_expr_unambiguously(&self) -> bool {
use AssocOp::*;
+ use BinOpKind::*;
matches!(
self,
- BitXor | // `{ 42 } ^ 3`
Assign | // `{ 42 } = { 42 }`
- Divide | // `{ 42 } / 42`
- Modulus | // `{ 42 } % 2`
- ShiftRight | // `{ 42 } >> 2`
- LessEqual | // `{ 42 } <= 3`
- Greater | // `{ 42 } > 3`
- GreaterEqual | // `{ 42 } >= 3`
+ Binary(
+ BitXor | // `{ 42 } ^ 3`
+ Div | // `{ 42 } / 42`
+ Rem | // `{ 42 } % 2`
+ Shr | // `{ 42 } >> 2`
+ Le | // `{ 42 } <= 3`
+ Gt | // `{ 42 } > 3`
+ Ge // `{ 42 } >= 3`
+ ) |
AssignOp(_) | // `{ 42 } +=`
// Equal | // `{ 42 } == { 42 }` Accepting these here would regress incorrect
// NotEqual | // `{ 42 } != { 42 } struct literals parser recovery.
- As // `{ 42 } as usize`
+ Cast // `{ 42 } as usize`
)
}
}
-pub const PREC_CLOSURE: i8 = -40;
-pub const PREC_JUMP: i8 = -30;
-pub const PREC_RANGE: i8 = -10;
-// The range 2..=14 is reserved for AssocOp binary operator precedences.
-pub const PREC_PREFIX: i8 = 50;
-pub const PREC_UNAMBIGUOUS: i8 = 60;
-pub const PREC_FORCE_PAREN: i8 = 100;
-
-#[derive(Debug, Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, PartialOrd)]
pub enum ExprPrecedence {
- Closure,
- Break,
- Continue,
- Ret,
- Yield,
- Yeet,
- Become,
-
+ // return, break, yield, closures
+ Jump,
+ // = += -= *= /= %= &= |= ^= <<= >>=
+ Assign,
+ // .. ..=
Range,
-
- Binary(BinOpKind),
-
+ // ||
+ LOr,
+ // &&
+ LAnd,
+ // == != < > <= >=
+ Compare,
+ // |
+ BitOr,
+ // ^
+ BitXor,
+ // &
+ BitAnd,
+ // << >>
+ Shift,
+ // + -
+ Sum,
+ // * / %
+ Product,
+ // as
Cast,
-
- Assign,
- AssignOp,
-
- AddrOf,
- Let,
- Unary,
-
- Call,
- MethodCall,
- Field,
- Index,
- Try,
- InlineAsm,
- OffsetOf,
- Mac,
- FormatArgs,
-
- Array,
- Repeat,
- Tup,
- Lit,
- Path,
- Paren,
- If,
- While,
- ForLoop,
- Loop,
- Match,
- PostfixMatch,
- ConstBlock,
- Block,
- TryBlock,
- Struct,
- Gen,
- Await,
- Err,
-}
-
-impl ExprPrecedence {
- pub fn order(self) -> i8 {
- match self {
- ExprPrecedence::Closure => PREC_CLOSURE,
-
- ExprPrecedence::Break
- | ExprPrecedence::Continue
- | ExprPrecedence::Ret
- | ExprPrecedence::Yield
- | ExprPrecedence::Yeet
- | ExprPrecedence::Become => PREC_JUMP,
-
- // `Range` claims to have higher precedence than `Assign`, but `x .. x = x` fails to
- // parse, instead of parsing as `(x .. x) = x`. Giving `Range` a lower precedence
- // ensures that `pprust` will add parentheses in the right places to get the desired
- // parse.
- ExprPrecedence::Range => PREC_RANGE,
-
- // Binop-like expr kinds, handled by `AssocOp`.
- ExprPrecedence::Binary(op) => AssocOp::from_ast_binop(op).precedence() as i8,
- ExprPrecedence::Cast => AssocOp::As.precedence() as i8,
-
- ExprPrecedence::Assign |
- ExprPrecedence::AssignOp => AssocOp::Assign.precedence() as i8,
-
- // Unary, prefix
- ExprPrecedence::AddrOf
- // Here `let pats = expr` has `let pats =` as a "unary" prefix of `expr`.
- // However, this is not exactly right. When `let _ = a` is the LHS of a binop we
- // need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
- // but we need to print `(let _ = a) < b` as-is with parens.
- | ExprPrecedence::Let
- | ExprPrecedence::Unary => PREC_PREFIX,
-
- // Never need parens
- ExprPrecedence::Array
- | ExprPrecedence::Await
- | ExprPrecedence::Block
- | ExprPrecedence::Call
- | ExprPrecedence::ConstBlock
- | ExprPrecedence::Field
- | ExprPrecedence::ForLoop
- | ExprPrecedence::FormatArgs
- | ExprPrecedence::Gen
- | ExprPrecedence::If
- | ExprPrecedence::Index
- | ExprPrecedence::InlineAsm
- | ExprPrecedence::Lit
- | ExprPrecedence::Loop
- | ExprPrecedence::Mac
- | ExprPrecedence::Match
- | ExprPrecedence::MethodCall
- | ExprPrecedence::OffsetOf
- | ExprPrecedence::Paren
- | ExprPrecedence::Path
- | ExprPrecedence::PostfixMatch
- | ExprPrecedence::Repeat
- | ExprPrecedence::Struct
- | ExprPrecedence::Try
- | ExprPrecedence::TryBlock
- | ExprPrecedence::Tup
- | ExprPrecedence::While
- | ExprPrecedence::Err => PREC_UNAMBIGUOUS,
- }
- }
+ // unary - * ! & &mut
+ Prefix,
+ // paths, loops, function calls, array indexing, field expressions, method calls
+ Unambiguous,
}
/// In `let p = e`, operators with precedence `<=` this one requires parentheses in `e`.
-pub fn prec_let_scrutinee_needs_par() -> usize {
- AssocOp::LAnd.precedence()
+pub fn prec_let_scrutinee_needs_par() -> ExprPrecedence {
+ ExprPrecedence::LAnd
}
/// Suppose we have `let _ = e` and the `order` of `e`.
@@ -367,8 +182,8 @@ pub fn prec_let_scrutinee_needs_par() -> usize {
///
/// Conversely, suppose that we have `(let _ = a) OP b` and `order` is that of `OP`.
/// Can we print this as `let _ = a OP b`?
-pub fn needs_par_as_let_scrutinee(order: i8) -> bool {
- order <= prec_let_scrutinee_needs_par() as i8
+pub fn needs_par_as_let_scrutinee(order: ExprPrecedence) -> bool {
+ order <= prec_let_scrutinee_needs_par()
}
/// Expressions that syntactically contain an "exterior" struct literal i.e., not surrounded by any
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index f6929057bed13..69a186c8cf1b7 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -13,19 +13,18 @@
//! instance, a walker looking for item names in a module will miss all of
//! those that are created by the expansion of a macro.
-use crate::ast::*;
-use crate::ptr::P;
-
-use rustc_span::symbol::Ident;
-use rustc_span::Span;
-
pub use rustc_ast_ir::visit::VisitorResult;
pub use rustc_ast_ir::{try_visit, visit_opt, walk_list, walk_visitable_list};
+use rustc_span::{Ident, Span};
+use thin_vec::ThinVec;
+
+use crate::ast::*;
+use crate::ptr::P;
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum AssocCtxt {
Trait,
- Impl,
+ Impl { of_trait: bool },
}
#[derive(Copy, Clone, Debug, PartialEq)]
@@ -67,31 +66,31 @@ impl BoundKind {
#[derive(Copy, Clone, Debug)]
pub enum FnKind<'a> {
/// E.g., `fn foo()`, `fn foo(&self)`, or `extern "Abi" fn foo()`.
- Fn(FnCtxt, Ident, &'a FnSig, &'a Visibility, &'a Generics, Option<&'a Block>),
+ Fn(FnCtxt, &'a Visibility, &'a Fn),
/// E.g., `|x, y| body`.
- Closure(&'a ClosureBinder, &'a FnDecl, &'a Expr),
+ Closure(&'a ClosureBinder, &'a Option<CoroutineKind>, &'a FnDecl, &'a Expr),
}
impl<'a> FnKind<'a> {
pub fn header(&self) -> Option<&'a FnHeader> {
match *self {
- FnKind::Fn(_, _, sig, _, _, _) => Some(&sig.header),
- FnKind::Closure(_, _, _) => None,
+ FnKind::Fn(_, _, Fn { sig, .. }) => Some(&sig.header),
+ FnKind::Closure(..) => None,
}
}
pub fn ident(&self) -> Option<&Ident> {
match self {
- FnKind::Fn(_, ident, ..) => Some(ident),
+ FnKind::Fn(_, _, Fn { ident, .. }) => Some(ident),
_ => None,
}
}
pub fn decl(&self) -> &'a FnDecl {
match self {
- FnKind::Fn(_, _, sig, _, _, _) => &sig.decl,
- FnKind::Closure(_, decl, _) => decl,
+ FnKind::Fn(_, _, Fn { sig, .. }) => &sig.decl,
+ FnKind::Closure(_, _, decl, _) => decl,
}
}
@@ -113,11 +112,14 @@ pub enum LifetimeCtxt {
GenericArg,
}
-pub trait WalkItemKind: Sized {
+pub trait WalkItemKind {
+ type Ctxt;
fn walk<'a, V: Visitor<'a>>(
&'a self,
- item: &'a Item<Self>,
- ctxt: AssocCtxt,
+ span: Span,
+ id: NodeId,
+ visibility: &'a Visibility,
+ ctxt: Self::Ctxt,
visitor: &mut V,
) -> V::Result;
}
@@ -136,7 +138,7 @@ pub trait Visitor<'ast>: Sized {
/// or `ControlFlow<T>`.
type Result: VisitorResult = ();
- fn visit_ident(&mut self, _ident: Ident) -> Self::Result {
+ fn visit_ident(&mut self, _ident: &'ast Ident) -> Self::Result {
Self::Result::output()
}
fn visit_foreign_item(&mut self, i: &'ast ForeignItem) -> Self::Result {
@@ -174,12 +176,12 @@ pub trait Visitor<'ast>: Sized {
fn visit_method_receiver_expr(&mut self, ex: &'ast Expr) -> Self::Result {
self.visit_expr(ex)
}
- fn visit_expr_post(&mut self, _ex: &'ast Expr) -> Self::Result {
- Self::Result::output()
- }
fn visit_ty(&mut self, t: &'ast Ty) -> Self::Result {