[ { "path": ".cargo/config.toml", "content": "[alias]\nbuild-man = \"run --package xtask-build-man --\"\nstale-label = \"run --package xtask-stale-label --\"\nbump-check = \"run --package xtask-bump-check --\"\nlint-docs = \"run --package xtask-lint-docs --\"\nspellcheck = \"run --package xtask-spellcheck --\"\n\n[env]\n# HACK: Until this is stabilized, `snapbox`s polyfill could get confused\n# inside of the rust-lang/rust repo because it looks for the furthest-away `Cargo.toml`\nCARGO_RUSTC_CURRENT_DIR = { value = \"\", relative = true }\n" }, { "path": ".git-blame-ignore-revs", "content": "# Use `git config blame.ignorerevsfile .git-blame-ignore-revs` to make `git blame` ignore the following commits.\n\n# refactor: rustfmt for tracing\ne84cc17db6ac48620e2723f51bce0703f5590060\n# Rustfmt with latest nightly.\n43c253e69a20321cdfd73d632fa5ec641b1aace3\n# reformat with rustfmt\ndf62c36b214449003997d8ee630c7d5c1c08a90c\n# rustfmt\nc973a6d0af55785f3072623b4d29127051a84b90\n# Apply rustfmt\nebd0d58c1c11f98e804c80b3378d00f9e1000a95\n# rustfmt\n4787dd3acfb32c6d608342bca115094e1ed866e7\n# Fix for rustfmt\nad44f0e898721f35173b59f32dae344b964dff22\n# rustfmt\nb9554f37abe4f802dd615a550773105a8b2eb386\n# Normalize raw string indentation.\n6f8c7d5a87526d10e3bbfa4098a1002076386068\n# rustfmt\ndcae5fcf2dc6e040d1cadac14276fd306c058b74\n# Rustfmt\n0dfdba6f7a7702a7f45d523b028c896084411de8\n# Run rustfmt\ne06a911de616b3f402f1e142b5202445d333f4eb\n# rustfmt\nd02f476804ae73d79059e3243ecb4c814f53bea1\n# Update for nightly rustfmt.\n4b6c26dd16786b416190bd0a36e7646d33b9846a\n# Run rustfmt\nd0430dd2b11e6ac004e8f39a712ee6425b81e12d\n# Run rustfmt\nc56cb4287fa98a42dafea36d0b88bb4441f63c1f\n# Run rustfmt\nc3f8cd3cd2999949c49c8f0e76108ffe7a37bec0\n# Run code through rustfmt\n648b39e98101f9b6417fc6ebc88fa7f397a5f509\n# Run rustfmt\nba81441f297c6d9799473a62af021236b8bc9ed8\n# Wrap some really long lines.\nd6d15141f8ef21f1cebeaa4d42606f29e7d00239\n# rustfmt for nightly changes.\n384c311692e6ff537b51bcf57f804b917a702c9c\n# Rustfmt lint\n9dc70a3dabb291052a4d117b8348c9b461d1b570\n# Run rustfmt\n3a6cd74434cc1fdd57266740d4827ed162580005\n# rustfmt, even if I disagree\n189fef1173118ee3be47fa59e22fd2d21bb05bbd\n# Fix zalgo formatting.\n56f8848a51e5db5214ec27bb41c7d99ebac21af8\n# Rustfmt adjustments\na50be59a70af64b83c07f40bc2faef80a73bc908\n# Run rustfmt\nebd10526f3526b695872a8ecb381f65aaf74c019\n# Rustfmt fixes\nac2a4382ee5d927d917df026d2236ff5cd668717\n# Rustfmt fixes\nfc4ee774483dc6b40f1edbd259879dc4cbcf20a5\n# Fixed formatting with rustfmt\na82de176952f7c244adbd392d444baaafdfc819c\n# Fix some formatting for some strings.\na4e9611453cb4ba3f9bcc34f2851546f57152229\n# fix(fingerprint): rustfmt\n009876a88af659c10b022ec4c4956f77b983d531\n# Make rustfmt happy\n2415a2980f455238e9422cc07abcfa4cbec9be6b\n# run rustfmt\ndac967ce27d4eeb496dcd98ba91641fbe29df957\n# $cargo fmt --all\ndb09895f3c123c36e05175e2c0273bf487068b37\n# Reformat everything with rustfmt from stable 1.26\nd85336084d8855bfbfd431b85beaa5c094dc5e72\n# rustfmt\na4947c2b47fd38857c7332d333fda7bcc405de0c\n# rustfmt\n404970f2261e2d6c9ba4eac410065fa6226271d9\n# Prettify rustfmted single-line strings\nb0c181d91ccfe1d27d4c7133049a6bfe5bacf29b\n# cargo fmt\n1e6828485eea0f550ed7be46ef96107b46aeb162\n# rustfmt for bin/cargo.rs\nef4c09f986c0b1f701c765d894da911c2de44724\n# rustfmt cargo_doc.rs\n87124d5ade897b3fb38ce5cd0a2f19a9038dd8a7\n# run rustfmt on core/source.rs\n76fb87e2bab025acaff2d6dd919dde0e328267da\n# cargo fmt\n7a67e88baf0f73196973cadf887bf9a31c13e95f\n# cargo fmt\n7a6ff7f068acde98230d712637e934c58fc84805\n# cargo fmt\n7c8ee49bffdeeb138db5e22f14abbf88cf99c547\n# cargo fmt\n72d6c5411a215ce5ab0ff22b1e1e1525883b7c33\n# rust fmt\nddd5c83b8cf63458bf67ae504bb289ed4e987d38\n# cargo fmt\n1179e7ef6b88a6940168cbc2e806d48ed20d92ef\n# cargo fmt\n0c07056bfeffee213e21cdf1e48875f59f834282\n# cargo fmt\nc7a79be6f8a8da1d6dee54fe3f5c137d293692b0\n# cargo fmt\n1839ded4aa5607d3564f02b36e517289ad6ed8e8\n# cargo fmt\nf2b5271a09a13f89a50861ebd71da333836bded3\n# Run `cargo fmt --all`\n3aa99422ca7808f1bc5621fda3a8f32f27273d9b\n# cargo fmt\n4538ade2d55d7353cfac8a0ce320e3c4a29bc450\n# style: cargo fmt\n3d042688a851d985013ee8ff64a9caef47b7b495\n# run cargo fmt to pass the CI build\na4e3b81a55b8c142ab1b84f4f209414a72727e86\n# Run 'cargo fmt'\n60afaa77335ab464a5b6c913883ad145ae97d750\n# Run 'cargo fmt'\n511050baefa2ec21c2be8c3eaee2aade1da2c06b\n# cargo fmt\n577968e44828457dfa62fc10ccd29f42a359b746\n# cargo fmt\nd0f7c0ee31c81cd405dc2c163e4ca7638895610c\n# appease cargo fmt\nc4922052fc7470264f3df491213f74142ac67ebf\n# named-profiles: formatting fixes from 'cargo fmt'\n29b7e90ba37f311baaf448894bbf04721bed5791\n# cargo fmt\nf39302f432f62e29910c876f766eb8a324cee843\n# cargo fmt\n6b07c8da63c0896cc31fa6cb8b47a71fe29c88e2\n# run cargo fmt --all\nb48ae60e67096f7cda80a17dfa2a9ff7a916bbf7\n# $cargo fmt --all\n63a9c7aa6d54ff0580288f1a01795a29b3ea1c75\n# Run `cargo fmt`\nf16efff1509be313f4bed825e7ab974673dd03fc\n# cargo fmt tests/testsuite/rustflags.rs\n3ca98adbbac5752cdef337f5ac803e7843ab601a\n# Format with `cargo fmt`\nfecb72464328846dacd0ff8252d105b7818733ab\n# cargo fmt\n9b2295d11fd2816aa3032403a88d7c055cd2cf58\n# Run `cargo fmt`\n5d201944d7aba8380082dcb9e0c340d92e92850f\n# Correct formatting with cargo fmt\n90954d700ccb71b3df6ecf8ff83891dd3570f887\n# Correct formatting with cargo fmt\n5c241e102756e340991365d7b376997a9ae95f62\n# Fix formatting issues with cargo fmt\n5c7979cdf879a6cc9011432098f7ef68ed7f5e37\n# cargo fmt\na6ad2de0484f1910d42793f3ec73b111403099b7\n# cargo fmt\nb0fbc89c33780ca3e1f2bfeacc67922ee7abe1dc\n# Rustfmt 2024\n1ce80236261a3cd42a95b1f1abcffede87cafef4\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.yml", "content": "name: Bug Report\ndescription: Create a report to help us improve\nlabels: [\"C-bug\", \"S-triage\"]\nbody:\n - type: markdown\n attributes:\n value: Thanks for filing a šŸ› bug report šŸ˜„!\n - type: textarea\n id: problem\n attributes:\n label: Problem\n description: >\n Please provide a clear and concise description of what the bug is,\n including what currently happens and what you expected to happen.\n validations:\n required: true\n - type: textarea\n id: steps\n attributes:\n label: Steps\n description: Please list the steps to reproduce the bug.\n placeholder: |\n 1.\n 2.\n 3.\n - type: textarea\n id: possible-solutions\n attributes:\n label: Possible Solution(s)\n description: >\n Not obligatory, but suggest a fix/reason for the bug,\n or ideas how to implement the addition or change.\n - type: textarea\n id: notes\n attributes:\n label: Notes\n description: Provide any additional notes that might be helpful.\n - type: textarea\n id: version\n attributes:\n label: Version\n description: Please paste the output of running `cargo version --verbose`.\n render: text\n" }, { "path": ".github/ISSUE_TEMPLATE/config.yml", "content": "contact_links:\n - name: Question\n url: https://users.rust-lang.org\n about: >\n Got a question about Cargo? Ask the community on the user forum.\n - name: Inspiring Idea\n url: https://internals.rust-lang.org/c/tools-and-infrastructure/cargo\n about: >\n Need more discussions with your next big idea?\n Reach out the community on the internals forum.\n" }, { "path": ".github/ISSUE_TEMPLATE/feature_request.yml", "content": "name: Feature Request\ndescription: Suggest an idea for enhancing Cargo\nlabels: [\"C-feature-request\", \"S-triage\"]\nbody:\n - type: markdown\n attributes:\n value: |\n Thanks for filing a šŸ™‹ feature request šŸ˜„!\n\n If the feature request is relatively small and already with a possible solution, this might be the place for you.\n\n If you are brewing a big feature that needs feedback from the community, [the internal forum] is the best fit, especially for pre-RFC. You can also talk the idea over with other developers in [#t-cargo Zulip stream].\n\n [the internal forum]: https://internals.rust-lang.org/c/tools-and-infrastructure/cargo/15\n [#t-cargo Zulip stream]: https://rust-lang.zulipchat.com/#narrow/stream/246057-t-cargo\n - type: textarea\n id: problem\n attributes:\n label: Problem\n description: >\n Please provide a clear description of your use case and the problem\n this feature request is trying to solve.\n validations:\n required: true\n - type: textarea\n id: solution\n attributes:\n label: Proposed Solution\n description: >\n Please provide a clear and concise description of what you want to happen.\n - type: textarea\n id: notes\n attributes:\n label: Notes\n description: Provide any additional context or information that might be helpful.\n" }, { "path": ".github/ISSUE_TEMPLATE/new_lint.yml", "content": "name: New lint suggestion\ndescription: Suggest a new Cargo lint.\nlabels: [\"A-new-lint\", \"S-triage\"]\nbody:\n - type: markdown\n attributes:\n value: Thank you for your lint idea!\n - type: textarea\n id: what\n attributes:\n label: What it does\n description: What does this lint do?\n validations:\n required: true\n - type: textarea\n id: advantage\n attributes:\n label: Advantage\n description: >\n What is the advantage of the recommended code over the original code?\n placeholder: |\n - Remove bounds check inserted by ...\n - Remove the need to duplicate/store ...\n - Remove typo ...\n - type: textarea\n id: drawbacks\n attributes:\n label: Drawbacks\n description: What might be possible drawbacks of such a lint?\n - type: textarea\n id: example\n attributes:\n label: Example\n description: >\n Include a short example showing when the lint should trigger together\n with the improved code.\n value: |\n ```toml\n \n ```\n\n Could be written as:\n\n ```toml\n \n ```\n validations:\n required: true\n" }, { "path": ".github/ISSUE_TEMPLATE/tracking_issue.yml", "content": "name: Tracking Issue\ndescription: A tracking issue for an accepted feature or RFC in Cargo.\ntitle: \"Tracking Issue for _FEATURE_NAME_\"\nlabels: [\"C-tracking-issue\"]\nbody:\n - type: markdown\n attributes:\n value: >\n Thank you for creating a tracking issue! Tracking issues are for tracking an\n accepted feature or RFC from implementation to stabilization. Please do not\n file a tracking issue until the feature or RFC has been approved.\n - type: textarea\n id: summary\n attributes:\n label: Summary\n description: Please provide a very brief summary of the feature.\n value: |\n RFC: [#NNNN](https://github.com/rust-lang/rfcs/pull/NNNN) \n Original issue: #NNNN \n Implementation: #NNNN \n Documentation: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#my-feature\n\n Please enter a short, one-sentence description here.\n validations:\n required: true\n - type: textarea\n id: unresolved\n attributes:\n label: Unresolved Issues\n description: List issues that have not yet been resolved.\n placeholder: |\n * [ ] Make a list of any known implementation or design issues.\n - type: textarea\n id: future\n attributes:\n label: Future Extensions\n description: >\n An optional section where you can mention where the feature may be\n extended in the future, but is explicitly not intended to\n address.\n - type: textarea\n id: about\n attributes:\n label: About tracking issues\n description: Please include this notice in the issue.\n value: |\n Tracking issues are used to record the overall progress of implementation.\n They are also used as hubs connecting to other relevant issues, e.g., bugs or open design questions.\n A tracking issue is however *not* meant for large scale discussion, questions, or bug reports about a feature.\n Instead, open a dedicated issue for the specific matter and add the relevant feature gate label.\n" }, { "path": ".github/PULL_REQUEST_TEMPLATE.md", "content": "_Thanks for the pull request šŸŽ‰!_\n_Please read the contribution guide: ._\n\n### What does this PR try to resolve?\n\n_Explain the motivation behind this change._\n_A clear overview along with an in-depth explanation are helpful._\n\n### How to test and review this PR?\n\n_Demonstrate how you test this change and guide reviewers through your PR._\n_With a smooth review process, a pull request usually gets reviewed quicker._\n" }, { "path": ".github/renovate.json5", "content": "{\n schedule: [\n 'before 5am on the first day of the month',\n ],\n semanticCommits: 'enabled',\n configMigration: true,\n dependencyDashboard: true,\n ignorePaths: [\n '**/tests/**',\n ],\n // Ignore curl-sys, for now\n // https://github.com/rust-lang/cargo/issues/16357\n ignoreDeps: ['curl-sys'],\n customManagers: [\n {\n customType: 'regex',\n managerFilePatterns: [\n '/Cargo.toml$/',\n ],\n matchStrings: [\n '\\\\bMSRV:1\\\\b.*?(?\\\\d+\\\\.\\\\d+(\\\\.\\\\d+)?)',\n '(?\\\\d+\\\\.\\\\d+(\\\\.\\\\d+)?).*?\\\\bMSRV:1\\\\b',\n ],\n depNameTemplate: 'MSRV:1', // Support 1 version of rustc\n packageNameTemplate: 'rust-lang/rust',\n datasourceTemplate: 'github-releases',\n },\n {\n customType: 'regex',\n managerFilePatterns: [\n '/Cargo.toml$/',\n ],\n matchStrings: [\n '\\\\bMSRV:3\\\\b.*?(?\\\\d+\\\\.\\\\d+(\\\\.\\\\d+)?)',\n '(?\\\\d+\\\\.\\\\d+(\\\\.\\\\d+)?).*?\\\\bMSRV:3\\\\b',\n ],\n depNameTemplate: 'MSRV:3', // Support 3 versions of rustc\n packageNameTemplate: 'rust-lang/rust',\n datasourceTemplate: 'github-releases',\n },\n {\n customType: 'regex',\n managerFilePatterns: [\n '/^.github.workflows.main.yml$/',\n ],\n matchStrings: [\n 'cargo-semver-checks.releases.download.v(?\\\\d+\\\\.\\\\d+(\\\\.\\\\d+)?)',\n ],\n depNameTemplate: 'cargo-semver-checks',\n packageNameTemplate: 'obi1kenobi/cargo-semver-checks',\n datasourceTemplate: 'github-releases',\n },\n ],\n packageRules: [\n {\n commitMessageTopic: 'MSRV (1 version)',\n matchManagers: [\n 'custom.regex',\n ],\n matchDepNames: [\n 'MSRV:1',\n ],\n extractVersion: '^(?\\\\d+\\\\.\\\\d+)', // Drop the patch version\n schedule: [\n '* * * * *',\n ],\n groupName: 'msrv',\n },\n {\n commitMessageTopic: 'MSRV (3 versions)',\n matchManagers: [\n 'custom.regex',\n ],\n matchDepNames: [\n 'MSRV:3',\n ],\n extractVersion: '^(?\\\\d+\\\\.\\\\d+)', // Drop the patch version\n schedule: [\n '* * * * *',\n ],\n minimumReleaseAge: '85 days', // 2 releases back * 6 weeks per release * 7 days per week + 1\n internalChecksFilter: 'strict',\n groupName: 'msrv',\n },\n {\n commitMessageTopic: 'cargo-semver-checks',\n matchManagers: [\n 'custom.regex',\n ],\n matchDepNames: [\n 'cargo-semver-checks',\n ],\n extractVersion: '^v(?\\\\d+\\\\.\\\\d+\\\\.\\\\d+)',\n schedule: [\n '* * * * *',\n ],\n internalChecksFilter: 'strict',\n },\n // Goals:\n // - Rollup safe upgrades to reduce CI runner load\n // - Have lockfile and manifest in-sync (implicit rules)\n {\n matchManagers: [\n 'cargo',\n ],\n matchCurrentVersion: '>=0.1.0',\n matchUpdateTypes: [\n 'patch',\n ],\n automerge: false,\n groupName: 'compatible',\n },\n {\n matchManagers: [\n 'cargo',\n ],\n matchCurrentVersion: '>=1.0.0',\n matchUpdateTypes: [\n 'minor',\n ],\n automerge: false,\n groupName: 'compatible',\n },\n ],\n}\n" }, { "path": ".github/workflows/audit.yml", "content": "name: Security audit\n\npermissions:\n contents: read\n\non:\n pull_request:\n paths:\n - '**/Cargo.toml'\n - '**/Cargo.lock'\n push:\n branches:\n - master\n\njobs:\n cargo_deny:\n runs-on: ubuntu-latest\n strategy:\n matrix:\n checks:\n - advisories\n - bans licenses sources\n steps:\n - uses: actions/checkout@v5\n - uses: EmbarkStudios/cargo-deny-action@v2\n # Prevent sudden announcement of a new advisory from failing ci:\n continue-on-error: ${{ matrix.checks == 'advisories' }}\n with:\n command: check ${{ matrix.checks }}\n rust-version: stable\n" }, { "path": ".github/workflows/contrib.yml", "content": "name: Contrib Deploy\non:\n push:\n branches:\n - master\n\nconcurrency:\n cancel-in-progress: false\n group: \"gh-pages\"\n\npermissions:\n contents: read\n\nenv:\n MDBOOK_VERSION: 0.5.1\n\njobs:\n deploy:\n permissions:\n contents: write # for Git to git push\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n with:\n fetch-depth: 0\n - name: Install mdbook\n run: |\n mkdir mdbook\n curl -Lf https://github.com/rust-lang/mdBook/releases/download/v${MDBOOK_VERSION}/mdbook-v${MDBOOK_VERSION}-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=./mdbook\n echo `pwd`/mdbook >> $GITHUB_PATH\n - name: Deploy docs\n run: |\n GENERATE_PY=\"$(pwd)/ci/generate.py\"\n\n cd src/doc/contrib\n mdbook build\n\n # Override previous ref to avoid keeping history.\n git worktree add --orphan -B gh-pages gh-pages\n git config user.name \"Deploy from CI\"\n git config user.email \"\"\n cd gh-pages\n mv ../book contrib\n git add contrib\n\n # Generate HTML for link redirections.\n python3 \"$GENERATE_PY\"\n git add *.html\n # WARN: The CNAME file is for GitHub to redirect requests to the custom domain.\n # Missing this may entail security hazard and domain takeover.\n # See \n git add CNAME\n\n git commit -m \"Deploy $GITHUB_SHA to gh-pages\"\n git push origin +gh-pages\n" }, { "path": ".github/workflows/main.yml", "content": "name: CI\non:\n merge_group:\n pull_request:\n branches:\n - \"**\"\n\ndefaults:\n run:\n shell: bash\n\npermissions:\n contents: read\n\nconcurrency:\n group: \"${{ github.workflow }}-${{ github.ref }}\"\n cancel-in-progress: true\n\nenv:\n MDBOOK_VERSION: 0.5.1\n\njobs:\n conclusion:\n needs:\n - build_std\n - clippy\n - msrv\n - docs\n - lint-docs\n - lockfile\n - resolver\n - report-timings\n - rustfmt\n - schema\n - spellcheck\n - test\n - test_gitoxide\n permissions:\n contents: none\n # We need to ensure this job does *not* get skipped if its dependencies fail,\n # because a skipped job is considered a success by GitHub. So we have to\n # overwrite `if:`. We use `!cancelled()` to ensure the job does still not get run\n # when the workflow is canceled manually.\n #\n # ALL THE PREVIOUS JOBS NEED TO BE ADDED TO THE `needs` SECTION OF THIS JOB!\n if: ${{ !cancelled() }}\n runs-on: ubuntu-latest\n steps:\n # Manually check the status of all dependencies. `if: failure()` does not work.\n - name: Conclusion\n run: |\n # Print the dependent jobs to see them in the CI log\n jq -C <<< '${{ toJson(needs) }}'\n # Check if all jobs that we depend on (in the needs array) were successful.\n jq --exit-status 'all(.result == \"success\")' <<< '${{ toJson(needs) }}'\n\n # Check Code style quickly by running `rustfmt` over all code\n rustfmt:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update stable && rustup default stable\n - run: rustup component add rustfmt\n - run: cargo fmt --all --check\n\n # Ensure there are no clippy warnings\n clippy:\n strategy:\n matrix:\n include:\n - name: Linux x86_64\n os: ubuntu-latest\n - name: macOS aarch64\n os: macos-14\n - name: Windows x86_64 MSVC\n os: windows-latest\n name: Clippy ${{ matrix.name }}\n runs-on: ${{ matrix.os }}\n steps:\n - uses: actions/checkout@v5\n - run: rustup update stable && rustup default stable\n - run: rustup component add clippy\n - run: cargo clippy --workspace --all-targets --no-deps -- -D warnings\n\n stale-label:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update stable && rustup default stable\n - run: cargo stale-label\n\n lint-docs:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update stable && rustup default stable\n - run: cargo lint-docs --check\n\n # Ensure Cargo.lock is up-to-date\n lockfile:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update stable && rustup default stable\n - run: cargo update -p cargo --locked\n\n check-version-bump:\n runs-on: ubuntu-latest\n if: github.repository_owner == 'rust-lang'\n env:\n BASE_SHA: ${{ github.event.pull_request.base.sha }}\n HEAD_SHA: ${{ github.event.pull_request.head.sha != '' && github.event.pull_request.head.sha || github.sha }}\n steps:\n - uses: actions/checkout@v5\n with:\n fetch-depth: 0\n - run: rustup update stable && rustup default stable\n - name: Install cargo-semver-checks\n run: |\n mkdir installed-bins\n curl -Lf https://github.com/obi1kenobi/cargo-semver-checks/releases/download/v0.47.0/cargo-semver-checks-x86_64-unknown-linux-gnu.tar.gz \\\n | tar -xz --directory=./installed-bins\n echo `pwd`/installed-bins >> $GITHUB_PATH\n - run: ci/validate-version-bump.sh\n\n test:\n runs-on: ${{ matrix.os }}\n env:\n CARGO_PROFILE_DEV_DEBUG: 1\n CARGO_PROFILE_TEST_DEBUG: 1\n CARGO_INCREMENTAL: 0\n CARGO_PUBLIC_NETWORK_TESTS: 1\n # Workaround for https://github.com/rust-lang/rustup/issues/3036\n RUSTUP_WINDOWS_PATH_ADD_BIN: 0\n strategy:\n matrix:\n include:\n - name: Linux x86_64 stable\n os: ubuntu-latest\n rust: stable\n other: i686-unknown-linux-gnu\n - name: Linux x86_64 beta\n os: ubuntu-latest\n rust: beta\n other: i686-unknown-linux-gnu\n - name: Linux x86_64 nightly\n os: ubuntu-latest\n rust: nightly\n other: i686-unknown-linux-gnu\n - name: Linux aarch64 stable\n os: ubuntu-24.04-arm\n rust: stable\n other: TODO # cross-compile tests are disabled, this shouldn't matter.\n - name: Linux aarch64 nightly\n os: ubuntu-24.04-arm\n rust: nightly\n other: TODO # cross-compile tests are disabled, this shouldn't matter.\n - name: macOS aarch64 stable\n os: macos-14\n rust: stable\n other: x86_64-apple-darwin\n - name: macOS aarch64 nightly\n os: macos-14\n rust: nightly\n other: x86_64-apple-darwin\n - name: Windows x86_64 MSVC stable\n os: windows-latest\n rust: stable-msvc\n other: i686-pc-windows-msvc\n - name: Windows x86_64 MSVC nightly\n os: windows-latest\n rust: nightly-msvc\n other: i686-pc-windows-msvc\n - name: Windows aarch64 MSVC stable\n os: windows-11-arm\n rust: stable-msvc\n other: i686-pc-windows-msvc\n - name: Windows aarch64 MSVC nightly\n os: windows-11-arm\n rust: nightly-msvc\n other: i686-pc-windows-msvc\n - name: Windows x86_64 gnu nightly # runs out of space while trying to link the test suite\n os: windows-latest\n rust: nightly-gnu\n other: i686-pc-windows-gnu\n name: Tests ${{ matrix.name }}\n steps:\n - uses: actions/checkout@v5\n - name: Dump Environment\n run: ci/dump-environment.sh\n # Some tests require stable. Make sure it is set to the most recent stable\n # so that we can predictably handle updates if necessary (and not randomly\n # when GitHub updates its image).\n - run: rustup update --no-self-update stable\n - run: rustup update --no-self-update ${{ matrix.rust }} && rustup default ${{ matrix.rust }}\n - run: rustup target add ${{ matrix.other }}\n if: matrix.os != 'ubuntu-24.04-arm' # cross-compile tests are disabled on ARM machines\n - run: rustup target add wasm32-unknown-unknown\n - run: rustup target add aarch64-unknown-none # need this for build-std mock tests\n if: startsWith(matrix.rust, 'nightly')\n - run: rustup component add rustc-dev llvm-tools-preview rust-docs\n if: startsWith(matrix.rust, 'nightly')\n - run: sudo apt update -y && sudo apt install lldb gcc-multilib libsecret-1-0 libsecret-1-dev -y\n if: matrix.os == 'ubuntu-latest'\n - run: rustup component add rustfmt || echo \"rustfmt not available\"\n - name: Add Windows debuggers bin to PATH\n shell: pwsh\n run: Add-Content $env:GITHUB_PATH \"C:\\Program Files (x86)\\Windows Kits\\10\\Debuggers\\x64\"\n if: matrix.os == 'windows-latest'\n - name: Add Windows debuggers bin to PATH\n shell: pwsh\n run: Add-Content $env:GITHUB_PATH \"C:\\Program Files (x86)\\Windows Kits\\10\\Debuggers\\arm64\"\n if: matrix.os == 'windows-11-arm'\n - name: Configure extra test environment\n run: echo CARGO_CONTAINER_TESTS=1 >> $GITHUB_ENV\n if: matrix.os == 'ubuntu-latest'\n - run: cargo test -p cargo\n - name: Clear intermediate test output\n run: ci/clean-test-output.sh\n\n - name: gitoxide tests (all git-related tests)\n run: cargo test -p cargo git\n env:\n __CARGO_USE_GITOXIDE_INSTEAD_OF_GIT2: 1\n # The testsuite generates a huge amount of data, and fetch-smoke-test was\n # running out of disk space.\n - name: Clear test output\n run: ci/clean-test-output.sh\n\n # This only tests `cargo fix` because fix-proxy-mode is one of the most\n # complicated subprocess management in Cargo.\n - name: Check operability of rustc invocation with argfile\n run: 'cargo test -p cargo --test testsuite -- fix::'\n env:\n __CARGO_TEST_FORCE_ARGFILE: 1\n - run: cargo test --workspace --exclude cargo --exclude benchsuite --exclude resolver-tests\n - name: Check benchmarks\n run: |\n # This only tests one benchmark since it can take over 10 minutes to\n # download all workspaces.\n cargo test -p benchsuite --all-targets -- cargo\n cargo check -p capture\n # The testsuite generates a huge amount of data, and fetch-smoke-test was\n # running out of disk space.\n - name: Clear benchmark output\n run: ci/clean-test-output.sh\n\n - name: Fetch smoke test\n run: ci/fetch-smoke-test.sh\n\n schema:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update stable && rustup default stable\n - run: cargo test -p cargo-util-schemas -F unstable-schema\n\n resolver:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update stable && rustup default stable\n - run: cargo test -p resolver-tests\n\n test_gitoxide:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update --no-self-update stable && rustup default stable\n - run: rustup target add i686-unknown-linux-gnu\n - run: rustup target add wasm32-unknown-unknown\n - run: sudo apt update -y && sudo apt install gcc-multilib libsecret-1-0 libsecret-1-dev -y\n - run: rustup component add rustfmt || echo \"rustfmt not available\"\n - run: cargo test -p cargo\n env:\n __CARGO_USE_GITOXIDE_INSTEAD_OF_GIT2: 1\n\n build_std:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update nightly && rustup default nightly\n - run: rustup component add rust-src\n - run: cargo build\n - run: cargo test -p cargo --test build-std\n env:\n CARGO_RUN_BUILD_STD_TESTS: 1\n docs:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update nightly && rustup default nightly\n - run: rustup update stable\n - run: rustup component add rust-docs\n - run: rustup component add rustfmt --toolchain stable\n - run: ci/validate-man.sh\n # This requires rustfmt, use stable.\n - name: Run semver-check\n run: cargo +stable run -p semver-check\n - name: Ensure intradoc links are valid\n run: cargo doc --workspace --document-private-items --no-deps\n env:\n RUSTDOCFLAGS: -D warnings\n - name: Install mdbook\n run: |\n mkdir mdbook\n curl -Lf https://github.com/rust-lang/mdBook/releases/download/v${MDBOOK_VERSION}/mdbook-v${MDBOOK_VERSION}-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=./mdbook\n echo `pwd`/mdbook >> $GITHUB_PATH\n - run: cd src/doc && mdbook build --dest-dir ../../target/doc\n - name: Run linkchecker.sh\n run: |\n cd target\n curl -sSLO https://raw.githubusercontent.com/rust-lang/rust/master/src/tools/linkchecker/linkcheck.sh\n sh linkcheck.sh --all --path ../src/doc cargo\n\n msrv:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - uses: taiki-e/install-action@cargo-hack\n - run: cargo hack check --all-targets --rust-version --workspace --ignore-private --locked\n\n spellcheck:\n name: Spell Check with Typos\n runs-on: ubuntu-latest\n steps:\n - name: Checkout Actions Repository\n uses: actions/checkout@v5\n - name: Spell Check Repo\n uses: crate-ci/typos@v1.44.0\n\n report-timings:\n name: Timing HTML report\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - run: rustup update nightly && rustup default nightly\n - run: cargo build\n - name: Generate timing report for rustfix\n run: |\n cargo run -- build -p rustfix -Zbuild-analysis -Zsection-timings --config build.analysis.enabled=true --config 'build.build-dir=\"tmp\"'\n cargo run -- report timings -Zbuild-analysis\n - uses: actions/upload-artifact@v6\n with:\n name: timing-report\n path: target/cargo-timings/*.html\n if-no-files-found: error\n" }, { "path": ".github/workflows/release.yml", "content": "# Publish Cargo to crates.io whenever a new tag is pushed. Tags are pushed by\n# the Rust release process (https://github.com/rust-lang/promote-release),\n# which will cause this workflow to run.\n\nname: Release\non:\n push:\n tags:\n - \"0.*\"\n\n# Prevent multiple releases from starting at the same time.\nconcurrency:\n group: release\n\njobs:\n crates-io:\n name: Publish on crates.io\n runs-on: ubuntu-latest\n permissions:\n contents: read\n\n # Gain access to the crates.io publishing token.\n environment:\n name: release\n\n steps:\n - name: Checkout the source code\n uses: actions/checkout@v5\n\n - name: Publish Cargo to crates.io\n run: ./publish.py\n env:\n CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}\n" }, { "path": ".gitignore", "content": "/target\n/Cargo.lock\n/config.stamp\n/Makefile\n/config.mk\n/src/doc/build\n/src/etc/*.pyc\n/src/registry/target\nrustc\n__pycache__\n.idea/\n.vscode/\n*.iml\n*.swp\n" }, { "path": ".ignore", "content": "# Output generated from src/doc/man\n#\n# The goal is to help people find the right file to edit\nsrc/doc/man/generated_txt\nsrc/doc/src/commands/*\nsrc/etc/man\n!src/doc/src/commands/build-commands.md\n!src/doc/src/commands/cargo-clippy.md\n!src/doc/src/commands/cargo-fmt.md\n!src/doc/src/commands/cargo-miri.md\n!src/doc/src/commands/general-commands.md\n!src/doc/src/commands/index.md\n!src/doc/src/commands/manifest-commands.md\n!src/doc/src/commands/package-commands.md\n!src/doc/src/commands/publishing-commands.md\n!src/doc/src/commands/report-commands.md\n\n# Snapshots of HTML reports and log files are just too large\ntests/testsuite/**/*.jsonl\ntests/testsuite/**/*.html\n" }, { "path": "CHANGELOG.md", "content": "# Changelog\n\nThe changelog has moved to the [Cargo Book](https://doc.rust-lang.org/nightly/cargo/CHANGELOG.html).\n" }, { "path": "CODE_OF_CONDUCT.md", "content": "# The Rust Code of Conduct\n\nThe Code of Conduct for this repository [can be found online](https://www.rust-lang.org/conduct.html).\n" }, { "path": "CONTRIBUTING.md", "content": "# Contributing to Cargo\n\nContributing documentation has moved to the **[Cargo Contributor Guide]**.\n\n[Cargo Contributor Guide]: https://rust-lang.github.io/cargo/contrib/\n\n## Before hacking on Cargo\n\nWe encourage people to discuss their design before hacking on code. Typically,\nyou [file an issue] or start a thread on the [internals forum] before submitting\na pull request.\n\nPlease read [the process] of how features and bugs are managed in Cargo.\n**Only issues that have been explicitly marked as [accepted] will be reviewed.**\n\n[internals forum]: https://internals.rust-lang.org/c/tools-and-infrastructure/cargo\n[file an issue]: https://github.com/rust-lang/cargo/issues\n[the process]: https://doc.crates.io/contrib/process/index.html\n[accepted]: https://github.com/rust-lang/cargo/issues?q=is%3Aissue+is%3Aopen+label%3AS-accepted\n" }, { "path": "Cargo.toml", "content": "[workspace]\nresolver = \"2\"\nmembers = [\n \"crates/*\",\n \"credential/*\",\n \"benches/benchsuite\",\n \"benches/capture\",\n]\nexclude = [\n \"target/\", # exclude bench testing\n]\n\n[workspace.package]\nrust-version = \"1.92\" # MSRV:3\nedition = \"2024\"\nlicense = \"MIT OR Apache-2.0\"\nrepository = \"https://github.com/rust-lang/cargo\"\n\n[workspace.dependencies]\nannotate-snippets = { version = \"0.12.12\", features = [\"simd\"] }\nanstream = \"1.0.0\"\nanstyle = \"1.0.13\"\nanstyle-hyperlink = \"1.0.1\"\nanstyle-progress = \"0.1.0\"\nanyhow = \"1.0.102\"\nbase64 = \"0.22.1\"\nblake3 = \"1.8.3\"\nbuild-rs = { version = \"0.3.4\", path = \"crates/build-rs\" }\ncargo = { path = \"\" }\ncargo-credential = { version = \"0.4.10\", path = \"credential/cargo-credential\" }\ncargo-credential-libsecret = { version = \"0.5.6\", path = \"credential/cargo-credential-libsecret\" }\ncargo-credential-macos-keychain = { version = \"0.4.21\", path = \"credential/cargo-credential-macos-keychain\" }\ncargo-credential-wincred = { version = \"0.4.21\", path = \"credential/cargo-credential-wincred\" }\ncargo-platform = { path = \"crates/cargo-platform\", version = \"0.3.3\" }\ncargo-test-macro = { version = \"0.4.10\", path = \"crates/cargo-test-macro\" }\ncargo-test-support = { version = \"0.11.0\", path = \"crates/cargo-test-support\" }\ncargo-util = { version = \"0.2.28\", path = \"crates/cargo-util\" }\ncargo-util-schemas = { version = \"0.13.0\", path = \"crates/cargo-util-schemas\" }\ncargo_metadata = \"0.23.1\"\nclap = \"4.5.60\"\nclap_complete = { version = \"4.5.66\", features = [\"unstable-dynamic\"] }\ncolor-print = \"0.3.7\"\ncore-foundation = { version = \"0.10.1\", features = [\"mac_os_10_7_support\"] }\ncrates-io = { version = \"0.40.18\", path = \"crates/crates-io\" }\ncriterion = { version = \"0.8.2\", features = [\"html_reports\"] }\ncurl = \"0.4.49\"\n# Do not upgrade curl-sys past 0.4.83\n# https://github.com/rust-lang/cargo/issues/16357\ncurl-sys = \"=0.4.83\"\nfiletime = \"0.2.27\"\nflate2 = { version = \"1.1.9\", default-features = false, features = [\"zlib-rs\"] }\ngit2 = \"0.20.4\"\ngit2-curl = \"0.21.0\"\n# When updating this, also see if `gix-transport` further down needs updating or some auth-related tests will fail.\ngix = { version = \"0.80.0\", default-features = false, features = [\"progress-tree\", \"parallel\", \"dirwalk\", \"status\"] }\ngix-transport = \"0.55.0\"\nglob = \"0.3.3\"\nhandlebars = { version = \"6.4.0\", features = [\"dir_source\"] }\nheck = \"0.5.0\"\nhex = \"0.4.3\"\nhmac = \"0.12.1\"\nhome = \"0.5.12\"\nhttp-auth = { version = \"0.1.10\", default-features = false }\nignore = \"0.4.25\"\nim-rc = \"15.1.0\"\nindexmap = \"2.13.0\"\nitertools = \"0.14.0\"\njiff = { version = \"0.2.22\", default-features = false, features = [ \"std\" ] }\njobserver = \"0.1.34\"\nlibc = \"0.2.180\"\nlibgit2-sys = \"0.18.3\"\nlibloading = \"0.9.0\"\nmemchr = \"2.8.0\"\nmemfd = \"0.6.5\"\nmiow = \"0.6.1\"\nopener = \"0.8.4\"\nopenssl = \"0.10.75\"\n# Pinned due to ppc64 ELFv1/v2 ABI issue in 3.5.5\n# https://github.com/openssl/openssl/issues/29815\nopenssl-src = \"=300.5.4\"\nos_info = { version = \"3.14.0\", default-features = false }\npasetors = { version = \"0.7.8\", features = [\"v3\", \"paserk\", \"std\", \"serde\"] }\npathdiff = \"0.2.3\"\npercent-encoding = \"2.3.2\"\nproptest = \"1.10.0\"\npulldown-cmark = { version = \"0.13.1\", default-features = false, features = [\"html\"] }\nrand = \"0.10.0\"\nregex = \"1.12.3\"\nrusqlite = { version = \"0.38.0\", features = [\"bundled\"] }\nrustc-hash = \"2.1.1\"\nrustc-stable-hash = \"0.1.2\"\nrustfix = { version = \"0.9.5\", path = \"crates/rustfix\" }\nsame-file = \"1.0.6\"\nschemars = \"1.2.1\"\nsecurity-framework = \"3.7.0\"\nsemver = { version = \"1.0.27\", features = [\"serde\"] }\nserde = \"1.0.228\"\nserde_core = \"1.0.228\"\nserde-untagged = \"0.1.9\"\nserde-value = \"0.7.0\"\nserde_ignored = \"0.1.14\"\nserde_json = \"1.0.149\"\nsha1 = \"0.10.6\"\nsha2 = \"0.10.9\"\nshell-escape = \"0.1.5\"\nsimilar = \"2.7.0\"\nsupports-hyperlinks = \"3.2.0\"\nsupports-unicode = \"3.0.0\"\nsnapbox = { version = \"1.0.0\", features = [\"diff\", \"dir\", \"term-svg\", \"regex\", \"json\"] }\ntar = { version = \"0.4.45\", default-features = false }\ntempfile = \"3.25.0\"\nthiserror = \"2.0.18\"\ntime = { version = \"0.3.47\", features = [\"parsing\", \"formatting\", \"serde\"] }\ntoml = { version = \"1.0.3\", default-features = false }\ntoml_edit = { version = \"0.25.3\", features = [\"serde\"] }\ntracing = { version = \"0.1.44\", default-features = false, features = [\"std\"] } # be compatible with rustc_log: https://github.com/rust-lang/rust/blob/e51e98dde6a/compiler/rustc_log/Cargo.toml#L9\ntracing-chrome = \"0.7.2\"\ntracing-subscriber = { version = \"0.3.22\", features = [\"env-filter\"] }\nunicase = \"2.9.0\"\nunicode-ident = \"1.0.24\"\nunicode-width = \"0.2.2\"\nurl = \"2.5.8\"\nvarisat = \"0.2.2\"\nwalkdir = \"2.5.0\"\nwindows-sys = \"0.61\"\nwinnow = \"0.7.14\"\n\n[workspace.lints.rust]\nrust_2018_idioms = \"warn\" # TODO: could this be removed?\n\n[workspace.lints.rustdoc]\nprivate_intra_doc_links = \"allow\"\n\n[workspace.lints.clippy]\nall = { level = \"allow\", priority = -2 }\ncorrectness = { level = \"warn\", priority = -1 }\ndbg_macro = \"warn\"\ndisallowed_methods = \"warn\"\nprint_stderr = \"warn\"\nprint_stdout = \"warn\"\nself_named_module_files = \"warn\"\n\n[package]\nname = \"cargo\"\nversion = \"0.97.0\"\nedition.workspace = true\nlicense.workspace = true\nrust-version = \"1.94\" # MSRV:1\nhomepage = \"https://doc.rust-lang.org/cargo/index.html\"\nrepository.workspace = true\ndocumentation = \"https://docs.rs/cargo\"\ndescription = \"\"\"\nCargo, a package manager for Rust.\n\"\"\"\n\n[lib]\nname = \"cargo\"\npath = \"src/cargo/lib.rs\"\n\n[dependencies]\nannotate-snippets.workspace = true\nanstream.workspace = true\nanstyle.workspace = true\nanstyle-hyperlink = { workspace = true, features = [\"file\"] }\nanstyle-progress.workspace = true\nanyhow.workspace = true\nbase64.workspace = true\nblake3.workspace = true\ncargo-credential.workspace = true\ncargo-platform.workspace = true\ncargo-util-schemas.workspace = true\ncargo-util.workspace = true\nclap = { workspace = true, features = [\"wrap_help\"] }\nclap_complete.workspace = true\ncolor-print.workspace = true\ncrates-io.workspace = true\ncurl = { workspace = true, features = [\"http2\"] }\ncurl-sys.workspace = true\nfiletime.workspace = true\nflate2.workspace = true\ngit2.workspace = true\ngit2-curl.workspace = true\ngix.workspace = true\nglob.workspace = true\nheck.workspace = true\nhex.workspace = true\nhmac.workspace = true\nhome.workspace = true\nhttp-auth.workspace = true\nignore.workspace = true\nim-rc.workspace = true\nindexmap.workspace = true\nitertools.workspace = true\njiff = { workspace = true, features = [\"serde\", \"std\"] }\njobserver.workspace = true\nlibgit2-sys.workspace = true\nmemchr.workspace = true\nopener.workspace = true\nos_info.workspace = true\npasetors.workspace = true\npathdiff.workspace = true\nrand.workspace = true\nregex.workspace = true\nrusqlite = { workspace = true, features = [\"fallible_uint\"] }\nrustc-hash.workspace = true\nrustc-stable-hash.workspace = true\nrustfix.workspace = true\nsame-file.workspace = true\nsemver.workspace = true\nserde = { workspace = true, features = [\"derive\"] }\nserde-untagged.workspace = true\nserde_ignored.workspace = true\nserde_json = { workspace = true, features = [\"raw_value\"] }\nsha1.workspace = true\nshell-escape.workspace = true\nsupports-hyperlinks.workspace = true\nsupports-unicode.workspace = true\ntar.workspace = true\ntempfile.workspace = true\nthiserror.workspace = true\ntime.workspace = true\ntoml = { workspace = true, features = [\"std\", \"serde\", \"parse\", \"display\", \"preserve_order\"] }\ntoml_edit.workspace = true\ntracing = { workspace = true, features = [\"attributes\"] }\ntracing-subscriber.workspace = true\nunicase.workspace = true\nunicode-width.workspace = true\nunicode-ident.workspace = true\nurl.workspace = true\nwalkdir.workspace = true\nwinnow.workspace = true\n\n[target.'cfg(target_has_atomic = \"64\")'.dependencies]\ntracing-chrome.workspace = true\n\n[target.'cfg(unix)'.dependencies]\nlibc.workspace = true\n\n[target.'cfg(target_os = \"linux\")'.dependencies]\ncargo-credential-libsecret.workspace = true\n\n[target.'cfg(target_os = \"macos\")'.dependencies]\ncargo-credential-macos-keychain.workspace = true\n\n[target.'cfg(not(windows))'.dependencies]\nopenssl = { workspace = true, optional = true }\nopenssl-src = { workspace = true, optional = true }\n\n[target.'cfg(windows)'.dependencies]\ncargo-credential-wincred.workspace = true\n\n[target.'cfg(windows)'.dependencies.windows-sys]\nworkspace = true\nfeatures = [\n \"Win32_Foundation\",\n \"Win32_Security\",\n \"Win32_Storage_FileSystem\",\n \"Win32_System_IO\",\n \"Win32_System_Console\",\n \"Win32_System_JobObjects\",\n \"Win32_System_Threading\",\n]\n\n[dev-dependencies]\nannotate-snippets = { workspace = true, features = [\"testing-colors\"] }\ncargo-test-support.workspace = true\ngix = { workspace = true, features = [\"revision\"] }\n# When building Cargo for tests, a safety-measure in `gix` needs to be disabled\n# to allow sending credentials over HTTP connections.\ngix-transport = { workspace = true, features = [\"http-client-insecure-credentials\"] }\nsame-file.workspace = true\nsnapbox.workspace = true\n\n[target.'cfg(target_os = \"linux\")'.dev-dependencies]\nmemfd.workspace = true\n\n[build-dependencies]\nflate2.workspace = true\ntar.workspace = true\n\n[[bin]]\nname = \"cargo\"\ntest = false\ndoc = false\n\n[features]\ndefault = [\"http-transport-curl\"]\nvendored-openssl = [\"openssl/vendored\"]\nvendored-libgit2 = [\"libgit2-sys/vendored\"]\n# This is primarily used by rust-lang/rust distributing cargo the executable.\nall-static = ['vendored-openssl', 'curl/static-curl', 'curl/force-system-lib-on-osx', 'vendored-libgit2']\n# Exactly one of 'http-transport-curl' or 'http-transport-reqwest' must be enabled\n# when using Cargo as a library. By default, it is 'http-transport-curl'.\nhttp-transport-curl = [\"gix/blocking-http-transport-curl\"]\nhttp-transport-reqwest = [\"gix/blocking-http-transport-reqwest\"]\n\n[lints]\nworkspace = true\n" }, { "path": "LICENSE-APACHE", "content": " Apache License\n Version 2.0, January 2004\n https://www.apache.org/licenses/LICENSE-2.0\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n\thttps://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n" }, { "path": "LICENSE-MIT", "content": "Permission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentation files (the \"Software\"), to deal in the\nSoftware without restriction, including without\nlimitation the rights to use, copy, modify, merge,\npublish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software\nis furnished to do so, subject to the following\nconditions:\n\nThe above copyright notice and this permission notice\nshall be included in all copies or substantial portions\nof the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\nANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\nTO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\nSHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\nIN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n" }, { "path": "LICENSE-THIRD-PARTY", "content": "The Cargo source code itself does not bundle any third party libraries, but it\ndepends on a number of libraries which carry their own copyright notices and\nlicense terms. These libraries are normally all linked static into the binary\ndistributions of Cargo:\n\n* OpenSSL - https://www.openssl.org/source/license.html\n\n Copyright (c) 1998-2011 The OpenSSL Project. All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in\n the documentation and/or other materials provided with the\n distribution.\n\n 3. All advertising materials mentioning features or use of this\n software must display the following acknowledgment:\n \"This product includes software developed by the OpenSSL Project\n for use in the OpenSSL Toolkit. (https://www.openssl.org/)\"\n\n 4. The names \"OpenSSL Toolkit\" and \"OpenSSL Project\" must not be used to\n endorse or promote products derived from this software without\n prior written permission. For written permission, please contact\n openssl-core@openssl.org.\n\n 5. Products derived from this software may not be called \"OpenSSL\"\n nor may \"OpenSSL\" appear in their names without prior written\n permission of the OpenSSL Project.\n\n 6. Redistributions of any form whatsoever must retain the following\n acknowledgment:\n \"This product includes software developed by the OpenSSL Project\n for use in the OpenSSL Toolkit (https://www.openssl.org/)\"\n\n THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY\n EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR\n ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\n OF THE POSSIBILITY OF SUCH DAMAGE.\n ====================================================================\n\n This product includes cryptographic software written by Eric Young\n (eay@cryptsoft.com). This product includes software written by Tim\n Hudson (tjh@cryptsoft.com).\n\n ---\n\n Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)\n All rights reserved.\n\n This package is an SSL implementation written\n by Eric Young (eay@cryptsoft.com).\n The implementation was written so as to conform with Netscapes SSL.\n\n This library is free for commercial and non-commercial use as long as\n the following conditions are aheared to. The following conditions\n apply to all code found in this distribution, be it the RC4, RSA,\n lhash, DES, etc., code; not just the SSL code. The SSL documentation\n included with this distribution is covered by the same copyright terms\n except that the holder is Tim Hudson (tjh@cryptsoft.com).\n\n Copyright remains Eric Young's, and as such any Copyright notices in\n the code are not to be removed.\n If this package is used in a product, Eric Young should be given attribution\n as the author of the parts of the library used.\n This can be in the form of a textual message at program startup or\n in documentation (online or textual) provided with the package.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n 1. Redistributions of source code must retain the copyright\n notice, this list of conditions and the following disclaimer.\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n 3. All advertising materials mentioning features or use of this software\n must display the following acknowledgement:\n \"This product includes cryptographic software written by\n Eric Young (eay@cryptsoft.com)\"\n The word 'cryptographic' can be left out if the rouines from the library\n being used are not cryptographic related :-).\n 4. If you include any Windows specific code (or a derivative thereof) from\n the apps directory (application code) you must include an acknowledgement:\n \"This product includes software written by Tim Hudson (tjh@cryptsoft.com)\"\n\n THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND\n ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n SUCH DAMAGE.\n\n The licence and distribution terms for any publically available version or\n derivative of this code cannot be changed. i.e. this code cannot simply be\n copied and put under another distribution licence\n [including the GNU Public Licence.]\n\n* libgit2 - https://github.com/libgit2/libgit2/blob/master/COPYING\n\n libgit2 is Copyright (C) the libgit2 contributors,\n unless otherwise stated. See the AUTHORS file for details.\n\n Note that the only valid version of the GPL as far as this project\n is concerned is _this_ particular version of the license (ie v2, not\n v2.2 or v3.x or whatever), unless explicitly otherwise stated.\n\n ----------------------------------------------------------------------\n\n LINKING EXCEPTION\n\n In addition to the permissions in the GNU General Public License,\n the authors give you unlimited permission to link the compiled\n version of this library into combinations with other programs,\n and to distribute those combinations without any restriction\n coming from the use of this file. (The General Public License\n restrictions do apply in other respects; for example, they cover\n modification of the file, and distribution when not linked into\n a combined executable.)\n\n ----------------------------------------------------------------------\n\n GNU GENERAL PUBLIC LICENSE\n Version 2, June 1991\n\n Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n Preamble\n\n The licenses for most software are designed to take away your\n freedom to share and change it. By contrast, the GNU General Public\n License is intended to guarantee your freedom to share and change free\n software--to make sure the software is free for all its users. This\n General Public License applies to most of the Free Software\n Foundation's software and to any other program whose authors commit to\n using it. (Some other Free Software Foundation software is covered by\n the GNU Library General Public License instead.) You can apply it to\n your programs, too.\n\n When we speak of free software, we are referring to freedom, not\n price. Our General Public Licenses are designed to make sure that you\n have the freedom to distribute copies of free software (and charge for\n this service if you wish), that you receive source code or can get it\n if you want it, that you can change the software or use pieces of it\n in new free programs; and that you know you can do these things.\n\n To protect your rights, we need to make restrictions that forbid\n anyone to deny you these rights or to ask you to surrender the rights.\n These restrictions translate to certain responsibilities for you if you\n distribute copies of the software, or if you modify it.\n\n For example, if you distribute copies of such a program, whether\n gratis or for a fee, you must give the recipients all the rights that\n you have. You must make sure that they, too, receive or can get the\n source code. And you must show them these terms so they know their\n rights.\n\n We protect your rights with two steps: (1) copyright the software, and\n (2) offer you this license which gives you legal permission to copy,\n distribute and/or modify the software.\n\n Also, for each author's protection and ours, we want to make certain\n that everyone understands that there is no warranty for this free\n software. If the software is modified by someone else and passed on, we\n want its recipients to know that what they have is not the original, so\n that any problems introduced by others will not reflect on the original\n authors' reputations.\n\n Finally, any free program is threatened constantly by software\n patents. We wish to avoid the danger that redistributors of a free\n program will individually obtain patent licenses, in effect making the\n program proprietary. To prevent this, we have made it clear that any\n patent must be licensed for everyone's free use or not licensed at all.\n\n The precise terms and conditions for copying, distribution and\n modification follow.\n\n GNU GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License applies to any program or other work which contains\n a notice placed by the copyright holder saying it may be distributed\n under the terms of this General Public License. The \"Program\", below,\n refers to any such program or work, and a \"work based on the Program\"\n means either the Program or any derivative work under copyright law:\n that is to say, a work containing the Program or a portion of it,\n either verbatim or with modifications and/or translated into another\n language. (Hereinafter, translation is included without limitation in\n the term \"modification\".) Each licensee is addressed as \"you\".\n\n Activities other than copying, distribution and modification are not\n covered by this License; they are outside its scope. The act of\n running the Program is not restricted, and the output from the Program\n is covered only if its contents constitute a work based on the\n Program (independent of having been made by running the Program).\n Whether that is true depends on what the Program does.\n\n 1. You may copy and distribute verbatim copies of the Program's\n source code as you receive it, in any medium, provided that you\n conspicuously and appropriately publish on each copy an appropriate\n copyright notice and disclaimer of warranty; keep intact all the\n notices that refer to this License and to the absence of any warranty;\n and give any other recipients of the Program a copy of this License\n along with the Program.\n\n You may charge a fee for the physical act of transferring a copy, and\n you may at your option offer warranty protection in exchange for a fee.\n\n 2. You may modify your copy or copies of the Program or any portion\n of it, thus forming a work based on the Program, and copy and\n distribute such modifications or work under the terms of Section 1\n above, provided that you also meet all of these conditions:\n\n a) You must cause the modified files to carry prominent notices\n stating that you changed the files and the date of any change.\n\n b) You must cause any work that you distribute or publish, that in\n whole or in part contains or is derived from the Program or any\n part thereof, to be licensed as a whole at no charge to all third\n parties under the terms of this License.\n\n c) If the modified program normally reads commands interactively\n when run, you must cause it, when started running for such\n interactive use in the most ordinary way, to print or display an\n announcement including an appropriate copyright notice and a\n notice that there is no warranty (or else, saying that you provide\n a warranty) and that users may redistribute the program under\n these conditions, and telling the user how to view a copy of this\n License. (Exception: if the Program itself is interactive but\n does not normally print such an announcement, your work based on\n the Program is not required to print an announcement.)\n\n These requirements apply to the modified work as a whole. If\n identifiable sections of that work are not derived from the Program,\n and can be reasonably considered independent and separate works in\n themselves, then this License, and its terms, do not apply to those\n sections when you distribute them as separate works. But when you\n distribute the same sections as part of a whole which is a work based\n on the Program, the distribution of the whole must be on the terms of\n this License, whose permissions for other licensees extend to the\n entire whole, and thus to each and every part regardless of who wrote it.\n\n Thus, it is not the intent of this section to claim rights or contest\n your rights to work written entirely by you; rather, the intent is to\n exercise the right to control the distribution of derivative or\n collective works based on the Program.\n\n In addition, mere aggregation of another work not based on the Program\n with the Program (or with a work based on the Program) on a volume of\n a storage or distribution medium does not bring the other work under\n the scope of this License.\n\n 3. You may copy and distribute the Program (or a work based on it,\n under Section 2) in object code or executable form under the terms of\n Sections 1 and 2 above provided that you also do one of the following:\n\n a) Accompany it with the complete corresponding machine-readable\n source code, which must be distributed under the terms of Sections\n 1 and 2 above on a medium customarily used for software interchange; or,\n\n b) Accompany it with a written offer, valid for at least three\n years, to give any third party, for a charge no more than your\n cost of physically performing source distribution, a complete\n machine-readable copy of the corresponding source code, to be\n distributed under the terms of Sections 1 and 2 above on a medium\n customarily used for software interchange; or,\n\n c) Accompany it with the information you received as to the offer\n to distribute corresponding source code. (This alternative is\n allowed only for noncommercial distribution and only if you\n received the program in object code or executable form with such\n an offer, in accord with Subsection b above.)\n\n The source code for a work means the preferred form of the work for\n making modifications to it. For an executable work, complete source\n code means all the source code for all modules it contains, plus any\n associated interface definition files, plus the scripts used to\n control compilation and installation of the executable. However, as a\n special exception, the source code distributed need not include\n anything that is normally distributed (in either source or binary\n form) with the major components (compiler, kernel, and so on) of the\n operating system on which the executable runs, unless that component\n itself accompanies the executable.\n\n If distribution of executable or object code is made by offering\n access to copy from a designated place, then offering equivalent\n access to copy the source code from the same place counts as\n distribution of the source code, even though third parties are not\n compelled to copy the source along with the object code.\n\n 4. You may not copy, modify, sublicense, or distribute the Program\n except as expressly provided under this License. Any attempt\n otherwise to copy, modify, sublicense or distribute the Program is\n void, and will automatically terminate your rights under this License.\n However, parties who have received copies, or rights, from you under\n this License will not have their licenses terminated so long as such\n parties remain in full compliance.\n\n 5. You are not required to accept this License, since you have not\n signed it. However, nothing else grants you permission to modify or\n distribute the Program or its derivative works. These actions are\n prohibited by law if you do not accept this License. Therefore, by\n modifying or distributing the Program (or any work based on the\n Program), you indicate your acceptance of this License to do so, and\n all its terms and conditions for copying, distributing or modifying\n the Program or works based on it.\n\n 6. Each time you redistribute the Program (or any work based on the\n Program), the recipient automatically receives a license from the\n original licensor to copy, distribute or modify the Program subject to\n these terms and conditions. You may not impose any further\n restrictions on the recipients' exercise of the rights granted herein.\n You are not responsible for enforcing compliance by third parties to\n this License.\n\n 7. If, as a consequence of a court judgment or allegation of patent\n infringement or for any other reason (not limited to patent issues),\n conditions are imposed on you (whether by court order, agreement or\n otherwise) that contradict the conditions of this License, they do not\n excuse you from the conditions of this License. If you cannot\n distribute so as to satisfy simultaneously your obligations under this\n License and any other pertinent obligations, then as a consequence you\n may not distribute the Program at all. For example, if a patent\n license would not permit royalty-free redistribution of the Program by\n all those who receive copies directly or indirectly through you, then\n the only way you could satisfy both it and this License would be to\n refrain entirely from distribution of the Program.\n\n If any portion of this section is held invalid or unenforceable under\n any particular circumstance, the balance of the section is intended to\n apply and the section as a whole is intended to apply in other\n circumstances.\n\n It is not the purpose of this section to induce you to infringe any\n patents or other property right claims or to contest validity of any\n such claims; this section has the sole purpose of protecting the\n integrity of the free software distribution system, which is\n implemented by public license practices. Many people have made\n generous contributions to the wide range of software distributed\n through that system in reliance on consistent application of that\n system; it is up to the author/donor to decide if he or she is willing\n to distribute software through any other system and a licensee cannot\n impose that choice.\n\n This section is intended to make thoroughly clear what is believed to\n be a consequence of the rest of this License.\n\n 8. If the distribution and/or use of the Program is restricted in\n certain countries either by patents or by copyrighted interfaces, the\n original copyright holder who places the Program under this License\n may add an explicit geographical distribution limitation excluding\n those countries, so that distribution is permitted only in or among\n countries not thus excluded. In such case, this License incorporates\n the limitation as if written in the body of this License.\n\n 9. The Free Software Foundation may publish revised and/or new versions\n of the General Public License from time to time. Such new versions will\n be similar in spirit to the present version, but may differ in detail to\n address new problems or concerns.\n\n Each version is given a distinguishing version number. If the Program\n specifies a version number of this License which applies to it and \"any\n later version\", you have the option of following the terms and conditions\n either of that version or of any later version published by the Free\n Software Foundation. If the Program does not specify a version number of\n this License, you may choose any version ever published by the Free Software\n Foundation.\n\n 10. If you wish to incorporate parts of the Program into other free\n programs whose distribution conditions are different, write to the author\n to ask for permission. For software which is copyrighted by the Free\n Software Foundation, write to the Free Software Foundation; we sometimes\n make exceptions for this. Our decision will be guided by the two goals\n of preserving the free status of all derivatives of our free software and\n of promoting the sharing and reuse of software generally.\n\n NO WARRANTY\n\n 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\n OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\n TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\n PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n REPAIR OR CORRECTION.\n\n 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n POSSIBILITY OF SUCH DAMAGES.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Programs\n\n If you develop a new program, and you want it to be of the greatest\n possible use to the public, the best way to achieve this is to make it\n free software which everyone can redistribute and change under these terms.\n\n To do so, attach the following notices to the program. It is safest\n to attach them to the start of each source file to most effectively\n convey the exclusion of warranty; and each file should have at least\n the \"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This program is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2 of the License, or\n (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU General Public License for more details.\n\n You should have received a copy of the GNU General Public License\n along with this program; if not, write to the Free Software\n Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n\n\n Also add information on how to contact you by electronic and paper mail.\n\n If the program is interactive, make it output a short notice like this\n when it starts in an interactive mode:\n\n Gnomovision version 69, Copyright (C) year name of author\n Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n This is free software, and you are welcome to redistribute it\n under certain conditions; type `show c' for details.\n\n The hypothetical commands `show w' and `show c' should show the appropriate\n parts of the General Public License. Of course, the commands you use may\n be called something other than `show w' and `show c'; they could even be\n mouse-clicks or menu items--whatever suits your program.\n\n You should also get your employer (if you work as a programmer) or your\n school, if any, to sign a \"copyright disclaimer\" for the program, if\n necessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the program\n `Gnomovision' (which makes passes at compilers) written by James Hacker.\n\n , 1 April 1989\n Ty Coon, President of Vice\n\n This General Public License does not permit incorporating your program into\n proprietary programs. If your program is a subroutine library, you may\n consider it more useful to permit linking proprietary applications with the\n library. If this is what you want to do, use the GNU Library General\n Public License instead of this License.\n\n ----------------------------------------------------------------------\n\n The bundled ZLib code is licensed under the ZLib license:\n\n Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler\n\n This software is provided 'as-is', without any express or implied\n warranty. In no event will the authors be held liable for any damages\n arising from the use of this software.\n\n Permission is granted to anyone to use this software for any purpose,\n including commercial applications, and to alter it and redistribute it\n freely, subject to the following restrictions:\n\n 1. The origin of this software must not be misrepresented; you must not\n claim that you wrote the original software. If you use this software\n in a product, an acknowledgment in the product documentation would be\n appreciated but is not required.\n 2. Altered source versions must be plainly marked as such, and must not be\n misrepresented as being the original software.\n 3. This notice may not be removed or altered from any source distribution.\n\n Jean-loup Gailly Mark Adler\n jloup@gzip.org madler@alumni.caltech.edu\n\n ----------------------------------------------------------------------\n\n The Clar framework is licensed under the MIT license:\n\n Copyright (C) 2011 by Vicent Marti\n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n\n ----------------------------------------------------------------------\n\n The regex library (deps/regex/) is licensed under the GNU LGPL\n\n GNU LESSER GENERAL PUBLIC LICENSE\n Version 2.1, February 1999\n\n Copyright (C) 1991, 1999 Free Software Foundation, Inc.\n 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n [This is the first released version of the Lesser GPL. It also counts\n as the successor of the GNU Library Public License, version 2, hence\n the version number 2.1.]\n\n Preamble\n\n The licenses for most software are designed to take away your\n freedom to share and change it. By contrast, the GNU General Public\n Licenses are intended to guarantee your freedom to share and change\n free software--to make sure the software is free for all its users.\n\n This license, the Lesser General Public License, applies to some\n specially designated software packages--typically libraries--of the\n Free Software Foundation and other authors who decide to use it. You\n can use it too, but we suggest you first think carefully about whether\n this license or the ordinary General Public License is the better\n strategy to use in any particular case, based on the explanations below.\n\n When we speak of free software, we are referring to freedom of use,\n not price. Our General Public Licenses are designed to make sure that\n you have the freedom to distribute copies of free software (and charge\n for this service if you wish); that you receive source code or can get\n it if you want it; that you can change the software and use pieces of\n it in new free programs; and that you are informed that you can do\n these things.\n\n To protect your rights, we need to make restrictions that forbid\n distributors to deny you these rights or to ask you to surrender these\n rights. These restrictions translate to certain responsibilities for\n you if you distribute copies of the library or if you modify it.\n\n For example, if you distribute copies of the library, whether gratis\n or for a fee, you must give the recipients all the rights that we gave\n you. You must make sure that they, too, receive or can get the source\n code. If you link other code with the library, you must provide\n complete object files to the recipients, so that they can relink them\n with the library after making changes to the library and recompiling\n it. And you must show them these terms so they know their rights.\n\n We protect your rights with a two-step method: (1) we copyright the\n library, and (2) we offer you this license, which gives you legal\n permission to copy, distribute and/or modify the library.\n\n To protect each distributor, we want to make it very clear that\n there is no warranty for the free library. Also, if the library is\n modified by someone else and passed on, the recipients should know\n that what they have is not the original version, so that the original\n author's reputation will not be affected by problems that might be\n introduced by others.\n\n Finally, software patents pose a constant threat to the existence of\n any free program. We wish to make sure that a company cannot\n effectively restrict the users of a free program by obtaining a\n restrictive license from a patent holder. Therefore, we insist that\n any patent license obtained for a version of the library must be\n consistent with the full freedom of use specified in this license.\n\n Most GNU software, including some libraries, is covered by the\n ordinary GNU General Public License. This license, the GNU Lesser\n General Public License, applies to certain designated libraries, and\n is quite different from the ordinary General Public License. We use\n this license for certain libraries in order to permit linking those\n libraries into non-free programs.\n\n When a program is linked with a library, whether statically or using\n a shared library, the combination of the two is legally speaking a\n combined work, a derivative of the original library. The ordinary\n General Public License therefore permits such linking only if the\n entire combination fits its criteria of freedom. The Lesser General\n Public License permits more lax criteria for linking other code with\n the library.\n\n We call this license the \"Lesser\" General Public License because it\n does Less to protect the user's freedom than the ordinary General\n Public License. It also provides other free software developers Less\n of an advantage over competing non-free programs. These disadvantages\n are the reason we use the ordinary General Public License for many\n libraries. However, the Lesser license provides advantages in certain\n special circumstances.\n\n For example, on rare occasions, there may be a special need to\n encourage the widest possible use of a certain library, so that it becomes\n a de-facto standard. To achieve this, non-free programs must be\n allowed to use the library. A more frequent case is that a free\n library does the same job as widely used non-free libraries. In this\n case, there is little to gain by limiting the free library to free\n software only, so we use the Lesser General Public License.\n\n In other cases, permission to use a particular library in non-free\n programs enables a greater number of people to use a large body of\n free software. For example, permission to use the GNU C Library in\n non-free programs enables many more people to use the whole GNU\n operating system, as well as its variant, the GNU/Linux operating\n system.\n\n Although the Lesser General Public License is Less protective of the\n users' freedom, it does ensure that the user of a program that is\n linked with the Library has the freedom and the wherewithal to run\n that program using a modified version of the Library.\n\n The precise terms and conditions for copying, distribution and\n modification follow. Pay close attention to the difference between a\n \"work based on the library\" and a \"work that uses the library\". The\n former contains code derived from the library, whereas the latter must\n be combined with the library in order to run.\n\n GNU LESSER GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License Agreement applies to any software library or other\n program which contains a notice placed by the copyright holder or\n other authorized party saying it may be distributed under the terms of\n this Lesser General Public License (also called \"this License\").\n Each licensee is addressed as \"you\".\n\n A \"library\" means a collection of software functions and/or data\n prepared so as to be conveniently linked with application programs\n (which use some of those functions and data) to form executables.\n\n The \"Library\", below, refers to any such software library or work\n which has been distributed under these terms. A \"work based on the\n Library\" means either the Library or any derivative work under\n copyright law: that is to say, a work containing the Library or a\n portion of it, either verbatim or with modifications and/or translated\n straightforwardly into another language. (Hereinafter, translation is\n included without limitation in the term \"modification\".)\n\n \"Source code\" for a work means the preferred form of the work for\n making modifications to it. For a library, complete source code means\n all the source code for all modules it contains, plus any associated\n interface definition files, plus the scripts used to control compilation\n and installation of the library.\n\n Activities other than copying, distribution and modification are not\n covered by this License; they are outside its scope. The act of\n running a program using the Library is not restricted, and output from\n such a program is covered only if its contents constitute a work based\n on the Library (independent of the use of the Library in a tool for\n writing it). Whether that is true depends on what the Library does\n and what the program that uses the Library does.\n\n 1. You may copy and distribute verbatim copies of the Library's\n complete source code as you receive it, in any medium, provided that\n you conspicuously and appropriately publish on each copy an\n appropriate copyright notice and disclaimer of warranty; keep intact\n all the notices that refer to this License and to the absence of any\n warranty; and distribute a copy of this License along with the\n Library.\n\n You may charge a fee for the physical act of transferring a copy,\n and you may at your option offer warranty protection in exchange for a\n fee.\n\n 2. You may modify your copy or copies of the Library or any portion\n of it, thus forming a work based on the Library, and copy and\n distribute such modifications or work under the terms of Section 1\n above, provided that you also meet all of these conditions:\n\n a) The modified work must itself be a software library.\n\n b) You must cause the files modified to carry prominent notices\n stating that you changed the files and the date of any change.\n\n c) You must cause the whole of the work to be licensed at no\n charge to all third parties under the terms of this License.\n\n d) If a facility in the modified Library refers to a function or a\n table of data to be supplied by an application program that uses\n the facility, other than as an argument passed when the facility\n is invoked, then you must make a good faith effort to ensure that,\n in the event an application does not supply such function or\n table, the facility still operates, and performs whatever part of\n its purpose remains meaningful.\n\n (For example, a function in a library to compute square roots has\n a purpose that is entirely well-defined independent of the\n application. Therefore, Subsection 2d requires that any\n application-supplied function or table used by this function must\n be optional: if the application does not supply it, the square\n root function must still compute square roots.)\n\n These requirements apply to the modified work as a whole. If\n identifiable sections of that work are not derived from the Library,\n and can be reasonably considered independent and separate works in\n themselves, then this License, and its terms, do not apply to those\n sections when you distribute them as separate works. But when you\n distribute the same sections as part of a whole which is a work based\n on the Library, the distribution of the whole must be on the terms of\n this License, whose permissions for other licensees extend to the\n entire whole, and thus to each and every part regardless of who wrote\n it.\n\n Thus, it is not the intent of this section to claim rights or contest\n your rights to work written entirely by you; rather, the intent is to\n exercise the right to control the distribution of derivative or\n collective works based on the Library.\n\n In addition, mere aggregation of another work not based on the Library\n with the Library (or with a work based on the Library) on a volume of\n a storage or distribution medium does not bring the other work under\n the scope of this License.\n\n 3. You may opt to apply the terms of the ordinary GNU General Public\n License instead of this License to a given copy of the Library. To do\n this, you must alter all the notices that refer to this License, so\n that they refer to the ordinary GNU General Public License, version 2,\n instead of to this License. (If a newer version than version 2 of the\n ordinary GNU General Public License has appeared, then you can specify\n that version instead if you wish.) Do not make any other change in\n these notices.\n\n Once this change is made in a given copy, it is irreversible for\n that copy, so the ordinary GNU General Public License applies to all\n subsequent copies and derivative works made from that copy.\n\n This option is useful when you wish to copy part of the code of\n the Library into a program that is not a library.\n\n 4. You may copy and distribute the Library (or a portion or\n derivative of it, under Section 2) in object code or executable form\n under the terms of Sections 1 and 2 above provided that you accompany\n it with the complete corresponding machine-readable source code, which\n must be distributed under the terms of Sections 1 and 2 above on a\n medium customarily used for software interchange.\n\n If distribution of object code is made by offering access to copy\n from a designated place, then offering equivalent access to copy the\n source code from the same place satisfies the requirement to\n distribute the source code, even though third parties are not\n compelled to copy the source along with the object code.\n\n 5. A program that contains no derivative of any portion of the\n Library, but is designed to work with the Library by being compiled or\n linked with it, is called a \"work that uses the Library\". Such a\n work, in isolation, is not a derivative work of the Library, and\n therefore falls outside the scope of this License.\n\n However, linking a \"work that uses the Library\" with the Library\n creates an executable that is a derivative of the Library (because it\n contains portions of the Library), rather than a \"work that uses the\n library\". The executable is therefore covered by this License.\n Section 6 states terms for distribution of such executables.\n\n When a \"work that uses the Library\" uses material from a header file\n that is part of the Library, the object code for the work may be a\n derivative work of the Library even though the source code is not.\n Whether this is true is especially significant if the work can be\n linked without the Library, or if the work is itself a library. The\n threshold for this to be true is not precisely defined by law.\n\n If such an object file uses only numerical parameters, data\n structure layouts and accessors, and small macros and small inline\n functions (ten lines or less in length), then the use of the object\n file is unrestricted, regardless of whether it is legally a derivative\n work. (Executables containing this object code plus portions of the\n Library will still fall under Section 6.)\n\n Otherwise, if the work is a derivative of the Library, you may\n distribute the object code for the work under the terms of Section 6.\n Any executables containing that work also fall under Section 6,\n whether or not they are linked directly with the Library itself.\n\n 6. As an exception to the Sections above, you may also combine or\n link a \"work that uses the Library\" with the Library to produce a\n work containing portions of the Library, and distribute that work\n under terms of your choice, provided that the terms permit\n modification of the work for the customer's own use and reverse\n engineering for debugging such modifications.\n\n You must give prominent notice with each copy of the work that the\n Library is used in it and that the Library and its use are covered by\n this License. You must supply a copy of this License. If the work\n during execution displays copyright notices, you must include the\n copyright notice for the Library among them, as well as a reference\n directing the user to the copy of this License. Also, you must do one\n of these things:\n\n a) Accompany the work with the complete corresponding\n machine-readable source code for the Library including whatever\n changes were used in the work (which must be distributed under\n Sections 1 and 2 above); and, if the work is an executable linked\n with the Library, with the complete machine-readable \"work that\n uses the Library\", as object code and/or source code, so that the\n user can modify the Library and then relink to produce a modified\n executable containing the modified Library. (It is understood\n that the user who changes the contents of definitions files in the\n Library will not necessarily be able to recompile the application\n to use the modified definitions.)\n\n b) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (1) uses at run time a\n copy of the library already present on the user's computer system,\n rather than copying library functions into the executable, and (2)\n will operate properly with a modified version of the library, if\n the user installs one, as long as the modified version is\n interface-compatible with the version that the work was made with.\n\n c) Accompany the work with a written offer, valid for at\n least three years, to give the same user the materials\n specified in Subsection 6a, above, for a charge no more\n than the cost of performing this distribution.\n\n d) If distribution of the work is made by offering access to copy\n from a designated place, offer equivalent access to copy the above\n specified materials from the same place.\n\n e) Verify that the user has already received a copy of these\n materials or that you have already sent this user a copy.\n\n For an executable, the required form of the \"work that uses the\n Library\" must include any data and utility programs needed for\n reproducing the executable from it. However, as a special exception,\n the materials to be distributed need not include anything that is\n normally distributed (in either source or binary form) with the major\n components (compiler, kernel, and so on) of the operating system on\n which the executable runs, unless that component itself accompanies\n the executable.\n\n It may happen that this requirement contradicts the license\n restrictions of other proprietary libraries that do not normally\n accompany the operating system. Such a contradiction means you cannot\n use both them and the Library together in an executable that you\n distribute.\n\n 7. You may place library facilities that are a work based on the\n Library side-by-side in a single library together with other library\n facilities not covered by this License, and distribute such a combined\n library, provided that the separate distribution of the work based on\n the Library and of the other library facilities is otherwise\n permitted, and provided that you do these two things:\n\n a) Accompany the combined library with a copy of the same work\n based on the Library, uncombined with any other library\n facilities. This must be distributed under the terms of the\n Sections above.\n\n b) Give prominent notice with the combined library of the fact\n that part of it is a work based on the Library, and explaining\n where to find the accompanying uncombined form of the same work.\n\n 8. You may not copy, modify, sublicense, link with, or distribute\n the Library except as expressly provided under this License. Any\n attempt otherwise to copy, modify, sublicense, link with, or\n distribute the Library is void, and will automatically terminate your\n rights under this License. However, parties who have received copies,\n or rights, from you under this License will not have their licenses\n terminated so long as such parties remain in full compliance.\n\n 9. You are not required to accept this License, since you have not\n signed it. However, nothing else grants you permission to modify or\n distribute the Library or its derivative works. These actions are\n prohibited by law if you do not accept this License. Therefore, by\n modifying or distributing the Library (or any work based on the\n Library), you indicate your acceptance of this License to do so, and\n all its terms and conditions for copying, distributing or modifying\n the Library or works based on it.\n\n 10. Each time you redistribute the Library (or any work based on the\n Library), the recipient automatically receives a license from the\n original licensor to copy, distribute, link with or modify the Library\n subject to these terms and conditions. You may not impose any further\n restrictions on the recipients' exercise of the rights granted herein.\n You are not responsible for enforcing compliance by third parties with\n this License.\n\n 11. If, as a consequence of a court judgment or allegation of patent\n infringement or for any other reason (not limited to patent issues),\n conditions are imposed on you (whether by court order, agreement or\n otherwise) that contradict the conditions of this License, they do not\n excuse you from the conditions of this License. If you cannot\n distribute so as to satisfy simultaneously your obligations under this\n License and any other pertinent obligations, then as a consequence you\n may not distribute the Library at all. For example, if a patent\n license would not permit royalty-free redistribution of the Library by\n all those who receive copies directly or indirectly through you, then\n the only way you could satisfy both it and this License would be to\n refrain entirely from distribution of the Library.\n\n If any portion of this section is held invalid or unenforceable under any\n particular circumstance, the balance of the section is intended to apply,\n and the section as a whole is intended to apply in other circumstances.\n\n It is not the purpose of this section to induce you to infringe any\n patents or other property right claims or to contest validity of any\n such claims; this section has the sole purpose of protecting the\n integrity of the free software distribution system which is\n implemented by public license practices. Many people have made\n generous contributions to the wide range of software distributed\n through that system in reliance on consistent application of that\n system; it is up to the author/donor to decide if he or she is willing\n to distribute software through any other system and a licensee cannot\n impose that choice.\n\n This section is intended to make thoroughly clear what is believed to\n be a consequence of the rest of this License.\n\n 12. If the distribution and/or use of the Library is restricted in\n certain countries either by patents or by copyrighted interfaces, the\n original copyright holder who places the Library under this License may add\n an explicit geographical distribution limitation excluding those countries,\n so that distribution is permitted only in or among countries not thus\n excluded. In such case, this License incorporates the limitation as if\n written in the body of this License.\n\n 13. The Free Software Foundation may publish revised and/or new\n versions of the Lesser General Public License from time to time.\n Such new versions will be similar in spirit to the present version,\n but may differ in detail to address new problems or concerns.\n\n Each version is given a distinguishing version number. If the Library\n specifies a version number of this License which applies to it and\n \"any later version\", you have the option of following the terms and\n conditions either of that version or of any later version published by\n the Free Software Foundation. If the Library does not specify a\n license version number, you may choose any version ever published by\n the Free Software Foundation.\n\n 14. If you wish to incorporate parts of the Library into other free\n programs whose distribution conditions are incompatible with these,\n write to the author to ask for permission. For software which is\n copyrighted by the Free Software Foundation, write to the Free\n Software Foundation; we sometimes make exceptions for this. Our\n decision will be guided by the two goals of preserving the free status\n of all derivatives of our free software and of promoting the sharing\n and reuse of software generally.\n\n NO WARRANTY\n\n 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\n WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\n EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\n OTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY\n KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\n LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\n THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\n WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\n AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\n FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\n CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\n LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\n RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\n FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\n SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\n DAMAGES.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Libraries\n\n If you develop a new library, and you want it to be of the greatest\n possible use to the public, we recommend making it free software that\n everyone can redistribute and change. You can do so by permitting\n redistribution under these terms (or, alternatively, under the terms of the\n ordinary General Public License).\n\n To apply these terms, attach the following notices to the library. It is\n safest to attach them to the start of each source file to most effectively\n convey the exclusion of warranty; and each file should have at least the\n \"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation; either\n version 2.1 of the License, or (at your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n\n Also add information on how to contact you by electronic and paper mail.\n\n You should also get your employer (if you work as a programmer) or your\n school, if any, to sign a \"copyright disclaimer\" for the library, if\n necessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\n library `Frob' (a library for tweaking knobs) written by James Random Hacker.\n\n , 1 April 1990\n Ty Coon, President of Vice\n\n That's all there is to it!\n\n ----------------------------------------------------------------------\n\n* libssh2 - https://www.libssh2.org/license.html\n\n Copyright (c) 2004-2007 Sara Golemon \n Copyright (c) 2005,2006 Mikhail Gusarov \n Copyright (c) 2006-2007 The Written Word, Inc.\n Copyright (c) 2007 Eli Fant \n Copyright (c) 2009 Daniel Stenberg\n Copyright (C) 2008, 2009 Simon Josefsson\n All rights reserved.\n\n Redistribution and use in source and binary forms,\n with or without modification, are permitted provided\n that the following conditions are met:\n\n Redistributions of source code must retain the above\n copyright notice, this list of conditions and the\n following disclaimer.\n\n Redistributions in binary form must reproduce the above\n copyright notice, this list of conditions and the following\n disclaimer in the documentation and/or other materials\n provided with the distribution.\n\n Neither the name of the copyright holder nor the names\n of any other contributors may be used to endorse or\n promote products derived from this software without\n specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND\n CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\n INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,\n BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\n WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE\n USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY\n OF SUCH DAMAGE.\n\n* libcurl - https://curl.haxx.se/docs/copyright.html\n\n COPYRIGHT AND PERMISSION NOTICE\n\n Copyright (c) 1996 - 2014, Daniel Stenberg, daniel@haxx.se.\n\n All rights reserved.\n\n Permission to use, copy, modify, and distribute this software for any\n purpose with or without fee is hereby granted, provided that the above\n copyright notice and this permission notice appear in all copies.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.\n IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n Except as contained in this notice, the name of a copyright holder shall not\n be used in advertising or otherwise to promote the sale, use or other\n dealings in this Software without prior written authorization of the\n copyright holder.\n\n* flate2-rs - https://github.com/alexcrichton/flate2-rs/blob/master/LICENSE-MIT\n* link-config - https://github.com/alexcrichton/link-config/blob/master/LICENSE-MIT\n* openssl-static-sys - https://github.com/alexcrichton/openssl-static-sys/blob/master/LICENSE-MIT\n* toml-rs - https://github.com/alexcrichton/toml-rs/blob/master/LICENSE-MIT\n* libssh2-static-sys - https://github.com/alexcrichton/libssh2-static-sys/blob/master/LICENSE-MIT\n* git2-rs - https://github.com/alexcrichton/git2-rs/blob/master/LICENSE-MIT\n* tar-rs - https://github.com/alexcrichton/tar-rs/blob/master/LICENSE-MIT\n\n Copyright (c) 2014 Alex Crichton\n\n Permission is hereby granted, free of charge, to any\n person obtaining a copy of this software and associated\n documentation files (the \"Software\"), to deal in the\n Software without restriction, including without\n limitation the rights to use, copy, modify, merge,\n publish, distribute, sublicense, and/or sell copies of\n the Software, and to permit persons to whom the Software\n is furnished to do so, subject to the following\n conditions:\n\n The above copyright notice and this permission notice\n shall be included in all copies or substantial portions\n of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\n ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\n TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\n PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\n SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\n IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n\n* glob - https://github.com/rust-lang/glob/blob/master/LICENSE-MIT\n* semver - https://github.com/rust-lang/semver/blob/master/LICENSE-MIT\n\n Copyright (c) 2014 The Rust Project Developers\n\n Permission is hereby granted, free of charge, to any\n person obtaining a copy of this software and associated\n documentation files (the \"Software\"), to deal in the\n Software without restriction, including without\n limitation the rights to use, copy, modify, merge,\n publish, distribute, sublicense, and/or sell copies of\n the Software, and to permit persons to whom the Software\n is furnished to do so, subject to the following\n conditions:\n\n The above copyright notice and this permission notice\n shall be included in all copies or substantial portions\n of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\n ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\n TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\n PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\n SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\n IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n\n* rust-url - https://github.com/servo/rust-url/blob/master/LICENSE-MIT\n\n Copyright (c) 2006-2009 Graydon Hoare\n Copyright (c) 2009-2013 Mozilla Foundation\n\n Permission is hereby granted, free of charge, to any\n person obtaining a copy of this software and associated\n documentation files (the \"Software\"), to deal in the\n Software without restriction, including without\n limitation the rights to use, copy, modify, merge,\n publish, distribute, sublicense, and/or sell copies of\n the Software, and to permit persons to whom the Software\n is furnished to do so, subject to the following\n conditions:\n\n The above copyright notice and this permission notice\n shall be included in all copies or substantial portions\n of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\n ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\n TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\n PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\n SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\n IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n\n* rust-encoding - https://github.com/lifthrasiir/rust-encoding/blob/master/LICENSE.txt\n\n The MIT License (MIT)\n\n Copyright (c) 2013, Kang Seonghoon.\n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n\n* curl-rust - https://github.com/carllerche/curl-rust/blob/master/LICENSE\n\n Copyright (c) 2014 Carl Lerche\n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n\n* docopt.rs - https://github.com/docopt/docopt.rs/blob/master/UNLICENSE\n\n This is free and unencumbered software released into the public domain.\n\n Anyone is free to copy, modify, publish, use, compile, sell, or\n distribute this software, either in source code form or as a compiled\n binary, for any purpose, commercial or non-commercial, and by any\n means.\n\n In jurisdictions that recognize copyright laws, the author or authors\n of this software dedicate any and all copyright interest in the\n software to the public domain. We make this dedication for the benefit\n of the public at large and to the detriment of our heirs and\n successors. We intend this dedication to be an overt act of\n relinquishment in perpetuity of all present and future rights to this\n software under copyright law.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR\n OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\n ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n OTHER DEALINGS IN THE SOFTWARE.\n\n For more information, please refer to \n\n" }, { "path": "README.md", "content": "# Cargo\n\nCargo downloads your Rust projectā€™s dependencies and compiles your project.\n\n**To start using Cargo**, learn more at [The Cargo Book].\n\n**To start developing Cargo itself**, read the [Cargo Contributor Guide].\n\n[The Cargo Book]: https://doc.rust-lang.org/cargo/\n[Cargo Contributor Guide]: https://rust-lang.github.io/cargo/contrib/\n\n> The Cargo binary distributed through with Rust is maintained by the Cargo\n> team for use by the wider ecosystem.\n> For all other uses of this crate (as a binary or library) this is maintained\n> by the Cargo team, primarily for use by Cargo and not intended for external\n> use (except as a transitive dependency). This crate may make major changes to\n> its APIs.\n\n## Code Status\n\n[![CI](https://github.com/rust-lang/cargo/actions/workflows/main.yml/badge.svg?branch=auto-cargo)](https://github.com/rust-lang/cargo/actions/workflows/main.yml)\n\nCode documentation: \n\n## Compiling from Source\n\n### Requirements\n\nCargo requires the following tools and packages to build:\n\n* `cargo` and `rustc`\n* A C compiler [for your platform](https://github.com/rust-lang/cc-rs#compile-time-requirements)\n* `git` (to clone this repository)\n\n**Other requirements:**\n\nThe following are optional based on your platform and needs.\n\n* `pkg-config` ā€” This is used to help locate system packages, such as `libssl` headers/libraries. This may not be required in all cases, such as using vendored OpenSSL, or on Windows.\n* OpenSSL ā€” Only needed on Unix-like systems and only if the `vendored-openssl` Cargo feature is not used.\n\n This requires the development headers, which can be obtained from the `libssl-dev` package on Ubuntu or `openssl-devel` with apk or yum or the `openssl` package from Homebrew on macOS.\n\n If using the `vendored-openssl` Cargo feature, then a static copy of OpenSSL will be built from source instead of using the system OpenSSL.\n This may require additional tools such as `perl` and `make`.\n\n On macOS, common installation directories from Homebrew, MacPorts, or pkgsrc will be checked. Otherwise it will fall back to `pkg-config`.\n\n On Windows, the system-provided Schannel will be used instead.\n\n LibreSSL is also supported.\n\n**Optional system libraries:**\n\nThe build will automatically use vendored versions of the following libraries. However, if they are provided by the system and can be found with `pkg-config`, then the system libraries will be used instead:\n\n* [`libcurl`](https://curl.se/libcurl/) ā€” Used for network transfers.\n* [`libgit2`](https://libgit2.org/) ā€” Used for fetching git dependencies.\n* [`libssh2`](https://www.libssh2.org/) ā€” Used for SSH access to git repositories.\n* [`libz`](https://zlib.net/) (AKA zlib) ā€” Used by the above C libraries for data compression. (Rust code uses [`zlib-rs`](https://github.com/trifectatechfoundation/zlib-rs) instead.)\n\nIt is recommended to use the vendored versions as they are the versions that are tested to work with Cargo.\n\n### Compiling\n\nFirst, you'll want to check out this repository\n\n```\ngit clone https://github.com/rust-lang/cargo.git\ncd cargo\n```\n\nWith `cargo` already installed, you can simply run:\n\n```\ncargo build --release\n```\n\n## Adding new subcommands to Cargo\n\nCargo is designed to be extensible with new subcommands without having to modify\nCargo itself. See [the Wiki page][third-party-subcommands] for more details and\na list of known community-developed subcommands.\n\n[third-party-subcommands]: https://github.com/rust-lang/cargo/wiki/Third-party-cargo-subcommands\n\n\n## Releases\n\nCargo releases coincide with Rust releases.\nHigh level release notes are available as part of [Rust's release notes][rel].\nDetailed release notes are available in the [changelog].\n\n[rel]: https://github.com/rust-lang/rust/blob/master/RELEASES.md\n[changelog]: https://doc.rust-lang.org/nightly/cargo/CHANGELOG.html\n\n## Reporting issues\n\nFound a bug? We'd love to know about it!\n\nPlease report all issues on the GitHub [issue tracker][issues].\n\n[issues]: https://github.com/rust-lang/cargo/issues\n\n## Contributing\n\nSee the **[Cargo Contributor Guide]** for a complete introduction\nto contributing to Cargo.\n\n## License\n\nCargo is primarily distributed under the terms of both the MIT license\nand the Apache License (Version 2.0).\n\nSee [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT) for details.\n\n### Third party software\n\nThis product includes software developed by the OpenSSL Project\nfor use in the OpenSSL Toolkit (https://www.openssl.org/).\n\nIn binary form, this product includes software that is licensed under the\nterms of the GNU General Public License, version 2, with a linking exception,\nwhich can be obtained from the [upstream repository][1].\n\nSee [LICENSE-THIRD-PARTY](LICENSE-THIRD-PARTY) for details.\n\n[1]: https://github.com/libgit2/libgit2\n\n" }, { "path": "benches/README.md", "content": "# Cargo Benchmarking\n\nThis directory contains some benchmarks for cargo itself. This uses\n[Criterion] for running benchmarks. It is recommended to read the Criterion\nbook to get familiar with how to use it. A basic usage would be:\n\n```sh\ncd benches/benchsuite\ncargo bench\n```\n\nHowever, running all benchmarks would take many minutes, so in most cases it\nis recommended to just run the benchmarks relevant to whatever section of code\nyou are working on.\n\n## Benchmarks\n\nThere are several different kinds of benchmarks in the `benchsuite/benches` directory:\n\n* `global_cache_tracker` ā€” Benchmarks saving data to the global cache tracker\n database using samples of real-world data.\n* `resolve` ā€” Benchmarks the resolver against simulations of real-world workspaces.\n* `workspace_initialization` ā€” Benchmarks initialization of a workspace\n against simulations of real-world workspaces.\n\n### Resolve benchmarks\n\nThe resolve benchmarks involve downloading the index and benchmarking against some\nreal-world and artificial workspaces located in the [`workspaces`](workspaces)\ndirectory.\n\n**Beware** that the initial download can take a fairly long amount of time (10\nminutes minimum on an extremely fast network) and require significant disk\nspace (around 4.5GB). The benchsuite will cache the index and downloaded\ncrates in the `target/tmp/bench` directory, so subsequent runs should be\nfaster. You can (and probably should) specify individual benchmarks to run to\nnarrow it down to a more reasonable set, for example:\n\n```sh\ncargo bench -p benchsuite --bench resolve -- resolve_ws/rust\n```\n\nThis will only download what's necessary for the rust-lang/rust workspace\n(which is about 330MB) and run the benchmarks against it (which should take\nabout a minute). To get a list of all the benchmarks, run:\n\n```sh\ncargo bench -p benchsuite --bench resolve -- --list\n```\n\n### Global cache tracker\n\nThe `global_cache_tracker` benchmark tests saving data to the global cache\ntracker database using samples of real-world data. This benchmark should run\nrelatively quickly.\n\nThe real-world data is based on a capture of my personal development\nenvironment which has accumulated a large cache. So it is somewhat arbitrary,\nbut hopefully representative of a challenging environment. Capturing of the\ndata is done with the `capture-last-use` binary, which you can run if you need\nto rebuild the database. Just try to run on a system with a relatively full\ncache in your cargo home directory.\n\n```sh\ncargo bench -p benchsuite --bench global_cache_tracker\n```\n\n## Viewing reports\n\nThe benchmarks display some basic information on the command-line while they\nrun. A more complete HTML report can be found at\n`target/criterion/report/index.html` which contains links to all the\nbenchmarks and summaries. Check out the Criterion book for more information on\nthe extensive reporting capabilities.\n\n## Comparing implementations\n\nKnowing the raw numbers can be useful, but what you're probably most\ninterested in is checking if your changes help or hurt performance. To do\nthat, you need to run the benchmarks multiple times.\n\nFirst, run the benchmarks from the master branch of cargo without any changes.\nTo make it easier to compare, Criterion supports naming the baseline so that\nyou can iterate on your code and compare against it multiple times.\n\n```sh\ncargo bench -- --save-baseline master\n```\n\nNow you can switch to your branch with your changes. Re-run the benchmarks\ncompared against the baseline:\n\n```sh\ncargo bench -- --baseline master\n```\n\nYou can repeat the last command as you make changes to re-compare against the\nmaster baseline.\n\nWithout the baseline arguments, it will compare against the last run, which\ncan be helpful for comparing incremental changes.\n\n## Capturing workspaces\n\nThe [`workspaces`](workspaces) directory contains several workspaces that\nprovide a variety of different workspaces intended to provide good exercises\nfor benchmarks. Some of these are shadow copies of real-world workspaces. This\nis done with the tool in the [`capture`](capture) directory. The tool will\ncopy `Cargo.lock` and all of the `Cargo.toml` files of the workspace members.\nIt also adds an empty `lib.rs` so Cargo won't error, and sanitizes the\n`Cargo.toml` to some degree, removing unwanted elements. Finally, it\ncompresses everything into a `tgz`.\n\nTo run it, do:\n\n```sh\ncd benches/capture\ncargo run -- /path/to/workspace/foo\n```\n\nThe resolver benchmarks also support the `CARGO_BENCH_WORKSPACES` environment\nvariable, which you can point to a Cargo workspace if you want to try\ndifferent workspaces. For example:\n\n```sh\nCARGO_BENCH_WORKSPACES=/path/to/some/workspace cargo bench\n```\n\n## TODO\n\nThis is just a start for establishing a benchmarking suite for Cargo. There's\na lot that can be added. Some ideas:\n\n* Fix the benchmarks so that the resolver setup doesn't run every iteration.\n* Benchmark [this section of\n code](https://github.com/rust-lang/cargo/blob/a821e2cb24d7b6013433f069ab3bad53d160e100/src/cargo/ops/cargo_compile.rs#L470-L549)\n which builds the unit graph. The performance there isn't great, and it would\n be good to keep an eye on it. Unfortunately that would mean doing a bit of\n work to make `generate_targets` publicly visible, and there is a bunch of\n setup code that may need to be duplicated.\n* Benchmark the fingerprinting code.\n* Benchmark running the `cargo` executable. Running something like `cargo\n build` or `cargo check` with everything \"Fresh\" would be a good end-to-end\n exercise to measure the overall overhead of Cargo.\n* Benchmark pathological resolver scenarios. There might be some cases where\n the resolver can spend a significant amount of time. It would be good to\n identify if these exist, and create benchmarks for them. This may require\n creating an artificial index, similar to the `resolver-tests`. This should\n also consider scenarios where the resolver ultimately fails.\n* Benchmark without `Cargo.lock`. I'm not sure if this is particularly\n valuable, since we are mostly concerned with incremental builds which will\n always have a lock file.\n* Benchmark just\n [`resolve::resolve`](https://github.com/rust-lang/cargo/blob/a821e2cb24d7b6013433f069ab3bad53d160e100/src/cargo/core/resolver/mod.rs#L122)\n without anything else. This can help focus on just the resolver.\n\n[Criterion]: https://bheisler.github.io/criterion.rs/book/\n" }, { "path": "benches/benchsuite/Cargo.toml", "content": "[package]\nname = \"benchsuite\"\nversion = \"0.0.0\"\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"Benchmarking suite for Cargo.\"\npublish = false\n\n[dependencies]\ncargo.workspace = true\ncargo-util.workspace = true\ncriterion.workspace = true\nflate2.workspace = true\nrand.workspace = true\ntar.workspace = true\nurl.workspace = true\n\n[lib]\nbench = false\n\n[[bench]]\nname = \"resolve\"\nharness = false\n\n[[bench]]\nname = \"workspace_initialization\"\nharness = false\n\n[[bench]]\nname = \"global_cache_tracker\"\nharness = false\n\n[lints]\nworkspace = true\n" }, { "path": "benches/benchsuite/README.md", "content": "> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use. This\n> crate may make major changes to its APIs or be deprecated without warning.\n" }, { "path": "benches/benchsuite/benches/global_cache_tracker.rs", "content": "//! Benchmarks for the global cache tracker.\n\nuse cargo::core::global_cache_tracker::{self, DeferredGlobalLastUse, GlobalCacheTracker};\nuse cargo::util::GlobalContext;\nuse cargo::util::cache_lock::CacheLockMode;\nuse cargo::util::interning::InternedString;\nuse criterion::{Criterion, criterion_group, criterion_main};\nuse std::fs;\nuse std::path::{Path, PathBuf};\n\n// Samples of real-world data.\nconst GLOBAL_CACHE_SAMPLE: &str = \"global-cache-tracker/global-cache-sample\";\nconst GLOBAL_CACHE_RANDOM: &str = \"global-cache-tracker/random-sample\";\n\n/// A scratch directory where the benchmark can place some files.\nfn root() -> PathBuf {\n let mut p = PathBuf::from(env!(\"CARGO_TARGET_TMPDIR\"));\n p.push(\"bench_global_cache_tracker\");\n p\n}\n\nfn cargo_home() -> PathBuf {\n let mut p = root();\n p.push(\"chome\");\n p\n}\n\nfn initialize_context() -> GlobalContext {\n // Set up config.\n let shell = cargo::core::Shell::new();\n let homedir = cargo_home();\n if !homedir.exists() {\n fs::create_dir_all(&homedir).unwrap();\n }\n let cwd = homedir.clone();\n let mut gctx = GlobalContext::new(shell, cwd, homedir);\n gctx.nightly_features_allowed = true;\n gctx.set_search_stop_path(root());\n gctx.configure(\n 0,\n false,\n None,\n false,\n false,\n false,\n &None,\n &[\"gc\".to_string()],\n &[],\n )\n .unwrap();\n // Set up database sample.\n let db_path = GlobalCacheTracker::db_path(&gctx).into_path_unlocked();\n if db_path.exists() {\n fs::remove_file(&db_path).unwrap();\n }\n let sample = Path::new(env!(\"CARGO_MANIFEST_DIR\")).join(GLOBAL_CACHE_SAMPLE);\n fs::copy(sample, &db_path).unwrap();\n gctx\n}\n\n/// Benchmarks how long it takes to initialize `GlobalCacheTracker` with an already\n/// existing full database.\nfn global_tracker_init(c: &mut Criterion) {\n let gctx = initialize_context();\n let _lock = gctx\n .acquire_package_cache_lock(CacheLockMode::DownloadExclusive)\n .unwrap();\n c.bench_function(\"global_tracker_init\", |b| {\n b.iter(|| {\n GlobalCacheTracker::new(&gctx).unwrap();\n })\n });\n}\n\n/// Benchmarks how long it takes to save a `GlobalCacheTracker` when there are zero\n/// updates.\nfn global_tracker_empty_save(c: &mut Criterion) {\n let gctx = initialize_context();\n let _lock = gctx\n .acquire_package_cache_lock(CacheLockMode::DownloadExclusive)\n .unwrap();\n let mut deferred = DeferredGlobalLastUse::new();\n let mut tracker = GlobalCacheTracker::new(&gctx).unwrap();\n\n c.bench_function(\"global_tracker_empty_save\", |b| {\n b.iter(|| {\n deferred.save(&mut tracker).unwrap();\n })\n });\n}\n\nfn load_random_sample() -> Vec<(InternedString, InternedString, u64)> {\n let path = Path::new(env!(\"CARGO_MANIFEST_DIR\")).join(GLOBAL_CACHE_RANDOM);\n fs::read_to_string(path)\n .unwrap()\n .lines()\n .map(|s| {\n let mut s = s.split(',');\n (\n s.next().unwrap().into(),\n s.next().unwrap().into(),\n s.next().unwrap().parse().unwrap(),\n )\n })\n .collect()\n}\n\n/// Tests performance of updating the last-use timestamps in an already\n/// populated database.\n///\n/// This runs for different sizes of number of crates to update (selecting\n/// from the random sample stored on disk).\nfn global_tracker_update(c: &mut Criterion) {\n let gctx = initialize_context();\n let _lock = gctx\n .acquire_package_cache_lock(CacheLockMode::DownloadExclusive)\n .unwrap();\n let sample = Path::new(env!(\"CARGO_MANIFEST_DIR\")).join(GLOBAL_CACHE_SAMPLE);\n let db_path = GlobalCacheTracker::db_path(&gctx).into_path_unlocked();\n\n let random_sample = load_random_sample();\n\n let mut group = c.benchmark_group(\"global_tracker_update\");\n for size in [1, 10, 100, 500] {\n if db_path.exists() {\n fs::remove_file(&db_path).unwrap();\n }\n\n fs::copy(&sample, &db_path).unwrap();\n let mut deferred = DeferredGlobalLastUse::new();\n let mut tracker = GlobalCacheTracker::new(&gctx).unwrap();\n group.bench_with_input(size.to_string(), &size, |b, &size| {\n b.iter(|| {\n for (encoded_registry_name, name, size) in &random_sample[..size] {\n deferred.mark_registry_crate_used(global_cache_tracker::RegistryCrate {\n encoded_registry_name: *encoded_registry_name,\n crate_filename: format!(\"{}.crate\", name).into(),\n size: *size,\n });\n deferred.mark_registry_src_used(global_cache_tracker::RegistrySrc {\n encoded_registry_name: *encoded_registry_name,\n package_dir: *name,\n size: Some(*size),\n });\n }\n deferred.save(&mut tracker).unwrap();\n })\n });\n }\n}\n\ncriterion_group!(\n benches,\n global_tracker_init,\n global_tracker_empty_save,\n global_tracker_update\n);\ncriterion_main!(benches);\n" }, { "path": "benches/benchsuite/benches/resolve.rs", "content": "use benchsuite::fixtures;\nuse cargo::GlobalContext;\nuse cargo::core::compiler::{CompileKind, RustcTargetData};\nuse cargo::core::resolver::features::{FeatureOpts, FeatureResolver};\nuse cargo::core::resolver::{CliFeatures, ForceAllTargets, HasDevUnits, ResolveBehavior};\nuse cargo::core::{PackageIdSpec, Workspace};\nuse cargo::ops::WorkspaceResolve;\nuse criterion::{Criterion, criterion_group, criterion_main};\nuse std::path::Path;\n\nstruct ResolveInfo<'gctx> {\n ws: Workspace<'gctx>,\n requested_kinds: [CompileKind; 1],\n target_data: RustcTargetData<'gctx>,\n cli_features: CliFeatures,\n specs: Vec,\n has_dev_units: HasDevUnits,\n force_all_targets: ForceAllTargets,\n ws_resolve: WorkspaceResolve<'gctx>,\n}\n\n/// Helper for resolving a workspace. This will run the resolver once to\n/// download everything, and returns all the data structures that are used\n/// during resolution.\nfn do_resolve<'gctx>(gctx: &'gctx GlobalContext, ws_root: &Path) -> ResolveInfo<'gctx> {\n let requested_kinds = [CompileKind::Host];\n let ws = Workspace::new(&ws_root.join(\"Cargo.toml\"), gctx).unwrap();\n let mut target_data = RustcTargetData::new(&ws, &requested_kinds).unwrap();\n let cli_features = CliFeatures::from_command_line(&[], false, true).unwrap();\n let pkgs = cargo::ops::Packages::Default;\n let specs = pkgs.to_package_id_specs(&ws).unwrap();\n let has_dev_units = HasDevUnits::Yes;\n let force_all_targets = ForceAllTargets::No;\n // Do an initial run to download anything necessary so that it does\n // not confuse criterion's warmup.\n let dry_run = false;\n let ws_resolve = cargo::ops::resolve_ws_with_opts(\n &ws,\n &mut target_data,\n &requested_kinds,\n &cli_features,\n &specs,\n has_dev_units,\n force_all_targets,\n dry_run,\n )\n .unwrap();\n ResolveInfo {\n ws,\n requested_kinds,\n target_data,\n cli_features,\n specs,\n has_dev_units,\n force_all_targets,\n ws_resolve,\n }\n}\n\n/// Benchmark of the full `resolve_ws_with_opts` which runs the resolver\n/// twice, the feature resolver, and more. This is a major component of a\n/// regular cargo build.\nfn resolve_ws(c: &mut Criterion) {\n let fixtures = fixtures!();\n let mut group = c.benchmark_group(\"resolve_ws\");\n for (ws_name, ws_root) in fixtures.workspaces() {\n let gctx = fixtures.make_context(&ws_root);\n // The resolver info is initialized only once in a lazy fashion. This\n // allows criterion to skip this workspace if the user passes a filter\n // on the command-line (like `cargo bench -- resolve_ws/tikv`).\n //\n // Due to the way criterion works, it tends to only run the inner\n // iterator once, and we don't want to call `do_resolve` in every\n // \"step\", since that would just be some useless work.\n let mut lazy_info = None;\n let dry_run = false;\n group.bench_function(&ws_name, |b| {\n let ResolveInfo {\n ws,\n requested_kinds,\n target_data,\n cli_features,\n specs,\n has_dev_units,\n force_all_targets,\n ..\n } = lazy_info.get_or_insert_with(|| do_resolve(&gctx, &ws_root));\n b.iter(|| {\n cargo::ops::resolve_ws_with_opts(\n ws,\n target_data,\n requested_kinds,\n cli_features,\n specs,\n *has_dev_units,\n *force_all_targets,\n dry_run,\n )\n .unwrap();\n })\n });\n }\n group.finish();\n}\n\n/// Benchmark of the feature resolver.\nfn feature_resolver(c: &mut Criterion) {\n let fixtures = fixtures!();\n let mut group = c.benchmark_group(\"feature_resolver\");\n for (ws_name, ws_root) in fixtures.workspaces() {\n let gctx = fixtures.make_context(&ws_root);\n let mut lazy_info = None;\n group.bench_function(&ws_name, |b| {\n let ResolveInfo {\n ws,\n requested_kinds,\n target_data,\n cli_features,\n specs,\n has_dev_units,\n ws_resolve,\n ..\n } = lazy_info.get_or_insert_with(|| do_resolve(&gctx, &ws_root));\n b.iter(|| {\n let feature_opts = FeatureOpts::new_behavior(ResolveBehavior::V2, *has_dev_units);\n FeatureResolver::resolve(\n ws,\n target_data,\n &ws_resolve.targeted_resolve,\n &ws_resolve.pkg_set,\n cli_features,\n specs,\n requested_kinds,\n feature_opts,\n )\n .unwrap();\n })\n });\n }\n group.finish();\n}\n\n// Criterion complains about the measurement time being too small, but the\n// measurement time doesn't seem important to me, what is more important is\n// the number of iterations which defaults to 100, which seems like a\n// reasonable default. Otherwise, the measurement time would need to be\n// changed per workspace. We wouldn't want to spend 60s on every workspace,\n// that would take too long and isn't necessary for the smaller workspaces.\ncriterion_group!(benches, resolve_ws, feature_resolver);\ncriterion_main!(benches);\n" }, { "path": "benches/benchsuite/benches/workspace_initialization.rs", "content": "use benchsuite::fixtures;\nuse cargo::core::Workspace;\nuse criterion::{Criterion, criterion_group, criterion_main};\n\nfn workspace_initialization(c: &mut Criterion) {\n let fixtures = fixtures!();\n let mut group = c.benchmark_group(\"workspace_initialization\");\n for (ws_name, ws_root) in fixtures.workspaces() {\n let gctx = fixtures.make_context(&ws_root);\n // The resolver info is initialized only once in a lazy fashion. This\n // allows criterion to skip this workspace if the user passes a filter\n // on the command-line (like `cargo bench -- workspace_initialization/tikv`).\n group.bench_function(ws_name, |b| {\n b.iter(|| Workspace::new(&ws_root.join(\"Cargo.toml\"), &gctx).unwrap())\n });\n }\n group.finish();\n}\n\n// Criterion complains about the measurement time being too small, but the\n// measurement time doesn't seem important to me, what is more important is\n// the number of iterations which defaults to 100, which seems like a\n// reasonable default. Otherwise, the measurement time would need to be\n// changed per workspace. We wouldn't want to spend 60s on every workspace,\n// that would take too long and isn't necessary for the smaller workspaces.\ncriterion_group!(benches, workspace_initialization);\ncriterion_main!(benches);\n" }, { "path": "benches/benchsuite/global-cache-tracker/random-sample", "content": "github.com-1ecc6299db9ec823,tungstenite-0.18.0,218740\ngithub.com-1ecc6299db9ec823,integer-encoding-1.1.5,30672\ngithub.com-1ecc6299db9ec823,tungstenite-0.14.0,315676\ngithub.com-1ecc6299db9ec823,oxcable-0.5.1,163196\ngithub.com-1ecc6299db9ec823,swc_ecma_transforms_typescript-0.32.0,245522\ngithub.com-1ecc6299db9ec823,hyper-0.12.35,601153\ngithub.com-1ecc6299db9ec823,resiter-0.4.0,59880\ngithub.com-1ecc6299db9ec823,net2-0.2.37,115813\ngithub.com-1ecc6299db9ec823,str_inflector-0.12.0,182460\ngithub.com-1ecc6299db9ec823,derive_builder_macro-0.10.2,16441\ngithub.com-1ecc6299db9ec823,smol_str-0.1.23,42436\ngithub.com-1ecc6299db9ec823,wasm-bindgen-multi-value-xform-0.2.83,35347\ngithub.com-1ecc6299db9ec823,time-macros-0.1.0,1620\ngithub.com-1ecc6299db9ec823,unicode-bidi-0.3.7,140153\ngithub.com-1ecc6299db9ec823,socket2-0.4.0,167295\ngithub.com-1ecc6299db9ec823,ppv-lite86-0.2.10,125234\ngithub.com-1ecc6299db9ec823,tracing-wasm-0.2.1,31449\ngithub.com-1ecc6299db9ec823,eframe-0.19.0,158130\ngithub.com-1ecc6299db9ec823,block-modes-0.7.0,42530\ngithub.com-1ecc6299db9ec823,rangemap-0.1.11,144157\ngithub.com-1ecc6299db9ec823,metal-0.23.1,1038699\ngithub.com-1ecc6299db9ec823,os_str_bytes-6.0.1,86390\ngithub.com-1ecc6299db9ec823,plotters-backend-0.3.4,53018\ngithub.com-1ecc6299db9ec823,spidev-0.4.0,45301\ngithub.com-1ecc6299db9ec823,axum-macros-0.2.3,102058\ngithub.com-1ecc6299db9ec823,embedded-time-0.12.1,246450\ngithub.com-1ecc6299db9ec823,envmnt-0.10.4,2328079\ngithub.com-1ecc6299db9ec823,camino-1.1.1,133976\ngithub.com-1ecc6299db9ec823,siphasher-0.3.5,46666\ngithub.com-1ecc6299db9ec823,lexical-write-integer-0.8.5,388374\ngithub.com-1ecc6299db9ec823,reqwest-0.11.14,686608\ngithub.com-1ecc6299db9ec823,enum-map-2.4.1,51184\ngithub.com-1ecc6299db9ec823,sentry-panic-0.29.0,18211\ngithub.com-1ecc6299db9ec823,msf-srtp-0.2.0,73164\ngithub.com-1ecc6299db9ec823,near-sandbox-utils-0.4.1,7543\ngithub.com-1ecc6299db9ec823,ablescript-0.5.2,129318\ngithub.com-1ecc6299db9ec823,apecs-derive-0.2.3,10620\ngithub.com-1ecc6299db9ec823,libc-0.2.133,3417382\ngithub.com-1ecc6299db9ec823,tracing-0.1.35,380627\ngithub.com-1ecc6299db9ec823,serde-wasm-bindgen-0.3.1,55371\ngithub.com-1ecc6299db9ec823,compiler_builtins-0.1.71,692853\ngithub.com-1ecc6299db9ec823,mockito-0.7.2,1179718\ngithub.com-1ecc6299db9ec823,tonic-0.5.2,420299\ngithub.com-1ecc6299db9ec823,tracing-core-0.1.30,240058\ngithub.com-1ecc6299db9ec823,tower-timeout-0.3.0-alpha.2,7486\ngithub.com-1ecc6299db9ec823,js-intern-0.3.1,7026\ngithub.com-1ecc6299db9ec823,json-ld-context-processing-0.12.1,78101\ngithub.com-1ecc6299db9ec823,generic-array-0.14.6,67349\ngithub.com-1ecc6299db9ec823,synstructure-0.12.3,93523\ngithub.com-1ecc6299db9ec823,version-compare-0.0.10,74950\ngithub.com-1ecc6299db9ec823,dirs-1.0.5,51075\ngithub.com-1ecc6299db9ec823,worker-kv-0.5.1,67351\ngithub.com-1ecc6299db9ec823,vsimd-0.8.0,170805\ngithub.com-1ecc6299db9ec823,mockall-0.9.1,187734\ngithub.com-1ecc6299db9ec823,nan-preserving-float-0.1.0,6341\ngithub.com-1ecc6299db9ec823,wasmer-types-2.3.0,192436\ngithub.com-1ecc6299db9ec823,sodiumoxide-0.2.7,5131115\ngithub.com-1ecc6299db9ec823,tracing-attributes-0.1.11,74857\ngithub.com-1ecc6299db9ec823,treediff-4.0.2,72588\ngithub.com-1ecc6299db9ec823,wiggle-generate-5.0.0,103044\ngithub.com-1ecc6299db9ec823,lapin-1.6.6,497368\ngithub.com-1ecc6299db9ec823,cranelift-entity-0.93.1,114206\ngithub.com-1ecc6299db9ec823,pcap-parser-0.13.3,184131\ngithub.com-1ecc6299db9ec823,rustfft-5.1.1,1638221\ngithub.com-1ecc6299db9ec823,string_cache-0.7.5,75074\ngithub.com-1ecc6299db9ec823,maybe-uninit-2.0.0,38492\ngithub.com-1ecc6299db9ec823,diesel_full_text_search-2.0.0,10179\ngithub.com-1ecc6299db9ec823,quinn-proto-0.8.4,687565\ngithub.com-1ecc6299db9ec823,semver-0.5.1,73365\ngithub.com-1ecc6299db9ec823,rocket_http-0.5.0-rc.2,409939\ngithub.com-1ecc6299db9ec823,dialoguer-0.7.1,95159\ngithub.com-1ecc6299db9ec823,fallible_collections-0.4.5,244152\ngithub.com-1ecc6299db9ec823,parking_lot_core-0.9.0,138932\ngithub.com-1ecc6299db9ec823,relative-path-1.6.0,103315\ngithub.com-1ecc6299db9ec823,lua52-sys-0.1.2,584054\ngithub.com-1ecc6299db9ec823,actix-files-0.6.0,126121\ngithub.com-1ecc6299db9ec823,crates-io-0.35.1,29498\ngithub.com-1ecc6299db9ec823,sentry-backtrace-0.19.1,20268\ngithub.com-1ecc6299db9ec823,text_unit-0.1.10,26100\ngithub.com-1ecc6299db9ec823,ascii-1.0.0,143025\ngithub.com-1ecc6299db9ec823,crossbeam-utils-0.8.6,169542\ngithub.com-1ecc6299db9ec823,nelf-0.1.0,28868\ngithub.com-1ecc6299db9ec823,colorsys-0.6.5,86989\ngithub.com-1ecc6299db9ec823,enum-iterator-1.2.0,31042\ngithub.com-1ecc6299db9ec823,ansi-str-0.7.2,111689\ngithub.com-1ecc6299db9ec823,anyhow-1.0.68,209123\ngithub.com-1ecc6299db9ec823,gix-lock-5.0.1,65110\ngithub.com-1ecc6299db9ec823,nom-supreme-0.8.0,147530\ngithub.com-1ecc6299db9ec823,path-slash-0.1.4,28655\ngithub.com-1ecc6299db9ec823,crates-io-0.35.0,29406\ngithub.com-1ecc6299db9ec823,stb_truetype-0.2.8,22939\ngithub.com-1ecc6299db9ec823,proc-macro2-1.0.50,185288\ngithub.com-1ecc6299db9ec823,snapbox-0.4.1,169526\ngithub.com-1ecc6299db9ec823,hyper-0.14.9,764075\ngithub.com-1ecc6299db9ec823,ab_glyph-0.2.15,61722\ngithub.com-1ecc6299db9ec823,uuid-0.1.18,47889\ngithub.com-1ecc6299db9ec823,data-url-0.2.0,123480\ngithub.com-1ecc6299db9ec823,threadpool-1.7.1,59558\ngithub.com-1ecc6299db9ec823,thiserror-impl-1.0.29,65149\ngithub.com-1ecc6299db9ec823,sha1-0.6.0,31102\ngithub.com-1ecc6299db9ec823,tokio-tls-0.2.1,51467\ngithub.com-1ecc6299db9ec823,locspan-derive-0.6.0,59360\ngithub.com-1ecc6299db9ec823,ureq-1.5.1,249335\ngithub.com-1ecc6299db9ec823,protoc-rust-2.24.1,13459\ngithub.com-1ecc6299db9ec823,serde-1.0.159,509060\ngithub.com-1ecc6299db9ec823,unescape-0.1.0,6047\ngithub.com-1ecc6299db9ec823,data-encoding-2.2.0,113191\ngithub.com-1ecc6299db9ec823,bytestring-1.1.0,23705\ngithub.com-1ecc6299db9ec823,ab_glyph_rasterizer-0.1.8,34773\ngithub.com-1ecc6299db9ec823,syn-0.12.15,912964\ngithub.com-1ecc6299db9ec823,reqwest-0.11.9,656209\ngithub.com-1ecc6299db9ec823,rustls-0.17.0,903717\ngithub.com-1ecc6299db9ec823,term_size-0.3.2,36226\ngithub.com-1ecc6299db9ec823,ordered-float-3.1.0,91357\ngithub.com-1ecc6299db9ec823,cookie-0.2.5,44912\ngithub.com-1ecc6299db9ec823,debugid-0.8.0,44521\ngithub.com-1ecc6299db9ec823,conrod-0.51.1,2154016\ngithub.com-1ecc6299db9ec823,indexmap-1.6.1,247801\ngithub.com-1ecc6299db9ec823,target-spec-1.3.1,68315\ngithub.com-1ecc6299db9ec823,lexical-parse-integer-0.8.6,139671\ngithub.com-1ecc6299db9ec823,time-0.1.38,131629\ngithub.com-1ecc6299db9ec823,glib-macros-0.14.1,102959\ngithub.com-1ecc6299db9ec823,metrics-macros-0.6.0,37750\ngithub.com-1ecc6299db9ec823,structopt-0.3.12,224213\ngithub.com-1ecc6299db9ec823,criterion-0.3.2,439241\ngithub.com-1ecc6299db9ec823,lyon_path-0.17.7,186745\ngithub.com-1ecc6299db9ec823,miette-5.5.0,312945\ngithub.com-1ecc6299db9ec823,tokio-codec-0.2.0-alpha.6,118193\ngithub.com-1ecc6299db9ec823,structopt-derive-0.4.14,84883\ngithub.com-1ecc6299db9ec823,objekt-0.1.2,24191\ngithub.com-1ecc6299db9ec823,sqlx-macros-0.5.7,110890\ngithub.com-1ecc6299db9ec823,systemstat-0.1.10,127295\ngithub.com-1ecc6299db9ec823,colorful-0.2.2,99698\ngithub.com-1ecc6299db9ec823,quick-xml-0.20.0,645935\ngithub.com-1ecc6299db9ec823,selinux-sys-0.6.2,27060\ngithub.com-1ecc6299db9ec823,vsmtp-mail-parser-1.4.0-rc.10,137699\ngithub.com-1ecc6299db9ec823,sec1-0.7.2,64870\ngithub.com-1ecc6299db9ec823,nix-0.22.1,1161830\ngithub.com-1ecc6299db9ec823,snow-0.9.0,2658286\ngithub.com-1ecc6299db9ec823,per_test_directory_macros-0.1.0,2962\ngithub.com-1ecc6299db9ec823,syn-helpers-0.4.3,58801\ngithub.com-1ecc6299db9ec823,terminal_size-0.2.2,29633\ngithub.com-1ecc6299db9ec823,bevy_hierarchy-0.7.0,41018\ngithub.com-1ecc6299db9ec823,dynamic_reload-0.4.0,74455\ngithub.com-1ecc6299db9ec823,http-signature-normalization-actix-0.5.0-beta.14,126857\ngithub.com-1ecc6299db9ec823,http-body-0.4.1,24138\ngithub.com-1ecc6299db9ec823,gix-index-0.13.0,207795\ngithub.com-1ecc6299db9ec823,darling_macro-0.13.1,4156\ngithub.com-1ecc6299db9ec823,serde_json-1.0.66,543072\ngithub.com-1ecc6299db9ec823,minreq-1.4.1,41355\ngithub.com-1ecc6299db9ec823,sct-0.6.1,60974\ngithub.com-1ecc6299db9ec823,openssl-0.10.50,1173941\ngithub.com-1ecc6299db9ec823,bevy_pbr-0.6.0,201163\ngithub.com-1ecc6299db9ec823,security-framework-2.3.1,290512\ngithub.com-1ecc6299db9ec823,pin-project-internal-0.4.30,128419\ngithub.com-1ecc6299db9ec823,serde_yaml-0.7.5,158524\ngithub.com-1ecc6299db9ec823,cid-0.3.2,17269\ngithub.com-1ecc6299db9ec823,plotters-backend-0.3.0,51995\ngithub.com-1ecc6299db9ec823,serde_yaml-0.8.12,179579\ngithub.com-1ecc6299db9ec823,cosmwasm-schema-derive-1.1.9,34956\ngithub.com-1ecc6299db9ec823,docopt-0.6.86,175553\ngithub.com-1ecc6299db9ec823,git-testament-0.2.4,27685\ngithub.com-1ecc6299db9ec823,htmlescape-0.3.1,143378\ngithub.com-1ecc6299db9ec823,is_proc_translated-0.1.1,16533\ngithub.com-1ecc6299db9ec823,futures-macro-0.3.4,33147\ngithub.com-1ecc6299db9ec823,futures-intrusive-0.4.2,520476\ngithub.com-1ecc6299db9ec823,rustix-0.35.13,1581355\ngithub.com-1ecc6299db9ec823,glsl-layout-0.3.2,75515\ngithub.com-1ecc6299db9ec823,darling-0.12.0,67446\ngithub.com-1ecc6299db9ec823,blake3-0.1.5,394136\ngithub.com-1ecc6299db9ec823,async-stripe-0.15.0,3157635\ngithub.com-1ecc6299db9ec823,hbs-common-sys-0.2.1,1034\ngithub.com-1ecc6299db9ec823,base58-0.1.0,7019\ngithub.com-1ecc6299db9ec823,time-0.2.23,342720\ngithub.com-1ecc6299db9ec823,memoffset-0.5.6,27595\ngithub.com-1ecc6299db9ec823,colored-1.9.3,85161\ngithub.com-1ecc6299db9ec823,lrpar-0.13.1,153317\ngithub.com-1ecc6299db9ec823,clap-2.34.0,975823\ngithub.com-1ecc6299db9ec823,chalk-engine-0.55.0,203718\ngithub.com-1ecc6299db9ec823,cosmic-space-0.3.6,800331\ngithub.com-1ecc6299db9ec823,syn-1.0.93,1886902\ngithub.com-1ecc6299db9ec823,futures-core-0.3.5,43430\ngithub.com-1ecc6299db9ec823,prost-derive-0.11.6,99428\ngithub.com-1ecc6299db9ec823,toml_edit-0.15.0,491549\ngithub.com-1ecc6299db9ec823,pcb-llvm-0.2.0,17328\ngithub.com-1ecc6299db9ec823,rusticata-macros-2.1.0,35537\ngithub.com-1ecc6299db9ec823,rustyline-with-hint-fix-10.1.0,548833\ngithub.com-1ecc6299db9ec823,sharded-slab-0.1.1,239224\ngithub.com-1ecc6299db9ec823,literally-0.1.3,20415\ngithub.com-1ecc6299db9ec823,riff-1.0.1,20582\ngithub.com-1ecc6299db9ec823,futures-macro-0.3.23,38691\ngithub.com-1ecc6299db9ec823,criterion-0.3.1,431723\ngithub.com-1ecc6299db9ec823,atty-0.2.14,14567\ngithub.com-1ecc6299db9ec823,vergen-3.1.0,49089\ngithub.com-1ecc6299db9ec823,peeking_take_while-0.1.2,18604\ngithub.com-1ecc6299db9ec823,serde_derive-1.0.156,316173\ngithub.com-1ecc6299db9ec823,geo-0.23.1,1022596\ngithub.com-1ecc6299db9ec823,persy-1.4.3,778219\ngithub.com-1ecc6299db9ec823,futures-lite-1.13.0,214632\ngithub.com-1ecc6299db9ec823,ms_dtyp-0.0.3,44387\ngithub.com-1ecc6299db9ec823,thiserror-1.0.33,66618\ngithub.com-1ecc6299db9ec823,marksman_escape-0.1.2,587235\ngithub.com-1ecc6299db9ec823,serde_derive-1.0.101,289156\ngithub.com-1ecc6299db9ec823,gix-ref-0.29.0,214105\ngithub.com-1ecc6299db9ec823,der-0.7.5,384316\ngithub.com-1ecc6299db9ec823,promptly-0.3.0,35216\ngithub.com-1ecc6299db9ec823,libc-0.2.115,3166629\ngithub.com-1ecc6299db9ec823,ppv-lite86-0.1.2,33514\ngithub.com-1ecc6299db9ec823,gfx-hal-0.6.0,254453\ngithub.com-1ecc6299db9ec823,as-slice-0.1.3,20306\ngithub.com-1ecc6299db9ec823,gpu-alloc-0.3.0,78823\ngithub.com-1ecc6299db9ec823,arc-swap-0.4.8,167950\ngithub.com-1ecc6299db9ec823,libusb1-sys-0.5.0,1458763\ngithub.com-1ecc6299db9ec823,sysinfo-0.26.8,609932\ngithub.com-1ecc6299db9ec823,refinery-macros-0.8.7,6514\ngithub.com-1ecc6299db9ec823,assert_float_eq-1.1.3,38445\ngithub.com-1ecc6299db9ec823,tinyvec-1.1.0,363582\ngithub.com-1ecc6299db9ec823,predicates-1.0.7,1168580\ngithub.com-1ecc6299db9ec823,pulldown-cmark-0.9.3,595681\ngithub.com-1ecc6299db9ec823,aws-sigv4-0.46.0,97885\ngithub.com-1ecc6299db9ec823,fastrand-1.5.0,39175\ngithub.com-1ecc6299db9ec823,futures-channel-0.3.17,131816\ngithub.com-1ecc6299db9ec823,usbd_scsi-0.1.0,172205\ngithub.com-1ecc6299db9ec823,tinyvec-1.4.0,379505\ngithub.com-1ecc6299db9ec823,structsy-0.5.1,513822\ngithub.com-1ecc6299db9ec823,aws-sdk-ssm-0.21.0,9755619\ngithub.com-1ecc6299db9ec823,pin-project-lite-0.1.1,63942\ngithub.com-1ecc6299db9ec823,tokio-rustls-0.13.0,78252\ngithub.com-1ecc6299db9ec823,tinyvec_macros-0.1.0,2912\ngithub.com-1ecc6299db9ec823,extended_matrix_float-1.0.0,6233\ngithub.com-1ecc6299db9ec823,displaydoc-0.2.3,68676\ngithub.com-1ecc6299db9ec823,typed-arena-2.0.2,43549\ngithub.com-1ecc6299db9ec823,cranelift-0.86.1,16294\ngithub.com-1ecc6299db9ec823,modular-bitfield-impl-0.10.0,64389\ngithub.com-1ecc6299db9ec823,schemafy_core-0.5.2,7696\ngithub.com-1ecc6299db9ec823,sea-orm-macros-0.8.0,86930\ngithub.com-1ecc6299db9ec823,core-foundation-sys-0.4.6,61859\ngithub.com-1ecc6299db9ec823,move-symbol-pool-0.3.2,14473\ngithub.com-1ecc6299db9ec823,glutin-0.25.1,300518\ngithub.com-1ecc6299db9ec823,postcard-cobs-0.2.0,41524\ngithub.com-1ecc6299db9ec823,quote-0.6.11,69636\ngithub.com-1ecc6299db9ec823,encoding_rs-0.8.32,5022316\ngithub.com-1ecc6299db9ec823,clap-2.32.0,946148\ngithub.com-1ecc6299db9ec823,term-0.6.1,181220\ngithub.com-1ecc6299db9ec823,enumset-1.0.12,85911\ngithub.com-1ecc6299db9ec823,ctest2-0.4.1,100745\ngithub.com-1ecc6299db9ec823,serde-xml-any-0.0.3,70554\ngithub.com-1ecc6299db9ec823,proc-macro-hack-0.5.11,39025\ngithub.com-1ecc6299db9ec823,remove_dir_all-0.5.1,23418\ngithub.com-1ecc6299db9ec823,weezl-0.1.5,134218\ngithub.com-1ecc6299db9ec823,windows_x86_64_gnullvm-0.42.1,3254874\ngithub.com-1ecc6299db9ec823,rocket-0.5.0-rc.2,1225987\ngithub.com-1ecc6299db9ec823,pin-project-0.4.27,282004\ngithub.com-1ecc6299db9ec823,criterion-cycles-per-byte-0.1.3,18296\ngithub.com-1ecc6299db9ec823,coco-0.1.1,107143\ngithub.com-1ecc6299db9ec823,solana-bloom-1.15.1,22207\ngithub.com-1ecc6299db9ec823,qoqo_calculator-1.1.1,163666\ngithub.com-1ecc6299db9ec823,aes-gcm-0.9.4,381036\ngithub.com-1ecc6299db9ec823,blowfish-0.9.1,39658\ngithub.com-1ecc6299db9ec823,pango-0.14.3,258440\ngithub.com-1ecc6299db9ec823,clap_derive-3.0.0,129105\ngithub.com-1ecc6299db9ec823,content_inspector-0.2.4,27568\ngithub.com-1ecc6299db9ec823,jsona-0.2.0,104104\ngithub.com-1ecc6299db9ec823,gix-quote-0.4.3,32314\ngithub.com-1ecc6299db9ec823,bcs-0.1.3,93194\ngithub.com-1ecc6299db9ec823,statrs-0.14.0,681982\ngithub.com-1ecc6299db9ec823,cw-controllers-0.16.0,32195\ngithub.com-1ecc6299db9ec823,hyper-0.12.36,578470\ngithub.com-1ecc6299db9ec823,argon2-0.4.1,112707\ngithub.com-1ecc6299db9ec823,fraction-0.12.2,482976\ngithub.com-1ecc6299db9ec823,quickcheck-0.7.2,89884\ngithub.com-1ecc6299db9ec823,typetag-0.1.8,135149\ngithub.com-1ecc6299db9ec823,object-0.20.0,916661\ngithub.com-1ecc6299db9ec823,pest_derive-2.2.1,60318\ngithub.com-1ecc6299db9ec823,coremidi-sys-3.1.0,40849\ngithub.com-1ecc6299db9ec823,either-1.6.0,48881\ngithub.com-1ecc6299db9ec823,tarpc-0.29.0,244416\ngithub.com-1ecc6299db9ec823,num-integer-0.1.42,88403\ngithub.com-1ecc6299db9ec823,oid-registry-0.6.0,46996\ngithub.com-1ecc6299db9ec823,historian-3.0.11,23818\ngithub.com-1ecc6299db9ec823,ui-sys-0.1.3,1784250\ngithub.com-1ecc6299db9ec823,cranelift-frontend-0.92.0,166902\ngithub.com-1ecc6299db9ec823,pin-project-lite-0.1.12,77882\ngithub.com-1ecc6299db9ec823,piston2d-gfx_graphics-0.72.0,91826\ngithub.com-1ecc6299db9ec823,stylist-macros-0.9.2,78647\ngithub.com-1ecc6299db9ec823,valico-3.4.0,1394467\ngithub.com-1ecc6299db9ec823,inventory-0.3.3,40329\ngithub.com-1ecc6299db9ec823,wrapping_arithmetic-0.1.0,8774\ngithub.com-1ecc6299db9ec823,serde-1.0.138,502921\ngithub.com-1ecc6299db9ec823,ra_common-0.1.3,16920\ngithub.com-1ecc6299db9ec823,markup5ever-0.10.0,213742\ngithub.com-1ecc6299db9ec823,libp2p-core-0.20.1,460422\ngithub.com-1ecc6299db9ec823,inout-0.1.2,40474\ngithub.com-1ecc6299db9ec823,flatbuffers-23.1.21,103944\ngithub.com-1ecc6299db9ec823,gdk-pixbuf-sys-0.10.0,42914\ngithub.com-1ecc6299db9ec823,miniz_oxide-0.5.1,223551\ngithub.com-1ecc6299db9ec823,merge-0.1.0,70214\ngithub.com-1ecc6299db9ec823,pagecache-0.6.0,260742\ngithub.com-1ecc6299db9ec823,ritelinked-0.3.2,142063\ngithub.com-1ecc6299db9ec823,ethers-contract-1.0.2,589452\ngithub.com-1ecc6299db9ec823,color_quant-1.1.0,21284\ngithub.com-1ecc6299db9ec823,libykpers-sys-0.3.1,14270\ngithub.com-1ecc6299db9ec823,cgmath-0.17.0,367702\ngithub.com-1ecc6299db9ec823,clap-4.0.18,1096299\ngithub.com-1ecc6299db9ec823,ears-0.5.1,165152\ngithub.com-1ecc6299db9ec823,h2-0.2.5,765073\ngithub.com-1ecc6299db9ec823,image-0.22.5,725576\ngithub.com-1ecc6299db9ec823,digest-0.10.1,83013\ngithub.com-1ecc6299db9ec823,js-sys-0.3.46,410849\ngithub.com-1ecc6299db9ec823,psl-types-2.0.11,25329\ngithub.com-1ecc6299db9ec823,apub-core-0.2.0,52434\ngithub.com-1ecc6299db9ec823,thiserror-1.0.22,59077\ngithub.com-1ecc6299db9ec823,num-complex-0.4.3,139539\ngithub.com-1ecc6299db9ec823,autocfg-1.0.1,41521\ngithub.com-1ecc6299db9ec823,amethyst_locale-0.15.3,4896\ngithub.com-1ecc6299db9ec823,tokio-timer-0.2.11,167147\ngithub.com-1ecc6299db9ec823,pipe-trait-0.2.1,11031\ngithub.com-1ecc6299db9ec823,http-muncher-0.3.2,259101\ngithub.com-1ecc6299db9ec823,thin-dst-1.1.0,46297\ngithub.com-1ecc6299db9ec823,float-ord-0.2.0,21145\ngithub.com-1ecc6299db9ec823,trust-dns-proto-0.21.2,1312809\ngithub.com-1ecc6299db9ec823,ordered-multimap-0.4.3,178966\ngithub.com-1ecc6299db9ec823,bitflags-0.4.0,33932\ngithub.com-1ecc6299db9ec823,windows_x86_64_gnullvm-0.42.0,3240134\ngithub.com-1ecc6299db9ec823,cargo-util-0.1.2,72189\ngithub.com-1ecc6299db9ec823,serde_with_macros-1.5.2,72325\ngithub.com-1ecc6299db9ec823,wasmer-2.3.0,529984\ngithub.com-1ecc6299db9ec823,tokio-codec-0.1.2,30428\ngithub.com-1ecc6299db9ec823,pico-args-0.5.0,54991\ngithub.com-1ecc6299db9ec823,migformatting-0.1.1,1680\ngithub.com-1ecc6299db9ec823,lexical-core-0.6.7,2382284\ngithub.com-1ecc6299db9ec823,katex-wasmbind-0.10.0,274096\ngithub.com-1ecc6299db9ec823,blender-armature-0.0.1,51371\ngithub.com-1ecc6299db9ec823,twoway-0.2.1,129719\ngithub.com-1ecc6299db9ec823,sha3-0.10.0,540582\ngithub.com-1ecc6299db9ec823,ringbuf-0.2.8,92733\ngithub.com-1ecc6299db9ec823,pest_meta-2.1.3,175833\ngithub.com-1ecc6299db9ec823,selectme-macros-0.7.1,79130\ngithub.com-1ecc6299db9ec823,secp256k1-sys-0.7.0,5303296\ngithub.com-1ecc6299db9ec823,panic-probe-0.3.0,18841\ngithub.com-1ecc6299db9ec823,ron-0.6.6,208755\ngithub.com-1ecc6299db9ec823,defmt-macros-0.3.3,78405\ngithub.com-1ecc6299db9ec823,winapi-x86_64-pc-windows-gnu-0.4.0,53158182\ngithub.com-1ecc6299db9ec823,aph-0.2.0,30088\ngithub.com-1ecc6299db9ec823,winnow-0.4.6,959730\ngithub.com-1ecc6299db9ec823,syntex_syntax-0.54.0,1272567\ngithub.com-1ecc6299db9ec823,prost-derive-0.11.9,99428\ngithub.com-1ecc6299db9ec823,commoncrypto-sys-0.2.0,16095\ngithub.com-1ecc6299db9ec823,yew-router-macro-0.15.0,42667\ngithub.com-1ecc6299db9ec823,http-range-header-0.3.0,29647\ngithub.com-1ecc6299db9ec823,crossbeam-queue-0.2.3,60131\ngithub.com-1ecc6299db9ec823,slice-deque-0.3.0,271889\ngithub.com-1ecc6299db9ec823,libc-0.2.65,2334946\ngithub.com-1ecc6299db9ec823,minidom-0.14.0,102507\ngithub.com-1ecc6299db9ec823,tokio-native-tls-0.3.0,60313\ngithub.com-1ecc6299db9ec823,glam-0.17.3,1191013\ngithub.com-1ecc6299db9ec823,semver-1.0.6,114819\ngithub.com-1ecc6299db9ec823,cortex-m-rtfm-macros-0.5.1,112048\ngithub.com-1ecc6299db9ec823,bitvec-1.0.0,1006982\ngithub.com-1ecc6299db9ec823,gfx-backend-metal-0.6.5,660301\ngithub.com-1ecc6299db9ec823,object-0.30.1,1467041\ngithub.com-1ecc6299db9ec823,proc-macro-error-attr-0.4.11,18220\ngithub.com-1ecc6299db9ec823,proteus-0.5.0,179567\ngithub.com-1ecc6299db9ec823,crunchy-0.1.6,6678\ngithub.com-1ecc6299db9ec823,once_cell-1.7.2,121632\ngithub.com-1ecc6299db9ec823,rel-0.2.0,14524\ngithub.com-1ecc6299db9ec823,lexical-core-0.7.5,2355166\ngithub.com-1ecc6299db9ec823,windows_x86_64_gnu-0.42.1,10581222\ngithub.com-1ecc6299db9ec823,thread_local-1.1.5,49409\ngithub.com-1ecc6299db9ec823,openssl-sys-0.9.63,285709\ngithub.com-1ecc6299db9ec823,simplelog-0.11.2,85170\ngithub.com-1ecc6299db9ec823,thiserror-impl-1.0.25,55249\ngithub.com-1ecc6299db9ec823,quanta-0.10.0,82241\ngithub.com-1ecc6299db9ec823,vsmtp-common-1.4.0-rc.10,122740\ngithub.com-1ecc6299db9ec823,tonic-0.1.0-alpha.6,302938\ngithub.com-1ecc6299db9ec823,ecdsa-0.16.1,121203\ngithub.com-1ecc6299db9ec823,deltae-0.3.0,2871017\ngithub.com-1ecc6299db9ec823,phf_shared-0.11.1,30454\ngithub.com-1ecc6299db9ec823,trustfall-rustdoc-adapter-22.5.2,5348192\ngithub.com-1ecc6299db9ec823,mockall_derive-0.11.0,227736\ngithub.com-1ecc6299db9ec823,wasm-bindgen-0.2.64,584320\ngithub.com-1ecc6299db9ec823,sg-std-0.12.0,27020\ngithub.com-1ecc6299db9ec823,chalk-ir-0.87.0,288472\ngithub.com-1ecc6299db9ec823,environment-0.1.1,9957\ngithub.com-1ecc6299db9ec823,crash-handler-0.3.3,125183\ngithub.com-1ecc6299db9ec823,bindgen-0.59.2,958852\ngithub.com-1ecc6299db9ec823,serde_path_to_error-0.1.7,101591\ngithub.com-1ecc6299db9ec823,tinyvec-0.3.3,77508\ngithub.com-1ecc6299db9ec823,precomputed-hash-0.1.1,2853\ngithub.com-1ecc6299db9ec823,rustc-rayon-core-0.4.1,264995\ngithub.com-1ecc6299db9ec823,gix-sec-0.6.2,57428\ngithub.com-1ecc6299db9ec823,pistoncore-input-0.19.0,83490\ngithub.com-1ecc6299db9ec823,gloo-utils-0.1.5,15602\ngithub.com-1ecc6299db9ec823,redox_intelflash-0.1.3,28056\ngithub.com-1ecc6299db9ec823,block2-0.2.0-alpha.6,39192\ngithub.com-1ecc6299db9ec823,fastly-shared-0.9.1,19292\ngithub.com-1ecc6299db9ec823,ibc-chain-registry-0.1.0,48243\ngithub.com-1ecc6299db9ec823,socket2-0.4.4,205035\ngithub.com-1ecc6299db9ec823,futures-channel-0.3.19,132274\ngithub.com-1ecc6299db9ec823,structopt-0.3.16,217443\ngithub.com-1ecc6299db9ec823,rusty-fork-0.2.2,64570\ngithub.com-1ecc6299db9ec823,parking_lot_core-0.9.7,139601\ngithub.com-1ecc6299db9ec823,async-lock-2.6.0,99844\ngithub.com-1ecc6299db9ec823,bindgen-0.56.0,923373\ngithub.com-1ecc6299db9ec823,quad-rand-0.2.1,9108\ngithub.com-1ecc6299db9ec823,wasmflow-codec-0.10.0,12343\ngithub.com-1ecc6299db9ec823,gix-0.38.0,883190\ngithub.com-1ecc6299db9ec823,futures-macro-0.3.27,38519\ngithub.com-1ecc6299db9ec823,portable-atomic-0.3.13,549649\ngithub.com-1ecc6299db9ec823,portable-atomic-1.3.2,799707\ngithub.com-1ecc6299db9ec823,bevy-crevice-derive-0.6.0,16165\ngithub.com-1ecc6299db9ec823,gltf-json-0.15.2,118263\ngithub.com-1ecc6299db9ec823,struple-impl-0.1.0,4096\ngithub.com-1ecc6299db9ec823,annotate-snippets-0.9.1,153174\ngithub.com-1ecc6299db9ec823,futures-core-0.3.28,46207\ngithub.com-1ecc6299db9ec823,wezterm-bidi-0.2.2,361283\ngithub.com-1ecc6299db9ec823,mildew-0.1.2,3002\ngithub.com-1ecc6299db9ec823,bytecount-0.6.3,46567\ngithub.com-1ecc6299db9ec823,numext-fixed-hash-core-0.1.6,7403\ngithub.com-1ecc6299db9ec823,bytesize-1.1.0,34012\ngithub.com-1ecc6299db9ec823,oxsdatatypes-0.1.0,174662\ngithub.com-1ecc6299db9ec823,hostname-0.1.5,4811\ngithub.com-1ecc6299db9ec823,io-lifetimes-1.0.4,207652\ngithub.com-1ecc6299db9ec823,derive_builder_core-0.11.2,135502\ngithub.com-1ecc6299db9ec823,ttf-parser-0.15.2,711615\ngithub.com-1ecc6299db9ec823,tracing-opentelemetry-0.17.4,187675\ngithub.com-1ecc6299db9ec823,ab_glyph_rasterizer-0.1.7,34278\ngithub.com-1ecc6299db9ec823,bevy_diagnostic-0.6.0,14396\ngithub.com-1ecc6299db9ec823,toml_datetime-0.5.0,34801\ngithub.com-1ecc6299db9ec823,wasm-parser-0.1.7,39726\ngithub.com-1ecc6299db9ec823,ppv-null-0.1.2,26098\ngithub.com-1ecc6299db9ec823,ci_info-0.10.2,1197933\ngithub.com-1ecc6299db9ec823,jobserver-0.1.21,72720\ngithub.com-1ecc6299db9ec823,sentencepiece-sys-0.10.0,10055292\ngithub.com-1ecc6299db9ec823,zstd-sys-2.0.1+zstd.1.5.2,3387955\ngithub.com-1ecc6299db9ec823,byte-strings-proc_macros-0.2.2,7886\ngithub.com-1ecc6299db9ec823,snapbox-0.4.11,193312\ngithub.com-1ecc6299db9ec823,ron-0.6.4,198516\ngithub.com-1ecc6299db9ec823,gix-object-0.28.0,102536\ngithub.com-1ecc6299db9ec823,strum_macros-0.23.1,87403\ngithub.com-1ecc6299db9ec823,defmt-0.3.2,93568\ngithub.com-1ecc6299db9ec823,openssl-0.10.35,971227\ngithub.com-1ecc6299db9ec823,gtk-sys-0.14.0,1376726\ngithub.com-1ecc6299db9ec823,gpu-alloc-0.4.7,99476\ngithub.com-1ecc6299db9ec823,colored-2.0.0,91075\ngithub.com-1ecc6299db9ec823,fixedbitset-0.4.2,67872\ngithub.com-1ecc6299db9ec823,argparse-0.2.2,95032\ngithub.com-1ecc6299db9ec823,bevy_mod_raycast-0.6.2,456756\ngithub.com-1ecc6299db9ec823,byte-strings-0.2.2,35209\ngithub.com-1ecc6299db9ec823,mem_tools-0.1.0,937956\ngithub.com-1ecc6299db9ec823,deno_core-0.167.0,11067700\ngithub.com-1ecc6299db9ec823,rocksdb-0.19.0,628015\ngithub.com-1ecc6299db9ec823,num-traits-0.2.12,231414\ngithub.com-1ecc6299db9ec823,type-info-derive-0.2.0,56221\ngithub.com-1ecc6299db9ec823,structopt-derive-0.3.4,68017\ngithub.com-1ecc6299db9ec823,extendr-macros-0.3.1,49695\ngithub.com-1ecc6299db9ec823,secret-cosmwasm-std-1.0.0,632711\ngithub.com-1ecc6299db9ec823,skim-0.7.0,380243\ngithub.com-1ecc6299db9ec823,serde-1.0.135,501463\ngithub.com-1ecc6299db9ec823,lock_api-0.1.5,109183\ngithub.com-1ecc6299db9ec823,cw-multi-test-0.16.2,445599\ngithub.com-1ecc6299db9ec823,quote-1.0.10,120640\ngithub.com-1ecc6299db9ec823,safemem-0.3.2,17382\ngithub.com-1ecc6299db9ec823,gloo-dialogs-0.1.1,4653\ngithub.com-1ecc6299db9ec823,dashmap-4.0.2,105438\ngithub.com-1ecc6299db9ec823,oorandom-11.1.0,31893\ngithub.com-1ecc6299db9ec823,polars-core-0.21.1,1678691\ngithub.com-1ecc6299db9ec823,claxon-0.4.2,259276\ngithub.com-1ecc6299db9ec823,cc-1.0.35,179169\ngithub.com-1ecc6299db9ec823,cocoa-0.19.1,296083\ngithub.com-1ecc6299db9ec823,tokio-1.9.0,2490393\ngithub.com-1ecc6299db9ec823,gix-refspec-0.10.1,105495\ngithub.com-1ecc6299db9ec823,futures-task-0.3.12,39561\ngithub.com-1ecc6299db9ec823,sqlx-core-0.4.2,1064795\ngithub.com-1ecc6299db9ec823,futures-task-0.3.14,39566\ngithub.com-1ecc6299db9ec823,datastore_grpc-0.4.0,18233399\ngithub.com-1ecc6299db9ec823,directories-4.0.1,74013\ngithub.com-1ecc6299db9ec823,wgpu-hal-0.15.1,1201034\ngithub.com-1ecc6299db9ec823,discard-1.0.4,14342\ngithub.com-1ecc6299db9ec823,tinytga-0.1.0,102322\ngithub.com-1ecc6299db9ec823,prost-types-0.10.1,126121\ngithub.com-1ecc6299db9ec823,assert2-0.3.6,36145\ngithub.com-1ecc6299db9ec823,syn-inline-mod-0.5.0,35740\ngithub.com-1ecc6299db9ec823,bat-0.22.1,5407476\ngithub.com-1ecc6299db9ec823,minidumper-child-0.1.0,32329\ngithub.com-1ecc6299db9ec823,libp2p-kad-0.21.0,416675\ngithub.com-1ecc6299db9ec823,asn1_der-0.6.3,1102166\ngithub.com-1ecc6299db9ec823,h2-0.2.4,764682\ngithub.com-1ecc6299db9ec823,ena-0.14.2,90713\ngithub.com-1ecc6299db9ec823,prost-build-0.8.0,31248726\ngithub.com-1ecc6299db9ec823,wasmer-compiler-cranelift-3.1.1,300456\ngithub.com-1ecc6299db9ec823,gfx-hal-0.7.0,238750\ngithub.com-1ecc6299db9ec823,nom-4.2.3,644514\ngithub.com-1ecc6299db9ec823,os_str_bytes-2.4.0,52159\ngithub.com-1ecc6299db9ec823,sourcemap-6.2.1,135303\ngithub.com-1ecc6299db9ec823,actix-router-0.5.1,150753\ngithub.com-1ecc6299db9ec823,markup5ever-0.9.0,229731\ngithub.com-1ecc6299db9ec823,gloo-worker-0.2.1,31624\ngithub.com-1ecc6299db9ec823,object-0.25.3,1313095\ngithub.com-1ecc6299db9ec823,rustversion-1.0.0,41602\n" }, { "path": "benches/benchsuite/src/bin/capture-last-use.rs", "content": "//! Utility for capturing a global cache last-use database based on the files\n//! on a real-world system.\n//!\n//! This will look in the `CARGO_HOME` of the current system and record last-use\n//! data for all files in the cache. This is intended to provide a real-world\n//! example for a benchmark that should be close to what a real set of data\n//! should look like.\n//!\n//! See `benches/global_cache_tracker.rs` for the benchmark that uses this\n//! data.\n//!\n//! The database is kept in git. It usually shouldn't need to be re-generated\n//! unless there is a change in the schema or the benchmark.\n\nuse cargo::GlobalContext;\nuse cargo::core::global_cache_tracker::{self, DeferredGlobalLastUse, GlobalCacheTracker};\nuse cargo::util::cache_lock::CacheLockMode;\nuse rand::prelude::*;\nuse std::collections::HashMap;\nuse std::fs;\nuse std::fs::File;\nuse std::io::Write;\nuse std::path::Path;\n\nfn main() {\n // Set up config.\n let shell = cargo::core::Shell::new();\n let homedir = Path::new(env!(\"CARGO_MANIFEST_DIR\")).join(\"global-cache-tracker\");\n let cwd = homedir.clone();\n let mut gctx = GlobalContext::new(shell, cwd, homedir.clone());\n gctx.configure(\n 0,\n false,\n None,\n false,\n false,\n false,\n &None,\n &[\"gc\".to_string()],\n &[],\n )\n .unwrap();\n let db_path = GlobalCacheTracker::db_path(&gctx).into_path_unlocked();\n if db_path.exists() {\n fs::remove_file(&db_path).unwrap();\n }\n\n let _lock = gctx\n .acquire_package_cache_lock(CacheLockMode::DownloadExclusive)\n .unwrap();\n let mut deferred = DeferredGlobalLastUse::new();\n let mut tracker = GlobalCacheTracker::new(&gctx).unwrap();\n\n let real_home = cargo::util::homedir(&std::env::current_dir().unwrap()).unwrap();\n\n let cache_dir = real_home.join(\"registry/cache\");\n for dir_ent in fs::read_dir(cache_dir).unwrap() {\n let registry = dir_ent.unwrap();\n let encoded_registry_name = registry.file_name().to_string_lossy().into();\n for krate in fs::read_dir(registry.path()).unwrap() {\n let krate = krate.unwrap();\n let meta = krate.metadata().unwrap();\n deferred.mark_registry_crate_used_stamp(\n global_cache_tracker::RegistryCrate {\n encoded_registry_name,\n crate_filename: krate.file_name().to_string_lossy().as_ref().into(),\n size: meta.len(),\n },\n Some(&meta.modified().unwrap()),\n );\n }\n }\n\n let mut src_entries = Vec::new();\n\n let cache_dir = real_home.join(\"registry/src\");\n for dir_ent in fs::read_dir(cache_dir).unwrap() {\n let registry = dir_ent.unwrap();\n let encoded_registry_name = registry.file_name().to_string_lossy().into();\n for krate in fs::read_dir(registry.path()).unwrap() {\n let krate = krate.unwrap();\n let meta = krate.metadata().unwrap();\n let src = global_cache_tracker::RegistrySrc {\n encoded_registry_name,\n package_dir: krate.file_name().to_string_lossy().as_ref().into(),\n size: Some(cargo_util::du(&krate.path(), &[]).unwrap()),\n };\n src_entries.push(src.clone());\n let timestamp = meta.modified().unwrap();\n deferred.mark_registry_src_used_stamp(src, Some(×tamp));\n }\n }\n\n let git_co_dir = real_home.join(\"git/checkouts\");\n for dir_ent in fs::read_dir(git_co_dir).unwrap() {\n let git_source = dir_ent.unwrap();\n let encoded_git_name = git_source.file_name().to_string_lossy().into();\n for co in fs::read_dir(git_source.path()).unwrap() {\n let co = co.unwrap();\n let meta = co.metadata().unwrap();\n deferred.mark_git_checkout_used_stamp(\n global_cache_tracker::GitCheckout {\n encoded_git_name,\n short_name: co.file_name().to_string_lossy().as_ref().into(),\n size: Some(cargo_util::du(&co.path(), &[]).unwrap()),\n },\n Some(&meta.modified().unwrap()),\n );\n }\n }\n\n deferred.save(&mut tracker).unwrap();\n drop(deferred);\n drop(tracker);\n fs::rename(&db_path, homedir.join(\"global-cache-sample\")).unwrap();\n // Clean up the lock file created above.\n fs::remove_file(homedir.join(\".package-cache\")).unwrap();\n\n // Save a random sample of crates that the benchmark should update.\n // Pick whichever registry has the most entries. This is to be somewhat\n // realistic for the common case that all dependencies come from one\n // registry (crates.io).\n let mut counts = HashMap::new();\n for src in &src_entries {\n let c: &mut u32 = counts.entry(src.encoded_registry_name).or_default();\n *c += 1;\n }\n let mut counts: Vec<_> = counts.into_iter().map(|(k, v)| (v, k)).collect();\n counts.sort();\n let biggest = counts.last().unwrap().1;\n\n src_entries.retain(|src| src.encoded_registry_name == biggest);\n let mut rng = &mut rand::rng();\n let sample: Vec<_> = src_entries.sample(&mut rng, 500).collect();\n let mut f = File::create(homedir.join(\"random-sample\")).unwrap();\n for src in sample {\n writeln!(\n f,\n \"{},{},{}\",\n src.encoded_registry_name,\n src.package_dir,\n src.size.unwrap()\n )\n .unwrap();\n }\n}\n" }, { "path": "benches/benchsuite/src/lib.rs", "content": "//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use. This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\n#![allow(clippy::disallowed_methods)]\n\nuse cargo::GlobalContext;\nuse std::fs;\nuse std::path::{Path, PathBuf};\nuse std::process::Command;\nuse url::Url;\n\n#[macro_export]\nmacro_rules! fixtures {\n () => {\n $crate::Fixtures::new(env!(\"CARGO_TARGET_TMPDIR\"))\n };\n}\n\n// This is an arbitrary commit that existed when I started. This helps\n// ensure consistent results. It can be updated if needed, but that can\n// make it harder to compare results with older versions of cargo.\nconst CRATES_IO_COMMIT: &str = \"85f7bfd61ea4fee08ec68c468762e886b2aebec6\";\n\npub struct Fixtures {\n cargo_target_tmpdir: PathBuf,\n}\n\nimpl Fixtures {\n pub fn new(cargo_target_tmpdir: &str) -> Self {\n let bench = Self {\n cargo_target_tmpdir: PathBuf::from(cargo_target_tmpdir),\n };\n bench.create_home();\n bench.create_target_dir();\n bench.clone_index();\n bench.unpack_workspaces();\n bench\n }\n\n fn root(&self) -> PathBuf {\n self.cargo_target_tmpdir.join(\"bench\")\n }\n\n fn target_dir(&self) -> PathBuf {\n let mut p = self.root();\n p.push(\"target\");\n p\n }\n\n fn cargo_home(&self) -> PathBuf {\n let mut p = self.root();\n p.push(\"chome\");\n p\n }\n\n fn index(&self) -> PathBuf {\n let mut p = self.root();\n p.push(\"index\");\n p\n }\n\n fn workspaces_path(&self) -> PathBuf {\n let mut p = self.root();\n p.push(\"workspaces\");\n p\n }\n\n fn registry_url(&self) -> Url {\n Url::from_file_path(self.index()).unwrap()\n }\n\n fn create_home(&self) {\n let home = self.cargo_home();\n if !home.exists() {\n fs::create_dir_all(&home).unwrap();\n }\n fs::write(\n home.join(\"config.toml\"),\n format!(\n r#\"\n [source.crates-io]\n replace-with = 'local-snapshot'\n\n [source.local-snapshot]\n registry = '{}'\n \"#,\n self.registry_url()\n ),\n )\n .unwrap();\n }\n\n fn create_target_dir(&self) {\n // This is necessary to ensure the .rustc_info.json file is written.\n // Otherwise it won't be written, and it is very expensive to create.\n if !self.target_dir().exists() {\n fs::create_dir_all(self.target_dir()).unwrap();\n }\n }\n\n /// This clones crates.io at a specific point in time into tmp/index.\n fn clone_index(&self) {\n let index = self.index();\n let maybe_git = |command: &str| {\n let status = Command::new(\"git\")\n .current_dir(&index)\n .args(command.split_whitespace().collect::>())\n .status()\n .expect(\"git should be installed\");\n status.success()\n };\n let git = |command: &str| {\n if !maybe_git(command) {\n panic!(\"failed to run git command: {}\", command);\n }\n };\n if index.exists() {\n if maybe_git(&format!(\n \"rev-parse -q --verify {}^{{commit}}\",\n CRATES_IO_COMMIT\n )) {\n // Already fetched.\n return;\n }\n } else {\n fs::create_dir_all(&index).unwrap();\n // git 2.48.0 changed the behavior of setting HEAD when doing a\n // fetch, so let's just force it to match\n // crates.io-index-archive's default branch. This also accounts\n // for users who may override init.defaultBranch.\n git(\"init --bare --initial-branch=main\");\n git(\"remote add origin https://github.com/rust-lang/crates.io-index-archive\");\n }\n git(&format!(\"fetch origin {}\", CRATES_IO_COMMIT));\n git(\"branch -f main FETCH_HEAD\");\n }\n\n /// This unpacks the compressed workspace skeletons into tmp/workspaces.\n fn unpack_workspaces(&self) {\n let ws_dir = Path::new(env!(\"CARGO_MANIFEST_DIR\"))\n .parent()\n .unwrap()\n .join(\"workspaces\");\n let archives = fs::read_dir(ws_dir)\n .unwrap()\n .map(|e| e.unwrap().path())\n .filter(|p| p.extension() == Some(std::ffi::OsStr::new(\"tgz\")));\n for archive in archives {\n let name = archive.file_stem().unwrap();\n let f = fs::File::open(&archive).unwrap();\n let f = flate2::read::GzDecoder::new(f);\n let dest = self.workspaces_path().join(&name);\n if dest.exists() {\n fs::remove_dir_all(&dest).unwrap();\n }\n let mut archive = tar::Archive::new(f);\n archive.unpack(self.workspaces_path()).unwrap();\n }\n }\n\n /// Vec of `(ws_name, ws_root)`.\n pub fn workspaces(&self) -> Vec<(String, PathBuf)> {\n // CARGO_BENCH_WORKSPACES can be used to override, otherwise it just uses\n // the workspaces in the workspaces directory.\n let mut ps: Vec<_> = match std::env::var_os(\"CARGO_BENCH_WORKSPACES\") {\n Some(s) => std::env::split_paths(&s).collect(),\n None => fs::read_dir(self.workspaces_path())\n .unwrap()\n .map(|e| e.unwrap().path())\n // These currently fail in most cases on Windows due to long\n // filenames in the git checkouts.\n .filter(|p| {\n !(cfg!(windows)\n && matches!(p.file_name().unwrap().to_str().unwrap(), \"servo\" | \"tikv\"))\n })\n .collect(),\n };\n // Sort so it is consistent.\n ps.sort();\n ps.into_iter()\n .map(|p| (p.file_name().unwrap().to_str().unwrap().to_owned(), p))\n .collect()\n }\n\n /// Creates a new Context.\n pub fn make_context(&self, ws_root: &Path) -> GlobalContext {\n let shell = cargo::core::Shell::new();\n let mut gctx = GlobalContext::new(shell, ws_root.to_path_buf(), self.cargo_home());\n // Configure is needed to set the target_dir which is needed to write\n // the .rustc_info.json file which is very expensive.\n gctx.configure(\n 0,\n false,\n None,\n false,\n false,\n false,\n &Some(self.target_dir()),\n &[],\n &[],\n )\n .unwrap();\n gctx\n }\n}\n" }, { "path": "benches/capture/Cargo.toml", "content": "[package]\nname = \"capture\"\nversion = \"0.1.0\"\nedition.workspace = true\nlicense.workspace = true\ndescription = \"Tool for capturing a real-world workspace for benchmarking.\"\npublish = false\n\n[dependencies]\ncargo_metadata.workspace = true\nflate2.workspace = true\ntar.workspace = true\ntoml = { workspace = true, features = [\"display\", \"parse\", \"serde\"] }\n\n[lints]\nworkspace = true\n" }, { "path": "benches/capture/src/main.rs", "content": "//! This tool helps to capture the `Cargo.toml` files of a workspace.\n//!\n//! Run it by passing a list of workspaces to capture.\n//! Use the `-f` flag to allow it to overwrite existing captures.\n//! The workspace will be saved in a `.tgz` file in the `../workspaces` directory.\n\n#![allow(clippy::disallowed_methods)]\n#![allow(clippy::print_stderr)]\n\nuse flate2::{Compression, GzBuilder};\nuse std::fs;\nuse std::path::{Path, PathBuf};\nuse std::process::Command;\n\nfn main() {\n let force = std::env::args().any(|arg| arg == \"-f\");\n let dest = Path::new(env!(\"CARGO_MANIFEST_DIR\"))\n .parent()\n .unwrap()\n .join(\"workspaces\");\n if !dest.exists() {\n panic!(\"expected {} to exist\", dest.display());\n }\n for arg in std::env::args().skip(1).filter(|arg| !arg.starts_with(\"-\")) {\n let source_root = fs::canonicalize(arg).unwrap();\n capture(&source_root, &dest, force);\n }\n}\n\nfn capture(source_root: &Path, dest: &Path, force: bool) {\n let name = Path::new(source_root.file_name().unwrap());\n let mut dest_gz = PathBuf::from(dest);\n dest_gz.push(name);\n dest_gz.set_extension(\"tgz\");\n if dest_gz.exists() {\n if !force {\n panic!(\n \"dest {:?} already exists, use -f to force overwriting\",\n dest_gz\n );\n }\n fs::remove_file(&dest_gz).unwrap();\n }\n let vcs_info = capture_vcs_info(source_root, force);\n let dst = fs::File::create(&dest_gz).unwrap();\n let encoder = GzBuilder::new()\n .filename(format!(\"{}.tar\", name.to_str().unwrap()))\n .write(dst, Compression::best());\n let mut ar = tar::Builder::new(encoder);\n ar.mode(tar::HeaderMode::Deterministic);\n if let Some(info) = &vcs_info {\n add_ar_file(&mut ar, &name.join(\".cargo_vcs_info.json\"), info);\n }\n\n // Gather all local packages.\n let metadata = cargo_metadata::MetadataCommand::new()\n .manifest_path(source_root.join(\"Cargo.toml\"))\n .features(cargo_metadata::CargoOpt::AllFeatures)\n .exec()\n .expect(\"cargo_metadata failed\");\n let mut found_root = false;\n for package in &metadata.packages {\n if package.source.is_some() {\n continue;\n }\n let manifest_path = package.manifest_path.as_std_path();\n copy_manifest(&manifest_path, &mut ar, name, &source_root);\n found_root |= manifest_path == source_root.join(\"Cargo.toml\");\n }\n if !found_root {\n // A virtual workspace.\n let contents = fs::read_to_string(source_root.join(\"Cargo.toml\")).unwrap();\n assert!(!contents.contains(\"[package]\"));\n add_ar_file(&mut ar, &name.join(\"Cargo.toml\"), &contents);\n }\n let lock = fs::read_to_string(source_root.join(\"Cargo.lock\")).unwrap();\n add_ar_file(&mut ar, &name.join(\"Cargo.lock\"), &lock);\n let encoder = ar.into_inner().unwrap();\n encoder.finish().unwrap();\n eprintln!(\"created {}\", dest_gz.display());\n}\n\nfn copy_manifest(\n manifest_path: &Path,\n ar: &mut tar::Builder,\n name: &Path,\n source_root: &Path,\n) {\n let relative_path = manifest_path\n .parent()\n .unwrap()\n .strip_prefix(source_root)\n .expect(\"workspace member should be under workspace root\");\n let relative_path = name.join(relative_path);\n let contents = fs::read_to_string(&manifest_path).unwrap();\n let mut manifest: toml::Value = toml::from_str(&contents).unwrap();\n let remove = |obj: &mut toml::Value, name| {\n let table = obj.as_table_mut().unwrap();\n if table.contains_key(name) {\n table.remove(name);\n }\n };\n remove(&mut manifest, \"lib\");\n remove(&mut manifest, \"bin\");\n remove(&mut manifest, \"example\");\n remove(&mut manifest, \"test\");\n remove(&mut manifest, \"bench\");\n remove(&mut manifest, \"profile\");\n if let Some(package) = manifest.get_mut(\"package\") {\n remove(package, \"default-run\");\n }\n let contents = toml::to_string(&manifest).unwrap();\n add_ar_file(ar, &relative_path.join(\"Cargo.toml\"), &contents);\n add_ar_file(ar, &relative_path.join(\"src\").join(\"lib.rs\"), \"\");\n}\n\nfn add_ar_file(ar: &mut tar::Builder, path: &Path, contents: &str) {\n let mut header = tar::Header::new_gnu();\n header.set_entry_type(tar::EntryType::file());\n header.set_mode(0o644);\n header.set_size(contents.len() as u64);\n header.set_mtime(123456789);\n header.set_cksum();\n ar.append_data(&mut header, path, contents.as_bytes())\n .unwrap();\n}\n\nfn capture_vcs_info(ws_root: &Path, force: bool) -> Option {\n let maybe_git = |command: &str| {\n Command::new(\"git\")\n .current_dir(ws_root)\n .args(command.split_whitespace().collect::>())\n .output()\n .expect(\"git should be installed\")\n };\n assert!(ws_root.join(\"Cargo.toml\").exists());\n let relative = maybe_git(\"ls-files --full-name Cargo.toml\");\n if !relative.status.success() {\n if !force {\n panic!(\"git repository not detected, use -f to force\");\n }\n return None;\n }\n let p = Path::new(std::str::from_utf8(&relative.stdout).unwrap().trim());\n let relative = p.parent().unwrap();\n if !force {\n let has_changes = !maybe_git(\"diff-index --quiet HEAD .\").status.success();\n if has_changes {\n panic!(\"git repo appears to have changes, use -f to force, or clean the repo\");\n }\n }\n let commit = maybe_git(\"rev-parse HEAD\");\n assert!(commit.status.success());\n let commit = std::str::from_utf8(&commit.stdout).unwrap().trim();\n let remote = maybe_git(\"remote get-url origin\");\n assert!(remote.status.success());\n let remote = std::str::from_utf8(&remote.stdout).unwrap().trim();\n let info = format!(\n \"{{\\n \\\"git\\\": {{\\n \\\"sha1\\\": \\\"{}\\\",\\n \\\"remote\\\": \\\"{}\\\"\\n }},\\\n \\n \\\"path_in_vcs\\\": \\\"{}\\\"\\n}}\\n\",\n commit,\n remote,\n relative.display()\n );\n eprintln!(\"recording vcs info:\\n{}\", info);\n Some(info)\n}\n" }, { "path": "build.rs", "content": "use flate2::{Compression, GzBuilder};\nuse std::ffi::OsStr;\nuse std::fs;\nuse std::path::Path;\nuse std::process::Command;\n\nfn main() {\n commit_info();\n compress_man();\n windows_manifest();\n #[expect(\n clippy::disallowed_methods,\n reason = \"not `cargo`, not needing to load from config\"\n )]\n let target = std::env::var(\"TARGET\").unwrap();\n println!(\"cargo:rustc-env=RUST_HOST_TARGET={target}\");\n}\n\nfn compress_man() {\n #[expect(\n clippy::disallowed_methods,\n reason = \"not `cargo`, not needing to load from config\"\n )]\n let out_path = Path::new(&std::env::var(\"OUT_DIR\").unwrap()).join(\"man.tgz\");\n let dst = fs::File::create(out_path).unwrap();\n let encoder = GzBuilder::new()\n .filename(\"man.tar\")\n .write(dst, Compression::best());\n let mut ar = tar::Builder::new(encoder);\n ar.mode(tar::HeaderMode::Deterministic);\n\n let mut add_files = |dir, extension| {\n let mut files = fs::read_dir(dir)\n .unwrap()\n .map(|e| e.unwrap().path())\n .collect::>();\n files.sort();\n for path in files {\n if path.extension() != Some(extension) {\n continue;\n }\n println!(\"cargo:rerun-if-changed={}\", path.display());\n ar.append_path_with_name(&path, path.file_name().unwrap())\n .unwrap();\n }\n };\n\n add_files(Path::new(\"src/etc/man\"), OsStr::new(\"1\"));\n add_files(Path::new(\"src/doc/man/generated_txt\"), OsStr::new(\"txt\"));\n let encoder = ar.into_inner().unwrap();\n encoder.finish().unwrap();\n}\n\nstruct CommitInfo {\n hash: String,\n short_hash: String,\n date: String,\n}\n\nfn commit_info_from_git() -> Option {\n if !Path::new(\".git\").exists() {\n return None;\n }\n\n let output = match Command::new(\"git\")\n .arg(\"log\")\n .arg(\"-1\")\n .arg(\"--date=short\")\n .arg(\"--format=%H %h %cd\")\n .arg(\"--abbrev=9\")\n .output()\n {\n Ok(output) if output.status.success() => output,\n _ => return None,\n };\n\n let stdout = String::from_utf8(output.stdout).unwrap();\n let mut parts = stdout.split_whitespace().map(|s| s.to_string());\n\n Some(CommitInfo {\n hash: parts.next()?,\n short_hash: parts.next()?,\n date: parts.next()?,\n })\n}\n\n// The rustc source tarball is meant to contain all the source code to build an exact copy of the\n// toolchain, but it doesn't include the git repository itself. It wouldn't thus be possible to\n// populate the version information with the commit hash and the commit date.\n//\n// To work around this, the rustc build process obtains the git information when creating the\n// source tarball and writes it to the `git-commit-info` file. The build process actually creates\n// at least *two* of those files, one for Rust as a whole (in the root of the tarball) and one\n// specifically for Cargo (in src/tools/cargo). This function loads that file.\n//\n// The file is a newline-separated list of full commit hash, short commit hash, and commit date.\nfn commit_info_from_rustc_source_tarball() -> Option {\n let path = Path::new(\"git-commit-info\");\n if !path.exists() {\n return None;\n }\n\n // Dependency tracking is a nice to have for this (git doesn't do it), so if the path is not\n // valid UTF-8 just avoid doing it rather than erroring out.\n if let Some(utf8) = path.to_str() {\n println!(\"cargo:rerun-if-changed={utf8}\");\n }\n\n let content = std::fs::read_to_string(&path).ok()?;\n let mut parts = content.split('\\n').map(|s| s.to_string());\n Some(CommitInfo {\n hash: parts.next()?,\n short_hash: parts.next()?,\n date: parts.next()?,\n })\n}\n\nfn commit_info() {\n // Var set by bootstrap whenever omit-git-hash is enabled in rust-lang/rust's config.toml.\n println!(\"cargo:rerun-if-env-changed=CFG_OMIT_GIT_HASH\");\n #[expect(\n clippy::disallowed_methods,\n reason = \"not `cargo`, not needing to load from config\"\n )]\n if std::env::var_os(\"CFG_OMIT_GIT_HASH\").is_some() {\n return;\n }\n\n let Some(git) = commit_info_from_git().or_else(commit_info_from_rustc_source_tarball) else {\n return;\n };\n\n println!(\"cargo:rustc-env=CARGO_COMMIT_HASH={}\", git.hash);\n println!(\"cargo:rustc-env=CARGO_COMMIT_SHORT_HASH={}\", git.short_hash);\n println!(\"cargo:rustc-env=CARGO_COMMIT_DATE={}\", git.date);\n}\n\n#[expect(\n clippy::disallowed_methods,\n reason = \"not `cargo`, not needing to load from config\"\n)]\nfn windows_manifest() {\n use std::env;\n let target_os = env::var(\"CARGO_CFG_TARGET_OS\");\n let target_env = env::var(\"CARGO_CFG_TARGET_ENV\");\n if Ok(\"windows\") == target_os.as_deref() && Ok(\"msvc\") == target_env.as_deref() {\n static WINDOWS_MANIFEST_FILE: &str = \"windows.manifest.xml\";\n\n let mut manifest = env::current_dir().unwrap();\n manifest.push(WINDOWS_MANIFEST_FILE);\n\n println!(\"cargo:rerun-if-changed={WINDOWS_MANIFEST_FILE}\");\n // Embed the Windows application manifest file.\n println!(\"cargo:rustc-link-arg-bin=cargo=/MANIFEST:EMBED\");\n println!(\n \"cargo:rustc-link-arg-bin=cargo=/MANIFESTINPUT:{}\",\n manifest.to_str().unwrap()\n );\n // Turn linker warnings into errors.\n println!(\"cargo:rustc-link-arg-bin=cargo=/WX\");\n }\n}\n" }, { "path": "ci/clean-test-output.sh", "content": "#!/bin/bash\n# This script remove test and benchmark output and displays disk usage.\n\nset -euo pipefail\n\ndf -h\nrm -rf target/tmp\ndf -h\n" }, { "path": "ci/dump-environment.sh", "content": "#!/bin/bash\n# This script dumps information about the build environment to stdout.\n\nset -euo pipefail\nIFS=$'\\n\\t'\n\necho \"environment variables:\"\nprintenv | sort\necho\n\necho \"disk usage:\"\ndf -h\necho\n\necho \"CPU info:\"\nif [[ \"${OSTYPE}\" = \"darwin\"* ]]; then\n system_profiler SPHardwareDataType || true\n sysctl hw || true\nelse\n cat /proc/cpuinfo || true\n cat /proc/meminfo || true\nfi\n" }, { "path": "ci/fetch-smoke-test.sh", "content": "#!/bin/bash\n# This script builds with static curl, and verifies that fetching works.\n\nset -ex\n\nif [[ -z \"$RUNNER_TEMP\" ]]\nthen\n echo \"RUNNER_TEMP must be set\"\n exit 1\nfi\n\nif [ ! -f Cargo.toml ]; then\n echo \"Must be run from root of project.\"\n exit 1\nfi\n\n\n# Building openssl on Windows is a pain.\nif [[ $(rustc -Vv | grep host:) != *windows* ]]; then\n FEATURES='vendored-openssl,curl-sys/static-curl,curl-sys/force-system-lib-on-osx'\n export LIBZ_SYS_STATIC=1\nfi\n\ncargo build --features \"$FEATURES\"\nexport CARGO_HOME=$RUNNER_TEMP/chome\ntarget/debug/cargo fetch\nrm -rf $CARGO_HOME\n" }, { "path": "ci/generate.py", "content": "#!/usr/bin/env python3\n\nMAPPING = {\n \"build-script.html\": \"https://doc.rust-lang.org/cargo/reference/build-scripts.html\",\n \"config.html\": None,\n \"crates-io.html\": \"https://doc.rust-lang.org/cargo/reference/publishing.html\",\n \"environment-variables.html\": None,\n \"external-tools.html\": None,\n \"faq.html\": \"https://doc.rust-lang.org/cargo/faq.html\",\n \"guide.html\": \"https://doc.rust-lang.org/cargo/guide/\",\n \"index.html\": \"https://doc.rust-lang.org/cargo/\",\n \"manifest.html\": None,\n \"pkgid-spec.html\": None,\n \"policies.html\": \"https://crates.io/policies\",\n \"source-replacement.html\": None,\n \"specifying-dependencies.html\": None,\n}\n\nTEMPLATE = \"\"\"\\\n\n\n\n\nPage Moved\n\n\nThis page has moved. Click here to go to the new page.\n\n\n\"\"\"\n\ndef main():\n for name in sorted(MAPPING):\n with open(name, 'w') as f:\n mapped = MAPPING[name]\n if mapped is None:\n mapped = \"https://doc.rust-lang.org/cargo/reference/{}\".format(name)\n f.write(TEMPLATE.format(name=name, mapped=mapped))\n\n # WARN: The CNAME file is for GitHub to redirect requests to the custom domain.\n # Missing this may entail security hazard and domain takeover.\n # See \n with open('CNAME', 'w') as f:\n f.write('doc.crates.io')\n\nif __name__ == '__main__':\n main()\n" }, { "path": "ci/validate-man.sh", "content": "#!/bin/bash\n# This script validates that there aren't any changes to the man pages.\n\nset -e\n\ncargo_man=\"src/doc\"\nmdman_man=\"crates/mdman/doc\"\nman_out=\"src/etc/man\"\n\nchanges=$(git status --porcelain -- $cargo_man $mdman_man $man_out)\nif [ -n \"$changes\" ]\nthen\n echo \"git directory must be clean before running this script.\"\n exit 1\nfi\n\ncargo build-man\n\nchanges=$(git status --porcelain -- $cargo_man $mdman_man $man_out)\nif [ -n \"$changes\" ]\nthen\n echo \"Detected changes of man pages:\"\n echo \"$changes\"\n echo\n echo 'Please run `cargo build-man` to rebuild the man pages'\n echo \"and commit the changes.\"\n exit 1\nfi\n" }, { "path": "ci/validate-version-bump.sh", "content": "#!/bin/bash\n# This script checks if a crate needs a version bump.\n#\n# At the time of writing, it doesn't check what kind of bump is required.\n# In the future, we could take SemVer compatibility into account, like\n# integrating `cargo-semver-checks` of else\n#\n# Inputs:\n# BASE_SHA The commit SHA of the branch where the PR wants to merge into.\n# HEAD_SHA The commit SHA that triggered the workflow.\n\nset -euo pipefail\n\n# When `BASE_SHA` is missing, we assume it is from GitHub merge queue merge commit,\n# so hope `HEAD~` to find the previous commit on master branch.\nbase_sha=$(git rev-parse \"${BASE_SHA:-HEAD~1}\")\nhead_sha=$(git rev-parse \"${HEAD_SHA:-HEAD}\")\n\necho \"Base revision is $base_sha\"\necho \"Head revision is $head_sha\"\n\necho \"::group::Building xtask\"\ncargo bump-check --help\necho \"::endgroup::\"\ncargo bump-check --github --base-rev \"$base_sha\" --head-rev \"$head_sha\"\n" }, { "path": "clippy.toml", "content": "allow-print-in-tests = true\nallow-dbg-in-tests = true\ndisallowed-methods = [\n { path = \"std::env::var\", reason = \"use `Config::get_env` instead. See rust-lang/cargo#11588\" },\n { path = \"std::env::var_os\", reason = \"use `Config::get_env_os` instead. See rust-lang/cargo#11588\" },\n { path = \"std::env::vars\", reason = \"not recommended to use in Cargo. See rust-lang/cargo#11588\" },\n { path = \"std::env::vars_os\", reason = \"not recommended to use in Cargo. See rust-lang/cargo#11588\" },\n]\ndisallowed-types = [\n { path = \"std::sync::atomic::AtomicU64\", reason = \"not portable. See rust-lang/cargo#12988\" },\n]\n" }, { "path": "crates/build-rs/Cargo.toml", "content": "[package]\nname = \"build-rs\"\nversion = \"0.3.4\"\nrust-version.workspace = true\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"API for writing Cargo `build.rs` files\"\n\n[features]\n## Experimental API. This feature flag is **NOT** semver stable.\nunstable = []\n\n[dependencies]\nunicode-ident.workspace = true\n" }, { "path": "crates/build-rs/README.md", "content": "> This crate is maintained by the Cargo team for use by the wider\n> ecosystem. This crate follows semver compatibility for its APIs.\n" }, { "path": "crates/build-rs/src/ident.rs", "content": "use unicode_ident::{is_xid_continue, is_xid_start};\n\npub(crate) fn is_feature_name(s: &str) -> bool {\n s.chars()\n .all(|ch| is_xid_continue(ch) || matches!(ch, '-' | '+' | '.'))\n}\n\npub(crate) fn is_ident(s: &str) -> bool {\n let mut cs = s.chars();\n cs.next()\n .is_some_and(|ch| is_xid_start(ch) || matches!(ch, '_'))\n && cs.all(is_xid_continue)\n}\n\npub(crate) fn is_ascii_ident(s: &str) -> bool {\n let mut cs = s.chars();\n cs.next()\n .is_some_and(|ch| ch.is_ascii_alphabetic() || matches!(ch, '_'))\n && cs.all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '_'))\n}\n\npub(crate) fn is_crate_name(s: &str) -> bool {\n let mut cs = s.chars();\n cs.next()\n .is_some_and(|ch| is_xid_start(ch) || matches!(ch, '-' | '_'))\n && cs.all(|ch| is_xid_continue(ch) || matches!(ch, '-'))\n}\n" }, { "path": "crates/build-rs/src/input.rs", "content": "//! Inputs from the build system to the build script.\n//!\n//! This crate does not do any caching or interpreting of the values provided by\n//! Cargo beyond the communication protocol itself. It is up to the build script\n//! to interpret the string values and decide what to do with them.\n//!\n//! Reference: \n\nuse std::path::PathBuf;\n\nuse crate::ident::{is_ascii_ident, is_crate_name, is_feature_name};\nuse crate::output::rerun_if_env_changed;\n\n/// [`ProcessEnv`] wrapper that implicit calls [`rerun_if_env_changed`]\nconst ENV: RerunIfEnvChanged = RerunIfEnvChanged::new();\n\n/// Abstraction over environment variables\ntrait Env {\n /// Fetches the environment variable `key`, returning `None` if the variable isnā€™t set or if\n /// there is another error.\n ///\n /// It may return `None` if the environment variableā€™s name contains the equal sign character\n /// (`=`) or the NUL character.\n ///\n /// Note that this function will not check if the environment variable is valid Unicode.\n fn get(&self, key: &str) -> Option;\n\n /// Checks the environment variable `key` is present\n ///\n /// It may not be considered present if the environment variableā€™s name contains the equal sign character\n /// (`=`) or the NUL character.\n fn is_present(&self, key: &str) -> bool;\n}\n\n/// Fetches environment variables from the current process\nstruct ProcessEnv;\n\nimpl Env for ProcessEnv {\n fn get(&self, key: &str) -> Option {\n std::env::var_os(key)\n }\n\n fn is_present(&self, key: &str) -> bool {\n self.get(key).is_some()\n }\n}\n\n/// [`Env`] wrapper that implicitly calls [`rerun_if_env_changed`]\nstruct RerunIfEnvChanged(E);\n\nimpl RerunIfEnvChanged {\n const fn new() -> Self {\n Self(ProcessEnv)\n }\n}\n\nimpl Env for RerunIfEnvChanged {\n #[track_caller]\n fn get(&self, key: &str) -> Option {\n rerun_if_env_changed(key);\n self.0.get(key)\n }\n\n #[track_caller]\n fn is_present(&self, key: &str) -> bool {\n self.get(key).is_some()\n }\n}\n\n/// Path to the `cargo` binary performing the build.\n#[track_caller]\npub fn cargo() -> PathBuf {\n to_path(var_or_panic(\"CARGO\"))\n}\n\n/// The directory containing the manifest for the package being built (the package\n/// containing the build script).\n///\n/// Also note that this is the value of the current\n/// working directory of the build script when it starts.\n#[track_caller]\npub fn cargo_manifest_dir() -> PathBuf {\n to_path(var_or_panic(\"CARGO_MANIFEST_DIR\"))\n}\n\n/// The path to the manifest of your package.\n#[track_caller]\npub fn cargo_manifest_path() -> PathBuf {\n ENV.get(\"CARGO_MANIFEST_PATH\")\n .map(to_path)\n .unwrap_or_else(|| {\n let mut path = cargo_manifest_dir();\n path.push(\"Cargo.toml\");\n path\n })\n}\n\n/// The manifest `links` value.\n#[track_caller]\npub fn cargo_manifest_links() -> Option {\n ENV.get(\"CARGO_MANIFEST_LINKS\").map(to_string)\n}\n\n/// Contains parameters needed for Cargoā€™s [jobserver] implementation to parallelize\n/// subprocesses.\n///\n/// Rustc or cargo invocations from build.rs can already read\n/// `CARGO_MAKEFLAGS`, but GNU Make requires the flags to be specified either\n/// directly as arguments, or through the `MAKEFLAGS` environment variable.\n/// Currently Cargo doesnā€™t set the `MAKEFLAGS` variable, but itā€™s free for build\n/// scripts invoking GNU Make to set it to the contents of `CARGO_MAKEFLAGS`.\n///\n/// [jobserver]: https://www.gnu.org/software/make/manual/html_node/Job-Slots.html\n#[track_caller]\npub fn cargo_makeflags() -> Option {\n ENV.get(\"CARGO_MAKEFLAGS\").map(to_string)\n}\n\n/// For each activated feature of the package being built, this will be `true`.\n#[track_caller]\npub fn cargo_feature(name: &str) -> bool {\n if !is_feature_name(name) {\n panic!(\"invalid feature name {name:?}\")\n }\n let name = name.to_uppercase().replace('-', \"_\");\n let key = format!(\"CARGO_FEATURE_{name}\");\n ENV.is_present(&key)\n}\n\n/// For each [configuration option] of the package being built, this will contain\n/// the value of the configuration.\n///\n/// This includes values built-in to the compiler\n/// (which can be seen with `rustc --print=cfg`) and values set by build scripts\n/// and extra flags passed to rustc (such as those defined in `RUSTFLAGS`).\n///\n/// [configuration option]: https://doc.rust-lang.org/stable/reference/conditional-compilation.html\n#[track_caller]\npub fn cargo_cfg(cfg: &str) -> Option> {\n let var = cargo_cfg_var(cfg);\n ENV.get(&var).map(|v| to_strings(v, ','))\n}\n\n#[track_caller]\nfn cargo_cfg_var(cfg: &str) -> String {\n if !is_ascii_ident(cfg) {\n panic!(\"invalid configuration option {cfg:?}\")\n }\n let cfg = cfg.to_uppercase().replace('-', \"_\");\n let key = format!(\"CARGO_CFG_{cfg}\");\n key\n}\n\npub use self::cfg::*;\nmod cfg {\n use super::*;\n\n // those disabled with #[cfg(any())] don't seem meaningfully useful\n // but we list all cfg that are default known to check-cfg\n\n /// Each activated feature of the package being built\n #[doc = requires_msrv!(\"1.85\")]\n #[track_caller]\n pub fn cargo_cfg_feature() -> Vec {\n to_strings(var_or_panic(&cargo_cfg_var(\"feature\")), ',')\n }\n\n #[cfg(any())]\n #[track_caller]\n pub fn cargo_cfg_clippy() -> bool {\n ENV.is_present(\"CARGO_CFG_CLIPPY\")\n }\n\n /// If we are compiling with debug assertions enabled.\n #[track_caller]\n pub fn cargo_cfg_debug_assertions() -> bool {\n ENV.is_present(\"CARGO_CFG_DEBUG_ASSERTIONS\")\n }\n\n #[cfg(any())]\n #[track_caller]\n pub fn cargo_cfg_doc() -> bool {\n ENV.is_present(\"CARGO_CFG_DOC\")\n }\n\n #[cfg(any())]\n #[track_caller]\n pub fn cargo_cfg_docsrs() -> bool {\n ENV.is_present(\"CARGO_CFG_DOCSRS\")\n }\n\n #[cfg(any())]\n #[track_caller]\n pub fn cargo_cfg_doctest() -> bool {\n ENV.is_present(\"CARGO_CFG_DOCTEST\")\n }\n\n /// The level of detail provided by derived [`Debug`] implementations.\n #[doc = unstable!(fmt_dbg, 129709)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_fmt_debug() -> String {\n to_string(var_or_panic(\"CARGO_CFG_FMT_DEBUG\"))\n }\n\n #[cfg(any())]\n #[track_caller]\n pub fn cargo_cfg_miri() -> bool {\n ENV.is_present(\"CARGO_CFG_MIRI\")\n }\n\n /// If we are compiling with overflow checks enabled.\n #[doc = unstable!(cfg_overflow_checks, 111466)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_overflow_checks() -> bool {\n ENV.is_present(\"CARGO_CFG_OVERFLOW_CHECKS\")\n }\n\n /// The [panic strategy](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#panic).\n #[track_caller]\n pub fn cargo_cfg_panic() -> String {\n to_string(var_or_panic(\"CARGO_CFG_PANIC\"))\n }\n\n /// If the crate is being compiled as a procedural macro.\n #[track_caller]\n pub fn cargo_cfg_proc_macro() -> bool {\n ENV.is_present(\"CARGO_CFG_PROC_MACRO\")\n }\n\n /// The target relocation model.\n #[doc = unstable!(cfg_relocation_model, 114929)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_relocation_model() -> String {\n to_string(var_or_panic(\"CARGO_CFG_RELOCATION_MODEL\"))\n }\n\n #[cfg(any())]\n #[track_caller]\n pub fn cargo_cfg_rustfmt() -> bool {\n ENV.is_present(\"CARGO_CFG_RUSTFMT\")\n }\n\n /// Sanitizers enabled for the crate being compiled.\n #[doc = unstable!(cfg_sanitize, 39699)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_sanitize() -> Option> {\n ENV.get(\"CARGO_CFG_SANITIZE\").map(|v| to_strings(v, ','))\n }\n\n /// If CFI sanitization is generalizing pointers.\n #[doc = unstable!(cfg_sanitizer_cfi, 89653)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_sanitizer_cfi_generalize_pointers() -> bool {\n ENV.is_present(\"CARGO_CFG_SANITIZER_CFI_GENERALIZE_POINTERS\")\n }\n\n /// If CFI sanitization is normalizing integers.\n #[doc = unstable!(cfg_sanitizer_cfi, 89653)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_sanitizer_cfi_normalize_integers() -> bool {\n ENV.is_present(\"CARGO_CFG_SANITIZER_CFI_NORMALIZE_INTEGERS\")\n }\n\n /// Disambiguation of the [target ABI](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_abi)\n /// when the [target env](cargo_cfg_target_env) isn't sufficient.\n ///\n /// For historical reasons, this value is only defined as `Some` when\n /// actually needed for disambiguation. Thus, for example, on many GNU platforms,\n /// this value will be `None`.\n #[track_caller]\n pub fn cargo_cfg_target_abi() -> Option {\n to_opt(var_or_panic(\"CARGO_CFG_TARGET_ABI\")).map(to_string)\n }\n\n /// The CPU [target architecture](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_arch).\n /// This is similar to the first element of the platform's target triple, but not identical.\n #[track_caller]\n pub fn cargo_cfg_target_arch() -> String {\n to_string(var_or_panic(\"CARGO_CFG_TARGET_ARCH\"))\n }\n\n /// The CPU [target endianness](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_endian).\n #[track_caller]\n pub fn cargo_cfg_target_endian() -> String {\n to_string(var_or_panic(\"CARGO_CFG_TARGET_ENDIAN\"))\n }\n\n /// The [target environment](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_env) ABI.\n /// This value is similar to the fourth element of the platform's target triple.\n ///\n /// For historical reasons, this value is only defined as not the empty-string when\n /// actually needed for disambiguation. Thus, for example, on many GNU platforms,\n /// this value will be empty.\n #[track_caller]\n pub fn cargo_cfg_target_env() -> String {\n to_string(var_or_panic(\"CARGO_CFG_TARGET_ENV\"))\n }\n\n /// The [target family](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_family).\n #[track_caller]\n pub fn cargo_target_family() -> Vec {\n to_strings(var_or_panic(&cargo_cfg_var(\"target_family\")), ',')\n }\n\n /// List of CPU [target features](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_feature) enabled.\n #[track_caller]\n pub fn cargo_cfg_target_feature() -> Vec {\n to_strings(var_or_panic(&cargo_cfg_var(\"target_feature\")), ',')\n }\n\n /// List of CPU [supported atomic widths](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_has_atomic).\n #[track_caller]\n pub fn cargo_cfg_target_has_atomic() -> Vec {\n to_strings(var_or_panic(&cargo_cfg_var(\"target_has_atomic\")), ',')\n }\n\n /// List of atomic widths that have equal alignment requirements.\n #[doc = unstable!(cfg_target_has_atomic_equal_alignment, 93822)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_target_has_atomic_equal_alignment() -> Vec {\n to_strings(\n var_or_panic(&cargo_cfg_var(\"target_has_atomic_equal_alignment\")),\n ',',\n )\n }\n\n /// List of atomic widths that have atomic load and store operations.\n #[doc = unstable!(cfg_target_has_atomic_load_store, 94039)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_target_has_atomic_load_store() -> Vec {\n to_strings(\n var_or_panic(&cargo_cfg_var(\"target_has_atomic_load_store\")),\n ',',\n )\n }\n\n /// The [target operating system](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_os).\n /// This value is similar to the second and third element of the platform's target triple.\n #[track_caller]\n pub fn cargo_cfg_target_os() -> String {\n to_string(var_or_panic(\"CARGO_CFG_TARGET_OS\"))\n }\n\n /// The CPU [pointer width](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_pointer_width).\n #[track_caller]\n pub fn cargo_cfg_target_pointer_width() -> u32 {\n to_parsed(var_or_panic(\"CARGO_CFG_TARGET_POINTER_WIDTH\"))\n }\n\n /// If the target supports thread-local storage.\n #[doc = unstable!(cfg_target_thread_local, 29594)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_target_thread_local() -> bool {\n ENV.is_present(\"CARGO_CFG_TARGET_THREAD_LOCAL\")\n }\n\n /// The [target vendor](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#target_vendor).\n #[track_caller]\n pub fn cargo_cfg_target_vendor() -> String {\n to_string(var_or_panic(\"CARGO_CFG_TARGET_VENDOR\"))\n }\n\n #[cfg(any())]\n #[track_caller]\n pub fn cargo_cfg_test() -> bool {\n ENV.is_present(\"CARGO_CFG_TEST\")\n }\n\n /// If we are compiling with UB checks enabled.\n #[doc = unstable!(cfg_ub_checks, 123499)]\n #[cfg(feature = \"unstable\")]\n #[track_caller]\n pub fn cargo_cfg_ub_checks() -> bool {\n ENV.is_present(\"CARGO_CFG_UB_CHECKS\")\n }\n\n /// Set on [unix-like platforms](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#unix-and-windows).\n #[track_caller]\n pub fn cargo_cfg_unix() -> bool {\n ENV.is_present(\"CARGO_CFG_UNIX\")\n }\n\n /// Set on [windows-like platforms](https://doc.rust-lang.org/stable/reference/conditional-compilation.html#unix-and-windows).\n #[track_caller]\n pub fn cargo_cfg_windows() -> bool {\n ENV.is_present(\"CARGO_CFG_WINDOWS\")\n }\n}\n\n/// The folder in which all output and intermediate artifacts should be placed.\n///\n/// This folder is inside the build directory for the package being built, and\n/// it is unique for the package in question.\n#[track_caller]\npub fn out_dir() -> PathBuf {\n to_path(var_or_panic(\"OUT_DIR\"))\n}\n\n/// The [target triple] that is being compiled for. Native code should be compiled\n/// for this triple.\n///\n/// [target triple]: https://doc.rust-lang.org/stable/cargo/appendix/glossary.html#target\n#[track_caller]\npub fn target() -> String {\n to_string(var_or_panic(\"TARGET\"))\n}\n\n/// The host triple of the Rust compiler.\n#[track_caller]\npub fn host() -> String {\n to_string(var_or_panic(\"HOST\"))\n}\n\n/// The parallelism specified as the top-level parallelism.\n///\n/// This can be useful to\n/// pass a `-j` parameter to a system like `make`. Note that care should be taken\n/// when interpreting this value. For historical purposes this is still provided\n/// but Cargo, for example, does not need to run `make -j`, and instead can set the\n/// `MAKEFLAGS` env var to the content of `CARGO_MAKEFLAGS` to activate the use of\n/// Cargoā€™s GNU Make compatible [jobserver] for sub-make invocations.\n///\n/// [jobserver]: https://www.gnu.org/software/make/manual/html_node/Job-Slots.html\n#[track_caller]\npub fn num_jobs() -> u32 {\n to_parsed(var_or_panic(\"NUM_JOBS\"))\n}\n\n/// The [level of optimization](https://doc.rust-lang.org/stable/cargo/reference/profiles.html#opt-level).\n#[track_caller]\npub fn opt_level() -> String {\n to_string(var_or_panic(\"OPT_LEVEL\"))\n}\n\n/// The amount of [debug information](https://doc.rust-lang.org/stable/cargo/reference/profiles.html#debug) included.\n#[track_caller]\npub fn debug() -> String {\n to_string(var_or_panic(\"DEBUG\"))\n}\n\n/// `release` for release builds, `debug` for other builds.\n///\n/// This is determined based\n/// on if the [profile] inherits from the [`dev`] or [`release`] profile. Using this\n/// function is not recommended. Using other functions like [`opt_level`] provides\n/// a more correct view of the actual settings being used.\n///\n/// [profile]: https://doc.rust-lang.org/stable/cargo/reference/profiles.html\n/// [`dev`]: https://doc.rust-lang.org/stable/cargo/reference/profiles.html#dev\n/// [`release`]: https://doc.rust-lang.org/stable/cargo/reference/profiles.html#release\n#[track_caller]\npub fn profile() -> String {\n to_string(var_or_panic(\"PROFILE\"))\n}\n\n/// [Metadata] set by dependencies. For more information, see build script\n/// documentation about [the `links` manifest key][links].\n///\n/// [metadata]: crate::output::metadata\n/// [links]: https://doc.rust-lang.org/stable/cargo/reference/build-scripts.html#the-links-manifest-key\n#[track_caller]\npub fn dep_metadata(name: &str, key: &str) -> Option {\n if !is_crate_name(name) {\n panic!(\"invalid dependency name {name:?}\")\n }\n if !is_ascii_ident(key) {\n panic!(\"invalid metadata key {key:?}\")\n }\n\n let name = name.to_uppercase().replace('-', \"_\");\n let key = key.to_uppercase().replace('-', \"_\");\n let key = format!(\"DEP_{name}_{key}\");\n ENV.get(&key).map(to_string)\n}\n\n/// The compiler that Cargo has resolved to use.\n#[track_caller]\npub fn rustc() -> PathBuf {\n to_path(var_or_panic(\"RUSTC\"))\n}\n\n/// The documentation generator that Cargo has resolved to use.\n#[track_caller]\npub fn rustdoc() -> PathBuf {\n to_path(var_or_panic(\"RUSTDOC\"))\n}\n\n/// The rustc wrapper, if any, that Cargo is using. See [`build.rustc-wrapper`].\n///\n/// [`build.rustc-wrapper`]: https://doc.rust-lang.org/stable/cargo/reference/config.html#buildrustc-wrapper\n#[track_caller]\npub fn rustc_wrapper() -> Option {\n ENV.get(\"RUSTC_WRAPPER\").map(to_path)\n}\n\n/// The rustc wrapper, if any, that Cargo is using for workspace members. See\n/// [`build.rustc-workspace-wrapper`].\n///\n/// [`build.rustc-workspace-wrapper`]: https://doc.rust-lang.org/stable/cargo/reference/config.html#buildrustc-workspace-wrapper\n#[track_caller]\npub fn rustc_workspace_wrapper() -> Option {\n ENV.get(\"RUSTC_WORKSPACE_WRAPPER\").map(to_path)\n}\n\n/// The linker that Cargo has resolved to use for the current target, if specified.\n///\n/// [`target.*.linker`]: https://doc.rust-lang.org/stable/cargo/reference/config.html#targettriplelinker\n#[track_caller]\npub fn rustc_linker() -> Option {\n ENV.get(\"RUSTC_LINKER\").map(to_path)\n}\n\n/// Extra flags that Cargo invokes rustc with. See [`build.rustflags`].\n///\n/// [`build.rustflags`]: https://doc.rust-lang.org/stable/cargo/reference/config.html#buildrustflags\n#[track_caller]\npub fn cargo_encoded_rustflags() -> Vec {\n to_strings(var_or_panic(\"CARGO_ENCODED_RUSTFLAGS\"), '\\x1f')\n}\n\n/// The full version of your package.\n#[track_caller]\npub fn cargo_pkg_version() -> String {\n to_string(var_or_panic(\"CARGO_PKG_VERSION\"))\n}\n\n/// The major version of your package.\n#[track_caller]\npub fn cargo_pkg_version_major() -> u64 {\n to_parsed(var_or_panic(\"CARGO_PKG_VERSION_MAJOR\"))\n}\n\n/// The minor version of your package.\n#[track_caller]\npub fn cargo_pkg_version_minor() -> u64 {\n to_parsed(var_or_panic(\"CARGO_PKG_VERSION_MINOR\"))\n}\n\n/// The patch version of your package.\n#[track_caller]\npub fn cargo_pkg_version_patch() -> u64 {\n to_parsed(var_or_panic(\"CARGO_PKG_VERSION_PATCH\"))\n}\n\n/// The pre-release version of your package.\n#[track_caller]\npub fn cargo_pkg_version_pre() -> Option {\n to_opt(var_or_panic(\"CARGO_PKG_VERSION_PRE\")).map(to_string)\n}\n\n/// The authors from the manifest of your package.\n#[track_caller]\npub fn cargo_pkg_authors() -> Vec {\n to_strings(var_or_panic(\"CARGO_PKG_AUTHORS\"), ':')\n}\n\n/// The name of your package.\n#[track_caller]\npub fn cargo_pkg_name() -> String {\n to_string(var_or_panic(\"CARGO_PKG_NAME\"))\n}\n\n/// The description from the manifest of your package.\n#[track_caller]\npub fn cargo_pkg_description() -> Option {\n to_opt(var_or_panic(\"CARGO_PKG_DESCRIPTION\")).map(to_string)\n}\n\n/// The home page from the manifest of your package.\n#[track_caller]\npub fn cargo_pkg_homepage() -> Option {\n to_opt(var_or_panic(\"CARGO_PKG_HOMEPAGE\")).map(to_string)\n}\n\n/// The repository from the manifest of your package.\n#[track_caller]\npub fn cargo_pkg_repository() -> Option {\n to_opt(var_or_panic(\"CARGO_PKG_REPOSITORY\")).map(to_string)\n}\n\n/// The license from the manifest of your package.\n#[track_caller]\npub fn cargo_pkg_license() -> Option {\n to_opt(var_or_panic(\"CARGO_PKG_LICENSE\")).map(to_string)\n}\n\n/// The license file from the manifest of your package.\n#[track_caller]\npub fn cargo_pkg_license_file() -> Option {\n to_opt(var_or_panic(\"CARGO_PKG_LICENSE_FILE\")).map(to_path)\n}\n\n/// The Rust version from the manifest of your package. Note that this is the\n/// minimum Rust version supported by the package, not the current Rust version.\n#[track_caller]\npub fn cargo_pkg_rust_version() -> Option {\n to_opt(var_or_panic(\"CARGO_PKG_RUST_VERSION\")).map(to_string)\n}\n\n/// Path to the README file of your package.\n#[track_caller]\npub fn cargo_pkg_readme() -> Option {\n to_opt(var_or_panic(\"CARGO_PKG_README\")).map(to_path)\n}\n\n#[track_caller]\nfn var_or_panic(key: &str) -> std::ffi::OsString {\n ENV.get(key)\n .unwrap_or_else(|| panic!(\"cargo environment variable `{key}` is missing\"))\n}\n\nfn to_path(value: std::ffi::OsString) -> PathBuf {\n PathBuf::from(value)\n}\n\n#[track_caller]\nfn to_string(value: std::ffi::OsString) -> String {\n match value.into_string() {\n Ok(s) => s,\n Err(value) => {\n let err = std::str::from_utf8(value.as_encoded_bytes()).unwrap_err();\n panic!(\"{err}\")\n }\n }\n}\n\nfn to_opt(value: std::ffi::OsString) -> Option {\n (!value.is_empty()).then_some(value)\n}\n\n#[track_caller]\nfn to_strings(value: std::ffi::OsString, sep: char) -> Vec {\n if value.is_empty() {\n return Vec::new();\n }\n let value = to_string(value);\n value.split(sep).map(str::to_owned).collect()\n}\n\n#[track_caller]\nfn to_parsed(value: std::ffi::OsString) -> T\nwhere\n T: std::str::FromStr,\n T::Err: std::fmt::Display,\n{\n let value = to_string(value);\n match value.parse() {\n Ok(s) => s,\n Err(err) => {\n panic!(\"{err}\")\n }\n }\n}\n" }, { "path": "crates/build-rs/src/lib.rs", "content": "//! build-rs provides a strongly typed interface around the Cargo build script\n//! protocol. Cargo provides inputs to the build script by environment variable\n//! and accepts commands by printing to stdout.\n//!\n//! > This crate is maintained by the Cargo team for use by the wider\n//! > ecosystem. This crate follows semver compatibility for its APIs.\n#![cfg_attr(all(doc, feature = \"unstable\"), feature(doc_auto_cfg, doc_cfg))]\n#![allow(clippy::disallowed_methods)] // HACK: deferred resoling this\n#![allow(clippy::print_stdout)] // HACK: deferred resoling this\n\n#[cfg(feature = \"unstable\")]\nmacro_rules! unstable {\n ($feature:ident, $issue:literal) => {\n concat!(\n r#\"
\"#,\n r#\"šŸ”¬\"#,\n r#\"This is a nightly-only experimental API. (\"#,\n stringify!($feature),\n r#\" #\"#,\n $issue,\n r#\")\"#,\n r#\"
\"#\n )\n };\n}\n\nmacro_rules! respected_msrv {\n ($ver:literal) => {\n concat!(\n r#\"
\n\nMSRV: Respected as of \"#,\n $ver,\n r#\".\n\n
\"#\n )\n };\n}\n\nmacro_rules! requires_msrv {\n ($ver:literal) => {\n concat!(\n r#\"
\n\nMSRV: Requires \"#,\n $ver,\n r#\".\n\n
\"#\n )\n };\n}\n\nmod ident;\n\npub mod input;\npub mod output;\n" }, { "path": "crates/build-rs/src/output.rs", "content": "//! Outputs from the build script to the build system.\n//!\n//! This crate assumes that stdout is at a new line whenever an output directive\n//! is called. Printing to stdout without a terminating newline (i.e. not using\n//! [`println!`]) may lead to surprising behavior.\n//!\n//! Reference: \n\nuse std::ffi::OsStr;\nuse std::path::Path;\nuse std::{fmt::Display, fmt::Write as _};\n\nuse crate::ident::{is_ascii_ident, is_ident};\n\nfn emit(directive: &str, value: impl Display) {\n println!(\"cargo::{directive}={value}\");\n}\n\n/// The `rerun-if-changed` instruction tells Cargo to re-run the build script if the\n/// file at the given path has changed.\n///\n/// Currently, Cargo only uses the filesystem\n/// last-modified ā€œmtimeā€ timestamp to determine if the file has changed. It\n/// compares against an internal cached timestamp of when the build script last ran.\n///\n/// If the path points to a directory, it will scan the entire directory for any\n/// modifications.\n///\n/// If the build script inherently does not need to re-run under any circumstance,\n/// then calling `rerun_if_changed(\"build.rs\")` is a simple way to prevent it from\n/// being re-run (otherwise, the default if no `rerun-if` instructions are emitted\n/// is to scan the entire package directory for changes). Cargo automatically\n/// handles whether or not the script itself needs to be recompiled, and of course\n/// the script will be re-run after it has been recompiled. Otherwise, specifying\n/// `build.rs` is redundant and unnecessary.\n#[track_caller]\npub fn rerun_if_changed(path: impl AsRef) {\n let Some(path) = path.as_ref().to_str() else {\n panic!(\"cannot emit rerun-if-changed: path is not UTF-8\");\n };\n if path.contains('\\n') {\n panic!(\"cannot emit rerun-if-changed: path contains newline\");\n }\n emit(\"rerun-if-changed\", path);\n}\n\n/// The `rerun-if-env-changed` instruction tells Cargo to re-run the build script\n/// if the value of an environment variable of the given name has changed.\n///\n/// Note that the environment variables here are intended for global environment\n/// variables like `CC` and such, it is not possible to use this for environment\n/// variables like `TARGET` that [Cargo sets for build scripts][build-env]. The\n/// environment variables in use are those received by cargo invocations, not\n/// those received by the executable of the build script.\n///\n/// [build-env]: https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-build-scripts\n#[track_caller]\npub fn rerun_if_env_changed(key: impl AsRef) {\n let Some(key) = key.as_ref().to_str() else {\n panic!(\"cannot emit rerun-if-env-changed: key is not UTF-8\");\n };\n if key.contains('\\n') {\n panic!(\"cannot emit rerun-if-env-changed: key contains newline\");\n }\n emit(\"rerun-if-env-changed\", key);\n}\n\n/// The `rustc-link-arg` instruction tells Cargo to pass the\n/// [`-C link-arg=FLAG` option][link-arg] to the compiler, but only when building\n/// supported targets (benchmarks, binaries, cdylib crates, examples, and tests).\n///\n/// Its usage is highly platform specific. It is useful to set the shared library\n/// version or linker script.\n///\n/// [link-arg]: https://doc.rust-lang.org/rustc/codegen-options/index.html#link-arg\n#[track_caller]\npub fn rustc_link_arg(flag: &str) {\n if flag.contains([' ', '\\n']) {\n panic!(\"cannot emit rustc-link-arg: invalid flag {flag:?}\");\n }\n emit(\"rustc-link-arg\", flag);\n}\n\n/// The `rustc-link-arg-bin` instruction tells Cargo to pass the\n/// [`-C link-arg=FLAG` option][link-arg] to the compiler, but only when building\n/// the binary target with name `BIN`. Its usage is highly platform specific.\n///\n/// It\n/// is useful to set a linker script or other linker options.\n///\n/// [link-arg]: https://doc.rust-lang.org/rustc/codegen-options/index.html#link-arg\n#[track_caller]\npub fn rustc_link_arg_bin(bin: &str, flag: &str) {\n if !is_ident(bin) {\n panic!(\"cannot emit rustc-link-arg-bin: invalid bin name {bin:?}\");\n }\n if flag.contains([' ', '\\n']) {\n panic!(\"cannot emit rustc-link-arg-bin: invalid flag {flag:?}\");\n }\n emit(\"rustc-link-arg-bin\", format_args!(\"{bin}={flag}\"));\n}\n\n/// The `rustc-link-arg-bins` instruction tells Cargo to pass the\n/// [`-C link-arg=FLAG` option][link-arg] to the compiler, but only when building\n/// the binary target.\n///\n/// Its usage is highly platform specific. It is useful to set\n/// a linker script or other linker options.\n///\n/// [link-arg]: https://doc.rust-lang.org/rustc/codegen-options/index.html#link-arg\n#[track_caller]\npub fn rustc_link_arg_bins(flag: &str) {\n if flag.contains([' ', '\\n']) {\n panic!(\"cannot emit rustc-link-arg-bins: invalid flag {flag:?}\");\n }\n emit(\"rustc-link-arg-bins\", flag);\n}\n\n/// The `rustc-link-arg-tests` instruction tells Cargo to pass the\n/// [`-C link-arg=FLAG` option][link-arg] to the compiler, but only when building\n/// a tests target.\n///\n/// [link-arg]: https://doc.rust-lang.org/rustc/codegen-options/index.html#link-arg\n#[track_caller]\npub fn rustc_link_arg_tests(flag: &str) {\n if flag.contains([' ', '\\n']) {\n panic!(\"cannot emit rustc-link-arg-tests: invalid flag {flag:?}\");\n }\n emit(\"rustc-link-arg-tests\", flag);\n}\n\n/// The `rustc-link-arg-examples` instruction tells Cargo to pass the\n/// [`-C link-arg=FLAG` option][link-arg] to the compiler, but only when building\n/// an examples target.\n///\n/// [link-arg]: https://doc.rust-lang.org/rustc/codegen-options/index.html#link-arg\n#[track_caller]\npub fn rustc_link_arg_examples(flag: &str) {\n if flag.contains([' ', '\\n']) {\n panic!(\"cannot emit rustc-link-arg-examples: invalid flag {flag:?}\");\n }\n emit(\"rustc-link-arg-examples\", flag);\n}\n\n/// The `rustc-link-arg-benches` instruction tells Cargo to pass the\n/// [`-C link-arg=FLAG` option][link-arg] to the compiler, but only when building\n/// a benchmark target.\n///\n/// [link-arg]: https://doc.rust-lang.org/rustc/codegen-options/index.html#link-arg\n#[track_caller]\npub fn rustc_link_arg_benches(flag: &str) {\n if flag.contains([' ', '\\n']) {\n panic!(\"cannot emit rustc-link-arg-benches: invalid flag {flag:?}\");\n }\n emit(\"rustc-link-arg-benches\", flag);\n}\n\n/// The `rustc-link-lib` instruction tells Cargo to link the given library using\n/// the compilerā€™s [`-l` flag][-l].\n///\n/// This is typically used to link a native library\n/// using [FFI].\n///\n/// The `LIB` string is passed directly to rustc, so it supports any syntax that\n/// `-l` does. Currently the full supported syntax for `LIB` is\n/// `[KIND[:MODIFIERS]=]NAME[:RENAME]`.\n///\n/// The `-l` flag is only passed to the library target of the package, unless there\n/// is no library target, in which case it is passed to all targets. This is done\n/// because all other targets have an implicit dependency on the library target,\n/// and the given library to link should only be included once. This means that\n/// if a package has both a library and a binary target, the library has access\n/// to the symbols from the given lib, and the binary should access them through\n/// the library targetā€™s public API.\n///\n/// The optional `KIND` may be one of `dylib`, `static`, or `framework`. See the\n/// [rustc book][-l] for more detail.\n///\n/// [-l]: https://doc.rust-lang.org/stable/rustc/command-line-arguments.html#option-l-link-lib\n/// [FFI]: https://doc.rust-lang.org/stable/nomicon/ffi.html\n#[track_caller]\npub fn rustc_link_lib(lib: &str) {\n if lib.contains([' ', '\\n']) {\n panic!(\"cannot emit rustc-link-lib: invalid lib {lib:?}\");\n }\n emit(\"rustc-link-lib\", lib);\n}\n\n/// Like [`rustc_link_lib`], but with `KIND[:MODIFIERS]` specified separately.\n#[track_caller]\npub fn rustc_link_lib_kind(kind: &str, lib: &str) {\n if kind.contains(['=', ' ', '\\n']) {\n panic!(\"cannot emit rustc-link-lib: invalid kind {kind:?}\");\n }\n if lib.contains([' ', '\\n']) {\n panic!(\"cannot emit rustc-link-lib: invalid lib {lib:?}\");\n }\n emit(\"rustc-link-lib\", format_args!(\"{kind}={lib}\"));\n}\n\n/// The `rustc-link-search` instruction tells Cargo to pass the [`-L` flag] to the\n/// compiler to add a directory to the library search path.\n///\n/// The optional `KIND` may be one of `dependency`, `crate`, `native`, `framework`,\n/// or `all`. See the [rustc book][-L] for more detail.\n///\n/// These paths are also added to the\n/// [dynamic library search path environment variable][search-path] if they are\n/// within the `OUT_DIR`. Depending on this behavior is discouraged since this\n/// makes it difficult to use the resulting binary. In general, it is best to\n/// avoid creating dynamic libraries in a build script (using existing system\n/// libraries is fine).\n///\n/// [-L]: https://doc.rust-lang.org/stable/rustc/command-line-arguments.html#option-l-search-path\n/// [search-path]: https://doc.rust-lang.org/stable/cargo/reference/environment-variables.html#dynamic-library-paths\n#[track_caller]\npub fn rustc_link_search(path: impl AsRef) {\n let Some(path) = path.as_ref().to_str() else {\n panic!(\"cannot emit rustc-link-search: path is not UTF-8\");\n };\n if path.contains('\\n') {\n panic!(\"cannot emit rustc-link-search: path contains newline\");\n }\n emit(\"rustc-link-search\", path);\n}\n\n/// Like [`rustc_link_search`], but with KIND specified separately.\n#[track_caller]\npub fn rustc_link_search_kind(kind: &str, path: impl AsRef) {\n if kind.contains(['=', '\\n']) {\n panic!(\"cannot emit rustc-link-search: invalid kind {kind:?}\");\n }\n let Some(path) = path.as_ref().to_str() else {\n panic!(\"cannot emit rustc-link-search: path is not UTF-8\");\n };\n if path.contains('\\n') {\n panic!(\"cannot emit rustc-link-search: path contains newline\");\n }\n emit(\"rustc-link-search\", format_args!(\"{kind}={path}\"));\n}\n\n/// The `rustc-flags` instruction tells Cargo to pass the given space-separated\n/// flags to the compiler.\n///\n/// This only allows the `-l` and `-L` flags, and is\n/// equivalent to using [`rustc_link_lib`] and [`rustc_link_search`].\n#[track_caller]\npub fn rustc_flags(flags: &str) {\n if flags.contains('\\n') {\n panic!(\"cannot emit rustc-flags: invalid flags\");\n }\n emit(\"rustc-flags\", flags);\n}\n\n/// The `rustc-cfg` instruction tells Cargo to pass the given value to the\n/// [`--cfg` flag][cfg] to the compiler.\n///\n/// This may be used for compile-time\n/// detection of features to enable conditional compilation.\n///\n/// Note that this does not affect Cargoā€™s dependency resolution. This cannot\n/// be used to enable an optional dependency, or enable other Cargo features.\n///\n/// Be aware that [Cargo features] use the form `feature=\"foo\"`. `cfg` values\n/// passed with this flag are not restricted to that form, and may provide just\n/// a single identifier, or any arbitrary key/value pair. For example, emitting\n/// `rustc_cfg(\"abc\")` will then allow code to use `#[cfg(abc)]` (note the lack\n/// of `feature=`). Or an arbitrary key/value pair may be used with an `=` symbol\n/// like `rustc_cfg(r#\"my_component=\"foo\"\"#)`. The key should be a Rust identifier,\n/// the value should be a string.\n///\n/// [cfg]: https://doc.rust-lang.org/rustc/command-line-arguments.html#option-cfg\n/// [Cargo features]: https://doc.rust-lang.org/cargo/reference/features.html\n#[track_caller]\npub fn rustc_cfg(key: &str) {\n if !is_ident(key) {\n panic!(\"cannot emit rustc-cfg: invalid key {key:?}\");\n }\n emit(\"rustc-cfg\", key);\n}\n\n/// Like [`rustc_cfg`], but with the value specified separately.\n///\n/// To replace the\n/// less convenient `rustc_cfg(r#\"my_component=\"foo\"\"#)`, you can instead use\n/// `rustc_cfg_value(\"my_component\", \"foo\")`.\n#[track_caller]\npub fn rustc_cfg_value(key: &str, value: &str) {\n if !is_ident(key) {\n panic!(\"cannot emit rustc-cfg-value: invalid key\");\n }\n let value = value.escape_default();\n emit(\"rustc-cfg\", format_args!(\"{key}=\\\"{value}\\\"\"));\n}\n\n/// Add to the list of expected config names that is used when checking the\n/// *reachable* cfg expressions with the [`unexpected_cfgs`] lint.\n///\n/// This form is for keys without an expected value, such as `cfg(name)`.\n///\n/// It is recommended to group the `rustc_check_cfg` and `rustc_cfg` calls as\n/// closely as possible in order to avoid typos, missing check_cfg, stale cfgs,\n/// and other mistakes.\n///\n/// [`unexpected_cfgs`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#unexpected-cfgs\n#[doc = respected_msrv!(\"1.80\")]\n#[track_caller]\npub fn rustc_check_cfgs(keys: &[&str]) {\n if keys.is_empty() {\n return;\n }\n for key in keys {\n if !is_ident(key) {\n panic!(\"cannot emit rustc-check-cfg: invalid key {key:?}\");\n }\n }\n\n let mut directive = keys[0].to_string();\n for key in &keys[1..] {\n write!(directive, \", {key}\").expect(\"writing to string should be infallible\");\n }\n emit(\"rustc-check-cfg\", format_args!(\"cfg({directive})\"));\n}\n\n/// Add to the list of expected config names that is used when checking the\n/// *reachable* cfg expressions with the [`unexpected_cfgs`] lint.\n///\n/// This form is for keys with expected values, such as `cfg(name = \"value\")`.\n///\n/// It is recommended to group the `rustc_check_cfg` and `rustc_cfg` calls as\n/// closely as possible in order to avoid typos, missing check_cfg, stale cfgs,\n/// and other mistakes.\n///\n/// [`unexpected_cfgs`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#unexpected-cfgs\n#[doc = respected_msrv!(\"1.80\")]\n#[track_caller]\npub fn rustc_check_cfg_values(key: &str, values: &[&str]) {\n if !is_ident(key) {\n panic!(\"cannot emit rustc-check-cfg: invalid key {key:?}\");\n }\n if values.is_empty() {\n rustc_check_cfgs(&[key]);\n return;\n }\n\n let mut directive = format!(\"\\\"{}\\\"\", values[0].escape_default());\n for value in &values[1..] {\n write!(directive, \", \\\"{}\\\"\", value.escape_default())\n .expect(\"writing to string should be infallible\");\n }\n emit(\n \"rustc-check-cfg\",\n format_args!(\"cfg({key}, values({directive}))\"),\n );\n}\n\n/// The `rustc-env` instruction tells Cargo to set the given environment variable\n/// when compiling the package.\n///\n/// The value can be then retrieved by the\n/// [`env!` macro][env!] in the compiled crate. This is useful for embedding\n/// additional metadata in crateā€™s code, such as the hash of git HEAD or the\n/// unique identifier of a continuous integration server.\n///\n/// See also the [environment variables automatically included by Cargo][cargo-env].\n///\n/// [cargo-env]: https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates\n#[track_caller]\npub fn rustc_env(key: &str, value: &str) {\n if key.contains(['=', '\\n']) {\n panic!(\"cannot emit rustc-env: invalid key {key:?}\");\n }\n if value.contains('\\n') {\n panic!(\"cannot emit rustc-env: invalid value {value:?}\");\n }\n emit(\"rustc-env\", format_args!(\"{key}={value}\"));\n}\n\n/// The `rustc-cdylib-link-arg` instruction tells Cargo to pass the\n/// [`-C link-arg=FLAG` option][link-arg] to the compiler, but only when building\n/// a `cdylib` library target.\n///\n/// Its usage is highly platform specific. It is useful\n/// to set the shared library version or the runtime-path.\n///\n/// [link-arg]: https://doc.rust-lang.org/rustc/codegen-options/index.html#link-arg\n#[track_caller]\npub fn rustc_cdylib_link_arg(flag: &str) {\n if flag.contains('\\n') {\n panic!(\"cannot emit rustc-cdylib-link-arg: invalid flag {flag:?}\");\n }\n emit(\"rustc-cdylib-link-arg\", flag);\n}\n\n/// The `warning` instruction tells Cargo to display a warning after the build\n/// script has finished running.\n///\n/// Warnings are only shown for path dependencies\n/// (that is, those youā€™re working on locally), so for example warnings printed\n/// out in [crates.io] crates are not emitted by default. The `-vv` ā€œvery verboseā€\n/// flag may be used to have Cargo display warnings for all crates.\n///\n/// [crates.io]: https://crates.io/\n#[track_caller]\npub fn warning(message: &str) {\n if message.contains('\\n') {\n panic!(\"cannot emit warning: message contains newline\");\n }\n emit(\"warning\", message);\n}\n\n/// The `error` instruction tells Cargo to display an error after the build script has finished\n/// running, and then fail the build.\n///\n///
\n///\n/// Build script libraries should carefully consider if they want to use [`error`] versus\n/// returning a `Result`. It may be better to return a `Result`, and allow the caller to decide if the\n/// error is fatal or not. The caller can then decide whether or not to display the `Err` variant\n/// using [`error`].\n///\n///
\n#[doc = respected_msrv!(\"1.84\")]\n#[track_caller]\npub fn error(message: &str) {\n if message.contains('\\n') {\n panic!(\"cannot emit error: message contains newline\");\n }\n emit(\"error\", message);\n}\n\n/// Metadata, used by `links` scripts.\n#[track_caller]\npub fn metadata(key: &str, val: &str) {\n if !is_ascii_ident(key) {\n panic!(\"cannot emit metadata: invalid key {key:?}\");\n }\n if val.contains('\\n') {\n panic!(\"cannot emit metadata: invalid value {val:?}\");\n }\n\n emit(\"metadata\", format_args!(\"{key}={val}\"));\n}\n" }, { "path": "crates/build-rs-test-lib/Cargo.toml", "content": "[package]\nname = \"build-rs-test-lib\"\nversion = \"0.0.0\"\nedition.workspace = true\npublish = false\n\n[features]\nunstable = [\"build-rs/unstable\"]\n\n[build-dependencies]\nbuild-rs.workspace = true\n" }, { "path": "crates/build-rs-test-lib/build.rs", "content": "fn main() {\n smoke_test_inputs();\n\n build_rs::output::rerun_if_changed(\"build.rs\");\n build_rs::output::rustc_check_cfgs(&[\"did_run_build_script\"]);\n build_rs::output::rustc_cfg(\"did_run_build_script\");\n}\n\nfn smoke_test_inputs() {\n use build_rs::input::*;\n dbg!(cargo());\n dbg!(cargo_cfg_feature());\n dbg!(cargo_cfg(\"careful\"));\n dbg!(cargo_cfg_debug_assertions());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_fmt_debug());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_overflow_checks());\n dbg!(cargo_cfg_panic());\n dbg!(cargo_cfg_proc_macro());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_relocation_model());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_sanitize());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_sanitizer_cfi_generalize_pointers());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_sanitizer_cfi_normalize_integers());\n dbg!(cargo_cfg_target_abi());\n dbg!(cargo_cfg_target_arch());\n dbg!(cargo_cfg_target_endian());\n dbg!(cargo_cfg_target_env());\n dbg!(cargo_cfg_target_feature());\n dbg!(cargo_cfg_target_has_atomic());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_target_has_atomic_equal_alignment());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_target_has_atomic_load_store());\n dbg!(cargo_cfg_target_os());\n dbg!(cargo_cfg_target_pointer_width());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_target_thread_local());\n dbg!(cargo_cfg_target_vendor());\n #[cfg(feature = \"unstable\")]\n dbg!(cargo_cfg_ub_checks());\n dbg!(cargo_cfg_unix());\n dbg!(cargo_cfg_windows());\n dbg!(cargo_encoded_rustflags());\n dbg!(cargo_feature(\"unstable\"));\n dbg!(cargo_manifest_dir());\n dbg!(cargo_manifest_path());\n dbg!(cargo_manifest_links());\n dbg!(cargo_pkg_authors());\n dbg!(cargo_pkg_description());\n dbg!(cargo_pkg_homepage());\n dbg!(cargo_pkg_license());\n dbg!(cargo_pkg_license_file());\n dbg!(cargo_pkg_name());\n dbg!(cargo_pkg_readme());\n dbg!(cargo_pkg_repository());\n dbg!(cargo_pkg_rust_version());\n dbg!(cargo_pkg_version());\n dbg!(cargo_pkg_version_major());\n dbg!(cargo_pkg_version_minor());\n dbg!(cargo_pkg_version_patch());\n dbg!(cargo_pkg_version_pre());\n dbg!(debug());\n dbg!(dep_metadata(\"z\", \"include\"));\n dbg!(host());\n dbg!(num_jobs());\n dbg!(opt_level());\n dbg!(out_dir());\n dbg!(profile());\n dbg!(rustc());\n dbg!(rustc_linker());\n dbg!(rustc_workspace_wrapper());\n dbg!(rustc_wrapper());\n dbg!(rustdoc());\n dbg!(target());\n}\n" }, { "path": "crates/build-rs-test-lib/src/lib.rs", "content": "#[test]\nfn test() {\n const { assert!(cfg!(did_run_build_script)) };\n}\n" }, { "path": "crates/cargo-platform/Cargo.toml", "content": "[package]\nname = \"cargo-platform\"\nversion = \"0.3.3\"\nedition.workspace = true\nlicense.workspace = true\nrust-version.workspace = true\nrepository.workspace = true\ndocumentation = \"https://docs.rs/cargo-platform\"\ndescription = \"Cargo's representation of a target platform.\"\n\n[dependencies]\nserde_core.workspace = true\n\n# serde v1.0.220 is the first version that released with `serde_core`.\n# This is required to avoid conflict with other `serde` users which may require an older version.\n[target.'cfg(any())'.dependencies]\nserde.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/cargo-platform/README.md", "content": "> This crate is maintained by the Cargo team for use by the wider\n> ecosystem. This crate follows semver compatibility for its APIs.\n" }, { "path": "crates/cargo-platform/examples/matches.rs", "content": "//! This example demonstrates how to filter a Platform based on the current\n//! host target.\n\n#![allow(clippy::print_stdout)]\n\nuse cargo_platform::{Cfg, Platform};\nuse std::process::Command;\nuse std::str::FromStr;\n\nstatic EXAMPLES: &[&str] = &[\n \"cfg(windows)\",\n \"cfg(unix)\",\n \"cfg(target_os=\\\"macos\\\")\",\n \"cfg(target_os=\\\"linux\\\")\",\n \"cfg(any(target_arch=\\\"x86\\\", target_arch=\\\"x86_64\\\"))\",\n];\n\nfn main() {\n let target = get_target();\n let cfgs = get_cfgs();\n println!(\"host target={} cfgs:\", target);\n for cfg in &cfgs {\n println!(\" {}\", cfg);\n }\n let mut examples: Vec<&str> = EXAMPLES.iter().copied().collect();\n examples.push(target.as_str());\n for example in examples {\n let p = Platform::from_str(example).unwrap();\n println!(\"{:?} matches: {:?}\", example, p.matches(&target, &cfgs));\n }\n}\n\nfn get_target() -> String {\n let output = Command::new(\"rustc\")\n .arg(\"-Vv\")\n .output()\n .expect(\"rustc failed to run\");\n let stdout = String::from_utf8(output.stdout).unwrap();\n for line in stdout.lines() {\n if let Some(line) = line.strip_prefix(\"host: \") {\n return String::from(line);\n }\n }\n panic!(\"Failed to find host: {}\", stdout);\n}\n\nfn get_cfgs() -> Vec {\n let output = Command::new(\"rustc\")\n .arg(\"--print=cfg\")\n .output()\n .expect(\"rustc failed to run\");\n let stdout = String::from_utf8(output.stdout).unwrap();\n stdout\n .lines()\n .map(|line| Cfg::from_str(line).unwrap())\n .collect()\n}\n" }, { "path": "crates/cargo-platform/src/cfg.rs", "content": "use crate::error::{ParseError, ParseErrorKind::*};\nuse std::fmt;\nuse std::hash::{Hash, Hasher};\nuse std::iter;\nuse std::str::{self, FromStr};\n\n/// A cfg expression.\n#[derive(Eq, PartialEq, Hash, Ord, PartialOrd, Clone, Debug)]\npub enum CfgExpr {\n Not(Box),\n All(Vec),\n Any(Vec),\n Value(Cfg),\n True,\n False,\n}\n\n/// A cfg value.\n#[derive(Eq, PartialEq, Hash, Ord, PartialOrd, Clone, Debug)]\npub enum Cfg {\n /// A named cfg value, like `unix`.\n Name(Ident),\n /// A key/value cfg pair, like `target_os = \"linux\"`.\n KeyPair(Ident, String),\n}\n\n/// A identifier\n#[derive(Eq, Ord, PartialOrd, Clone, Debug)]\npub struct Ident {\n /// The identifier\n pub name: String,\n /// Is this a raw ident: `r#async`\n ///\n /// It's mainly used for display and doesn't take\n /// part in the hash or equality (`foo` == `r#foo`).\n pub raw: bool,\n}\n\n#[derive(PartialEq)]\nenum Token<'a> {\n LeftParen,\n RightParen,\n Ident(bool, &'a str),\n Comma,\n Equals,\n String(&'a str),\n}\n\n/// The list of keywords.\n///\n/// We should consider all the keywords, but some are conditional on\n/// the edition so for now we just consider true/false.\n///\n/// \npub(crate) const KEYWORDS: &[&str; 2] = &[\"true\", \"false\"];\n\n#[derive(Clone)]\nstruct Tokenizer<'a> {\n s: iter::Peekable>,\n orig: &'a str,\n}\n\nstruct Parser<'a> {\n t: Tokenizer<'a>,\n}\n\nimpl Ident {\n pub fn as_str(&self) -> &str {\n &self.name\n }\n}\n\nimpl Hash for Ident {\n fn hash(&self, state: &mut H) {\n self.name.hash(state);\n }\n}\n\nimpl PartialEq for Ident {\n fn eq(&self, other: &str) -> bool {\n self.name == other\n }\n}\n\nimpl PartialEq<&str> for Ident {\n fn eq(&self, other: &&str) -> bool {\n self.name == *other\n }\n}\n\nimpl PartialEq for Ident {\n fn eq(&self, other: &Ident) -> bool {\n self.name == other.name\n }\n}\n\nimpl fmt::Display for Ident {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n if self.raw {\n f.write_str(\"r#\")?;\n }\n f.write_str(&*self.name)\n }\n}\n\nimpl FromStr for Cfg {\n type Err = ParseError;\n\n fn from_str(s: &str) -> Result {\n let mut p = Parser::new(s);\n let e = p.cfg()?;\n if let Some(rest) = p.rest() {\n return Err(ParseError::new(\n p.t.orig,\n UnterminatedExpression(rest.to_string()),\n ));\n }\n Ok(e)\n }\n}\n\nimpl fmt::Display for Cfg {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match *self {\n Cfg::Name(ref s) => s.fmt(f),\n Cfg::KeyPair(ref k, ref v) => write!(f, \"{} = \\\"{}\\\"\", k, v),\n }\n }\n}\n\nimpl CfgExpr {\n /// Utility function to check if the key, \"cfg(..)\" matches the `target_cfg`\n pub fn matches_key(key: &str, target_cfg: &[Cfg]) -> bool {\n if key.starts_with(\"cfg(\") && key.ends_with(')') {\n let cfg = &key[4..key.len() - 1];\n\n CfgExpr::from_str(cfg)\n .ok()\n .map(|ce| ce.matches(target_cfg))\n .unwrap_or(false)\n } else {\n false\n }\n }\n\n pub fn matches(&self, cfg: &[Cfg]) -> bool {\n match *self {\n CfgExpr::Not(ref e) => !e.matches(cfg),\n CfgExpr::All(ref e) => e.iter().all(|e| e.matches(cfg)),\n CfgExpr::Any(ref e) => e.iter().any(|e| e.matches(cfg)),\n CfgExpr::Value(ref e) => cfg.contains(e),\n CfgExpr::True => true,\n CfgExpr::False => false,\n }\n }\n}\n\nimpl FromStr for CfgExpr {\n type Err = ParseError;\n\n fn from_str(s: &str) -> Result {\n let mut p = Parser::new(s);\n let e = p.expr()?;\n if let Some(rest) = p.rest() {\n return Err(ParseError::new(\n p.t.orig,\n UnterminatedExpression(rest.to_string()),\n ));\n }\n Ok(e)\n }\n}\n\nimpl fmt::Display for CfgExpr {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match *self {\n CfgExpr::Not(ref e) => write!(f, \"not({})\", e),\n CfgExpr::All(ref e) => write!(f, \"all({})\", CommaSep(e)),\n CfgExpr::Any(ref e) => write!(f, \"any({})\", CommaSep(e)),\n CfgExpr::Value(ref e) => write!(f, \"{}\", e),\n CfgExpr::True => write!(f, \"true\"),\n CfgExpr::False => write!(f, \"false\"),\n }\n }\n}\n\nstruct CommaSep<'a, T>(&'a [T]);\n\nimpl<'a, T: fmt::Display> fmt::Display for CommaSep<'a, T> {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n for (i, v) in self.0.iter().enumerate() {\n if i > 0 {\n write!(f, \", \")?;\n }\n write!(f, \"{}\", v)?;\n }\n Ok(())\n }\n}\n\nimpl<'a> Parser<'a> {\n fn new(s: &'a str) -> Parser<'a> {\n Parser {\n t: Tokenizer {\n s: s.char_indices().peekable(),\n orig: s,\n },\n }\n }\n\n fn expr(&mut self) -> Result {\n match self.peek() {\n Some(Ok(Token::Ident(false, op @ \"all\")))\n | Some(Ok(Token::Ident(false, op @ \"any\"))) => {\n self.t.next();\n let mut e = Vec::new();\n self.eat(&Token::LeftParen)?;\n while !self.r#try(&Token::RightParen) {\n e.push(self.expr()?);\n if !self.r#try(&Token::Comma) {\n self.eat(&Token::RightParen)?;\n break;\n }\n }\n if op == \"all\" {\n Ok(CfgExpr::All(e))\n } else {\n Ok(CfgExpr::Any(e))\n }\n }\n Some(Ok(Token::Ident(false, \"not\"))) => {\n self.t.next();\n self.eat(&Token::LeftParen)?;\n let e = self.expr()?;\n self.eat(&Token::RightParen)?;\n Ok(CfgExpr::Not(Box::new(e)))\n }\n Some(Ok(..)) => self.cfg().map(|v| match v {\n Cfg::Name(n) if n == \"true\" => CfgExpr::True,\n Cfg::Name(n) if n == \"false\" => CfgExpr::False,\n v => CfgExpr::Value(v),\n }),\n Some(Err(..)) => Err(self.t.next().unwrap().err().unwrap()),\n None => Err(ParseError::new(\n self.t.orig,\n IncompleteExpr(\"start of a cfg expression\"),\n )),\n }\n }\n\n fn cfg(&mut self) -> Result {\n match self.t.next() {\n Some(Ok(Token::Ident(raw, name))) => {\n let e = if self.r#try(&Token::Equals) {\n let val = match self.t.next() {\n Some(Ok(Token::String(s))) => s,\n Some(Ok(t)) => {\n return Err(ParseError::new(\n self.t.orig,\n UnexpectedToken {\n expected: \"a string\",\n found: t.classify(),\n },\n ));\n }\n Some(Err(e)) => return Err(e),\n None => {\n return Err(ParseError::new(self.t.orig, IncompleteExpr(\"a string\")));\n }\n };\n Cfg::KeyPair(\n Ident {\n name: name.to_string(),\n raw,\n },\n val.to_string(),\n )\n } else {\n Cfg::Name(Ident {\n name: name.to_string(),\n raw,\n })\n };\n Ok(e)\n }\n Some(Ok(t)) => Err(ParseError::new(\n self.t.orig,\n UnexpectedToken {\n expected: \"identifier\",\n found: t.classify(),\n },\n )),\n Some(Err(e)) => Err(e),\n None => Err(ParseError::new(self.t.orig, IncompleteExpr(\"identifier\"))),\n }\n }\n\n fn peek(&mut self) -> Option, ParseError>> {\n self.t.clone().next()\n }\n\n fn r#try(&mut self, token: &Token<'a>) -> bool {\n match self.peek() {\n Some(Ok(ref t)) if token == t => {}\n _ => return false,\n }\n self.t.next();\n true\n }\n\n fn eat(&mut self, token: &Token<'a>) -> Result<(), ParseError> {\n match self.t.next() {\n Some(Ok(ref t)) if token == t => Ok(()),\n Some(Ok(t)) => Err(ParseError::new(\n self.t.orig,\n UnexpectedToken {\n expected: token.classify(),\n found: t.classify(),\n },\n )),\n Some(Err(e)) => Err(e),\n None => Err(ParseError::new(\n self.t.orig,\n IncompleteExpr(token.classify()),\n )),\n }\n }\n\n /// Returns the rest of the input from the current location.\n fn rest(&self) -> Option<&str> {\n let mut s = self.t.s.clone();\n loop {\n match s.next() {\n Some((_, ' ')) => {}\n Some((start, _ch)) => return Some(&self.t.orig[start..]),\n None => return None,\n }\n }\n }\n}\n\nimpl<'a> Iterator for Tokenizer<'a> {\n type Item = Result, ParseError>;\n\n fn next(&mut self) -> Option, ParseError>> {\n loop {\n match self.s.next() {\n Some((_, ' ')) => {}\n Some((_, '(')) => return Some(Ok(Token::LeftParen)),\n Some((_, ')')) => return Some(Ok(Token::RightParen)),\n Some((_, ',')) => return Some(Ok(Token::Comma)),\n Some((_, '=')) => return Some(Ok(Token::Equals)),\n Some((start, '\"')) => {\n while let Some((end, ch)) = self.s.next() {\n if ch == '\"' {\n return Some(Ok(Token::String(&self.orig[start + 1..end])));\n }\n }\n return Some(Err(ParseError::new(self.orig, UnterminatedString)));\n }\n Some((start, ch)) if is_ident_start(ch) => {\n let (start, raw) = if ch == 'r' {\n if let Some(&(_pos, '#')) = self.s.peek() {\n // starts with `r#` is a raw ident\n self.s.next();\n if let Some((start, ch)) = self.s.next() {\n if is_ident_start(ch) {\n (start, true)\n } else {\n // not a starting ident character\n return Some(Err(ParseError::new(\n self.orig,\n UnexpectedChar(ch),\n )));\n }\n } else {\n // not followed by a ident, error out\n return Some(Err(ParseError::new(\n self.orig,\n IncompleteExpr(\"identifier\"),\n )));\n }\n } else {\n // starts with `r` but not does continue with `#`\n // cannot be a raw ident\n (start, false)\n }\n } else {\n // do not start with `r`, cannot be a raw ident\n (start, false)\n };\n while let Some(&(end, ch)) = self.s.peek() {\n if !is_ident_rest(ch) {\n return Some(Ok(Token::Ident(raw, &self.orig[start..end])));\n } else {\n self.s.next();\n }\n }\n return Some(Ok(Token::Ident(raw, &self.orig[start..])));\n }\n Some((_, ch)) => {\n return Some(Err(ParseError::new(self.orig, UnexpectedChar(ch))));\n }\n None => return None,\n }\n }\n }\n}\n\nfn is_ident_start(ch: char) -> bool {\n ch == '_' || ch.is_ascii_alphabetic()\n}\n\nfn is_ident_rest(ch: char) -> bool {\n is_ident_start(ch) || ch.is_ascii_digit()\n}\n\nimpl<'a> Token<'a> {\n fn classify(&self) -> &'static str {\n match *self {\n Token::LeftParen => \"`(`\",\n Token::RightParen => \"`)`\",\n Token::Ident(..) => \"an identifier\",\n Token::Comma => \"`,`\",\n Token::Equals => \"`=`\",\n Token::String(..) => \"a string\",\n }\n }\n}\n" }, { "path": "crates/cargo-platform/src/error.rs", "content": "use std::fmt;\n\n#[derive(Debug)]\npub struct ParseError {\n kind: ParseErrorKind,\n orig: String,\n}\n\n#[non_exhaustive]\n#[derive(Debug)]\npub enum ParseErrorKind {\n UnterminatedString,\n UnexpectedChar(char),\n UnexpectedToken {\n expected: &'static str,\n found: &'static str,\n },\n IncompleteExpr(&'static str),\n UnterminatedExpression(String),\n InvalidTarget(String),\n}\n\nimpl fmt::Display for ParseError {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(\n f,\n \"failed to parse `{}` as a cfg expression: {}\",\n self.orig, self.kind\n )\n }\n}\n\nimpl fmt::Display for ParseErrorKind {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n use ParseErrorKind::*;\n match self {\n UnterminatedString => write!(f, \"unterminated string in cfg\"),\n UnexpectedChar(ch) => write!(\n f,\n \"unexpected character `{}` in cfg, expected parens, a comma, \\\n an identifier, or a string\",\n ch\n ),\n UnexpectedToken { expected, found } => {\n write!(f, \"expected {}, found {}\", expected, found)\n }\n IncompleteExpr(expected) => {\n write!(f, \"expected {}, but cfg expression ended\", expected)\n }\n UnterminatedExpression(s) => {\n write!(f, \"unexpected content `{}` found after cfg expression\", s)\n }\n InvalidTarget(s) => write!(f, \"invalid target specifier: {}\", s),\n }\n }\n}\n\nimpl std::error::Error for ParseError {}\n\nimpl ParseError {\n pub fn new(orig: &str, kind: ParseErrorKind) -> ParseError {\n ParseError {\n kind,\n orig: orig.to_string(),\n }\n }\n}\n" }, { "path": "crates/cargo-platform/src/lib.rs", "content": "//! Platform definition used by Cargo.\n//!\n//! This defines a [`Platform`] type which is used in Cargo to specify a target platform.\n//! There are two kinds, a named target like `x86_64-apple-darwin`, and a \"cfg expression\"\n//! like `cfg(any(target_os = \"macos\", target_os = \"ios\"))`.\n//!\n//! See `examples/matches.rs` for an example of how to match against a `Platform`.\n//!\n//! > This crate is maintained by the Cargo team for use by the wider\n//! > ecosystem. This crate follows semver compatibility for its APIs.\n//!\n//! [`Platform`]: enum.Platform.html\n\nuse std::str::FromStr;\nuse std::{fmt, path::Path};\n\nmod cfg;\nmod error;\n\nuse cfg::KEYWORDS;\npub use cfg::{Cfg, CfgExpr, Ident};\npub use error::{ParseError, ParseErrorKind};\n\n/// Platform definition.\n#[derive(Eq, PartialEq, Hash, Ord, PartialOrd, Clone, Debug)]\npub enum Platform {\n /// A named platform, like `x86_64-apple-darwin`.\n Name(String),\n /// A cfg expression, like `cfg(windows)`.\n Cfg(CfgExpr),\n}\n\nimpl Platform {\n /// Returns whether the Platform matches the given target and cfg.\n ///\n /// The named target and cfg values should be obtained from `rustc`.\n pub fn matches(&self, name: &str, cfg: &[Cfg]) -> bool {\n match *self {\n Platform::Name(ref p) => p == name,\n Platform::Cfg(ref p) => p.matches(cfg),\n }\n }\n\n fn validate_named_platform(name: &str) -> Result<(), ParseError> {\n if let Some(ch) = name\n .chars()\n .find(|&c| !(c.is_alphanumeric() || c == '_' || c == '-' || c == '.'))\n {\n if name.chars().any(|c| c == '(') {\n return Err(ParseError::new(\n name,\n ParseErrorKind::InvalidTarget(\n \"unexpected `(` character, cfg expressions must start with `cfg(`\"\n .to_string(),\n ),\n ));\n }\n return Err(ParseError::new(\n name,\n ParseErrorKind::InvalidTarget(format!(\n \"unexpected character {} in target name\",\n ch\n )),\n ));\n }\n Ok(())\n }\n\n pub fn check_cfg_attributes(&self, warnings: &mut Vec) {\n fn check_cfg_expr(expr: &CfgExpr, warnings: &mut Vec) {\n match *expr {\n CfgExpr::Not(ref e) => check_cfg_expr(e, warnings),\n CfgExpr::All(ref e) | CfgExpr::Any(ref e) => {\n for e in e {\n check_cfg_expr(e, warnings);\n }\n }\n CfgExpr::Value(ref e) => match e {\n Cfg::Name(name) => match name.as_str() {\n \"test\" | \"debug_assertions\" | \"proc_macro\" =>\n warnings.push(format!(\n \"Found `{}` in `target.'cfg(...)'.dependencies`. \\\n This value is not supported for selecting dependencies \\\n and will not work as expected. \\\n To learn more visit \\\n https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#platform-specific-dependencies\",\n name\n )),\n _ => (),\n },\n Cfg::KeyPair(name, _) => if name.as_str() == \"feature\" {\n warnings.push(String::from(\n \"Found `feature = ...` in `target.'cfg(...)'.dependencies`. \\\n This key is not supported for selecting dependencies \\\n and will not work as expected. \\\n Use the [features] section instead: \\\n https://doc.rust-lang.org/cargo/reference/features.html\"\n ))\n },\n }\n CfgExpr::True | CfgExpr::False => {},\n }\n }\n\n if let Platform::Cfg(cfg) = self {\n check_cfg_expr(cfg, warnings);\n }\n }\n\n pub fn check_cfg_keywords(&self, warnings: &mut Vec, path: &Path) {\n fn check_cfg_expr(expr: &CfgExpr, warnings: &mut Vec, path: &Path) {\n match *expr {\n CfgExpr::Not(ref e) => check_cfg_expr(e, warnings, path),\n CfgExpr::All(ref e) | CfgExpr::Any(ref e) => {\n for e in e {\n check_cfg_expr(e, warnings, path);\n }\n }\n CfgExpr::True | CfgExpr::False => {}\n CfgExpr::Value(ref e) => match e {\n Cfg::Name(name) | Cfg::KeyPair(name, _) => {\n if !name.raw && KEYWORDS.contains(&name.as_str()) {\n warnings.push(format!(\n \"[{}] future-incompatibility: `cfg({e})` is deprecated as `{name}` is a keyword \\\n and not an identifier and should not have have been accepted in this position.\\n \\\n | this was previously accepted by Cargo but is being phased out; it will become a hard error in a future release!\\n \\\n |\\n \\\n | help: use raw-idents instead: `cfg(r#{name})`\",\n path.display()\n ));\n }\n }\n },\n }\n }\n\n if let Platform::Cfg(cfg) = self {\n check_cfg_expr(cfg, warnings, path);\n }\n }\n}\n\nimpl serde_core::Serialize for Platform {\n fn serialize(&self, s: S) -> Result\n where\n S: serde_core::Serializer,\n {\n self.to_string().serialize(s)\n }\n}\n\nimpl<'de> serde_core::Deserialize<'de> for Platform {\n fn deserialize(deserializer: D) -> Result\n where\n D: serde_core::Deserializer<'de>,\n {\n let s = String::deserialize(deserializer)?;\n FromStr::from_str(&s).map_err(serde_core::de::Error::custom)\n }\n}\n\nimpl FromStr for Platform {\n type Err = ParseError;\n\n fn from_str(s: &str) -> Result {\n if let Some(s) = s.strip_prefix(\"cfg(\").and_then(|s| s.strip_suffix(')')) {\n s.parse().map(Platform::Cfg)\n } else {\n Platform::validate_named_platform(s)?;\n Ok(Platform::Name(s.to_string()))\n }\n }\n}\n\nimpl fmt::Display for Platform {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match *self {\n Platform::Name(ref n) => n.fmt(f),\n Platform::Cfg(ref e) => write!(f, \"cfg({})\", e),\n }\n }\n}\n" }, { "path": "crates/cargo-platform/tests/test_cfg.rs", "content": "use cargo_platform::{Cfg, CfgExpr, Ident, Platform};\nuse std::fmt;\nuse std::str::FromStr;\n\nmacro_rules! c {\n ($a:ident) => {\n Cfg::Name(Ident {\n name: stringify!($a).to_string(),\n raw: false,\n })\n };\n (r # $a:ident) => {\n Cfg::Name(Ident {\n name: stringify!($a).to_string(),\n raw: true,\n })\n };\n ($a:ident = $e:expr) => {\n Cfg::KeyPair(\n Ident {\n name: stringify!($a).to_string(),\n raw: false,\n },\n $e.to_string(),\n )\n };\n (r # $a:ident = $e:expr) => {\n Cfg::KeyPair(\n Ident {\n name: stringify!($a).to_string(),\n raw: true,\n },\n $e.to_string(),\n )\n };\n}\n\nmacro_rules! e {\n (any($($t:tt),*)) => (CfgExpr::Any(vec![$(e!($t)),*]));\n (all($($t:tt),*)) => (CfgExpr::All(vec![$(e!($t)),*]));\n (not($($t:tt)*)) => (CfgExpr::Not(Box::new(e!($($t)*))));\n (true) => (CfgExpr::True);\n (false) => (CfgExpr::False);\n (($($t:tt)*)) => (e!($($t)*));\n ($($t:tt)*) => (CfgExpr::Value(c!($($t)*)));\n}\n\nfn good(s: &str, expected: T)\nwhere\n T: FromStr + PartialEq + fmt::Debug,\n T::Err: fmt::Display,\n{\n let c = match T::from_str(s) {\n Ok(c) => c,\n Err(e) => panic!(\"failed to parse `{}`: {}\", s, e),\n };\n assert_eq!(c, expected);\n}\n\nfn bad(s: &str, err: &str)\nwhere\n T: FromStr + fmt::Display,\n T::Err: fmt::Display,\n{\n let e = match T::from_str(s) {\n Ok(cfg) => panic!(\"expected `{}` to not parse but got {}\", s, cfg),\n Err(e) => e.to_string(),\n };\n assert!(\n e.contains(err),\n \"when parsing `{}`,\\n\\\"{}\\\" not contained \\\n inside: {}\",\n s,\n err,\n e\n );\n}\n\n#[test]\nfn cfg_syntax() {\n good(\"foo\", c!(foo));\n good(\"_bar\", c!(_bar));\n good(\" foo\", c!(foo));\n good(\" foo \", c!(foo));\n good(\"r#foo\", c!(r # foo));\n good(\" foo = \\\"bar\\\"\", c!(foo = \"bar\"));\n good(\"foo=\\\"\\\"\", c!(foo = \"\"));\n good(\"r#foo=\\\"\\\"\", c!(r # foo = \"\"));\n good(\" foo=\\\"3\\\" \", c!(foo = \"3\"));\n good(\"foo = \\\"3 e\\\"\", c!(foo = \"3 e\"));\n good(\" r#foo = \\\"3 e\\\"\", c!(r # foo = \"3 e\"));\n}\n\n#[test]\nfn cfg_syntax_bad() {\n bad::(\"\", \"but cfg expression ended\");\n bad::(\" \", \"but cfg expression ended\");\n bad::(\"\\t\", \"unexpected character\");\n bad::(\"7\", \"unexpected character\");\n bad::(\"=\", \"expected identifier\");\n bad::(\",\", \"expected identifier\");\n bad::(\"(\", \"expected identifier\");\n bad::(\"foo (\", \"unexpected content `(` found after cfg expression\");\n bad::(\"bar =\", \"expected a string\");\n bad::(\"bar = \\\"\", \"unterminated string\");\n bad::(\n \"foo, bar\",\n \"unexpected content `, bar` found after cfg expression\",\n );\n bad::(\"r# foo\", \"unexpected character\");\n bad::(\"r #foo\", \"unexpected content\");\n bad::(\"r#\\\"foo\\\"\", \"unexpected character\");\n bad::(\"foo = r#\\\"\\\"\", \"unexpected character\");\n}\n\n#[test]\nfn cfg_expr() {\n good(\"foo\", e!(foo));\n good(\"_bar\", e!(_bar));\n good(\" foo\", e!(foo));\n good(\" foo \", e!(foo));\n good(\" foo = \\\"bar\\\"\", e!(foo = \"bar\"));\n good(\"foo=\\\"\\\"\", e!(foo = \"\"));\n good(\" foo=\\\"3\\\" \", e!(foo = \"3\"));\n good(\"foo = \\\"3 e\\\"\", e!(foo = \"3 e\"));\n\n good(\"true\", e!(true));\n good(\"false\", e!(false));\n\n good(\"all()\", e!(all()));\n good(\"all(a)\", e!(all(a)));\n good(\"all(a, b)\", e!(all(a, b)));\n good(\"all(a, )\", e!(all(a)));\n good(\"not(a = \\\"b\\\")\", e!(not(a = \"b\")));\n good(\"not(all(a))\", e!(not(all(a))));\n}\n\n#[test]\nfn cfg_expr_bad() {\n bad::(\" \", \"but cfg expression ended\");\n bad::(\" all\", \"expected `(`\");\n bad::(\"all(a\", \"expected `)`\");\n bad::(\"not\", \"expected `(`\");\n bad::(\"not(a\", \"expected `)`\");\n bad::(\"a = \", \"expected a string\");\n bad::(\"all(not())\", \"expected identifier\");\n bad::(\n \"foo(a)\",\n \"unexpected content `(a)` found after cfg expression\",\n );\n}\n\n#[test]\nfn cfg_matches() {\n assert!(e!(foo).matches(&[c!(bar), c!(foo), c!(baz)]));\n assert!(e!(any(foo)).matches(&[c!(bar), c!(foo), c!(baz)]));\n assert!(e!(any(foo, bar)).matches(&[c!(bar)]));\n assert!(e!(any(foo, bar)).matches(&[c!(foo)]));\n assert!(e!(all(foo, bar)).matches(&[c!(foo), c!(bar)]));\n assert!(e!(all(foo, bar)).matches(&[c!(foo), c!(bar)]));\n assert!(e!(not(foo)).matches(&[c!(bar)]));\n assert!(e!(not(foo)).matches(&[]));\n assert!(e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(bar)]));\n assert!(e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(foo), c!(bar)]));\n assert!(e!(foo).matches(&[c!(r # foo)]));\n assert!(e!(r # foo).matches(&[c!(foo)]));\n assert!(e!(r # foo).matches(&[c!(r # foo)]));\n\n assert!(!e!(foo).matches(&[]));\n assert!(!e!(foo).matches(&[c!(bar)]));\n assert!(!e!(foo).matches(&[c!(fo)]));\n assert!(!e!(any(foo)).matches(&[]));\n assert!(!e!(any(foo)).matches(&[c!(bar)]));\n assert!(!e!(any(foo)).matches(&[c!(bar), c!(baz)]));\n assert!(!e!(all(foo)).matches(&[c!(bar), c!(baz)]));\n assert!(!e!(all(foo, bar)).matches(&[c!(bar)]));\n assert!(!e!(all(foo, bar)).matches(&[c!(foo)]));\n assert!(!e!(all(foo, bar)).matches(&[]));\n assert!(!e!(not(bar)).matches(&[c!(bar)]));\n assert!(!e!(not(bar)).matches(&[c!(baz), c!(bar)]));\n assert!(!e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(foo)]));\n}\n\n#[test]\nfn bad_target_name() {\n bad::(\n \"any(cfg(unix), cfg(windows))\",\n \"failed to parse `any(cfg(unix), cfg(windows))` as a cfg expression: \\\n invalid target specifier: unexpected `(` character, \\\n cfg expressions must start with `cfg(`\",\n );\n bad::(\n \"!foo\",\n \"failed to parse `!foo` as a cfg expression: \\\n invalid target specifier: unexpected character ! in target name\",\n );\n}\n\n#[test]\nfn round_trip_platform() {\n fn rt(s: &str) {\n let p = Platform::from_str(s).unwrap();\n let s2 = p.to_string();\n let p2 = Platform::from_str(&s2).unwrap();\n assert_eq!(p, p2);\n }\n rt(\"x86_64-apple-darwin\");\n rt(\"foo\");\n rt(\"cfg(windows)\");\n rt(\"cfg(target_os = \\\"windows\\\")\");\n rt(\n \"cfg(any(all(any(target_os = \\\"android\\\", target_os = \\\"linux\\\"), \\\n any(target_arch = \\\"aarch64\\\", target_arch = \\\"arm\\\", target_arch = \\\"powerpc64\\\", \\\n target_arch = \\\"x86\\\", target_arch = \\\"x86_64\\\")), \\\n all(target_os = \\\"freebsd\\\", target_arch = \\\"x86_64\\\")))\",\n );\n}\n\n#[test]\nfn check_cfg_attributes() {\n fn ok(s: &str) {\n let p = Platform::Cfg(s.parse().unwrap());\n let mut warnings = Vec::new();\n p.check_cfg_attributes(&mut warnings);\n assert!(\n warnings.is_empty(),\n \"Expected no warnings but got: {:?}\",\n warnings,\n );\n }\n\n fn warn(s: &str, names: &[&str]) {\n let p = Platform::Cfg(s.parse().unwrap());\n let mut warnings = Vec::new();\n p.check_cfg_attributes(&mut warnings);\n assert_eq!(\n warnings.len(),\n names.len(),\n \"Expecter warnings about {:?} but got {:?}\",\n names,\n warnings,\n );\n for (name, warning) in names.iter().zip(warnings.iter()) {\n assert!(\n warning.contains(name),\n \"Expected warning about '{}' but got: {}\",\n name,\n warning,\n );\n }\n }\n\n ok(\"unix\");\n ok(\"windows\");\n ok(\"any(not(unix), windows)\");\n ok(\"foo\");\n ok(\"true\");\n ok(\"false\");\n\n ok(\"target_arch = \\\"abc\\\"\");\n ok(\"target_feature = \\\"abc\\\"\");\n ok(\"target_os = \\\"abc\\\"\");\n ok(\"target_family = \\\"abc\\\"\");\n ok(\"target_env = \\\"abc\\\"\");\n ok(\"target_endian = \\\"abc\\\"\");\n ok(\"target_pointer_width = \\\"abc\\\"\");\n ok(\"target_vendor = \\\"abc\\\"\");\n ok(\"bar = \\\"def\\\"\");\n\n warn(\"test\", &[\"test\"]);\n warn(\"debug_assertions\", &[\"debug_assertions\"]);\n warn(\"proc_macro\", &[\"proc_macro\"]);\n warn(\"feature = \\\"abc\\\"\", &[\"feature\"]);\n\n warn(\"any(not(debug_assertions), windows)\", &[\"debug_assertions\"]);\n warn(\n \"any(not(feature = \\\"def\\\"), target_arch = \\\"abc\\\")\",\n &[\"feature\"],\n );\n warn(\n \"any(not(target_os = \\\"windows\\\"), proc_macro)\",\n &[\"proc_macro\"],\n );\n warn(\n \"any(not(feature = \\\"windows\\\"), proc_macro)\",\n &[\"feature\", \"proc_macro\"],\n );\n warn(\n \"all(not(debug_assertions), any(windows, proc_macro))\",\n &[\"debug_assertions\", \"proc_macro\"],\n );\n}\n" }, { "path": "crates/cargo-test-macro/Cargo.toml", "content": "[package]\nname = \"cargo-test-macro\"\nversion = \"0.4.11\"\nedition.workspace = true\nrust-version = \"1.94\" # MSRV:1\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"Helper proc-macro for Cargo's testsuite.\"\n\n[lib]\nproc-macro = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/cargo-test-macro/README.md", "content": "> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use. This\n> crate may make major changes to its APIs or be deprecated without warning.\n" }, { "path": "crates/cargo-test-macro/src/lib.rs", "content": "//! # Cargo test macro.\n//!\n//! This is meant to be consumed alongside `cargo-test-support`. See\n//! for a guide on writing tests.\n//!\n//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use. This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\nuse proc_macro::*;\nuse std::path::Path;\nuse std::process::Command;\nuse std::sync::LazyLock;\n\n/// Replacement for `#[test]`\n///\n/// The `#[cargo_test]` attribute extends `#[test]` with some setup before starting the test.\n/// It will create a filesystem \"sandbox\" under the \"cargo integration test\" directory for each test, such as `/path/to/cargo/target/tmp/cit/t123/`.\n/// The sandbox will contain a `home` directory that will be used instead of your normal home directory.\n///\n/// The `#[cargo_test]` attribute takes several options that will affect how the test is generated.\n/// They are listed in parentheses separated with commas, such as:\n///\n/// ```rust,ignore\n/// #[cargo_test(nightly, reason = \"-Zfoo is unstable\")]\n/// ```\n///\n/// The options it supports are:\n///\n/// * `>=1.64` --- This indicates that the test will only run with the given version of `rustc` or newer.\n/// This can be used when a new `rustc` feature has been stabilized that the test depends on.\n/// If this is specified, a `reason` is required to explain why it is being checked.\n/// * `nightly` --- This will cause the test to be ignored if not running on the nightly toolchain.\n/// This is useful for tests that use unstable options in `rustc` or `rustdoc`.\n/// These tests are run in Cargo's CI, but are disabled in rust-lang/rust's CI due to the difficulty of updating both repos simultaneously.\n/// A `reason` field is required to explain why it is nightly-only.\n/// * `requires = \"\"` --- This indicates a command that is required to be installed to be run.\n/// For example, `requires = \"rustfmt\"` means the test will only run if the executable `rustfmt` is installed.\n/// These tests are *always* run on CI.\n/// This is mainly used to avoid requiring contributors from having every dependency installed.\n/// * `build_std_real` --- This is a \"real\" `-Zbuild-std` test (in the `build_std` integration test).\n/// This only runs on nightly, and only if the environment variable `CARGO_RUN_BUILD_STD_TESTS` is set (these tests on run on Linux).\n/// * `build_std_mock` --- This is a \"mock\" `-Zbuild-std` test (which uses a mock standard library).\n/// This only runs on nightly, and is disabled for windows-gnu.\n/// * `public_network_test` --- This tests contacts the public internet.\n/// These tests are disabled unless the `CARGO_PUBLIC_NETWORK_TESTS` environment variable is set.\n/// Use of this should be *extremely rare*, please avoid using it if possible.\n/// The hosts it contacts should have a relatively high confidence that they are reliable and stable (such as github.com), especially in CI.\n/// The tests should be carefully considered for developer security and privacy as well.\n/// * `container_test` --- This indicates that it is a test that uses Docker.\n/// These tests are disabled unless the `CARGO_CONTAINER_TESTS` environment variable is set.\n/// This requires that you have Docker installed.\n/// The SSH tests also assume that you have OpenSSH installed.\n/// These should work on Linux, macOS, and Windows where possible.\n/// Unfortunately these tests are not run in CI for macOS or Windows (no Docker on macOS, and Windows does not support Linux images).\n/// See [`cargo-test-support::containers`](https://doc.rust-lang.org/nightly/nightly-rustc/cargo_test_support/containers) for more on writing these tests.\n/// * `ignore_windows=\"reason\"` --- Indicates that the test should be ignored on windows for the given reason.\n#[proc_macro_attribute]\npub fn cargo_test(attr: TokenStream, item: TokenStream) -> TokenStream {\n // Ideally these options would be embedded in the test itself. However, I\n // find it very helpful to have the test clearly state whether or not it\n // is ignored. It would be nice to have some kind of runtime ignore\n // support (such as\n // https://internals.rust-lang.org/t/pre-rfc-skippable-tests/14611).\n //\n // Unfortunately a big drawback here is that if the environment changes\n // (such as the existence of the `git` CLI), this will not trigger a\n // rebuild and the test will still be ignored. In theory, something like\n // `tracked_env` or `tracked_path`\n // (https://github.com/rust-lang/rust/issues/99515) could help with this,\n // but they don't really handle the absence of files well.\n let mut ignore = false;\n let mut requires_reason = false;\n let mut explicit_reason = None;\n let mut implicit_reasons = Vec::new();\n macro_rules! set_ignore {\n ($predicate:expr, $($arg:tt)*) => {\n let p = $predicate;\n ignore |= p;\n if p {\n implicit_reasons.push(std::fmt::format(format_args!($($arg)*)));\n }\n };\n }\n let is_not_nightly = !version().1;\n for rule in split_rules(attr) {\n match rule.as_str() {\n \"build_std_real\" => {\n // Only run the \"real\" build-std tests on nightly and with an\n // explicit opt-in (these generally only work on linux, and\n // have some extra requirements, and are slow, and can pollute\n // the environment since it downloads dependencies).\n set_ignore!(is_not_nightly, \"requires nightly\");\n set_ignore!(\n option_env!(\"CARGO_RUN_BUILD_STD_TESTS\").is_none(),\n \"CARGO_RUN_BUILD_STD_TESTS must be set\"\n );\n }\n \"build_std_mock\" => {\n // Only run the \"mock\" build-std tests on nightly and disable\n // for windows-gnu which is missing object files (see\n // https://github.com/rust-lang/wg-cargo-std-aware/issues/46).\n set_ignore!(is_not_nightly, \"requires nightly\");\n set_ignore!(\n cfg!(all(target_os = \"windows\", target_env = \"gnu\")),\n \"does not work on windows-gnu\"\n );\n }\n \"container_test\" => {\n // These tests must be opt-in because they require docker.\n set_ignore!(\n option_env!(\"CARGO_CONTAINER_TESTS\").is_none(),\n \"CARGO_CONTAINER_TESTS must be set\"\n );\n }\n \"public_network_test\" => {\n // These tests must be opt-in because they touch the public\n // network. The use of these should be **EXTREMELY RARE**, and\n // should only touch things which would nearly certainly work\n // in CI (like github.com).\n set_ignore!(\n option_env!(\"CARGO_PUBLIC_NETWORK_TESTS\").is_none(),\n \"CARGO_PUBLIC_NETWORK_TESTS must be set\"\n );\n }\n \"nightly\" => {\n requires_reason = true;\n set_ignore!(is_not_nightly, \"requires nightly\");\n }\n \"requires_rustup_stable\" => {\n set_ignore!(\n !has_rustup_stable(),\n \"rustup or stable toolchain not installed\"\n );\n }\n s if s.starts_with(\"requires=\") => {\n let command = &s[9..];\n let Ok(literal) = command.parse::() else {\n panic!(\"expect a string literal, found: {command}\");\n };\n let literal = literal.to_string();\n let Some(command) = literal\n .strip_prefix('\"')\n .and_then(|lit| lit.strip_suffix('\"'))\n else {\n panic!(\"expect a quoted string literal, found: {literal}\");\n };\n set_ignore!(!has_command(command), \"{command} not installed\");\n }\n s if s.starts_with(\">=1.\") => {\n requires_reason = true;\n let min_minor = s[4..].parse().unwrap();\n let minor = version().0;\n set_ignore!(minor < min_minor, \"requires rustc 1.{minor} or newer\");\n }\n s if s.starts_with(\"reason=\") => {\n explicit_reason = Some(s[7..].parse().unwrap());\n }\n s if s.starts_with(\"ignore_windows=\") => {\n set_ignore!(cfg!(windows), \"{}\", &s[16..s.len() - 1]);\n }\n _ => panic!(\"unknown rule {:?}\", rule),\n }\n }\n if requires_reason && explicit_reason.is_none() {\n panic!(\n \"#[cargo_test] with a rule also requires a reason, \\\n such as #[cargo_test(nightly, reason = \\\"needs -Z unstable-thing\\\")]\"\n );\n }\n\n // Construct the appropriate attributes.\n let span = Span::call_site();\n let mut ret = TokenStream::new();\n let add_attr = |ret: &mut TokenStream, attr_name, attr_input| {\n ret.extend(Some(TokenTree::from(Punct::new('#', Spacing::Alone))));\n let attr = TokenTree::from(Ident::new(attr_name, span));\n let mut attr_stream: TokenStream = attr.into();\n if let Some(input) = attr_input {\n attr_stream.extend(input);\n }\n ret.extend(Some(TokenTree::from(Group::new(\n Delimiter::Bracket,\n attr_stream,\n ))));\n };\n add_attr(&mut ret, \"test\", None);\n if ignore {\n let reason = explicit_reason\n .or_else(|| {\n (!implicit_reasons.is_empty())\n .then(|| TokenTree::from(Literal::string(&implicit_reasons.join(\", \"))).into())\n })\n .map(|reason: TokenStream| {\n let mut stream = TokenStream::new();\n stream.extend(Some(TokenTree::from(Punct::new('=', Spacing::Alone))));\n stream.extend(Some(reason));\n stream\n });\n add_attr(&mut ret, \"ignore\", reason);\n }\n\n let mut test_name = None;\n let mut num = 0;\n\n // Find where the function body starts, and add the boilerplate at the start.\n for token in item {\n let group = match token {\n TokenTree::Group(g) => {\n if g.delimiter() == Delimiter::Brace {\n g\n } else {\n ret.extend(Some(TokenTree::Group(g)));\n continue;\n }\n }\n TokenTree::Ident(i) => {\n // The first time through it will be `fn` the second time is the\n // name of the test.\n if test_name.is_none() && num == 1 {\n test_name = Some(i.to_string())\n } else {\n num += 1;\n }\n ret.extend(Some(TokenTree::Ident(i)));\n continue;\n }\n other => {\n ret.extend(Some(other));\n continue;\n }\n };\n\n let name = &test_name\n .clone()\n .map(|n| n.split(\"::\").next().unwrap().to_string())\n .unwrap();\n\n let mut new_body = to_token_stream(&format!(\n r#\"let _test_guard = {{\n let tmp_dir = env!(\"CARGO_TARGET_TMPDIR\");\n let test_dir = cargo_test_support::paths::test_dir(std::file!(), \"{name}\");\n cargo_test_support::paths::init_root(tmp_dir, test_dir)\n }};\"#\n ));\n\n new_body.extend(group.stream());\n ret.extend(Some(TokenTree::from(Group::new(\n group.delimiter(),\n new_body,\n ))));\n }\n\n ret\n}\n\nfn split_rules(t: TokenStream) -> Vec {\n let tts: Vec<_> = t.into_iter().collect();\n tts.split(|tt| match tt {\n TokenTree::Punct(p) => p.as_char() == ',',\n _ => false,\n })\n .filter(|parts| !parts.is_empty())\n .map(|parts| {\n parts\n .into_iter()\n .map(|part| part.to_string())\n .collect::()\n })\n .collect()\n}\n\nfn to_token_stream(code: &str) -> TokenStream {\n code.parse().unwrap()\n}\n\nstatic VERSION: std::sync::LazyLock<(u32, bool)> = LazyLock::new(|| {\n let output = Command::new(\"rustc\")\n .arg(\"-V\")\n .output()\n .expect(\"rustc should run\");\n let stdout = std::str::from_utf8(&output.stdout).expect(\"utf8\");\n let vers = stdout.split_whitespace().skip(1).next().unwrap();\n let is_nightly = option_env!(\"CARGO_TEST_DISABLE_NIGHTLY\").is_none()\n && (vers.contains(\"-nightly\") || vers.contains(\"-dev\"));\n let minor = vers.split('.').skip(1).next().unwrap().parse().unwrap();\n (minor, is_nightly)\n});\n\nfn version() -> (u32, bool) {\n LazyLock::force(&VERSION).clone()\n}\n\nfn check_command(command_path: &Path, args: &[&str]) -> bool {\n let mut command = Command::new(command_path);\n let command_name = command.get_program().to_str().unwrap().to_owned();\n command.args(args);\n let output = match command.output() {\n Ok(output) => output,\n Err(e) => {\n // * hg is not installed on GitHub macOS or certain constrained\n // environments like Docker. Consider installing it if Cargo\n // gains more hg support, but otherwise it isn't critical.\n // * lldb is not pre-installed on Ubuntu and Windows, so skip.\n if is_ci() && !matches!(command_name.as_str(), \"hg\" | \"lldb\") {\n panic!(\"expected command `{command_name}` to be somewhere in PATH: {e}\",);\n }\n return false;\n }\n };\n if !output.status.success() {\n panic!(\n \"expected command `{command_name}` to be runnable, got error {}:\\n\\\n stderr:{}\\n\\\n stdout:{}\\n\",\n output.status,\n String::from_utf8_lossy(&output.stderr),\n String::from_utf8_lossy(&output.stdout)\n );\n }\n true\n}\n\nfn has_command(command: &str) -> bool {\n use std::env::consts::EXE_EXTENSION;\n // ALLOWED: For testing cargo itself only.\n #[allow(clippy::disallowed_methods)]\n let Some(paths) = std::env::var_os(\"PATH\") else {\n return false;\n };\n std::env::split_paths(&paths)\n .flat_map(|path| {\n let candidate = path.join(&command);\n let with_exe = if EXE_EXTENSION.is_empty() {\n None\n } else {\n Some(candidate.with_extension(EXE_EXTENSION))\n };\n std::iter::once(candidate).chain(with_exe)\n })\n .find(|p| is_executable(p))\n .is_some()\n}\n\n#[cfg(unix)]\nfn is_executable>(path: P) -> bool {\n use std::os::unix::prelude::*;\n std::fs::metadata(path)\n .map(|metadata| metadata.is_file() && metadata.permissions().mode() & 0o111 != 0)\n .unwrap_or(false)\n}\n\n#[cfg(windows)]\nfn is_executable>(path: P) -> bool {\n path.as_ref().is_file()\n}\n\nfn has_rustup_stable() -> bool {\n if option_env!(\"CARGO_TEST_DISABLE_NIGHTLY\").is_some() {\n // This cannot run on rust-lang/rust CI due to the lack of rustup.\n return false;\n }\n // Cargo mucks with PATH on Windows, adding sysroot host libdir, which is\n // \"bin\", which circumvents the rustup wrapper. Use the path directly from\n // CARGO_HOME.\n let home = match option_env!(\"CARGO_HOME\") {\n Some(home) => home,\n None if is_ci() => panic!(\"expected to run under rustup\"),\n None => return false,\n };\n let cargo = Path::new(home).join(\"bin/cargo\");\n check_command(&cargo, &[\"+stable\", \"--version\"])\n}\n\n/// Whether or not this running in a Continuous Integration environment.\nfn is_ci() -> bool {\n // Consider using `tracked_env` instead of option_env! when it is stabilized.\n // `tracked_env` will handle changes, but not require rebuilding the macro\n // itself like option_env does.\n option_env!(\"CI\").is_some() || option_env!(\"TF_BUILD\").is_some()\n}\n" }, { "path": "crates/cargo-test-support/Cargo.toml", "content": "[package]\nname = \"cargo-test-support\"\nversion = \"0.11.1\"\nedition.workspace = true\nrust-version = \"1.94\" # MSRV:1\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"Testing framework for Cargo's testsuite.\"\n\n[dependencies]\nanstream.workspace = true\nanstyle.workspace = true\nanyhow.workspace = true\ncargo-test-macro.workspace = true\ncargo-util.workspace = true\ncrates-io.workspace = true\nfiletime.workspace = true\nflate2.workspace = true\ngit2.workspace = true\nglob.workspace = true\nitertools.workspace = true\npasetors.workspace = true\nregex.workspace = true\nserde = { workspace = true, features = [\"derive\"] }\nserde_json.workspace = true\nsnapbox.workspace = true\ntar.workspace = true\ntime.workspace = true\ntoml = { workspace = true, features = [\"display\", \"serde\"] }\nurl.workspace = true\nwalkdir.workspace = true\n\n[target.'cfg(windows)'.dependencies]\nwindows-sys = { workspace = true, features = [\"Win32_Storage_FileSystem\"] }\n\n[lints]\nworkspace = true\n" }, { "path": "crates/cargo-test-support/README.md", "content": "> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use. This\n> crate may make major changes to its APIs or be deprecated without warning.\n" }, { "path": "crates/cargo-test-support/build.rs", "content": "#![allow(clippy::disallowed_methods)]\n\nfn main() {\n println!(\"cargo:rustc-check-cfg=cfg(emulate_second_only_system)\");\n println!(\n \"cargo:rustc-env=NATIVE_ARCH={}\",\n std::env::var(\"TARGET\").unwrap()\n );\n println!(\"cargo:rerun-if-changed=build.rs\");\n}\n" }, { "path": "crates/cargo-test-support/containers/apache/Dockerfile", "content": "FROM httpd:2.4-alpine\n\nRUN apk add --no-cache git git-daemon openssl\n\nCOPY bar /repos/bar\nWORKDIR /repos/bar\nRUN git config --global user.email \"testuser@example.com\" &&\\\n git config --global user.name \"Test User\" &&\\\n git config --system --add safe.directory '*' &&\\\n git init -b master . &&\\\n git add Cargo.toml src &&\\\n git commit -m \"Initial commit\" &&\\\n cd .. &&\\\n git clone --bare bar bar.git &&\\\n rm -rf bar\nWORKDIR /\n\nEXPOSE 443\n\nWORKDIR /usr/local/apache2/conf\nCOPY httpd-cargo.conf .\nRUN cat httpd-cargo.conf >> httpd.conf\nRUN openssl req -x509 -nodes -days 3650 -newkey rsa:2048 \\\n -keyout server.key -out server.crt \\\n -subj \"/emailAddress=webmaster@example.com/C=US/ST=California/L=San Francisco/O=Rust/OU=Cargo/CN=127.0.0.1\"\nWORKDIR /\n" }, { "path": "crates/cargo-test-support/containers/apache/bar/Cargo.toml", "content": "[package]\nname = \"bar\"\nversion = \"1.0.0\"\nedition = \"2021\"\n" }, { "path": "crates/cargo-test-support/containers/apache/bar/src/lib.rs", "content": "// Intentionally blank.\n" }, { "path": "crates/cargo-test-support/containers/apache/httpd-cargo.conf", "content": "SetEnv GIT_PROJECT_ROOT /repos\nSetEnv GIT_HTTP_EXPORT_ALL\nScriptAlias /repos /usr/libexec/git-core/git-http-backend/\nLoadModule cgid_module modules/mod_cgid.so\n\n\n Require all granted\n\n\nInclude conf/extra/httpd-ssl.conf\nLoadModule ssl_module modules/mod_ssl.so\nLoadModule socache_shmcb_module modules/mod_socache_shmcb.so\n" }, { "path": "crates/cargo-test-support/containers/sshd/Dockerfile", "content": "FROM alpine:3.23\n\nRUN apk add --no-cache openssh git\nRUN apk upgrade --no-cache libcrypto3\nRUN ssh-keygen -A\n\nRUN addgroup -S testuser && adduser -S testuser -G testuser -s /bin/ash\n# NOTE: Ideally the password should be set to *, but I am uncertain how to do\n# that in alpine. It shouldn't matter since PermitEmptyPasswords is \"no\".\nRUN passwd -u testuser\n\nRUN mkdir /repos && chown testuser /repos\nCOPY --chown=testuser:testuser bar /repos/bar\nUSER testuser\nWORKDIR /repos/bar\nRUN git config --global user.email \"testuser@example.com\" &&\\\n git config --global user.name \"Test User\" &&\\\n git init -b master . &&\\\n git add Cargo.toml src &&\\\n git commit -m \"Initial commit\" &&\\\n cd .. &&\\\n git clone --bare bar bar.git &&\\\n rm -rf bar\nWORKDIR /\nUSER root\n\nEXPOSE 22\n\nENTRYPOINT [\"/usr/sbin/sshd\", \"-D\", \"-E\", \"/var/log/auth.log\"]\n" }, { "path": "crates/cargo-test-support/containers/sshd/bar/Cargo.toml", "content": "[package]\nname = \"bar\"\nversion = \"1.0.0\"\nedition = \"2021\"\n" }, { "path": "crates/cargo-test-support/containers/sshd/bar/src/lib.rs", "content": "// Intentionally blank.\n" }, { "path": "crates/cargo-test-support/src/compare.rs", "content": "//! Routines for comparing and diffing output.\n//!\n//! # Deprecated comparisons\n//!\n//! Cargo's tests are in transition from internal-only pattern and normalization routines used in\n//! asserts like [`crate::Execs::with_stdout_contains`] to [`assert_e2e`] and [`assert_ui`].\n//!\n//! ## Patterns\n//!\n//! Many of these functions support special markup to assist with comparing\n//! text that may vary or is otherwise uninteresting for the test at hand. The\n//! supported patterns are:\n//!\n//! - `[..]` is a wildcard that matches 0 or more characters on the same line\n//! (similar to `.*` in a regex). It is non-greedy.\n//! - `[EXE]` optionally adds `.exe` on Windows (empty string on other\n//! platforms).\n//! - `[ROOT]` is the path to the test directory's root.\n//! - `[CWD]` is the working directory of the process that was run.\n//! - There is a wide range of substitutions (such as `[COMPILING]` or\n//! `[WARNING]`) to match cargo's \"status\" output and allows you to ignore\n//! the alignment. See the source of `substitute_macros` for a complete list\n//! of substitutions.\n//! - `[DIRTY-MSVC]` (only when the line starts with it) would be replaced by\n//! `[DIRTY]` when `cfg(target_env = \"msvc\")` or the line will be ignored otherwise.\n//! Tests that work around [issue 7358](https://github.com/rust-lang/cargo/issues/7358)\n//! can use this to avoid duplicating the `with_stderr` call like:\n//! `if cfg!(target_env = \"msvc\") {e.with_stderr(\"...[DIRTY]...\");} else {e.with_stderr(\"...\");}`.\n//!\n//! ## Normalization\n//!\n//! In addition to the patterns described above, the strings are normalized\n//! in such a way to avoid unwanted differences. The normalizations are:\n//!\n//! - Raw tab characters are converted to the string ``. This is helpful\n//! so that raw tabs do not need to be written in the expected string, and\n//! to avoid confusion of tabs vs spaces.\n//! - Backslashes are converted to forward slashes to deal with Windows paths.\n//! This helps so that all tests can be written assuming forward slashes.\n//! Other heuristics are applied to try to ensure Windows-style paths aren't\n//! a problem.\n//! - Carriage returns are removed, which can help when running on Windows.\n\nuse crate::cross_compile::try_alternate;\nuse crate::paths;\nuse crate::rustc_host;\nuse anyhow::{Result, bail};\nuse snapbox::Data;\nuse snapbox::IntoData;\nuse std::fmt;\nuse std::path::Path;\nuse std::path::PathBuf;\nuse std::str;\n\n/// This makes it easier to write regex replacements that are guaranteed to only\n/// get compiled once\nmacro_rules! regex {\n ($re:literal $(,)?) => {{\n static RE: std::sync::OnceLock = std::sync::OnceLock::new();\n RE.get_or_init(|| regex::Regex::new($re).unwrap())\n }};\n}\n\n/// Assertion policy for UI tests\n///\n/// This emphasizes showing as much content as possible at the cost of more brittleness\n///\n/// # Snapshots\n///\n/// Updating of snapshots is controlled with the `SNAPSHOTS` environment variable:\n///\n/// - `skip`: do not run the tests\n/// - `ignore`: run the tests but ignore their failure\n/// - `verify`: run the tests\n/// - `overwrite`: update the snapshots based on the output of the tests\n///\n/// # Patterns\n///\n/// - `[..]` is a character wildcard, stopping at line breaks\n/// - `\\n...\\n` is a multi-line wildcard\n/// - `[EXE]` matches the exe suffix for the current platform\n/// - `[ROOT]` matches [`paths::root()`][crate::paths::root]\n/// - `[ROOTURL]` matches [`paths::root()`][crate::paths::root] as a URL\n///\n/// # Normalization\n///\n/// In addition to the patterns described above, text is normalized\n/// in such a way to avoid unwanted differences. The normalizations are:\n///\n/// - Backslashes are converted to forward slashes to deal with Windows paths.\n/// This helps so that all tests can be written assuming forward slashes.\n/// Other heuristics are applied to try to ensure Windows-style paths aren't\n/// a problem.\n/// - Carriage returns are removed, which can help when running on Windows.\n///\n/// # Example\n///\n/// ```no_run\n/// # use cargo_test_support::compare::assert_e2e;\n/// # use cargo_test_support::file;\n/// # let p = cargo_test_support::project().build();\n/// # let stdout = \"\";\n/// assert_e2e().eq(stdout, file![\"stderr.term.svg\"]);\n/// ```\n/// ```console\n/// $ SNAPSHOTS=overwrite cargo test\n/// ```\npub fn assert_ui() -> snapbox::Assert {\n let mut subs = snapbox::Redactions::new();\n subs.extend(MIN_LITERAL_REDACTIONS.into_iter().cloned())\n .unwrap();\n add_test_support_redactions(&mut subs);\n add_regex_redactions(&mut subs);\n\n snapbox::Assert::new()\n .action_env(snapbox::assert::DEFAULT_ACTION_ENV)\n .redact_with(subs)\n}\n\n/// Assertion policy for functional end-to-end tests\n///\n/// This emphasizes showing as much content as possible at the cost of more brittleness\n///\n/// # Snapshots\n///\n/// Updating of snapshots is controlled with the `SNAPSHOTS` environment variable:\n///\n/// - `skip`: do not run the tests\n/// - `ignore`: run the tests but ignore their failure\n/// - `verify`: run the tests\n/// - `overwrite`: update the snapshots based on the output of the tests\n///\n/// # Patterns\n///\n/// - `[..]` is a character wildcard, stopping at line breaks\n/// - `\\n...\\n` is a multi-line wildcard\n/// - `[EXE]` matches the exe suffix for the current platform\n/// - `[ROOT]` matches [`paths::root()`][crate::paths::root]\n/// - `[ROOTURL]` matches [`paths::root()`][crate::paths::root] as a URL\n///\n/// # Normalization\n///\n/// In addition to the patterns described above, text is normalized\n/// in such a way to avoid unwanted differences. The normalizations are:\n///\n/// - Backslashes are converted to forward slashes to deal with Windows paths.\n/// This helps so that all tests can be written assuming forward slashes.\n/// Other heuristics are applied to try to ensure Windows-style paths aren't\n/// a problem.\n/// - Carriage returns are removed, which can help when running on Windows.\n///\n/// # Example\n///\n/// ```no_run\n/// # use cargo_test_support::compare::assert_e2e;\n/// # use cargo_test_support::str;\n/// # let p = cargo_test_support::project().build();\n/// assert_e2e().eq(p.read_lockfile(), str![]);\n/// ```\n/// ```console\n/// $ SNAPSHOTS=overwrite cargo test\n/// ```\npub fn assert_e2e() -> snapbox::Assert {\n let mut subs = snapbox::Redactions::new();\n subs.extend(MIN_LITERAL_REDACTIONS.into_iter().cloned())\n .unwrap();\n subs.extend(E2E_LITERAL_REDACTIONS.into_iter().cloned())\n .unwrap();\n add_test_support_redactions(&mut subs);\n add_regex_redactions(&mut subs);\n\n snapbox::Assert::new()\n .action_env(snapbox::assert::DEFAULT_ACTION_ENV)\n .redact_with(subs)\n}\n\nfn add_test_support_redactions(subs: &mut snapbox::Redactions) {\n let root = paths::root();\n // Use `from_file_path` instead of `from_dir_path` so the trailing slash is\n // put in the users output, rather than hidden in the variable\n let root_url = url::Url::from_file_path(&root).unwrap().to_string();\n\n subs.insert(\"[ROOT]\", root).unwrap();\n subs.insert(\"[ROOTURL]\", root_url).unwrap();\n subs.insert(\"[HOST_TARGET]\", rustc_host()).unwrap();\n if let Some(alt_target) = try_alternate() {\n subs.insert(\"[ALT_TARGET]\", alt_target).unwrap();\n }\n}\n\nfn add_regex_redactions(subs: &mut snapbox::Redactions) {\n // For e2e tests\n subs.insert(\n \"[ELAPSED]\",\n regex!(r\"\\[FINISHED\\].*in (?[0-9]+(\\.[0-9]+)?(m [0-9]+)?)s\"),\n )\n .unwrap();\n // for UI tests\n subs.insert(\n \"[ELAPSED]\",\n regex!(r\"Finished.*in (?[0-9]+(\\.[0-9]+)?(m [0-9]+)?)s\"),\n )\n .unwrap();\n // output from libtest\n subs.insert(\n \"[ELAPSED]\",\n regex!(r\"; finished in (?[0-9]+(\\.[0-9]+)?(m [0-9]+)?)s\"),\n )\n .unwrap();\n subs.insert(\n \"[FILE_NUM]\",\n regex!(r\"\\[(REMOVED|SUMMARY)\\] (?[1-9][0-9]*) files\"),\n )\n .unwrap();\n subs.insert(\n \"[FILE_SIZE]\",\n regex!(r\"(?[0-9]+(\\.[0-9]+)?([a-zA-Z]i)?)B\\s\"),\n )\n .unwrap();\n subs.insert(\n \"[HASH]\",\n regex!(r\"home/\\.cargo/registry/(cache|index|src)/-(?[a-z0-9]+)\"),\n )\n .unwrap();\n subs.insert(\n \"[HASH]\",\n regex!(r\"\\.cargo/target/(?[0-9a-f]{2}/[0-9a-f]{14})\"),\n )\n .unwrap();\n subs.insert(\"[HASH]\", regex!(r\"/[a-z0-9\\-_]+-(?[0-9a-f]{16})\"))\n .unwrap();\n // Match multi-part hashes like `06/b451d0d6f88b1d` used in directory paths\n subs.insert(\"[HASH]\", regex!(r\"/(?[a-f0-9]{2}\\/[0-9a-f]{14})\"))\n .unwrap();\n // Match file name hashes like `foo-06b451d0d6f88b1d`\n subs.insert(\"[HASH]\", regex!(r\"[a-z0-9]+-(?[a-f0-9]{16})\"))\n .unwrap();\n // Match path hashes like `../06b451d0d6f88b1d/..` used in directory paths\n subs.insert(\"[HASH]\", regex!(r\"\\/(?[0-9a-f]{16})\\/\"))\n .unwrap();\n subs.insert(\n \"[AVG_ELAPSED]\",\n regex!(r\"(?[0-9]+(\\.[0-9]+)?) ns/iter\"),\n )\n .unwrap();\n subs.insert(\n \"[JITTER]\",\n regex!(r\"ns/iter \\(\\+/- (?[0-9]+(\\.[0-9]+)?)\\)\"),\n )\n .unwrap();\n\n // Following 3 subs redact:\n // \"1719325877.527949100s, 61549498ns after last build at 1719325877.466399602s\"\n // \"1719503592.218193216s, 1h 1s after last build at 1719499991.982681034s\"\n // into \"[DIRTY_REASON_NEW_TIME], [DIRTY_REASON_DIFF] after last build at [DIRTY_REASON_OLD_TIME]\"\n subs.insert(\n \"[TIME_DIFF_AFTER_LAST_BUILD]\",\n regex!(r\"(?[0-9]+(\\.[0-9]+)?s, (\\s?[0-9]+(\\.[0-9]+)?(s|ns|h))+ after last build at [0-9]+(\\.[0-9]+)?s)\"),\n )\n .unwrap();\n}\n\nstatic MIN_LITERAL_REDACTIONS: &[(&str, &str)] = &[\n (\"[EXE]\", std::env::consts::EXE_SUFFIX),\n (\"[BROKEN_PIPE]\", \"Broken pipe (os error 32)\"),\n (\"[BROKEN_PIPE]\", \"The pipe is being closed. (os error 232)\"),\n // Unix message for an entity was not found\n (\"[NOT_FOUND]\", \"No such file or directory (os error 2)\"),\n // Windows message for an entity was not found\n (\n \"[NOT_FOUND]\",\n \"The system cannot find the file specified. (os error 2)\",\n ),\n (\n \"[NOT_FOUND]\",\n \"The system cannot find the path specified. (os error 3)\",\n ),\n (\"[NOT_FOUND]\", \"Access is denied. (os error 5)\"),\n (\"[NOT_FOUND]\", \"program not found\"),\n // Unix message for exit status\n (\"[EXIT_STATUS]\", \"exit status\"),\n // Windows message for exit status\n (\"[EXIT_STATUS]\", \"exit code\"),\n];\nstatic E2E_LITERAL_REDACTIONS: &[(&str, &str)] = &[\n (\"[RUNNING]\", \" Running\"),\n (\"[COMPILING]\", \" Compiling\"),\n (\"[CHECKING]\", \" Checking\"),\n (\"[COMPLETED]\", \" Completed\"),\n (\"[CREATED]\", \" Created\"),\n (\"[CREATING]\", \" Creating\"),\n (\"[CREDENTIAL]\", \" Credential\"),\n (\"[DOWNGRADING]\", \" Downgrading\"),\n (\"[FINISHED]\", \" Finished\"),\n (\"[ERROR]\", \"error:\"),\n (\"[WARNING]\", \"warning:\"),\n (\"[NOTE]\", \"note:\"),\n (\"[HELP]\", \"help:\"),\n (\"[DOCUMENTING]\", \" Documenting\"),\n (\"[SCRAPING]\", \" Scraping\"),\n (\"[FRESH]\", \" Fresh\"),\n (\"[DIRTY]\", \" Dirty\"),\n (\"[LOCKING]\", \" Locking\"),\n (\"[UPDATING]\", \" Updating\"),\n (\"[UPGRADING]\", \" Upgrading\"),\n (\"[ADDING]\", \" Adding\"),\n (\"[REMOVING]\", \" Removing\"),\n (\"[REMOVED]\", \" Removed\"),\n (\"[UNCHANGED]\", \" Unchanged\"),\n (\"[DOCTEST]\", \" Doc-tests\"),\n (\"[PACKAGING]\", \" Packaging\"),\n (\"[PACKAGED]\", \" Packaged\"),\n (\"[DOWNLOADING]\", \" Downloading\"),\n (\"[DOWNLOADED]\", \" Downloaded\"),\n (\"[UPLOADING]\", \" Uploading\"),\n (\"[UPLOADED]\", \" Uploaded\"),\n (\"[VERIFYING]\", \" Verifying\"),\n (\"[ARCHIVING]\", \" Archiving\"),\n (\"[INSTALLING]\", \" Installing\"),\n (\"[REPLACING]\", \" Replacing\"),\n (\"[UNPACKING]\", \" Unpacking\"),\n (\"[SUMMARY]\", \" Summary\"),\n (\"[FIXED]\", \" Fixed\"),\n (\"[FIXING]\", \" Fixing\"),\n (\"[IGNORED]\", \" Ignored\"),\n (\"[INSTALLED]\", \" Installed\"),\n (\"[REPLACED]\", \" Replaced\"),\n (\"[BUILDING]\", \" Building\"),\n (\"[LOGIN]\", \" Login\"),\n (\"[LOGOUT]\", \" Logout\"),\n (\"[YANK]\", \" Yank\"),\n (\"[OWNER]\", \" Owner\"),\n (\"[MIGRATING]\", \" Migrating\"),\n (\"[EXECUTABLE]\", \" Executable\"),\n (\"[SKIPPING]\", \" Skipping\"),\n (\"[WAITING]\", \" Waiting\"),\n (\"[PUBLISHED]\", \" Published\"),\n (\"[BLOCKING]\", \" Blocking\"),\n (\"[GENERATED]\", \" Generated\"),\n (\"[OPENING]\", \" Opening\"),\n (\"[MERGING]\", \" Merging\"),\n];\n\n/// Checks that the given string contains the given contiguous lines\n/// somewhere.\n///\n/// See [Patterns](index.html#patterns) for more information on pattern matching.\npub(crate) fn match_contains(\n expected: &str,\n actual: &str,\n redactions: &snapbox::Redactions,\n) -> Result<()> {\n let expected = normalize_expected(expected, redactions);\n let actual = normalize_actual(actual, redactions);\n let e: Vec<_> = expected.lines().map(|line| WildStr::new(line)).collect();\n let a: Vec<_> = actual.lines().collect();\n if e.len() == 0 {\n bail!(\"expected length must not be zero\");\n }\n for window in a.windows(e.len()) {\n if e == window {\n return Ok(());\n }\n }\n bail!(\n \"expected to find:\\n\\\n {}\\n\\n\\\n did not find in output:\\n\\\n {}\",\n expected,\n actual\n );\n}\n\n/// Checks that the given string does not contain the given contiguous lines\n/// anywhere.\n///\n/// See [Patterns](index.html#patterns) for more information on pattern matching.\npub(crate) fn match_does_not_contain(\n expected: &str,\n actual: &str,\n redactions: &snapbox::Redactions,\n) -> Result<()> {\n if match_contains(expected, actual, redactions).is_ok() {\n bail!(\n \"expected not to find:\\n\\\n {}\\n\\n\\\n but found in output:\\n\\\n {}\",\n expected,\n actual\n );\n } else {\n Ok(())\n }\n}\n\n/// Checks that the given string has a line that contains the given patterns,\n/// and that line also does not contain the `without` patterns.\n///\n/// See [Patterns](index.html#patterns) for more information on pattern matching.\n///\n/// See [`crate::Execs::with_stderr_line_without`] for an example and cautions\n/// against using.\npub(crate) fn match_with_without(\n actual: &str,\n with: &[String],\n without: &[String],\n redactions: &snapbox::Redactions,\n) -> Result<()> {\n let actual = normalize_actual(actual, redactions);\n let norm = |s: &String| format!(\"[..]{}[..]\", normalize_expected(s, redactions));\n let with: Vec<_> = with.iter().map(norm).collect();\n let without: Vec<_> = without.iter().map(norm).collect();\n let with_wild: Vec<_> = with.iter().map(|w| WildStr::new(w)).collect();\n let without_wild: Vec<_> = without.iter().map(|w| WildStr::new(w)).collect();\n\n let matches: Vec<_> = actual\n .lines()\n .filter(|line| with_wild.iter().all(|with| with == line))\n .filter(|line| !without_wild.iter().any(|without| without == line))\n .collect();\n match matches.len() {\n 0 => bail!(\n \"Could not find expected line in output.\\n\\\n With contents: {:?}\\n\\\n Without contents: {:?}\\n\\\n Actual stderr:\\n\\\n {}\\n\",\n with,\n without,\n actual\n ),\n 1 => Ok(()),\n _ => bail!(\n \"Found multiple matching lines, but only expected one.\\n\\\n With contents: {:?}\\n\\\n Without contents: {:?}\\n\\\n Matching lines:\\n\\\n {}\\n\",\n with,\n without,\n itertools::join(matches, \"\\n\")\n ),\n }\n}\n\n/// Normalizes the output so that it can be compared against the expected value.\nfn normalize_actual(content: &str, redactions: &snapbox::Redactions) -> String {\n use snapbox::filter::Filter as _;\n let content = snapbox::filter::FilterPaths.filter(content.into_data());\n let content = snapbox::filter::FilterNewlines.filter(content);\n let content = content.render().expect(\"came in as a String\");\n let content = redactions.redact(&content);\n content\n}\n\n/// Normalizes the expected string so that it can be compared against the actual output.\nfn normalize_expected(content: &str, redactions: &snapbox::Redactions) -> String {\n use snapbox::filter::Filter as _;\n let content = snapbox::filter::FilterPaths.filter(content.into_data());\n let content = snapbox::filter::FilterNewlines.filter(content);\n // Remove any conditionally absent redactions like `[EXE]`\n let content = content.render().expect(\"came in as a String\");\n let content = redactions.clear_unused(&content);\n content.into_owned()\n}\n\n/// A single line string that supports `[..]` wildcard matching.\nstruct WildStr<'a> {\n has_meta: bool,\n line: &'a str,\n}\n\nimpl<'a> WildStr<'a> {\n fn new(line: &'a str) -> WildStr<'a> {\n WildStr {\n has_meta: line.contains(\"[..]\"),\n line,\n }\n }\n}\n\nimpl PartialEq<&str> for WildStr<'_> {\n fn eq(&self, other: &&str) -> bool {\n if self.has_meta {\n meta_cmp(self.line, other)\n } else {\n self.line == *other\n }\n }\n}\n\nfn meta_cmp(a: &str, mut b: &str) -> bool {\n for (i, part) in a.split(\"[..]\").enumerate() {\n match b.find(part) {\n Some(j) => {\n if i == 0 && j != 0 {\n return false;\n }\n b = &b[j + part.len()..];\n }\n None => return false,\n }\n }\n b.is_empty() || a.ends_with(\"[..]\")\n}\n\nimpl fmt::Display for WildStr<'_> {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n f.write_str(&self.line)\n }\n}\n\nimpl fmt::Debug for WildStr<'_> {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"{:?}\", self.line)\n }\n}\n\npub struct InMemoryDir {\n files: Vec<(PathBuf, Data)>,\n}\n\nimpl InMemoryDir {\n pub fn paths(&self) -> impl Iterator {\n self.files.iter().map(|(p, _)| p.as_path())\n }\n\n #[track_caller]\n pub fn assert_contains(&self, expected: &Self) {\n use std::fmt::Write as _;\n let assert = assert_e2e();\n let mut errs = String::new();\n for (path, expected_data) in &expected.files {\n let actual_data = self\n .files\n .iter()\n .find_map(|(p, d)| (path == p).then(|| d.clone()))\n .unwrap_or_else(|| Data::new());\n if let Err(err) =\n assert.try_eq(Some(&path.display()), actual_data, expected_data.clone())\n {\n let _ = write!(&mut errs, \"{err}\");\n }\n }\n if !errs.is_empty() {\n panic!(\"{errs}\")\n }\n }\n}\n\nimpl FromIterator<(P, D)> for InMemoryDir\nwhere\n P: Into,\n D: IntoData,\n{\n fn from_iter>(files: I) -> Self {\n let files = files\n .into_iter()\n .map(|(p, d)| (p.into(), d.into_data()))\n .collect();\n Self { files }\n }\n}\n\nimpl From<[(P, D); N]> for InMemoryDir\nwhere\n P: Into,\n D: IntoData,\n{\n fn from(files: [(P, D); N]) -> Self {\n let files = files\n .into_iter()\n .map(|(p, d)| (p.into(), d.into_data()))\n .collect();\n Self { files }\n }\n}\n\nimpl From> for InMemoryDir\nwhere\n P: Into,\n D: IntoData,\n{\n fn from(files: std::collections::HashMap) -> Self {\n let files = files\n .into_iter()\n .map(|(p, d)| (p.into(), d.into_data()))\n .collect();\n Self { files }\n }\n}\n\nimpl From> for InMemoryDir\nwhere\n P: Into,\n D: IntoData,\n{\n fn from(files: std::collections::BTreeMap) -> Self {\n let files = files\n .into_iter()\n .map(|(p, d)| (p.into(), d.into_data()))\n .collect();\n Self { files }\n }\n}\n\nimpl From<()> for InMemoryDir {\n fn from(_files: ()) -> Self {\n let files = Vec::new();\n Self { files }\n }\n}\n\n/// Create an `impl _ for InMemoryDir` for a generic tuple\n///\n/// Must pass in names for each tuple parameter for\n/// - internal variable name\n/// - `Path` type\n/// - `Data` type\nmacro_rules! impl_from_tuple_for_inmemorydir {\n ($($var:ident $path:ident $data:ident),+) => {\n impl<$($path: Into, $data: IntoData),+> From<($(($path, $data)),+ ,)> for InMemoryDir {\n fn from(files: ($(($path, $data)),+,)) -> Self {\n let ($($var),+ ,) = files;\n let files = [$(($var.0.into(), $var.1.into_data())),+];\n files.into()\n }\n }\n };\n}\n\n/// Extend `impl_from_tuple_for_inmemorydir` to generate for the specified tuple and all smaller\n/// tuples\nmacro_rules! impl_from_tuples_for_inmemorydir {\n ($var1:ident $path1:ident $data1:ident, $($var:ident $path:ident $data:ident),+) => {\n impl_from_tuples_for_inmemorydir!(__impl $var1 $path1 $data1; $($var $path $data),+);\n };\n (__impl $($var:ident $path:ident $data:ident),+; $var1:ident $path1:ident $data1:ident $(,$var2:ident $path2:ident $data2:ident)*) => {\n impl_from_tuple_for_inmemorydir!($($var $path $data),+);\n impl_from_tuples_for_inmemorydir!(__impl $($var $path $data),+, $var1 $path1 $data1; $($var2 $path2 $data2),*);\n };\n (__impl $($var:ident $path:ident $data:ident),+;) => {\n impl_from_tuple_for_inmemorydir!($($var $path $data),+);\n }\n}\n\n// Generate for tuples of size `1..=7`\nimpl_from_tuples_for_inmemorydir!(\n s1 P1 D1,\n s2 P2 D2,\n s3 P3 D3,\n s4 P4 D4,\n s5 P5 D5,\n s6 P6 D6,\n s7 P7 D7\n);\n\n#[cfg(test)]\nmod test {\n use snapbox::assert_data_eq;\n use snapbox::prelude::*;\n use snapbox::str;\n\n use super::*;\n\n #[test]\n fn wild_str_cmp() {\n for (a, b) in &[\n (\"a b\", \"a b\"),\n (\"a[..]b\", \"a b\"),\n (\"a[..]\", \"a b\"),\n (\"[..]\", \"a b\"),\n (\"[..]b\", \"a b\"),\n ] {\n assert_eq!(WildStr::new(a), b);\n }\n for (a, b) in &[(\"[..]b\", \"c\"), (\"b\", \"c\"), (\"b\", \"cb\")] {\n assert_ne!(WildStr::new(a), b);\n }\n }\n\n #[test]\n fn redact_elapsed_time() {\n let mut subs = snapbox::Redactions::new();\n add_regex_redactions(&mut subs);\n\n assert_data_eq!(\n subs.redact(\"[FINISHED] `release` profile [optimized] target(s) in 5.5s\"),\n str![\"[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\"].raw()\n );\n assert_data_eq!(\n subs.redact(\"[FINISHED] `release` profile [optimized] target(s) in 1m 05s\"),\n str![\"[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\"].raw()\n );\n }\n}\n" }, { "path": "crates/cargo-test-support/src/containers.rs", "content": "//! Support for testing using Docker containers.\n//!\n//! The [`Container`] type is a builder for configuring a container to run.\n//! After you call `launch`, you can use the [`ContainerHandle`] to interact\n//! with the running container.\n//!\n//! Tests using containers must use `#[cargo_test(container_test)]` to disable\n//! them unless the `CARGO_CONTAINER_TESTS` environment variable is set.\n\nuse cargo_util::ProcessBuilder;\nuse std::collections::HashMap;\nuse std::io::Read;\nuse std::path::PathBuf;\nuse std::process::Command;\nuse std::sync::Mutex;\nuse std::sync::atomic::{AtomicUsize, Ordering};\nuse tar::Header;\n\n/// A builder for configuring a container to run.\npub struct Container {\n /// The host directory that forms the basis of the Docker image.\n build_context: PathBuf,\n /// Files to copy over to the image.\n files: Vec,\n}\n\n/// A handle to a running container.\n///\n/// You can use this to interact with the container.\npub struct ContainerHandle {\n /// The name of the container.\n name: String,\n /// Port mappings of `container_port` to `host_port` for ports exposed via EXPOSE.\n pub port_mappings: HashMap,\n}\n\nimpl Container {\n pub fn new(context_dir: &str) -> Container {\n assert!(std::env::var_os(\"CARGO_CONTAINER_TESTS\").is_some());\n let mut build_context = PathBuf::from(env!(\"CARGO_MANIFEST_DIR\"));\n build_context.push(\"containers\");\n build_context.push(context_dir);\n Container {\n build_context,\n files: Vec::new(),\n }\n }\n\n /// Adds a file to be copied into the container.\n pub fn file(mut self, file: MkFile) -> Self {\n self.files.push(file);\n self\n }\n\n /// Starts the container.\n pub fn launch(mut self) -> ContainerHandle {\n static NEXT_ID: AtomicUsize = AtomicUsize::new(0);\n\n let id = NEXT_ID.fetch_add(1, Ordering::SeqCst);\n let name = format!(\"cargo_test_{id}\");\n remove_if_exists(&name);\n self.create_container(&name);\n self.copy_files(&name);\n self.start_container(&name);\n let info = self.container_inspect(&name);\n let port_mappings = self.port_mappings(&info);\n self.wait_till_ready(&port_mappings);\n\n ContainerHandle {\n name,\n port_mappings,\n }\n }\n\n fn create_container(&self, name: &str) {\n static BUILD_LOCK: Mutex<()> = Mutex::new(());\n\n let image_base = self.build_context.file_name().unwrap();\n let image_name = format!(\"cargo-test-{}\", image_base.to_str().unwrap());\n let _lock = BUILD_LOCK\n .lock()\n .map_err(|_| panic!(\"previous docker build failed, unable to run test\"));\n ProcessBuilder::new(\"docker\")\n .args(&[\"build\", \"--tag\", image_name.as_str()])\n .arg(&self.build_context)\n .exec_with_output()\n .unwrap();\n\n ProcessBuilder::new(\"docker\")\n .args(&[\n \"container\",\n \"create\",\n \"--publish-all\",\n \"--rm\",\n \"--name\",\n name,\n ])\n .arg(image_name)\n .exec_with_output()\n .unwrap();\n }\n\n fn copy_files(&mut self, name: &str) {\n if self.files.is_empty() {\n return;\n }\n let mut ar = tar::Builder::new(Vec::new());\n ar.sparse(false);\n let files = std::mem::replace(&mut self.files, Vec::new());\n for mut file in files {\n ar.append_data(&mut file.header, &file.path, file.contents.as_slice())\n .unwrap();\n }\n let ar = ar.into_inner().unwrap();\n ProcessBuilder::new(\"docker\")\n .args(&[\"cp\", \"-\"])\n .arg(format!(\"{name}:/\"))\n .stdin(ar)\n .exec_with_output()\n .unwrap();\n }\n\n fn start_container(&self, name: &str) {\n ProcessBuilder::new(\"docker\")\n .args(&[\"container\", \"start\"])\n .arg(name)\n .exec_with_output()\n .unwrap();\n }\n\n fn container_inspect(&self, name: &str) -> serde_json::Value {\n let output = ProcessBuilder::new(\"docker\")\n .args(&[\"inspect\", name])\n .exec_with_output()\n .unwrap();\n serde_json::from_slice(&output.stdout).unwrap()\n }\n\n /// Returns the mapping of container_port->host_port for ports that were\n /// exposed with EXPOSE.\n fn port_mappings(&self, info: &serde_json::Value) -> HashMap {\n info[0][\"NetworkSettings\"][\"Ports\"]\n .as_object()\n .unwrap()\n .iter()\n .map(|(key, value)| {\n let key = key\n .strip_suffix(\"/tcp\")\n .expect(\"expected TCP only ports\")\n .parse()\n .unwrap();\n let values = value.as_array().unwrap();\n let value = values\n .iter()\n .find(|value| value[\"HostIp\"].as_str().unwrap() == \"0.0.0.0\")\n .expect(\"expected localhost IP\");\n let host_port = value[\"HostPort\"].as_str().unwrap().parse().unwrap();\n (key, host_port)\n })\n .collect()\n }\n\n fn wait_till_ready(&self, port_mappings: &HashMap) {\n for port in port_mappings.values() {\n let mut ok = false;\n for _ in 0..30 {\n match std::net::TcpStream::connect(format!(\"127.0.0.1:{port}\")) {\n Ok(_) => {\n ok = true;\n break;\n }\n Err(e) => {\n if e.kind() != std::io::ErrorKind::ConnectionRefused {\n panic!(\"unexpected localhost connection error: {e:?}\");\n }\n std::thread::sleep(std::time::Duration::new(1, 0));\n }\n }\n }\n if !ok {\n panic!(\"no listener on localhost port {port}\");\n }\n }\n }\n}\n\nimpl ContainerHandle {\n /// Executes a program inside a running container.\n pub fn exec(&self, args: &[&str]) -> std::process::Output {\n ProcessBuilder::new(\"docker\")\n .args(&[\"container\", \"exec\", &self.name])\n .args(args)\n .exec_with_output()\n .unwrap()\n }\n\n /// Returns the contents of a file inside the container.\n pub fn read_file(&self, path: &str) -> String {\n let output = ProcessBuilder::new(\"docker\")\n .args(&[\"cp\", &format!(\"{}:{}\", self.name, path), \"-\"])\n .exec_with_output()\n .unwrap();\n let mut ar = tar::Archive::new(output.stdout.as_slice());\n let mut entry = ar.entries().unwrap().next().unwrap().unwrap();\n let mut contents = String::new();\n entry.read_to_string(&mut contents).unwrap();\n contents\n }\n}\n\nimpl Drop for ContainerHandle {\n fn drop(&mut self) {\n // To help with debugging, this will keep the container alive.\n if std::env::var_os(\"CARGO_CONTAINER_TEST_KEEP\").is_some() {\n return;\n }\n remove_if_exists(&self.name);\n }\n}\n\nfn remove_if_exists(name: &str) {\n if let Err(e) = Command::new(\"docker\")\n .args(&[\"container\", \"rm\", \"--force\", name])\n .output()\n {\n panic!(\"failed to run docker: {e}\");\n }\n}\n\n/// Builder for configuring a file to copy into a container.\npub struct MkFile {\n path: String,\n contents: Vec,\n header: Header,\n}\n\nimpl MkFile {\n /// Defines a file to add to the container.\n ///\n /// This should be passed to `Container::file`.\n ///\n /// The path is the path inside the container to create the file.\n pub fn path(path: &str) -> MkFile {\n MkFile {\n path: path.to_string(),\n contents: Vec::new(),\n header: Header::new_gnu(),\n }\n }\n\n pub fn contents(mut self, contents: impl Into>) -> Self {\n self.contents = contents.into();\n self.header.set_size(self.contents.len() as u64);\n self\n }\n\n pub fn mode(mut self, mode: u32) -> Self {\n self.header.set_mode(mode);\n self\n }\n\n pub fn uid(mut self, uid: u64) -> Self {\n self.header.set_uid(uid);\n self\n }\n\n pub fn gid(mut self, gid: u64) -> Self {\n self.header.set_gid(gid);\n self\n }\n}\n" }, { "path": "crates/cargo-test-support/src/cross_compile.rs", "content": "//! Support for cross-compile tests with the `--target` flag.\n//!\n//! Note that cross-testing is very limited. You need to install the\n//! \"alternate\" target to the host (32-bit for 64-bit hosts or vice-versa).\n//!\n//! Set `CFG_DISABLE_CROSS_TESTS=1` environment variable to disable these tests\n//! if you are unable to use the alternate target. Unfortunately 32-bit\n//! support on macOS is going away, so macOS users are out of luck.\n//!\n//! These tests are all disabled on rust-lang/rust's CI, but run in Cargo's CI.\n\nuse std::env;\n\n/// The arch triple of the test-running host.\npub fn native() -> &'static str {\n env!(\"NATIVE_ARCH\")\n}\n\npub fn native_arch() -> &'static str {\n match native()\n .split(\"-\")\n .next()\n .expect(\"Target triple has unexpected format\")\n {\n \"x86_64\" => \"x86_64\",\n \"aarch64\" => \"aarch64\",\n \"i686\" => \"x86\",\n _ => panic!(\"This test should be gated on cross_compile::disabled.\"),\n }\n}\n\n/// The alternate target-triple to build with.\n///\n/// Only use this function on tests that check `cross_compile::disabled`.\npub fn alternate() -> &'static str {\n try_alternate().expect(\"This test should be gated on cross_compile::disabled.\")\n}\n\n/// A possible alternate target-triple to build with.\npub(crate) fn try_alternate() -> Option<&'static str> {\n if cfg!(target_os = \"macos\") {\n Some(\"x86_64-apple-darwin\")\n } else if cfg!(target_os = \"linux\") {\n Some(\"i686-unknown-linux-gnu\")\n } else if cfg!(all(target_os = \"windows\", target_env = \"msvc\")) {\n Some(\"i686-pc-windows-msvc\")\n } else if cfg!(all(target_os = \"windows\", target_env = \"gnu\")) {\n Some(\"i686-pc-windows-gnu\")\n } else {\n None\n }\n}\n\npub fn alternate_arch() -> &'static str {\n if cfg!(target_os = \"macos\") {\n \"x86_64\"\n } else {\n \"x86\"\n }\n}\n\n/// A target-triple that is neither the host nor the target.\n///\n/// Rustc may not work with it and it's alright, apart from being a\n/// valid target triple it is supposed to be used only as a\n/// placeholder for targets that should not be considered.\npub fn unused() -> &'static str {\n \"wasm32-unknown-unknown\"\n}\n\n/// Check if the given target has been installed.\n///\n/// Generally `testsuite::utils::cross_compile::disabled` should be used to check if cross-compilation is allowed.\n/// And [`alternate`] to get the cross target.\n///\n/// You should only use this as a last resort to skip tests,\n/// because it doesn't report skipped tests as ignored.\npub fn requires_target_installed(target: &str) -> bool {\n let has_target = std::process::Command::new(\"rustup\")\n .args([\"target\", \"list\", \"--installed\"])\n .output()\n .ok()\n .map(|output| {\n String::from_utf8(output.stdout)\n .map(|stdout| stdout.contains(target))\n .unwrap_or_default()\n })\n .unwrap_or_default();\n if !has_target {\n let msg =\n format!(\"to run this test, run `rustup target add {target} --toolchain `\",);\n if cargo_util::is_ci() {\n panic!(\"{msg}\");\n } else {\n eprintln!(\"{msg}\");\n }\n }\n has_target\n}\n" }, { "path": "crates/cargo-test-support/src/git.rs", "content": "//! # Git Testing Support\n//!\n//! ## Creating a git dependency\n//! [`new()`] is an easy way to create a new git repository containing a\n//! project that you can then use as a dependency. It will automatically add all\n//! the files you specify in the project and commit them to the repository.\n//!\n//! ### Example:\n//!\n//! ```no_run\n//! # use cargo_test_support::project;\n//! # use cargo_test_support::basic_manifest;\n//! # use cargo_test_support::git;\n//! let git_project = git::new(\"dep1\", |project| {\n//! project\n//! .file(\"Cargo.toml\", &basic_manifest(\"dep1\", \"1.0.0\"))\n//! .file(\"src/lib.rs\", r#\"pub fn f() { println!(\"hi!\"); } \"#)\n//! });\n//!\n//! // Use the `url()` method to get the file url to the new repository.\n//! let p = project()\n//! .file(\"Cargo.toml\", &format!(r#\"\n//! [package]\n//! name = \"a\"\n//! version = \"1.0.0\"\n//!\n//! [dependencies]\n//! dep1 = {{ git = '{}' }}\n//! \"#, git_project.url()))\n//! .file(\"src/lib.rs\", \"extern crate dep1;\")\n//! .build();\n//! ```\n//!\n//! ## Manually creating repositories\n//!\n//! [`repo()`] can be used to create a [`RepoBuilder`] which provides a way of\n//! adding files to a blank repository and committing them.\n//!\n//! If you want to then manipulate the repository (such as adding new files or\n//! tags), you can use `git2::Repository::open()` to open the repository and then\n//! use some of the helper functions in this file to interact with the repository.\n\nuse crate::{Project, ProjectBuilder, SymlinkBuilder, paths::CargoPathExt, project};\nuse std::fs;\nuse std::path::{Path, PathBuf};\nuse std::sync::Once;\nuse url::Url;\n\n/// Manually construct a [`Repository`]\n///\n/// See also [`new`], [`repo`]\n#[must_use]\npub struct RepoBuilder {\n repo: git2::Repository,\n files: Vec,\n}\n\n/// See [`new`]\npub struct Repository(git2::Repository);\n\n/// Create a [`RepoBuilder`] to build a new git repository.\n///\n/// Call [`RepoBuilder::build()`] to finalize and create the repository.\npub fn repo(p: &Path) -> RepoBuilder {\n RepoBuilder::init(p)\n}\n\nimpl RepoBuilder {\n pub fn init(p: &Path) -> RepoBuilder {\n t!(fs::create_dir_all(p.parent().unwrap()));\n let repo = init(p);\n RepoBuilder {\n repo,\n files: Vec::new(),\n }\n }\n\n /// Add a file to the repository.\n pub fn file(self, path: &str, contents: &str) -> RepoBuilder {\n let mut me = self.nocommit_file(path, contents);\n me.files.push(PathBuf::from(path));\n me\n }\n\n /// Create a symlink to a directory\n pub fn nocommit_symlink_dir>(self, dst: T, src: T) -> Self {\n let workdir = self.repo.workdir().unwrap();\n SymlinkBuilder::new_dir(workdir.join(dst), workdir.join(src)).mk();\n self\n }\n\n /// Add a file that will be left in the working directory, but not added\n /// to the repository.\n pub fn nocommit_file(self, path: &str, contents: &str) -> RepoBuilder {\n let dst = self.repo.workdir().unwrap().join(path);\n t!(fs::create_dir_all(dst.parent().unwrap()));\n t!(fs::write(&dst, contents));\n self\n }\n\n /// Create the repository and commit the new files.\n pub fn build(self) -> Repository {\n {\n let mut index = t!(self.repo.index());\n for file in self.files.iter() {\n t!(index.add_path(file));\n }\n t!(index.write());\n let id = t!(index.write_tree());\n let tree = t!(self.repo.find_tree(id));\n let sig = t!(self.repo.signature());\n t!(self\n .repo\n .commit(Some(\"HEAD\"), &sig, &sig, \"Initial commit\", &tree, &[]));\n }\n let RepoBuilder { repo, .. } = self;\n Repository(repo)\n }\n}\n\nimpl Repository {\n pub fn root(&self) -> &Path {\n self.0.workdir().unwrap()\n }\n\n pub fn url(&self) -> Url {\n self.0.workdir().unwrap().to_url()\n }\n\n pub fn revparse_head(&self) -> String {\n self.0\n .revparse_single(\"HEAD\")\n .expect(\"revparse HEAD\")\n .id()\n .to_string()\n }\n}\n\n/// *(`git2`)* Initialize a new repository at the given path.\npub fn init(path: &Path) -> git2::Repository {\n default_search_path();\n let repo = t!(git2::Repository::init(path));\n default_repo_cfg(&repo);\n repo\n}\n\nfn default_search_path() {\n use crate::paths::global_root;\n use git2::{ConfigLevel, opts::set_search_path};\n\n static INIT: Once = Once::new();\n INIT.call_once(|| unsafe {\n let path = global_root().join(\"blank_git_search_path\");\n t!(set_search_path(ConfigLevel::System, &path));\n t!(set_search_path(ConfigLevel::Global, &path));\n t!(set_search_path(ConfigLevel::XDG, &path));\n t!(set_search_path(ConfigLevel::ProgramData, &path));\n })\n}\n\nfn default_repo_cfg(repo: &git2::Repository) {\n let mut cfg = t!(repo.config());\n t!(cfg.set_str(\"user.email\", \"foo@bar.com\"));\n t!(cfg.set_str(\"user.name\", \"Foo Bar\"));\n}\n\n/// Create a new [`Project`] in a git [`Repository`]\npub fn new(name: &str, callback: F) -> Project\nwhere\n F: FnOnce(ProjectBuilder) -> ProjectBuilder,\n{\n new_repo(name, callback).0\n}\n\n/// Create a new [`Project`] with access to the [`Repository`]\npub fn new_repo(name: &str, callback: F) -> (Project, git2::Repository)\nwhere\n F: FnOnce(ProjectBuilder) -> ProjectBuilder,\n{\n let mut git_project = project().at(name);\n git_project = callback(git_project);\n let git_project = git_project.build();\n\n let repo = init(&git_project.root());\n add(&repo);\n commit(&repo);\n (git_project, repo)\n}\n\n/// *(`git2`)* Add all files in the working directory to the git index\npub fn add(repo: &git2::Repository) {\n let mut index = t!(repo.index());\n t!(index.add_all([\"*\"].iter(), git2::IndexAddOption::DEFAULT, None));\n t!(index.write());\n}\n\n/// *(`git2`)* Add a git submodule to the repository\npub fn add_submodule<'a>(\n repo: &'a git2::Repository,\n url: &str,\n path: &Path,\n) -> git2::Submodule<'a> {\n let path = path.to_str().unwrap().replace(r\"\\\", \"/\");\n let mut s = t!(repo.submodule(url, Path::new(&path), false));\n let subrepo = t!(s.open());\n default_repo_cfg(&subrepo);\n t!(subrepo.remote_add_fetch(\"origin\", \"refs/heads/*:refs/heads/*\"));\n let mut origin = t!(subrepo.find_remote(\"origin\"));\n t!(origin.fetch(&Vec::::new(), None, None));\n t!(subrepo.checkout_head(None));\n t!(s.add_finalize());\n s\n}\n\n/// *(`git2`)* Commit changes to the git repository\npub fn commit(repo: &git2::Repository) -> git2::Oid {\n let tree_id = t!(t!(repo.index()).write_tree());\n let sig = t!(repo.signature());\n let mut parents = Vec::new();\n if let Some(parent) = repo.head().ok().map(|h| h.target().unwrap()) {\n parents.push(t!(repo.find_commit(parent)))\n }\n let parents = parents.iter().collect::>();\n t!(repo.commit(\n Some(\"HEAD\"),\n &sig,\n &sig,\n \"test\",\n &t!(repo.find_tree(tree_id)),\n &parents\n ))\n}\n\n/// *(`git2`)* Create a new tag in the git repository\npub fn tag(repo: &git2::Repository, name: &str) {\n let head = repo.head().unwrap().target().unwrap();\n t!(repo.tag(\n name,\n &t!(repo.find_object(head, None)),\n &t!(repo.signature()),\n \"make a new tag\",\n false\n ));\n}\n\n/// Returns true if gitoxide is globally activated.\n///\n/// That way, tests that normally use `git2` can transparently use `gitoxide`.\npub fn cargo_uses_gitoxide() -> bool {\n std::env::var_os(\"__CARGO_USE_GITOXIDE_INSTEAD_OF_GIT2\").map_or(false, |value| value == \"1\")\n}\n" }, { "path": "crates/cargo-test-support/src/install.rs", "content": "//! Helpers for testing `cargo install`\n\nuse std::env::consts::EXE_SUFFIX;\nuse std::path::Path;\n\n/// Used by `cargo install` tests to assert an executable binary\n/// has been installed. Example usage:\n/// ```no_run\n/// use cargo_test_support::install::assert_has_installed_exe;\n/// use cargo_test_support::paths;\n///\n/// assert_has_installed_exe(paths::cargo_home(), \"foo\");\n/// ```\n#[track_caller]\npub fn assert_has_installed_exe>(path: P, name: &'static str) {\n assert!(check_has_installed_exe(path, name));\n}\n\n#[track_caller]\npub fn assert_has_not_installed_exe>(path: P, name: &'static str) {\n assert!(!check_has_installed_exe(path, name));\n}\n\nfn check_has_installed_exe>(path: P, name: &'static str) -> bool {\n path.as_ref().join(\"bin\").join(exe(name)).is_file()\n}\n\n/// `$name$EXE`\npub fn exe(name: &str) -> String {\n format!(\"{}{}\", name, EXE_SUFFIX)\n}\n" }, { "path": "crates/cargo-test-support/src/lib.rs", "content": "//! # Cargo test support.\n//!\n//! See for a guide on writing tests.\n//!\n//! There are two places you can find API documentation\n//!\n//! - :\n//! targeted at external tool developers testing cargo-related code\n//! - Released with every rustc release\n//! - :\n//! targeted at cargo contributors\n//! - Updated on each update of the `cargo` submodule in `rust-lang/rust`\n//!\n//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use. This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n//!\n//! # Example\n//!\n//! ```rust,no_run\n//! use cargo_test_support::prelude::*;\n//! use cargo_test_support::str;\n//! use cargo_test_support::project;\n//!\n//! #[cargo_test]\n//! fn some_test() {\n//! let p = project()\n//! .file(\"src/main.rs\", r#\"fn main() { println!(\"hi!\"); }\"#)\n//! .build();\n//!\n//! p.cargo(\"run --bin foo\")\n//! .with_stderr_data(str![[r#\"\n//! [COMPILING] foo [..]\n//! [FINISHED] [..]\n//! [RUNNING] `target/debug/foo`\n//! \"#]])\n//! .with_stdout_data(str![[\"hi!\"]])\n//! .run();\n//! }\n//! ```\n\n#![allow(clippy::disallowed_methods)]\n#![allow(clippy::print_stderr)]\n#![allow(clippy::print_stdout)]\n\nuse std::env;\nuse std::ffi::OsStr;\nuse std::fmt::Write;\nuse std::fs;\nuse std::os;\nuse std::path::{Path, PathBuf};\nuse std::process::{Command, Output};\nuse std::sync::LazyLock;\nuse std::sync::OnceLock;\nuse std::thread::JoinHandle;\nuse std::time::{self, Duration};\n\nuse anyhow::{Result, bail};\nuse cargo_util::{ProcessError, is_ci};\nuse snapbox::IntoData as _;\nuse url::Url;\n\nuse self::paths::CargoPathExt;\n\n/// Unwrap a `Result` with a useful panic message\n///\n/// # Example\n///\n/// ```rust\n/// use cargo_test_support::t;\n/// t!(std::fs::read_to_string(\"Cargo.toml\"));\n/// ```\n#[macro_export]\nmacro_rules! t {\n ($e:expr) => {\n match $e {\n Ok(e) => e,\n Err(e) => $crate::panic_error(&format!(\"failed running {}\", stringify!($e)), e),\n }\n };\n}\n\npub use cargo_util::ProcessBuilder;\npub use snapbox::file;\npub use snapbox::str;\npub use snapbox::utils::current_dir;\n\n/// `panic!`, reporting the specified error , see also [`t!`]\n#[track_caller]\npub fn panic_error(what: &str, err: impl Into) -> ! {\n let err = err.into();\n pe(what, err);\n #[track_caller]\n fn pe(what: &str, err: anyhow::Error) -> ! {\n let mut result = format!(\"{}\\nerror: {}\", what, err);\n for cause in err.chain().skip(1) {\n let _ = writeln!(result, \"\\nCaused by:\");\n let _ = write!(result, \"{}\", cause);\n }\n panic!(\"\\n{}\", result);\n }\n}\n\npub use cargo_test_macro::cargo_test;\n\npub mod compare;\npub mod containers;\npub mod cross_compile;\npub mod git;\npub mod install;\npub mod paths;\npub mod publish;\npub mod registry;\n\npub mod prelude {\n pub use crate::ArgLineCommandExt;\n pub use crate::ChannelChangerCommandExt;\n pub use crate::TestEnvCommandExt;\n pub use crate::cargo_test;\n pub use crate::paths::CargoPathExt;\n pub use snapbox::IntoData;\n}\n\n/*\n *\n * ===== Builders =====\n *\n */\n\n#[derive(PartialEq, Clone)]\nstruct FileBuilder {\n path: PathBuf,\n body: String,\n executable: bool,\n}\n\nimpl FileBuilder {\n pub fn new(path: PathBuf, body: &str, executable: bool) -> FileBuilder {\n FileBuilder {\n path,\n body: body.to_string(),\n executable: executable,\n }\n }\n\n fn mk(&mut self) {\n if self.executable {\n let mut path = self.path.clone().into_os_string();\n write!(path, \"{}\", env::consts::EXE_SUFFIX).unwrap();\n self.path = path.into();\n }\n\n self.dirname().mkdir_p();\n fs::write(&self.path, &self.body)\n .unwrap_or_else(|e| panic!(\"could not create file {}: {}\", self.path.display(), e));\n\n #[cfg(unix)]\n if self.executable {\n use std::os::unix::fs::PermissionsExt;\n\n let mut perms = fs::metadata(&self.path).unwrap().permissions();\n let mode = perms.mode();\n perms.set_mode(mode | 0o111);\n fs::set_permissions(&self.path, perms).unwrap();\n }\n }\n\n fn dirname(&self) -> &Path {\n self.path.parent().unwrap()\n }\n}\n\n#[derive(PartialEq, Clone)]\nstruct SymlinkBuilder {\n dst: PathBuf,\n src: PathBuf,\n src_is_dir: bool,\n}\n\nimpl SymlinkBuilder {\n pub fn new(dst: PathBuf, src: PathBuf) -> SymlinkBuilder {\n SymlinkBuilder {\n dst,\n src,\n src_is_dir: false,\n }\n }\n\n pub fn new_dir(dst: PathBuf, src: PathBuf) -> SymlinkBuilder {\n SymlinkBuilder {\n dst,\n src,\n src_is_dir: true,\n }\n }\n\n #[cfg(unix)]\n fn mk(&self) {\n self.dirname().mkdir_p();\n t!(os::unix::fs::symlink(&self.dst, &self.src));\n }\n\n #[cfg(windows)]\n fn mk(&mut self) {\n self.dirname().mkdir_p();\n if self.src_is_dir {\n t!(os::windows::fs::symlink_dir(&self.dst, &self.src));\n } else {\n if let Some(ext) = self.dst.extension() {\n if ext == env::consts::EXE_EXTENSION {\n self.src.set_extension(ext);\n }\n }\n t!(os::windows::fs::symlink_file(&self.dst, &self.src));\n }\n }\n\n fn dirname(&self) -> &Path {\n self.src.parent().unwrap()\n }\n}\n\n/// A cargo project to run tests against.\n///\n/// See [`ProjectBuilder`] or [`Project::from_template`] to get started.\npub struct Project {\n root: PathBuf,\n}\n\n/// Create a project to run tests against\n///\n/// - Creates a [`basic_manifest`] if one isn't supplied\n///\n/// To get started, see:\n/// - [`project`]\n/// - [`project_in`]\n/// - [`project_in_home`]\n/// - [`Project::from_template`]\n#[must_use]\npub struct ProjectBuilder {\n root: Project,\n files: Vec,\n symlinks: Vec,\n no_manifest: bool,\n}\n\nimpl ProjectBuilder {\n /// Root of the project\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo`\n pub fn root(&self) -> PathBuf {\n self.root.root()\n }\n\n /// Project's debug dir\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo/target/debug`\n pub fn target_debug_dir(&self) -> PathBuf {\n self.root.target_debug_dir()\n }\n\n /// Create project in `root`\n pub fn new(root: PathBuf) -> ProjectBuilder {\n ProjectBuilder {\n root: Project { root },\n files: vec![],\n symlinks: vec![],\n no_manifest: false,\n }\n }\n\n /// Create project, relative to [`paths::root`]\n pub fn at>(mut self, path: P) -> Self {\n self.root = Project {\n root: paths::root().join(path),\n };\n self\n }\n\n /// Adds a file to the project.\n pub fn file>(mut self, path: B, body: &str) -> Self {\n self._file(path.as_ref(), body, false);\n self\n }\n\n /// Adds an executable file to the project.\n pub fn executable>(mut self, path: B, body: &str) -> Self {\n self._file(path.as_ref(), body, true);\n self\n }\n\n fn _file(&mut self, path: &Path, body: &str, executable: bool) {\n self.files.push(FileBuilder::new(\n self.root.root().join(path),\n body,\n executable,\n ));\n }\n\n /// Adds a symlink to a file to the project.\n pub fn symlink(mut self, dst: impl AsRef, src: impl AsRef) -> Self {\n self.symlinks.push(SymlinkBuilder::new(\n self.root.root().join(dst),\n self.root.root().join(src),\n ));\n self\n }\n\n /// Create a symlink to a directory\n pub fn symlink_dir(mut self, dst: impl AsRef, src: impl AsRef) -> Self {\n self.symlinks.push(SymlinkBuilder::new_dir(\n self.root.root().join(dst),\n self.root.root().join(src),\n ));\n self\n }\n\n pub fn no_manifest(mut self) -> Self {\n self.no_manifest = true;\n self\n }\n\n /// Creates the project.\n pub fn build(mut self) -> Project {\n // First, clean the directory if it already exists\n self.rm_root();\n\n // Create the empty directory\n self.root.root().mkdir_p();\n\n let manifest_path = self.root.root().join(\"Cargo.toml\");\n if !self.no_manifest && self.files.iter().all(|fb| fb.path != manifest_path) {\n self._file(\n Path::new(\"Cargo.toml\"),\n &basic_manifest(\"foo\", \"0.0.1\"),\n false,\n )\n }\n\n let past = time::SystemTime::now() - Duration::new(1, 0);\n let ftime = filetime::FileTime::from_system_time(past);\n\n for file in self.files.iter_mut() {\n file.mk();\n if is_coarse_mtime() {\n // Place the entire project 1 second in the past to ensure\n // that if cargo is called multiple times, the 2nd call will\n // see targets as \"fresh\". Without this, if cargo finishes in\n // under 1 second, the second call will see the mtime of\n // source == mtime of output and consider it dirty.\n filetime::set_file_times(&file.path, ftime, ftime).unwrap();\n }\n }\n\n for symlink in self.symlinks.iter_mut() {\n symlink.mk();\n }\n\n let ProjectBuilder { root, .. } = self;\n root\n }\n\n fn rm_root(&self) {\n self.root.root().rm_rf()\n }\n}\n\nimpl Project {\n /// Copy the test project from a fixed state\n pub fn from_template(template_path: impl AsRef) -> Self {\n let root = paths::root();\n let project_root = root.join(\"case\");\n snapbox::dir::copy_template(template_path.as_ref(), &project_root).unwrap();\n Self { root: project_root }\n }\n\n /// Root of the project\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo`\n pub fn root(&self) -> PathBuf {\n self.root.clone()\n }\n\n /// Project's target dir\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo/target`\n pub fn build_dir(&self) -> PathBuf {\n self.root().join(\"target\")\n }\n\n /// Project's debug dir\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo/target/debug`\n pub fn target_debug_dir(&self) -> PathBuf {\n self.build_dir().join(\"debug\")\n }\n\n /// File url for root\n ///\n /// ex: `file://$CARGO_TARGET_TMPDIR/cit/t0/foo`\n pub fn url(&self) -> Url {\n use paths::CargoPathExt;\n self.root().to_url()\n }\n\n /// Path to an example built as a library.\n ///\n /// `kind` should be one of: \"lib\", \"rlib\", \"staticlib\", \"dylib\", \"proc-macro\"\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo/target/debug/examples/libex.rlib`\n pub fn example_lib(&self, name: &str, kind: &str) -> PathBuf {\n self.target_debug_dir()\n .join(\"examples\")\n .join(paths::get_lib_filename(name, kind))\n }\n\n /// Path to a dynamic library.\n /// ex: `/path/to/cargo/target/cit/t0/foo/target/debug/examples/libex.dylib`\n pub fn dylib(&self, name: &str) -> PathBuf {\n self.target_debug_dir().join(format!(\n \"{}{name}{}\",\n env::consts::DLL_PREFIX,\n env::consts::DLL_SUFFIX\n ))\n }\n\n /// Path to a debug binary.\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo/target/debug/foo`\n pub fn bin(&self, b: &str) -> PathBuf {\n self.build_dir()\n .join(\"debug\")\n .join(&format!(\"{}{}\", b, env::consts::EXE_SUFFIX))\n }\n\n /// Path to a release binary.\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo/target/release/foo`\n pub fn release_bin(&self, b: &str) -> PathBuf {\n self.build_dir()\n .join(\"release\")\n .join(&format!(\"{}{}\", b, env::consts::EXE_SUFFIX))\n }\n\n /// Path to a debug binary for a specific target triple.\n ///\n /// ex: `$CARGO_TARGET_TMPDIR/cit/t0/foo/target/i686-apple-darwin/debug/foo`\n pub fn target_bin(&self, target: &str, b: &str) -> PathBuf {\n self.build_dir().join(target).join(\"debug\").join(&format!(\n \"{}{}\",\n b,\n env::consts::EXE_SUFFIX\n ))\n }\n\n /// Returns an iterator of paths within [`Project::root`] matching the glob pattern\n pub fn glob>(&self, pattern: P) -> glob::Paths {\n let pattern = self.root().join(pattern);\n glob::glob(pattern.to_str().expect(\"failed to convert pattern to str\"))\n .expect(\"failed to glob\")\n }\n\n /// Overwrite a file with new content\n ///\n // # Example:\n ///\n /// ```no_run\n /// # let p = cargo_test_support::project().build();\n /// p.change_file(\"src/lib.rs\", \"fn new_fn() {}\");\n /// ```\n pub fn change_file(&self, path: impl AsRef, body: &str) {\n FileBuilder::new(self.root().join(path), body, false).mk()\n }\n\n /// Creates a `ProcessBuilder` to run a program in the project\n /// and wrap it in an Execs to assert on the execution.\n ///\n /// # Example:\n ///\n /// ```no_run\n /// # use cargo_test_support::str;\n /// # let p = cargo_test_support::project().build();\n /// p.process(&p.bin(\"foo\"))\n /// .with_stdout_data(str![\"bar\\n\"])\n /// .run();\n /// ```\n pub fn process>(&self, program: T) -> Execs {\n let mut p = process(program);\n p.cwd(self.root());\n execs().with_process_builder(p)\n }\n\n /// Safely run a process after `cargo build`.\n ///\n /// Windows has a problem where a process cannot be reliably\n /// be replaced, removed, or renamed immediately after executing it.\n /// The action may fail (with errors like Access is denied), or\n /// it may succeed, but future attempts to use the same filename\n /// will fail with \"Already Exists\".\n ///\n /// If you have a test that needs to do `cargo run` multiple\n /// times, you should instead use `cargo build` and use this\n /// method to run the executable. Each time you call this,\n /// use a new name for `dst`.\n /// See rust-lang/cargo#5481.\n pub fn rename_run(&self, src: &str, dst: &str) -> Execs {\n let src = self.bin(src);\n let dst = self.bin(dst);\n fs::rename(&src, &dst)\n .unwrap_or_else(|e| panic!(\"Failed to rename `{:?}` to `{:?}`: {}\", src, dst, e));\n self.process(dst)\n }\n\n /// Returns the contents of `Cargo.lock`.\n pub fn read_lockfile(&self) -> String {\n self.read_file(\"Cargo.lock\")\n }\n\n /// Returns the contents of a path in the project root\n pub fn read_file(&self, path: impl AsRef) -> String {\n let full = self.root().join(path);\n fs::read_to_string(&full)\n .unwrap_or_else(|e| panic!(\"could not read file {}: {}\", full.display(), e))\n }\n\n /// Modifies `Cargo.toml` to remove all commented lines.\n pub fn uncomment_root_manifest(&self) {\n let contents = self.read_file(\"Cargo.toml\").replace(\"#\", \"\");\n fs::write(self.root().join(\"Cargo.toml\"), contents).unwrap();\n }\n\n pub fn symlink(&self, src: impl AsRef, dst: impl AsRef) {\n let src = self.root().join(src.as_ref());\n let dst = self.root().join(dst.as_ref());\n #[cfg(unix)]\n {\n if let Err(e) = os::unix::fs::symlink(&src, &dst) {\n panic!(\"failed to symlink {:?} to {:?}: {:?}\", src, dst, e);\n }\n }\n #[cfg(windows)]\n {\n if src.is_dir() {\n if let Err(e) = os::windows::fs::symlink_dir(&src, &dst) {\n panic!(\"failed to symlink {:?} to {:?}: {:?}\", src, dst, e);\n }\n } else {\n if let Err(e) = os::windows::fs::symlink_file(&src, &dst) {\n panic!(\"failed to symlink {:?} to {:?}: {:?}\", src, dst, e);\n }\n }\n }\n }\n}\n\n/// Generates a project layout, see [`ProjectBuilder`]\npub fn project() -> ProjectBuilder {\n ProjectBuilder::new(paths::root().join(\"foo\"))\n}\n\n/// Generates a project layout in given directory, see [`ProjectBuilder`]\npub fn project_in(dir: impl AsRef) -> ProjectBuilder {\n ProjectBuilder::new(paths::root().join(dir).join(\"foo\"))\n}\n\n/// Generates a project layout inside our fake home dir, see [`ProjectBuilder`]\npub fn project_in_home(name: impl AsRef) -> ProjectBuilder {\n ProjectBuilder::new(paths::home().join(name))\n}\n\n// === Helpers ===\n\n/// Generate a `main.rs` printing the specified text\n///\n/// ```rust\n/// # use cargo_test_support::main_file;\n/// # mod dep {\n/// # fn bar() -> &'static str {\n/// # \"world\"\n/// # }\n/// # }\n/// main_file(\n/// r#\"\"hello {}\", dep::bar()\"#,\n/// &[]\n/// );\n/// ```\npub fn main_file(println: &str, externed_deps: &[&str]) -> String {\n let mut buf = String::new();\n\n for dep in externed_deps.iter() {\n buf.push_str(&format!(\"extern crate {};\\n\", dep));\n }\n\n buf.push_str(\"fn main() { println!(\");\n buf.push_str(println);\n buf.push_str(\"); }\\n\");\n\n buf\n}\n\n/// This is the raw output from the process.\n///\n/// This is similar to `std::process::Output`, however the `status` is\n/// translated to the raw `code`. This is necessary because `ProcessError`\n/// does not have access to the raw `ExitStatus` because `ProcessError` needs\n/// to be serializable (for the Rustc cache), and `ExitStatus` does not\n/// provide a constructor.\npub struct RawOutput {\n pub code: Option,\n pub stdout: Vec,\n pub stderr: Vec,\n}\n\n/// Run and verify a [`ProcessBuilder`]\n///\n/// Construct with\n/// - [`execs`]\n/// - [`Project`] methods\n/// - `cargo_process` in testsuite\n#[must_use]\n#[derive(Clone)]\npub struct Execs {\n ran: bool,\n process_builder: Option,\n expect_stdin: Option,\n expect_exit_code: Option,\n expect_stdout_data: Option,\n expect_stderr_data: Option,\n expect_stdout_contains: Vec,\n expect_stderr_contains: Vec,\n expect_stdout_not_contains: Vec,\n expect_stderr_not_contains: Vec,\n expect_stderr_with_without: Vec<(Vec, Vec)>,\n stream_output: bool,\n assert: snapbox::Assert,\n}\n\nimpl Execs {\n pub fn with_process_builder(mut self, p: ProcessBuilder) -> Execs {\n self.process_builder = Some(p);\n self\n }\n}\n\n/// # Configure assertions\nimpl Execs {\n /// Verifies that stdout is equal to the given lines.\n ///\n /// See [`compare::assert_e2e`] for assertion details.\n ///\n ///
\n ///\n /// Prefer passing in [`str!`] for `expected` to get snapshot updating.\n ///\n /// If `format!` is needed for content that changes from run to run that you don't care about,\n /// consider whether you could have [`compare::assert_e2e`] redact the content.\n /// If nothing else, a wildcard (`[..]`, `...`) may be useful.\n ///\n /// However, `\"\"` may be preferred for intentionally empty output so people don't accidentally\n /// bless a change.\n ///\n ///
\n ///\n /// # Examples\n ///\n /// ```no_run\n /// use cargo_test_support::prelude::*;\n /// use cargo_test_support::str;\n /// use cargo_test_support::execs;\n ///\n /// execs().with_stdout_data(str![r#\"\n /// Hello world!\n /// \"#]);\n /// ```\n ///\n /// Non-deterministic compiler output\n /// ```no_run\n /// use cargo_test_support::prelude::*;\n /// use cargo_test_support::str;\n /// use cargo_test_support::execs;\n ///\n /// execs().with_stdout_data(str![r#\"\n /// [COMPILING] foo\n /// [COMPILING] bar\n /// \"#].unordered());\n /// ```\n ///\n /// jsonlines\n /// ```no_run\n /// use cargo_test_support::prelude::*;\n /// use cargo_test_support::str;\n /// use cargo_test_support::execs;\n ///\n /// execs().with_stdout_data(str![r#\"\n /// [\n /// {},\n /// {}\n /// ]\n /// \"#].is_json().against_jsonlines());\n /// ```\n pub fn with_stdout_data(&mut self, expected: impl snapbox::IntoData) -> &mut Self {\n self.expect_stdout_data = Some(expected.into_data());\n self\n }\n\n /// Verifies that stderr is equal to the given lines.\n ///\n /// See [`compare::assert_e2e`] for assertion details.\n ///\n ///
\n ///\n /// Prefer passing in [`str!`] for `expected` to get snapshot updating.\n ///\n /// If `format!` is needed for content that changes from run to run that you don't care about,\n /// consider whether you could have [`compare::assert_e2e`] redact the content.\n /// If nothing else, a wildcard (`[..]`, `...`) may be useful.\n ///\n /// However, `\"\"` may be preferred for intentionally empty output so people don't accidentally\n /// bless a change.\n ///\n ///
\n ///\n /// # Examples\n ///\n /// ```no_run\n /// use cargo_test_support::prelude::*;\n /// use cargo_test_support::str;\n /// use cargo_test_support::execs;\n ///\n /// execs().with_stderr_data(str![r#\"\n /// Hello world!\n /// \"#]);\n /// ```\n ///\n /// Non-deterministic compiler output\n /// ```no_run\n /// use cargo_test_support::prelude::*;\n /// use cargo_test_support::str;\n /// use cargo_test_support::execs;\n ///\n /// execs().with_stderr_data(str![r#\"\n /// [COMPILING] foo\n /// [COMPILING] bar\n /// \"#].unordered());\n /// ```\n ///\n /// jsonlines\n /// ```no_run\n /// use cargo_test_support::prelude::*;\n /// use cargo_test_support::str;\n /// use cargo_test_support::execs;\n ///\n /// execs().with_stderr_data(str![r#\"\n /// [\n /// {},\n /// {}\n /// ]\n /// \"#].is_json().against_jsonlines());\n /// ```\n pub fn with_stderr_data(&mut self, expected: impl snapbox::IntoData) -> &mut Self {\n self.expect_stderr_data = Some(expected.into_data());\n self\n }\n\n /// Writes the given lines to stdin.\n pub fn with_stdin(&mut self, expected: S) -> &mut Self {\n self.expect_stdin = Some(expected.to_string());\n self\n }\n\n /// Verifies the exit code from the process.\n ///\n /// This is not necessary if the expected exit code is `0`.\n pub fn with_status(&mut self, expected: i32) -> &mut Self {\n self.expect_exit_code = Some(expected);\n self\n }\n\n /// Removes exit code check for the process.\n ///\n /// By default, the expected exit code is `0`.\n pub fn without_status(&mut self) -> &mut Self {\n self.expect_exit_code = None;\n self\n }\n\n /// Verifies that stdout contains the given contiguous lines somewhere in\n /// its output.\n ///\n /// See [`compare`] for supported patterns.\n ///\n ///
\n ///\n /// Prefer [`Execs::with_stdout_data`] where possible.\n /// - `expected` cannot be snapshotted\n /// - `expected` can end up being ambiguous, causing the assertion to succeed when it should fail\n ///\n ///
\n pub fn with_stdout_contains(&mut self, expected: S) -> &mut Self {\n self.expect_stdout_contains.push(expected.to_string());\n self\n }\n\n /// Verifies that stderr contains the given contiguous lines somewhere in\n /// its output.\n ///\n /// See [`compare`] for supported patterns.\n ///\n ///
\n ///\n /// Prefer [`Execs::with_stderr_data`] where possible.\n /// - `expected` cannot be snapshotted\n /// - `expected` can end up being ambiguous, causing the assertion to succeed when it should fail\n ///\n ///
\n pub fn with_stderr_contains(&mut self, expected: S) -> &mut Self {\n self.expect_stderr_contains.push(expected.to_string());\n self\n }\n\n /// Verifies that stdout does not contain the given contiguous lines.\n ///\n /// See [`compare`] for supported patterns.\n ///\n /// See note on [`Self::with_stderr_does_not_contain`].\n ///\n ///
\n ///\n /// Prefer [`Execs::with_stdout_data`] where possible.\n /// - `expected` cannot be snapshotted\n /// - The absence of `expected` can either mean success or that the string being looked for\n /// changed.\n ///\n /// To mitigate this, consider matching this up with\n /// [`Execs::with_stdout_contains`].\n ///\n ///
\n pub fn with_stdout_does_not_contain(&mut self, expected: S) -> &mut Self {\n self.expect_stdout_not_contains.push(expected.to_string());\n self\n }\n\n /// Verifies that stderr does not contain the given contiguous lines.\n ///\n /// See [`compare`] for supported patterns.\n ///\n ///
\n ///\n /// Prefer [`Execs::with_stdout_data`] where possible.\n /// - `expected` cannot be snapshotted\n /// - The absence of `expected` can either mean success or that the string being looked for\n /// changed.\n ///\n /// To mitigate this, consider either matching this up with\n /// [`Execs::with_stdout_contains`] or replace it\n /// with [`Execs::with_stderr_line_without`].\n ///\n ///
\n pub fn with_stderr_does_not_contain(&mut self, expected: S) -> &mut Self {\n self.expect_stderr_not_contains.push(expected.to_string());\n self\n }\n\n /// Verify that a particular line appears in stderr with and without the\n /// given substrings. Exactly one line must match.\n ///\n /// The substrings are matched as `contains`.\n ///\n ///
\n ///\n /// Prefer [`Execs::with_stdout_data`] where possible.\n /// - `with` cannot be snapshotted\n /// - The absence of `without` can either mean success or that the string being looked for\n /// changed.\n ///\n ///
\n ///\n /// # Example\n ///\n /// ```no_run\n /// use cargo_test_support::execs;\n ///\n /// execs().with_stderr_line_without(\n /// &[\n /// \"[RUNNING] `rustc --crate-name build_script_build\",\n /// \"-C opt-level=3\",\n /// ],\n /// &[\"-C debuginfo\", \"-C incremental\"],\n /// );\n /// ```\n ///\n /// This will check that a build line includes `-C opt-level=3` but does\n /// not contain `-C debuginfo` or `-C incremental`.\n ///\n pub fn with_stderr_line_without(\n &mut self,\n with: &[S],\n without: &[S],\n ) -> &mut Self {\n let with = with.iter().map(|s| s.to_string()).collect();\n let without = without.iter().map(|s| s.to_string()).collect();\n self.expect_stderr_with_without.push((with, without));\n self\n }\n}\n\n/// # Configure the process\nimpl Execs {\n /// Forward subordinate process stdout/stderr to the terminal.\n /// Useful for printf debugging of the tests.\n /// CAUTION: CI will fail if you leave this in your test!\n #[allow(unused)]\n pub fn stream(&mut self) -> &mut Self {\n self.stream_output = true;\n self\n }\n\n pub fn arg>(&mut self, arg: T) -> &mut Self {\n if let Some(ref mut p) = self.process_builder {\n p.arg(arg);\n }\n self\n }\n\n pub fn args>(&mut self, args: &[T]) -> &mut Self {\n if let Some(ref mut p) = self.process_builder {\n p.args(args);\n }\n self\n }\n\n pub fn cwd>(&mut self, path: T) -> &mut Self {\n if let Some(ref mut p) = self.process_builder {\n if let Some(cwd) = p.get_cwd() {\n let new_path = cwd.join(path.as_ref());\n p.cwd(new_path);\n } else {\n p.cwd(path);\n }\n }\n self\n }\n\n pub fn env>(&mut self, key: &str, val: T) -> &mut Self {\n if let Some(ref mut p) = self.process_builder {\n p.env(key, val);\n }\n self\n }\n\n pub fn env_remove(&mut self, key: &str) -> &mut Self {\n if let Some(ref mut p) = self.process_builder {\n p.env_remove(key);\n }\n self\n }\n\n /// Enables nightly features for testing\n ///\n /// The list of reasons should be why nightly cargo is needed. If it is\n /// because of an unstable feature put the name of the feature as the reason,\n /// e.g. `&[\"print-im-a-teapot\"]`\n pub fn masquerade_as_nightly_cargo(&mut self, reasons: &[&str]) -> &mut Self {\n if let Some(ref mut p) = self.process_builder {\n p.masquerade_as_nightly_cargo(reasons);\n }\n self\n }\n\n /// Overrides the crates.io URL for testing.\n ///\n /// Can be used for testing crates-io functionality where alt registries\n /// cannot be used.\n pub fn replace_crates_io(&mut self, url: &Url) -> &mut Self {\n if let Some(ref mut p) = self.process_builder {\n p.env(\"__CARGO_TEST_CRATES_IO_URL_DO_NOT_USE_THIS\", url.as_str());\n }\n self\n }\n\n pub fn overlay_registry(&mut self, url: &Url, path: &str) -> &mut Self {\n if let Some(ref mut p) = self.process_builder {\n let env_value = format!(\"{}={}\", url, path);\n p.env(\n \"__CARGO_TEST_DEPENDENCY_CONFUSION_VULNERABILITY_DO_NOT_USE_THIS\",\n env_value,\n );\n }\n self\n }\n\n pub fn enable_split_debuginfo_packed(&mut self) -> &mut Self {\n self.env(\"CARGO_PROFILE_DEV_SPLIT_DEBUGINFO\", \"packed\")\n .env(\"CARGO_PROFILE_TEST_SPLIT_DEBUGINFO\", \"packed\")\n .env(\"CARGO_PROFILE_RELEASE_SPLIT_DEBUGINFO\", \"packed\")\n .env(\"CARGO_PROFILE_BENCH_SPLIT_DEBUGINFO\", \"packed\");\n self\n }\n\n pub fn enable_mac_dsym(&mut self) -> &mut Self {\n if cfg!(target_os = \"macos\") {\n return self.enable_split_debuginfo_packed();\n }\n self\n }\n}\n\n/// # Run and verify the process\nimpl Execs {\n pub fn exec_with_output(&mut self) -> Result {\n self.ran = true;\n // TODO avoid unwrap\n let p = (&self.process_builder).clone().unwrap();\n p.exec_with_output()\n }\n\n pub fn build_command(&mut self) -> Command {\n self.ran = true;\n // TODO avoid unwrap\n let p = (&self.process_builder).clone().unwrap();\n p.build_command()\n }\n\n #[track_caller]\n pub fn run(&mut self) -> RawOutput {\n self.ran = true;\n let mut p = (&self.process_builder).clone().unwrap();\n if let Some(stdin) = self.expect_stdin.take() {\n p.stdin(stdin);\n }\n\n match self.match_process(&p) {\n Err(e) => panic_error(&format!(\"test failed running {}\", p), e),\n Ok(output) => output,\n }\n }\n\n /// Runs the process, checks the expected output, and returns the first\n /// JSON object on stdout.\n #[track_caller]\n pub fn run_json(&mut self) -> serde_json::Value {\n let output = self.run();\n serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {\n panic!(\n \"\\nfailed to parse JSON: {}\\n\\\n output was:\\n{}\\n\",\n e,\n String::from_utf8_lossy(&output.stdout)\n );\n })\n }\n\n #[track_caller]\n pub fn run_output(&mut self, output: &Output) {\n self.ran = true;\n if let Err(e) = self.match_output(output.status.code(), &output.stdout, &output.stderr) {\n panic_error(\"process did not return the expected result\", e)\n }\n }\n\n #[track_caller]\n fn verify_checks_output(&self, stdout: &[u8], stderr: &[u8]) {\n if self.expect_exit_code.unwrap_or(0) != 0\n && self.expect_stdin.is_none()\n && self.expect_stdout_data.is_none()\n && self.expect_stderr_data.is_none()\n && self.expect_stdout_contains.is_empty()\n && self.expect_stderr_contains.is_empty()\n && self.expect_stdout_not_contains.is_empty()\n && self.expect_stderr_not_contains.is_empty()\n && self.expect_stderr_with_without.is_empty()\n {\n panic!(\n \"`with_status()` is used, but no output is checked.\\n\\\n The test must check the output to ensure the correct error is triggered.\\n\\\n --- stdout\\n{}\\n--- stderr\\n{}\",\n String::from_utf8_lossy(stdout),\n String::from_utf8_lossy(stderr),\n );\n }\n }\n\n #[track_caller]\n fn match_process(&self, process: &ProcessBuilder) -> Result {\n println!(\"running {}\", process);\n let res = if self.stream_output {\n if is_ci() {\n panic!(\"`.stream()` is for local debugging\")\n }\n process.exec_with_streaming(\n &mut |out| {\n println!(\"{}\", out);\n Ok(())\n },\n &mut |err| {\n eprintln!(\"{}\", err);\n Ok(())\n },\n true,\n )\n } else {\n process.exec_with_output()\n };\n\n match res {\n Ok(out) => {\n self.match_output(out.status.code(), &out.stdout, &out.stderr)?;\n return Ok(RawOutput {\n stdout: out.stdout,\n stderr: out.stderr,\n code: out.status.code(),\n });\n }\n Err(e) => {\n if let Some(ProcessError {\n stdout: Some(stdout),\n stderr: Some(stderr),\n code,\n ..\n }) = e.downcast_ref::()\n {\n self.match_output(*code, stdout, stderr)?;\n return Ok(RawOutput {\n stdout: stdout.to_vec(),\n stderr: stderr.to_vec(),\n code: *code,\n });\n }\n bail!(\"could not exec process {}: {:?}\", process, e)\n }\n }\n }\n\n #[track_caller]\n fn match_output(&self, code: Option, stdout: &[u8], stderr: &[u8]) -> Result<()> {\n self.verify_checks_output(stdout, stderr);\n let stdout = std::str::from_utf8(stdout).expect(\"stdout is not utf8\");\n let stderr = std::str::from_utf8(stderr).expect(\"stderr is not utf8\");\n\n match self.expect_exit_code {\n None => {}\n Some(expected) if code == Some(expected) => {}\n Some(expected) => bail!(\n \"process exited with code {} (expected {})\\n--- stdout\\n{}\\n--- stderr\\n{}\",\n code.unwrap_or(-1),\n expected,\n stdout,\n stderr\n ),\n }\n\n if let Some(expect_stdout_data) = &self.expect_stdout_data {\n if let Err(err) = self.assert.try_eq(\n Some(&\"stdout\"),\n stdout.into_data(),\n expect_stdout_data.clone(),\n ) {\n panic!(\"{err}\")\n }\n }\n if let Some(expect_stderr_data) = &self.expect_stderr_data {\n if let Err(err) = self.assert.try_eq(\n Some(&\"stderr\"),\n stderr.into_data(),\n expect_stderr_data.clone(),\n ) {\n panic!(\"{err}\")\n }\n }\n for expect in self.expect_stdout_contains.iter() {\n compare::match_contains(expect, stdout, self.assert.redactions())?;\n }\n for expect in self.expect_stderr_contains.iter() {\n compare::match_contains(expect, stderr, self.assert.redactions())?;\n }\n for expect in self.expect_stdout_not_contains.iter() {\n compare::match_does_not_contain(expect, stdout, self.assert.redactions())?;\n }\n for expect in self.expect_stderr_not_contains.iter() {\n compare::match_does_not_contain(expect, stderr, self.assert.redactions())?;\n }\n for (with, without) in self.expect_stderr_with_without.iter() {\n compare::match_with_without(stderr, with, without, self.assert.redactions())?;\n }\n Ok(())\n }\n}\n\nimpl Drop for Execs {\n fn drop(&mut self) {\n if !self.ran && !std::thread::panicking() {\n panic!(\"forgot to run this command\");\n }\n }\n}\n\n/// Run and verify a process, see [`Execs`]\npub fn execs() -> Execs {\n Execs {\n ran: false,\n process_builder: None,\n expect_stdin: None,\n expect_exit_code: Some(0),\n expect_stdout_data: None,\n expect_stderr_data: None,\n expect_stdout_contains: Vec::new(),\n expect_stderr_contains: Vec::new(),\n expect_stdout_not_contains: Vec::new(),\n expect_stderr_not_contains: Vec::new(),\n expect_stderr_with_without: Vec::new(),\n stream_output: false,\n assert: compare::assert_e2e(),\n }\n}\n\n/// Generate a basic `Cargo.toml`\npub fn basic_manifest(name: &str, version: &str) -> String {\n format!(\n r#\"\n [package]\n name = \"{}\"\n version = \"{}\"\n authors = []\n edition = \"2015\"\n \"#,\n name, version\n )\n}\n\n/// Generate a `Cargo.toml` with the specified `bin.name`\npub fn basic_bin_manifest(name: &str) -> String {\n format!(\n r#\"\n [package]\n\n name = \"{}\"\n version = \"0.5.0\"\n authors = [\"wycats@example.com\"]\n edition = \"2015\"\n\n [[bin]]\n\n name = \"{}\"\n \"#,\n name, name\n )\n}\n\n/// Generate a `Cargo.toml` with the specified `lib.name`\npub fn basic_lib_manifest(name: &str) -> String {\n format!(\n r#\"\n [package]\n\n name = \"{}\"\n version = \"0.5.0\"\n authors = [\"wycats@example.com\"]\n edition = \"2015\"\n\n [lib]\n\n name = \"{}\"\n \"#,\n name, name\n )\n}\n\n/// Gets a valid target spec JSON from rustc.\n///\n/// To avoid any hardcoded value, this fetches `x86_64-unknown-none` target\n/// spec JSON directly from `rustc`, as Cargo shouldn't know the JSON schema.\npub fn target_spec_json() -> &'static str {\n static TARGET_SPEC_JSON: LazyLock = LazyLock::new(|| {\n let json = std::process::Command::new(\"rustc\")\n .env(\"RUSTC_BOOTSTRAP\", \"1\")\n .arg(\"--print\")\n .arg(\"target-spec-json\")\n .arg(\"-Zunstable-options\")\n .arg(\"--target\")\n .arg(\"x86_64-unknown-none\")\n .output()\n .expect(\"rustc --print target-spec-json\")\n .stdout;\n String::from_utf8(json).expect(\"utf8 target spec json\")\n });\n\n TARGET_SPEC_JSON.as_str()\n}\n\nstruct RustcInfo {\n verbose_version: String,\n host: String,\n}\n\nimpl RustcInfo {\n fn new() -> RustcInfo {\n let output = ProcessBuilder::new(\"rustc\")\n .arg(\"-vV\")\n .exec_with_output()\n .expect(\"rustc should exec\");\n let verbose_version = String::from_utf8(output.stdout).expect(\"utf8 output\");\n let host = verbose_version\n .lines()\n .filter_map(|line| line.strip_prefix(\"host: \"))\n .next()\n .expect(\"verbose version has host: field\")\n .to_string();\n RustcInfo {\n verbose_version,\n host,\n }\n }\n}\n\nfn rustc_info() -> &'static RustcInfo {\n static RUSTC_INFO: OnceLock = OnceLock::new();\n RUSTC_INFO.get_or_init(RustcInfo::new)\n}\n\n/// The rustc host such as `x86_64-unknown-linux-gnu`.\npub fn rustc_host() -> &'static str {\n &rustc_info().host\n}\n\n/// The host triple suitable for use in a cargo environment variable (uppercased).\npub fn rustc_host_env() -> String {\n rustc_host().to_uppercase().replace('-', \"_\")\n}\n\npub fn is_nightly() -> bool {\n let vv = &rustc_info().verbose_version;\n // CARGO_TEST_DISABLE_NIGHTLY is set in rust-lang/rust's CI so that all\n // nightly-only tests are disabled there. Otherwise, it could make it\n // difficult to land changes which would need to be made simultaneously in\n // rust-lang/cargo and rust-lan/rust, which isn't possible.\n env::var(\"CARGO_TEST_DISABLE_NIGHTLY\").is_err()\n && (vv.contains(\"-nightly\") || vv.contains(\"-dev\"))\n}\n\n/// Run `$bin` in the test's environment, see [`ProcessBuilder`]\n///\n/// For more on the test environment, see\n/// - [`paths::root`]\n/// - [`TestEnvCommandExt`]\npub fn process>(bin: T) -> ProcessBuilder {\n _process(bin.as_ref())\n}\n\nfn _process(t: &OsStr) -> ProcessBuilder {\n let mut p = ProcessBuilder::new(t);\n p.cwd(&paths::root()).test_env();\n p\n}\n\n/// Enable nightly features for testing\npub trait ChannelChangerCommandExt {\n /// The list of reasons should be why nightly cargo is needed. If it is\n /// because of an unstable feature put the name of the feature as the reason,\n /// e.g. `&[\"print-im-a-teapot\"]`.\n fn masquerade_as_nightly_cargo(self, _reasons: &[&str]) -> Self;\n}\n\nimpl ChannelChangerCommandExt for &mut ProcessBuilder {\n fn masquerade_as_nightly_cargo(self, _reasons: &[&str]) -> Self {\n self.env(\"__CARGO_TEST_CHANNEL_OVERRIDE_DO_NOT_USE_THIS\", \"nightly\")\n }\n}\n\nimpl ChannelChangerCommandExt for snapbox::cmd::Command {\n fn masquerade_as_nightly_cargo(self, _reasons: &[&str]) -> Self {\n self.env(\"__CARGO_TEST_CHANNEL_OVERRIDE_DO_NOT_USE_THIS\", \"nightly\")\n }\n}\n\n/// Establish a process's test environment\npub trait TestEnvCommandExt: Sized {\n fn test_env(mut self) -> Self {\n // In general just clear out all cargo-specific configuration already in the\n // environment. Our tests all assume a \"default configuration\" unless\n // specified otherwise.\n for (k, _v) in env::vars() {\n if k.starts_with(\"CARGO_\") {\n self = self.env_remove(&k);\n }\n }\n if env::var_os(\"RUSTUP_TOOLCHAIN\").is_some() {\n // Override the PATH to avoid executing the rustup wrapper thousands\n // of times. This makes the testsuite run substantially faster.\n static RUSTC_DIR: OnceLock = OnceLock::new();\n let rustc_dir = RUSTC_DIR.get_or_init(|| {\n match ProcessBuilder::new(\"rustup\")\n .args(&[\"which\", \"rustc\"])\n .exec_with_output()\n {\n Ok(output) => {\n let s = std::str::from_utf8(&output.stdout).expect(\"utf8\").trim();\n let mut p = PathBuf::from(s);\n p.pop();\n p\n }\n Err(e) => {\n panic!(\"RUSTUP_TOOLCHAIN was set, but could not run rustup: {}\", e);\n }\n }\n });\n let path = env::var_os(\"PATH\").unwrap_or_default();\n let paths = env::split_paths(&path);\n let new_path =\n env::join_paths(std::iter::once(rustc_dir.clone()).chain(paths)).unwrap();\n self = self.env(\"PATH\", new_path);\n }\n\n self = self\n .current_dir(&paths::root())\n .env(\"HOME\", paths::home())\n .env(\"CARGO_HOME\", paths::cargo_home())\n .env(\"__CARGO_TEST_ROOT\", paths::global_root())\n // Force Cargo to think it's on the stable channel for all tests, this\n // should hopefully not surprise us as we add cargo features over time and\n // cargo rides the trains.\n .env(\"__CARGO_TEST_CHANNEL_OVERRIDE_DO_NOT_USE_THIS\", \"stable\")\n // Keeps cargo within its sandbox.\n .env(\"__CARGO_TEST_DISABLE_GLOBAL_KNOWN_HOST\", \"1\")\n // Set retry sleep to 1 millisecond.\n .env(\"__CARGO_TEST_FIXED_RETRY_SLEEP_MS\", \"1\")\n // Setting this to a large number helps avoid problems with long\n // paths getting trimmed in snapshot tests.\n //\n // When updating this value, keep in mind that the `CARGO_TARGET_DIR`\n // that gets set when Cargo's tests get run in `rust-lang/rust` can\n // easily cause path lengths to exceed 200 characters.\n .env(\"__CARGO_TEST_TTY_WIDTH_DO_NOT_USE_THIS\", \"400\")\n // Incremental generates a huge amount of data per test, which we\n // don't particularly need. Tests that specifically need to check\n // the incremental behavior should turn this back on.\n .env(\"CARGO_INCREMENTAL\", \"0\")\n // Don't read the system git config which is out of our control.\n .env(\"GIT_CONFIG_NOSYSTEM\", \"1\")\n .env_remove(\"__CARGO_DEFAULT_LIB_METADATA\")\n .env_remove(\"ALL_PROXY\")\n .env_remove(\"EMAIL\")\n .env_remove(\"GIT_AUTHOR_EMAIL\")\n .env_remove(\"GIT_AUTHOR_NAME\")\n .env_remove(\"GIT_COMMITTER_EMAIL\")\n .env_remove(\"GIT_COMMITTER_NAME\")\n .env_remove(\"http_proxy\")\n .env_remove(\"HTTPS_PROXY\")\n .env_remove(\"https_proxy\")\n .env_remove(\"MAKEFLAGS\")\n .env_remove(\"MFLAGS\")\n .env_remove(\"MSYSTEM\") // assume cmd.exe everywhere on windows\n .env_remove(\"RUSTC\")\n .env_remove(\"RUST_BACKTRACE\")\n .env_remove(\"RUSTC_WORKSPACE_WRAPPER\")\n .env_remove(\"RUSTC_WRAPPER\")\n .env_remove(\"RUSTDOC\")\n .env_remove(\"RUSTDOCFLAGS\")\n .env_remove(\"RUSTFLAGS\")\n .env_remove(\"SSH_AUTH_SOCK\") // ensure an outer agent is never contacted\n .env_remove(\"USER\") // not set on some rust-lang docker images\n .env_remove(\"XDG_CONFIG_HOME\") // see #2345\n .env_remove(\"OUT_DIR\"); // see #13204\n if cfg!(windows) {\n self = self.env(\"USERPROFILE\", paths::home());\n }\n self\n }\n\n fn current_dir>(self, path: S) -> Self;\n fn env>(self, key: &str, value: S) -> Self;\n fn env_remove(self, key: &str) -> Self;\n}\n\nimpl TestEnvCommandExt for &mut ProcessBuilder {\n fn current_dir>(self, path: S) -> Self {\n let path = path.as_ref();\n self.cwd(path)\n }\n fn env>(self, key: &str, value: S) -> Self {\n self.env(key, value)\n }\n fn env_remove(self, key: &str) -> Self {\n self.env_remove(key)\n }\n}\n\nimpl TestEnvCommandExt for snapbox::cmd::Command {\n fn current_dir>(self, path: S) -> Self {\n self.current_dir(path)\n }\n fn env>(self, key: &str, value: S) -> Self {\n self.env(key, value)\n }\n fn env_remove(self, key: &str) -> Self {\n self.env_remove(key)\n }\n}\n\n/// Add a list of arguments as a line\npub trait ArgLineCommandExt: Sized {\n fn arg_line(mut self, s: &str) -> Self {\n for mut arg in s.split_whitespace() {\n if (arg.starts_with('\"') && arg.ends_with('\"'))\n || (arg.starts_with('\\'') && arg.ends_with('\\''))\n {\n arg = &arg[1..(arg.len() - 1).max(1)];\n } else if arg.contains(&['\"', '\\''][..]) {\n panic!(\"shell-style argument parsing is not supported\")\n }\n self = self.arg(arg);\n }\n self\n }\n\n fn arg>(self, s: S) -> Self;\n}\n\nimpl ArgLineCommandExt for &mut ProcessBuilder {\n fn arg>(self, s: S) -> Self {\n self.arg(s)\n }\n}\n\nimpl ArgLineCommandExt for &mut Execs {\n fn arg>(self, s: S) -> Self {\n self.arg(s)\n }\n}\n\nimpl ArgLineCommandExt for snapbox::cmd::Command {\n fn arg>(self, s: S) -> Self {\n self.arg(s)\n }\n}\n\n/// Run `git $arg_line`, see [`ProcessBuilder`]\npub fn git_process(arg_line: &str) -> ProcessBuilder {\n let mut p = process(\"git\");\n p.arg_line(arg_line);\n p\n}\n\npub fn sleep_ms(ms: u64) {\n ::std::thread::sleep(Duration::from_millis(ms));\n}\n\n/// Returns `true` if the local filesystem has low-resolution mtimes.\npub fn is_coarse_mtime() -> bool {\n // If the filetime crate is being used to emulate HFS then\n // return `true`, without looking at the actual hardware.\n cfg!(emulate_second_only_system) ||\n // This should actually be a test that `$CARGO_TARGET_DIR` is on an HFS\n // filesystem, (or any filesystem with low-resolution mtimes). However,\n // that's tricky to detect, so for now just deal with CI.\n cfg!(target_os = \"macos\") && is_ci()\n}\n\n/// A way for to increase the cut off for all the time based test.\n///\n/// Some CI setups are much slower then the equipment used by Cargo itself.\n/// Architectures that do not have a modern processor, hardware emulation, etc.\npub fn slow_cpu_multiplier(main: u64) -> Duration {\n static SLOW_CPU_MULTIPLIER: OnceLock = OnceLock::new();\n let slow_cpu_multiplier = SLOW_CPU_MULTIPLIER.get_or_init(|| {\n env::var(\"CARGO_TEST_SLOW_CPU_MULTIPLIER\")\n .ok()\n .and_then(|m| m.parse().ok())\n .unwrap_or(1)\n });\n Duration::from_secs(slow_cpu_multiplier * main)\n}\n\n#[cfg(windows)]\npub fn symlink_supported() -> bool {\n if is_ci() {\n // We want to be absolutely sure this runs on CI.\n return true;\n }\n let src = paths::root().join(\"symlink_src\");\n fs::write(&src, \"\").unwrap();\n let dst = paths::root().join(\"symlink_dst\");\n let result = match os::windows::fs::symlink_file(&src, &dst) {\n Ok(_) => {\n fs::remove_file(&dst).unwrap();\n true\n }\n Err(e) => {\n eprintln!(\n \"symlinks not supported: {:?}\\n\\\n Windows 10 users should enable developer mode.\",\n e\n );\n false\n }\n };\n fs::remove_file(&src).unwrap();\n return result;\n}\n\n#[cfg(not(windows))]\npub fn symlink_supported() -> bool {\n true\n}\n\n/// The error message for ENOENT.\npub fn no_such_file_err_msg() -> String {\n std::io::Error::from_raw_os_error(2).to_string()\n}\n\n/// Helper to retry a function `n` times.\n///\n/// The function should return `Some` when it is ready.\n#[track_caller]\npub fn retry(n: u32, mut f: F) -> R\nwhere\n F: FnMut() -> Option,\n{\n let mut count = 0;\n let start = std::time::Instant::now();\n loop {\n if let Some(r) = f() {\n return r;\n }\n count += 1;\n if count > n {\n panic!(\n \"test did not finish within {n} attempts ({:?} total)\",\n start.elapsed()\n );\n }\n sleep_ms(100);\n }\n}\n\n#[test]\n#[should_panic(expected = \"test did not finish\")]\nfn retry_fails() {\n retry(2, || None::<()>);\n}\n\n/// Helper that waits for a thread to finish, up to `n` tenths of a second.\n#[track_caller]\npub fn thread_wait_timeout(n: u32, thread: JoinHandle) -> T {\n retry(n, || thread.is_finished().then_some(()));\n thread.join().unwrap()\n}\n\n/// Helper that runs some function, and waits up to `n` tenths of a second for\n/// it to finish.\n#[track_caller]\npub fn threaded_timeout(n: u32, f: F) -> R\nwhere\n F: FnOnce() -> R + Send + 'static,\n R: Send + 'static,\n{\n let thread = std::thread::spawn(|| f());\n thread_wait_timeout(n, thread)\n}\n\n// Helper for testing dep-info files in the fingerprint dir.\n#[track_caller]\npub fn assert_deps(project: &Project, fingerprint: &str, test_cb: impl Fn(&Path, &[(u8, &str)])) {\n let mut files = project\n .glob(fingerprint)\n .map(|f| f.expect(\"unwrap glob result\"))\n // Filter out `.json` entries.\n .filter(|f| f.extension().is_none());\n let info_path = files\n .next()\n .unwrap_or_else(|| panic!(\"expected 1 dep-info file at {}, found 0\", fingerprint));\n assert!(files.next().is_none(), \"expected only 1 dep-info file\");\n let dep_info = fs::read(&info_path).unwrap();\n let dep_info = &mut &dep_info[..];\n\n // Consume the magic marker and version. Here they don't really matter.\n read_usize(dep_info);\n read_u8(dep_info);\n read_u8(dep_info);\n\n let deps = (0..read_usize(dep_info))\n .map(|_| {\n let ty = read_u8(dep_info);\n let path = std::str::from_utf8(read_bytes(dep_info)).unwrap();\n let checksum_present = read_bool(dep_info);\n if checksum_present {\n // Read out the checksum info without using it\n let _file_len = read_u64(dep_info);\n let _checksum = read_bytes(dep_info);\n }\n (ty, path)\n })\n .collect::>();\n test_cb(&info_path, &deps);\n\n fn read_usize(bytes: &mut &[u8]) -> usize {\n let ret = &bytes[..4];\n *bytes = &bytes[4..];\n\n u32::from_le_bytes(ret.try_into().unwrap()) as usize\n }\n\n fn read_u8(bytes: &mut &[u8]) -> u8 {\n let ret = bytes[0];\n *bytes = &bytes[1..];\n ret\n }\n\n fn read_bool(bytes: &mut &[u8]) -> bool {\n read_u8(bytes) != 0\n }\n\n fn read_u64(bytes: &mut &[u8]) -> u64 {\n let ret = &bytes[..8];\n *bytes = &bytes[8..];\n\n u64::from_le_bytes(ret.try_into().unwrap())\n }\n\n fn read_bytes<'a>(bytes: &mut &'a [u8]) -> &'a [u8] {\n let n = read_usize(bytes);\n let ret = &bytes[..n];\n *bytes = &bytes[n..];\n ret\n }\n}\n\n#[track_caller]\npub fn assert_deps_contains(project: &Project, fingerprint: &str, expected: &[(u8, &str)]) {\n assert_deps(project, fingerprint, |info_path, entries| {\n for (e_kind, e_path) in expected {\n let pattern = glob::Pattern::new(e_path).unwrap();\n let count = entries\n .iter()\n .filter(|(kind, path)| kind == e_kind && pattern.matches(path))\n .count();\n if count != 1 {\n panic!(\n \"Expected 1 match of {} {} in {:?}, got {}:\\n{:#?}\",\n e_kind, e_path, info_path, count, entries\n );\n }\n }\n })\n}\n\n#[track_caller]\npub fn assert_deterministic_mtime(path: impl AsRef) {\n // Hardcoded value be removed once alexcrichton/tar-rs#420 is merged and released.\n // See also rust-lang/cargo#16237\n const DETERMINISTIC_TIMESTAMP: u64 = 1153704088;\n\n let path = path.as_ref();\n let mtime = path.metadata().unwrap().modified().unwrap();\n let timestamp = mtime\n .duration_since(std::time::UNIX_EPOCH)\n .unwrap()\n .as_secs();\n assert_eq!(\n timestamp, DETERMINISTIC_TIMESTAMP,\n \"expected deterministic mtime for {path:?}, got {timestamp}\"\n );\n}\n" }, { "path": "crates/cargo-test-support/src/paths.rs", "content": "//! Access common paths and manipulate the filesystem\n\nuse filetime::FileTime;\nuse itertools::Itertools;\nuse walkdir::WalkDir;\n\nuse std::cell::RefCell;\nuse std::fs;\nuse std::io::{self, ErrorKind};\nuse std::path::{Path, PathBuf};\nuse std::process::Command;\nuse std::sync::Mutex;\nuse std::sync::OnceLock;\nuse std::sync::atomic::{AtomicUsize, Ordering};\n\nuse crate::compare::assert_e2e;\nuse crate::compare::match_contains;\n\nstatic CARGO_INTEGRATION_TEST_DIR: &str = \"cit\";\n\nstatic GLOBAL_ROOT: OnceLock>> = OnceLock::new();\n\nfn set_global_root(tmp_dir: &'static str) {\n let mut lock = GLOBAL_ROOT\n .get_or_init(|| Default::default())\n .lock()\n .unwrap();\n if lock.is_none() {\n let mut root = PathBuf::from(tmp_dir);\n root.push(CARGO_INTEGRATION_TEST_DIR);\n *lock = Some(root);\n }\n}\n\n/// Path to the parent directory of all test [`root`]s\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit`\npub fn global_root() -> PathBuf {\n let lock = GLOBAL_ROOT\n .get_or_init(|| Default::default())\n .lock()\n .unwrap();\n match lock.as_ref() {\n Some(p) => p.clone(),\n None => unreachable!(\"GLOBAL_ROOT not set yet\"),\n }\n}\n\n// We need to give each test a unique id. The test name serve this\n// purpose. We are able to get the test name by having the `cargo-test-macro`\n// crate automatically insert an init function for each test that sets the\n// test name in a thread local variable.\nthread_local! {\n static TEST_ID: RefCell> = const { RefCell::new(None) };\n static TEST_DIR: RefCell> = const { RefCell::new(None) };\n}\n\n/// See [`init_root`]\npub struct TestIdGuard {\n _private: (),\n}\n\n/// For test harnesses like [`crate::cargo_test`]\npub fn init_root(tmp_dir: &'static str, test_dir: PathBuf) -> TestIdGuard {\n static NEXT_ID: AtomicUsize = AtomicUsize::new(0);\n let id = NEXT_ID.fetch_add(1, Ordering::SeqCst);\n TEST_ID.with(|n| *n.borrow_mut() = Some(id));\n if cfg!(windows) {\n // Due to path-length limits, Windows doesn't use the full test name.\n TEST_DIR.with(|n| *n.borrow_mut() = Some(PathBuf::from(format!(\"t{id}\"))));\n } else {\n TEST_DIR.with(|n| *n.borrow_mut() = Some(test_dir));\n }\n let guard = TestIdGuard { _private: () };\n set_global_root(tmp_dir);\n let r = root();\n r.rm_rf();\n r.mkdir_p();\n #[cfg(not(windows))]\n if id == 0 {\n // Create a symlink from `t0` to the first test to make it easier to\n // find and reuse when running a single test.\n use crate::SymlinkBuilder;\n let mut alias = global_root();\n alias.push(\"t0\");\n alias.rm_rf();\n SymlinkBuilder::new_dir(r, alias).mk();\n }\n guard\n}\n\nimpl Drop for TestIdGuard {\n fn drop(&mut self) {\n TEST_ID.with(|n| *n.borrow_mut() = None);\n TEST_DIR.with(|n| *n.borrow_mut() = None);\n }\n}\n\n/// Path to the test's filesystem scratchpad\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit////`\n/// or `$CARGO_TARGET_TMPDIR/cit/t0` on Windows\npub fn root() -> PathBuf {\n let test_dir = TEST_DIR.with(|n| {\n n.borrow().clone().expect(\n \"Tests must use the `#[cargo_test]` attribute in \\\n order to be able to use the crate root.\",\n )\n });\n let mut root = global_root();\n root.push(&test_dir);\n root\n}\n/// Path to the current test's `$HOME`\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/home`\npub fn home() -> PathBuf {\n let mut path = root();\n path.push(\"home\");\n path.mkdir_p();\n path\n}\n\n/// Path to the current test's `$CARGO_HOME`\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/home/.cargo`\npub fn cargo_home() -> PathBuf {\n home().join(\".cargo\")\n}\n\n/// Path to the current test's `$CARGO_LOG`\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/home/.cargo/log`\npub fn log_dir() -> PathBuf {\n cargo_home().join(\"log\")\n}\n\n/// Path to the current test's `$CARGO_LOG` file\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/home/.cargo/log/.jsonl`\n///\n/// This also asserts the number of log files is exactly the same as `idx + 1`.\npub fn log_file(idx: usize) -> PathBuf {\n let log_dir = log_dir();\n\n let entries = std::fs::read_dir(&log_dir).unwrap();\n let mut log_files: Vec<_> = entries\n .filter_map(Result::ok)\n .filter(|e| e.path().extension().and_then(|s| s.to_str()) == Some(\"jsonl\"))\n .collect();\n\n // Sort them to get chronological order\n log_files.sort_unstable_by(|a, b| a.file_name().to_str().cmp(&b.file_name().to_str()));\n\n assert_eq!(\n idx + 1,\n log_files.len(),\n \"unexpected number of log files: {}, expected {}\",\n log_files.len(),\n idx + 1\n );\n\n log_files[idx].path()\n}\n\n/// Common path and file operations\npub trait CargoPathExt {\n fn to_url(&self) -> url::Url;\n\n fn rm_rf(&self);\n fn mkdir_p(&self);\n\n /// Returns a list of all files and directories underneath the given\n /// directory, recursively, including the starting path.\n fn ls_r(&self) -> Vec;\n\n fn move_into_the_past(&self) {\n self.move_in_time(|sec, nsec| (sec - 3600, nsec))\n }\n\n fn move_into_the_future(&self) {\n self.move_in_time(|sec, nsec| (sec + 3600, nsec))\n }\n\n fn move_in_time(&self, travel_amount: F)\n where\n F: Fn(i64, u32) -> (i64, u32);\n\n fn assert_build_dir_layout(&self, expected: impl snapbox::IntoData);\n\n fn assert_dir_layout(&self, expected: impl snapbox::IntoData, ignored_path_patterns: &[String]);\n}\n\nimpl CargoPathExt for Path {\n fn to_url(&self) -> url::Url {\n url::Url::from_file_path(self).ok().unwrap()\n }\n\n fn rm_rf(&self) {\n let meta = match self.symlink_metadata() {\n Ok(meta) => meta,\n Err(e) => {\n if e.kind() == ErrorKind::NotFound {\n return;\n }\n panic!(\"failed to remove {:?}, could not read: {:?}\", self, e);\n }\n };\n // There is a race condition between fetching the metadata and\n // actually performing the removal, but we don't care all that much\n // for our tests.\n if meta.is_dir() {\n if let Err(e) = fs::remove_dir_all(self) {\n panic!(\"failed to remove {:?}: {:?}\", self, e)\n }\n } else if let Err(e) = fs::remove_file(self) {\n panic!(\"failed to remove {:?}: {:?}\", self, e)\n }\n }\n\n fn mkdir_p(&self) {\n fs::create_dir_all(self)\n .unwrap_or_else(|e| panic!(\"failed to mkdir_p {}: {}\", self.display(), e))\n }\n\n fn ls_r(&self) -> Vec {\n walkdir::WalkDir::new(self)\n .sort_by_file_name()\n .into_iter()\n .filter_map(|e| e.map(|e| e.path().to_owned()).ok())\n .collect()\n }\n\n fn move_in_time(&self, travel_amount: F)\n where\n F: Fn(i64, u32) -> (i64, u32),\n {\n if self.is_file() {\n time_travel(self, &travel_amount);\n } else {\n recurse(self, &self.join(\"target\"), &travel_amount);\n }\n\n fn recurse(p: &Path, bad: &Path, travel_amount: &F)\n where\n F: Fn(i64, u32) -> (i64, u32),\n {\n if p.is_file() {\n time_travel(p, travel_amount)\n } else if !p.starts_with(bad) {\n for f in t!(fs::read_dir(p)) {\n let f = t!(f).path();\n recurse(&f, bad, travel_amount);\n }\n }\n }\n\n fn time_travel(path: &Path, travel_amount: &F)\n where\n F: Fn(i64, u32) -> (i64, u32),\n {\n let stat = t!(path.symlink_metadata());\n\n let mtime = FileTime::from_last_modification_time(&stat);\n\n let (sec, nsec) = travel_amount(mtime.unix_seconds(), mtime.nanoseconds());\n let newtime = FileTime::from_unix_time(sec, nsec);\n\n // Sadly change_file_times has a failure mode where a readonly file\n // cannot have its times changed on windows.\n do_op(path, \"set file times\", |path| {\n filetime::set_file_times(path, newtime, newtime)\n });\n }\n }\n\n #[track_caller]\n fn assert_build_dir_layout(&self, expected: impl snapbox::IntoData) {\n // We call `unordered()` here to because the build-dir has some scenarios that make\n // consistent ordering not possible.\n // Notably:\n // 1. Binaries with `.exe` on Windows causing the ordering to change with the dep-info `.d`\n // file.\n // 2. Directories with hashes are often reordered differently by platform.\n self.assert_dir_layout(expected.unordered(), &build_dir_ignored_path_patterns());\n }\n\n #[track_caller]\n fn assert_dir_layout(\n &self,\n expected: impl snapbox::IntoData,\n ignored_path_patterns: &[String],\n ) {\n let assert = assert_e2e();\n let actual = WalkDir::new(self)\n .sort_by_file_name()\n .into_iter()\n .filter_map(|e| e.ok())\n .filter(|e| e.file_type().is_file())\n .map(|e| e.path().to_string_lossy().into_owned())\n .filter(|file| {\n for ignored in ignored_path_patterns {\n if match_contains(&ignored, file, &assert.redactions()).is_ok() {\n return false;\n }\n }\n return true;\n })\n .join(\"\\n\");\n\n assert.eq(format!(\"{actual}\\n\"), expected);\n }\n}\n\nimpl CargoPathExt for PathBuf {\n fn to_url(&self) -> url::Url {\n self.as_path().to_url()\n }\n\n fn rm_rf(&self) {\n self.as_path().rm_rf()\n }\n fn mkdir_p(&self) {\n self.as_path().mkdir_p()\n }\n\n fn ls_r(&self) -> Vec {\n self.as_path().ls_r()\n }\n\n fn move_in_time(&self, travel_amount: F)\n where\n F: Fn(i64, u32) -> (i64, u32),\n {\n self.as_path().move_in_time(travel_amount)\n }\n\n #[track_caller]\n fn assert_build_dir_layout(&self, expected: impl snapbox::IntoData) {\n self.as_path().assert_build_dir_layout(expected);\n }\n\n #[track_caller]\n fn assert_dir_layout(\n &self,\n expected: impl snapbox::IntoData,\n ignored_path_patterns: &[String],\n ) {\n self.as_path()\n .assert_dir_layout(expected, ignored_path_patterns);\n }\n}\n\nfn do_op(path: &Path, desc: &str, mut f: F)\nwhere\n F: FnMut(&Path) -> io::Result<()>,\n{\n match f(path) {\n Ok(()) => {}\n Err(ref e) if e.kind() == ErrorKind::PermissionDenied => {\n let mut p = t!(path.metadata()).permissions();\n p.set_readonly(false);\n t!(fs::set_permissions(path, p));\n\n // Unix also requires the parent to not be readonly for example when\n // removing files\n let parent = path.parent().unwrap();\n let mut p = t!(parent.metadata()).permissions();\n p.set_readonly(false);\n t!(fs::set_permissions(parent, p));\n\n f(path).unwrap_or_else(|e| {\n panic!(\"failed to {} {}: {}\", desc, path.display(), e);\n })\n }\n Err(e) => {\n panic!(\"failed to {} {}: {}\", desc, path.display(), e);\n }\n }\n}\n\n/// The paths to ignore when [`CargoPathExt::assert_build_dir_layout`] is called\nfn build_dir_ignored_path_patterns() -> Vec {\n vec![\n // Ignore MacOS debug symbols as there are many files/directories that would clutter up\n // tests few not a lot of benefit.\n \"[..].dSYM/[..]\",\n // Ignore Windows debug symbols files (.pdb)\n \"[..].pdb\",\n ]\n .into_iter()\n .map(ToString::to_string)\n .collect()\n}\n\n/// Get the filename for a library.\n///\n/// `kind` should be one of:\n/// - `lib`\n/// - `rlib`\n/// - `staticlib`\n/// - `dylib`\n/// - `proc-macro`\n///\n/// # Examples\n/// ```\n/// # use cargo_test_support::paths::get_lib_filename;\n/// get_lib_filename(\"foo\", \"dylib\");\n/// ```\n/// would return:\n/// - macOS: `\"libfoo.dylib\"`\n/// - Windows: `\"foo.dll\"`\n/// - Unix: `\"libfoo.so\"`\npub fn get_lib_filename(name: &str, kind: &str) -> String {\n let prefix = get_lib_prefix(kind);\n let extension = get_lib_extension(kind);\n format!(\"{}{}.{}\", prefix, name, extension)\n}\n\n/// See [`get_lib_filename`] for more details\npub fn get_lib_prefix(kind: &str) -> &str {\n match kind {\n \"lib\" | \"rlib\" => \"lib\",\n \"staticlib\" | \"dylib\" | \"proc-macro\" => {\n if cfg!(windows) {\n \"\"\n } else {\n \"lib\"\n }\n }\n _ => unreachable!(),\n }\n}\n\n/// See [`get_lib_filename`] for more details\npub fn get_lib_extension(kind: &str) -> &str {\n match kind {\n \"lib\" | \"rlib\" => \"rlib\",\n \"staticlib\" => {\n if cfg!(windows) {\n \"lib\"\n } else {\n \"a\"\n }\n }\n \"dylib\" | \"proc-macro\" => {\n if cfg!(windows) {\n \"dll\"\n } else if cfg!(target_os = \"macos\") {\n \"dylib\"\n } else {\n \"so\"\n }\n }\n _ => unreachable!(),\n }\n}\n\n/// Path to `rustc`s sysroot\npub fn sysroot() -> String {\n let output = Command::new(\"rustc\")\n .arg(\"--print=sysroot\")\n .output()\n .expect(\"rustc to run\");\n assert!(output.status.success());\n let sysroot = String::from_utf8(output.stdout).unwrap();\n sysroot.trim().to_string()\n}\n\n/// Returns true if names such as aux.* are allowed.\n///\n/// Traditionally, Windows did not allow a set of file names (see `is_windows_reserved`\n/// for a list). More recent versions of Windows have relaxed this restriction. This test\n/// determines whether we are running in a mode that allows Windows reserved names.\n#[cfg(windows)]\npub fn windows_reserved_names_are_allowed() -> bool {\n use std::ffi::OsStr;\n use std::os::windows::ffi::OsStrExt;\n use std::ptr;\n use windows_sys::Win32::Storage::FileSystem::GetFullPathNameW;\n\n let test_file_name: Vec<_> = OsStr::new(\"aux.rs\").encode_wide().chain([0]).collect();\n\n let buffer_length =\n unsafe { GetFullPathNameW(test_file_name.as_ptr(), 0, ptr::null_mut(), ptr::null_mut()) };\n\n if buffer_length == 0 {\n // This means the call failed, so we'll conservatively assume reserved names are not allowed.\n return false;\n }\n\n let mut buffer = vec![0u16; buffer_length as usize];\n\n let result = unsafe {\n GetFullPathNameW(\n test_file_name.as_ptr(),\n buffer_length,\n buffer.as_mut_ptr(),\n ptr::null_mut(),\n )\n };\n\n if result == 0 {\n // Once again, conservatively assume reserved names are not allowed if the\n // GetFullPathNameW call failed.\n return false;\n }\n\n // Under the old rules, a file name like aux.rs would get converted into \\\\.\\aux, so\n // we detect this case by checking if the string starts with \\\\.\\\n //\n // Otherwise, the filename will be something like C:\\Users\\Foo\\Documents\\aux.rs\n let prefix: Vec<_> = OsStr::new(\"\\\\\\\\.\\\\\").encode_wide().collect();\n if buffer.starts_with(&prefix) {\n false\n } else {\n true\n }\n}\n\n/// This takes the test location (std::file!() should be passed) and the test name\n/// and outputs the location the test should be places in, inside of `target/tmp/cit`\n///\n/// `path: tests/testsuite/workspaces.rs`\n/// `name: `workspace_in_git\n/// `output: \"testsuite/workspaces/workspace_in_git`\npub fn test_dir(path: &str, name: &str) -> std::path::PathBuf {\n let test_dir: std::path::PathBuf = std::path::PathBuf::from(path)\n .components()\n // Trim .rs from any files\n .map(|c| c.as_os_str().to_str().unwrap().trim_end_matches(\".rs\"))\n // We only want to take once we have reached `tests` or `src`. This helps when in a\n // workspace: `workspace/more/src/...` would result in `src/...`\n .skip_while(|c| c != &\"tests\" && c != &\"src\")\n // We want to skip \"tests\" since it is taken in `skip_while`.\n // \"src\" is fine since you could have test in \"src\" named the same as one in \"tests\"\n // Skip \"mod\" since `snapbox` tests have a folder per test not a file and the files\n // are named \"mod.rs\"\n .filter(|c| c != &\"tests\" && c != &\"mod\")\n .collect();\n test_dir.join(name)\n}\n" }, { "path": "crates/cargo-test-support/src/publish.rs", "content": "//! Helpers for testing `cargo package` / `cargo publish`\n//!\n//! # Example\n//!\n//! ```no_run\n//! # use cargo_test_support::registry::RegistryBuilder;\n//! # use cargo_test_support::publish::validate_upload;\n//! # use cargo_test_support::project;\n//! validate_upload(\n//! r#\"\n//! {\n//! \"authors\": [],\n//! \"badges\": {},\n//! \"categories\": [],\n//! \"deps\": [],\n//! \"description\": \"foo\",\n//! \"documentation\": null,\n//! \"features\": {},\n//! \"homepage\": null,\n//! \"keywords\": [],\n//! \"license\": \"MIT\",\n//! \"license_file\": null,\n//! \"links\": null,\n//! \"name\": \"foo\",\n//! \"readme\": null,\n//! \"readme_file\": null,\n//! \"repository\": null,\n//! \"rust_version\": null,\n//! \"vers\": \"0.0.1\"\n//! }\n//! \"#,\n//! \"foo-0.0.1.crate\",\n//! &[\"Cargo.lock\", \"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\"],\n//! );\n//! ```\n\nuse crate::compare::InMemoryDir;\nuse crate::registry::{self, FeatureMap, alt_api_path};\nuse flate2::read::GzDecoder;\nuse snapbox::prelude::*;\nuse std::collections::HashSet;\nuse std::fs;\nuse std::fs::File;\nuse std::io::{self, SeekFrom, prelude::*};\nuse std::path::Path;\nuse tar::Archive;\n\nfn read_le_u32(mut reader: R) -> io::Result\nwhere\n R: Read,\n{\n let mut buf = [0; 4];\n reader.read_exact(&mut buf)?;\n Ok(u32::from_le_bytes(buf))\n}\n\n/// Check the `cargo publish` API call\n#[track_caller]\npub fn validate_upload(expected_json: &str, expected_crate_name: &str, expected_files: &[&str]) {\n let new_path = registry::api_path().join(\"api/v1/crates/new\");\n _validate_upload(\n &new_path,\n expected_json,\n expected_crate_name,\n expected_files,\n (),\n );\n}\n\n/// Check the `cargo publish` API call, with file contents\n#[track_caller]\npub fn validate_upload_with_contents(\n expected_json: &str,\n expected_crate_name: &str,\n expected_files: &[&str],\n expected_contents: impl Into,\n) {\n let new_path = registry::api_path().join(\"api/v1/crates/new\");\n _validate_upload(\n &new_path,\n expected_json,\n expected_crate_name,\n expected_files,\n expected_contents,\n );\n}\n\n/// Check the `cargo publish` API call to the alternative test registry\n#[track_caller]\npub fn validate_alt_upload(\n expected_json: &str,\n expected_crate_name: &str,\n expected_files: &[&str],\n) {\n let new_path = alt_api_path().join(\"api/v1/crates/new\");\n _validate_upload(\n &new_path,\n expected_json,\n expected_crate_name,\n expected_files,\n (),\n );\n}\n\n#[track_caller]\nfn _validate_upload(\n new_path: &Path,\n expected_json: &str,\n expected_crate_name: &str,\n expected_files: &[&str],\n expected_contents: impl Into,\n) {\n let (actual_json, krate_bytes) = read_new_post(new_path);\n\n snapbox::assert_data_eq!(actual_json, expected_json.is_json());\n\n // Verify the tarball.\n validate_crate_contents(\n &krate_bytes[..],\n expected_crate_name,\n expected_files,\n expected_contents,\n );\n}\n\n#[track_caller]\nfn read_new_post(new_path: &Path) -> (Vec, Vec) {\n let mut f = File::open(new_path).unwrap();\n\n // 32-bit little-endian integer of length of JSON data.\n let json_sz = read_le_u32(&mut f).expect(\"read json length\");\n let mut json_bytes = vec![0; json_sz as usize];\n f.read_exact(&mut json_bytes).expect(\"read JSON data\");\n\n // 32-bit little-endian integer of length of crate file.\n let crate_sz = read_le_u32(&mut f).expect(\"read crate length\");\n let mut krate_bytes = vec![0; crate_sz as usize];\n f.read_exact(&mut krate_bytes).expect(\"read crate data\");\n\n // Check at end.\n let current = f.seek(SeekFrom::Current(0)).unwrap();\n assert_eq!(f.seek(SeekFrom::End(0)).unwrap(), current);\n\n (json_bytes, krate_bytes)\n}\n\n/// Checks the contents of a `.crate` file.\n///\n/// - `expected_crate_name` should be something like `foo-0.0.1.crate`.\n/// - `expected_files` should be a complete list of files in the crate\n/// (relative to `expected_crate_name`).\n/// - `expected_contents` should be a list of `(file_name, contents)` tuples\n/// to validate the contents of the given file. Only the listed files will\n/// be checked (others will be ignored).\n#[track_caller]\npub fn validate_crate_contents(\n reader: impl Read,\n expected_crate_name: &str,\n expected_files: &[&str],\n expected_contents: impl Into,\n) {\n let expected_contents = expected_contents.into();\n validate_crate_contents_(\n reader,\n expected_crate_name,\n expected_files,\n expected_contents,\n )\n}\n\n#[track_caller]\nfn validate_crate_contents_(\n reader: impl Read,\n expected_crate_name: &str,\n expected_files: &[&str],\n expected_contents: InMemoryDir,\n) {\n let mut rdr = GzDecoder::new(reader);\n snapbox::assert_data_eq!(rdr.header().unwrap().filename().unwrap(), {\n let expected: snapbox::Data = expected_crate_name.into();\n expected.raw()\n });\n\n let mut contents = Vec::new();\n rdr.read_to_end(&mut contents).unwrap();\n let mut ar = Archive::new(&contents[..]);\n let base_crate_name = Path::new(\n expected_crate_name\n .strip_suffix(\".crate\")\n .expect(\"must end with .crate\"),\n );\n let actual_contents: InMemoryDir = ar\n .entries()\n .unwrap()\n .map(|entry| {\n let mut entry = entry.unwrap();\n let name = entry\n .path()\n .unwrap()\n .strip_prefix(base_crate_name)\n .unwrap()\n .to_owned();\n let mut contents = String::new();\n entry.read_to_string(&mut contents).unwrap();\n (name, contents)\n })\n .collect();\n let actual_files: HashSet<&Path> = actual_contents.paths().collect();\n let expected_files: HashSet<&Path> =\n expected_files.iter().map(|name| Path::new(name)).collect();\n let missing: Vec<&&Path> = expected_files.difference(&actual_files).collect();\n let extra: Vec<&&Path> = actual_files.difference(&expected_files).collect();\n if !missing.is_empty() || !extra.is_empty() {\n panic!(\n \"uploaded archive does not match.\\nMissing: {:?}\\nExtra: {:?}\\n\",\n missing, extra\n );\n }\n actual_contents.assert_contains(&expected_contents);\n}\n\npub(crate) fn create_index_line(\n name: serde_json::Value,\n vers: &str,\n deps: Vec,\n cksum: &str,\n features: crate::registry::FeatureMap,\n yanked: bool,\n links: Option,\n rust_version: Option<&str>,\n pubtime: Option<&str>,\n v: Option,\n) -> String {\n // This emulates what crates.io does to retain backwards compatibility.\n let (features, features2) = split_index_features(features.clone());\n let mut json = serde_json::json!({\n \"name\": name,\n \"vers\": vers,\n \"deps\": deps,\n \"cksum\": cksum,\n \"features\": features,\n \"yanked\": yanked,\n \"links\": links,\n });\n if let Some(f2) = &features2 {\n json[\"features2\"] = serde_json::json!(f2);\n json[\"v\"] = serde_json::json!(2);\n }\n if let Some(v) = v {\n json[\"v\"] = serde_json::json!(v);\n }\n if let Some(rust_version) = rust_version {\n json[\"rust_version\"] = serde_json::json!(rust_version);\n }\n if let Some(pubtime) = pubtime {\n json[\"pubtime\"] = serde_json::json!(pubtime);\n }\n\n json.to_string()\n}\n\npub(crate) fn write_to_index(registry_path: &Path, name: &str, line: String, local: bool) {\n let file = cargo_util::registry::make_dep_path(name, false);\n\n // Write file/line in the index.\n let dst = if local {\n registry_path.join(\"index\").join(&file)\n } else {\n registry_path.join(&file)\n };\n let prev = fs::read_to_string(&dst).unwrap_or_default();\n t!(fs::create_dir_all(dst.parent().unwrap()));\n t!(fs::write(&dst, prev + &line[..] + \"\\n\"));\n\n // Add the new file to the index.\n if !local {\n let repo = t!(git2::Repository::open(®istry_path));\n let mut index = t!(repo.index());\n t!(index.add_path(Path::new(&file)));\n t!(index.write());\n let id = t!(index.write_tree());\n\n // Commit this change.\n let tree = t!(repo.find_tree(id));\n let sig = t!(repo.signature());\n let parent = t!(repo.refname_to_id(\"refs/heads/master\"));\n let parent = t!(repo.find_commit(parent));\n t!(repo.commit(\n Some(\"HEAD\"),\n &sig,\n &sig,\n \"Another commit\",\n &tree,\n &[&parent]\n ));\n }\n}\n\nfn split_index_features(mut features: FeatureMap) -> (FeatureMap, Option) {\n let mut features2 = FeatureMap::new();\n for (feat, values) in features.iter_mut() {\n if values\n .iter()\n .any(|value| value.starts_with(\"dep:\") || value.contains(\"?/\"))\n {\n let new_values = std::mem::take(values);\n features2.insert(feat.clone(), new_values);\n }\n }\n if features2.is_empty() {\n (features, None)\n } else {\n (features, Some(features2))\n }\n}\n" }, { "path": "crates/cargo-test-support/src/registry.rs", "content": "//! Interact with the [`TestRegistry`]\n//!\n//! # Example\n//!\n//! ```no_run\n//! use cargo_test_support::registry::Package;\n//! use cargo_test_support::project;\n//! use cargo_test_support::str;\n//!\n//! // Publish package \"a\" depending on \"b\".\n//! Package::new(\"a\", \"1.0.0\")\n//! .dep(\"b\", \"1.0.0\")\n//! .file(\"src/lib.rs\", r#\"\n//! extern crate b;\n//! pub fn f() -> i32 { b::f() * 2 }\n//! \"#)\n//! .publish();\n//!\n//! // Publish package \"b\".\n//! Package::new(\"b\", \"1.0.0\")\n//! .file(\"src/lib.rs\", r#\"\n//! pub fn f() -> i32 { 12 }\n//! \"#)\n//! .publish();\n//!\n//! // Create a project that uses package \"a\".\n//! let p = project()\n//! .file(\"Cargo.toml\", r#\"\n//! [package]\n//! name = \"foo\"\n//! version = \"0.0.1\"\n//!\n//! [dependencies]\n//! a = \"1.0\"\n//! \"#)\n//! .file(\"src/main.rs\", r#\"\n//! extern crate a;\n//! fn main() { println!(\"{}\", a::f()); }\n//! \"#)\n//! .build();\n//!\n//! // p.cargo(\"run\").with_stdout_data(str![\"24\"]).run();\n//! ```\n\nuse crate::git::repo;\nuse crate::paths;\nuse crate::publish::{create_index_line, write_to_index};\nuse cargo_util::Sha256;\nuse cargo_util::paths::append;\nuse flate2::Compression;\nuse flate2::write::GzEncoder;\nuse pasetors::keys::{AsymmetricPublicKey, AsymmetricSecretKey};\nuse pasetors::paserk::FormatAsPaserk;\nuse pasetors::token::UntrustedToken;\nuse std::collections::{BTreeMap, HashMap};\nuse std::fmt;\nuse std::fs::{self, File};\nuse std::io::{BufRead, BufReader, Read, Write};\nuse std::net::{SocketAddr, TcpListener, TcpStream};\nuse std::path::{Path, PathBuf};\nuse std::thread::{self, JoinHandle};\nuse tar::{Builder, Header};\nuse time::format_description::well_known::Rfc3339;\nuse time::{Duration, OffsetDateTime};\nuse url::Url;\n\n/// Path to the local index for pseudo-crates.io.\n///\n/// This is a Git repo\n/// initialized with a `config.json` file pointing to `dl_path` for downloads\n/// and `api_path` for uploads.\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/registry`\npub fn registry_path() -> PathBuf {\n generate_path(\"registry\")\n}\n\n/// Path to the local web API uploads\n///\n/// Cargo will place the contents of a web API\n/// request here. For example, `api/v1/crates/new` is the result of publishing a crate.\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/api`\npub fn api_path() -> PathBuf {\n generate_path(\"api\")\n}\n\n/// Path to download `.crate` files using the web API endpoint.\n///\n/// Crates\n/// should be organized as `{name}/{version}/download` to match the web API\n/// endpoint. This is rarely used and must be manually set up.\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/dl`\npub fn dl_path() -> PathBuf {\n generate_path(\"dl\")\n}\n\n/// Path to the alternative-registry version of [`registry_path`]\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/alternative-registry`\npub fn alt_registry_path() -> PathBuf {\n generate_path(\"alternative-registry\")\n}\n\n/// URL to the alternative-registry version of `registry_url`\nfn alt_registry_url() -> Url {\n generate_url(\"alternative-registry\")\n}\n\n/// Path to the alternative-registry version of [`dl_path`]\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/alternative-dl`\npub fn alt_dl_path() -> PathBuf {\n generate_path(\"alternative-dl\")\n}\n\n/// Path to the alternative-registry version of [`api_path`]\n///\n/// ex: `$CARGO_TARGET_TMPDIR/cit/t0/alternative-api`\npub fn alt_api_path() -> PathBuf {\n generate_path(\"alternative-api\")\n}\n\nfn generate_path(name: &str) -> PathBuf {\n paths::root().join(name)\n}\nfn generate_url(name: &str) -> Url {\n Url::from_file_path(generate_path(name)).ok().unwrap()\n}\n\n/// Auth-token for publishing, see [`RegistryBuilder::token`]\n#[derive(Clone)]\npub enum Token {\n Plaintext(String),\n Keys(String, Option),\n}\n\nimpl Token {\n /// This is a valid PASETO secret key.\n ///\n /// This one is already publicly available as part of the text of the RFC so is safe to use for tests.\n pub fn rfc_key() -> Token {\n Token::Keys(\n \"k3.secret.fNYVuMvBgOlljt9TDohnaYLblghqaHoQquVZwgR6X12cBFHZLFsaU3q7X3k1Zn36\"\n .to_string(),\n Some(\"sub\".to_string()),\n )\n }\n}\n\ntype RequestCallback = Box Response>;\n\n/// Prepare a local [`TestRegistry`] fixture\n///\n/// See also [`init`] and [`alt_init`]\npub struct RegistryBuilder {\n /// If set, configures an alternate registry with the given name.\n alternative: Option,\n /// The authorization token for the registry.\n token: Option,\n /// If set, the registry requires authorization for all operations.\n auth_required: bool,\n /// If set, serves the index over http.\n http_index: bool,\n /// If set, serves the API over http.\n http_api: bool,\n /// If set, config.json includes 'api'\n api: bool,\n /// Write the token in the configuration.\n configure_token: bool,\n /// Write the registry in configuration.\n configure_registry: bool,\n /// API responders.\n custom_responders: HashMap,\n /// Handler for 404 responses.\n not_found_handler: RequestCallback,\n /// If nonzero, the git index update to be delayed by the given number of seconds.\n delayed_index_update: usize,\n /// Credential provider in configuration\n credential_provider: Option,\n}\n\n/// A local registry fixture\n///\n/// Most tests won't need to call this directly but instead interact with [`Package`]\npub struct TestRegistry {\n server: Option,\n index_url: Url,\n path: PathBuf,\n api_url: Url,\n dl_url: Url,\n token: Token,\n}\n\nimpl TestRegistry {\n pub fn index_url(&self) -> &Url {\n &self.index_url\n }\n\n pub fn api_url(&self) -> &Url {\n &self.api_url\n }\n\n pub fn token(&self) -> &str {\n match &self.token {\n Token::Plaintext(s) => s,\n Token::Keys(_, _) => panic!(\"registry was not configured with a plaintext token\"),\n }\n }\n\n pub fn key(&self) -> &str {\n match &self.token {\n Token::Plaintext(_) => panic!(\"registry was not configured with a secret key\"),\n Token::Keys(s, _) => s,\n }\n }\n\n /// Shutdown the server thread and wait for it to stop.\n /// `Drop` automatically stops the server, but this additionally\n /// waits for the thread to stop.\n pub fn join(self) {\n if let Some(mut server) = self.server {\n server.stop();\n let handle = server.handle.take().unwrap();\n handle.join().unwrap();\n }\n }\n}\n\nimpl RegistryBuilder {\n #[must_use]\n pub fn new() -> RegistryBuilder {\n let not_found = |_req: &Request, _server: &HttpServer| -> Response {\n Response {\n code: 404,\n headers: vec![],\n body: b\"not found\".to_vec(),\n }\n };\n RegistryBuilder {\n alternative: None,\n token: None,\n auth_required: false,\n http_api: false,\n http_index: false,\n api: true,\n configure_registry: true,\n configure_token: true,\n custom_responders: HashMap::new(),\n not_found_handler: Box::new(not_found),\n delayed_index_update: 0,\n credential_provider: None,\n }\n }\n\n /// Adds a custom HTTP response for a specific url\n #[must_use]\n pub fn add_responder Response>(\n mut self,\n url: impl Into,\n responder: R,\n ) -> Self {\n self.custom_responders\n .insert(url.into(), Box::new(responder));\n self\n }\n\n #[must_use]\n pub fn not_found_handler Response>(\n mut self,\n responder: R,\n ) -> Self {\n self.not_found_handler = Box::new(responder);\n self\n }\n\n /// Configures the git index update to be delayed by the given number of seconds.\n #[must_use]\n pub fn delayed_index_update(mut self, delay: usize) -> Self {\n self.delayed_index_update = delay;\n self\n }\n\n /// Initializes as an alternative registry with the given name.\n #[must_use]\n pub fn alternative_named(mut self, alt: &str) -> Self {\n self.alternative = Some(alt.to_string());\n self\n }\n\n /// Initializes as an alternative registry named \"alternative\".\n #[must_use]\n pub fn alternative(self) -> Self {\n self.alternative_named(\"alternative\")\n }\n\n /// Prevents placing a token in the configuration\n #[must_use]\n pub fn no_configure_token(mut self) -> Self {\n self.configure_token = false;\n self\n }\n\n /// Prevents adding the registry to the configuration.\n #[must_use]\n pub fn no_configure_registry(mut self) -> Self {\n self.configure_registry = false;\n self\n }\n\n /// Sets the token value\n #[must_use]\n pub fn token(mut self, token: Token) -> Self {\n self.token = Some(token);\n self\n }\n\n /// Sets this registry to require the authentication token for\n /// all operations.\n #[must_use]\n pub fn auth_required(mut self) -> Self {\n self.auth_required = true;\n self\n }\n\n /// Operate the index over http\n #[must_use]\n pub fn http_index(mut self) -> Self {\n self.http_index = true;\n self\n }\n\n /// Operate the api over http\n #[must_use]\n pub fn http_api(mut self) -> Self {\n self.http_api = true;\n self\n }\n\n /// The registry has no api.\n #[must_use]\n pub fn no_api(mut self) -> Self {\n self.api = false;\n self\n }\n\n /// The credential provider to configure for this registry.\n #[must_use]\n pub fn credential_provider(mut self, provider: &[&str]) -> Self {\n self.credential_provider = Some(format!(\"['{}']\", provider.join(\"','\")));\n self\n }\n\n /// Initializes the registry.\n #[must_use]\n pub fn build(self) -> TestRegistry {\n let config_path = paths::cargo_home().join(\"config.toml\");\n t!(fs::create_dir_all(config_path.parent().unwrap()));\n let prefix = if let Some(alternative) = &self.alternative {\n format!(\"{alternative}-\")\n } else {\n String::new()\n };\n let registry_path = generate_path(&format!(\"{prefix}registry\"));\n let index_url = generate_url(&format!(\"{prefix}registry\"));\n let api_url = generate_url(&format!(\"{prefix}api\"));\n let dl_url = generate_url(&format!(\"{prefix}dl\"));\n let dl_path = generate_path(&format!(\"{prefix}dl\"));\n let api_path = generate_path(&format!(\"{prefix}api\"));\n let token = self\n .token\n .unwrap_or_else(|| Token::Plaintext(format!(\"{prefix}sekrit\")));\n\n let (server, index_url, api_url, dl_url) = if !self.http_index && !self.http_api {\n // No need to start the HTTP server.\n (None, index_url, api_url, dl_url)\n } else {\n let server = HttpServer::new(\n registry_path.clone(),\n dl_path,\n api_path.clone(),\n token.clone(),\n self.auth_required,\n self.custom_responders,\n self.not_found_handler,\n self.delayed_index_update,\n );\n let index_url = if self.http_index {\n server.index_url()\n } else {\n index_url\n };\n let api_url = if self.http_api {\n server.api_url()\n } else {\n api_url\n };\n let dl_url = server.dl_url();\n (Some(server), index_url, api_url, dl_url)\n };\n\n let registry = TestRegistry {\n api_url,\n index_url,\n server,\n dl_url,\n path: registry_path,\n token,\n };\n\n if self.configure_registry {\n if let Some(alternative) = &self.alternative {\n append(\n &config_path,\n format!(\n \"\n [registries.{alternative}]\n index = '{}'\",\n registry.index_url\n )\n .as_bytes(),\n )\n .unwrap();\n if let Some(p) = &self.credential_provider {\n append(\n &config_path,\n &format!(\n \"\n credential-provider = {p}\n \"\n )\n .as_bytes(),\n )\n .unwrap()\n }\n } else {\n append(\n &config_path,\n format!(\n \"\n [source.crates-io]\n replace-with = 'dummy-registry'\n\n [registries.dummy-registry]\n index = '{}'\",\n registry.index_url\n )\n .as_bytes(),\n )\n .unwrap();\n\n if let Some(p) = &self.credential_provider {\n append(\n &config_path,\n &format!(\n \"\n [registry]\n credential-provider = {p}\n \"\n )\n .as_bytes(),\n )\n .unwrap()\n }\n }\n }\n\n if self.configure_token {\n let credentials = paths::cargo_home().join(\"credentials.toml\");\n match ®istry.token {\n Token::Plaintext(token) => {\n if let Some(alternative) = &self.alternative {\n append(\n &credentials,\n format!(\n r#\"\n [registries.{alternative}]\n token = \"{token}\"\n \"#\n )\n .as_bytes(),\n )\n .unwrap();\n } else {\n append(\n &credentials,\n format!(\n r#\"\n [registry]\n token = \"{token}\"\n \"#\n )\n .as_bytes(),\n )\n .unwrap();\n }\n }\n Token::Keys(key, subject) => {\n let mut out = if let Some(alternative) = &self.alternative {\n format!(\"\\n[registries.{alternative}]\\n\")\n } else {\n format!(\"\\n[registry]\\n\")\n };\n out += &format!(\"secret-key = \\\"{key}\\\"\\n\");\n if let Some(subject) = subject {\n out += &format!(\"secret-key-subject = \\\"{subject}\\\"\\n\");\n }\n\n append(&credentials, out.as_bytes()).unwrap();\n }\n }\n }\n\n let auth = if self.auth_required {\n r#\",\"auth-required\":true\"#\n } else {\n \"\"\n };\n let api = if self.api {\n format!(r#\",\"api\":\"{}\"\"#, registry.api_url)\n } else {\n String::new()\n };\n // Initialize a new registry.\n repo(®istry.path)\n .file(\n \"config.json\",\n &format!(r#\"{{\"dl\":\"{}\"{api}{auth}}}\"#, registry.dl_url),\n )\n .build();\n fs::create_dir_all(api_path.join(\"api/v1/crates\")).unwrap();\n\n registry\n }\n}\n\n/// Published package builder for [`TestRegistry`]\n///\n/// This uses \"source replacement\" using an automatically generated\n/// `.cargo/config` file to ensure that dependencies will use these packages\n/// instead of contacting crates.io. See `source-replacement.md` for more\n/// details on how source replacement works.\n///\n/// Call [`Package::publish`] to finalize and create the package.\n///\n/// If no files are specified, an empty `lib.rs` file is automatically created.\n///\n/// The `Cargo.toml` file is automatically generated based on the methods\n/// called on `Package` (for example, calling [`Package::dep()`] will add to the\n/// `[dependencies]` automatically). You may also specify a `Cargo.toml` file\n/// to override the generated one.\n///\n/// This supports different registry types:\n/// - Regular source replacement that replaces `crates.io` (the default).\n/// - A \"local registry\" which is a subset for vendoring (see\n/// [`Package::local`]).\n/// - An \"alternative registry\" which requires specifying the registry name\n/// (see [`Package::alternative`]).\n///\n/// This does not support \"directory sources\". See `directory.rs` for\n/// `VendorPackage` which implements directory sources.\n#[must_use]\npub struct Package {\n name: String,\n vers: String,\n deps: Vec,\n files: Vec,\n yanked: bool,\n features: FeatureMap,\n local: bool,\n alternative: bool,\n invalid_index_line: bool,\n index_line: Option,\n edition: Option,\n resolver: Option,\n proc_macro: bool,\n links: Option,\n rust_version: Option,\n cargo_features: Vec,\n pubtime: Option,\n v: Option,\n}\n\npub(crate) type FeatureMap = BTreeMap>;\n\n/// Published package dependency builder, see [`Package::add_dep`]\n#[derive(Clone)]\npub struct Dependency {\n name: String,\n vers: String,\n kind: String,\n artifact: Option,\n bindep_target: Option,\n lib: bool,\n target: Option,\n features: Vec,\n registry: Option,\n package: Option,\n optional: bool,\n default_features: bool,\n public: bool,\n}\n\n/// Entry with data that corresponds to [`tar::EntryType`].\n#[non_exhaustive]\nenum EntryData {\n Regular(String),\n Symlink(PathBuf),\n Directory,\n}\n\n/// A file to be created in a package.\nstruct PackageFile {\n path: String,\n contents: EntryData,\n /// The Unix mode for the file. Note that when extracted on Windows, this\n /// is mostly ignored since it doesn't have the same style of permissions.\n mode: u32,\n /// If `true`, the file is created in the root of the tarfile, used for\n /// testing invalid packages.\n extra: bool,\n}\n\nconst DEFAULT_MODE: u32 = 0o644;\n\n/// Setup a local pseudo-crates.io [`TestRegistry`]\n///\n/// This is implicitly called by [`Package::new`].\n///\n/// When calling `cargo publish`, see instead [`crate::publish`].\npub fn init() -> TestRegistry {\n RegistryBuilder::new().build()\n}\n\n/// Setup a local \"alternative\" [`TestRegistry`]\n///\n/// When calling `cargo publish`, see instead [`crate::publish`].\npub fn alt_init() -> TestRegistry {\n init();\n RegistryBuilder::new().alternative().build()\n}\n\npub struct HttpServerHandle {\n addr: SocketAddr,\n handle: Option>,\n}\n\nimpl HttpServerHandle {\n pub fn index_url(&self) -> Url {\n Url::parse(&format!(\"sparse+http://{}/index/\", self.addr)).unwrap()\n }\n\n pub fn api_url(&self) -> Url {\n Url::parse(&format!(\"http://{}/\", self.addr)).unwrap()\n }\n\n pub fn dl_url(&self) -> Url {\n Url::parse(&format!(\"http://{}/dl\", self.addr)).unwrap()\n }\n\n fn stop(&self) {\n if let Ok(mut stream) = TcpStream::connect(self.addr) {\n // shutdown the server\n let _ = stream.write_all(b\"stop\");\n let _ = stream.flush();\n }\n }\n}\n\nimpl Drop for HttpServerHandle {\n fn drop(&mut self) {\n self.stop();\n }\n}\n\n/// Request to the test http server\n#[derive(Clone)]\npub struct Request {\n pub url: Url,\n pub method: String,\n pub body: Option>,\n pub authorization: Option,\n pub if_modified_since: Option,\n pub if_none_match: Option,\n}\n\nimpl fmt::Debug for Request {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n // body is not included as it can produce long debug outputs\n f.debug_struct(\"Request\")\n .field(\"url\", &self.url)\n .field(\"method\", &self.method)\n .field(\"authorization\", &self.authorization)\n .field(\"if_modified_since\", &self.if_modified_since)\n .field(\"if_none_match\", &self.if_none_match)\n .finish()\n }\n}\n\n/// Response from the test http server\npub struct Response {\n pub code: u32,\n pub headers: Vec,\n pub body: Vec,\n}\n\npub struct HttpServer {\n listener: TcpListener,\n registry_path: PathBuf,\n dl_path: PathBuf,\n api_path: PathBuf,\n addr: SocketAddr,\n token: Token,\n auth_required: bool,\n custom_responders: HashMap,\n not_found_handler: RequestCallback,\n delayed_index_update: usize,\n}\n\n/// A helper struct that collects the arguments for [`HttpServer::check_authorized`].\n/// Based on looking at the request, these are the fields that the authentication header should attest to.\nstruct Mutation<'a> {\n mutation: &'a str,\n name: Option<&'a str>,\n vers: Option<&'a str>,\n cksum: Option<&'a str>,\n}\n\nimpl HttpServer {\n pub fn new(\n registry_path: PathBuf,\n dl_path: PathBuf,\n api_path: PathBuf,\n token: Token,\n auth_required: bool,\n custom_responders: HashMap,\n not_found_handler: RequestCallback,\n delayed_index_update: usize,\n ) -> HttpServerHandle {\n let listener = TcpListener::bind(\"127.0.0.1:0\").unwrap();\n let addr = listener.local_addr().unwrap();\n let server = HttpServer {\n listener,\n registry_path,\n dl_path,\n api_path,\n addr,\n token,\n auth_required,\n custom_responders,\n not_found_handler,\n delayed_index_update,\n };\n let handle = Some(thread::spawn(move || server.start()));\n HttpServerHandle { addr, handle }\n }\n\n fn start(&self) {\n let mut line = String::new();\n 'server: loop {\n let (socket, _) = self.listener.accept().unwrap();\n let mut buf = BufReader::new(socket);\n line.clear();\n if buf.read_line(&mut line).unwrap() == 0 {\n // Connection terminated.\n continue;\n }\n // Read the \"GET path HTTP/1.1\" line.\n let mut parts = line.split_ascii_whitespace();\n let method = parts.next().unwrap().to_ascii_lowercase();\n if method == \"stop\" {\n // Shutdown the server.\n return;\n }\n let addr = self.listener.local_addr().unwrap();\n let url = format!(\n \"http://{}/{}\",\n addr,\n parts.next().unwrap().trim_start_matches('/')\n );\n let url = Url::parse(&url).unwrap();\n\n // Grab headers we care about.\n let mut if_modified_since = None;\n let mut if_none_match = None;\n let mut authorization = None;\n let mut content_len = None;\n loop {\n line.clear();\n if buf.read_line(&mut line).unwrap() == 0 {\n continue 'server;\n }\n if line == \"\\r\\n\" {\n // End of headers.\n line.clear();\n break;\n }\n let (name, value) = line.split_once(':').unwrap();\n let name = name.trim().to_ascii_lowercase();\n let value = value.trim().to_string();\n match name.as_str() {\n \"if-modified-since\" => if_modified_since = Some(value),\n \"if-none-match\" => if_none_match = Some(value),\n \"authorization\" => authorization = Some(value),\n \"content-length\" => content_len = Some(value),\n _ => {}\n }\n }\n\n let mut body = None;\n if let Some(con_len) = content_len {\n let len = con_len.parse::().unwrap();\n let mut content = vec![0u8; len as usize];\n buf.read_exact(&mut content).unwrap();\n body = Some(content)\n }\n\n let req = Request {\n authorization,\n if_modified_since,\n if_none_match,\n method,\n url,\n body,\n };\n let response = self.route(&req);\n let buf = buf.get_mut();\n write!(buf, \"HTTP/1.1 {}\\r\\n\", response.code).unwrap();\n write!(buf, \"Content-Length: {}\\r\\n\", response.body.len()).unwrap();\n write!(buf, \"Connection: close\\r\\n\").unwrap();\n for header in response.headers {\n write!(buf, \"{}\\r\\n\", header).unwrap();\n }\n write!(buf, \"\\r\\n\").unwrap();\n buf.write_all(&response.body).unwrap();\n buf.flush().unwrap();\n }\n }\n\n fn check_authorized(&self, req: &Request, mutation: Option>) -> bool {\n let (private_key, private_key_subject) = if mutation.is_some() || self.auth_required {\n match &self.token {\n Token::Plaintext(token) => return Some(token) == req.authorization.as_ref(),\n Token::Keys(private_key, private_key_subject) => {\n (private_key.as_str(), private_key_subject)\n }\n }\n } else {\n assert!(req.authorization.is_none(), \"unexpected token\");\n return true;\n };\n\n macro_rules! t {\n ($e:expr) => {\n match $e {\n Some(e) => e,\n None => return false,\n }\n };\n }\n\n let secret: AsymmetricSecretKey = private_key.try_into().unwrap();\n let public: AsymmetricPublicKey = (&secret).try_into().unwrap();\n let pub_key_id: pasetors::paserk::Id = (&public).into();\n let mut paserk_pub_key_id = String::new();\n FormatAsPaserk::fmt(&pub_key_id, &mut paserk_pub_key_id).unwrap();\n // https://github.com/rust-lang/rfcs/blob/master/text/3231-cargo-asymmetric-tokens.md#how-the-registry-server-will-validate-an-asymmetric-token\n\n // - The PASETO is in v3.public format.\n let authorization = t!(&req.authorization);\n let untrusted_token = t!(\n UntrustedToken::::try_from(authorization)\n .ok()\n );\n\n // - The PASETO validates using the public key it looked up based on the key ID.\n #[derive(serde::Deserialize, Debug)]\n struct Footer<'a> {\n url: &'a str,\n kip: &'a str,\n }\n let footer: Footer<'_> =\n t!(serde_json::from_slice(untrusted_token.untrusted_footer()).ok());\n if footer.kip != paserk_pub_key_id {\n return false;\n }\n let trusted_token =\n t!(\n pasetors::version3::PublicToken::verify(&public, &untrusted_token, None, None,)\n .ok()\n );\n\n // - The URL matches the registry base URL\n if footer.url != \"https://github.com/rust-lang/crates.io-index\"\n && footer.url != &format!(\"sparse+http://{}/index/\", self.addr)\n {\n return false;\n }\n\n // - The PASETO is still within its valid time period.\n #[derive(serde::Deserialize)]\n struct Message<'a> {\n iat: &'a str,\n sub: Option<&'a str>,\n mutation: Option<&'a str>,\n name: Option<&'a str>,\n vers: Option<&'a str>,\n cksum: Option<&'a str>,\n _challenge: Option<&'a str>, // todo: PASETO with challenges\n v: Option,\n }\n let message: Message<'_> = t!(serde_json::from_str(trusted_token.payload()).ok());\n let token_time = t!(OffsetDateTime::parse(message.iat, &Rfc3339).ok());\n let now = OffsetDateTime::now_utc();\n if (now - token_time) > Duration::MINUTE {\n return false;\n }\n if private_key_subject.as_deref() != message.sub {\n return false;\n }\n // - If the claim v is set, that it has the value of 1.\n if let Some(v) = message.v {\n if v != 1 {\n return false;\n }\n }\n // - If the server issues challenges, that the challenge has not yet been answered.\n // todo: PASETO with challenges\n // - If the operation is a mutation:\n if let Some(mutation) = mutation {\n // - That the operation matches the mutation field and is one of publish, yank, or unyank.\n if message.mutation != Some(mutation.mutation) {\n return false;\n }\n // - That the package, and version match the request.\n if message.name != mutation.name {\n return false;\n }\n if message.vers != mutation.vers {\n return false;\n }\n // - If the mutation is publish, that the version has not already been published, and that the hash matches the request.\n if mutation.mutation == \"publish\" {\n if message.cksum != mutation.cksum {\n return false;\n }\n }\n } else {\n // - If the operation is a read, that the mutation field is not set.\n if message.mutation.is_some()\n || message.name.is_some()\n || message.vers.is_some()\n || message.cksum.is_some()\n {\n return false;\n }\n }\n true\n }\n\n /// Route the request\n fn route(&self, req: &Request) -> Response {\n // Check for custom responder\n if let Some(responder) = self.custom_responders.get(req.url.path()) {\n return responder(&req, self);\n }\n let path: Vec<_> = req.url.path()[1..].split('/').collect();\n match (req.method.as_str(), path.as_slice()) {\n (\"get\", [\"index\", ..]) => {\n if !self.check_authorized(req, None) {\n self.unauthorized(req)\n } else {\n self.index(&req)\n }\n }\n (\"get\", [\"dl\", ..]) => {\n if !self.check_authorized(req, None) {\n self.unauthorized(req)\n } else {\n self.dl(&req)\n }\n }\n // publish\n (\"put\", [\"api\", \"v1\", \"crates\", \"new\"]) => self.check_authorized_publish(req),\n // The remainder of the operators in the test framework do nothing other than responding 'ok'.\n //\n // Note: We don't need to support anything real here because there are no tests that\n // currently require anything other than publishing via the http api.\n\n // yank / unyank\n (\"delete\" | \"put\", [\"api\", \"v1\", \"crates\", crate_name, version, mutation]) => {\n if !self.check_authorized(\n req,\n Some(Mutation {\n mutation,\n name: Some(crate_name),\n vers: Some(version),\n cksum: None,\n }),\n ) {\n self.unauthorized(req)\n } else {\n self.ok(&req)\n }\n }\n // owners\n (\"get\" | \"put\" | \"delete\", [\"api\", \"v1\", \"crates\", crate_name, \"owners\"]) => {\n if !self.check_authorized(\n req,\n Some(Mutation {\n mutation: \"owners\",\n name: Some(crate_name),\n vers: None,\n cksum: None,\n }),\n ) {\n self.unauthorized(req)\n } else {\n self.ok(&req)\n }\n }\n _ => self.not_found(&req),\n }\n }\n\n /// Unauthorized response\n pub fn unauthorized(&self, _req: &Request) -> Response {\n Response {\n code: 401,\n headers: vec![\n r#\"www-authenticate: Cargo login_url=\"https://test-registry-login/me\"\"#.to_string(),\n ],\n body: b\"Unauthorized message from server.\".to_vec(),\n }\n }\n\n /// Not found response\n pub fn not_found(&self, req: &Request) -> Response {\n (self.not_found_handler)(req, self)\n }\n\n /// Respond OK without doing anything\n pub fn ok(&self, _req: &Request) -> Response {\n Response {\n code: 200,\n headers: vec![],\n body: br#\"{\"ok\": true, \"msg\": \"completed!\"}\"#.to_vec(),\n }\n }\n\n /// Return an internal server error (HTTP 500)\n pub fn internal_server_error(&self, _req: &Request) -> Response {\n Response {\n code: 500,\n headers: vec![],\n body: br#\"internal server error\"#.to_vec(),\n }\n }\n\n /// Return too many requests (HTTP 429)\n pub fn too_many_requests(&self, _req: &Request, delay: std::time::Duration) -> Response {\n Response {\n code: 429,\n headers: vec![format!(\"Retry-After: {}\", delay.as_secs())],\n body: format!(\n \"too many requests, try again in {} seconds\",\n delay.as_secs()\n )\n .into_bytes(),\n }\n }\n\n /// Serve the download endpoint\n pub fn dl(&self, req: &Request) -> Response {\n let file = self\n .dl_path\n .join(req.url.path().strip_prefix(\"/dl/\").unwrap());\n println!(\"{}\", file.display());\n if !file.exists() {\n return self.not_found(req);\n }\n return Response {\n body: fs::read(&file).unwrap(),\n code: 200,\n headers: vec![],\n };\n }\n\n /// Serve the registry index\n pub fn index(&self, req: &Request) -> Response {\n let file = self\n .registry_path\n .join(req.url.path().strip_prefix(\"/index/\").unwrap());\n if !file.exists() {\n return self.not_found(req);\n } else {\n // Now grab info about the file.\n let data = fs::read(&file).unwrap();\n let etag = Sha256::new().update(&data).finish_hex();\n let last_modified = format!(\"{:?}\", file.metadata().unwrap().modified().unwrap());\n\n // Start to construct our response:\n let mut any_match = false;\n let mut all_match = true;\n if let Some(expected) = &req.if_none_match {\n if &etag != expected {\n all_match = false;\n } else {\n any_match = true;\n }\n }\n if let Some(expected) = &req.if_modified_since {\n // NOTE: Equality comparison is good enough for tests.\n if &last_modified != expected {\n all_match = false;\n } else {\n any_match = true;\n }\n }\n\n if any_match && all_match {\n return Response {\n body: Vec::new(),\n code: 304,\n headers: vec![],\n };\n } else {\n return Response {\n body: data,\n code: 200,\n headers: vec![\n format!(\"ETag: \\\"{}\\\"\", etag),\n format!(\"Last-Modified: {}\", last_modified),\n ],\n };\n }\n }\n }\n\n pub fn check_authorized_publish(&self, req: &Request) -> Response {\n if let Some(body) = &req.body {\n // Mimic the publish behavior for local registries by writing out the request\n // so tests can verify publishes made to either registry type.\n let path = self.api_path.join(\"api/v1/crates/new\");\n t!(fs::create_dir_all(path.parent().unwrap()));\n t!(fs::write(&path, body));\n\n // Get the metadata of the package\n let (len, remaining) = body.split_at(4);\n let json_len = u32::from_le_bytes(len.try_into().unwrap());\n let (json, remaining) = remaining.split_at(json_len as usize);\n let new_crate = serde_json::from_slice::(json).unwrap();\n // Get the `.crate` file\n let (len, remaining) = remaining.split_at(4);\n let file_len = u32::from_le_bytes(len.try_into().unwrap());\n let (file, _remaining) = remaining.split_at(file_len as usize);\n let file_cksum = cksum(&file);\n\n if !self.check_authorized(\n req,\n Some(Mutation {\n mutation: \"publish\",\n name: Some(&new_crate.name),\n vers: Some(&new_crate.vers),\n cksum: Some(&file_cksum),\n }),\n ) {\n return self.unauthorized(req);\n }\n\n let dst = self\n .dl_path\n .join(&new_crate.name)\n .join(&new_crate.vers)\n .join(\"download\");\n\n if self.delayed_index_update == 0 {\n save_new_crate(dst, new_crate, file, file_cksum, &self.registry_path);\n } else {\n let delayed_index_update = self.delayed_index_update;\n let registry_path = self.registry_path.clone();\n let file = Vec::from(file);\n thread::spawn(move || {\n thread::sleep(std::time::Duration::new(delayed_index_update as u64, 0));\n save_new_crate(dst, new_crate, &file, file_cksum, ®istry_path);\n });\n }\n\n self.ok(&req)\n } else {\n Response {\n code: 400,\n headers: vec![],\n body: b\"The request was missing a body\".to_vec(),\n }\n }\n }\n}\n\nfn save_new_crate(\n dst: PathBuf,\n new_crate: crates_io::NewCrate,\n file: &[u8],\n file_cksum: String,\n registry_path: &Path,\n) {\n // Write the `.crate`\n t!(fs::create_dir_all(dst.parent().unwrap()));\n t!(fs::write(&dst, file));\n\n let deps = new_crate\n .deps\n .iter()\n .map(|dep| {\n let (name, package) = match &dep.explicit_name_in_toml {\n Some(explicit) => (explicit.to_string(), Some(dep.name.to_string())),\n None => (dep.name.to_string(), None),\n };\n serde_json::json!({\n \"name\": name,\n \"req\": dep.version_req,\n \"features\": dep.features,\n \"default_features\": dep.default_features,\n \"target\": dep.target,\n \"optional\": dep.optional,\n \"kind\": dep.kind,\n \"registry\": dep.registry,\n \"package\": package,\n \"artifact\": dep.artifact,\n \"bindep_target\": dep.bindep_target,\n \"lib\": dep.lib,\n })\n })\n .collect::>();\n\n let line = create_index_line(\n serde_json::json!(new_crate.name),\n &new_crate.vers,\n deps,\n &file_cksum,\n new_crate.features,\n false,\n new_crate.links,\n new_crate.rust_version.as_deref(),\n None,\n None,\n );\n\n write_to_index(registry_path, &new_crate.name, line, false);\n}\n\nimpl Package {\n /// Creates a new package builder.\n /// Call `publish()` to finalize and build the package.\n pub fn new(name: &str, vers: &str) -> Package {\n let config = paths::cargo_home().join(\"config.toml\");\n if !config.exists() {\n init();\n }\n Package {\n name: name.to_string(),\n vers: vers.to_string(),\n deps: Vec::new(),\n files: Vec::new(),\n yanked: false,\n features: BTreeMap::new(),\n local: false,\n alternative: false,\n invalid_index_line: false,\n index_line: None,\n edition: None,\n resolver: None,\n proc_macro: false,\n links: None,\n rust_version: None,\n cargo_features: Vec::new(),\n pubtime: None,\n v: None,\n }\n }\n\n /// Call with `true` to publish in a \"local registry\".\n ///\n /// See `source-replacement.html#local-registry-sources` for more details\n /// on local registries. See `local_registry.rs` for the tests that use\n /// this.\n pub fn local(&mut self, local: bool) -> &mut Package {\n self.local = local;\n self\n }\n\n /// Call with `true` to publish in an \"alternative registry\".\n ///\n /// The name of the alternative registry is called \"alternative\".\n ///\n /// See `src/doc/src/reference/registries.md` for more details on\n /// alternative registries. See `alt_registry.rs` for the tests that use\n /// this.\n ///\n /// **Requires:** [`alt_init`]\n pub fn alternative(&mut self, alternative: bool) -> &mut Package {\n self.alternative = alternative;\n self\n }\n\n /// Adds a file to the package.\n pub fn file(&mut self, name: &str, contents: &str) -> &mut Package {\n self.file_with_mode(name, DEFAULT_MODE, contents)\n }\n\n /// Adds a file with a specific Unix mode.\n pub fn file_with_mode(&mut self, path: &str, mode: u32, contents: &str) -> &mut Package {\n self.files.push(PackageFile {\n path: path.to_string(),\n contents: EntryData::Regular(contents.into()),\n mode,\n extra: false,\n });\n self\n }\n\n /// Adds a symlink to a path to the package.\n pub fn symlink(&mut self, dst: &str, src: &str) -> &mut Package {\n self.files.push(PackageFile {\n path: dst.to_string(),\n contents: EntryData::Symlink(src.into()),\n mode: DEFAULT_MODE,\n extra: false,\n });\n self\n }\n\n /// Adds an empty directory at the given path.\n pub fn directory(&mut self, path: &str) -> &mut Package {\n self.files.push(PackageFile {\n path: path.to_string(),\n contents: EntryData::Directory,\n mode: DEFAULT_MODE,\n extra: false,\n });\n self\n }\n\n /// Adds an \"extra\" file that is not rooted within the package.\n ///\n /// Normal files are automatically placed within a directory named\n /// `$PACKAGE-$VERSION`. This allows you to override that behavior,\n /// typically for testing invalid behavior.\n pub fn extra_file(&mut self, path: &str, contents: &str) -> &mut Package {\n self.files.push(PackageFile {\n path: path.to_string(),\n contents: EntryData::Regular(contents.to_string()),\n mode: DEFAULT_MODE,\n extra: true,\n });\n self\n }\n\n /// Adds a normal dependency. Example:\n /// ```toml\n /// [dependencies]\n /// foo = {version = \"1.0\"}\n /// ```\n pub fn dep(&mut self, name: &str, vers: &str) -> &mut Package {\n self.add_dep(&Dependency::new(name, vers))\n }\n\n /// Adds a dependency with the given feature. Example:\n /// ```toml\n /// [dependencies]\n /// foo = {version = \"1.0\", \"features\": [\"feat1\", \"feat2\"]}\n /// ```\n pub fn feature_dep(&mut self, name: &str, vers: &str, features: &[&str]) -> &mut Package {\n self.add_dep(Dependency::new(name, vers).enable_features(features))\n }\n\n /// Adds a platform-specific dependency. Example:\n /// ```toml\n /// [target.'cfg(windows)'.dependencies]\n /// foo = {version = \"1.0\"}\n /// ```\n pub fn target_dep(&mut self, name: &str, vers: &str, target: &str) -> &mut Package {\n self.add_dep(Dependency::new(name, vers).target(target))\n }\n\n /// Adds a dependency to the alternative registry.\n pub fn registry_dep(&mut self, name: &str, vers: &str) -> &mut Package {\n self.add_dep(Dependency::new(name, vers).registry(\"alternative\"))\n }\n\n /// Adds a dev-dependency. Example:\n /// ```toml\n /// [dev-dependencies]\n /// foo = {version = \"1.0\"}\n /// ```\n pub fn dev_dep(&mut self, name: &str, vers: &str) -> &mut Package {\n self.add_dep(Dependency::new(name, vers).dev())\n }\n\n /// Adds a build-dependency. Example:\n /// ```toml\n /// [build-dependencies]\n /// foo = {version = \"1.0\"}\n /// ```\n pub fn build_dep(&mut self, name: &str, vers: &str) -> &mut Package {\n self.add_dep(Dependency::new(name, vers).build())\n }\n\n pub fn add_dep(&mut self, dep: &Dependency) -> &mut Package {\n self.deps.push(dep.clone());\n self\n }\n\n /// Specifies whether or not the package is \"yanked\".\n pub fn yanked(&mut self, yanked: bool) -> &mut Package {\n self.yanked = yanked;\n self\n }\n\n /// Specifies `package.edition`\n pub fn edition(&mut self, edition: &str) -> &mut Package {\n self.edition = Some(edition.to_owned());\n self\n }\n\n /// Specifies `package.resolver`\n pub fn resolver(&mut self, resolver: &str) -> &mut Package {\n self.resolver = Some(resolver.to_owned());\n self\n }\n\n /// Specifies whether or not this is a proc macro.\n pub fn proc_macro(&mut self, proc_macro: bool) -> &mut Package {\n self.proc_macro = proc_macro;\n self\n }\n\n /// Adds an entry in the `[features]` section.\n pub fn feature(&mut self, name: &str, deps: &[&str]) -> &mut Package {\n let deps = deps.iter().map(|s| s.to_string()).collect();\n self.features.insert(name.to_string(), deps);\n self\n }\n\n /// Specify a minimal Rust version.\n pub fn rust_version(&mut self, rust_version: &str) -> &mut Package {\n self.rust_version = Some(rust_version.into());\n self\n }\n\n /// Causes the JSON line emitted in the index to be invalid, presumably\n /// causing Cargo to skip over this version.\n pub fn invalid_index_line(&mut self, invalid: bool) -> &mut Package {\n self.invalid_index_line = invalid;\n self\n }\n\n /// Override the auto-generated index line\n ///\n /// This can give more control over error cases than [`Package::invalid_index_line`]\n pub fn index_line(&mut self, line: &str) -> &mut Package {\n self.index_line = Some(line.to_owned());\n self\n }\n\n pub fn links(&mut self, links: &str) -> &mut Package {\n self.links = Some(links.to_string());\n self\n }\n\n pub fn cargo_feature(&mut self, feature: &str) -> &mut Package {\n self.cargo_features.push(feature.to_owned());\n self\n }\n\n /// The publish time for the package in ISO8601 with UTC timezone (e.g. 2025-11-12T19:30:12Z)\n pub fn pubtime(&mut self, time: &str) -> &mut Package {\n self.pubtime = Some(time.to_owned());\n self\n }\n\n /// Sets the index schema version for this package.\n ///\n /// See `cargo::sources::registry::IndexPackage` for more information.\n pub fn schema_version(&mut self, version: u32) -> &mut Package {\n self.v = Some(version);\n self\n }\n\n /// Creates the package and place it in the registry.\n ///\n /// This does not actually use Cargo's publishing system, but instead\n /// manually creates the entry in the registry on the filesystem.\n ///\n /// Returns the checksum for the package.\n pub fn publish(&self) -> String {\n self.make_archive();\n\n // Figure out what we're going to write into the index.\n let deps = self\n .deps\n .iter()\n .map(|dep| {\n // In the index, the `registry` is null if it is from the same registry.\n // In Cargo.toml, it is None if it is from crates.io.\n let registry_url = match (self.alternative, dep.registry.as_deref()) {\n (false, None) => None,\n (false, Some(\"alternative\")) => Some(alt_registry_url().to_string()),\n (true, None) => {\n Some(\"https://github.com/rust-lang/crates.io-index\".to_string())\n }\n (true, Some(\"alternative\")) => None,\n _ => panic!(\"registry_dep currently only supports `alternative`\"),\n };\n let artifact = if let Some(artifact) = &dep.artifact {\n serde_json::json!([artifact])\n } else {\n serde_json::json!(null)\n };\n serde_json::json!({\n \"name\": dep.name,\n \"req\": dep.vers,\n \"features\": dep.features,\n \"default_features\": dep.default_features,\n \"target\": dep.target,\n \"artifact\": artifact,\n \"bindep_target\": dep.bindep_target,\n \"lib\": dep.lib,\n \"optional\": dep.optional,\n \"kind\": dep.kind,\n \"registry\": registry_url,\n \"package\": dep.package,\n \"public\": dep.public,\n })\n })\n .collect::>();\n let cksum = {\n let c = t!(fs::read(&self.archive_dst()));\n cksum(&c)\n };\n let line = if let Some(line) = self.index_line.clone() {\n line\n } else {\n let name = if self.invalid_index_line {\n serde_json::json!(1)\n } else {\n serde_json::json!(self.name)\n };\n create_index_line(\n name,\n &self.vers,\n deps,\n &cksum,\n self.features.clone(),\n self.yanked,\n self.links.clone(),\n self.rust_version.as_deref(),\n self.pubtime.as_deref(),\n self.v,\n )\n };\n\n let registry_path = if self.alternative {\n alt_registry_path()\n } else {\n registry_path()\n };\n\n write_to_index(®istry_path, &self.name, line, self.local);\n\n cksum\n }\n\n fn make_archive(&self) {\n let dst = self.archive_dst();\n t!(fs::create_dir_all(dst.parent().unwrap()));\n let f = t!(File::create(&dst));\n let mut a = Builder::new(GzEncoder::new(f, Compression::none()));\n a.sparse(false);\n\n if !self\n .files\n .iter()\n .any(|PackageFile { path, .. }| path == \"Cargo.toml\")\n {\n self.append_manifest(&mut a);\n }\n if self.files.is_empty() {\n self.append(\n &mut a,\n \"src/lib.rs\",\n DEFAULT_MODE,\n &EntryData::Regular(\"\".into()),\n );\n } else {\n for PackageFile {\n path,\n contents,\n mode,\n extra,\n } in &self.files\n {\n if *extra {\n self.append_raw(&mut a, path, *mode, contents);\n } else {\n self.append(&mut a, path, *mode, contents);\n }\n }\n }\n }\n\n fn append_manifest(&self, ar: &mut Builder) {\n let mut manifest = String::new();\n\n if !self.cargo_features.is_empty() {\n let mut features = String::new();\n serde::Serialize::serialize(\n &self.cargo_features,\n toml::ser::ValueSerializer::new(&mut features),\n )\n .unwrap();\n manifest.push_str(&format!(\"cargo-features = {}\\n\\n\", features));\n }\n\n manifest.push_str(&format!(\n r#\"\n [package]\n name = \"{}\"\n version = \"{}\"\n authors = []\n \"#,\n self.name, self.vers\n ));\n\n if let Some(version) = &self.rust_version {\n manifest.push_str(&format!(\"rust-version = \\\"{}\\\"\\n\", version));\n }\n\n if let Some(edition) = &self.edition {\n manifest.push_str(&format!(\"edition = \\\"{}\\\"\\n\", edition));\n }\n\n if let Some(resolver) = &self.resolver {\n manifest.push_str(&format!(\"resolver = \\\"{}\\\"\\n\", resolver));\n }\n\n if !self.features.is_empty() {\n let features: Vec = self\n .features\n .iter()\n .map(|(feature, features)| {\n if features.is_empty() {\n format!(\"{} = []\", feature)\n } else {\n format!(\n \"{} = [{}]\",\n feature,\n features\n .iter()\n .map(|s| format!(\"\\\"{}\\\"\", s))\n .collect::>()\n .join(\", \")\n )\n }\n })\n .collect();\n\n manifest.push_str(&format!(\"\\n[features]\\n{}\", features.join(\"\\n\")));\n }\n\n for dep in self.deps.iter() {\n let target = match dep.target {\n None => String::new(),\n Some(ref s) => format!(\"target.'{}'.\", s),\n };\n let kind = match &dep.kind[..] {\n \"build\" => \"build-\",\n \"dev\" => \"dev-\",\n _ => \"\",\n };\n manifest.push_str(&format!(\n r#\"\n [{}{}dependencies.{}]\n version = \"{}\"\n \"#,\n target, kind, dep.name, dep.vers\n ));\n if dep.optional {\n manifest.push_str(\"optional = true\\n\");\n }\n if let Some(artifact) = &dep.artifact {\n manifest.push_str(&format!(\"artifact = \\\"{}\\\"\\n\", artifact));\n }\n if let Some(target) = &dep.bindep_target {\n manifest.push_str(&format!(\"target = \\\"{}\\\"\\n\", target));\n }\n if dep.lib {\n manifest.push_str(\"lib = true\\n\");\n }\n if let Some(registry) = &dep.registry {\n assert_eq!(registry, \"alternative\");\n manifest.push_str(&format!(\"registry-index = \\\"{}\\\"\", alt_registry_url()));\n }\n if !dep.default_features {\n manifest.push_str(\"default-features = false\\n\");\n }\n if !dep.features.is_empty() {\n let mut features = String::new();\n serde::Serialize::serialize(\n &dep.features,\n toml::ser::ValueSerializer::new(&mut features),\n )\n .unwrap();\n manifest.push_str(&format!(\"features = {}\\n\", features));\n }\n if let Some(package) = &dep.package {\n manifest.push_str(&format!(\"package = \\\"{}\\\"\\n\", package));\n }\n }\n if self.proc_macro {\n manifest.push_str(\"[lib]\\nproc-macro = true\\n\");\n }\n\n self.append(\n ar,\n \"Cargo.toml\",\n DEFAULT_MODE,\n &EntryData::Regular(manifest.into()),\n );\n }\n\n fn append(&self, ar: &mut Builder, file: &str, mode: u32, contents: &EntryData) {\n self.append_raw(\n ar,\n &format!(\"{}-{}/{}\", self.name, self.vers, file),\n mode,\n contents,\n );\n }\n\n fn append_raw(\n &self,\n ar: &mut Builder,\n path: &str,\n mode: u32,\n contents: &EntryData,\n ) {\n let mut header = Header::new_ustar();\n let contents = match contents {\n EntryData::Regular(contents) => contents.as_str(),\n EntryData::Symlink(src) => {\n header.set_entry_type(tar::EntryType::Symlink);\n t!(header.set_link_name(src));\n \"\" // Symlink has no contents.\n }\n EntryData::Directory => {\n header.set_entry_type(tar::EntryType::Directory);\n \"\"\n }\n };\n header.set_size(contents.len() as u64);\n t!(header.set_path(path));\n header.set_mode(mode);\n header.set_cksum();\n t!(ar.append(&header, contents.as_bytes()));\n }\n\n /// Returns the path to the compressed package file.\n pub fn archive_dst(&self) -> PathBuf {\n if self.local {\n let path = if self.alternative {\n alt_registry_path()\n } else {\n registry_path()\n };\n path.join(format!(\"{}-{}.crate\", self.name, self.vers))\n } else if self.alternative {\n alt_dl_path()\n .join(&self.name)\n .join(&self.vers)\n .join(\"download\")\n } else {\n dl_path().join(&self.name).join(&self.vers).join(\"download\")\n }\n }\n}\n\n/// Generate a checksum\npub fn cksum(s: &[u8]) -> String {\n Sha256::new().update(s).finish_hex()\n}\n\nimpl Dependency {\n pub fn new(name: &str, vers: &str) -> Dependency {\n Dependency {\n name: name.to_string(),\n vers: vers.to_string(),\n kind: \"normal\".to_string(),\n artifact: None,\n bindep_target: None,\n lib: false,\n target: None,\n features: Vec::new(),\n package: None,\n optional: false,\n registry: None,\n default_features: true,\n public: false,\n }\n }\n\n /// Changes this to `[build-dependencies]`.\n pub fn build(&mut self) -> &mut Self {\n self.kind = \"build\".to_string();\n self\n }\n\n /// Changes this to `[dev-dependencies]`.\n pub fn dev(&mut self) -> &mut Self {\n self.kind = \"dev\".to_string();\n self\n }\n\n /// Changes this to `[target.$target.dependencies]`.\n pub fn target(&mut self, target: &str) -> &mut Self {\n self.target = Some(target.to_string());\n self\n }\n\n /// Change the artifact to be of the given kind, like \"bin\", or \"staticlib\",\n /// along with a specific target triple if provided.\n pub fn artifact(&mut self, kind: &str, target: Option) -> &mut Self {\n self.artifact = Some(kind.to_string());\n self.bindep_target = target;\n self\n }\n\n /// Adds `registry = $registry` to this dependency.\n pub fn registry(&mut self, registry: &str) -> &mut Self {\n self.registry = Some(registry.to_string());\n self\n }\n\n /// Adds `features = [ ... ]` to this dependency.\n pub fn enable_features(&mut self, features: &[&str]) -> &mut Self {\n self.features.extend(features.iter().map(|s| s.to_string()));\n self\n }\n\n /// Adds `package = ...` to this dependency.\n pub fn package(&mut self, pkg: &str) -> &mut Self {\n self.package = Some(pkg.to_string());\n self\n }\n\n /// Changes this to an optional dependency.\n pub fn optional(&mut self, optional: bool) -> &mut Self {\n self.optional = optional;\n self\n }\n\n /// Changes this to an public dependency.\n pub fn public(&mut self, public: bool) -> &mut Self {\n self.public = public;\n self\n }\n\n /// Adds `default-features = false` if the argument is `false`.\n pub fn default_features(&mut self, default_features: bool) -> &mut Self {\n self.default_features = default_features;\n self\n }\n}\n" }, { "path": "crates/cargo-util/Cargo.toml", "content": "[package]\nname = \"cargo-util\"\nversion = \"0.2.29\"\nrust-version = \"1.94\" # MSRV:1\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"Miscellaneous support code used by Cargo.\"\n\n[dependencies]\nanyhow.workspace = true\nfiletime.workspace = true\nhex.workspace = true\nignore.workspace = true\njobserver.workspace = true\nsame-file.workspace = true\nsha2.workspace = true\nshell-escape.workspace = true\ntempfile.workspace = true\ntracing.workspace = true\nwalkdir.workspace = true\n\n[target.'cfg(target_os = \"macos\")'.dependencies]\ncore-foundation.workspace = true\n\n[target.'cfg(unix)'.dependencies]\nlibc.workspace = true\n\n[target.'cfg(windows)'.dependencies]\nmiow.workspace = true\nwindows-sys = { workspace = true, features = [\"Win32_Storage_FileSystem\", \"Win32_Foundation\", \"Win32_System_Console\"] }\n\n[lints]\nworkspace = true\n" }, { "path": "crates/cargo-util/README.md", "content": "> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use (except as a transitive dependency). This\n> crate may make major changes to its APIs or be deprecated without warning.\n" }, { "path": "crates/cargo-util/src/du.rs", "content": "//! A simple disk usage estimator.\n\nuse anyhow::{Context, Result};\nuse ignore::overrides::OverrideBuilder;\nuse ignore::{WalkBuilder, WalkState};\nuse std::path::Path;\nuse std::sync::{Arc, Mutex};\n\n/// Determines the disk usage of all files in the given directory.\n///\n/// The given patterns are gitignore style patterns relative to the given\n/// path. If there are patterns, it will only count things matching that\n/// pattern. `!` can be used to exclude things. See [`OverrideBuilder::add`]\n/// for more info.\n///\n/// This is a primitive implementation that doesn't handle hard links, and\n/// isn't particularly fast (for example, not using `getattrlistbulk` on\n/// macOS). It also only uses actual byte sizes instead of block counts (and\n/// thus vastly undercounts directories with lots of small files). It would be\n/// nice to improve this or replace it with something better.\npub fn du(path: &Path, patterns: &[&str]) -> Result {\n du_inner(path, patterns).with_context(|| format!(\"failed to walk `{}`\", path.display()))\n}\n\nfn du_inner(path: &Path, patterns: &[&str]) -> Result {\n let mut builder = OverrideBuilder::new(path);\n for pattern in patterns {\n builder.add(pattern)?;\n }\n let overrides = builder.build()?;\n\n let mut builder = WalkBuilder::new(path);\n builder\n .overrides(overrides)\n .hidden(false)\n .parents(false)\n .ignore(false)\n .git_global(false)\n .git_ignore(false)\n .git_exclude(false);\n let walker = builder.build_parallel();\n\n // Platforms like PowerPC don't support AtomicU64, so we use a Mutex instead.\n //\n // See:\n // - https://github.com/rust-lang/cargo/pull/12981\n // - https://github.com/rust-lang/rust/pull/117916#issuecomment-1812635848\n let total = Arc::new(Mutex::new(0u64));\n\n // A slot used to indicate there was an error while walking.\n //\n // It is possible that more than one error happens (such as in different\n // threads). The error returned is arbitrary in that case.\n let err = Arc::new(Mutex::new(None));\n walker.run(|| {\n Box::new(|entry| {\n match entry {\n Ok(entry) => match entry.metadata() {\n Ok(meta) => {\n if meta.is_file() {\n let mut lock = total.lock().unwrap();\n *lock += meta.len();\n }\n }\n Err(e) => {\n *err.lock().unwrap() = Some(e.into());\n return WalkState::Quit;\n }\n },\n Err(e) => {\n *err.lock().unwrap() = Some(e.into());\n return WalkState::Quit;\n }\n }\n WalkState::Continue\n })\n });\n\n if let Some(e) = err.lock().unwrap().take() {\n return Err(e);\n }\n\n let total = *total.lock().unwrap();\n Ok(total)\n}\n" }, { "path": "crates/cargo-util/src/lib.rs", "content": "//! Miscellaneous support code used by Cargo.\n//!\n//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use (except as a transitive dependency). This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\n#![allow(clippy::disallowed_methods)]\n\npub use self::read2::read2;\npub use du::du;\npub use process_builder::ProcessBuilder;\npub use process_error::{ProcessError, exit_status_to_string, is_simple_exit_code};\npub use sha256::Sha256;\n\nmod du;\npub mod paths;\nmod process_builder;\nmod process_error;\nmod read2;\npub mod registry;\nmod sha256;\n\n/// Whether or not this running in a Continuous Integration environment.\npub fn is_ci() -> bool {\n std::env::var(\"CI\").is_ok() || std::env::var(\"TF_BUILD\").is_ok()\n}\n" }, { "path": "crates/cargo-util/src/paths.rs", "content": "//! Various utilities for working with files and paths.\n\nuse anyhow::{Context, Result};\nuse filetime::FileTime;\nuse std::env;\nuse std::ffi::{OsStr, OsString};\nuse std::fs::{self, File, Metadata, OpenOptions};\nuse std::io;\nuse std::io::prelude::*;\nuse std::iter;\nuse std::path::{Component, Path, PathBuf};\nuse tempfile::Builder as TempFileBuilder;\n\n/// Joins paths into a string suitable for the `PATH` environment variable.\n///\n/// This is equivalent to [`std::env::join_paths`], but includes a more\n/// detailed error message. The given `env` argument is the name of the\n/// environment variable this is will be used for, which is included in the\n/// error message.\npub fn join_paths>(paths: &[T], env: &str) -> Result {\n env::join_paths(paths.iter()).with_context(|| {\n let mut message = format!(\n \"failed to join paths from `${env}` together\\n\\n\\\n Check if any of path segments listed below contain an \\\n unterminated quote character or path separator:\"\n );\n for path in paths {\n use std::fmt::Write;\n write!(&mut message, \"\\n {:?}\", Path::new(path)).unwrap();\n }\n\n message\n })\n}\n\n/// Returns the name of the environment variable used for searching for\n/// dynamic libraries.\npub fn dylib_path_envvar() -> &'static str {\n if cfg!(windows) {\n \"PATH\"\n } else if cfg!(target_os = \"macos\") {\n // When loading and linking a dynamic library or bundle, dlopen\n // searches in LD_LIBRARY_PATH, DYLD_LIBRARY_PATH, PWD, and\n // DYLD_FALLBACK_LIBRARY_PATH.\n // In the Mach-O format, a dynamic library has an \"install path.\"\n // Clients linking against the library record this path, and the\n // dynamic linker, dyld, uses it to locate the library.\n // dyld searches DYLD_LIBRARY_PATH *before* the install path.\n // dyld searches DYLD_FALLBACK_LIBRARY_PATH only if it cannot\n // find the library in the install path.\n // Setting DYLD_LIBRARY_PATH can easily have unintended\n // consequences.\n //\n // Also, DYLD_LIBRARY_PATH appears to have significant performance\n // penalty starting in 10.13. Cargo's testsuite ran more than twice as\n // slow with it on CI.\n \"DYLD_FALLBACK_LIBRARY_PATH\"\n } else if cfg!(target_os = \"aix\") {\n \"LIBPATH\"\n } else {\n \"LD_LIBRARY_PATH\"\n }\n}\n\n/// Returns a list of directories that are searched for dynamic libraries.\n///\n/// Note that some operating systems will have defaults if this is empty that\n/// will need to be dealt with.\npub fn dylib_path() -> Vec {\n match env::var_os(dylib_path_envvar()) {\n Some(var) => env::split_paths(&var).collect(),\n None => Vec::new(),\n }\n}\n\n/// Normalize a path, removing things like `.` and `..`.\n///\n/// CAUTION: This does not resolve symlinks (unlike\n/// [`std::fs::canonicalize`]). This may cause incorrect or surprising\n/// behavior at times. This should be used carefully. Unfortunately,\n/// [`std::fs::canonicalize`] can be hard to use correctly, since it can often\n/// fail, or on Windows returns annoying device paths. This is a problem Cargo\n/// needs to improve on.\npub fn normalize_path(path: &Path) -> PathBuf {\n let mut components = path.components().peekable();\n let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {\n components.next();\n PathBuf::from(c.as_os_str())\n } else {\n PathBuf::new()\n };\n\n for component in components {\n match component {\n Component::Prefix(..) => unreachable!(),\n Component::RootDir => {\n ret.push(Component::RootDir);\n }\n Component::CurDir => {}\n Component::ParentDir => {\n if ret.ends_with(Component::ParentDir) {\n ret.push(Component::ParentDir);\n } else {\n let popped = ret.pop();\n if !popped && !ret.has_root() {\n ret.push(Component::ParentDir);\n }\n }\n }\n Component::Normal(c) => {\n ret.push(c);\n }\n }\n }\n ret\n}\n\n/// Returns the absolute path of where the given executable is located based\n/// on searching the `PATH` environment variable.\n///\n/// Returns an error if it cannot be found.\npub fn resolve_executable(exec: &Path) -> Result {\n if exec.components().count() == 1 {\n let paths = env::var_os(\"PATH\").ok_or_else(|| anyhow::format_err!(\"no PATH\"))?;\n let candidates = env::split_paths(&paths).flat_map(|path| {\n let candidate = path.join(&exec);\n let with_exe = if env::consts::EXE_EXTENSION.is_empty() {\n None\n } else {\n Some(candidate.with_extension(env::consts::EXE_EXTENSION))\n };\n iter::once(candidate).chain(with_exe)\n });\n for candidate in candidates {\n if candidate.is_file() {\n return Ok(candidate);\n }\n }\n\n anyhow::bail!(\"no executable for `{}` found in PATH\", exec.display())\n } else {\n Ok(exec.into())\n }\n}\n\n/// Returns metadata for a file (follows symlinks).\n///\n/// Equivalent to [`std::fs::metadata`] with better error messages.\npub fn metadata>(path: P) -> Result {\n let path = path.as_ref();\n std::fs::metadata(path)\n .with_context(|| format!(\"failed to load metadata for path `{}`\", path.display()))\n}\n\n/// Returns metadata for a file without following symlinks.\n///\n/// Equivalent to [`std::fs::metadata`] with better error messages.\npub fn symlink_metadata>(path: P) -> Result {\n let path = path.as_ref();\n std::fs::symlink_metadata(path)\n .with_context(|| format!(\"failed to load metadata for path `{}`\", path.display()))\n}\n\n/// Reads a file to a string.\n///\n/// Equivalent to [`std::fs::read_to_string`] with better error messages.\npub fn read(path: &Path) -> Result {\n match String::from_utf8(read_bytes(path)?) {\n Ok(s) => Ok(s),\n Err(_) => anyhow::bail!(\"path at `{}` was not valid utf-8\", path.display()),\n }\n}\n\n/// Reads a file into a bytes vector.\n///\n/// Equivalent to [`std::fs::read`] with better error messages.\npub fn read_bytes(path: &Path) -> Result> {\n fs::read(path).with_context(|| format!(\"failed to read `{}`\", path.display()))\n}\n\n/// Writes a file to disk.\n///\n/// Equivalent to [`std::fs::write`] with better error messages.\npub fn write, C: AsRef<[u8]>>(path: P, contents: C) -> Result<()> {\n let path = path.as_ref();\n fs::write(path, contents.as_ref())\n .with_context(|| format!(\"failed to write `{}`\", path.display()))\n}\n\n/// Writes a file to disk atomically.\n///\n/// This uses `tempfile::persist` to accomplish atomic writes.\n/// If the path is a symlink, it will follow the symlink and write to the actual target.\npub fn write_atomic, C: AsRef<[u8]>>(path: P, contents: C) -> Result<()> {\n let path = path.as_ref();\n\n // Check if the path is a symlink and follow it if it is\n let resolved_path;\n let path = if path.is_symlink() {\n resolved_path = fs::read_link(path)\n .with_context(|| format!(\"failed to read symlink at `{}`\", path.display()))?;\n &resolved_path\n } else {\n path\n };\n\n // On unix platforms, get the permissions of the original file. Copy only the user/group/other\n // read/write/execute permission bits. The tempfile lib defaults to an initial mode of 0o600,\n // and we'll set the proper permissions after creating the file.\n #[cfg(unix)]\n let perms = path.metadata().ok().map(|meta| {\n use std::os::unix::fs::PermissionsExt;\n\n // these constants are u16 on macOS\n let mask = u32::from(libc::S_IRWXU | libc::S_IRWXG | libc::S_IRWXO);\n let mode = meta.permissions().mode() & mask;\n\n std::fs::Permissions::from_mode(mode)\n });\n\n let mut tmp = TempFileBuilder::new()\n .prefix(path.file_name().unwrap())\n .tempfile_in(path.parent().unwrap())?;\n tmp.write_all(contents.as_ref())?;\n\n // On unix platforms, set the permissions on the newly created file. We can use fchmod (called\n // by the std lib; subject to change) which ignores the umask so that the new file has the same\n // permissions as the old file.\n #[cfg(unix)]\n if let Some(perms) = perms {\n tmp.as_file().set_permissions(perms)?;\n }\n\n tmp.persist(path)?;\n Ok(())\n}\n\n/// Equivalent to [`write()`], but does not write anything if the file contents\n/// are identical to the given contents.\npub fn write_if_changed, C: AsRef<[u8]>>(path: P, contents: C) -> Result<()> {\n (|| -> Result<()> {\n let contents = contents.as_ref();\n let mut f = OpenOptions::new()\n .read(true)\n .write(true)\n .create(true)\n .open(&path)?;\n let mut orig = Vec::new();\n f.read_to_end(&mut orig)?;\n if orig != contents {\n f.set_len(0)?;\n f.seek(io::SeekFrom::Start(0))?;\n f.write_all(contents)?;\n }\n Ok(())\n })()\n .with_context(|| format!(\"failed to write `{}`\", path.as_ref().display()))?;\n Ok(())\n}\n\n/// Equivalent to [`write()`], but appends to the end instead of replacing the\n/// contents.\npub fn append(path: &Path, contents: &[u8]) -> Result<()> {\n (|| -> Result<()> {\n let mut f = OpenOptions::new()\n .write(true)\n .append(true)\n .create(true)\n .open(path)?;\n\n f.write_all(contents)?;\n Ok(())\n })()\n .with_context(|| format!(\"failed to write `{}`\", path.display()))?;\n Ok(())\n}\n\n/// Creates a new file.\npub fn create>(path: P) -> Result {\n let path = path.as_ref();\n File::create(path).with_context(|| format!(\"failed to create file `{}`\", path.display()))\n}\n\n/// Opens an existing file.\npub fn open>(path: P) -> Result {\n let path = path.as_ref();\n File::open(path).with_context(|| format!(\"failed to open file `{}`\", path.display()))\n}\n\n/// Returns the last modification time of a file.\npub fn mtime(path: &Path) -> Result {\n let meta = metadata(path)?;\n Ok(FileTime::from_last_modification_time(&meta))\n}\n\n/// Returns the maximum mtime of the given path, recursing into\n/// subdirectories, and following symlinks.\npub fn mtime_recursive(path: &Path) -> Result {\n let meta = metadata(path)?;\n if !meta.is_dir() {\n return Ok(FileTime::from_last_modification_time(&meta));\n }\n let max_meta = walkdir::WalkDir::new(path)\n .follow_links(true)\n .into_iter()\n .filter_map(|e| match e {\n Ok(e) => Some(e),\n Err(e) => {\n // Ignore errors while walking. If Cargo can't access it, the\n // build script probably can't access it, either.\n tracing::debug!(\"failed to determine mtime while walking directory: {}\", e);\n None\n }\n })\n .filter_map(|e| {\n if e.path_is_symlink() {\n // Use the mtime of both the symlink and its target, to\n // handle the case where the symlink is modified to a\n // different target.\n let sym_meta = match std::fs::symlink_metadata(e.path()) {\n Ok(m) => m,\n Err(err) => {\n // I'm not sure when this is really possible (maybe a\n // race with unlinking?). Regardless, if Cargo can't\n // read it, the build script probably can't either.\n tracing::debug!(\n \"failed to determine mtime while fetching symlink metadata of {}: {}\",\n e.path().display(),\n err\n );\n return None;\n }\n };\n let sym_mtime = FileTime::from_last_modification_time(&sym_meta);\n // Walkdir follows symlinks.\n match e.metadata() {\n Ok(target_meta) => {\n let target_mtime = FileTime::from_last_modification_time(&target_meta);\n Some(sym_mtime.max(target_mtime))\n }\n Err(err) => {\n // Can't access the symlink target. If Cargo can't\n // access it, the build script probably can't access\n // it either.\n tracing::debug!(\n \"failed to determine mtime of symlink target for {}: {}\",\n e.path().display(),\n err\n );\n Some(sym_mtime)\n }\n }\n } else {\n let meta = match e.metadata() {\n Ok(m) => m,\n Err(err) => {\n // I'm not sure when this is really possible (maybe a\n // race with unlinking?). Regardless, if Cargo can't\n // read it, the build script probably can't either.\n tracing::debug!(\n \"failed to determine mtime while fetching metadata of {}: {}\",\n e.path().display(),\n err\n );\n return None;\n }\n };\n Some(FileTime::from_last_modification_time(&meta))\n }\n })\n .max()\n // or_else handles the case where there are no files in the directory.\n .unwrap_or_else(|| FileTime::from_last_modification_time(&meta));\n Ok(max_meta)\n}\n\n/// Record the current time on the filesystem (using the filesystem's clock)\n/// using a file at the given directory. Returns the current time.\npub fn set_invocation_time(path: &Path) -> Result {\n // note that if `FileTime::from_system_time(SystemTime::now());` is determined to be sufficient,\n // then this can be removed.\n let timestamp = path.join(\"invoked.timestamp\");\n write(\n ×tamp,\n \"This file has an mtime of when this was started.\",\n )?;\n let ft = mtime(×tamp)?;\n tracing::debug!(\"invocation time for {:?} is {}\", path, ft);\n Ok(ft)\n}\n\n/// Converts a path to UTF-8 bytes.\npub fn path2bytes(path: &Path) -> Result<&[u8]> {\n #[cfg(unix)]\n {\n use std::os::unix::prelude::*;\n Ok(path.as_os_str().as_bytes())\n }\n #[cfg(windows)]\n {\n match path.as_os_str().to_str() {\n Some(s) => Ok(s.as_bytes()),\n None => Err(anyhow::format_err!(\n \"invalid non-unicode path: {}\",\n path.display()\n )),\n }\n }\n}\n\n/// Converts UTF-8 bytes to a path.\npub fn bytes2path(bytes: &[u8]) -> Result {\n #[cfg(unix)]\n {\n use std::os::unix::prelude::*;\n Ok(PathBuf::from(OsStr::from_bytes(bytes)))\n }\n #[cfg(windows)]\n {\n use std::str;\n match str::from_utf8(bytes) {\n Ok(s) => Ok(PathBuf::from(s)),\n Err(..) => Err(anyhow::format_err!(\"invalid non-unicode path\")),\n }\n }\n}\n\n/// Returns an iterator that walks up the directory hierarchy towards the root.\n///\n/// Each item is a [`Path`]. It will start with the given path, finishing at\n/// the root. If the `stop_root_at` parameter is given, it will stop at the\n/// given path (which will be the last item).\npub fn ancestors<'a>(path: &'a Path, stop_root_at: Option<&Path>) -> PathAncestors<'a> {\n PathAncestors::new(path, stop_root_at)\n}\n\npub struct PathAncestors<'a> {\n current: Option<&'a Path>,\n stop_at: Option,\n}\n\nimpl<'a> PathAncestors<'a> {\n fn new(path: &'a Path, stop_root_at: Option<&Path>) -> PathAncestors<'a> {\n let stop_at = env::var(\"__CARGO_TEST_ROOT\")\n .ok()\n .map(PathBuf::from)\n .or_else(|| stop_root_at.map(|p| p.to_path_buf()));\n PathAncestors {\n current: Some(path),\n //HACK: avoid reading `~/.cargo/config` when testing Cargo itself.\n stop_at,\n }\n }\n}\n\nimpl<'a> Iterator for PathAncestors<'a> {\n type Item = &'a Path;\n\n fn next(&mut self) -> Option<&'a Path> {\n if let Some(path) = self.current {\n self.current = path.parent();\n\n if let Some(ref stop_at) = self.stop_at {\n if path == stop_at {\n self.current = None;\n }\n }\n\n Some(path)\n } else {\n None\n }\n }\n}\n\n/// Equivalent to [`std::fs::create_dir_all`] with better error messages.\npub fn create_dir_all(p: impl AsRef) -> Result<()> {\n _create_dir_all(p.as_ref())\n}\n\nfn _create_dir_all(p: &Path) -> Result<()> {\n fs::create_dir_all(p)\n .with_context(|| format!(\"failed to create directory `{}`\", p.display()))?;\n Ok(())\n}\n\n/// Equivalent to [`std::fs::remove_dir_all`] with better error messages.\n///\n/// This does *not* follow symlinks.\npub fn remove_dir_all>(p: P) -> Result<()> {\n _remove_dir_all(p.as_ref()).or_else(|prev_err| {\n // `std::fs::remove_dir_all` is highly specialized for different platforms\n // and may be more reliable than a simple walk. We try the walk first in\n // order to report more detailed errors.\n fs::remove_dir_all(p.as_ref()).with_context(|| {\n format!(\n \"{:?}\\n\\nError: failed to remove directory `{}`\",\n prev_err,\n p.as_ref().display(),\n )\n })\n })\n}\n\nfn _remove_dir_all(p: &Path) -> Result<()> {\n if symlink_metadata(p)?.is_symlink() {\n return remove_file(p);\n }\n let entries = p\n .read_dir()\n .with_context(|| format!(\"failed to read directory `{}`\", p.display()))?;\n for entry in entries {\n let entry = entry?;\n let path = entry.path();\n if entry.file_type()?.is_dir() {\n remove_dir_all(&path)?;\n } else {\n remove_file(&path)?;\n }\n }\n remove_dir(&p)\n}\n\n/// Equivalent to [`std::fs::remove_dir`] with better error messages.\npub fn remove_dir>(p: P) -> Result<()> {\n _remove_dir(p.as_ref())\n}\n\nfn _remove_dir(p: &Path) -> Result<()> {\n fs::remove_dir(p).with_context(|| format!(\"failed to remove directory `{}`\", p.display()))?;\n Ok(())\n}\n\n/// Equivalent to [`std::fs::remove_file`] with better error messages.\n///\n/// If the file is readonly, this will attempt to change the permissions to\n/// force the file to be deleted.\n/// On Windows, if the file is a symlink to a directory, this will attempt to remove\n/// the symlink itself.\npub fn remove_file>(p: P) -> Result<()> {\n _remove_file(p.as_ref())\n}\n\nfn _remove_file(p: &Path) -> Result<()> {\n // For Windows, we need to check if the file is a symlink to a directory\n // and remove the symlink itself by calling `remove_dir` instead of\n // `remove_file`.\n #[cfg(target_os = \"windows\")]\n {\n use std::os::windows::fs::FileTypeExt;\n let metadata = symlink_metadata(p)?;\n let file_type = metadata.file_type();\n if file_type.is_symlink_dir() {\n return remove_symlink_dir_with_permission_check(p);\n }\n }\n\n remove_file_with_permission_check(p)\n}\n\n#[cfg(target_os = \"windows\")]\nfn remove_symlink_dir_with_permission_check(p: &Path) -> Result<()> {\n remove_with_permission_check(fs::remove_dir, p)\n .with_context(|| format!(\"failed to remove symlink dir `{}`\", p.display()))\n}\n\nfn remove_file_with_permission_check(p: &Path) -> Result<()> {\n remove_with_permission_check(fs::remove_file, p)\n .with_context(|| format!(\"failed to remove file `{}`\", p.display()))\n}\n\nfn remove_with_permission_check(remove_func: F, p: P) -> io::Result<()>\nwhere\n F: Fn(P) -> io::Result<()>,\n P: AsRef + Clone,\n{\n match remove_func(p.clone()) {\n Ok(()) => Ok(()),\n Err(e) => {\n if e.kind() == io::ErrorKind::PermissionDenied\n && set_not_readonly(p.as_ref()).unwrap_or(false)\n {\n remove_func(p)\n } else {\n Err(e)\n }\n }\n }\n}\n\nfn set_not_readonly(p: &Path) -> io::Result {\n let mut perms = p.metadata()?.permissions();\n if !perms.readonly() {\n return Ok(false);\n }\n perms.set_readonly(false);\n fs::set_permissions(p, perms)?;\n Ok(true)\n}\n\n/// Hardlink (file) or symlink (dir) src to dst if possible, otherwise copy it.\n///\n/// If the destination already exists, it is removed before linking.\npub fn link_or_copy(src: impl AsRef, dst: impl AsRef) -> Result<()> {\n let src = src.as_ref();\n let dst = dst.as_ref();\n _link_or_copy(src, dst)\n}\n\nfn _link_or_copy(src: &Path, dst: &Path) -> Result<()> {\n tracing::debug!(\"linking {} to {}\", src.display(), dst.display());\n if same_file::is_same_file(src, dst).unwrap_or(false) {\n return Ok(());\n }\n\n // NB: we can't use dst.exists(), as if dst is a broken symlink,\n // dst.exists() will return false. This is problematic, as we still need to\n // unlink dst in this case. symlink_metadata(dst).is_ok() will tell us\n // whether dst exists *without* following symlinks, which is what we want.\n if fs::symlink_metadata(dst).is_ok() {\n remove_file(&dst)?;\n }\n\n let link_result = if src.is_dir() {\n #[cfg(unix)]\n use std::os::unix::fs::symlink;\n #[cfg(windows)]\n // FIXME: This should probably panic or have a copy fallback. Symlinks\n // are not supported in all windows environments. Currently symlinking\n // is only used for .dSYM directories on macos, but this shouldn't be\n // accidentally relied upon.\n use std::os::windows::fs::symlink_dir as symlink;\n\n let dst_dir = dst.parent().unwrap();\n let src = if src.starts_with(dst_dir) {\n src.strip_prefix(dst_dir).unwrap()\n } else {\n src\n };\n symlink(src, dst)\n } else {\n if cfg!(target_os = \"macos\") {\n // There seems to be a race condition with APFS when hard-linking\n // binaries. Gatekeeper does not have signing or hash information\n // stored in kernel when running the process. Therefore killing it.\n // This problem does not appear when copying files as kernel has\n // time to process it. Note that: fs::copy on macos is using\n // CopyOnWrite (syscall fclonefileat) which should be as fast as\n // hardlinking. See these issues for the details:\n //\n // * https://github.com/rust-lang/cargo/issues/7821\n // * https://github.com/rust-lang/cargo/issues/10060\n fs::copy(src, dst).map_or_else(\n |e| {\n if e.raw_os_error()\n .map_or(false, |os_err| os_err == 35 /* libc::EAGAIN */)\n {\n tracing::info!(\"copy failed {e:?}. falling back to fs::hard_link\");\n\n // Working around an issue copying too fast with zfs (probably related to\n // https://github.com/openzfsonosx/zfs/issues/809)\n // See https://github.com/rust-lang/cargo/issues/13838\n fs::hard_link(src, dst)\n } else {\n Err(e)\n }\n },\n |_| Ok(()),\n )\n } else {\n fs::hard_link(src, dst)\n }\n };\n link_result\n .or_else(|err| {\n tracing::debug!(\"link failed {}. falling back to fs::copy\", err);\n fs::copy(src, dst).map(|_| ())\n })\n .with_context(|| {\n format!(\n \"failed to link or copy `{}` to `{}`\",\n src.display(),\n dst.display()\n )\n })?;\n Ok(())\n}\n\n/// Copies a file from one location to another.\n///\n/// Equivalent to [`std::fs::copy`] with better error messages.\npub fn copy, Q: AsRef>(from: P, to: Q) -> Result {\n let from = from.as_ref();\n let to = to.as_ref();\n fs::copy(from, to)\n .with_context(|| format!(\"failed to copy `{}` to `{}`\", from.display(), to.display()))\n}\n\n/// Changes the filesystem mtime (and atime if possible) for the given file.\n///\n/// This intentionally does not return an error, as this is sometimes not\n/// supported on network filesystems. For the current uses in Cargo, this is a\n/// \"best effort\" approach, and errors shouldn't be propagated.\npub fn set_file_time_no_err>(path: P, time: FileTime) {\n let path = path.as_ref();\n match filetime::set_file_times(path, time, time) {\n Ok(()) => tracing::debug!(\"set file mtime {} to {}\", path.display(), time),\n Err(e) => tracing::warn!(\n \"could not set mtime of {} to {}: {:?}\",\n path.display(),\n time,\n e\n ),\n }\n}\n\n/// Strips `base` from `path`.\n///\n/// This canonicalizes both paths before stripping. This is useful if the\n/// paths are obtained in different ways, and one or the other may or may not\n/// have been normalized in some way.\npub fn strip_prefix_canonical(\n path: impl AsRef,\n base: impl AsRef,\n) -> Result {\n // Not all filesystems support canonicalize. Just ignore if it doesn't work.\n let safe_canonicalize = |path: &Path| match path.canonicalize() {\n Ok(p) => p,\n Err(e) => {\n tracing::warn!(\"cannot canonicalize {:?}: {:?}\", path, e);\n path.to_path_buf()\n }\n };\n let canon_path = safe_canonicalize(path.as_ref());\n let canon_base = safe_canonicalize(base.as_ref());\n canon_path.strip_prefix(canon_base).map(|p| p.to_path_buf())\n}\n\n/// Creates an excluded from cache directory atomically with its parents as needed.\n///\n/// The atomicity only covers creating the leaf directory and exclusion from cache. Any missing\n/// parent directories will not be created in an atomic manner.\n///\n/// This function is idempotent and in addition to that it won't exclude ``p`` from cache if it\n/// already exists.\npub fn create_dir_all_excluded_from_backups_atomic(p: impl AsRef) -> Result<()> {\n let path = p.as_ref();\n if path.is_dir() {\n return Ok(());\n }\n\n let parent = path.parent().unwrap();\n let base = path.file_name().unwrap();\n create_dir_all(parent)?;\n // We do this in two steps (first create a temporary directory and exclude\n // it from backups, then rename it to the desired name. If we created the\n // directory directly where it should be and then excluded it from backups\n // we would risk a situation where cargo is interrupted right after the directory\n // creation but before the exclusion the directory would remain non-excluded from\n // backups because we only perform exclusion right after we created the directory\n // ourselves.\n //\n // We need the tempdir created in parent instead of $TMP, because only then we can be\n // easily sure that rename() will succeed (the new name needs to be on the same mount\n // point as the old one).\n let tempdir = TempFileBuilder::new().prefix(base).tempdir_in(parent)?;\n exclude_from_backups(tempdir.path());\n exclude_from_content_indexing(tempdir.path());\n // Previously std::fs::create_dir_all() (through paths::create_dir_all()) was used\n // here to create the directory directly and fs::create_dir_all() explicitly treats\n // the directory being created concurrently by another thread or process as success,\n // hence the check below to follow the existing behavior. If we get an error at\n // rename() and suddenly the directory (which didn't exist a moment earlier) exists\n // we can infer from it's another cargo process doing work.\n if let Err(e) = fs::rename(tempdir.path(), path) {\n if !path.exists() {\n return Err(anyhow::Error::from(e))\n .with_context(|| format!(\"failed to create directory `{}`\", path.display()));\n }\n }\n Ok(())\n}\n\n/// Mark an existing directory as excluded from backups and indexing.\n///\n/// Errors in marking it are ignored.\npub fn exclude_from_backups_and_indexing(p: impl AsRef) {\n let path = p.as_ref();\n exclude_from_backups(path);\n exclude_from_content_indexing(path);\n}\n\n/// Marks the directory as excluded from archives/backups.\n///\n/// This is recommended to prevent derived/temporary files from bloating backups. There are two\n/// mechanisms used to achieve this right now:\n///\n/// * A dedicated resource property excluding from Time Machine backups on macOS\n/// * CACHEDIR.TAG files supported by various tools in a platform-independent way\nfn exclude_from_backups(path: &Path) {\n exclude_from_time_machine_and_cloud_sync(path);\n let file = path.join(\"CACHEDIR.TAG\");\n if !file.exists() {\n let _ = std::fs::write(\n file,\n \"Signature: 8a477f597d28d172789f06886806bc55\n# This file is a cache directory tag created by cargo.\n# For information about cache directory tags see https://bford.info/cachedir/\n\",\n );\n // Similarly to exclude_from_time_machine_and_cloud_sync() we ignore errors here as it's an optional feature.\n }\n}\n\n/// Marks the directory as excluded from content indexing.\n///\n/// This is recommended to prevent the content of derived/temporary files from being indexed.\n/// This is very important for Windows users, as the live content indexing significantly slows\n/// cargo's I/O operations.\n///\n/// This is currently a no-op on non-Windows platforms.\nfn exclude_from_content_indexing(path: &Path) {\n #[cfg(windows)]\n {\n use std::iter::once;\n use std::os::windows::prelude::OsStrExt;\n use windows_sys::Win32::Storage::FileSystem::{\n FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, GetFileAttributesW, SetFileAttributesW,\n };\n\n let path: Vec = path.as_os_str().encode_wide().chain(once(0)).collect();\n unsafe {\n SetFileAttributesW(\n path.as_ptr(),\n GetFileAttributesW(path.as_ptr()) | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,\n );\n }\n }\n #[cfg(not(windows))]\n {\n let _ = path;\n }\n}\n\n#[cfg(not(target_os = \"macos\"))]\nfn exclude_from_time_machine_and_cloud_sync(_: &Path) {}\n\n#[cfg(target_os = \"macos\")]\n/// Marks files or directories as excluded from Time Machine and iCloud Drive on macOS\nfn exclude_from_time_machine_and_cloud_sync(path: &Path) {\n use core_foundation::base::TCFType;\n use core_foundation::{number, string, url};\n use std::ptr;\n\n let path = match url::CFURL::from_path(path, false) {\n Some(url) => url,\n None => return,\n };\n\n // For compatibility with old systems strings are used instead of global symbols\n const KEY_NAMES: [&str; 2] = [\n \"NSURLIsExcludedFromBackupKey\", // kCFURLIsExcludedFromBackupKey\n \"NSURLUbiquitousItemIsExcludedFromSyncKey\", // kCFURLUbiquitousItemIsExcludedFromSyncKey\n ];\n\n for key_name in KEY_NAMES {\n let is_excluded_key = match key_name.parse::() {\n Ok(key) => key,\n Err(_) => continue,\n };\n unsafe {\n url::CFURLSetResourcePropertyForKey(\n path.as_concrete_TypeRef(),\n is_excluded_key.as_concrete_TypeRef(),\n number::kCFBooleanTrue as *const _,\n ptr::null_mut(),\n );\n }\n }\n // Errors are ignored, since it's an optional feature and failure\n // doesn't prevent Cargo from working\n}\n\n#[cfg(test)]\nmod tests {\n use super::join_paths;\n use super::normalize_path;\n use super::write;\n use super::write_atomic;\n\n #[test]\n fn test_normalize_path() {\n let cases = &[\n (\"\", \"\"),\n (\".\", \"\"),\n (\".////./.\", \"\"),\n (\"/\", \"/\"),\n (\"/..\", \"/\"),\n (\"/foo/bar\", \"/foo/bar\"),\n (\"/foo/bar/\", \"/foo/bar\"),\n (\"/foo/bar/./././///\", \"/foo/bar\"),\n (\"/foo/bar/..\", \"/foo\"),\n (\"/foo/bar/../..\", \"/\"),\n (\"/foo/bar/../../..\", \"/\"),\n (\"foo/bar\", \"foo/bar\"),\n (\"foo/bar/\", \"foo/bar\"),\n (\"foo/bar/./././///\", \"foo/bar\"),\n (\"foo/bar/..\", \"foo\"),\n (\"foo/bar/../..\", \"\"),\n (\"foo/bar/../../..\", \"..\"),\n (\"../../foo/bar\", \"../../foo/bar\"),\n (\"../../foo/bar/\", \"../../foo/bar\"),\n (\"../../foo/bar/./././///\", \"../../foo/bar\"),\n (\"../../foo/bar/..\", \"../../foo\"),\n (\"../../foo/bar/../..\", \"../..\"),\n (\"../../foo/bar/../../..\", \"../../..\"),\n ];\n for (input, expected) in cases {\n let actual = normalize_path(std::path::Path::new(input));\n assert_eq!(actual, std::path::Path::new(expected), \"input: {input}\");\n }\n }\n\n #[test]\n fn write_works() {\n let original_contents = \"[dependencies]\\nfoo = 0.1.0\";\n\n let tmpdir = tempfile::tempdir().unwrap();\n let path = tmpdir.path().join(\"Cargo.toml\");\n write(&path, original_contents).unwrap();\n let contents = std::fs::read_to_string(&path).unwrap();\n assert_eq!(contents, original_contents);\n }\n #[test]\n fn write_atomic_works() {\n let original_contents = \"[dependencies]\\nfoo = 0.1.0\";\n\n let tmpdir = tempfile::tempdir().unwrap();\n let path = tmpdir.path().join(\"Cargo.toml\");\n write_atomic(&path, original_contents).unwrap();\n let contents = std::fs::read_to_string(&path).unwrap();\n assert_eq!(contents, original_contents);\n }\n\n #[test]\n #[cfg(unix)]\n fn write_atomic_permissions() {\n use std::os::unix::fs::PermissionsExt;\n\n let original_perms = std::fs::Permissions::from_mode(u32::from(\n libc::S_IRWXU | libc::S_IRGRP | libc::S_IWGRP | libc::S_IROTH,\n ));\n\n let tmp = tempfile::Builder::new().tempfile().unwrap();\n\n // need to set the permissions after creating the file to avoid umask\n tmp.as_file()\n .set_permissions(original_perms.clone())\n .unwrap();\n\n // after this call, the file at `tmp.path()` will not be the same as the file held by `tmp`\n write_atomic(tmp.path(), \"new\").unwrap();\n assert_eq!(std::fs::read_to_string(tmp.path()).unwrap(), \"new\");\n\n let new_perms = std::fs::metadata(tmp.path()).unwrap().permissions();\n\n let mask = u32::from(libc::S_IRWXU | libc::S_IRWXG | libc::S_IRWXO);\n assert_eq!(original_perms.mode(), new_perms.mode() & mask);\n }\n\n #[test]\n fn join_paths_lists_paths_on_error() {\n let valid_paths = vec![\"/testing/one\", \"/testing/two\"];\n // does not fail on valid input\n let _joined = join_paths(&valid_paths, \"TESTING1\").unwrap();\n\n #[cfg(unix)]\n {\n let invalid_paths = vec![\"/testing/one\", \"/testing/t:wo/three\"];\n let err = join_paths(&invalid_paths, \"TESTING2\").unwrap_err();\n assert_eq!(\n err.to_string(),\n \"failed to join paths from `$TESTING2` together\\n\\n\\\n Check if any of path segments listed below contain an \\\n unterminated quote character or path separator:\\\n \\n \\\"/testing/one\\\"\\\n \\n \\\"/testing/t:wo/three\\\"\\\n \"\n );\n }\n #[cfg(windows)]\n {\n let invalid_paths = vec![\"/testing/one\", \"/testing/t\\\"wo/three\"];\n let err = join_paths(&invalid_paths, \"TESTING2\").unwrap_err();\n assert_eq!(\n err.to_string(),\n \"failed to join paths from `$TESTING2` together\\n\\n\\\n Check if any of path segments listed below contain an \\\n unterminated quote character or path separator:\\\n \\n \\\"/testing/one\\\"\\\n \\n \\\"/testing/t\\\\\\\"wo/three\\\"\\\n \"\n );\n }\n }\n\n #[test]\n fn write_atomic_symlink() {\n let tmpdir = tempfile::tempdir().unwrap();\n let target_path = tmpdir.path().join(\"target.txt\");\n let symlink_path = tmpdir.path().join(\"symlink.txt\");\n\n // Create initial file\n write(&target_path, \"initial\").unwrap();\n\n // Create symlink\n #[cfg(unix)]\n std::os::unix::fs::symlink(&target_path, &symlink_path).unwrap();\n #[cfg(windows)]\n std::os::windows::fs::symlink_file(&target_path, &symlink_path).unwrap();\n\n // Write through symlink\n write_atomic(&symlink_path, \"updated\").unwrap();\n\n // Verify both paths show the updated content\n assert_eq!(std::fs::read_to_string(&target_path).unwrap(), \"updated\");\n assert_eq!(std::fs::read_to_string(&symlink_path).unwrap(), \"updated\");\n\n // Verify symlink still exists and points to the same target\n assert!(symlink_path.is_symlink());\n assert_eq!(std::fs::read_link(&symlink_path).unwrap(), target_path);\n }\n\n #[test]\n #[cfg(windows)]\n fn test_remove_symlink_dir() {\n use super::*;\n use std::fs;\n use std::os::windows::fs::symlink_dir;\n\n let tmpdir = tempfile::tempdir().unwrap();\n let dir_path = tmpdir.path().join(\"testdir\");\n let symlink_path = tmpdir.path().join(\"symlink\");\n\n fs::create_dir(&dir_path).unwrap();\n\n symlink_dir(&dir_path, &symlink_path).expect(\"failed to create symlink\");\n\n assert!(symlink_path.exists());\n\n assert!(remove_file(symlink_path.clone()).is_ok());\n\n assert!(!symlink_path.exists());\n assert!(dir_path.exists());\n }\n\n #[test]\n #[cfg(windows)]\n fn test_remove_symlink_file() {\n use super::*;\n use std::fs;\n use std::os::windows::fs::symlink_file;\n\n let tmpdir = tempfile::tempdir().unwrap();\n let file_path = tmpdir.path().join(\"testfile\");\n let symlink_path = tmpdir.path().join(\"symlink\");\n\n fs::write(&file_path, b\"test\").unwrap();\n\n symlink_file(&file_path, &symlink_path).expect(\"failed to create symlink\");\n\n assert!(symlink_path.exists());\n\n assert!(remove_file(symlink_path.clone()).is_ok());\n\n assert!(!symlink_path.exists());\n assert!(file_path.exists());\n }\n}\n" }, { "path": "crates/cargo-util/src/process_builder.rs", "content": "use crate::process_error::ProcessError;\nuse crate::read2;\n\nuse anyhow::{Context, Result, bail};\nuse jobserver::Client;\nuse shell_escape::escape;\nuse tempfile::NamedTempFile;\n\nuse std::collections::BTreeMap;\nuse std::env;\nuse std::ffi::{OsStr, OsString};\nuse std::fmt;\nuse std::io::{self, Write};\nuse std::iter::once;\nuse std::path::Path;\nuse std::process::{Command, ExitStatus, Output, Stdio};\n\n/// A builder object for an external process, similar to [`std::process::Command`].\n#[derive(Clone, Debug)]\npub struct ProcessBuilder {\n /// The program to execute.\n program: OsString,\n /// Best-effort replacement for arg0\n arg0: Option,\n /// A list of arguments to pass to the program.\n args: Vec,\n /// Any environment variables that should be set for the program.\n env: BTreeMap>,\n /// The directory to run the program from.\n cwd: Option,\n /// A list of wrappers that wrap the original program when calling\n /// [`ProcessBuilder::wrapped`]. The last one is the outermost one.\n wrappers: Vec,\n /// The `make` jobserver. See the [jobserver crate] for\n /// more information.\n ///\n /// [jobserver crate]: https://docs.rs/jobserver/\n jobserver: Option,\n /// `true` to include environment variable in display.\n display_env_vars: bool,\n /// `true` to retry with an argfile if hitting \"command line too big\" error.\n /// See [`ProcessBuilder::retry_with_argfile`] for more information.\n retry_with_argfile: bool,\n /// Data to write to stdin.\n stdin: Option>,\n}\n\nimpl fmt::Display for ProcessBuilder {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"`\")?;\n\n if self.display_env_vars {\n for (key, val) in self.env.iter() {\n if let Some(val) = val {\n let val = escape(val.to_string_lossy());\n if cfg!(windows) {\n write!(f, \"set {}={}&& \", key, val)?;\n } else {\n write!(f, \"{}={} \", key, val)?;\n }\n }\n }\n }\n\n write!(f, \"{}\", self.get_program().to_string_lossy())?;\n\n for arg in self.get_args() {\n write!(f, \" {}\", escape(arg.to_string_lossy()))?;\n }\n\n write!(f, \"`\")\n }\n}\n\nimpl ProcessBuilder {\n /// Creates a new [`ProcessBuilder`] with the given executable path.\n pub fn new>(cmd: T) -> ProcessBuilder {\n ProcessBuilder {\n program: cmd.as_ref().to_os_string(),\n arg0: None,\n args: Vec::new(),\n cwd: None,\n env: BTreeMap::new(),\n wrappers: Vec::new(),\n jobserver: None,\n display_env_vars: false,\n retry_with_argfile: false,\n stdin: None,\n }\n }\n\n /// (chainable) Sets the executable for the process.\n pub fn program>(&mut self, program: T) -> &mut ProcessBuilder {\n self.program = program.as_ref().to_os_string();\n self\n }\n\n /// (chainable) Overrides `arg0` for this program.\n pub fn arg0>(&mut self, arg: T) -> &mut ProcessBuilder {\n self.arg0 = Some(arg.as_ref().to_os_string());\n self\n }\n\n /// (chainable) Adds `arg` to the args list.\n pub fn arg>(&mut self, arg: T) -> &mut ProcessBuilder {\n self.args.push(arg.as_ref().to_os_string());\n self\n }\n\n /// (chainable) Adds multiple `args` to the args list.\n pub fn args>(&mut self, args: &[T]) -> &mut ProcessBuilder {\n self.args\n .extend(args.iter().map(|t| t.as_ref().to_os_string()));\n self\n }\n\n /// (chainable) Replaces the args list with the given `args`.\n pub fn args_replace>(&mut self, args: &[T]) -> &mut ProcessBuilder {\n if let Some(program) = self.wrappers.pop() {\n // User intend to replace all args, so we\n // - use the outermost wrapper as the main program, and\n // - cleanup other inner wrappers.\n self.program = program;\n self.wrappers = Vec::new();\n }\n self.args = args.iter().map(|t| t.as_ref().to_os_string()).collect();\n self\n }\n\n /// (chainable) Sets the current working directory of the process.\n pub fn cwd>(&mut self, path: T) -> &mut ProcessBuilder {\n self.cwd = Some(path.as_ref().to_os_string());\n self\n }\n\n /// (chainable) Sets an environment variable for the process.\n pub fn env>(&mut self, key: &str, val: T) -> &mut ProcessBuilder {\n self.env\n .insert(key.to_string(), Some(val.as_ref().to_os_string()));\n self\n }\n\n /// (chainable) Unsets an environment variable for the process.\n pub fn env_remove(&mut self, key: &str) -> &mut ProcessBuilder {\n self.env.insert(key.to_string(), None);\n self\n }\n\n /// Gets the executable name.\n pub fn get_program(&self) -> &OsString {\n self.wrappers.last().unwrap_or(&self.program)\n }\n\n /// Gets the program arg0.\n pub fn get_arg0(&self) -> Option<&OsStr> {\n self.arg0.as_deref()\n }\n\n /// Gets the program arguments.\n pub fn get_args(&self) -> impl Iterator {\n self.wrappers\n .iter()\n .rev()\n .chain(once(&self.program))\n .chain(self.args.iter())\n .skip(1) // Skip the main `program\n }\n\n /// Gets the current working directory for the process.\n pub fn get_cwd(&self) -> Option<&Path> {\n self.cwd.as_ref().map(Path::new)\n }\n\n /// Gets an environment variable as the process will see it (will inherit from environment\n /// unless explicitly unset).\n pub fn get_env(&self, var: &str) -> Option {\n self.env\n .get(var)\n .cloned()\n .or_else(|| Some(env::var_os(var)))\n .and_then(|s| s)\n }\n\n /// Gets all environment variables explicitly set or unset for the process (not inherited\n /// vars).\n pub fn get_envs(&self) -> &BTreeMap> {\n &self.env\n }\n\n /// Sets the `make` jobserver. See the [jobserver crate][jobserver_docs] for\n /// more information.\n ///\n /// [jobserver_docs]: https://docs.rs/jobserver/latest/jobserver/\n pub fn inherit_jobserver(&mut self, jobserver: &Client) -> &mut Self {\n self.jobserver = Some(jobserver.clone());\n self\n }\n\n /// Enables environment variable display.\n pub fn display_env_vars(&mut self) -> &mut Self {\n self.display_env_vars = true;\n self\n }\n\n /// Enables retrying with an argfile if hitting \"command line too big\" error\n ///\n /// This is primarily for the `@path` arg of rustc and rustdoc, which treat\n /// each line as an command-line argument, so `LF` and `CRLF` bytes are not\n /// valid as an argument for argfile at this moment.\n /// For example, `RUSTDOCFLAGS=\"--crate-version foo\\nbar\" cargo doc` is\n /// valid when invoking from command-line but not from argfile.\n ///\n /// To sum up, the limitations of the argfile are:\n ///\n /// - Must be valid UTF-8 encoded.\n /// - Must not contain any newlines in each argument.\n ///\n /// Ref:\n ///\n /// - \n /// - \n pub fn retry_with_argfile(&mut self, enabled: bool) -> &mut Self {\n self.retry_with_argfile = enabled;\n self\n }\n\n /// Sets a value that will be written to stdin of the process on launch.\n pub fn stdin>>(&mut self, stdin: T) -> &mut Self {\n self.stdin = Some(stdin.into());\n self\n }\n\n fn should_retry_with_argfile(&self, err: &io::Error) -> bool {\n self.retry_with_argfile && imp::command_line_too_big(err)\n }\n\n /// Like [`Command::status`] but with a better error message.\n pub fn status(&self) -> Result {\n self._status()\n .with_context(|| ProcessError::could_not_execute(self))\n }\n\n fn _status(&self) -> io::Result {\n if !debug_force_argfile(self.retry_with_argfile) {\n let mut cmd = self.build_command();\n match cmd.spawn() {\n Err(ref e) if self.should_retry_with_argfile(e) => {}\n Err(e) => return Err(e),\n Ok(mut child) => return child.wait(),\n }\n }\n let (mut cmd, argfile) = self.build_command_with_argfile()?;\n let status = cmd.spawn()?.wait();\n close_tempfile_and_log_error(argfile);\n status\n }\n\n /// Runs the process, waiting for completion, and mapping non-success exit codes to an error.\n pub fn exec(&self) -> Result<()> {\n let exit = self.status()?;\n if exit.success() {\n Ok(())\n } else {\n Err(ProcessError::new(\n &format!(\"process didn't exit successfully: {}\", self),\n Some(exit),\n None,\n )\n .into())\n }\n }\n\n /// Replaces the current process with the target process.\n ///\n /// On Unix, this executes the process using the Unix syscall `execvp`, which will block\n /// this process, and will only return if there is an error.\n ///\n /// On Windows this isn't technically possible. Instead we emulate it to the best of our\n /// ability. One aspect we fix here is that we specify a handler for the Ctrl-C handler.\n /// In doing so (and by effectively ignoring it) we should emulate proxying Ctrl-C\n /// handling to the application at hand, which will either terminate or handle it itself.\n /// According to Microsoft's documentation at\n /// .\n /// the Ctrl-C signal is sent to all processes attached to a terminal, which should\n /// include our child process. If the child terminates then we'll reap them in Cargo\n /// pretty quickly, and if the child handles the signal then we won't terminate\n /// (and we shouldn't!) until the process itself later exits.\n pub fn exec_replace(&self) -> Result<()> {\n imp::exec_replace(self)\n }\n\n /// Like [`Command::output`] but with a better error message.\n pub fn output(&self) -> Result {\n self._output()\n .with_context(|| ProcessError::could_not_execute(self))\n }\n\n fn _output(&self) -> io::Result {\n if !debug_force_argfile(self.retry_with_argfile) {\n let mut cmd = self.build_command();\n match piped(&mut cmd, self.stdin.is_some()).spawn() {\n Err(ref e) if self.should_retry_with_argfile(e) => {}\n Err(e) => return Err(e),\n Ok(mut child) => {\n if let Some(stdin) = &self.stdin {\n child.stdin.take().unwrap().write_all(stdin)?;\n }\n return child.wait_with_output();\n }\n }\n }\n let (mut cmd, argfile) = self.build_command_with_argfile()?;\n let mut child = piped(&mut cmd, self.stdin.is_some()).spawn()?;\n if let Some(stdin) = &self.stdin {\n child.stdin.take().unwrap().write_all(stdin)?;\n }\n let output = child.wait_with_output();\n close_tempfile_and_log_error(argfile);\n output\n }\n\n /// Executes the process, returning the stdio output, or an error if non-zero exit status.\n pub fn exec_with_output(&self) -> Result {\n let output = self.output()?;\n if output.status.success() {\n Ok(output)\n } else {\n Err(ProcessError::new(\n &format!(\"process didn't exit successfully: {}\", self),\n Some(output.status),\n Some(&output),\n )\n .into())\n }\n }\n\n /// Executes a command, passing each line of stdout and stderr to the supplied callbacks, which\n /// can mutate the string data.\n ///\n /// If any invocations of these function return an error, it will be propagated.\n ///\n /// If `capture_output` is true, then all the output will also be buffered\n /// and stored in the returned `Output` object. If it is false, no caching\n /// is done, and the callbacks are solely responsible for handling the\n /// output.\n pub fn exec_with_streaming(\n &self,\n on_stdout_line: &mut dyn FnMut(&str) -> Result<()>,\n on_stderr_line: &mut dyn FnMut(&str) -> Result<()>,\n capture_output: bool,\n ) -> Result {\n let mut stdout = Vec::new();\n let mut stderr = Vec::new();\n\n let mut callback_error = None;\n let mut stdout_pos = 0;\n let mut stderr_pos = 0;\n\n let spawn = |mut cmd| {\n if !debug_force_argfile(self.retry_with_argfile) {\n match piped(&mut cmd, false).spawn() {\n Err(ref e) if self.should_retry_with_argfile(e) => {}\n Err(e) => return Err(e),\n Ok(child) => return Ok((child, None)),\n }\n }\n let (mut cmd, argfile) = self.build_command_with_argfile()?;\n Ok((piped(&mut cmd, false).spawn()?, Some(argfile)))\n };\n\n let status = (|| {\n let cmd = self.build_command();\n let (mut child, argfile) = spawn(cmd)?;\n let out = child.stdout.take().unwrap();\n let err = child.stderr.take().unwrap();\n read2(out, err, &mut |is_out, data, eof| {\n let pos = if is_out {\n &mut stdout_pos\n } else {\n &mut stderr_pos\n };\n let idx = if eof {\n data.len()\n } else {\n match data[*pos..].iter().rposition(|b| *b == b'\\n') {\n Some(i) => *pos + i + 1,\n None => {\n *pos = data.len();\n return;\n }\n }\n };\n\n let new_lines = &data[..idx];\n\n for line in String::from_utf8_lossy(new_lines).lines() {\n if callback_error.is_some() {\n break;\n }\n let callback_result = if is_out {\n on_stdout_line(line)\n } else {\n on_stderr_line(line)\n };\n if let Err(e) = callback_result {\n callback_error = Some(e);\n break;\n }\n }\n\n if capture_output {\n let dst = if is_out { &mut stdout } else { &mut stderr };\n dst.extend(new_lines);\n }\n\n data.drain(..idx);\n *pos = 0;\n })?;\n let status = child.wait();\n if let Some(argfile) = argfile {\n close_tempfile_and_log_error(argfile);\n }\n status\n })()\n .with_context(|| ProcessError::could_not_execute(self))?;\n let output = Output {\n status,\n stdout,\n stderr,\n };\n\n {\n let to_print = if capture_output { Some(&output) } else { None };\n if let Some(e) = callback_error {\n let cx = ProcessError::new(\n &format!(\"failed to parse process output: {}\", self),\n Some(output.status),\n to_print,\n );\n bail!(anyhow::Error::new(cx).context(e));\n } else if !output.status.success() {\n bail!(ProcessError::new(\n &format!(\"process didn't exit successfully: {}\", self),\n Some(output.status),\n to_print,\n ));\n }\n }\n\n Ok(output)\n }\n\n /// Builds the command with an `@` argfile that contains all the\n /// arguments. This is primarily served for rustc/rustdoc command family.\n fn build_command_with_argfile(&self) -> io::Result<(Command, NamedTempFile)> {\n use std::io::Write as _;\n\n let mut tmp = tempfile::Builder::new()\n .prefix(\"cargo-argfile.\")\n .tempfile()?;\n\n let mut arg = OsString::from(\"@\");\n arg.push(tmp.path());\n let mut cmd = self.build_command_without_args();\n cmd.arg(arg);\n tracing::debug!(\"created argfile at {} for {self}\", tmp.path().display());\n\n let cap = self.get_args().map(|arg| arg.len() + 1).sum::();\n let mut buf = Vec::with_capacity(cap);\n for arg in &self.args {\n let arg = arg.to_str().ok_or_else(|| {\n io::Error::new(\n io::ErrorKind::Other,\n format!(\n \"argument for argfile contains invalid UTF-8 characters: `{}`\",\n arg.to_string_lossy()\n ),\n )\n })?;\n if arg.contains('\\n') {\n return Err(io::Error::new(\n io::ErrorKind::Other,\n format!(\"argument for argfile contains newlines: `{arg}`\"),\n ));\n }\n writeln!(buf, \"{arg}\")?;\n }\n tmp.write_all(&mut buf)?;\n Ok((cmd, tmp))\n }\n\n /// Builds a command from `ProcessBuilder` for everything but not `args`.\n fn build_command_without_args(&self) -> Command {\n let mut command = {\n let mut iter = self.wrappers.iter().rev().chain(once(&self.program));\n let mut cmd = Command::new(iter.next().expect(\"at least one `program` exists\"));\n cmd.args(iter);\n cmd\n };\n #[cfg(unix)]\n if let Some(arg0) = self.get_arg0() {\n use std::os::unix::process::CommandExt as _;\n command.arg0(arg0);\n }\n if let Some(cwd) = self.get_cwd() {\n command.current_dir(cwd);\n }\n for (k, v) in &self.env {\n match *v {\n Some(ref v) => {\n command.env(k, v);\n }\n None => {\n command.env_remove(k);\n }\n }\n }\n if let Some(ref c) = self.jobserver {\n c.configure(&mut command);\n }\n command\n }\n\n /// Converts `ProcessBuilder` into a `std::process::Command`, and handles\n /// the jobserver, if present.\n ///\n /// Note that this method doesn't take argfile fallback into account. The\n /// caller should handle it by themselves.\n pub fn build_command(&self) -> Command {\n let mut command = self.build_command_without_args();\n for arg in &self.args {\n command.arg(arg);\n }\n command\n }\n\n /// Wraps an existing command with the provided wrapper, if it is present and valid.\n ///\n /// # Examples\n ///\n /// ```rust\n /// use cargo_util::ProcessBuilder;\n /// // Running this would execute `rustc`\n /// let cmd = ProcessBuilder::new(\"rustc\");\n ///\n /// // Running this will execute `sccache rustc`\n /// let cmd = cmd.wrapped(Some(\"sccache\"));\n /// ```\n pub fn wrapped(mut self, wrapper: Option>) -> Self {\n if let Some(wrapper) = wrapper.as_ref() {\n let wrapper = wrapper.as_ref();\n if !wrapper.is_empty() {\n self.wrappers.push(wrapper.to_os_string());\n }\n }\n self\n }\n}\n\n/// Forces the command to use `@path` argfile.\n///\n/// You should set `__CARGO_TEST_FORCE_ARGFILE` to enable this.\nfn debug_force_argfile(retry_enabled: bool) -> bool {\n cfg!(debug_assertions) && env::var(\"__CARGO_TEST_FORCE_ARGFILE\").is_ok() && retry_enabled\n}\n\n/// Creates new pipes for stderr, stdout, and optionally stdin.\nfn piped(cmd: &mut Command, pipe_stdin: bool) -> &mut Command {\n cmd.stdout(Stdio::piped())\n .stderr(Stdio::piped())\n .stdin(if pipe_stdin {\n Stdio::piped()\n } else {\n Stdio::null()\n })\n}\n\nfn close_tempfile_and_log_error(file: NamedTempFile) {\n file.close().unwrap_or_else(|e| {\n tracing::warn!(\"failed to close temporary file: {e}\");\n });\n}\n\n#[cfg(unix)]\nmod imp {\n use super::{ProcessBuilder, ProcessError, close_tempfile_and_log_error, debug_force_argfile};\n use anyhow::Result;\n use std::io;\n use std::os::unix::process::CommandExt;\n\n pub fn exec_replace(process_builder: &ProcessBuilder) -> Result<()> {\n let mut error;\n let mut file = None;\n if debug_force_argfile(process_builder.retry_with_argfile) {\n let (mut command, argfile) = process_builder.build_command_with_argfile()?;\n file = Some(argfile);\n error = command.exec()\n } else {\n let mut command = process_builder.build_command();\n error = command.exec();\n if process_builder.should_retry_with_argfile(&error) {\n let (mut command, argfile) = process_builder.build_command_with_argfile()?;\n file = Some(argfile);\n error = command.exec()\n }\n }\n if let Some(file) = file {\n close_tempfile_and_log_error(file);\n }\n\n Err(anyhow::Error::from(error).context(ProcessError::new(\n &format!(\"could not execute process {}\", process_builder),\n None,\n None,\n )))\n }\n\n pub fn command_line_too_big(err: &io::Error) -> bool {\n err.raw_os_error() == Some(libc::E2BIG)\n }\n}\n\n#[cfg(windows)]\nmod imp {\n use super::{ProcessBuilder, ProcessError};\n use anyhow::Result;\n use std::io;\n use windows_sys::Win32::Foundation::{FALSE, TRUE};\n use windows_sys::Win32::System::Console::SetConsoleCtrlHandler;\n use windows_sys::core::BOOL;\n\n unsafe extern \"system\" fn ctrlc_handler(_: u32) -> BOOL {\n // Do nothing; let the child process handle it.\n TRUE\n }\n\n pub fn exec_replace(process_builder: &ProcessBuilder) -> Result<()> {\n unsafe {\n if SetConsoleCtrlHandler(Some(ctrlc_handler), TRUE) == FALSE {\n return Err(ProcessError::new(\"Could not set Ctrl-C handler.\", None, None).into());\n }\n }\n\n // Just execute the process as normal.\n process_builder.exec()\n }\n\n pub fn command_line_too_big(err: &io::Error) -> bool {\n use windows_sys::Win32::Foundation::ERROR_FILENAME_EXCED_RANGE;\n err.raw_os_error() == Some(ERROR_FILENAME_EXCED_RANGE as i32)\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::ProcessBuilder;\n use std::fs;\n\n #[test]\n fn argfile_build_succeeds() {\n let mut cmd = ProcessBuilder::new(\"echo\");\n cmd.args([\"foo\", \"bar\"].as_slice());\n let (cmd, argfile) = cmd.build_command_with_argfile().unwrap();\n\n assert_eq!(cmd.get_program(), \"echo\");\n let cmd_args: Vec<_> = cmd.get_args().map(|s| s.to_str().unwrap()).collect();\n assert_eq!(cmd_args.len(), 1);\n assert!(cmd_args[0].starts_with(\"@\"));\n assert!(cmd_args[0].contains(\"cargo-argfile.\"));\n\n let buf = fs::read_to_string(argfile.path()).unwrap();\n assert_eq!(buf, \"foo\\nbar\\n\");\n }\n\n #[test]\n fn argfile_build_fails_if_arg_contains_newline() {\n let mut cmd = ProcessBuilder::new(\"echo\");\n cmd.arg(\"foo\\n\");\n let err = cmd.build_command_with_argfile().unwrap_err();\n assert_eq!(\n err.to_string(),\n \"argument for argfile contains newlines: `foo\\n`\"\n );\n }\n\n #[test]\n fn argfile_build_fails_if_arg_contains_invalid_utf8() {\n let mut cmd = ProcessBuilder::new(\"echo\");\n\n #[cfg(windows)]\n let invalid_arg = {\n use std::os::windows::prelude::*;\n std::ffi::OsString::from_wide(&[0x0066, 0x006f, 0xD800, 0x006f])\n };\n\n #[cfg(unix)]\n let invalid_arg = {\n use std::os::unix::ffi::OsStrExt;\n std::ffi::OsStr::from_bytes(&[0x66, 0x6f, 0x80, 0x6f]).to_os_string()\n };\n\n cmd.arg(invalid_arg);\n let err = cmd.build_command_with_argfile().unwrap_err();\n assert_eq!(\n err.to_string(),\n \"argument for argfile contains invalid UTF-8 characters: `foļæ½o`\"\n );\n }\n}\n" }, { "path": "crates/cargo-util/src/process_error.rs", "content": "//! Error value for [`crate::ProcessBuilder`] when a process fails.\n\nuse std::fmt;\nuse std::process::{ExitStatus, Output};\nuse std::str;\n\n#[derive(Debug)]\npub struct ProcessError {\n /// A detailed description to show to the user why the process failed.\n pub desc: String,\n\n /// The exit status of the process.\n ///\n /// This can be `None` if the process failed to launch (like process not\n /// found) or if the exit status wasn't a code but was instead something\n /// like termination via a signal.\n pub code: Option,\n\n /// The stdout from the process.\n ///\n /// This can be `None` if the process failed to launch, or the output was\n /// not captured.\n pub stdout: Option>,\n\n /// The stderr from the process.\n ///\n /// This can be `None` if the process failed to launch, or the output was\n /// not captured.\n pub stderr: Option>,\n}\n\nimpl fmt::Display for ProcessError {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n self.desc.fmt(f)\n }\n}\n\nimpl std::error::Error for ProcessError {}\n\nimpl ProcessError {\n /// Creates a new [`ProcessError`].\n ///\n /// * `status` can be `None` if the process did not launch.\n /// * `output` can be `None` if the process did not launch, or output was not captured.\n pub fn new(msg: &str, status: Option, output: Option<&Output>) -> ProcessError {\n let exit = match status {\n Some(s) => exit_status_to_string(s),\n None => \"never executed\".to_string(),\n };\n\n Self::new_raw(\n msg,\n status.and_then(|s| s.code()),\n &exit,\n output.map(|s| s.stdout.as_slice()),\n output.map(|s| s.stderr.as_slice()),\n )\n }\n\n /// Creates a new [`ProcessError`] with the raw output data.\n ///\n /// * `code` can be `None` for situations like being killed by a signal on unix.\n pub fn new_raw(\n msg: &str,\n code: Option,\n status: &str,\n stdout: Option<&[u8]>,\n stderr: Option<&[u8]>,\n ) -> ProcessError {\n let mut desc = format!(\"{} ({})\", msg, status);\n\n if let Some(out) = stdout {\n match str::from_utf8(out) {\n Ok(s) if !s.trim().is_empty() => {\n desc.push_str(\"\\n--- stdout\\n\");\n desc.push_str(s);\n }\n Ok(..) | Err(..) => {}\n }\n }\n if let Some(out) = stderr {\n match str::from_utf8(out) {\n Ok(s) if !s.trim().is_empty() => {\n desc.push_str(\"\\n--- stderr\\n\");\n desc.push_str(s);\n }\n Ok(..) | Err(..) => {}\n }\n }\n\n ProcessError {\n desc,\n code,\n stdout: stdout.map(|s| s.to_vec()),\n stderr: stderr.map(|s| s.to_vec()),\n }\n }\n\n /// Creates a [`ProcessError`] with \"could not execute process {cmd}\".\n ///\n /// * `cmd` is usually but not limited to [`std::process::Command`].\n pub fn could_not_execute(cmd: impl fmt::Display) -> ProcessError {\n ProcessError::new(&format!(\"could not execute process {cmd}\"), None, None)\n }\n}\n\n/// Converts an [`ExitStatus`] to a human-readable string suitable for\n/// displaying to a user.\npub fn exit_status_to_string(status: ExitStatus) -> String {\n return status_to_string(status);\n\n #[cfg(unix)]\n fn status_to_string(status: ExitStatus) -> String {\n use std::os::unix::process::*;\n\n if let Some(signal) = status.signal() {\n let name = match signal as libc::c_int {\n libc::SIGABRT => \", SIGABRT: process abort signal\",\n libc::SIGALRM => \", SIGALRM: alarm clock\",\n libc::SIGFPE => \", SIGFPE: erroneous arithmetic operation\",\n libc::SIGHUP => \", SIGHUP: hangup\",\n libc::SIGILL => \", SIGILL: illegal instruction\",\n libc::SIGINT => \", SIGINT: terminal interrupt signal\",\n libc::SIGKILL => \", SIGKILL: kill\",\n libc::SIGPIPE => \", SIGPIPE: write on a pipe with no one to read\",\n libc::SIGQUIT => \", SIGQUIT: terminal quit signal\",\n libc::SIGSEGV => \", SIGSEGV: invalid memory reference\",\n libc::SIGTERM => \", SIGTERM: termination signal\",\n libc::SIGBUS => \", SIGBUS: access to undefined memory\",\n #[cfg(not(target_os = \"haiku\"))]\n libc::SIGSYS => \", SIGSYS: bad system call\",\n libc::SIGTRAP => \", SIGTRAP: trace/breakpoint trap\",\n _ => \"\",\n };\n format!(\"signal: {}{}\", signal, name)\n } else {\n status.to_string()\n }\n }\n\n #[cfg(windows)]\n fn status_to_string(status: ExitStatus) -> String {\n use windows_sys::Win32::Foundation::*;\n\n let mut base = status.to_string();\n let extra = match status.code().unwrap() as i32 {\n STATUS_ACCESS_VIOLATION => \"STATUS_ACCESS_VIOLATION\",\n STATUS_IN_PAGE_ERROR => \"STATUS_IN_PAGE_ERROR\",\n STATUS_INVALID_HANDLE => \"STATUS_INVALID_HANDLE\",\n STATUS_INVALID_PARAMETER => \"STATUS_INVALID_PARAMETER\",\n STATUS_NO_MEMORY => \"STATUS_NO_MEMORY\",\n STATUS_ILLEGAL_INSTRUCTION => \"STATUS_ILLEGAL_INSTRUCTION\",\n STATUS_NONCONTINUABLE_EXCEPTION => \"STATUS_NONCONTINUABLE_EXCEPTION\",\n STATUS_INVALID_DISPOSITION => \"STATUS_INVALID_DISPOSITION\",\n STATUS_ARRAY_BOUNDS_EXCEEDED => \"STATUS_ARRAY_BOUNDS_EXCEEDED\",\n STATUS_FLOAT_DENORMAL_OPERAND => \"STATUS_FLOAT_DENORMAL_OPERAND\",\n STATUS_FLOAT_DIVIDE_BY_ZERO => \"STATUS_FLOAT_DIVIDE_BY_ZERO\",\n STATUS_FLOAT_INEXACT_RESULT => \"STATUS_FLOAT_INEXACT_RESULT\",\n STATUS_FLOAT_INVALID_OPERATION => \"STATUS_FLOAT_INVALID_OPERATION\",\n STATUS_FLOAT_OVERFLOW => \"STATUS_FLOAT_OVERFLOW\",\n STATUS_FLOAT_STACK_CHECK => \"STATUS_FLOAT_STACK_CHECK\",\n STATUS_FLOAT_UNDERFLOW => \"STATUS_FLOAT_UNDERFLOW\",\n STATUS_INTEGER_DIVIDE_BY_ZERO => \"STATUS_INTEGER_DIVIDE_BY_ZERO\",\n STATUS_INTEGER_OVERFLOW => \"STATUS_INTEGER_OVERFLOW\",\n STATUS_PRIVILEGED_INSTRUCTION => \"STATUS_PRIVILEGED_INSTRUCTION\",\n STATUS_STACK_OVERFLOW => \"STATUS_STACK_OVERFLOW\",\n STATUS_DLL_NOT_FOUND => \"STATUS_DLL_NOT_FOUND\",\n STATUS_ORDINAL_NOT_FOUND => \"STATUS_ORDINAL_NOT_FOUND\",\n STATUS_ENTRYPOINT_NOT_FOUND => \"STATUS_ENTRYPOINT_NOT_FOUND\",\n STATUS_CONTROL_C_EXIT => \"STATUS_CONTROL_C_EXIT\",\n STATUS_DLL_INIT_FAILED => \"STATUS_DLL_INIT_FAILED\",\n STATUS_FLOAT_MULTIPLE_FAULTS => \"STATUS_FLOAT_MULTIPLE_FAULTS\",\n STATUS_FLOAT_MULTIPLE_TRAPS => \"STATUS_FLOAT_MULTIPLE_TRAPS\",\n STATUS_REG_NAT_CONSUMPTION => \"STATUS_REG_NAT_CONSUMPTION\",\n STATUS_HEAP_CORRUPTION => \"STATUS_HEAP_CORRUPTION\",\n STATUS_STACK_BUFFER_OVERRUN => \"STATUS_STACK_BUFFER_OVERRUN\",\n STATUS_ASSERTION_FAILURE => \"STATUS_ASSERTION_FAILURE\",\n _ => return base,\n };\n base.push_str(\", \");\n base.push_str(extra);\n base\n }\n}\n\n/// Returns `true` if the given process exit code is something a normal\n/// process would exit with.\n///\n/// This helps differentiate from abnormal termination codes, such as\n/// segmentation faults or signals.\npub fn is_simple_exit_code(code: i32) -> bool {\n // Typical unix exit codes are 0 to 127.\n // Windows doesn't have anything \"typical\", and is a\n // 32-bit number (which appears signed here, but is really\n // unsigned). However, most of the interesting NTSTATUS\n // codes are very large. This is just a rough\n // approximation of which codes are \"normal\" and which\n // ones are abnormal termination.\n code >= 0 && code <= 127\n}\n" }, { "path": "crates/cargo-util/src/read2.rs", "content": "pub use self::imp::read2;\n\n#[cfg(unix)]\nmod imp {\n use libc::{F_GETFL, F_SETFL, O_NONBLOCK, c_int, fcntl};\n use std::io;\n use std::io::prelude::*;\n use std::mem;\n use std::os::unix::prelude::*;\n use std::process::{ChildStderr, ChildStdout};\n\n fn set_nonblock(fd: c_int) -> io::Result<()> {\n let flags = unsafe { fcntl(fd, F_GETFL) };\n if flags == -1 || unsafe { fcntl(fd, F_SETFL, flags | O_NONBLOCK) } == -1 {\n return Err(io::Error::last_os_error());\n }\n Ok(())\n }\n\n pub fn read2(\n mut out_pipe: ChildStdout,\n mut err_pipe: ChildStderr,\n data: &mut dyn FnMut(bool, &mut Vec, bool),\n ) -> io::Result<()> {\n set_nonblock(out_pipe.as_raw_fd())?;\n set_nonblock(err_pipe.as_raw_fd())?;\n\n let mut out_done = false;\n let mut err_done = false;\n let mut out = Vec::new();\n let mut err = Vec::new();\n\n let mut fds: [libc::pollfd; 2] = unsafe { mem::zeroed() };\n fds[0].fd = out_pipe.as_raw_fd();\n fds[0].events = libc::POLLIN;\n fds[1].fd = err_pipe.as_raw_fd();\n fds[1].events = libc::POLLIN;\n let mut nfds = 2;\n let mut errfd = 1;\n\n while nfds > 0 {\n // wait for either pipe to become readable using `poll`\n let r = unsafe { libc::poll(fds.as_mut_ptr(), nfds, -1) };\n if r == -1 {\n let err = io::Error::last_os_error();\n if err.kind() == io::ErrorKind::Interrupted {\n continue;\n }\n return Err(err);\n }\n\n // Read as much as we can from each pipe, ignoring EWOULDBLOCK or\n // EAGAIN. If we hit EOF, then this will happen because the underlying\n // reader will return Ok(0), in which case we'll see `Ok` ourselves. In\n // this case we flip the other fd back into blocking mode and read\n // whatever's leftover on that file descriptor.\n let handle = |res: io::Result<_>| match res {\n Ok(_) => Ok(true),\n Err(e) => {\n if e.kind() == io::ErrorKind::WouldBlock {\n Ok(false)\n } else {\n Err(e)\n }\n }\n };\n if !err_done && fds[errfd].revents != 0 && handle(err_pipe.read_to_end(&mut err))? {\n err_done = true;\n nfds -= 1;\n }\n data(false, &mut err, err_done);\n if !out_done && fds[0].revents != 0 && handle(out_pipe.read_to_end(&mut out))? {\n out_done = true;\n fds[0].fd = err_pipe.as_raw_fd();\n errfd = 0;\n nfds -= 1;\n }\n data(true, &mut out, out_done);\n }\n Ok(())\n }\n}\n\n#[cfg(windows)]\nmod imp {\n use std::io;\n use std::os::windows::prelude::*;\n use std::process::{ChildStderr, ChildStdout};\n use std::slice;\n\n use miow::Overlapped;\n use miow::iocp::{CompletionPort, CompletionStatus};\n use miow::pipe::NamedPipe;\n use windows_sys::Win32::Foundation::ERROR_BROKEN_PIPE;\n\n struct Pipe<'a> {\n dst: &'a mut Vec,\n overlapped: Overlapped,\n pipe: NamedPipe,\n done: bool,\n }\n\n pub fn read2(\n out_pipe: ChildStdout,\n err_pipe: ChildStderr,\n data: &mut dyn FnMut(bool, &mut Vec, bool),\n ) -> io::Result<()> {\n let mut out = Vec::new();\n let mut err = Vec::new();\n\n let port = CompletionPort::new(1)?;\n port.add_handle(0, &out_pipe)?;\n port.add_handle(1, &err_pipe)?;\n\n unsafe {\n let mut out_pipe = Pipe::new(out_pipe, &mut out);\n let mut err_pipe = Pipe::new(err_pipe, &mut err);\n\n out_pipe.read()?;\n err_pipe.read()?;\n\n let mut status = [CompletionStatus::zero(), CompletionStatus::zero()];\n\n while !out_pipe.done || !err_pipe.done {\n for status in port.get_many(&mut status, None)? {\n if status.token() == 0 {\n out_pipe.complete(status);\n data(true, out_pipe.dst, out_pipe.done);\n out_pipe.read()?;\n } else {\n err_pipe.complete(status);\n data(false, err_pipe.dst, err_pipe.done);\n err_pipe.read()?;\n }\n }\n }\n\n Ok(())\n }\n }\n\n impl<'a> Pipe<'a> {\n unsafe fn new(p: P, dst: &'a mut Vec) -> Pipe<'a> {\n // SAFETY: Handle must be owned, open, and closeable with CloseHandle.\n let pipe = unsafe { NamedPipe::from_raw_handle(p.into_raw_handle()) };\n Pipe {\n dst,\n pipe,\n overlapped: Overlapped::zero(),\n done: false,\n }\n }\n\n unsafe fn read(&mut self) -> io::Result<()> {\n let dst = unsafe { slice_to_end(self.dst) };\n // SAFETY: The buffer must be valid until the end of the I/O,\n // which is handled in `read2`.\n match unsafe { self.pipe.read_overlapped(dst, self.overlapped.raw()) } {\n Ok(_) => Ok(()),\n Err(e) => {\n if e.raw_os_error() == Some(ERROR_BROKEN_PIPE as i32) {\n self.done = true;\n Ok(())\n } else {\n Err(e)\n }\n }\n }\n }\n\n unsafe fn complete(&mut self, status: &CompletionStatus) {\n let prev = self.dst.len();\n unsafe { self.dst.set_len(prev + status.bytes_transferred() as usize) };\n if status.bytes_transferred() == 0 {\n self.done = true;\n }\n }\n }\n\n unsafe fn slice_to_end(v: &mut Vec) -> &mut [u8] {\n if v.capacity() == 0 {\n v.reserve(16);\n }\n if v.capacity() == v.len() {\n v.reserve(1);\n }\n unsafe { slice::from_raw_parts_mut(v.as_mut_ptr().add(v.len()), v.capacity() - v.len()) }\n }\n}\n" }, { "path": "crates/cargo-util/src/registry.rs", "content": "/// Make a path to a dependency, which aligns to\n///\n/// - [index from of Cargo's index on filesystem][1], and\n/// - [index from Crates.io][2].\n///\n///
\n///\n/// Note: For index files, `dep_name` must have had `to_lowercase` called on it.\n///\n///
\n///\n/// [1]: https://docs.rs/cargo/latest/cargo/sources/registry/index.html#the-format-of-the-index\n/// [2]: https://github.com/rust-lang/crates.io-index\npub fn make_dep_path(dep_name: &str, prefix_only: bool) -> String {\n let (slash, name) = if prefix_only {\n (\"\", \"\")\n } else {\n (\"/\", dep_name)\n };\n match dep_name.len() {\n 1 => format!(\"1{}{}\", slash, name),\n 2 => format!(\"2{}{}\", slash, name),\n 3 => format!(\"3/{}{}{}\", &dep_name[..1], slash, name),\n _ => format!(\"{}/{}{}{}\", &dep_name[0..2], &dep_name[2..4], slash, name),\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::make_dep_path;\n\n #[test]\n fn prefix_only() {\n assert_eq!(make_dep_path(\"a\", true), \"1\");\n assert_eq!(make_dep_path(\"ab\", true), \"2\");\n assert_eq!(make_dep_path(\"abc\", true), \"3/a\");\n assert_eq!(make_dep_path(\"Abc\", true), \"3/A\");\n assert_eq!(make_dep_path(\"AbCd\", true), \"Ab/Cd\");\n assert_eq!(make_dep_path(\"aBcDe\", true), \"aB/cD\");\n }\n\n #[test]\n fn full() {\n assert_eq!(make_dep_path(\"a\", false), \"1/a\");\n assert_eq!(make_dep_path(\"ab\", false), \"2/ab\");\n assert_eq!(make_dep_path(\"abc\", false), \"3/a/abc\");\n assert_eq!(make_dep_path(\"Abc\", false), \"3/A/Abc\");\n assert_eq!(make_dep_path(\"AbCd\", false), \"Ab/Cd/AbCd\");\n assert_eq!(make_dep_path(\"aBcDe\", false), \"aB/cD/aBcDe\");\n }\n}\n" }, { "path": "crates/cargo-util/src/sha256.rs", "content": "use super::paths;\nuse anyhow::{Context, Result};\nuse sha2::{Digest, Sha256 as Sha2_sha256};\nuse std::fs::File;\nuse std::io::{self, Read};\nuse std::path::Path;\n\npub struct Sha256(Sha2_sha256);\n\nimpl Sha256 {\n pub fn new() -> Sha256 {\n let hasher = Sha2_sha256::new();\n Sha256(hasher)\n }\n\n pub fn update(&mut self, bytes: &[u8]) -> &mut Sha256 {\n let _ = self.0.update(bytes);\n self\n }\n\n pub fn update_file(&mut self, mut file: &File) -> io::Result<&mut Sha256> {\n let mut buf = [0; 64 * 1024];\n loop {\n let n = file.read(&mut buf)?;\n if n == 0 {\n break Ok(self);\n }\n self.update(&buf[..n]);\n }\n }\n\n pub fn update_path>(&mut self, path: P) -> Result<&mut Sha256> {\n let path = path.as_ref();\n let file = paths::open(path)?;\n self.update_file(&file)\n .with_context(|| format!(\"failed to read `{}`\", path.display()))?;\n Ok(self)\n }\n\n pub fn finish(&mut self) -> [u8; 32] {\n self.0.finalize_reset().into()\n }\n\n pub fn finish_hex(&mut self) -> String {\n hex::encode(self.finish())\n }\n}\n\nimpl Default for Sha256 {\n fn default() -> Self {\n Self::new()\n }\n}\n" }, { "path": "crates/cargo-util-schemas/Cargo.toml", "content": "[package]\nname = \"cargo-util-schemas\"\nversion = \"0.13.1\"\nrust-version = \"1.94\" # MSRV:1\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"Deserialization schemas for Cargo\"\n\n[dependencies]\njiff = { workspace = true, features = [\"std\", \"serde\"] }\nschemars = { workspace = true, features = [\"preserve_order\", \"semver1\"], optional = true }\nsemver.workspace = true\nserde = { workspace = true, features = [\"derive\"] }\nserde_json = { workspace = true, optional = true }\nserde-untagged.workspace = true\nserde-value.workspace = true\nthiserror.workspace = true\ntoml = { workspace = true, features = [\"serde\"] }\nunicode-ident.workspace = true\nurl.workspace = true\n\n[lints]\nworkspace = true\n\n[dev-dependencies]\nsnapbox.workspace = true\nserde_json.workspace = true\n\n[features]\nunstable-schema = [\"dep:schemars\", \"dep:serde_json\"]\n" }, { "path": "crates/cargo-util-schemas/README.md", "content": "> This crate is maintained by the Cargo team for use by the wider\n> ecosystem. This crate follows semver compatibility for its APIs.\n" }, { "path": "crates/cargo-util-schemas/index.schema.json", "content": "{\n \"$schema\": \"https://json-schema.org/draft/2020-12/schema\",\n \"title\": \"IndexPackage\",\n \"description\": \"A single line in the index representing a single version of a package.\",\n \"type\": \"object\",\n \"properties\": {\n \"name\": {\n \"description\": \"Name of the package.\",\n \"type\": \"string\"\n },\n \"vers\": {\n \"description\": \"The version of this dependency.\",\n \"$ref\": \"#/$defs/SemVer\"\n },\n \"deps\": {\n \"description\": \"All kinds of direct dependencies of the package, including dev and\\nbuild dependencies.\",\n \"type\": \"array\",\n \"items\": {\n \"$ref\": \"#/$defs/RegistryDependency\"\n }\n },\n \"features\": {\n \"description\": \"Set of features defined for the package, i.e., `[features]` table.\",\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"default\": {}\n },\n \"features2\": {\n \"description\": \"This field contains features with new, extended syntax. Specifically,\\nnamespaced features (`dep:`) and weak dependencies (`pkg?/feat`).\\n\\nThis is separated from `features` because versions older than 1.19\\nwill fail to load due to not being able to parse the new syntax, even\\nwith a `Cargo.lock` file.\",\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n }\n },\n \"cksum\": {\n \"description\": \"Checksum for verifying the integrity of the corresponding downloaded package.\",\n \"type\": \"string\"\n },\n \"yanked\": {\n \"description\": \"If `true`, Cargo will skip this version when resolving.\\n\\nThis was added in 2014. Everything in the crates.io index has this set\\nnow, so this probably doesn't need to be an option anymore.\",\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"links\": {\n \"description\": \"Native library name this package links to.\\n\\nAdded early 2018 (see ),\\ncan be `None` if published before then.\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"rust_version\": {\n \"description\": \"Required version of rust\\n\\nCorresponds to `package.rust-version`.\\n\\nAdded in 2023 (see ),\\ncan be `None` if published before then or if not set in the manifest.\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"pubtime\": {\n \"description\": \"The publish time of this package version (optional).\\n\\nThe format is a subset of ISO8601:\\n- `yyyy-mm-ddThh:mm:ssZ`\\n- no fractional seconds\\n- always `Z` for UTC timezone, no timezone offsets supported\\n- fields are 0-padded\\n\\nExample: 2025-11-12T19:30:12Z\\n\\nThis should be the original publish time and not changed on any status changes,\\nlike [`IndexPackage::yanked`].\",\n \"type\": [\n \"string\",\n \"null\"\n ],\n \"default\": null\n },\n \"v\": {\n \"description\": \"The schema version for this entry.\\n\\nIf this is None, it defaults to version `1`. Entries with unknown\\nversions are ignored.\\n\\nVersion `2` schema adds the `features2` field.\\n\\nVersion `3` schema adds `artifact`, `bindep_targes`, and `lib` for\\nartifact dependencies support.\\n\\nThis provides a method to safely introduce changes to index entries\\nand allow older versions of cargo to ignore newer entries it doesn't\\nunderstand. This is honored as of 1.51, so unfortunately older\\nversions will ignore it, and potentially misinterpret version 2 and\\nnewer entries.\\n\\nThe intent is that versions older than 1.51 will work with a\\npre-existing `Cargo.lock`, but they may not correctly process `cargo\\nupdate` or build a lock from scratch. In that case, cargo may\\nincorrectly select a new package that uses a new index schema. A\\nworkaround is to downgrade any packages that are incompatible with the\\n`--precise` flag of `cargo update`.\",\n \"type\": [\n \"integer\",\n \"null\"\n ],\n \"format\": \"uint32\",\n \"minimum\": 0\n }\n },\n \"required\": [\n \"name\",\n \"vers\",\n \"deps\",\n \"cksum\"\n ],\n \"$defs\": {\n \"SemVer\": {\n \"type\": \"string\",\n \"pattern\": \"^(0|[1-9]\\\\d*)\\\\.(0|[1-9]\\\\d*)\\\\.(0|[1-9]\\\\d*)(?:-((?:0|[1-9]\\\\d*|\\\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\\\.(?:0|[1-9]\\\\d*|\\\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\\\+([0-9a-zA-Z-]+(?:\\\\.[0-9a-zA-Z-]+)*))?$\"\n },\n \"RegistryDependency\": {\n \"description\": \"A dependency as encoded in the [`IndexPackage`] index JSON.\",\n \"type\": \"object\",\n \"properties\": {\n \"name\": {\n \"description\": \"Name of the dependency. If the dependency is renamed, the original\\nwould be stored in [`RegistryDependency::package`].\",\n \"type\": \"string\"\n },\n \"req\": {\n \"description\": \"The SemVer requirement for this dependency.\",\n \"type\": \"string\"\n },\n \"features\": {\n \"description\": \"Set of features enabled for this dependency.\",\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n },\n \"default\": []\n },\n \"optional\": {\n \"description\": \"Whether or not this is an optional dependency.\",\n \"type\": \"boolean\",\n \"default\": false\n },\n \"default_features\": {\n \"description\": \"Whether or not default features are enabled.\",\n \"type\": \"boolean\",\n \"default\": true\n },\n \"target\": {\n \"description\": \"The target platform for this dependency.\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"kind\": {\n \"description\": \"The dependency kind. \\\"dev\\\", \\\"build\\\", and \\\"normal\\\".\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"registry\": {\n \"description\": \"The URL of the index of the registry where this dependency is from.\\n`None` if it is from the same index.\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"package\": {\n \"description\": \"The original name if the dependency is renamed.\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"public\": {\n \"description\": \"Whether or not this is a public dependency. Unstable. See [RFC 1977].\\n\\n[RFC 1977]: https://rust-lang.github.io/rfcs/1977-public-private-dependencies.html\",\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"artifact\": {\n \"description\": \"The artifacts to build from this dependency.\",\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"bindep_target\": {\n \"description\": \"The target for bindep.\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"lib\": {\n \"description\": \"Whether or not this is a library dependency.\",\n \"type\": \"boolean\",\n \"default\": false\n }\n },\n \"required\": [\n \"name\",\n \"req\"\n ]\n }\n }\n}" }, { "path": "crates/cargo-util-schemas/lockfile.schema.json", "content": "{\n \"$schema\": \"https://json-schema.org/draft/2020-12/schema\",\n \"title\": \"TomlLockfile\",\n \"description\": \"Serialization of `Cargo.lock`\",\n \"type\": \"object\",\n \"properties\": {\n \"version\": {\n \"description\": \"The lockfile format version (`version =` field).\\n\\nThis field is optional for backward compatibility. Older lockfiles, i.e. V1 and V2, does\\nnot have the version field serialized.\",\n \"type\": [\n \"integer\",\n \"null\"\n ],\n \"format\": \"uint32\",\n \"minimum\": 0\n },\n \"package\": {\n \"description\": \"The list of `[[package]]` entries describing each resolved dependency.\",\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"$ref\": \"#/$defs/TomlLockfileDependency\"\n }\n },\n \"root\": {\n \"description\": \"The `[root]` table describing the root package.\\n\\nThis field is optional for backward compatibility. Older lockfiles have the root package\\nseparated, whereas newer lockfiles have the root package as part of `[[package]]`.\",\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlLockfileDependency\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"metadata\": {\n \"description\": \"The `[metadata]` table\\n\\n\\nIn older lockfile versions, dependency checksums were stored here instead of alongside each\\npackage entry.\",\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"patch\": {\n \"description\": \"The `[patch]` table describing unused patches.\\n\\nThe lockfile stores them as a list of `[[patch.unused]]` entries.\",\n \"$ref\": \"#/$defs/TomlLockfilePatch\"\n }\n },\n \"$defs\": {\n \"TomlLockfileDependency\": {\n \"description\": \"Serialization of lockfiles dependencies\",\n \"type\": \"object\",\n \"properties\": {\n \"name\": {\n \"description\": \"The name of the dependency.\",\n \"type\": \"string\"\n },\n \"version\": {\n \"description\": \"The version of the dependency.\",\n \"type\": \"string\"\n },\n \"source\": {\n \"description\": \"The source of the dependency.\\n\\nCargo does not serialize path dependencies.\",\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlLockfileSourceId\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"checksum\": {\n \"description\": \"The checksum of the dependency.\\n\\nIn older lockfiles, checksums were not stored here and instead on a separate `[metadata]`\\ntable (see [`TomlLockfileMetadata`]).\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"dependencies\": {\n \"description\": \"The transitive dependencies used by this dependency.\",\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"$ref\": \"#/$defs/TomlLockfilePackageId\"\n }\n },\n \"replace\": {\n \"description\": \"The replace of the dependency.\",\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlLockfilePackageId\"\n },\n {\n \"type\": \"null\"\n }\n ]\n }\n },\n \"required\": [\n \"name\",\n \"version\"\n ]\n },\n \"TomlLockfileSourceId\": {\n \"description\": \"Serialization of dependency's source\",\n \"type\": \"string\"\n },\n \"TomlLockfilePackageId\": {\n \"description\": \"Serialization of package IDs.\\n\\nThe version and source are only included when necessary to disambiguate between packages:\\n- If multiple packages share the same name, the version is included.\\n- If multiple packages share the same name and version, the source is included.\",\n \"type\": \"object\",\n \"properties\": {\n \"name\": {\n \"type\": \"string\"\n },\n \"version\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"source\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlLockfileSourceId\"\n },\n {\n \"type\": \"null\"\n }\n ]\n }\n },\n \"required\": [\n \"name\"\n ]\n },\n \"TomlLockfilePatch\": {\n \"description\": \"Serialization of unused patches\\n\\nCargo stores patches that were declared but not used during resolution.\",\n \"type\": \"object\",\n \"properties\": {\n \"unused\": {\n \"description\": \"The list of unused dependency patches.\",\n \"type\": \"array\",\n \"items\": {\n \"$ref\": \"#/$defs/TomlLockfileDependency\"\n }\n }\n },\n \"required\": [\n \"unused\"\n ]\n }\n }\n}" }, { "path": "crates/cargo-util-schemas/manifest.schema.json", "content": "{\n \"$schema\": \"https://json-schema.org/draft/2020-12/schema\",\n \"title\": \"TomlManifest\",\n \"description\": \"This type is used to deserialize `Cargo.toml` files.\",\n \"type\": \"object\",\n \"properties\": {\n \"cargo-features\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"package\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlPackage\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"project\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlPackage\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"badges\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n }\n },\n \"features\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n }\n },\n \"lib\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlTarget\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"bin\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"$ref\": \"#/$defs/TomlTarget\"\n }\n },\n \"example\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"$ref\": \"#/$defs/TomlTarget\"\n }\n },\n \"test\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"$ref\": \"#/$defs/TomlTarget\"\n }\n },\n \"bench\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"$ref\": \"#/$defs/TomlTarget\"\n }\n },\n \"dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"dev-dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"dev_dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"build-dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"build_dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"target\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlPlatform\"\n }\n },\n \"lints\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableLints\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"hints\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/Hints\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"workspace\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlWorkspace\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"profile\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlProfiles\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"patch\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlDependency\"\n }\n }\n },\n \"replace\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlDependency\"\n }\n }\n },\n \"$defs\": {\n \"TomlPackage\": {\n \"description\": \"Represents the `package`/`project` sections of a `Cargo.toml`.\\n\\nNote that the order of the fields matters, since this is the order they\\nare serialized to a TOML file. For example, you cannot have values after\\nthe field `metadata`, since it is a table and values cannot appear after\\ntables.\",\n \"type\": \"object\",\n \"properties\": {\n \"edition\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"rust-version\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"name\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"version\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField2\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"authors\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField3\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"build\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlPackageBuild\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"metabuild\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/StringOrVec\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"default-target\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"forced-target\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"links\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"exclude\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField3\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"include\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField3\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"publish\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField4\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"workspace\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"im-a-teapot\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"autolib\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"autobins\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"autoexamples\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"autotests\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"autobenches\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"default-run\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"description\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"homepage\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"documentation\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"readme\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField5\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"keywords\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField3\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"categories\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField3\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"license\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"license-file\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"repository\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritableField\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"resolver\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"metadata\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlValue\"\n },\n {\n \"type\": \"null\"\n }\n ]\n }\n }\n },\n \"InheritableField\": {\n \"description\": \"An enum that allows for inheriting keys from a workspace in a Cargo.toml.\",\n \"anyOf\": [\n {\n \"description\": \"The type that is used when not inheriting from a workspace.\",\n \"type\": \"string\"\n },\n {\n \"description\": \"The type when inheriting from a workspace.\",\n \"$ref\": \"#/$defs/TomlInheritedField\"\n }\n ]\n },\n \"TomlInheritedField\": {\n \"type\": \"object\",\n \"properties\": {\n \"workspace\": {\n \"$ref\": \"#/$defs/WorkspaceValue\"\n }\n },\n \"required\": [\n \"workspace\"\n ]\n },\n \"WorkspaceValue\": {\n \"type\": \"boolean\"\n },\n \"InheritableField2\": {\n \"description\": \"An enum that allows for inheriting keys from a workspace in a Cargo.toml.\",\n \"anyOf\": [\n {\n \"description\": \"The type that is used when not inheriting from a workspace.\",\n \"$ref\": \"#/$defs/SemVer\"\n },\n {\n \"description\": \"The type when inheriting from a workspace.\",\n \"$ref\": \"#/$defs/TomlInheritedField\"\n }\n ]\n },\n \"SemVer\": {\n \"type\": \"string\",\n \"pattern\": \"^(0|[1-9]\\\\d*)\\\\.(0|[1-9]\\\\d*)\\\\.(0|[1-9]\\\\d*)(?:-((?:0|[1-9]\\\\d*|\\\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\\\.(?:0|[1-9]\\\\d*|\\\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\\\+([0-9a-zA-Z-]+(?:\\\\.[0-9a-zA-Z-]+)*))?$\"\n },\n \"InheritableField3\": {\n \"description\": \"An enum that allows for inheriting keys from a workspace in a Cargo.toml.\",\n \"anyOf\": [\n {\n \"description\": \"The type that is used when not inheriting from a workspace.\",\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n },\n {\n \"description\": \"The type when inheriting from a workspace.\",\n \"$ref\": \"#/$defs/TomlInheritedField\"\n }\n ]\n },\n \"TomlPackageBuild\": {\n \"anyOf\": [\n {\n \"description\": \"If build scripts are disabled or enabled.\\nIf true, `build.rs` in the root folder will be the build script.\",\n \"type\": \"boolean\"\n },\n {\n \"description\": \"Path of Build Script if there's just one script.\",\n \"type\": \"string\"\n },\n {\n \"description\": \"Vector of paths if multiple build script are to be used.\",\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n }\n ]\n },\n \"StringOrVec\": {\n \"description\": \"This can be parsed from either a TOML string or array,\\nbut is always stored as a vector.\",\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"InheritableField4\": {\n \"description\": \"An enum that allows for inheriting keys from a workspace in a Cargo.toml.\",\n \"anyOf\": [\n {\n \"description\": \"The type that is used when not inheriting from a workspace.\",\n \"$ref\": \"#/$defs/VecStringOrBool\"\n },\n {\n \"description\": \"The type when inheriting from a workspace.\",\n \"$ref\": \"#/$defs/TomlInheritedField\"\n }\n ]\n },\n \"VecStringOrBool\": {\n \"anyOf\": [\n {\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n },\n {\n \"type\": \"boolean\"\n }\n ]\n },\n \"InheritableField5\": {\n \"description\": \"An enum that allows for inheriting keys from a workspace in a Cargo.toml.\",\n \"anyOf\": [\n {\n \"description\": \"The type that is used when not inheriting from a workspace.\",\n \"$ref\": \"#/$defs/StringOrBool\"\n },\n {\n \"description\": \"The type when inheriting from a workspace.\",\n \"$ref\": \"#/$defs/TomlInheritedField\"\n }\n ]\n },\n \"StringOrBool\": {\n \"anyOf\": [\n {\n \"type\": \"string\"\n },\n {\n \"type\": \"boolean\"\n }\n ]\n },\n \"TomlValue\": true,\n \"TomlTarget\": {\n \"type\": \"object\",\n \"properties\": {\n \"name\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"crate-type\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"crate_type\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"path\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"filename\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"test\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"doctest\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"bench\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"doc\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"doc-scrape-examples\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"proc-macro\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"proc_macro\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"harness\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"required-features\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"edition\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n }\n }\n },\n \"InheritableDependency\": {\n \"anyOf\": [\n {\n \"description\": \"The type that is used when not inheriting from a workspace.\",\n \"$ref\": \"#/$defs/TomlDependency\"\n },\n {\n \"description\": \"The type when inheriting from a workspace.\",\n \"$ref\": \"#/$defs/TomlInheritedDependency\"\n }\n ]\n },\n \"TomlDependency\": {\n \"anyOf\": [\n {\n \"description\": \"In the simple format, only a version is specified, eg.\\n`package = \\\"\\\"`\",\n \"type\": \"string\"\n },\n {\n \"description\": \"The simple format is equivalent to a detailed dependency\\nspecifying only a version, eg.\\n`package = { version = \\\"\\\" }`\",\n \"$ref\": \"#/$defs/TomlDetailedDependency\"\n }\n ]\n },\n \"TomlDetailedDependency\": {\n \"type\": \"object\",\n \"properties\": {\n \"version\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"registry\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"registry-index\": {\n \"description\": \"The URL of the `registry` field.\\nThis is an internal implementation detail. When Cargo creates a\\npackage, it replaces `registry` with `registry-index` so that the\\nmanifest contains the correct URL. All users won't have the same\\nregistry names configured, so Cargo can't rely on just the name for\\ncrates published by other users.\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"path\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"base\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"git\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"branch\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"tag\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"rev\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"features\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"optional\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"default-features\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"default_features\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"package\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"public\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"artifact\": {\n \"description\": \"One or more of `bin`, `cdylib`, `staticlib`, `bin:`.\",\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/StringOrVec\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"lib\": {\n \"description\": \"If set, the artifact should also be a dependency\",\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"target\": {\n \"description\": \"A platform name, like `x86_64-apple-darwin`\",\n \"type\": [\n \"string\",\n \"null\"\n ]\n }\n }\n },\n \"TomlInheritedDependency\": {\n \"type\": \"object\",\n \"properties\": {\n \"workspace\": {\n \"type\": \"boolean\"\n },\n \"features\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"default-features\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"default_features\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"optional\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n },\n \"public\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ]\n }\n },\n \"required\": [\n \"workspace\"\n ]\n },\n \"TomlPlatform\": {\n \"description\": \"Corresponds to a `target` entry, but `TomlTarget` is already used.\",\n \"type\": \"object\",\n \"properties\": {\n \"dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"build-dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"build_dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"dev-dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n },\n \"dev_dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/InheritableDependency\"\n }\n }\n }\n },\n \"InheritableLints\": {\n \"type\": \"object\",\n \"properties\": {\n \"workspace\": {\n \"type\": \"boolean\"\n }\n },\n \"additionalProperties\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlLint\"\n }\n }\n },\n \"TomlLint\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlLintLevel\"\n },\n {\n \"$ref\": \"#/$defs/TomlLintConfig\"\n }\n ]\n },\n \"TomlLintLevel\": {\n \"type\": \"string\",\n \"enum\": [\n \"forbid\",\n \"deny\",\n \"warn\",\n \"allow\"\n ]\n },\n \"TomlLintConfig\": {\n \"type\": \"object\",\n \"properties\": {\n \"level\": {\n \"$ref\": \"#/$defs/TomlLintLevel\"\n },\n \"priority\": {\n \"type\": \"integer\",\n \"format\": \"int8\",\n \"minimum\": -128,\n \"maximum\": 127,\n \"default\": 0\n }\n },\n \"required\": [\n \"level\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlValue\"\n }\n },\n \"Hints\": {\n \"type\": \"object\",\n \"properties\": {\n \"mostly-unused\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlValue\"\n },\n {\n \"type\": \"null\"\n }\n ]\n }\n }\n },\n \"TomlWorkspace\": {\n \"type\": \"object\",\n \"properties\": {\n \"members\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"exclude\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"default-members\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"resolver\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"metadata\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlValue\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"package\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/InheritablePackage\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"dependencies\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlDependency\"\n }\n },\n \"lints\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlLint\"\n }\n }\n }\n }\n },\n \"InheritablePackage\": {\n \"description\": \"A group of fields that are inheritable by members of the workspace\",\n \"type\": \"object\",\n \"properties\": {\n \"version\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/SemVer\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"authors\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"description\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"homepage\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"documentation\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"readme\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/StringOrBool\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"keywords\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"categories\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"license\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"license-file\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"repository\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"publish\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/VecStringOrBool\"\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"edition\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n },\n \"badges\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n }\n },\n \"exclude\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"include\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"rust-version\": {\n \"type\": [\n \"string\",\n \"null\"\n ]\n }\n }\n },\n \"TomlProfiles\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlProfile\"\n }\n },\n \"TomlProfile\": {\n \"type\": \"object\",\n \"properties\": {\n \"opt-level\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlOptLevel\"\n },\n {\n \"type\": \"null\"\n }\n ],\n \"default\": null\n },\n \"lto\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/StringOrBool\"\n },\n {\n \"type\": \"null\"\n }\n ],\n \"default\": null\n },\n \"codegen-backend\": {\n \"type\": [\n \"string\",\n \"null\"\n ],\n \"default\": null\n },\n \"codegen-units\": {\n \"type\": [\n \"integer\",\n \"null\"\n ],\n \"format\": \"uint32\",\n \"minimum\": 0,\n \"default\": null\n },\n \"debug\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlDebugInfo\"\n },\n {\n \"type\": \"null\"\n }\n ],\n \"default\": null\n },\n \"split-debuginfo\": {\n \"type\": [\n \"string\",\n \"null\"\n ],\n \"default\": null\n },\n \"debug-assertions\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ],\n \"default\": null\n },\n \"rpath\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ],\n \"default\": null\n },\n \"panic\": {\n \"type\": [\n \"string\",\n \"null\"\n ],\n \"default\": null\n },\n \"overflow-checks\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ],\n \"default\": null\n },\n \"incremental\": {\n \"type\": [\n \"boolean\",\n \"null\"\n ],\n \"default\": null\n },\n \"dir-name\": {\n \"type\": [\n \"string\",\n \"null\"\n ],\n \"default\": null\n },\n \"inherits\": {\n \"type\": [\n \"string\",\n \"null\"\n ],\n \"default\": null\n },\n \"strip\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/StringOrBool\"\n },\n {\n \"type\": \"null\"\n }\n ],\n \"default\": null\n },\n \"rustflags\": {\n \"type\": [\n \"array\",\n \"null\"\n ],\n \"items\": {\n \"type\": \"string\"\n },\n \"default\": null\n },\n \"package\": {\n \"type\": [\n \"object\",\n \"null\"\n ],\n \"additionalProperties\": {\n \"$ref\": \"#/$defs/TomlProfile\"\n },\n \"default\": null\n },\n \"build-override\": {\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlProfile\"\n },\n {\n \"type\": \"null\"\n }\n ],\n \"default\": null\n },\n \"trim-paths\": {\n \"description\": \"Unstable feature `-Ztrim-paths`.\",\n \"anyOf\": [\n {\n \"$ref\": \"#/$defs/TomlTrimPaths\"\n },\n {\n \"type\": \"null\"\n }\n ],\n \"default\": null\n },\n \"hint-mostly-unused\": {\n \"description\": \"Unstable feature `hint-mostly-unused`\",\n \"type\": [\n \"boolean\",\n \"null\"\n ],\n \"default\": null\n }\n }\n },\n \"TomlOptLevel\": {\n \"type\": \"string\"\n },\n \"TomlDebugInfo\": {\n \"type\": \"string\",\n \"enum\": [\n \"None\",\n \"LineDirectivesOnly\",\n \"LineTablesOnly\",\n \"Limited\",\n \"Full\"\n ]\n },\n \"PackageIdSpec\": {\n \"type\": \"string\"\n },\n \"TomlTrimPaths\": {\n \"anyOf\": [\n {\n \"type\": \"array\",\n \"items\": {\n \"$ref\": \"#/$defs/TomlTrimPathsValue\"\n }\n },\n {\n \"type\": \"null\"\n }\n ]\n },\n \"TomlTrimPathsValue\": {\n \"type\": \"string\",\n \"enum\": [\n \"diagnostics\",\n \"macro\",\n \"object\"\n ]\n }\n }\n}" }, { "path": "crates/cargo-util-schemas/src/core/mod.rs", "content": "mod package_id_spec;\nmod partial_version;\nmod source_kind;\n\npub use package_id_spec::PackageIdSpec;\npub use package_id_spec::PackageIdSpecError;\npub use partial_version::PartialVersion;\npub use partial_version::PartialVersionError;\npub use source_kind::GitReference;\npub use source_kind::SourceKind;\n" }, { "path": "crates/cargo-util-schemas/src/core/package_id_spec.rs", "content": "use std::fmt;\n\nuse semver::Version;\nuse serde::{de, ser};\nuse url::Url;\n\nuse crate::core::GitReference;\nuse crate::core::PartialVersion;\nuse crate::core::PartialVersionError;\nuse crate::core::SourceKind;\nuse crate::manifest::PackageName;\nuse crate::restricted_names::NameValidationError;\n\ntype Result = std::result::Result;\n\n/// Some or all of the data required to identify a package:\n///\n/// 1. the package name (a `String`, required)\n/// 2. the package version (a `Version`, optional)\n/// 3. the package source (a `Url`, optional)\n///\n/// If any of the optional fields are omitted, then the package ID may be ambiguous, there may be\n/// more than one package/version/url combo that will match. However, often just the name is\n/// sufficient to uniquely define a package ID.\n#[derive(Clone, PartialEq, Eq, Debug, Hash, Ord, PartialOrd)]\npub struct PackageIdSpec {\n name: String,\n version: Option,\n url: Option,\n kind: Option,\n}\n\nimpl PackageIdSpec {\n pub fn new(name: String) -> Self {\n Self {\n name,\n version: None,\n url: None,\n kind: None,\n }\n }\n\n pub fn with_version(mut self, version: PartialVersion) -> Self {\n self.version = Some(version);\n self\n }\n\n pub fn with_url(mut self, url: Url) -> Self {\n self.url = Some(url);\n self\n }\n\n pub fn with_kind(mut self, kind: SourceKind) -> Self {\n self.kind = Some(kind);\n self\n }\n\n /// Parses a spec string and returns a `PackageIdSpec` if the string was valid.\n ///\n /// # Examples\n /// Some examples of valid strings\n ///\n /// ```\n /// use cargo_util_schemas::core::PackageIdSpec;\n ///\n /// let specs = vec![\n /// \"foo\",\n /// \"foo@1.4\",\n /// \"foo@1.4.3\",\n /// \"foo:1.2.3\",\n /// \"https://github.com/rust-lang/crates.io-index#foo\",\n /// \"https://github.com/rust-lang/crates.io-index#foo@1.4.3\",\n /// \"ssh://git@github.com/rust-lang/foo.git#foo@1.4.3\",\n /// \"file:///path/to/my/project/foo\",\n /// \"file:///path/to/my/project/foo#1.1.8\"\n /// ];\n /// for spec in specs {\n /// assert!(PackageIdSpec::parse(spec).is_ok());\n /// }\n pub fn parse(spec: &str) -> Result {\n if spec.contains(\"://\") {\n if let Ok(url) = Url::parse(spec) {\n return PackageIdSpec::from_url(url);\n }\n } else if spec.contains('/') || spec.contains('\\\\') {\n let abs = std::env::current_dir().unwrap_or_default().join(spec);\n if abs.exists() {\n let maybe_url = Url::from_file_path(abs)\n .map_or_else(|_| \"a file:// URL\".to_string(), |url| url.to_string());\n return Err(ErrorKind::MaybeFilePath {\n spec: spec.into(),\n maybe_url,\n }\n .into());\n }\n }\n let (name, version) = parse_spec(spec)?.unwrap_or_else(|| (spec.to_owned(), None));\n PackageName::new(&name)?;\n Ok(PackageIdSpec {\n name: String::from(name),\n version,\n url: None,\n kind: None,\n })\n }\n\n /// Tries to convert a valid `Url` to a `PackageIdSpec`.\n fn from_url(mut url: Url) -> Result {\n let mut kind = None;\n if let Some((kind_str, scheme)) = url.scheme().split_once('+') {\n match kind_str {\n \"git\" => {\n let git_ref = GitReference::from_query(url.query_pairs());\n url.set_query(None);\n kind = Some(SourceKind::Git(git_ref));\n url = strip_url_protocol(&url);\n }\n \"registry\" => {\n if url.query().is_some() {\n return Err(ErrorKind::UnexpectedQueryString(url).into());\n }\n kind = Some(SourceKind::Registry);\n url = strip_url_protocol(&url);\n }\n \"sparse\" => {\n if url.query().is_some() {\n return Err(ErrorKind::UnexpectedQueryString(url).into());\n }\n kind = Some(SourceKind::SparseRegistry);\n // Leave `sparse` as part of URL, see `SourceId::new`\n // url = strip_url_protocol(&url);\n }\n \"path\" => {\n if url.query().is_some() {\n return Err(ErrorKind::UnexpectedQueryString(url).into());\n }\n if scheme != \"file\" {\n return Err(ErrorKind::UnsupportedPathPlusScheme(scheme.into()).into());\n }\n kind = Some(SourceKind::Path);\n url = strip_url_protocol(&url);\n }\n kind => return Err(ErrorKind::UnsupportedProtocol(kind.into()).into()),\n }\n } else {\n if url.query().is_some() {\n return Err(ErrorKind::UnexpectedQueryString(url).into());\n }\n }\n\n let frag = url.fragment().map(|s| s.to_owned());\n url.set_fragment(None);\n\n let (name, version) = {\n let Some(path_name) = url.path_segments().and_then(|mut p| p.next_back()) else {\n return Err(ErrorKind::MissingUrlPath(url).into());\n };\n match frag {\n Some(fragment) => match parse_spec(&fragment)? {\n Some((name, ver)) => (name, ver),\n None => {\n let Some(f) = fragment.chars().next() else {\n return Err(PackageIdSpecError(ErrorKind::EmptyFragment));\n };\n\n if f.is_alphabetic() {\n (String::from(fragment.as_str()), None)\n } else {\n let version = fragment.parse::()?;\n (String::from(path_name), Some(version))\n }\n }\n },\n None => (String::from(path_name), None),\n }\n };\n PackageName::new(&name)?;\n Ok(PackageIdSpec {\n name,\n version,\n url: Some(url),\n kind,\n })\n }\n\n pub fn name(&self) -> &str {\n self.name.as_str()\n }\n\n /// Full `semver::Version`, if present\n pub fn version(&self) -> Option {\n self.version.as_ref().and_then(|v| v.to_version())\n }\n\n pub fn partial_version(&self) -> Option<&PartialVersion> {\n self.version.as_ref()\n }\n\n pub fn url(&self) -> Option<&Url> {\n self.url.as_ref()\n }\n\n pub fn set_url(&mut self, url: Url) {\n self.url = Some(url);\n }\n\n pub fn kind(&self) -> Option<&SourceKind> {\n self.kind.as_ref()\n }\n\n pub fn set_kind(&mut self, kind: SourceKind) {\n self.kind = Some(kind);\n }\n}\n\nfn parse_spec(spec: &str) -> Result)>> {\n let Some((name, ver)) = spec\n .rsplit_once('@')\n .or_else(|| spec.rsplit_once(':').filter(|(n, _)| !n.ends_with(':')))\n else {\n return Ok(None);\n };\n let name = name.to_owned();\n let ver = ver.parse::()?;\n Ok(Some((name, Some(ver))))\n}\n\nfn strip_url_protocol(url: &Url) -> Url {\n // Ridiculous hoop because `Url::set_scheme` errors when changing to http/https\n let raw = url.to_string();\n raw.split_once('+').unwrap().1.parse().unwrap()\n}\n\nimpl fmt::Display for PackageIdSpec {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n let mut printed_name = false;\n match self.url {\n Some(ref url) => {\n if let Some(protocol) = self.kind.as_ref().and_then(|k| k.protocol()) {\n write!(f, \"{protocol}+\")?;\n }\n write!(f, \"{}\", url)?;\n if let Some(SourceKind::Git(git_ref)) = self.kind.as_ref() {\n if let Some(pretty) = git_ref.pretty_ref(true) {\n write!(f, \"?{}\", pretty)?;\n }\n }\n if url.path_segments().unwrap().next_back().unwrap() != &*self.name {\n printed_name = true;\n write!(f, \"#{}\", self.name)?;\n }\n }\n None => {\n printed_name = true;\n write!(f, \"{}\", self.name)?;\n }\n }\n if let Some(ref v) = self.version {\n write!(f, \"{}{}\", if printed_name { \"@\" } else { \"#\" }, v)?;\n }\n Ok(())\n }\n}\n\nimpl ser::Serialize for PackageIdSpec {\n fn serialize(&self, s: S) -> std::result::Result\n where\n S: ser::Serializer,\n {\n self.to_string().serialize(s)\n }\n}\n\nimpl<'de> de::Deserialize<'de> for PackageIdSpec {\n fn deserialize(d: D) -> std::result::Result\n where\n D: de::Deserializer<'de>,\n {\n let string = String::deserialize(d)?;\n PackageIdSpec::parse(&string).map_err(de::Error::custom)\n }\n}\n\n#[cfg(feature = \"unstable-schema\")]\nimpl schemars::JsonSchema for PackageIdSpec {\n fn schema_name() -> std::borrow::Cow<'static, str> {\n \"PackageIdSpec\".into()\n }\n fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {\n ::json_schema(generator)\n }\n}\n\n#[derive(Debug, thiserror::Error)]\n#[error(transparent)]\npub struct PackageIdSpecError(#[from] ErrorKind);\n\nimpl From for PackageIdSpecError {\n fn from(value: PartialVersionError) -> Self {\n ErrorKind::PartialVersion(value).into()\n }\n}\n\nimpl From for PackageIdSpecError {\n fn from(value: NameValidationError) -> Self {\n ErrorKind::NameValidation(value).into()\n }\n}\n\n/// Non-public error kind for [`PackageIdSpecError`].\n#[non_exhaustive]\n#[derive(Debug, thiserror::Error)]\nenum ErrorKind {\n #[error(\"unsupported source protocol: {0}\")]\n UnsupportedProtocol(String),\n\n #[error(\"`path+{0}` is unsupported; `path+file` and `file` schemes are supported\")]\n UnsupportedPathPlusScheme(String),\n\n #[error(\"cannot have a query string in a pkgid: {0}\")]\n UnexpectedQueryString(Url),\n\n #[error(\"pkgid urls must have at least one path component: {0}\")]\n MissingUrlPath(Url),\n\n #[error(\"package ID specification `{spec}` looks like a file path, maybe try {maybe_url}\")]\n MaybeFilePath { spec: String, maybe_url: String },\n\n #[error(\"pkgid url cannot have an empty fragment\")]\n EmptyFragment,\n\n #[error(transparent)]\n NameValidation(#[from] crate::restricted_names::NameValidationError),\n\n #[error(transparent)]\n PartialVersion(#[from] crate::core::PartialVersionError),\n}\n\n#[cfg(test)]\nmod tests {\n use super::ErrorKind;\n use super::PackageIdSpec;\n use crate::core::{GitReference, SourceKind};\n use url::Url;\n\n #[track_caller]\n fn ok(spec: &str, expected: PackageIdSpec, expected_rendered: &str) {\n let parsed = PackageIdSpec::parse(spec).unwrap();\n assert_eq!(parsed, expected);\n let rendered = parsed.to_string();\n assert_eq!(rendered, expected_rendered);\n let reparsed = PackageIdSpec::parse(&rendered).unwrap();\n assert_eq!(reparsed, expected);\n }\n\n macro_rules! err {\n ($spec:expr, $expected:pat) => {\n let err = PackageIdSpec::parse($spec).unwrap_err();\n let kind = err.0;\n assert!(\n matches!(kind, $expected),\n \"`{}` parse error mismatch, got {kind:?}\",\n $spec\n );\n };\n }\n\n #[test]\n fn good_parsing() {\n ok(\n \"https://crates.io/foo\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: None,\n url: Some(Url::parse(\"https://crates.io/foo\").unwrap()),\n kind: None,\n },\n \"https://crates.io/foo\",\n );\n ok(\n \"https://crates.io/foo#1.2.3\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: Some(\"1.2.3\".parse().unwrap()),\n url: Some(Url::parse(\"https://crates.io/foo\").unwrap()),\n kind: None,\n },\n \"https://crates.io/foo#1.2.3\",\n );\n ok(\n \"https://crates.io/foo#1.2\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: Some(\"1.2\".parse().unwrap()),\n url: Some(Url::parse(\"https://crates.io/foo\").unwrap()),\n kind: None,\n },\n \"https://crates.io/foo#1.2\",\n );\n ok(\n \"https://crates.io/foo#bar:1.2.3\",\n PackageIdSpec {\n name: String::from(\"bar\"),\n version: Some(\"1.2.3\".parse().unwrap()),\n url: Some(Url::parse(\"https://crates.io/foo\").unwrap()),\n kind: None,\n },\n \"https://crates.io/foo#bar@1.2.3\",\n );\n ok(\n \"https://crates.io/foo#bar@1.2.3\",\n PackageIdSpec {\n name: String::from(\"bar\"),\n version: Some(\"1.2.3\".parse().unwrap()),\n url: Some(Url::parse(\"https://crates.io/foo\").unwrap()),\n kind: None,\n },\n \"https://crates.io/foo#bar@1.2.3\",\n );\n ok(\n \"https://crates.io/foo#bar@1.2\",\n PackageIdSpec {\n name: String::from(\"bar\"),\n version: Some(\"1.2\".parse().unwrap()),\n url: Some(Url::parse(\"https://crates.io/foo\").unwrap()),\n kind: None,\n },\n \"https://crates.io/foo#bar@1.2\",\n );\n ok(\n \"registry+https://crates.io/foo#bar@1.2\",\n PackageIdSpec {\n name: String::from(\"bar\"),\n version: Some(\"1.2\".parse().unwrap()),\n url: Some(Url::parse(\"https://crates.io/foo\").unwrap()),\n kind: Some(SourceKind::Registry),\n },\n \"registry+https://crates.io/foo#bar@1.2\",\n );\n ok(\n \"sparse+https://crates.io/foo#bar@1.2\",\n PackageIdSpec {\n name: String::from(\"bar\"),\n version: Some(\"1.2\".parse().unwrap()),\n url: Some(Url::parse(\"sparse+https://crates.io/foo\").unwrap()),\n kind: Some(SourceKind::SparseRegistry),\n },\n \"sparse+https://crates.io/foo#bar@1.2\",\n );\n ok(\n \"foo\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: None,\n url: None,\n kind: None,\n },\n \"foo\",\n );\n ok(\n \"foo::bar\",\n PackageIdSpec {\n name: String::from(\"foo::bar\"),\n version: None,\n url: None,\n kind: None,\n },\n \"foo::bar\",\n );\n ok(\n \"foo:1.2.3\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: Some(\"1.2.3\".parse().unwrap()),\n url: None,\n kind: None,\n },\n \"foo@1.2.3\",\n );\n ok(\n \"foo::bar:1.2.3\",\n PackageIdSpec {\n name: String::from(\"foo::bar\"),\n version: Some(\"1.2.3\".parse().unwrap()),\n url: None,\n kind: None,\n },\n \"foo::bar@1.2.3\",\n );\n ok(\n \"foo@1.2.3\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: Some(\"1.2.3\".parse().unwrap()),\n url: None,\n kind: None,\n },\n \"foo@1.2.3\",\n );\n ok(\n \"foo::bar@1.2.3\",\n PackageIdSpec {\n name: String::from(\"foo::bar\"),\n version: Some(\"1.2.3\".parse().unwrap()),\n url: None,\n kind: None,\n },\n \"foo::bar@1.2.3\",\n );\n ok(\n \"foo@1.2\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: Some(\"1.2\".parse().unwrap()),\n url: None,\n kind: None,\n },\n \"foo@1.2\",\n );\n\n // pkgid-spec.md\n ok(\n \"regex\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: None,\n url: None,\n kind: None,\n },\n \"regex\",\n );\n ok(\n \"regex@1.4\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: Some(\"1.4\".parse().unwrap()),\n url: None,\n kind: None,\n },\n \"regex@1.4\",\n );\n ok(\n \"regex@1.4.3\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: Some(\"1.4.3\".parse().unwrap()),\n url: None,\n kind: None,\n },\n \"regex@1.4.3\",\n );\n ok(\n \"https://github.com/rust-lang/crates.io-index#regex\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: None,\n url: Some(Url::parse(\"https://github.com/rust-lang/crates.io-index\").unwrap()),\n kind: None,\n },\n \"https://github.com/rust-lang/crates.io-index#regex\",\n );\n ok(\n \"https://github.com/rust-lang/crates.io-index#regex@1.4.3\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: Some(\"1.4.3\".parse().unwrap()),\n url: Some(Url::parse(\"https://github.com/rust-lang/crates.io-index\").unwrap()),\n kind: None,\n },\n \"https://github.com/rust-lang/crates.io-index#regex@1.4.3\",\n );\n ok(\n \"sparse+https://github.com/rust-lang/crates.io-index#regex@1.4.3\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: Some(\"1.4.3\".parse().unwrap()),\n url: Some(\n Url::parse(\"sparse+https://github.com/rust-lang/crates.io-index\").unwrap(),\n ),\n kind: Some(SourceKind::SparseRegistry),\n },\n \"sparse+https://github.com/rust-lang/crates.io-index#regex@1.4.3\",\n );\n ok(\n \"https://github.com/rust-lang/cargo#0.52.0\",\n PackageIdSpec {\n name: String::from(\"cargo\"),\n version: Some(\"0.52.0\".parse().unwrap()),\n url: Some(Url::parse(\"https://github.com/rust-lang/cargo\").unwrap()),\n kind: None,\n },\n \"https://github.com/rust-lang/cargo#0.52.0\",\n );\n ok(\n \"https://github.com/rust-lang/cargo#cargo-platform@0.1.2\",\n PackageIdSpec {\n name: String::from(\"cargo-platform\"),\n version: Some(\"0.1.2\".parse().unwrap()),\n url: Some(Url::parse(\"https://github.com/rust-lang/cargo\").unwrap()),\n kind: None,\n },\n \"https://github.com/rust-lang/cargo#cargo-platform@0.1.2\",\n );\n ok(\n \"ssh://git@github.com/rust-lang/regex.git#regex@1.4.3\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: Some(\"1.4.3\".parse().unwrap()),\n url: Some(Url::parse(\"ssh://git@github.com/rust-lang/regex.git\").unwrap()),\n kind: None,\n },\n \"ssh://git@github.com/rust-lang/regex.git#regex@1.4.3\",\n );\n ok(\n \"git+ssh://git@github.com/rust-lang/regex.git#regex@1.4.3\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: Some(\"1.4.3\".parse().unwrap()),\n url: Some(Url::parse(\"ssh://git@github.com/rust-lang/regex.git\").unwrap()),\n kind: Some(SourceKind::Git(GitReference::DefaultBranch)),\n },\n \"git+ssh://git@github.com/rust-lang/regex.git#regex@1.4.3\",\n );\n ok(\n \"git+ssh://git@github.com/rust-lang/regex.git?branch=dev#regex@1.4.3\",\n PackageIdSpec {\n name: String::from(\"regex\"),\n version: Some(\"1.4.3\".parse().unwrap()),\n url: Some(Url::parse(\"ssh://git@github.com/rust-lang/regex.git\").unwrap()),\n kind: Some(SourceKind::Git(GitReference::Branch(\"dev\".to_owned()))),\n },\n \"git+ssh://git@github.com/rust-lang/regex.git?branch=dev#regex@1.4.3\",\n );\n ok(\n \"file:///path/to/my/project/foo\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: None,\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: None,\n },\n \"file:///path/to/my/project/foo\",\n );\n ok(\n \"file:///path/to/my/project/foo::bar\",\n PackageIdSpec {\n name: String::from(\"foo::bar\"),\n version: None,\n url: Some(Url::parse(\"file:///path/to/my/project/foo::bar\").unwrap()),\n kind: None,\n },\n \"file:///path/to/my/project/foo::bar\",\n );\n ok(\n \"file:///path/to/my/project/foo#1.1.8\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: Some(\"1.1.8\".parse().unwrap()),\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: None,\n },\n \"file:///path/to/my/project/foo#1.1.8\",\n );\n ok(\n \"path+file:///path/to/my/project/foo#1.1.8\",\n PackageIdSpec {\n name: String::from(\"foo\"),\n version: Some(\"1.1.8\".parse().unwrap()),\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: Some(SourceKind::Path),\n },\n \"path+file:///path/to/my/project/foo#1.1.8\",\n );\n ok(\n \"path+file:///path/to/my/project/foo#bar\",\n PackageIdSpec {\n name: String::from(\"bar\"),\n version: None,\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: Some(SourceKind::Path),\n },\n \"path+file:///path/to/my/project/foo#bar\",\n );\n ok(\n \"path+file:///path/to/my/project/foo#foo::bar\",\n PackageIdSpec {\n name: String::from(\"foo::bar\"),\n version: None,\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: Some(SourceKind::Path),\n },\n \"path+file:///path/to/my/project/foo#foo::bar\",\n );\n ok(\n \"path+file:///path/to/my/project/foo#bar:1.1.8\",\n PackageIdSpec {\n name: String::from(\"bar\"),\n version: Some(\"1.1.8\".parse().unwrap()),\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: Some(SourceKind::Path),\n },\n \"path+file:///path/to/my/project/foo#bar@1.1.8\",\n );\n ok(\n \"path+file:///path/to/my/project/foo#foo::bar:1.1.8\",\n PackageIdSpec {\n name: String::from(\"foo::bar\"),\n version: Some(\"1.1.8\".parse().unwrap()),\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: Some(SourceKind::Path),\n },\n \"path+file:///path/to/my/project/foo#foo::bar@1.1.8\",\n );\n ok(\n \"path+file:///path/to/my/project/foo#bar@1.1.8\",\n PackageIdSpec {\n name: String::from(\"bar\"),\n version: Some(\"1.1.8\".parse().unwrap()),\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: Some(SourceKind::Path),\n },\n \"path+file:///path/to/my/project/foo#bar@1.1.8\",\n );\n ok(\n \"path+file:///path/to/my/project/foo#foo::bar@1.1.8\",\n PackageIdSpec {\n name: String::from(\"foo::bar\"),\n version: Some(\"1.1.8\".parse().unwrap()),\n url: Some(Url::parse(\"file:///path/to/my/project/foo\").unwrap()),\n kind: Some(SourceKind::Path),\n },\n \"path+file:///path/to/my/project/foo#foo::bar@1.1.8\",\n );\n }\n\n #[test]\n fn bad_parsing() {\n err!(\"baz:\", ErrorKind::PartialVersion(_));\n err!(\"baz:*\", ErrorKind::PartialVersion(_));\n err!(\"baz@\", ErrorKind::PartialVersion(_));\n err!(\"baz@*\", ErrorKind::PartialVersion(_));\n err!(\"baz@^1.0\", ErrorKind::PartialVersion(_));\n err!(\"https://baz:1.0\", ErrorKind::NameValidation(_));\n err!(\"https://#baz:1.0\", ErrorKind::NameValidation(_));\n err!(\n \"foobar+https://github.com/rust-lang/crates.io-index\",\n ErrorKind::UnsupportedProtocol(_)\n );\n err!(\n \"path+https://github.com/rust-lang/crates.io-index\",\n ErrorKind::UnsupportedPathPlusScheme(_)\n );\n\n // Only `git+` can use `?`\n err!(\n \"file:///path/to/my/project/foo?branch=dev\",\n ErrorKind::UnexpectedQueryString(_)\n );\n err!(\n \"path+file:///path/to/my/project/foo?branch=dev\",\n ErrorKind::UnexpectedQueryString(_)\n );\n err!(\n \"registry+https://github.com/rust-lang/cargo?branch=dev#0.52.0\",\n ErrorKind::UnexpectedQueryString(_)\n );\n err!(\n \"sparse+https://github.com/rust-lang/cargo?branch=dev#0.52.0\",\n ErrorKind::UnexpectedQueryString(_)\n );\n err!(\"@1.2.3\", ErrorKind::NameValidation(_));\n err!(\"registry+https://github.com\", ErrorKind::NameValidation(_));\n err!(\"https://crates.io/1foo#1.2.3\", ErrorKind::NameValidation(_));\n err!(\"https://example.com/foo#\", ErrorKind::EmptyFragment);\n }\n}\n" }, { "path": "crates/cargo-util-schemas/src/core/partial_version.rs", "content": "use std::fmt::{self, Display};\n\nuse semver::{Comparator, Version, VersionReq};\nuse serde_untagged::UntaggedEnumVisitor;\n\n#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Debug)]\npub struct PartialVersion {\n pub major: u64,\n pub minor: Option,\n pub patch: Option,\n pub pre: Option,\n pub build: Option,\n}\n\nimpl PartialVersion {\n pub fn to_version(&self) -> Option {\n Some(Version {\n major: self.major,\n minor: self.minor?,\n patch: self.patch?,\n pre: self.pre.clone().unwrap_or_default(),\n build: self.build.clone().unwrap_or_default(),\n })\n }\n\n pub fn to_caret_req(&self) -> VersionReq {\n VersionReq {\n comparators: vec![Comparator {\n op: semver::Op::Caret,\n major: self.major,\n minor: self.minor,\n patch: self.patch,\n pre: self.pre.as_ref().cloned().unwrap_or_default(),\n }],\n }\n }\n\n /// Check if this matches a version, including build metadata\n ///\n /// Build metadata does not affect version precedence but may be necessary for uniquely\n /// identifying a package.\n pub fn matches(&self, version: &Version) -> bool {\n if !version.pre.is_empty() && self.pre.is_none() {\n // Pre-release versions must be explicitly opted into, if for no other reason than to\n // give us room to figure out and define the semantics\n return false;\n }\n self.major == version.major\n && self.minor.map(|f| f == version.minor).unwrap_or(true)\n && self.patch.map(|f| f == version.patch).unwrap_or(true)\n && self.pre.as_ref().map(|f| f == &version.pre).unwrap_or(true)\n && self\n .build\n .as_ref()\n .map(|f| f == &version.build)\n .unwrap_or(true)\n }\n}\n\nimpl From for PartialVersion {\n fn from(ver: semver::Version) -> Self {\n let pre = if ver.pre.is_empty() {\n None\n } else {\n Some(ver.pre)\n };\n let build = if ver.build.is_empty() {\n None\n } else {\n Some(ver.build)\n };\n Self {\n major: ver.major,\n minor: Some(ver.minor),\n patch: Some(ver.patch),\n pre,\n build,\n }\n }\n}\n\nimpl std::str::FromStr for PartialVersion {\n type Err = PartialVersionError;\n\n fn from_str(value: &str) -> Result {\n match semver::Version::parse(value) {\n Ok(ver) => Ok(ver.into()),\n Err(_) => {\n // HACK: Leverage `VersionReq` for partial version parsing\n let mut version_req = match semver::VersionReq::parse(value) {\n Ok(req) => req,\n Err(_) if value.contains('-') => return Err(ErrorKind::Prerelease.into()),\n Err(_) if value.contains('+') => return Err(ErrorKind::BuildMetadata.into()),\n Err(_) => return Err(ErrorKind::Unexpected.into()),\n };\n if version_req.comparators.len() != 1 {\n return Err(ErrorKind::VersionReq.into());\n }\n let comp = version_req.comparators.pop().unwrap();\n if comp.op != semver::Op::Caret {\n return Err(ErrorKind::VersionReq.into());\n } else if value.starts_with('^') {\n // Can't distinguish between `^` present or not\n return Err(ErrorKind::VersionReq.into());\n }\n let pre = if comp.pre.is_empty() {\n None\n } else {\n Some(comp.pre)\n };\n Ok(Self {\n major: comp.major,\n minor: comp.minor,\n patch: comp.patch,\n pre,\n build: None,\n })\n }\n }\n }\n}\n\nimpl Display for PartialVersion {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n let major = self.major;\n write!(f, \"{major}\")?;\n if let Some(minor) = self.minor {\n write!(f, \".{minor}\")?;\n }\n if let Some(patch) = self.patch {\n write!(f, \".{patch}\")?;\n }\n if let Some(pre) = self.pre.as_ref() {\n write!(f, \"-{pre}\")?;\n }\n if let Some(build) = self.build.as_ref() {\n write!(f, \"+{build}\")?;\n }\n Ok(())\n }\n}\n\nimpl serde::Serialize for PartialVersion {\n fn serialize(&self, serializer: S) -> Result\n where\n S: serde::Serializer,\n {\n serializer.collect_str(self)\n }\n}\n\nimpl<'de> serde::Deserialize<'de> for PartialVersion {\n fn deserialize(deserializer: D) -> Result\n where\n D: serde::Deserializer<'de>,\n {\n UntaggedEnumVisitor::new()\n .expecting(\"SemVer version\")\n .string(|value| value.parse().map_err(serde::de::Error::custom))\n .deserialize(deserializer)\n }\n}\n\n/// Error parsing a [`PartialVersion`].\n#[derive(Debug, thiserror::Error)]\n#[error(transparent)]\npub struct PartialVersionError(#[from] ErrorKind);\n\n/// Non-public error kind for [`PartialVersionError`].\n#[non_exhaustive]\n#[derive(Debug, thiserror::Error)]\nenum ErrorKind {\n #[error(\"unexpected version requirement, expected a version like \\\"1.32\\\"\")]\n VersionReq,\n\n #[error(\"unexpected prerelease field, expected a version like \\\"1.32\\\"\")]\n Prerelease,\n\n #[error(\"unexpected build field, expected a version like \\\"1.32\\\"\")]\n BuildMetadata,\n\n #[error(\"expected a version like \\\"1.32\\\"\")]\n Unexpected,\n}\n\n#[cfg(test)]\nmod test {\n use super::*;\n use snapbox::prelude::*;\n use snapbox::str;\n\n #[test]\n fn parse_success() {\n let cases = &[\n // Valid pre-release\n (\"1.43.0-beta.1\", str![\"1.43.0-beta.1\"]),\n // Valid pre-release with wildcard\n (\"1.43.0-beta.1.x\", str![\"1.43.0-beta.1.x\"]),\n ];\n for (input, expected) in cases {\n let actual: Result = input.parse();\n let actual = match actual {\n Ok(result) => result.to_string(),\n Err(err) => format!(\"didn't pass: {err}\"),\n };\n snapbox::assert_data_eq!(actual, expected.clone().raw());\n }\n }\n\n #[test]\n fn parse_errors() {\n let cases = &[\n // Disallow caret\n (\n \"^1.43\",\n str![[r#\"unexpected version requirement, expected a version like \"1.32\"\"#]],\n ),\n // Bad pre-release\n (\n \"1.43-beta.1\",\n str![[r#\"unexpected prerelease field, expected a version like \"1.32\"\"#]],\n ),\n // Weird wildcard\n (\n \"x\",\n str![[r#\"unexpected version requirement, expected a version like \"1.32\"\"#]],\n ),\n (\n \"1.x\",\n str![[r#\"unexpected version requirement, expected a version like \"1.32\"\"#]],\n ),\n (\n \"1.1.x\",\n str![[r#\"unexpected version requirement, expected a version like \"1.32\"\"#]],\n ),\n // Non-sense\n (\"foodaddle\", str![[r#\"expected a version like \"1.32\"\"#]]),\n ];\n for (input, expected) in cases {\n let actual: Result = input.parse();\n let actual = match actual {\n Ok(result) => format!(\"didn't fail: {result:?}\"),\n Err(err) => err.to_string(),\n };\n snapbox::assert_data_eq!(actual, expected.clone().raw());\n }\n }\n}\n" }, { "path": "crates/cargo-util-schemas/src/core/source_kind.rs", "content": "use std::cmp::Ordering;\n\n/// The possible kinds of code source.\n#[derive(Debug, Clone, PartialEq, Eq)]\npub enum SourceKind {\n /// A git repository.\n Git(GitReference),\n /// A local path.\n Path,\n /// A remote registry.\n Registry,\n /// A sparse registry.\n SparseRegistry,\n /// A local filesystem-based registry.\n LocalRegistry,\n /// A directory-based registry.\n Directory,\n}\n\n// The hash here is important for what folder packages get downloaded into.\n// Changes trigger all users to download another copy of their crates.\n// So the `stable_hash` test checks that we only change it intentionally.\n// We implement hash manually to callout the stability impact.\nimpl std::hash::Hash for SourceKind {\n fn hash(&self, state: &mut H) {\n core::mem::discriminant(self).hash(state);\n if let SourceKind::Git(git) = self {\n git.hash(state);\n }\n }\n}\n\nimpl SourceKind {\n pub fn protocol(&self) -> Option<&str> {\n match self {\n SourceKind::Path => Some(\"path\"),\n SourceKind::Git(_) => Some(\"git\"),\n SourceKind::Registry => Some(\"registry\"),\n // Sparse registry URL already includes the `sparse+` prefix, see `SourceId::new`\n SourceKind::SparseRegistry => None,\n SourceKind::LocalRegistry => Some(\"local-registry\"),\n SourceKind::Directory => Some(\"directory\"),\n }\n }\n}\n\n// The ordering here is important for how packages are serialized into lock files.\n// We implement it manually to callout the stability guarantee.\n// See https://github.com/rust-lang/cargo/pull/9397 for the history.\nimpl Ord for SourceKind {\n fn cmp(&self, other: &SourceKind) -> Ordering {\n match (self, other) {\n (SourceKind::Path, SourceKind::Path) => Ordering::Equal,\n (SourceKind::Path, _) => Ordering::Less,\n (_, SourceKind::Path) => Ordering::Greater,\n\n (SourceKind::Registry, SourceKind::Registry) => Ordering::Equal,\n (SourceKind::Registry, _) => Ordering::Less,\n (_, SourceKind::Registry) => Ordering::Greater,\n\n (SourceKind::SparseRegistry, SourceKind::SparseRegistry) => Ordering::Equal,\n (SourceKind::SparseRegistry, _) => Ordering::Less,\n (_, SourceKind::SparseRegistry) => Ordering::Greater,\n\n (SourceKind::LocalRegistry, SourceKind::LocalRegistry) => Ordering::Equal,\n (SourceKind::LocalRegistry, _) => Ordering::Less,\n (_, SourceKind::LocalRegistry) => Ordering::Greater,\n\n (SourceKind::Directory, SourceKind::Directory) => Ordering::Equal,\n (SourceKind::Directory, _) => Ordering::Less,\n (_, SourceKind::Directory) => Ordering::Greater,\n\n (SourceKind::Git(a), SourceKind::Git(b)) => a.cmp(b),\n }\n }\n}\n\n/// Forwards to `Ord`\nimpl PartialOrd for SourceKind {\n fn partial_cmp(&self, other: &SourceKind) -> Option {\n Some(self.cmp(other))\n }\n}\n\n/// Information to find a specific commit in a Git repository.\n#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\npub enum GitReference {\n /// From a tag.\n Tag(String),\n /// From a branch.\n Branch(String),\n /// From a specific revision. Can be a commit hash (either short or full),\n /// or a named reference like `refs/pull/493/head`.\n Rev(String),\n /// The default branch of the repository, the reference named `HEAD`.\n DefaultBranch,\n}\n\nimpl GitReference {\n pub fn from_query(\n query_pairs: impl Iterator, impl AsRef)>,\n ) -> Self {\n let mut reference = GitReference::DefaultBranch;\n for (k, v) in query_pairs {\n let v = v.as_ref();\n match k.as_ref() {\n // Map older 'ref' to branch.\n \"branch\" | \"ref\" => reference = GitReference::Branch(v.to_owned()),\n\n \"rev\" => reference = GitReference::Rev(v.to_owned()),\n \"tag\" => reference = GitReference::Tag(v.to_owned()),\n _ => {}\n }\n }\n reference\n }\n\n /// Returns a `Display`able view of this git reference, or None if using\n /// the head of the default branch\n pub fn pretty_ref(&self, url_encoded: bool) -> Option> {\n match self {\n GitReference::DefaultBranch => None,\n _ => Some(PrettyRef {\n inner: self,\n url_encoded,\n }),\n }\n }\n}\n\n/// A git reference that can be `Display`ed\npub struct PrettyRef<'a> {\n inner: &'a GitReference,\n url_encoded: bool,\n}\n\nimpl<'a> std::fmt::Display for PrettyRef<'a> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let value: &str;\n match self.inner {\n GitReference::Branch(s) => {\n write!(f, \"branch=\")?;\n value = s;\n }\n GitReference::Tag(s) => {\n write!(f, \"tag=\")?;\n value = s;\n }\n GitReference::Rev(s) => {\n write!(f, \"rev=\")?;\n value = s;\n }\n GitReference::DefaultBranch => unreachable!(),\n }\n if self.url_encoded {\n for value in url::form_urlencoded::byte_serialize(value.as_bytes()) {\n write!(f, \"{value}\")?;\n }\n } else {\n write!(f, \"{value}\")?;\n }\n Ok(())\n }\n}\n" }, { "path": "crates/cargo-util-schemas/src/index.rs", "content": "use crate::manifest::RustVersion;\nuse semver::Version;\nuse serde::{Deserialize, Serialize};\nuse std::{borrow::Cow, collections::BTreeMap};\n\n/// A single line in the index representing a single version of a package.\n#[derive(Deserialize, Serialize)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct IndexPackage<'a> {\n /// Name of the package.\n #[serde(borrow)]\n pub name: Cow<'a, str>,\n /// The version of this dependency.\n pub vers: Version,\n /// All kinds of direct dependencies of the package, including dev and\n /// build dependencies.\n #[serde(borrow)]\n pub deps: Vec>,\n /// Set of features defined for the package, i.e., `[features]` table.\n #[serde(default)]\n pub features: BTreeMap, Vec>>,\n /// This field contains features with new, extended syntax. Specifically,\n /// namespaced features (`dep:`) and weak dependencies (`pkg?/feat`).\n ///\n /// This is separated from `features` because versions older than 1.19\n /// will fail to load due to not being able to parse the new syntax, even\n /// with a `Cargo.lock` file.\n pub features2: Option, Vec>>>,\n /// Checksum for verifying the integrity of the corresponding downloaded package.\n pub cksum: String,\n /// If `true`, Cargo will skip this version when resolving.\n ///\n /// This was added in 2014. Everything in the crates.io index has this set\n /// now, so this probably doesn't need to be an option anymore.\n pub yanked: Option,\n /// Native library name this package links to.\n ///\n /// Added early 2018 (see ),\n /// can be `None` if published before then.\n pub links: Option>,\n /// Required version of rust\n ///\n /// Corresponds to `package.rust-version`.\n ///\n /// Added in 2023 (see ),\n /// can be `None` if published before then or if not set in the manifest.\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n pub rust_version: Option,\n /// The publish time of this package version (optional).\n ///\n /// The format is a subset of ISO8601:\n /// - `yyyy-mm-ddThh:mm:ssZ`\n /// - no fractional seconds\n /// - always `Z` for UTC timezone, no timezone offsets supported\n /// - fields are 0-padded\n ///\n /// Example: 2025-11-12T19:30:12Z\n ///\n /// This should be the original publish time and not changed on any status changes,\n /// like [`IndexPackage::yanked`].\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n #[serde(with = \"serde_pubtime\")]\n #[serde(default)]\n pub pubtime: Option,\n /// The schema version for this entry.\n ///\n /// If this is None, it defaults to version `1`. Entries with unknown\n /// versions are ignored.\n ///\n /// Version `2` schema adds the `features2` field.\n ///\n /// Version `3` schema adds `artifact`, `bindep_targes`, and `lib` for\n /// artifact dependencies support.\n ///\n /// This provides a method to safely introduce changes to index entries\n /// and allow older versions of cargo to ignore newer entries it doesn't\n /// understand. This is honored as of 1.51, so unfortunately older\n /// versions will ignore it, and potentially misinterpret version 2 and\n /// newer entries.\n ///\n /// The intent is that versions older than 1.51 will work with a\n /// pre-existing `Cargo.lock`, but they may not correctly process `cargo\n /// update` or build a lock from scratch. In that case, cargo may\n /// incorrectly select a new package that uses a new index schema. A\n /// workaround is to downgrade any packages that are incompatible with the\n /// `--precise` flag of `cargo update`.\n pub v: Option,\n}\n\n/// A dependency as encoded in the [`IndexPackage`] index JSON.\n#[derive(Deserialize, Serialize, Clone)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct RegistryDependency<'a> {\n /// Name of the dependency. If the dependency is renamed, the original\n /// would be stored in [`RegistryDependency::package`].\n #[serde(borrow)]\n pub name: Cow<'a, str>,\n /// The SemVer requirement for this dependency.\n #[serde(borrow)]\n pub req: Cow<'a, str>,\n /// Set of features enabled for this dependency.\n #[serde(default)]\n pub features: Vec>,\n /// Whether or not this is an optional dependency.\n #[serde(default)]\n pub optional: bool,\n /// Whether or not default features are enabled.\n #[serde(default = \"default_true\")]\n pub default_features: bool,\n /// The target platform for this dependency.\n pub target: Option>,\n /// The dependency kind. \"dev\", \"build\", and \"normal\".\n pub kind: Option>,\n /// The URL of the index of the registry where this dependency is from.\n /// `None` if it is from the same index.\n pub registry: Option>,\n /// The original name if the dependency is renamed.\n pub package: Option>,\n /// Whether or not this is a public dependency. Unstable. See [RFC 1977].\n ///\n /// [RFC 1977]: https://rust-lang.github.io/rfcs/1977-public-private-dependencies.html\n pub public: Option,\n /// The artifacts to build from this dependency.\n pub artifact: Option>>,\n /// The target for bindep.\n pub bindep_target: Option>,\n /// Whether or not this is a library dependency.\n #[serde(default)]\n pub lib: bool,\n}\n\npub fn parse_pubtime(s: &str) -> Result {\n let dt = jiff::civil::DateTime::strptime(\"%Y-%m-%dT%H:%M:%SZ\", s)?;\n if s.len() == 20 {\n let zoned = dt.to_zoned(jiff::tz::TimeZone::UTC)?;\n let timestamp = zoned.timestamp();\n Ok(timestamp)\n } else {\n Err(jiff::Error::from_args(format_args!(\n \"padding required for `{s}`\"\n )))\n }\n}\n\npub fn format_pubtime(t: jiff::Timestamp) -> String {\n t.strftime(\"%Y-%m-%dT%H:%M:%SZ\").to_string()\n}\n\nmod serde_pubtime {\n #[inline]\n pub(super) fn serialize(\n timestamp: &Option,\n se: S,\n ) -> Result {\n match *timestamp {\n None => se.serialize_none(),\n Some(ref ts) => {\n let s = super::format_pubtime(*ts);\n se.serialize_str(&s)\n }\n }\n }\n\n #[inline]\n pub(super) fn deserialize<'de, D: serde::Deserializer<'de>>(\n de: D,\n ) -> Result, D::Error> {\n de.deserialize_option(OptionalVisitor(\n serde_untagged::UntaggedEnumVisitor::new()\n .expecting(\"date time\")\n .string(|value| super::parse_pubtime(&value).map_err(serde::de::Error::custom)),\n ))\n }\n\n /// A generic visitor for `Option`.\n struct OptionalVisitor(V);\n\n impl<'de, V: serde::de::Visitor<'de, Value = jiff::Timestamp>> serde::de::Visitor<'de>\n for OptionalVisitor\n {\n type Value = Option;\n\n fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {\n f.write_str(\"date time\")\n }\n\n #[inline]\n fn visit_some>(\n self,\n de: D,\n ) -> Result, D::Error> {\n de.deserialize_str(self.0).map(Some)\n }\n\n #[inline]\n fn visit_none(self) -> Result, E> {\n Ok(None)\n }\n }\n}\n\nfn default_true() -> bool {\n true\n}\n\n#[test]\nfn escaped_char_in_index_json_blob() {\n let _: IndexPackage<'_> = serde_json::from_str(\n r#\"{\"name\":\"a\",\"vers\":\"0.0.1\",\"deps\":[],\"cksum\":\"bae3\",\"features\":{}}\"#,\n )\n .unwrap();\n let _: IndexPackage<'_> = serde_json::from_str(\n r#\"{\"name\":\"a\",\"vers\":\"0.0.1\",\"deps\":[],\"cksum\":\"bae3\",\"features\":{\"test\":[\"k\",\"q\"]},\"links\":\"a-sys\"}\"#\n ).unwrap();\n\n // Now we add escaped cher all the places they can go\n // these are not valid, but it should error later than json parsing\n let _: IndexPackage<'_> = serde_json::from_str(\n r#\"{\n \"name\":\"This name has a escaped cher in it \\n\\t\\\" \",\n \"vers\":\"0.0.1\",\n \"deps\":[{\n \"name\": \" \\n\\t\\\" \",\n \"req\": \" \\n\\t\\\" \",\n \"features\": [\" \\n\\t\\\" \"],\n \"optional\": true,\n \"default_features\": true,\n \"target\": \" \\n\\t\\\" \",\n \"kind\": \" \\n\\t\\\" \",\n \"registry\": \" \\n\\t\\\" \"\n }],\n \"cksum\":\"bae3\",\n \"features\":{\"test \\n\\t\\\" \":[\"k \\n\\t\\\" \",\"q \\n\\t\\\" \"]},\n \"links\":\" \\n\\t\\\" \"}\"#,\n )\n .unwrap();\n}\n\n#[cfg(feature = \"unstable-schema\")]\n#[test]\nfn dump_index_schema() {\n let schema = schemars::schema_for!(crate::index::IndexPackage<'_>);\n let dump = serde_json::to_string_pretty(&schema).unwrap();\n snapbox::assert_data_eq!(dump, snapbox::file!(\"../index.schema.json\").raw());\n}\n\n#[test]\nfn pubtime_format() {\n use snapbox::str;\n\n let input = [\n (\"2025-11-12T19:30:12Z\", Some(str![\"2025-11-12T19:30:12Z\"])),\n // Padded values\n (\"2025-01-02T09:03:02Z\", Some(str![\"2025-01-02T09:03:02Z\"])),\n // Alt timezone format\n (\"2025-11-12T19:30:12-04\", None),\n // Alt date/time separator\n (\"2025-11-12 19:30:12Z\", None),\n // Non-padded values\n (\"2025-11-12T19:30:12+4\", None),\n (\"2025-1-12T19:30:12+4\", None),\n (\"2025-11-2T19:30:12+4\", None),\n (\"2025-11-12T9:30:12Z\", None),\n (\"2025-11-12T19:3:12Z\", None),\n (\"2025-11-12T19:30:2Z\", None),\n ];\n for (input, expected) in input {\n let (parsed, expected) = match (parse_pubtime(input), expected) {\n (Ok(_), None) => {\n panic!(\"`{input}` did not error\");\n }\n (Ok(parsed), Some(expected)) => (parsed, expected),\n (Err(err), Some(_)) => {\n panic!(\"`{input}` did not parse successfully: {err}\");\n }\n _ => {\n continue;\n }\n };\n let output = format_pubtime(parsed);\n snapbox::assert_data_eq!(output, expected);\n }\n}\n" }, { "path": "crates/cargo-util-schemas/src/lib.rs", "content": "//! Low-level Cargo format schemas\n//!\n//! This is types with logic mostly focused on `serde` and `FromStr` for use in reading files and\n//! parsing command-lines.\n//! Any logic for getting final semantics from these will likely need other tools to process, like\n//! `cargo metadata`.\n//!\n//! > This crate is maintained by the Cargo team for use by the wider\n//! > ecosystem. This crate follows semver compatibility for its APIs.\n\npub mod core;\npub mod index;\npub mod lockfile;\npub mod manifest;\npub mod messages;\n#[cfg(feature = \"unstable-schema\")]\npub mod schema;\n\nmod restricted_names;\n" }, { "path": "crates/cargo-util-schemas/src/lockfile.rs", "content": "//! `Cargo.lock` / Lockfile schema definition\n\nuse std::collections::BTreeMap;\nuse std::fmt;\nuse std::{cmp::Ordering, str::FromStr};\n\nuse serde::{Deserialize, Serialize, de, ser};\nuse url::Url;\n\nuse crate::core::{GitReference, SourceKind};\n\n/// Serialization of `Cargo.lock`\n#[derive(Serialize, Deserialize, Debug)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlLockfile {\n /// The lockfile format version (`version =` field).\n ///\n /// This field is optional for backward compatibility. Older lockfiles, i.e. V1 and V2, does\n /// not have the version field serialized.\n pub version: Option,\n /// The list of `[[package]]` entries describing each resolved dependency.\n pub package: Option>,\n /// The `[root]` table describing the root package.\n ///\n /// This field is optional for backward compatibility. Older lockfiles have the root package\n /// separated, whereas newer lockfiles have the root package as part of `[[package]]`.\n pub root: Option,\n /// The `[metadata]` table\n ///\n ///\n /// In older lockfile versions, dependency checksums were stored here instead of alongside each\n /// package entry.\n pub metadata: Option,\n /// The `[patch]` table describing unused patches.\n ///\n /// The lockfile stores them as a list of `[[patch.unused]]` entries.\n #[serde(default, skip_serializing_if = \"TomlLockfilePatch::is_empty\")]\n pub patch: TomlLockfilePatch,\n}\n\n/// Serialization of lockfiles metadata\n///\n/// Older versions of lockfiles have their dependencies' checksums on this `[metadata]` table.\npub type TomlLockfileMetadata = BTreeMap;\n\n/// Serialization of unused patches\n///\n/// Cargo stores patches that were declared but not used during resolution.\n#[derive(Serialize, Deserialize, Debug, Default)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlLockfilePatch {\n /// The list of unused dependency patches.\n pub unused: Vec,\n}\n\nimpl TomlLockfilePatch {\n fn is_empty(&self) -> bool {\n self.unused.is_empty()\n }\n}\n\n/// Serialization of lockfiles dependencies\n#[derive(Serialize, Deserialize, Debug, PartialOrd, Ord, PartialEq, Eq)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlLockfileDependency {\n /// The name of the dependency.\n pub name: String,\n /// The version of the dependency.\n pub version: String,\n /// The source of the dependency.\n ///\n /// Cargo does not serialize path dependencies.\n pub source: Option,\n /// The checksum of the dependency.\n ///\n /// In older lockfiles, checksums were not stored here and instead on a separate `[metadata]`\n /// table (see [`TomlLockfileMetadata`]).\n pub checksum: Option,\n /// The transitive dependencies used by this dependency.\n pub dependencies: Option>,\n /// The replace of the dependency.\n pub replace: Option,\n}\n\n/// Serialization of dependency's source\n#[derive(Debug, Clone)]\n#[cfg_attr(\n feature = \"unstable-schema\",\n derive(schemars::JsonSchema),\n schemars(with = \"String\")\n)]\npub struct TomlLockfileSourceId {\n /// The string representation of the source as it appears in the lockfile.\n source_str: String,\n /// The parsed source type, e.g. `git`, `registry`.\n ///\n /// Used for sources ordering.\n kind: SourceKind,\n /// The parsed URL of the source.\n ///\n /// Used for sources ordering.\n url: Url,\n}\n\nimpl TomlLockfileSourceId {\n pub fn new(source: String) -> Result {\n let source_str = source.clone();\n let (kind, url) = source\n .split_once('+')\n .ok_or_else(|| TomlLockfileSourceIdErrorKind::InvalidSource(source.clone()))?;\n\n // Sparse URLs store the kind prefix (sparse+) in the URL. Therefore, for sparse kinds, we\n // want to use the raw `source` instead of the split `url`.\n let url = Url::parse(if kind == \"sparse\" { &source } else { url }).map_err(|msg| {\n TomlLockfileSourceIdErrorKind::InvalidUrl {\n url: url.to_string(),\n msg: msg.to_string(),\n }\n })?;\n\n let kind = match kind {\n \"git\" => {\n let reference = GitReference::from_query(url.query_pairs());\n SourceKind::Git(reference)\n }\n \"registry\" => SourceKind::Registry,\n \"sparse\" => SourceKind::SparseRegistry,\n \"path\" => SourceKind::Path,\n kind => {\n return Err(\n TomlLockfileSourceIdErrorKind::UnsupportedSource(kind.to_string()).into(),\n );\n }\n };\n\n Ok(Self {\n source_str,\n kind,\n url,\n })\n }\n\n pub fn kind(&self) -> &SourceKind {\n &self.kind\n }\n\n pub fn url(&self) -> &Url {\n &self.url\n }\n\n pub fn source_str(&self) -> &String {\n &self.source_str\n }\n\n pub fn as_url(&self) -> impl fmt::Display + '_ {\n self.source_str.clone()\n }\n}\n\nimpl ser::Serialize for TomlLockfileSourceId {\n fn serialize(&self, s: S) -> Result\n where\n S: ser::Serializer,\n {\n s.collect_str(&self.as_url())\n }\n}\n\nimpl<'de> de::Deserialize<'de> for TomlLockfileSourceId {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n let s = String::deserialize(d)?;\n Ok(TomlLockfileSourceId::new(s).map_err(de::Error::custom)?)\n }\n}\n\nimpl std::hash::Hash for TomlLockfileSourceId {\n fn hash(&self, state: &mut H) {\n self.kind.hash(state);\n self.url.hash(state);\n }\n}\n\nimpl std::cmp::PartialEq for TomlLockfileSourceId {\n fn eq(&self, other: &Self) -> bool {\n self.kind == other.kind && self.url == other.url\n }\n}\n\nimpl std::cmp::Eq for TomlLockfileSourceId {}\n\nimpl PartialOrd for TomlLockfileSourceId {\n fn partial_cmp(&self, other: &TomlLockfileSourceId) -> Option {\n Some(self.cmp(other))\n }\n}\n\nimpl Ord for TomlLockfileSourceId {\n fn cmp(&self, other: &TomlLockfileSourceId) -> Ordering {\n self.kind\n .cmp(&other.kind)\n .then_with(|| self.url.cmp(&other.url))\n }\n}\n\n/// Serialization of package IDs.\n///\n/// The version and source are only included when necessary to disambiguate between packages:\n/// - If multiple packages share the same name, the version is included.\n/// - If multiple packages share the same name and version, the source is included.\n#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Hash, Clone)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlLockfilePackageId {\n pub name: String,\n pub version: Option,\n pub source: Option,\n}\n\nimpl fmt::Display for TomlLockfilePackageId {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"{}\", self.name)?;\n if let Some(s) = &self.version {\n write!(f, \" {}\", s)?;\n }\n if let Some(s) = &self.source {\n write!(f, \" ({})\", s.as_url())?;\n }\n Ok(())\n }\n}\n\nimpl FromStr for TomlLockfilePackageId {\n type Err = TomlLockfilePackageIdError;\n\n fn from_str(s: &str) -> Result {\n let mut s = s.splitn(3, ' ');\n let name = s.next().unwrap();\n let version = s.next();\n let source_id = match s.next() {\n Some(s) => {\n if let Some(s) = s.strip_prefix('(').and_then(|s| s.strip_suffix(')')) {\n Some(TomlLockfileSourceId::new(s.to_string())?)\n } else {\n return Err(TomlLockfilePackageIdErrorKind::InvalidSerializedPackageId.into());\n }\n }\n None => None,\n };\n\n Ok(TomlLockfilePackageId {\n name: name.to_string(),\n version: version.map(|v| v.to_string()),\n source: source_id,\n })\n }\n}\n\nimpl ser::Serialize for TomlLockfilePackageId {\n fn serialize(&self, s: S) -> Result\n where\n S: ser::Serializer,\n {\n s.collect_str(self)\n }\n}\n\nimpl<'de> de::Deserialize<'de> for TomlLockfilePackageId {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n String::deserialize(d).and_then(|string| {\n string\n .parse::()\n .map_err(de::Error::custom)\n })\n }\n}\n\n#[derive(Debug, thiserror::Error)]\n#[error(transparent)]\npub struct TomlLockfileSourceIdError(#[from] TomlLockfileSourceIdErrorKind);\n\n#[non_exhaustive]\n#[derive(Debug, thiserror::Error)]\nenum TomlLockfileSourceIdErrorKind {\n #[error(\"invalid source `{0}`\")]\n InvalidSource(String),\n\n #[error(\"invalid url `{url}`: {msg}\")]\n InvalidUrl { url: String, msg: String },\n\n #[error(\"unsupported source protocol: {0}\")]\n UnsupportedSource(String),\n}\n\n#[derive(Debug, thiserror::Error)]\n#[error(transparent)]\npub struct TomlLockfilePackageIdError(#[from] TomlLockfilePackageIdErrorKind);\n\nimpl From for TomlLockfilePackageIdError {\n fn from(value: TomlLockfileSourceIdError) -> Self {\n TomlLockfilePackageIdErrorKind::Source(value).into()\n }\n}\n\n#[non_exhaustive]\n#[derive(Debug, thiserror::Error)]\nenum TomlLockfilePackageIdErrorKind {\n #[error(\"invalid serialied PackageId\")]\n InvalidSerializedPackageId,\n\n #[error(transparent)]\n Source(#[from] TomlLockfileSourceIdError),\n}\n\n#[cfg(feature = \"unstable-schema\")]\n#[test]\nfn dump_lockfile_schema() {\n let schema = schemars::schema_for!(crate::lockfile::TomlLockfile);\n let dump = serde_json::to_string_pretty(&schema).unwrap();\n snapbox::assert_data_eq!(dump, snapbox::file!(\"../lockfile.schema.json\").raw());\n}\n\n#[cfg(test)]\nmod tests {\n use crate::core::{GitReference, SourceKind};\n use crate::lockfile::{TomlLockfileSourceId, TomlLockfileSourceIdErrorKind};\n\n #[track_caller]\n fn ok(source_str: &str, source_kind: SourceKind, url: &str) {\n let source_str = source_str.to_owned();\n let source_id = TomlLockfileSourceId::new(source_str).unwrap();\n assert_eq!(source_id.kind, source_kind);\n assert_eq!(source_id.url().to_string(), url);\n }\n\n macro_rules! err {\n ($src:expr, $expected:pat) => {\n let kind = TomlLockfileSourceId::new($src.to_owned()).unwrap_err().0;\n assert!(\n matches!(kind, $expected),\n \"`{}` parse error mismatch, got {kind:?}\",\n $src,\n );\n };\n }\n\n #[test]\n fn good_sources() {\n ok(\n \"sparse+https://my-crates.io\",\n SourceKind::SparseRegistry,\n \"sparse+https://my-crates.io\",\n );\n ok(\n \"registry+https://github.com/rust-lang/crates.io-index\",\n SourceKind::Registry,\n \"https://github.com/rust-lang/crates.io-index\",\n );\n ok(\n \"git+https://github.com/rust-lang/cargo\",\n SourceKind::Git(GitReference::DefaultBranch),\n \"https://github.com/rust-lang/cargo\",\n );\n ok(\n \"git+https://github.com/rust-lang/cargo?branch=dev\",\n SourceKind::Git(GitReference::Branch(\"dev\".to_owned())),\n \"https://github.com/rust-lang/cargo?branch=dev\",\n );\n ok(\n \"git+https://github.com/rust-lang/cargo?tag=v1.0\",\n SourceKind::Git(GitReference::Tag(\"v1.0\".to_owned())),\n \"https://github.com/rust-lang/cargo?tag=v1.0\",\n );\n ok(\n \"git+https://github.com/rust-lang/cargo?rev=refs/pull/493/head\",\n SourceKind::Git(GitReference::Rev(\"refs/pull/493/head\".to_owned())),\n \"https://github.com/rust-lang/cargo?rev=refs/pull/493/head\",\n );\n ok(\n \"path+file:///path/to/root\",\n SourceKind::Path,\n \"file:///path/to/root\",\n );\n }\n\n #[test]\n fn bad_sources() {\n err!(\n \"unknown+https://my-crates.io\",\n TomlLockfileSourceIdErrorKind::UnsupportedSource(..)\n );\n err!(\n \"registry+https//github.com/rust-lang/crates.io-index\",\n TomlLockfileSourceIdErrorKind::InvalidUrl { .. }\n );\n err!(\n \"https//github.com/rust-lang/crates.io-index\",\n TomlLockfileSourceIdErrorKind::InvalidSource(..)\n );\n }\n}\n" }, { "path": "crates/cargo-util-schemas/src/manifest/mod.rs", "content": "//! `Cargo.toml` / Manifest schema definition\n//!\n//! ## Style\n//!\n//! - Fields duplicated for an alias will have an accessor with the primary field's name\n//! - Keys that exist for bookkeeping but don't correspond to the schema have a `_` prefix\n\nuse std::collections::BTreeMap;\nuse std::collections::BTreeSet;\n#[cfg(feature = \"unstable-schema\")]\nuse std::collections::HashMap;\nuse std::fmt::{self, Display, Write};\nuse std::path::PathBuf;\nuse std::str;\n\nuse serde::de::{self, IntoDeserializer as _, Unexpected};\nuse serde::ser;\nuse serde::{Deserialize, Serialize};\nuse serde_untagged::UntaggedEnumVisitor;\n\nuse crate::core::PackageIdSpec;\nuse crate::restricted_names;\n\nmod rust_version;\n\npub use crate::restricted_names::NameValidationError;\npub use rust_version::RustVersion;\npub use rust_version::RustVersionError;\n\n#[cfg(feature = \"unstable-schema\")]\nuse crate::schema::TomlValueWrapper;\n\n/// This type is used to deserialize `Cargo.toml` files.\n#[derive(Default, Clone, Debug, Deserialize, Serialize)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlManifest {\n pub cargo_features: Option>,\n\n // Update `requires_package` when adding new package-specific fields\n pub package: Option>,\n pub project: Option>,\n pub badges: Option>>,\n pub features: Option>>,\n pub lib: Option,\n pub bin: Option>,\n pub example: Option>,\n pub test: Option>,\n pub bench: Option>,\n pub dependencies: Option>,\n pub dev_dependencies: Option>,\n #[serde(rename = \"dev_dependencies\")]\n pub dev_dependencies2: Option>,\n pub build_dependencies: Option>,\n #[serde(rename = \"build_dependencies\")]\n pub build_dependencies2: Option>,\n pub target: Option>,\n pub lints: Option,\n pub hints: Option,\n\n pub workspace: Option,\n pub profile: Option,\n pub patch: Option>>,\n pub replace: Option>,\n\n /// Report unused keys (see also nested `_unused_keys`)\n /// Note: this is populated by the caller, rather than automatically\n #[serde(skip)]\n pub _unused_keys: BTreeSet,\n}\n\nimpl TomlManifest {\n pub fn requires_package(&self) -> impl Iterator {\n [\n self.badges.as_ref().map(|_| \"badges\"),\n self.features.as_ref().map(|_| \"features\"),\n self.lib.as_ref().map(|_| \"lib\"),\n self.bin.as_ref().map(|_| \"bin\"),\n self.example.as_ref().map(|_| \"example\"),\n self.test.as_ref().map(|_| \"test\"),\n self.bench.as_ref().map(|_| \"bench\"),\n self.dependencies.as_ref().map(|_| \"dependencies\"),\n self.dev_dependencies().as_ref().map(|_| \"dev-dependencies\"),\n self.build_dependencies()\n .as_ref()\n .map(|_| \"build-dependencies\"),\n self.target.as_ref().map(|_| \"target\"),\n self.lints.as_ref().map(|_| \"lints\"),\n self.hints.as_ref().map(|_| \"hints\"),\n ]\n .into_iter()\n .flatten()\n }\n\n pub fn has_profiles(&self) -> bool {\n self.profile.is_some()\n }\n\n pub fn package(&self) -> Option<&Box> {\n self.package.as_ref().or(self.project.as_ref())\n }\n\n pub fn dev_dependencies(&self) -> Option<&BTreeMap> {\n self.dev_dependencies\n .as_ref()\n .or(self.dev_dependencies2.as_ref())\n }\n\n pub fn build_dependencies(&self) -> Option<&BTreeMap> {\n self.build_dependencies\n .as_ref()\n .or(self.build_dependencies2.as_ref())\n }\n\n pub fn features(&self) -> Option<&BTreeMap>> {\n self.features.as_ref()\n }\n\n pub fn normalized_lints(&self) -> Result, UnresolvedError> {\n self.lints.as_ref().map(|l| l.normalized()).transpose()\n }\n}\n\n#[derive(Debug, Default, Deserialize, Serialize, Clone)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlWorkspace {\n pub members: Option>,\n pub exclude: Option>,\n pub default_members: Option>,\n pub resolver: Option,\n\n #[cfg_attr(\n feature = \"unstable-schema\",\n schemars(with = \"Option\")\n )]\n pub metadata: Option,\n\n // Properties that can be inherited by members.\n pub package: Option,\n pub dependencies: Option>,\n pub lints: Option,\n}\n\n/// A group of fields that are inheritable by members of the workspace\n#[derive(Clone, Debug, Default, Deserialize, Serialize)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct InheritablePackage {\n pub version: Option,\n pub authors: Option>,\n pub description: Option,\n pub homepage: Option,\n pub documentation: Option,\n pub readme: Option,\n pub keywords: Option>,\n pub categories: Option>,\n pub license: Option,\n pub license_file: Option,\n pub repository: Option,\n pub publish: Option,\n pub edition: Option,\n pub badges: Option>>,\n pub exclude: Option>,\n pub include: Option>,\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n pub rust_version: Option,\n}\n\n/// Represents the `package`/`project` sections of a `Cargo.toml`.\n///\n/// Note that the order of the fields matters, since this is the order they\n/// are serialized to a TOML file. For example, you cannot have values after\n/// the field `metadata`, since it is a table and values cannot appear after\n/// tables.\n#[derive(Deserialize, Serialize, Clone, Debug, Default)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlPackage {\n pub edition: Option,\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n pub rust_version: Option,\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n pub name: Option,\n pub version: Option,\n pub authors: Option,\n pub build: Option,\n pub metabuild: Option,\n pub default_target: Option,\n pub forced_target: Option,\n pub links: Option,\n pub exclude: Option,\n pub include: Option,\n pub publish: Option,\n pub workspace: Option,\n pub im_a_teapot: Option,\n pub autolib: Option,\n pub autobins: Option,\n pub autoexamples: Option,\n pub autotests: Option,\n pub autobenches: Option,\n pub default_run: Option,\n\n // Package metadata.\n pub description: Option,\n pub homepage: Option,\n pub documentation: Option,\n pub readme: Option,\n pub keywords: Option,\n pub categories: Option,\n pub license: Option,\n pub license_file: Option,\n pub repository: Option,\n pub resolver: Option,\n\n #[cfg_attr(\n feature = \"unstable-schema\",\n schemars(with = \"Option\")\n )]\n pub metadata: Option,\n\n /// Provide a helpful error message for a common user error.\n #[serde(rename = \"cargo-features\", skip_serializing)]\n #[cfg_attr(feature = \"unstable-schema\", schemars(skip))]\n pub _invalid_cargo_features: Option,\n}\n\nimpl TomlPackage {\n pub fn new(name: PackageName) -> Self {\n Self {\n name: Some(name),\n ..Default::default()\n }\n }\n\n pub fn normalized_name(&self) -> Result<&PackageName, UnresolvedError> {\n self.name.as_ref().ok_or(UnresolvedError)\n }\n\n pub fn normalized_edition(&self) -> Result, UnresolvedError> {\n self.edition.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_rust_version(&self) -> Result, UnresolvedError> {\n self.rust_version\n .as_ref()\n .map(|v| v.normalized())\n .transpose()\n }\n\n pub fn normalized_version(&self) -> Result, UnresolvedError> {\n self.version.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_authors(&self) -> Result>, UnresolvedError> {\n self.authors.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_build(&self) -> Result, UnresolvedError> {\n let build = self.build.as_ref().ok_or(UnresolvedError)?;\n match build {\n TomlPackageBuild::Auto(false) => Ok(None),\n TomlPackageBuild::Auto(true) => Err(UnresolvedError),\n TomlPackageBuild::SingleScript(value) => Ok(Some(std::slice::from_ref(value))),\n TomlPackageBuild::MultipleScript(scripts) => Ok(Some(scripts)),\n }\n }\n\n pub fn normalized_exclude(&self) -> Result>, UnresolvedError> {\n self.exclude.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_include(&self) -> Result>, UnresolvedError> {\n self.include.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_publish(&self) -> Result, UnresolvedError> {\n self.publish.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_description(&self) -> Result, UnresolvedError> {\n self.description\n .as_ref()\n .map(|v| v.normalized())\n .transpose()\n }\n\n pub fn normalized_homepage(&self) -> Result, UnresolvedError> {\n self.homepage.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_documentation(&self) -> Result, UnresolvedError> {\n self.documentation\n .as_ref()\n .map(|v| v.normalized())\n .transpose()\n }\n\n pub fn normalized_readme(&self) -> Result, UnresolvedError> {\n let readme = self.readme.as_ref().ok_or(UnresolvedError)?;\n readme.normalized().and_then(|sb| match sb {\n StringOrBool::Bool(false) => Ok(None),\n StringOrBool::Bool(true) => Err(UnresolvedError),\n StringOrBool::String(value) => Ok(Some(value)),\n })\n }\n\n pub fn normalized_keywords(&self) -> Result>, UnresolvedError> {\n self.keywords.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_categories(&self) -> Result>, UnresolvedError> {\n self.categories.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_license(&self) -> Result, UnresolvedError> {\n self.license.as_ref().map(|v| v.normalized()).transpose()\n }\n\n pub fn normalized_license_file(&self) -> Result, UnresolvedError> {\n self.license_file\n .as_ref()\n .map(|v| v.normalized())\n .transpose()\n }\n\n pub fn normalized_repository(&self) -> Result, UnresolvedError> {\n self.repository.as_ref().map(|v| v.normalized()).transpose()\n }\n}\n\n/// An enum that allows for inheriting keys from a workspace in a Cargo.toml.\n#[derive(Serialize, Copy, Clone, Debug)]\n#[serde(untagged)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum InheritableField {\n /// The type that is used when not inheriting from a workspace.\n Value(T),\n /// The type when inheriting from a workspace.\n Inherit(TomlInheritedField),\n}\n\nimpl InheritableField {\n pub fn normalized(&self) -> Result<&T, UnresolvedError> {\n self.as_value().ok_or(UnresolvedError)\n }\n\n pub fn as_value(&self) -> Option<&T> {\n match self {\n InheritableField::Inherit(_) => None,\n InheritableField::Value(defined) => Some(defined),\n }\n }\n\n pub fn into_value(self) -> Option {\n match self {\n Self::Inherit(_) => None,\n Self::Value(defined) => Some(defined),\n }\n }\n\n pub fn is_inherited(&self) -> bool {\n matches!(self, Self::Inherit(_))\n }\n}\n\n//. This already has a `Deserialize` impl from version_trim_whitespace\npub type InheritableSemverVersion = InheritableField;\nimpl<'de> de::Deserialize<'de> for InheritableSemverVersion {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n UntaggedEnumVisitor::new()\n .expecting(\"SemVer version\")\n .string(\n |value| match value.trim().parse().map_err(de::Error::custom) {\n Ok(parsed) => Ok(InheritableField::Value(parsed)),\n Err(e) => Err(e),\n },\n )\n .map(|value| value.deserialize().map(InheritableField::Inherit))\n .deserialize(d)\n }\n}\n\npub type InheritableString = InheritableField;\nimpl<'de> de::Deserialize<'de> for InheritableString {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n struct Visitor;\n\n impl<'de> de::Visitor<'de> for Visitor {\n type Value = InheritableString;\n\n fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {\n f.write_str(\"a string or workspace\")\n }\n\n fn visit_string(self, value: String) -> Result\n where\n E: de::Error,\n {\n Ok(InheritableString::Value(value))\n }\n\n fn visit_str(self, value: &str) -> Result\n where\n E: de::Error,\n {\n self.visit_string(value.to_owned())\n }\n\n fn visit_map(self, map: V) -> Result\n where\n V: de::MapAccess<'de>,\n {\n let mvd = de::value::MapAccessDeserializer::new(map);\n TomlInheritedField::deserialize(mvd).map(InheritableField::Inherit)\n }\n }\n\n d.deserialize_any(Visitor)\n }\n}\n\npub type InheritableRustVersion = InheritableField;\nimpl<'de> de::Deserialize<'de> for InheritableRustVersion {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n struct Visitor;\n\n impl<'de> de::Visitor<'de> for Visitor {\n type Value = InheritableRustVersion;\n\n fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {\n f.write_str(\"a semver or workspace\")\n }\n\n fn visit_string(self, value: String) -> Result\n where\n E: de::Error,\n {\n let value = value.parse::().map_err(|e| E::custom(e))?;\n Ok(InheritableRustVersion::Value(value))\n }\n\n fn visit_str(self, value: &str) -> Result\n where\n E: de::Error,\n {\n self.visit_string(value.to_owned())\n }\n\n fn visit_map(self, map: V) -> Result\n where\n V: de::MapAccess<'de>,\n {\n let mvd = de::value::MapAccessDeserializer::new(map);\n TomlInheritedField::deserialize(mvd).map(InheritableField::Inherit)\n }\n }\n\n d.deserialize_any(Visitor)\n }\n}\n\npub type InheritableVecString = InheritableField>;\nimpl<'de> de::Deserialize<'de> for InheritableVecString {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n struct Visitor;\n\n impl<'de> de::Visitor<'de> for Visitor {\n type Value = InheritableVecString;\n\n fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {\n f.write_str(\"a vector of strings or workspace\")\n }\n fn visit_seq(self, v: A) -> Result\n where\n A: de::SeqAccess<'de>,\n {\n let seq = de::value::SeqAccessDeserializer::new(v);\n Vec::deserialize(seq).map(InheritableField::Value)\n }\n\n fn visit_map(self, map: V) -> Result\n where\n V: de::MapAccess<'de>,\n {\n let mvd = de::value::MapAccessDeserializer::new(map);\n TomlInheritedField::deserialize(mvd).map(InheritableField::Inherit)\n }\n }\n\n d.deserialize_any(Visitor)\n }\n}\n\npub type InheritableStringOrBool = InheritableField;\nimpl<'de> de::Deserialize<'de> for InheritableStringOrBool {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n struct Visitor;\n\n impl<'de> de::Visitor<'de> for Visitor {\n type Value = InheritableStringOrBool;\n\n fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {\n f.write_str(\"a string, a bool, or workspace\")\n }\n\n fn visit_bool(self, v: bool) -> Result\n where\n E: de::Error,\n {\n let b = de::value::BoolDeserializer::new(v);\n StringOrBool::deserialize(b).map(InheritableField::Value)\n }\n\n fn visit_string(self, v: String) -> Result\n where\n E: de::Error,\n {\n let string = de::value::StringDeserializer::new(v);\n StringOrBool::deserialize(string).map(InheritableField::Value)\n }\n\n fn visit_str(self, value: &str) -> Result\n where\n E: de::Error,\n {\n self.visit_string(value.to_owned())\n }\n\n fn visit_map(self, map: V) -> Result\n where\n V: de::MapAccess<'de>,\n {\n let mvd = de::value::MapAccessDeserializer::new(map);\n TomlInheritedField::deserialize(mvd).map(InheritableField::Inherit)\n }\n }\n\n d.deserialize_any(Visitor)\n }\n}\n\npub type InheritableVecStringOrBool = InheritableField;\nimpl<'de> de::Deserialize<'de> for InheritableVecStringOrBool {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n struct Visitor;\n\n impl<'de> de::Visitor<'de> for Visitor {\n type Value = InheritableVecStringOrBool;\n\n fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {\n f.write_str(\"a boolean, a vector of strings, or workspace\")\n }\n\n fn visit_bool(self, v: bool) -> Result\n where\n E: de::Error,\n {\n let b = de::value::BoolDeserializer::new(v);\n VecStringOrBool::deserialize(b).map(InheritableField::Value)\n }\n\n fn visit_seq(self, v: A) -> Result\n where\n A: de::SeqAccess<'de>,\n {\n let seq = de::value::SeqAccessDeserializer::new(v);\n VecStringOrBool::deserialize(seq).map(InheritableField::Value)\n }\n\n fn visit_map(self, map: V) -> Result\n where\n V: de::MapAccess<'de>,\n {\n let mvd = de::value::MapAccessDeserializer::new(map);\n TomlInheritedField::deserialize(mvd).map(InheritableField::Inherit)\n }\n }\n\n d.deserialize_any(Visitor)\n }\n}\n\npub type InheritableBtreeMap = InheritableField>>;\n\nimpl<'de> de::Deserialize<'de> for InheritableBtreeMap {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n let value = serde_value::Value::deserialize(deserializer)?;\n\n if let Ok(w) = TomlInheritedField::deserialize(\n serde_value::ValueDeserializer::::new(value.clone()),\n ) {\n return Ok(InheritableField::Inherit(w));\n }\n BTreeMap::deserialize(serde_value::ValueDeserializer::::new(value))\n .map(InheritableField::Value)\n }\n}\n\n#[derive(Deserialize, Serialize, Copy, Clone, Debug)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlInheritedField {\n workspace: WorkspaceValue,\n}\n\nimpl TomlInheritedField {\n pub fn new() -> Self {\n TomlInheritedField {\n workspace: WorkspaceValue,\n }\n }\n}\n\nimpl Default for TomlInheritedField {\n fn default() -> Self {\n Self::new()\n }\n}\n\n#[derive(Deserialize, Serialize, Copy, Clone, Debug)]\n#[serde(try_from = \"bool\")]\n#[serde(into = \"bool\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\nstruct WorkspaceValue;\n\nimpl TryFrom for WorkspaceValue {\n type Error = String;\n fn try_from(other: bool) -> Result {\n if other {\n Ok(WorkspaceValue)\n } else {\n Err(\"`workspace` cannot be false\".to_owned())\n }\n }\n}\n\nimpl From for bool {\n fn from(_: WorkspaceValue) -> bool {\n true\n }\n}\n\n#[derive(Serialize, Clone, Debug)]\n#[serde(untagged)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum InheritableDependency {\n /// The type that is used when not inheriting from a workspace.\n Value(TomlDependency),\n /// The type when inheriting from a workspace.\n Inherit(TomlInheritedDependency),\n}\n\nimpl InheritableDependency {\n pub fn unused_keys(&self) -> Vec {\n match self {\n InheritableDependency::Value(d) => d.unused_keys(),\n InheritableDependency::Inherit(w) => w._unused_keys.keys().cloned().collect(),\n }\n }\n\n pub fn normalized(&self) -> Result<&TomlDependency, UnresolvedError> {\n match self {\n InheritableDependency::Value(d) => Ok(d),\n InheritableDependency::Inherit(_) => Err(UnresolvedError),\n }\n }\n\n pub fn is_inherited(&self) -> bool {\n matches!(self, InheritableDependency::Inherit(_))\n }\n}\n\nimpl<'de> de::Deserialize<'de> for InheritableDependency {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n let value = serde_value::Value::deserialize(deserializer)?;\n\n if let Ok(w) = TomlInheritedDependency::deserialize(serde_value::ValueDeserializer::<\n D::Error,\n >::new(value.clone()))\n {\n return if w.workspace {\n Ok(InheritableDependency::Inherit(w))\n } else {\n Err(de::Error::custom(\"`workspace` cannot be false\"))\n };\n }\n TomlDependency::deserialize(serde_value::ValueDeserializer::::new(value))\n .map(InheritableDependency::Value)\n }\n}\n\n#[derive(Deserialize, Serialize, Clone, Debug)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlInheritedDependency {\n pub workspace: bool,\n pub features: Option>,\n pub default_features: Option,\n #[serde(rename = \"default_features\")]\n pub default_features2: Option,\n pub optional: Option,\n pub public: Option,\n\n /// This is here to provide a way to see the \"unused manifest keys\" when deserializing\n #[serde(skip_serializing)]\n #[serde(flatten)]\n #[cfg_attr(feature = \"unstable-schema\", schemars(skip))]\n pub _unused_keys: BTreeMap,\n}\n\nimpl TomlInheritedDependency {\n pub fn default_features(&self) -> Option {\n self.default_features.or(self.default_features2)\n }\n}\n\n#[derive(Clone, Debug, Serialize)]\n#[serde(untagged)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum TomlDependency {\n /// In the simple format, only a version is specified, eg.\n /// `package = \"\"`\n Simple(String),\n /// The simple format is equivalent to a detailed dependency\n /// specifying only a version, eg.\n /// `package = { version = \"\" }`\n Detailed(TomlDetailedDependency

),\n}\n\nimpl TomlDependency {\n pub fn is_version_specified(&self) -> bool {\n match self {\n TomlDependency::Detailed(d) => d.version.is_some(),\n TomlDependency::Simple(..) => true,\n }\n }\n\n pub fn is_optional(&self) -> bool {\n match self {\n TomlDependency::Detailed(d) => d.optional.unwrap_or(false),\n TomlDependency::Simple(..) => false,\n }\n }\n\n pub fn is_public(&self) -> bool {\n match self {\n TomlDependency::Detailed(d) => d.public.unwrap_or(false),\n TomlDependency::Simple(..) => false,\n }\n }\n\n pub fn default_features(&self) -> Option {\n match self {\n TomlDependency::Detailed(d) => d.default_features(),\n TomlDependency::Simple(..) => None,\n }\n }\n\n pub fn unused_keys(&self) -> Vec {\n match self {\n TomlDependency::Simple(_) => vec![],\n TomlDependency::Detailed(detailed) => detailed._unused_keys.keys().cloned().collect(),\n }\n }\n}\n\nimpl<'de, P: Deserialize<'de> + Clone> de::Deserialize<'de> for TomlDependency

{\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n use serde::de::Error as _;\n let expected = \"a version string like \\\"0.9.8\\\" or a \\\n detailed dependency like { version = \\\"0.9.8\\\" }\";\n UntaggedEnumVisitor::new()\n .expecting(expected)\n .string(|value| Ok(TomlDependency::Simple(value.to_owned())))\n .bool(|value| {\n let expected = format!(\"invalid type: boolean `{value}`, expected {expected}\");\n let err = if value {\n format!(\n \"{expected}\\n\\\n note: if you meant to use a workspace member, you can write\\n \\\n dep.workspace = {value}\"\n )\n } else {\n expected\n };\n\n Err(serde_untagged::de::Error::custom(err))\n })\n .map(|value| value.deserialize().map(TomlDependency::Detailed))\n .deserialize(deserializer)\n }\n}\n\n#[derive(Deserialize, Serialize, Clone, Debug)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlDetailedDependency {\n pub version: Option,\n\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n pub registry: Option,\n /// The URL of the `registry` field.\n /// This is an internal implementation detail. When Cargo creates a\n /// package, it replaces `registry` with `registry-index` so that the\n /// manifest contains the correct URL. All users won't have the same\n /// registry names configured, so Cargo can't rely on just the name for\n /// crates published by other users.\n pub registry_index: Option,\n // `path` is relative to the file it appears in. If that's a `Cargo.toml`, it'll be relative to\n // that TOML file, and if it's a `.cargo/config` file, it'll be relative to that file.\n pub path: Option

,\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n pub base: Option,\n pub git: Option,\n pub branch: Option,\n pub tag: Option,\n pub rev: Option,\n pub features: Option>,\n pub optional: Option,\n pub default_features: Option,\n #[serde(rename = \"default_features\")]\n pub default_features2: Option,\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n pub package: Option,\n pub public: Option,\n\n /// One or more of `bin`, `cdylib`, `staticlib`, `bin:`.\n pub artifact: Option,\n /// If set, the artifact should also be a dependency\n pub lib: Option,\n /// A platform name, like `x86_64-apple-darwin`\n pub target: Option,\n\n /// This is here to provide a way to see the \"unused manifest keys\" when deserializing\n #[serde(skip_serializing)]\n #[serde(flatten)]\n #[cfg_attr(feature = \"unstable-schema\", schemars(skip))]\n pub _unused_keys: BTreeMap,\n}\n\nimpl TomlDetailedDependency

{\n pub fn default_features(&self) -> Option {\n self.default_features.or(self.default_features2)\n }\n}\n\n// Explicit implementation so we avoid pulling in P: Default\nimpl Default for TomlDetailedDependency

{\n fn default() -> Self {\n Self {\n version: Default::default(),\n registry: Default::default(),\n registry_index: Default::default(),\n path: Default::default(),\n base: Default::default(),\n git: Default::default(),\n branch: Default::default(),\n tag: Default::default(),\n rev: Default::default(),\n features: Default::default(),\n optional: Default::default(),\n default_features: Default::default(),\n default_features2: Default::default(),\n package: Default::default(),\n public: Default::default(),\n artifact: Default::default(),\n lib: Default::default(),\n target: Default::default(),\n _unused_keys: Default::default(),\n }\n }\n}\n\n#[derive(Deserialize, Serialize, Clone, Debug, Default)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlProfiles(pub BTreeMap);\n\nimpl TomlProfiles {\n pub fn get_all(&self) -> &BTreeMap {\n &self.0\n }\n\n pub fn get(&self, name: &str) -> Option<&TomlProfile> {\n self.0.get(name)\n }\n}\n\n#[derive(Deserialize, Serialize, Clone, Debug, Default, Eq, PartialEq)]\n#[serde(default, rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlProfile {\n pub opt_level: Option,\n pub lto: Option,\n pub codegen_backend: Option,\n pub codegen_units: Option,\n pub debug: Option,\n pub split_debuginfo: Option,\n pub debug_assertions: Option,\n pub rpath: Option,\n pub panic: Option,\n pub overflow_checks: Option,\n pub incremental: Option,\n pub dir_name: Option,\n pub inherits: Option,\n pub strip: Option,\n // Note that `rustflags` is used for the cargo-feature `profile_rustflags`\n pub rustflags: Option>,\n // These two fields must be last because they are sub-tables, and TOML\n // requires all non-tables to be listed first.\n pub package: Option>,\n pub build_override: Option>,\n /// Unstable feature `-Ztrim-paths`.\n pub trim_paths: Option,\n /// Unstable feature `hint-mostly-unused`\n pub hint_mostly_unused: Option,\n}\n\nimpl TomlProfile {\n /// Overwrite self's values with the given profile.\n pub fn merge(&mut self, profile: &Self) {\n if let Some(v) = &profile.opt_level {\n self.opt_level = Some(v.clone());\n }\n\n if let Some(v) = &profile.lto {\n self.lto = Some(v.clone());\n }\n\n if let Some(v) = &profile.codegen_backend {\n self.codegen_backend = Some(v.clone());\n }\n\n if let Some(v) = profile.codegen_units {\n self.codegen_units = Some(v);\n }\n\n if let Some(v) = profile.debug {\n self.debug = Some(v);\n }\n\n if let Some(v) = profile.debug_assertions {\n self.debug_assertions = Some(v);\n }\n\n if let Some(v) = &profile.split_debuginfo {\n self.split_debuginfo = Some(v.clone());\n }\n\n if let Some(v) = profile.rpath {\n self.rpath = Some(v);\n }\n\n if let Some(v) = &profile.panic {\n self.panic = Some(v.clone());\n }\n\n if let Some(v) = profile.overflow_checks {\n self.overflow_checks = Some(v);\n }\n\n if let Some(v) = profile.incremental {\n self.incremental = Some(v);\n }\n\n if let Some(v) = &profile.rustflags {\n self.rustflags = Some(v.clone());\n }\n\n if let Some(other_package) = &profile.package {\n match &mut self.package {\n Some(self_package) => {\n for (spec, other_pkg_profile) in other_package {\n match self_package.get_mut(spec) {\n Some(p) => p.merge(other_pkg_profile),\n None => {\n self_package.insert(spec.clone(), other_pkg_profile.clone());\n }\n }\n }\n }\n None => self.package = Some(other_package.clone()),\n }\n }\n\n if let Some(other_bo) = &profile.build_override {\n match &mut self.build_override {\n Some(self_bo) => self_bo.merge(other_bo),\n None => self.build_override = Some(other_bo.clone()),\n }\n }\n\n if let Some(v) = &profile.inherits {\n self.inherits = Some(v.clone());\n }\n\n if let Some(v) = &profile.dir_name {\n self.dir_name = Some(v.clone());\n }\n\n if let Some(v) = &profile.strip {\n self.strip = Some(v.clone());\n }\n\n if let Some(v) = &profile.trim_paths {\n self.trim_paths = Some(v.clone())\n }\n\n if let Some(v) = profile.hint_mostly_unused {\n self.hint_mostly_unused = Some(v);\n }\n }\n}\n\n#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum ProfilePackageSpec {\n Spec(PackageIdSpec),\n All,\n}\n\nimpl fmt::Display for ProfilePackageSpec {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n ProfilePackageSpec::Spec(spec) => spec.fmt(f),\n ProfilePackageSpec::All => f.write_str(\"*\"),\n }\n }\n}\n\nimpl ser::Serialize for ProfilePackageSpec {\n fn serialize(&self, s: S) -> Result\n where\n S: ser::Serializer,\n {\n self.to_string().serialize(s)\n }\n}\n\nimpl<'de> de::Deserialize<'de> for ProfilePackageSpec {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n let string = String::deserialize(d)?;\n if string == \"*\" {\n Ok(ProfilePackageSpec::All)\n } else {\n PackageIdSpec::parse(&string)\n .map_err(de::Error::custom)\n .map(ProfilePackageSpec::Spec)\n }\n }\n}\n\n#[derive(Clone, Debug, Eq, PartialEq)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlOptLevel(pub String);\n\nimpl ser::Serialize for TomlOptLevel {\n fn serialize(&self, serializer: S) -> Result\n where\n S: ser::Serializer,\n {\n match self.0.parse::() {\n Ok(n) => n.serialize(serializer),\n Err(_) => self.0.serialize(serializer),\n }\n }\n}\n\nimpl<'de> de::Deserialize<'de> for TomlOptLevel {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n use serde::de::Error as _;\n UntaggedEnumVisitor::new()\n .expecting(\"an optimization level\")\n .i64(|value| Ok(TomlOptLevel(value.to_string())))\n .string(|value| {\n if value == \"s\" || value == \"z\" {\n Ok(TomlOptLevel(value.to_string()))\n } else {\n Err(serde_untagged::de::Error::custom(format!(\n \"must be `0`, `1`, `2`, `3`, `s` or `z`, \\\n but found the string: \\\"{}\\\"\",\n value\n )))\n }\n })\n .deserialize(d)\n }\n}\n\n#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum TomlDebugInfo {\n None,\n LineDirectivesOnly,\n LineTablesOnly,\n Limited,\n Full,\n}\n\nimpl Display for TomlDebugInfo {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n TomlDebugInfo::None => f.write_char('0'),\n TomlDebugInfo::Limited => f.write_char('1'),\n TomlDebugInfo::Full => f.write_char('2'),\n TomlDebugInfo::LineDirectivesOnly => f.write_str(\"line-directives-only\"),\n TomlDebugInfo::LineTablesOnly => f.write_str(\"line-tables-only\"),\n }\n }\n}\n\nimpl ser::Serialize for TomlDebugInfo {\n fn serialize(&self, serializer: S) -> Result\n where\n S: ser::Serializer,\n {\n match self {\n Self::None => 0.serialize(serializer),\n Self::LineDirectivesOnly => \"line-directives-only\".serialize(serializer),\n Self::LineTablesOnly => \"line-tables-only\".serialize(serializer),\n Self::Limited => 1.serialize(serializer),\n Self::Full => 2.serialize(serializer),\n }\n }\n}\n\nimpl<'de> de::Deserialize<'de> for TomlDebugInfo {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n use serde::de::Error as _;\n let expecting = \"a boolean, 0, 1, 2, \\\"none\\\", \\\"limited\\\", \\\"full\\\", \\\"line-tables-only\\\", or \\\"line-directives-only\\\"\";\n UntaggedEnumVisitor::new()\n .expecting(expecting)\n .bool(|value| {\n Ok(if value {\n TomlDebugInfo::Full\n } else {\n TomlDebugInfo::None\n })\n })\n .i64(|value| {\n let debuginfo = match value {\n 0 => TomlDebugInfo::None,\n 1 => TomlDebugInfo::Limited,\n 2 => TomlDebugInfo::Full,\n _ => {\n return Err(serde_untagged::de::Error::invalid_value(\n Unexpected::Signed(value),\n &expecting,\n ));\n }\n };\n Ok(debuginfo)\n })\n .string(|value| {\n let debuginfo = match value {\n \"none\" => TomlDebugInfo::None,\n \"limited\" => TomlDebugInfo::Limited,\n \"full\" => TomlDebugInfo::Full,\n \"line-directives-only\" => TomlDebugInfo::LineDirectivesOnly,\n \"line-tables-only\" => TomlDebugInfo::LineTablesOnly,\n _ => {\n return Err(serde_untagged::de::Error::invalid_value(\n Unexpected::Str(value),\n &expecting,\n ));\n }\n };\n Ok(debuginfo)\n })\n .deserialize(d)\n }\n}\n\n#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash, Serialize)]\n#[serde(untagged, rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum TomlTrimPaths {\n Values(Vec),\n All,\n}\n\nimpl TomlTrimPaths {\n pub fn none() -> Self {\n TomlTrimPaths::Values(Vec::new())\n }\n\n pub fn is_none(&self) -> bool {\n match self {\n TomlTrimPaths::Values(v) => v.is_empty(),\n TomlTrimPaths::All => false,\n }\n }\n}\n\nimpl<'de> de::Deserialize<'de> for TomlTrimPaths {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n use serde::de::Error as _;\n let expecting = r#\"a boolean, \"none\", \"diagnostics\", \"macro\", \"object\", \"all\", or an array with these options\"#;\n UntaggedEnumVisitor::new()\n .expecting(expecting)\n .bool(|value| {\n Ok(if value {\n TomlTrimPaths::All\n } else {\n TomlTrimPaths::none()\n })\n })\n .string(|v| match v {\n \"none\" => Ok(TomlTrimPaths::none()),\n \"all\" => Ok(TomlTrimPaths::All),\n v => {\n let d = v.into_deserializer();\n let err = |_: D::Error| {\n serde_untagged::de::Error::custom(format!(\"expected {expecting}\"))\n };\n TomlTrimPathsValue::deserialize(d)\n .map_err(err)\n .map(|v| v.into())\n }\n })\n .seq(|seq| {\n let seq: Vec = seq.deserialize()?;\n let seq: Vec<_> = seq\n .into_iter()\n .map(|s| TomlTrimPathsValue::deserialize(s.into_deserializer()))\n .collect::>()?;\n Ok(seq.into())\n })\n .deserialize(d)\n }\n}\n\nimpl fmt::Display for TomlTrimPaths {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n TomlTrimPaths::All => write!(f, \"all\"),\n TomlTrimPaths::Values(v) if v.is_empty() => write!(f, \"none\"),\n TomlTrimPaths::Values(v) => {\n let mut iter = v.iter();\n if let Some(value) = iter.next() {\n write!(f, \"{value}\")?;\n }\n for value in iter {\n write!(f, \",{value}\")?;\n }\n Ok(())\n }\n }\n }\n}\n\nimpl From for TomlTrimPaths {\n fn from(value: TomlTrimPathsValue) -> Self {\n TomlTrimPaths::Values(vec![value])\n }\n}\n\nimpl From> for TomlTrimPaths {\n fn from(value: Vec) -> Self {\n TomlTrimPaths::Values(value)\n }\n}\n\n#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash, Serialize, Deserialize)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum TomlTrimPathsValue {\n Diagnostics,\n Macro,\n Object,\n}\n\nimpl TomlTrimPathsValue {\n pub fn as_str(&self) -> &'static str {\n match self {\n TomlTrimPathsValue::Diagnostics => \"diagnostics\",\n TomlTrimPathsValue::Macro => \"macro\",\n TomlTrimPathsValue::Object => \"object\",\n }\n }\n}\n\nimpl fmt::Display for TomlTrimPathsValue {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"{}\", self.as_str())\n }\n}\n\npub type TomlLibTarget = TomlTarget;\npub type TomlBinTarget = TomlTarget;\npub type TomlExampleTarget = TomlTarget;\npub type TomlTestTarget = TomlTarget;\npub type TomlBenchTarget = TomlTarget;\n\n#[derive(Default, Serialize, Deserialize, Debug, Clone)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlTarget {\n pub name: Option,\n\n // The intention was to only accept `crate-type` here but historical\n // versions of Cargo also accepted `crate_type`, so look for both.\n pub crate_type: Option>,\n #[serde(rename = \"crate_type\")]\n pub crate_type2: Option>,\n\n #[cfg_attr(feature = \"unstable-schema\", schemars(with = \"Option\"))]\n pub path: Option,\n // Note that `filename` is used for the cargo-feature `different_binary_name`\n pub filename: Option,\n pub test: Option,\n pub doctest: Option,\n pub bench: Option,\n pub doc: Option,\n pub doc_scrape_examples: Option,\n pub proc_macro: Option,\n #[serde(rename = \"proc_macro\")]\n pub proc_macro2: Option,\n pub harness: Option,\n pub required_features: Option>,\n pub edition: Option,\n}\n\nimpl TomlTarget {\n pub fn new() -> TomlTarget {\n TomlTarget::default()\n }\n\n pub fn proc_macro(&self) -> Option {\n self.proc_macro.or(self.proc_macro2).or_else(|| {\n if let Some(types) = self.crate_types() {\n if types.contains(&\"proc-macro\".to_string()) {\n return Some(true);\n }\n }\n None\n })\n }\n\n pub fn crate_types(&self) -> Option<&Vec> {\n self.crate_type\n .as_ref()\n .or_else(|| self.crate_type2.as_ref())\n }\n}\n\nmacro_rules! str_newtype {\n ($name:ident) => {\n /// Verified string newtype\n #[derive(Serialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\n #[serde(transparent)]\n #[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\n pub struct $name = String>(T);\n\n impl> $name {\n pub fn into_inner(self) -> T {\n self.0\n }\n }\n\n impl> AsRef for $name {\n fn as_ref(&self) -> &str {\n self.0.as_ref()\n }\n }\n\n impl> std::ops::Deref for $name {\n type Target = T;\n\n fn deref(&self) -> &Self::Target {\n &self.0\n }\n }\n\n impl> std::borrow::Borrow for $name {\n fn borrow(&self) -> &str {\n self.0.as_ref()\n }\n }\n\n impl<'a> std::str::FromStr for $name {\n type Err = restricted_names::NameValidationError;\n\n fn from_str(value: &str) -> Result {\n Self::new(value.to_owned())\n }\n }\n\n impl<'de, T: AsRef + serde::Deserialize<'de>> serde::Deserialize<'de> for $name {\n fn deserialize(deserializer: D) -> Result\n where\n D: serde::Deserializer<'de>,\n {\n let inner = T::deserialize(deserializer)?;\n Self::new(inner).map_err(serde::de::Error::custom)\n }\n }\n\n impl> Display for $name {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n self.0.as_ref().fmt(f)\n }\n }\n };\n}\n\nstr_newtype!(PackageName);\n\nimpl> PackageName {\n /// Validated package name\n pub fn new(name: T) -> Result {\n restricted_names::validate_package_name(name.as_ref())?;\n Ok(Self(name))\n }\n}\n\nimpl PackageName {\n /// Coerce a value to be a validate package name\n ///\n /// Replaces invalid values with `placeholder`\n pub fn sanitize(name: impl AsRef, placeholder: char) -> Self {\n PackageName(restricted_names::sanitize_package_name(\n name.as_ref(),\n placeholder,\n ))\n }\n}\n\nstr_newtype!(RegistryName);\n\nimpl> RegistryName {\n /// Validated registry name\n pub fn new(name: T) -> Result {\n restricted_names::validate_registry_name(name.as_ref())?;\n Ok(Self(name))\n }\n}\n\nstr_newtype!(ProfileName);\n\nimpl> ProfileName {\n /// Validated profile name\n pub fn new(name: T) -> Result {\n restricted_names::validate_profile_name(name.as_ref())?;\n Ok(Self(name))\n }\n}\n\nstr_newtype!(FeatureName);\n\nimpl> FeatureName {\n /// Validated feature name\n pub fn new(name: T) -> Result {\n restricted_names::validate_feature_name(name.as_ref())?;\n Ok(Self(name))\n }\n}\n\nstr_newtype!(PathBaseName);\n\nimpl> PathBaseName {\n /// Validated path base name\n pub fn new(name: T) -> Result {\n restricted_names::validate_path_base_name(name.as_ref())?;\n Ok(Self(name))\n }\n}\n\n/// Corresponds to a `target` entry, but `TomlTarget` is already used.\n#[derive(Serialize, Deserialize, Debug, Clone)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlPlatform {\n pub dependencies: Option>,\n pub build_dependencies: Option>,\n #[serde(rename = \"build_dependencies\")]\n pub build_dependencies2: Option>,\n pub dev_dependencies: Option>,\n #[serde(rename = \"dev_dependencies\")]\n pub dev_dependencies2: Option>,\n}\n\nimpl TomlPlatform {\n pub fn dev_dependencies(&self) -> Option<&BTreeMap> {\n self.dev_dependencies\n .as_ref()\n .or(self.dev_dependencies2.as_ref())\n }\n\n pub fn build_dependencies(&self) -> Option<&BTreeMap> {\n self.build_dependencies\n .as_ref()\n .or(self.build_dependencies2.as_ref())\n }\n}\n\n#[derive(Serialize, Debug, Clone)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct InheritableLints {\n #[serde(skip_serializing_if = \"std::ops::Not::not\")]\n #[cfg_attr(feature = \"unstable-schema\", schemars(default))]\n pub workspace: bool,\n #[serde(flatten)]\n pub lints: TomlLints,\n}\n\nimpl InheritableLints {\n pub fn normalized(&self) -> Result<&TomlLints, UnresolvedError> {\n if self.workspace {\n Err(UnresolvedError)\n } else {\n Ok(&self.lints)\n }\n }\n}\n\nimpl<'de> Deserialize<'de> for InheritableLints {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n struct InheritableLintsVisitor;\n\n impl<'de> de::Visitor<'de> for InheritableLintsVisitor {\n // The type that our Visitor is going to produce.\n type Value = InheritableLints;\n\n // Format a message stating what data this Visitor expects to receive.\n fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {\n formatter.write_str(\"a lints table\")\n }\n\n // Deserialize MyMap from an abstract \"map\" provided by the\n // Deserializer. The MapAccess input is a callback provided by\n // the Deserializer to let us see each entry in the map.\n fn visit_map(self, mut access: M) -> Result\n where\n M: de::MapAccess<'de>,\n {\n let mut lints = TomlLints::new();\n let mut workspace = false;\n\n // While there are entries remaining in the input, add them\n // into our map.\n while let Some(key) = access.next_key()? {\n if key == \"workspace\" {\n workspace = match access.next_value()? {\n Some(WorkspaceValue) => true,\n None => false,\n };\n } else {\n let value = access.next_value()?;\n lints.insert(key, value);\n }\n }\n\n Ok(InheritableLints { workspace, lints })\n }\n }\n\n deserializer.deserialize_map(InheritableLintsVisitor)\n }\n}\n\npub type TomlLints = BTreeMap;\n\npub type TomlToolLints = BTreeMap;\n\n#[derive(Serialize, Debug, Clone)]\n#[serde(untagged)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum TomlLint {\n Level(TomlLintLevel),\n Config(TomlLintConfig),\n}\n\nimpl<'de> Deserialize<'de> for TomlLint {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n UntaggedEnumVisitor::new()\n .string(|string| {\n TomlLintLevel::deserialize(string.into_deserializer()).map(TomlLint::Level)\n })\n .map(|map| map.deserialize().map(TomlLint::Config))\n .deserialize(deserializer)\n }\n}\n\nimpl TomlLint {\n pub fn level(&self) -> TomlLintLevel {\n match self {\n Self::Level(level) => *level,\n Self::Config(config) => config.level,\n }\n }\n\n pub fn priority(&self) -> i8 {\n match self {\n Self::Level(_) => 0,\n Self::Config(config) => config.priority,\n }\n }\n\n pub fn config(&self) -> Option<&toml::Table> {\n match self {\n Self::Level(_) => None,\n Self::Config(config) => Some(&config.config),\n }\n }\n}\n\n#[derive(Serialize, Deserialize, Debug, Clone)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct TomlLintConfig {\n pub level: TomlLintLevel,\n #[serde(default)]\n pub priority: i8,\n #[serde(flatten)]\n #[cfg_attr(\n feature = \"unstable-schema\",\n schemars(with = \"HashMap\")\n )]\n pub config: toml::Table,\n}\n\n#[derive(Serialize, Deserialize, Debug, Copy, Clone, Eq, PartialEq)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum TomlLintLevel {\n Forbid,\n Deny,\n Warn,\n Allow,\n}\n\n#[derive(Serialize, Deserialize, Debug, Default, Clone)]\n#[serde(rename_all = \"kebab-case\")]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct Hints {\n #[cfg_attr(\n feature = \"unstable-schema\",\n schemars(with = \"Option\")\n )]\n pub mostly_unused: Option,\n}\n\n#[derive(Copy, Clone, Debug)]\npub struct InvalidCargoFeatures {}\n\nimpl<'de> de::Deserialize<'de> for InvalidCargoFeatures {\n fn deserialize(_d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n use serde::de::Error as _;\n\n Err(D::Error::custom(\n \"the field `cargo-features` should be set at the top of Cargo.toml before any tables\",\n ))\n }\n}\n\n/// This can be parsed from either a TOML string or array,\n/// but is always stored as a vector.\n#[derive(Clone, Debug, Serialize, Eq, PartialEq, PartialOrd, Ord)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct StringOrVec(pub Vec);\n\nimpl StringOrVec {\n pub fn iter<'a>(&'a self) -> std::slice::Iter<'a, String> {\n self.0.iter()\n }\n}\n\nimpl<'de> de::Deserialize<'de> for StringOrVec {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n UntaggedEnumVisitor::new()\n .expecting(\"string or list of strings\")\n .string(|value| Ok(StringOrVec(vec![value.to_owned()])))\n .seq(|value| value.deserialize().map(StringOrVec))\n .deserialize(deserializer)\n }\n}\n\n#[derive(Clone, Debug, Serialize, Eq, PartialEq)]\n#[serde(untagged)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum StringOrBool {\n String(String),\n Bool(bool),\n}\n\nimpl<'de> Deserialize<'de> for StringOrBool {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n UntaggedEnumVisitor::new()\n .bool(|b| Ok(StringOrBool::Bool(b)))\n .string(|s| Ok(StringOrBool::String(s.to_owned())))\n .deserialize(deserializer)\n }\n}\n\n#[derive(Clone, Debug, Serialize, Eq, PartialEq)]\n#[serde(untagged)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum TomlPackageBuild {\n /// If build scripts are disabled or enabled.\n /// If true, `build.rs` in the root folder will be the build script.\n Auto(bool),\n\n /// Path of Build Script if there's just one script.\n SingleScript(String),\n\n /// Vector of paths if multiple build script are to be used.\n MultipleScript(Vec),\n}\n\nimpl<'de> Deserialize<'de> for TomlPackageBuild {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n UntaggedEnumVisitor::new()\n .bool(|b| Ok(TomlPackageBuild::Auto(b)))\n .string(|s| Ok(TomlPackageBuild::SingleScript(s.to_owned())))\n .seq(|value| value.deserialize().map(TomlPackageBuild::MultipleScript))\n .deserialize(deserializer)\n }\n}\n\n#[derive(PartialEq, Clone, Debug, Serialize)]\n#[serde(untagged)]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub enum VecStringOrBool {\n VecString(Vec),\n Bool(bool),\n}\n\nimpl<'de> de::Deserialize<'de> for VecStringOrBool {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n UntaggedEnumVisitor::new()\n .expecting(\"a boolean or vector of strings\")\n .bool(|value| Ok(VecStringOrBool::Bool(value)))\n .seq(|value| value.deserialize().map(VecStringOrBool::VecString))\n .deserialize(deserializer)\n }\n}\n\n#[derive(Clone, PartialEq, Eq)]\npub struct PathValue(pub PathBuf);\n\nimpl fmt::Debug for PathValue {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n self.0.fmt(f)\n }\n}\n\nimpl ser::Serialize for PathValue {\n fn serialize(&self, serializer: S) -> Result\n where\n S: ser::Serializer,\n {\n self.0.serialize(serializer)\n }\n}\n\nimpl<'de> de::Deserialize<'de> for PathValue {\n fn deserialize(deserializer: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n Ok(PathValue(String::deserialize(deserializer)?.into()))\n }\n}\n\n/// Error validating names in Cargo.\n#[derive(Debug, thiserror::Error)]\n#[error(\"manifest field was not resolved\")]\n#[non_exhaustive]\n#[cfg_attr(feature = \"unstable-schema\", derive(schemars::JsonSchema))]\npub struct UnresolvedError;\n\n#[cfg(feature = \"unstable-schema\")]\n#[test]\nfn dump_manifest_schema() {\n let schema = schemars::schema_for!(crate::manifest::TomlManifest);\n let dump = serde_json::to_string_pretty(&schema).unwrap();\n snapbox::assert_data_eq!(dump, snapbox::file!(\"../../manifest.schema.json\").raw());\n}\n" }, { "path": "crates/cargo-util-schemas/src/manifest/rust_version.rs", "content": "use std::fmt;\nuse std::fmt::Display;\n\nuse serde_untagged::UntaggedEnumVisitor;\n\nuse crate::core::PartialVersion;\nuse crate::core::PartialVersionError;\n\n#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)]\npub struct RustVersion {\n major: u64,\n minor: Option,\n patch: Option,\n}\n\nimpl RustVersion {\n pub const fn new(major: u64, minor: u64, patch: u64) -> Self {\n Self {\n major,\n minor: Some(minor),\n patch: Some(patch),\n }\n }\n\n pub fn is_compatible_with(&self, rustc: &PartialVersion) -> bool {\n let msrv = self.to_partial().to_caret_req();\n // Remove any pre-release identifiers for easier comparison\n let rustc = semver::Version {\n major: rustc.major,\n minor: rustc.minor.unwrap_or_default(),\n patch: rustc.patch.unwrap_or_default(),\n pre: Default::default(),\n build: Default::default(),\n };\n msrv.matches(&rustc)\n }\n\n pub fn to_partial(&self) -> PartialVersion {\n let Self {\n major,\n minor,\n patch,\n } = *self;\n PartialVersion {\n major,\n minor,\n patch,\n pre: None,\n build: None,\n }\n }\n}\n\nimpl std::str::FromStr for RustVersion {\n type Err = RustVersionError;\n\n fn from_str(value: &str) -> Result {\n let partial = value.parse::();\n let partial = partial.map_err(RustVersionErrorKind::PartialVersion)?;\n partial.try_into()\n }\n}\n\nimpl TryFrom for RustVersion {\n type Error = RustVersionError;\n\n fn try_from(version: semver::Version) -> Result {\n let version = PartialVersion::from(version);\n Self::try_from(version)\n }\n}\n\nimpl TryFrom for RustVersion {\n type Error = RustVersionError;\n\n fn try_from(partial: PartialVersion) -> Result {\n let PartialVersion {\n major,\n minor,\n patch,\n pre,\n build,\n } = partial;\n if pre.is_some() {\n return Err(RustVersionErrorKind::Prerelease.into());\n }\n if build.is_some() {\n return Err(RustVersionErrorKind::BuildMetadata.into());\n }\n Ok(Self {\n major,\n minor,\n patch,\n })\n }\n}\n\nimpl serde::Serialize for RustVersion {\n fn serialize(&self, serializer: S) -> Result\n where\n S: serde::Serializer,\n {\n serializer.collect_str(self)\n }\n}\n\nimpl<'de> serde::Deserialize<'de> for RustVersion {\n fn deserialize(deserializer: D) -> Result\n where\n D: serde::Deserializer<'de>,\n {\n UntaggedEnumVisitor::new()\n .expecting(\"SemVer version\")\n .string(|value| value.parse().map_err(serde::de::Error::custom))\n .deserialize(deserializer)\n }\n}\n\nimpl Display for RustVersion {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n self.to_partial().fmt(f)\n }\n}\n\n/// Error parsing a [`RustVersion`].\n#[derive(Debug, thiserror::Error)]\n#[error(transparent)]\npub struct RustVersionError(#[from] RustVersionErrorKind);\n\n/// Non-public error kind for [`RustVersionError`].\n#[non_exhaustive]\n#[derive(Debug, thiserror::Error)]\nenum RustVersionErrorKind {\n #[error(\"unexpected prerelease field, expected a version like \\\"1.32\\\"\")]\n Prerelease,\n\n #[error(\"unexpected build field, expected a version like \\\"1.32\\\"\")]\n BuildMetadata,\n\n #[error(transparent)]\n PartialVersion(#[from] PartialVersionError),\n}\n\n#[cfg(test)]\nmod test {\n use super::*;\n use snapbox::prelude::*;\n use snapbox::str;\n\n #[test]\n fn is_compatible_with_rustc() {\n let cases = &[\n (\"1\", \"1.70.0\", true),\n (\"1.30\", \"1.70.0\", true),\n (\"1.30.10\", \"1.70.0\", true),\n (\"1.70\", \"1.70.0\", true),\n (\"1.70.0\", \"1.70.0\", true),\n (\"1.70.1\", \"1.70.0\", false),\n (\"1.70\", \"1.70.0-nightly\", true),\n (\"1.70.0\", \"1.70.0-nightly\", true),\n (\"1.71\", \"1.70.0\", false),\n (\"2\", \"1.70.0\", false),\n ];\n let mut passed = true;\n for (msrv, rustc, expected) in cases {\n let msrv: RustVersion = msrv.parse().unwrap();\n let rustc = PartialVersion::from(semver::Version::parse(rustc).unwrap());\n if msrv.is_compatible_with(&rustc) != *expected {\n println!(\"failed: {msrv} is_compatible_with {rustc} == {expected}\");\n passed = false;\n }\n }\n assert!(passed);\n }\n\n #[test]\n fn is_compatible_with_workspace_msrv() {\n let cases = &[\n (\"1\", \"1\", true),\n (\"1\", \"1.70\", true),\n (\"1\", \"1.70.0\", true),\n (\"1.30\", \"1\", false),\n (\"1.30\", \"1.70\", true),\n (\"1.30\", \"1.70.0\", true),\n (\"1.30.10\", \"1\", false),\n (\"1.30.10\", \"1.70\", true),\n (\"1.30.10\", \"1.70.0\", true),\n (\"1.70\", \"1\", false),\n (\"1.70\", \"1.70\", true),\n (\"1.70\", \"1.70.0\", true),\n (\"1.70.0\", \"1\", false),\n (\"1.70.0\", \"1.70\", true),\n (\"1.70.0\", \"1.70.0\", true),\n (\"1.70.1\", \"1\", false),\n (\"1.70.1\", \"1.70\", false),\n (\"1.70.1\", \"1.70.0\", false),\n (\"1.71\", \"1\", false),\n (\"1.71\", \"1.70\", false),\n (\"1.71\", \"1.70.0\", false),\n (\"2\", \"1.70.0\", false),\n ];\n let mut passed = true;\n for (dep_msrv, ws_msrv, expected) in cases {\n let dep_msrv: RustVersion = dep_msrv.parse().unwrap();\n let ws_msrv = ws_msrv.parse::().unwrap().to_partial();\n if dep_msrv.is_compatible_with(&ws_msrv) != *expected {\n println!(\"failed: {dep_msrv} is_compatible_with {ws_msrv} == {expected}\");\n passed = false;\n }\n }\n assert!(passed);\n }\n\n #[test]\n fn parse_errors() {\n let cases = &[\n // Disallow caret\n (\n \"^1.43\",\n str![[r#\"unexpected version requirement, expected a version like \"1.32\"\"#]],\n ),\n // Valid pre-release\n (\n \"1.43.0-beta.1\",\n str![[r#\"unexpected prerelease field, expected a version like \"1.32\"\"#]],\n ),\n // Bad pre-release\n (\n \"1.43-beta.1\",\n str![[r#\"unexpected prerelease field, expected a version like \"1.32\"\"#]],\n ),\n // Weird wildcard\n (\n \"x\",\n str![[r#\"unexpected version requirement, expected a version like \"1.32\"\"#]],\n ),\n (\n \"1.x\",\n str![[r#\"unexpected version requirement, expected a version like \"1.32\"\"#]],\n ),\n (\n \"1.1.x\",\n str![[r#\"unexpected version requirement, expected a version like \"1.32\"\"#]],\n ),\n // Non-sense\n (\"foodaddle\", str![[r#\"expected a version like \"1.32\"\"#]]),\n ];\n for (input, expected) in cases {\n let actual: Result = input.parse();\n let actual = match actual {\n Ok(result) => format!(\"didn't fail: {result:?}\"),\n Err(err) => err.to_string(),\n };\n snapbox::assert_data_eq!(actual, expected.clone().raw());\n }\n }\n}\n" }, { "path": "crates/cargo-util-schemas/src/messages.rs", "content": "//! Schemas for JSON messages emitted by Cargo.\n\nuse std::collections::BTreeMap;\nuse std::path::PathBuf;\n\n/// File information of a package archive generated by `cargo package --list`.\n#[derive(Debug, serde::Serialize)]\n#[serde(rename_all = \"snake_case\")]\npub struct PackageList {\n /// The Package ID Spec of the package.\n pub id: crate::core::PackageIdSpec,\n /// A map of relative paths in the archive to their detailed file information.\n pub files: BTreeMap,\n}\n\n/// Where the file is from.\n#[derive(Debug, serde::Serialize)]\n#[serde(rename_all = \"snake_case\", tag = \"kind\")]\npub enum PackageFile {\n /// File being copied from another location.\n Copy {\n /// An absolute path to the actual file content\n path: PathBuf,\n },\n /// File being generated during packaging\n Generate {\n /// An absolute path to the original file the generated one is based on.\n /// if any.\n #[serde(skip_serializing_if = \"Option::is_none\")]\n path: Option,\n },\n}\n" }, { "path": "crates/cargo-util-schemas/src/restricted_names.rs", "content": "//! Helpers for validating and checking names like package and crate names.\n\ntype Result = std::result::Result;\n\n/// Error validating names in Cargo.\n#[derive(Debug, thiserror::Error)]\n#[error(transparent)]\npub struct NameValidationError(#[from] ErrorKind);\n\n/// Non-public error kind for [`NameValidationError`].\n#[non_exhaustive]\n#[derive(Debug, thiserror::Error)]\nenum ErrorKind {\n #[error(\"{0} cannot be empty\")]\n Empty(&'static str),\n\n #[error(\"invalid character `{ch}` in {what}: `{name}`, {reason}\")]\n InvalidCharacter {\n ch: char,\n what: &'static str,\n name: String,\n reason: &'static str,\n },\n\n #[error(\n \"profile name `{name}` is reserved\\n{help}\\n\\\n See https://doc.rust-lang.org/cargo/reference/profiles.html \\\n for more on configuring profiles.\"\n )]\n ProfileNameReservedKeyword { name: String, help: &'static str },\n\n #[error(\"feature named `{0}` is not allowed to start with `dep:`\")]\n FeatureNameStartsWithDepColon(String),\n}\n\npub(crate) fn validate_package_name(name: &str) -> Result<()> {\n for part in name.split(\"::\") {\n validate_name(part, \"package name\")?;\n }\n Ok(())\n}\n\npub(crate) fn validate_registry_name(name: &str) -> Result<()> {\n validate_name(name, \"registry name\")\n}\n\npub(crate) fn validate_name(name: &str, what: &'static str) -> Result<()> {\n if name.is_empty() {\n return Err(ErrorKind::Empty(what).into());\n }\n\n let mut chars = name.chars();\n if let Some(ch) = chars.next() {\n if ch.is_digit(10) {\n // A specific error for a potentially common case.\n return Err(ErrorKind::InvalidCharacter {\n ch,\n what,\n name: name.into(),\n reason: \"the name cannot start with a digit\",\n }\n .into());\n }\n if !(unicode_ident::is_xid_start(ch) || ch == '_') {\n return Err(ErrorKind::InvalidCharacter {\n ch,\n what,\n name: name.into(),\n reason: \"the first character must be a Unicode XID start character \\\n (most letters or `_`)\",\n }\n .into());\n }\n }\n for ch in chars {\n if !(unicode_ident::is_xid_continue(ch) || ch == '-') {\n return Err(ErrorKind::InvalidCharacter {\n ch,\n what,\n name: name.into(),\n reason: \"characters must be Unicode XID characters \\\n (numbers, `-`, `_`, or most letters)\",\n }\n .into());\n }\n }\n Ok(())\n}\n\n/// Ensure a package name is [valid][validate_package_name]\npub(crate) fn sanitize_package_name(name: &str, placeholder: char) -> String {\n let mut slug = String::new();\n for part in name.split(\"::\") {\n if !slug.is_empty() {\n slug.push_str(\"::\");\n }\n slug.push_str(&sanitize_name(part, placeholder));\n }\n slug\n}\n\npub(crate) fn sanitize_name(name: &str, placeholder: char) -> String {\n let mut slug = String::new();\n let mut chars = name.chars();\n while let Some(ch) = chars.next() {\n if (unicode_ident::is_xid_start(ch) || ch == '_') && !ch.is_digit(10) {\n slug.push(ch);\n break;\n }\n }\n while let Some(ch) = chars.next() {\n if unicode_ident::is_xid_continue(ch) || ch == '-' {\n slug.push(ch);\n } else {\n slug.push(placeholder);\n }\n }\n if slug.is_empty() {\n slug.push_str(\"package\");\n }\n slug\n}\n\n/// Validate dir-names and profile names according to RFC 2678.\npub(crate) fn validate_profile_name(name: &str) -> Result<()> {\n if let Some(ch) = name\n .chars()\n .find(|ch| !ch.is_alphanumeric() && *ch != '_' && *ch != '-')\n {\n return Err(ErrorKind::InvalidCharacter {\n ch,\n what: \"profile name\",\n name: name.into(),\n reason: \"allowed characters are letters, numbers, underscore, and hyphen\",\n }\n .into());\n }\n\n let lower_name = name.to_lowercase();\n if lower_name == \"debug\" {\n return Err(ErrorKind::ProfileNameReservedKeyword {\n name: name.into(),\n help: \"To configure the default development profile, \\\n use the name `dev` as in [profile.dev]\",\n }\n .into());\n }\n if lower_name == \"build-override\" {\n return Err(ErrorKind::ProfileNameReservedKeyword {\n name: name.into(),\n help: \"To configure build dependency settings, use [profile.dev.build-override] \\\n and [profile.release.build-override]\",\n }\n .into());\n }\n\n // These are some arbitrary reservations. We have no plans to use\n // these, but it seems safer to reserve a few just in case we want to\n // add more built-in profiles in the future. We can also uses special\n // syntax like cargo:foo if needed. But it is unlikely these will ever\n // be used.\n if matches!(\n lower_name.as_str(),\n \"build\"\n | \"check\"\n | \"clean\"\n | \"config\"\n | \"fetch\"\n | \"fix\"\n | \"install\"\n | \"metadata\"\n | \"package\"\n | \"publish\"\n | \"report\"\n | \"root\"\n | \"run\"\n | \"rust\"\n | \"rustc\"\n | \"rustdoc\"\n | \"target\"\n | \"tmp\"\n | \"uninstall\"\n ) || lower_name.starts_with(\"cargo\")\n {\n return Err(ErrorKind::ProfileNameReservedKeyword {\n name: name.into(),\n help: \"Please choose a different name.\",\n }\n .into());\n }\n\n Ok(())\n}\n\npub(crate) fn validate_feature_name(name: &str) -> Result<()> {\n let what = \"feature name\";\n if name.is_empty() {\n return Err(ErrorKind::Empty(what).into());\n }\n\n if name.starts_with(\"dep:\") {\n return Err(ErrorKind::FeatureNameStartsWithDepColon(name.into()).into());\n }\n if name.contains('/') {\n return Err(ErrorKind::InvalidCharacter {\n ch: '/',\n what,\n name: name.into(),\n reason: \"feature name is not allowed to contain slashes\",\n }\n .into());\n }\n let mut chars = name.chars();\n if let Some(ch) = chars.next() {\n if !(unicode_ident::is_xid_start(ch) || ch == '_' || ch.is_digit(10)) {\n return Err(ErrorKind::InvalidCharacter {\n ch,\n what,\n name: name.into(),\n reason: \"the first character must be a Unicode XID start character or digit \\\n (most letters or `_` or `0` to `9`)\",\n }\n .into());\n }\n }\n for ch in chars {\n if !(unicode_ident::is_xid_continue(ch) || ch == '-' || ch == '+' || ch == '.') {\n return Err(ErrorKind::InvalidCharacter {\n ch,\n what,\n name: name.into(),\n reason: \"characters must be Unicode XID characters, '-', `+`, or `.` \\\n (numbers, `+`, `-`, `_`, `.`, or most letters)\",\n }\n .into());\n }\n }\n Ok(())\n}\n\npub(crate) fn validate_path_base_name(name: &str) -> Result<()> {\n validate_name(name, \"path base name\")\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn valid_feature_names() {\n assert!(validate_feature_name(\"c++17\").is_ok());\n assert!(validate_feature_name(\"128bit\").is_ok());\n assert!(validate_feature_name(\"_foo\").is_ok());\n assert!(validate_feature_name(\"feat-name\").is_ok());\n assert!(validate_feature_name(\"feat_name\").is_ok());\n assert!(validate_feature_name(\"foo.bar\").is_ok());\n\n assert!(validate_feature_name(\"\").is_err());\n assert!(validate_feature_name(\"+foo\").is_err());\n assert!(validate_feature_name(\"-foo\").is_err());\n assert!(validate_feature_name(\".foo\").is_err());\n assert!(validate_feature_name(\"dep:bar\").is_err());\n assert!(validate_feature_name(\"foo/bar\").is_err());\n assert!(validate_feature_name(\"foo:bar\").is_err());\n assert!(validate_feature_name(\"foo?\").is_err());\n assert!(validate_feature_name(\"?foo\").is_err());\n assert!(validate_feature_name(\"ā’¶ā’·ā’ø\").is_err());\n assert!(validate_feature_name(\"aĀ¼\").is_err());\n assert!(validate_feature_name(\"\").is_err());\n }\n}\n" }, { "path": "crates/cargo-util-schemas/src/schema.rs", "content": "use schemars::JsonSchema;\n\nuse serde::{Deserialize, Serialize};\n\nuse toml::Value as TomlValue;\n\n#[derive(Serialize, Deserialize)]\npub struct TomlValueWrapper(pub TomlValue);\n\nimpl JsonSchema for TomlValueWrapper {\n fn schema_name() -> std::borrow::Cow<'static, str> {\n \"TomlValue\".into()\n }\n\n fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {\n // HACK: this is both more and less permissive than `TomlValue` but its close\n generator.subschema_for::().into()\n }\n}\n" }, { "path": "crates/crates-io/Cargo.toml", "content": "[package]\nname = \"crates-io\"\nversion = \"0.40.19\"\nrust-version = \"1.94\" # MSRV:1\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"\"\"\nHelpers for interacting with crates.io\n\"\"\"\n\n[lib]\nname = \"crates_io\"\npath = \"lib.rs\"\n\n[dependencies]\ncurl.workspace = true\npercent-encoding.workspace = true\nserde = { workspace = true, features = [\"derive\"] }\nserde_json.workspace = true\nthiserror.workspace = true\nurl.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/crates-io/README.md", "content": "> This crate is maintained by the Cargo team for use by the wider\n> ecosystem. This crate follows semver compatibility for its APIs.\n" }, { "path": "crates/crates-io/lib.rs", "content": "//! > This crate is maintained by the Cargo team for use by the wider\n//! > ecosystem. This crate follows semver compatibility for its APIs.\n\nuse std::collections::BTreeMap;\nuse std::fs::File;\nuse std::io::prelude::*;\nuse std::io::{Cursor, SeekFrom};\nuse std::time::Instant;\n\nuse curl::easy::{Easy, List};\nuse percent_encoding::{NON_ALPHANUMERIC, percent_encode};\nuse serde::{Deserialize, Serialize};\nuse url::Url;\n\npub type Result = std::result::Result;\n\npub struct Registry {\n /// The base URL for issuing API requests.\n host: String,\n /// Optional authorization token.\n /// If None, commands requiring authorization will fail.\n token: Option,\n /// Curl handle for issuing requests.\n handle: Easy,\n /// Whether to include the authorization token with all requests.\n auth_required: bool,\n}\n\n#[derive(PartialEq, Clone, Copy)]\npub enum Auth {\n Authorized,\n Unauthorized,\n}\n\n#[derive(Deserialize)]\npub struct Crate {\n pub name: String,\n pub description: Option,\n pub max_version: String,\n}\n\n/// This struct is serialized as JSON and sent as metadata ahead of the crate\n/// tarball when publishing crates to a crate registry like crates.io.\n///\n/// see \n#[derive(Serialize, Deserialize)]\npub struct NewCrate {\n pub name: String,\n pub vers: String,\n pub deps: Vec,\n pub features: BTreeMap>,\n pub authors: Vec,\n pub description: Option,\n pub documentation: Option,\n pub homepage: Option,\n pub readme: Option,\n pub readme_file: Option,\n pub keywords: Vec,\n pub categories: Vec,\n pub license: Option,\n pub license_file: Option,\n pub repository: Option,\n pub badges: BTreeMap>,\n pub links: Option,\n pub rust_version: Option,\n}\n\n#[derive(Serialize, Deserialize)]\npub struct NewCrateDependency {\n pub optional: bool,\n pub default_features: bool,\n pub name: String,\n pub features: Vec,\n pub version_req: String,\n pub target: Option,\n pub kind: String,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub registry: Option,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub explicit_name_in_toml: Option,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub artifact: Option>,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub bindep_target: Option,\n #[serde(default, skip_serializing_if = \"std::ops::Not::not\")]\n pub lib: bool,\n}\n\n#[derive(Deserialize)]\npub struct User {\n pub id: u32,\n pub login: String,\n pub avatar: Option,\n pub email: Option,\n pub name: Option,\n}\n\npub struct Warnings {\n pub invalid_categories: Vec,\n pub invalid_badges: Vec,\n pub other: Vec,\n}\n\n#[derive(Deserialize)]\nstruct R {\n ok: bool,\n}\n#[derive(Deserialize)]\nstruct OwnerResponse {\n ok: bool,\n msg: String,\n}\n#[derive(Deserialize)]\nstruct ApiErrorList {\n errors: Vec,\n}\n#[derive(Deserialize)]\nstruct ApiError {\n detail: String,\n}\n#[derive(Serialize)]\nstruct OwnersReq<'a> {\n users: &'a [&'a str],\n}\n#[derive(Deserialize)]\nstruct Users {\n users: Vec,\n}\n#[derive(Deserialize)]\nstruct TotalCrates {\n total: u32,\n}\n#[derive(Deserialize)]\nstruct Crates {\n crates: Vec,\n meta: TotalCrates,\n}\n\n/// Error returned when interacting with a registry.\n#[derive(Debug, thiserror::Error)]\npub enum Error {\n /// Error from libcurl.\n #[error(transparent)]\n Curl(#[from] curl::Error),\n\n /// Error from serializing the request payload and deserializing the\n /// response body (like response body didn't match expected structure).\n #[error(transparent)]\n Json(#[from] serde_json::Error),\n\n /// Error from IO. Mostly from reading the tarball to upload.\n #[error(\"failed to seek tarball\")]\n Io(#[from] std::io::Error),\n\n /// Response body was not valid utf8.\n #[error(\"invalid response body from server\")]\n Utf8(#[from] std::string::FromUtf8Error),\n\n /// Error from API response containing JSON field `errors.details`.\n #[error(\n \"the remote server responded with an error{}: {}\",\n status(*code),\n errors.join(\", \"),\n )]\n Api {\n code: u32,\n headers: Vec,\n errors: Vec,\n },\n\n /// Error from API response which didn't have pre-programmed `errors.details`.\n #[error(\n \"failed to get a 200 OK response, got {code}\\nheaders:\\n\\t{}\\nbody:\\n{body}\",\n headers.join(\"\\n\\t\"),\n )]\n Code {\n code: u32,\n headers: Vec,\n body: String,\n },\n\n /// Reason why the token was invalid.\n #[error(\"{0}\")]\n InvalidToken(&'static str),\n\n /// Server was unavailable and timed out. Happened when uploading a way\n /// too large tarball to crates.io.\n #[error(\n \"Request timed out after 30 seconds. If you're trying to \\\n upload a crate it may be too large. If the crate is under \\\n 10MB in size, you can email help@crates.io for assistance.\\n\\\n Total size was {0}.\"\n )]\n Timeout(u64),\n}\n\nimpl Registry {\n /// Creates a new `Registry`.\n ///\n /// ## Example\n ///\n /// ```rust\n /// use curl::easy::Easy;\n /// use crates_io::Registry;\n ///\n /// let mut handle = Easy::new();\n /// // If connecting to crates.io, a user-agent is required.\n /// handle.useragent(\"my_crawler (example.com/info)\");\n /// let mut reg = Registry::new_handle(String::from(\"https://crates.io\"), None, handle, true);\n /// ```\n pub fn new_handle(\n host: String,\n token: Option,\n handle: Easy,\n auth_required: bool,\n ) -> Registry {\n Registry {\n host,\n token,\n handle,\n auth_required,\n }\n }\n\n pub fn set_token(&mut self, token: Option) {\n self.token = token;\n }\n\n fn token(&self) -> Result<&str> {\n let token = self.token.as_ref().ok_or_else(|| {\n Error::InvalidToken(\"no upload token found, please run `cargo login`\")\n })?;\n check_token(token)?;\n Ok(token)\n }\n\n pub fn host(&self) -> &str {\n &self.host\n }\n\n pub fn host_is_crates_io(&self) -> bool {\n is_url_crates_io(&self.host)\n }\n\n pub fn add_owners(&mut self, krate: &str, owners: &[&str]) -> Result {\n let body = serde_json::to_string(&OwnersReq { users: owners })?;\n let body = self.put(&format!(\"/crates/{}/owners\", krate), body.as_bytes())?;\n assert!(serde_json::from_str::(&body)?.ok);\n Ok(serde_json::from_str::(&body)?.msg)\n }\n\n pub fn remove_owners(&mut self, krate: &str, owners: &[&str]) -> Result<()> {\n let body = serde_json::to_string(&OwnersReq { users: owners })?;\n let body = self.delete(&format!(\"/crates/{}/owners\", krate), Some(body.as_bytes()))?;\n assert!(serde_json::from_str::(&body)?.ok);\n Ok(())\n }\n\n pub fn list_owners(&mut self, krate: &str) -> Result> {\n let body = self.get(&format!(\"/crates/{}/owners\", krate))?;\n Ok(serde_json::from_str::(&body)?.users)\n }\n\n pub fn publish(&mut self, krate: &NewCrate, mut tarball: &File) -> Result {\n let json = serde_json::to_string(krate)?;\n // Prepare the body. The format of the upload request is:\n //\n // \n // (metadata for the package)\n // \n // \n\n // NOTE: This can be replaced with `stream_len` if it is ever stabilized.\n //\n // This checks the length using seeking instead of metadata, because\n // on some filesystems, getting the metadata will fail because\n // the file was renamed in ops::package.\n let tarball_len = tarball.seek(SeekFrom::End(0))?;\n tarball.seek(SeekFrom::Start(0))?;\n let header = {\n let mut w = Vec::new();\n w.extend(&(json.len() as u32).to_le_bytes());\n w.extend(json.as_bytes().iter().cloned());\n w.extend(&(tarball_len as u32).to_le_bytes());\n w\n };\n let size = tarball_len as usize + header.len();\n let mut body = Cursor::new(header).chain(tarball);\n\n let url = format!(\"{}/api/v1/crates/new\", self.host);\n\n self.handle.put(true)?;\n self.handle.url(&url)?;\n self.handle.in_filesize(size as u64)?;\n let mut headers = List::new();\n headers.append(\"Accept: application/json\")?;\n headers.append(&format!(\"Authorization: {}\", self.token()?))?;\n self.handle.http_headers(headers)?;\n\n let started = Instant::now();\n let body = self\n .handle(&mut |buf| body.read(buf).unwrap_or(0))\n .map_err(|e| match e {\n Error::Code { code, .. }\n if code == 503\n && started.elapsed().as_secs() >= 29\n && self.host_is_crates_io() =>\n {\n Error::Timeout(tarball_len)\n }\n _ => e.into(),\n })?;\n\n let response = if body.is_empty() {\n \"{}\".parse()?\n } else {\n body.parse::()?\n };\n\n let invalid_categories: Vec = response\n .get(\"warnings\")\n .and_then(|j| j.get(\"invalid_categories\"))\n .and_then(|j| j.as_array())\n .map(|x| x.iter().flat_map(|j| j.as_str()).map(Into::into).collect())\n .unwrap_or_else(Vec::new);\n\n let invalid_badges: Vec = response\n .get(\"warnings\")\n .and_then(|j| j.get(\"invalid_badges\"))\n .and_then(|j| j.as_array())\n .map(|x| x.iter().flat_map(|j| j.as_str()).map(Into::into).collect())\n .unwrap_or_else(Vec::new);\n\n let other: Vec = response\n .get(\"warnings\")\n .and_then(|j| j.get(\"other\"))\n .and_then(|j| j.as_array())\n .map(|x| x.iter().flat_map(|j| j.as_str()).map(Into::into).collect())\n .unwrap_or_else(Vec::new);\n\n Ok(Warnings {\n invalid_categories,\n invalid_badges,\n other,\n })\n }\n\n pub fn search(&mut self, query: &str, limit: u32) -> Result<(Vec, u32)> {\n let formatted_query = percent_encode(query.as_bytes(), NON_ALPHANUMERIC);\n let body = self.req(\n &format!(\"/crates?q={}&per_page={}\", formatted_query, limit),\n None,\n Auth::Unauthorized,\n )?;\n\n let crates = serde_json::from_str::(&body)?;\n Ok((crates.crates, crates.meta.total))\n }\n\n pub fn yank(&mut self, krate: &str, version: &str) -> Result<()> {\n let body = self.delete(&format!(\"/crates/{}/{}/yank\", krate, version), None)?;\n assert!(serde_json::from_str::(&body)?.ok);\n Ok(())\n }\n\n pub fn unyank(&mut self, krate: &str, version: &str) -> Result<()> {\n let body = self.put(&format!(\"/crates/{}/{}/unyank\", krate, version), &[])?;\n assert!(serde_json::from_str::(&body)?.ok);\n Ok(())\n }\n\n fn put(&mut self, path: &str, b: &[u8]) -> Result {\n self.handle.put(true)?;\n self.req(path, Some(b), Auth::Authorized)\n }\n\n fn get(&mut self, path: &str) -> Result {\n self.handle.get(true)?;\n self.req(path, None, Auth::Authorized)\n }\n\n fn delete(&mut self, path: &str, b: Option<&[u8]>) -> Result {\n self.handle.custom_request(\"DELETE\")?;\n self.req(path, b, Auth::Authorized)\n }\n\n fn req(&mut self, path: &str, body: Option<&[u8]>, authorized: Auth) -> Result {\n self.handle.url(&format!(\"{}/api/v1{}\", self.host, path))?;\n let mut headers = List::new();\n headers.append(\"Accept: application/json\")?;\n if body.is_some() {\n headers.append(\"Content-Type: application/json\")?;\n }\n\n if self.auth_required || authorized == Auth::Authorized {\n headers.append(&format!(\"Authorization: {}\", self.token()?))?;\n }\n self.handle.http_headers(headers)?;\n match body {\n Some(mut body) => {\n self.handle.upload(true)?;\n self.handle.in_filesize(body.len() as u64)?;\n self.handle(&mut |buf| body.read(buf).unwrap_or(0))\n .map_err(|e| e.into())\n }\n None => self.handle(&mut |_| 0).map_err(|e| e.into()),\n }\n }\n\n fn handle(&mut self, read: &mut dyn FnMut(&mut [u8]) -> usize) -> Result {\n let mut headers = Vec::new();\n let mut body = Vec::new();\n {\n let mut handle = self.handle.transfer();\n handle.read_function(|buf| Ok(read(buf)))?;\n handle.write_function(|data| {\n body.extend_from_slice(data);\n Ok(data.len())\n })?;\n handle.header_function(|data| {\n // Headers contain trailing \\r\\n, trim them to make it easier\n // to work with.\n let s = String::from_utf8_lossy(data).trim().to_string();\n // Don't let server sneak extra lines anywhere.\n if s.contains('\\n') {\n return true;\n }\n headers.push(s);\n true\n })?;\n handle.perform()?;\n }\n\n let body = String::from_utf8(body)?;\n let errors = serde_json::from_str::(&body)\n .ok()\n .map(|s| s.errors.into_iter().map(|s| s.detail).collect::>());\n\n match (self.handle.response_code()?, errors) {\n (0, None) => Ok(body),\n (code, None) if is_success(code) => Ok(body),\n (code, Some(errors)) => Err(Error::Api {\n code,\n headers,\n errors,\n }),\n (code, None) => Err(Error::Code {\n code,\n headers,\n body,\n }),\n }\n }\n}\n\nfn is_success(code: u32) -> bool {\n code >= 200 && code < 300\n}\n\nfn status(code: u32) -> String {\n if is_success(code) {\n String::new()\n } else {\n let reason = reason(code);\n format!(\" (status {code} {reason})\")\n }\n}\n\nfn reason(code: u32) -> &'static str {\n // Taken from https://developer.mozilla.org/en-US/docs/Web/HTTP/Status\n match code {\n 100 => \"Continue\",\n 101 => \"Switching Protocol\",\n 103 => \"Early Hints\",\n 200 => \"OK\",\n 201 => \"Created\",\n 202 => \"Accepted\",\n 203 => \"Non-Authoritative Information\",\n 204 => \"No Content\",\n 205 => \"Reset Content\",\n 206 => \"Partial Content\",\n 300 => \"Multiple Choice\",\n 301 => \"Moved Permanently\",\n 302 => \"Found\",\n 303 => \"See Other\",\n 304 => \"Not Modified\",\n 307 => \"Temporary Redirect\",\n 308 => \"Permanent Redirect\",\n 400 => \"Bad Request\",\n 401 => \"Unauthorized\",\n 402 => \"Payment Required\",\n 403 => \"Forbidden\",\n 404 => \"Not Found\",\n 405 => \"Method Not Allowed\",\n 406 => \"Not Acceptable\",\n 407 => \"Proxy Authentication Required\",\n 408 => \"Request Timeout\",\n 409 => \"Conflict\",\n 410 => \"Gone\",\n 411 => \"Length Required\",\n 412 => \"Precondition Failed\",\n 413 => \"Payload Too Large\",\n 414 => \"URI Too Long\",\n 415 => \"Unsupported Media Type\",\n 416 => \"Request Range Not Satisfiable\",\n 417 => \"Expectation Failed\",\n 429 => \"Too Many Requests\",\n 431 => \"Request Header Fields Too Large\",\n 500 => \"Internal Server Error\",\n 501 => \"Not Implemented\",\n 502 => \"Bad Gateway\",\n 503 => \"Service Unavailable\",\n 504 => \"Gateway Timeout\",\n _ => \"\",\n }\n}\n\n/// Returns `true` if the host of the given URL is \"crates.io\".\npub fn is_url_crates_io(url: &str) -> bool {\n Url::parse(url)\n .map(|u| u.host_str() == Some(\"crates.io\"))\n .unwrap_or(false)\n}\n\n/// Checks if a token is valid or malformed.\n///\n/// This check is necessary to prevent sending tokens which create an invalid HTTP request.\n/// It would be easier to check just for alphanumeric tokens, but we can't be sure that all\n/// registries only create tokens in that format so that is as less restricted as possible.\npub fn check_token(token: &str) -> Result<()> {\n if token.is_empty() {\n return Err(Error::InvalidToken(\"please provide a non-empty token\"));\n }\n if token.bytes().all(|b| {\n // This is essentially the US-ASCII limitation of\n // https://www.rfc-editor.org/rfc/rfc9110#name-field-values. That is,\n // visible ASCII characters (0x21-0x7e), space, and tab. We want to be\n // able to pass this in an HTTP header without encoding.\n b >= 32 && b < 127 || b == b'\\t'\n }) {\n Ok(())\n } else {\n Err(Error::InvalidToken(\n \"token contains invalid characters.\\nOnly printable ISO-8859-1 characters \\\n are allowed as it is sent in a HTTPS header.\",\n ))\n }\n}\n" }, { "path": "crates/home/CHANGELOG.md", "content": "# Changelog\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),\nand this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n\n## 0.5.11 - 2024-12-16\n\nNote: 0.5.10 was not published.\n\n- Updated package metadata.\n [#13184](https://github.com/rust-lang/cargo/pull/13184)\n- Updated minimum Rust version to 1.81.\n [#13266](https://github.com/rust-lang/cargo/pull/13266)\n [#13324](https://github.com/rust-lang/cargo/pull/13324)\n [#14871](https://github.com/rust-lang/cargo/pull/14871)\n- Updated windows-sys to 0.59.\n [#14335](https://github.com/rust-lang/cargo/pull/14335)\n- Clarified support level of this crate (not intended for external use).\n [#14600](https://github.com/rust-lang/cargo/pull/14600)\n- Docs cleanup.\n [#14823]()\n- Add notice that this crate should not be used, and to use the standard library's `home_dir` instead.\n [#14939](https://github.com/rust-lang/cargo/pull/14939)\n\n## 0.5.9 - 2023-12-15\n\n- Replace SHGetFolderPathW with SHGetKnownFolderPath\n [#13173](https://github.com/rust-lang/cargo/pull/13173)\n- Update windows-sys to 0.52\n [#13089](https://github.com/rust-lang/cargo/pull/13089)\n- Set MSRV to 1.70.0\n [#12654](https://github.com/rust-lang/cargo/pull/12654)\n- Fixed & enhanced documentation.\n [#12047](https://github.com/rust-lang/cargo/pull/12047)\n\n## 0.5.5 - 2023-04-25\n- The `home` crate has migrated to the repository.\n [#11359](https://github.com/rust-lang/cargo/pull/11359)\n- Replaced the winapi dependency with windows-sys.\n [#11656](https://github.com/rust-lang/cargo/pull/11656)\n\n## [0.5.4] - 2022-10-10\n- Add `_with_env` variants of functions to support in-process threaded tests for\n rustup.\n\n## [0.5.3] - 2020-01-07\n\nUse Rust 1.36.0 as minimum Rust version.\n\n## [0.5.2] - 2020-01-05\n\n*YANKED since it cannot be built on Rust 1.36.0*\n\n### Changed\n- Check for emptiness of `CARGO_HOME` and `RUSTUP_HOME` environment variables.\n- Windows: Use `SHGetFolderPath` to replace `GetUserProfileDirectory` syscall.\n * Remove `scopeguard` dependency.\n\n## [0.5.1] - 2019-10-12\n### Changed\n- Disable unnecessary features for `scopeguard`. Thanks @mati865.\n\n## [0.5.0] - 2019-08-21\n### Added\n- Add `home_dir` implementation for Windows UWP platforms.\n\n### Fixed\n- Fix `rustup_home` implementation when `RUSTUP_HOME` is an absolute directory.\n- Fix `cargo_home` implementation when `CARGO_HOME` is an absolute directory.\n\n### Removed\n- Remove support for `multirust` folder used in old version of `rustup`.\n\n[0.5.4]: https://github.com/brson/home/compare/v0.5.3...v0.5.4\n[0.5.3]: https://github.com/brson/home/compare/v0.5.2...v0.5.3\n[0.5.2]: https://github.com/brson/home/compare/v0.5.1...v0.5.2\n[0.5.1]: https://github.com/brson/home/compare/v0.5.0...v0.5.1\n[0.5.0]: https://github.com/brson/home/compare/0.4.2...v0.5.0\n" }, { "path": "crates/home/Cargo.toml", "content": "[package]\nname = \"home\"\nversion = \"0.5.13\"\nauthors = [\"Brian Anderson \"]\nrust-version.workspace = true\ndocumentation = \"https://docs.rs/home\"\nedition.workspace = true\ninclude = [\n \"/src\",\n \"/Cargo.toml\",\n \"/CHANGELOG\",\n \"/LICENSE-*\",\n \"/README.md\",\n]\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"Shared definitions of home directories.\"\n\n[target.'cfg(windows)'.dependencies]\nwindows-sys = { workspace = true, features = [\"Win32_Foundation\", \"Win32_UI_Shell\", \"Win32_System_Com\"] }\n\n[lints]\nworkspace = true\n" }, { "path": "crates/home/README.md", "content": "[![Documentation](https://docs.rs/home/badge.svg)](https://docs.rs/home)\n[![crates.io](https://img.shields.io/crates/v/home.svg)](https://crates.io/crates/home)\n\nCanonical definitions of `home_dir`, `cargo_home`, and `rustup_home`.\n\nThis provides the definition of `home_dir` used by Cargo and rustup,\nas well functions to find the correct value of `CARGO_HOME` and\n`RUSTUP_HOME`.\n\nThe definition of [`home_dir`] provided by the standard library is\nincorrect because it considers the `HOME` environment variable on\nWindows. This causes surprising situations where a Rust program will\nbehave differently depending on whether it is run under a Unix\nemulation environment like Cygwin or MinGW. Neither Cargo nor rustup\nuse the standard library's definition - they use the definition here.\n\n**Note:** This has been fixed in Rust 1.85 to no longer use the `HOME`\nenvironment variable on Windows. If you are still using this crate for the\npurpose of getting a home directory, you are strongly encouraged to switch to\nusing the standard library's [`home_dir`] instead. It is planned to have the\ndeprecation notice removed in 1.87.\n\nThis crate further provides two functions, `cargo_home` and\n`rustup_home`, which are the canonical way to determine the location\nthat Cargo and rustup store their data.\n\nSee [rust-lang/rust#43321].\n\n> This crate is maintained by the Cargo team, primarily for use by Cargo and Rustup\n> and not intended for external use. This\n> crate may make major changes to its APIs or be deprecated without warning.\n\n[rust-lang/rust#43321]: https://github.com/rust-lang/rust/issues/43321\n[`home_dir`]: https://doc.rust-lang.org/nightly/std/env/fn.home_dir.html\n\n## License\n\nMIT OR Apache-2.0\n" }, { "path": "crates/home/src/env.rs", "content": "//! Lower-level utilities for mocking the process environment.\n\nuse std::{\n ffi::OsString,\n io,\n path::{Path, PathBuf},\n};\n\n/// Permits parameterizing the home functions via the _from variants - used for\n/// in-process unit testing by rustup.\npub trait Env {\n /// Return the path to the users home dir, or None if any error occurs:\n /// see `home_inner`.\n fn home_dir(&self) -> Option;\n /// Return the current working directory.\n fn current_dir(&self) -> io::Result;\n /// Get an environment variable, as per `std::env::var_os`.\n fn var_os(&self, key: &str) -> Option;\n}\n\n/// Implements Env for the OS context, both Unix style and Windows.\n///\n/// This is trait permits in-process testing by providing a control point to\n/// allow in-process divergence on what is normally process wide state.\n///\n/// Implementations should be provided by whatever testing framework the caller\n/// is using. Code that is not performing in-process threaded testing requiring\n/// isolated rustup/cargo directories does not need this trait or the _from\n/// functions.\npub struct OsEnv;\nimpl Env for OsEnv {\n fn home_dir(&self) -> Option {\n crate::home_dir_inner()\n }\n fn current_dir(&self) -> io::Result {\n std::env::current_dir()\n }\n fn var_os(&self, key: &str) -> Option {\n std::env::var_os(key)\n }\n}\n\npub const OS_ENV: OsEnv = OsEnv {};\n\n/// Returns the path of the current user's home directory from [`Env::home_dir`].\npub fn home_dir_with_env(env: &dyn Env) -> Option {\n env.home_dir()\n}\n\n/// Variant of `cargo_home` where the environment source is parameterized.\n///\n/// This is\n/// specifically to support in-process testing scenarios as environment\n/// variables and user home metadata are normally process global state. See the\n/// [`Env`] trait.\npub fn cargo_home_with_env(env: &dyn Env) -> io::Result {\n let cwd = env.current_dir()?;\n cargo_home_with_cwd_env(env, &cwd)\n}\n\n/// Variant of `cargo_home_with_cwd` where the environment source is\n/// parameterized.\n///\n/// This is specifically to support in-process testing scenarios\n/// as environment variables and user home metadata are normally process global\n/// state. See the `OsEnv` trait.\npub fn cargo_home_with_cwd_env(env: &dyn Env, cwd: &Path) -> io::Result {\n match env.var_os(\"CARGO_HOME\").filter(|h| !h.is_empty()) {\n Some(home) => {\n let home = PathBuf::from(home);\n if home.is_absolute() {\n Ok(home)\n } else {\n Ok(cwd.join(&home))\n }\n }\n _ => home_dir_with_env(env)\n .map(|p| p.join(\".cargo\"))\n .ok_or_else(|| io::Error::new(io::ErrorKind::Other, \"could not find cargo home dir\")),\n }\n}\n\n/// Variant of `cargo_home_with_cwd` where the environment source is\n/// parameterized.\n///\n/// This is specifically to support in-process testing scenarios\n/// as environment variables and user home metadata are normally process global\n/// state. See the `OsEnv` trait.\npub fn rustup_home_with_env(env: &dyn Env) -> io::Result {\n let cwd = env.current_dir()?;\n rustup_home_with_cwd_env(env, &cwd)\n}\n\n/// Variant of `cargo_home_with_cwd` where the environment source is\n/// parameterized.\n///\n/// This is specifically to support in-process testing scenarios\n/// as environment variables and user home metadata are normally process global\n/// state. See the `OsEnv` trait.\npub fn rustup_home_with_cwd_env(env: &dyn Env, cwd: &Path) -> io::Result {\n match env.var_os(\"RUSTUP_HOME\").filter(|h| !h.is_empty()) {\n Some(home) => {\n let home = PathBuf::from(home);\n if home.is_absolute() {\n Ok(home)\n } else {\n Ok(cwd.join(&home))\n }\n }\n _ => home_dir_with_env(env)\n .map(|d| d.join(\".rustup\"))\n .ok_or_else(|| io::Error::new(io::ErrorKind::Other, \"could not find rustup home dir\")),\n }\n}\n" }, { "path": "crates/home/src/lib.rs", "content": "//! Canonical definitions of `home_dir`, `cargo_home`, and `rustup_home`.\n//!\n//! The definition of `home_dir` provided by the standard library is\n//! incorrect because it considers the `HOME` environment variable on\n//! Windows. This causes surprising situations where a Rust program\n//! will behave differently depending on whether it is run under a\n//! Unix emulation environment like Cygwin or MinGW. Neither Cargo nor\n//! rustup use the standard libraries definition - they use the\n//! definition here.\n//!\n//! This crate provides two additional functions, `cargo_home` and\n//! `rustup_home`, which are the canonical way to determine the\n//! location that Cargo and rustup use to store their data.\n//! The `env` module contains utilities for mocking the process environment\n//! by Cargo and rustup.\n//!\n//! See also this [discussion].\n//!\n//! > This crate is maintained by the Cargo team, primarily for use by Cargo and Rustup\n//! > and not intended for external use. This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n//!\n//! [discussion]: https://github.com/rust-lang/rust/pull/46799#issuecomment-361156935\n\n#![allow(clippy::disallowed_methods)]\n\npub mod env;\n\n#[cfg(target_os = \"windows\")]\nmod windows;\n\nuse std::io;\nuse std::path::{Path, PathBuf};\n\n/// Returns the path of the current user's home directory using environment\n/// variables or OS-specific APIs.\n///\n/// # Unix\n///\n/// Returns the value of the `HOME` environment variable if it is set\n/// **even** if it is an empty string. Otherwise, it tries to determine the\n/// home directory by invoking the [`getpwuid_r`][getpwuid] function with\n/// the UID of the current user.\n///\n/// [getpwuid]: https://linux.die.net/man/3/getpwuid_r\n///\n/// # Windows\n///\n/// Returns the value of the `USERPROFILE` environment variable if it is set\n/// **and** it is not an empty string. Otherwise, it tries to determine the\n/// home directory by invoking the [`SHGetKnownFolderPath`][shgkfp] function with\n/// [`FOLDERID_Profile`][knownfolderid].\n///\n/// [shgkfp]: https://learn.microsoft.com/en-us/windows/win32/api/shlobj_core/nf-shlobj_core-shgetknownfolderpath\n/// [knownfolderid]: https://learn.microsoft.com/en-us/windows/win32/shell/knownfolderid\n///\n/// # Examples\n///\n/// ```\n/// match home::home_dir() {\n/// Some(path) if !path.as_os_str().is_empty() => println!(\"{}\", path.display()),\n/// _ => println!(\"Unable to get your home dir!\"),\n/// }\n/// ```\npub fn home_dir() -> Option {\n env::home_dir_with_env(&env::OS_ENV)\n}\n\n#[cfg(windows)]\nuse windows::home_dir_inner;\n\n#[cfg(unix)]\nfn home_dir_inner() -> Option {\n #[allow(deprecated)]\n std::env::home_dir()\n}\n\n/// Returns the storage directory used by Cargo, often known as\n/// `.cargo` or `CARGO_HOME`.\n///\n/// It returns one of the following values, in this order of\n/// preference:\n///\n/// - The value of the `CARGO_HOME` environment variable, if it is\n/// an absolute path.\n/// - The value of the current working directory joined with the value\n/// of the `CARGO_HOME` environment variable, if `CARGO_HOME` is a\n/// relative directory.\n/// - The `.cargo` directory in the user's home directory, as reported\n/// by the `home_dir` function.\n///\n/// # Errors\n///\n/// This function fails if it fails to retrieve the current directory,\n/// or if the home directory cannot be determined.\n///\n/// # Examples\n///\n/// ```\n/// match home::cargo_home() {\n/// Ok(path) => println!(\"{}\", path.display()),\n/// Err(err) => eprintln!(\"Cannot get your cargo home dir: {:?}\", err),\n/// }\n/// ```\npub fn cargo_home() -> io::Result {\n env::cargo_home_with_env(&env::OS_ENV)\n}\n\n/// Returns the storage directory used by Cargo within `cwd`.\n/// For more details, see [`cargo_home`](fn.cargo_home.html).\npub fn cargo_home_with_cwd(cwd: &Path) -> io::Result {\n env::cargo_home_with_cwd_env(&env::OS_ENV, cwd)\n}\n\n/// Returns the storage directory used by rustup, often known as\n/// `.rustup` or `RUSTUP_HOME`.\n///\n/// It returns one of the following values, in this order of\n/// preference:\n///\n/// - The value of the `RUSTUP_HOME` environment variable, if it is\n/// an absolute path.\n/// - The value of the current working directory joined with the value\n/// of the `RUSTUP_HOME` environment variable, if `RUSTUP_HOME` is a\n/// relative directory.\n/// - The `.rustup` directory in the user's home directory, as reported\n/// by the `home_dir` function.\n///\n/// # Errors\n///\n/// This function fails if it fails to retrieve the current directory,\n/// or if the home directory cannot be determined.\n///\n/// # Examples\n///\n/// ```\n/// match home::rustup_home() {\n/// Ok(path) => println!(\"{}\", path.display()),\n/// Err(err) => eprintln!(\"Cannot get your rustup home dir: {:?}\", err),\n/// }\n/// ```\npub fn rustup_home() -> io::Result {\n env::rustup_home_with_env(&env::OS_ENV)\n}\n\n/// Returns the storage directory used by rustup within `cwd`.\n/// For more details, see [`rustup_home`](fn.rustup_home.html).\npub fn rustup_home_with_cwd(cwd: &Path) -> io::Result {\n env::rustup_home_with_cwd_env(&env::OS_ENV, cwd)\n}\n" }, { "path": "crates/home/src/windows.rs", "content": "use std::env;\nuse std::ffi::OsString;\nuse std::os::windows::ffi::OsStringExt;\nuse std::path::PathBuf;\nuse std::ptr;\nuse std::slice;\n\nuse windows_sys::Win32::Foundation::S_OK;\nuse windows_sys::Win32::System::Com::CoTaskMemFree;\nuse windows_sys::Win32::UI::Shell::{FOLDERID_Profile, KF_FLAG_DONT_VERIFY, SHGetKnownFolderPath};\n\npub fn home_dir_inner() -> Option {\n env::var_os(\"USERPROFILE\")\n .filter(|s| !s.is_empty())\n .map(PathBuf::from)\n .or_else(home_dir_crt)\n}\n\n#[cfg(not(target_vendor = \"uwp\"))]\nfn home_dir_crt() -> Option {\n unsafe {\n let mut path = ptr::null_mut();\n match SHGetKnownFolderPath(\n &FOLDERID_Profile,\n KF_FLAG_DONT_VERIFY as u32,\n std::ptr::null_mut(),\n &mut path,\n ) {\n S_OK => {\n let path_slice = slice::from_raw_parts(path, wcslen(path));\n let s = OsString::from_wide(&path_slice);\n CoTaskMemFree(path.cast());\n Some(PathBuf::from(s))\n }\n _ => {\n // Free any allocated memory even on failure. A null ptr is a no-op for `CoTaskMemFree`.\n CoTaskMemFree(path.cast());\n None\n }\n }\n }\n}\n\n#[cfg(target_vendor = \"uwp\")]\nfn home_dir_crt() -> Option {\n None\n}\n\nunsafe extern \"C\" {\n fn wcslen(buf: *const u16) -> usize;\n}\n\n#[cfg(not(target_vendor = \"uwp\"))]\n#[cfg(test)]\nmod tests {\n use super::home_dir_inner;\n use std::env;\n use std::ops::Deref;\n use std::path::{Path, PathBuf};\n\n #[test]\n fn test_with_without() {\n let olduserprofile = env::var_os(\"USERPROFILE\").unwrap();\n\n unsafe {\n env::remove_var(\"HOME\");\n env::remove_var(\"USERPROFILE\");\n }\n\n assert_eq!(home_dir_inner(), Some(PathBuf::from(olduserprofile)));\n\n let home = Path::new(r\"C:\\Users\\foo tar baz\");\n\n unsafe {\n env::set_var(\"HOME\", home.as_os_str());\n }\n assert_ne!(home_dir_inner().as_ref().map(Deref::deref), Some(home));\n\n unsafe {\n env::set_var(\"USERPROFILE\", home.as_os_str());\n }\n assert_eq!(home_dir_inner().as_ref().map(Deref::deref), Some(home));\n }\n}\n" }, { "path": "crates/mdman/Cargo.toml", "content": "[package]\nname = \"mdman\"\nversion = \"0.0.0\"\nedition.workspace = true\nlicense.workspace = true\ndescription = \"Creates a man page from markdown.\"\npublish = false\n\n[dependencies]\nanyhow.workspace = true\nhandlebars.workspace = true\npulldown-cmark.workspace = true\nsame-file.workspace = true\nserde_json.workspace = true\nurl.workspace = true\n\n[dev-dependencies]\nsnapbox.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/mdman/README.md", "content": "# mdman\n\nmdman is a small utility for creating man pages from markdown text files.\n\n> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use (except as a transitive dependency). This\n> crate may make major changes to its APIs or be deprecated without warning.\n\n## Usage\n\nSee the [man page](doc/out/mdman.md) generated by this tool.\n" }, { "path": "crates/mdman/doc/mdman.md", "content": "# mdman(1)\n\n## NAME\n\nmdman - Converts markdown to a man page\n\n## SYNOPSIS\n\n`mdman` [_options_] `-t` _type_ `-o` _outdir_ _sources..._\n\n## DESCRIPTION\n\nConverts a markdown file to a man page.\n\nThe source file is first processed as a\n[handlebars](https://handlebarsjs.com/) template. Then, it is processed as\nmarkdown into the target format. This supports different output formats,\nsuch as troff or plain text.\n\nEvery man page should start with a level-1 header with the man name and\nsection, such as `# mdman(1)`.\n\nThe handlebars template has several special tags to assist with generating the\nman page:\n\n{{{{raw}}}}\n- Every block of command-line options must be wrapped between `{{#options}}`\n and `{{/options}}` tags. This tells the processor where the options start\n and end.\n- Each option must be expressed with a `{{#option}}` block. The parameters to\n the block are a sequence of strings indicating the option. For example,\n ```{{#option \"`-p` _spec_...\" \"`--package` _spec_...\"}}``` is an option that\n has two different forms. The text within the string is processed as markdown.\n It is recommended to use formatting similar to this example.\n\n The content of the `{{#option}}` block should contain a detailed description\n of the option.\n\n Use the `{{/option}}` tag to end the option block.\n- References to other man pages should use the `{{man name section}}`\n expression. For example, `{{man \"mdman\" 1}}` will generate a reference to\n the `mdman(1)` man page. For non-troff output, the `--man` option will tell\n `mdman` how to create links to the man page. If there is no matching `--man`\n option, then it links to a file named _name_`.md` in the same directory.\n- Variables can be set with `{{*set name=\"value\"}}`. These variables can\n then be referenced with `{{name}}` expressions.\n- Partial templates should be placed in a directory named `includes`\n next to the source file. Templates can be included with an expression like\n `{{> template-name}}`.\n- Other helpers include:\n - `{{lower value}}` Converts the given value to lowercase.\n{{{{/raw}}}}\n\n## OPTIONS\n\n{{#options}}\n\n{{#option \"`-t` _type_\"}}\nSpecifies the output type. The following output types are supported:\n- `man` ā€” A troff-style man page. Outputs with a numbered extension (like\n `.1`) matching the man page section.\n- `md` ā€” A markdown file, after all handlebars processing has been finished.\n Outputs with the `.md` extension.\n- `txt` ā€” A text file, rendered for situations where a man page viewer isn't\n available. Outputs with the `.txt` extension.\n{{/option}}\n\n{{#option \"`-o` _outdir_\"}}\nSpecifies the directory where to save the output.\n{{/option}}\n\n{{#option \"`--url` _base_url_\"}}\nSpecifies a base URL to use for relative URLs within the document. Any\nrelative URL will be joined with this URL.\n{{/option}}\n\n{{#option \"`--man` _name_`:`_section_`=`_url_\"}}\nSpecifies a URL to use for the given man page. When the `\\{{man name\nsection}}` expression is used, the given URL will be inserted as a link. This\nmay be specified multiple times. If a man page reference does not have a\nmatching `--man` entry, then a relative link to a file named _name_`.md` will\nbe used.\n{{/option}}\n\n{{#option \"_sources..._\"}}\nThe source input filename, may be specified multiple times.\n{{/option}}\n\n{{/options}}\n\n## EXAMPLES\n\n1. Convert the given documents to man pages:\n\n mdman -t man -o doc doc/mdman.md\n" }, { "path": "crates/mdman/doc/out/mdman.1", "content": "'\\\" t\n.TH \"MDMAN\" \"1\"\n.nh\n.ad l\n.ss \\n[.ss] 0\n.SH \"NAME\"\nmdman \\- Converts markdown to a man page\n.SH \"SYNOPSIS\"\n\\fBmdman\\fR [\\fIoptions\\fR] \\fB\\-t\\fR \\fItype\\fR \\fB\\-o\\fR \\fIoutdir\\fR \\fIsources\\[u2026]\\fR\n.SH \"DESCRIPTION\"\nConverts a markdown file to a man page.\n.sp\nThe source file is first processed as a\n\\fIhandlebars\\fR template. Then, it is processed as\nmarkdown into the target format. This supports different output formats,\nsuch as troff or plain text.\n.sp\nEvery man page should start with a level\\-1 header with the man name and\nsection, such as \\fB# mdman(1)\\fR\\&.\n.sp\nThe handlebars template has several special tags to assist with generating the\nman page:\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Every block of command\\-line options must be wrapped between \\fB{{#options}}\\fR\nand \\fB{{/options}}\\fR tags. This tells the processor where the options start\nand end.\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Each option must be expressed with a \\fB{{#option}}\\fR block. The parameters to\nthe block are a sequence of strings indicating the option. For example,\n\\fB{{#option \"`\\-p` _spec_...\" \"`\\-\\-package` _spec_...\"}}\\fR is an option that\nhas two different forms. The text within the string is processed as markdown.\nIt is recommended to use formatting similar to this example.\n.sp\nThe content of the \\fB{{#option}}\\fR block should contain a detailed description\nof the option.\n.sp\nUse the \\fB{{/option}}\\fR tag to end the option block.\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'References to other man pages should use the \\fB{{man name section}}\\fR\nexpression. For example, \\fB{{man \"mdman\" 1}}\\fR will generate a reference to\nthe \\fBmdman(1)\\fR man page. For non\\-troff output, the \\fB\\-\\-man\\fR option will tell\n\\fBmdman\\fR how to create links to the man page. If there is no matching \\fB\\-\\-man\\fR\noption, then it links to a file named \\fIname\\fR\\fB\\&.md\\fR in the same directory.\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Variables can be set with \\fB{{*set name=\"value\"}}\\fR\\&. These variables can\nthen be referenced with \\fB{{name}}\\fR expressions.\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Partial templates should be placed in a directory named \\fBincludes\\fR\nnext to the source file. Templates can be included with an expression like\n\\fB{{> template\\-name}}\\fR\\&.\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Other helpers include:\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'\\fB{{lower value}}\\fR Converts the given value to lowercase.\n.RE\n.RE\n.SH \"OPTIONS\"\n.sp\n\\fB\\-t\\fR \\fItype\\fR\n.RS 4\nSpecifies the output type. The following output types are supported:\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'\\fBman\\fR \\[em] A troff\\-style man page. Outputs with a numbered extension (like\n\\fB\\&.1\\fR) matching the man page section.\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'\\fBmd\\fR \\[em] A markdown file, after all handlebars processing has been finished.\nOutputs with the \\fB\\&.md\\fR extension.\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'\\fBtxt\\fR \\[em] A text file, rendered for situations where a man page viewer isn\\[cq]t\navailable. Outputs with the \\fB\\&.txt\\fR extension.\n.RE\n.RE\n.sp\n\\fB\\-o\\fR \\fIoutdir\\fR\n.RS 4\nSpecifies the directory where to save the output.\n.RE\n.sp\n\\fB\\-\\-url\\fR \\fIbase_url\\fR\n.RS 4\nSpecifies a base URL to use for relative URLs within the document. Any\nrelative URL will be joined with this URL.\n.RE\n.sp\n\\fB\\-\\-man\\fR \\fIname\\fR\\fB:\\fR\\fIsection\\fR\\fB=\\fR\\fIurl\\fR\n.RS 4\nSpecifies a URL to use for the given man page. When the \\fB{{man name section}}\\fR expression is used, the given URL will be inserted as a link. This\nmay be specified multiple times. If a man page reference does not have a\nmatching \\fB\\-\\-man\\fR entry, then a relative link to a file named \\fIname\\fR\\fB\\&.md\\fR will\nbe used.\n.RE\n.sp\n\\fIsources\\[u2026]\\fR\n.RS 4\nThe source input filename, may be specified multiple times.\n.RE\n.SH \"EXAMPLES\"\n.sp\n.RS 4\n\\h'-04' 1.\\h'+01'Convert the given documents to man pages:\n.sp\n.RS 4\n.nf\nmdman \\-t man \\-o doc doc/mdman.md\n.fi\n.RE\n.RE\n" }, { "path": "crates/mdman/doc/out/mdman.md", "content": "# mdman(1)\n\n## NAME\n\nmdman - Converts markdown to a man page\n\n## SYNOPSIS\n\n`mdman` [_options_] `-t` _type_ `-o` _outdir_ _sources..._\n\n## DESCRIPTION\n\nConverts a markdown file to a man page.\n\nThe source file is first processed as a\n[handlebars](https://handlebarsjs.com/) template. Then, it is processed as\nmarkdown into the target format. This supports different output formats,\nsuch as troff or plain text.\n\nEvery man page should start with a level-1 header with the man name and\nsection, such as `# mdman(1)`.\n\nThe handlebars template has several special tags to assist with generating the\nman page:\n\n- Every block of command-line options must be wrapped between `{{#options}}`\n and `{{/options}}` tags. This tells the processor where the options start\n and end.\n- Each option must be expressed with a `{{#option}}` block. The parameters to\n the block are a sequence of strings indicating the option. For example,\n ```{{#option \"`-p` _spec_...\" \"`--package` _spec_...\"}}``` is an option that\n has two different forms. The text within the string is processed as markdown.\n It is recommended to use formatting similar to this example.\n\n The content of the `{{#option}}` block should contain a detailed description\n of the option.\n\n Use the `{{/option}}` tag to end the option block.\n- References to other man pages should use the `{{man name section}}`\n expression. For example, `{{man \"mdman\" 1}}` will generate a reference to\n the `mdman(1)` man page. For non-troff output, the `--man` option will tell\n `mdman` how to create links to the man page. If there is no matching `--man`\n option, then it links to a file named _name_`.md` in the same directory.\n- Variables can be set with `{{*set name=\"value\"}}`. These variables can\n then be referenced with `{{name}}` expressions.\n- Partial templates should be placed in a directory named `includes`\n next to the source file. Templates can be included with an expression like\n `{{> template-name}}`.\n- Other helpers include:\n - `{{lower value}}` Converts the given value to lowercase.\n\n## OPTIONS\n\n

\n\n
-t type
\n

Specifies the output type. The following output types are supported:

\n
    \n
  • man ā€” A troff-style man page. Outputs with a numbered extension (like\n.1) matching the man page section.
    • \n
  • md ā€” A markdown file, after all handlebars processing has been finished.\nOutputs with the .md extension.
    • \n
  • txt ā€” A text file, rendered for situations where a man page viewer isnā€™t\navailable. Outputs with the .txt extension.
    • \n
\n
\n\n\n
-o outdir
\n

Specifies the directory where to save the output.

\n
\n\n\n
--url base_url
\n

Specifies a base URL to use for relative URLs within the document. Any\nrelative URL will be joined with this URL.

\n
\n\n\n
--man name:section=url
\n

Specifies a URL to use for the given man page. When the {{man name section}} expression is used, the given URL will be inserted as a link. This\nmay be specified multiple times. If a man page reference does not have a\nmatching --man entry, then a relative link to a file named name.md will\nbe used.

\n
\n\n\n
sourcesā€¦
\n

The source input filename, may be specified multiple times.

\n
\n\n\n
\n\n## EXAMPLES\n\n1. Convert the given documents to man pages:\n\n mdman -t man -o doc doc/mdman.md\n" }, { "path": "crates/mdman/doc/out/mdman.txt", "content": "MDMAN(1)\n\nNAME\n mdman - Converts markdown to a man page\n\nSYNOPSIS\n mdman [options] -t type -o outdir sourcesā€¦\n\nDESCRIPTION\n Converts a markdown file to a man page.\n\n The source file is first processed as a handlebars\n template. Then, it is processed as markdown\n into the target format. This supports different output formats, such as\n troff or plain text.\n\n Every man page should start with a level-1 header with the man name and\n section, such as # mdman(1).\n\n The handlebars template has several special tags to assist with\n generating the man page:\n\n o Every block of command-line options must be wrapped between\n {{#options}} and {{/options}} tags. This tells the processor where\n the options start and end.\n\n o Each option must be expressed with a {{#option}} block. The\n parameters to the block are a sequence of strings indicating the\n option. For example, {{#option \"`-p` _spec_...\" \"`--package`\n _spec_...\"}} is an option that has two different forms. The text\n within the string is processed as markdown. It is recommended to use\n formatting similar to this example.\n\n The content of the {{#option}} block should contain a detailed\n description of the option.\n\n Use the {{/option}} tag to end the option block.\n\n o References to other man pages should use the {{man name section}}\n expression. For example, {{man \"mdman\" 1}} will generate a reference\n to the mdman(1) man page. For non-troff output, the --man option will\n tell mdman how to create links to the man page. If there is no\n matching --man option, then it links to a file named name.md in the\n same directory.\n\n o Variables can be set with {{*set name=\"value\"}}. These variables can\n then be referenced with {{name}} expressions.\n\n o Partial templates should be placed in a directory named includes next\n to the source file. Templates can be included with an expression like\n {{> template-name}}.\n\n o Other helpers include:\n\n o {{lower value}} Converts the given value to lowercase.\n\nOPTIONS\n -t type\n Specifies the output type. The following output types are supported:\n\n o man ā€” A troff-style man page. Outputs with a numbered extension\n (like .1) matching the man page section.\n\n o md ā€” A markdown file, after all handlebars processing has been\n finished. Outputs with the .md extension.\n\n o txt ā€” A text file, rendered for situations where a man page\n viewer isnā€™t available. Outputs with the .txt extension.\n\n -o outdir\n Specifies the directory where to save the output.\n\n --url base_url\n Specifies a base URL to use for relative URLs within the document.\n Any relative URL will be joined with this URL.\n\n --man name:section=url\n Specifies a URL to use for the given man page. When the {{man name\n section}} expression is used, the given URL will be inserted as a\n link. This may be specified multiple times. If a man page reference\n does not have a matching --man entry, then a relative link to a file\n named name.md will be used.\n\n sourcesā€¦\n The source input filename, may be specified multiple times.\n\nEXAMPLES\n 1. Convert the given documents to man pages:\n\n mdman -t man -o doc doc/mdman.md\n\n" }, { "path": "crates/mdman/src/format/man.rs", "content": "//! Man-page formatter.\n\nuse crate::EventIter;\nuse crate::util::{header_text, parse_name_and_section};\nuse anyhow::{Error, bail};\nuse pulldown_cmark::{Alignment, Event, HeadingLevel, LinkType, Tag, TagEnd};\nuse std::fmt::Write;\nuse url::Url;\n\npub struct ManFormatter {\n url: Option,\n}\n\nimpl ManFormatter {\n pub fn new(url: Option) -> ManFormatter {\n ManFormatter { url }\n }\n}\n\nimpl super::Formatter for ManFormatter {\n fn render(&self, input: &str) -> Result {\n ManRenderer::render(input, self.url.clone())\n }\n\n fn render_options_start(&self) -> &'static str {\n // Tell pulldown_cmark to ignore this.\n // This will be stripped out later.\n \" &'static str {\n \"]]>\"\n }\n\n fn render_option(\n &self,\n params: &[&str],\n block: &str,\n _man_name: &str,\n ) -> Result {\n let rendered_options = params\n .iter()\n .map(|param| {\n let r = self.render(param)?;\n Ok(r.trim().trim_start_matches(\".sp\").to_string())\n })\n .collect::, Error>>()?;\n let rendered_block = self.render(block)?;\n let rendered_block = rendered_block.trim().trim_start_matches(\".sp\").trim();\n // .RS = move left margin to right 4.\n // .RE = move margin back one level.\n Ok(format!(\n \"\\n.sp\\n{}\\n.RS 4\\n{}\\n.RE\\n\",\n rendered_options.join(\", \"),\n rendered_block\n ))\n }\n\n fn linkify_man_to_md(&self, name: &str, section: u8) -> Result {\n Ok(format!(\"`{}`({})\", name, section))\n }\n}\n\n#[derive(Copy, Clone)]\nenum Font {\n Bold,\n Italic,\n}\n\nimpl Font {\n fn str_from_stack(font_stack: &[Font]) -> &'static str {\n let has_bold = font_stack.iter().any(|font| matches!(font, Font::Bold));\n let has_italic = font_stack.iter().any(|font| matches!(font, Font::Italic));\n match (has_bold, has_italic) {\n (false, false) => \"\\\\fR\", // roman (normal)\n (false, true) => \"\\\\fI\", // italic\n (true, false) => \"\\\\fB\", // bold\n (true, true) => \"\\\\f(BI\", // bold italic\n }\n }\n}\n\nstruct ManRenderer<'e> {\n output: String,\n parser: EventIter<'e>,\n font_stack: Vec,\n}\n\nimpl<'e> ManRenderer<'e> {\n fn render(input: &str, url: Option) -> Result {\n let parser = crate::md_parser(input, url);\n let output = String::with_capacity(input.len() * 3 / 2);\n let mut mr = ManRenderer {\n parser,\n output,\n font_stack: Vec::new(),\n };\n mr.push_man()?;\n Ok(mr.output)\n }\n\n fn push_man(&mut self) -> Result<(), Error> {\n // If this is true, this is inside a cdata block used for hiding\n // content from pulldown_cmark.\n let mut in_cdata = false;\n // The current list stack. None if unordered, Some if ordered with the\n // given number as the current index.\n let mut list: Vec> = Vec::new();\n // Used in some cases where spacing isn't desired.\n let mut suppress_paragraph = false;\n let mut table_cell_index = 0;\n\n let mut last_seen_link_data = None;\n while let Some((event, range)) = self.parser.next() {\n let this_suppress_paragraph = suppress_paragraph;\n suppress_paragraph = false;\n match event {\n Event::Start(tag) => {\n match tag {\n Tag::Paragraph => {\n if !this_suppress_paragraph {\n self.flush();\n self.output.push_str(\".sp\\n\");\n }\n }\n Tag::Heading { level, .. } => {\n if level == HeadingLevel::H1 {\n self.push_top_header()?;\n } else if level == HeadingLevel::H2 {\n // Section header\n let text = header_text(&mut self.parser)?;\n self.flush();\n write!(self.output, \".SH \\\"{}\\\"\\n\", text)?;\n suppress_paragraph = true;\n } else {\n // Subsection header\n let text = header_text(&mut self.parser)?;\n self.flush();\n write!(self.output, \".SS \\\"{}\\\"\\n\", text)?;\n suppress_paragraph = true;\n }\n }\n Tag::BlockQuote(..) => {\n self.flush();\n // .RS = move left margin over 3\n // .ll = shrink line length\n self.output.push_str(\".RS 3\\n.ll -5\\n.sp\\n\");\n suppress_paragraph = true;\n }\n Tag::CodeBlock(_kind) => {\n // space down, indent 4, no-fill mode\n self.flush();\n self.output.push_str(\".sp\\n.RS 4\\n.nf\\n\");\n }\n Tag::List(start) => list.push(start),\n Tag::Item => {\n // Note: This uses explicit movement instead of .IP\n // because the spacing on .IP looks weird to me.\n // space down, indent 4\n self.flush();\n self.output.push_str(\".sp\\n.RS 4\\n\");\n match list.last_mut().expect(\"item must have list start\") {\n // Ordered list.\n Some(n) => {\n // move left 4, output the list index number, move right 1.\n write!(self.output, \"\\\\h'-04' {}.\\\\h'+01'\", n)?;\n *n += 1;\n }\n // Unordered list.\n None => self.output.push_str(\"\\\\h'-04'\\\\(bu\\\\h'+03'\"),\n }\n suppress_paragraph = true;\n }\n Tag::FootnoteDefinition(_label) => unimplemented!(),\n Tag::Table(alignment) => {\n // Table start\n // allbox = draw a box around all the cells\n // tab(:) = Use `:` to separate cell data (instead of tab)\n // ; = end of options\n self.output.push_str(\n \"\\n.TS\\n\\\n allbox tab(:);\\n\",\n );\n let alignments: Vec<_> = alignment\n .iter()\n .map(|a| match a {\n Alignment::Left | Alignment::None => \"lt\",\n Alignment::Center => \"ct\",\n Alignment::Right => \"rt\",\n })\n .collect();\n self.output.push_str(&alignments.join(\" \"));\n self.output.push_str(\".\\n\");\n table_cell_index = 0;\n }\n Tag::TableHead => {\n table_cell_index = 0;\n }\n Tag::TableRow => {\n table_cell_index = 0;\n self.output.push('\\n');\n }\n Tag::TableCell => {\n if table_cell_index != 0 {\n // Separator between columns.\n self.output.push(':');\n }\n // Start a text block.\n self.output.push_str(\"T{\\n\");\n table_cell_index += 1\n }\n Tag::Emphasis => self.push_font(Font::Italic),\n Tag::Strong => self.push_font(Font::Bold),\n // Strikethrough isn't usually supported for TTY.\n Tag::Strikethrough => self.output.push_str(\"~~\"),\n Tag::Link {\n link_type,\n dest_url,\n ..\n } => {\n last_seen_link_data = Some((link_type.clone(), dest_url.to_owned()));\n if dest_url.starts_with('#') {\n // In a man page, page-relative anchors don't\n // have much meaning.\n continue;\n }\n match link_type {\n LinkType::Autolink | LinkType::Email => {\n // The text is a copy of the URL, which is not needed.\n match self.parser.next() {\n Some((Event::Text(_), _range)) => {}\n _ => bail!(\"expected text after autolink\"),\n }\n }\n LinkType::Inline\n | LinkType::Reference\n | LinkType::Collapsed\n | LinkType::Shortcut => {\n self.push_font(Font::Italic);\n }\n // This is currently unused. This is only\n // emitted with a broken link callback, but I\n // felt it is too annoying to escape `[` in\n // option descriptions.\n LinkType::ReferenceUnknown\n | LinkType::CollapsedUnknown\n | LinkType::ShortcutUnknown => {\n bail!(\n \"link with missing reference `{}` located at offset {}\",\n dest_url,\n range.start\n );\n }\n LinkType::WikiLink { .. } => {\n panic!(\"wikilink unsupported\");\n }\n }\n }\n Tag::Image { .. } => {\n bail!(\"images are not currently supported\")\n }\n Tag::HtmlBlock { .. }\n | Tag::MetadataBlock { .. }\n | Tag::DefinitionList\n | Tag::DefinitionListTitle\n | Tag::DefinitionListDefinition\n | Tag::Superscript\n | Tag::Subscript => {}\n }\n }\n Event::End(tag_end) => {\n match &tag_end {\n TagEnd::Paragraph => self.flush(),\n TagEnd::Heading(..) => {}\n TagEnd::BlockQuote(..) => {\n self.flush();\n // restore left margin, restore line length\n self.output.push_str(\".br\\n.RE\\n.ll\\n\");\n }\n TagEnd::CodeBlock => {\n self.flush();\n // Restore fill mode, move margin back one level.\n self.output.push_str(\".fi\\n.RE\\n\");\n }\n TagEnd::List(_) => {\n list.pop();\n }\n TagEnd::Item => {\n self.flush();\n // Move margin back one level.\n self.output.push_str(\".RE\\n\");\n }\n TagEnd::FootnoteDefinition => {}\n TagEnd::Table => {\n // Table end\n // I don't know why, but the .sp is needed to provide\n // space with the following content.\n self.output.push_str(\"\\n.TE\\n.sp\\n\");\n }\n TagEnd::TableHead => {}\n TagEnd::TableRow => {}\n TagEnd::TableCell => {\n // End text block.\n self.output.push_str(\"\\nT}\");\n }\n TagEnd::Emphasis | TagEnd::Strong => self.pop_font(),\n TagEnd::Strikethrough => self.output.push_str(\"~~\"),\n TagEnd::Link => {\n if let Some((link_type, ref dest_url)) = last_seen_link_data {\n if dest_url.starts_with('#') {\n continue;\n }\n match link_type {\n LinkType::Autolink | LinkType::Email => {}\n LinkType::Inline\n | LinkType::Reference\n | LinkType::Collapsed\n | LinkType::Shortcut => {\n self.pop_font();\n self.output.push(' ');\n }\n _ => {\n panic!(\"unexpected tag {:?}\", tag_end);\n }\n }\n write!(self.output, \"<{}>\", escape(&dest_url)?)?;\n }\n }\n TagEnd::Image\n | TagEnd::HtmlBlock\n | TagEnd::MetadataBlock(..)\n | TagEnd::DefinitionListDefinition\n | TagEnd::DefinitionListTitle\n | TagEnd::DefinitionList\n | TagEnd::Superscript\n | TagEnd::Subscript => {}\n }\n }\n Event::Text(t) => {\n self.output.push_str(&escape(&t)?);\n }\n Event::Code(t) => {\n self.push_font(Font::Bold);\n self.output.push_str(&escape(&t)?);\n self.pop_font();\n }\n Event::Html(t) => {\n if t.starts_with(\"\") {\n in_cdata = false;\n } else if !t.trim().is_empty() {\n self.output.push_str(&t);\n }\n } else {\n self.output.push_str(&escape(&t)?);\n }\n }\n Event::FootnoteReference(_t) => {}\n Event::SoftBreak => self.output.push('\\n'),\n Event::HardBreak => {\n self.flush();\n self.output.push_str(\".br\\n\");\n }\n Event::Rule => {\n self.flush();\n // \\l' **length** ' Draw horizontal line (default underscore).\n // \\n(.lu Gets value from register \"lu\" (current line length)\n self.output.push_str(\"\\\\l'\\\\n(.lu'\\n\");\n }\n Event::TaskListMarker(_b) => unimplemented!(),\n Event::InlineHtml(..) => unimplemented!(),\n Event::InlineMath(..) => unimplemented!(),\n Event::DisplayMath(..) => unimplemented!(),\n }\n }\n Ok(())\n }\n\n fn flush(&mut self) {\n if !self.output.ends_with('\\n') {\n self.output.push('\\n');\n }\n }\n\n /// Switch to the given font.\n ///\n /// Because the troff sequence `\\fP` for switching to the \"previous\" font\n /// doesn't support nesting, this needs to emulate it here. This is needed\n /// for situations like **hi _there_**.\n fn push_font(&mut self, font: Font) {\n self.font_stack.push(font);\n self.output.push_str(Font::str_from_stack(&self.font_stack));\n }\n\n fn pop_font(&mut self) {\n self.font_stack.pop();\n self.output.push_str(Font::str_from_stack(&self.font_stack));\n }\n\n /// Parse and render the first top-level header of the document.\n fn push_top_header(&mut self) -> Result<(), Error> {\n // This enables the tbl preprocessor for tables.\n // This seems to be enabled by default on every modern system I could\n // find, but it doesn't seem to hurt to enable this.\n self.output.push_str(\"'\\\\\\\" t\\n\");\n // Extract the name of the man page.\n let text = header_text(&mut self.parser)?;\n let (name, section) = parse_name_and_section(&text)?;\n // .TH = Table header\n // .nh = disable hyphenation\n // .ad l = Left-adjust mode (disable justified).\n // .ss sets sentence_space_size to 0 (prevents double spaces after .\n // if . is last on the line)\n write!(\n self.output,\n \".TH \\\"{}\\\" \\\"{}\\\"\\n\\\n .nh\\n\\\n .ad l\\n\\\n .ss \\\\n[.ss] 0\\n\",\n escape(&name.to_uppercase())?,\n section\n )?;\n Ok(())\n }\n}\n\n#[allow(clippy::collapsible_str_replace)]\nfn escape(s: &str) -> Result {\n // Note: Possible source on output escape sequences: https://man7.org/linux/man-pages/man7/groff_char.7.html.\n // Otherwise, use generic escaping in the form `\\[u1EE7]` or `\\[u1F994]`.\n\n let mut replaced = s\n .replace('\\\\', \"\\\\(rs\")\n .replace('-', \"\\\\-\")\n .replace('\\u{00A0}', \"\\\\ \") // non-breaking space (non-stretchable)\n .replace('ā€“', \"\\\\[en]\") // \\u{2013} en-dash\n .replace('ā€”', \"\\\\[em]\") // \\u{2014} em-dash\n .replace('ā€˜', \"\\\\[oq]\") // \\u{2018} left single quote\n .replace('ā€™', \"\\\\[cq]\") // \\u{2019} right single quote or apostrophe\n .replace('ā€œ', \"\\\\[lq]\") // \\u{201C} left double quote\n .replace('ā€', \"\\\\[rq]\") // \\u{201D} right double quote\n .replace('ā€¦', \"\\\\[u2026]\") // \\u{2026} ellipsis\n .replace('ā”‚', \"|\") // \\u{2502} box drawing light vertical (could use \\[br])\n .replace('ā”œ', \"|\") // \\u{251C} box drawings light vertical and right\n .replace('ā””', \"`\") // \\u{2514} box drawings light up and right\n .replace('ā”€', \"\\\\-\") // \\u{2500} box drawing light horizontal\n ;\n if replaced.starts_with('.') {\n replaced = format!(\"\\\\&.{}\", &replaced[1..]);\n }\n\n if let Some(ch) = replaced.chars().find(|ch| {\n !matches!(ch, '\\n' | ' ' | '!'..='/' | '0'..='9'\n | ':'..='@' | 'A'..='Z' | '['..='`' | 'a'..='z' | '{'..='~')\n }) {\n bail!(\n \"character {:?} is not allowed (update the translation table if needed)\",\n ch\n );\n }\n Ok(replaced)\n}\n" }, { "path": "crates/mdman/src/format/md.rs", "content": "//! Markdown formatter.\n\nuse crate::ManMap;\nuse crate::util::unwrap;\nuse anyhow::{Error, bail, format_err};\nuse std::fmt::Write;\n\npub struct MdFormatter {\n man_map: ManMap,\n}\n\nimpl MdFormatter {\n pub fn new(man_map: ManMap) -> MdFormatter {\n MdFormatter { man_map }\n }\n}\n\nimpl MdFormatter {\n fn render_html(&self, input: &str) -> Result {\n let parser = crate::md_parser(input, None);\n let mut html_output: String = String::with_capacity(input.len() * 3 / 2);\n pulldown_cmark::html::push_html(&mut html_output, parser.map(|(e, _r)| e));\n Ok(html_output)\n }\n}\n\nimpl super::Formatter for MdFormatter {\n fn render(&self, input: &str) -> Result {\n Ok(input.replace(\"\\r\\n\", \"\\n\"))\n }\n\n fn render_options_start(&self) -> &'static str {\n \"
\\n\"\n }\n\n fn render_options_end(&self) -> &'static str {\n \"
\\n\"\n }\n\n fn render_option(&self, params: &[&str], block: &str, man_name: &str) -> Result {\n let mut result = String::new();\n fn unwrap_p(t: &str) -> &str {\n unwrap(t, \"

\", \"

\")\n }\n\n for param in params {\n let rendered = self.render_html(param)?;\n let no_p = unwrap_p(&rendered);\n // split out first term to use as the id.\n let first = no_p\n .split_whitespace()\n .next()\n .ok_or_else(|| format_err!(\"did not expect option `{}` to be empty\", param))?;\n let no_tags = trim_tags(first);\n if no_tags.is_empty() {\n bail!(\"unexpected empty option with no tags `{}`\", param);\n }\n let id = format!(\"option-{}-{}\", man_name, no_tags);\n write!(\n result,\n \"
\\\n {no_p}
\\n\",\n )?;\n }\n let rendered_block = self.render_html(block)?;\n write!(\n result,\n \"
{rendered_block}
\\n\\n\",\n )?;\n Ok(result)\n }\n\n fn linkify_man_to_md(&self, name: &str, section: u8) -> Result {\n let s = match self.man_map.get(&(name.to_string(), section)) {\n Some(link) => format!(\"[{}({})]({})\", name, section, link),\n None => format!(\"[{}({})]({}.html)\", name, section, name),\n };\n Ok(s)\n }\n}\n\nfn trim_tags(s: &str) -> String {\n // This is a hack. It removes all HTML tags.\n let mut in_tag = false;\n let mut in_char_ref = false;\n s.chars()\n .filter(|&ch| match ch {\n '<' if in_tag => panic!(\"unexpected nested tag\"),\n '&' if in_char_ref => panic!(\"unexpected nested char ref\"),\n '<' => {\n in_tag = true;\n false\n }\n '&' => {\n in_char_ref = true;\n false\n }\n '>' if in_tag => {\n in_tag = false;\n false\n }\n ';' if in_char_ref => {\n in_char_ref = false;\n false\n }\n _ => !in_tag && !in_char_ref,\n })\n .collect()\n}\n" }, { "path": "crates/mdman/src/format/mod.rs", "content": "use anyhow::Error;\n\npub mod man;\npub mod md;\npub mod text;\n\npub trait Formatter {\n /// Renders the given markdown to the formatter's output.\n fn render(&self, input: &str) -> Result;\n /// Renders the start of a block of options (triggered by `{{#options}}`).\n fn render_options_start(&self) -> &'static str;\n /// Renders the end of a block of options (triggered by `{{/options}}`).\n fn render_options_end(&self) -> &'static str;\n /// Renders an option (triggered by `{{#option}}`).\n fn render_option(&self, params: &[&str], block: &str, man_name: &str) -> Result;\n /// Converts a man page reference into markdown that is appropriate for this format.\n ///\n /// Triggered by `{{man name section}}`.\n fn linkify_man_to_md(&self, name: &str, section: u8) -> Result;\n}\n" }, { "path": "crates/mdman/src/format/text.rs", "content": "//! Text formatter.\n\nuse crate::EventIter;\nuse crate::util::{header_text, unwrap};\nuse anyhow::{Error, bail};\nuse pulldown_cmark::{Alignment, Event, HeadingLevel, LinkType, Tag, TagEnd};\nuse std::fmt::Write;\nuse std::mem;\nuse url::Url;\n\npub struct TextFormatter {\n url: Option,\n}\n\nimpl TextFormatter {\n pub fn new(url: Option) -> TextFormatter {\n TextFormatter { url }\n }\n}\n\nimpl super::Formatter for TextFormatter {\n fn render(&self, input: &str) -> Result {\n TextRenderer::render(input, self.url.clone(), 0)\n }\n\n fn render_options_start(&self) -> &'static str {\n // Tell pulldown_cmark to ignore this.\n // This will be stripped out later.\n \" &'static str {\n \"]]>\\n\"\n }\n\n fn render_option(\n &self,\n params: &[&str],\n block: &str,\n _man_name: &str,\n ) -> Result {\n let rendered_options = params\n .iter()\n .map(|param| TextRenderer::render(param, self.url.clone(), 0))\n .collect::, Error>>()?;\n let trimmed: Vec<_> = rendered_options.iter().map(|o| o.trim()).collect();\n // Wrap in HTML tags, they will be stripped out during rendering.\n Ok(format!(\n \"
{}
\\n
\\n{}
\\n
\\n\",\n trimmed.join(\", \"),\n block\n ))\n }\n\n fn linkify_man_to_md(&self, name: &str, section: u8) -> Result {\n Ok(format!(\"`{}`({})\", name, section))\n }\n}\n\nstruct TextRenderer<'e> {\n output: String,\n indent: usize,\n /// The current line being written. Once a line break is encountered (such\n /// as starting a new paragraph), this will be written to `output` via\n /// `flush`.\n line: String,\n /// The current word being written. Once a break is encountered (such as a\n /// space) this will be written to `line` via `flush_word`.\n word: String,\n parser: EventIter<'e>,\n /// The base URL used for relative URLs.\n url: Option,\n table: Table,\n}\n\nimpl<'e> TextRenderer<'e> {\n fn render(input: &str, url: Option, indent: usize) -> Result {\n let parser = crate::md_parser(input, url.clone());\n let output = String::with_capacity(input.len() * 3 / 2);\n let mut mr = TextRenderer {\n output,\n indent,\n line: String::new(),\n word: String::new(),\n parser,\n url,\n table: Table::new(),\n };\n mr.push_md()?;\n Ok(mr.output)\n }\n\n fn push_md(&mut self) -> Result<(), Error> {\n // If this is true, this is inside a cdata block used for hiding\n // content from pulldown_cmark.\n let mut in_cdata = false;\n // The current list stack. None if unordered, Some if ordered with the\n // given number as the current index.\n let mut list: Vec> = Vec::new();\n // Used in some cases where spacing isn't desired.\n let mut suppress_paragraph = false;\n // Whether or not word-wrapping is enabled.\n let mut wrap_text = true;\n\n let mut last_seen_link_data = None;\n while let Some((event, range)) = self.parser.next() {\n let this_suppress_paragraph = suppress_paragraph;\n // Always reset suppression, even if the next event isn't a\n // paragraph. This is in essence, a 1-token lookahead where the\n // suppression is only enabled if the next event is a paragraph.\n suppress_paragraph = false;\n match event {\n Event::Start(tag) => {\n match tag {\n Tag::Paragraph => {\n if !this_suppress_paragraph {\n self.flush();\n }\n }\n Tag::Heading { level, .. } => {\n self.flush();\n if level == HeadingLevel::H1 {\n let text = header_text(&mut self.parser)?;\n self.push_to_line(&text.to_uppercase());\n self.hard_break();\n self.hard_break();\n } else if level == HeadingLevel::H2 {\n let text = header_text(&mut self.parser)?;\n self.push_to_line(&text.to_uppercase());\n self.flush();\n self.indent = 7;\n } else {\n let text = header_text(&mut self.parser)?;\n self.push_indent((level as usize - 2) * 3);\n self.push_to_line(&text);\n self.flush();\n self.indent = (level as usize - 1) * 3 + 1;\n }\n }\n Tag::BlockQuote(_kind) => {\n self.indent += 3;\n }\n Tag::CodeBlock(_kind) => {\n self.flush();\n wrap_text = false;\n self.indent += 4;\n }\n Tag::List(start) => list.push(start),\n Tag::Item => {\n self.flush();\n match list.last_mut().expect(\"item must have list start\") {\n // Ordered list.\n Some(n) => {\n self.push_indent(self.indent);\n write!(self.line, \"{}.\", n)?;\n *n += 1;\n }\n // Unordered list.\n None => {\n self.push_indent(self.indent);\n self.push_to_line(\"o \")\n }\n }\n self.indent += 3;\n suppress_paragraph = true;\n }\n Tag::FootnoteDefinition(_label) => unimplemented!(),\n Tag::Table(alignment) => {\n assert!(self.table.alignment.is_empty());\n self.flush();\n self.table.alignment.extend(alignment);\n let table = self.table.process(&mut self.parser, self.indent)?;\n self.output.push_str(&table);\n self.hard_break();\n self.table = Table::new();\n }\n Tag::TableHead | Tag::TableRow | Tag::TableCell => {\n bail!(\"unexpected table element\")\n }\n Tag::Emphasis => {}\n Tag::Strong => {}\n // Strikethrough isn't usually supported for TTY.\n Tag::Strikethrough => self.word.push_str(\"~~\"),\n Tag::Link {\n link_type,\n dest_url,\n ..\n } => {\n last_seen_link_data = Some((link_type.clone(), dest_url.to_owned()));\n if dest_url.starts_with('#') {\n // In a man page, page-relative anchors don't\n // have much meaning.\n continue;\n }\n match link_type {\n LinkType::Autolink | LinkType::Email => {\n // The text is a copy of the URL, which is not needed.\n match self.parser.next() {\n Some((Event::Text(_), _range)) => {}\n _ => bail!(\"expected text after autolink\"),\n }\n }\n LinkType::Inline\n | LinkType::Reference\n | LinkType::Collapsed\n | LinkType::Shortcut => {}\n // This is currently unused. This is only\n // emitted with a broken link callback, but I\n // felt it is too annoying to escape `[` in\n // option descriptions.\n LinkType::ReferenceUnknown\n | LinkType::CollapsedUnknown\n | LinkType::ShortcutUnknown => {\n bail!(\n \"link with missing reference `{}` located at offset {}\",\n dest_url,\n range.start\n );\n }\n LinkType::WikiLink { .. } => {\n panic!(\"wikilink unsupported\");\n }\n }\n }\n Tag::Image { .. } => {\n bail!(\"images are not currently supported\")\n }\n Tag::HtmlBlock { .. }\n | Tag::MetadataBlock { .. }\n | Tag::DefinitionList\n | Tag::DefinitionListTitle\n | Tag::DefinitionListDefinition\n | Tag::Superscript\n | Tag::Subscript => {}\n }\n }\n Event::End(tag_end) => match &tag_end {\n TagEnd::Paragraph => {\n self.flush();\n self.hard_break();\n }\n TagEnd::Heading(..) => {}\n TagEnd::BlockQuote(..) => {\n self.indent -= 3;\n }\n TagEnd::CodeBlock => {\n self.hard_break();\n wrap_text = true;\n self.indent -= 4;\n }\n TagEnd::List(..) => {\n list.pop();\n }\n TagEnd::Item => {\n self.flush();\n self.indent -= 3;\n self.hard_break();\n }\n TagEnd::FootnoteDefinition => {}\n TagEnd::Table => {}\n TagEnd::TableHead => {}\n TagEnd::TableRow => {}\n TagEnd::TableCell => {}\n TagEnd::Emphasis => {}\n TagEnd::Strong => {}\n TagEnd::Strikethrough => self.word.push_str(\"~~\"),\n TagEnd::Link => {\n if let Some((link_type, ref dest_url)) = last_seen_link_data {\n if dest_url.starts_with('#') {\n continue;\n }\n match link_type {\n LinkType::Autolink | LinkType::Email => {}\n LinkType::Inline\n | LinkType::Reference\n | LinkType::Collapsed\n | LinkType::Shortcut => self.flush_word(),\n _ => {\n panic!(\"unexpected tag {:?}\", tag_end);\n }\n }\n self.flush_word();\n write!(self.word, \"<{}>\", dest_url)?;\n }\n }\n TagEnd::HtmlBlock { .. }\n | TagEnd::MetadataBlock { .. }\n | TagEnd::DefinitionList\n | TagEnd::DefinitionListTitle\n | TagEnd::Image\n | TagEnd::DefinitionListDefinition\n | TagEnd::Superscript\n | TagEnd::Subscript => {}\n },\n Event::Text(t) | Event::Code(t) => {\n if wrap_text {\n let chunks = split_chunks(&t);\n for chunk in chunks {\n if chunk == \" \" {\n self.flush_word();\n } else {\n self.word.push_str(chunk);\n }\n }\n } else {\n for line in t.lines() {\n self.push_indent(self.indent);\n self.push_to_line(line);\n self.flush();\n }\n }\n }\n Event::Html(t) => {\n if t.starts_with(\"\") {\n in_cdata = false;\n } else {\n let trimmed = t.trim();\n if trimmed.is_empty() {\n continue;\n }\n if trimmed == \"
\" {\n self.hard_break();\n } else if trimmed.starts_with(\"
\") {\n let opts = unwrap(trimmed, \"
\", \"
\");\n self.push_indent(self.indent);\n self.push_to_line(opts);\n self.flush();\n } else if trimmed.starts_with(\"
\") {\n let mut def = String::new();\n while let Some((Event::Html(t), _range)) = self.parser.next() {\n if t.starts_with(\"
\") {\n break;\n }\n def.push_str(&t);\n }\n let rendered =\n TextRenderer::render(&def, self.url.clone(), self.indent + 4)?;\n self.push_to_line(rendered.trim_end());\n self.flush();\n } else {\n self.push_to_line(&t);\n self.flush();\n }\n }\n } else {\n self.push_to_line(&t);\n self.flush();\n }\n }\n Event::FootnoteReference(_t) => {}\n Event::SoftBreak => self.flush_word(),\n Event::HardBreak => self.flush(),\n Event::Rule => {\n self.flush();\n self.push_indent(self.indent);\n self.push_to_line(&\"_\".repeat(79 - self.indent * 2));\n self.flush();\n }\n Event::TaskListMarker(_b) => unimplemented!(),\n Event::InlineHtml(..) => unimplemented!(),\n Event::InlineMath(..) => unimplemented!(),\n Event::DisplayMath(..) => unimplemented!(),\n }\n }\n Ok(())\n }\n\n fn flush(&mut self) {\n self.flush_word();\n if !self.line.is_empty() {\n self.output.push_str(&self.line);\n self.output.push('\\n');\n self.line.clear();\n }\n }\n\n fn hard_break(&mut self) {\n self.flush();\n if !self.output.ends_with(\"\\n\\n\") {\n self.output.push('\\n');\n }\n }\n\n fn flush_word(&mut self) {\n if self.word.is_empty() {\n return;\n }\n if self.line.len() + self.word.len() >= 79 {\n self.output.push_str(&self.line);\n self.output.push('\\n');\n self.line.clear();\n }\n if self.line.is_empty() {\n self.push_indent(self.indent);\n self.line.push_str(&self.word);\n } else {\n self.line.push(' ');\n self.line.push_str(&self.word);\n }\n self.word.clear();\n }\n\n fn push_indent(&mut self, indent: usize) {\n for _ in 0..indent {\n self.line.push(' ');\n }\n }\n\n fn push_to_line(&mut self, text: &str) {\n self.flush_word();\n self.line.push_str(text);\n }\n}\n\n/// Splits the text on whitespace.\n///\n/// Consecutive whitespace is collapsed to a single ' ', and is included as a\n/// separate element in the result.\nfn split_chunks(text: &str) -> Vec<&str> {\n let mut result = Vec::new();\n let mut start = 0;\n while start < text.len() {\n match text[start..].find(' ') {\n Some(i) => {\n if i != 0 {\n result.push(&text[start..start + i]);\n }\n result.push(\" \");\n // Skip past whitespace.\n match text[start + i..].find(|c| c != ' ') {\n Some(n) => {\n start = start + i + n;\n }\n None => {\n break;\n }\n }\n }\n None => {\n result.push(&text[start..]);\n break;\n }\n }\n }\n result\n}\n\nstruct Table {\n alignment: Vec,\n rows: Vec>,\n row: Vec,\n cell: String,\n}\n\nimpl Table {\n fn new() -> Table {\n Table {\n alignment: Vec::new(),\n rows: Vec::new(),\n row: Vec::new(),\n cell: String::new(),\n }\n }\n\n /// Processes table events and generates a text table.\n fn process(&mut self, parser: &mut EventIter<'_>, indent: usize) -> Result {\n while let Some((event, _range)) = parser.next() {\n match event {\n Event::Start(tag) => match tag {\n Tag::TableHead\n | Tag::TableRow\n | Tag::TableCell\n | Tag::Emphasis\n | Tag::Strong => {}\n Tag::Strikethrough => self.cell.push_str(\"~~\"),\n // Links not yet supported, they usually won't fit.\n Tag::Link { .. } => {}\n _ => bail!(\"unexpected tag in table: {:?}\", tag),\n },\n Event::End(tag_end) => match tag_end {\n TagEnd::Table => return self.render(indent),\n TagEnd::TableCell => {\n let cell = mem::replace(&mut self.cell, String::new());\n self.row.push(cell);\n }\n TagEnd::TableHead | TagEnd::TableRow => {\n let row = mem::replace(&mut self.row, Vec::new());\n self.rows.push(row);\n }\n TagEnd::Strikethrough => self.cell.push_str(\"~~\"),\n _ => {}\n },\n Event::Text(t) | Event::Code(t) => {\n self.cell.push_str(&t);\n }\n Event::Html(t) => bail!(\"html unsupported in tables: {:?}\", t),\n _ => bail!(\"unexpected event in table: {:?}\", event),\n }\n }\n bail!(\"table end not reached\");\n }\n\n fn render(&self, indent: usize) -> Result {\n // This is an extremely primitive layout routine.\n // First compute the potential maximum width of each cell.\n // 2 for 1 space margin on left and right.\n let width_acc = vec![2; self.alignment.len()];\n let mut col_widths = self\n .rows\n .iter()\n .map(|row| row.iter().map(|cell| cell.len()))\n .fold(width_acc, |mut acc, row| {\n acc.iter_mut()\n .zip(row)\n // +3 for left/right margin and | symbol\n .for_each(|(a, b)| *a = (*a).max(b + 3));\n acc\n });\n // Shrink each column until it fits the total width, proportional to\n // the columns total percent width.\n let max_width = 78 - indent;\n // Include total len for | characters, and +1 for final |.\n let total_width = col_widths.iter().sum::() + col_widths.len() + 1;\n if total_width > max_width {\n let to_shrink = total_width - max_width;\n // Compute percentage widths, and shrink each column based on its\n // total percentage.\n for width in &mut col_widths {\n let percent = *width as f64 / total_width as f64;\n *width -= (to_shrink as f64 * percent).ceil() as usize;\n }\n }\n // Start rendering.\n let mut result = String::new();\n\n // Draw the horizontal line separating each row.\n let mut row_line = String::new();\n row_line.push_str(&\" \".repeat(indent));\n row_line.push('+');\n let lines = col_widths\n .iter()\n .map(|width| \"-\".repeat(*width))\n .collect::>();\n row_line.push_str(&lines.join(\"+\"));\n row_line.push('+');\n row_line.push('\\n');\n\n // Draw top of the table.\n result.push_str(&row_line);\n // Draw each row.\n for row in &self.rows {\n // Word-wrap and fill each column as needed.\n let filled = fill_row(row, &col_widths, &self.alignment);\n // Need to transpose the cells across rows for cells that span\n // multiple rows.\n let height = filled.iter().map(|c| c.len()).max().unwrap();\n for row_i in 0..height {\n result.push_str(&\" \".repeat(indent));\n result.push('|');\n for filled_row in &filled {\n let cell = &filled_row[row_i];\n result.push_str(cell);\n result.push('|');\n }\n result.push('\\n');\n }\n result.push_str(&row_line);\n }\n Ok(result)\n }\n}\n\n/// Formats a row, filling cells with spaces and word-wrapping text.\n///\n/// Returns a vec of cells, where each cell is split into multiple lines.\nfn fill_row(row: &[String], col_widths: &[usize], alignment: &[Alignment]) -> Vec> {\n let mut cell_lines = row\n .iter()\n .zip(col_widths)\n .zip(alignment)\n .map(|((cell, width), alignment)| fill_cell(cell, *width - 2, *alignment))\n .collect::>();\n // Fill each cell to match the maximum vertical height of the tallest cell.\n let max_lines = cell_lines.iter().map(|cell| cell.len()).max().unwrap();\n for (cell, width) in cell_lines.iter_mut().zip(col_widths) {\n if cell.len() < max_lines {\n cell.extend(std::iter::repeat(\" \".repeat(*width)).take(max_lines - cell.len()));\n }\n }\n cell_lines\n}\n\n/// Formats a cell. Word-wraps based on width, and adjusts based on alignment.\n///\n/// Returns a vec of lines for the cell.\nfn fill_cell(text: &str, width: usize, alignment: Alignment) -> Vec {\n let fill_width = |text: &str| match alignment {\n Alignment::None | Alignment::Left => format!(\" {: format!(\" {:^width$} \", text, width = width),\n Alignment::Right => format!(\" {:>width$} \", text, width = width),\n };\n if text.len() < width {\n // No wrapping necessary, just format.\n vec![fill_width(text)]\n } else {\n // Word-wrap the cell.\n let mut result = Vec::new();\n let mut line = String::new();\n for word in text.split_whitespace() {\n if line.len() + word.len() >= width {\n // todo: word.len() > width\n result.push(fill_width(&line));\n line.clear();\n }\n if line.is_empty() {\n line.push_str(word);\n } else {\n line.push(' ');\n line.push_str(&word);\n }\n }\n if !line.is_empty() {\n result.push(fill_width(&line));\n }\n\n result\n }\n}\n" }, { "path": "crates/mdman/src/hbs.rs", "content": "//! Handlebars template processing.\n\nuse std::collections::HashMap;\nuse std::path::Path;\n\nuse anyhow::Error;\nuse handlebars::{\n Context, Decorator, DirectorySourceOptions, Handlebars, Helper, HelperDef, HelperResult,\n Output, RenderContext, RenderError, RenderErrorReason, Renderable, handlebars_helper,\n};\n\nuse crate::format::Formatter;\n\ntype FormatterRef<'a> = &'a (dyn Formatter + Send + Sync);\n\n/// Processes the handlebars template at the given file.\npub fn expand(file: &Path, formatter: FormatterRef<'_>) -> Result {\n let mut handlebars = Handlebars::new();\n handlebars.set_strict_mode(true);\n handlebars.register_helper(\"lower\", Box::new(lower));\n handlebars.register_helper(\"options\", Box::new(OptionsHelper { formatter }));\n handlebars.register_helper(\"option\", Box::new(OptionHelper { formatter }));\n handlebars.register_helper(\"man\", Box::new(ManLinkHelper { formatter }));\n handlebars.register_decorator(\"set\", Box::new(set_decorator));\n handlebars.register_template_file(\"template\", file)?;\n let includes = file.parent().unwrap().join(\"includes\");\n let mut options = DirectorySourceOptions::default();\n options.tpl_extension = \".md\".to_string();\n handlebars.register_templates_directory(includes, options)?;\n let man_name = file\n .file_stem()\n .expect(\"expected filename\")\n .to_str()\n .expect(\"utf8 filename\")\n .to_string();\n let data = HashMap::from([(\"man_name\", man_name)]);\n let expanded = handlebars.render(\"template\", &data)?;\n Ok(expanded)\n}\n\n/// Helper for `{{#options}}` block.\nstruct OptionsHelper<'a> {\n formatter: FormatterRef<'a>,\n}\n\nimpl HelperDef for OptionsHelper<'_> {\n fn call<'reg: 'rc, 'rc>(\n &self,\n h: &Helper<'rc>,\n r: &'reg Handlebars<'reg>,\n ctx: &'rc Context,\n rc: &mut RenderContext<'reg, 'rc>,\n out: &mut dyn Output,\n ) -> HelperResult {\n if in_options(rc) {\n return Err(\n RenderErrorReason::Other(\"options blocks cannot be nested\".to_string()).into(),\n );\n }\n // Prevent nested {{#options}}.\n set_in_context(rc, \"__MDMAN_IN_OPTIONS\", serde_json::Value::Bool(true));\n let s = self.formatter.render_options_start();\n out.write(&s)?;\n let t = match h.template() {\n Some(t) => t,\n None => {\n return Err(RenderErrorReason::Other(\n \"options block must not be empty\".to_string(),\n )\n .into());\n }\n };\n let block = t.renders(r, ctx, rc)?;\n out.write(&block)?;\n\n let s = self.formatter.render_options_end();\n out.write(&s)?;\n remove_from_context(rc, \"__MDMAN_IN_OPTIONS\");\n Ok(())\n }\n}\n\n/// Whether or not the context is currently inside a `{{#options}}` block.\nfn in_options(rc: &RenderContext<'_, '_>) -> bool {\n rc.context()\n .map_or(false, |ctx| ctx.data().get(\"__MDMAN_IN_OPTIONS\").is_some())\n}\n\n/// Helper for `{{#option}}` block.\nstruct OptionHelper<'a> {\n formatter: FormatterRef<'a>,\n}\n\nimpl HelperDef for OptionHelper<'_> {\n fn call<'reg: 'rc, 'rc>(\n &self,\n h: &Helper<'rc>,\n r: &'reg Handlebars<'reg>,\n gctx: &'rc Context,\n rc: &mut RenderContext<'reg, 'rc>,\n out: &mut dyn Output,\n ) -> HelperResult {\n if !in_options(rc) {\n return Err(\n RenderErrorReason::Other(\"option must be in options block\".to_string()).into(),\n );\n }\n let params = h.params();\n if params.is_empty() {\n return Err(RenderErrorReason::Other(\n \"option block must have at least one param\".to_string(),\n )\n .into());\n }\n // Convert params to strings.\n let params = params\n .iter()\n .map(|param| {\n param\n .value()\n .as_str()\n .ok_or_else(|| {\n RenderErrorReason::Other(\"option params must be strings\".to_string())\n })\n .into()\n })\n .collect::, RenderErrorReason>>()?;\n let t = match h.template() {\n Some(t) => t,\n None => {\n return Err(\n RenderErrorReason::Other(\"option block must not be empty\".to_string()).into(),\n );\n }\n };\n // Render the block.\n let block = t.renders(r, gctx, rc)?;\n\n // Windows newlines can break some rendering, so normalize.\n let block = block.replace(\"\\r\\n\", \"\\n\");\n\n // Get the name of this page.\n let man_name = gctx\n .data()\n .get(\"man_name\")\n .expect(\"expected man_name in context\")\n .as_str()\n .expect(\"expect man_name str\");\n\n // Ask the formatter to convert this option to its format.\n let option = self\n .formatter\n .render_option(¶ms, &block, man_name)\n .map_err(|e| RenderErrorReason::Other(format!(\"option render failed: {}\", e)))?;\n out.write(&option)?;\n Ok(())\n }\n}\n\n/// Helper for `{{man name section}}` expression.\nstruct ManLinkHelper<'a> {\n formatter: FormatterRef<'a>,\n}\n\nimpl HelperDef for ManLinkHelper<'_> {\n fn call<'reg: 'rc, 'rc>(\n &self,\n h: &Helper<'rc>,\n _r: &'reg Handlebars<'reg>,\n _ctx: &'rc Context,\n _rc: &mut RenderContext<'reg, 'rc>,\n out: &mut dyn Output,\n ) -> HelperResult {\n let params = h.params();\n if params.len() != 2 {\n return Err(\n RenderErrorReason::Other(\"{{man}} must have two arguments\".to_string()).into(),\n );\n }\n let name = params[0].value().as_str().ok_or_else(|| {\n RenderErrorReason::Other(\"man link name must be a string\".to_string())\n })?;\n let section = params[1].value().as_u64().ok_or_else(|| {\n RenderErrorReason::Other(\"man link section must be an integer\".to_string())\n })?;\n let section = u8::try_from(section)\n .map_err(|_e| RenderErrorReason::Other(\"section number too large\".to_string()))?;\n let link = self\n .formatter\n .linkify_man_to_md(name, section)\n .map_err(|e| RenderErrorReason::Other(format!(\"failed to linkify man: {}\", e)))?;\n out.write(&link)?;\n Ok(())\n }\n}\n\n/// `{{*set var=value}}` decorator.\n///\n/// This sets a variable to a value within the template context.\nfn set_decorator(\n d: &Decorator<'_>,\n _: &Handlebars<'_>,\n _ctx: &Context,\n rc: &mut RenderContext<'_, '_>,\n) -> Result<(), RenderError> {\n let data_to_set = d.hash();\n for (k, v) in data_to_set {\n set_in_context(rc, k, v.value().clone());\n }\n Ok(())\n}\n\n/// Sets a variable to a value within the context.\nfn set_in_context(rc: &mut RenderContext<'_, '_>, key: &str, value: serde_json::Value) {\n let mut gctx = match rc.context() {\n Some(c) => (*c).clone(),\n None => Context::wraps(serde_json::Value::Object(serde_json::Map::new())).unwrap(),\n };\n if let serde_json::Value::Object(m) = gctx.data_mut() {\n m.insert(key.to_string(), value);\n rc.set_context(gctx);\n } else {\n panic!(\"expected object in context\");\n }\n}\n\n/// Removes a variable from the context.\nfn remove_from_context(rc: &mut RenderContext<'_, '_>, key: &str) {\n let gctx = rc.context().expect(\"cannot remove from null context\");\n let mut gctx = (*gctx).clone();\n if let serde_json::Value::Object(m) = gctx.data_mut() {\n m.remove(key);\n rc.set_context(gctx);\n } else {\n panic!(\"expected object in context\");\n }\n}\n\nhandlebars_helper!(lower: |s: str| s.to_lowercase());\n" }, { "path": "crates/mdman/src/lib.rs", "content": "//! mdman markdown to man converter.\n//!\n//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use (except as a transitive dependency). This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\nuse anyhow::{Context, Error, bail};\nuse pulldown_cmark::{CowStr, Event, LinkType, Options, Parser, Tag, TagEnd};\nuse std::collections::HashMap;\nuse std::fs;\nuse std::io::{self, BufRead};\nuse std::ops::Range;\nuse std::path::Path;\nuse url::Url;\n\nmod format;\nmod hbs;\nmod util;\n\nuse format::Formatter;\n\n/// Mapping of `(name, section)` of a man page to a URL.\npub type ManMap = HashMap<(String, u8), String>;\n\n/// A man section.\npub type Section = u8;\n\n/// The output formats supported by mdman.\n#[derive(Copy, Clone)]\npub enum Format {\n Man,\n Md,\n Text,\n}\n\nimpl Format {\n /// The filename extension for the format.\n pub fn extension(&self, section: Section) -> String {\n match self {\n Format::Man => section.to_string(),\n Format::Md => \"md\".to_string(),\n Format::Text => \"txt\".to_string(),\n }\n }\n}\n\n/// Converts the handlebars markdown file at the given path into the given\n/// format, returning the translated result.\npub fn convert(\n file: &Path,\n format: Format,\n url: Option,\n man_map: ManMap,\n) -> Result {\n let formatter: Box = match format {\n Format::Man => Box::new(format::man::ManFormatter::new(url)),\n Format::Md => Box::new(format::md::MdFormatter::new(man_map)),\n Format::Text => Box::new(format::text::TextFormatter::new(url)),\n };\n let expanded = hbs::expand(file, &*formatter)?;\n // pulldown-cmark can behave a little differently with Windows newlines,\n // just normalize it.\n let expanded = expanded.replace(\"\\r\\n\", \"\\n\");\n formatter.render(&expanded)\n}\n\n/// Pulldown-cmark iterator yielding an `(event, range)` tuple.\ntype EventIter<'a> = Box, Range)> + 'a>;\n\n/// Creates a new markdown parser with the given input.\npub(crate) fn md_parser(input: &str, url: Option) -> EventIter<'_> {\n let mut options = Options::empty();\n options.insert(Options::ENABLE_TABLES);\n options.insert(Options::ENABLE_FOOTNOTES);\n options.insert(Options::ENABLE_STRIKETHROUGH);\n options.insert(Options::ENABLE_SMART_PUNCTUATION);\n let parser = Parser::new_ext(input, options);\n let parser = parser.into_offset_iter();\n // Translate all links to include the base url.\n let parser = parser.map(move |(event, range)| match event {\n Event::Start(Tag::Link {\n link_type,\n dest_url,\n title,\n id,\n }) if !matches!(link_type, LinkType::Email) => (\n Event::Start(Tag::Link {\n link_type,\n dest_url: join_url(url.as_ref(), dest_url),\n title,\n id,\n }),\n range,\n ),\n Event::End(TagEnd::Link) => (Event::End(TagEnd::Link), range),\n _ => (event, range),\n });\n Box::new(parser)\n}\n\nfn join_url<'a>(base: Option<&Url>, dest: CowStr<'a>) -> CowStr<'a> {\n match base {\n Some(base_url) => {\n // Absolute URL or page-relative anchor doesn't need to be translated.\n if dest.contains(':') || dest.starts_with('#') {\n dest\n } else {\n let joined = base_url.join(&dest).unwrap_or_else(|e| {\n panic!(\"failed to join URL `{}` to `{}`: {}\", dest, base_url, e)\n });\n String::from(joined).into()\n }\n }\n None => dest,\n }\n}\n\npub fn extract_section(file: &Path) -> Result {\n let f = fs::File::open(file).with_context(|| format!(\"could not open `{}`\", file.display()))?;\n let mut f = io::BufReader::new(f);\n let mut line = String::new();\n f.read_line(&mut line)?;\n if !line.starts_with(\"# \") {\n bail!(\"expected input file to start with # header\");\n }\n let (_name, section) = util::parse_name_and_section(&line[2..].trim()).with_context(|| {\n format!(\n \"expected input file to have header with the format `# command-name(1)`, found: `{}`\",\n line\n )\n })?;\n Ok(section)\n}\n" }, { "path": "crates/mdman/src/main.rs", "content": "#![allow(clippy::print_stderr)]\n\nuse anyhow::{Context, Error, bail, format_err};\nuse mdman::{Format, ManMap};\nuse std::collections::HashMap;\nuse std::path::{Path, PathBuf};\nuse url::Url;\n\n/// Command-line options.\nstruct Options {\n format: Format,\n output_dir: PathBuf,\n sources: Vec,\n url: Option,\n man_map: ManMap,\n}\n\nfn main() {\n if let Err(e) = run() {\n eprintln!(\"error: {}\", e);\n for cause in e.chain().skip(1) {\n eprintln!(\"\\nCaused by:\");\n for line in cause.to_string().lines() {\n if line.is_empty() {\n eprintln!();\n } else {\n eprintln!(\" {}\", line);\n }\n }\n }\n std::process::exit(1);\n }\n}\n\nfn run() -> Result<(), Error> {\n let opts = process_args()?;\n if !opts.output_dir.exists() {\n std::fs::create_dir_all(&opts.output_dir).with_context(|| {\n format!(\n \"failed to create output directory {}\",\n opts.output_dir.display()\n )\n })?;\n }\n for source in &opts.sources {\n let section = mdman::extract_section(source)?;\n let filename =\n Path::new(source.file_name().unwrap()).with_extension(opts.format.extension(section));\n let out_path = opts.output_dir.join(filename);\n if same_file::is_same_file(source, &out_path).unwrap_or(false) {\n bail!(\"cannot output to the same file as the source\");\n }\n eprintln!(\"Converting {} -> {}\", source.display(), out_path.display());\n let result = mdman::convert(&source, opts.format, opts.url.clone(), opts.man_map.clone())\n .with_context(|| format!(\"failed to translate {}\", source.display()))?;\n\n std::fs::write(out_path, result)?;\n }\n Ok(())\n}\n\nfn process_args() -> Result {\n let mut format = None;\n let mut output = None;\n let mut url = None;\n let mut man_map: ManMap = HashMap::new();\n let mut sources = Vec::new();\n let mut args = std::env::args().skip(1);\n while let Some(arg) = args.next() {\n match arg.as_str() {\n \"-t\" => {\n format = match args.next().as_deref() {\n Some(\"man\") => Some(Format::Man),\n Some(\"md\") => Some(Format::Md),\n Some(\"txt\") => Some(Format::Text),\n Some(s) => bail!(\"unknown output format: {}\", s),\n None => bail!(\"-t requires a value (man, md, txt)\"),\n };\n }\n \"-o\" => {\n output = match args.next() {\n Some(s) => Some(PathBuf::from(s)),\n None => bail!(\"-o requires a value\"),\n };\n }\n \"--url\" => {\n url = match args.next() {\n Some(s) => {\n let url = Url::parse(&s)\n .with_context(|| format!(\"could not convert `{}` to a url\", s))?;\n if !url.path().ends_with('/') {\n bail!(\"url `{}` should end with a /\", url);\n }\n Some(url)\n }\n None => bail!(\"--url requires a value\"),\n }\n }\n \"--man\" => {\n let man = args\n .next()\n .ok_or_else(|| format_err!(\"--man requires a value\"))?;\n let parts = man.split_once('=').ok_or_else(|| {\n anyhow::format_err!(\"--man expected value with form name:1=link\")\n })?;\n let key_parts = parts.0.split_once(':').ok_or_else(|| {\n anyhow::format_err!(\"--man expected value with form name:1=link\")\n })?;\n let section: u8 = key_parts.1.parse().with_context(|| {\n format!(\"expected unsigned integer for section, got `{}`\", parts.1)\n })?;\n man_map.insert((key_parts.0.to_string(), section), parts.1.to_string());\n }\n s => {\n sources.push(PathBuf::from(s));\n }\n }\n }\n if format.is_none() {\n bail!(\"-t must be specified (man, md, txt)\");\n }\n if output.is_none() {\n bail!(\"-o must be specified (output directory)\");\n }\n if sources.is_empty() {\n bail!(\"at least one source must be specified\");\n }\n let opts = Options {\n format: format.unwrap(),\n output_dir: output.unwrap(),\n sources,\n url,\n man_map,\n };\n Ok(opts)\n}\n" }, { "path": "crates/mdman/src/util.rs", "content": "///! General utilities.\nuse crate::EventIter;\nuse anyhow::{Context, Error, bail, format_err};\nuse pulldown_cmark::{CowStr, Event, TagEnd};\n\n/// Splits the text `foo(1)` into \"foo\" and `1`.\npub fn parse_name_and_section(text: &str) -> Result<(&str, u8), Error> {\n let mut i = text.split_terminator(&['(', ')'][..]);\n let name = i\n .next()\n .ok_or_else(|| format_err!(\"man reference must have a name\"))?;\n let section = i\n .next()\n .ok_or_else(|| format_err!(\"man reference must have a section such as mycommand(1)\"))?;\n if let Some(s) = i.next() {\n bail!(\n \"man reference must have the form mycommand(1), got extra part `{}`\",\n s\n );\n }\n let section: u8 = section\n .parse()\n .with_context(|| format!(\"section must be a number, got {}\", section))?;\n Ok((name, section))\n}\n\n/// Extracts the text from a header after `Tag::Heading` has been received.\npub fn header_text<'e>(parser: &mut EventIter<'e>) -> Result, Error> {\n let text = match parser.next() {\n Some((Event::Text(t), _range)) => t,\n e => bail!(\"expected plain text in man header, got {:?}\", e),\n };\n match parser.next() {\n Some((Event::End(TagEnd::Heading(..)), _range)) => {\n return Ok(text);\n }\n e => bail!(\"expected plain text in man header, got {:?}\", e),\n }\n}\n\n/// Removes tags from the front and back of a string.\npub fn unwrap<'t>(text: &'t str, front: &str, back: &str) -> &'t str {\n text.trim().trim_start_matches(front).trim_end_matches(back)\n}\n" }, { "path": "crates/mdman/tests/compare/expected/formatting.1", "content": "'\\\" t\n.TH \"FORMATTING\" \"1\"\n.nh\n.ad l\n.ss \\n[.ss] 0\n.sp\nThis is \\fBnested \\f(BIformatting\\fB \\fBtext\\fB\\fR\\&.\n.SH \"SECOND HEADING\"\nSome text at second level.\n.SS \"Third heading\"\nSome text at third level.\n.SS \"Fourth heading\"\nSome text at fourth level.\n.SH \"Quotes and blocks.\"\nHere are some quotes and blocks.\n.RS 3\n.ll -5\n.sp\nThis is a block quote. Ambidextrously koala apart that prudent blindly alas\nfar amid dear goodness turgid so exact inside oh and alas much fanciful that\ndark on spoon\\-fed adequately insolent walking crud.\n.br\n.RE\n.ll\n.sp\n.RS 4\n.nf\nThis is a code block. Groundhog watchfully sudden firefly some self\\-consciously hotly jeepers satanic after that this parrot this at virtuous\nsome mocking the leaned jeez nightingale as much mallard so because jeez\nturned dear crud grizzly strenuously.\n\n Indented and should be unmodified.\n.fi\n.RE\n.sp\n.RS 4\n.nf\nThis is an indented code block. Egregiously yikes animatedly since outside beseechingly a badger hey shakily giraffe a one wow one this\ngoodness regarding reindeer so astride before.\n\n Doubly indented\n.fi\n.RE\n.SH \"Lists\"\n.sp\n.RS 4\n\\h'-04' 1.\\h'+01'Ordered list\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Unordered list\n.sp\nWith a second paragraph inside it\n.sp\n.RS 4\n\\h'-04' 1.\\h'+01'Inner ordered list\n.RE\n.sp\n.RS 4\n\\h'-04' 2.\\h'+01'Another\n.RE\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Eggs\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Milk\n.sp\n.RS 4\n\\h'-04' 5.\\h'+01'Don\\[cq]t start at one.\n.RE\n.sp\n.RS 4\n\\h'-04' 6.\\h'+01'tamarind\n.RE\n.RE\n.RE\n.sp\n.RS 4\n\\h'-04' 2.\\h'+01'Second element\n.RE\n.sp\n.RS 4\n\\h'-04' 3.\\h'+01'Third element\n.RE\n.SH \"Breaks\"\nThis has a\n.br\nhard break in it\nand a soft one.\n.SH \"Horizontal rule\"\nThis should contain a line:\n\\l'\\n(.lu'\n.sp\nNice!\n.SH \"Strange characters\"\nHandles escaping for characters\n.sp\n\\&.dot at the start of a line.\n.sp\n\\(rsfBnot really troff\n.sp\nVarious characters \\(rs \\- \\[en] \\[em] \\- | | `\n.sp\n.RS 4\n.nf\ntree\n`\\-\\- example\n |\\-\\- salamander\n | |\\-\\- honey\n | `\\-\\- some\n |\\-\\- fancifully\n `\\-\\- trout\n.fi\n.RE\n.sp\n\\ \\ \\ \\ non\\-breaking space.\n" }, { "path": "crates/mdman/tests/compare/expected/formatting.md", "content": "# formatting(1)\n\nThis is **nested _formatting_ `text`**.\n\n## SECOND HEADING\n\nSome text at second level.\n\n### Third heading\n\nSome text at third level.\n\n#### Fourth heading\n\nSome text at fourth level.\n\n## Quotes and blocks.\n\nHere are some quotes and blocks.\n\n> This is a block quote. Ambidextrously koala apart that prudent blindly alas\n> far amid dear goodness turgid so exact inside oh and alas much fanciful that\n> dark on spoon-fed adequately insolent walking crud.\n\n```\nThis is a code block. Groundhog watchfully sudden firefly some self-consciously hotly jeepers satanic after that this parrot this at virtuous\nsome mocking the leaned jeez nightingale as much mallard so because jeez\nturned dear crud grizzly strenuously.\n\n Indented and should be unmodified.\n```\n\n This is an indented code block. Egregiously yikes animatedly since outside beseechingly a badger hey shakily giraffe a one wow one this\n goodness regarding reindeer so astride before.\n\n Doubly indented\n\n## Lists\n\n1. Ordered list\n\n * Unordered list\n\n With a second paragraph inside it\n\n 1. Inner ordered list\n\n 1. Another\n\n * Eggs\n\n * Milk\n\n 5. Don't start at one.\n 6. tamarind\n\n1. Second element\n\n1. Third element\n\n## Breaks\n\nThis has a\\\nhard break in it\nand a soft one.\n\n## Horizontal rule\n\nThis should contain a line:\n\n---\n\nNice!\n\n## Strange characters\n\nHandles escaping for characters\n\n.dot at the start of a line.\n\n\\fBnot really troff\n\nVarious characters \\ - ā€“ ā€” ā”€ ā”‚ ā”œ ā””\n\n```\ntree\nā””ā”€ā”€ example\n ā”œā”€ā”€ salamander\n ā”‚ ā”œā”€ā”€ honey\n ā”‚ ā””ā”€ā”€ some\n ā”œā”€ā”€ fancifully\n ā””ā”€ā”€ trout\n```\n\n    non-breaking space.\n" }, { "path": "crates/mdman/tests/compare/expected/formatting.txt", "content": "FORMATTING(1)\n\nThis is nested formatting text.\n\nSECOND HEADING\n Some text at second level.\n\n Third heading\n Some text at third level.\n\n Fourth heading\n Some text at fourth level.\n\nQUOTES AND BLOCKS.\n Here are some quotes and blocks.\n\n This is a block quote. Ambidextrously koala apart that prudent\n blindly alas far amid dear goodness turgid so exact inside oh and\n alas much fanciful that dark on spoon-fed adequately insolent walking\n crud.\n\n This is a code block. Groundhog watchfully sudden firefly some self-consciously hotly jeepers satanic after that this parrot this at virtuous\n some mocking the leaned jeez nightingale as much mallard so because jeez\n turned dear crud grizzly strenuously.\n \n Indented and should be unmodified.\n\n This is an indented code block. Egregiously yikes animatedly since outside beseechingly a badger hey shakily giraffe a one wow one this\n goodness regarding reindeer so astride before.\n \n Doubly indented\n\nLISTS\n 1. Ordered list\n\n o Unordered list\n\n With a second paragraph inside it\n\n 1. Inner ordered list\n\n 2. Another\n\n o Eggs\n\n o Milk\n\n 5. Donā€™t start at one.\n\n 6. tamarind\n\n 2. Second element\n\n 3. Third element\n\nBREAKS\n This has a\n hard break in it and a soft one.\n\nHORIZONTAL RULE\n This should contain a line:\n\n _________________________________________________________________\n Nice!\n\nSTRANGE CHARACTERS\n Handles escaping for characters\n\n .dot at the start of a line.\n\n \\fBnot really troff\n\n Various characters \\ - ā€“ ā€” ā”€ ā”‚ ā”œ ā””\n\n tree\n ā””ā”€ā”€ example\n ā”œā”€ā”€ salamander\n ā”‚ ā”œā”€ā”€ honey\n ā”‚ ā””ā”€ā”€ some\n ā”œā”€ā”€ fancifully\n ā””ā”€ā”€ trout\n\n Ā Ā Ā Ā non-breaking space.\n\n" }, { "path": "crates/mdman/tests/compare/expected/links.1", "content": "'\\\" t\n.TH \"LINKS\" \"1\"\n.nh\n.ad l\n.ss \\n[.ss] 0\n.SH \"NAME\"\nlinks \\- Test of different link kinds\n.SH \"DESCRIPTION\"\nInline link: \\fIinline link\\fR \n.sp\nReference link: \\fIthis is a link\\fR \n.sp\nCollapsed: \\fIcollapsed\\fR \n.sp\nShortcut: \\fIshortcut\\fR \n.sp\nAutolink: \n.sp\nEmail: \n.sp\nRelative link: \\fIrelative link\\fR \n.sp\nCollapsed unknown: [collapsed unknown][]\n.sp\nReference unknown: [foo][unknown]\n.sp\nShortcut unknown: [shortcut unknown]\n.sp\n\\fBother\\-cmd\\fR(1)\n.sp\n\\fBlocal\\-cmd\\fR(1)\n.sp\n\\fISome link\\fR \n.sp\n\\fB\\-\\-include\\fR\n.RS 4\nTesting an \\fIincluded link\\fR \\&.\n.RE\n.SH \"OPTIONS\"\n.sp\n\\fB\\-\\-foo\\-bar\\fR\n.RS 4\nExample \\fIlink\\fR \\&.\nSee \\fBother\\-cmd\\fR(1), \\fBlocal\\-cmd\\fR(1)\n.RE\n" }, { "path": "crates/mdman/tests/compare/expected/links.md", "content": "# links(1)\n\n## NAME\n\nlinks - Test of different link kinds\n\n## DESCRIPTION\n\nInline link: [inline link](https://example.com/inline)\n\nReference link: [this is a link][bar]\n\nCollapsed: [collapsed][]\n\nShortcut: [shortcut]\n\nAutolink: \n\nEmail: \n\nRelative link: [relative link](foo/bar.html)\n\nCollapsed unknown: [collapsed unknown][]\n\nReference unknown: [foo][unknown]\n\nShortcut unknown: [shortcut unknown]\n\n[other-cmd(1)](https://example.org/commands/other-cmd.html)\n\n[local-cmd(1)](local-cmd.html)\n\n[Some link](foo.html)\n\n
\n
--include
\n

Testing an included link.

\n
\n\n
\n\n\n## OPTIONS\n\n
\n\n
--foo-bar
\n

Example link.\nSee other-cmd(1), local-cmd(1)

\n
\n\n\n
\n\n\n[bar]: https://example.com/bar\n[collapsed]: https://example.com/collapsed\n[shortcut]: https://example.com/shortcut\n" }, { "path": "crates/mdman/tests/compare/expected/links.txt", "content": "LINKS(1)\n\nNAME\n links - Test of different link kinds\n\nDESCRIPTION\n Inline link: inline link \n\n Reference link: this is a link \n\n Collapsed: collapsed \n\n Shortcut: shortcut \n\n Autolink: \n\n Email: \n\n Relative link: relative link \n\n Collapsed unknown: [collapsed unknown][]\n\n Reference unknown: [foo][unknown]\n\n Shortcut unknown: [shortcut unknown]\n\n other-cmd(1)\n\n local-cmd(1)\n\n Some link \n\n --include\n Testing an included link .\n\nOPTIONS\n --foo-bar\n Example link . See other-cmd(1),\n local-cmd(1)\n\n" }, { "path": "crates/mdman/tests/compare/expected/options.1", "content": "'\\\" t\n.TH \"MY\\-COMMAND\" \"1\"\n.nh\n.ad l\n.ss \\n[.ss] 0\n.SH \"NAME\"\nmy\\-command \\- A brief description\n.SH \"SYNOPSIS\"\n\\fBmy\\-command\\fR [\\fB\\-\\-abc\\fR | \\fB\\-\\-xyz\\fR] \\fIname\\fR\n.br\n\\fBmy\\-command\\fR [\\fB\\-f\\fR \\fIfile\\fR]\n.br\n\\fBmy\\-command\\fR (\\fB\\-m\\fR | \\fB\\-M\\fR) [\\fIoldbranch\\fR] \\fInewbranch\\fR\n.br\n\\fBmy\\-command\\fR (\\fB\\-d\\fR | \\fB\\-D\\fR) [\\fB\\-r\\fR] \\fIbranchname\\fR\\[u2026]\n.SH \"DESCRIPTION\"\nA description of the command.\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'One\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Sub one\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Sub two\n.RE\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Two\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'Three\n.RE\n.SH \"OPTIONS\"\n.SS \"Command options\"\n.sp\n\\fB\\-\\-foo\\-bar\\fR\n.RS 4\nDemo \\fIemphasis\\fR, \\fBstrong\\fR, ~~strike~~\n.RE\n.sp\n\\fB\\-p\\fR \\fIspec\\fR, \n\\fB\\-\\-package\\fR \\fIspec\\fR\n.RS 4\nThis has multiple flags.\n.RE\n.sp\n\\fInamed\\-arg\\[u2026]\\fR\n.RS 4\nA named argument.\n.RE\n.sp\n\\fB\\-\\-complex\\fR\n.RS 4\nThis option has a list.\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'alpha\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'beta\n.RE\n.sp\n.RS 4\n\\h'-04'\\(bu\\h'+03'gamma\n.RE\n.sp\nThen text continues here.\n.RE\n.SS \"Common Options\"\n.sp\n\\fB@\\fR\\fIfilename\\fR\n.RS 4\nLoad from filename.\n.RE\n.sp\n\\fB\\-\\-foo\\fR [\\fIbar\\fR]\n.RS 4\nFlag with optional value.\n.RE\n.sp\n\\fB\\-\\-foo\\fR[\\fB=\\fR\\fIbar\\fR]\n.RS 4\nAlternate syntax for optional value (with required = for disambiguation).\n.RE\n.sp\n\\fB\\-\\-split\\-block\\fR\n.RS 4\nAn option where the description has a \\fBblock statement that is split across multiple lines\\fR\n.RE\n.SH \"EXAMPLES\"\n.sp\n.RS 4\n\\h'-04' 1.\\h'+01'An example\n.sp\n.RS 4\n.nf\nmy\\-command \\-\\-abc\n.fi\n.RE\n.RE\n.sp\n.RS 4\n\\h'-04' 2.\\h'+01'Another example\n.sp\n.RS 4\n.nf\nmy\\-command \\-\\-xyz\n.fi\n.RE\n.RE\n.SH \"SEE ALSO\"\n\\fBother\\-command\\fR(1) \\fBabc\\fR(7)\n" }, { "path": "crates/mdman/tests/compare/expected/options.md", "content": "# my-command(1)\n\n## NAME\n\nmy-command - A brief description\n\n## SYNOPSIS\n\n`my-command` [`--abc` | `--xyz`] _name_\\\n`my-command` [`-f` _file_]\\\n`my-command` (`-m` | `-M`) [_oldbranch_] _newbranch_\\\n`my-command` (`-d` | `-D`) [`-r`] _branchname_...\n\n## DESCRIPTION\n\nA description of the command.\n\n* One\n * Sub one\n * Sub two\n* Two\n* Three\n\n\n## OPTIONS\n\n### Command options\n\n
\n\n
--foo-bar
\n

Demo emphasis, strong, strike

\n
\n\n\n
-p spec
\n
--package spec
\n

This has multiple flags.

\n
\n\n\n
named-argā€¦
\n

A named argument.

\n
\n\n\n
--complex
\n

This option has a list.

\n
    \n
  • alpha
    • \n
  • beta
    • \n
  • gamma
    • \n
\n

Then text continues here.

\n
\n\n\n
\n\n### Common Options\n\n
\n
@filename
\n

Load from filename.

\n
\n\n\n
--foo [bar]
\n

Flag with optional value.

\n
\n\n\n
--foo[=bar]
\n

Alternate syntax for optional value (with required = for disambiguation).

\n
\n\n\n
--split-block
\n

An option where the description has a block statement that is split across multiple lines

\n
\n\n\n
\n\n\n## EXAMPLES\n\n1. An example\n\n ```\n my-command --abc\n ```\n\n1. Another example\n\n my-command --xyz\n\n## SEE ALSO\n[other-command(1)](other-command.html) [abc(7)](abc.html)\n" }, { "path": "crates/mdman/tests/compare/expected/options.txt", "content": "MY-COMMAND(1)\n\nNAME\n my-command - A brief description\n\nSYNOPSIS\n my-command [--abc | --xyz] name\n my-command [-f file]\n my-command (-m | -M) [oldbranch] newbranch\n my-command (-d | -D) [-r] branchnameā€¦\n\nDESCRIPTION\n A description of the command.\n\n o One\n o Sub one\n\n o Sub two\n\n o Two\n\n o Three\n\nOPTIONS\n Command options\n --foo-bar\n Demo emphasis, strong, ~~strike~~\n\n -p spec, --package spec\n This has multiple flags.\n\n named-argā€¦\n A named argument.\n\n --complex\n This option has a list.\n\n o alpha\n\n o beta\n\n o gamma\n\n Then text continues here.\n\n Common Options\n @filename\n Load from filename.\n\n --foo [bar]\n Flag with optional value.\n\n --foo[=bar]\n Alternate syntax for optional value (with required = for\n disambiguation).\n\n --split-block\n An option where the description has a block statement that is split\n across multiple lines\n\nEXAMPLES\n 1. An example\n\n my-command --abc\n\n 2. Another example\n\n my-command --xyz\n\nSEE ALSO\n other-command(1) abc(7)\n\n" }, { "path": "crates/mdman/tests/compare/expected/tables.1", "content": "'\\\" t\n.TH \"TABLES\" \"1\"\n.nh\n.ad l\n.ss \\n[.ss] 0\n.SH \"DESCRIPTION\"\nTesting tables.\n\n.TS\nallbox tab(:);\nlt.\nT{\nSingle col\nT}\nT{\nHi! :)\nT}\n.TE\n.sp\n\n.TS\nallbox tab(:);\nlt lt lt.\nT{\nHeader content\nT}:T{\nWith \\fBformat\\fR \\fItext\\fR\nT}:T{\nAnother column\nT}\nT{\nSome data\nT}:T{\nMore data\nT}:T{\n\nT}\nT{\nExtra long amount of text within a column\nT}:T{\nhi\nT}:T{\nthere\nT}\n.TE\n.sp\n\n.TS\nallbox tab(:);\nlt ct rt.\nT{\nLeft aligned\nT}:T{\nCenter aligned\nT}:T{\nRight aligned\nT}\nT{\nabc\nT}:T{\ndef\nT}:T{\nghi\nT}\n.TE\n.sp\n\n.TS\nallbox tab(:);\nlt ct rt.\nT{\nLeft aligned\nT}:T{\nCenter aligned\nT}:T{\nRight aligned\nT}\nT{\nX\nT}:T{\nX\nT}:T{\nX\nT}\nT{\nExtra long text 123456789012 with mixed widths.\nT}:T{\nExtra long text 123456789012 with mixed widths.\nT}:T{\nExtra long text 123456789012 with mixed widths.\nT}\n.TE\n.sp\n\n.TS\nallbox tab(:);\nlt.\nT{\nLink check\nT}\nT{\n\\fIfoo\\fR \nT}\nT{\n\nT}\n.TE\n.sp\n" }, { "path": "crates/mdman/tests/compare/expected/tables.md", "content": "# tables(1)\n\n## DESCRIPTION\n\nTesting tables.\n\n| Single col |\n|------------|\n| Hi! :) |\n\n\nHeader content | With `format` *text* | Another column\n---------------|----------------------|----------------\nSome data | More data |\nExtra long amount of text within a column | hi | there\n\n\nLeft aligned | Center aligned | Right aligned\n-------------|:--------------:|--------------:\nabc | def | ghi\n\n\nLeft aligned | Center aligned | Right aligned\n-------------|:--------------:|--------------:\nX | X | X\nExtra long text 123456789012 with mixed widths. | Extra long text 123456789012 with mixed widths. | Extra long text 123456789012 with mixed widths.\n\n\n| Link check |\n|------------|\n| [foo] |\n| |\n\n\n[foo]: https://example.com/\n" }, { "path": "crates/mdman/tests/compare/expected/tables.txt", "content": "TABLES(1)\n\nDESCRIPTION\n Testing tables.\n\n +-------------+\n | Single col |\n +-------------+\n | Hi! :) |\n +-------------+\n\n +-------------------------------------+----------------+--------------+\n | Header content | With format | Another |\n | | text | column |\n +-------------------------------------+----------------+--------------+\n | Some data | More data | |\n +-------------------------------------+----------------+--------------+\n | Extra long amount of text within a | hi | there |\n | column | | |\n +-------------------------------------+----------------+--------------+\n\n +---------------+-----------------+----------------+\n | Left aligned | Center aligned | Right aligned |\n +---------------+-----------------+----------------+\n | abc | def | ghi |\n +---------------+-----------------+----------------+\n\n +-----------------------+-----------------------+-----------------------+\n | Left aligned | Center aligned | Right aligned |\n +-----------------------+-----------------------+-----------------------+\n | X | X | X |\n +-----------------------+-----------------------+-----------------------+\n | Extra long text | Extra long text | Extra long text |\n | 123456789012 with | 123456789012 with | 123456789012 with |\n | mixed widths. | mixed widths. | mixed widths. |\n +-----------------------+-----------------------+-----------------------+\n\n +-----------------------+\n | Link check |\n +-----------------------+\n | foo |\n +-----------------------+\n | https://example.com/ |\n +-----------------------+\n\n" }, { "path": "crates/mdman/tests/compare/expected/vars.7", "content": "'\\\" t\n.TH \"VARS\" \"7\"\n.nh\n.ad l\n.ss \\n[.ss] 0\n.sp\nBar\n.sp\nbar\n" }, { "path": "crates/mdman/tests/compare/expected/vars.md", "content": "# vars(7)\n\n\n\nBar\n\nbar\n" }, { "path": "crates/mdman/tests/compare/expected/vars.txt", "content": "VARS(7)\n\nBar\n\nbar\n\n" }, { "path": "crates/mdman/tests/compare/formatting.md", "content": "# formatting(1)\n\nThis is **nested _formatting_ `text`**.\n\n## SECOND HEADING\n\nSome text at second level.\n\n### Third heading\n\nSome text at third level.\n\n#### Fourth heading\n\nSome text at fourth level.\n\n## Quotes and blocks.\n\nHere are some quotes and blocks.\n\n> This is a block quote. Ambidextrously koala apart that prudent blindly alas\n> far amid dear goodness turgid so exact inside oh and alas much fanciful that\n> dark on spoon-fed adequately insolent walking crud.\n\n```\nThis is a code block. Groundhog watchfully sudden firefly some self-consciously hotly jeepers satanic after that this parrot this at virtuous\nsome mocking the leaned jeez nightingale as much mallard so because jeez\nturned dear crud grizzly strenuously.\n\n Indented and should be unmodified.\n```\n\n This is an indented code block. Egregiously yikes animatedly since outside beseechingly a badger hey shakily giraffe a one wow one this\n goodness regarding reindeer so astride before.\n\n Doubly indented\n\n## Lists\n\n1. Ordered list\n\n * Unordered list\n\n With a second paragraph inside it\n\n 1. Inner ordered list\n\n 1. Another\n\n * Eggs\n\n * Milk\n\n 5. Don't start at one.\n 6. tamarind\n\n1. Second element\n\n1. Third element\n\n## Breaks\n\nThis has a\\\nhard break in it\nand a soft one.\n\n## Horizontal rule\n\nThis should contain a line:\n\n---\n\nNice!\n\n## Strange characters\n\nHandles escaping for characters\n\n.dot at the start of a line.\n\n\\fBnot really troff\n\nVarious characters \\ - ā€“ ā€” ā”€ ā”‚ ā”œ ā””\n\n```\ntree\nā””ā”€ā”€ example\n ā”œā”€ā”€ salamander\n ā”‚ ā”œā”€ā”€ honey\n ā”‚ ā””ā”€ā”€ some\n ā”œā”€ā”€ fancifully\n ā””ā”€ā”€ trout\n```\n\n    non-breaking space.\n" }, { "path": "crates/mdman/tests/compare/includes/links-include.md", "content": "[Some link](foo.html)\n\n{{#options}}\n{{#option \"`--include`\"}}\nTesting an [included link](included_link.html).\n{{/option}}\n{{/options}}\n" }, { "path": "crates/mdman/tests/compare/includes/options-common.md", "content": "{{#options}}\n{{#option \"`@`_filename_\"}}\nLoad from filename.\n{{/option}}\n\n{{#option \"`--foo` [_bar_]\"}}\nFlag with optional value.\n{{/option}}\n\n{{#option \"`--foo`[`=`_bar_]\"}}\nAlternate syntax for optional value (with required = for disambiguation).\n{{/option}}\n\n{{#option \"`--split-block`\"}}\nAn option where the description has a `block statement\nthat is split across multiple lines`\n{{/option}}\n\n{{/options}}\n" }, { "path": "crates/mdman/tests/compare/links.md", "content": "# links(1)\n\n## NAME\n\nlinks - Test of different link kinds\n\n## DESCRIPTION\n\nInline link: [inline link](https://example.com/inline)\n\nReference link: [this is a link][bar]\n\nCollapsed: [collapsed][]\n\nShortcut: [shortcut]\n\nAutolink: \n\nEmail: \n\nRelative link: [relative link](foo/bar.html)\n\nCollapsed unknown: [collapsed unknown][]\n\nReference unknown: [foo][unknown]\n\nShortcut unknown: [shortcut unknown]\n\n{{man \"other-cmd\" 1}}\n\n{{man \"local-cmd\" 1}}\n\n{{> links-include}}\n\n\n## OPTIONS\n\n{{#options}}\n\n{{#option \"`--foo-bar`\"}}\nExample [link](bar.html).\nSee {{man \"other-cmd\" 1}}, {{man \"local-cmd\" 1}}\n{{/option}}\n\n{{/options}}\n\n\n[bar]: https://example.com/bar\n[collapsed]: https://example.com/collapsed\n[shortcut]: https://example.com/shortcut\n" }, { "path": "crates/mdman/tests/compare/options.md", "content": "# my-command(1)\n\n## NAME\n\nmy-command - A brief description\n\n## SYNOPSIS\n\n`my-command` [`--abc` | `--xyz`] _name_\\\n`my-command` [`-f` _file_]\\\n`my-command` (`-m` | `-M`) [_oldbranch_] _newbranch_\\\n`my-command` (`-d` | `-D`) [`-r`] _branchname_...\n\n## DESCRIPTION\n\nA description of the command.\n\n* One\n * Sub one\n * Sub two\n* Two\n* Three\n\n\n## OPTIONS\n\n### Command options\n\n{{#options}}\n\n{{#option \"`--foo-bar`\"}}\nDemo *emphasis*, **strong**, ~~strike~~\n{{/option}}\n\n{{#option \"`-p` _spec_\" \"`--package` _spec_\"}}\nThis has multiple flags.\n{{/option}}\n\n{{#option \"_named-arg..._\"}}\nA named argument.\n{{/option}}\n\n{{#option \"`--complex`\"}}\nThis option has a list.\n\n- alpha\n- beta\n- gamma\n\nThen text continues here.\n{{/option}}\n\n{{/options}}\n\n### Common Options\n\n{{> options-common}}\n\n\n## EXAMPLES\n\n1. An example\n\n ```\n my-command --abc\n ```\n\n1. Another example\n\n my-command --xyz\n\n## SEE ALSO\n{{man \"other-command\" 1}} {{man \"abc\" 7}}\n" }, { "path": "crates/mdman/tests/compare/tables.md", "content": "# tables(1)\n\n## DESCRIPTION\n\nTesting tables.\n\n| Single col |\n|------------|\n| Hi! :) |\n\n\nHeader content | With `format` *text* | Another column\n---------------|----------------------|----------------\nSome data | More data |\nExtra long amount of text within a column | hi | there\n\n\nLeft aligned | Center aligned | Right aligned\n-------------|:--------------:|--------------:\nabc | def | ghi\n\n\nLeft aligned | Center aligned | Right aligned\n-------------|:--------------:|--------------:\nX | X | X\nExtra long text 123456789012 with mixed widths. | Extra long text 123456789012 with mixed widths. | Extra long text 123456789012 with mixed widths.\n\n\n| Link check |\n|------------|\n| [foo] |\n| |\n\n\n[foo]: https://example.com/\n" }, { "path": "crates/mdman/tests/compare/vars.md", "content": "# vars(7)\n\n{{*set foo=\"Bar\"}}\n\n\n{{foo}}\n\n{{lower foo}}\n" }, { "path": "crates/mdman/tests/compare.rs", "content": "//! Compares input to expected output.\n\nuse std::path::PathBuf;\n\nuse mdman::{Format, ManMap};\nuse url::Url;\n\nfn run(name: &str) {\n let input = PathBuf::from(format!(\"tests/compare/{}.md\", name));\n let url = Some(Url::parse(\"https://example.org/\").unwrap());\n let mut map = ManMap::new();\n map.insert(\n (\"other-cmd\".to_string(), 1),\n \"https://example.org/commands/other-cmd.html\".to_string(),\n );\n\n for &format in &[Format::Man, Format::Md, Format::Text] {\n let section = mdman::extract_section(&input).unwrap();\n let result = mdman::convert(&input, format, url.clone(), map.clone()).unwrap();\n let expected_path = PathBuf::from(format!(\n \"tests/compare/expected/{}.{}\",\n name,\n format.extension(section)\n ));\n snapbox::assert_data_eq!(result, snapbox::Data::read_from(&expected_path, None).raw());\n }\n}\n\nmacro_rules! test( ($name:ident) => (\n #[test]\n fn $name() { run(stringify!($name)); }\n) );\n\ntest!(formatting);\ntest!(links);\ntest!(options);\ntest!(tables);\ntest!(vars);\n" }, { "path": "crates/mdman/tests/invalid/nested.md", "content": "# nested(1)\n\n{{#options}}\n{{#options}}\n{{/options}}\n{{/options}}\n" }, { "path": "crates/mdman/tests/invalid/not-inside-options.md", "content": "# not-inside-options(1)\n\n{{#option \"`-o`\"}}\nTesting without options block.\n{{/option}}\n" }, { "path": "crates/mdman/tests/invalid.rs", "content": "//! Tests for errors and invalid input.\n\nuse std::path::PathBuf;\n\nuse mdman::{Format, ManMap};\nuse snapbox::prelude::*;\n\nfn run(name: &str, expected_error: impl IntoData) {\n let input = PathBuf::from(format!(\"tests/invalid/{}\", name));\n match mdman::convert(&input, Format::Man, None, ManMap::new()) {\n Ok(_) => {\n panic!(\"expected {} to fail\", name);\n }\n Err(e) => {\n snapbox::assert_data_eq!(e.to_string(), expected_error.raw());\n }\n }\n}\n\nmacro_rules! test( ($name:ident, $file_name:expr, $error:expr) => (\n #[test]\n fn $name() { run($file_name, $error); }\n) );\n\ntest!(\n nested,\n \"nested.md\",\n \"Error rendering \\\"template\\\" line 4, col 1: options blocks cannot be nested\"\n);\n\ntest!(\n not_inside_options,\n \"not-inside-options.md\",\n \"Error rendering \\\"template\\\" line 3, col 1: option must be in options block\"\n);\n" }, { "path": "crates/resolver-tests/Cargo.toml", "content": "[package]\nname = \"resolver-tests\"\nversion = \"0.0.0\"\nedition.workspace = true\npublish = false\n\n[dependencies]\ncargo.workspace = true\ncargo-platform.workspace = true\ncargo-util-schemas.workspace = true\ncargo-util.workspace = true\nproptest.workspace = true\nvarisat.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/resolver-tests/README.md", "content": "# resolver-tests\n\n## The aim\n\nThis crate aims to test the resolution of Cargo's resolver. It implements a [SAT solver](https://en.wikipedia.org/wiki/SAT_solver) to compare with resolution of Cargo's resolver. \nThis ensures that Cargo's dependency resolution is proven valid by lowering to [SAT problem](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem). \n\n> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use (except as a transitive dependency). This\n> crate may make major changes to its APIs or be deprecated without warning.\n\n## About the test\n\nThe Cargo's resolver is very sensitive to what order it tries to evaluate constraints. This makes it incredibly difficult \nto be sure that a handful of tests actually covers all the important permutations of decision-making. The tests not only needs \nto hit all the corner cases, it needs to try all of the orders of evaluation. So we use fuzz testing to cover more permutations. \n\n" }, { "path": "crates/resolver-tests/src/helpers.rs", "content": "use std::collections::BTreeMap;\nuse std::fmt::Debug;\nuse std::sync::OnceLock;\n\nuse cargo::core::dependency::DepKind;\nuse cargo::core::{Dependency, GitReference, PackageId, SourceId, Summary};\nuse cargo::util::IntoUrl;\n\npub trait ToDep {\n fn to_dep(self) -> Dependency;\n fn opt(self) -> Dependency;\n fn with(self, features: &[&'static str]) -> Dependency;\n fn with_default(self) -> Dependency;\n fn rename(self, name: &str) -> Dependency;\n}\n\nimpl ToDep for &'static str {\n fn to_dep(self) -> Dependency {\n Dependency::parse(self, Some(\"1.0.0\"), registry_loc()).unwrap()\n }\n fn opt(self) -> Dependency {\n let mut dep = self.to_dep();\n dep.set_optional(true);\n dep\n }\n fn with(self, features: &[&'static str]) -> Dependency {\n let mut dep = self.to_dep();\n dep.set_default_features(false);\n dep.set_features(features.into_iter().copied());\n dep\n }\n fn with_default(self) -> Dependency {\n let mut dep = self.to_dep();\n dep.set_default_features(true);\n dep\n }\n fn rename(self, name: &str) -> Dependency {\n let mut dep = self.to_dep();\n dep.set_explicit_name_in_toml(name);\n dep\n }\n}\n\nimpl ToDep for Dependency {\n fn to_dep(self) -> Dependency {\n self\n }\n fn opt(mut self) -> Dependency {\n self.set_optional(true);\n self\n }\n fn with(mut self, features: &[&'static str]) -> Dependency {\n self.set_default_features(false);\n self.set_features(features.into_iter().copied());\n self\n }\n fn with_default(mut self) -> Dependency {\n self.set_default_features(true);\n self\n }\n fn rename(mut self, name: &str) -> Dependency {\n self.set_explicit_name_in_toml(name);\n self\n }\n}\n\npub trait ToPkgId {\n fn to_pkgid(&self) -> PackageId;\n}\n\nimpl ToPkgId for PackageId {\n fn to_pkgid(&self) -> PackageId {\n *self\n }\n}\n\nimpl<'a> ToPkgId for &'a str {\n fn to_pkgid(&self) -> PackageId {\n PackageId::try_new(*self, \"1.0.0\", registry_loc()).unwrap()\n }\n}\n\nimpl, U: AsRef> ToPkgId for (T, U) {\n fn to_pkgid(&self) -> PackageId {\n let (name, vers) = self;\n PackageId::try_new(name.as_ref(), vers.as_ref(), registry_loc()).unwrap()\n }\n}\n\n#[macro_export]\nmacro_rules! pkg {\n ($pkgid:expr => [$($deps:expr),* $(,)? ]) => ({\n use $crate::helpers::ToDep;\n let d: Vec = vec![$($deps.to_dep()),*];\n $crate::helpers::pkg_dep($pkgid, d)\n });\n\n ($pkgid:expr) => ({\n $crate::helpers::pkg($pkgid)\n })\n}\n\nfn registry_loc() -> SourceId {\n static EXAMPLE_DOT_COM: OnceLock = OnceLock::new();\n let example_dot = EXAMPLE_DOT_COM.get_or_init(|| {\n SourceId::for_registry(&\"https://example.com\".into_url().unwrap()).unwrap()\n });\n *example_dot\n}\n\npub fn pkg(name: T) -> Summary {\n pkg_dep(name, Vec::new())\n}\n\npub fn pkg_dep(name: T, dep: Vec) -> Summary {\n let pkgid = name.to_pkgid();\n let link = if pkgid.name().ends_with(\"-sys\") {\n Some(pkgid.name())\n } else {\n None\n };\n Summary::new(name.to_pkgid(), dep, &BTreeMap::new(), link, None).unwrap()\n}\n\npub fn pkg_dep_with(\n name: T,\n dep: Vec,\n features: &[(&'static str, &[&'static str])],\n) -> Summary {\n let pkgid = name.to_pkgid();\n let link = if pkgid.name().ends_with(\"-sys\") {\n Some(pkgid.name())\n } else {\n None\n };\n let features = features\n .into_iter()\n .map(|&(name, values)| (name.into(), values.into_iter().map(|&v| v.into()).collect()))\n .collect();\n Summary::new(name.to_pkgid(), dep, &features, link, None).unwrap()\n}\n\npub fn pkg_dep_link(name: T, link: &str, dep: Vec) -> Summary {\n Summary::new(name.to_pkgid(), dep, &BTreeMap::new(), Some(link), None).unwrap()\n}\n\npub fn pkg_id(name: &str) -> PackageId {\n PackageId::try_new(name, \"1.0.0\", registry_loc()).unwrap()\n}\n\npub fn pkg_id_source(name: &str, source: &str) -> PackageId {\n PackageId::try_new(\n name,\n \"1.0.0\",\n SourceId::for_registry(&source.into_url().unwrap()).unwrap(),\n )\n .unwrap()\n}\n\nfn pkg_id_loc(name: &str, loc: &str) -> PackageId {\n let remote = loc.into_url();\n let master = GitReference::Branch(\"master\".to_string());\n let source_id = SourceId::for_git(&remote.unwrap(), master).unwrap();\n\n PackageId::try_new(name, \"1.0.0\", source_id).unwrap()\n}\n\npub fn pkg_loc(name: &str, loc: &str) -> Summary {\n let link = if name.ends_with(\"-sys\") {\n Some(name)\n } else {\n None\n };\n Summary::new(\n pkg_id_loc(name, loc),\n Vec::new(),\n &BTreeMap::new(),\n link,\n None,\n )\n .unwrap()\n}\n\npub fn remove_dep(sum: &Summary, ind: usize) -> Summary {\n let mut deps = sum.dependencies().to_vec();\n deps.remove(ind);\n // note: more things will need to be copied over in the future, but it works for now.\n Summary::new(sum.package_id(), deps, &BTreeMap::new(), sum.links(), None).unwrap()\n}\n\npub fn dep(name: &str) -> Dependency {\n dep_req(name, \"*\")\n}\n\npub fn dep_req(name: &str, req: &str) -> Dependency {\n Dependency::parse(name, Some(req), registry_loc()).unwrap()\n}\n\npub fn dep_req_kind(name: &str, req: &str, kind: DepKind) -> Dependency {\n let mut dep = dep_req(name, req);\n dep.set_kind(kind);\n dep\n}\n\npub fn dep_req_platform(name: &str, req: &str, platform: &str) -> Dependency {\n let mut dep = dep_req(name, req);\n dep.set_platform(Some(platform.parse().unwrap()));\n dep\n}\n\npub fn dep_loc(name: &str, location: &str) -> Dependency {\n let url = location.into_url().unwrap();\n let master = GitReference::Branch(\"master\".to_string());\n let source_id = SourceId::for_git(&url, master).unwrap();\n Dependency::parse(name, Some(\"1.0.0\"), source_id).unwrap()\n}\n\npub fn dep_kind(name: &str, kind: DepKind) -> Dependency {\n let mut dep = dep(name);\n dep.set_kind(kind);\n dep\n}\n\npub fn dep_platform(name: &str, platform: &str) -> Dependency {\n let mut dep = dep(name);\n dep.set_platform(Some(platform.parse().unwrap()));\n dep\n}\n\npub fn registry(pkgs: Vec) -> Vec {\n pkgs\n}\n\npub fn names(names: &[P]) -> Vec {\n names.iter().map(|name| name.to_pkgid()).collect()\n}\n\npub fn loc_names(names: &[(&'static str, &'static str)]) -> Vec {\n names\n .iter()\n .map(|&(name, loc)| pkg_id_loc(name, loc))\n .collect()\n}\n\n/// Assert `xs` contains `elems`\n#[track_caller]\npub fn assert_contains(xs: &[A], elems: &[A]) {\n for elem in elems {\n assert!(\n xs.contains(elem),\n \"missing element\\nset: {xs:?}\\nmissing: {elem:?}\"\n );\n }\n}\n\n#[track_caller]\npub fn assert_same(a: &[A], b: &[A]) {\n assert_eq!(a.len(), b.len(), \"not equal\\n{a:?}\\n{b:?}\");\n assert_contains(b, a);\n}\n" }, { "path": "crates/resolver-tests/src/lib.rs", "content": "//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use (except as a transitive dependency). This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\n#![allow(clippy::print_stderr)]\n\npub mod helpers;\npub mod sat;\n\nuse std::cmp::{max, min};\nuse std::collections::{BTreeMap, HashSet};\nuse std::fmt;\nuse std::task::Poll;\nuse std::time::Instant;\n\nuse cargo::core::Resolve;\nuse cargo::core::ResolveVersion;\nuse cargo::core::SourceId;\nuse cargo::core::dependency::DepKind;\nuse cargo::core::resolver::{self, ResolveOpts, VersionOrdering, VersionPreferences};\nuse cargo::core::{Dependency, PackageId, Registry, Summary};\nuse cargo::sources::IndexSummary;\nuse cargo::sources::source::QueryKind;\nuse cargo::util::interning::InternedString;\nuse cargo::util::{CargoResult, GlobalContext};\n\nuse crate::helpers::{ToPkgId, dep_req, dep_req_kind, pkg_dep, pkg_id};\nuse crate::sat::SatResolver;\n\nuse proptest::collection::{btree_map, vec};\nuse proptest::prelude::*;\nuse proptest::sample::Index;\nuse proptest::string::string_regex;\n\npub fn resolve(deps: Vec, registry: &[Summary]) -> CargoResult> {\n Ok(\n resolve_with_global_context(deps, registry, &GlobalContext::default().unwrap())?\n .into_iter()\n .map(|(pkg, _)| pkg)\n .collect(),\n )\n}\n\npub fn resolve_and_validated(\n deps: Vec,\n registry: &[Summary],\n sat_resolver: &mut SatResolver,\n) -> CargoResult)>> {\n resolve_and_validated_raw(deps, registry, pkg_id(\"root\"), sat_resolver)\n}\n\n// Verify that the resolution of cargo resolver can pass the verification of SAT\npub fn resolve_and_validated_raw(\n deps: Vec,\n registry: &[Summary],\n root_pkg_id: PackageId,\n sat_resolver: &mut SatResolver,\n) -> CargoResult)>> {\n let resolve = resolve_with_global_context_raw(\n deps.clone(),\n registry,\n root_pkg_id,\n &GlobalContext::default().unwrap(),\n );\n\n match resolve {\n Err(e) => {\n if sat_resolver.sat_resolve(&deps) {\n panic!(\n \"`resolve()` returned an error but the sat resolver thinks this will work:\\n{}\",\n sat_resolver.used_packages().unwrap()\n );\n }\n Err(e)\n }\n Ok(resolve) => {\n let mut stack = vec![root_pkg_id];\n let mut used = HashSet::new();\n let mut links = HashSet::new();\n while let Some(p) = stack.pop() {\n assert!(resolve.contains(&p));\n if used.insert(p) {\n // in the tests all `links` crates end in `-sys`\n if p.name().ends_with(\"-sys\") {\n assert!(links.insert(p.name()));\n }\n stack.extend(resolve.deps(p).map(|(dp, deps)| {\n for d in deps {\n assert!(d.matches_id(dp));\n }\n dp\n }));\n }\n }\n let out = collect_features(&resolve);\n assert_eq!(out.len(), used.len());\n\n if !sat_resolver.sat_is_valid_solution(&out) {\n panic!(\n \"`resolve()` thinks this will work, but the solution is \\\n invalid according to the sat resolver:\\n{resolve:?}\",\n );\n }\n Ok(out)\n }\n }\n}\n\nfn collect_features(resolve: &Resolve) -> Vec<(PackageId, Vec)> {\n resolve\n .sort()\n .iter()\n .map(|&pkg| (pkg, resolve.features(pkg).to_vec()))\n .collect()\n}\n\npub fn resolve_with_global_context(\n deps: Vec,\n registry: &[Summary],\n gctx: &GlobalContext,\n) -> CargoResult)>> {\n let resolve = resolve_with_global_context_raw(deps, registry, pkg_id(\"root\"), gctx)?;\n Ok(collect_features(&resolve))\n}\n\npub fn resolve_with_global_context_raw(\n deps: Vec,\n registry: &[Summary],\n root_pkg_id: PackageId,\n gctx: &GlobalContext,\n) -> CargoResult {\n struct MyRegistry<'a> {\n list: &'a [Summary],\n used: HashSet,\n }\n impl<'a> Registry for MyRegistry<'a> {\n fn query(\n &mut self,\n dep: &Dependency,\n kind: QueryKind,\n f: &mut dyn FnMut(IndexSummary),\n ) -> Poll> {\n for summary in self.list.iter() {\n let matched = match kind {\n QueryKind::Exact => dep.matches(summary),\n QueryKind::RejectedVersions => dep.matches(summary),\n QueryKind::AlternativeNames => true,\n QueryKind::Normalized => true,\n };\n if matched {\n self.used.insert(summary.package_id());\n f(IndexSummary::Candidate(summary.clone()));\n }\n }\n Poll::Ready(Ok(()))\n }\n\n fn describe_source(&self, _src: SourceId) -> String {\n String::new()\n }\n\n fn is_replaced(&self, _src: SourceId) -> bool {\n false\n }\n\n fn block_until_ready(&mut self) -> CargoResult<()> {\n Ok(())\n }\n }\n impl<'a> Drop for MyRegistry<'a> {\n fn drop(&mut self) {\n if std::thread::panicking() && self.list.len() != self.used.len() {\n // we found a case that causes a panic and did not use all of the input.\n // lets print the part of the input that was used for minimization.\n eprintln!(\n \"Part used before drop: {:?}\",\n PrettyPrintRegistry(\n self.list\n .iter()\n .filter(|s| { self.used.contains(&s.package_id()) })\n .cloned()\n .collect()\n )\n );\n }\n }\n }\n let mut registry = MyRegistry {\n list: registry,\n used: HashSet::new(),\n };\n\n let root_summary =\n Summary::new(root_pkg_id, deps, &BTreeMap::new(), None::<&String>, None).unwrap();\n\n let opts = ResolveOpts::everything();\n\n let start = Instant::now();\n let mut version_prefs = VersionPreferences::default();\n if gctx.cli_unstable().minimal_versions {\n version_prefs.version_ordering(VersionOrdering::MinimumVersionsFirst)\n }\n\n let resolve = resolver::resolve(\n &[(root_summary, opts)],\n &[],\n &mut registry,\n &version_prefs,\n ResolveVersion::with_rust_version(None),\n Some(gctx),\n );\n\n // The largest test in our suite takes less then 30 secs.\n // So let's fail the test if we have been running for more than 60 secs.\n assert!(start.elapsed().as_secs() < 60);\n resolve\n}\n\n/// By default `Summary` and `Dependency` have a very verbose `Debug` representation.\n/// This replaces with a representation that uses constructors from this file.\n///\n/// If `registry_strategy` is improved to modify more fields\n/// then this needs to update to display the corresponding constructor.\npub struct PrettyPrintRegistry(pub Vec);\n\nimpl fmt::Debug for PrettyPrintRegistry {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"vec![\")?;\n for s in &self.0 {\n if s.dependencies().is_empty() {\n write!(f, \"pkg!((\\\"{}\\\", \\\"{}\\\")),\", s.name(), s.version())?;\n } else {\n write!(f, \"pkg!((\\\"{}\\\", \\\"{}\\\") => [\", s.name(), s.version())?;\n for d in s.dependencies() {\n if d.kind() == DepKind::Normal\n && &d.version_req().to_string() == \"*\"\n && !d.is_public()\n {\n write!(f, \"dep(\\\"{}\\\"),\", d.name_in_toml())?;\n } else if d.kind() == DepKind::Normal && !d.is_public() {\n write!(\n f,\n \"dep_req(\\\"{}\\\", \\\"{}\\\"),\",\n d.name_in_toml(),\n d.version_req()\n )?;\n } else {\n write!(\n f,\n \"dep_req_kind(\\\"{}\\\", \\\"{}\\\", {}, {}),\",\n d.name_in_toml(),\n d.version_req(),\n match d.kind() {\n DepKind::Development => \"DepKind::Development\",\n DepKind::Build => \"DepKind::Build\",\n DepKind::Normal => \"DepKind::Normal\",\n },\n d.is_public()\n )?;\n }\n }\n write!(f, \"]),\")?;\n }\n }\n write!(f, \"]\")\n }\n}\n\n/// This generates a random registry index.\n/// Unlike `vec((Name, Ver, vec((Name, VerRq), ..), ..)`,\n/// this strategy has a high probability of having valid dependencies.\npub fn registry_strategy(\n max_crates: usize,\n max_versions: usize,\n shrinkage: usize,\n) -> impl Strategy {\n let name = string_regex(\"[A-Za-z][A-Za-z0-9_-]*(-sys)?\").unwrap();\n\n let raw_version = ..max_versions.pow(3);\n let version_from_raw = move |r: usize| {\n let major = ((r / max_versions) / max_versions) % max_versions;\n let minor = (r / max_versions) % max_versions;\n let patch = r % max_versions;\n format!(\"{}.{}.{}\", major, minor, patch)\n };\n\n // If this is false then the crate will depend on the nonexistent \"bad\"\n // instead of the complex set we generated for it.\n let allow_deps = prop::bool::weighted(0.99);\n\n let list_of_versions =\n btree_map(raw_version, allow_deps, 1..=max_versions).prop_map(move |ver| {\n ver.into_iter()\n .map(|a| (version_from_raw(a.0), a.1))\n .collect::>()\n });\n\n let list_of_crates_with_versions =\n btree_map(name, list_of_versions, 1..=max_crates).prop_map(|mut vers| {\n // root is the name of the thing being compiled\n // so it would be confusing to have it in the index\n vers.remove(\"root\");\n // bad is a name reserved for a dep that won't work\n vers.remove(\"bad\");\n vers\n });\n\n // each version of each crate can depend on each crate smaller than it.\n // In theory shrinkage should be 2, but in practice we get better trees with a larger value.\n let max_deps = max_versions * (max_crates * (max_crates - 1)) / shrinkage;\n\n let raw_version_range = (any::(), any::());\n let raw_dependency = (any::(), any::(), raw_version_range, 0..=1);\n\n fn order_index(a: Index, b: Index, size: usize) -> (usize, usize) {\n let (a, b) = (a.index(size), b.index(size));\n (min(a, b), max(a, b))\n }\n\n let list_of_raw_dependency = vec(raw_dependency, ..=max_deps);\n\n // By default a package depends only on other packages that have a smaller name,\n // this helps make sure that all things in the resulting index are DAGs.\n // If this is true then the DAG is maintained with grater instead.\n let reverse_alphabetical = any::().no_shrink();\n\n (\n list_of_crates_with_versions,\n list_of_raw_dependency,\n reverse_alphabetical,\n )\n .prop_map(\n |(crate_vers_by_name, raw_dependencies, reverse_alphabetical)| {\n let list_of_pkgid: Vec<_> = crate_vers_by_name\n .iter()\n .flat_map(|(name, vers)| vers.iter().map(move |x| ((name.as_str(), &x.0), x.1)))\n .collect();\n let len_all_pkgid = list_of_pkgid.len();\n let mut dependency_by_pkgid = vec![vec![]; len_all_pkgid];\n for (a, b, (c, d), k) in raw_dependencies {\n let (a, b) = order_index(a, b, len_all_pkgid);\n let (a, b) = if reverse_alphabetical { (b, a) } else { (a, b) };\n let ((dep_name, _), _) = list_of_pkgid[a];\n if (list_of_pkgid[b].0).0 == dep_name {\n continue;\n }\n let s = &crate_vers_by_name[dep_name];\n let s_last_index = s.len() - 1;\n let (c, d) = order_index(c, d, s.len());\n\n dependency_by_pkgid[b].push(dep_req_kind(\n dep_name,\n &if c == 0 && d == s_last_index {\n \"*\".to_string()\n } else if c == 0 {\n format!(\"<={}\", s[d].0)\n } else if d == s_last_index {\n format!(\">={}\", s[c].0)\n } else if c == d {\n format!(\"={}\", s[c].0)\n } else {\n format!(\">={}, <={}\", s[c].0, s[d].0)\n },\n match k {\n 0 => DepKind::Normal,\n 1 => DepKind::Build,\n // => DepKind::Development, // Development has no impact so don't gen\n _ => panic!(\"bad index for DepKind\"),\n },\n ))\n }\n\n let mut out: Vec = list_of_pkgid\n .into_iter()\n .zip(dependency_by_pkgid.into_iter())\n .map(|(((name, ver), allow_deps), deps)| {\n pkg_dep(\n (name, ver).to_pkgid(),\n if !allow_deps {\n vec![dep_req(\"bad\", \"*\")]\n } else {\n let mut deps = deps;\n deps.sort_by_key(|d| d.name_in_toml());\n deps.dedup_by_key(|d| d.name_in_toml());\n deps\n },\n )\n })\n .collect();\n\n if reverse_alphabetical {\n // make sure the complicated cases are at the end\n out.reverse();\n }\n\n PrettyPrintRegistry(out)\n },\n )\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use crate::helpers::registry;\n\n #[test]\n fn meta_test_deep_pretty_print_registry() {\n assert_eq!(\n &format!(\n \"{:?}\",\n PrettyPrintRegistry(vec![\n pkg!((\"foo\", \"1.0.1\") => [dep_req(\"bar\", \"1\")]),\n pkg!((\"foo\", \"1.0.0\") => [dep_req(\"bar\", \"2\")]),\n pkg!((\"foo\", \"2.0.0\") => [dep_req(\"bar\", \"*\")]),\n pkg!((\"bar\", \"1.0.0\") => [dep_req(\"baz\", \"=1.0.2\"),\n dep_req(\"other\", \"1\")]),\n pkg!((\"bar\", \"2.0.0\") => [dep_req(\"baz\", \"=1.0.1\")]),\n pkg!((\"baz\", \"1.0.2\") => [dep_req(\"other\", \"2\")]),\n pkg!((\"baz\", \"1.0.1\")),\n pkg!((\"cat\", \"1.0.2\") => [dep_req_kind(\"other\", \"2\", DepKind::Build)]),\n pkg!((\"cat\", \"1.0.3\") => [dep_req_kind(\"other\", \"2\", DepKind::Development)]),\n pkg!((\"dep_req\", \"1.0.0\")),\n pkg!((\"dep_req\", \"2.0.0\")),\n ])\n ),\n \"vec![pkg!((\\\"foo\\\", \\\"1.0.1\\\") => [dep_req(\\\"bar\\\", \\\"^1\\\"),]),\\\n pkg!((\\\"foo\\\", \\\"1.0.0\\\") => [dep_req(\\\"bar\\\", \\\"^2\\\"),]),\\\n pkg!((\\\"foo\\\", \\\"2.0.0\\\") => [dep(\\\"bar\\\"),]),\\\n pkg!((\\\"bar\\\", \\\"1.0.0\\\") => [dep_req(\\\"baz\\\", \\\"=1.0.2\\\"),dep_req(\\\"other\\\", \\\"^1\\\"),]),\\\n pkg!((\\\"bar\\\", \\\"2.0.0\\\") => [dep_req(\\\"baz\\\", \\\"=1.0.1\\\"),]),\\\n pkg!((\\\"baz\\\", \\\"1.0.2\\\") => [dep_req(\\\"other\\\", \\\"^2\\\"),]),\\\n pkg!((\\\"baz\\\", \\\"1.0.1\\\")),\\\n pkg!((\\\"cat\\\", \\\"1.0.2\\\") => [dep_req_kind(\\\"other\\\", \\\"^2\\\", DepKind::Build, false),]),\\\n pkg!((\\\"cat\\\", \\\"1.0.3\\\") => [dep_req_kind(\\\"other\\\", \\\"^2\\\", DepKind::Development, false),]),\\\n pkg!((\\\"dep_req\\\", \\\"1.0.0\\\")),\\\n pkg!((\\\"dep_req\\\", \\\"2.0.0\\\")),]\"\n )\n }\n\n /// This test is to test the generator to ensure\n /// that it makes registries with large dependency trees\n #[test]\n fn meta_test_deep_trees_from_strategy() {\n use proptest::strategy::ValueTree;\n use proptest::test_runner::TestRunner;\n\n let mut dis = [0; 21];\n\n let strategy = registry_strategy(50, 20, 60);\n let mut test_runner = TestRunner::deterministic();\n for _ in 0..128 {\n let PrettyPrintRegistry(input) = strategy\n .new_tree(&mut TestRunner::new_with_rng(\n Default::default(),\n test_runner.new_rng(),\n ))\n .unwrap()\n .current();\n let reg = registry(input.clone());\n for this in input.iter().rev().take(10) {\n let res = resolve(\n vec![dep_req(&this.name(), &format!(\"={}\", this.version()))],\n ®,\n );\n dis[res\n .as_ref()\n .map(|x| min(x.len(), dis.len()) - 1)\n .unwrap_or(0)] += 1;\n if dis.iter().all(|&x| x > 0) {\n return;\n }\n }\n }\n\n panic!(\n \"In 1280 tries we did not see a wide enough distribution \\\n of dependency trees! dis: {dis:?}\"\n );\n }\n\n /// This test is to test the generator to ensure\n /// that it makes registries that include multiple versions of the same library\n #[test]\n fn meta_test_multiple_versions_strategy() {\n use proptest::strategy::ValueTree;\n use proptest::test_runner::TestRunner;\n\n let mut dis = [0; 10];\n\n let strategy = registry_strategy(50, 20, 60);\n let mut test_runner = TestRunner::deterministic();\n for _ in 0..128 {\n let PrettyPrintRegistry(input) = strategy\n .new_tree(&mut TestRunner::new_with_rng(\n Default::default(),\n test_runner.new_rng(),\n ))\n .unwrap()\n .current();\n let reg = registry(input.clone());\n for this in input.iter().rev().take(10) {\n let res = resolve(\n vec![dep_req(&this.name(), &format!(\"={}\", this.version()))],\n ®,\n );\n if let Ok(mut res) = res {\n let res_len = res.len();\n res.sort_by_key(|s| s.name());\n res.dedup_by_key(|s| s.name());\n dis[min(res_len - res.len(), dis.len() - 1)] += 1;\n }\n if dis.iter().all(|&x| x > 0) {\n return;\n }\n }\n }\n panic!(\n \"In 1280 tries we did not see a wide enough distribution \\\n of multiple versions of the same library! dis: {dis:?}\"\n );\n }\n}\n" }, { "path": "crates/resolver-tests/src/sat.rs", "content": "use std::collections::hash_map::Entry;\nuse std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};\nuse std::fmt::Write;\n\nuse cargo::core::dependency::DepKind;\nuse cargo::core::{Dependency, FeatureMap, FeatureValue, PackageId, Summary};\nuse cargo::util::interning::{INTERNED_DEFAULT, InternedString};\nuse cargo_platform::Platform;\nuse varisat::ExtendFormula;\n\nconst fn num_bits() -> usize {\n std::mem::size_of::() * 8\n}\n\nfn log_bits(x: usize) -> usize {\n if x == 0 {\n return 0;\n }\n assert!(x > 0);\n (num_bits::() as u32 - x.leading_zeros()) as usize\n}\n\n/// At this point is possible to select every version of every package.\n///\n/// So we need to mark certain versions as incompatible with each other.\n/// We could add a clause not A, not B for all A and B that are incompatible,\nfn sat_at_most_one(solver: &mut varisat::Solver<'_>, vars: &[varisat::Var]) {\n if vars.len() <= 1 {\n return;\n } else if vars.len() == 2 {\n solver.add_clause(&[vars[0].negative(), vars[1].negative()]);\n return;\n } else if vars.len() == 3 {\n solver.add_clause(&[vars[0].negative(), vars[1].negative()]);\n solver.add_clause(&[vars[0].negative(), vars[2].negative()]);\n solver.add_clause(&[vars[1].negative(), vars[2].negative()]);\n return;\n }\n // There are more efficient ways to do it for large numbers of versions.\n //\n // Use the \"Binary Encoding\" from\n // https://www.it.uu.se/research/group/astra/ModRef10/papers/Alan%20M.%20Frisch%20and%20Paul%20A.%20Giannoros.%20SAT%20Encodings%20of%20the%20At-Most-k%20Constraint%20-%20ModRef%202010.pdf\n let bits: Vec = solver.new_var_iter(log_bits(vars.len())).collect();\n for (i, p) in vars.iter().enumerate() {\n for b in 0..bits.len() {\n solver.add_clause(&[p.negative(), bits[b].lit(((1 << b) & i) > 0)]);\n }\n }\n}\n\nfn sat_at_most_one_by_key(\n solver: &mut varisat::Solver<'_>,\n data: impl Iterator,\n) -> HashMap> {\n // No two packages with the same keys set\n let mut by_keys: HashMap> = HashMap::new();\n for (p, v) in data {\n by_keys.entry(p).or_default().push(v)\n }\n for key in by_keys.values() {\n sat_at_most_one(solver, key);\n }\n by_keys\n}\n\ntype DependencyVarMap<'a> =\n HashMap), varisat::Var>>;\n\ntype DependencyFeatureVarMap<'a> = HashMap<\n InternedString,\n HashMap<(DepKind, Option<&'a Platform>), HashMap>,\n>;\n\nfn create_dependencies_vars<'a>(\n solver: &mut varisat::Solver<'_>,\n pkg_var: varisat::Var,\n pkg_dependencies: &'a [Dependency],\n pkg_features: &FeatureMap,\n) -> (DependencyVarMap<'a>, DependencyFeatureVarMap<'a>) {\n let mut var_for_is_dependencies_used = DependencyVarMap::new();\n let mut var_for_is_dependencies_features_used = DependencyFeatureVarMap::new();\n\n for dep in pkg_dependencies {\n let (name, kind, platform) = (dep.name_in_toml(), dep.kind(), dep.platform());\n\n var_for_is_dependencies_used\n .entry(name)\n .or_default()\n .insert((kind, platform), solver.new_var());\n\n let dep_feature_vars = var_for_is_dependencies_features_used\n .entry(name)\n .or_default()\n .entry((kind, platform))\n .or_default();\n\n for &feature_name in dep.features() {\n if let Entry::Vacant(entry) = dep_feature_vars.entry(feature_name) {\n entry.insert(solver.new_var());\n }\n }\n }\n\n for feature_values in pkg_features.values() {\n for feature_value in feature_values {\n let FeatureValue::DepFeature {\n dep_name,\n dep_feature,\n weak: _,\n } = *feature_value\n else {\n continue;\n };\n\n for dep_feature_vars in var_for_is_dependencies_features_used\n .get_mut(&dep_name)\n .expect(\"feature dep name exists\")\n .values_mut()\n {\n if let Entry::Vacant(entry) = dep_feature_vars.entry(dep_feature) {\n entry.insert(solver.new_var());\n }\n }\n }\n }\n\n // If a package dependency is used, then the package is used\n for dep_var_map in var_for_is_dependencies_used.values() {\n for dep_var in dep_var_map.values() {\n solver.add_clause(&[dep_var.negative(), pkg_var.positive()]);\n }\n }\n\n // If a dependency feature is used, then the dependency is used\n for (&dep_name, map) in &mut var_for_is_dependencies_features_used {\n for (&(dep_kind, dep_platform), dep_feature_var_map) in map {\n for dep_feature_var in dep_feature_var_map.values() {\n let dep_var_map = &var_for_is_dependencies_used[&dep_name];\n let dep_var = dep_var_map[&(dep_kind, dep_platform)];\n solver.add_clause(&[dep_feature_var.negative(), dep_var.positive()]);\n }\n }\n }\n\n (\n var_for_is_dependencies_used,\n var_for_is_dependencies_features_used,\n )\n}\n\nfn process_pkg_dependencies(\n solver: &mut varisat::Solver<'_>,\n var_for_is_dependencies_used: &DependencyVarMap<'_>,\n var_for_is_dependencies_features_used: &DependencyFeatureVarMap<'_>,\n pkg_var: varisat::Var,\n pkg_dependencies: &[Dependency],\n) {\n // Add clauses for package dependencies\n for dep in pkg_dependencies {\n let (name, kind, platform) = (dep.name_in_toml(), dep.kind(), dep.platform());\n let dep_var_map = &var_for_is_dependencies_used[&name];\n let dep_var = dep_var_map[&(kind, platform)];\n\n if !dep.is_optional() {\n solver.add_clause(&[pkg_var.negative(), dep_var.positive()]);\n }\n\n for &feature_name in dep.features() {\n let dep_feature_var =\n &var_for_is_dependencies_features_used[&name][&(kind, platform)][&feature_name];\n\n solver.add_clause(&[dep_var.negative(), dep_feature_var.positive()]);\n }\n }\n}\n\nfn process_pkg_features(\n solver: &mut varisat::Solver<'_>,\n var_for_is_dependencies_used: &DependencyVarMap<'_>,\n var_for_is_dependencies_features_used: &DependencyFeatureVarMap<'_>,\n pkg_feature_var_map: &HashMap,\n pkg_dependencies: &[Dependency],\n pkg_features: &FeatureMap,\n) {\n let optional_dependencies = pkg_dependencies\n .iter()\n .filter(|dep| dep.is_optional())\n .map(|dep| (dep.kind(), dep.platform(), dep.name_in_toml()))\n .collect::>();\n\n // Add clauses for package features\n for (&feature_name, feature_values) in pkg_features {\n for feature_value in feature_values {\n let pkg_feature_var = pkg_feature_var_map[&feature_name];\n\n match *feature_value {\n FeatureValue::Feature(other_feature_name) => {\n solver.add_clause(&[\n pkg_feature_var.negative(),\n pkg_feature_var_map[&other_feature_name].positive(),\n ]);\n }\n FeatureValue::Dep { dep_name } => {\n // Add a clause for each dependency with the provided name (normal/build/dev with target)\n for (&(dep_kind, _), &dep_var) in &var_for_is_dependencies_used[&dep_name] {\n if dep_kind == DepKind::Development {\n continue;\n }\n solver.add_clause(&[pkg_feature_var.negative(), dep_var.positive()]);\n }\n }\n FeatureValue::DepFeature {\n dep_name,\n dep_feature: dep_feature_name,\n weak,\n } => {\n // Behavior of the feature:\n // * if dependency `dep_name` is not optional, its feature `\"dep_feature_name\"` is activated.\n // * if dependency `dep_name` is optional:\n // - if this is a weak dependency feature:\n // - feature `\"dep_feature_name\"` of dependency `dep_name` is activated if `dep_name` has been activated via another feature.\n // - if this is not a weak dependency feature:\n // - feature `dep_name` is activated if it exists.\n // - dependency `dep_name` is activated.\n // - feature `\"dep_feature_name\"` of dependency `dep_name` is activated.\n\n // Add clauses for each dependency with the provided name (normal/build/dev with target)\n let dep_var_map = &var_for_is_dependencies_used[&dep_name];\n for (&(dep_kind, dep_platform), &dep_var) in dep_var_map {\n if dep_kind == DepKind::Development {\n continue;\n }\n\n let dep_feature_var = &var_for_is_dependencies_features_used[&dep_name]\n [&(dep_kind, dep_platform)][&dep_feature_name];\n\n solver.add_clause(&[\n pkg_feature_var.negative(),\n dep_var.negative(),\n dep_feature_var.positive(),\n ]);\n\n let key = (dep_kind, dep_platform, dep_name);\n if !weak && optional_dependencies.contains(&key) {\n solver.add_clause(&[pkg_feature_var.negative(), dep_var.positive()]);\n\n if let Some(other_feature_var) = pkg_feature_var_map.get(&dep_name) {\n solver.add_clause(&[\n pkg_feature_var.negative(),\n other_feature_var.positive(),\n ]);\n }\n }\n }\n }\n }\n }\n }\n}\n\nfn process_compatible_dep_summaries(\n solver: &mut varisat::Solver<'_>,\n var_for_is_dependencies_used: &DependencyVarMap<'_>,\n var_for_is_dependencies_features_used: &DependencyFeatureVarMap<'_>,\n var_for_is_packages_used: &HashMap,\n var_for_is_packages_features_used: &HashMap>,\n by_name: &HashMap>,\n pkg_dependencies: &[Dependency],\n check_dev_dependencies: bool,\n) {\n for dep in pkg_dependencies {\n if dep.kind() == DepKind::Development && !check_dev_dependencies {\n continue;\n }\n\n let (name, kind, platform) = (dep.name_in_toml(), dep.kind(), dep.platform());\n let dep_var = var_for_is_dependencies_used[&name][&(kind, platform)];\n let dep_feature_var_map = &var_for_is_dependencies_features_used[&name][&(kind, platform)];\n\n let compatible_pkg_ids = by_name\n .get(&dep.package_name())\n .into_iter()\n .flatten()\n .filter(|s| dep.matches(s))\n .filter(|s| dep.features().iter().all(|f| s.features().contains_key(f)))\n .map(|s| s.package_id())\n .collect::>();\n\n // At least one compatible package should be activated\n let dep_clause = compatible_pkg_ids\n .iter()\n .map(|id| var_for_is_packages_used[&id].positive())\n .chain([dep_var.negative()])\n .collect::>();\n\n solver.add_clause(&dep_clause);\n\n for (&feature_name, &dep_feature_var) in dep_feature_var_map {\n // At least one compatible package with the additional feature should be activated\n let dep_feature_clause = compatible_pkg_ids\n .iter()\n .filter_map(|id| var_for_is_packages_features_used[&id].get(&feature_name))\n .map(|var| var.positive())\n .chain([dep_feature_var.negative()])\n .collect::>();\n\n solver.add_clause(&dep_feature_clause);\n }\n\n if dep.uses_default_features() {\n // For the selected package for this dependency, the `\"default\"` feature should be activated if it exists\n let mut dep_default_clause = vec![dep_var.negative()];\n\n for &id in &compatible_pkg_ids {\n let s_var = var_for_is_packages_used[&id];\n let s_feature_var_map = &var_for_is_packages_features_used[&id];\n\n if let Some(s_default_feature_var) = s_feature_var_map.get(&INTERNED_DEFAULT) {\n dep_default_clause\n .extend_from_slice(&[s_var.negative(), s_default_feature_var.positive()]);\n } else {\n dep_default_clause.push(s_var.positive());\n }\n }\n\n solver.add_clause(&dep_default_clause);\n }\n }\n}\n\n/// Resolution can be reduced to the SAT problem.\n///\n/// So this is an alternative implementation\n/// of the resolver that uses a SAT library for the hard work. This is intended to be easy to read,\n/// as compared to the real resolver.\n///\n/// For the subset of functionality that are currently made by `registry_strategy`,\n/// this will find a valid resolution if one exists.\n///\n/// The SAT library does not optimize for the newer version,\n/// so the selected packages may not match the real resolver.\npub struct SatResolver {\n solver: varisat::Solver<'static>,\n old_root_vars: Vec,\n var_for_is_packages_used: HashMap,\n var_for_is_packages_features_used: HashMap>,\n by_name: HashMap>,\n}\n\nimpl SatResolver {\n pub fn new<'a>(registry: impl IntoIterator) -> Self {\n let mut by_name: HashMap> = HashMap::new();\n for pkg in registry {\n by_name.entry(pkg.name()).or_default().push(pkg.clone());\n }\n\n let mut solver = varisat::Solver::new();\n\n // Create boolean variables for packages and packages features\n let mut var_for_is_packages_used = HashMap::new();\n let mut var_for_is_packages_features_used = HashMap::<_, HashMap<_, _>>::new();\n\n for pkg in by_name.values().flatten() {\n let pkg_id = pkg.package_id();\n\n var_for_is_packages_used.insert(pkg_id, solver.new_var());\n\n var_for_is_packages_features_used.insert(\n pkg_id,\n (pkg.features().keys().map(|&f| (f, solver.new_var()))).collect(),\n );\n }\n\n // If a package feature is used, then the package is used\n for (&pkg_id, pkg_feature_var_map) in &var_for_is_packages_features_used {\n for pkg_feature_var in pkg_feature_var_map.values() {\n let pkg_var = var_for_is_packages_used[&pkg_id];\n solver.add_clause(&[pkg_feature_var.negative(), pkg_var.positive()]);\n }\n }\n\n // No two packages with the same links set\n sat_at_most_one_by_key(\n &mut solver,\n by_name\n .values()\n .flatten()\n .map(|s| (s.links(), var_for_is_packages_used[&s.package_id()]))\n .filter(|(l, _)| l.is_some()),\n );\n\n // No two semver compatible versions of the same package\n sat_at_most_one_by_key(\n &mut solver,\n var_for_is_packages_used\n .iter()\n .map(|(p, &v)| (p.as_activations_key(), v)),\n );\n\n for pkg in by_name.values().flatten() {\n let pkg_id = pkg.package_id();\n let pkg_dependencies = pkg.dependencies();\n let pkg_features = pkg.features();\n let pkg_var = var_for_is_packages_used[&pkg_id];\n\n // Create boolean variables for dependencies and dependencies features\n let (var_for_is_dependencies_used, var_for_is_dependencies_features_used) =\n create_dependencies_vars(&mut solver, pkg_var, pkg_dependencies, pkg_features);\n\n process_pkg_dependencies(\n &mut solver,\n &var_for_is_dependencies_used,\n &var_for_is_dependencies_features_used,\n pkg_var,\n pkg_dependencies,\n );\n\n process_pkg_features(\n &mut solver,\n &var_for_is_dependencies_used,\n &var_for_is_dependencies_features_used,\n &var_for_is_packages_features_used[&pkg_id],\n pkg_dependencies,\n pkg_features,\n );\n\n process_compatible_dep_summaries(\n &mut solver,\n &var_for_is_dependencies_used,\n &var_for_is_dependencies_features_used,\n &var_for_is_packages_used,\n &var_for_is_packages_features_used,\n &by_name,\n pkg_dependencies,\n false,\n );\n }\n\n // We don't need to `solve` now. We know that \"use nothing\" will satisfy all the clauses so far.\n // But things run faster if we let it spend some time figuring out how the constraints interact before we add assumptions.\n solver\n .solve()\n .expect(\"docs say it can't error in default config\");\n\n SatResolver {\n solver,\n old_root_vars: Vec::new(),\n var_for_is_packages_used,\n var_for_is_packages_features_used,\n by_name,\n }\n }\n\n pub fn sat_resolve(&mut self, root_dependencies: &[Dependency]) -> bool {\n let SatResolver {\n solver,\n old_root_vars,\n var_for_is_packages_used,\n var_for_is_packages_features_used,\n by_name,\n } = self;\n\n let root_var = solver.new_var();\n\n // Create boolean variables for dependencies and dependencies features\n let (var_for_is_dependencies_used, var_for_is_dependencies_features_used) =\n create_dependencies_vars(solver, root_var, root_dependencies, &FeatureMap::new());\n\n process_pkg_dependencies(\n solver,\n &var_for_is_dependencies_used,\n &var_for_is_dependencies_features_used,\n root_var,\n root_dependencies,\n );\n\n process_compatible_dep_summaries(\n solver,\n &var_for_is_dependencies_used,\n &var_for_is_dependencies_features_used,\n var_for_is_packages_used,\n var_for_is_packages_features_used,\n by_name,\n root_dependencies,\n true,\n );\n\n // Root package is always used.\n // Root vars from previous runs are deactivated.\n let assumption = old_root_vars\n .iter()\n .map(|v| v.negative())\n .chain([root_var.positive()])\n .collect::>();\n\n old_root_vars.push(root_var);\n\n solver.assume(&assumption);\n\n solver\n .solve()\n .expect(\"docs say it can't error in default config\")\n }\n\n pub fn sat_is_valid_solution(&mut self, pkgs: &[(PackageId, Vec)]) -> bool {\n let contains_pkg = |pkg| pkgs.iter().any(|(p, _)| p == pkg);\n let contains_pkg_feature =\n |pkg, f| pkgs.iter().any(|(p, flist)| p == pkg && flist.contains(f));\n\n for (p, _) in pkgs {\n if p.name() != \"root\" && !self.var_for_is_packages_used.contains_key(p) {\n return false;\n }\n }\n\n // Root vars from previous runs are deactivated\n let assumption = (self.old_root_vars.iter().map(|v| v.negative()))\n .chain(\n self.var_for_is_packages_used\n .iter()\n .map(|(p, v)| v.lit(contains_pkg(p))),\n )\n .chain(\n self.var_for_is_packages_features_used\n .iter()\n .flat_map(|(p, fmap)| {\n fmap.iter()\n .map(move |(f, v)| v.lit(contains_pkg_feature(p, f)))\n }),\n )\n .collect::>();\n\n self.solver.assume(&assumption);\n\n self.solver\n .solve()\n .expect(\"docs say it can't error in default config\")\n }\n\n pub fn used_packages(&self) -> Option {\n self.solver.model().map(|lits| {\n let lits: HashSet<_> = lits\n .iter()\n .filter(|l| l.is_positive())\n .map(|l| l.var())\n .collect();\n\n let mut used_packages = BTreeMap::>::new();\n for (&p, v) in self.var_for_is_packages_used.iter() {\n if lits.contains(v) {\n used_packages.entry(p).or_default();\n }\n }\n for (&p, map) in &self.var_for_is_packages_features_used {\n for (&f, v) in map {\n if lits.contains(v) {\n used_packages\n .get_mut(&p)\n .expect(\"the feature is activated without the package being activated\")\n .insert(f);\n }\n }\n }\n\n let mut out = String::from(\"used:\\n\");\n for (package, feature_names) in used_packages {\n writeln!(&mut out, \" {package}\").unwrap();\n for feature_name in feature_names {\n writeln!(&mut out, \" + {feature_name}\").unwrap();\n }\n }\n\n out\n })\n }\n}\n" }, { "path": "crates/resolver-tests/tests/proptests.rs", "content": "use std::io::IsTerminal;\n\nuse cargo::util::GlobalContext;\nuse cargo_util::is_ci;\n\nuse resolver_tests::{\n PrettyPrintRegistry,\n helpers::{dep_req, registry, remove_dep},\n registry_strategy, resolve, resolve_and_validated, resolve_with_global_context,\n sat::SatResolver,\n};\n\nuse proptest::prelude::*;\n\n// NOTE: proptest is a form of fuzz testing. It generates random input and makes sure that\n// certain universal truths are upheld. Therefore, it can pass when there is a problem,\n// but if it fails then there really is something wrong. When testing something as\n// complicated as the resolver, the problems can be very subtle and hard to generate.\n// We have had a history of these tests only failing on PRs long after a bug is introduced.\n// If you have one of these test fail please report it on #6258,\n// and if you did not change the resolver then feel free to retry without concern.\nproptest! {\n #![proptest_config(ProptestConfig {\n max_shrink_iters:\n if is_ci() || !std::io::stderr().is_terminal() {\n // This attempts to make sure that CI will fail fast,\n 0\n } else {\n // but that local builds will give a small clear test case.\n u32::MAX\n },\n result_cache: prop::test_runner::basic_result_cache,\n .. ProptestConfig::default()\n })]\n\n /// NOTE: if you think this test has failed spuriously see the note at the top of this macro.\n #[test]\n fn prop_passes_validation(\n PrettyPrintRegistry(input) in registry_strategy(50, 20, 60)\n ) {\n let reg = registry(input.clone());\n let mut sat_resolver = SatResolver::new(®);\n\n // There is only a small chance that a crate will be interesting.\n // So we try some of the most complicated.\n for this in input.iter().rev().take(20) {\n let _ = resolve_and_validated(\n vec![dep_req(&this.name(), &format!(\"={}\", this.version()))],\n ®,\n &mut sat_resolver,\n );\n }\n }\n\n /// NOTE: if you think this test has failed spuriously see the note at the top of this macro.\n #[test]\n fn prop_minimum_version_errors_the_same(\n PrettyPrintRegistry(input) in registry_strategy(50, 20, 60)\n ) {\n let mut gctx = GlobalContext::default().unwrap();\n gctx.nightly_features_allowed = true;\n gctx\n .configure(\n 1,\n false,\n None,\n false,\n false,\n false,\n &None,\n &[\"minimal-versions\".to_string()],\n &[],\n )\n .unwrap();\n\n let reg = registry(input.clone());\n\n // There is only a small chance that a crate will be interesting.\n // So we try some of the most complicated.\n for this in input.iter().rev().take(10) {\n let deps = vec![dep_req(&this.name(), &format!(\"={}\", this.version()))];\n let res = resolve(deps.clone(), ®);\n let mres = resolve_with_global_context(deps, ®, &gctx);\n\n // `minimal-versions` changes what order the candidates are tried but not the existence of a solution.\n prop_assert_eq!(\n res.is_ok(),\n mres.is_ok(),\n \"minimal-versions and regular resolver disagree about whether `{} = \\\"={}\\\"` can resolve\",\n this.name(),\n this.version()\n )\n }\n }\n\n /// NOTE: if you think this test has failed spuriously see the note at the top of this macro.\n #[test]\n fn prop_direct_minimum_version_error_implications(\n PrettyPrintRegistry(input) in registry_strategy(50, 20, 60)\n ) {\n let mut gctx = GlobalContext::default().unwrap();\n gctx.nightly_features_allowed = true;\n gctx\n .configure(\n 1,\n false,\n None,\n false,\n false,\n false,\n &None,\n &[\"direct-minimal-versions\".to_string()],\n &[],\n )\n .unwrap();\n\n let reg = registry(input.clone());\n\n // There is only a small chance that a crate will be interesting.\n // So we try some of the most complicated.\n for this in input.iter().rev().take(10) {\n let deps = vec![dep_req(&this.name(), &format!(\"={}\", this.version()))];\n let res = resolve(deps.clone(), ®);\n let mres = resolve_with_global_context(deps, ®, &gctx);\n\n // `direct-minimal-versions` reduces the number of available solutions,\n // so we verify that we do not come up with solutions not seen in `maximal-versions`.\n if res.is_err() {\n prop_assert!(\n mres.is_err(),\n \"direct-minimal-versions should not have more solutions than the regular, maximal resolver but found one when resolving `{} = \\\"={}\\\"`\",\n this.name(),\n this.version()\n )\n }\n if mres.is_ok() {\n prop_assert!(\n res.is_ok(),\n \"direct-minimal-versions should not have more solutions than the regular, maximal resolver but found one when resolving `{} = \\\"={}\\\"`\",\n this.name(),\n this.version()\n )\n }\n }\n }\n\n /// NOTE: if you think this test has failed spuriously see the note at the top of this macro.\n #[test]\n fn prop_removing_a_dep_cant_break(\n PrettyPrintRegistry(input) in registry_strategy(50, 20, 60),\n indexes_to_remove in prop::collection::vec((any::(), any::()), ..10)\n ) {\n let reg = registry(input.clone());\n let mut removed_input = input.clone();\n for (summary_idx, dep_idx) in indexes_to_remove {\n if !removed_input.is_empty() {\n let summary_idx = summary_idx.index(removed_input.len());\n let deps = removed_input[summary_idx].dependencies();\n if !deps.is_empty() {\n let new = remove_dep(&removed_input[summary_idx], dep_idx.index(deps.len()));\n removed_input[summary_idx] = new;\n }\n }\n }\n let removed_reg = registry(removed_input);\n\n // There is only a small chance that a crate will be interesting.\n // So we try some of the most complicated.\n for this in input.iter().rev().take(10) {\n if resolve(\n vec![dep_req(&this.name(), &format!(\"={}\", this.version()))],\n ®,\n ).is_ok() {\n prop_assert!(\n resolve(\n vec![dep_req(&this.name(), &format!(\"={}\", this.version()))],\n &removed_reg,\n ).is_ok(),\n \"full index worked for `{} = \\\"={}\\\"` but removing some deps broke it!\",\n this.name(),\n this.version(),\n )\n }\n }\n }\n\n /// NOTE: if you think this test has failed spuriously see the note at the top of this macro.\n #[test]\n fn prop_limited_independence_of_irrelevant_alternatives(\n PrettyPrintRegistry(input) in registry_strategy(50, 20, 60),\n indexes_to_unpublish in prop::collection::vec(any::(), ..10)\n ) {\n let reg = registry(input.clone());\n\n // There is only a small chance that a crate will be interesting.\n // So we try some of the most complicated.\n for this in input.iter().rev().take(10) {\n let res = resolve(\n vec![dep_req(&this.name(), &format!(\"={}\", this.version()))],\n ®,\n );\n\n match res {\n Ok(r) => {\n // If resolution was successful, then unpublishing a version of a crate\n // that was not selected should not change that.\n let not_selected: Vec<_> = input\n .iter().filter(|&x| !r.contains(&x.package_id())).cloned()\n .collect();\n\n if !not_selected.is_empty() {\n let indexes_to_unpublish: Vec<_> = indexes_to_unpublish.iter().map(|x| x.get(¬_selected)).collect();\n\n let new_reg = registry(\n input\n .iter().filter(|&x| !indexes_to_unpublish.contains(&x)).cloned()\n .collect(),\n );\n\n let res = resolve(\n vec![dep_req(&this.name(), &format!(\"={}\", this.version()))],\n &new_reg,\n );\n\n // Note: that we can not assert that the two `res` are identical\n // as the resolver does depend on irrelevant alternatives.\n // It uses how constrained a dependency requirement is\n // to determine what order to evaluate requirements.\n\n prop_assert!(\n res.is_ok(),\n \"unpublishing {:?} stopped `{} = \\\"={}\\\"` from working\",\n indexes_to_unpublish.iter().map(|x| x.package_id()).collect::>(),\n this.name(),\n this.version()\n )\n }\n }\n\n Err(_) => {\n // If resolution was unsuccessful, then it should stay unsuccessful\n // even if any version of a crate is unpublished.\n let indexes_to_unpublish: Vec<_> = indexes_to_unpublish.iter().map(|x| x.get(&input)).collect();\n\n let new_reg = registry(\n input\n .iter().filter(|&x| !indexes_to_unpublish.contains(&x)).cloned()\n .collect(),\n );\n\n let res = resolve(\n vec![dep_req(&this.name(), &format!(\"={}\", this.version()))],\n &new_reg,\n );\n\n prop_assert!(\n res.is_err(),\n \"full index did not work for `{} = \\\"={}\\\"` but unpublishing {:?} fixed it!\",\n this.name(),\n this.version(),\n indexes_to_unpublish.iter().map(|x| x.package_id()).collect::>(),\n )\n }\n }\n }\n }\n}\n" }, { "path": "crates/resolver-tests/tests/pubgrub.rs", "content": "use cargo::core::{Dependency, dependency::DepKind};\n\nuse resolver_tests::{\n helpers::{\n ToDep, dep, dep_kind, dep_req, dep_req_kind, pkg, pkg_dep, pkg_dep_link, pkg_dep_with,\n pkg_id_source, registry,\n },\n pkg, resolve, resolve_and_validated, resolve_and_validated_raw,\n sat::SatResolver,\n};\n\n#[test]\nfn test_01_renamed_package() {\n let reg = registry(vec![\n pkg_dep_with(\n \"a\",\n vec![\"b\".opt().rename(\"b_package\")],\n &[(\"default\", &[\"b_package\"])],\n ),\n pkg(\"b\"),\n ]);\n\n let deps = vec![\"a\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_02_renamed_package_no_shadowing() {\n let reg = registry(vec![\n pkg(\"url\"),\n pkg_dep(\"wasmi\", vec![\"wasmparser-nostd\".rename(\"wasmparser\")]),\n pkg_dep(\"wasmparser\", vec![\"url\".to_dep()]),\n ]);\n\n let deps = vec![dep(\"wasmi\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_03_prerelease_semver() {\n let reg = registry(vec![\n pkg!(\"parking_lot_core\" => [dep_req(\"smallvec\", \"^1.6.1\")]),\n pkg((\"smallvec\", \"2.0.0-alpha.3\")),\n pkg_dep_with(\n (\"tokio\", \"1.35.1\"),\n vec![\"parking_lot_core\".opt()],\n &[(\"default\", &[\"parking_lot_core\"])],\n ),\n ]);\n\n let deps = vec![\"tokio\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_04_cyclic_features() {\n let reg = registry(vec![pkg_dep_with(\n \"windows\",\n vec![],\n &[\n (\"Win32\", &[\"Win32_Foundation\"]),\n (\"Win32_Foundation\", &[\"Win32\"]),\n ],\n )]);\n\n let deps = vec![\"windows\".with(&[\"Win32_Foundation\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_05_cyclic_optional_dependencies() {\n let reg = registry(vec![\n pkg_dep(\"async-global-executor\", vec![\"io-lifetimes\".opt()]),\n pkg_dep(\n \"io-lifetimes\",\n vec![\"test\".with(&[\"async-global-executor\"])],\n ),\n pkg_dep_with(\n \"test\",\n vec![\"async-global-executor\".opt().with(&[\"io-lifetimes\"])],\n &[],\n ),\n ]);\n\n let deps = vec![dep(\"test\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_06_cyclic_dependencies() {\n let reg = registry(vec![\n pkg((\"a\", \"1.0.0\")),\n pkg_dep((\"a\", \"1.0.1\"), vec![dep(\"dep\")]),\n pkg_dep(\"dep\", vec![dep(\"a\")]),\n ]);\n\n let deps = vec![dep(\"dep\")];\n\n // Cyclic dependencies are not checked in the SAT resolver\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n}\n\n#[test]\nfn test_07_self_dependency() {\n let reg = registry(vec![pkg_dep(\"dep\", vec![dep(\"dep\")])]);\n\n let deps = vec![dep(\"dep\")];\n\n // Cyclic dependencies are not checked in the SAT resolver\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n}\n\n#[test]\nfn test_08_activated_optional_self_dependency() {\n let reg = registry(vec![pkg_dep(\"a\", vec![\"a\".opt()])]);\n\n let deps = vec![\"a\".with(&[\"a\"])];\n\n // Cyclic dependencies are not checked in the SAT resolver\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n}\n\n#[test]\nfn test_09_build_dependency_with_same_name() {\n let reg = registry(vec![\n pkg(\"memchr\"),\n pkg_dep_with(\n (\"regex\", \"1.4.6\"),\n vec![\"memchr\".opt()],\n &[(\"default\", &[\"memchr\"])],\n ),\n pkg_dep(\"sv-parser\", vec![\"regex\".with(&[\"default\"])]),\n pkg_dep(\n \"svlint\",\n vec![\n dep_req(\"regex\", \"^1.5\"),\n dep_req_kind(\"regex\", \"^1\", DepKind::Build),\n dep(\"sv-parser\"),\n ],\n ),\n ]);\n\n let deps = vec![dep(\"svlint\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_10_root_dev_dependency_with_same_name() {\n let reg = registry(vec![pkg((\"root\", \"1.0.1\"))]);\n\n let deps = vec![dep_req_kind(\"root\", \"=1.0.1\", DepKind::Development).rename(\"root101\")];\n let source = pkg_id_source(\"root\", \"https://root.example.com\");\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated_raw(deps, ®, source, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_11_dev_dependency() {\n let reg = registry(vec![pkg_dep_with(\n \"burn-core\",\n vec![dep_kind(\"burn-ndarray\", DepKind::Development)],\n &[(\"default\", &[\"burn-ndarray/std\"])],\n )]);\n\n let deps = vec![\"burn-core\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_12_weak_dependencies() {\n let reg = registry(vec![\n pkg_dep_with(\"borsh\", vec![\"borsh-derive\".opt()], &[(\"std\", &[])]),\n pkg_dep_with(\n \"rust_decimal\",\n vec![\"borsh\".opt().with(&[\"borsh-derive\"])],\n &[(\"default\", &[\"borsh?/std\"])],\n ),\n ]);\n\n let deps = vec![\"rust_decimal\".with(&[\"default\"])];\n\n // Weak dependencies are not supported yet in the dependency resolver\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n}\n\n#[test]\nfn test_13_weak_dependencies() {\n let reg = registry(vec![\n pkg_dep_with(\"memchr\", vec![\"std\".opt()], &[(\"std\", &[\"dep:std\"])]),\n pkg_dep_with(\n \"winnow\",\n vec![\"memchr\".opt()],\n &[(\"default\", &[\"memchr?/std\"]), (\"simd\", &[\"dep:memchr\"])],\n ),\n ]);\n\n let deps = vec![\"winnow\".with(&[\"default\"])];\n\n // Weak dependencies are not supported yet in the dependency resolver\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n}\n\n#[test]\nfn test_14_weak_dependencies() {\n let reg = registry(vec![\n pkg_dep(\"a\", vec![dep(\"bad\")]),\n pkg_dep_with(\"b\", vec![\"a\".opt()], &[(\"perf-literal\", &[\"dep:a\"])]),\n pkg_dep_with(\n \"c\",\n vec![\"b\".opt()],\n &[\n (\"perf-literal\", &[\"b?/perf-literal\"]),\n (\"perf-literal-multisubstring\", &[\"dep:b\"]),\n ],\n ),\n pkg_dep_with(\"dep\", vec![dep(\"c\")], &[(\"default\", &[\"c/perf-literal\"])]),\n ]);\n\n let deps = vec![\"dep\".with(&[\"default\"])];\n\n // Weak dependencies are not supported yet in the dependency resolver\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n}\n\n#[test]\nfn test_15_duplicate_sys_crate() {\n let reg = registry(vec![\n pkg_dep_link(\"js\", \"js\", vec![]),\n pkg_dep_link(\"dep\", \"js\", vec![dep(\"js\")]),\n ]);\n\n let deps = vec![dep(\"dep\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_16_missing_optional_dependency() {\n let reg = registry(vec![\n pkg_dep(\"b\", vec![\"c\".opt()]),\n pkg_dep_with(\"dep\", vec![dep(\"b\")], &[(\"d\", &[\"b/c\"])]),\n ]);\n\n let deps = vec![\"dep\".with(&[\"d\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_17_feature_shadowing_missing_optional_dependency() {\n let reg = registry(vec![pkg_dep_with(\n \"rustix\",\n vec![\"alloc\".opt()],\n &[\n (\"alloc\", &[]),\n (\"default\", &[\"alloc\"]),\n (\"rustc-dep-of-std\", &[\"dep:alloc\"]),\n ],\n )]);\n\n let deps = vec![\"rustix\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_18_feature_shadowing_activated_optional_dependency() {\n let reg = registry(vec![\n pkg_dep(\"alloc\", vec![dep(\"bad\")]),\n pkg_dep_with(\n \"rustix\",\n vec![\"alloc\".opt()],\n &[\n (\"alloc\", &[]),\n (\"default\", &[\"dep:alloc\"]),\n (\"rustc-dep-of-std\", &[\"alloc\"]),\n ],\n ),\n ]);\n\n let deps = vec![\"rustix\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_19_same_dep_twice_feature_unification() {\n let reg = registry(vec![\n pkg_dep_with(\n \"iced\",\n vec![\"iced_wgpu\".opt(), \"iced_wgpu\".opt().with(&[\"webgl\"])],\n &[(\"default\", &[\"iced_wgpu\"])],\n ),\n pkg_dep_with(\"iced_wgpu\", vec![], &[(\"webgl\", &[])]),\n ]);\n\n let deps = vec![\"iced\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_20_no_implicit_feature() {\n let reg = registry(vec![\n pkg(\"c\"),\n pkg_dep_with(\"ureq\", vec![\"c\".opt()], &[(\"cookies\", &[\"dep:c\"])]),\n pkg_dep_with(\"dep\", vec![dep(\"ureq\")], &[(\"cookies\", &[\"ureq/c\"])]),\n ]);\n\n let deps = vec![\"dep\".with(&[\"cookies\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_21_implicit_feature() {\n let reg = registry(vec![\n pkg(\"c\"),\n pkg_dep(\"ureq\", vec![\"c\".opt()]),\n pkg_dep_with(\"dep\", vec![dep(\"ureq\")], &[(\"cookies\", &[\"ureq/c\"])]),\n ]);\n\n let deps = vec![\"dep\".with(&[\"cookies\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_22_missing_explicit_default_feature() {\n let reg = registry(vec![\n pkg_dep_with(\n \"fuel-tx\",\n vec![dep(\"serde\"), \"serde_json\".opt()],\n &[(\"default\", &[\"serde/default\"]), (\"serde\", &[\"serde_json\"])],\n ),\n pkg(\"serde\"),\n ]);\n\n let deps = vec![\"fuel-tx\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_23_no_need_for_explicit_default_feature() {\n let reg = registry(vec![\n pkg(\"a\"),\n pkg_dep_with(\n \"b\",\n vec![\"a\".with_default()],\n &[(\"default\", &[\"std\"]), (\"std\", &[])],\n ),\n ]);\n\n let deps = vec![\"b\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_24_dep_feature() {\n let reg = registry(vec![\n pkg_dep_with(\"proc-macro2\", vec![], &[(\"proc-macro\", &[])]),\n pkg_dep_with(\n \"syn\",\n vec![dep(\"proc-macro2\")],\n &[(\"proc-macro\", &[\"proc-macro2/proc-macro\"])],\n ),\n pkg_dep(\"serde_derive\", vec![\"syn\".with(&[\"proc-macro\"])]),\n ]);\n\n let deps = vec![dep(\"serde_derive\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_25_dep_feature() {\n let reg = registry(vec![\n pkg_dep_with(\"proc-macro2\", vec![], &[(\"proc-macro\", &[])]),\n pkg_dep_with(\n \"syn\",\n vec![dep(\"proc-macro2\")],\n &[(\"proc-macro\", &[\"proc-macro2/proc-macro\"])],\n ),\n ]);\n\n let deps = vec![\"syn\".with(&[\"proc-macro\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_26_implicit_feature_with_dep_feature() {\n let reg = registry(vec![\n pkg_dep_with(\"quote\", vec![], &[(\"proc-macro\", &[])]),\n pkg_dep_with(\n \"syn\",\n vec![\"quote\".opt()],\n &[(\"default\", &[\"quote\", \"quote/proc-macro\"])],\n ),\n ]);\n\n let deps = vec![\"syn\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn test_27_dep_feature_activating_shadowing_feature() {\n let reg = registry(vec![\n pkg_dep_with(\n \"a\",\n vec![\"b\".opt(), \"x\".opt()],\n &[(\"b\", &[\"x\"]), (\"default\", &[\"b/native\"])],\n ),\n pkg_dep_with(\"b\", vec![], &[(\"native\", &[])]),\n ]);\n\n let deps = vec![\"a\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn test_28_dep_feature_not_activating_shadowing_feature() {\n let reg = registry(vec![\n pkg_dep_with(\n \"fuel-tx\",\n vec![dep(\"serde\"), \"serde_json\".opt()],\n &[(\"default\", &[\"serde/default\"]), (\"serde\", &[\"serde_json\"])],\n ),\n pkg_dep_with(\"serde\", vec![], &[(\"default\", &[])]),\n ]);\n\n let deps = vec![\"fuel-tx\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n" }, { "path": "crates/resolver-tests/tests/resolve.rs", "content": "use cargo::core::Dependency;\nuse cargo::core::dependency::DepKind;\nuse cargo::util::GlobalContext;\n\nuse resolver_tests::{\n helpers::{\n ToDep, ToPkgId, assert_contains, assert_same, dep, dep_kind, dep_loc, dep_req, loc_names,\n names, pkg, pkg_dep, pkg_dep_with, pkg_id, pkg_loc, registry,\n },\n pkg, resolve, resolve_with_global_context,\n};\n\n#[test]\n#[should_panic(expected = \"assertion failed: !name.is_empty()\")]\nfn test_dependency_with_empty_name() {\n // Bug 5229, dependency-names must not be empty\n dep(\"\");\n}\n\n#[test]\nfn test_resolving_empty_dependency_list() {\n let res = resolve(Vec::new(), ®istry(vec![])).unwrap();\n\n assert_eq!(res, names(&[\"root\"]));\n}\n\n#[test]\nfn test_resolving_only_package() {\n let reg = registry(vec![pkg!(\"foo\")]);\n let res = resolve(vec![dep(\"foo\")], ®).unwrap();\n assert_same(&res, &names(&[\"root\", \"foo\"]));\n}\n\n#[test]\nfn test_resolving_one_dep() {\n let reg = registry(vec![pkg!(\"foo\"), pkg!(\"bar\")]);\n let res = resolve(vec![dep(\"foo\")], ®).unwrap();\n assert_same(&res, &names(&[\"root\", \"foo\"]));\n}\n\n#[test]\nfn test_resolving_multiple_deps() {\n let reg = registry(vec![pkg!(\"foo\"), pkg!(\"bar\"), pkg!(\"baz\")]);\n let res = resolve(vec![dep(\"foo\"), dep(\"baz\")], ®).unwrap();\n assert_same(&res, &names(&[\"root\", \"foo\", \"baz\"]));\n}\n\n#[test]\nfn test_resolving_transitive_deps() {\n let reg = registry(vec![pkg!(\"foo\"), pkg!(\"bar\" => [\"foo\"])]);\n let res = resolve(vec![dep(\"bar\")], ®).unwrap();\n\n assert_same(&res, &names(&[\"root\", \"foo\", \"bar\"]));\n}\n\n#[test]\nfn test_resolving_common_transitive_deps() {\n let reg = registry(vec![pkg!(\"foo\" => [\"bar\"]), pkg!(\"bar\")]);\n let res = resolve(vec![dep(\"foo\"), dep(\"bar\")], ®).unwrap();\n\n assert_same(&res, &names(&[\"root\", \"foo\", \"bar\"]));\n}\n\n#[test]\nfn test_resolving_with_same_name() {\n let list = vec![\n pkg_loc(\"foo\", \"https://first.example.com\"),\n pkg_loc(\"bar\", \"https://second.example.com\"),\n ];\n\n let reg = registry(list);\n let res = resolve(\n vec![\n dep_loc(\"foo\", \"https://first.example.com\"),\n dep_loc(\"bar\", \"https://second.example.com\"),\n ],\n ®,\n )\n .unwrap();\n\n let mut names = loc_names(&[\n (\"foo\", \"https://first.example.com\"),\n (\"bar\", \"https://second.example.com\"),\n ]);\n\n names.push(pkg_id(\"root\"));\n assert_same(&res, &names);\n}\n\n#[test]\nfn test_resolving_with_dev_deps() {\n let reg = registry(vec![\n pkg!(\"foo\" => [\"bar\", dep_kind(\"baz\", DepKind::Development)]),\n pkg!(\"baz\" => [\"bat\", dep_kind(\"bam\", DepKind::Development)]),\n pkg!(\"bar\"),\n pkg!(\"bat\"),\n ]);\n\n let res = resolve(\n vec![dep(\"foo\"), dep_kind(\"baz\", DepKind::Development)],\n ®,\n )\n .unwrap();\n\n assert_same(&res, &names(&[\"root\", \"foo\", \"bar\", \"baz\", \"bat\"]));\n}\n\n#[test]\nfn resolving_with_many_versions() {\n let reg = registry(vec![pkg!((\"foo\", \"1.0.1\")), pkg!((\"foo\", \"1.0.2\"))]);\n\n let res = resolve(vec![dep(\"foo\")], ®).unwrap();\n\n assert_same(&res, &names(&[(\"root\", \"1.0.0\"), (\"foo\", \"1.0.2\")]));\n}\n\n#[test]\nfn resolving_with_specific_version() {\n let reg = registry(vec![pkg!((\"foo\", \"1.0.1\")), pkg!((\"foo\", \"1.0.2\"))]);\n\n let res = resolve(vec![dep_req(\"foo\", \"=1.0.1\")], ®).unwrap();\n\n assert_same(&res, &names(&[(\"root\", \"1.0.0\"), (\"foo\", \"1.0.1\")]));\n}\n\n#[test]\nfn test_resolving_maximum_version_with_transitive_deps() {\n let reg = registry(vec![\n pkg!((\"util\", \"1.2.2\")),\n pkg!((\"util\", \"1.0.0\")),\n pkg!((\"util\", \"1.1.1\")),\n pkg!(\"foo\" => [dep_req(\"util\", \"1.0.0\")]),\n pkg!(\"bar\" => [dep_req(\"util\", \">=1.0.1\")]),\n ]);\n\n let res = resolve(vec![dep_req(\"foo\", \"1.0.0\"), dep_req(\"bar\", \"1.0.0\")], ®).unwrap();\n\n assert_contains(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"foo\", \"1.0.0\"),\n (\"bar\", \"1.0.0\"),\n (\"util\", \"1.2.2\"),\n ]),\n );\n assert!(!res.contains(&(\"util\", \"1.0.1\").to_pkgid()));\n assert!(!res.contains(&(\"util\", \"1.1.1\").to_pkgid()));\n}\n\n#[test]\nfn test_resolving_minimum_version_with_transitive_deps() {\n let reg = registry(vec![\n pkg!((\"util\", \"1.2.2\")),\n pkg!((\"util\", \"1.0.0\")),\n pkg!((\"util\", \"1.1.1\")),\n pkg!(\"foo\" => [dep_req(\"util\", \"1.0.0\")]),\n pkg!(\"bar\" => [dep_req(\"util\", \">=1.0.1\")]),\n ]);\n\n let mut gctx = GlobalContext::default().unwrap();\n // -Z minimal-versions\n // When the minimal-versions config option is specified then the lowest\n // possible version of a package should be selected. \"util 1.0.0\" can't be\n // selected because of the requirements of \"bar\", so the minimum version\n // must be 1.1.1.\n gctx.nightly_features_allowed = true;\n gctx.configure(\n 1,\n false,\n None,\n false,\n false,\n false,\n &None,\n &[\"minimal-versions\".to_string()],\n &[],\n )\n .unwrap();\n\n let res = resolve_with_global_context(\n vec![dep_req(\"foo\", \"1.0.0\"), dep_req(\"bar\", \"1.0.0\")],\n ®,\n &gctx,\n )\n .unwrap()\n .into_iter()\n .map(|(pkg, _)| pkg)\n .collect::>();\n\n assert_contains(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"foo\", \"1.0.0\"),\n (\"bar\", \"1.0.0\"),\n (\"util\", \"1.1.1\"),\n ]),\n );\n assert!(!res.contains(&(\"util\", \"1.2.2\").to_pkgid()));\n assert!(!res.contains(&(\"util\", \"1.0.0\").to_pkgid()));\n}\n\n#[test]\nfn resolving_incompat_versions() {\n let reg = registry(vec![\n pkg!((\"foo\", \"1.0.1\")),\n pkg!((\"foo\", \"1.0.2\")),\n pkg!(\"bar\" => [dep_req(\"foo\", \"=1.0.2\")]),\n ]);\n\n assert!(resolve(vec![dep_req(\"foo\", \"=1.0.1\"), dep(\"bar\")], ®).is_err());\n}\n\n#[test]\nfn resolving_wrong_case_from_registry() {\n // In the future we may #5678 allow this to happen.\n // For back compatibility reasons, we probably won't.\n // But we may want to future prove ourselves by understanding it.\n // This test documents the current behavior.\n let reg = registry(vec![pkg!((\"foo\", \"1.0.0\")), pkg!(\"bar\" => [\"Foo\"])]);\n\n assert!(resolve(vec![dep(\"bar\")], ®).is_err());\n}\n\n#[test]\nfn resolving_mis_hyphenated_from_registry() {\n // In the future we may #2775 allow this to happen.\n // For back compatibility reasons, we probably won't.\n // But we may want to future prove ourselves by understanding it.\n // This test documents the current behavior.\n let reg = registry(vec![pkg!((\"fo-o\", \"1.0.0\")), pkg!(\"bar\" => [\"fo_o\"])]);\n\n assert!(resolve(vec![dep(\"bar\")], ®).is_err());\n}\n\n#[test]\nfn resolving_backtrack() {\n let reg = registry(vec![\n pkg!((\"foo\", \"1.0.2\") => [dep(\"bar\")]),\n pkg!((\"foo\", \"1.0.1\") => [dep(\"baz\")]),\n pkg!(\"bar\" => [dep_req(\"foo\", \"=2.0.2\")]),\n pkg!(\"baz\"),\n ]);\n\n let res = resolve(vec![dep_req(\"foo\", \"^1\")], ®).unwrap();\n\n assert_contains(\n &res,\n &names(&[(\"root\", \"1.0.0\"), (\"foo\", \"1.0.1\"), (\"baz\", \"1.0.0\")]),\n );\n}\n\n#[test]\nfn resolving_backtrack_features() {\n // test for cargo/issues/4347\n let mut bad = dep(\"bar\");\n bad.set_features(vec![\"bad\"]);\n\n let reg = registry(vec![\n pkg!((\"foo\", \"1.0.2\") => [bad]),\n pkg!((\"foo\", \"1.0.1\") => [dep(\"bar\")]),\n pkg!(\"bar\"),\n ]);\n\n let res = resolve(vec![dep_req(\"foo\", \"^1\")], ®).unwrap();\n\n assert_contains(\n &res,\n &names(&[(\"root\", \"1.0.0\"), (\"foo\", \"1.0.1\"), (\"bar\", \"1.0.0\")]),\n );\n}\n\n#[test]\nfn resolving_allows_multiple_compatible_versions() {\n let reg = registry(vec![\n pkg!((\"foo\", \"1.0.0\")),\n pkg!((\"foo\", \"2.0.0\")),\n pkg!((\"foo\", \"0.1.0\")),\n pkg!((\"foo\", \"0.2.0\")),\n pkg!(\"bar\" => [\"d1\", \"d2\", \"d3\", \"d4\"]),\n pkg!(\"d1\" => [dep_req(\"foo\", \"1\")]),\n pkg!(\"d2\" => [dep_req(\"foo\", \"2\")]),\n pkg!(\"d3\" => [dep_req(\"foo\", \"0.1\")]),\n pkg!(\"d4\" => [dep_req(\"foo\", \"0.2\")]),\n ]);\n\n let res = resolve(vec![dep(\"bar\")], ®).unwrap();\n\n assert_same(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"foo\", \"1.0.0\"),\n (\"foo\", \"2.0.0\"),\n (\"foo\", \"0.1.0\"),\n (\"foo\", \"0.2.0\"),\n (\"d1\", \"1.0.0\"),\n (\"d2\", \"1.0.0\"),\n (\"d3\", \"1.0.0\"),\n (\"d4\", \"1.0.0\"),\n (\"bar\", \"1.0.0\"),\n ]),\n );\n}\n\n#[test]\nfn resolving_with_deep_backtracking() {\n let reg = registry(vec![\n pkg!((\"foo\", \"1.0.1\") => [dep_req(\"bar\", \"1\")]),\n pkg!((\"foo\", \"1.0.0\") => [dep_req(\"bar\", \"2\")]),\n pkg!((\"bar\", \"1.0.0\") => [dep_req(\"baz\", \"=1.0.2\"),\n dep_req(\"other\", \"1\")]),\n pkg!((\"bar\", \"2.0.0\") => [dep_req(\"baz\", \"=1.0.1\")]),\n pkg!((\"baz\", \"1.0.2\") => [dep_req(\"other\", \"2\")]),\n pkg!((\"baz\", \"1.0.1\")),\n pkg!((\"dep_req\", \"1.0.0\")),\n pkg!((\"dep_req\", \"2.0.0\")),\n ]);\n\n let res = resolve(vec![dep_req(\"foo\", \"1\")], ®).unwrap();\n\n assert_same(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"foo\", \"1.0.0\"),\n (\"bar\", \"2.0.0\"),\n (\"baz\", \"1.0.1\"),\n ]),\n );\n}\n\n#[test]\nfn resolving_with_sys_crates() {\n // This is based on issues/4902\n // With `l` a normal library we get 2copies so everyone gets the newest compatible.\n // But `l-sys` a library with a links attribute we make sure there is only one.\n let reg = registry(vec![\n pkg!((\"l-sys\", \"0.9.1\")),\n pkg!((\"l-sys\", \"0.10.0\")),\n pkg!((\"l\", \"0.9.1\")),\n pkg!((\"l\", \"0.10.0\")),\n pkg!((\"d\", \"1.0.0\") => [dep_req(\"l-sys\", \">=0.8.0, <=0.10.0\"), dep_req(\"l\", \">=0.8.0, <=0.10.0\")]),\n pkg!((\"r\", \"1.0.0\") => [dep_req(\"l-sys\", \"0.9\"), dep_req(\"l\", \"0.9\")]),\n ]);\n\n let res = resolve(vec![dep_req(\"d\", \"1\"), dep_req(\"r\", \"1\")], ®).unwrap();\n\n assert_same(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"d\", \"1.0.0\"),\n (\"r\", \"1.0.0\"),\n (\"l-sys\", \"0.9.1\"),\n (\"l\", \"0.9.1\"),\n (\"l\", \"0.10.0\"),\n ]),\n );\n}\n\n#[test]\nfn resolving_with_constrained_sibling_backtrack_parent() {\n // There is no point in considering all of the backtrack_trap{1,2}\n // candidates since they can't change the result of failing to\n // resolve 'constrained'. Cargo should (ideally) skip past them and resume\n // resolution once the activation of the parent, 'bar', is rolled back.\n // Note that the traps are slightly more constrained to make sure they\n // get picked first.\n let mut reglist = vec![\n pkg!((\"foo\", \"1.0.0\") => [dep_req(\"bar\", \"1.0\"),\n dep_req(\"constrained\", \"=1.0.0\")]),\n pkg!((\"bar\", \"1.0.0\") => [dep_req(\"backtrack_trap1\", \"1.0.2\"),\n dep_req(\"backtrack_trap2\", \"1.0.2\"),\n dep_req(\"constrained\", \"1.0.0\")]),\n pkg!((\"constrained\", \"1.0.0\")),\n pkg!((\"backtrack_trap1\", \"1.0.0\")),\n pkg!((\"backtrack_trap2\", \"1.0.0\")),\n ];\n // Bump this to make the test harder - it adds more versions of bar that will\n // fail to resolve, and more versions of the traps to consider.\n const NUM_BARS_AND_TRAPS: usize = 50; // minimum 2\n for i in 1..NUM_BARS_AND_TRAPS {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(\n pkg!((\"bar\", vsn.clone()) => [dep_req(\"backtrack_trap1\", \"1.0.2\"),\n dep_req(\"backtrack_trap2\", \"1.0.2\"),\n dep_req(\"constrained\", \"1.0.1\")]),\n );\n reglist.push(pkg!((\"backtrack_trap1\", vsn.clone())));\n reglist.push(pkg!((\"backtrack_trap2\", vsn.clone())));\n reglist.push(pkg!((\"constrained\", vsn.clone())));\n }\n let reg = registry(reglist);\n\n let res = resolve(vec![dep_req(\"foo\", \"1\")], ®).unwrap();\n\n assert_contains(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"foo\", \"1.0.0\"),\n (\"bar\", \"1.0.0\"),\n (\"constrained\", \"1.0.0\"),\n ]),\n );\n}\n\n#[test]\nfn resolving_with_many_equivalent_backtracking() {\n let mut reglist = Vec::new();\n\n const DEPTH: usize = 200;\n const BRANCHING_FACTOR: usize = 100;\n\n // Each level depends on the next but the last level does not exist.\n // Without cashing we need to test every path to the last level O(BRANCHING_FACTOR ^ DEPTH)\n // and this test will time out. With cashing we need to discover that none of these\n // can be activated O(BRANCHING_FACTOR * DEPTH)\n for l in 0..DEPTH {\n let name = format!(\"level{}\", l);\n let next = format!(\"level{}\", l + 1);\n for i in 1..BRANCHING_FACTOR {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((name.as_str(), vsn.as_str()) => [dep(next.as_str())]));\n }\n }\n\n let reg = registry(reglist.clone());\n\n let res = resolve(vec![dep(\"level0\")], ®);\n\n assert!(res.is_err());\n\n // It is easy to write code that quickly returns an error.\n // Lets make sure we can find a good answer if it is there.\n reglist.push(pkg!((\"level0\", \"1.0.0\")));\n\n let reg = registry(reglist.clone());\n\n let res = resolve(vec![dep(\"level0\")], ®).unwrap();\n\n assert_contains(&res, &names(&[(\"root\", \"1.0.0\"), (\"level0\", \"1.0.0\")]));\n\n // Make sure we have not special case no candidates.\n reglist.push(pkg!((\"constrained\", \"1.1.0\")));\n reglist.push(pkg!((\"constrained\", \"1.0.0\")));\n reglist.push(\n pkg!((format!(\"level{}\", DEPTH).as_str(), \"1.0.0\") => [dep_req(\"constrained\", \"=1.0.0\")]),\n );\n\n let reg = registry(reglist.clone());\n\n let res = resolve(vec![dep(\"level0\"), dep(\"constrained\")], ®).unwrap();\n\n assert_contains(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"level0\", \"1.0.0\"),\n (\"constrained\", \"1.1.0\"),\n ]),\n );\n\n let reg = registry(reglist.clone());\n\n let res = resolve(vec![dep_req(\"level0\", \"1.0.1\"), dep(\"constrained\")], ®).unwrap();\n\n assert_contains(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (format!(\"level{}\", DEPTH).as_str(), \"1.0.0\"),\n (\"constrained\", \"1.0.0\"),\n ]),\n );\n\n let reg = registry(reglist);\n\n let res = resolve(\n vec![dep_req(\"level0\", \"1.0.1\"), dep_req(\"constrained\", \"1.1.0\")],\n ®,\n );\n\n assert!(res.is_err());\n}\n\n#[test]\nfn resolving_with_deep_traps() {\n let mut reglist = Vec::new();\n\n const DEPTH: usize = 200;\n const BRANCHING_FACTOR: usize = 100;\n\n // Each backtrack_trap depends on the next, and adds a backtrack frame.\n // None of witch is going to help with `bad`.\n for l in 0..DEPTH {\n let name = format!(\"backtrack_trap{}\", l);\n let next = format!(\"backtrack_trap{}\", l + 1);\n for i in 1..BRANCHING_FACTOR {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((name.as_str(), vsn.as_str()) => [dep(next.as_str())]));\n }\n }\n {\n let name = format!(\"backtrack_trap{}\", DEPTH);\n for i in 1..BRANCHING_FACTOR {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((name.as_str(), vsn.as_str())));\n }\n }\n {\n // slightly less constrained to make sure `cloaking` gets picked last.\n for i in 1..(BRANCHING_FACTOR + 10) {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((\"cloaking\", vsn.as_str()) => [dep_req(\"bad\", \"1.0.1\")]));\n }\n }\n\n let reg = registry(reglist);\n\n let res = resolve(vec![dep(\"backtrack_trap0\"), dep(\"cloaking\")], ®);\n\n assert!(res.is_err());\n}\n\n#[test]\nfn resolving_with_constrained_cousins_backtrack() {\n let mut reglist = Vec::new();\n\n const DEPTH: usize = 100;\n const BRANCHING_FACTOR: usize = 50;\n\n // Each backtrack_trap depends on the next.\n // The last depends on a specific ver of constrained.\n for l in 0..DEPTH {\n let name = format!(\"backtrack_trap{}\", l);\n let next = format!(\"backtrack_trap{}\", l + 1);\n for i in 1..BRANCHING_FACTOR {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((name.as_str(), vsn.as_str()) => [dep(next.as_str())]));\n }\n }\n {\n let name = format!(\"backtrack_trap{}\", DEPTH);\n for i in 1..BRANCHING_FACTOR {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(\n pkg!((name.as_str(), vsn.as_str()) => [dep_req(\"constrained\", \">=1.1.0, <=2.0.0\")]),\n );\n }\n }\n {\n // slightly less constrained to make sure `constrained` gets picked last.\n for i in 0..(BRANCHING_FACTOR + 10) {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((\"constrained\", vsn.as_str())));\n }\n reglist.push(pkg!((\"constrained\", \"1.1.0\")));\n reglist.push(pkg!((\"constrained\", \"2.0.0\")));\n reglist.push(pkg!((\"constrained\", \"2.0.1\")));\n }\n reglist.push(pkg!((\"cloaking\", \"1.0.0\") => [dep_req(\"constrained\", \"~1.0.0\")]));\n\n let reg = registry(reglist.clone());\n\n // `backtrack_trap0 = \"*\"` is a lot of ways of saying `constrained = \">=1.1.0, <=2.0.0\"`\n // but `constrained= \"2.0.1\"` is already picked.\n // Only then to try and solve `constrained= \"~1.0.0\"` which is incompatible.\n let res = resolve(\n vec![\n dep(\"backtrack_trap0\"),\n dep_req(\"constrained\", \"2.0.1\"),\n dep(\"cloaking\"),\n ],\n ®,\n );\n\n assert!(res.is_err());\n\n // Each level depends on the next but the last depends on incompatible deps.\n // Let's make sure that we can cache that a dep has incompatible deps.\n for l in 0..DEPTH {\n let name = format!(\"level{}\", l);\n let next = format!(\"level{}\", l + 1);\n for i in 1..BRANCHING_FACTOR {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((name.as_str(), vsn.as_str()) => [dep(next.as_str())]));\n }\n }\n reglist.push(\n pkg!((format!(\"level{}\", DEPTH).as_str(), \"1.0.0\") => [dep(\"backtrack_trap0\"),\n dep(\"cloaking\")\n ]),\n );\n\n let reg = registry(reglist);\n\n let res = resolve(vec![dep(\"level0\"), dep_req(\"constrained\", \"2.0.1\")], ®);\n\n assert!(res.is_err());\n\n let res = resolve(vec![dep(\"level0\"), dep_req(\"constrained\", \"2.0.0\")], ®).unwrap();\n\n assert_contains(\n &res,\n &names(&[(\"constrained\", \"2.0.0\"), (\"cloaking\", \"1.0.0\")]),\n );\n}\n\n#[test]\nfn resolving_with_constrained_sibling_backtrack_activation() {\n // It makes sense to resolve most-constrained deps first, but\n // with that logic the backtrack traps here come between the two\n // attempted resolutions of 'constrained'. When backtracking,\n // cargo should skip past them and resume resolution once the\n // number of activations for 'constrained' changes.\n let mut reglist = vec![\n pkg!((\"foo\", \"1.0.0\") => [dep_req(\"bar\", \"=1.0.0\"),\n dep_req(\"backtrack_trap1\", \"1.0\"),\n dep_req(\"backtrack_trap2\", \"1.0\"),\n dep_req(\"constrained\", \"<=1.0.60\")]),\n pkg!((\"bar\", \"1.0.0\") => [dep_req(\"constrained\", \">=1.0.60\")]),\n ];\n // Bump these to make the test harder, but you'll also need to\n // change the version constraints on `constrained` above. To correctly\n // exercise Cargo, the relationship between the values is:\n // NUM_CONSTRAINED - vsn < NUM_TRAPS < vsn\n // to make sure the traps are resolved between `constrained`.\n const NUM_TRAPS: usize = 45; // min 1\n const NUM_CONSTRAINED: usize = 100; // min 1\n for i in 0..NUM_TRAPS {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((\"backtrack_trap1\", vsn.clone())));\n reglist.push(pkg!((\"backtrack_trap2\", vsn.clone())));\n }\n for i in 0..NUM_CONSTRAINED {\n let vsn = format!(\"1.0.{}\", i);\n reglist.push(pkg!((\"constrained\", vsn.clone())));\n }\n let reg = registry(reglist);\n\n let res = resolve(vec![dep_req(\"foo\", \"1\")], ®).unwrap();\n\n assert_contains(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"foo\", \"1.0.0\"),\n (\"bar\", \"1.0.0\"),\n (\"constrained\", \"1.0.60\"),\n ]),\n );\n}\n\n#[test]\nfn resolving_with_constrained_sibling_transitive_dep_effects() {\n // When backtracking due to a failed dependency, if Cargo is\n // trying to be clever and skip irrelevant dependencies, care must\n // be taken to not miss the transitive effects of alternatives. E.g.\n // in the right-to-left resolution of the graph below, B may\n // affect whether D is successfully resolved.\n //\n // A\n // / | \\\n // B C D\n // | |\n // C D\n let reg = registry(vec![\n pkg!((\"A\", \"1.0.0\") => [dep_req(\"B\", \"1.0\"),\n dep_req(\"C\", \"1.0\"),\n dep_req(\"D\", \"1.0.100\")]),\n pkg!((\"B\", \"1.0.0\") => [dep_req(\"C\", \">=1.0.0\")]),\n pkg!((\"B\", \"1.0.1\") => [dep_req(\"C\", \">=1.0.1\")]),\n pkg!((\"C\", \"1.0.0\") => [dep_req(\"D\", \"1.0.0\")]),\n pkg!((\"C\", \"1.0.1\") => [dep_req(\"D\", \">=1.0.1,<1.0.100\")]),\n pkg!((\"C\", \"1.0.2\") => [dep_req(\"D\", \">=1.0.2,<1.0.100\")]),\n pkg!((\"D\", \"1.0.0\")),\n pkg!((\"D\", \"1.0.1\")),\n pkg!((\"D\", \"1.0.2\")),\n pkg!((\"D\", \"1.0.100\")),\n pkg!((\"D\", \"1.0.101\")),\n pkg!((\"D\", \"1.0.102\")),\n pkg!((\"D\", \"1.0.103\")),\n pkg!((\"D\", \"1.0.104\")),\n pkg!((\"D\", \"1.0.105\")),\n ]);\n\n let res = resolve(vec![dep_req(\"A\", \"1\")], ®).unwrap();\n\n assert_same(\n &res,\n &names(&[\n (\"root\", \"1.0.0\"),\n (\"A\", \"1.0.0\"),\n (\"B\", \"1.0.0\"),\n (\"C\", \"1.0.0\"),\n (\"D\", \"1.0.105\"),\n ]),\n );\n}\n\n#[test]\nfn incomplete_information_skipping() {\n // When backtracking due to a failed dependency, if Cargo is\n // trying to be clever and skip irrelevant dependencies, care must\n // be taken to not miss the transitive effects of alternatives.\n // Fuzzing discovered that for some reason cargo was skipping based\n // on incomplete information in the following case:\n // minimized bug found in:\n // https://github.com/rust-lang/cargo/commit/003c29b0c71e5ea28fbe8e72c148c755c9f3f8d9\n let input = vec![\n pkg!((\"a\", \"1.0.0\")),\n pkg!((\"a\", \"1.1.0\")),\n pkg!(\"b\" => [dep(\"a\")]),\n pkg!((\"c\", \"1.0.0\")),\n pkg!((\"c\", \"1.1.0\")),\n pkg!(\"d\" => [dep_req(\"c\", \"=1.0\")]),\n pkg!((\"e\", \"1.0.0\")),\n pkg!((\"e\", \"1.1.0\") => [dep_req(\"c\", \"1.1\")]),\n pkg!(\"to_yank\"),\n pkg!((\"f\", \"1.0.0\") => [\n dep(\"to_yank\"),\n dep(\"d\"),\n ]),\n pkg!((\"f\", \"1.1.0\") => [dep(\"d\")]),\n pkg!(\"g\" => [\n dep(\"b\"),\n dep(\"e\"),\n dep(\"f\"),\n ]),\n ];\n let reg = registry(input.clone());\n\n let res = resolve(vec![dep(\"g\")], ®).unwrap();\n let package_to_yank = \"to_yank\".to_pkgid();\n // this package is not used in the resolution.\n assert!(!res.contains(&package_to_yank));\n // so when we yank it\n let new_reg = registry(\n input\n .iter()\n .filter(|&x| package_to_yank != x.package_id())\n .cloned()\n .collect(),\n );\n assert_eq!(input.len(), new_reg.len() + 1);\n // it should still build\n assert!(resolve(vec![dep(\"g\")], &new_reg).is_ok());\n}\n\n#[test]\nfn incomplete_information_skipping_2() {\n // When backtracking due to a failed dependency, if Cargo is\n // trying to be clever and skip irrelevant dependencies, care must\n // be taken to not miss the transitive effects of alternatives.\n // Fuzzing discovered that for some reason cargo was skipping based\n // on incomplete information in the following case:\n // https://github.com/rust-lang/cargo/commit/003c29b0c71e5ea28fbe8e72c148c755c9f3f8d9\n let input = vec![\n pkg!((\"b\", \"3.8.10\")),\n pkg!((\"b\", \"8.7.4\")),\n pkg!((\"b\", \"9.4.6\")),\n pkg!((\"c\", \"1.8.8\")),\n pkg!((\"c\", \"10.2.5\")),\n pkg!((\"d\", \"4.1.2\") => [\n dep_req(\"bad\", \"=6.10.9\"),\n ]),\n pkg!((\"d\", \"5.5.6\")),\n pkg!((\"d\", \"5.6.10\")),\n pkg!((\"to_yank\", \"8.0.1\")),\n pkg!((\"to_yank\", \"8.8.1\")),\n pkg!((\"e\", \"4.7.8\") => [\n dep_req(\"d\", \">=5.5.6, <=5.6.10\"),\n dep_req(\"to_yank\", \"=8.0.1\"),\n ]),\n pkg!((\"e\", \"7.4.9\") => [\n dep_req(\"bad\", \"=4.7.5\"),\n ]),\n pkg!(\"f\" => [\n dep_req(\"d\", \">=4.1.2, <=5.5.6\"),\n ]),\n pkg!(\"g\" => [\n dep(\"bad\"),\n ]),\n pkg!((\"h\", \"3.8.3\") => [\n dep(\"g\"),\n ]),\n pkg!((\"h\", \"6.8.3\") => [\n dep(\"f\"),\n ]),\n pkg!((\"h\", \"8.1.9\") => [\n dep_req(\"to_yank\", \"=8.8.1\"),\n ]),\n pkg!(\"i\" => [\n dep(\"b\"),\n dep(\"c\"),\n dep(\"e\"),\n dep(\"h\"),\n ]),\n ];\n let reg = registry(input.clone());\n\n let res = resolve(vec![dep(\"i\")], ®).unwrap();\n let package_to_yank = (\"to_yank\", \"8.8.1\").to_pkgid();\n // this package is not used in the resolution.\n assert!(!res.contains(&package_to_yank));\n // so when we yank it\n let new_reg = registry(\n input\n .iter()\n .filter(|&x| package_to_yank != x.package_id())\n .cloned()\n .collect(),\n );\n assert_eq!(input.len(), new_reg.len() + 1);\n // it should still build\n assert!(resolve(vec![dep(\"i\")], &new_reg).is_ok());\n}\n\n#[test]\nfn incomplete_information_skipping_3() {\n // When backtracking due to a failed dependency, if Cargo is\n // trying to be clever and skip irrelevant dependencies, care must\n // be taken to not miss the transitive effects of alternatives.\n // Fuzzing discovered that for some reason cargo was skipping based\n // on incomplete information in the following case:\n // minimized bug found in:\n // https://github.com/rust-lang/cargo/commit/003c29b0c71e5ea28fbe8e72c148c755c9f3f8d9\n let input = vec![\n pkg! {(\"to_yank\", \"3.0.3\")},\n pkg! {(\"to_yank\", \"3.3.0\")},\n pkg! {(\"to_yank\", \"3.3.1\")},\n pkg! {(\"a\", \"3.3.0\") => [\n dep_req(\"to_yank\", \"=3.0.3\"),\n ] },\n pkg! {(\"a\", \"3.3.2\") => [\n dep_req(\"to_yank\", \"<=3.3.0\"),\n ] },\n pkg! {(\"b\", \"0.1.3\") => [\n dep_req(\"a\", \"=3.3.0\"),\n ] },\n pkg! {(\"b\", \"2.0.2\") => [\n dep_req(\"to_yank\", \"3.3.0\"),\n dep(\"a\"),\n ] },\n pkg! {(\"b\", \"2.3.3\") => [\n dep_req(\"to_yank\", \"3.3.0\"),\n dep_req(\"a\", \"=3.3.0\"),\n ] },\n ];\n let reg = registry(input.clone());\n\n let res = resolve(vec![dep(\"b\")], ®).unwrap();\n let package_to_yank = (\"to_yank\", \"3.0.3\").to_pkgid();\n // this package is not used in the resolution.\n assert!(!res.contains(&package_to_yank));\n // so when we yank it\n let new_reg = registry(\n input\n .iter()\n .filter(|&x| package_to_yank != x.package_id())\n .cloned()\n .collect(),\n );\n assert_eq!(input.len(), new_reg.len() + 1);\n // it should still build\n assert!(resolve(vec![dep(\"b\")], &new_reg).is_ok());\n}\n\n#[test]\nfn resolving_but_no_exists() {\n let reg = registry(vec![]);\n\n let res = resolve(vec![dep_req(\"foo\", \"1\")], ®);\n assert!(res.is_err());\n\n assert_eq!(\n res.err().unwrap().to_string(),\n \"no matching package named `foo` found\\n\\\n location searched: registry `https://example.com/`\\n\\\n required by package `root v1.0.0 (registry `https://example.com/`)`\\\n \"\n );\n}\n\n#[test]\nfn resolving_cycle() {\n let reg = registry(vec![pkg!(\"foo\" => [\"foo\"])]);\n\n let _ = resolve(vec![dep_req(\"foo\", \"1\")], ®);\n}\n\n#[test]\nfn hard_equality() {\n let reg = registry(vec![\n pkg!((\"foo\", \"1.0.1\")),\n pkg!((\"foo\", \"1.0.0\")),\n pkg!((\"bar\", \"1.0.0\") => [dep_req(\"foo\", \"1.0.0\")]),\n ]);\n\n let res = resolve(vec![dep_req(\"bar\", \"1\"), dep_req(\"foo\", \"=1.0.0\")], ®).unwrap();\n\n assert_same(\n &res,\n &names(&[(\"root\", \"1.0.0\"), (\"foo\", \"1.0.0\"), (\"bar\", \"1.0.0\")]),\n );\n}\n\n#[test]\nfn large_conflict_cache() {\n let mut input = vec![\n pkg!((\"last\", \"0.0.0\") => [dep(\"bad\")]), // just to make sure last is less constrained\n ];\n let mut root_deps = vec![dep(\"last\")];\n const NUM_VERSIONS: u8 = 20;\n for name in 0..=NUM_VERSIONS {\n // a large number of conflicts can easily be generated by a sys crate.\n let sys_name = format!(\"{}-sys\", (b'a' + name) as char);\n let in_len = input.len();\n input.push(pkg!((\"last\", format!(\"{}.0.0\", in_len)) => [dep_req(&sys_name, \"=0.0.0\")]));\n root_deps.push(dep_req(&sys_name, \">= 0.0.1\"));\n\n // a large number of conflicts can also easily be generated by a major release version.\n let plane_name = format!(\"{}\", (b'a' + name) as char);\n let in_len = input.len();\n input.push(pkg!((\"last\", format!(\"{}.0.0\", in_len)) => [dep_req(&plane_name, \"=1.0.0\")]));\n root_deps.push(dep_req(&plane_name, \">= 1.0.1\"));\n\n for i in 0..=NUM_VERSIONS {\n input.push(pkg!((&sys_name, format!(\"{}.0.0\", i))));\n input.push(pkg!((&plane_name, format!(\"1.0.{}\", i))));\n }\n }\n let reg = registry(input);\n let _ = resolve(root_deps, ®);\n}\n\n#[test]\nfn resolving_slow_case_missing_feature() {\n let mut reg = Vec::new();\n\n const LAST_CRATE_VERSION_COUNT: usize = 50;\n\n // increase in resolve time is at least cubic over `INTERMEDIATE_CRATES_VERSION_COUNT`.\n // it should be `>= LAST_CRATE_VERSION_COUNT` to reproduce slowdown.\n const INTERMEDIATE_CRATES_VERSION_COUNT: usize = LAST_CRATE_VERSION_COUNT + 5;\n\n // should be `>= 2` to reproduce slowdown\n const TRANSITIVE_CRATES_COUNT: usize = 3;\n\n reg.push(pkg_dep_with((\"last\", \"1.0.0\"), vec![], &[(\"f\", &[])]));\n for v in 1..LAST_CRATE_VERSION_COUNT {\n reg.push(pkg((\"last\", format!(\"1.0.{v}\"))));\n }\n\n reg.push(pkg_dep(\n (\"dep\", \"1.0.0\"),\n vec![\n dep(\"last\"), // <-- needed to reproduce slowdown\n dep_req(\"intermediate-1\", \"1.0.0\"),\n ],\n ));\n\n for n in 0..INTERMEDIATE_CRATES_VERSION_COUNT {\n let version = format!(\"1.0.{n}\");\n for c in 1..TRANSITIVE_CRATES_COUNT {\n reg.push(pkg_dep(\n (format!(\"intermediate-{c}\"), &version),\n vec![dep_req(&format!(\"intermediate-{}\", c + 1), &version)],\n ));\n }\n reg.push(pkg_dep(\n (format!(\"intermediate-{TRANSITIVE_CRATES_COUNT}\"), &version),\n vec![dep_req(\"last\", \"1.0.0\").with(&[\"f\"])],\n ));\n }\n\n let deps = vec![dep(\"dep\")];\n let _ = resolve(deps, ®);\n}\n\n#[test]\nfn cyclic_good_error_message() {\n let input = vec![\n pkg!((\"A\", \"0.0.0\") => [dep(\"C\")]),\n pkg!((\"B\", \"0.0.0\") => [dep(\"C\")]),\n pkg!((\"C\", \"0.0.0\") => [dep(\"A\")]),\n ];\n let reg = registry(input);\n let error = resolve(vec![dep(\"A\"), dep(\"B\")], ®).unwrap_err();\n println!(\"{}\", error);\n assert_eq!(\"\\\ncyclic package dependency: package `A v0.0.0 (registry `https://example.com/`)` depends on itself. Cycle:\npackage `A v0.0.0 (registry `https://example.com/`)`\n ... which satisfies dependency `A = \\\"*\\\"` of package `C v0.0.0 (registry `https://example.com/`)`\n ... which satisfies dependency `C = \\\"*\\\"` of package `A v0.0.0 (registry `https://example.com/`)`\\\n\", error.to_string());\n}\n\n#[test]\nfn shortest_path_in_error_message() {\n let input = vec![\n pkg!((\"F\", \"0.1.2\")),\n pkg!((\"F\", \"0.1.1\") => [dep(\"bad\"),]),\n pkg!((\"F\", \"0.1.0\") => [dep(\"bad\"),]),\n pkg!(\"E\" => [dep_req(\"F\", \"^0.1.2\"),]),\n pkg!(\"D\" => [dep_req(\"F\", \"^0.1.2\"),]),\n pkg!(\"C\" => [dep(\"D\"),]),\n pkg!(\"A\" => [dep(\"C\"),dep(\"E\"),dep_req(\"F\", \"<=0.1.1\"),]),\n ];\n let error = resolve(vec![dep(\"A\")], ®istry(input)).unwrap_err();\n println!(\"{}\", error);\n assert_eq!(\n \"\\\nfailed to select a version for `F`.\n ... required by package `A v1.0.0 (registry `https://example.com/`)`\n ... which satisfies dependency `A = \\\"*\\\"` of package `root v1.0.0 (registry `https://example.com/`)`\nversions that meet the requirements `<=0.1.1` are: 0.1.1, 0.1.0\n\nall possible versions conflict with previously selected packages.\n\n previously selected package `F v0.1.2 (registry `https://example.com/`)`\n ... which satisfies dependency `F = \\\"^0.1.2\\\"` of package `E v1.0.0 (registry `https://example.com/`)`\n ... which satisfies dependency `E = \\\"*\\\"` of package `A v1.0.0 (registry `https://example.com/`)`\n ... which satisfies dependency `A = \\\"*\\\"` of package `root v1.0.0 (registry `https://example.com/`)`\n\nfailed to select a version for `F` which could resolve this conflict\\\n \",\n error.to_string()\n );\n}\n" }, { "path": "crates/resolver-tests/tests/validated.rs", "content": "use cargo::core::{Dependency, dependency::DepKind};\n\nuse resolver_tests::{\n helpers::{\n ToDep, dep, dep_kind, dep_platform, dep_req, dep_req_kind, dep_req_platform, pkg, pkg_dep,\n pkg_dep_with, registry,\n },\n pkg, resolve, resolve_and_validated,\n sat::SatResolver,\n};\n\n#[test]\nfn off_by_one_bug() {\n let input = vec![\n pkg!((\"A-sys\", \"0.0.1\")),\n pkg!((\"A-sys\", \"0.0.4\")),\n pkg!((\"A-sys\", \"0.0.6\")),\n pkg!((\"A-sys\", \"0.0.7\")),\n pkg!((\"NA\", \"0.0.0\") => [dep_req(\"A-sys\", \"<= 0.0.5\"),]),\n pkg!((\"NA\", \"0.0.1\") => [dep_req(\"A-sys\", \">= 0.0.6, <= 0.0.8\"),]),\n pkg!((\"a\", \"0.0.1\")),\n pkg!((\"a\", \"0.0.2\")),\n pkg!((\"aa\", \"0.0.0\") => [dep_req(\"A-sys\", \">= 0.0.4, <= 0.0.6\"),dep_req(\"NA\", \"<= 0.0.0\"),]),\n pkg!((\"f\", \"0.0.3\") => [dep(\"NA\"),dep_req(\"a\", \"<= 0.0.2\"),dep(\"aa\"),]),\n ];\n\n let reg = registry(input);\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(vec![dep(\"f\")], ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn conflict_store_bug() {\n let input = vec![\n pkg!((\"A\", \"0.0.3\")),\n pkg!((\"A\", \"0.0.5\")),\n pkg!((\"A\", \"0.0.9\") => [dep(\"bad\"),]),\n pkg!((\"A\", \"0.0.10\") => [dep(\"bad\"),]),\n pkg!((\"L-sys\", \"0.0.1\") => [dep(\"bad\"),]),\n pkg!((\"L-sys\", \"0.0.5\")),\n pkg!((\"R\", \"0.0.4\") => [\n dep_req(\"L-sys\", \"= 0.0.5\"),\n ]),\n pkg!((\"R\", \"0.0.6\")),\n pkg!((\"a-sys\", \"0.0.5\")),\n pkg!((\"a-sys\", \"0.0.11\")),\n pkg!((\"c\", \"0.0.12\") => [\n dep_req(\"R\", \">= 0.0.3, <= 0.0.4\"),\n ]),\n pkg!((\"c\", \"0.0.13\") => [\n dep_req(\"a-sys\", \">= 0.0.8, <= 0.0.11\"),\n ]),\n pkg!((\"c0\", \"0.0.6\") => [\n dep_req(\"L-sys\", \"<= 0.0.2\"),\n ]),\n pkg!((\"c0\", \"0.0.10\") => [\n dep_req(\"A\", \">= 0.0.9, <= 0.0.10\"),\n dep_req(\"a-sys\", \"= 0.0.5\"),\n ]),\n pkg!(\"j\" => [\n dep_req(\"A\", \">= 0.0.3, <= 0.0.5\"),\n dep_req(\"R\", \">=0.0.4, <= 0.0.6\"),\n dep_req(\"c\", \">= 0.0.9\"),\n dep_req(\"c0\", \">= 0.0.6\"),\n ]),\n ];\n\n let reg = registry(input);\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(vec![dep(\"j\")], ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn conflict_store_more_then_one_match() {\n let input = vec![\n pkg!((\"A\", \"0.0.0\")),\n pkg!((\"A\", \"0.0.1\")),\n pkg!((\"A-sys\", \"0.0.0\")),\n pkg!((\"A-sys\", \"0.0.1\")),\n pkg!((\"A-sys\", \"0.0.2\")),\n pkg!((\"A-sys\", \"0.0.3\")),\n pkg!((\"A-sys\", \"0.0.12\")),\n pkg!((\"A-sys\", \"0.0.16\")),\n pkg!((\"B-sys\", \"0.0.0\")),\n pkg!((\"B-sys\", \"0.0.1\")),\n pkg!((\"B-sys\", \"0.0.2\") => [dep_req(\"A-sys\", \"= 0.0.12\"),]),\n pkg!((\"BA-sys\", \"0.0.0\") => [dep_req(\"A-sys\",\"= 0.0.16\"),]),\n pkg!((\"BA-sys\", \"0.0.1\") => [dep(\"bad\"),]),\n pkg!((\"BA-sys\", \"0.0.2\") => [dep(\"bad\"),]),\n pkg!(\"nA\" => [\n dep(\"A\"),\n dep_req(\"A-sys\", \"<= 0.0.3\"),\n dep(\"B-sys\"),\n dep(\"BA-sys\"),\n ]),\n ];\n let reg = registry(input);\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(vec![dep(\"nA\")], ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn bad_lockfile_from_8249() {\n let input = vec![\n pkg!((\"a-sys\", \"0.2.0\")),\n pkg!((\"a-sys\", \"0.1.0\")),\n pkg!((\"b\", \"0.1.0\") => [\n dep_req(\"a-sys\", \"0.1\"), // should be optional: true, but not needed for now\n ]),\n pkg!((\"c\", \"1.0.0\") => [\n dep_req(\"b\", \"=0.1.0\"),\n ]),\n pkg!(\"foo\" => [\n dep_req(\"a-sys\", \"=0.2.0\"),\n {\n let mut b = dep_req(\"b\", \"=0.1.0\");\n b.set_features(vec![\"a-sys\"]);\n b\n },\n dep_req(\"c\", \"=1.0.0\"),\n ]),\n ];\n let reg = registry(input);\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(vec![dep(\"foo\")], ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn registry_with_features() {\n let reg = registry(vec![\n pkg!(\"a\"),\n pkg!(\"b\"),\n pkg_dep_with(\n \"image\",\n vec![\"a\".opt(), \"b\".opt(), \"jpg\".to_dep()],\n &[(\"default\", &[\"a\"]), (\"b\", &[\"dep:b\"])],\n ),\n pkg!(\"jpg\"),\n pkg!(\"log\"),\n pkg!(\"man\"),\n pkg_dep_with(\"rgb\", vec![\"man\".opt()], &[(\"man\", &[\"dep:man\"])]),\n pkg_dep_with(\n \"dep\",\n vec![\"image\".with(&[\"b\"]), \"log\".opt(), \"rgb\".opt()],\n &[\n (\"default\", &[\"log\", \"image/default\"]),\n (\"man\", &[\"rgb?/man\"]),\n ],\n ),\n ]);\n\n for deps in [\n vec![\"dep\".with(&[\"default\", \"man\", \"log\", \"rgb\"])],\n vec![\"dep\".with(&[\"default\"])],\n vec![\"dep\".with(&[])],\n vec![\"dep\".with(&[\"man\"])],\n vec![\"dep\".with(&[\"man\", \"rgb\"])],\n ] {\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n }\n}\n\n#[test]\nfn missing_feature() {\n let reg = registry(vec![pkg!(\"a\")]);\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(vec![\"a\".with(&[\"f\"])], ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn missing_dep_feature() {\n let reg = registry(vec![\n pkg(\"a\"),\n pkg_dep_with(\"dep\", vec![dep(\"a\")], &[(\"f\", &[\"a/a\"])]),\n ]);\n\n let deps = vec![dep(\"dep\").with(&[\"f\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn missing_weak_dep_feature() {\n let reg = registry(vec![\n pkg(\"a\"),\n pkg_dep_with(\"dep1\", vec![dep(\"a\")], &[(\"f\", &[\"a/a\"])]),\n pkg_dep_with(\"dep2\", vec![\"a\".opt()], &[(\"f\", &[\"a/a\"])]),\n pkg_dep_with(\"dep3\", vec![\"a\".opt()], &[(\"f\", &[\"a?/a\"])]),\n pkg_dep_with(\"dep4\", vec![\"x\".opt()], &[(\"f\", &[\"x?/a\"])]),\n ]);\n\n let deps = vec![dep(\"dep1\").with(&[\"f\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n\n let deps = vec![dep(\"dep2\").with(&[\"f\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n\n let deps = vec![dep(\"dep2\").with(&[\"a\", \"f\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n\n // Weak dependencies are not supported yet in the dependency resolver\n let deps = vec![dep(\"dep3\").with(&[\"f\"])];\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n\n let deps = vec![dep(\"dep3\").with(&[\"a\", \"f\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n\n // Weak dependencies are not supported yet in the dependency resolver\n let deps = vec![dep(\"dep4\").with(&[\"f\"])];\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n\n let deps = vec![dep(\"dep4\").with(&[\"x\", \"f\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn conflict_feature_and_sys() {\n let reg = registry(vec![\n pkg((\"a-sys\", \"1.0.0\")),\n pkg((\"a-sys\", \"2.0.0\")),\n pkg_dep_with(\n (\"a\", \"1.0.0\"),\n vec![dep_req(\"a-sys\", \"1.0.0\")],\n &[(\"f\", &[])],\n ),\n pkg_dep_with(\n (\"a\", \"2.0.0\"),\n vec![dep_req(\"a-sys\", \"2.0.0\")],\n &[(\"g\", &[])],\n ),\n pkg_dep(\"dep\", vec![dep_req(\"a\", \"2.0.0\")]),\n ]);\n\n let deps = vec![dep_req(\"a\", \"*\").with(&[\"f\"]), dep(\"dep\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn conflict_weak_features() {\n let reg = registry(vec![\n pkg((\"a-sys\", \"1.0.0\")),\n pkg((\"a-sys\", \"2.0.0\")),\n pkg_dep(\"a1\", vec![dep_req(\"a-sys\", \"1.0.0\").opt()]),\n pkg_dep(\"a2\", vec![dep_req(\"a-sys\", \"2.0.0\").opt()]),\n pkg_dep_with(\n \"dep\",\n vec![\"a1\".opt(), \"a2\".opt()],\n &[(\"a1\", &[\"a1?/a-sys\"]), (\"a2\", &[\"a2?/a-sys\"])],\n ),\n ]);\n\n let deps = vec![dep(\"dep\").with(&[\"a1\", \"a2\"])];\n\n // Weak dependencies are not supported yet in the dependency resolver\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n}\n\n#[test]\nfn multiple_dep_kinds_and_targets() {\n let reg = registry(vec![\n pkg((\"a-sys\", \"1.0.0\")),\n pkg((\"a-sys\", \"2.0.0\")),\n pkg_dep_with(\n \"dep1\",\n vec![\n dep_req_platform(\"a-sys\", \"1.0.0\", \"cfg(all())\").opt(),\n dep_req(\"a-sys\", \"1.0.0\").opt(),\n dep_req_kind(\"a-sys\", \"2.0.0\", DepKind::Build).opt(),\n ],\n &[(\"default\", &[\"dep:a-sys\"])],\n ),\n pkg_dep_with(\n \"dep2\",\n vec![\n dep_req_platform(\"a-sys\", \"1.0.0\", \"cfg(all())\").opt(),\n dep_req(\"a-sys\", \"1.0.0\").opt(),\n dep_req_kind(\"a-sys\", \"2.0.0\", DepKind::Development).rename(\"a-sys-dev\"),\n ],\n &[(\"default\", &[\"dep:a-sys\", \"a-sys-dev/bad\"])],\n ),\n ]);\n\n let deps = vec![dep(\"dep1\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n\n let deps = vec![dep(\"dep2\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n\n let deps = vec![\n dep_req(\"a-sys\", \"1.0.0\"),\n dep_req_kind(\"a-sys\", \"2.0.0\", DepKind::Build).rename(\"a2\"),\n ];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n\n let deps = vec![\n dep_req(\"a-sys\", \"1.0.0\"),\n dep_req_kind(\"a-sys\", \"2.0.0\", DepKind::Development).rename(\"a2\"),\n ];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn multiple_dep_kinds_and_targets_with_different_packages() {\n let reg = registry(vec![\n pkg_dep_with(\"a\", vec![], &[(\"f\", &[])]),\n pkg_dep_with(\"b\", vec![], &[(\"f\", &[])]),\n pkg_dep_with(\"c\", vec![], &[(\"g\", &[])]),\n pkg_dep_with(\n \"dep1\",\n vec![\n \"a\".opt().rename(\"x\").with(&[\"f\"]),\n dep_platform(\"a\", \"cfg(all())\").opt().rename(\"x\"),\n dep_kind(\"b\", DepKind::Build).opt().rename(\"x\").with(&[\"f\"]),\n ],\n &[(\"default\", &[\"x\"])],\n ),\n pkg_dep_with(\n \"dep2\",\n vec![\n \"a\".opt().rename(\"x\").with(&[\"f\"]),\n dep_platform(\"a\", \"cfg(all())\").opt().rename(\"x\"),\n dep_kind(\"c\", DepKind::Build).opt().rename(\"x\").with(&[\"f\"]),\n ],\n &[(\"default\", &[\"x\"])],\n ),\n ]);\n\n let deps = vec![\"dep1\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n\n let deps = vec![\"dep2\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn dep_feature_with_shadowing_feature() {\n let reg = registry(vec![\n pkg_dep_with(\"a\", vec![], &[(\"b\", &[])]),\n pkg_dep_with(\n \"dep\",\n vec![\"a\".opt().rename(\"aa\"), \"c\".opt()],\n &[(\"default\", &[\"aa/b\"]), (\"aa\", &[\"c\"])],\n ),\n ]);\n\n let deps = vec![\"dep\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn dep_feature_not_optional_with_shadowing_feature() {\n let reg = registry(vec![\n pkg_dep_with(\"a\", vec![], &[(\"b\", &[])]),\n pkg_dep_with(\n \"dep\",\n vec![\"a\".rename(\"aa\"), \"c\".opt()],\n &[(\"default\", &[\"aa/b\"]), (\"aa\", &[\"c\"])],\n ),\n ]);\n\n let deps = vec![\"dep\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn dep_feature_weak_with_shadowing_feature() {\n let reg = registry(vec![\n pkg_dep_with(\"a\", vec![], &[(\"b\", &[])]),\n pkg_dep_with(\n \"dep\",\n vec![\"a\".opt().rename(\"aa\"), \"c\".opt()],\n &[(\"default\", &[\"aa?/b\"]), (\"aa\", &[\"c\"])],\n ),\n ]);\n\n let deps = vec![\"dep\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn dep_feature_duplicate_with_shadowing_feature() {\n let reg = registry(vec![\n pkg_dep_with(\"a\", vec![], &[(\"b\", &[])]),\n pkg_dep_with(\n \"dep\",\n vec![\n \"a\".opt().rename(\"aa\"),\n dep_kind(\"a\", DepKind::Build).rename(\"aa\"),\n \"c\".opt(),\n ],\n &[(\"default\", &[\"aa/b\"]), (\"aa\", &[\"c\"])],\n ),\n ]);\n\n let deps = vec![\"dep\".with(&[\"default\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n}\n\n#[test]\nfn optional_dep_features() {\n let reg = registry(vec![\n pkg_dep(\"a\", vec![\"bad\".opt()]),\n pkg_dep(\"b\", vec![\"a\".opt().with(&[\"bad\"])]),\n pkg_dep(\"dep\", vec![dep(\"a\"), dep(\"b\")]),\n ]);\n\n let deps = vec![dep(\"dep\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn optional_dep_features_with_rename() {\n let reg = registry(vec![\n pkg(\"x1\"),\n pkg_dep(\"a\", vec![\"x1\".opt(), \"x2\".opt(), \"x3\".opt()]),\n pkg_dep(\n \"dep1\",\n vec![\n \"a\".opt().with(&[\"x1\"]),\n dep_kind(\"a\", DepKind::Build).opt().with(&[\"x2\"]),\n ],\n ),\n pkg_dep(\n \"dep2\",\n vec![\n \"a\".opt().with(&[\"x1\"]),\n \"a\".opt().rename(\"a2\").with(&[\"x3\"]),\n ],\n ),\n ]);\n\n let deps = vec![\"dep1\".with(&[\"a\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_err());\n\n let deps = vec![\"dep2\".with(&[\"a\"])];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n\n#[test]\nfn optional_weak_dep_features() {\n let reg = registry(vec![\n pkg_dep(\"a\", vec![\"bad\".opt()]),\n pkg_dep(\"b\", vec![dep(\"a\")]),\n pkg_dep_with(\"dep\", vec![\"a\".opt(), dep(\"b\")], &[(\"f\", &[\"a?/bad\"])]),\n ]);\n\n let deps = vec![\"dep\".with(&[\"f\"])];\n\n // Weak dependencies are not supported yet in the dependency resolver\n assert!(resolve(deps.clone(), ®).is_err());\n assert!(SatResolver::new(®).sat_resolve(&deps));\n}\n\n#[test]\nfn default_feature_multiple_major_versions() {\n let reg = registry(vec![\n pkg_dep_with((\"a\", \"0.2.0\"), vec![], &[(\"default\", &[])]),\n pkg((\"a\", \"0.3.0\")),\n pkg_dep_with((\"a\", \"0.4.0\"), vec![], &[(\"default\", &[])]),\n pkg_dep(\n \"dep1\",\n vec![\n dep_req(\"a\", \">=0.2, <0.4\").with_default(),\n dep_req(\"a\", \"0.2\").rename(\"a2\").with(&[]),\n ],\n ),\n pkg_dep(\n \"dep2\",\n vec![\n dep_req(\"a\", \">=0.2, <0.4\").with_default(),\n dep_req(\"a\", \"0.3\").rename(\"a2\").with(&[]),\n ],\n ),\n pkg_dep(\n \"dep3\",\n vec![\n dep_req(\"a\", \">=0.2, <0.4\").with_default(),\n dep_req(\"a\", \"0.2\").rename(\"a1\").with(&[]),\n dep_req(\"a\", \"0.3\").rename(\"a2\").with(&[]),\n ],\n ),\n pkg_dep(\"dep4\", vec![dep_req(\"a\", \">=0.2, <0.4\").with_default()]),\n pkg_dep(\"dep5\", vec![dep_req(\"a\", \">=0.3, <0.5\").with_default()]),\n ]);\n\n let deps = vec![dep(\"dep1\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n\n let deps = vec![dep(\"dep2\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n\n let deps = vec![dep(\"dep3\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n\n let deps = vec![dep(\"dep4\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n\n let deps = vec![dep(\"dep5\")];\n let mut sat_resolver = SatResolver::new(®);\n assert!(resolve_and_validated(deps, ®, &mut sat_resolver).is_ok());\n}\n" }, { "path": "crates/rustfix/CHANGELOG.md", "content": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),\nand this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n\n## [Unreleased]\n\n## [0.4.6] - 2019-07-16\n\n### Changed\n\nInternal changes:\n\n- Change example to automatically determine filename\n- Migrate to Rust 2018\n- use `derive` feature over `serde_derive` crate\n\n## [0.4.5] - 2019-03-26\n\n### Added\n\n- Implement common traits for Diagnostic and related types\n\n### Fixed\n\n- Fix out of bounds access in parse_snippet\n\n## [0.4.4] - 2018-12-13\n\n### Added\n\n- Make Diagnostic::rendered public.\n\n### Changed\n\n- Revert faulty \"Allow multiple solutions in a suggestion\"\n\n## [0.4.3] - 2018-12-09 - *yanked!*\n\n### Added\n\n- Allow multiple solutions in a suggestion\n\n### Changed\n\n- use `RUSTC` environment var if present\n\n## [0.4.2] - 2018-07-31\n\n### Added\n\n- Expose an interface to apply fixes on-by-one\n\n### Changed\n\n- Handle invalid snippets instead of panicking\n\n## [0.4.1] - 2018-07-26\n\n### Changed\n\n- Ignore duplicate replacements\n\n## [0.4.0] - 2018-05-23\n\n### Changed\n\n- Filter by machine applicability by default\n\n[Unreleased]: https://github.com/rust-lang-nursery/rustfix/compare/rustfix-0.4.6...HEAD\n[0.4.6]: https://github.com/rust-lang-nursery/rustfix/compare/rustfix-0.4.5...rustfix-0.4.6\n[0.4.5]: https://github.com/rust-lang-nursery/rustfix/compare/rustfix-0.4.4...rustfix-0.4.5\n[0.4.4]: https://github.com/rust-lang-nursery/rustfix/compare/rustfix-0.4.3...rustfix-0.4.4\n[0.4.3]: https://github.com/rust-lang-nursery/rustfix/compare/rustfix-0.4.2...rustfix-0.4.3\n[0.4.2]: https://github.com/rust-lang-nursery/rustfix/compare/rustfix-0.4.1...rustfix-0.4.2\n[0.4.1]: https://github.com/rust-lang-nursery/rustfix/compare/rustfix-0.4.0...rustfix-0.4.1\n[0.4.0]: https://github.com/rust-lang-nursery/rustfix/compare/rustfix-0.4.0\n" }, { "path": "crates/rustfix/Cargo.toml", "content": "[package]\nname = \"rustfix\"\nversion = \"0.9.5\"\nauthors = [\n \"Pascal Hertleif \",\n \"Oliver Schneider \",\n]\nrust-version.workspace = true\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"Automatically apply the suggestions made by rustc\"\ndocumentation = \"https://docs.rs/rustfix\"\nexclude = [\n \"examples/*\",\n \"tests/*\",\n]\n\n[dependencies]\nserde = { workspace = true, features = [\"derive\"] }\nserde_json.workspace = true\nthiserror.workspace = true\ntracing.workspace = true\n\n[dev-dependencies]\nanyhow.workspace = true\nproptest.workspace = true\nsimilar.workspace = true\ntempfile.workspace = true\ntracing-subscriber.workspace = true\nsnapbox.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/rustfix/README.md", "content": "# rustfix\n\n[![Latest Version](https://img.shields.io/crates/v/rustfix.svg)](https://crates.io/crates/rustfix)\n[![Rust Documentation](https://docs.rs/rustfix/badge.svg)](https://docs.rs/rustfix)\n\nRustfix is a library defining useful structures that represent fix suggestions from rustc.\n\nThis is a low-level library. You pass it the JSON output from `rustc`, and you can then use it to apply suggestions to in-memory strings. This library doesn't execute commands, or read or write from the filesystem.\n\nIf you are looking for the [`cargo fix`] implementation, the core of it is located in [`cargo::ops::fix`].\n\n> This crate is maintained by the Cargo team, primarily for use by Cargo and Rust compiler test suite\n> and not intended for external use (except as a transitive dependency). This\n> crate may make major changes to its APIs or be deprecated without warning.\n\n[`cargo fix`]: https://doc.rust-lang.org/cargo/commands/cargo-fix.html\n[`cargo::ops::fix`]: https://github.com/rust-lang/cargo/blob/master/src/cargo/ops/fix.rs\n\n## License\n\nLicensed under either of\n\n- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or )\n- MIT license ([LICENSE-MIT](LICENSE-MIT) or )\n\nat your option.\n\n### Contribution\n\nUnless you explicitly state otherwise, any contribution intentionally\nsubmitted for inclusion in the work by you, as defined in the Apache-2.0\nlicense, shall be dual licensed as above, without any additional terms or\nconditions.\n" }, { "path": "crates/rustfix/examples/fix-json.rs", "content": "#![allow(clippy::print_stderr)]\n\nuse std::io::{BufReader, Read, stdin};\nuse std::{collections::HashMap, collections::HashSet, env, fs};\n\nuse anyhow::Error;\n\nfn main() -> Result<(), Error> {\n let suggestions_file = env::args().nth(1).expect(\"USAGE: fix-json \");\n let suggestions = if suggestions_file == \"--\" {\n let mut buffer = String::new();\n BufReader::new(stdin()).read_to_string(&mut buffer)?;\n buffer\n } else {\n fs::read_to_string(&suggestions_file)?\n };\n let suggestions = rustfix::get_suggestions_from_json(\n &suggestions,\n &HashSet::new(),\n rustfix::Filter::Everything,\n )?;\n\n let mut files = HashMap::new();\n for suggestion in suggestions {\n let file = suggestion.solutions[0].replacements[0]\n .snippet\n .file_name\n .clone();\n files.entry(file).or_insert_with(Vec::new).push(suggestion);\n }\n\n for (source_file, suggestions) in &files {\n let source = fs::read_to_string(source_file)?;\n let mut fix = rustfix::CodeFix::new(&source);\n for suggestion in suggestions.iter().rev() {\n if let Err(e) = fix.apply(suggestion) {\n eprintln!(\"Failed to apply suggestion to {}: {}\", source_file, e);\n }\n }\n let fixes = fix.finish()?;\n fs::write(source_file, fixes)?;\n }\n\n Ok(())\n}\n" }, { "path": "crates/rustfix/proptest-regressions/replace.txt", "content": "# Seeds for failure cases proptest has generated in the past. It is\n# automatically read and these particular cases re-run before any\n# novel cases are generated.\n#\n# It is recommended to check this file in to source control so that\n# everyone who runs the test benefits from these saved cases.\nxs 358148376 3634975642 2528447681 3675516813 # shrinks to ref s = \"\"\nxs 3127423015 3362740891 2605681441 2390162043 # shrinks to ref data = \"\", ref replacements = [(0..0, [])]\n" }, { "path": "crates/rustfix/src/diagnostics.rs", "content": "//! Rustc Diagnostic JSON Output.\n//!\n//! The following data types are copied from [rust-lang/rust](https://github.com/rust-lang/rust/blob/4fd68eb47bad1c121417ac4450b2f0456150db86/compiler/rustc_errors/src/json.rs).\n//!\n//! For examples of the JSON output, see JSON fixture files under `tests/` directory.\n\nuse serde::Deserialize;\n\n/// The root diagnostic JSON output emitted by the compiler.\n#[derive(Clone, Deserialize, Debug, Hash, Eq, PartialEq)]\npub struct Diagnostic {\n /// The primary error message.\n pub message: String,\n pub code: Option,\n /// \"error: internal compiler error\", \"error\", \"warning\", \"note\", \"help\".\n level: String,\n pub spans: Vec,\n /// Associated diagnostic messages.\n pub children: Vec,\n /// The message as rustc would render it.\n pub rendered: Option,\n}\n\n/// Span information of a diagnostic item.\n#[derive(Clone, Deserialize, Debug, Hash, Eq, PartialEq)]\npub struct DiagnosticSpan {\n pub file_name: String,\n pub byte_start: u32,\n pub byte_end: u32,\n /// 1-based.\n pub line_start: usize,\n pub line_end: usize,\n /// 1-based, character offset.\n pub column_start: usize,\n pub column_end: usize,\n /// Is this a \"primary\" span -- meaning the point, or one of the points,\n /// where the error occurred?\n pub is_primary: bool,\n /// Source text from the start of `line_start` to the end of `line_end`.\n pub text: Vec,\n /// Label that should be placed at this location (if any)\n label: Option,\n /// If we are suggesting a replacement, this will contain text\n /// that should be sliced in atop this span.\n pub suggested_replacement: Option,\n /// If the suggestion is approximate\n pub suggestion_applicability: Option,\n /// Macro invocations that created the code at this span, if any.\n expansion: Option>,\n}\n\n/// Indicates the confidence in the correctness of a suggestion.\n///\n/// All suggestions are marked with an `Applicability`. Tools use the applicability of a suggestion\n/// to determine whether it should be automatically applied or if the user should be consulted\n/// before applying the suggestion.\n#[derive(Copy, Clone, Debug, PartialEq, Deserialize, Hash, Eq)]\npub enum Applicability {\n /// The suggestion is definitely what the user intended, or maintains the exact meaning of the code.\n /// This suggestion should be automatically applied.\n ///\n /// In case of multiple `MachineApplicable` suggestions (whether as part of\n /// the same `multipart_suggestion` or not), all of them should be\n /// automatically applied.\n MachineApplicable,\n\n /// The suggestion may be what the user intended, but it is uncertain. The suggestion should\n /// result in valid Rust code if it is applied.\n MaybeIncorrect,\n\n /// The suggestion contains placeholders like `(...)` or `{ /* fields */ }`. The suggestion\n /// cannot be applied automatically because it will not result in valid Rust code. The user\n /// will need to fill in the placeholders.\n HasPlaceholders,\n\n /// The applicability of the suggestion is unknown.\n Unspecified,\n}\n\n/// Span information of a single line.\n#[derive(Clone, Deserialize, Debug, Eq, PartialEq, Hash)]\npub struct DiagnosticSpanLine {\n pub text: String,\n\n /// 1-based, character offset in self.text.\n pub highlight_start: usize,\n\n pub highlight_end: usize,\n}\n\n/// Span information for macro expansions.\n#[derive(Clone, Deserialize, Debug, Eq, PartialEq, Hash)]\nstruct DiagnosticSpanMacroExpansion {\n /// span where macro was applied to generate this code; note that\n /// this may itself derive from a macro (if\n /// `span.expansion.is_some()`)\n span: DiagnosticSpan,\n\n /// name of macro that was applied (e.g., \"foo!\" or \"#[derive(Eq)]\")\n macro_decl_name: String,\n\n /// span where macro was defined (if known)\n def_site_span: Option,\n}\n\n/// The error code emitted by the compiler. See [Rust error codes index].\n///\n/// [Rust error codes index]: https://doc.rust-lang.org/error_codes/error-index.html\n#[derive(Clone, Deserialize, Debug, Eq, PartialEq, Hash)]\npub struct DiagnosticCode {\n /// The code itself.\n pub code: String,\n /// An explanation for the code.\n explanation: Option,\n}\n" }, { "path": "crates/rustfix/src/error.rs", "content": "//! Error types.\n\nuse std::ops::Range;\n\n#[non_exhaustive]\n#[derive(Debug, thiserror::Error)]\npub enum Error {\n #[error(\"invalid range {0:?}, start is larger than end\")]\n InvalidRange(Range),\n\n #[error(\"invalid range {0:?}, original data is only {1} byte long\")]\n DataLengthExceeded(Range, usize),\n\n #[non_exhaustive]\n #[error(\"cannot replace slice of data that was already replaced\")]\n AlreadyReplaced {\n /// The location of the intended replacement.\n range: Range,\n /// Whether the modification exactly matches (both range and data) the one it conflicts with.\n /// Some clients may wish to simply ignore this condition.\n is_identical: bool,\n },\n\n #[error(transparent)]\n Utf8(#[from] std::string::FromUtf8Error),\n}\n" }, { "path": "crates/rustfix/src/lib.rs", "content": "//! Library for applying diagnostic suggestions to source code.\n//!\n//! This is a low-level library. You pass it the [JSON output] from `rustc`,\n//! and you can then use it to apply suggestions to in-memory strings.\n//! This library doesn't execute commands, or read or write from the filesystem.\n//!\n//! If you are looking for the [`cargo fix`] implementation, the core of it is\n//! located in [`cargo::ops::fix`].\n//!\n//! [`cargo fix`]: https://doc.rust-lang.org/cargo/commands/cargo-fix.html\n//! [`cargo::ops::fix`]: https://github.com/rust-lang/cargo/blob/master/src/cargo/ops/fix.rs\n//! [JSON output]: diagnostics\n//!\n//! The general outline of how to use this library is:\n//!\n//! 1. Call `rustc` and collect the JSON data.\n//! 2. Pass the json data to [`get_suggestions_from_json`].\n//! 3. Create a [`CodeFix`] with the source of a file to modify.\n//! 4. Call [`CodeFix::apply`] to apply a change.\n//! 5. Call [`CodeFix::finish`] to get the result and write it back to disk.\n//!\n//! > This crate is maintained by the Cargo team, primarily for use by Cargo and Rust compiler test suite\n//! > and not intended for external use (except as a transitive dependency). This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\nuse std::collections::HashSet;\nuse std::ops::Range;\n\npub mod diagnostics;\nmod error;\nmod replace;\n\nuse diagnostics::Diagnostic;\nuse diagnostics::DiagnosticSpan;\npub use error::Error;\n\n/// A filter to control which suggestion should be applied.\n#[derive(Debug, Clone, Copy)]\npub enum Filter {\n /// For [`diagnostics::Applicability::MachineApplicable`] only.\n MachineApplicableOnly,\n /// Everything is included. YOLO!\n Everything,\n}\n\n/// Collects code [`Suggestion`]s from one or more compiler diagnostic lines.\n///\n/// Fails if any of diagnostic line `input` is not a valid [`Diagnostic`] JSON.\n///\n/// * `only` --- only diagnostics with code in a set of error codes would be collected.\npub fn get_suggestions_from_json(\n input: &str,\n only: &HashSet,\n filter: Filter,\n) -> serde_json::error::Result> {\n let mut result = Vec::new();\n for cargo_msg in serde_json::Deserializer::from_str(input).into_iter::() {\n // One diagnostic line might have multiple suggestions\n result.extend(collect_suggestions(&cargo_msg?, only, filter));\n }\n Ok(result)\n}\n\n#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]\npub struct LinePosition {\n pub line: usize,\n pub column: usize,\n}\n\nimpl std::fmt::Display for LinePosition {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{}:{}\", self.line, self.column)\n }\n}\n\n#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]\npub struct LineRange {\n pub start: LinePosition,\n pub end: LinePosition,\n}\n\nimpl std::fmt::Display for LineRange {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{}-{}\", self.start, self.end)\n }\n}\n\n/// An error/warning and possible solutions for fixing it\n#[derive(Debug, Clone, Hash, PartialEq, Eq)]\npub struct Suggestion {\n pub message: String,\n pub snippets: Vec,\n pub solutions: Vec,\n}\n\n/// Solution to a diagnostic item.\n#[derive(Debug, Clone, Hash, PartialEq, Eq)]\npub struct Solution {\n /// The error message of the diagnostic item.\n pub message: String,\n /// Possible solutions to fix the error.\n pub replacements: Vec,\n}\n\n/// Represents code that will get replaced.\n#[derive(Debug, Clone, Hash, PartialEq, Eq)]\npub struct Snippet {\n pub file_name: String,\n pub line_range: LineRange,\n pub range: Range,\n}\n\n/// Represents a replacement of a `snippet`.\n#[derive(Debug, Clone, Hash, PartialEq, Eq)]\npub struct Replacement {\n /// Code snippet that gets replaced.\n pub snippet: Snippet,\n /// The replacement of the snippet.\n pub replacement: String,\n}\n\n/// Converts a [`DiagnosticSpan`] to a [`Snippet`].\nfn span_to_snippet(span: &DiagnosticSpan) -> Snippet {\n Snippet {\n file_name: span.file_name.clone(),\n line_range: LineRange {\n start: LinePosition {\n line: span.line_start,\n column: span.column_start,\n },\n end: LinePosition {\n line: span.line_end,\n column: span.column_end,\n },\n },\n range: (span.byte_start as usize)..(span.byte_end as usize),\n }\n}\n\n/// Converts a [`DiagnosticSpan`] into a [`Replacement`].\nfn collect_span(span: &DiagnosticSpan) -> Option {\n let snippet = span_to_snippet(span);\n let replacement = span.suggested_replacement.clone()?;\n Some(Replacement {\n snippet,\n replacement,\n })\n}\n\n/// Collects code [`Suggestion`]s from a single compiler diagnostic line.\n///\n/// * `only` --- only diagnostics with code in a set of error codes would be collected.\npub fn collect_suggestions(\n diagnostic: &Diagnostic,\n only: &HashSet,\n filter: Filter,\n) -> Option {\n if !only.is_empty() {\n if let Some(ref code) = diagnostic.code {\n if !only.contains(&code.code) {\n // This is not the code we are looking for\n return None;\n }\n } else {\n // No code, probably a weird builtin warning/error\n return None;\n }\n }\n\n let solutions: Vec<_> = diagnostic\n .children\n .iter()\n .filter_map(|child| {\n let replacements: Vec<_> = child\n .spans\n .iter()\n .filter(|span| {\n use crate::Filter::*;\n use crate::diagnostics::Applicability::*;\n\n match (filter, &span.suggestion_applicability) {\n (MachineApplicableOnly, Some(MachineApplicable)) => true,\n (MachineApplicableOnly, _) => false,\n (Everything, _) => true,\n }\n })\n .filter_map(collect_span)\n .collect();\n if !replacements.is_empty() {\n Some(Solution {\n message: child.message.clone(),\n replacements,\n })\n } else {\n None\n }\n })\n .collect();\n\n if solutions.is_empty() {\n None\n } else {\n Some(Suggestion {\n message: diagnostic.message.clone(),\n snippets: diagnostic.spans.iter().map(span_to_snippet).collect(),\n solutions,\n })\n }\n}\n\n/// Represents a code fix. This doesn't write to disks but is only in memory.\n///\n/// The general way to use this is:\n///\n/// 1. Feeds the source of a file to [`CodeFix::new`].\n/// 2. Calls [`CodeFix::apply`] to apply suggestions to the source code.\n/// 3. Calls [`CodeFix::finish`] to get the \"fixed\" code.\n#[derive(Clone)]\npub struct CodeFix {\n data: replace::Data,\n /// Whether or not the data has been modified.\n modified: bool,\n}\n\nimpl CodeFix {\n /// Creates a `CodeFix` with the source of a file to modify.\n pub fn new(s: &str) -> CodeFix {\n CodeFix {\n data: replace::Data::new(s.as_bytes()),\n modified: false,\n }\n }\n\n /// Applies a suggestion to the code.\n pub fn apply(&mut self, suggestion: &Suggestion) -> Result<(), Error> {\n for solution in &suggestion.solutions {\n for r in &solution.replacements {\n self.data\n .replace_range(r.snippet.range.clone(), r.replacement.as_bytes())\n .inspect_err(|_| self.data.restore())?;\n }\n }\n self.data.commit();\n self.modified = true;\n Ok(())\n }\n\n /// Applies an individual solution from a [`Suggestion`].\n pub fn apply_solution(&mut self, solution: &Solution) -> Result<(), Error> {\n for r in &solution.replacements {\n self.data\n .replace_range(r.snippet.range.clone(), r.replacement.as_bytes())\n .inspect_err(|_| self.data.restore())?;\n }\n self.data.commit();\n self.modified = true;\n Ok(())\n }\n\n /// Gets the result of the \"fixed\" code.\n pub fn finish(&self) -> Result {\n Ok(String::from_utf8(self.data.to_vec())?)\n }\n\n /// Returns whether or not the data has been modified.\n pub fn modified(&self) -> bool {\n self.modified\n }\n}\n\n/// Applies multiple `suggestions` to the given `code`, handling certain conflicts automatically.\n///\n/// If a replacement in a suggestion exactly matches a replacement of a previously applied solution,\n/// that entire suggestion will be skipped without generating an error.\n/// This is currently done to alleviate issues like rust-lang/rust#51211,\n/// although it may be removed if that's fixed deeper in the compiler.\n///\n/// The intent of this design is that the overall application process\n/// should repeatedly apply non-conflicting suggestions then rĆ«evaluate the result,\n/// looping until either there are no more suggestions to apply or some budget is exhausted.\npub fn apply_suggestions(code: &str, suggestions: &[Suggestion]) -> Result {\n let mut fix = CodeFix::new(code);\n for suggestion in suggestions.iter().rev() {\n fix.apply(suggestion).or_else(|err| match err {\n Error::AlreadyReplaced {\n is_identical: true, ..\n } => Ok(()),\n _ => Err(err),\n })?;\n }\n fix.finish()\n}\n" }, { "path": "crates/rustfix/src/replace.rs", "content": "//! A small module giving you a simple container that allows\n//! easy and cheap replacement of parts of its content,\n//! with the ability to commit or rollback pending changes.\n//!\n//! Create a new [`Data`] struct with some initial set of code,\n//! then record changes with [`Data::replace_range`],\n//! which will validate that the changes do not conflict with one another.\n//! At any time, you can \"checkpoint\" the current changes with [`Data::commit`]\n//! or roll them back (perhaps due to a conflict) with [`Data::restore`].\n//! When you're done, use [`Data::to_vec`]\n//! to merge the original data with the changes.\n//!\n//! # Notes\n//!\n//! The [`Data::to_vec`] method includes uncommitted changes, if present.\n//! The reason for including uncommitted changes is that typically, once you're calling those,\n//! you're done with edits and will be dropping the [`Data`] struct in a moment.\n//! In this case, requiring an extra call to `commit` would be unnecessary work.\n//! Of course, there's no harm in calling `commit`---it's just not strictly necessary.\n//!\n//! Put another way, the main point of `commit` is to checkpoint a set of known-good changes\n//! before applying additional sets of as-of-yet unvalidated changes.\n//! If no future changes are expected, you aren't _required_ to pay the cost of `commit`.\n//! If you want to discard uncommitted changes, simply call [`Data::restore`] first.\n\nuse std::ops::Range;\nuse std::rc::Rc;\n\nuse crate::error::Error;\n\n/// Data that should replace a particular range of the original.\n#[derive(Clone)]\nstruct Span {\n /// Span of the parent data to be replaced, inclusive of the start, exclusive of the end.\n range: Range,\n /// New data to insert at the `start` position of the `original` data.\n data: Rc<[u8]>,\n /// Whether this data is committed or provisional.\n committed: bool,\n}\n\nimpl std::fmt::Debug for Span {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let state = if self.is_insert() {\n \"inserted\"\n } else {\n \"replaced\"\n };\n\n let committed = if self.committed {\n \"committed\"\n } else {\n \"uncommitted\"\n };\n\n write!(\n f,\n \"({}, {}: {state}, {committed})\",\n self.range.start, self.range.end\n )\n }\n}\n\nimpl Span {\n fn new(range: Range, data: &[u8]) -> Self {\n Self {\n range,\n data: data.into(),\n committed: false,\n }\n }\n\n /// Returns `true` if and only if this is a \"pure\" insertion,\n /// i.e. does not remove any existing data.\n ///\n /// The insertion point is the `start` position of the range.\n fn is_insert(&self) -> bool {\n self.range.start == self.range.end\n }\n}\n\nimpl PartialEq for Span {\n /// Returns `true` if and only if this `Span` and `other` have the same range and data,\n /// regardless of `committed` status.\n fn eq(&self, other: &Self) -> bool {\n self.range == other.range && self.data == other.data\n }\n}\n\n/// A container that allows easily replacing chunks of its data.\n#[derive(Debug, Clone, Default)]\npub struct Data {\n /// Original data.\n original: Vec,\n /// [`Span`]s covering the full range of the original data.\n /// Important: it's expected that the underlying implementation maintains this in order,\n /// sorted ascending by start position.\n parts: Vec,\n}\n\nimpl Data {\n /// Create a new data container from a slice of bytes\n pub fn new(data: &[u8]) -> Self {\n Data {\n original: data.into(),\n parts: vec![],\n }\n }\n\n /// Commit the current changes.\n pub fn commit(&mut self) {\n self.parts.iter_mut().for_each(|span| span.committed = true);\n }\n\n /// Discard uncommitted changes.\n pub fn restore(&mut self) {\n self.parts.retain(|parts| parts.committed);\n }\n\n /// Merge the original data with changes, **including** uncommitted changes.\n ///\n /// See the module-level documentation for more information on why uncommitted changes are included.\n pub fn to_vec(&self) -> Vec {\n let mut prev_end = 0;\n let mut s = self.parts.iter().fold(Vec::new(), |mut acc, span| {\n // Hedge against potential implementation errors.\n debug_assert!(\n prev_end <= span.range.start,\n \"expected parts in sorted order\"\n );\n\n acc.extend_from_slice(&self.original[prev_end..span.range.start]);\n acc.extend_from_slice(&span.data);\n prev_end = span.range.end;\n acc\n });\n\n // Append remaining data, if any.\n s.extend_from_slice(&self.original[prev_end..]);\n s\n }\n\n /// Record a provisional change.\n ///\n /// If committed, the original data in the given `range` will be replaced by the given data.\n /// If there already exist changes for data in the given range (committed or not),\n /// this method will return an error.\n /// It will also return an error if the beginning of the range comes before its end,\n /// or if the range is outside that of the original data.\n pub fn replace_range(&mut self, range: Range, data: &[u8]) -> Result<(), Error> {\n if range.start > range.end {\n return Err(Error::InvalidRange(range));\n }\n\n if range.end > self.original.len() {\n return Err(Error::DataLengthExceeded(range, self.original.len()));\n }\n\n // Keep sorted by start position, or by end position if the start position is the same,\n // which has the effect of keeping a pure insertion ahead of a replacement.\n // That limits the kinds of conflicts that can happen, simplifying the checks below.\n let ins_point = self.parts.partition_point(|span| {\n span.range.start < range.start\n || (span.range.start == range.start && span.range.end < range.end)\n });\n\n let incoming = Span::new(range, data.as_ref());\n\n // Reject if the change starts before the previous one ends.\n if let Some(before) = ins_point.checked_sub(1).and_then(|i| self.parts.get(i)) {\n if incoming.range.start < before.range.end {\n return Err(Error::AlreadyReplaced {\n is_identical: incoming == *before,\n range: incoming.range,\n });\n }\n }\n\n // Reject if the change ends after the next one starts,\n // or if this is an insert and there's already an insert there.\n if let Some(after) = self.parts.get(ins_point) {\n if incoming.range.end > after.range.start || incoming.range == after.range {\n return Err(Error::AlreadyReplaced {\n is_identical: incoming == *after,\n range: incoming.range,\n });\n }\n }\n\n self.parts.insert(ins_point, incoming);\n Ok(())\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use proptest::prelude::*;\n\n fn str(i: &[u8]) -> &str {\n ::std::str::from_utf8(i).unwrap()\n }\n\n #[test]\n fn insert_at_beginning() {\n let mut d = Data::new(b\"foo bar baz\");\n d.replace_range(0..0, b\"oh no \").unwrap();\n assert_eq!(\"oh no foo bar baz\", str(&d.to_vec()));\n }\n\n #[test]\n fn insert_at_end() {\n let mut d = Data::new(b\"foo bar baz\");\n d.replace_range(11..11, b\" oh no\").unwrap();\n assert_eq!(\"foo bar baz oh no\", str(&d.to_vec()));\n }\n\n #[test]\n fn replace_some_stuff() {\n let mut d = Data::new(b\"foo bar baz\");\n d.replace_range(4..7, b\"lol\").unwrap();\n assert_eq!(\"foo lol baz\", str(&d.to_vec()));\n }\n\n #[test]\n fn replace_a_single_char() {\n let mut d = Data::new(b\"let y = true;\");\n d.replace_range(4..5, b\"mut y\").unwrap();\n assert_eq!(\"let mut y = true;\", str(&d.to_vec()));\n }\n\n #[test]\n fn replace_multiple_lines() {\n let mut d = Data::new(b\"lorem\\nipsum\\ndolor\");\n\n d.replace_range(6..11, b\"lol\").unwrap();\n assert_eq!(\"lorem\\nlol\\ndolor\", str(&d.to_vec()));\n\n d.replace_range(12..17, b\"lol\").unwrap();\n assert_eq!(\"lorem\\nlol\\nlol\", str(&d.to_vec()));\n }\n\n #[test]\n fn replace_multiple_lines_with_insert_only() {\n let mut d = Data::new(b\"foo!\");\n\n d.replace_range(3..3, b\"bar\").unwrap();\n assert_eq!(\"foobar!\", str(&d.to_vec()));\n\n d.replace_range(0..3, b\"baz\").unwrap();\n assert_eq!(\"bazbar!\", str(&d.to_vec()));\n\n d.replace_range(3..4, b\"?\").unwrap();\n assert_eq!(\"bazbar?\", str(&d.to_vec()));\n }\n\n #[test]\n #[allow(clippy::reversed_empty_ranges)]\n fn replace_invalid_range() {\n let mut d = Data::new(b\"foo!\");\n\n assert!(d.replace_range(2..1, b\"bar\").is_err());\n assert!(d.replace_range(0..3, b\"bar\").is_ok());\n }\n\n #[test]\n fn empty_to_vec_roundtrip() {\n let s = \"\";\n assert_eq!(s.as_bytes(), Data::new(s.as_bytes()).to_vec().as_slice());\n }\n\n #[test]\n fn replace_same_range_diff_data() {\n let mut d = Data::new(b\"foo bar baz\");\n\n d.replace_range(4..7, b\"lol\").unwrap();\n assert_eq!(\"foo lol baz\", str(&d.to_vec()));\n\n assert!(matches!(\n d.replace_range(4..7, b\"lol2\").unwrap_err(),\n Error::AlreadyReplaced {\n is_identical: false,\n ..\n },\n ));\n }\n\n #[test]\n fn replace_same_range_same_data() {\n let mut d = Data::new(b\"foo bar baz\");\n\n d.replace_range(4..7, b\"lol\").unwrap();\n assert_eq!(\"foo lol baz\", str(&d.to_vec()));\n\n assert!(matches!(\n d.replace_range(4..7, b\"lol\").unwrap_err(),\n Error::AlreadyReplaced {\n is_identical: true,\n ..\n },\n ));\n }\n\n #[test]\n fn broken_replacements() {\n let mut d = Data::new(b\"foo\");\n assert!(matches!(\n d.replace_range(4..8, b\"lol\").unwrap_err(),\n Error::DataLengthExceeded(std::ops::Range { start: 4, end: 8 }, 3),\n ));\n }\n\n #[test]\n fn insert_same_twice() {\n let mut d = Data::new(b\"foo\");\n d.replace_range(1..1, b\"b\").unwrap();\n assert_eq!(\"fboo\", str(&d.to_vec()));\n assert!(matches!(\n d.replace_range(1..1, b\"b\").unwrap_err(),\n Error::AlreadyReplaced {\n is_identical: true,\n ..\n },\n ));\n assert_eq!(\"fboo\", str(&d.to_vec()));\n }\n\n #[test]\n fn commit_restore() {\n let mut d = Data::new(b\", \");\n assert_eq!(\", \", str(&d.to_vec()));\n\n d.replace_range(2..2, b\"world\").unwrap();\n d.replace_range(0..0, b\"hello\").unwrap();\n assert_eq!(\"hello, world\", str(&d.to_vec()));\n\n d.restore();\n assert_eq!(\", \", str(&d.to_vec()));\n\n d.commit();\n assert_eq!(\", \", str(&d.to_vec()));\n\n d.replace_range(2..2, b\"world\").unwrap();\n assert_eq!(\", world\", str(&d.to_vec()));\n d.commit();\n assert_eq!(\", world\", str(&d.to_vec()));\n d.restore();\n assert_eq!(\", world\", str(&d.to_vec()));\n\n d.replace_range(0..0, b\"hello\").unwrap();\n assert_eq!(\"hello, world\", str(&d.to_vec()));\n d.commit();\n assert_eq!(\"hello, world\", str(&d.to_vec()));\n d.restore();\n assert_eq!(\"hello, world\", str(&d.to_vec()));\n }\n\n proptest! {\n #[test]\n fn new_to_vec_roundtrip(ref s in \"\\\\PC*\") {\n assert_eq!(s.as_bytes(), Data::new(s.as_bytes()).to_vec().as_slice());\n }\n\n #[test]\n fn replace_random_chunks(\n ref data in \"\\\\PC*\",\n ref replacements in prop::collection::vec(\n (any::<::std::ops::Range>(), any::>()),\n 1..100,\n )\n ) {\n let mut d = Data::new(data.as_bytes());\n for &(ref range, ref bytes) in replacements {\n let _ = d.replace_range(range.clone(), bytes);\n }\n }\n }\n}\n" }, { "path": "crates/rustfix/tests/edge-cases/empty.json", "content": "{\n \"message\": \"`main` function not found in crate `empty`\",\n \"code\": {\n \"code\": \"E0601\",\n \"explanation\": \"No `main` function was found in a binary crate. To fix this error, add a\\n`main` function. For example:\\n\\n```\\nfn main() {\\n // Your program will start here.\\n println!(\\\"Hello world!\\\");\\n}\\n```\\n\\nIf you don't know the basics of Rust, you can go look to the Rust Book to get\\nstarted: https://doc.rust-lang.org/book/\\n\"\n },\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"empty.rs\",\n \"byte_start\": 0,\n \"byte_end\": 0,\n \"line_start\": 0,\n \"line_end\": 0,\n \"column_start\": 1,\n \"column_end\": 1,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \"\",\n \"highlight_start\": 1,\n \"highlight_end\": 1\n }\n ],\n \"label\": null,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"expansion\": null\n }\n ],\n \"children\": [\n {\n \"message\": \"consider adding a `main` function to `empty.rs`\",\n \"code\": null,\n \"level\": \"note\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": null\n }\n ],\n \"rendered\": \"error[E0601]: `main` function not found in crate `empty`\\n |\\n = note: consider adding a `main` function to `empty.rs`\\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/edge-cases/empty.rs", "content": "" }, { "path": "crates/rustfix/tests/edge-cases/indented_whitespace.json", "content": "{\n \"message\": \"non-ASCII whitespace symbol '\\\\u{a0}' is not skipped\",\n \"code\": null,\n \"level\": \"warning\",\n \"spans\":\n [\n {\n \"file_name\": \"lib.rs\",\n \"byte_start\": 26,\n \"byte_end\": 28,\n \"line_start\": 2,\n \"line_end\": 2,\n \"column_start\": 1,\n \"column_end\": 2,\n \"is_primary\": false,\n \"text\":\n [\n {\n \"text\": \"Ā indented\\\";\",\n \"highlight_start\": 1,\n \"highlight_end\": 2\n }\n ],\n \"label\": \"non-ASCII whitespace symbol '\\\\u{a0}' is not skipped\",\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"expansion\": null\n },\n {\n \"file_name\": \"lib.rs\",\n \"byte_start\": 24,\n \"byte_end\": 28,\n \"line_start\": 1,\n \"line_end\": 2,\n \"column_start\": 25,\n \"column_end\": 2,\n \"is_primary\": true,\n \"text\":\n [\n {\n \"text\": \"pub static FOO: &str = \\\"\\\\\",\n \"highlight_start\": 25,\n \"highlight_end\": 26\n },\n {\n \"text\": \"Ā indented\\\";\",\n \"highlight_start\": 1,\n \"highlight_end\": 2\n }\n ],\n \"label\": null,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"expansion\": null\n }\n ],\n \"children\":\n [],\n \"rendered\": \"warning: non-ASCII whitespace symbol '\\\\u{a0}' is not skipped\\n --> lib.rs:1:25\\n |\\n1 | pub static FOO: &str = \\\"\\\\\\n | _________________________^\\n2 | | Ā indented\\\";\\n | | ^ non-ASCII whitespace symbol '\\\\u{a0}' is not skipped\\n | |_|\\n | \\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/edge-cases/no_main.json", "content": "{\n \"message\": \"`main` function not found in crate `no_main`\",\n \"code\": {\n \"code\": \"E0601\",\n \"explanation\": \"No `main` function was found in a binary crate. To fix this error, add a\\n`main` function. For example:\\n\\n```\\nfn main() {\\n // Your program will start here.\\n println!(\\\"Hello world!\\\");\\n}\\n```\\n\\nIf you don't know the basics of Rust, you can go look to the Rust Book to get\\nstarted: https://doc.rust-lang.org/book/\\n\"\n },\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"no_main.rs\",\n \"byte_start\": 26,\n \"byte_end\": 26,\n \"line_start\": 1,\n \"line_end\": 1,\n \"column_start\": 27,\n \"column_end\": 27,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \"// This file has no main.\",\n \"highlight_start\": 27,\n \"highlight_end\": 27\n }\n ],\n \"label\": \"consider adding a `main` function to `no_main.rs`\",\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": \"error[E0601]: `main` function not found in crate `no_main`\\n --> no_main.rs:1:27\\n |\\n1 | // This file has no main.\\n | ^ consider adding a `main` function to `no_main.rs`\\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/edge-cases/no_main.rs", "content": "// This file has no main.\n" }, { "path": "crates/rustfix/tests/edge-cases/out_of_bounds.recorded.json", "content": "{\n \"message\": \"unterminated double quote string\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/tab_2.rs\",\n \"byte_start\": 485,\n \"byte_end\": 526,\n \"line_start\": 12,\n \"line_end\": 13,\n \"column_start\": 7,\n \"column_end\": 3,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" \\\"\\\"\\\"; //~ ERROR unterminated double quote\",\n \"highlight_start\": 7,\n \"highlight_end\": 45\n },\n {\n \"text\": \"}\",\n \"highlight_start\": 1,\n \"highlight_end\": 3\n }\n ],\n \"label\": null,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": \"error: unterminated double quote string\\n --> ./tests/everything/tab_2.rs:12:7\\n |\\n12 | \\\"\\\"\\\"; //~ ERROR unterminated double quote\\n | _______^\\n13 | | }\\n | |__^\\n\\n\"\n}\n{\n \"message\": \"aborting due to previous error\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": \"error: aborting due to previous error\\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/edge-cases/utf8_idents.recorded.json", "content": "{\n \"message\": \"expected one of `,`, `:`, `=`, or `>`, found `'Ī²`\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/utf8_idents.rs\",\n \"byte_start\": 14,\n \"byte_end\": 14,\n \"line_start\": 2,\n \"line_end\": 2,\n \"column_start\": 6,\n \"column_end\": 6,\n \"is_primary\": false,\n \"text\": [\n {\n \"text\": \" Ī³ //~ ERROR non-ascii idents are not fully supported\",\n \"highlight_start\": 6,\n \"highlight_end\": 6\n }\n ],\n \"label\": \"expected one of `,`, `:`, `=`, or `>` here\",\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"expansion\": null\n },\n {\n \"file_name\": \"./tests/everything/utf8_idents.rs\",\n \"byte_start\": 145,\n \"byte_end\": 148,\n \"line_start\": 4,\n \"line_end\": 4,\n \"column_start\": 5,\n \"column_end\": 7,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" 'Ī², //~ ERROR non-ascii idents are not fully supported\",\n \"highlight_start\": 5,\n \"highlight_end\": 7\n }\n ],\n \"label\": \"unexpected token\",\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": \"error: expected one of `,`, `:`, `=`, or `>`, found `'Ī²`\\n --> ./tests/everything/utf8_idents.rs:4:5\\n |\\n2 | Ī³ //~ ERROR non-ascii idents are not fully supported\\n | - expected one of `,`, `:`, `=`, or `>` here\\n3 | //~^ WARN type parameter `Ī³` should have an upper camel case name\\n4 | 'Ī², //~ ERROR non-ascii idents are not fully supported\\n | ^^ unexpected token\\n\\n\"\n}\n{\n \"message\": \"aborting due to previous error\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": \"error: aborting due to previous error\\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/edge_cases.rs", "content": "use std::collections::HashSet;\nuse std::fs;\n\nmacro_rules! expect_empty_json_test {\n ($name:ident, $file:expr) => {\n #[test]\n fn $name() {\n let json = fs::read_to_string(concat!(\"./tests/edge-cases/\", $file)).unwrap();\n let expected_suggestions = rustfix::get_suggestions_from_json(\n &json,\n &HashSet::new(),\n rustfix::Filter::Everything,\n )\n .unwrap();\n assert!(expected_suggestions.is_empty());\n }\n };\n}\n\nexpect_empty_json_test! {out_of_bounds_test, \"out_of_bounds.recorded.json\"}\nexpect_empty_json_test! {utf8_identifiers_test, \"utf8_idents.recorded.json\"}\nexpect_empty_json_test! {empty, \"empty.json\"}\nexpect_empty_json_test! {no_main, \"no_main.json\"}\nexpect_empty_json_test! {indented_whitespace, \"indented_whitespace.json\"}\n" }, { "path": "crates/rustfix/tests/everything/.gitignore", "content": "*.recorded.json\n*.recorded.rs\n" }, { "path": "crates/rustfix/tests/everything/E0178.fixed.rs", "content": "#![allow(dead_code)]\n\ntrait Foo {}\n\nstruct Bar<'a> {\n w: &'a (dyn Foo + Send),\n}\n\nfn main() {\n}\n" }, { "path": "crates/rustfix/tests/everything/E0178.json", "content": "{\n \"message\": \"expected a path on the left-hand side of `+`, not `&'a Foo`\",\n \"code\": {\n \"code\": \"E0178\",\n \"explanation\": \"\\nIn types, the `+` type operator has low precedence, so it is often necessary\\nto use parentheses.\\n\\nFor example:\\n\\n```compile_fail,E0178\\ntrait Foo {}\\n\\nstruct Bar<'a> {\\n w: &'a Foo + Copy, // error, use &'a (Foo + Copy)\\n x: &'a Foo + 'a, // error, use &'a (Foo + 'a)\\n y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a)\\n z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a)\\n}\\n```\\n\\nMore details can be found in [RFC 438].\\n\\n[RFC 438]: https://github.com/rust-lang/rfcs/pull/438\\n\"\n },\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/E0178.rs\",\n \"byte_start\": 60,\n \"byte_end\": 74,\n \"line_start\": 6,\n \"line_end\": 6,\n \"column_start\": 8,\n \"column_end\": 22,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" w: &'a Foo + Send,\",\n \"highlight_start\": 8,\n \"highlight_end\": 22\n }\n ],\n \"label\": null,\n \"suggested_replacement\": null,\n \"expansion\": null\n }\n ],\n \"children\": [\n {\n \"message\": \"try adding parentheses\",\n \"code\": null,\n \"level\": \"help\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/E0178.rs\",\n \"byte_start\": 60,\n \"byte_end\": 74,\n \"line_start\": 6,\n \"line_end\": 6,\n \"column_start\": 8,\n \"column_end\": 22,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" w: &'a Foo + Send,\",\n \"highlight_start\": 8,\n \"highlight_end\": 22\n }\n ],\n \"label\": null,\n \"suggested_replacement\": \"&'a (Foo + Send)\",\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": null\n }\n ],\n \"rendered\": \"error[E0178]: expected a path on the left-hand side of `+`, not `&'a Foo`\\n --> ./tests/everything/E0178.rs:6:8\\n |\\n6 | w: &'a Foo + Send,\\n | ^^^^^^^^^^^^^^ help: try adding parentheses: `&'a (Foo + Send)`\\n\\nIf you want more information on this error, try using \\\"rustc --explain E0178\\\"\\n\"\n}\n{\n \"message\": \"aborting due to previous error\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": \"error: aborting due to previous error\\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/everything/E0178.rs", "content": "#![allow(dead_code)]\n\ntrait Foo {}\n\nstruct Bar<'a> {\n w: &'a dyn Foo + Send,\n}\n\nfn main() {\n}\n" }, { "path": "crates/rustfix/tests/everything/closure-immutable-outer-variable.fixed.rs", "content": "// Point at the captured immutable outer variable\n\n// Suppress unrelated warnings\n#![allow(unused)]\n\nfn foo(mut f: Box) {\n f();\n}\n\nfn main() {\n let mut y = true;\n foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable\n}\n" }, { "path": "crates/rustfix/tests/everything/closure-immutable-outer-variable.json", "content": "{\n \"$message_type\": \"diagnostic\",\n \"children\": [\n {\n \"children\": [],\n \"code\": null,\n \"level\": \"help\",\n \"message\": \"consider changing this to be mutable\",\n \"rendered\": null,\n \"spans\": [\n {\n \"byte_end\": 167,\n \"byte_start\": 167,\n \"column_end\": 9,\n \"column_start\": 9,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/closure-immutable-outer-variable.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 11,\n \"line_start\": 11,\n \"suggested_replacement\": \"mut \",\n \"suggestion_applicability\": \"MachineApplicable\",\n \"text\": [\n {\n \"highlight_end\": 9,\n \"highlight_start\": 9,\n \"text\": \" let y = true;\"\n }\n ]\n }\n ]\n }\n ],\n \"code\": {\n \"code\": \"E0594\",\n \"explanation\": \"A non-mutable value was assigned a value./n/nErroneous code example:/n/n```compile_fail,E0594/nstruct SolarSystem {/n earth: i32,/n}/n/nlet ss = SolarSystem { earth: 3 };/nss.earth = 2; // error!/n```/n/nTo fix this error, declare `ss` as mutable by using the `mut` keyword:/n/n```/nstruct SolarSystem {/n earth: i32,/n}/n/nlet mut ss = SolarSystem { earth: 3 }; // declaring `ss` as mutable/nss.earth = 2; // ok!/n```/n\"\n },\n \"level\": \"error\",\n \"message\": \"cannot assign to `y`, as it is not declared as mutable\",\n \"rendered\": \"error[E0594]: cannot assign to `y`, as it is not declared as mutable/n --> ./tests/everything/closure-immutable-outer-variable.rs:12:26/n |/n12 | foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable/n | ^^^^^^^^^ cannot assign/n |/nhelp: consider changing this to be mutable/n |/n11 | let mut y = true;/n | +++/n/n\",\n \"spans\": [\n {\n \"byte_end\": 211,\n \"byte_start\": 202,\n \"column_end\": 35,\n \"column_start\": 26,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/closure-immutable-outer-variable.rs\",\n \"is_primary\": true,\n \"label\": \"cannot assign\",\n \"line_end\": 12,\n \"line_start\": 12,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 35,\n \"highlight_start\": 26,\n \"text\": \" foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable\"\n }\n ]\n }\n ]\n}\n{\n \"$message_type\": \"diagnostic\",\n \"children\": [],\n \"code\": null,\n \"level\": \"error\",\n \"message\": \"aborting due to 1 previous error\",\n \"rendered\": \"error: aborting due to 1 previous error/n/n\",\n \"spans\": []\n}\n{\n \"$message_type\": \"diagnostic\",\n \"children\": [],\n \"code\": null,\n \"level\": \"failure-note\",\n \"message\": \"For more information about this error, try `rustc --explain E0594`.\",\n \"rendered\": \"For more information about this error, try `rustc --explain E0594`./n\",\n \"spans\": []\n}" }, { "path": "crates/rustfix/tests/everything/closure-immutable-outer-variable.rs", "content": "// Point at the captured immutable outer variable\n\n// Suppress unrelated warnings\n#![allow(unused)]\n\nfn foo(mut f: Box) {\n f();\n}\n\nfn main() {\n let y = true;\n foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable\n}\n" }, { "path": "crates/rustfix/tests/everything/dedup-suggestions.fixed.rs", "content": "// See \nmacro_rules! foo {\n () => {\n let x = Box::new(1);\n let _ = &x;\n };\n}\n\nfn main() {\n foo!();\n foo!();\n}\n" }, { "path": "crates/rustfix/tests/everything/dedup-suggestions.json", "content": "{\n \"$message_type\": \"diagnostic\",\n \"children\": [\n {\n \"children\": [],\n \"code\": null,\n \"level\": \"note\",\n \"message\": \"`#[warn(forgetting_references)]` on by default\",\n \"rendered\": null,\n \"spans\": []\n },\n {\n \"children\": [],\n \"code\": null,\n \"level\": \"help\",\n \"message\": \"use `let _ = ...` to ignore the expression or result\",\n \"rendered\": null,\n \"spans\": [\n {\n \"byte_end\": 142,\n \"byte_start\": 125,\n \"column_end\": 26,\n \"column_start\": 9,\n \"expansion\": {\n \"def_site_span\": {\n \"byte_end\": 73,\n \"byte_start\": 57,\n \"column_end\": 17,\n \"column_start\": 1,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 17,\n \"highlight_start\": 1,\n \"text\": \"macro_rules! foo {\"\n }\n ]\n },\n \"macro_decl_name\": \"foo!\",\n \"span\": {\n \"byte_end\": 179,\n \"byte_start\": 173,\n \"column_end\": 11,\n \"column_start\": 5,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 10,\n \"line_start\": 10,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 11,\n \"highlight_start\": 5,\n \"text\": \" foo!();\"\n }\n ]\n }\n },\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 5,\n \"line_start\": 5,\n \"suggested_replacement\": \"let _ = \",\n \"suggestion_applicability\": \"MaybeIncorrect\",\n \"text\": [\n {\n \"highlight_end\": 26,\n \"highlight_start\": 9,\n \"text\": \" std::mem::forget(&x);\"\n }\n ]\n },\n {\n \"byte_end\": 145,\n \"byte_start\": 144,\n \"column_end\": 29,\n \"column_start\": 28,\n \"expansion\": {\n \"def_site_span\": {\n \"byte_end\": 73,\n \"byte_start\": 57,\n \"column_end\": 17,\n \"column_start\": 1,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 17,\n \"highlight_start\": 1,\n \"text\": \"macro_rules! foo {\"\n }\n ]\n },\n \"macro_decl_name\": \"foo!\",\n \"span\": {\n \"byte_end\": 179,\n \"byte_start\": 173,\n \"column_end\": 11,\n \"column_start\": 5,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 10,\n \"line_start\": 10,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 11,\n \"highlight_start\": 5,\n \"text\": \" foo!();\"\n }\n ]\n }\n },\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 5,\n \"line_start\": 5,\n \"suggested_replacement\": \"\",\n \"suggestion_applicability\": \"MaybeIncorrect\",\n \"text\": [\n {\n \"highlight_end\": 29,\n \"highlight_start\": 28,\n \"text\": \" std::mem::forget(&x);\"\n }\n ]\n }\n ]\n }\n ],\n \"code\": {\n \"code\": \"forgetting_references\",\n \"explanation\": null\n },\n \"level\": \"warning\",\n \"message\": \"calls to `std::mem::forget` with a reference instead of an owned value does nothing\",\n \"rendered\": \"warning: calls to `std::mem::forget` with a reference instead of an owned value does nothing/n --> ./tests/everything/dedup-suggestions.rs:5:9/n |/n5 | std::mem::forget(&x);/n | ^^^^^^^^^^^^^^^^^--^/n | |/n | argument has type `&Box`/n.../n10 | foo!();/n | ------ in this macro invocation/n |/n = note: `#[warn(forgetting_references)]` on by default/n = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)/nhelp: use `let _ = ...` to ignore the expression or result/n |/n5 - std::mem::forget(&x);/n5 + let _ = &x;/n |/n/n\",\n \"spans\": [\n {\n \"byte_end\": 144,\n \"byte_start\": 142,\n \"column_end\": 28,\n \"column_start\": 26,\n \"expansion\": {\n \"def_site_span\": {\n \"byte_end\": 73,\n \"byte_start\": 57,\n \"column_end\": 17,\n \"column_start\": 1,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 17,\n \"highlight_start\": 1,\n \"text\": \"macro_rules! foo {\"\n }\n ]\n },\n \"macro_decl_name\": \"foo!\",\n \"span\": {\n \"byte_end\": 179,\n \"byte_start\": 173,\n \"column_end\": 11,\n \"column_start\": 5,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 10,\n \"line_start\": 10,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 11,\n \"highlight_start\": 5,\n \"text\": \" foo!();\"\n }\n ]\n }\n },\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": \"argument has type `&Box`\",\n \"line_end\": 5,\n \"line_start\": 5,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 28,\n \"highlight_start\": 26,\n \"text\": \" std::mem::forget(&x);\"\n }\n ]\n },\n {\n \"byte_end\": 145,\n \"byte_start\": 125,\n \"column_end\": 29,\n \"column_start\": 9,\n \"expansion\": {\n \"def_site_span\": {\n \"byte_end\": 73,\n \"byte_start\": 57,\n \"column_end\": 17,\n \"column_start\": 1,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 17,\n \"highlight_start\": 1,\n \"text\": \"macro_rules! foo {\"\n }\n ]\n },\n \"macro_decl_name\": \"foo!\",\n \"span\": {\n \"byte_end\": 179,\n \"byte_start\": 173,\n \"column_end\": 11,\n \"column_start\": 5,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 10,\n \"line_start\": 10,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 11,\n \"highlight_start\": 5,\n \"text\": \" foo!();\"\n }\n ]\n }\n },\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 5,\n \"line_start\": 5,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 29,\n \"highlight_start\": 9,\n \"text\": \" std::mem::forget(&x);\"\n }\n ]\n }\n ]\n}\n{\n \"$message_type\": \"diagnostic\",\n \"children\": [\n {\n \"children\": [],\n \"code\": null,\n \"level\": \"help\",\n \"message\": \"use `let _ = ...` to ignore the expression or result\",\n \"rendered\": null,\n \"spans\": [\n {\n \"byte_end\": 142,\n \"byte_start\": 125,\n \"column_end\": 26,\n \"column_start\": 9,\n \"expansion\": {\n \"def_site_span\": {\n \"byte_end\": 73,\n \"byte_start\": 57,\n \"column_end\": 17,\n \"column_start\": 1,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 17,\n \"highlight_start\": 1,\n \"text\": \"macro_rules! foo {\"\n }\n ]\n },\n \"macro_decl_name\": \"foo!\",\n \"span\": {\n \"byte_end\": 191,\n \"byte_start\": 185,\n \"column_end\": 11,\n \"column_start\": 5,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 11,\n \"line_start\": 11,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 11,\n \"highlight_start\": 5,\n \"text\": \" foo!();\"\n }\n ]\n }\n },\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 5,\n \"line_start\": 5,\n \"suggested_replacement\": \"let _ = \",\n \"suggestion_applicability\": \"MaybeIncorrect\",\n \"text\": [\n {\n \"highlight_end\": 26,\n \"highlight_start\": 9,\n \"text\": \" std::mem::forget(&x);\"\n }\n ]\n },\n {\n \"byte_end\": 145,\n \"byte_start\": 144,\n \"column_end\": 29,\n \"column_start\": 28,\n \"expansion\": {\n \"def_site_span\": {\n \"byte_end\": 73,\n \"byte_start\": 57,\n \"column_end\": 17,\n \"column_start\": 1,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 17,\n \"highlight_start\": 1,\n \"text\": \"macro_rules! foo {\"\n }\n ]\n },\n \"macro_decl_name\": \"foo!\",\n \"span\": {\n \"byte_end\": 191,\n \"byte_start\": 185,\n \"column_end\": 11,\n \"column_start\": 5,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 11,\n \"line_start\": 11,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 11,\n \"highlight_start\": 5,\n \"text\": \" foo!();\"\n }\n ]\n }\n },\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 5,\n \"line_start\": 5,\n \"suggested_replacement\": \"\",\n \"suggestion_applicability\": \"MaybeIncorrect\",\n \"text\": [\n {\n \"highlight_end\": 29,\n \"highlight_start\": 28,\n \"text\": \" std::mem::forget(&x);\"\n }\n ]\n }\n ]\n }\n ],\n \"code\": {\n \"code\": \"forgetting_references\",\n \"explanation\": null\n },\n \"level\": \"warning\",\n \"message\": \"calls to `std::mem::forget` with a reference instead of an owned value does nothing\",\n \"rendered\": \"warning: calls to `std::mem::forget` with a reference instead of an owned value does nothing/n --> ./tests/everything/dedup-suggestions.rs:5:9/n |/n5 | std::mem::forget(&x);/n | ^^^^^^^^^^^^^^^^^--^/n | |/n | argument has type `&Box`/n.../n11 | foo!();/n | ------ in this macro invocation/n |/n = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)/nhelp: use `let _ = ...` to ignore the expression or result/n |/n5 - std::mem::forget(&x);/n5 + let _ = &x;/n |/n/n\",\n \"spans\": [\n {\n \"byte_end\": 144,\n \"byte_start\": 142,\n \"column_end\": 28,\n \"column_start\": 26,\n \"expansion\": {\n \"def_site_span\": {\n \"byte_end\": 73,\n \"byte_start\": 57,\n \"column_end\": 17,\n \"column_start\": 1,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 17,\n \"highlight_start\": 1,\n \"text\": \"macro_rules! foo {\"\n }\n ]\n },\n \"macro_decl_name\": \"foo!\",\n \"span\": {\n \"byte_end\": 191,\n \"byte_start\": 185,\n \"column_end\": 11,\n \"column_start\": 5,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 11,\n \"line_start\": 11,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 11,\n \"highlight_start\": 5,\n \"text\": \" foo!();\"\n }\n ]\n }\n },\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": \"argument has type `&Box`\",\n \"line_end\": 5,\n \"line_start\": 5,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 28,\n \"highlight_start\": 26,\n \"text\": \" std::mem::forget(&x);\"\n }\n ]\n },\n {\n \"byte_end\": 145,\n \"byte_start\": 125,\n \"column_end\": 29,\n \"column_start\": 9,\n \"expansion\": {\n \"def_site_span\": {\n \"byte_end\": 73,\n \"byte_start\": 57,\n \"column_end\": 17,\n \"column_start\": 1,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 17,\n \"highlight_start\": 1,\n \"text\": \"macro_rules! foo {\"\n }\n ]\n },\n \"macro_decl_name\": \"foo!\",\n \"span\": {\n \"byte_end\": 191,\n \"byte_start\": 185,\n \"column_end\": 11,\n \"column_start\": 5,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": false,\n \"label\": null,\n \"line_end\": 11,\n \"line_start\": 11,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 11,\n \"highlight_start\": 5,\n \"text\": \" foo!();\"\n }\n ]\n }\n },\n \"file_name\": \"./tests/everything/dedup-suggestions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 5,\n \"line_start\": 5,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 29,\n \"highlight_start\": 9,\n \"text\": \" std::mem::forget(&x);\"\n }\n ]\n }\n ]\n}\n{\n \"$message_type\": \"diagnostic\",\n \"children\": [],\n \"code\": null,\n \"level\": \"warning\",\n \"message\": \"2 warnings emitted\",\n \"rendered\": \"warning: 2 warnings emitted/n/n\",\n \"spans\": []\n}" }, { "path": "crates/rustfix/tests/everything/dedup-suggestions.rs", "content": "// See \nmacro_rules! foo {\n () => {\n let x = Box::new(1);\n std::mem::forget(&x);\n };\n}\n\nfn main() {\n foo!();\n foo!();\n}\n" }, { "path": "crates/rustfix/tests/everything/handle-insert-only.fixed.rs", "content": "fn main() {\n // insert only fix, adds `,` to first match arm\n // why doesnt this replace 1 with 1,?\n match &Some(3) {\n &None => 1,\n &Some(x) => x,\n };\n}\n" }, { "path": "crates/rustfix/tests/everything/handle-insert-only.json", "content": "{\n \"message\": \"expected one of `,`, `.`, `?`, `}`, or an operator, found `=>`\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/handle-insert-only.rs\",\n \"byte_start\": 163,\n \"byte_end\": 165,\n \"line_start\": 6,\n \"line_end\": 6,\n \"column_start\": 18,\n \"column_end\": 20,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" &Some(x) => x,\",\n \"highlight_start\": 18,\n \"highlight_end\": 20\n }\n ],\n \"label\": \"expected one of `,`, `.`, `?`, `}`, or an operator here\",\n \"suggested_replacement\": null,\n \"expansion\": null\n }\n ],\n \"children\": [\n {\n \"message\": \"missing a comma here to end this `match` arm\",\n \"code\": null,\n \"level\": \"help\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/handle-insert-only.rs\",\n \"byte_start\": 145,\n \"byte_end\": 145,\n \"line_start\": 5,\n \"line_end\": 5,\n \"column_start\": 19,\n \"column_end\": 19,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" &None => 1\",\n \"highlight_start\": 19,\n \"highlight_end\": 19\n }\n ],\n \"label\": null,\n \"suggested_replacement\": \",\",\n \"suggestion_applicability\": \"Unspecified\",\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": null\n }\n ],\n \"rendered\": \"error: expected one of `,`, `.`, `?`, `}`, or an operator, found `=>`\\n --> ./tests/everything/handle-insert-only.rs:6:18\\n |\\n5 | &None => 1\\n | - help: missing a comma here to end this `match` arm\\n6 | &Some(x) => x,\\n | ^^ expected one of `,`, `.`, `?`, `}`, or an operator here\\n\\n\"\n}\n{\n \"message\": \"aborting due to previous error\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": \"error: aborting due to previous error\\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/everything/handle-insert-only.rs", "content": "fn main() {\n // insert only fix, adds `,` to first match arm\n // why doesnt this replace 1 with 1,?\n match &Some(3) {\n &None => 1\n &Some(x) => x,\n };\n}\n" }, { "path": "crates/rustfix/tests/everything/lt-generic-comp.fixed.rs", "content": "fn main() {\n let x = 5i64;\n\n if (x as u32) < 4 {\n println!(\"yay\");\n }\n}\n" }, { "path": "crates/rustfix/tests/everything/lt-generic-comp.json", "content": "{\n \"message\": \"`<` is interpreted as a start of generic arguments for `u32`, not a comparison\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/lt-generic-comp.rs\",\n \"byte_start\": 49,\n \"byte_end\": 50,\n \"line_start\": 4,\n \"line_end\": 4,\n \"column_start\": 19,\n \"column_end\": 20,\n \"is_primary\": false,\n \"text\": [\n {\n \"text\": \" if x as u32 < 4 {\",\n \"highlight_start\": 19,\n \"highlight_end\": 20\n }\n ],\n \"label\": \"interpreted as generic arguments\",\n \"suggested_replacement\": null,\n \"expansion\": null\n },\n {\n \"file_name\": \"./tests/everything/lt-generic-comp.rs\",\n \"byte_start\": 47,\n \"byte_end\": 48,\n \"line_start\": 4,\n \"line_end\": 4,\n \"column_start\": 17,\n \"column_end\": 18,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" if x as u32 < 4 {\",\n \"highlight_start\": 17,\n \"highlight_end\": 18\n }\n ],\n \"label\": \"not interpreted as comparison\",\n \"suggested_replacement\": null,\n \"expansion\": null\n }\n ],\n \"children\": [\n {\n \"message\": \"try comparing the cast value\",\n \"code\": null,\n \"level\": \"help\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/lt-generic-comp.rs\",\n \"byte_start\": 38,\n \"byte_end\": 46,\n \"line_start\": 4,\n \"line_end\": 4,\n \"column_start\": 8,\n \"column_end\": 16,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" if x as u32 < 4 {\",\n \"highlight_start\": 8,\n \"highlight_end\": 16\n }\n ],\n \"label\": null,\n \"suggested_replacement\": \"(x as u32)\",\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": null\n }\n ],\n \"rendered\": \"error: `<` is interpreted as a start of generic arguments for `u32`, not a comparison\\n --> ./tests/everything/lt-generic-comp.rs:4:17\\n |\\n4 | if x as u32 < 4 {\\n | -------- ^ - interpreted as generic arguments\\n | | |\\n | | not interpreted as comparison\\n | help: try comparing the cast value: `(x as u32)`\\n\\n\"\n}\n{\n \"message\": \"aborting due to previous error\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": \"error: aborting due to previous error\\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/everything/lt-generic-comp.rs", "content": "fn main() {\n let x = 5i64;\n\n if x as u32 < 4 {\n println!(\"yay\");\n }\n}\n" }, { "path": "crates/rustfix/tests/everything/multiple-solutions.fixed.rs", "content": "use std::collections::HashSet;\n\nfn main() {\n let _: HashSet<()>;\n}\n" }, { "path": "crates/rustfix/tests/everything/multiple-solutions.json", "content": "{\n \"$message_type\": \"diagnostic\",\n \"children\": [\n {\n \"children\": [],\n \"code\": null,\n \"level\": \"note\",\n \"message\": \"`#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default\",\n \"rendered\": null,\n \"spans\": []\n },\n {\n \"children\": [],\n \"code\": null,\n \"level\": \"help\",\n \"message\": \"remove the unused imports\",\n \"rendered\": null,\n \"spans\": [\n {\n \"byte_end\": 32,\n \"byte_start\": 23,\n \"column_end\": 33,\n \"column_start\": 24,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/multiple-solutions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 1,\n \"line_start\": 1,\n \"suggested_replacement\": \"\",\n \"suggestion_applicability\": \"MachineApplicable\",\n \"text\": [\n {\n \"highlight_end\": 33,\n \"highlight_start\": 24,\n \"text\": \"use std::collections::{HashMap, HashSet, VecDeque};\"\n }\n ]\n },\n {\n \"byte_end\": 49,\n \"byte_start\": 39,\n \"column_end\": 50,\n \"column_start\": 40,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/multiple-solutions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 1,\n \"line_start\": 1,\n \"suggested_replacement\": \"\",\n \"suggestion_applicability\": \"MachineApplicable\",\n \"text\": [\n {\n \"highlight_end\": 50,\n \"highlight_start\": 40,\n \"text\": \"use std::collections::{HashMap, HashSet, VecDeque};\"\n }\n ]\n },\n {\n \"byte_end\": 23,\n \"byte_start\": 22,\n \"column_end\": 24,\n \"column_start\": 23,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/multiple-solutions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 1,\n \"line_start\": 1,\n \"suggested_replacement\": \"\",\n \"suggestion_applicability\": \"MachineApplicable\",\n \"text\": [\n {\n \"highlight_end\": 24,\n \"highlight_start\": 23,\n \"text\": \"use std::collections::{HashMap, HashSet, VecDeque};\"\n }\n ]\n },\n {\n \"byte_end\": 50,\n \"byte_start\": 49,\n \"column_end\": 51,\n \"column_start\": 50,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/multiple-solutions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 1,\n \"line_start\": 1,\n \"suggested_replacement\": \"\",\n \"suggestion_applicability\": \"MachineApplicable\",\n \"text\": [\n {\n \"highlight_end\": 51,\n \"highlight_start\": 50,\n \"text\": \"use std::collections::{HashMap, HashSet, VecDeque};\"\n }\n ]\n }\n ]\n }\n ],\n \"code\": {\n \"code\": \"unused_imports\",\n \"explanation\": null\n },\n \"level\": \"warning\",\n \"message\": \"unused imports: `HashMap` and `VecDeque`\",\n \"rendered\": \"warning: unused imports: `HashMap` and `VecDeque`/n --> ./tests/everything/multiple-solutions.rs:1:24/n |/n1 | use std::collections::{HashMap, HashSet, VecDeque};/n | ^^^^^^^ ^^^^^^^^/n |/n = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default/n/n\",\n \"spans\": [\n {\n \"byte_end\": 30,\n \"byte_start\": 23,\n \"column_end\": 31,\n \"column_start\": 24,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/multiple-solutions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 1,\n \"line_start\": 1,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 31,\n \"highlight_start\": 24,\n \"text\": \"use std::collections::{HashMap, HashSet, VecDeque};\"\n }\n ]\n },\n {\n \"byte_end\": 49,\n \"byte_start\": 41,\n \"column_end\": 50,\n \"column_start\": 42,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/multiple-solutions.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 1,\n \"line_start\": 1,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 50,\n \"highlight_start\": 42,\n \"text\": \"use std::collections::{HashMap, HashSet, VecDeque};\"\n }\n ]\n }\n ]\n}\n{\n \"$message_type\": \"diagnostic\",\n \"children\": [],\n \"code\": null,\n \"level\": \"warning\",\n \"message\": \"1 warning emitted\",\n \"rendered\": \"warning: 1 warning emitted/n/n\",\n \"spans\": []\n}" }, { "path": "crates/rustfix/tests/everything/multiple-solutions.rs", "content": "use std::collections::{HashMap, HashSet, VecDeque};\n\nfn main() {\n let _: HashSet<()>;\n}\n" }, { "path": "crates/rustfix/tests/everything/replace-only-one-char.fixed.rs", "content": "fn main() {\n let _x = 42;\n}\n" }, { "path": "crates/rustfix/tests/everything/replace-only-one-char.json", "content": "{\n \"$message_type\": \"diagnostic\",\n \"children\": [\n {\n \"children\": [],\n \"code\": null,\n \"level\": \"note\",\n \"message\": \"`#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default\",\n \"rendered\": null,\n \"spans\": []\n },\n {\n \"children\": [],\n \"code\": null,\n \"level\": \"help\",\n \"message\": \"if this is intentional, prefix it with an underscore\",\n \"rendered\": null,\n \"spans\": [\n {\n \"byte_end\": 21,\n \"byte_start\": 20,\n \"column_end\": 10,\n \"column_start\": 9,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/replace-only-one-char.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": \"_x\",\n \"suggestion_applicability\": \"MaybeIncorrect\",\n \"text\": [\n {\n \"highlight_end\": 10,\n \"highlight_start\": 9,\n \"text\": \" let x = 42;\"\n }\n ]\n }\n ]\n }\n ],\n \"code\": {\n \"code\": \"unused_variables\",\n \"explanation\": null\n },\n \"level\": \"warning\",\n \"message\": \"unused variable: `x`\",\n \"rendered\": \"warning: unused variable: `x`/n --> ./tests/everything/replace-only-one-char.rs:2:9/n |/n2 | let x = 42;/n | ^ help: if this is intentional, prefix it with an underscore: `_x`/n |/n = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default/n/n\",\n \"spans\": [\n {\n \"byte_end\": 21,\n \"byte_start\": 20,\n \"column_end\": 10,\n \"column_start\": 9,\n \"expansion\": null,\n \"file_name\": \"./tests/everything/replace-only-one-char.rs\",\n \"is_primary\": true,\n \"label\": null,\n \"line_end\": 2,\n \"line_start\": 2,\n \"suggested_replacement\": null,\n \"suggestion_applicability\": null,\n \"text\": [\n {\n \"highlight_end\": 10,\n \"highlight_start\": 9,\n \"text\": \" let x = 42;\"\n }\n ]\n }\n ]\n}\n{\n \"$message_type\": \"diagnostic\",\n \"children\": [],\n \"code\": null,\n \"level\": \"warning\",\n \"message\": \"1 warning emitted\",\n \"rendered\": \"warning: 1 warning emitted/n/n\",\n \"spans\": []\n}" }, { "path": "crates/rustfix/tests/everything/replace-only-one-char.rs", "content": "fn main() {\n let x = 42;\n}\n" }, { "path": "crates/rustfix/tests/everything/str-lit-type-mismatch.fixed.rs", "content": "fn main() {\n let x: &[u8] = b\"foo\"; //~ ERROR mismatched types\n let y: &[u8; 4] = b\"baaa\"; //~ ERROR mismatched types\n let z: &str = \"foo\"; //~ ERROR mismatched types\n}\n" }, { "path": "crates/rustfix/tests/everything/str-lit-type-mismatch.json", "content": "{\n \"message\": \"mismatched types\",\n \"code\": {\n \"code\": \"E0308\",\n \"explanation\": \"\\nThis error occurs when the compiler was unable to infer the concrete type of a\\nvariable. It can occur for several cases, the most common of which is a\\nmismatch in the expected type that the compiler inferred for a variable's\\ninitializing expression, and the actual type explicitly assigned to the\\nvariable.\\n\\nFor example:\\n\\n```compile_fail,E0308\\nlet x: i32 = \\\"I am not a number!\\\";\\n// ~~~ ~~~~~~~~~~~~~~~~~~~~\\n// | |\\n// | initializing expression;\\n// | compiler infers type `&str`\\n// |\\n// type `i32` assigned to variable `x`\\n```\\n\"\n },\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/str-lit-type-mismatch.rs\",\n \"byte_start\": 499,\n \"byte_end\": 504,\n \"line_start\": 13,\n \"line_end\": 13,\n \"column_start\": 20,\n \"column_end\": 25,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" let x: &[u8] = \\\"foo\\\"; //~ ERROR mismatched types\",\n \"highlight_start\": 20,\n \"highlight_end\": 25\n }\n ],\n \"label\": \"expected slice, found str\",\n \"suggested_replacement\": null,\n \"expansion\": null\n }\n ],\n \"children\": [\n {\n \"message\": \"expected type `&[u8]`\\n found type `&'static str`\",\n \"code\": null,\n \"level\": \"note\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": null\n },\n {\n \"message\": \"consider adding a leading `b`\",\n \"code\": null,\n \"level\": \"help\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/str-lit-type-mismatch.rs\",\n \"byte_start\": 499,\n \"byte_end\": 504,\n \"line_start\": 13,\n \"line_end\": 13,\n \"column_start\": 20,\n \"column_end\": 25,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" let x: &[u8] = \\\"foo\\\"; //~ ERROR mismatched types\",\n \"highlight_start\": 20,\n \"highlight_end\": 25\n }\n ],\n \"label\": null,\n \"suggested_replacement\": \"b\\\"foo\\\"\",\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": null\n }\n ],\n \"rendered\": \"error[E0308]: mismatched types\\n --> ./tests/everything/str-lit-type-mismatch.rs:13:20\\n |\\n13 | let x: &[u8] = \\\"foo\\\"; //~ ERROR mismatched types\\n | ^^^^^\\n | |\\n | expected slice, found str\\n | help: consider adding a leading `b`: `b\\\"foo\\\"`\\n |\\n = note: expected type `&[u8]`\\n found type `&'static str`\\n\\nIf you want more information on this error, try using \\\"rustc --explain E0308\\\"\\n\"\n}\n{\n \"message\": \"mismatched types\",\n \"code\": {\n \"code\": \"E0308\",\n \"explanation\": \"\\nThis error occurs when the compiler was unable to infer the concrete type of a\\nvariable. It can occur for several cases, the most common of which is a\\nmismatch in the expected type that the compiler inferred for a variable's\\ninitializing expression, and the actual type explicitly assigned to the\\nvariable.\\n\\nFor example:\\n\\n```compile_fail,E0308\\nlet x: i32 = \\\"I am not a number!\\\";\\n// ~~~ ~~~~~~~~~~~~~~~~~~~~\\n// | |\\n// | initializing expression;\\n// | compiler infers type `&str`\\n// |\\n// type `i32` assigned to variable `x`\\n```\\n\"\n },\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/str-lit-type-mismatch.rs\",\n \"byte_start\": 555,\n \"byte_end\": 561,\n \"line_start\": 14,\n \"line_end\": 14,\n \"column_start\": 23,\n \"column_end\": 29,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" let y: &[u8; 4] = \\\"baaa\\\"; //~ ERROR mismatched types\",\n \"highlight_start\": 23,\n \"highlight_end\": 29\n }\n ],\n \"label\": \"expected array of 4 elements, found str\",\n \"suggested_replacement\": null,\n \"expansion\": null\n }\n ],\n \"children\": [\n {\n \"message\": \"expected type `&[u8; 4]`\\n found type `&'static str`\",\n \"code\": null,\n \"level\": \"note\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": null\n },\n {\n \"message\": \"consider adding a leading `b`\",\n \"code\": null,\n \"level\": \"help\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/str-lit-type-mismatch.rs\",\n \"byte_start\": 555,\n \"byte_end\": 561,\n \"line_start\": 14,\n \"line_end\": 14,\n \"column_start\": 23,\n \"column_end\": 29,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" let y: &[u8; 4] = \\\"baaa\\\"; //~ ERROR mismatched types\",\n \"highlight_start\": 23,\n \"highlight_end\": 29\n }\n ],\n \"label\": null,\n \"suggested_replacement\": \"b\\\"baaa\\\"\",\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": null\n }\n ],\n \"rendered\": \"error[E0308]: mismatched types\\n --> ./tests/everything/str-lit-type-mismatch.rs:14:23\\n |\\n14 | let y: &[u8; 4] = \\\"baaa\\\"; //~ ERROR mismatched types\\n | ^^^^^^\\n | |\\n | expected array of 4 elements, found str\\n | help: consider adding a leading `b`: `b\\\"baaa\\\"`\\n |\\n = note: expected type `&[u8; 4]`\\n found type `&'static str`\\n\\nIf you want more information on this error, try using \\\"rustc --explain E0308\\\"\\n\"\n}\n{\n \"message\": \"mismatched types\",\n \"code\": {\n \"code\": \"E0308\",\n \"explanation\": \"\\nThis error occurs when the compiler was unable to infer the concrete type of a\\nvariable. It can occur for several cases, the most common of which is a\\nmismatch in the expected type that the compiler inferred for a variable's\\ninitializing expression, and the actual type explicitly assigned to the\\nvariable.\\n\\nFor example:\\n\\n```compile_fail,E0308\\nlet x: i32 = \\\"I am not a number!\\\";\\n// ~~~ ~~~~~~~~~~~~~~~~~~~~\\n// | |\\n// | initializing expression;\\n// | compiler infers type `&str`\\n// |\\n// type `i32` assigned to variable `x`\\n```\\n\"\n },\n \"level\": \"error\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/str-lit-type-mismatch.rs\",\n \"byte_start\": 608,\n \"byte_end\": 614,\n \"line_start\": 15,\n \"line_end\": 15,\n \"column_start\": 19,\n \"column_end\": 25,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" let z: &str = b\\\"foo\\\"; //~ ERROR mismatched types\",\n \"highlight_start\": 19,\n \"highlight_end\": 25\n }\n ],\n \"label\": \"expected str, found array of 3 elements\",\n \"suggested_replacement\": null,\n \"expansion\": null\n }\n ],\n \"children\": [\n {\n \"message\": \"expected type `&str`\\n found type `&'static [u8; 3]`\",\n \"code\": null,\n \"level\": \"note\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": null\n },\n {\n \"message\": \"consider removing the leading `b`\",\n \"code\": null,\n \"level\": \"help\",\n \"spans\": [\n {\n \"file_name\": \"./tests/everything/str-lit-type-mismatch.rs\",\n \"byte_start\": 608,\n \"byte_end\": 614,\n \"line_start\": 15,\n \"line_end\": 15,\n \"column_start\": 19,\n \"column_end\": 25,\n \"is_primary\": true,\n \"text\": [\n {\n \"text\": \" let z: &str = b\\\"foo\\\"; //~ ERROR mismatched types\",\n \"highlight_start\": 19,\n \"highlight_end\": 25\n }\n ],\n \"label\": null,\n \"suggested_replacement\": \"\\\"foo\\\"\",\n \"expansion\": null\n }\n ],\n \"children\": [],\n \"rendered\": null\n }\n ],\n \"rendered\": \"error[E0308]: mismatched types\\n --> ./tests/everything/str-lit-type-mismatch.rs:15:19\\n |\\n15 | let z: &str = b\\\"foo\\\"; //~ ERROR mismatched types\\n | ^^^^^^\\n | |\\n | expected str, found array of 3 elements\\n | help: consider removing the leading `b`: `\\\"foo\\\"`\\n |\\n = note: expected type `&str`\\n found type `&'static [u8; 3]`\\n\\nIf you want more information on this error, try using \\\"rustc --explain E0308\\\"\\n\"\n}\n{\n \"message\": \"aborting due to 3 previous errors\",\n \"code\": null,\n \"level\": \"error\",\n \"spans\": [],\n \"children\": [],\n \"rendered\": \"error: aborting due to 3 previous errors\\n\\n\"\n}\n" }, { "path": "crates/rustfix/tests/everything/str-lit-type-mismatch.rs", "content": "fn main() {\n let x: &[u8] = \"foo\"; //~ ERROR mismatched types\n let y: &[u8; 4] = \"baaa\"; //~ ERROR mismatched types\n let z: &str = b\"foo\"; //~ ERROR mismatched types\n}\n" }, { "path": "crates/rustfix/tests/everything/use-insert.fixed.rs", "content": "use a::f;\n\nmod a {\n pub fn f() {}\n}\n\nfn main() {\n f();\n}\n" }, { "path": "crates/rustfix/tests/everything/use-insert.json", "content": "{\"$message_type\":\"diagnostic\",\"message\":\"cannot find function `f` in this scope\",\"code\":{\"code\":\"E0425\",\"explanation\":\"An unresolved name was used.\\n\\nErroneous code examples:\\n\\n```compile_fail,E0425\\nsomething_that_doesnt_exist::foo;\\n// error: unresolved name `something_that_doesnt_exist::foo`\\n\\n// or:\\n\\ntrait Foo {\\n fn bar() {\\n Self; // error: unresolved name `Self`\\n }\\n}\\n\\n// or:\\n\\nlet x = unknown_variable; // error: unresolved name `unknown_variable`\\n```\\n\\nPlease verify that the name wasn't misspelled and ensure that the\\nidentifier being referred to is valid for the given situation. Example:\\n\\n```\\nenum something_that_does_exist {\\n Foo,\\n}\\n```\\n\\nOr:\\n\\n```\\nmod something_that_does_exist {\\n pub static foo : i32 = 0i32;\\n}\\n\\nsomething_that_does_exist::foo; // ok!\\n```\\n\\nOr:\\n\\n```\\nlet unknown_variable = 12u32;\\nlet x = unknown_variable; // ok!\\n```\\n\\nIf the item is not defined in the current module, it must be imported using a\\n`use` statement, like so:\\n\\n```\\n# mod foo { pub fn bar() {} }\\n# fn main() {\\nuse foo::bar;\\nbar();\\n# }\\n```\\n\\nIf the item you are importing is not defined in some super-module of the\\ncurrent module, then it must also be declared as public (e.g., `pub fn`).\\n\"},\"level\":\"error\",\"spans\":[{\"file_name\":\"./tests/everything/use-insert.rs\",\"byte_start\":45,\"byte_end\":46,\"line_start\":6,\"line_end\":6,\"column_start\":5,\"column_end\":6,\"is_primary\":true,\"text\":[{\"text\":\" f();\",\"highlight_start\":5,\"highlight_end\":6}],\"label\":\"not found in this scope\",\"suggested_replacement\":null,\"suggestion_applicability\":null,\"expansion\":null}],\"children\":[{\"message\":\"consider importing this function\",\"code\":null,\"level\":\"help\",\"spans\":[{\"file_name\":\"./tests/everything/use-insert.rs\",\"byte_start\":0,\"byte_end\":0,\"line_start\":1,\"line_end\":1,\"column_start\":1,\"column_end\":1,\"is_primary\":true,\"text\":[],\"label\":null,\"suggested_replacement\":\"use a::f;\\n\\n\",\"suggestion_applicability\":\"MaybeIncorrect\",\"expansion\":null}],\"children\":[],\"rendered\":null}],\"rendered\":\"error[E0425]: cannot find function `f` in this scope\\n --> ./tests/everything/use-insert.rs:6:5\\n |\\n6 | f();\\n | ^ not found in this scope\\n |\\nhelp: consider importing this function\\n |\\n1 + use a::f;\\n |\\n\\n\"}\n{\"$message_type\":\"diagnostic\",\"message\":\"aborting due to 1 previous error\",\"code\":null,\"level\":\"error\",\"spans\":[],\"children\":[],\"rendered\":\"error: aborting due to 1 previous error\\n\\n\"}\n{\"$message_type\":\"diagnostic\",\"message\":\"For more information about this error, try `rustc --explain E0425`.\",\"code\":null,\"level\":\"failure-note\",\"spans\":[],\"children\":[],\"rendered\":\"For more information about this error, try `rustc --explain E0425`.\\n\"}\n" }, { "path": "crates/rustfix/tests/everything/use-insert.rs", "content": "mod a {\n pub fn f() {}\n}\n\nfn main() {\n f();\n}\n" }, { "path": "crates/rustfix/tests/parse_and_replace.rs", "content": "//! Tests that verify rustfix applies the appropriate changes to a file.\n//!\n//! This test works by reading a series of `*.rs` files in the\n//! `tests/everything` directory. For each `.rs` file, it runs `rustc` to\n//! collect JSON diagnostics from the file. It feeds that JSON data into\n//! rustfix and applies the recommended suggestions to the `.rs` file. It then\n//! compares the result with the corresponding `.fixed.rs` file. If they don't\n//! match, then the test fails.\n//!\n//! The files ending in `.nightly.rs` will run only on the nightly toolchain\n//!\n//! To override snapshots, run `SNAPSHOTS=overwrite cargo test`.\n//! See [`snapbox::assert::Action`] for different actions.\n\n#![allow(clippy::disallowed_methods, clippy::print_stdout, clippy::print_stderr)]\n\nuse anyhow::{Context, Error, anyhow};\nuse rustfix::apply_suggestions;\nuse serde_json::Value;\nuse snapbox::data::DataFormat;\nuse snapbox::{Assert, Data};\nuse std::collections::HashSet;\nuse std::env;\nuse std::ffi::OsString;\nuse std::fs;\nuse std::path::Path;\nuse std::process::{Command, Output};\nuse tempfile::tempdir;\n\nmod fixmode {\n pub const EVERYTHING: &str = \"yolo\";\n}\n\nstatic mut VERSION: (u32, bool) = (0, false);\n\n// Temporarily copy from `cargo_test_macro::version`.\nfn version() -> (u32, bool) {\n static INIT: std::sync::Once = std::sync::Once::new();\n INIT.call_once(|| {\n let output = Command::new(\"rustc\")\n .arg(\"-V\")\n .output()\n .expect(\"cargo should run\");\n let stdout = std::str::from_utf8(&output.stdout).expect(\"utf8\");\n let vers = stdout.split_whitespace().skip(1).next().unwrap();\n let is_nightly = option_env!(\"CARGO_TEST_DISABLE_NIGHTLY\").is_none()\n && (vers.contains(\"-nightly\") || vers.contains(\"-dev\"));\n let minor = vers.split('.').skip(1).next().unwrap().parse().unwrap();\n unsafe { VERSION = (minor, is_nightly) }\n });\n unsafe { VERSION }\n}\n\nfn compile(file: &Path) -> Result {\n let tmp = tempdir()?;\n\n let args: Vec = vec![\n file.into(),\n \"--error-format=json\".into(),\n \"--emit=metadata\".into(),\n \"--crate-name=rustfix_test\".into(),\n \"--out-dir\".into(),\n tmp.path().into(),\n ];\n\n let res = Command::new(env::var_os(\"RUSTC\").unwrap_or(\"rustc\".into()))\n .args(&args)\n .env(\"CLIPPY_DISABLE_DOCS_LINKS\", \"true\")\n .env_remove(\"RUST_LOG\")\n .output()?;\n\n Ok(res)\n}\n\nfn compile_and_get_json_errors(file: &Path) -> Result {\n let res = compile(file)?;\n let stderr = String::from_utf8(res.stderr)?;\n if stderr.contains(\"is only accepted on the nightly compiler\") {\n panic!(\"rustfix tests require a nightly compiler\");\n }\n\n match res.status.code() {\n Some(0) | Some(1) | Some(101) => Ok(stderr),\n _ => Err(anyhow!(\n \"failed with status {:?}: {}\",\n res.status.code(),\n stderr\n )),\n }\n}\n\nfn compiles_without_errors(file: &Path) -> Result<(), Error> {\n let res = compile(file)?;\n\n match res.status.code() {\n Some(0) => Ok(()),\n _ => Err(anyhow!(\n \"file {:?} failed compile with status {:?}:\\n {}\",\n file,\n res.status.code(),\n String::from_utf8(res.stderr)?\n )),\n }\n}\n\nfn test_rustfix_with_file>(file: P, mode: &str) {\n let file: &Path = file.as_ref();\n let json_file = file.with_extension(\"json\");\n let expected_fixed_file = file.with_extension(\"fixed.rs\");\n\n let filter_suggestions = if mode == fixmode::EVERYTHING {\n rustfix::Filter::Everything\n } else {\n rustfix::Filter::MachineApplicableOnly\n };\n\n let code = fs::read_to_string(file).unwrap();\n\n let json = compile_and_get_json_errors(file)\n .with_context(|| format!(\"could not compile {}\", file.display()))\n .unwrap();\n\n let suggestions =\n rustfix::get_suggestions_from_json(&json, &HashSet::new(), filter_suggestions)\n .context(\"could not load suggestions\")\n .unwrap();\n\n let fixed = apply_suggestions(&code, &suggestions)\n .with_context(|| format!(\"could not apply suggestions to {}\", file.display()))\n .unwrap()\n .replace('\\r', \"\");\n\n let assert = Assert::new().action_env(snapbox::assert::DEFAULT_ACTION_ENV);\n let (actual_fix, expected_fix) = assert.normalize(\n Data::text(&fixed),\n Data::read_from(expected_fixed_file.as_path(), Some(DataFormat::Text)),\n );\n\n if actual_fix != expected_fix {\n let fixed_assert = assert.try_eq(Some(&\"Current Fix\"), actual_fix, expected_fix);\n assert!(fixed_assert.is_ok(), \"{}\", fixed_assert.err().unwrap());\n\n let expected_json = Data::read_from(json_file.as_path(), Some(DataFormat::Text));\n\n let pretty_json = json\n .split(\"\\n\")\n .filter(|j| !j.is_empty())\n .map(|j| {\n serde_json::to_string_pretty(&serde_json::from_str::(j).unwrap()).unwrap()\n })\n .collect::>()\n .join(\"\\n\");\n\n let json_assert = assert.try_eq(\n Some(&\"Compiler Error\"),\n Data::text(pretty_json),\n expected_json,\n );\n assert!(json_assert.is_ok(), \"{}\", json_assert.err().unwrap());\n }\n\n compiles_without_errors(&expected_fixed_file).unwrap();\n}\n\nmacro_rules! run_test {\n ($name:ident, $file:expr) => {\n #[test]\n #[allow(non_snake_case)]\n fn $name() {\n let (_, nightly) = version();\n if !$file.ends_with(\".nightly.rs\") || nightly {\n let file = Path::new(concat!(\"./tests/everything/\", $file));\n assert!(file.is_file(), \"could not load {}\", $file);\n test_rustfix_with_file(file, fixmode::EVERYTHING);\n }\n }\n };\n}\n\nrun_test! {\n closure_immutable_outer_variable,\n \"closure-immutable-outer-variable.rs\"\n}\nrun_test! {dedup_suggestions, \"dedup-suggestions.rs\"}\nrun_test! {E0178, \"E0178.rs\"}\nrun_test! {handle_insert_only, \"handle-insert-only.rs\"}\nrun_test! {lt_generic_comp, \"lt-generic-comp.rs\"}\nrun_test! {multiple_solutions, \"multiple-solutions.rs\"}\nrun_test! {replace_only_one_char, \"replace-only-one-char.rs\"}\nrun_test! {str_lit_type_mismatch, \"str-lit-type-mismatch.rs\"}\nrun_test! {use_insert, \"use-insert.rs\"}\n" }, { "path": "crates/semver-check/Cargo.toml", "content": "[package]\nname = \"semver-check\"\nversion = \"0.0.0\"\nauthors = [\"Eric Huss\"]\nedition.workspace = true\npublish = false\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\ntempfile.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/semver-check/src/main.rs", "content": "//! Test runner for the semver compatibility doc chapter.\n//!\n//! This extracts all the \"rust\" annotated code blocks and tests that they\n//! either fail or succeed as expected. This also checks that the examples are\n//! formatted correctly.\n//!\n//! An example with the word \"MINOR\" at the top is expected to successfully\n//! build against the before and after. Otherwise it should fail. A comment of\n//! \"// Error:\" will check that the given message appears in the error output.\n//!\n//! The code block can also include the annotations:\n//! - `run-fail`: The test should fail at runtime, not compiletime.\n//! - `dont-deny`: By default tests have a `#![deny(warnings)]`. This option\n//! avoids this attribute. Note that `#![allow(unused)]` is always added.\n\n#![allow(clippy::print_stderr)]\n\nuse std::error::Error;\nuse std::fs;\nuse std::path::Path;\nuse std::process::{Command, Output};\n\nfn main() {\n if let Err(e) = doit() {\n eprintln!(\"error: {}\", e);\n std::process::exit(1);\n }\n}\n\nconst SEPARATOR: &str = \"///////////////////////////////////////////////////////////\";\n\nfn doit() -> Result<(), Box> {\n let filename = std::env::args().nth(1).unwrap_or_else(|| {\n Path::new(env!(\"CARGO_MANIFEST_DIR\"))\n .join(\"../../src/doc/src/reference/semver.md\")\n .to_str()\n .unwrap()\n .to_string()\n });\n let contents = fs::read_to_string(filename)?;\n let mut lines = contents.lines().enumerate();\n\n loop {\n // Find a rust block.\n let (block_start, run_program, deny_warnings) = loop {\n match lines.next() {\n Some((lineno, line)) => {\n if line.trim().starts_with(\"```rust\") && !line.contains(\"skip\") {\n break (\n lineno + 1,\n line.contains(\"run-fail\"),\n !line.contains(\"dont-deny\"),\n );\n }\n }\n None => return Ok(()),\n }\n };\n // Read in the code block.\n let mut block = Vec::new();\n loop {\n match lines.next() {\n Some((_, line)) => {\n if line.trim() == \"```\" {\n break;\n }\n // Support rustdoc/mdbook hidden lines.\n let line = line.strip_prefix(\"# \").unwrap_or(line);\n if line == \"#\" {\n block.push(\"\");\n } else {\n block.push(line);\n }\n }\n None => {\n return Err(format!(\n \"rust block did not end for example starting on line {}\",\n block_start\n )\n .into());\n }\n }\n }\n // Split it into the separate source files.\n let parts: Vec<_> = block.split(|line| line.trim() == SEPARATOR).collect();\n if parts.len() != 4 {\n return Err(format!(\n \"expected 4 sections in example starting on line {}, got {}:\\n{:?}\",\n block_start,\n parts.len(),\n parts\n )\n .into());\n }\n let join = |part: &[&str]| {\n let mut result = String::new();\n result.push_str(\"#![allow(unused)]\\n\");\n if deny_warnings {\n result.push_str(\"#![deny(warnings)]\\n\");\n }\n result.push_str(&part.join(\"\\n\"));\n if !result.ends_with('\\n') {\n result.push('\\n');\n }\n result\n };\n let expect_success = parts[0][0].contains(\"MINOR\");\n eprintln!(\"Running test from line {}\", block_start);\n\n let result = run_test(\n join(parts[1]),\n join(parts[2]),\n join(parts[3]),\n expect_success,\n run_program,\n );\n\n if let Err(e) = result {\n return Err(format!(\n \"test failed for example starting on line {}: {}\",\n block_start, e\n )\n .into());\n }\n }\n}\n\nconst CRATE_NAME: &str = \"updated_crate\";\n\nfn run_test(\n before: String,\n after: String,\n example: String,\n expect_success: bool,\n run_program: bool,\n) -> Result<(), Box> {\n let tempdir = tempfile::TempDir::new()?;\n let before_p = tempdir.path().join(\"before.rs\");\n let after_p = tempdir.path().join(\"after.rs\");\n let example_p = tempdir.path().join(\"example.rs\");\n\n let check_fn = if run_program {\n run_check\n } else {\n compile_check\n };\n\n compile_check(before, &before_p, CRATE_NAME, false, true)?;\n check_fn(example.clone(), &example_p, \"example\", true, true)?;\n compile_check(after, &after_p, CRATE_NAME, false, true)?;\n check_fn(example, &example_p, \"example\", true, expect_success)?;\n Ok(())\n}\n\nfn check_formatting(path: &Path) -> Result<(), Box> {\n match Command::new(\"rustfmt\")\n .args(&[\"--edition=2018\", \"--check\"])\n .arg(path)\n .status()\n {\n Ok(status) => {\n if !status.success() {\n return Err(format!(\"failed to run rustfmt: {}\", status).into());\n }\n Ok(())\n }\n Err(e) => Err(format!(\"failed to run rustfmt: {}\", e).into()),\n }\n}\n\nfn compile(\n contents: &str,\n path: &Path,\n crate_name: &str,\n extern_path: bool,\n) -> Result> {\n let crate_type = if contents.contains(\"fn main()\") {\n \"bin\"\n } else {\n \"rlib\"\n };\n\n fs::write(path, &contents)?;\n check_formatting(path)?;\n let out_dir = path.parent().unwrap();\n let mut cmd = Command::new(\"rustc\");\n cmd.args(&[\n \"--edition=2021\",\n \"--crate-type\",\n crate_type,\n \"--crate-name\",\n crate_name,\n \"--out-dir\",\n ]);\n cmd.arg(&out_dir);\n if extern_path {\n let epath = out_dir.join(format!(\"lib{}.rlib\", CRATE_NAME));\n cmd.arg(\"--extern\")\n .arg(format!(\"{}={}\", CRATE_NAME, epath.display()));\n }\n cmd.arg(path);\n cmd.output().map_err(Into::into)\n}\n\nfn compile_check(\n mut contents: String,\n path: &Path,\n crate_name: &str,\n extern_path: bool,\n expect_success: bool,\n) -> Result<(), Box> {\n // If the example has an error message, remove it so that it can be\n // compared with the actual output, and also to avoid issues with rustfmt\n // moving it around.\n let expected_error = match contents.find(\"// Error:\") {\n Some(index) => {\n let start = contents[..index].rfind(|ch| ch != ' ').unwrap();\n let end = contents[index..].find('\\n').unwrap();\n let error = contents[index + 9..index + end].trim().to_string();\n contents.replace_range(start + 1..index + end, \"\");\n Some(error)\n }\n None => None,\n };\n\n let output = compile(&contents, path, crate_name, extern_path)?;\n\n let stderr = std::str::from_utf8(&output.stderr).unwrap();\n match (output.status.success(), expect_success) {\n (true, true) => Ok(()),\n (true, false) => Err(format!(\n \"expected failure, got success {}\\n===== Contents:\\n{}\\n===== Output:\\n{}\\n\",\n path.display(),\n contents,\n stderr\n )\n .into()),\n (false, true) => Err(format!(\n \"expected success, got error {}\\n===== Contents:\\n{}\\n===== Output:\\n{}\\n\",\n path.display(),\n contents,\n stderr\n )\n .into()),\n (false, false) => {\n if expected_error.is_none() {\n return Err(\"failing test should have an \\\"// Error:\\\" annotation \".into());\n }\n let expected_error = expected_error.unwrap();\n if !stderr.contains(&expected_error) {\n Err(format!(\n \"expected error message not found in compiler output\\nExpected: {}\\nGot:\\n{}\\n\",\n expected_error, stderr\n )\n .into())\n } else {\n Ok(())\n }\n }\n }\n}\n\nfn run_check(\n contents: String,\n path: &Path,\n crate_name: &str,\n extern_path: bool,\n expect_success: bool,\n) -> Result<(), Box> {\n let compile_output = compile(&contents, path, crate_name, extern_path)?;\n\n if !compile_output.status.success() {\n let stderr = std::str::from_utf8(&compile_output.stderr).unwrap();\n return Err(format!(\n \"expected success, got error {}\\n===== Contents:\\n{}\\n===== Output:\\n{}\\n\",\n path.display(),\n contents,\n stderr\n )\n .into());\n }\n\n let binary_path = path.parent().unwrap().join(crate_name);\n\n let output = Command::new(binary_path).output()?;\n\n let stderr = std::str::from_utf8(&output.stderr).unwrap();\n\n match (output.status.success(), expect_success) {\n (true, false) => Err(format!(\n \"expected panic, got success {}\\n===== Contents:\\n{}\\n===== Output:\\n{}\\n\",\n path.display(),\n contents,\n stderr\n )\n .into()),\n (false, true) => Err(format!(\n \"expected success, got panic {}\\n===== Contents:\\n{}\\n===== Output:\\n{}\\n\",\n path.display(),\n contents,\n stderr,\n )\n .into()),\n (_, _) => Ok(()),\n }\n}\n" }, { "path": "crates/xtask-build-man/Cargo.toml", "content": "[package]\nname = \"xtask-build-man\"\nversion = \"0.0.0\"\nedition.workspace = true\npublish = false\n\n[dependencies]\n\n[lints]\nworkspace = true\n" }, { "path": "crates/xtask-build-man/src/main.rs", "content": "//! ```text\n//! NAME\n//! build-man\n//!\n//! SYNOPSIS\n//! build-man\n//!\n//! DESCRIPTION\n//! Build the man pages for packages `mdman` and `cargo`.\n//! For more, read their doc comments.\n//! ```\n\n#![allow(clippy::print_stderr)]\n\nuse std::fs;\nuse std::io;\nuse std::path::PathBuf;\nuse std::process;\nuse std::process::Command;\n\nfn main() -> io::Result<()> {\n build_mdman()?;\n build_cargo()?;\n Ok(())\n}\n\n/// Builds the man pages for `mdman`.\nfn build_mdman() -> io::Result<()> {\n cwd_to_workspace_root()?;\n\n let src_paths = &[\"crates/mdman/doc/mdman.md\".into()];\n let dst_path = \"crates/mdman/doc/out\";\n let outs = [(\"md\", dst_path), (\"txt\", dst_path), (\"man\", dst_path)];\n\n build_man(\"mdman\", src_paths, &outs, &[])\n}\n\n/// Builds the man pages for Cargo.\n///\n/// The source for the man pages are located in src/doc/man/ in markdown format.\n/// These also are handlebars templates, see crates/mdman/README.md for details.\n///\n/// The generated man pages are placed in the src/etc/man/ directory. The pages\n/// are also expanded into markdown (after being expanded by handlebars) and\n/// saved in the src/doc/src/commands/ directory. These are included in the\n/// Cargo book, which is converted to HTML by mdbook.\nfn build_cargo() -> io::Result<()> {\n // Find all `src/doc/man/cargo*.md`\n let src_paths = {\n let mut src_paths = Vec::new();\n for entry in fs::read_dir(\"src/doc/man\")? {\n let entry = entry?;\n let file_name = entry.file_name();\n let file_name = file_name.to_str().unwrap();\n if file_name.starts_with(\"cargo\") && file_name.ends_with(\".md\") {\n src_paths.push(entry.path());\n }\n }\n src_paths\n };\n let outs = [\n (\"md\", \"src/doc/src/commands\"),\n (\"txt\", \"src/doc/man/generated_txt\"),\n (\"man\", \"src/etc/man\"),\n ];\n let args = [\n \"--url\",\n \"https://doc.rust-lang.org/cargo/commands/\",\n \"--man\",\n \"rustc:1=https://doc.rust-lang.org/rustc/index.html\",\n \"--man\",\n \"rustdoc:1=https://doc.rust-lang.org/rustdoc/index.html\",\n ];\n build_man(\"cargo\", &src_paths[..], &outs, &args)\n}\n\n/// Change to workspace root.\n///\n/// Assumed this xtask is located in `[WORKSPACE]/crates/xtask-build-man`.\nfn cwd_to_workspace_root() -> io::Result<()> {\n let pkg_root = std::env!(\"CARGO_MANIFEST_DIR\");\n let ws_root = format!(\"{pkg_root}/../..\");\n std::env::set_current_dir(ws_root)\n}\n\n/// Builds the man pages.\nfn build_man(\n pkg_name: &str,\n src_paths: &[PathBuf],\n outs: &[(&str, &str)],\n extra_args: &[&str],\n) -> io::Result<()> {\n for (format, dst_path) in outs {\n eprintln!(\"Start converting `{format}` for package `{pkg_name}`...\");\n let mut cmd = Command::new(std::env!(\"CARGO\"));\n cmd.args([\"run\", \"--package\", \"mdman\", \"--\"])\n .args([\"-t\", format, \"-o\", dst_path])\n .args(src_paths)\n .args(extra_args);\n\n let status = cmd.status()?;\n if !status.success() {\n eprintln!(\"failed to build the man pages for package `{pkg_name}`\");\n eprintln!(\"failed command: `{cmd:?}`\");\n process::exit(status.code().unwrap_or(1));\n }\n }\n\n Ok(())\n}\n" }, { "path": "crates/xtask-bump-check/Cargo.toml", "content": "[package]\nname = \"xtask-bump-check\"\nversion = \"0.0.0\"\nedition.workspace = true\npublish = false\n\n[dependencies]\nanyhow.workspace = true\ncargo.workspace = true\ncargo-util.workspace = true\nclap.workspace = true\ngit2.workspace = true\nsemver.workspace = true\ntracing-subscriber.workspace = true\ntracing.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/xtask-bump-check/src/main.rs", "content": "mod xtask;\n\nfn main() {\n setup_logger();\n\n let cli = xtask::cli();\n let matches = cli.get_matches();\n\n let mut gctx = cargo::util::context::GlobalContext::default().unwrap_or_else(|e| {\n let mut eval = cargo::core::shell::Shell::new();\n cargo::exit_with_error(e.into(), &mut eval)\n });\n if let Err(e) = xtask::exec(&matches, &mut gctx) {\n cargo::exit_with_error(e, &mut gctx.shell())\n }\n}\n\n// In sync with `src/bin/cargo/main.rs@setup_logger`.\nfn setup_logger() {\n let env = tracing_subscriber::EnvFilter::from_env(\"CARGO_LOG\");\n\n tracing_subscriber::fmt()\n .with_timer(tracing_subscriber::fmt::time::Uptime::default())\n .with_ansi(std::io::IsTerminal::is_terminal(&std::io::stderr()))\n .with_writer(std::io::stderr)\n .with_env_filter(env)\n .init();\n}\n" }, { "path": "crates/xtask-bump-check/src/xtask.rs", "content": "//! ```text\n//! NAME\n//! xtask-bump-check\n//!\n//! SYNOPSIS\n//! xtask-bump-check --base-rev --head-rev \n//!\n//! DESCRIPTION\n//! Checks if there is any member got changed since a base commit\n//! but forgot to bump its version.\n//! ```\n\n#![allow(clippy::print_stdout)] // Fine for build utilities\n\nuse std::collections::HashMap;\nuse std::fmt::Write;\nuse std::fs;\nuse std::task;\n\nuse cargo::CargoResult;\nuse cargo::core::Package;\nuse cargo::core::Registry;\nuse cargo::core::SourceId;\nuse cargo::core::Workspace;\nuse cargo::core::dependency::Dependency;\nuse cargo::sources::source::QueryKind;\nuse cargo::util::cache_lock::CacheLockMode;\nuse cargo::util::command_prelude::*;\nuse cargo_util::ProcessBuilder;\n\nconst UPSTREAM_BRANCH: &str = \"master\";\nconst STATUS: &str = \"BumpCheck\";\n\npub fn cli() -> clap::Command {\n clap::Command::new(\"xtask-bump-check\")\n .arg(\n opt(\n \"verbose\",\n \"Use verbose output (-vv very verbose/build.rs output)\",\n )\n .short('v')\n .action(ArgAction::Count)\n .global(true),\n )\n .arg(\n flag(\"quiet\", \"Do not print cargo log messages\")\n .short('q')\n .global(true),\n )\n .arg(\n opt(\"color\", \"Coloring: auto, always, never\")\n .value_name(\"WHEN\")\n .global(true),\n )\n .arg(opt(\"base-rev\", \"Git revision to lookup for a baseline\"))\n .arg(opt(\"head-rev\", \"Git revision with changes\"))\n .arg(flag(\"frozen\", \"Require Cargo.lock and cache to be up-to-date\").global(true))\n .arg(flag(\"locked\", \"Require Cargo.lock to be up-to-date\").global(true))\n .arg(flag(\"offline\", \"Run without accessing the network\").global(true))\n .arg(multi_opt(\"config\", \"KEY=VALUE\", \"Override a configuration value\").global(true))\n .arg(flag(\"github\", \"Group output using GitHub's syntax\"))\n .arg(\n Arg::new(\"unstable-features\")\n .help(\"Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details\")\n .short('Z')\n .value_name(\"FLAG\")\n .action(ArgAction::Append)\n .global(true),\n )\n}\n\npub fn exec(args: &clap::ArgMatches, gctx: &mut cargo::util::GlobalContext) -> cargo::CliResult {\n global_context_configure(gctx, args)?;\n\n bump_check(args, gctx)?;\n\n Ok(())\n}\n\nfn global_context_configure(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let verbose = args.verbose();\n // quiet is unusual because it is redefined in some subcommands in order\n // to provide custom help text.\n let quiet = args.flag(\"quiet\");\n let color = args.get_one::(\"color\").map(String::as_str);\n let frozen = args.flag(\"frozen\");\n let locked = args.flag(\"locked\");\n let offline = args.flag(\"offline\");\n let mut unstable_flags = vec![];\n if let Some(values) = args.get_many::(\"unstable-features\") {\n unstable_flags.extend(values.cloned());\n }\n let mut config_args = vec![];\n if let Some(values) = args.get_many::(\"config\") {\n config_args.extend(values.cloned());\n }\n gctx.configure(\n verbose,\n quiet,\n color,\n frozen,\n locked,\n offline,\n &None,\n &unstable_flags,\n &config_args,\n )?;\n Ok(())\n}\n\n/// Main entry of `xtask-bump-check`.\n///\n/// Assumption: version number are incremental. We never have point release for old versions.\nfn bump_check(args: &clap::ArgMatches, gctx: &cargo::util::GlobalContext) -> CargoResult<()> {\n let ws = args.workspace(gctx)?;\n let repo = git2::Repository::open(ws.root())?;\n let base_commit = get_base_commit(gctx, args, &repo)?;\n let head_commit = get_head_commit(args, &repo)?;\n let referenced_commit = get_referenced_commit(&repo, &base_commit)?;\n let github = args.get_flag(\"github\");\n let status = |msg: &str| gctx.shell().status(STATUS, msg);\n\n let crates_not_check_against_channels = [\n // High false positive rate between beta branch and requisite version bump soon after\n //\n // Low risk because we always bump the \"major\" version after beta branch; we are\n // only losing out on checks for patch releases.\n //\n // Note: this is already skipped in `changed`\n \"cargo\",\n // Don't check against beta and stable branches,\n // as the publish of these crates are not tied with Rust release process.\n // See `TO_PUBLISH` in publish.py.\n \"home\",\n ];\n\n status(&format!(\"base commit `{}`\", base_commit.id()))?;\n status(&format!(\"head commit `{}`\", head_commit.id()))?;\n\n let mut needs_bump = Vec::new();\n if github {\n println!(\"::group::Checking for bumps of changed packages\");\n }\n let changed_members = changed(&ws, &repo, &base_commit, &head_commit)?;\n check_crates_io(&ws, &changed_members, &mut needs_bump)?;\n if let Some(referenced_commit) = referenced_commit.as_ref() {\n status(&format!(\"compare against `{}`\", referenced_commit.id()))?;\n for referenced_member in checkout_ws(&ws, &repo, referenced_commit)?.members() {\n let pkg_name = referenced_member.name().as_str();\n\n if crates_not_check_against_channels.contains(&pkg_name) {\n continue;\n }\n\n let Some(changed_member) = changed_members.get(pkg_name) else {\n tracing::trace!(\"skipping {pkg_name}, may be removed or not published\");\n continue;\n };\n\n if changed_member.version() <= referenced_member.version() {\n needs_bump.push(*changed_member);\n }\n }\n }\n if !needs_bump.is_empty() {\n needs_bump.sort();\n needs_bump.dedup();\n let mut msg = String::new();\n msg.push_str(\"Detected changes in these crates but no version bump found:\\n\");\n for pkg in needs_bump {\n writeln!(&mut msg, \" {}@{}\", pkg.name(), pkg.version())?;\n }\n msg.push_str(\"\\nPlease bump at least one patch version in each corresponding Cargo.toml.\");\n anyhow::bail!(msg)\n }\n if github {\n println!(\"::endgroup::\");\n }\n\n if let Some(referenced_commit) = referenced_commit.as_ref() {\n if github {\n println!(\"::group::SemVer Checks against {}\", referenced_commit.id());\n }\n let mut cmd = ProcessBuilder::new(\"cargo\");\n cmd.arg(\"semver-checks\")\n .arg(\"--workspace\")\n .arg(\"--baseline-rev\")\n .arg(referenced_commit.id().to_string());\n for krate in crates_not_check_against_channels {\n cmd.args(&[\"--exclude\", krate]);\n }\n gctx.shell().status(\"Running\", &cmd)?;\n cmd.exec()?;\n if github {\n println!(\"::endgroup::\");\n }\n }\n\n // Even when we test against baseline-rev, we still need to make sure a\n // change doesn't violate SemVer rules against crates.io releases. The\n // possibility of this happening is nearly zero but no harm to check twice.\n if github {\n println!(\"::group::SemVer Checks against crates.io\");\n }\n\n let mut cmd = ProcessBuilder::new(\"cargo\");\n cmd.arg(\"semver-checks\")\n .arg(\"check-release\")\n .arg(\"--workspace\")\n .args(&[\"--exclude\", \"cargo\"]);\n\n gctx.shell().status(\"Running\", &cmd)?;\n cmd.exec()?;\n\n // Cargo has mutually exclusive features for different HTTP backends, so\n // pass a specific `--features` instead of including this in the\n // `--all-features` performed by the previous command.\n let mut cmd = ProcessBuilder::new(\"cargo\");\n cmd.arg(\"semver-checks\")\n .arg(\"check-release\")\n .args(&[\"--package\", \"cargo\"])\n .arg(\"--default-features\")\n .args(&[\"--features\", \"all-static\"]);\n\n gctx.shell().status(\"Running\", &cmd)?;\n cmd.exec()?;\n\n if github {\n println!(\"::endgroup::\");\n }\n\n status(\"no version bump needed for member crates.\")?;\n\n Ok(())\n}\n\n/// Returns the commit of upstream `master` branch if `base-rev` is missing.\nfn get_base_commit<'a>(\n gctx: &GlobalContext,\n args: &clap::ArgMatches,\n repo: &'a git2::Repository,\n) -> CargoResult> {\n let base_commit = match args.get_one::(\"base-rev\") {\n Some(sha) => {\n let obj = repo.revparse_single(sha)?;\n obj.peel_to_commit()?\n }\n None => {\n let upstream_branches = repo\n .branches(Some(git2::BranchType::Remote))?\n .filter_map(|r| r.ok())\n .filter(|(b, _)| {\n b.name()\n .ok()\n .flatten()\n .unwrap_or_default()\n .ends_with(&format!(\"/{UPSTREAM_BRANCH}\"))\n })\n .map(|(b, _)| b)\n .collect::>();\n if upstream_branches.is_empty() {\n anyhow::bail!(\n \"could not find `base-sha` for `{UPSTREAM_BRANCH}`, pass it in directly\"\n );\n }\n let upstream_ref = upstream_branches[0].get();\n if upstream_branches.len() > 1 {\n let name = upstream_ref.name().expect(\"name is valid UTF-8\");\n let _ = gctx.shell().warn(format!(\n \"multiple `{UPSTREAM_BRANCH}` found, picking {name}\"\n ));\n }\n upstream_ref.peel_to_commit()?\n }\n };\n Ok(base_commit)\n}\n\n/// Returns `HEAD` of the Git repository if `head-rev` is missing.\nfn get_head_commit<'a>(\n args: &clap::ArgMatches,\n repo: &'a git2::Repository,\n) -> CargoResult> {\n let head_commit = match args.get_one::(\"head-rev\") {\n Some(sha) => {\n let head_obj = repo.revparse_single(sha)?;\n head_obj.peel_to_commit()?\n }\n None => {\n let head_ref = repo.head()?;\n head_ref.peel_to_commit()?\n }\n };\n Ok(head_commit)\n}\n\n/// Gets the referenced commit to compare if version bump needed.\n///\n/// * When merging into nightly, check the version with beta branch\n/// * When merging into beta, check the version with stable branch\n/// * When merging into stable, check against crates.io registry directly\nfn get_referenced_commit<'a>(\n repo: &'a git2::Repository,\n base: &git2::Commit<'a>,\n) -> CargoResult>> {\n let [beta, stable] = beta_and_stable_branch(repo)?;\n let rev_id = base.id();\n let stable_commit = stable.get().peel_to_commit()?;\n let beta_commit = beta.get().peel_to_commit()?;\n\n let referenced_commit = if rev_id == stable_commit.id() {\n None\n } else if rev_id == beta_commit.id() {\n tracing::trace!(\"stable branch from `{}`\", stable.name().unwrap().unwrap());\n Some(stable_commit)\n } else {\n tracing::trace!(\"beta branch from `{}`\", beta.name().unwrap().unwrap());\n Some(beta_commit)\n };\n\n Ok(referenced_commit)\n}\n\n/// Get the current beta and stable branch in cargo repository.\n///\n/// Assumptions:\n///\n/// * The repository contains the full history of `/rust-1.*.0` branches.\n/// * The version part of `/rust-1.*.0` always ends with a zero.\n/// * The maximum version is for beta channel, and the second one is for stable.\nfn beta_and_stable_branch(repo: &git2::Repository) -> CargoResult<[git2::Branch<'_>; 2]> {\n let mut release_branches = Vec::new();\n for branch in repo.branches(Some(git2::BranchType::Remote))? {\n let (branch, _) = branch?;\n let name = branch.name()?.unwrap();\n let Some((_, version)) = name.split_once(\"/rust-\") else {\n tracing::trace!(\"branch `{name}` is not in the format of `/rust-`\");\n continue;\n };\n let Ok(version) = version.parse::() else {\n tracing::trace!(\"branch `{name}` is not a valid semver: `{version}`\");\n continue;\n };\n release_branches.push((version, branch));\n }\n release_branches.sort_unstable_by(|a, b| a.0.cmp(&b.0));\n release_branches.dedup_by(|a, b| a.0 == b.0);\n\n let beta = release_branches.pop().unwrap();\n let stable = release_branches.pop().unwrap();\n\n assert_eq!(beta.0.major, 1);\n assert_eq!(beta.0.patch, 0);\n assert_eq!(stable.0.major, 1);\n assert_eq!(stable.0.patch, 0);\n assert_ne!(beta.0.minor, stable.0.minor);\n\n Ok([beta.1, stable.1])\n}\n\n/// Lists all changed workspace members between two commits.\nfn changed<'r, 'ws>(\n ws: &'ws Workspace<'_>,\n repo: &'r git2::Repository,\n base_commit: &git2::Commit<'r>,\n head: &git2::Commit<'r>,\n) -> CargoResult> {\n let root_pkg_name = ws.current()?.name(); // `cargo` crate.\n let ws_members = ws\n .members()\n .filter(|pkg| pkg.name() != root_pkg_name) // Only take care of sub crates here.\n .filter(|pkg| pkg.publish() != &Some(vec![])) // filter out `publish = false`\n .map(|pkg| {\n // Having relative package root path so that we can compare with\n // paths of changed files to determine which package has changed.\n let relative_pkg_root = pkg.root().strip_prefix(ws.root()).unwrap();\n (relative_pkg_root, pkg)\n })\n .collect::>();\n\n let diff = symmetric_diff(repo, base_commit, head)?;\n let mut changed_members = HashMap::new();\n\n for delta in diff.deltas() {\n let old = delta.old_file().path().unwrap();\n let new = delta.new_file().path().unwrap();\n for (pkg_root, pkg) in ws_members.iter() {\n if old.starts_with(pkg_root) || new.starts_with(pkg_root) {\n changed_members.insert(pkg.name().as_str(), *pkg);\n break;\n }\n }\n }\n\n tracing::trace!(\"changed_members: {:?}\", changed_members.keys());\n Ok(changed_members)\n}\n\n/// Using a \"symmetric difference\" between base and head.\nfn symmetric_diff<'a>(\n repo: &'a git2::Repository,\n base: &'a git2::Commit<'a>,\n head: &'a git2::Commit<'a>,\n) -> CargoResult> {\n let ancestor_oid = repo.merge_base(base.id(), head.id())?;\n let ancestor_commit = repo.find_commit(ancestor_oid)?;\n let ancestor_tree = ancestor_commit.as_object().peel_to_tree()?;\n let head_tree = head.as_object().peel_to_tree()?;\n let diff =\n repo.diff_tree_to_tree(Some(&ancestor_tree), Some(&head_tree), Default::default())?;\n tracing::info!(merge_base = %ancestor_commit.id(), base = %base.id(), head = %head.id(), \"git diff base...head\");\n Ok(diff)\n}\n\n/// Compares version against published crates on crates.io.\n///\n/// Assumption: We always release a version larger than all existing versions.\nfn check_crates_io<'a>(\n ws: &Workspace<'a>,\n changed_members: &HashMap<&'a str, &'a Package>,\n needs_bump: &mut Vec<&'a Package>,\n) -> CargoResult<()> {\n let gctx = ws.gctx();\n let source_id = SourceId::crates_io(gctx)?;\n let mut registry = ws.package_registry()?;\n let _lock = gctx.acquire_package_cache_lock(CacheLockMode::DownloadExclusive)?;\n registry.lock_patches();\n gctx.shell().status(\n STATUS,\n format_args!(\"compare against `{}`\", source_id.display_registry_name()),\n )?;\n for (name, member) in changed_members {\n let current = member.version();\n let version_req = format!(\">={current}\");\n let query = Dependency::parse(*name, Some(&version_req), source_id)?;\n let possibilities = loop {\n // Exact to avoid returning all for path/git\n match registry.query_vec(&query, QueryKind::Exact) {\n task::Poll::Ready(res) => {\n break res?;\n }\n task::Poll::Pending => registry.block_until_ready()?,\n }\n };\n if possibilities.is_empty() {\n tracing::trace!(\"dep `{name}` has no version greater than or equal to `{current}`\");\n } else {\n tracing::trace!(\n \"`{name}@{current}` needs a bump because its should have a version newer than crates.io: {:?}`\",\n possibilities\n .iter()\n .map(|s| s.as_summary())\n .map(|s| format!(\"{}@{}\", s.name(), s.version()))\n .collect::>(),\n );\n needs_bump.push(member);\n }\n }\n\n Ok(())\n}\n\n/// Checkouts a temporary workspace to do further version comparisons.\nfn checkout_ws<'gctx, 'a>(\n ws: &Workspace<'gctx>,\n repo: &'a git2::Repository,\n referenced_commit: &git2::Commit<'a>,\n) -> CargoResult> {\n let repo_path = repo.path().as_os_str().to_str().unwrap();\n // Put it under `target/cargo-`\n let short_id = &referenced_commit.id().to_string()[..7];\n let checkout_path = ws.target_dir().join(format!(\"cargo-{short_id}\"));\n let checkout_path = checkout_path.as_path_unlocked();\n let _ = fs::remove_dir_all(checkout_path);\n let new_repo = git2::build::RepoBuilder::new()\n .clone_local(git2::build::CloneLocal::Local)\n .clone(repo_path, checkout_path)?;\n let obj = new_repo.find_object(referenced_commit.id(), None)?;\n new_repo.reset(&obj, git2::ResetType::Hard, None)?;\n Workspace::new(&checkout_path.join(\"Cargo.toml\"), ws.gctx())\n}\n\n#[test]\nfn verify_cli() {\n cli().debug_assert();\n}\n" }, { "path": "crates/xtask-lint-docs/Cargo.toml", "content": "[package]\nname = \"xtask-lint-docs\"\nversion = \"0.1.0\"\nedition.workspace = true\npublish = false\n\n[dependencies]\nanyhow.workspace = true\ncargo.workspace = true\nclap.workspace = true\nitertools.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/xtask-lint-docs/src/main.rs", "content": "use std::fmt::Write;\nuse std::path::PathBuf;\n\nuse cargo::lints::Lint;\nuse cargo::lints::LintLevel;\nuse cargo::util::command_prelude::{ArgMatchesExt, flag};\nuse itertools::Itertools;\n\nfn cli() -> clap::Command {\n clap::Command::new(\"xtask-lint-docs\").arg(flag(\"check\", \"Check that the docs are up-to-date\"))\n}\n\nfn main() -> anyhow::Result<()> {\n let args = cli().get_matches();\n let check = args.flag(\"check\");\n\n let mut allow = Vec::new();\n let mut warn = Vec::new();\n let mut deny = Vec::new();\n let mut forbid = Vec::new();\n\n let mut lint_docs = String::new();\n for lint in cargo::lints::LINTS.iter().sorted_by_key(|lint| lint.name) {\n if lint.docs.is_some() {\n let sectipn = match lint.primary_group.default_level {\n LintLevel::Allow => &mut allow,\n LintLevel::Warn => &mut warn,\n LintLevel::Deny => &mut deny,\n LintLevel::Forbid => &mut forbid,\n };\n sectipn.push(lint.name);\n add_lint(lint, &mut lint_docs)?;\n }\n }\n\n let mut buf = String::new();\n writeln!(buf, \"# Lints\\n\")?;\n writeln!(\n buf,\n \"Note: [Cargo's linting system is unstable](unstable.md#lintscargo) and can only be used on nightly toolchains\"\n )?;\n writeln!(buf)?;\n\n lint_groups(&mut buf)?;\n\n if !allow.is_empty() {\n add_level_section(LintLevel::Allow, &allow, &mut buf)?;\n }\n if !warn.is_empty() {\n add_level_section(LintLevel::Warn, &warn, &mut buf)?;\n }\n if !deny.is_empty() {\n add_level_section(LintLevel::Deny, &deny, &mut buf)?;\n }\n if !forbid.is_empty() {\n add_level_section(LintLevel::Forbid, &forbid, &mut buf)?;\n }\n\n buf.push_str(&lint_docs);\n\n if check {\n let old = std::fs::read_to_string(lint_docs_path())?;\n if old != buf {\n anyhow::bail!(\n \"The lints documentation is out-of-date. Run `cargo lint-docs` to update it.\"\n );\n }\n } else {\n std::fs::write(lint_docs_path(), buf)?;\n }\n Ok(())\n}\n\nfn lint_groups(buf: &mut String) -> anyhow::Result<()> {\n let (max_name_len, max_desc_len) = cargo::lints::LINT_GROUPS.iter().filter(|g| !g.hidden).fold(\n (0, 0),\n |(max_name_len, max_desc_len), group| {\n // We add 9 to account for the \"cargo::\" prefix and backticks\n let name_len = group.name.chars().count() + 9;\n let desc_len = group.desc.chars().count();\n (max_name_len.max(name_len), max_desc_len.max(desc_len))\n },\n );\n let default_level_len = \"Default level\".chars().count();\n writeln!(buf, \"\\n\")?;\n writeln!(\n buf,\n \"| {: std::fmt::Result {\n writeln!(buf, \"## `{}`\", lint.name)?;\n writeln!(buf, \"Group: `{}`\", lint.primary_group.name)?;\n writeln!(buf)?;\n writeln!(buf, \"Level: `{}`\", lint.primary_group.default_level)?;\n if let Some(msrv) = &lint.msrv {\n writeln!(buf)?;\n writeln!(buf, \"MSRV: `{msrv}`\")?;\n }\n writeln!(buf, \"{}\\n\", lint.docs.as_ref().unwrap())\n}\n\nfn add_level_section(level: LintLevel, lint_names: &[&str], buf: &mut String) -> std::fmt::Result {\n let title = match level {\n LintLevel::Allow => \"Allowed-by-default\",\n LintLevel::Warn => \"Warn-by-default\",\n LintLevel::Deny => \"Deny-by-default\",\n LintLevel::Forbid => \"Forbid-by-default\",\n };\n writeln!(buf, \"## {title}\\n\")?;\n writeln!(\n buf,\n \"These lints are all set to the '{}' level by default.\",\n level\n )?;\n\n for name in lint_names {\n writeln!(buf, \"- [`{}`](#{})\", name, name)?;\n }\n writeln!(buf)?;\n Ok(())\n}\n\nfn lint_docs_path() -> PathBuf {\n let pkg_root = env!(\"CARGO_MANIFEST_DIR\");\n let ws_root = PathBuf::from(format!(\"{pkg_root}/../..\"));\n let path = {\n let path = ws_root.join(\"src/doc/src/reference/lints.md\");\n path.canonicalize().unwrap_or(path)\n };\n path\n}\n" }, { "path": "crates/xtask-spellcheck/Cargo.toml", "content": "[package]\nname = \"xtask-spellcheck\"\nversion = \"0.0.0\"\nedition.workspace = true\npublish = false\n\n[dependencies]\nanyhow.workspace = true\ncargo_metadata.workspace = true\ncargo-util.workspace = true\nclap.workspace = true\nsemver.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/xtask-spellcheck/src/main.rs", "content": "#![allow(clippy::disallowed_methods)]\n#![allow(clippy::print_stderr)]\n#![allow(clippy::print_stdout)]\n\nuse anyhow::Result;\nuse cargo_metadata::{Metadata, MetadataCommand};\nuse clap::{Arg, ArgAction};\nuse semver::Version;\nuse std::{\n env, io,\n path::{Path, PathBuf},\n process::Command,\n};\n\nconst BIN_NAME: &str = \"typos\";\nconst PKG_NAME: &str = \"typos-cli\";\n\nfn main() -> anyhow::Result<()> {\n let cli = cli();\n exec(&cli.get_matches())?;\n Ok(())\n}\n\npub fn cli() -> clap::Command {\n clap::Command::new(\"xtask-spellcheck\")\n .arg(\n Arg::new(\"color\")\n .long(\"color\")\n .help(\"Coloring: auto, always, never\")\n .action(ArgAction::Set)\n .value_name(\"WHEN\")\n .global(true),\n )\n .arg(\n Arg::new(\"quiet\")\n .long(\"quiet\")\n .short('q')\n .help(\"Do not print cargo log messages\")\n .action(ArgAction::SetTrue)\n .global(true),\n )\n .arg(\n Arg::new(\"verbose\")\n .long(\"verbose\")\n .short('v')\n .help(\"Use verbose output (-vv very verbose/build.rs output)\")\n .action(ArgAction::Count)\n .global(true),\n )\n .arg(\n Arg::new(\"write-changes\")\n .long(\"write-changes\")\n .short('w')\n .help(\"Write fixes out\")\n .action(ArgAction::SetTrue)\n .global(true),\n )\n}\n\npub fn exec(matches: &clap::ArgMatches) -> Result<()> {\n let mut args = vec![];\n\n match matches.get_one::(\"color\") {\n Some(c) if matches!(c.as_str(), \"auto\" | \"always\" | \"never\") => {\n args.push(\"--color\");\n args.push(c);\n }\n Some(c) => {\n anyhow::bail!(\n \"argument for --color must be auto, always, or \\\n never, but found `{}`\",\n c\n );\n }\n _ => {}\n }\n\n if matches.get_flag(\"quiet\") {\n args.push(\"--quiet\");\n }\n\n let verbose_count = matches.get_count(\"verbose\");\n\n for _ in 0..verbose_count {\n args.push(\"--verbose\");\n }\n if matches.get_flag(\"write-changes\") {\n args.push(\"--write-changes\");\n }\n\n let metadata = MetadataCommand::new()\n .exec()\n .expect(\"cargo_metadata failed\");\n\n let required_version = extract_workflow_typos_version(&metadata)?;\n\n let outdir = metadata\n .build_directory\n .unwrap_or_else(|| metadata.target_directory)\n .as_std_path()\n .join(\"tmp\");\n let workspace_root = metadata.workspace_root.as_path().as_std_path();\n let bin_path = crate::ensure_version_or_cargo_install(&outdir, required_version)?;\n\n eprintln!(\"running {BIN_NAME}\");\n Command::new(bin_path)\n .current_dir(workspace_root)\n .args(args)\n .status()?;\n\n Ok(())\n}\n\nfn extract_workflow_typos_version(metadata: &Metadata) -> anyhow::Result {\n let ws_root = metadata.workspace_root.as_path().as_std_path();\n let workflow_path = ws_root.join(\".github\").join(\"workflows\").join(\"main.yml\");\n let file_content = std::fs::read_to_string(workflow_path)?;\n\n extract_typos_version_from_content(&file_content)\n}\n\nfn extract_typos_version_from_content(file_content: &str) -> anyhow::Result {\n file_content\n .lines()\n .find_map(|line| {\n line.trim()\n .strip_prefix(\"uses: crate-ci/typos@v\")\n .and_then(|v| Version::parse(v).ok())\n })\n .ok_or_else(|| anyhow::anyhow!(\"Could not find typos version in workflow\"))\n}\n\n/// If the given executable is installed with the given version, use that,\n/// otherwise install via cargo.\npub fn ensure_version_or_cargo_install(\n build_dir: &Path,\n required_version: Version,\n) -> io::Result {\n // Check if the user has a sufficient version already installed\n let bin_path = PathBuf::from(BIN_NAME).with_extension(env::consts::EXE_EXTENSION);\n if let Some(user_version) = get_typos_version(&bin_path) {\n if user_version >= required_version {\n return Ok(bin_path);\n }\n }\n\n let tool_root_dir = build_dir.join(\"misc-tools\");\n let tool_bin_dir = tool_root_dir.join(\"bin\");\n let bin_path = tool_bin_dir\n .join(BIN_NAME)\n .with_extension(env::consts::EXE_EXTENSION);\n\n // Check if we have already installed sufficient version\n if let Some(misc_tools_version) = get_typos_version(&bin_path) {\n if misc_tools_version >= required_version {\n return Ok(bin_path);\n }\n }\n\n eprintln!(\"required `typos` version ({required_version}) not found, building from source\");\n\n let mut cmd = Command::new(\"cargo\");\n // use --force to ensure that if the required version is bumped, we update it.\n cmd.args([\"install\", \"--locked\", \"--force\", \"--quiet\"])\n .arg(\"--root\")\n .arg(&tool_root_dir)\n // use --target-dir to ensure we have a build cache so repeated invocations aren't slow.\n .arg(\"--target-dir\")\n .arg(tool_root_dir.join(\"target\"))\n .arg(format!(\"{PKG_NAME}@{required_version}\"))\n // modify PATH so that cargo doesn't print a warning telling the user to modify the path.\n .env(\n \"PATH\",\n env::join_paths(\n env::split_paths(&env::var(\"PATH\").unwrap())\n .chain(std::iter::once(tool_bin_dir.clone())),\n )\n .expect(\"build dir contains invalid char\"),\n );\n\n let cargo_exit_code = cmd.spawn()?.wait()?;\n if !cargo_exit_code.success() {\n return Err(io::Error::other(\"cargo install failed\"));\n }\n assert!(\n matches!(bin_path.try_exists(), Ok(true)),\n \"cargo install did not produce the expected binary\"\n );\n eprintln!(\"finished {BIN_NAME}\");\n Ok(bin_path)\n}\n\nfn get_typos_version(bin: &PathBuf) -> Option {\n // ignore the process exit code here and instead just let the version number check fail\n if let Ok(output) = Command::new(&bin).arg(\"--version\").output()\n && let Ok(s) = String::from_utf8(output.stdout)\n && let Some(version_str) = s.trim().split_whitespace().last()\n {\n Version::parse(version_str).ok()\n } else {\n None\n }\n}\n" }, { "path": "crates/xtask-stale-label/Cargo.toml", "content": "[package]\nname = \"xtask-stale-label\"\nversion = \"0.0.0\"\nedition.workspace = true\npublish = false\n\n[dependencies]\ntoml_edit.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "crates/xtask-stale-label/src/main.rs", "content": "//! ```text\n//! NAME\n//! stale-label\n//!\n//! SYNOPSIS\n//! stale-label\n//!\n//! DESCRIPTION\n//! Detect stale paths in autolabel definitions in triagebot.toml.\n//! Probably autofix them in the future.\n//! ```\n\n#![allow(clippy::print_stderr)]\n\nuse std::fmt::Write as _;\nuse std::path::PathBuf;\nuse std::process;\nuse toml_edit::DocumentMut;\n\nfn main() {\n let pkg_root = std::env!(\"CARGO_MANIFEST_DIR\");\n let ws_root = PathBuf::from(format!(\"{pkg_root}/../..\"));\n let path = {\n let path = ws_root.join(\"triagebot.toml\");\n path.canonicalize().unwrap_or(path)\n };\n\n eprintln!(\"Checking file {path:?}\\n\");\n\n let mut failed = 0;\n let mut passed = 0;\n\n let toml = std::fs::read_to_string(path).expect(\"read from file\");\n let doc = toml.parse::().expect(\"a toml\");\n let autolabel = doc[\"autolabel\"].as_table().expect(\"a toml table\");\n\n for (label, value) in autolabel.iter() {\n let Some(trigger_files) = value.get(\"trigger_files\") else {\n continue;\n };\n let trigger_files = trigger_files.as_array().expect(\"an array\");\n let missing_files: Vec<_> = trigger_files\n .iter()\n // Hey TOML content is strict UTF-8.\n .map(|v| v.as_str().unwrap())\n .filter(|f| {\n // triagebot checks with `starts_with` only.\n // See https://github.com/rust-lang/triagebot/blob/0e4b48ca86ffede9cc70fb1611e658e4d013bce2/src/handlers/autolabel.rs#L45\n let path = ws_root.join(f);\n if path.exists() {\n return false;\n }\n let Some(mut read_dir) = path.parent().and_then(|p| p.read_dir().ok()) else {\n return true;\n };\n !read_dir.any(|e| {\n e.unwrap()\n .path()\n .strip_prefix(&ws_root)\n .unwrap()\n .to_str()\n .unwrap()\n .starts_with(f)\n })\n })\n .collect();\n\n failed += missing_files.len();\n passed += trigger_files.len() - missing_files.len();\n\n if missing_files.is_empty() {\n continue;\n }\n\n let mut msg = String::new();\n writeln!(\n &mut msg,\n \"missing files defined in `autolabel.{label}.trigger_files`:\"\n )\n .unwrap();\n for f in missing_files.iter() {\n writeln!(&mut msg, \"\\t {f}\").unwrap();\n }\n eprintln!(\"{msg}\");\n }\n\n let result = if failed == 0 { \"ok\" } else { \"FAILED\" };\n eprintln!(\"test result: {result}. {passed} passed; {failed} failed;\");\n\n if failed > 0 {\n process::exit(1);\n }\n}\n" }, { "path": "credential/README.md", "content": "# Cargo Credential Packages\n\nThis directory contains Cargo packages for handling storage of tokens in a\nsecure manner.\n\n`cargo-credential` is a generic library to assist writing a credential\nprocess. The other directories contain implementations that integrate with\nspecific credential systems.\n" }, { "path": "credential/cargo-credential/Cargo.toml", "content": "[package]\nname = \"cargo-credential\"\nversion = \"0.4.10\"\nrust-version.workspace = true\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"A library to assist writing Cargo credential helpers.\"\n\n[dependencies]\nanyhow.workspace = true\nserde = { workspace = true, features = [\"derive\"] }\nserde_json.workspace = true\nthiserror.workspace = true\ntime.workspace = true\n\n[target.'cfg(unix)'.dependencies]\nlibc.workspace = true\n\n[target.'cfg(windows)'.dependencies]\nwindows-sys = { workspace = true, features = [\"Win32_System_Console\", \"Win32_Foundation\"] }\n\n[dev-dependencies]\nsnapbox = { workspace = true, features = [\"examples\"] }\n\n[lints]\nworkspace = true\n" }, { "path": "credential/cargo-credential/README.md", "content": "# cargo-credential\n\nThis package is a library to assist writing a Cargo credential helper, which\nprovides an interface to store tokens for authorizing access to a registry\nsuch as https://crates.io/.\n\nDocumentation about credential processes may be found at\nhttps://doc.rust-lang.org/nightly/cargo/reference/credential-provider-protocol.html\n\nExample implementations may be found at\nhttps://github.com/rust-lang/cargo/tree/master/credential\n\n> This crate is maintained by the Cargo team for use by the wider\n> ecosystem. This crate follows semver compatibility for its APIs.\n\n## Usage\n\nCreate a Cargo project with this as a dependency:\n\n```toml\n# Add this to your Cargo.toml:\n\n[dependencies]\ncargo-credential = \"0.4\"\n```\n\nAnd then include a `main.rs` binary which implements the `Credential` trait, and calls\nthe `main` function which will call the appropriate method of the trait:\n\n```rust\n// src/main.rs\n\nuse cargo_credential::{Credential, Error};\n\nstruct MyCredential;\n\nimpl Credential for MyCredential {\n /// implement trait methods here...\n}\n\nfn main() {\n cargo_credential::main(MyCredential);\n}\n```\n" }, { "path": "credential/cargo-credential/examples/file-provider.rs", "content": "//! Example credential provider that stores credentials in a JSON file.\n//! This is not secure\n\nuse cargo_credential::{\n Action, CacheControl, Credential, CredentialResponse, RegistryInfo, Secret,\n};\nuse std::{collections::HashMap, fs::File, io::ErrorKind};\ntype Error = Box;\n\nstruct FileCredential;\n\nimpl Credential for FileCredential {\n fn perform(\n &self,\n registry: &RegistryInfo<'_>,\n action: &Action<'_>,\n _args: &[&str],\n ) -> Result {\n if registry.index_url != \"https://github.com/rust-lang/crates.io-index\" {\n // Restrict this provider to only work for crates.io. Cargo will skip it and attempt\n // another provider for any other registry.\n //\n // If a provider supports any registry, then this check should be omitted.\n return Err(cargo_credential::Error::UrlNotSupported);\n }\n\n // `Error::Other` takes a boxed `std::error::Error` type that causes Cargo to show the error.\n let mut creds = FileCredential::read().map_err(cargo_credential::Error::Other)?;\n\n match action {\n Action::Get(_) => {\n // Cargo requested a token, look it up.\n if let Some(token) = creds.get(registry.index_url) {\n Ok(CredentialResponse::Get {\n token: token.clone(),\n cache: CacheControl::Session,\n operation_independent: true,\n })\n } else {\n // Credential providers should respond with `NotFound` when a credential can not be\n // found, allowing Cargo to attempt another provider.\n Err(cargo_credential::Error::NotFound)\n }\n }\n Action::Login(login_options) => {\n // The token for `cargo login` can come from the `login_options` parameter or i\n // interactively reading from stdin.\n //\n // `cargo_credential::read_token` automatically handles this.\n let token = cargo_credential::read_token(login_options, registry)?;\n creds.insert(registry.index_url.to_string(), token);\n\n FileCredential::write(&creds).map_err(cargo_credential::Error::Other)?;\n\n // Credentials were successfully stored.\n Ok(CredentialResponse::Login)\n }\n Action::Logout => {\n if creds.remove(registry.index_url).is_none() {\n // If the user attempts to log out from a registry that has no credentials\n // stored, then NotFound is the appropriate error.\n Err(cargo_credential::Error::NotFound)\n } else {\n // Credentials were successfully erased.\n Ok(CredentialResponse::Logout)\n }\n }\n // If a credential provider doesn't support a given operation, it should respond with `OperationNotSupported`.\n _ => Err(cargo_credential::Error::OperationNotSupported),\n }\n }\n}\n\nimpl FileCredential {\n fn read() -> Result>, Error> {\n match File::open(\"cargo-credentials.json\") {\n Ok(f) => Ok(serde_json::from_reader(f)?),\n Err(e) if e.kind() == ErrorKind::NotFound => Ok(HashMap::new()),\n Err(e) => Err(e)?,\n }\n }\n fn write(value: &HashMap>) -> Result<(), Error> {\n let file = File::create(\"cargo-credentials.json\")?;\n Ok(serde_json::to_writer_pretty(file, value)?)\n }\n}\n\nfn main() {\n cargo_credential::main(FileCredential);\n}\n" }, { "path": "credential/cargo-credential/examples/stdout-redirected.rs", "content": "//! Provider used for testing redirection of stdout.\n\n#![allow(clippy::print_stderr)]\n#![allow(clippy::print_stdout)]\n\nuse cargo_credential::{Action, Credential, CredentialResponse, Error, RegistryInfo};\n\nstruct MyCredential;\n\nimpl Credential for MyCredential {\n fn perform(\n &self,\n _registry: &RegistryInfo<'_>,\n _action: &Action<'_>,\n _args: &[&str],\n ) -> Result {\n // Informational messages should be sent on stderr.\n eprintln!(\"message on stderr should be sent to the parent process\");\n\n // Reading from stdin and writing to stdout will go to the attached console (tty).\n println!(\"message from test credential provider\");\n Err(Error::OperationNotSupported)\n }\n}\n\nfn main() {\n cargo_credential::main(MyCredential);\n}\n" }, { "path": "credential/cargo-credential/src/error.rs", "content": "use serde::{Deserialize, Serialize};\nuse std::error::Error as StdError;\nuse thiserror::Error as ThisError;\n\n/// Credential provider error type.\n///\n/// `UrlNotSupported` and `NotFound` errors both cause Cargo\n/// to attempt another provider, if one is available. The other\n/// variants are fatal.\n///\n/// Note: Do not add a tuple variant, as it cannot be serialized.\n#[derive(Serialize, Deserialize, ThisError, Debug)]\n#[serde(rename_all = \"kebab-case\", tag = \"kind\")]\n#[non_exhaustive]\npub enum Error {\n /// Registry URL is not supported. This should be used if\n /// the provider only works for some registries. Cargo will\n /// try another provider, if available\n #[error(\"registry not supported\")]\n UrlNotSupported,\n\n /// Credentials could not be found. Cargo will try another\n /// provider, if available\n #[error(\"credential not found\")]\n NotFound,\n\n /// The provider doesn't support this operation, such as\n /// a provider that can't support 'login' / 'logout'\n #[error(\"requested operation not supported\")]\n OperationNotSupported,\n\n /// The provider failed to perform the operation. Other\n /// providers will not be attempted\n #[error(transparent)]\n #[serde(with = \"error_serialize\")]\n Other(Box),\n\n /// A new variant was added to this enum since Cargo was built\n #[error(\"unknown error kind; try updating Cargo?\")]\n #[serde(other)]\n Unknown,\n}\n\nimpl From for Error {\n fn from(message: String) -> Self {\n Box::new(StringTypedError {\n message,\n source: None,\n })\n .into()\n }\n}\n\nimpl From<&str> for Error {\n fn from(err: &str) -> Self {\n err.to_string().into()\n }\n}\n\nimpl From for Error {\n fn from(value: anyhow::Error) -> Self {\n let mut prev = None;\n for e in value.chain().rev() {\n prev = Some(Box::new(StringTypedError {\n message: e.to_string(),\n source: prev,\n }));\n }\n Error::Other(prev.unwrap())\n }\n}\n\nimpl From> for Error {\n fn from(value: Box) -> Self {\n Error::Other(value)\n }\n}\n\n/// String-based error type with an optional source\n#[derive(Debug)]\nstruct StringTypedError {\n message: String,\n source: Option>,\n}\n\nimpl StdError for StringTypedError {\n fn source(&self) -> Option<&(dyn StdError + 'static)> {\n self.source.as_ref().map(|err| err as &dyn StdError)\n }\n}\n\nimpl std::fmt::Display for StringTypedError {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n self.message.fmt(f)\n }\n}\n\n/// Serializer / deserializer for any boxed error.\n/// The string representation of the error, and its `source` chain can roundtrip across\n/// the serialization. The actual types are lost (downcast will not work).\nmod error_serialize {\n use std::error::Error as StdError;\n use std::ops::Deref;\n\n use serde::{Deserialize, Deserializer, Serializer, ser::SerializeStruct};\n\n use crate::error::StringTypedError;\n\n pub fn serialize(\n e: &Box,\n serializer: S,\n ) -> Result\n where\n S: Serializer,\n {\n let mut state = serializer.serialize_struct(\"StringTypedError\", 2)?;\n state.serialize_field(\"message\", &format!(\"{}\", e))?;\n\n // Serialize the source error chain recursively\n let mut current_source: &dyn StdError = e.deref();\n let mut sources = Vec::new();\n while let Some(err) = current_source.source() {\n sources.push(err.to_string());\n current_source = err;\n }\n state.serialize_field(\"caused-by\", &sources)?;\n state.end()\n }\n\n pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error>\n where\n D: Deserializer<'de>,\n {\n #[derive(Deserialize)]\n #[serde(rename_all = \"kebab-case\")]\n struct ErrorData {\n message: String,\n caused_by: Option>,\n }\n let data = ErrorData::deserialize(deserializer)?;\n let mut prev = None;\n if let Some(source) = data.caused_by {\n for e in source.into_iter().rev() {\n prev = Some(Box::new(StringTypedError {\n message: e,\n source: prev,\n }));\n }\n }\n let e = Box::new(StringTypedError {\n message: data.message,\n source: prev,\n });\n Ok(e)\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::Error;\n\n #[test]\n pub fn unknown_kind() {\n let json = r#\"{\n \"kind\": \"unexpected-kind\",\n \"unexpected-content\": \"test\"\n }\"#;\n let e: Error = serde_json::from_str(&json).unwrap();\n assert!(matches!(e, Error::Unknown));\n }\n\n #[test]\n pub fn roundtrip() {\n // Construct an error with context\n let e = anyhow::anyhow!(\"E1\").context(\"E2\").context(\"E3\");\n // Convert to a string with contexts.\n let s1 = format!(\"{:?}\", e);\n // Convert the error into an `Error`\n let e: Error = e.into();\n // Convert that error into JSON\n let json = serde_json::to_string_pretty(&e).unwrap();\n // Convert that error back to anyhow\n let e: anyhow::Error = e.into();\n let s2 = format!(\"{:?}\", e);\n assert_eq!(s1, s2);\n\n // Convert the error back from JSON\n let e: Error = serde_json::from_str(&json).unwrap();\n // Convert to back to anyhow\n let e: anyhow::Error = e.into();\n let s3 = format!(\"{:?}\", e);\n assert_eq!(s2, s3);\n\n assert_eq!(\n r#\"{\n \"kind\": \"other\",\n \"message\": \"E3\",\n \"caused-by\": [\n \"E2\",\n \"E1\"\n ]\n}\"#,\n json\n );\n }\n}\n" }, { "path": "credential/cargo-credential/src/lib.rs", "content": "//! Helper library for writing Cargo credential providers.\n//!\n//! A credential process should have a `struct` that implements the `Credential` trait.\n//! The `main` function should be called with an instance of that struct, such as:\n//!\n//! ```rust,ignore\n//! fn main() {\n//! cargo_credential::main(MyCredential);\n//! }\n//! ```\n//!\n//! While in the `perform` function, stdin and stdout will be re-attached to the\n//! active console. This allows credential providers to be interactive if necessary.\n//!\n//! > This crate is maintained by the Cargo team for use by the wider\n//! > ecosystem. This crate follows semver compatibility for its APIs.\n//!\n//! ## Error handling\n//! ### [`Error::UrlNotSupported`]\n//! A credential provider may only support some registry URLs. If this is the case\n//! and an unsupported index URL is passed to the provider, it should respond with\n//! [`Error::UrlNotSupported`]. Other credential providers may be attempted by Cargo.\n//!\n//! ### [`Error::NotFound`]\n//! When attempting an [`Action::Get`] or [`Action::Logout`], if a credential can not\n//! be found, the provider should respond with [`Error::NotFound`]. Other credential\n//! providers may be attempted by Cargo.\n//!\n//! ### [`Error::OperationNotSupported`]\n//! A credential provider might not support all operations. For example if the provider\n//! only supports [`Action::Get`], [`Error::OperationNotSupported`] should be returned\n//! for all other requests.\n//!\n//! ### [`Error::Other`]\n//! All other errors go here. The error will be shown to the user in Cargo, including\n//! the full error chain using [`std::error::Error::source`].\n//!\n//! ## Example\n//! ```rust,ignore\n#![doc = include_str!(\"../examples/file-provider.rs\")]\n//! ```\n\n#![allow(clippy::print_stderr)]\n#![allow(clippy::print_stdout)]\n\nuse serde::{Deserialize, Serialize};\nuse std::{fmt::Display, io};\nuse time::OffsetDateTime;\n\nmod error;\nmod secret;\nmod stdio;\n\npub use error::Error;\npub use secret::Secret;\nuse stdio::stdin_stdout_to_console;\n\n/// Message sent by the credential helper on startup\n#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]\npub struct CredentialHello {\n // Protocol versions supported by the credential process.\n pub v: Vec,\n}\n\n/// Credential provider that doesn't support any registries.\npub struct UnsupportedCredential;\nimpl Credential for UnsupportedCredential {\n fn perform(\n &self,\n _registry: &RegistryInfo<'_>,\n _action: &Action<'_>,\n _args: &[&str],\n ) -> Result {\n Err(Error::UrlNotSupported)\n }\n}\n\n/// Message sent by Cargo to the credential helper after the hello\n#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]\n#[serde(rename_all = \"kebab-case\")]\npub struct CredentialRequest<'a> {\n // Cargo will respond with the highest common protocol supported by both.\n pub v: u32,\n #[serde(borrow)]\n pub registry: RegistryInfo<'a>,\n #[serde(borrow, flatten)]\n pub action: Action<'a>,\n /// Additional command-line arguments passed to the credential provider.\n #[serde(skip_serializing_if = \"Vec::is_empty\", default)]\n pub args: Vec<&'a str>,\n}\n\n#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]\n#[serde(rename_all = \"kebab-case\")]\npub struct RegistryInfo<'a> {\n /// Registry index url\n pub index_url: &'a str,\n /// Name of the registry in configuration. May not be available.\n /// The crates.io registry will be `crates-io` (`CRATES_IO_REGISTRY`).\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub name: Option<&'a str>,\n /// Headers from attempting to access a registry that resulted in a HTTP 401.\n #[serde(skip_serializing_if = \"Vec::is_empty\", default)]\n pub headers: Vec,\n}\n\n#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]\n#[non_exhaustive]\n#[serde(tag = \"kind\", rename_all = \"kebab-case\")]\npub enum Action<'a> {\n #[serde(borrow)]\n Get(Operation<'a>),\n Login(LoginOptions<'a>),\n Logout,\n #[serde(other)]\n Unknown,\n}\n\nimpl<'a> Display for Action<'a> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n match self {\n Action::Get(_) => f.write_str(\"get\"),\n Action::Login(_) => f.write_str(\"login\"),\n Action::Logout => f.write_str(\"logout\"),\n Action::Unknown => f.write_str(\"\"),\n }\n }\n}\n\n#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]\n#[serde(rename_all = \"kebab-case\")]\npub struct LoginOptions<'a> {\n /// Token passed on the command line via --token or from stdin\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub token: Option>,\n /// Optional URL that the user can visit to log in to the registry\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub login_url: Option<&'a str>,\n}\n\n/// A record of what kind of operation is happening that we should generate a token for.\n#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]\n#[non_exhaustive]\n#[serde(tag = \"operation\", rename_all = \"kebab-case\")]\npub enum Operation<'a> {\n /// The user is attempting to fetch a crate.\n Read,\n /// The user is attempting to publish a crate.\n Publish {\n /// The name of the crate\n name: &'a str,\n /// The version of the crate\n vers: &'a str,\n /// The checksum of the crate file being uploaded\n cksum: &'a str,\n },\n /// The user is attempting to yank a crate.\n Yank {\n /// The name of the crate\n name: &'a str,\n /// The version of the crate\n vers: &'a str,\n },\n /// The user is attempting to unyank a crate.\n Unyank {\n /// The name of the crate\n name: &'a str,\n /// The version of the crate\n vers: &'a str,\n },\n /// The user is attempting to modify the owners of a crate.\n Owners {\n /// The name of the crate\n name: &'a str,\n },\n #[serde(other)]\n Unknown,\n}\n\n/// Message sent by the credential helper\n#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]\n#[serde(tag = \"kind\", rename_all = \"kebab-case\")]\n#[non_exhaustive]\npub enum CredentialResponse {\n Get {\n token: Secret,\n #[serde(flatten)]\n cache: CacheControl,\n operation_independent: bool,\n },\n Login,\n Logout,\n #[serde(other)]\n Unknown,\n}\n\n#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]\n#[serde(tag = \"cache\", rename_all = \"kebab-case\")]\n#[non_exhaustive]\npub enum CacheControl {\n /// Do not cache this result.\n Never,\n /// Cache this result and use it for subsequent requests in the current Cargo invocation until the specified time.\n Expires {\n #[serde(with = \"time::serde::timestamp\")]\n expiration: OffsetDateTime,\n },\n /// Cache this result and use it for all subsequent requests in the current Cargo invocation.\n Session,\n #[serde(other)]\n Unknown,\n}\n\n/// Credential process JSON protocol version.\n///\n/// If the protocol needs to make\n/// a breaking change, a new protocol version should be defined (`PROTOCOL_VERSION_2`).\n/// This library should offer support for both protocols if possible, by signaling\n/// in the `CredentialHello` message. Cargo will then choose which protocol to use,\n/// or it will error if there are no common protocol versions available.\npub const PROTOCOL_VERSION_1: u32 = 1;\npub trait Credential {\n /// Retrieves a token for the given registry.\n fn perform(\n &self,\n registry: &RegistryInfo<'_>,\n action: &Action<'_>,\n args: &[&str],\n ) -> Result;\n}\n\n/// Runs the credential interaction\npub fn main(credential: impl Credential) {\n let result = doit(credential).map_err(|e| Error::Other(e));\n if result.is_err() {\n serde_json::to_writer(std::io::stdout(), &result)\n .expect(\"failed to serialize credential provider error\");\n println!();\n }\n}\n\nfn doit(\n credential: impl Credential,\n) -> Result<(), Box> {\n let hello = CredentialHello {\n v: vec![PROTOCOL_VERSION_1],\n };\n serde_json::to_writer(std::io::stdout(), &hello)?;\n println!();\n\n loop {\n let mut buffer = String::new();\n let len = std::io::stdin().read_line(&mut buffer)?;\n if len == 0 {\n return Ok(());\n }\n let request = deserialize_request(&buffer)?;\n let response = stdin_stdout_to_console(|| {\n credential.perform(&request.registry, &request.action, &request.args)\n })?;\n\n serde_json::to_writer(std::io::stdout(), &response)?;\n println!();\n }\n}\n\n/// Deserialize a request from Cargo.\nfn deserialize_request(\n value: &str,\n) -> Result, Box> {\n let request: CredentialRequest<'_> = serde_json::from_str(&value)?;\n if request.v != PROTOCOL_VERSION_1 {\n return Err(format!(\"unsupported protocol version {}\", request.v).into());\n }\n Ok(request)\n}\n\n/// Read a line of text from stdin.\npub fn read_line() -> Result {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf)?;\n Ok(buf.trim().to_string())\n}\n\n/// Prompt the user for a token.\npub fn read_token(\n login_options: &LoginOptions<'_>,\n registry: &RegistryInfo<'_>,\n) -> Result, Error> {\n if let Some(token) = &login_options.token {\n return Ok(token.to_owned());\n }\n\n if let Some(url) = login_options.login_url {\n eprintln!(\"please paste the token found on {url} below\");\n } else if let Some(name) = registry.name {\n eprintln!(\"please paste the token for {name} below\");\n } else {\n eprintln!(\"please paste the token for {} below\", registry.index_url);\n }\n\n Ok(Secret::from(read_line().map_err(Box::new)?))\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn unsupported_version() {\n // This shouldn't ever happen in practice, since the credential provider signals to Cargo which\n // protocol versions it supports, and Cargo should only attempt to use one of those.\n let msg = r#\"{\"v\":999, \"registry\": {\"index-url\":\"\"}, \"args\":[], \"kind\": \"unexpected\"}\"#;\n assert_eq!(\n \"unsupported protocol version 999\",\n deserialize_request(msg).unwrap_err().to_string()\n );\n }\n\n #[test]\n fn cache_control() {\n let cc = CacheControl::Expires {\n expiration: OffsetDateTime::from_unix_timestamp(1693928537).unwrap(),\n };\n let json = serde_json::to_string(&cc).unwrap();\n assert_eq!(json, r#\"{\"cache\":\"expires\",\"expiration\":1693928537}\"#);\n\n let cc = CacheControl::Session;\n let json = serde_json::to_string(&cc).unwrap();\n assert_eq!(json, r#\"{\"cache\":\"session\"}\"#);\n\n let cc: CacheControl = serde_json::from_str(r#\"{\"cache\":\"unknown-kind\"}\"#).unwrap();\n assert_eq!(cc, CacheControl::Unknown);\n\n assert_eq!(\n \"missing field `expiration`\",\n serde_json::from_str::(r#\"{\"cache\":\"expires\"}\"#)\n .unwrap_err()\n .to_string()\n );\n }\n\n #[test]\n fn credential_response() {\n let cr = CredentialResponse::Get {\n cache: CacheControl::Never,\n operation_independent: true,\n token: Secret::from(\"value\".to_string()),\n };\n let json = serde_json::to_string(&cr).unwrap();\n assert_eq!(\n json,\n r#\"{\"kind\":\"get\",\"token\":\"value\",\"cache\":\"never\",\"operation_independent\":true}\"#\n );\n\n let cr = CredentialResponse::Login;\n let json = serde_json::to_string(&cr).unwrap();\n assert_eq!(json, r#\"{\"kind\":\"login\"}\"#);\n\n let cr: CredentialResponse =\n serde_json::from_str(r#\"{\"kind\":\"unknown-kind\",\"extra-data\":true}\"#).unwrap();\n assert_eq!(cr, CredentialResponse::Unknown);\n\n let cr: CredentialResponse =\n serde_json::from_str(r#\"{\"kind\":\"login\",\"extra-data\":true}\"#).unwrap();\n assert_eq!(cr, CredentialResponse::Login);\n\n let cr: CredentialResponse = serde_json::from_str(r#\"{\"kind\":\"get\",\"token\":\"value\",\"cache\":\"never\",\"operation_independent\":true,\"extra-field-ignored\":123}\"#).unwrap();\n assert_eq!(\n cr,\n CredentialResponse::Get {\n cache: CacheControl::Never,\n operation_independent: true,\n token: Secret::from(\"value\".to_string())\n }\n );\n }\n\n #[test]\n fn credential_request() {\n let get_oweners = CredentialRequest {\n v: PROTOCOL_VERSION_1,\n args: vec![],\n registry: RegistryInfo {\n index_url: \"url\",\n name: None,\n headers: vec![],\n },\n action: Action::Get(Operation::Owners { name: \"pkg\" }),\n };\n\n let json = serde_json::to_string(&get_oweners).unwrap();\n assert_eq!(\n json,\n r#\"{\"v\":1,\"registry\":{\"index-url\":\"url\"},\"kind\":\"get\",\"operation\":\"owners\",\"name\":\"pkg\"}\"#\n );\n\n let cr: CredentialRequest<'_> =\n serde_json::from_str(r#\"{\"extra-1\":true,\"v\":1,\"registry\":{\"index-url\":\"url\",\"extra-2\":true},\"kind\":\"get\",\"operation\":\"owners\",\"name\":\"pkg\",\"args\":[]}\"#).unwrap();\n assert_eq!(cr, get_oweners);\n }\n\n #[test]\n fn credential_request_logout() {\n let unknown = CredentialRequest {\n v: PROTOCOL_VERSION_1,\n args: vec![],\n registry: RegistryInfo {\n index_url: \"url\",\n name: None,\n headers: vec![],\n },\n action: Action::Logout,\n };\n\n let cr: CredentialRequest<'_> = serde_json::from_str(\n r#\"{\"v\":1,\"registry\":{\"index-url\":\"url\"},\"kind\":\"logout\",\"extra-1\":true,\"args\":[]}\"#,\n )\n .unwrap();\n assert_eq!(cr, unknown);\n }\n\n #[test]\n fn credential_request_unknown() {\n let unknown = CredentialRequest {\n v: PROTOCOL_VERSION_1,\n args: vec![],\n registry: RegistryInfo {\n index_url: \"\",\n name: None,\n headers: vec![],\n },\n action: Action::Unknown,\n };\n\n let cr: CredentialRequest<'_> = serde_json::from_str(\n r#\"{\"v\":1,\"registry\":{\"index-url\":\"\"},\"kind\":\"unexpected-1\",\"extra-1\":true,\"args\":[]}\"#,\n )\n .unwrap();\n assert_eq!(cr, unknown);\n }\n}\n" }, { "path": "credential/cargo-credential/src/secret.rs", "content": "use std::fmt;\nuse std::ops::Deref;\n\nuse serde::{Deserialize, Serialize};\n\n/// A wrapper for values that should not be printed.\n///\n/// This type does not implement `Display`, and has a `Debug` impl that hides\n/// the contained value.\n///\n/// ```\n/// # use cargo_credential::Secret;\n/// let token = Secret::from(\"super secret string\");\n/// assert_eq!(format!(\"{:?}\", token), \"Secret { inner: \\\"REDACTED\\\" }\");\n/// ```\n///\n/// Currently, we write a borrowed `Secret` as `Secret<&T>`.\n/// The [`as_deref`](Secret::as_deref) and [`to_owned`](Secret::to_owned) methods can\n/// be used to convert back and forth between `Secret` and `Secret<&str>`.\n#[derive(Default, Clone, PartialEq, Eq, Serialize, Deserialize)]\n#[serde(transparent)]\npub struct Secret {\n inner: T,\n}\n\nimpl Secret {\n /// Unwraps the contained value.\n ///\n /// Use of this method marks the boundary of where the contained value is\n /// hidden.\n pub fn expose(self) -> T {\n self.inner\n }\n\n /// Converts a `Secret` to a `Secret<&T::Target>`.\n /// ```\n /// # use cargo_credential::Secret;\n /// let owned: Secret = Secret::from(String::from(\"token\"));\n /// let borrowed: Secret<&str> = owned.as_deref();\n /// ```\n pub fn as_deref(&self) -> Secret<&::Target>\n where\n T: Deref,\n {\n Secret::from(self.inner.deref())\n }\n\n /// Converts a `Secret` to a `Secret<&T>`.\n pub fn as_ref(&self) -> Secret<&T> {\n Secret::from(&self.inner)\n }\n\n /// Converts a `Secret` to a `Secret` by applying `f` to the contained value.\n pub fn map(self, f: F) -> Secret\n where\n F: FnOnce(T) -> U,\n {\n Secret::from(f(self.inner))\n }\n}\n\nimpl Secret<&T> {\n /// Converts a `Secret` containing a borrowed type to a `Secret` containing the\n /// corresponding owned type.\n /// ```\n /// # use cargo_credential::Secret;\n /// let borrowed: Secret<&str> = Secret::from(\"token\");\n /// let owned: Secret = borrowed.to_owned();\n /// ```\n pub fn to_owned(&self) -> Secret<::Owned> {\n Secret::from(self.inner.to_owned())\n }\n}\n\nimpl Secret> {\n /// Converts a `Secret>` to a `Result, E>`.\n pub fn transpose(self) -> Result, E> {\n self.inner.map(|v| Secret::from(v))\n }\n}\n\nimpl> Secret {\n /// Checks if the contained value is empty.\n pub fn is_empty(&self) -> bool {\n self.inner.as_ref().is_empty()\n }\n}\n\nimpl From for Secret {\n fn from(inner: T) -> Self {\n Self { inner }\n }\n}\n\nimpl fmt::Debug for Secret {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n f.debug_struct(\"Secret\")\n .field(\"inner\", &\"REDACTED\")\n .finish()\n }\n}\n" }, { "path": "credential/cargo-credential/src/stdio.rs", "content": "use std::{fs::File, io::Error};\n\n/// Reset stdin and stdout to the attached console / tty for the duration of the closure.\n/// If no console is available, stdin and stdout will be redirected to null.\npub fn stdin_stdout_to_console(f: F) -> Result\nwhere\n F: FnOnce() -> T,\n{\n let open_write = |f| std::fs::OpenOptions::new().write(true).open(f);\n\n let mut stdin = File::open(imp::IN_DEVICE).or_else(|_| File::open(imp::NULL_DEVICE))?;\n let mut stdout = open_write(imp::OUT_DEVICE).or_else(|_| open_write(imp::NULL_DEVICE))?;\n\n let _stdin_guard = imp::ReplacementGuard::new(Stdio::Stdin, &mut stdin)?;\n let _stdout_guard = imp::ReplacementGuard::new(Stdio::Stdout, &mut stdout)?;\n Ok(f())\n}\n\nenum Stdio {\n Stdin,\n Stdout,\n}\n\n#[cfg(windows)]\nmod imp {\n use super::Stdio;\n use std::{fs::File, io::Error, os::windows::prelude::AsRawHandle};\n use windows_sys::Win32::{\n Foundation::{HANDLE, INVALID_HANDLE_VALUE},\n System::Console::{\n GetStdHandle, STD_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, SetStdHandle,\n },\n };\n pub const OUT_DEVICE: &str = \"CONOUT$\";\n pub const IN_DEVICE: &str = \"CONIN$\";\n pub const NULL_DEVICE: &str = \"NUL\";\n\n /// Restores previous stdio when dropped.\n pub struct ReplacementGuard {\n std_handle: STD_HANDLE,\n previous: HANDLE,\n }\n\n impl ReplacementGuard {\n pub(super) fn new(stdio: Stdio, replacement: &mut File) -> Result {\n let std_handle = match stdio {\n Stdio::Stdin => STD_INPUT_HANDLE,\n Stdio::Stdout => STD_OUTPUT_HANDLE,\n };\n\n let previous;\n unsafe {\n // Make a copy of the current handle\n previous = GetStdHandle(std_handle);\n if previous == INVALID_HANDLE_VALUE {\n return Err(std::io::Error::last_os_error());\n }\n\n // Replace stdin with the replacement handle\n if SetStdHandle(std_handle, replacement.as_raw_handle() as HANDLE) == 0 {\n return Err(std::io::Error::last_os_error());\n }\n }\n\n Ok(ReplacementGuard {\n previous,\n std_handle,\n })\n }\n }\n\n impl Drop for ReplacementGuard {\n fn drop(&mut self) {\n unsafe {\n // Put previous handle back in to stdin\n SetStdHandle(self.std_handle, self.previous);\n }\n }\n }\n}\n\n#[cfg(unix)]\nmod imp {\n use super::Stdio;\n use libc::{STDIN_FILENO, STDOUT_FILENO, close, dup, dup2};\n use std::{fs::File, io::Error, os::fd::AsRawFd};\n pub const IN_DEVICE: &str = \"/dev/tty\";\n pub const OUT_DEVICE: &str = \"/dev/tty\";\n pub const NULL_DEVICE: &str = \"/dev/null\";\n\n /// Restores previous stdio when dropped.\n pub struct ReplacementGuard {\n std_fileno: i32,\n previous: i32,\n }\n\n impl ReplacementGuard {\n pub(super) fn new(stdio: Stdio, replacement: &mut File) -> Result {\n let std_fileno = match stdio {\n Stdio::Stdin => STDIN_FILENO,\n Stdio::Stdout => STDOUT_FILENO,\n };\n\n let previous;\n unsafe {\n // Duplicate the existing stdin file to a new descriptor\n previous = dup(std_fileno);\n if previous == -1 {\n return Err(std::io::Error::last_os_error());\n }\n // Replace stdin with the replacement file\n if dup2(replacement.as_raw_fd(), std_fileno) == -1 {\n return Err(std::io::Error::last_os_error());\n }\n }\n\n Ok(ReplacementGuard {\n previous,\n std_fileno,\n })\n }\n }\n\n impl Drop for ReplacementGuard {\n fn drop(&mut self) {\n unsafe {\n // Put previous file back in to stdin\n dup2(self.previous, self.std_fileno);\n // Close the file descriptor we used as a backup\n close(self.previous);\n }\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n use std::fs::OpenOptions;\n use std::io::{Seek, Write};\n\n use super::Stdio;\n use super::imp::ReplacementGuard;\n\n #[test]\n fn stdin() {\n let tempdir = snapbox::dir::DirRoot::mutable_temp().unwrap();\n let file = tempdir.path().unwrap().join(\"stdin\");\n let mut file = OpenOptions::new()\n .read(true)\n .write(true)\n .create(true)\n .open(file)\n .unwrap();\n\n writeln!(&mut file, \"hello\").unwrap();\n file.seek(std::io::SeekFrom::Start(0)).unwrap();\n {\n let _guard = ReplacementGuard::new(Stdio::Stdin, &mut file).unwrap();\n let line = std::io::stdin().lines().next().unwrap().unwrap();\n assert_eq!(line, \"hello\");\n }\n }\n}\n" }, { "path": "credential/cargo-credential/tests/examples.rs", "content": "use std::path::Path;\n\nuse snapbox::cmd::Command;\nuse snapbox::prelude::*;\n\n#[test]\nfn stdout_redirected() {\n let bin = snapbox::cmd::compile_example(\"stdout-redirected\", []).unwrap();\n\n let hello = r#\"{\"v\":[1]}\"#;\n let get_request = r#\"{\"v\": 1, \"registry\": {\"index-url\":\"sparse+https://test/\",\"name\":\"alternative\"},\"kind\": \"get\",\"operation\": \"read\",\"args\": []}\"#;\n let err_not_supported = r#\"{\"Err\":{\"kind\":\"operation-not-supported\"}}\"#;\n\n Command::new(bin)\n .stdin(format!(\"{get_request}\\n\"))\n .arg(\"--cargo-plugin\")\n .assert()\n .stdout_eq(format!(\"{hello}\\n{err_not_supported}\\n\").raw())\n .stderr_eq(\"message on stderr should be sent to the parent process\\n\".raw())\n .success();\n}\n\n#[test]\nfn file_provider() {\n let bin = snapbox::cmd::compile_example(\"file-provider\", []).unwrap();\n\n let hello = r#\"{\"v\":[1]}\"#;\n let login_request = r#\"{\"v\": 1,\"registry\": {\"index-url\":\"https://github.com/rust-lang/crates.io-index\",\"name\":\"crates-io\"},\"kind\": \"login\",\"token\": \"s3krit\",\"args\": []}\"#;\n let login_response = r#\"{\"Ok\":{\"kind\":\"login\"}}\"#;\n\n let get_request = r#\"{\"v\": 1,\"registry\": {\"index-url\":\"https://github.com/rust-lang/crates.io-index\",\"name\":\"crates-io\"},\"kind\": \"get\",\"operation\": \"read\",\"args\": []}\"#;\n let get_response =\n r#\"{\"Ok\":{\"kind\":\"get\",\"token\":\"s3krit\",\"cache\":\"session\",\"operation_independent\":true}}\"#;\n\n let dir = Path::new(env!(\"CARGO_TARGET_TMPDIR\")).join(\"cargo-credential-tests\");\n std::fs::create_dir(&dir).unwrap();\n Command::new(bin)\n .current_dir(&dir)\n .stdin(format!(\"{login_request}\\n{get_request}\\n\"))\n .arg(\"--cargo-plugin\")\n .assert()\n .stdout_eq(format!(\"{hello}\\n{login_response}\\n{get_response}\\n\").raw())\n .stderr_eq(\"\".raw())\n .success();\n std::fs::remove_dir_all(&dir).unwrap();\n}\n" }, { "path": "credential/cargo-credential-1password/Cargo.toml", "content": "[package]\nname = \"cargo-credential-1password\"\nversion = \"0.4.6\"\nrust-version.workspace = true\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"A Cargo credential process that stores tokens in a 1password vault.\"\n\n[dependencies]\ncargo-credential.workspace = true\nserde = { workspace = true, features = [\"derive\"] }\nserde_json.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "credential/cargo-credential-1password/README.md", "content": "# cargo-credential-1password\n\nA Cargo [credential provider] for [1password].\n\n> This crate is maintained by the Cargo team as a part of an experiment around\n> 1password integration. We encourage people to try to use this crate in their projects and\n> provide feedback through [issues](https://github.com/rust-lang/cargo/issues/), but do not\n> guarantee long term maintenance.\n\n## Usage\n\n`cargo-credential-1password` uses the 1password `op` CLI to store the token. You\nmust install the `op` CLI from the [1password\nwebsite](https://1password.com/downloads/command-line/).\n\nAfterward you need to configure `cargo` to use `cargo-credential-1password` as\nthe credential provider. You can do this by adding something like the following\nto your [cargo config file][credential provider]:\n\n```toml\n[registry]\nglobal-credential-providers = [\"cargo-credential-1password --account my.1password.com\"]\n```\n\nFinally, run `cargo login` to save your registry token in 1password.\n\n## CLI Arguments\n\n`cargo-credential-1password` supports the following command-line arguments:\n\n* `--account`: The account name to use. For a list of available accounts, \n run `op account list`.\n* `--vault`: The vault name to use. For a list of available vaults,\n run `op vault list`.\n\n[1password]: https://1password.com/\n[credential provider]: https://doc.rust-lang.org/stable/cargo/reference/registry-authentication.html\n" }, { "path": "credential/cargo-credential-1password/src/main.rs", "content": "//! Cargo registry 1password credential process.\n//!\n//! > This crate is maintained by the Cargo team as a part of an experiment around\n//! > 1password integration. We encourage people to try to use this crate in their projects and\n//! > provide feedback through [issues](https://github.com/rust-lang/cargo/issues/), but do not\n//! > guarantee long term maintenance.\n\n#![allow(clippy::disallowed_methods)]\n#![allow(clippy::print_stderr)]\n\nuse cargo_credential::{\n Action, CacheControl, Credential, CredentialResponse, Error, RegistryInfo, Secret,\n};\nuse serde::Deserialize;\nuse std::io::Read;\nuse std::process::{Command, Stdio};\n\nconst CARGO_TAG: &str = \"cargo-registry\";\n\n/// Implementation of 1password keychain access for Cargo registries.\nstruct OnePasswordKeychain {\n account: Option,\n vault: Option,\n}\n\n/// 1password Login item type, used for the JSON output of `op item get`.\n#[derive(Deserialize)]\nstruct Login {\n fields: Vec,\n}\n\n#[derive(Deserialize)]\nstruct Field {\n id: String,\n value: Option,\n}\n\n/// 1password item from `op items list`.\n#[derive(Deserialize)]\nstruct ListItem {\n id: String,\n urls: Vec,\n}\n\n#[derive(Deserialize)]\nstruct Url {\n href: String,\n}\n\nimpl OnePasswordKeychain {\n fn new(args: &[&str]) -> Result {\n let mut args = args.iter();\n let mut action = false;\n let mut account = None;\n let mut vault = None;\n while let Some(arg) = args.next() {\n match *arg {\n \"--account\" => {\n account = Some(args.next().ok_or(\"--account needs an arg\")?);\n }\n \"--vault\" => {\n vault = Some(args.next().ok_or(\"--vault needs an arg\")?);\n }\n s if s.starts_with('-') => {\n return Err(format!(\"unknown option {}\", s).into());\n }\n _ => {\n if action {\n return Err(\"too many arguments\".into());\n } else {\n action = true;\n }\n }\n }\n }\n Ok(OnePasswordKeychain {\n account: account.map(|s| s.to_string()),\n vault: vault.map(|s| s.to_string()),\n })\n }\n\n fn signin(&self) -> Result, Error> {\n // If there are any session env vars, we'll assume that this is the\n // correct account, and that the user knows what they are doing.\n if std::env::vars().any(|(name, _)| name.starts_with(\"OP_SESSION_\")) {\n return Ok(None);\n }\n let mut cmd = Command::new(\"op\");\n cmd.args([\"signin\", \"--raw\"]);\n if let Some(account) = &self.account {\n cmd.arg(\"--account\");\n cmd.arg(account);\n }\n cmd.stdout(Stdio::piped());\n let mut child = cmd\n .spawn()\n .map_err(|e| format!(\"failed to spawn `op`: {}\", e))?;\n let mut buffer = String::new();\n child\n .stdout\n .as_mut()\n .unwrap()\n .read_to_string(&mut buffer)\n .map_err(|e| format!(\"failed to get session from `op`: {}\", e))?;\n if let Some(end) = buffer.find('\\n') {\n buffer.truncate(end);\n }\n let status = child\n .wait()\n .map_err(|e| format!(\"failed to wait for `op`: {}\", e))?;\n if !status.success() {\n return Err(format!(\"failed to run `op signin`: {}\", status).into());\n }\n if buffer.is_empty() {\n // When using CLI integration, `op signin` returns no output,\n // so there is no need to set the session.\n return Ok(None);\n }\n Ok(Some(buffer))\n }\n\n fn make_cmd(&self, session: &Option, args: &[&str]) -> Command {\n let mut cmd = Command::new(\"op\");\n cmd.args(args);\n if let Some(account) = &self.account {\n cmd.arg(\"--account\");\n cmd.arg(account);\n }\n if let Some(vault) = &self.vault {\n cmd.arg(\"--vault\");\n cmd.arg(vault);\n }\n if let Some(session) = session {\n cmd.arg(\"--session\");\n cmd.arg(session);\n }\n cmd\n }\n\n fn run_cmd(&self, mut cmd: Command) -> Result {\n cmd.stdout(Stdio::piped());\n let mut child = cmd\n .spawn()\n .map_err(|e| format!(\"failed to spawn `op`: {}\", e))?;\n let mut buffer = String::new();\n child\n .stdout\n .as_mut()\n .unwrap()\n .read_to_string(&mut buffer)\n .map_err(|e| format!(\"failed to read `op` output: {}\", e))?;\n let status = child\n .wait()\n .map_err(|e| format!(\"failed to wait for `op`: {}\", e))?;\n if !status.success() {\n return Err(format!(\"`op` command exit error: {}\", status).into());\n }\n Ok(buffer)\n }\n\n fn search(&self, session: &Option, index_url: &str) -> Result, Error> {\n let cmd = self.make_cmd(\n session,\n &[\n \"items\",\n \"list\",\n \"--categories\",\n \"Login\",\n \"--tags\",\n CARGO_TAG,\n \"--format\",\n \"json\",\n ],\n );\n let buffer = self.run_cmd(cmd)?;\n let items: Vec = serde_json::from_str(&buffer)\n .map_err(|e| format!(\"failed to deserialize JSON from 1password list: {}\", e))?;\n let mut matches = items\n .into_iter()\n .filter(|item| item.urls.iter().any(|url| url.href == index_url));\n match matches.next() {\n Some(login) => {\n // Should this maybe just sort on `updatedAt` and return the newest one?\n if matches.next().is_some() {\n return Err(format!(\n \"too many 1password logins match registry `{}`, \\\n consider deleting the excess entries\",\n index_url\n )\n .into());\n }\n Ok(Some(login.id))\n }\n None => Ok(None),\n }\n }\n\n fn modify(\n &self,\n session: &Option,\n id: &str,\n token: Secret<&str>,\n _name: Option<&str>,\n ) -> Result<(), Error> {\n let cmd = self.make_cmd(\n session,\n &[\"item\", \"edit\", id, &format!(\"password={}\", token.expose())],\n );\n self.run_cmd(cmd)?;\n Ok(())\n }\n\n fn create(\n &self,\n session: &Option,\n index_url: &str,\n token: Secret<&str>,\n name: Option<&str>,\n ) -> Result<(), Error> {\n let title = match name {\n Some(name) => format!(\"Cargo registry token for {}\", name),\n None => \"Cargo registry token\".to_string(),\n };\n let cmd = self.make_cmd(\n session,\n &[\n \"item\",\n \"create\",\n \"--category\",\n \"Login\",\n &format!(\"password={}\", token.expose()),\n &format!(\"url={}\", index_url),\n \"--title\",\n &title,\n \"--tags\",\n CARGO_TAG,\n ],\n );\n self.run_cmd(cmd)?;\n Ok(())\n }\n\n fn get_token(&self, session: &Option, id: &str) -> Result, Error> {\n let cmd = self.make_cmd(session, &[\"item\", \"get\", \"--format=json\", id]);\n let buffer = self.run_cmd(cmd)?;\n let item: Login = serde_json::from_str(&buffer)\n .map_err(|e| format!(\"failed to deserialize JSON from 1password get: {}\", e))?;\n let password = item.fields.into_iter().find(|item| item.id == \"password\");\n match password {\n Some(password) => password\n .value\n .map(Secret::from)\n .ok_or(\"missing password value for entry\".into()),\n None => Err(\"could not find password field\".into()),\n }\n }\n\n fn delete(&self, session: &Option, id: &str) -> Result<(), Error> {\n let cmd = self.make_cmd(session, &[\"item\", \"delete\", id]);\n self.run_cmd(cmd)?;\n Ok(())\n }\n}\n\npub struct OnePasswordCredential {}\n\nimpl Credential for OnePasswordCredential {\n fn perform(\n &self,\n registry: &RegistryInfo<'_>,\n action: &Action<'_>,\n args: &[&str],\n ) -> Result {\n let op = OnePasswordKeychain::new(args)?;\n match action {\n Action::Get(_) => {\n let session = op.signin()?;\n if let Some(id) = op.search(&session, registry.index_url)? {\n op.get_token(&session, &id)\n .map(|token| CredentialResponse::Get {\n token,\n cache: CacheControl::Session,\n operation_independent: true,\n })\n } else {\n Err(Error::NotFound)\n }\n }\n Action::Login(options) => {\n let session = op.signin()?;\n // Check if an item already exists.\n if let Some(id) = op.search(&session, registry.index_url)? {\n eprintln!(\"note: token already exists for `{}`\", registry.index_url);\n let token = cargo_credential::read_token(options, registry)?;\n op.modify(&session, &id, token.as_deref(), None)?;\n } else {\n let token = cargo_credential::read_token(options, registry)?;\n op.create(&session, registry.index_url, token.as_deref(), None)?;\n }\n Ok(CredentialResponse::Login)\n }\n Action::Logout => {\n let session = op.signin()?;\n // Check if an item already exists.\n if let Some(id) = op.search(&session, registry.index_url)? {\n op.delete(&session, &id)?;\n Ok(CredentialResponse::Logout)\n } else {\n Err(Error::NotFound)\n }\n }\n _ => Err(Error::OperationNotSupported),\n }\n }\n}\n\nfn main() {\n cargo_credential::main(OnePasswordCredential {});\n}\n" }, { "path": "credential/cargo-credential-libsecret/Cargo.toml", "content": "[package]\nname = \"cargo-credential-libsecret\"\nversion = \"0.5.7\"\nrust-version = \"1.94\" # MSRV:1\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"A Cargo credential process that stores tokens with GNOME libsecret.\"\n\n[dependencies]\nanyhow.workspace = true\ncargo-credential.workspace = true\nlibloading.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "credential/cargo-credential-libsecret/README.md", "content": "# cargo-credential-libsecret\n\nThis is the implementation for the Cargo credential helper for [GNOME libsecret].\nSee the [credential-provider] documentation for how to use this.\n\nThis credential provider is built-in to cargo as `cargo:libsecret`.\n\n> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use (except as a transitive dependency). This\n> crate may make major changes to its APIs or be deprecated without warning.\n\n[GNOME libsecret]: https://wiki.gnome.org/Projects/Libsecret\n[credential-provider]: https://doc.rust-lang.org/nightly/cargo/reference/registry-authentication.html\n" }, { "path": "credential/cargo-credential-libsecret/src/lib.rs", "content": "//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use (except as a transitive dependency). This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\n#[cfg(target_os = \"linux\")]\nmod linux {\n //! Implementation of the libsecret credential helper.\n\n use anyhow::Context;\n use cargo_credential::{\n Action, CacheControl, Credential, CredentialResponse, Error, RegistryInfo, Secret,\n read_token,\n };\n use libloading::{Library, Symbol};\n use std::ffi::{CStr, CString};\n use std::os::raw::{c_char, c_int};\n use std::ptr::{null, null_mut};\n\n #[allow(non_camel_case_types)]\n type gchar = c_char;\n\n #[allow(non_camel_case_types)]\n type gboolean = c_int;\n\n #[allow(non_camel_case_types)]\n type gint = c_int;\n\n #[allow(non_camel_case_types)]\n type gpointer = *mut ();\n\n type GQuark = u32;\n\n #[repr(C)]\n struct GError {\n domain: GQuark,\n code: c_int,\n message: *mut gchar,\n }\n\n #[repr(C)]\n struct GCancellable {\n _private: [u8; 0],\n }\n\n #[repr(C)]\n struct SecretSchema {\n name: *const gchar,\n flags: SecretSchemaFlags,\n attributes: [SecretSchemaAttribute; 32],\n reserved: gint,\n reserved1: gpointer,\n reserved2: gpointer,\n reserved3: gpointer,\n reserved4: gpointer,\n reserved5: gpointer,\n reserved6: gpointer,\n reserved7: gpointer,\n }\n\n #[repr(C)]\n #[derive(Copy, Clone)]\n struct SecretSchemaAttribute {\n name: *const gchar,\n attr_type: SecretSchemaAttributeType,\n }\n\n #[repr(C)]\n enum SecretSchemaFlags {\n None = 0,\n }\n\n #[repr(C)]\n #[derive(Copy, Clone)]\n enum SecretSchemaAttributeType {\n String = 0,\n }\n\n type SecretPasswordStoreSync = extern \"C\" fn(\n schema: *const SecretSchema,\n collection: *const gchar,\n label: *const gchar,\n password: *const gchar,\n cancellable: *mut GCancellable,\n error: *mut *mut GError,\n ...\n ) -> gboolean;\n type SecretPasswordClearSync = extern \"C\" fn(\n schema: *const SecretSchema,\n cancellable: *mut GCancellable,\n error: *mut *mut GError,\n ...\n ) -> gboolean;\n type SecretPasswordLookupSync = extern \"C\" fn(\n schema: *const SecretSchema,\n cancellable: *mut GCancellable,\n error: *mut *mut GError,\n ...\n ) -> *mut gchar;\n\n pub struct LibSecretCredential {\n libsecret: Library,\n }\n\n fn label(index_url: &str) -> CString {\n CString::new(format!(\"cargo-registry:{}\", index_url)).unwrap()\n }\n\n fn schema() -> SecretSchema {\n let mut attributes = [SecretSchemaAttribute {\n name: null(),\n attr_type: SecretSchemaAttributeType::String,\n }; 32];\n attributes[0] = SecretSchemaAttribute {\n name: c\"url\".as_ptr() as *const gchar,\n attr_type: SecretSchemaAttributeType::String,\n };\n SecretSchema {\n name: c\"org.rust-lang.cargo.registry\".as_ptr() as *const gchar,\n flags: SecretSchemaFlags::None,\n attributes,\n reserved: 0,\n reserved1: null_mut(),\n reserved2: null_mut(),\n reserved3: null_mut(),\n reserved4: null_mut(),\n reserved5: null_mut(),\n reserved6: null_mut(),\n reserved7: null_mut(),\n }\n }\n\n impl LibSecretCredential {\n pub fn new() -> Result {\n // Dynamically load libsecret to avoid users needing to install\n // additional -dev packages when building this provider.\n let libsecret = unsafe { Library::new(\"libsecret-1.so.0\") }.context(\n \"failed to load libsecret: try installing the `libsecret` \\\n or `libsecret-1-0` package with the system package manager\",\n )?;\n Ok(Self { libsecret })\n }\n }\n\n impl Credential for &LibSecretCredential {\n fn perform(\n &self,\n registry: &RegistryInfo<'_>,\n action: &Action<'_>,\n _args: &[&str],\n ) -> Result {\n let secret_password_lookup_sync: Symbol<'_, SecretPasswordLookupSync>;\n let secret_password_store_sync: Symbol<'_, SecretPasswordStoreSync>;\n let secret_password_clear_sync: Symbol<'_, SecretPasswordClearSync>;\n unsafe {\n secret_password_lookup_sync = self\n .libsecret\n .get(b\"secret_password_lookup_sync\\0\")\n .map_err(Box::new)?;\n secret_password_store_sync = self\n .libsecret\n .get(b\"secret_password_store_sync\\0\")\n .map_err(Box::new)?;\n secret_password_clear_sync = self\n .libsecret\n .get(b\"secret_password_clear_sync\\0\")\n .map_err(Box::new)?;\n }\n\n let index_url_c = CString::new(registry.index_url).unwrap();\n let mut error: *mut GError = null_mut();\n let attr_url = c\"url\".as_ptr() as *const gchar;\n let schema = schema();\n match action {\n cargo_credential::Action::Get(_) => unsafe {\n let token_c = secret_password_lookup_sync(\n &schema,\n null_mut(),\n &mut error,\n attr_url,\n index_url_c.as_ptr(),\n null() as *const gchar,\n );\n if !error.is_null() {\n return Err(format!(\n \"failed to get token: {}\",\n CStr::from_ptr((*error).message)\n .to_str()\n .unwrap_or_default()\n )\n .into());\n }\n if token_c.is_null() {\n return Err(Error::NotFound);\n }\n let token = Secret::from(\n CStr::from_ptr(token_c)\n .to_str()\n .map_err(|e| format!(\"expected utf8 token: {}\", e))?\n .to_string(),\n );\n Ok(CredentialResponse::Get {\n token,\n cache: CacheControl::Session,\n operation_independent: true,\n })\n },\n cargo_credential::Action::Login(options) => {\n let label = label(registry.name.unwrap_or(registry.index_url));\n let token = CString::new(read_token(options, registry)?.expose()).unwrap();\n unsafe {\n secret_password_store_sync(\n &schema,\n c\"default\".as_ptr() as *const gchar,\n label.as_ptr(),\n token.as_ptr(),\n null_mut(),\n &mut error,\n attr_url,\n index_url_c.as_ptr(),\n null() as *const gchar,\n );\n if !error.is_null() {\n return Err(format!(\n \"failed to store token: {}\",\n CStr::from_ptr((*error).message)\n .to_str()\n .unwrap_or_default()\n )\n .into());\n }\n }\n Ok(CredentialResponse::Login)\n }\n cargo_credential::Action::Logout => {\n unsafe {\n secret_password_clear_sync(\n &schema,\n null_mut(),\n &mut error,\n attr_url,\n index_url_c.as_ptr(),\n null() as *const gchar,\n );\n if !error.is_null() {\n return Err(format!(\n \"failed to erase token: {}\",\n CStr::from_ptr((*error).message)\n .to_str()\n .unwrap_or_default()\n )\n .into());\n }\n }\n Ok(CredentialResponse::Logout)\n }\n _ => Err(Error::OperationNotSupported),\n }\n }\n }\n}\n\n#[cfg(not(target_os = \"linux\"))]\npub use cargo_credential::UnsupportedCredential as LibSecretCredential;\n#[cfg(target_os = \"linux\")]\npub use linux::LibSecretCredential;\n" }, { "path": "credential/cargo-credential-macos-keychain/Cargo.toml", "content": "[package]\nname = \"cargo-credential-macos-keychain\"\nversion = \"0.4.22\"\nrust-version = \"1.94\" # MSRV:1\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"A Cargo credential process that stores tokens in a macOS keychain.\"\n\n[dependencies]\ncargo-credential.workspace = true\n\n[target.'cfg(target_os = \"macos\")'.dependencies]\nsecurity-framework.workspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "credential/cargo-credential-macos-keychain/README.md", "content": "# cargo-credential-macos-keychain\n\nThis is the implementation for the Cargo credential helper for [macOS Keychain].\nSee the [credential-provider] documentation for how to use this.\n\nThis credential provider is built-in to cargo as `cargo:macos-keychain`.\n\n> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use (except as a transitive dependency). This\n> crate may make major changes to its APIs or be deprecated without warning.\n\n[macOS Keychain]: https://support.apple.com/guide/keychain-access/welcome/mac\n[credential-provider]: https://doc.rust-lang.org/nightly/cargo/reference/registry-authentication.html\n\n" }, { "path": "credential/cargo-credential-macos-keychain/src/lib.rs", "content": "//! Cargo registry macos keychain credential process.\n//!\n//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use (except as a transitive dependency). This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\n#![allow(clippy::print_stderr)]\n\n#[cfg(target_os = \"macos\")]\nmod macos {\n use cargo_credential::{\n Action, CacheControl, Credential, CredentialResponse, Error, RegistryInfo, read_token,\n };\n use security_framework::os::macos::keychain::SecKeychain;\n\n pub struct MacKeychain;\n\n /// The account name is not used.\n const ACCOUNT: &'static str = \"\";\n const NOT_FOUND: i32 = -25300; // errSecItemNotFound\n\n fn registry(index_url: &str) -> String {\n format!(\"cargo-registry:{}\", index_url)\n }\n\n impl Credential for MacKeychain {\n fn perform(\n &self,\n reg: &RegistryInfo<'_>,\n action: &Action<'_>,\n _args: &[&str],\n ) -> Result {\n let keychain = SecKeychain::default().unwrap();\n let service_name = registry(reg.index_url);\n let not_found = security_framework::base::Error::from(NOT_FOUND).code();\n match action {\n Action::Get(_) => match keychain.find_generic_password(&service_name, ACCOUNT) {\n Err(e) if e.code() == not_found => Err(Error::NotFound),\n Err(e) => Err(Box::new(e).into()),\n Ok((pass, _)) => {\n let token = String::from_utf8(pass.as_ref().to_vec()).map_err(Box::new)?;\n Ok(CredentialResponse::Get {\n token: token.into(),\n cache: CacheControl::Session,\n operation_independent: true,\n })\n }\n },\n Action::Login(options) => {\n let token = read_token(options, reg)?;\n match keychain.find_generic_password(&service_name, ACCOUNT) {\n Err(e) => {\n if e.code() == not_found {\n keychain\n .add_generic_password(\n &service_name,\n ACCOUNT,\n token.expose().as_bytes(),\n )\n .map_err(Box::new)?;\n }\n }\n Ok((_, mut item)) => {\n item.set_password(token.expose().as_bytes())\n .map_err(Box::new)?;\n }\n }\n Ok(CredentialResponse::Login)\n }\n Action::Logout => match keychain.find_generic_password(&service_name, ACCOUNT) {\n Err(e) if e.code() == not_found => Err(Error::NotFound),\n Err(e) => Err(Box::new(e).into()),\n Ok((_, item)) => {\n item.delete();\n Ok(CredentialResponse::Logout)\n }\n },\n _ => Err(Error::OperationNotSupported),\n }\n }\n }\n}\n\n#[cfg(not(target_os = \"macos\"))]\npub use cargo_credential::UnsupportedCredential as MacKeychain;\n#[cfg(target_os = \"macos\")]\npub use macos::MacKeychain;\n" }, { "path": "credential/cargo-credential-wincred/Cargo.toml", "content": "[package]\nname = \"cargo-credential-wincred\"\nversion = \"0.4.22\"\nrust-version = \"1.94\" # MSRV:1\nedition.workspace = true\nlicense.workspace = true\nrepository.workspace = true\ndescription = \"A Cargo credential process that stores tokens with Windows Credential Manager.\"\n\n[dependencies]\ncargo-credential.workspace = true\n\n[target.'cfg(windows)'.dependencies.windows-sys]\nfeatures = [\"Win32_Foundation\", \"Win32_Security_Credentials\"]\nworkspace = true\n\n[lints]\nworkspace = true\n" }, { "path": "credential/cargo-credential-wincred/README.md", "content": "# cargo-credential-wincred\n\nThis is the implementation for the Cargo credential helper for [Windows Credential Manager].\nSee the [credential-provider] documentation for how to use this.\n\nThis credential provider is built-in to cargo as `cargo:wincred`.\n\n> This crate is maintained by the Cargo team, primarily for use by Cargo\n> and not intended for external use (except as a transitive dependency). This\n> crate may make major changes to its APIs or be deprecated without warning.\n\n[Windows Credential Manager]: https://support.microsoft.com/en-us/windows/accessing-credential-manager-1b5c916a-6a16-889f-8581-fc16e8165ac0\n[credential-provider]: https://doc.rust-lang.org/nightly/cargo/reference/registry-authentication.html\n" }, { "path": "credential/cargo-credential-wincred/src/lib.rs", "content": "//! Cargo registry windows credential process.\n//!\n//! > This crate is maintained by the Cargo team, primarily for use by Cargo\n//! > and not intended for external use (except as a transitive dependency). This\n//! > crate may make major changes to its APIs or be deprecated without warning.\n\n#[cfg(windows)]\nmod win {\n use cargo_credential::{Action, CacheControl, CredentialResponse, RegistryInfo, read_token};\n use cargo_credential::{Credential, Error};\n use std::ffi::OsStr;\n\n use std::os::windows::ffi::OsStrExt;\n\n use windows_sys::Win32::Foundation::ERROR_NOT_FOUND;\n use windows_sys::Win32::Foundation::FILETIME;\n use windows_sys::Win32::Foundation::TRUE;\n use windows_sys::Win32::Security::Credentials::CRED_PERSIST_LOCAL_MACHINE;\n use windows_sys::Win32::Security::Credentials::CRED_TYPE_GENERIC;\n use windows_sys::Win32::Security::Credentials::CREDENTIALW;\n use windows_sys::Win32::Security::Credentials::CredReadW;\n use windows_sys::Win32::Security::Credentials::CredWriteW;\n use windows_sys::Win32::Security::Credentials::{CredDeleteW, CredFree};\n use windows_sys::core::PWSTR;\n\n pub struct WindowsCredential;\n\n /// Converts a string to a nul-terminated wide UTF-16 byte sequence.\n fn wstr(s: &str) -> Vec {\n let mut wide: Vec = OsStr::new(s).encode_wide().collect();\n if wide.iter().any(|b| *b == 0) {\n panic!(\"nul byte in wide string\");\n }\n wide.push(0);\n wide\n }\n\n fn target_name(index_url: &str) -> Vec {\n wstr(&format!(\"cargo-registry:{}\", index_url))\n }\n\n impl Credential for WindowsCredential {\n fn perform(\n &self,\n registry: &RegistryInfo<'_>,\n action: &Action<'_>,\n _args: &[&str],\n ) -> Result {\n match action {\n Action::Get(_) => {\n let target_name = target_name(registry.index_url);\n let mut p_credential: *mut CREDENTIALW = std::ptr::null_mut() as *mut _;\n let bytes = unsafe {\n if CredReadW(\n target_name.as_ptr(),\n CRED_TYPE_GENERIC,\n 0,\n &mut p_credential as *mut _,\n ) != TRUE\n {\n let err = std::io::Error::last_os_error();\n if err.raw_os_error() == Some(ERROR_NOT_FOUND as i32) {\n return Err(Error::NotFound);\n }\n return Err(Box::new(err).into());\n }\n std::slice::from_raw_parts(\n (*p_credential).CredentialBlob,\n (*p_credential).CredentialBlobSize as usize,\n )\n };\n let token = String::from_utf8(bytes.to_vec()).map_err(Box::new);\n unsafe { CredFree(p_credential as *mut _) };\n Ok(CredentialResponse::Get {\n token: token?.into(),\n cache: CacheControl::Session,\n operation_independent: true,\n })\n }\n Action::Login(options) => {\n let token = read_token(options, registry)?.expose();\n let target_name = target_name(registry.index_url);\n let comment = wstr(\"Cargo registry token\");\n let credential = CREDENTIALW {\n Flags: 0,\n Type: CRED_TYPE_GENERIC,\n TargetName: target_name.as_ptr() as PWSTR,\n Comment: comment.as_ptr() as PWSTR,\n LastWritten: FILETIME {\n dwLowDateTime: 0,\n dwHighDateTime: 0,\n },\n CredentialBlobSize: token.len() as u32,\n CredentialBlob: token.as_bytes().as_ptr() as *mut u8,\n Persist: CRED_PERSIST_LOCAL_MACHINE,\n AttributeCount: 0,\n Attributes: std::ptr::null_mut(),\n TargetAlias: std::ptr::null_mut(),\n UserName: std::ptr::null_mut(),\n };\n let result = unsafe { CredWriteW(&credential, 0) };\n if result != TRUE {\n let err = std::io::Error::last_os_error();\n return Err(Box::new(err).into());\n }\n Ok(CredentialResponse::Login)\n }\n Action::Logout => {\n let target_name = target_name(registry.index_url);\n let result = unsafe { CredDeleteW(target_name.as_ptr(), CRED_TYPE_GENERIC, 0) };\n if result != TRUE {\n let err = std::io::Error::last_os_error();\n if err.raw_os_error() == Some(ERROR_NOT_FOUND as i32) {\n return Err(Error::NotFound);\n }\n return Err(Box::new(err).into());\n }\n Ok(CredentialResponse::Logout)\n }\n _ => Err(Error::OperationNotSupported),\n }\n }\n }\n}\n\n#[cfg(not(windows))]\npub use cargo_credential::UnsupportedCredential as WindowsCredential;\n#[cfg(windows)]\npub use win::WindowsCredential;\n" }, { "path": "deny.toml", "content": "# This template contains all of the possible sections and their default values\n\n# Note that all fields that take a lint level have these possible values:\n# * deny - An error will be produced and the check will fail\n# * warn - A warning will be produced, but the check will not fail\n# * allow - No warning or error will be produced, though in some cases a note\n# will be\n\n# The values provided in this template are the default values that will be used\n# when any section or field is not specified in your own configuration\n\n# Root options\n\n# The graph table configures how the dependency graph is constructed and thus\n# which crates the checks are performed against\n[graph]\n# If 1 or more target triples (and optionally, target_features) are specified,\n# only the specified targets will be checked when running `cargo deny check`.\n# This means, if a particular package is only ever used as a target specific\n# dependency, such as, for example, the `nix` crate only being used via the\n# `target_family = \"unix\"` configuration, that only having windows targets in\n# this list would mean the nix crate, as well as any of its exclusive\n# dependencies not shared by any other crates, would be ignored, as the target\n# list here is effectively saying which targets you are building for.\ntargets = [\n # The triple can be any string, but only the target triples built in to\n # rustc (as of 1.40) can be checked against actual config expressions\n #\"x86_64-unknown-linux-musl\",\n # You can also specify which target_features you promise are enabled for a\n # particular target. target_features are currently not validated against\n # the actual valid features supported by the target architecture.\n #{ triple = \"wasm32-unknown-unknown\", features = [\"atomics\"] },\n]\n# When creating the dependency graph used as the source of truth when checks are\n# executed, this field can be used to prune crates from the graph, removing them\n# from the view of cargo-deny. This is an extremely heavy hammer, as if a crate\n# is pruned from the graph, all of its dependencies will also be pruned unless\n# they are connected to another crate in the graph that hasn't been pruned,\n# so it should be used with care. The identifiers are [Package ID Specifications]\n# (https://doc.rust-lang.org/cargo/reference/pkgid-spec.html)\n#exclude = []\n# If true, metadata will be collected with `--all-features`. Note that this can't\n# be toggled off if true, if you want to conditionally enable `--all-features` it\n# is recommended to pass `--all-features` on the cmd line instead\nall-features = false\n# If true, metadata will be collected with `--no-default-features`. The same\n# caveat with `all-features` applies\nno-default-features = false\n# If set, these feature will be enabled when collecting metadata. If `--features`\n# is specified on the cmd line they will take precedence over this option.\n#features = []\n\n# The output table provides options for how/if diagnostics are outputted\n[output]\n# When outputting inclusion graphs in diagnostics that include features, this\n# option can be used to specify the depth at which feature edges will be added.\n# This option is included since the graphs can be quite large and the addition\n# of features from the crate(s) to all of the graph roots can be far too verbose.\n# This option can be overridden via `--feature-depth` on the cmd line\nfeature-depth = 1\n\n# This section is considered when running `cargo deny check advisories`\n# More documentation for the advisories section can be found here:\n# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html\n[advisories]\n# The path where the advisory databases are cloned/fetched into\n#db-path = \"$CARGO_HOME/advisory-dbs\"\n# The url(s) of the advisory databases to use\n#db-urls = [\"https://github.com/rustsec/advisory-db\"]\nyanked = \"warn\"\n# A list of advisory IDs to ignore. Note that ignored advisories will still\n# output a note when they are encountered.\nignore = [\n #\"RUSTSEC-0000-0000\",\n #{ id = \"RUSTSEC-0000-0000\", reason = \"you can specify a reason the advisory is ignored\" },\n #\"a-crate-that-is-yanked@0.1.1\", # you can also ignore yanked crate versions if you wish\n #{ crate = \"a-crate-that-is-yanked@0.1.1\", reason = \"you can specify why you are ignoring the yanked crate\" },\n]\n# If this is true, then cargo deny will use the git executable to fetch advisory database.\n# If this is false, then it uses a built-in git library.\n# Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.\n# See Git Authentication for more information about setting up git authentication.\n#git-fetch-with-cli = true\n\n# This section is considered when running `cargo deny check licenses`\n# More documentation for the licenses section can be found here:\n# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html\n[licenses]\n# List of explicitly allowed licenses\n# See https://spdx.org/licenses/ for list of possible licenses\n# [possible values: any SPDX 3.11 short identifier (+ optional exception)].\nallow = [\n \"MIT\",\n \"MIT-0\",\n \"Apache-2.0\",\n \"BSD-2-Clause\",\n \"BSD-3-Clause\",\n \"MPL-2.0\",\n \"Unicode-3.0\",\n \"CC0-1.0\",\n \"ISC\",\n \"Zlib\",\n]\n# The confidence threshold for detecting a license from license text.\n# The higher the value, the more closely the license text must be to the\n# canonical license text of a valid SPDX license file.\n# [possible values: any between 0.0 and 1.0].\nconfidence-threshold = 0.8\n# Allow 1 or more licenses on a per-crate basis, so that particular licenses\n# aren't accepted for every possible crate as with the normal allow list\nexceptions = [\n # Each entry is the crate and version constraint, and its specific allow\n # list\n #{ allow = [\"Zlib\"], crate = \"adler32\" },\n]\n\n# Some crates don't have (easily) machine readable licensing information,\n# adding a clarification entry for it allows you to manually specify the\n# licensing information\n#[[licenses.clarify]]\n# The package spec the clarification applies to\n#crate = \"ring\"\n# The SPDX expression for the license requirements of the crate\n#expression = \"MIT AND ISC AND OpenSSL\"\n# One or more files in the crate's source used as the \"source of truth\" for\n# the license expression. If the contents match, the clarification will be used\n# when running the license check, otherwise the clarification will be ignored\n# and the crate will be checked normally, which may produce warnings or errors\n# depending on the rest of your configuration\n#license-files = [\n# Each entry is a crate relative path, and the (opaque) hash of its contents\n#{ path = \"LICENSE\", hash = 0xbd0eed23 }\n#]\n\n[licenses.private]\n# If true, ignores workspace crates that aren't published, or are only\n# published to private registries.\n# To see how to mark a crate as unpublished (to the official registry),\n# visit https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field.\nignore = false\n# One or more private registries that you might publish crates to, if a crate\n# is only published to private registries, and ignore is true, the crate will\n# not have its license(s) checked\nregistries = [\n #\"https://sekretz.com/registry\n]\n\n# This section is considered when running `cargo deny check bans`.\n# More documentation about the 'bans' section can be found here:\n# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html\n[bans]\n# Lint level for when multiple versions of the same crate are detected\nmultiple-versions = \"warn\"\n# Lint level for when a crate version requirement is `*`\nwildcards = \"allow\"\n# The graph highlighting used when creating dotgraphs for crates\n# with multiple versions\n# * lowest-version - The path to the lowest versioned duplicate is highlighted\n# * simplest-path - The path to the version with the fewest edges is highlighted\n# * all - Both lowest-version and simplest-path are used\nhighlight = \"all\"\n# The default lint level for `default` features for crates that are members of\n# the workspace that is being checked. This can be overridden by allowing/denying\n# `default` on a crate-by-crate basis if desired.\nworkspace-default-features = \"allow\"\n# The default lint level for `default` features for external crates that are not\n# members of the workspace. This can be overridden by allowing/denying `default`\n# on a crate-by-crate basis if desired.\nexternal-default-features = \"allow\"\n# List of crates that are allowed. Use with care!\nallow = [\n #\"ansi_term@0.11.0\",\n #{ crate = \"ansi_term@0.11.0\", reason = \"you can specify a reason it is allowed\" },\n]\n# List of crates to deny\ndeny = [\n #\"ansi_term@0.11.0\",\n #{ crate = \"ansi_term@0.11.0\", reason = \"you can specify a reason it is banned\" },\n # Wrapper crates can optionally be specified to allow the crate when it\n # is a direct dependency of the otherwise banned crate\n #{ crate = \"ansi_term@0.11.0\", wrappers = [\"this-crate-directly-depends-on-ansi_term\"] },\n]\n\n# List of features to allow/deny\n# Each entry the name of a crate and a version range. If version is\n# not specified, all versions will be matched.\n#[[bans.features]]\n#crate = \"reqwest\"\n# Features to not allow\n#deny = [\"json\"]\n# Features to allow\n#allow = [\n# \"rustls\",\n# \"__rustls\",\n# \"__tls\",\n# \"hyper-rustls\",\n# \"rustls\",\n# \"rustls-pemfile\",\n# \"rustls-tls-webpki-roots\",\n# \"tokio-rustls\",\n# \"webpki-roots\",\n#]\n# If true, the allowed features must exactly match the enabled feature set. If\n# this is set there is no point setting `deny`\n#exact = true\n\n# Certain crates/versions that will be skipped when doing duplicate detection.\nskip = [\n #\"ansi_term@0.11.0\",\n #{ crate = \"ansi_term@0.11.0\", reason = \"you can specify a reason why it can't be updated/removed\" },\n]\n# Similarly to `skip` allows you to skip certain crates during duplicate\n# detection. Unlike skip, it also includes the entire tree of transitive\n# dependencies starting at the specified crate, up to a certain depth, which is\n# by default infinite.\nskip-tree = [\n #\"ansi_term@0.11.0\", # will be skipped along with _all_ of its direct and transitive dependencies\n #{ crate = \"ansi_term@0.11.0\", depth = 20 },\n]\n\n# This section is considered when running `cargo deny check sources`.\n# More documentation about the 'sources' section can be found here:\n# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html\n[sources]\n# Lint level for what to happen when a crate from a crate registry that is not\n# in the allow list is encountered\nunknown-registry = \"warn\"\n# Lint level for what to happen when a crate from a git repository that is not\n# in the allow list is encountered\nunknown-git = \"warn\"\n# List of URLs for allowed crate registries. Defaults to the crates.io index\n# if not specified. If it is specified but empty, no registries are allowed.\nallow-registry = [\"https://github.com/rust-lang/crates.io-index\"]\n# List of URLs for allowed Git repositories\nallow-git = []\n\n[sources.allow-org]\n# github.com organizations to allow git sources for\ngithub = []\n# gitlab.com organizations to allow git sources for\ngitlab = []\n# bitbucket.org organizations to allow git sources for\nbitbucket = []\n" }, { "path": "publish.py", "content": "#!/usr/bin/env python3\n\n# This script is used to publish Cargo to crates.io.\n#\n# This is run automatically every 6 weeks by the Release team's automation\n# whose source is at https://github.com/rust-lang/simpleinfra/.\n#\n# See https://doc.crates.io/contrib/process/release.html for more about\n# Cargo's release process.\n\nimport os\nimport re\nimport subprocess\nimport urllib.request\nfrom urllib.error import HTTPError\n\n\n# Whenever you add a new crate to this list that does NOT start with \"cargo-\"\n# you must reach out to the infra team to add the crate to the list of crates\n# allowed to be published from the \"cargo CI\" crates.io token.\nTO_PUBLISH = [\n 'credential/cargo-credential',\n 'credential/cargo-credential-libsecret',\n 'credential/cargo-credential-wincred',\n 'credential/cargo-credential-1password',\n 'credential/cargo-credential-macos-keychain',\n 'crates/rustfix',\n 'crates/cargo-platform',\n 'crates/cargo-util',\n 'crates/crates-io',\n 'crates/cargo-util-schemas',\n 'crates/cargo-test-macro',\n 'crates/cargo-test-support',\n 'crates/build-rs',\n '.',\n]\n\n\ndef already_published(name, version):\n url = f'https://static.crates.io/crates/{name}/{version}/download'\n try:\n urllib.request.urlopen(url)\n except HTTPError as e:\n # 403 and 404 are common responses to assume it is not published\n if 400 <= e.code < 500:\n return False\n print(f'error: failed to check if {name} {version} is already published')\n print(f' HTTP response error code {e.code} checking {url}')\n raise\n return True\n\n\ndef maybe_publish(path):\n content = open(os.path.join(path, 'Cargo.toml')).read()\n name = re.search('^name = \"([^\"]+)\"', content, re.M).group(1)\n version = re.search('^version = \"([^\"]+)\"', content, re.M).group(1)\n if already_published(name, version):\n print('%s %s is already published, skipping' % (name, version))\n return False\n subprocess.check_call(['cargo', 'publish', '--no-verify'], cwd=path)\n return True\n\n\ndef main():\n print('Starting publish...')\n for path in TO_PUBLISH:\n maybe_publish(path)\n\n print('Publish complete!')\n\n\nif __name__ == '__main__':\n main()\n" }, { "path": "rustfmt.toml", "content": "style_edition = \"2024\"\n" }, { "path": "src/bin/cargo/cli.rs", "content": "use annotate_snippets::Level;\nuse anyhow::{Context as _, anyhow};\nuse cargo::core::{CliUnstable, features};\nuse cargo::util::context::TermConfig;\nuse cargo::{CargoResult, drop_print, drop_println};\nuse clap::builder::UnknownArgumentValueParser;\nuse itertools::Itertools;\nuse std::collections::HashMap;\nuse std::ffi::OsStr;\nuse std::ffi::OsString;\nuse std::fmt::Write;\n\nuse super::commands;\nuse super::list_commands;\nuse super::third_party_subcommands;\nuse super::user_defined_aliases;\nuse crate::command_prelude::*;\nuse crate::util::is_rustup;\nuse cargo::core::shell::ColorChoice;\nuse cargo::util::style;\n\n#[tracing::instrument(skip_all)]\npub fn main(gctx: &mut GlobalContext) -> CliResult {\n // CAUTION: Be careful with using `config` until it is configured below.\n // In general, try to avoid loading config values unless necessary (like\n // the [alias] table).\n\n let args = cli(gctx).try_get_matches()?;\n\n // Update the process-level notion of cwd\n if let Some(new_cwd) = args.get_one::(\"directory\") {\n // This is a temporary hack.\n // This cannot access `GlobalContext`, so this is a bit messy.\n // This does not properly parse `-Z` flags that appear after the subcommand.\n // The error message is not as helpful as the standard one.\n let nightly_features_allowed = matches!(&*features::channel(), \"nightly\" | \"dev\");\n if !nightly_features_allowed\n || (nightly_features_allowed\n && !args\n .get_many(\"unstable-features\")\n .map(|mut z| z.any(|value: &String| value == \"unstable-options\"))\n .unwrap_or(false))\n {\n return Err(anyhow::format_err!(\n \"the `-C` flag is unstable, \\\n pass `-Z unstable-options` on the nightly channel to enable it\"\n )\n .into());\n }\n std::env::set_current_dir(&new_cwd).context(\"could not change to requested directory\")?;\n gctx.reload_cwd()?;\n }\n\n let (expanded_args, global_args) = expand_aliases(gctx, args, vec![])?;\n\n let is_verbose = expanded_args.verbose() > 0;\n\n if expanded_args\n .get_one::(\"unstable-features\")\n .map(String::as_str)\n == Some(\"help\")\n {\n // Don't let config errors get in the way of parsing arguments\n let _ = configure_gctx(gctx, &expanded_args, None, global_args, None);\n print_zhelp(gctx);\n } else if expanded_args.flag(\"version\") {\n // Don't let config errors get in the way of parsing arguments\n let _ = configure_gctx(gctx, &expanded_args, None, global_args, None);\n let version = get_version_string(is_verbose);\n drop_print!(gctx, \"{}\", version);\n } else if let Some(code) = expanded_args.get_one::(\"explain\") {\n // Don't let config errors get in the way of parsing arguments\n let _ = configure_gctx(gctx, &expanded_args, None, global_args, None);\n let mut process = gctx.load_global_rustc(None)?.process();\n process.arg(\"--explain\").arg(code).exec()?;\n } else if expanded_args.flag(\"list\") {\n // Don't let config errors get in the way of parsing arguments\n let _ = configure_gctx(gctx, &expanded_args, None, global_args, None);\n print_list(gctx, is_verbose);\n } else {\n let (cmd, subcommand_args) = match expanded_args.subcommand() {\n Some((cmd, args)) => (cmd, args),\n _ => {\n // No subcommand provided.\n cli(gctx).print_help()?;\n return Ok(());\n }\n };\n let exec = Exec::infer(cmd)?;\n configure_gctx(\n gctx,\n &expanded_args,\n Some(subcommand_args),\n global_args,\n Some(&exec),\n )?;\n super::init_git(gctx);\n\n exec.exec(gctx, subcommand_args)?;\n }\n Ok(())\n}\n\nfn print_zhelp(gctx: &GlobalContext) {\n let header = style::HEADER;\n let literal = style::LITERAL;\n let placeholder = style::PLACEHOLDER;\n\n let options = CliUnstable::help();\n let max_length = options\n .iter()\n .filter(|(_, help)| help.is_some())\n .map(|(option_name, _)| option_name.len())\n .max()\n .unwrap_or(0);\n let z_flags = options\n .iter()\n .filter(|(_, help)| help.is_some())\n .map(|(opt, help)| {\n let opt = opt.replace(\"_\", \"-\");\n let help = help.unwrap();\n format!(\" {literal}-Z {opt:Installed Commands:\")\n );\n for (name, command) in list_commands(gctx) {\n let known_external_desc = known_external_command_descriptions.get(name.as_str());\n let literal = style::LITERAL;\n match command {\n CommandInfo::BuiltIn { about } => {\n assert!(\n known_external_desc.is_none(),\n \"known_external_commands shouldn't contain builtin `{name}`\",\n );\n let summary = about.unwrap_or_default();\n let summary = summary.lines().next().unwrap_or(&summary); // display only the first line\n drop_println!(gctx, \" {literal}{name:<20}{literal:#} {summary}\");\n }\n CommandInfo::External { path } => {\n if let Some(desc) = known_external_desc {\n drop_println!(gctx, \" {literal}{name:<20}{literal:#} {desc}\");\n } else if is_verbose {\n drop_println!(\n gctx,\n \" {literal}{name:<20}{literal:#} {}\",\n path.display()\n );\n } else {\n drop_println!(gctx, \" {literal}{name}{literal:#}\");\n }\n }\n CommandInfo::Alias { target } => {\n drop_println!(\n gctx,\n \" {literal}{name:<20}{literal:#} alias: {}\",\n target.iter().join(\" \")\n );\n }\n }\n }\n}\n\npub fn get_version_string(is_verbose: bool) -> String {\n let version = cargo::version();\n let mut version_string = format!(\"cargo {}\\n\", version);\n if is_verbose {\n version_string.push_str(&format!(\"release: {}\\n\", version.version));\n if let Some(ref ci) = version.commit_info {\n version_string.push_str(&format!(\"commit-hash: {}\\n\", ci.commit_hash));\n version_string.push_str(&format!(\"commit-date: {}\\n\", ci.commit_date));\n }\n writeln!(version_string, \"host: {}\", env!(\"RUST_HOST_TARGET\")).unwrap();\n add_libgit2(&mut version_string);\n add_curl(&mut version_string);\n add_ssl(&mut version_string);\n writeln!(version_string, \"os: {}\", os_info::get()).unwrap();\n }\n version_string\n}\n\nfn add_libgit2(version_string: &mut String) {\n let git2_v = git2::Version::get();\n let lib_v = git2_v.libgit2_version();\n let vendored = if git2_v.vendored() {\n format!(\"vendored\")\n } else {\n format!(\"system\")\n };\n writeln!(\n version_string,\n \"libgit2: {}.{}.{} (sys:{} {})\",\n lib_v.0,\n lib_v.1,\n lib_v.2,\n git2_v.crate_version(),\n vendored\n )\n .unwrap();\n}\n\nfn add_curl(version_string: &mut String) {\n let curl_v = curl::Version::get();\n let vendored = if curl_v.vendored() {\n format!(\"vendored\")\n } else {\n format!(\"system\")\n };\n writeln!(\n version_string,\n \"libcurl: {} (sys:{} {} ssl:{})\",\n curl_v.version(),\n curl_sys::rust_crate_version(),\n vendored,\n curl_v.ssl_version().unwrap_or(\"none\")\n )\n .unwrap();\n}\n\nfn add_ssl(version_string: &mut String) {\n #[cfg(feature = \"openssl\")]\n {\n writeln!(version_string, \"ssl: {}\", openssl::version::version()).unwrap();\n }\n #[cfg(not(feature = \"openssl\"))]\n {\n let _ = version_string; // Silence unused warning.\n }\n}\n\n/// Expands aliases recursively to collect all the command line arguments.\n///\n/// [`GlobalArgs`] need to be extracted before expanding aliases because the\n/// clap code for extracting a subcommand discards global options\n/// (appearing before the subcommand).\n#[tracing::instrument(skip_all)]\nfn expand_aliases(\n gctx: &mut GlobalContext,\n args: ArgMatches,\n mut already_expanded: Vec,\n) -> Result<(ArgMatches, GlobalArgs), CliError> {\n if let Some((cmd, sub_args)) = args.subcommand() {\n let exec = commands::builtin_exec(cmd);\n let aliased_cmd = super::aliased_command(gctx, cmd);\n\n match (exec, aliased_cmd) {\n (Some(_), Ok(Some(_))) => {\n // User alias conflicts with a built-in subcommand\n gctx.shell().warn(format!(\n \"user-defined alias `{}` is ignored, because it is shadowed by a built-in command\",\n cmd,\n ))?;\n }\n (Some(_), Ok(None) | Err(_)) => {\n // Here we ignore errors from aliasing as we already favor built-in command,\n // and alias doesn't involve in this context.\n\n if let Some(values) = sub_args.get_many::(\"\") {\n // Command is built-in and is not conflicting with alias, but contains ignored values.\n return Err(anyhow::format_err!(\n \"\\\ntrailing arguments after built-in command `{}` are unsupported: `{}`\n\nTo pass the arguments to the subcommand, remove `--`\",\n cmd,\n values.map(|s| s.to_string_lossy()).join(\" \"),\n )\n .into());\n }\n }\n (None, Ok(None)) => {}\n (None, Ok(Some(alias))) => {\n // Check if a user-defined alias is shadowing an external subcommand\n // (binary of the form `cargo-`)\n // Currently this is only a warning, but after a transition period this will become\n // a hard error.\n if super::builtin_aliases_execs(cmd).is_none() {\n if let Some(path) = super::find_external_subcommand(gctx, cmd) {\n gctx.shell().print_report(\n &[\n Level::WARNING.secondary_title(format!(\n \"user-defined alias `{}` is shadowing an external subcommand found at `{}`\",\n cmd,\n path.display()\n )).element(\n Level::NOTE.message(\n \"this was previously accepted but will become a hard error in the future; \\\n see \"\n )\n )\n ],\n false,\n )?;\n }\n }\n if commands::run::is_manifest_command(cmd) {\n if gctx.cli_unstable().script {\n return Ok((args, GlobalArgs::default()));\n } else {\n gctx.shell().print_report(\n &[\n Level::WARNING.secondary_title(\n format!(\"user-defined alias `{cmd}` has the appearance of a manifest-command\")\n ).element(\n Level::NOTE.message(\n \"this was previously accepted but will be phased out when `-Zscript` is stabilized; \\\n see \"\n )\n )\n ],\n false\n )?;\n }\n }\n\n let mut alias = alias\n .into_iter()\n .map(|s| OsString::from(s))\n .collect::>();\n alias.extend(\n sub_args\n .get_many::(\"\")\n .unwrap_or_default()\n .cloned(),\n );\n // new_args strips out everything before the subcommand, so\n // capture those global options now.\n // Note that an alias to an external command will not receive\n // these arguments. That may be confusing, but such is life.\n let global_args = GlobalArgs::new(sub_args);\n let new_args = cli(gctx).no_binary_name(true).try_get_matches_from(alias)?;\n\n let Some(new_cmd) = new_args.subcommand_name() else {\n return Err(anyhow!(\n \"subcommand is required, add a subcommand to the command alias `alias.{cmd}`\"\n )\n .into());\n };\n\n already_expanded.push(cmd.to_string());\n if already_expanded.contains(&new_cmd.to_string()) {\n // Crash if the aliases are corecursive / unresolvable\n return Err(anyhow!(\n \"alias {} has unresolvable recursive definition: {} -> {}\",\n already_expanded[0],\n already_expanded.join(\" -> \"),\n new_cmd,\n )\n .into());\n }\n\n let (expanded_args, _) = expand_aliases(gctx, new_args, already_expanded)?;\n return Ok((expanded_args, global_args));\n }\n (None, Err(e)) => return Err(e.into()),\n }\n };\n\n Ok((args, GlobalArgs::default()))\n}\n\n#[tracing::instrument(skip_all)]\nfn configure_gctx(\n gctx: &mut GlobalContext,\n args: &ArgMatches,\n subcommand_args: Option<&ArgMatches>,\n global_args: GlobalArgs,\n exec: Option<&Exec>,\n) -> CliResult {\n let arg_target_dir = &subcommand_args.and_then(|a| a.value_of_path(\"target-dir\", gctx));\n let mut verbose = global_args.verbose + args.verbose();\n // quiet is unusual because it is redefined in some subcommands in order\n // to provide custom help text.\n let mut quiet = args.flag(\"quiet\")\n || subcommand_args.map(|a| a.flag(\"quiet\")).unwrap_or_default()\n || global_args.quiet;\n if matches!(exec, Some(Exec::Manifest(_))) && !quiet {\n // Verbosity is shifted quieter for `Exec::Manifest` as it is can be used as if you ran\n // `cargo install` and we especially shouldn't pollute programmatic output.\n //\n // For now, interactive output has the same default output as `cargo run` but that is\n // subject to change.\n if let Some(lower) = verbose.checked_sub(1) {\n verbose = lower;\n } else if !gctx.shell().is_err_tty() {\n // Don't pollute potentially-scripted output\n quiet = true;\n }\n }\n let global_color = global_args.color; // Extract so it can take reference.\n let color = args\n .get_one::(\"color\")\n .map(String::as_str)\n .or_else(|| global_color.as_deref());\n let frozen = args.flag(\"frozen\") || global_args.frozen;\n let locked = args.flag(\"locked\") || global_args.locked;\n let offline = args.flag(\"offline\") || global_args.offline;\n let mut unstable_flags = global_args.unstable_flags;\n if let Some(values) = args.get_many::(\"unstable-features\") {\n unstable_flags.extend(values.cloned());\n }\n let mut config_args = global_args.config_args;\n if let Some(values) = args.get_many::(\"config\") {\n config_args.extend(values.cloned());\n }\n gctx.configure(\n verbose,\n quiet,\n color,\n frozen,\n locked,\n offline,\n arg_target_dir,\n &unstable_flags,\n &config_args,\n )?;\n Ok(())\n}\n\nenum Exec {\n Builtin(commands::Exec),\n Manifest(String),\n External(String),\n}\n\nimpl Exec {\n /// Precedence isn't the most obvious from this function because\n /// - Some is determined by `expand_aliases`\n /// - Some is enforced by `avoid_ambiguity_between_builtins_and_manifest_commands`\n ///\n /// In actuality, it is:\n /// 1. built-ins xor manifest-command\n /// 2. aliases\n /// 3. external subcommands\n fn infer(cmd: &str) -> CargoResult {\n if let Some(exec) = commands::builtin_exec(cmd) {\n Ok(Self::Builtin(exec))\n } else if commands::run::is_manifest_command(cmd) {\n Ok(Self::Manifest(cmd.to_owned()))\n } else {\n Ok(Self::External(cmd.to_owned()))\n }\n }\n\n #[tracing::instrument(skip_all)]\n fn exec(self, gctx: &mut GlobalContext, subcommand_args: &ArgMatches) -> CliResult {\n match self {\n Self::Builtin(exec) => exec(gctx, subcommand_args),\n Self::Manifest(cmd) => {\n let ext_path = super::find_external_subcommand(gctx, &cmd);\n if !gctx.cli_unstable().script && ext_path.is_some() {\n gctx.shell().print_report(\n &[\n Level::WARNING.secondary_title(\n format!(\"external subcommand `{cmd}` has the appearance of a manifest-command\")\n ).element(\n Level::NOTE.message(\n \"this was previously accepted but will be phased out when `-Zscript` is stabilized; \\\n see \"\n )\n )\n ],\n false\n )?;\n\n Self::External(cmd).exec(gctx, subcommand_args)\n } else {\n let ext_args: Vec = subcommand_args\n .get_many::(\"\")\n .unwrap_or_default()\n .cloned()\n .collect();\n commands::run::exec_manifest_command(gctx, &cmd, &ext_args)\n }\n }\n Self::External(cmd) => {\n let mut ext_args = vec![OsStr::new(&cmd)];\n ext_args.extend(\n subcommand_args\n .get_many::(\"\")\n .unwrap_or_default()\n .map(OsString::as_os_str),\n );\n super::execute_external_subcommand(gctx, &cmd, &ext_args)\n }\n }\n }\n}\n\n#[derive(Default)]\nstruct GlobalArgs {\n verbose: u32,\n quiet: bool,\n color: Option,\n frozen: bool,\n locked: bool,\n offline: bool,\n unstable_flags: Vec,\n config_args: Vec,\n}\n\nimpl GlobalArgs {\n fn new(args: &ArgMatches) -> GlobalArgs {\n GlobalArgs {\n verbose: args.verbose(),\n quiet: args.flag(\"quiet\"),\n color: args.get_one::(\"color\").cloned(),\n frozen: args.flag(\"frozen\"),\n locked: args.flag(\"locked\"),\n offline: args.flag(\"offline\"),\n unstable_flags: args\n .get_many::(\"unstable-features\")\n .unwrap_or_default()\n .cloned()\n .collect(),\n config_args: args\n .get_many::(\"config\")\n .unwrap_or_default()\n .cloned()\n .collect(),\n }\n }\n}\n\n#[tracing::instrument(skip_all)]\npub fn cli(gctx: &GlobalContext) -> Command {\n // Don't let config errors get in the way of parsing arguments\n let term = gctx.get::(\"term\").unwrap_or_default();\n let color = term\n .color\n .and_then(|c| c.parse().ok())\n .unwrap_or(ColorChoice::CargoAuto);\n let color = match color {\n ColorChoice::Always => clap::ColorChoice::Always,\n ColorChoice::Never => clap::ColorChoice::Never,\n ColorChoice::CargoAuto => clap::ColorChoice::Auto,\n };\n\n let usage = if is_rustup() {\n color_print::cstr!(\n \"cargo [+toolchain] [OPTIONS] [COMMAND]\\n cargo [+toolchain] [OPTIONS] -Zscript <> [ARGS]...\"\n )\n } else {\n color_print::cstr!(\n \"cargo [OPTIONS] [COMMAND]\\n cargo [OPTIONS] -Zscript <> [ARGS]...\"\n )\n };\n\n let styles = {\n clap::builder::styling::Styles::styled()\n .header(style::HEADER)\n .usage(style::USAGE)\n .literal(style::LITERAL)\n .placeholder(style::PLACEHOLDER)\n .error(style::ERROR)\n .valid(style::VALID)\n .invalid(style::INVALID)\n };\n\n Command::new(\"cargo\")\n // Subcommands all count their args' display order independently (from 0),\n // which makes their args interspersed with global args. This puts global args last.\n //\n // We also want these to come before auto-generated `--help`\n .next_display_order(800)\n .allow_external_subcommands(true)\n .color(color)\n .styles(styles)\n // Provide a custom help subcommand for calling into man pages\n .disable_help_subcommand(true)\n .override_usage(usage)\n .help_template(color_print::cstr!(\n \"\\\nRust's package manager\n\nUsage: {usage}\n\nOptions:\n{options}\n\nCommands:\n build, b Compile the current package\n check, c Analyze the current package and report errors, but don't build object files\n clean Remove the target directory\n doc, d Build this package's and its dependencies' documentation\n new Create a new cargo package\n init Create a new cargo package in an existing directory\n add Add dependencies to a manifest file\n remove Remove dependencies from a manifest file\n run, r Run a binary or example of the local package\n test, t Run the tests\n bench Run the benchmarks\n update Update dependencies listed in Cargo.lock\n search Search registry for crates\n publish Package and upload this package to the registry\n install Install a Rust binary\n uninstall Uninstall a Rust binary\n ... See all commands with --list\n\nSee 'cargo help <>' for more information on a specific command.\\n\",\n ))\n .arg(flag(\"version\", \"Print version info and exit\").short('V'))\n .arg(flag(\"list\", \"List installed commands\"))\n .arg(\n opt(\n \"explain\",\n \"Provide a detailed explanation of a rustc error message\",\n )\n .value_name(\"CODE\"),\n )\n .arg(\n opt(\n \"verbose\",\n \"Use verbose output (-vv very verbose/build.rs output)\",\n )\n .short('v')\n .action(ArgAction::Count)\n .global(true),\n )\n .arg(flag(\"quiet\", \"Do not print cargo log messages\").short('q').global(true))\n .arg(\n opt(\"color\", \"Coloring\")\n .value_name(\"WHEN\")\n .global(true)\n .value_parser([\"auto\", \"always\", \"never\"])\n .ignore_case(true),\n )\n .arg(\n Arg::new(\"directory\")\n .help(\"Change to DIRECTORY before doing anything (nightly-only)\")\n .short('C')\n .value_name(\"DIRECTORY\")\n .value_hint(clap::ValueHint::DirPath)\n .value_parser(clap::builder::ValueParser::path_buf()),\n )\n .arg(\n flag(\"locked\", \"Assert that `Cargo.lock` will remain unchanged\")\n .help_heading(heading::MANIFEST_OPTIONS)\n .global(true),\n )\n .arg(\n flag(\"offline\", \"Run without accessing the network\")\n .help_heading(heading::MANIFEST_OPTIONS)\n .global(true),\n )\n .arg(\n flag(\"frozen\", \"Equivalent to specifying both --locked and --offline\")\n .help_heading(heading::MANIFEST_OPTIONS)\n .global(true),\n )\n // Better suggestion for the unsupported short config flag.\n .arg( Arg::new(\"unsupported-short-config-flag\")\n .help(\"\")\n .short('c')\n .value_parser(UnknownArgumentValueParser::suggest_arg(\"--config\"))\n .action(ArgAction::SetTrue)\n .global(true)\n .hide(true))\n .arg(multi_opt(\"config\", \"KEY=VALUE|PATH\", \"Override a configuration value\").global(true))\n // Better suggestion for the unsupported lowercase unstable feature flag.\n .arg( Arg::new(\"unsupported-lowercase-unstable-feature-flag\")\n .help(\"\")\n .short('z')\n .value_parser(UnknownArgumentValueParser::suggest_arg(\"-Z\"))\n .action(ArgAction::SetTrue)\n .global(true)\n .hide(true))\n .arg(Arg::new(\"unstable-features\")\n .help(\"Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details\")\n .short('Z')\n .value_name(\"FLAG\")\n .action(ArgAction::Append)\n .global(true)\n .add(clap_complete::ArgValueCandidates::new(|| {\n let flags = CliUnstable::help();\n flags.into_iter().map(|flag| {\n clap_complete::CompletionCandidate::new(flag.0.replace(\"_\", \"-\")).help(flag.1.map(|help| {\n help.into()\n }))\n }).collect()\n })))\n .add(clap_complete::engine::SubcommandCandidates::new(move || {\n let mut candidates = get_toolchains_from_rustup()\n .into_iter()\n .map(|t| clap_complete::CompletionCandidate::new(t))\n .collect::>();\n if let Ok(gctx) = new_gctx_for_completions() {\n candidates.extend(get_command_candidates(&gctx));\n }\n candidates\n }))\n .subcommands(commands::builtin())\n}\n\nfn get_toolchains_from_rustup() -> Vec {\n let output = std::process::Command::new(\"rustup\")\n .arg(\"toolchain\")\n .arg(\"list\")\n .arg(\"-q\")\n .output()\n .unwrap();\n\n if !output.status.success() {\n return vec![];\n }\n\n let stdout = String::from_utf8(output.stdout).unwrap();\n\n stdout.lines().map(|line| format!(\"+{}\", line)).collect()\n}\n\nfn get_command_candidates(gctx: &GlobalContext) -> Vec {\n let mut commands = user_defined_aliases(gctx);\n commands.extend(third_party_subcommands(gctx));\n commands\n .iter()\n .map(|(name, cmd_info)| {\n let help_text = match cmd_info {\n CommandInfo::Alias { target } => {\n let cmd_str = target\n .iter()\n .map(String::as_str)\n .collect::>()\n .join(\" \");\n format!(\"alias for {}\", cmd_str)\n }\n CommandInfo::BuiltIn { .. } => {\n unreachable!(\"BuiltIn command shouldn't appear in alias map\")\n }\n CommandInfo::External { path } => {\n format!(\"from {}\", path.display())\n }\n };\n clap_complete::CompletionCandidate::new(name.clone()).help(Some(help_text.into()))\n })\n .collect()\n}\n\n#[test]\nfn verify_cli() {\n let gctx = GlobalContext::default().unwrap();\n cli(&gctx).debug_assert();\n}\n\n#[test]\nfn avoid_ambiguity_between_builtins_and_manifest_commands() {\n for cmd in commands::builtin() {\n let name = cmd.get_name();\n assert!(\n !commands::run::is_manifest_command(&name),\n \"built-in command {name} is ambiguous with manifest-commands\"\n )\n }\n}\n" }, { "path": "src/bin/cargo/commands/add.rs", "content": "use cargo::sources::CRATES_IO_REGISTRY;\nuse cargo::util::print_available_packages;\nuse indexmap::IndexMap;\nuse indexmap::IndexSet;\n\nuse cargo::CargoResult;\nuse cargo::core::FeatureValue;\nuse cargo::core::dependency::DepKind;\nuse cargo::ops::cargo_add::AddOptions;\nuse cargo::ops::cargo_add::DepOp;\nuse cargo::ops::cargo_add::add;\nuse cargo::ops::resolve_ws;\nuse cargo::util::command_prelude::*;\nuse cargo::util::toml_mut::manifest::DepTable;\n\npub fn cli() -> Command {\n clap::Command::new(\"add\")\n .about(\"Add dependencies to a Cargo.toml manifest file\")\n .override_usage(\n color_print::cstr!(\"\\\n cargo add [OPTIONS] <>[@<>] ...\n cargo add [OPTIONS] --path <> ...\n cargo add [OPTIONS] --git <> ...\"\n ))\n .after_help(color_print::cstr!(\"Run `cargo help add` for more detailed information.\\n\"))\n .group(clap::ArgGroup::new(\"selected\").multiple(true).required(true))\n .args([\n clap::Arg::new(\"crates\")\n .value_name(\"DEP_ID\")\n .num_args(0..)\n .help(\"Reference to a package to add as a dependency\")\n .long_help(\n \"Reference to a package to add as a dependency\n\nYou can reference a package by:\n- ``, like `cargo add serde` (latest version will be used)\n- `@`, like `cargo add serde@1` or `cargo add serde@=1.0.38`\"\n )\n .group(\"selected\"),\n flag(\"no-default-features\",\n \"Disable the default features\"),\n flag(\"default-features\",\n \"Re-enable the default features\")\n .overrides_with(\"no-default-features\"),\n clap::Arg::new(\"features\")\n .short('F')\n .long(\"features\")\n .value_name(\"FEATURES\")\n .action(ArgAction::Append)\n .help(\"Space or comma separated list of features to activate\"),\n flag(\"optional\",\n \"Mark the dependency as optional\")\n .long_help(\"Mark the dependency as optional\n\nThe package name will be exposed as feature of your crate.\")\n .conflicts_with(\"dev\"),\n flag(\"no-optional\",\n \"Mark the dependency as required\")\n .long_help(\"Mark the dependency as required\n\nThe package will be removed from your features.\")\n .conflicts_with(\"dev\")\n .overrides_with(\"optional\"),\n flag(\"public\", \"Mark the dependency as public (unstable)\")\n .conflicts_with(\"dev\")\n .conflicts_with(\"build\")\n .long_help(\"Mark the dependency as public (unstable)\n\nThe dependency can be referenced in your library's public API.\"),\n flag(\"no-public\", \"Mark the dependency as private (unstable)\")\n .conflicts_with(\"dev\")\n .conflicts_with(\"build\")\n .overrides_with(\"public\")\n .long_help(\"Mark the dependency as private (unstable)\n\nWhile you can use the crate in your implementation, it cannot be referenced in your public API.\"),\n clap::Arg::new(\"rename\")\n .long(\"rename\")\n .action(ArgAction::Set)\n .value_name(\"NAME\")\n .help(\"Rename the dependency\")\n .long_help(\"Rename the dependency\n\nExample uses:\n- Depending on multiple versions of a crate\n- Depend on crates with the same name from different registries\"),\n ])\n .arg_manifest_path_without_unsupported_path_tip()\n .arg_package(\"Package to modify\")\n .arg_ignore_rust_version()\n .arg_dry_run(\"Don't actually write the manifest\")\n .arg_silent_suggestion()\n .next_help_heading(\"Source\")\n .args([\n clap::Arg::new(\"path\")\n .long(\"path\")\n .action(ArgAction::Set)\n .value_name(\"PATH\")\n .help(\"Filesystem path to local crate to add\")\n .group(\"selected\")\n .conflicts_with(\"git\")\n .add(clap_complete::engine::ArgValueCompleter::new(\n clap_complete::engine::PathCompleter::any()\n .filter(|path| path.join(\"Cargo.toml\").exists()),\n )),\n clap::Arg::new(\"base\")\n .long(\"base\")\n .action(ArgAction::Set)\n .value_name(\"BASE\")\n .help(\"The path base to use when adding from a local crate (unstable).\")\n .requires(\"path\"),\n clap::Arg::new(\"git\")\n .long(\"git\")\n .action(ArgAction::Set)\n .value_name(\"URI\")\n .help(\"Git repository location\")\n .long_help(\"Git repository location\n\nWithout any other information, cargo will use latest commit on the main branch.\")\n .group(\"selected\"),\n clap::Arg::new(\"branch\")\n .long(\"branch\")\n .action(ArgAction::Set)\n .value_name(\"BRANCH\")\n .help(\"Git branch to download the crate from\")\n .requires(\"git\")\n .group(\"git-ref\"),\n clap::Arg::new(\"tag\")\n .long(\"tag\")\n .action(ArgAction::Set)\n .value_name(\"TAG\")\n .help(\"Git tag to download the crate from\")\n .requires(\"git\")\n .group(\"git-ref\"),\n clap::Arg::new(\"rev\")\n .long(\"rev\")\n .action(ArgAction::Set)\n .value_name(\"REV\")\n .help(\"Git reference to download the crate from\")\n .long_help(\"Git reference to download the crate from\n\nThis is the catch all, handling hashes to named references in remote repositories.\")\n .requires(\"git\")\n .group(\"git-ref\"),\n clap::Arg::new(\"registry\")\n .long(\"registry\")\n .action(ArgAction::Set)\n .value_name(\"NAME\")\n .help(\"Package registry for this dependency\")\n .add(clap_complete::ArgValueCandidates::new(|| {\n let candidates = get_registry_candidates();\n candidates.unwrap_or_default()\n })),\n ])\n .next_help_heading(\"Section\")\n .args([\n flag(\"dev\",\n \"Add as development dependency\")\n .long_help(\"Add as development dependency\n\nDev-dependencies are not used when compiling a package for building, but are used for compiling tests, examples, and benchmarks.\n\nThese dependencies are not propagated to other packages which depend on this package.\")\n .group(\"section\"),\n flag(\"build\",\n \"Add as build dependency\")\n .long_help(\"Add as build dependency\n\nBuild-dependencies are the only dependencies available for use by build scripts (`build.rs` files).\")\n .group(\"section\"),\n clap::Arg::new(\"target\")\n .long(\"target\")\n .action(ArgAction::Set)\n .value_name(\"TARGET\")\n .value_parser(clap::builder::NonEmptyStringValueParser::new())\n .help(\"Add as dependency to the given target platform\")\n ])\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let dry_run = args.dry_run();\n let section = parse_section(args);\n\n let ws = args.workspace(gctx)?;\n\n if args.is_present_with_zero_values(\"package\") {\n print_available_packages(&ws)?;\n }\n\n let packages = args.packages_from_flags()?;\n let packages = packages.get_packages(&ws)?;\n let spec = match packages.len() {\n 0 => {\n return Err(CliError::new(\n anyhow::format_err!(\n \"no packages selected to modify. Please specify one with `-p `\"\n ),\n 101,\n ));\n }\n 1 => packages[0],\n _ => {\n let names = packages.iter().map(|p| p.name()).collect::>();\n return Err(CliError::new(\n anyhow::format_err!(\n \"`cargo add` could not determine which package to modify. \\\n Use the `--package` option to specify a package. \\n\\\n available packages: {}\",\n names.join(\", \")\n ),\n 101,\n ));\n }\n };\n\n let dependencies = parse_dependencies(gctx, args)?;\n\n let honor_rust_version = args.honor_rust_version();\n\n let options = AddOptions {\n gctx,\n spec,\n dependencies,\n section,\n dry_run,\n honor_rust_version,\n };\n add(&ws, &options)?;\n\n // Reload the workspace since we've changed dependencies\n let ws = args.workspace(gctx)?;\n resolve_ws(&ws, dry_run)?;\n\n Ok(())\n}\n\nfn parse_dependencies(gctx: &GlobalContext, matches: &ArgMatches) -> CargoResult> {\n let path = matches.get_one::(\"path\");\n let base = matches.get_one::(\"base\");\n let git = matches.get_one::(\"git\");\n let branch = matches.get_one::(\"branch\");\n let rev = matches.get_one::(\"rev\");\n let tag = matches.get_one::(\"tag\");\n let rename = matches.get_one::(\"rename\");\n let registry = match matches.registry(gctx)? {\n Some(reg) if reg == CRATES_IO_REGISTRY => None,\n reg => reg,\n };\n let default_features = default_features(matches);\n let optional = optional(matches);\n let public = public(matches);\n\n let mut crates = matches\n .get_many::(\"crates\")\n .into_iter()\n .flatten()\n .map(|c| (Some(c.clone()), None))\n .collect::>();\n\n let mut infer_crate_name = false;\n\n for (crate_name, _) in crates.iter() {\n let crate_name = crate_name.as_ref().unwrap();\n\n if let Some(toolchain) = crate_name.strip_prefix(\"+\") {\n anyhow::bail!(\n \"invalid character `+` in dependency name: `+{toolchain}`\n Use `cargo +{toolchain} add` if you meant to use the `{toolchain}` toolchain.\"\n );\n }\n }\n\n if crates.is_empty() {\n if path.is_some() || git.is_some() {\n crates.insert(None, None);\n infer_crate_name = true;\n } else {\n unreachable!(\"clap should ensure we have some source selected\");\n }\n }\n for feature in matches\n .get_many::(\"features\")\n .into_iter()\n .flatten()\n .map(String::as_str)\n .flat_map(parse_feature)\n {\n let parsed_value = FeatureValue::new(feature.into());\n match parsed_value {\n FeatureValue::Feature(_) => {\n if 1 < crates.len() {\n let candidates = crates\n .keys()\n .map(|c| {\n format!(\n \"`{}/{}`\",\n c.as_deref().expect(\"only none when there is 1\"),\n feature\n )\n })\n .collect::>();\n anyhow::bail!(\n \"feature `{feature}` must be qualified by the dependency it's being activated for, like {}\",\n candidates.join(\", \")\n );\n }\n crates\n .first_mut()\n .expect(\"always at least one crate\")\n .1\n .get_or_insert_with(IndexSet::new)\n .insert(feature.to_owned());\n }\n FeatureValue::Dep { .. } => {\n anyhow::bail!(\"feature `{feature}` is not allowed to use explicit `dep:` syntax\",)\n }\n FeatureValue::DepFeature {\n dep_name,\n dep_feature,\n ..\n } => {\n if infer_crate_name {\n anyhow::bail!(\n \"`{feature}` is unsupported when inferring the crate name, use `{dep_feature}`\"\n );\n }\n if dep_feature.contains('/') {\n anyhow::bail!(\"multiple slashes in feature `{feature}` is not allowed\");\n }\n crates.get_mut(&Some(dep_name.as_str().to_owned())).ok_or_else(|| {\n anyhow::format_err!(\"feature `{dep_feature}` activated for crate `{dep_name}` but the crate wasn't specified\")\n })?\n .get_or_insert_with(IndexSet::new)\n .insert(dep_feature.as_str().to_owned());\n }\n }\n }\n\n let mut deps: Vec = Vec::new();\n for (crate_spec, features) in crates {\n let dep = DepOp {\n crate_spec,\n rename: rename.map(String::from),\n features,\n default_features,\n optional,\n public,\n registry: registry.clone(),\n path: path.map(String::from),\n base: base.map(String::from),\n git: git.map(String::from),\n branch: branch.map(String::from),\n rev: rev.map(String::from),\n tag: tag.map(String::from),\n };\n deps.push(dep);\n }\n\n if deps.len() > 1 && rename.is_some() {\n anyhow::bail!(\"cannot specify multiple crates with `--rename`\");\n }\n\n Ok(deps)\n}\n\nfn default_features(matches: &ArgMatches) -> Option {\n resolve_bool_arg(\n matches.flag(\"default-features\"),\n matches.flag(\"no-default-features\"),\n )\n}\n\nfn optional(matches: &ArgMatches) -> Option {\n resolve_bool_arg(matches.flag(\"optional\"), matches.flag(\"no-optional\"))\n}\n\nfn public(matches: &ArgMatches) -> Option {\n resolve_bool_arg(matches.flag(\"public\"), matches.flag(\"no-public\"))\n}\n\nfn resolve_bool_arg(yes: bool, no: bool) -> Option {\n match (yes, no) {\n (true, false) => Some(true),\n (false, true) => Some(false),\n (false, false) => None,\n (_, _) => unreachable!(\"clap should make this impossible\"),\n }\n}\n\nfn parse_section(matches: &ArgMatches) -> DepTable {\n let kind = if matches.flag(\"dev\") {\n DepKind::Development\n } else if matches.flag(\"build\") {\n DepKind::Build\n } else {\n DepKind::Normal\n };\n\n let mut table = DepTable::new().set_kind(kind);\n\n if let Some(target) = matches.get_one::(\"target\") {\n assert!(!target.is_empty(), \"Target specification may not be empty\");\n table = table.set_target(target);\n }\n\n table\n}\n\n/// Split feature flag list\nfn parse_feature(feature: &str) -> impl Iterator {\n // Not re-using `CliFeatures` because it uses a BTreeSet and loses user's ordering\n feature\n .split_whitespace()\n .flat_map(|s| s.split(','))\n .filter(|s| !s.is_empty())\n}\n" }, { "path": "src/bin/cargo/commands/bench.rs", "content": "use crate::command_prelude::*;\nuse cargo::ops::{self, TestOptions};\n\npub fn cli() -> Command {\n subcommand(\"bench\")\n .about(\"Execute all benchmarks of a local package\")\n .next_display_order(0)\n .arg(\n Arg::new(\"BENCHNAME\")\n .action(ArgAction::Set)\n .help(\"If specified, only run benches containing this string in their names\"),\n )\n .arg(\n Arg::new(\"args\")\n .value_name(\"ARGS\")\n .help(\"Arguments for the bench binary\")\n .num_args(0..)\n .last(true),\n )\n .arg(flag(\"no-run\", \"Compile, but don't run benchmarks\"))\n .arg(flag(\n \"no-fail-fast\",\n \"Run all benchmarks regardless of failure\",\n ))\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_package_spec(\n \"Package to run benchmarks for\",\n \"Benchmark all packages in the workspace\",\n \"Exclude packages from the benchmark\",\n )\n .arg_targets_all(\n \"Benchmark only this package's library\",\n \"Benchmark only the specified binary\",\n \"Benchmark all binaries\",\n \"Benchmark only the specified example\",\n \"Benchmark all examples\",\n \"Benchmark only the specified test target\",\n \"Benchmark all targets that have `test = true` set\",\n \"Benchmark only the specified bench target\",\n \"Benchmark all targets that have `bench = true` set\",\n \"Benchmark all targets\",\n )\n .arg_features()\n .arg_jobs()\n .arg_unsupported_keep_going()\n .arg_profile(\"Build artifacts with the specified profile\")\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg_unit_graph()\n .arg_timings()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .after_help(color_print::cstr!(\n \"Run `cargo help bench` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n\n let mut compile_opts =\n args.compile_options(gctx, UserIntent::Bench, Some(&ws), ProfileChecking::Custom)?;\n\n compile_opts.build_config.requested_profile =\n args.get_profile_name(\"bench\", ProfileChecking::Custom)?;\n\n let ops = TestOptions {\n no_run: args.flag(\"no-run\"),\n no_fail_fast: args.flag(\"no-fail-fast\"),\n compile_opts,\n };\n\n let bench_args = args.get_one::(\"BENCHNAME\").into_iter();\n let bench_args = bench_args.chain(args.get_many::(\"args\").unwrap_or_default());\n let bench_args = bench_args.map(String::as_str).collect::>();\n\n ops::run_benches(&ws, &ops, &bench_args)\n}\n" }, { "path": "src/bin/cargo/commands/build.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"build\")\n // subcommand aliases are handled in aliased_command()\n // .alias(\"b\")\n .about(\"Compile a local package and all of its dependencies\")\n .arg_future_incompat_report()\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_package_spec(\n \"Package to build (see `cargo help pkgid`)\",\n \"Build all packages in the workspace\",\n \"Exclude packages from the build\",\n )\n .arg_targets_all(\n \"Build only this package's library\",\n \"Build only the specified binary\",\n \"Build all binaries\",\n \"Build only the specified example\",\n \"Build all examples\",\n \"Build only the specified test target\",\n \"Build all targets that have `test = true` set\",\n \"Build only the specified bench target\",\n \"Build all targets that have `bench = true` set\",\n \"Build all targets\",\n )\n .arg_features()\n .arg_release(\"Build artifacts in release mode, with optimizations\")\n .arg_redundant_default_mode(\"debug\", \"build\", \"release\")\n .arg_profile(\"Build artifacts with the specified profile\")\n .arg_parallel()\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg_artifact_dir()\n .arg_unit_graph()\n .arg_timings()\n .arg_compile_time_deps()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .after_help(color_print::cstr!(\n \"Run `cargo help build` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n let mut compile_opts =\n args.compile_options(gctx, UserIntent::Build, Some(&ws), ProfileChecking::Custom)?;\n\n if let Some(artifact_dir) = args.value_of_path(\"artifact-dir\", gctx) {\n // If the user specifies `--artifact-dir`, use that\n compile_opts.build_config.export_dir = Some(artifact_dir);\n } else if let Some(artifact_dir) = gctx.build_config()?.artifact_dir.as_ref() {\n // If a CLI option is not specified for choosing the artifact dir, use the `artifact-dir` from the build config, if\n // present\n let artifact_dir = artifact_dir.resolve_path(gctx);\n compile_opts.build_config.export_dir = Some(artifact_dir);\n }\n\n if compile_opts.build_config.export_dir.is_some() {\n gctx.cli_unstable()\n .fail_if_stable_opt(\"--artifact-dir\", 6790)?;\n }\n\n ops::compile(&ws, &compile_opts)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/check.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"check\")\n // subcommand aliases are handled in aliased_command()\n // .alias(\"c\")\n .about(\"Check a local package and all of its dependencies for errors\")\n .arg_future_incompat_report()\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_package_spec(\n \"Package(s) to check\",\n \"Check all packages in the workspace\",\n \"Exclude packages from the check\",\n )\n .arg_targets_all(\n \"Check only this package's library\",\n \"Check only the specified binary\",\n \"Check all binaries\",\n \"Check only the specified example\",\n \"Check all examples\",\n \"Check only the specified test target\",\n \"Check all targets that have `test = true` set\",\n \"Check only the specified bench target\",\n \"Check all targets that have `bench = true` set\",\n \"Check all targets\",\n )\n .arg_features()\n .arg_parallel()\n .arg_release(\"Check artifacts in release mode, with optimizations\")\n .arg_profile(\"Check artifacts with the specified profile\")\n .arg_target_triple(\"Check for the target triple\")\n .arg_target_dir()\n .arg_unit_graph()\n .arg_timings()\n .arg_compile_time_deps()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .after_help(color_print::cstr!(\n \"Run `cargo help check` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n // This is a legacy behavior that causes `cargo check` to pass `--test`.\n let test = matches!(\n args.get_one::(\"profile\").map(String::as_str),\n Some(\"test\")\n );\n let intent = UserIntent::Check { test };\n let compile_opts =\n args.compile_options(gctx, intent, Some(&ws), ProfileChecking::LegacyTestOnly)?;\n\n ops::compile(&ws, &compile_opts)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/clean.rs", "content": "use crate::command_prelude::*;\nuse crate::util::cache_lock::CacheLockMode;\nuse cargo::core::gc::Gc;\nuse cargo::core::gc::{GcOpts, parse_human_size, parse_time_span};\nuse cargo::core::global_cache_tracker::GlobalCacheTracker;\nuse cargo::ops::CleanContext;\nuse cargo::ops::{self, CleanOptions};\nuse cargo::util::print_available_packages;\nuse clap_complete::ArgValueCandidates;\nuse indexmap::IndexSet;\nuse std::time::Duration;\n\npub fn cli() -> Command {\n subcommand(\"clean\")\n .about(\"Remove artifacts that cargo has generated in the past\")\n .arg_doc(\"Whether or not to clean just the documentation directory\")\n .arg_silent_suggestion()\n .arg_package_spec_simple(\n \"Package to clean artifacts for\",\n ArgValueCandidates::new(get_pkg_name_candidates),\n )\n .arg(\n flag(\"workspace\", \"Clean artifacts of the workspace members\")\n .help_heading(heading::PACKAGE_SELECTION),\n )\n .arg_release(\"Whether or not to clean release artifacts\")\n .arg_profile(\"Clean artifacts of the specified profile\")\n .arg_target_triple(\"Target triple to clean output for\")\n .arg_target_dir()\n .arg_manifest_path()\n .arg_dry_run(\"Display what would be deleted without deleting anything\")\n .args_conflicts_with_subcommands(true)\n .subcommand(\n subcommand(\"gc\")\n .about(\"Clean global caches\")\n .hide(true)\n .arg_silent_suggestion()\n .arg_dry_run(\"Display what would be deleted without deleting anything\")\n // NOTE: Not all of these options may get stabilized. Some of them are\n // very low-level details, and may not be something typical users need.\n .arg(\n opt(\n \"max-src-age\",\n \"Deletes source cache files that have not been used \\\n since the given age (unstable)\",\n )\n .value_name(\"DURATION\")\n .value_parser(parse_time_span),\n )\n .arg(\n opt(\n \"max-crate-age\",\n \"Deletes crate cache files that have not been used \\\n since the given age (unstable)\",\n )\n .value_name(\"DURATION\")\n .value_parser(parse_time_span),\n )\n .arg(\n opt(\n \"max-index-age\",\n \"Deletes registry indexes that have not been used \\\n since the given age (unstable)\",\n )\n .value_name(\"DURATION\")\n .value_parser(parse_time_span),\n )\n .arg(\n opt(\n \"max-git-co-age\",\n \"Deletes git dependency checkouts that have not been used \\\n since the given age (unstable)\",\n )\n .value_name(\"DURATION\")\n .value_parser(parse_time_span),\n )\n .arg(\n opt(\n \"max-git-db-age\",\n \"Deletes git dependency clones that have not been used \\\n since the given age (unstable)\",\n )\n .value_name(\"DURATION\")\n .value_parser(parse_time_span),\n )\n .arg(\n opt(\n \"max-download-age\",\n \"Deletes any downloaded cache data that has not been used \\\n since the given age (unstable)\",\n )\n .value_name(\"DURATION\")\n .value_parser(parse_time_span),\n )\n .arg(\n opt(\n \"max-src-size\",\n \"Deletes source cache files until the cache is under the \\\n given size (unstable)\",\n )\n .value_name(\"SIZE\")\n .value_parser(parse_human_size),\n )\n .arg(\n opt(\n \"max-crate-size\",\n \"Deletes crate cache files until the cache is under the \\\n given size (unstable)\",\n )\n .value_name(\"SIZE\")\n .value_parser(parse_human_size),\n )\n .arg(\n opt(\n \"max-git-size\",\n \"Deletes git dependency caches until the cache is under \\\n the given size (unstable)\",\n )\n .value_name(\"SIZE\")\n .value_parser(parse_human_size),\n )\n .arg(\n opt(\n \"max-download-size\",\n \"Deletes downloaded cache data until the cache is under \\\n the given size (unstable)\",\n )\n .value_name(\"SIZE\")\n .value_parser(parse_human_size),\n ),\n )\n .after_help(color_print::cstr!(\n \"Run `cargo help clean` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n match args.subcommand() {\n Some((\"gc\", args)) => {\n return gc(gctx, args);\n }\n Some((cmd, _)) => {\n unreachable!(\"unexpected command {}\", cmd)\n }\n None => {}\n }\n\n let ws = args.workspace(gctx)?;\n\n if args.is_present_with_zero_values(\"package\") {\n print_available_packages(&ws)?;\n }\n let mut spec = IndexSet::from_iter(values(args, \"package\"));\n\n if args.flag(\"workspace\") {\n spec.extend(ws.members().map(|package| package.name().to_string()))\n };\n let opts = CleanOptions {\n gctx,\n spec,\n targets: args.targets()?,\n requested_profile: args.get_profile_name(\"dev\", ProfileChecking::Custom)?,\n profile_specified: args.contains_id(\"profile\") || args.flag(\"release\"),\n doc: args.flag(\"doc\"),\n dry_run: args.dry_run(),\n };\n ops::clean(&ws, &opts)?;\n Ok(())\n}\n\nfn gc(gctx: &GlobalContext, args: &ArgMatches) -> CliResult {\n gctx.cli_unstable().fail_if_stable_command(\n gctx,\n \"clean gc\",\n 12633,\n \"gc\",\n gctx.cli_unstable().gc,\n )?;\n\n let size_opt = |opt| -> Option { args.get_one::(opt).copied() };\n let duration_opt = |opt| -> Option { args.get_one::(opt).copied() };\n let mut gc_opts = GcOpts {\n max_src_age: duration_opt(\"max-src-age\"),\n max_crate_age: duration_opt(\"max-crate-age\"),\n max_index_age: duration_opt(\"max-index-age\"),\n max_git_co_age: duration_opt(\"max-git-co-age\"),\n max_git_db_age: duration_opt(\"max-git-db-age\"),\n max_src_size: size_opt(\"max-src-size\"),\n max_crate_size: size_opt(\"max-crate-size\"),\n max_git_size: size_opt(\"max-git-size\"),\n max_download_size: size_opt(\"max-download-size\"),\n };\n if let Some(age) = duration_opt(\"max-download-age\") {\n gc_opts.set_max_download_age(age);\n }\n // If the user sets any options, then only perform the options requested.\n // If no options are set, do the default behavior.\n if !gc_opts.is_download_cache_opt_set() {\n gc_opts.update_for_auto_gc(gctx)?;\n }\n\n let _lock = gctx.acquire_package_cache_lock(CacheLockMode::MutateExclusive)?;\n let mut cache_track = GlobalCacheTracker::new(&gctx)?;\n let mut gc = Gc::new(gctx, &mut cache_track)?;\n let mut clean_ctx = CleanContext::new(gctx);\n clean_ctx.dry_run = args.dry_run();\n gc.gc(&mut clean_ctx, &gc_opts)?;\n clean_ctx.display_summary()?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/config.rs", "content": "use crate::command_prelude::*;\nuse cargo::ops::cargo_config;\n\npub fn cli() -> Command {\n subcommand(\"config\")\n .about(\"Inspect configuration values\")\n .subcommand_required(true)\n .arg_required_else_help(true)\n .subcommand(\n subcommand(\"get\")\n .arg(\n Arg::new(\"key\")\n .action(ArgAction::Set)\n .help(\"The config key to display\"),\n )\n .arg(\n opt(\"format\", \"Display format\")\n .value_parser(cargo_config::ConfigFormat::POSSIBLE_VALUES)\n .default_value(\"toml\"),\n )\n .arg(flag(\n \"show-origin\",\n \"Display where the config value is defined\",\n ))\n .arg(\n opt(\"merged\", \"Whether or not to merge config values\")\n .value_parser([\"yes\", \"no\"])\n .default_value(\"yes\"),\n ),\n )\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n gctx.cli_unstable().fail_if_stable_command(\n gctx,\n \"config\",\n 9301,\n \"unstable-options\",\n gctx.cli_unstable().unstable_options,\n )?;\n match args.subcommand() {\n Some((\"get\", args)) => {\n let opts = cargo_config::GetOptions {\n key: args.get_one::(\"key\").map(String::as_str),\n format: args.get_one::(\"format\").unwrap().parse()?,\n show_origin: args.flag(\"show-origin\"),\n merged: args.get_one::(\"merged\").map(String::as_str) == Some(\"yes\"),\n };\n cargo_config::get(gctx, &opts)?;\n }\n Some((cmd, _)) => {\n unreachable!(\"unexpected command {}\", cmd)\n }\n None => {\n unreachable!(\"unexpected command\")\n }\n }\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/doc.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops::{self, DocOptions};\n\npub fn cli() -> Command {\n subcommand(\"doc\")\n // subcommand aliases are handled in aliased_command()\n // .alias(\"d\")\n .about(\"Build a package's documentation\")\n .arg(flag(\n \"open\",\n \"Opens the docs in a browser after the operation\",\n ))\n .arg(flag(\n \"no-deps\",\n \"Don't build documentation for dependencies\",\n ))\n .arg(flag(\"document-private-items\", \"Document private items\"))\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_package_spec(\n \"Package to document\",\n \"Document all packages in the workspace\",\n \"Exclude packages from the build\",\n )\n .arg_features()\n .arg_targets_lib_bin_example(\n \"Document only this package's library\",\n \"Document only the specified binary\",\n \"Document all binaries\",\n \"Document only the specified example\",\n \"Document all examples\",\n )\n .arg_parallel()\n .arg_release(\"Build artifacts in release mode, with optimizations\")\n .arg_profile(\"Build artifacts with the specified profile\")\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg_unit_graph()\n .arg_timings()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .after_help(color_print::cstr!(\n \"Run `cargo help doc` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n let intent = UserIntent::Doc {\n deps: !args.flag(\"no-deps\"),\n json: false,\n };\n let mut compile_opts =\n args.compile_options(gctx, intent, Some(&ws), ProfileChecking::Custom)?;\n compile_opts.rustdoc_document_private_items = args.flag(\"document-private-items\");\n\n let doc_opts = DocOptions {\n open_result: args.flag(\"open\"),\n output_format: ops::OutputFormat::Html,\n compile_opts,\n };\n ops::doc(&ws, &doc_opts)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/fetch.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops;\nuse cargo::ops::FetchOptions;\n\npub fn cli() -> Command {\n subcommand(\"fetch\")\n .about(\"Fetch dependencies of a package from the network\")\n .arg_silent_suggestion()\n .arg_target_triple(\"Fetch dependencies for the target triple\")\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help fetch` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n\n let opts = FetchOptions {\n gctx,\n targets: args.targets()?,\n };\n let _ = ops::fetch(&ws, &opts)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/fix.rs", "content": "use crate::command_prelude::*;\nuse cargo::core::Workspace;\n\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"fix\")\n .about(\"Automatically fix lint warnings reported by rustc\")\n .arg(flag(\"edition\", \"Fix in preparation for the next edition\"))\n .arg(flag(\n \"edition-idioms\",\n \"Fix warnings to migrate to the idioms of an edition\",\n ))\n .arg(flag(\n \"broken-code\",\n \"Fix code even if it already has compiler errors\",\n ))\n .arg(flag(\n \"allow-no-vcs\",\n \"Fix code even if a VCS was not detected\",\n ))\n .arg(flag(\n \"allow-dirty\",\n \"Fix code even if the working directory is dirty or has staged changes\",\n ))\n .arg(flag(\n \"allow-staged\",\n \"Fix code even if the working directory has staged changes\",\n ))\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_package_spec(\n \"Package(s) to fix\",\n \"Fix all packages in the workspace\",\n \"Exclude packages from the fixes\",\n )\n .arg_targets_all(\n \"Fix only this package's library\",\n \"Fix only the specified binary\",\n \"Fix all binaries\",\n \"Fix only the specified example\",\n \"Fix all examples\",\n \"Fix only the specified test target\",\n \"Fix all targets that have `test = true` set\",\n \"Fix only the specified bench target\",\n \"Fix all targets that have `bench = true` set\",\n \"Fix all targets (default)\",\n )\n .arg_features()\n .arg_parallel()\n .arg_release(\"Fix artifacts in release mode, with optimizations\")\n .arg_profile(\"Build artifacts with the specified profile\")\n .arg_target_triple(\"Fix for the target triple\")\n .arg_target_dir()\n .arg_timings()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .after_help(color_print::cstr!(\n \"Run `cargo help fix` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n // This is a legacy behavior that causes `cargo fix` to pass `--test`.\n let test = matches!(\n args.get_one::(\"profile\").map(String::as_str),\n Some(\"test\")\n );\n let intent = UserIntent::Check { test };\n\n // Unlike other commands default `cargo fix` to all targets to fix as much\n // code as we can.\n let root_manifest = args.root_manifest(gctx)?;\n\n // Can't use workspace() to avoid using -Zavoid-dev-deps (if passed)\n let mut ws = Workspace::new(&root_manifest, gctx)?;\n ws.set_resolve_honors_rust_version(args.honor_rust_version());\n\n let mut opts =\n args.compile_options(gctx, intent, Some(&ws), ProfileChecking::LegacyTestOnly)?;\n\n let edition = args.flag(\"edition\") || args.flag(\"edition-idioms\");\n if !opts.filter.is_specific() && edition {\n // When `cargo fix` is run without specifying targets but with `--edition` or `--edition-idioms`,\n // it should default to fixing all targets.\n // See: https://github.com/rust-lang/cargo/issues/13527\n opts.filter = ops::CompileFilter::new_all_targets();\n }\n\n let allow_dirty = args.flag(\"allow-dirty\");\n\n let mut opts = ops::FixOptions {\n edition: args\n .flag(\"edition\")\n .then_some(ops::EditionFixMode::NextRelative),\n idioms: args.flag(\"edition-idioms\"),\n compile_opts: opts,\n allow_dirty,\n allow_staged: allow_dirty || args.flag(\"allow-staged\"),\n allow_no_vcs: args.flag(\"allow-no-vcs\"),\n broken_code: args.flag(\"broken-code\"),\n };\n\n if let Some(fe) = &gctx.cli_unstable().fix_edition {\n ops::fix_edition(gctx, &ws, &mut opts, fe)?;\n } else {\n ops::fix(gctx, &ws, &mut opts)?;\n }\n\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/generate_lockfile.rs", "content": "use clap_complete::engine::ArgValueCompleter;\nuse clap_complete::engine::CompletionCandidate;\n\nuse crate::command_prelude::*;\n\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"generate-lockfile\")\n .about(\"Generate the lockfile for a package\")\n .arg_silent_suggestion()\n .arg_manifest_path()\n .arg_ignore_rust_version_with_help(\"Ignore `rust-version` specification in packages\")\n .arg(\n clap::Arg::new(\"publish-time\")\n .long(\"publish-time\")\n .value_name(\"yyyy-mm-ddThh:mm:ssZ\")\n .add(ArgValueCompleter::new(datetime_completer))\n .help(\"Latest publish time allowed for registry packages (unstable)\")\n .help_heading(heading::MANIFEST_OPTIONS)\n )\n .after_help(color_print::cstr!(\n \"Run `cargo help generate-lockfile` for more detailed information.\\n\"\n ))\n}\n\nfn datetime_completer(current: &std::ffi::OsStr) -> Vec {\n let mut completions = vec![];\n let Some(current) = current.to_str() else {\n return completions;\n };\n\n if current.is_empty() {\n // While not likely what people want, it can at least give them a starting point to edit\n let timestamp = jiff::Timestamp::now();\n completions.push(CompletionCandidate::new(timestamp.to_string()));\n } else if let Ok(date) = current.parse::() {\n if let Ok(zoned) = jiff::Zoned::default().with().date(date).build() {\n let timestamp = zoned.timestamp();\n completions.push(CompletionCandidate::new(timestamp.to_string()));\n }\n }\n completions\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let publish_time = args.get_one::(\"publish-time\");\n let mut ws = args.workspace(gctx)?;\n if let Some(publish_time) = publish_time {\n gctx.cli_unstable()\n .fail_if_stable_opt(\"--publish-time\", 5221)?;\n let publish_time =\n cargo_util_schemas::index::parse_pubtime(publish_time).map_err(anyhow::Error::from)?;\n ws.set_resolve_publish_time(publish_time);\n }\n ops::generate_lockfile(&ws)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/git_checkout.rs", "content": "//! Removed.\n\nuse crate::command_prelude::*;\n\nconst REMOVED: &str = \"The `git-checkout` command has been removed.\";\n\npub fn cli() -> Command {\n subcommand(\"git-checkout\")\n .about(\"REMOVED: This command has been removed\")\n .hide(true)\n .override_help(REMOVED)\n}\n\npub fn exec(_gctx: &mut GlobalContext, _args: &ArgMatches) -> CliResult {\n Err(anyhow::format_err!(REMOVED).into())\n}\n" }, { "path": "src/bin/cargo/commands/help.rs", "content": "use crate::aliased_command;\nuse crate::command_prelude::*;\n\nuse cargo::drop_println;\nuse cargo::util::errors::CargoResult;\nuse cargo_util::paths::resolve_executable;\nuse flate2::read::GzDecoder;\n\nuse std::ffi::OsStr;\nuse std::ffi::OsString;\nuse std::io::Read;\nuse std::io::Write;\nuse std::path::Path;\n\nconst COMPRESSED_MAN: &[u8] = include_bytes!(concat!(env!(\"OUT_DIR\"), \"/man.tgz\"));\n\npub fn cli() -> Command {\n subcommand(\"help\")\n .about(\"Displays help for a cargo command\")\n .arg(\n Arg::new(\"COMMAND\")\n .num_args(1..)\n .action(ArgAction::Append)\n .add(clap_complete::ArgValueCandidates::new(\n get_completion_candidates,\n )),\n )\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let args_command = args\n .get_many::(\"COMMAND\")\n .map(|vals| vals.map(String::as_str).collect::>())\n .unwrap_or_default();\n\n if args_command.is_empty() {\n let _ = crate::cli::cli(gctx).print_help();\n return Ok(());\n }\n\n let cmd: String;\n let lookup_parts: Vec<&str> = if args_command.len() == 1 {\n // Expand alias first\n let subcommand = args_command.first().unwrap();\n match aliased_command(gctx, subcommand).ok().flatten() {\n Some(argv) if argv.len() > 1 => {\n // If this alias is more than a simple subcommand pass-through, show the alias.\n let alias = argv.join(\" \");\n drop_println!(gctx, \"`{}` is aliased to `{}`\", subcommand, alias);\n return Ok(());\n }\n // Otherwise, resolve the alias into its subcommand.\n Some(argv) => {\n // An alias with an empty argv can be created via `\"empty-alias\" = \"\"`.\n cmd = argv\n .into_iter()\n .next()\n .unwrap_or_else(|| subcommand.to_string());\n vec![cmd.as_str()]\n }\n None => args_command.clone(),\n }\n } else {\n args_command.clone()\n };\n\n match find_builtin_cmd(&lookup_parts) {\n Ok(path) => {\n let man_page_name = path.join(\"-\");\n if try_help(&man_page_name)? {\n return Ok(());\n }\n crate::execute_internal_subcommand(\n gctx,\n &[OsStr::new(&man_page_name), OsStr::new(\"--help\")],\n )?;\n }\n Err(FindError::UnknownCommand(cmd)) => {\n if lookup_parts.len() == 1 {\n if let Some(man_page_name) = find_builtin_cmd_dash_joined(cmd) {\n if try_help(&man_page_name)? {\n return Ok(());\n }\n crate::execute_internal_subcommand(\n gctx,\n &[OsStr::new(&man_page_name), OsStr::new(\"--help\")],\n )?;\n } else {\n crate::execute_external_subcommand(\n gctx,\n cmd,\n &[OsStr::new(cmd), OsStr::new(\"--help\")],\n )?;\n }\n } else {\n let err = anyhow::format_err!(\n \"no such command: `{cmd}`\\n\\n\\\n help: view all installed commands with `cargo --list`\",\n );\n return Err(err.into());\n }\n }\n Err(FindError::UnknownSubcommand {\n valid_prefix,\n invalid,\n }) => {\n let valid_prefix = valid_prefix.join(\" \");\n let err = anyhow::format_err!(\n \"no such command: `cargo {valid_prefix} {invalid}` \\n\\n\\\n help: view available subcommands with `cargo {valid_prefix} --help`\",\n );\n return Err(err.into());\n }\n }\n\n Ok(())\n}\n\nfn try_help(subcommand: &str) -> CargoResult {\n #[expect(\n clippy::disallowed_methods,\n reason = \"testing only, no reason for config support\"\n )]\n let force_help_text = std::env::var(\"__CARGO_TEST_FORCE_HELP_TXT\").is_ok();\n\n if resolve_executable(Path::new(\"man\")).is_ok() && !force_help_text {\n let Some(man) = extract_man(subcommand, \"1\") else {\n return Ok(false);\n };\n write_and_spawn(subcommand, &man, \"man\")?;\n } else {\n let Some(txt) = extract_man(subcommand, \"txt\") else {\n return Ok(false);\n };\n if force_help_text {\n drop(std::io::stdout().write_all(&txt));\n } else if resolve_executable(Path::new(\"less\")).is_ok() {\n write_and_spawn(subcommand, &txt, \"less\")?;\n } else if resolve_executable(Path::new(\"more\")).is_ok() {\n write_and_spawn(subcommand, &txt, \"more\")?;\n } else {\n drop(std::io::stdout().write_all(&txt));\n }\n }\n Ok(true)\n}\n\n/// Extracts the given man page from the compressed archive.\n///\n/// Returns None if the command wasn't found.\nfn extract_man(subcommand: &str, extension: &str) -> Option> {\n let extract_name = OsString::from(format!(\"cargo-{}.{}\", subcommand, extension));\n let gz = GzDecoder::new(COMPRESSED_MAN);\n let mut ar = tar::Archive::new(gz);\n // Unwraps should be safe here, since this is a static archive generated\n // by our build script. It should never be an invalid format!\n for entry in ar.entries().unwrap() {\n let mut entry = entry.unwrap();\n let path = entry.path().unwrap();\n if path.file_name().unwrap() != extract_name {\n continue;\n }\n let mut result = Vec::new();\n entry.read_to_end(&mut result).unwrap();\n return Some(result);\n }\n None\n}\n\n/// Write the contents of a man page to disk and spawn the given command to\n/// display it.\nfn write_and_spawn(name: &str, contents: &[u8], command: &str) -> CargoResult<()> {\n let prefix = format!(\"cargo-{}.\", name);\n let mut tmp = tempfile::Builder::new().prefix(&prefix).tempfile()?;\n let f = tmp.as_file_mut();\n f.write_all(contents)?;\n f.flush()?;\n let path = tmp.path();\n // Use a path relative to the temp directory so that it can work on\n // cygwin/msys systems which don't handle windows-style paths.\n let mut relative_name = std::ffi::OsString::from(\"./\");\n relative_name.push(path.file_name().unwrap());\n let mut cmd = std::process::Command::new(command)\n .arg(relative_name)\n .current_dir(path.parent().unwrap())\n .spawn()?;\n drop(cmd.wait());\n Ok(())\n}\n\nenum FindError<'a> {\n /// The primary command was not found.\n UnknownCommand(&'a str),\n /// A subcommand in the path was not found.\n UnknownSubcommand {\n valid_prefix: Vec<&'a str>,\n invalid: &'a str,\n },\n}\n\n/// Finds a auiltin command.\nfn find_builtin_cmd<'a>(parts: &[&'a str]) -> Result, FindError<'a>> {\n let Some((first, rest)) = parts.split_first() else {\n return Err(FindError::UnknownCommand(\"\"));\n };\n\n let builtins = super::builtin();\n\n let Some(mut current) = builtins\n .iter()\n .find(|cmd| cmd.get_name() == *first || cmd.get_all_aliases().any(|a| a == *first))\n else {\n return Err(FindError::UnknownCommand(first));\n };\n\n let mut path = vec![current.get_name().to_string()];\n\n for (i, &part) in rest.iter().enumerate() {\n let next = current\n .get_subcommands()\n .find(|cmd| cmd.get_name() == part || cmd.get_all_aliases().any(|a| a == part));\n if let Some(next) = next {\n path.push(next.get_name().to_string());\n current = next;\n } else {\n let valid_prefix = [*first]\n .into_iter()\n .chain(rest[..i].iter().copied())\n .collect::>();\n return Err(FindError::UnknownSubcommand {\n valid_prefix,\n invalid: part,\n });\n };\n }\n\n Ok(path)\n}\n\nfn find_builtin_cmd_dash_joined(s: &str) -> Option {\n let builtins = super::builtin();\n\n for cmd in builtins.iter() {\n if let Some(result) = try_match_cmd(cmd, s) {\n return Some(result);\n }\n }\n None\n}\n\n/// Tries to match a single dash-joined argument against commands\nfn try_match_cmd(cmd: &Command, arg: &str) -> Option {\n let name = cmd.get_name();\n\n if arg == name || cmd.get_all_aliases().any(|alias| alias == arg) {\n return Some(name.to_string());\n }\n\n if let Some(rest) = arg.strip_prefix(name).and_then(|r| r.strip_prefix('-')) {\n for cmd in cmd.get_subcommands() {\n if let Some(sub_cmds) = try_match_cmd(cmd, rest) {\n return Some(format!(\"{name}-{sub_cmds}\"));\n }\n }\n }\n\n for alias in cmd.get_all_aliases() {\n if let Some(rest) = arg.strip_prefix(alias).and_then(|r| r.strip_prefix('-')) {\n for cmd in cmd.get_subcommands() {\n if let Some(sub_cmds) = try_match_cmd(cmd, rest) {\n return Some(format!(\"{name}-{sub_cmds}\"));\n }\n }\n }\n }\n\n None\n}\n\n/// Returns dash-joined names for nested commands,\n/// so they can be completed as single tokens.\nfn get_completion_candidates() -> Vec {\n fn walk(\n cmd: Command,\n prefix: Option<&String>,\n candidates: &mut Vec,\n ) {\n let name = cmd.get_name();\n let key = match prefix {\n Some(prefix) => format!(\"{prefix}-{name}\"),\n None => name.to_string(),\n };\n\n for cmd in cmd.get_subcommands() {\n walk(cmd.clone(), Some(&key), candidates);\n }\n\n let candidate = clap_complete::CompletionCandidate::new(&key)\n .help(cmd.get_about().cloned())\n .hide(cmd.is_hide_set());\n candidates.push(candidate);\n }\n\n let mut candidates = Vec::new();\n for cmd in super::builtin() {\n walk(cmd, None, &mut candidates);\n }\n candidates\n}\n" }, { "path": "src/bin/cargo/commands/info.rs", "content": "use anyhow::Context;\nuse cargo::ops::info;\nuse cargo::util::command_prelude::*;\nuse cargo_util_schemas::core::PackageIdSpec;\n\npub fn cli() -> Command {\n Command::new(\"info\")\n .about(\"Display information about a package\")\n .arg(\n Arg::new(\"package\")\n .required(true)\n .value_name(\"SPEC\")\n .help_heading(heading::PACKAGE_SELECTION)\n .help(\"Package to inspect\"),\n )\n .arg_index(\"Registry index URL to search packages in\")\n .arg_registry(\"Registry to search packages in\")\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help info` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let package = args\n .get_one::(\"package\")\n .map(String::as_str)\n .unwrap();\n let spec = PackageIdSpec::parse(package)\n .with_context(|| format!(\"invalid package ID specification: `{package}`\"))?;\n\n // Check if --registry or --index was explicitly provided\n let explicit_registry = args._contains(\"registry\") || args._contains(\"index\");\n let reg_or_index = args.registry_or_index(gctx)?;\n info(&spec, gctx, reg_or_index, explicit_registry)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/init.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"init\")\n .about(\"Create a new cargo package in an existing directory\")\n .arg(\n Arg::new(\"path\")\n .value_name(\"PATH\")\n .action(ArgAction::Set)\n .default_value(\".\"),\n )\n .arg_new_opts()\n .arg_registry(\"Registry to use\")\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help init` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let opts = args.new_options(gctx)?;\n ops::init(&opts, gctx)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/install.rs", "content": "use crate::command_prelude::*;\n\nuse anyhow::anyhow;\nuse anyhow::bail;\nuse anyhow::format_err;\nuse cargo::CargoResult;\nuse cargo::core::{GitReference, SourceId, Workspace};\nuse cargo::ops;\nuse cargo::util::IntoUrl;\nuse cargo::util::VersionExt;\nuse cargo_util_schemas::manifest::PackageName;\nuse itertools::Itertools;\nuse semver::VersionReq;\n\nuse cargo_util::paths;\n\npub fn cli() -> Command {\n subcommand(\"install\")\n .about(\"Install a Rust binary\")\n .arg(\n Arg::new(\"crate\")\n .value_name(\"CRATE[@]\")\n .help(\"Select the package from the given source\")\n .value_parser(parse_crate)\n .num_args(0..),\n )\n .arg(\n opt(\"version\", \"Specify a version to install\")\n .alias(\"vers\")\n .value_name(\"VERSION\")\n .value_parser(parse_semver_flag)\n .requires(\"crate\"),\n )\n .arg(\n opt(\"index\", \"Registry index to install from\")\n .value_name(\"INDEX\")\n .requires(\"crate\")\n .conflicts_with_all(&[\"git\", \"path\", \"registry\"]),\n )\n .arg(\n opt(\"registry\", \"Registry to use\")\n .value_name(\"REGISTRY\")\n .requires(\"crate\")\n .conflicts_with_all(&[\"git\", \"path\", \"index\"]),\n )\n .arg(\n opt(\"git\", \"Git URL to install the specified crate from\")\n .value_name(\"URL\")\n .conflicts_with_all(&[\"path\", \"index\", \"registry\"]),\n )\n .arg(\n opt(\"branch\", \"Branch to use when installing from git\")\n .value_name(\"BRANCH\")\n .requires(\"git\"),\n )\n .arg(\n opt(\"tag\", \"Tag to use when installing from git\")\n .value_name(\"TAG\")\n .requires(\"git\"),\n )\n .arg(\n opt(\"rev\", \"Specific commit to use when installing from git\")\n .value_name(\"SHA\")\n .requires(\"git\"),\n )\n .arg(\n opt(\"path\", \"Filesystem path to local crate to install from\")\n .value_name(\"PATH\")\n .conflicts_with_all(&[\"git\", \"index\", \"registry\"])\n .add(clap_complete::engine::ArgValueCompleter::new(\n clap_complete::engine::PathCompleter::any()\n .filter(|path| path.join(\"Cargo.toml\").exists()),\n )),\n )\n .arg(opt(\"root\", \"Directory to install packages into\").value_name(\"DIR\"))\n .arg(flag(\"force\", \"Force overwriting existing crates or binaries\").short('f'))\n .arg_dry_run(\"Perform all checks without installing (unstable)\")\n .arg(flag(\"no-track\", \"Do not save tracking information\"))\n .arg(flag(\n \"list\",\n \"List all installed packages and their versions\",\n ))\n .arg_ignore_rust_version()\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_targets_bins_examples(\n \"Install only the specified binary\",\n \"Install all binaries\",\n \"Install only the specified example\",\n \"Install all examples\",\n )\n .arg_features()\n .arg_parallel()\n .arg(\n flag(\n \"debug\",\n \"Build in debug mode (with the 'dev' profile) instead of release mode\",\n )\n .conflicts_with(\"profile\"),\n )\n .arg_redundant_default_mode(\"release\", \"install\", \"debug\")\n .arg_profile(\"Install artifacts with the specified profile\")\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg_timings()\n .after_help(color_print::cstr!(\n \"Run `cargo help install` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let path = args.value_of_path(\"path\", gctx);\n if let Some(path) = &path {\n gctx.reload_rooted_at(path)?;\n } else {\n // TODO: Consider calling set_search_stop_path(home).\n gctx.reload_rooted_at(gctx.home().clone().into_path_unlocked())?;\n }\n\n // In general, we try to avoid normalizing paths in Cargo,\n // but in these particular cases we need it to fix rust-lang/cargo#10283.\n // (Handle `SourceId::for_path` and `Workspace::new`,\n // but not `GlobalContext::reload_rooted_at` which is always cwd)\n let path = path.map(|p| paths::normalize_path(&p));\n\n let version = args.get_one::(\"version\");\n let krates = args\n .get_many::(\"crate\")\n .unwrap_or_default()\n .cloned()\n .dedup_by(|x, y| x == y)\n .map(|(krate, local_version)| resolve_crate(krate, local_version, version))\n .collect::>>()?;\n\n for (crate_name, _) in krates.iter() {\n let package_name = PackageName::new(crate_name);\n if !crate_name.contains(\"@\") && package_name.is_err() {\n for (idx, ch) in crate_name.char_indices() {\n if !(unicode_ident::is_xid_continue(ch) || ch == '-') {\n let mut suggested_crate_name = crate_name.to_string();\n suggested_crate_name.insert_str(idx, \"@\");\n if let Ok((_, Some(_))) = parse_crate(&suggested_crate_name.as_str()) {\n let err = package_name.unwrap_err();\n return Err(\n anyhow::format_err!(\"{err}\\n\\n\\\n help: if this is meant to be a package name followed by a version, insert an `@` like `{suggested_crate_name}`\").into());\n }\n }\n }\n }\n\n if let Some(toolchain) = crate_name.strip_prefix(\"+\") {\n return Err(anyhow!(\n \"invalid character `+` in package name: `+{toolchain}`\n Use `cargo +{toolchain} install` if you meant to use the `{toolchain}` toolchain.\"\n )\n .into());\n }\n\n if let Ok(url) = crate_name.into_url() {\n if matches!(url.scheme(), \"http\" | \"https\") {\n return Err(anyhow!(\n \"invalid package name: `{url}`\n Use `cargo install --git {url}` if you meant to install from a git repository.\"\n )\n .into());\n }\n }\n\n if crate_name != \".\"\n && let Err(e) = package_name\n {\n return Err(anyhow::format_err!(\"{e}\").into());\n }\n }\n\n let mut from_cwd = false;\n\n let source = if let Some(url) = args.get_one::(\"git\") {\n let url = url.into_url()?;\n let gitref = if let Some(branch) = args.get_one::(\"branch\") {\n GitReference::Branch(branch.clone())\n } else if let Some(tag) = args.get_one::(\"tag\") {\n GitReference::Tag(tag.clone())\n } else if let Some(rev) = args.get_one::(\"rev\") {\n GitReference::Rev(rev.clone())\n } else {\n GitReference::DefaultBranch\n };\n SourceId::for_git(&url, gitref)?\n } else if let Some(path) = &path {\n SourceId::for_path(path)?\n } else if krates.is_empty() {\n from_cwd = true;\n SourceId::for_path(gctx.cwd())?\n } else if let Some(reg_or_index) = args.registry_or_index(gctx)? {\n match reg_or_index {\n ops::RegistryOrIndex::Registry(r) => SourceId::alt_registry(gctx, &r)?,\n ops::RegistryOrIndex::Index(url) => SourceId::for_registry(&url)?,\n }\n } else {\n SourceId::crates_io(gctx)?\n };\n\n let root = args.get_one::(\"root\").map(String::as_str);\n\n // We only provide workspace information for local crate installation from\n // one of the following sources:\n // - From current working directory (only work for edition 2015).\n // - From a specific local file path (from `--path` arg).\n //\n // This workspace information is for emitting helpful messages from\n // `ArgMatchesExt::compile_options` and won't affect the actual compilation.\n let workspace = if from_cwd {\n args.workspace(gctx).ok()\n } else if let Some(path) = &path {\n Workspace::new(&path.join(\"Cargo.toml\"), gctx).ok()\n } else {\n None\n };\n\n let mut compile_opts = args.compile_options(\n gctx,\n UserIntent::Build,\n workspace.as_ref(),\n ProfileChecking::Custom,\n )?;\n\n compile_opts.build_config.requested_profile =\n args.get_profile_name(\"release\", ProfileChecking::Custom)?;\n if args.dry_run() {\n gctx.cli_unstable().fail_if_stable_opt(\"--dry-run\", 11123)?;\n }\n\n if args.flag(\"list\") {\n ops::install_list(root, gctx)?;\n } else {\n ops::install(\n gctx,\n root,\n krates,\n source,\n from_cwd,\n &compile_opts,\n args.flag(\"force\"),\n args.flag(\"no-track\"),\n args.dry_run(),\n )?;\n }\n Ok(())\n}\n\ntype CrateVersion = (String, Option);\n\nfn parse_crate(krate: &str) -> crate::CargoResult {\n let (krate, version) = if let Some((k, v)) = krate.split_once('@') {\n if k.is_empty() {\n // by convention, arguments starting with `@` are response files\n anyhow::bail!(\"missing crate name before '@'\");\n }\n let krate = k.to_owned();\n let version = Some(parse_semver_flag(v)?);\n (krate, version)\n } else {\n let krate = krate.to_owned();\n let version = None;\n (krate, version)\n };\n\n if krate.is_empty() {\n anyhow::bail!(\"crate name is empty\");\n }\n\n Ok((krate, version))\n}\n\n/// Parses x.y.z as if it were =x.y.z, and gives CLI-specific error messages in the case of invalid\n/// values.\nfn parse_semver_flag(v: &str) -> CargoResult {\n // If the version begins with character <, >, =, ^, ~ parse it as a\n // version range, otherwise parse it as a specific version\n let first = v\n .chars()\n .next()\n .ok_or_else(|| format_err!(\"no version provided for the `--version` flag\"))?;\n\n if let Some(stripped) = v.strip_prefix(\"v\") {\n bail!(\n \"the version provided, `{v}` is not a valid SemVer requirement\\n\\n\\\n help: try changing the version to `{stripped}`\",\n )\n }\n let is_req = \"<>=^~\".contains(first) || v.contains('*');\n if is_req {\n match v.parse::() {\n Ok(v) => Ok(v),\n Err(_) => bail!(\n \"the `--version` provided, `{}`, is \\\n not a valid semver version requirement\\n\\n\\\n Please have a look at \\\n https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html \\\n for the correct format\",\n v\n ),\n }\n } else {\n match v.trim().parse::() {\n Ok(v) => Ok(v.to_exact_req()),\n Err(e) => {\n let mut msg = e.to_string();\n\n // If it is not a valid version but it is a valid version\n // requirement, add a note to the warning\n if v.parse::().is_ok() {\n msg.push_str(&format!(\n \"\\n\\n tip: if you want to specify SemVer range, \\\n add an explicit qualifier, like '^{}'\",\n v\n ));\n }\n bail!(msg);\n }\n }\n }\n}\n\nfn resolve_crate(\n krate: String,\n local_version: Option,\n version: Option<&VersionReq>,\n) -> crate::CargoResult {\n let version = match (local_version, version) {\n (Some(_), Some(_)) => {\n anyhow::bail!(\"cannot specify both `@` and `--version `\");\n }\n (Some(l), None) => Some(l),\n (None, Some(g)) => Some(g.to_owned()),\n (None, None) => None,\n };\n Ok((krate, version))\n}\n" }, { "path": "src/bin/cargo/commands/locate_project.rs", "content": "use crate::command_prelude::*;\nuse anyhow::bail;\nuse cargo::{CargoResult, drop_println};\nuse serde::Serialize;\n\npub fn cli() -> Command {\n subcommand(\"locate-project\")\n .about(\"Print a JSON representation of a Cargo.toml file's location\")\n .arg(flag(\"workspace\", \"Locate Cargo.toml of the workspace root\"))\n .arg(\n opt(\"message-format\", \"Output representation\")\n .value_name(\"FMT\")\n .value_parser([\"json\", \"plain\"])\n .ignore_case(true),\n )\n .arg_silent_suggestion()\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help locate-project` for more detailed information.\\n\"\n ))\n}\n\n#[derive(Serialize)]\npub struct ProjectLocation<'a> {\n root: &'a str,\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let root_manifest;\n let workspace_root;\n let workspace;\n let root = match WhatToFind::parse(args) {\n WhatToFind::CurrentManifest => {\n root_manifest = args.root_manifest(gctx)?;\n &root_manifest\n }\n WhatToFind::Workspace => {\n root_manifest = args.root_manifest(gctx)?;\n // Try fast path first - only works when package is explicitly listed in members\n if let Some(ws_root) =\n cargo::core::find_workspace_root_with_membership_check(&root_manifest, gctx)?\n {\n workspace_root = ws_root;\n &workspace_root\n } else {\n // Fallback to full workspace loading for path dependency membership.\n // If loading fails, we must propagate the error to avoid false results.\n workspace = args.workspace(gctx)?;\n workspace.root_manifest()\n }\n }\n };\n\n let root = root\n .to_str()\n .ok_or_else(|| {\n anyhow::format_err!(\n \"your package path contains characters \\\n not representable in Unicode\"\n )\n })\n .map_err(|e| CliError::new(e, 1))?;\n\n let location = ProjectLocation { root };\n\n match MessageFormat::parse(args)? {\n MessageFormat::Json => gctx.shell().print_json(&location)?,\n MessageFormat::Plain => drop_println!(gctx, \"{}\", location.root),\n }\n\n Ok(())\n}\n\nenum WhatToFind {\n CurrentManifest,\n Workspace,\n}\n\nimpl WhatToFind {\n fn parse(args: &ArgMatches) -> Self {\n if args.flag(\"workspace\") {\n WhatToFind::Workspace\n } else {\n WhatToFind::CurrentManifest\n }\n }\n}\n\nenum MessageFormat {\n Json,\n Plain,\n}\n\nimpl MessageFormat {\n fn parse(args: &ArgMatches) -> CargoResult {\n let fmt = match args.get_one::(\"message-format\") {\n Some(fmt) => fmt,\n None => return Ok(MessageFormat::Json),\n };\n match fmt.to_ascii_lowercase().as_str() {\n \"json\" => Ok(MessageFormat::Json),\n \"plain\" => Ok(MessageFormat::Plain),\n s => bail!(\"invalid message format specifier: `{}`\", s),\n }\n }\n}\n" }, { "path": "src/bin/cargo/commands/login.rs", "content": "use cargo::ops;\nuse cargo::ops::RegistryOrIndex;\n\nuse crate::command_prelude::*;\n\npub fn cli() -> Command {\n subcommand(\"login\")\n .about(\"Log in to a registry.\")\n .arg(\n Arg::new(\"token\")\n .value_name(\"TOKEN\")\n .action(ArgAction::Set)\n .hide(true),\n )\n .arg_registry(\"Registry to use\")\n .arg(\n Arg::new(\"args\")\n .help(\"Additional arguments for the credential provider\")\n .num_args(0..)\n .last(true),\n )\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help login` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let reg = args.registry_or_index(gctx)?;\n assert!(\n !matches!(reg, Some(RegistryOrIndex::Index(..))),\n \"must not be index URL\"\n );\n\n let token = args.get_one::(\"token\").map(|s| s.as_str().into());\n if token.is_some() {\n let _ = gctx\n .shell()\n .warn(\"`cargo login ` is deprecated in favor of reading `` from stdin\");\n }\n\n let extra_args = args\n .get_many::(\"args\")\n .unwrap_or_default()\n .map(String::as_str)\n .collect::>();\n ops::registry_login(gctx, token, reg.as_ref(), &extra_args)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/logout.rs", "content": "use cargo::ops;\nuse cargo::ops::RegistryOrIndex;\n\nuse crate::command_prelude::*;\n\npub fn cli() -> Command {\n subcommand(\"logout\")\n .about(\"Remove an API token from the registry locally\")\n .arg_registry(\"Registry to use\")\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help logout` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let reg = args.registry_or_index(gctx)?;\n assert!(\n !matches!(reg, Some(RegistryOrIndex::Index(..))),\n \"must not be index URL\"\n );\n\n ops::registry_logout(gctx, reg)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/metadata.rs", "content": "use cargo::ops::{self, OutputMetadataOptions};\n\nuse crate::command_prelude::*;\n\npub fn cli() -> Command {\n subcommand(\"metadata\")\n .about(\n \"Output the resolved dependencies of a package, \\\n the concrete used versions including overrides, \\\n in machine-readable format\",\n )\n .arg(multi_opt(\n \"filter-platform\",\n \"TRIPLE\",\n \"Only include resolve dependencies matching the given target-triple\",\n ))\n .arg(flag(\n \"no-deps\",\n \"Output information only about the workspace members \\\n and don't fetch dependencies\",\n ))\n .arg(\n opt(\"format-version\", \"Format version\")\n .value_name(\"VERSION\")\n .value_parser([\"1\"]),\n )\n .arg_silent_suggestion()\n .arg_features()\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help metadata` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n\n let version = match args.get_one::(\"format-version\") {\n None => {\n gctx.shell().warn(\n \"please specify `--format-version` flag explicitly \\\n to avoid compatibility problems\",\n )?;\n 1\n }\n Some(version) => version.parse().unwrap(),\n };\n\n let options = OutputMetadataOptions {\n cli_features: args.cli_features()?,\n no_deps: args.flag(\"no-deps\"),\n filter_platforms: args._values_of(\"filter-platform\"),\n version,\n };\n\n let result = ops::output_metadata(&ws, &options)?;\n gctx.shell().print_json(&result)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/mod.rs", "content": "use crate::command_prelude::*;\n\npub fn builtin() -> Vec {\n vec![\n add::cli(),\n bench::cli(),\n build::cli(),\n check::cli(),\n clean::cli(),\n config::cli(),\n doc::cli(),\n fetch::cli(),\n fix::cli(),\n generate_lockfile::cli(),\n git_checkout::cli(),\n help::cli(),\n info::cli(),\n init::cli(),\n install::cli(),\n locate_project::cli(),\n login::cli(),\n logout::cli(),\n metadata::cli(),\n new::cli(),\n owner::cli(),\n package::cli(),\n pkgid::cli(),\n publish::cli(),\n read_manifest::cli(),\n remove::cli(),\n report::cli(),\n run::cli(),\n rustc::cli(),\n rustdoc::cli(),\n search::cli(),\n test::cli(),\n tree::cli(),\n uninstall::cli(),\n update::cli(),\n vendor::cli(),\n verify_project::cli(),\n version::cli(),\n yank::cli(),\n ]\n}\n\npub type Exec = fn(&mut GlobalContext, &ArgMatches) -> CliResult;\n\npub fn builtin_exec(cmd: &str) -> Option {\n let f = match cmd {\n \"add\" => add::exec,\n \"bench\" => bench::exec,\n \"build\" => build::exec,\n \"check\" => check::exec,\n \"clean\" => clean::exec,\n \"config\" => config::exec,\n \"doc\" => doc::exec,\n \"fetch\" => fetch::exec,\n \"fix\" => fix::exec,\n \"generate-lockfile\" => generate_lockfile::exec,\n \"git-checkout\" => git_checkout::exec,\n \"help\" => help::exec,\n \"info\" => info::exec,\n \"init\" => init::exec,\n \"install\" => install::exec,\n \"locate-project\" => locate_project::exec,\n \"login\" => login::exec,\n \"logout\" => logout::exec,\n \"metadata\" => metadata::exec,\n \"new\" => new::exec,\n \"owner\" => owner::exec,\n \"package\" => package::exec,\n \"pkgid\" => pkgid::exec,\n \"publish\" => publish::exec,\n \"read-manifest\" => read_manifest::exec,\n \"remove\" => remove::exec,\n \"report\" => report::exec,\n \"run\" => run::exec,\n \"rustc\" => rustc::exec,\n \"rustdoc\" => rustdoc::exec,\n \"search\" => search::exec,\n \"test\" => test::exec,\n \"tree\" => tree::exec,\n \"uninstall\" => uninstall::exec,\n \"update\" => update::exec,\n \"vendor\" => vendor::exec,\n \"verify-project\" => verify_project::exec,\n \"version\" => version::exec,\n \"yank\" => yank::exec,\n _ => return None,\n };\n Some(f)\n}\n\npub mod add;\npub mod bench;\npub mod build;\npub mod check;\npub mod clean;\npub mod config;\npub mod doc;\npub mod fetch;\npub mod fix;\npub mod generate_lockfile;\npub mod git_checkout;\npub mod help;\npub mod info;\npub mod init;\npub mod install;\npub mod locate_project;\npub mod login;\npub mod logout;\npub mod metadata;\npub mod new;\npub mod owner;\npub mod package;\npub mod pkgid;\npub mod publish;\npub mod read_manifest;\npub mod remove;\npub mod report;\npub mod run;\npub mod rustc;\npub mod rustdoc;\npub mod search;\npub mod test;\npub mod tree;\npub mod uninstall;\npub mod update;\npub mod vendor;\npub mod verify_project;\npub mod version;\npub mod yank;\n" }, { "path": "src/bin/cargo/commands/new.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"new\")\n .about(\"Create a new cargo package at \")\n .arg(\n Arg::new(\"path\")\n .value_name(\"PATH\")\n .action(ArgAction::Set)\n .required(true),\n )\n .arg_new_opts()\n .arg_registry(\"Registry to use\")\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help new` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let opts = args.new_options(gctx)?;\n\n ops::new(&opts, gctx)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/owner.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops::{self, OwnersOptions};\nuse cargo_credential::Secret;\n\npub fn cli() -> Command {\n subcommand(\"owner\")\n .about(\"Manage the owners of a crate on the registry\")\n .arg(Arg::new(\"crate\").value_name(\"CRATE\").action(ArgAction::Set))\n .arg(\n multi_opt(\n \"add\",\n \"LOGIN\",\n \"Name of a user or team to invite as an owner\",\n )\n .short('a'),\n )\n .arg(\n multi_opt(\n \"remove\",\n \"LOGIN\",\n \"Name of a user or team to remove as an owner\",\n )\n .short('r'),\n )\n .arg(flag(\"list\", \"List owners of a crate\").short('l'))\n .arg_index(\"Registry index URL to modify owners for\")\n .arg_registry(\"Registry to modify owners for\")\n .arg(opt(\"token\", \"API token to use when authenticating\").value_name(\"TOKEN\"))\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help owner` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let opts = OwnersOptions {\n krate: args.get_one::(\"crate\").cloned(),\n token: args.get_one::(\"token\").cloned().map(Secret::from),\n reg_or_index: args.registry_or_index(gctx)?,\n to_add: args\n .get_many::(\"add\")\n .map(|xs| xs.cloned().collect()),\n to_remove: args\n .get_many::(\"remove\")\n .map(|xs| xs.cloned().collect()),\n list: args.flag(\"list\"),\n };\n ops::modify_owners(gctx, &opts)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/package.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops;\nuse cargo::ops::PackageMessageFormat;\nuse cargo::ops::PackageOpts;\nuse clap_complete::ArgValueCandidates;\n\npub fn cli() -> Command {\n subcommand(\"package\")\n .about(\"Assemble the local package into a distributable tarball\")\n .arg_index(\"Registry index URL to prepare the package for\")\n .arg_registry(\"Registry to prepare the package for\")\n .arg(\n flag(\n \"list\",\n \"Print files included in a package without making one\",\n )\n .short('l'),\n )\n .arg(flag(\n \"no-verify\",\n \"Don't verify the contents by building them\",\n ))\n .arg(flag(\n \"no-metadata\",\n \"Ignore warnings about a lack of human-usable metadata\",\n ))\n .arg(flag(\n \"allow-dirty\",\n \"Allow dirty working directories to be packaged\",\n ))\n .arg(flag(\n \"exclude-lockfile\",\n \"Don't include the lock file when packaging\",\n ))\n .arg(\n opt(\"message-format\", \"Output representation (unstable)\")\n .value_name(\"FMT\")\n // This currently requires and only works with `--list`.\n .requires(\"list\")\n .value_parser(PackageMessageFormat::POSSIBLE_VALUES),\n )\n .arg_silent_suggestion()\n .arg_package_spec_no_all(\n \"Package(s) to assemble\",\n \"Assemble all packages in the workspace\",\n \"Don't assemble specified packages\",\n ArgValueCandidates::new(get_ws_member_candidates),\n )\n .arg_features()\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg_parallel()\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help package` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let reg_or_index = args.registry_or_index(gctx)?;\n let ws = args.workspace(gctx)?;\n if ws.root_maybe().is_embedded() {\n return Err(anyhow::format_err!(\n \"{} is unsupported by `cargo package`\",\n ws.root_manifest().display()\n )\n .into());\n }\n let specs = args.packages_from_flags()?;\n\n let fmt = if let Some(fmt) = args._value_of(\"message-format\") {\n gctx.cli_unstable()\n .fail_if_stable_opt(\"--message-format\", 15353)?;\n fmt.parse()?\n } else {\n PackageMessageFormat::Human\n };\n\n ops::package(\n &ws,\n &PackageOpts {\n gctx,\n verify: !args.flag(\"no-verify\"),\n list: args.flag(\"list\"),\n fmt,\n check_metadata: !args.flag(\"no-metadata\"),\n allow_dirty: args.flag(\"allow-dirty\"),\n include_lockfile: !args.flag(\"exclude-lockfile\"),\n to_package: specs,\n targets: args.targets()?,\n jobs: args.jobs()?,\n keep_going: args.keep_going(),\n cli_features: args.cli_features()?,\n reg_or_index,\n dry_run: false,\n },\n )?;\n\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/pkgid.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops;\nuse cargo::util::print_available_packages;\n\npub fn cli() -> Command {\n subcommand(\"pkgid\")\n .about(\"Print a fully qualified package specification\")\n .arg(Arg::new(\"spec\").value_name(\"SPEC\").action(ArgAction::Set))\n .arg_silent_suggestion()\n .arg_package(\"Argument to get the package ID specifier for\")\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help pkgid` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n if args.is_present_with_zero_values(\"package\") {\n print_available_packages(&ws)?\n }\n let spec = args\n .get_one::(\"spec\")\n .or_else(|| args.get_one::(\"package\"))\n .map(String::as_str);\n let spec = ops::pkgid(&ws, spec)?;\n cargo::drop_println!(gctx, \"{}\", spec);\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/publish.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::ops::{self, PublishOpts};\nuse cargo_credential::Secret;\nuse clap_complete::ArgValueCandidates;\n\npub fn cli() -> Command {\n subcommand(\"publish\")\n .about(\"Upload a package to the registry\")\n .arg_dry_run(\"Perform all checks without uploading\")\n .arg_index(\"Registry index URL to upload the package to\")\n .arg_registry(\"Registry to upload the package to\")\n .arg(\n opt(\"token\", \"Token to use when uploading\")\n .value_name(\"TOKEN\")\n .hide(true),\n )\n .arg(flag(\n \"no-verify\",\n \"Don't verify the contents by building them\",\n ))\n .arg(flag(\n \"allow-dirty\",\n \"Allow dirty working directories to be packaged\",\n ))\n .arg_silent_suggestion()\n .arg_package_spec_no_all(\n \"Package(s) to publish\",\n \"Publish all packages in the workspace\",\n \"Don't publish specified packages\",\n ArgValueCandidates::new(get_ws_member_candidates),\n )\n .arg_features()\n .arg_parallel()\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help publish` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let reg_or_index = args.registry_or_index(gctx)?;\n let ws = args.workspace(gctx)?;\n if ws.root_maybe().is_embedded() {\n return Err(anyhow::format_err!(\n \"{} is unsupported by `cargo publish`\",\n ws.root_manifest().display()\n )\n .into());\n }\n\n let token = args.get_one::(\"token\").cloned().map(Secret::from);\n if token.is_some() {\n let _ = gctx.shell().warn(\"`cargo publish --token` is deprecated in favor of using `cargo login` and environment variables\");\n }\n\n ops::publish(\n &ws,\n &PublishOpts {\n gctx,\n token,\n reg_or_index,\n verify: !args.flag(\"no-verify\"),\n allow_dirty: args.flag(\"allow-dirty\"),\n to_publish: args.packages_from_flags()?,\n targets: args.targets()?,\n jobs: args.jobs()?,\n keep_going: args.keep_going(),\n dry_run: args.dry_run(),\n cli_features: args.cli_features()?,\n },\n )?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/read_manifest.rs", "content": "//! Deprecated.\n\nuse crate::command_prelude::*;\n\npub fn cli() -> Command {\n subcommand(\"read-manifest\")\n .hide(true)\n .about(color_print::cstr!(\n \"\\\nDEPRECATED: Print a JSON representation of a Cargo.toml manifest.\n\nUse `cargo metadata --no-deps` instead.\\\n\"\n ))\n .arg_silent_suggestion()\n .arg_manifest_path()\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n gctx.shell().print_json(\n &ws.current()?\n .serialized(gctx.cli_unstable(), ws.unstable_features()),\n )?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/remove.rs", "content": "use cargo::CargoResult;\nuse cargo::core::PackageIdSpec;\nuse cargo::core::PackageIdSpecQuery;\nuse cargo::core::Resolve;\nuse cargo::core::Workspace;\nuse cargo::core::dependency::DepKind;\nuse cargo::ops::cargo_remove::RemoveOptions;\nuse cargo::ops::cargo_remove::remove;\nuse cargo::ops::resolve_ws;\nuse cargo::util::command_prelude::*;\nuse cargo::util::print_available_packages;\nuse cargo::util::toml_mut::dependency::Dependency;\nuse cargo::util::toml_mut::dependency::MaybeWorkspace;\nuse cargo::util::toml_mut::dependency::Source;\nuse cargo::util::toml_mut::manifest::DepTable;\nuse cargo::util::toml_mut::manifest::LocalManifest;\n\npub fn cli() -> clap::Command {\n clap::Command::new(\"remove\")\n // Subcommand aliases are handled in `aliased_command()`.\n // .alias(\"rm\")\n .about(\"Remove dependencies from a Cargo.toml manifest file\")\n .args([clap::Arg::new(\"dependencies\")\n .action(clap::ArgAction::Append)\n .required(true)\n .num_args(1..)\n .value_name(\"DEP_ID\")\n .help(\"Dependencies to be removed\")\n .add(clap_complete::ArgValueCandidates::new(\n get_direct_dependencies_pkg_name_candidates,\n ))])\n .arg_dry_run(\"Don't actually write the manifest\")\n .arg_silent_suggestion()\n .next_help_heading(\"Section\")\n .args([\n clap::Arg::new(\"dev\")\n .long(\"dev\")\n .conflicts_with(\"build\")\n .action(clap::ArgAction::SetTrue)\n .group(\"section\")\n .help(\"Remove from dev-dependencies\"),\n clap::Arg::new(\"build\")\n .long(\"build\")\n .conflicts_with(\"dev\")\n .action(clap::ArgAction::SetTrue)\n .group(\"section\")\n .help(\"Remove from build-dependencies\"),\n clap::Arg::new(\"target\")\n .long(\"target\")\n .num_args(1)\n .value_name(\"TARGET\")\n .value_parser(clap::builder::NonEmptyStringValueParser::new())\n .help(\"Remove from target-dependencies\"),\n ])\n .arg_package(\"Package to remove from\")\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help remove` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let dry_run = args.dry_run();\n\n let workspace = args.workspace(gctx)?;\n\n if args.is_present_with_zero_values(\"package\") {\n print_available_packages(&workspace)?;\n }\n\n let packages = args.packages_from_flags()?;\n let packages = packages.get_packages(&workspace)?;\n let spec = match packages.len() {\n 0 => {\n return Err(CliError::new(\n anyhow::format_err!(\n \"no package selected to modify\nhelp: specify a package with `-p `\"\n ),\n 101,\n ));\n }\n 1 => packages[0],\n _ => {\n let names = packages.iter().map(|p| p.name()).collect::>();\n return Err(CliError::new(\n anyhow::format_err!(\n \"no package selected to modify\nhelp: specify a package with `-p `\n available packages: {}\",\n names.join(\", \")\n ),\n 101,\n ));\n }\n };\n\n let dependencies = args\n .get_many::(\"dependencies\")\n .expect(\"required(true)\")\n .cloned()\n .collect::>();\n\n let section = parse_section(args);\n\n let options = RemoveOptions {\n gctx,\n spec,\n dependencies,\n section,\n dry_run,\n };\n remove(&options)?;\n\n if !dry_run {\n // Clean up the workspace\n gc_workspace(&workspace)?;\n\n // Reload the workspace since we've changed dependencies\n let ws = args.workspace(gctx)?;\n let resolve = {\n // HACK: Avoid unused patch warnings by temporarily changing the verbosity.\n // In rare cases, this might cause index update messages to not show up\n let verbosity = ws.gctx().shell().verbosity();\n ws.gctx()\n .shell()\n .set_verbosity(cargo::core::Verbosity::Quiet);\n let resolve = resolve_ws(&ws, dry_run);\n ws.gctx().shell().set_verbosity(verbosity);\n resolve?.1\n };\n\n // Attempt to gc unused patches and re-resolve if anything is removed\n if gc_unused_patches(&workspace, &resolve)? {\n let ws = args.workspace(gctx)?;\n resolve_ws(&ws, dry_run)?;\n }\n }\n Ok(())\n}\n\nfn parse_section(args: &ArgMatches) -> DepTable {\n let dev = args.flag(\"dev\");\n let build = args.flag(\"build\");\n\n let kind = if dev {\n DepKind::Development\n } else if build {\n DepKind::Build\n } else {\n DepKind::Normal\n };\n\n let mut table = DepTable::new().set_kind(kind);\n\n if let Some(target) = args.get_one::(\"target\") {\n assert!(!target.is_empty(), \"Target specification may not be empty\");\n table = table.set_target(target);\n }\n\n table\n}\n\n/// Clean up the workspace.dependencies, profile, patch, and replace sections of the root manifest\n/// by removing dependencies which no longer have a reference to them.\nfn gc_workspace(workspace: &Workspace<'_>) -> CargoResult<()> {\n let mut workspace_manifest = LocalManifest::try_new(workspace.root_manifest())?;\n let mut is_modified = true;\n\n let members = workspace\n .members()\n .map(|p| {\n Ok((\n LocalManifest::try_new(p.manifest_path())?,\n p.manifest().unstable_features(),\n ))\n })\n .collect::>>()?;\n\n let mut dependencies = members\n .into_iter()\n .flat_map(|(member_manifest, unstable_features)| {\n member_manifest\n .get_sections()\n .into_iter()\n .flat_map(move |(_, table)| {\n table\n .as_table_like()\n .unwrap()\n .iter()\n .map(|(key, item)| {\n Dependency::from_toml(\n workspace.gctx(),\n workspace.root(),\n &member_manifest.path,\n &unstable_features,\n key,\n item,\n )\n })\n .collect::>()\n })\n })\n .collect::>>()?;\n\n // Clean up the workspace.dependencies section and replace instances of\n // workspace dependencies with their definitions\n if let Some(toml_edit::Item::Table(deps_table)) = workspace_manifest\n .data\n .get_mut(\"workspace\")\n .and_then(|t| t.get_mut(\"dependencies\"))\n {\n deps_table.set_implicit(true);\n for (key, item) in deps_table.iter_mut() {\n let ws_dep = Dependency::from_toml(\n workspace.gctx(),\n workspace.root(),\n &workspace.root(),\n workspace.unstable_features(),\n key.get(),\n item,\n )?;\n\n // search for uses of this workspace dependency\n let mut is_used = false;\n for dep in dependencies.iter_mut().filter(|d| {\n d.toml_key() == key.get() && matches!(d.source(), Some(Source::Workspace(_)))\n }) {\n // HACK: Replace workspace references in `dependencies` to simplify later GC steps:\n // 1. Avoid having to look it up again to determine the dependency source / spec\n // 2. The entry might get deleted, preventing us from looking it up again\n //\n // This does lose extra information, like features enabled, but that shouldn't be a\n // problem for GC\n *dep = ws_dep.clone();\n\n is_used = true;\n }\n\n if !is_used {\n *item = toml_edit::Item::None;\n is_modified = true;\n }\n }\n }\n\n // Clean up the profile section\n //\n // Example tables:\n // - profile.dev.package.foo\n // - profile.release.package.\"foo:2.1.0\"\n if let Some(toml_edit::Item::Table(profile_section_table)) =\n workspace_manifest.data.get_mut(\"profile\")\n {\n profile_section_table.set_implicit(true);\n\n for (_, item) in profile_section_table.iter_mut() {\n if let toml_edit::Item::Table(profile_table) = item {\n profile_table.set_implicit(true);\n\n if let Some(toml_edit::Item::Table(package_table)) =\n profile_table.get_mut(\"package\")\n {\n package_table.set_implicit(true);\n\n for (key, item) in package_table.iter_mut() {\n let key = key.get();\n // Skip globs. Can't do anything with them.\n // For example, profile.release.package.\"*\".\n if crate::util::restricted_names::is_glob_pattern(key) {\n continue;\n }\n if !spec_has_match(\n &PackageIdSpec::parse(key)?,\n &dependencies,\n workspace.gctx(),\n )? {\n *item = toml_edit::Item::None;\n is_modified = true;\n }\n }\n }\n }\n }\n }\n\n // Clean up the replace section\n if let Some(toml_edit::Item::Table(table)) = workspace_manifest.data.get_mut(\"replace\") {\n table.set_implicit(true);\n\n for (key, item) in table.iter_mut() {\n if !spec_has_match(\n &PackageIdSpec::parse(key.get())?,\n &dependencies,\n workspace.gctx(),\n )? {\n *item = toml_edit::Item::None;\n is_modified = true;\n }\n }\n }\n\n if is_modified {\n workspace_manifest.write()?;\n }\n\n Ok(())\n}\n\n/// Check whether or not a package ID spec matches any non-workspace dependencies.\nfn spec_has_match(\n spec: &PackageIdSpec,\n dependencies: &[Dependency],\n gctx: &GlobalContext,\n) -> CargoResult {\n for dep in dependencies {\n if spec.name() != &dep.name {\n continue;\n }\n\n let version_matches = match (spec.version(), dep.version()) {\n (Some(v), Some(vq)) => semver::VersionReq::parse(vq)?.matches(&v),\n (Some(_), None) => false,\n (None, None | Some(_)) => true,\n };\n if !version_matches {\n continue;\n }\n\n match dep.source_id(gctx)? {\n MaybeWorkspace::Other(source_id) => {\n if spec.url().map(|u| u == source_id.url()).unwrap_or(true) {\n return Ok(true);\n }\n }\n MaybeWorkspace::Workspace(_) => {}\n }\n }\n\n Ok(false)\n}\n\n/// Removes unused patches from the manifest\nfn gc_unused_patches(workspace: &Workspace<'_>, resolve: &Resolve) -> CargoResult {\n let mut workspace_manifest = LocalManifest::try_new(workspace.root_manifest())?;\n let mut modified = false;\n\n // Clean up the patch section\n if let Some(toml_edit::Item::Table(patch_section_table)) =\n workspace_manifest.data.get_mut(\"patch\")\n {\n patch_section_table.set_implicit(true);\n\n for (_, item) in patch_section_table.iter_mut() {\n if let toml_edit::Item::Table(patch_table) = item {\n patch_table.set_implicit(true);\n\n for (key, item) in patch_table.iter_mut() {\n let dep = Dependency::from_toml(\n workspace.gctx(),\n workspace.root(),\n &workspace.root_manifest(),\n workspace.unstable_features(),\n key.get(),\n item,\n )?;\n\n // Generate a PackageIdSpec url for querying\n let url = if let MaybeWorkspace::Other(source_id) =\n dep.source_id(workspace.gctx())?\n {\n format!(\"{}#{}\", source_id.url(), dep.name)\n } else {\n continue;\n };\n\n if PackageIdSpec::query_str(&url, resolve.unused_patches().iter().cloned())\n .is_ok()\n {\n *item = toml_edit::Item::None;\n modified = true;\n }\n }\n }\n }\n }\n\n if modified {\n workspace_manifest.write()?;\n }\n\n Ok(modified)\n}\n" }, { "path": "src/bin/cargo/commands/report.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::CargoResult;\nuse cargo::core::compiler::future_incompat::OnDiskReports;\nuse cargo::core::compiler::future_incompat::REPORT_PREAMBLE;\nuse cargo::drop_println;\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"report\")\n .about(\"Generate and display various kinds of reports\")\n .after_help(color_print::cstr!(\n \"Run `cargo help report` for more detailed information.\\n\"\n ))\n .subcommand_required(true)\n .arg_required_else_help(true)\n .subcommand(\n subcommand(\"future-incompatibilities\")\n .alias(\"future-incompat\")\n .about(\"Reports any crates which will eventually stop compiling\")\n .arg(\n opt(\n \"id\",\n \"identifier of the report generated by a Cargo command invocation\",\n )\n .value_name(\"id\"),\n )\n .arg_package(\"Package to display a report for\")\n .after_help(color_print::cstr!(\n \"Run `cargo help report future-incompatibilities` for more detailed information.\\n\"\n )),\n )\n .subcommand(\n subcommand(\"timings\")\n .about(\"Reports the build timings of previous sessions (unstable)\")\n .arg_manifest_path()\n .arg(flag(\"open\", \"Opens the timing report in a browser\"))\n .arg(opt(\"id\", \"Session ID to report on\").value_name(\"ID\")),\n )\n .subcommand(\n subcommand(\"sessions\")\n .about(\"Reports the previous sessions (unstable)\")\n .arg_manifest_path()\n .arg(\n opt(\"limit\", \"Limit the number of results\")\n .value_name(\"N\")\n .value_parser(clap::value_parser!(u64).range(1..))\n .default_value(\"10\"),\n ),\n )\n .subcommand(\n subcommand(\"rebuilds\")\n .about(\"Reports rebuild reasons from previous sessions (unstable)\")\n .arg_manifest_path()\n .arg(opt(\"id\", \"Session ID to report on\").value_name(\"ID\")),\n )\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n match args.subcommand() {\n Some((\"future-incompatibilities\", args)) => report_future_incompatibilities(gctx, args),\n Some((\"timings\", args)) => {\n gctx.cli_unstable().fail_if_stable_command(\n gctx,\n \"report timings\",\n 15844,\n \"build-analysis\",\n gctx.cli_unstable().build_analysis,\n )?;\n let opts = timings_opts(gctx, args)?;\n let ws = args.workspace(gctx).ok();\n ops::report_timings(gctx, ws.as_ref(), opts)?;\n Ok(())\n }\n Some((\"sessions\", args)) => {\n gctx.cli_unstable().fail_if_stable_command(\n gctx,\n \"report sessions\",\n 15844,\n \"build-analysis\",\n gctx.cli_unstable().build_analysis,\n )?;\n let ws = args.workspace(gctx).ok();\n let opts = sessions_opts(args)?;\n ops::report_sessions(gctx, ws.as_ref(), opts)?;\n Ok(())\n }\n Some((\"rebuilds\", args)) => {\n gctx.cli_unstable().fail_if_stable_command(\n gctx,\n \"report rebuilds\",\n 15844,\n \"build-analysis\",\n gctx.cli_unstable().build_analysis,\n )?;\n let ws = args.workspace(gctx).ok();\n let opts = rebuilds_opts(args)?;\n ops::report_rebuilds(gctx, ws.as_ref(), opts)?;\n Ok(())\n }\n Some((cmd, _)) => {\n unreachable!(\"unexpected command {}\", cmd)\n }\n None => {\n unreachable!(\"unexpected command\")\n }\n }\n}\n\nfn report_future_incompatibilities(gctx: &GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n let reports = OnDiskReports::load(&ws)?;\n let id = args\n .value_of_u32(\"id\")?\n .unwrap_or_else(|| reports.last_id());\n let krate = args.get_one::(\"package\").map(String::as_str);\n let report = reports.get_report(id, krate)?;\n drop_println!(gctx, \"{}\", REPORT_PREAMBLE);\n drop(gctx.shell().print_ansi_stdout(report.as_bytes()));\n Ok(())\n}\n\nfn timings_opts<'a>(\n gctx: &'a GlobalContext,\n args: &ArgMatches,\n) -> CargoResult> {\n let open_result = args.get_flag(\"open\");\n let id = args\n .get_one::(\"id\")\n .map(|s| s.parse())\n .transpose()?;\n\n Ok(ops::ReportTimingsOptions {\n open_result,\n gctx,\n id,\n })\n}\n\nfn sessions_opts(args: &ArgMatches) -> CargoResult {\n let limit = *args.get_one::(\"limit\").unwrap_or(&10);\n let limit = limit.min(usize::MAX as u64) as usize;\n\n Ok(ops::ReportSessionsOptions { limit })\n}\n\nfn rebuilds_opts(args: &ArgMatches) -> CargoResult {\n let id = args\n .get_one::(\"id\")\n .map(|s| s.parse())\n .transpose()?;\n\n Ok(ops::ReportRebuildsOptions { id })\n}\n" }, { "path": "src/bin/cargo/commands/run.rs", "content": "use std::ffi::OsStr;\nuse std::ffi::OsString;\nuse std::path::Path;\n\nuse crate::command_prelude::*;\nuse crate::util::restricted_names::is_glob_pattern;\nuse cargo::core::Verbosity;\nuse cargo::core::Workspace;\nuse cargo::ops::{self, CompileFilter, Packages};\nuse cargo::util::closest;\nuse cargo_util::ProcessError;\nuse itertools::Itertools as _;\n\npub fn cli() -> Command {\n subcommand(\"run\")\n // subcommand aliases are handled in aliased_command()\n // .alias(\"r\")\n .about(\"Run a binary or example of the local package\")\n .arg(\n Arg::new(\"args\")\n .value_name(\"ARGS\")\n .help(\"Arguments for the binary or example to run\")\n .value_parser(value_parser!(OsString))\n .num_args(0..)\n .trailing_var_arg(true),\n )\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_package(\"Package with the target to run\")\n .arg_targets_bin_example(\n \"Name of the bin target to run\",\n \"Name of the example target to run\",\n )\n .arg_features()\n .arg_parallel()\n .arg_release(\"Build artifacts in release mode, with optimizations\")\n .arg_profile(\"Build artifacts with the specified profile\")\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .arg_unit_graph()\n .arg_timings()\n .after_help(color_print::cstr!(\n \"Run `cargo help run` for more detailed information.\\n\\\n To pass `--help` to the specified binary, use `-- --help`.\\n\",\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n\n let mut compile_opts =\n args.compile_options(gctx, UserIntent::Build, Some(&ws), ProfileChecking::Custom)?;\n\n // Disallow `spec` to be an glob pattern\n if let Packages::Packages(opt_in) = &compile_opts.spec {\n if let Some(pattern) = opt_in.iter().find(|s| is_glob_pattern(s)) {\n return Err(anyhow::anyhow!(\n \"`cargo run` does not support glob pattern `{}` on package selection\",\n pattern,\n )\n .into());\n }\n }\n\n if !args.contains_id(\"example\") && !args.contains_id(\"bin\") {\n let default_runs: Vec<_> = compile_opts\n .spec\n .get_packages(&ws)?\n .iter()\n .filter_map(|pkg| pkg.manifest().default_run())\n .collect();\n if let [bin] = &default_runs[..] {\n compile_opts.filter = CompileFilter::single_bin(bin.to_string());\n } else {\n // ops::run will take care of errors if len pkgs != 1.\n compile_opts.filter = CompileFilter::Default {\n // Force this to false because the code in ops::run is not\n // able to pre-check features before compilation starts to\n // enforce that only 1 binary is built.\n required_features_filterable: false,\n };\n }\n };\n\n ops::run(&ws, &compile_opts, &values_os(args, \"args\")).map_err(|err| to_run_error(gctx, err))\n}\n\n/// See also `util/toml/mod.rs`s `is_embedded`\npub fn is_manifest_command(arg: &str) -> bool {\n let path = Path::new(arg);\n 1 < path.components().count() || path.extension() == Some(OsStr::new(\"rs\"))\n}\n\npub fn exec_manifest_command(gctx: &mut GlobalContext, cmd: &str, args: &[OsString]) -> CliResult {\n let manifest_path = Path::new(cmd);\n match (manifest_path.is_file(), gctx.cli_unstable().script) {\n (true, true) => {}\n (true, false) => {\n return Err(anyhow::anyhow!(\"running the file `{cmd}` requires `-Zscript`\").into());\n }\n (false, true) => {\n let possible_commands = crate::list_commands(gctx);\n let is_dir = if manifest_path.is_dir() {\n format!(\": `{cmd}` is a directory\")\n } else {\n \"\".to_owned()\n };\n let suggested_command = if let Some(suggested_command) = possible_commands\n .keys()\n .filter(|c| cmd.starts_with(c.as_str()))\n .max_by_key(|c| c.len())\n {\n let actual_args = cmd.strip_prefix(suggested_command).unwrap();\n let args = if args.is_empty() {\n \"\".to_owned()\n } else {\n format!(\n \" {}\",\n args.into_iter().map(|os| os.to_string_lossy()).join(\" \")\n )\n };\n format!(\n \"\\nhelp: there is a command with a similar name: `{suggested_command} {actual_args}{args}`\"\n )\n } else {\n \"\".to_owned()\n };\n let suggested_script = if let Some(suggested_script) = suggested_script(cmd) {\n format!(\"\\nhelp: there is a script with a similar name: `{suggested_script}`\")\n } else {\n \"\".to_owned()\n };\n return Err(anyhow::anyhow!(\n \"no such file or subcommand `{cmd}`{is_dir}{suggested_command}{suggested_script}\"\n )\n .into());\n }\n (false, false) => {\n // HACK: duplicating the above for minor tweaks but this will all go away on\n // stabilization\n let possible_commands = crate::list_commands(gctx);\n let suggested_command = if let Some(suggested_command) = possible_commands\n .keys()\n .filter(|c| cmd.starts_with(c.as_str()))\n .max_by_key(|c| c.len())\n {\n let actual_args = cmd.strip_prefix(suggested_command).unwrap();\n let args = if args.is_empty() {\n \"\".to_owned()\n } else {\n format!(\n \" {}\",\n args.into_iter().map(|os| os.to_string_lossy()).join(\" \")\n )\n };\n format!(\n \"\\nhelp: there is a command with a similar name: `{suggested_command} {actual_args}{args}`\"\n )\n } else {\n \"\".to_owned()\n };\n let suggested_script = if let Some(suggested_script) = suggested_script(cmd) {\n format!(\n \"\\nhelp: there is a script with a similar name: `{suggested_script}` (requires `-Zscript`)\"\n )\n } else {\n \"\".to_owned()\n };\n return Err(anyhow::anyhow!(\n \"no such subcommand `{cmd}`{suggested_command}{suggested_script}\"\n )\n .into());\n }\n }\n\n let manifest_path = root_manifest(Some(manifest_path), gctx)?;\n\n // Treat `cargo foo.rs` like `cargo install --path foo` and re-evaluate the config based on the\n // location where the script resides, rather than the environment from where it's being run.\n let parent_path = manifest_path\n .parent()\n .expect(\"a file should always have a parent\");\n gctx.reload_rooted_at(parent_path)?;\n\n let mut ws = Workspace::new(&manifest_path, gctx)?;\n if gctx.cli_unstable().avoid_dev_deps {\n ws.set_require_optional_deps(false);\n }\n\n let mut compile_opts =\n cargo::ops::CompileOptions::new(gctx, cargo::core::compiler::UserIntent::Build)?;\n compile_opts.spec = cargo::ops::Packages::Default;\n\n cargo::ops::run(&ws, &compile_opts, args).map_err(|err| to_run_error(gctx, err))\n}\n\nfn suggested_script(cmd: &str) -> Option {\n let cmd_path = Path::new(cmd);\n let mut suggestion = Path::new(\".\").to_owned();\n for cmd_part in cmd_path.components() {\n let exact_match = suggestion.join(cmd_part);\n suggestion = if exact_match.exists() {\n exact_match\n } else {\n let possible: Vec<_> = std::fs::read_dir(suggestion)\n .into_iter()\n .flatten()\n .filter_map(|e| e.ok())\n .map(|e| e.path())\n .filter(|p| p.to_str().is_some())\n .collect();\n if let Some(possible) = closest(\n cmd_part.as_os_str().to_str().unwrap(),\n possible.iter(),\n |p| p.file_name().unwrap().to_str().unwrap(),\n ) {\n possible.to_owned()\n } else {\n return None;\n }\n };\n }\n if suggestion.is_dir() {\n None\n } else {\n suggestion.into_os_string().into_string().ok()\n }\n}\n\nfn to_run_error(gctx: &GlobalContext, err: anyhow::Error) -> CliError {\n let proc_err = match err.downcast_ref::() {\n Some(e) => e,\n None => return CliError::new(err, 101),\n };\n\n // If we never actually spawned the process then that sounds pretty\n // bad and we always want to forward that up.\n let exit_code = match proc_err.code {\n Some(exit) => exit,\n None => return CliError::new(err, 101),\n };\n\n // If `-q` was passed then we suppress extra error information about\n // a failed process, we assume the process itself printed out enough\n // information about why it failed so we don't do so as well\n let is_quiet = gctx.shell().verbosity() == Verbosity::Quiet;\n if is_quiet {\n CliError::code(exit_code)\n } else {\n CliError::new(err, exit_code)\n }\n}\n" }, { "path": "src/bin/cargo/commands/rustc.rs", "content": "use crate::command_prelude::*;\nuse cargo::ops;\n\nconst PRINT_ARG_NAME: &str = \"print\";\nconst CRATE_TYPE_ARG_NAME: &str = \"crate-type\";\n\npub fn cli() -> Command {\n subcommand(\"rustc\")\n .about(\"Compile a package, and pass extra options to the compiler\")\n .arg(\n Arg::new(\"args\")\n .value_name(\"ARGS\")\n .num_args(0..)\n .help(\"Extra rustc flags\")\n .trailing_var_arg(true),\n )\n .arg(\n opt(\n PRINT_ARG_NAME,\n \"Output compiler information without compiling\",\n )\n .value_name(\"INFO\"),\n )\n .arg(multi_opt(\n CRATE_TYPE_ARG_NAME,\n \"CRATE-TYPE\",\n \"Comma separated list of types of crates for the compiler to emit\",\n ))\n .arg_future_incompat_report()\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_package(\"Package to build\")\n .arg_targets_all(\n \"Build only this package's library\",\n \"Build only the specified binary\",\n \"Build all binaries\",\n \"Build only the specified example\",\n \"Build all examples\",\n \"Build only the specified test target\",\n \"Build all targets that have `test = true` set\",\n \"Build only the specified bench target\",\n \"Build all targets that have `bench = true` set\",\n \"Build all targets\",\n )\n .arg_features()\n .arg_parallel()\n .arg_release(\"Build artifacts in release mode, with optimizations\")\n .arg_profile(\"Build artifacts with the specified profile\")\n .arg_target_triple(\"Target triple which compiles will be for\")\n .arg_target_dir()\n .arg_unit_graph()\n .arg_timings()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .after_help(color_print::cstr!(\n \"Run `cargo help rustc` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n // This is a legacy behavior that changes the behavior based on the profile.\n // If we want to support this more formally, I think adding a --mode flag\n // would be warranted.\n let intent = match args.get_one::(\"profile\").map(String::as_str) {\n Some(\"test\") => UserIntent::Test,\n Some(\"bench\") => UserIntent::Bench,\n Some(\"check\") => UserIntent::Check { test: false },\n _ => UserIntent::Build,\n };\n let mut compile_opts = args.compile_options_for_single_package(\n gctx,\n intent,\n Some(&ws),\n ProfileChecking::LegacyRustc,\n )?;\n if compile_opts.build_config.requested_profile == \"check\" {\n compile_opts.build_config.requested_profile = \"dev\".into();\n }\n let target_args = values(args, \"args\");\n compile_opts.target_rustc_args = if target_args.is_empty() {\n None\n } else {\n Some(target_args)\n };\n if let Some(opt_value) = args.get_one::(PRINT_ARG_NAME) {\n gctx.cli_unstable()\n .fail_if_stable_opt(PRINT_ARG_NAME, 9357)?;\n ops::print(&ws, &compile_opts, opt_value)?;\n return Ok(());\n }\n\n let crate_types = {\n let mut seen = std::collections::HashSet::new();\n args.get_many::(CRATE_TYPE_ARG_NAME)\n .into_iter()\n .flatten()\n .flat_map(|s| s.split(','))\n .filter(|s| !s.is_empty())\n .map(String::from)\n .filter(|s| seen.insert(s.clone()))\n .collect::>()\n };\n\n compile_opts.target_rustc_crate_types = if crate_types.is_empty() {\n None\n } else {\n Some(crate_types)\n };\n ops::compile(&ws, &compile_opts)?;\n\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/rustdoc.rs", "content": "use cargo::ops::{self, DocOptions, OutputFormat};\n\nuse crate::command_prelude::*;\n\npub fn cli() -> Command {\n subcommand(\"rustdoc\")\n .about(\"Build a package's documentation, using specified custom flags.\")\n .arg(\n Arg::new(\"args\")\n .value_name(\"ARGS\")\n .help(\"Extra rustdoc flags\")\n .num_args(0..)\n .trailing_var_arg(true),\n )\n .arg(flag(\n \"open\",\n \"Opens the docs in a browser after the operation\",\n ))\n .arg_message_format()\n .arg_silent_suggestion()\n .arg_package(\"Package to document\")\n .arg_targets_all(\n \"Build only this package's library\",\n \"Build only the specified binary\",\n \"Build all binaries\",\n \"Build only the specified example\",\n \"Build all examples\",\n \"Build only the specified test target\",\n \"Build all targets that have `test = true` set\",\n \"Build only the specified bench target\",\n \"Build all targets that have `bench = true` set\",\n \"Build all targets\",\n )\n .arg_features()\n .arg_parallel()\n .arg_release(\"Build artifacts in release mode, with optimizations\")\n .arg_profile(\"Build artifacts with the specified profile\")\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg(\n opt(\"output-format\", \"The output type to write (unstable)\")\n .value_name(\"FMT\")\n .value_parser(OutputFormat::POSSIBLE_VALUES),\n )\n .arg_unit_graph()\n .arg_timings()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .after_help(color_print::cstr!(\n \"Run `cargo help rustdoc` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n let output_format = if let Some(output_format) = args._value_of(\"output-format\") {\n gctx.cli_unstable()\n .fail_if_stable_opt(\"--output-format\", 12103)?;\n output_format.parse()?\n } else {\n OutputFormat::Html\n };\n\n let mut compile_opts = args.compile_options_for_single_package(\n gctx,\n UserIntent::Doc {\n deps: false,\n json: matches!(output_format, OutputFormat::Json),\n },\n Some(&ws),\n ProfileChecking::Custom,\n )?;\n let target_args = values(args, \"args\");\n\n compile_opts.target_rustdoc_args = if target_args.is_empty() {\n None\n } else {\n Some(target_args)\n };\n\n let doc_opts = DocOptions {\n open_result: args.flag(\"open\"),\n output_format,\n compile_opts,\n };\n ops::doc(&ws, &doc_opts)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/search.rs", "content": "use crate::command_prelude::*;\n\nuse std::cmp::min;\n\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"search\")\n .about(\"Search packages in the registry. Default registry is crates.io\")\n .arg(Arg::new(\"query\").value_name(\"QUERY\").num_args(0..))\n .arg(\n opt(\n \"limit\",\n \"Limit the number of results (default: 10, max: 100)\",\n )\n .value_name(\"LIMIT\"),\n )\n .arg_index(\"Registry index URL to search packages in\")\n .arg_registry(\"Registry to search packages in\")\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help search` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let reg_or_index = args.registry_or_index(gctx)?;\n let limit = args.value_of_u32(\"limit\")?;\n let limit = min(100, limit.unwrap_or(10));\n let query: Vec<&str> = args\n .get_many::(\"query\")\n .unwrap_or_default()\n .map(String::as_str)\n .collect();\n let query: String = query.join(\"+\");\n ops::search(&query, gctx, reg_or_index, limit)?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/test.rs", "content": "use crate::command_prelude::*;\nuse cargo::ops;\n\npub fn cli() -> Command {\n subcommand(\"test\")\n // Subcommand aliases are handled in `aliased_command()`.\n // .alias(\"t\")\n .about(\"Execute all unit and integration tests and build examples of a local package\")\n .arg(\n Arg::new(\"TESTNAME\")\n .action(ArgAction::Set)\n .help(\"If specified, only run tests containing this string in their names\"),\n )\n .arg(\n Arg::new(\"args\")\n .value_name(\"ARGS\")\n .help(\"Arguments for the test binary\")\n .num_args(0..)\n .last(true),\n )\n .arg(flag(\"no-run\", \"Compile, but don't run tests\"))\n .arg(flag(\"no-fail-fast\", \"Run all tests regardless of failure\"))\n .arg_future_incompat_report()\n .arg_message_format()\n .arg(\n flag(\n \"quiet\",\n \"Display one character per test instead of one line\",\n )\n .short('q'),\n )\n .arg_package_spec(\n \"Package to run tests for\",\n \"Test all packages in the workspace\",\n \"Exclude packages from the test\",\n )\n .arg_targets_all(\n \"Test only this package's library\",\n \"Test only the specified binary\",\n \"Test all binaries\",\n \"Test only the specified example\",\n \"Test all examples\",\n \"Test only the specified test target\",\n \"Test all targets that have `test = true` set\",\n \"Test only the specified bench target\",\n \"Test all targets that have `bench = true` set\",\n \"Test all targets (does not include doctests)\",\n )\n .arg(\n flag(\"doc\", \"Test only this library's documentation\")\n .help_heading(heading::TARGET_SELECTION),\n )\n .arg_features()\n .arg_jobs()\n .arg_unsupported_keep_going()\n .arg_release(\"Build artifacts in release mode, with optimizations\")\n .arg_profile(\"Build artifacts with the specified profile\")\n .arg_target_triple(\"Build for the target triple\")\n .arg_target_dir()\n .arg_unit_graph()\n .arg_timings()\n .arg_manifest_path()\n .arg_ignore_rust_version()\n .after_help(color_print::cstr!(\n \"Run `cargo help test` for more detailed information.\\n\\\n Run `cargo test -- --help` for test binary options.\\n\",\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let ws = args.workspace(gctx)?;\n\n let mut compile_opts =\n args.compile_options(gctx, UserIntent::Test, Some(&ws), ProfileChecking::Custom)?;\n\n compile_opts.build_config.requested_profile =\n args.get_profile_name(\"test\", ProfileChecking::Custom)?;\n\n // `TESTNAME` is actually an argument of the test binary, but it's\n // important, so we explicitly mention it and reconfigure.\n let test_name = args.get_one::(\"TESTNAME\");\n let test_args = args.get_one::(\"TESTNAME\").into_iter();\n let test_args = test_args.chain(args.get_many::(\"args\").unwrap_or_default());\n let test_args = test_args.map(String::as_str).collect::>();\n\n let no_run = args.flag(\"no-run\");\n let doc = args.flag(\"doc\");\n if doc {\n if compile_opts.filter.is_specific() {\n return Err(\n anyhow::format_err!(\"can't mix --doc with other target selecting options\").into(),\n );\n }\n if no_run {\n return Err(anyhow::format_err!(\"can't skip running doc tests with --no-run\").into());\n }\n compile_opts.build_config.intent = UserIntent::Doctest;\n compile_opts.filter = ops::CompileFilter::lib_only();\n } else if test_name.is_some() && !compile_opts.filter.is_specific() {\n // If arg `TESTNAME` is provided, assumed that the user knows what\n // exactly they wants to test, so we use `all_test_targets` to\n // avoid compiling unnecessary targets such as examples, which are\n // included by the logic of default target filter.\n compile_opts.filter = ops::CompileFilter::all_test_targets();\n }\n\n let ops = ops::TestOptions {\n no_run,\n no_fail_fast: args.flag(\"no-fail-fast\"),\n compile_opts,\n };\n\n ops::run_tests(&ws, &ops, &test_args)\n}\n" }, { "path": "src/bin/cargo/commands/tree.rs", "content": "use crate::cli;\nuse crate::command_prelude::*;\nuse annotate_snippets::Level;\nuse anyhow::{bail, format_err};\nuse cargo::core::dependency::DepKind;\nuse cargo::ops::Packages;\nuse cargo::ops::tree::{self, DisplayDepth, EdgeKind};\nuse cargo::util::CargoResult;\nuse cargo::util::print_available_packages;\nuse clap_complete::ArgValueCandidates;\nuse std::collections::HashSet;\nuse std::str::FromStr;\n\npub fn cli() -> Command {\n subcommand(\"tree\")\n .about(\"Display a tree visualization of a dependency graph\")\n .arg(\n flag(\"all\", \"Deprecated, use --no-dedupe instead\")\n .short('a')\n .hide(true),\n )\n .arg_silent_suggestion()\n .arg(flag(\"no-dev-dependencies\", \"Deprecated, use -e=no-dev instead\").hide(true))\n .arg(\n multi_opt(\"edges\", \"KINDS\", \"The kinds of dependencies to display\")\n .short('e')\n .value_delimiter(',')\n .value_parser([\n \"all\",\n \"normal\",\n \"build\",\n \"dev\",\n \"features\",\n \"public\",\n \"no-normal\",\n \"no-build\",\n \"no-dev\",\n \"no-proc-macro\",\n ]),\n )\n .arg(\n optional_multi_opt(\n \"invert\",\n \"SPEC\",\n \"Invert the tree direction and focus on the given package\",\n )\n .short('i')\n .add(clap_complete::ArgValueCandidates::new(\n get_pkg_id_spec_candidates,\n )),\n )\n .arg(\n multi_opt(\n \"prune\",\n \"SPEC\",\n \"Prune the given package from the display of the dependency tree\",\n )\n .add(clap_complete::ArgValueCandidates::new(\n get_pkg_id_spec_candidates,\n )),\n )\n .arg(opt(\"depth\", \"Maximum display depth of the dependency tree\").value_name(\"DEPTH\"))\n .arg(flag(\"no-indent\", \"Deprecated, use --prefix=none instead\").hide(true))\n .arg(flag(\"prefix-depth\", \"Deprecated, use --prefix=depth instead\").hide(true))\n .arg(\n opt(\n \"prefix\",\n \"Change the prefix (indentation) of how each entry is displayed\",\n )\n .value_name(\"PREFIX\")\n .value_parser([\"depth\", \"indent\", \"none\"])\n .default_value(\"indent\"),\n )\n .arg(flag(\n \"no-dedupe\",\n \"Do not de-duplicate (repeats all shared dependencies)\",\n ))\n .arg(\n flag(\n \"duplicates\",\n \"Show only dependencies which come in multiple versions (implies -i)\",\n )\n .short('d')\n .alias(\"duplicate\"),\n )\n .arg(\n opt(\"charset\", \"Character set to use in output\")\n .value_name(\"CHARSET\")\n .value_parser([\"utf8\", \"ascii\"]),\n )\n .arg(\n opt(\"format\", \"Format string used for printing dependencies\")\n .value_name(\"FORMAT\")\n .short('f')\n .default_value(\"{p}\"),\n )\n .arg(\n // Backwards compatibility with old cargo-tree.\n flag(\"version\", \"Print version info and exit\")\n .short('V')\n .hide(true),\n )\n .arg_package_spec_no_all(\n \"Package to be used as the root of the tree\",\n \"Display the tree for all packages in the workspace\",\n \"Exclude specific workspace members\",\n ArgValueCandidates::new(get_pkg_id_spec_candidates),\n )\n .arg_features()\n .arg(flag(\"all-targets\", \"Deprecated, use --target=all instead\").hide(true))\n .arg_target_triple_with_candidates(\n \"Filter dependencies matching the given target-triple (default host platform). \\\n Pass `all` to include all targets.\",\n ArgValueCandidates::new(get_target_triples_with_all),\n )\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help tree` for more detailed information.\\n\"\n ))\n}\n\n#[derive(Copy, Clone)]\npub enum Charset {\n Utf8,\n Ascii,\n}\n\nimpl FromStr for Charset {\n type Err = &'static str;\n\n fn from_str(s: &str) -> Result {\n match s {\n \"utf8\" => Ok(Charset::Utf8),\n \"ascii\" => Ok(Charset::Ascii),\n _ => Err(\"invalid charset\"),\n }\n }\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n if args.flag(\"version\") {\n let verbose = args.verbose() > 0;\n let version = cli::get_version_string(verbose);\n cargo::drop_print!(gctx, \"{}\", version);\n return Ok(());\n }\n let prefix = if args.flag(\"no-indent\") {\n gctx.shell()\n .warn(\"the --no-indent flag has been changed to --prefix=none\")?;\n \"none\"\n } else if args.flag(\"prefix-depth\") {\n gctx.shell()\n .warn(\"the --prefix-depth flag has been changed to --prefix=depth\")?;\n \"depth\"\n } else {\n args.get_one::(\"prefix\").unwrap().as_str()\n };\n let prefix = tree::Prefix::from_str(prefix).map_err(|e| anyhow::anyhow!(\"{}\", e))?;\n\n let no_dedupe = args.flag(\"no-dedupe\") || args.flag(\"all\");\n if args.flag(\"all\") {\n gctx.shell().print_report(\n &[Level::WARNING\n .secondary_title(\n \"the `cargo tree` --all flag has been changed to --no-dedupe, \\\n and may be removed in a future version\",\n )\n .element(Level::HELP.message(\n \"if you are looking to display all workspace members, use the --workspace flag\",\n ))],\n false,\n )?;\n }\n\n let targets = if args.flag(\"all-targets\") {\n gctx.shell()\n .warn(\"the --all-targets flag has been changed to --target=all\")?;\n vec![\"all\".to_string()]\n } else {\n args.targets()?\n };\n let target = tree::Target::from_cli(targets);\n\n let (edge_kinds, no_proc_macro, public) = parse_edge_kinds(gctx, args)?;\n let graph_features = edge_kinds.contains(&EdgeKind::Feature);\n\n let pkgs_to_prune = args._values_of(\"prune\");\n\n let display_depth = args\n ._value_of(\"depth\")\n .map(|s| s.parse::())\n .transpose()?\n .unwrap_or(DisplayDepth::MaxDisplayDepth(u32::MAX));\n\n let packages = args.packages_from_flags()?;\n let mut invert = args\n .get_many::(\"invert\")\n .map_or_else(|| Vec::new(), |is| is.map(|s| s.to_string()).collect());\n if args.is_present_with_zero_values(\"invert\") {\n match &packages {\n Packages::Packages(ps) => {\n // Backwards compatibility with old syntax of `cargo tree -i -p foo`.\n invert.extend(ps.clone());\n }\n _ => {\n return Err(format_err!(\n \"The `-i` flag requires a package name.\\n\\\n\\n\\\nThe `-i` flag is used to inspect the reverse dependencies of a specific\\n\\\npackage. It will invert the tree and display the packages that depend on the\\n\\\ngiven package.\\n\\\n\\n\\\nNote that in a workspace, by default it will only display the package's\\n\\\nreverse dependencies inside the tree of the workspace member in the current\\n\\\ndirectory. The --workspace flag can be used to extend it so that it will show\\n\\\nthe package's reverse dependencies across the entire workspace. The -p flag\\n\\\ncan be used to display the package's reverse dependencies only with the\\n\\\nsubtree of the package given to -p.\\n\\\n\"\n )\n .into());\n }\n }\n }\n\n let ws = args.workspace(gctx)?;\n\n if args.is_present_with_zero_values(\"package\") {\n print_available_packages(&ws)?;\n }\n\n let charset = args.get_one::(\"charset\");\n if let Some(charset) = charset\n .map(|c| Charset::from_str(c))\n .transpose()\n .map_err(|e| anyhow::anyhow!(\"{}\", e))?\n {\n match charset {\n Charset::Utf8 => gctx.shell().set_unicode(true)?,\n Charset::Ascii => gctx.shell().set_unicode(false)?,\n }\n }\n let opts = tree::TreeOptions {\n cli_features: args.cli_features()?,\n packages,\n target,\n edge_kinds,\n invert,\n pkgs_to_prune,\n prefix,\n no_dedupe,\n duplicates: args.flag(\"duplicates\"),\n format: args.get_one::(\"format\").cloned().unwrap(),\n graph_features,\n display_depth,\n no_proc_macro,\n public,\n };\n\n if opts.graph_features && opts.duplicates {\n return Err(format_err!(\"the `-e features` flag does not support `--duplicates`\").into());\n }\n\n tree::build_and_print(&ws, &opts)?;\n Ok(())\n}\n\n/// Parses `--edges` option.\n///\n/// Returns a tuple of `EdgeKind` map and `no_proc_marco` flag.\nfn parse_edge_kinds(\n gctx: &GlobalContext,\n args: &ArgMatches,\n) -> CargoResult<(HashSet, bool, bool)> {\n let (kinds, no_proc_macro, public) = {\n let mut no_proc_macro = false;\n let mut public = false;\n let mut kinds = args.get_many::(\"edges\").map_or_else(\n || Vec::new(),\n |es| {\n es.map(|e| e.as_str())\n .filter(|e| {\n if *e == \"no-proc-macro\" {\n no_proc_macro = true;\n false\n } else if *e == \"public\" {\n public = true;\n false\n } else {\n true\n }\n })\n .collect()\n },\n );\n\n if args.flag(\"no-dev-dependencies\") {\n gctx.shell()\n .warn(\"the --no-dev-dependencies flag has changed to -e=no-dev\")?;\n kinds.push(\"no-dev\");\n }\n\n if kinds.is_empty() {\n kinds.extend(&[\"normal\", \"build\", \"dev\"]);\n }\n\n if public && !gctx.cli_unstable().unstable_options {\n anyhow::bail!(\"`--edges public` requires `-Zunstable-options`\");\n }\n\n (kinds, no_proc_macro, public)\n };\n\n let mut result = HashSet::new();\n let insert_defaults = |result: &mut HashSet| {\n result.insert(EdgeKind::Dep(DepKind::Normal));\n result.insert(EdgeKind::Dep(DepKind::Build));\n result.insert(EdgeKind::Dep(DepKind::Development));\n };\n if kinds.iter().any(|k| k.starts_with(\"no-\")) {\n insert_defaults(&mut result);\n for kind in &kinds {\n match *kind {\n \"no-normal\" => result.remove(&EdgeKind::Dep(DepKind::Normal)),\n \"no-build\" => result.remove(&EdgeKind::Dep(DepKind::Build)),\n \"no-dev\" => result.remove(&EdgeKind::Dep(DepKind::Development)),\n \"features\" => result.insert(EdgeKind::Feature),\n \"normal\" | \"build\" | \"dev\" | \"all\" => {\n bail!(\n \"`{}` dependency kind cannot be mixed with \\\n \\\"no-normal\\\", \\\"no-build\\\", or \\\"no-dev\\\" \\\n dependency kinds\",\n kind\n )\n }\n _ => unreachable!(\"`{kind}` was validated by clap\"),\n };\n }\n return Ok((result, no_proc_macro, public));\n }\n for kind in &kinds {\n match *kind {\n \"all\" => {\n insert_defaults(&mut result);\n result.insert(EdgeKind::Feature);\n }\n \"features\" => {\n result.insert(EdgeKind::Feature);\n }\n \"normal\" => {\n result.insert(EdgeKind::Dep(DepKind::Normal));\n }\n \"build\" => {\n result.insert(EdgeKind::Dep(DepKind::Build));\n }\n \"dev\" => {\n result.insert(EdgeKind::Dep(DepKind::Development));\n }\n _ => unreachable!(\"`{kind}` was validated by clap\"),\n }\n }\n if kinds.len() == 1 && kinds[0] == \"features\" {\n insert_defaults(&mut result);\n }\n Ok((result, no_proc_macro, public))\n}\n" }, { "path": "src/bin/cargo/commands/uninstall.rs", "content": "use crate::command_prelude::*;\n\nuse cargo::{CargoResult, core::PackageId, ops};\nuse clap_complete::ArgValueCandidates;\n\nuse std::collections::BTreeSet;\n\npub fn cli() -> Command {\n subcommand(\"uninstall\")\n .about(\"Remove a Rust binary\")\n .arg(\n Arg::new(\"spec\")\n .value_name(\"SPEC\")\n .num_args(0..)\n .add::(clap_complete::ArgValueCandidates::new(\n || get_installed_crates(),\n )),\n )\n .arg(opt(\"root\", \"Directory to uninstall packages from\").value_name(\"DIR\"))\n .arg_silent_suggestion()\n .arg_package_spec_simple(\n \"Package to uninstall\",\n ArgValueCandidates::new(get_installed_package_candidates),\n )\n .arg(\n multi_opt(\"bin\", \"NAME\", \"Only uninstall the binary NAME\")\n .help_heading(heading::TARGET_SELECTION),\n )\n .after_help(color_print::cstr!(\n \"Run `cargo help uninstall` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let root = args.get_one::(\"root\").map(String::as_str);\n\n if args.is_present_with_zero_values(\"package\") {\n return Err(anyhow::anyhow!(\n \"\\\"--package \\\" requires a SPEC format value.\\n\\\n Run `cargo help pkgid` for more information about SPEC format.\"\n )\n .into());\n }\n\n let specs = args\n .get_many::(\"spec\")\n .unwrap_or_else(|| args.get_many::(\"package\").unwrap_or_default())\n .map(String::as_str)\n .collect();\n ops::uninstall(root, specs, &values(args, \"bin\"), gctx)?;\n Ok(())\n}\n\nfn get_installed_crates() -> Vec {\n get_installed_crates_().unwrap_or_default()\n}\n\nfn get_installed_crates_() -> Option> {\n let mut candidates = Vec::new();\n\n let gctx = new_gctx_for_completions().ok()?;\n\n let root = ops::resolve_root(None, &gctx).ok()?;\n\n let tracker = ops::InstallTracker::load(&gctx, &root).ok()?;\n\n for (_, v) in tracker.all_installed_bins() {\n for bin in v {\n candidates.push(clap_complete::CompletionCandidate::new(bin));\n }\n }\n\n Some(candidates)\n}\n\nfn get_installed_package_candidates() -> Vec {\n get_installed_packages()\n .unwrap_or_default()\n .into_iter()\n .map(|(pkg, bins)| {\n let single_binary = bins.iter().next().take_if(|_| bins.len() == 1);\n\n let help = if single_binary.is_some_and(|bin| bin == pkg.name().as_str()) {\n None\n } else {\n let binaries = bins.into_iter().collect::>().as_slice().join(\", \");\n Some(binaries)\n };\n\n clap_complete::CompletionCandidate::new(pkg.name().as_str()).help(help.map(From::from))\n })\n .collect()\n}\n\nfn get_installed_packages() -> CargoResult)>> {\n let gctx = new_gctx_for_completions()?;\n let root = ops::resolve_root(None, &gctx)?;\n\n let tracker = ops::InstallTracker::load(&gctx, &root)?;\n Ok(tracker\n .all_installed_bins()\n .map(|(package_id, bins)| (*package_id, bins.clone()))\n .collect())\n}\n" }, { "path": "src/bin/cargo/commands/update.rs", "content": "use crate::command_prelude::*;\n\nuse anyhow::anyhow;\nuse cargo::ops::{self, UpdateOptions};\nuse cargo::util::print_available_packages;\n\npub fn cli() -> Command {\n subcommand(\"update\")\n .about(\"Update dependencies as recorded in the local lock file\")\n .args([clap::Arg::new(\"package2\")\n .action(clap::ArgAction::Append)\n .num_args(1..)\n .value_name(\"SPEC\")\n .help_heading(heading::PACKAGE_SELECTION)\n .group(\"package-group\")\n .help(\"Package to update\")\n .add(clap_complete::ArgValueCandidates::new(\n get_pkg_id_spec_candidates,\n ))])\n .arg(\n optional_multi_opt(\"package\", \"SPEC\", \"Package to update\")\n .short('p')\n .hide(true)\n .help_heading(heading::PACKAGE_SELECTION)\n .group(\"package-group\"),\n )\n .arg_dry_run(\"Don't actually write the lockfile\")\n .arg(\n flag(\n \"recursive\",\n \"Force updating all dependencies of [SPEC]... as well\",\n )\n .alias(\"aggressive\")\n .conflicts_with(\"precise\"),\n )\n .arg(\n opt(\"precise\", \"Update [SPEC] to exactly PRECISE\")\n .value_name(\"PRECISE\")\n .requires(\"package-group\"),\n )\n .arg(\n flag(\n \"breaking\",\n \"Update [SPEC] to latest SemVer-breaking version (unstable)\",\n )\n .short('b'),\n )\n .arg_silent_suggestion()\n .arg(\n flag(\"workspace\", \"Only update the workspace packages\")\n .short('w')\n .help_heading(heading::PACKAGE_SELECTION),\n )\n .arg_manifest_path()\n .arg_ignore_rust_version_with_help(\"Ignore `rust-version` specification in packages\")\n .after_help(color_print::cstr!(\n \"Run `cargo help update` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let mut ws = args.workspace(gctx)?;\n\n if args.is_present_with_zero_values(\"package\") {\n print_available_packages(&ws)?;\n }\n\n let to_update = if args.contains_id(\"package\") {\n \"package\"\n } else {\n \"package2\"\n };\n let to_update = values(args, to_update);\n for crate_name in to_update.iter() {\n if let Some(toolchain) = crate_name.strip_prefix(\"+\") {\n return Err(anyhow!(\n \"invalid character `+` in package name: `+{toolchain}`\n Use `cargo +{toolchain} update` if you meant to use the `{toolchain}` toolchain.\"\n )\n .into());\n }\n }\n\n let update_opts = UpdateOptions {\n recursive: args.flag(\"recursive\"),\n precise: args.get_one::(\"precise\").map(String::as_str),\n to_update,\n dry_run: args.dry_run(),\n workspace: args.flag(\"workspace\"),\n gctx,\n };\n\n if args.flag(\"breaking\") {\n gctx.cli_unstable()\n .fail_if_stable_opt(\"--breaking\", 12425)?;\n\n let upgrades = ops::upgrade_manifests(&mut ws, &update_opts.to_update)?;\n ops::resolve_ws(&ws, update_opts.dry_run)?;\n ops::write_manifest_upgrades(&ws, &upgrades, update_opts.dry_run)?;\n\n if update_opts.dry_run {\n update_opts\n .gctx\n .shell()\n .warn(\"aborting update due to dry run\")?;\n }\n } else {\n ops::update_lockfile(&ws, &update_opts)?;\n }\n\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/vendor.rs", "content": "use crate::command_prelude::*;\nuse cargo::ops;\nuse std::path::PathBuf;\n\npub fn cli() -> Command {\n subcommand(\"vendor\")\n .about(\"Vendor all dependencies for a project locally\")\n .arg(\n Arg::new(\"path\")\n .action(ArgAction::Set)\n .value_parser(clap::value_parser!(PathBuf))\n .help(\"Where to vendor crates (`vendor` by default)\"),\n )\n .arg(flag(\n \"no-delete\",\n \"Don't delete older crates in the vendor directory\",\n ))\n .arg(\n Arg::new(\"tomls\")\n .short('s')\n .long(\"sync\")\n .help(\"Additional `Cargo.toml` to sync and vendor\")\n .value_name(\"TOML\")\n .value_parser(clap::value_parser!(PathBuf))\n .action(clap::ArgAction::Append),\n )\n .arg(flag(\n \"respect-source-config\",\n \"Respect `[source]` config in `.cargo/config`\",\n ))\n .arg(flag(\n \"versioned-dirs\",\n \"Always include version in subdir name\",\n ))\n .arg(unsupported(\"no-merge-sources\"))\n .arg(unsupported(\"relative-path\"))\n .arg(unsupported(\"only-git-deps\"))\n .arg(unsupported(\"disallow-duplicates\"))\n .arg_manifest_path()\n .after_help(color_print::cstr!(\n \"Run `cargo help vendor` for more detailed information.\\n\"\n ))\n}\n\nfn unsupported(name: &'static str) -> Arg {\n // When we moved `cargo vendor` into Cargo itself we didn't stabilize a few\n // flags, so try to provide a helpful error message in that case to ensure\n // that users currently using the flag aren't tripped up.\n let value_parser = clap::builder::UnknownArgumentValueParser::suggest(\"the crates.io `cargo vendor` command has been merged into Cargo\")\n .and_suggest(format!(\"and the flag `--{name}` isn't supported currently\"))\n .and_suggest(\"to continue using the flag, execute `cargo-vendor vendor ...`\")\n .and_suggest(\"to suggest this flag supported in Cargo, file an issue at \");\n\n flag(name, \"\").value_parser(value_parser).hide(true)\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n // We're doing the vendoring operation ourselves, so we don't actually want\n // to respect any of the `source` configuration in Cargo itself. That's\n // intended for other consumers of Cargo, but we want to go straight to the\n // source, e.g. crates.io, to fetch crates.\n let respect_source_config = args.flag(\"respect-source-config\");\n if !respect_source_config {\n gctx.values_mut()?.remove(\"source\");\n }\n\n let ws = args.workspace(gctx)?;\n let path = args\n .get_one::(\"path\")\n .cloned()\n .unwrap_or_else(|| PathBuf::from(\"vendor\"));\n ops::vendor(\n &ws,\n &ops::VendorOptions {\n no_delete: args.flag(\"no-delete\"),\n destination: &path,\n versioned_dirs: args.flag(\"versioned-dirs\"),\n extra: args\n .get_many::(\"tomls\")\n .unwrap_or_default()\n .cloned()\n .collect(),\n respect_source_config,\n },\n )?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/verify_project.rs", "content": "//! Deprecated.\n\nuse crate::command_prelude::*;\n\nuse std::collections::HashMap;\nuse std::process;\n\npub fn cli() -> Command {\n subcommand(\"verify-project\")\n .hide(true)\n .about(\n \"\\\nDEPRECATED: Check correctness of crate manifest.\n\nSee https://github.com/rust-lang/cargo/issues/14679.\",\n )\n .arg_silent_suggestion()\n .arg_manifest_path()\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n if let Err(e) = args.workspace(gctx) {\n gctx.shell()\n .print_json(&HashMap::from([(\"invalid\", e.to_string())]))?;\n process::exit(1)\n }\n\n gctx.shell()\n .print_json(&HashMap::from([(\"success\", \"true\")]))?;\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/version.rs", "content": "use crate::cli;\nuse crate::command_prelude::*;\n\npub fn cli() -> Command {\n subcommand(\"version\")\n .about(\"Show version information\")\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help version` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let verbose = args.verbose() > 0;\n let version = cli::get_version_string(verbose);\n cargo::drop_print!(gctx, \"{}\", version);\n Ok(())\n}\n" }, { "path": "src/bin/cargo/commands/yank.rs", "content": "use crate::command_prelude::*;\n\nuse anyhow::Context;\nuse cargo::ops;\nuse cargo_credential::Secret;\n\npub fn cli() -> Command {\n subcommand(\"yank\")\n .about(\"Remove a pushed crate from the index\")\n .arg(Arg::new(\"crate\").value_name(\"CRATE\").action(ArgAction::Set))\n .arg(\n opt(\"version\", \"The version to yank or un-yank\")\n .alias(\"vers\")\n .value_name(\"VERSION\"),\n )\n .arg(flag(\n \"undo\",\n \"Undo a yank, putting a version back into the index\",\n ))\n .arg_index(\"Registry index URL to yank from\")\n .arg_registry(\"Registry to yank from\")\n .arg(opt(\"token\", \"API token to use when authenticating\").value_name(\"TOKEN\"))\n .arg_silent_suggestion()\n .after_help(color_print::cstr!(\n \"Run `cargo help yank` for more detailed information.\\n\"\n ))\n}\n\npub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {\n let (krate, version) = resolve_crate(\n args.get_one::(\"crate\").map(String::as_str),\n args.get_one::(\"version\").map(String::as_str),\n )?;\n if version.is_none() {\n return Err(anyhow::format_err!(\"`--version` is required\").into());\n }\n\n ops::yank(\n gctx,\n krate.map(|s| s.to_string()),\n version.map(|s| s.to_string()),\n args.get_one::(\"token\").cloned().map(Secret::from),\n args.registry_or_index(gctx)?,\n args.flag(\"undo\"),\n )?;\n Ok(())\n}\n\nfn resolve_crate<'k>(\n mut krate: Option<&'k str>,\n mut version: Option<&'k str>,\n) -> crate::CargoResult<(Option<&'k str>, Option<&'k str>)> {\n if let Some((k, v)) = krate.and_then(|k| k.split_once('@')) {\n if version.is_some() {\n anyhow::bail!(\"cannot specify both `@{v}` and `--version`\");\n }\n if k.is_empty() {\n // by convention, arguments starting with `@` are response files\n anyhow::bail!(\"missing crate name for `@{v}`\");\n }\n krate = Some(k);\n version = Some(v);\n }\n\n if let Some(version) = version {\n semver::Version::parse(version).with_context(|| {\n if let Some(stripped) = version.strip_prefix(\"v\") {\n return format!(\n \"the version provided, `{version}` is not a \\\n valid SemVer version\\n\\n\\\n help: try changing the version to `{stripped}`\",\n );\n }\n format!(\"invalid version `{version}`\")\n })?;\n }\n\n Ok((krate, version))\n}\n" }, { "path": "src/bin/cargo/main.rs", "content": "use cargo::core::features;\nuse cargo::core::shell::Shell;\nuse cargo::util::network::http::http_handle;\nuse cargo::util::network::http::needs_custom_http_transport;\nuse cargo::util::{self, CargoResult, closest_msg, command_prelude};\nuse cargo_util::{ProcessBuilder, ProcessError};\nuse cargo_util_schemas::manifest::StringOrVec;\nuse std::collections::BTreeMap;\nuse std::env;\nuse std::ffi::OsStr;\nuse std::fs;\nuse std::path::{Path, PathBuf};\n\nmod cli;\nmod commands;\n\nuse crate::command_prelude::*;\n\nfn main() {\n let _guard = setup_logger();\n\n let mut gctx = match GlobalContext::default() {\n Ok(gctx) => gctx,\n Err(e) => {\n let mut shell = Shell::new();\n cargo::exit_with_error(e.into(), &mut shell)\n }\n };\n\n let nightly_features_allowed = matches!(&*features::channel(), \"nightly\" | \"dev\");\n if nightly_features_allowed {\n let _span = tracing::span!(tracing::Level::TRACE, \"completions\").entered();\n let args = std::env::args_os();\n let current_dir = std::env::current_dir().ok();\n let completer = clap_complete::CompleteEnv::with_factory(|| {\n let mut gctx = GlobalContext::default().expect(\"already loaded without errors\");\n cli::cli(&mut gctx)\n })\n .var(\"CARGO_COMPLETE\");\n if completer\n .try_complete(args, current_dir.as_deref())\n .unwrap_or_else(|e| {\n let mut shell = Shell::new();\n cargo::exit_with_error(e.into(), &mut shell)\n })\n {\n return;\n }\n }\n\n let result = if let Some(lock_addr) = cargo::ops::fix_get_proxy_lock_addr() {\n cargo::ops::fix_exec_rustc(&gctx, &lock_addr).map_err(|e| CliError::from(e))\n } else {\n let _token = cargo::util::job::setup();\n cli::main(&mut gctx)\n };\n\n match result {\n Err(e) => cargo::exit_with_error(e, &mut *gctx.shell()),\n Ok(()) => {}\n }\n}\n\nfn setup_logger() -> Option {\n use tracing_subscriber::prelude::*;\n\n let env = tracing_subscriber::EnvFilter::from_env(\"CARGO_LOG\");\n let fmt_layer = tracing_subscriber::fmt::layer()\n .with_timer(tracing_subscriber::fmt::time::Uptime::default())\n .with_ansi(std::io::IsTerminal::is_terminal(&std::io::stderr()))\n .with_writer(std::io::stderr)\n .with_filter(env);\n\n let (profile_layer, profile_guard) = chrome_layer();\n\n let registry = tracing_subscriber::registry()\n .with(fmt_layer)\n .with(profile_layer);\n registry.init();\n tracing::trace!(start = jiff::Timestamp::now().to_string());\n profile_guard\n}\n\n#[cfg(target_has_atomic = \"64\")]\ntype ChromeFlushGuard = tracing_chrome::FlushGuard;\n#[cfg(target_has_atomic = \"64\")]\nfn chrome_layer() -> (\n Option>,\n Option,\n)\nwhere\n S: tracing::Subscriber\n + for<'span> tracing_subscriber::registry::LookupSpan<'span>\n + Send\n + Sync,\n{\n #![expect(clippy::disallowed_methods, reason = \"runs before config is loaded\")]\n\n if env_to_bool(std::env::var_os(\"CARGO_LOG_PROFILE\").as_deref()) {\n let capture_args =\n env_to_bool(std::env::var_os(\"CARGO_LOG_PROFILE_CAPTURE_ARGS\").as_deref());\n let (layer, guard) = tracing_chrome::ChromeLayerBuilder::new()\n .include_args(capture_args)\n .build();\n (Some(layer), Some(guard))\n } else {\n (None, None)\n }\n}\n\n#[cfg(not(target_has_atomic = \"64\"))]\ntype ChromeFlushGuard = ();\n#[cfg(not(target_has_atomic = \"64\"))]\nfn chrome_layer() -> (\n Option,\n Option,\n) {\n (None, None)\n}\n\n#[cfg(target_has_atomic = \"64\")]\nfn env_to_bool(os: Option<&OsStr>) -> bool {\n match os.and_then(|os| os.to_str()) {\n Some(\"1\") | Some(\"true\") => true,\n _ => false,\n }\n}\n\n/// Table for defining the aliases which come builtin in `Cargo`.\n/// The contents are structured as: `(alias, aliased_command, description)`.\nconst BUILTIN_ALIASES: [(&str, &str, &str); 6] = [\n (\"b\", \"build\", \"alias: build\"),\n (\"c\", \"check\", \"alias: check\"),\n (\"d\", \"doc\", \"alias: doc\"),\n (\"r\", \"run\", \"alias: run\"),\n (\"t\", \"test\", \"alias: test\"),\n (\"rm\", \"remove\", \"alias: remove\"),\n];\n\n/// Function which contains the list of all of the builtin aliases and it's\n/// corresponding execs represented as &str.\nfn builtin_aliases_execs(cmd: &str) -> Option<&(&str, &str, &str)> {\n BUILTIN_ALIASES.iter().find(|alias| alias.0 == cmd)\n}\n\n/// Resolve the aliased command from the [`GlobalContext`] with a given command string.\n///\n/// The search fallback chain is:\n///\n/// 1. Get the aliased command as a string.\n/// 2. If an `Err` occurs (missing key, type mismatch, or any possible error),\n/// try to get it as an array again.\n/// 3. If still cannot find any, finds one insides [`BUILTIN_ALIASES`].\nfn aliased_command(gctx: &GlobalContext, command: &str) -> CargoResult>> {\n let alias_name = format!(\"alias.{}\", command);\n let user_alias = match gctx.get_string(&alias_name) {\n Ok(Some(record)) => Some(\n record\n .val\n .split_whitespace()\n .map(|s| s.to_string())\n .collect(),\n ),\n Ok(None) => None,\n Err(_) => gctx.get::>>(&alias_name)?,\n };\n\n let result = user_alias.or_else(|| {\n builtin_aliases_execs(command).map(|command_str| vec![command_str.1.to_string()])\n });\n if result\n .as_ref()\n .map(|alias| alias.is_empty())\n .unwrap_or_default()\n {\n anyhow::bail!(\"subcommand is required, but `{alias_name}` is empty\");\n }\n Ok(result)\n}\n\n/// List all runnable commands\nfn list_commands(gctx: &GlobalContext) -> BTreeMap {\n let mut commands = third_party_subcommands(gctx);\n\n for cmd in commands::builtin() {\n commands.insert(\n cmd.get_name().to_string(),\n CommandInfo::BuiltIn {\n about: cmd.get_about().map(|s| s.to_string()),\n },\n );\n }\n\n // Add the builtin_aliases and them descriptions to the\n // `commands` `BTreeMap`.\n for command in &BUILTIN_ALIASES {\n commands.insert(\n command.0.to_string(),\n CommandInfo::BuiltIn {\n about: Some(command.2.to_string()),\n },\n );\n }\n\n // Add the user-defined aliases\n let alias_commands = user_defined_aliases(gctx);\n commands.extend(alias_commands);\n\n // `help` is special, so it needs to be inserted separately.\n commands.insert(\n \"help\".to_string(),\n CommandInfo::BuiltIn {\n about: Some(\"Displays help for a cargo command\".to_string()),\n },\n );\n\n commands\n}\n\nfn third_party_subcommands(gctx: &GlobalContext) -> BTreeMap {\n let prefix = \"cargo-\";\n let suffix = env::consts::EXE_SUFFIX;\n let mut commands = BTreeMap::new();\n for dir in search_directories(gctx) {\n let entries = match fs::read_dir(dir) {\n Ok(entries) => entries,\n _ => continue,\n };\n for entry in entries.filter_map(|e| e.ok()) {\n let path = entry.path();\n let Some(filename) = path.file_name().and_then(|s| s.to_str()) else {\n continue;\n };\n let Some(name) = filename\n .strip_prefix(prefix)\n .and_then(|s| s.strip_suffix(suffix))\n else {\n continue;\n };\n if is_executable(entry.path()) {\n commands.insert(\n name.to_string(),\n CommandInfo::External { path: path.clone() },\n );\n }\n }\n }\n commands\n}\n\nfn user_defined_aliases(gctx: &GlobalContext) -> BTreeMap {\n let mut commands = BTreeMap::new();\n if let Ok(aliases) = gctx.get::>(\"alias\") {\n for (name, target) in aliases.iter() {\n commands.insert(\n name.to_string(),\n CommandInfo::Alias {\n target: target.clone(),\n },\n );\n }\n }\n commands\n}\n\nfn find_external_subcommand(gctx: &GlobalContext, cmd: &str) -> Option {\n let command_exe = format!(\"cargo-{}{}\", cmd, env::consts::EXE_SUFFIX);\n search_directories(gctx)\n .iter()\n .map(|dir| dir.join(&command_exe))\n .find(|file| is_executable(file))\n}\n\nfn execute_external_subcommand(gctx: &GlobalContext, cmd: &str, args: &[&OsStr]) -> CliResult {\n let path = find_external_subcommand(gctx, cmd);\n let command = match path {\n Some(command) => command,\n None => {\n let script_suggestion = if gctx.cli_unstable().script\n && std::path::Path::new(cmd).is_file()\n {\n let sep = std::path::MAIN_SEPARATOR;\n format!(\n \"\\nhelp: to run the file `{cmd}`, provide a relative path like `.{sep}{cmd}`\"\n )\n } else {\n \"\".to_owned()\n };\n let err = if cmd.starts_with('+') {\n anyhow::format_err!(\n \"no such command: `{cmd}`\\n\\n\\\n help: invoke `cargo` through `rustup` to handle `+toolchain` directives{script_suggestion}\",\n )\n } else {\n let suggestions = list_commands(gctx);\n let did_you_mean = closest_msg(cmd, suggestions.keys(), |c| c, \"command\");\n\n anyhow::format_err!(\n \"no such command: `{cmd}`{did_you_mean}\\n\\n\\\n help: view all installed commands with `cargo --list`\\n\\\n help: find a package to install `{cmd}` with `cargo search cargo-{cmd}`{script_suggestion}\",\n )\n };\n\n return Err(CliError::new(err, 101));\n }\n };\n execute_subcommand(gctx, Some(&command), args)\n}\n\nfn execute_internal_subcommand(gctx: &GlobalContext, args: &[&OsStr]) -> CliResult {\n execute_subcommand(gctx, None, args)\n}\n\n// This function is used to execute a subcommand. It is used to execute both\n// internal and external subcommands.\n// If `cmd_path` is `None`, then the subcommand is an internal subcommand.\nfn execute_subcommand(\n gctx: &GlobalContext,\n cmd_path: Option<&PathBuf>,\n args: &[&OsStr],\n) -> CliResult {\n let cargo_exe = gctx.cargo_exe()?;\n let mut cmd = match cmd_path {\n Some(cmd_path) => ProcessBuilder::new(cmd_path),\n None => ProcessBuilder::new(&cargo_exe),\n };\n cmd.env(cargo::CARGO_ENV, cargo_exe).args(args);\n if let Some(client) = gctx.jobserver_from_env() {\n cmd.inherit_jobserver(client);\n }\n let err = match cmd.exec_replace() {\n Ok(()) => return Ok(()),\n Err(e) => e,\n };\n\n if let Some(perr) = err.downcast_ref::() {\n if let Some(code) = perr.code {\n return Err(CliError::code(code));\n }\n }\n Err(CliError::new(err, 101))\n}\n\n#[cfg(unix)]\nfn is_executable>(path: P) -> bool {\n use std::os::unix::prelude::*;\n fs::metadata(path)\n .map(|metadata| metadata.is_file() && metadata.permissions().mode() & 0o111 != 0)\n .unwrap_or(false)\n}\n#[cfg(windows)]\nfn is_executable>(path: P) -> bool {\n path.as_ref().is_file()\n}\n\nfn search_directories(gctx: &GlobalContext) -> Vec {\n let mut path_dirs = if let Some(val) = gctx.get_env_os(\"PATH\") {\n env::split_paths(&val).collect()\n } else {\n vec![]\n };\n\n let home_bin = gctx.home().clone().into_path_unlocked().join(\"bin\");\n\n // If any of that PATH elements contains `home_bin`, do not\n // add it again. This is so that the users can control priority\n // of it using PATH, while preserving the historical\n // behavior of preferring it over system global directories even\n // when not in PATH at all.\n // See https://github.com/rust-lang/cargo/issues/11020 for details.\n //\n // Note: `p == home_bin` will ignore trailing slash, but we don't\n // `canonicalize` the paths.\n if !path_dirs.iter().any(|p| p == &home_bin) {\n path_dirs.insert(0, home_bin);\n };\n\n path_dirs\n}\n\n/// Initialize libgit2.\n#[tracing::instrument(skip_all)]\nfn init_git(gctx: &GlobalContext) {\n // Disabling the owner validation in git can, in theory, lead to code execution\n // vulnerabilities. However, libgit2 does not launch executables, which is the foundation of\n // the original security issue. Meanwhile, issues with refusing to load git repos in\n // `CARGO_HOME` for example will likely be very frustrating for users. So, we disable the\n // validation.\n //\n // For further discussion of Cargo's current interactions with git, see\n //\n // https://github.com/rust-lang/rfcs/pull/3279\n //\n // and in particular the subsection on \"Git support\".\n //\n // Note that we only disable this when Cargo is run as a binary. If Cargo is used as a library,\n // this code won't be invoked. Instead, developers will need to explicitly disable the\n // validation in their code. This is inconvenient, but won't accidentally open consuming\n // applications up to security issues if they use git2 to open repositories elsewhere in their\n // code.\n unsafe {\n git2::opts::set_verify_owner_validation(false)\n .expect(\"set_verify_owner_validation should never fail\");\n }\n\n init_git_transports(gctx);\n}\n\n/// Configure libgit2 to use libcurl if necessary.\n///\n/// If the user has a non-default network configuration, then libgit2 will be\n/// configured to use libcurl instead of the built-in networking support so\n/// that those configuration settings can be used.\n#[tracing::instrument(skip_all)]\nfn init_git_transports(gctx: &GlobalContext) {\n match needs_custom_http_transport(gctx) {\n Ok(true) => {}\n _ => return,\n }\n\n let handle = match http_handle(gctx) {\n Ok(handle) => handle,\n Err(..) => return,\n };\n\n // The unsafety of the registration function derives from two aspects:\n //\n // 1. This call must be synchronized with all other registration calls as\n // well as construction of new transports.\n // 2. The argument is leaked.\n //\n // We're clear on point (1) because this is only called at the start of this\n // binary (we know what the state of the world looks like) and we're mostly\n // clear on point (2) because we'd only free it after everything is done\n // anyway\n unsafe {\n git2_curl::register(handle);\n }\n}\n" }, { "path": "src/cargo/core/compiler/artifact.rs", "content": "//! Generate artifact information from unit dependencies for configuring the compiler environment.\n\nuse crate::CargoResult;\nuse crate::core::compiler::unit_graph::UnitDep;\nuse crate::core::compiler::{BuildRunner, CrateType, FileFlavor, Unit};\nuse crate::core::dependency::ArtifactKind;\nuse crate::core::{Dependency, Target, TargetKind};\nuse std::collections::{HashMap, HashSet};\nuse std::ffi::OsString;\n\n/// Return all environment variables for the given unit-dependencies\n/// if artifacts are present.\npub fn get_env(\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n dependencies: &[UnitDep],\n) -> CargoResult> {\n let mut env = HashMap::new();\n\n // Add `CARGO_BIN_EXE_` environment variables for building tests.\n //\n // These aren't built for `cargo check`, so can't use `dependencies`\n if unit.target.is_test() || unit.target.is_bench() {\n for bin_target in unit\n .pkg\n .manifest()\n .targets()\n .iter()\n .filter(|target| target.is_bin())\n {\n let name = bin_target\n .binary_filename()\n .unwrap_or_else(|| bin_target.name().to_string());\n\n // For `cargo check` builds we do not uplift the CARGO_BIN_EXE_ artifacts to the\n // artifact-dir. We do not want to provide a path to a non-existent binary but we still\n // need to provide *something* so `env!(\"CARGO_BIN_EXE_...\")` macros will compile.\n let exe_path = build_runner\n .files()\n .bin_link_for_target(bin_target, unit.kind, build_runner.bcx)?\n .map(|path| path.as_os_str().to_os_string())\n .unwrap_or_else(|| OsString::from(format!(\"placeholder:{name}\")));\n\n let key = format!(\"CARGO_BIN_EXE_{name}\");\n env.insert(key, exe_path);\n }\n }\n\n for unit_dep in dependencies.iter().filter(|d| d.unit.artifact.is_true()) {\n for artifact_path in build_runner\n .outputs(&unit_dep.unit)?\n .iter()\n .filter_map(|f| (f.flavor == FileFlavor::Normal).then(|| &f.path))\n {\n let artifact_type_upper = unit_artifact_type_name_upper(&unit_dep.unit);\n let dep_name = unit_dep.dep_name.unwrap_or(unit_dep.unit.pkg.name());\n let dep_name_upper = dep_name.to_uppercase().replace(\"-\", \"_\");\n\n let var = format!(\"CARGO_{}_DIR_{}\", artifact_type_upper, dep_name_upper);\n let path = artifact_path.parent().expect(\"parent dir for artifacts\");\n env.insert(var, path.to_owned().into());\n\n let var_file = format!(\n \"CARGO_{}_FILE_{}_{}\",\n artifact_type_upper,\n dep_name_upper,\n unit_dep.unit.target.name()\n );\n\n // In older releases, lib-targets defaulted to the name of the package. Newer releases\n // use the same name as default, but with dashes replaced. Hence, if the name of the\n // target was inferred by Cargo, we also set the env-var with the unconverted name for\n // backwards compatibility.\n let need_compat = unit_dep.unit.target.is_lib() && unit_dep.unit.target.name_inferred();\n if need_compat {\n let var_compat = format!(\n \"CARGO_{}_FILE_{}_{}\",\n artifact_type_upper,\n dep_name_upper,\n unit_dep.unit.pkg.name(),\n );\n if var_compat != var_file {\n env.insert(var_compat, artifact_path.to_owned().into());\n }\n }\n\n env.insert(var_file, artifact_path.to_owned().into());\n\n // If the name of the target matches the name of the dependency, we strip the\n // repetition and provide the simpler env-var as well.\n // For backwards-compatibility of inferred names, we compare against the name of the\n // package as well, since that used to be the default for library targets.\n if unit_dep.unit.target.name() == dep_name.as_str()\n || (need_compat && unit_dep.unit.pkg.name() == dep_name.as_str())\n {\n let var = format!(\"CARGO_{}_FILE_{}\", artifact_type_upper, dep_name_upper,);\n env.insert(var, artifact_path.to_owned().into());\n }\n }\n }\n Ok(env)\n}\n\nfn unit_artifact_type_name_upper(unit: &Unit) -> &'static str {\n match unit.target.kind() {\n TargetKind::Lib(kinds) => match kinds.as_slice() {\n &[CrateType::Cdylib] => \"CDYLIB\",\n &[CrateType::Staticlib] => \"STATICLIB\",\n invalid => unreachable!(\"BUG: artifacts cannot be of type {:?}\", invalid),\n },\n TargetKind::Bin => \"BIN\",\n invalid => unreachable!(\"BUG: artifacts cannot be of type {:?}\", invalid),\n }\n}\n\n/// Given a dependency with an artifact `artifact_dep` and a set of available `targets`\n/// of its package, find a target for each kind of artifacts that are to be built.\n///\n/// Failure to match any target results in an error mentioning the parent manifests\n/// `parent_package` name.\npub(crate) fn match_artifacts_kind_with_targets<'t, 'd>(\n artifact_dep: &'d Dependency,\n targets: &'t [Target],\n parent_package: &str,\n) -> CargoResult> {\n let mut out = HashSet::new();\n let artifact_requirements = artifact_dep.artifact().expect(\"artifact present\");\n for artifact_kind in artifact_requirements.kinds() {\n let mut extend = |kind, filter: &dyn Fn(&&Target) -> bool| {\n let mut iter = targets.iter().filter(filter).peekable();\n let found = iter.peek().is_some();\n out.extend(std::iter::repeat(kind).zip(iter));\n found\n };\n let found = match artifact_kind {\n ArtifactKind::Cdylib => extend(artifact_kind, &|t| t.is_cdylib()),\n ArtifactKind::Staticlib => extend(artifact_kind, &|t| t.is_staticlib()),\n ArtifactKind::AllBinaries => extend(artifact_kind, &|t| t.is_bin()),\n ArtifactKind::SelectedBinary(bin_name) => extend(artifact_kind, &|t| {\n t.is_bin() && t.name() == bin_name.as_str()\n }),\n };\n if !found {\n anyhow::bail!(\n \"dependency `{}` in package `{}` requires a `{}` artifact to be present.\",\n artifact_dep.name_in_toml(),\n parent_package,\n artifact_kind\n );\n }\n }\n Ok(out)\n}\n" }, { "path": "src/cargo/core/compiler/build_config.rs", "content": "use crate::core::compiler::CompileKind;\nuse crate::util::context::JobsConfig;\nuse crate::util::interning::InternedString;\nuse crate::util::{CargoResult, GlobalContext, RustfixDiagnosticServer};\nuse anyhow::{Context as _, bail};\nuse cargo_util::ProcessBuilder;\nuse serde::ser;\nuse std::cell::RefCell;\nuse std::path::PathBuf;\nuse std::rc::Rc;\nuse std::thread::available_parallelism;\n\n/// Configuration information for a rustc build.\n#[derive(Debug, Clone)]\npub struct BuildConfig {\n /// The requested kind of compilation for this session\n pub requested_kinds: Vec,\n /// Number of rustc jobs to run in parallel.\n pub jobs: u32,\n /// Do not abort the build as soon as there is an error.\n pub keep_going: bool,\n /// Build profile\n pub requested_profile: InternedString,\n /// The intent we are compiling in.\n pub intent: UserIntent,\n /// `true` to print stdout in JSON format (for machine reading).\n pub message_format: MessageFormat,\n /// Force Cargo to do a full rebuild and treat each target as changed.\n pub force_rebuild: bool,\n /// Output the unit graph to stdout instead of actually compiling.\n pub unit_graph: bool,\n /// `true` to avoid really compiling.\n pub dry_run: bool,\n /// An optional override of the rustc process for primary units\n pub primary_unit_rustc: Option,\n /// A thread used by `cargo fix` to receive messages on a socket regarding\n /// the success/failure of applying fixes.\n pub rustfix_diagnostic_server: Rc>>,\n /// The directory to copy final artifacts to. Note that even if\n /// `artifact-dir` is set, a copy of artifacts still can be found at\n /// `target/(debug\\release)` as usual.\n /// Named `export_dir` to avoid confusion with\n /// `CompilationFiles::artifact_dir`.\n pub export_dir: Option,\n /// `true` to output a future incompatibility report at the end of the build\n pub future_incompat_report: bool,\n /// Output timing report at the end of the build\n pub timing_report: bool,\n /// Output SBOM precursor files.\n pub sbom: bool,\n /// Build compile time dependencies only, e.g., build scripts and proc macros\n pub compile_time_deps_only: bool,\n}\n\nfn default_parallelism() -> CargoResult {\n Ok(available_parallelism()\n .context(\"failed to determine the amount of parallelism available\")?\n .get() as u32)\n}\n\nimpl BuildConfig {\n /// Parses all config files to learn about build configuration. Currently\n /// configured options are:\n ///\n /// * `build.jobs`\n /// * `build.target`\n /// * `target.$target.ar`\n /// * `target.$target.linker`\n /// * `target.$target.libfoo.metadata`\n pub fn new(\n gctx: &GlobalContext,\n jobs: Option,\n keep_going: bool,\n requested_targets: &[String],\n intent: UserIntent,\n ) -> CargoResult {\n let cfg = gctx.build_config()?;\n let requested_kinds = CompileKind::from_requested_targets(gctx, requested_targets)?;\n if jobs.is_some() && gctx.jobserver_from_env().is_some() {\n gctx.shell().warn(\n \"a `-j` argument was passed to Cargo but Cargo is \\\n also configured with an external jobserver in \\\n its environment, ignoring the `-j` parameter\",\n )?;\n }\n let jobs = match jobs.or(cfg.jobs.clone()) {\n None => default_parallelism()?,\n Some(value) => match value {\n JobsConfig::Integer(j) => match j {\n 0 => anyhow::bail!(\"jobs may not be 0\"),\n j if j < 0 => (default_parallelism()? as i32 + j).max(1) as u32,\n j => j as u32,\n },\n JobsConfig::String(j) => match j.as_str() {\n \"default\" => default_parallelism()?,\n _ => {\n anyhow::bail!(format!(\n \"could not parse `{j}`. Number of parallel jobs should be `default` or a number.\"\n ))\n }\n },\n },\n };\n\n // If sbom flag is set, it requires the unstable feature\n let sbom = match (cfg.sbom, gctx.cli_unstable().sbom) {\n (Some(sbom), true) => sbom,\n (Some(_), false) => {\n gctx.shell()\n .warn(\"ignoring 'sbom' config, pass `-Zsbom` to enable it\")?;\n false\n }\n (None, _) => false,\n };\n\n Ok(BuildConfig {\n requested_kinds,\n jobs,\n keep_going,\n requested_profile: \"dev\".into(),\n intent,\n message_format: MessageFormat::Human,\n force_rebuild: false,\n unit_graph: false,\n dry_run: false,\n primary_unit_rustc: None,\n rustfix_diagnostic_server: Rc::new(RefCell::new(None)),\n export_dir: None,\n future_incompat_report: false,\n timing_report: false,\n sbom,\n compile_time_deps_only: false,\n })\n }\n\n /// Whether or not the *user* wants JSON output. Whether or not rustc\n /// actually uses JSON is decided in `add_error_format`.\n pub fn emit_json(&self) -> bool {\n matches!(self.message_format, MessageFormat::Json { .. })\n }\n\n pub fn single_requested_kind(&self) -> CargoResult {\n match self.requested_kinds.len() {\n 1 => Ok(self.requested_kinds[0]),\n _ => bail!(\"only one `--target` argument is supported\"),\n }\n }\n}\n\n#[derive(Clone, Copy, Debug, PartialEq, Eq)]\npub enum MessageFormat {\n Human,\n Json {\n /// Whether rustc diagnostics are rendered by cargo or included into the\n /// output stream.\n render_diagnostics: bool,\n /// Whether the `rendered` field of rustc diagnostics are using the\n /// \"short\" rendering.\n short: bool,\n /// Whether the `rendered` field of rustc diagnostics embed ansi color\n /// codes.\n ansi: bool,\n },\n Short,\n}\n\n/// The specific action to be performed on each `Unit` of work.\n#[derive(Clone, Copy, PartialEq, Debug, Eq, Hash, PartialOrd, Ord)]\npub enum CompileMode {\n /// Test with `rustc`.\n Test,\n /// Compile with `rustc`.\n Build,\n /// Type-check with `rustc` by emitting `rmeta` metadata only.\n ///\n /// If `test` is true, then it is also compiled with `--test` to check it like\n /// a test.\n Check { test: bool },\n /// Document with `rustdoc`.\n Doc,\n /// Test with `rustdoc`.\n Doctest,\n /// Scrape for function calls by `rustdoc`.\n Docscrape,\n /// Execute the binary built from the `build.rs` script.\n RunCustomBuild,\n}\n\nimpl ser::Serialize for CompileMode {\n fn serialize(&self, s: S) -> Result\n where\n S: ser::Serializer,\n {\n use self::CompileMode::*;\n match *self {\n Test => \"test\".serialize(s),\n Build => \"build\".serialize(s),\n Check { .. } => \"check\".serialize(s),\n Doc { .. } => \"doc\".serialize(s),\n Doctest => \"doctest\".serialize(s),\n Docscrape => \"docscrape\".serialize(s),\n RunCustomBuild => \"run-custom-build\".serialize(s),\n }\n }\n}\n\nimpl<'de> serde::Deserialize<'de> for CompileMode {\n fn deserialize(deserializer: D) -> Result\n where\n D: serde::Deserializer<'de>,\n {\n let s = String::deserialize(deserializer)?;\n match s.as_str() {\n \"test\" => Ok(CompileMode::Test),\n \"build\" => Ok(CompileMode::Build),\n \"check\" => Ok(CompileMode::Check { test: false }),\n \"doc\" => Ok(CompileMode::Doc),\n \"doctest\" => Ok(CompileMode::Doctest),\n \"docscrape\" => Ok(CompileMode::Docscrape),\n \"run-custom-build\" => Ok(CompileMode::RunCustomBuild),\n other => Err(serde::de::Error::unknown_variant(\n other,\n &[\n \"test\",\n \"build\",\n \"check\",\n \"doc\",\n \"doctest\",\n \"docscrape\",\n \"run-custom-build\",\n ],\n )),\n }\n }\n}\n\nimpl CompileMode {\n /// Returns `true` if the unit is being checked.\n pub fn is_check(self) -> bool {\n matches!(self, CompileMode::Check { .. })\n }\n\n /// Returns `true` if this is generating documentation.\n pub fn is_doc(self) -> bool {\n matches!(self, CompileMode::Doc { .. })\n }\n\n /// Returns `true` if this a doc test.\n pub fn is_doc_test(self) -> bool {\n self == CompileMode::Doctest\n }\n\n /// Returns `true` if this is scraping examples for documentation.\n pub fn is_doc_scrape(self) -> bool {\n self == CompileMode::Docscrape\n }\n\n /// Returns `true` if this is any type of test (test, benchmark, doc test, or\n /// check test).\n pub fn is_any_test(self) -> bool {\n matches!(\n self,\n CompileMode::Test | CompileMode::Check { test: true } | CompileMode::Doctest\n )\n }\n\n /// Returns `true` if this is something that passes `--test` to rustc.\n pub fn is_rustc_test(self) -> bool {\n matches!(self, CompileMode::Test | CompileMode::Check { test: true })\n }\n\n /// Returns `true` if this is the *execution* of a `build.rs` script.\n pub fn is_run_custom_build(self) -> bool {\n self == CompileMode::RunCustomBuild\n }\n\n /// Returns `true` if this mode may generate an executable.\n ///\n /// Note that this also returns `true` for building libraries, so you also\n /// have to check the target.\n pub fn generates_executable(self) -> bool {\n matches!(self, CompileMode::Test | CompileMode::Build)\n }\n}\n\n/// Represents the high-level operation requested by the user.\n///\n/// It determines which \"Cargo targets\" are selected by default and influences\n/// how they will be processed. This is derived from the Cargo command the user\n/// invoked (like `cargo build` or `cargo test`).\n///\n/// Unlike [`CompileMode`], which describes the specific compilation steps for\n/// individual units, [`UserIntent`] represents the overall goal of the build\n/// process as specified by the user.\n///\n/// For example, when a user runs `cargo test`, the intent is [`UserIntent::Test`],\n/// but this might result in multiple [`CompileMode`]s for different units.\n#[derive(Clone, Copy, Debug)]\npub enum UserIntent {\n /// Build benchmark binaries, e.g., `cargo bench`\n Bench,\n /// Build binaries and libraries, e.g., `cargo run`, `cargo install`, `cargo build`.\n Build,\n /// Perform type-check, e.g., `cargo check`.\n Check { test: bool },\n /// Document packages.\n ///\n /// If `deps` is true, then it will also document all dependencies.\n /// if `json` is true, the documentation output is in json format.\n Doc { deps: bool, json: bool },\n /// Build doctest binaries, e.g., `cargo test --doc`\n Doctest,\n /// Build test binaries, e.g., `cargo test`\n Test,\n}\n\nimpl UserIntent {\n /// Returns `true` if this is generating documentation.\n pub fn is_doc(self) -> bool {\n matches!(self, UserIntent::Doc { .. })\n }\n\n /// User wants rustdoc output in JSON format.\n pub fn wants_doc_json_output(self) -> bool {\n matches!(self, UserIntent::Doc { json: true, .. })\n }\n\n /// User wants to document also for dependencies.\n pub fn wants_deps_docs(self) -> bool {\n matches!(self, UserIntent::Doc { deps: true, .. })\n }\n\n /// Returns `true` if this is any type of test (test, benchmark, doc test, or\n /// check test).\n pub fn is_any_test(self) -> bool {\n matches!(\n self,\n UserIntent::Test\n | UserIntent::Bench\n | UserIntent::Check { test: true }\n | UserIntent::Doctest\n )\n }\n\n /// Returns `true` if this is something that passes `--test` to rustc.\n pub fn is_rustc_test(self) -> bool {\n matches!(\n self,\n UserIntent::Test | UserIntent::Bench | UserIntent::Check { test: true }\n )\n }\n}\n" }, { "path": "src/cargo/core/compiler/build_context/mod.rs", "content": "//! [`BuildContext`] is a (mostly) static information about a build task.\n\nuse crate::core::PackageSet;\nuse crate::core::Workspace;\nuse crate::core::compiler::BuildConfig;\nuse crate::core::compiler::CompileKind;\nuse crate::core::compiler::Unit;\nuse crate::core::compiler::UnitIndex;\nuse crate::core::compiler::unit_graph::UnitGraph;\nuse crate::core::profiles::Profiles;\nuse crate::util::Rustc;\nuse crate::util::context::GlobalContext;\nuse crate::util::errors::CargoResult;\nuse crate::util::interning::InternedString;\nuse crate::util::logger::BuildLogger;\nuse std::collections::{HashMap, HashSet};\n\nmod target_info;\npub use self::target_info::FileFlavor;\npub use self::target_info::FileType;\npub use self::target_info::RustcTargetData;\npub use self::target_info::TargetInfo;\n\n/// The build context, containing complete information needed for a build task\n/// before it gets started.\n///\n/// It is intended that this is mostly static information. Stuff that mutates\n/// during the build can be found in the parent [`BuildRunner`]. (I say mostly,\n/// because this has internal caching, but nothing that should be observable\n/// or require &mut.)\n///\n/// As a result, almost every field on `BuildContext` is public, including\n///\n/// * a resolved [`UnitGraph`] of your dependencies,\n/// * a [`Profiles`] containing compiler flags presets,\n/// * a [`RustcTargetData`] containing host and target platform information,\n/// * and a [`PackageSet`] for further package downloads,\n///\n/// just to name a few. Learn more on each own documentation.\n///\n/// # How to use\n///\n/// To prepare a build task, you may not want to use [`BuildContext::new`] directly,\n/// since it is often too lower-level.\n/// Instead, [`ops::create_bcx`] is usually what you are looking for.\n///\n/// After a `BuildContext` is built, the next stage of building is handled in [`BuildRunner`].\n///\n/// [`BuildRunner`]: crate::core::compiler::BuildRunner\n/// [`ops::create_bcx`]: crate::ops::create_bcx\npub struct BuildContext<'a, 'gctx> {\n /// The workspace the build is for.\n pub ws: &'a Workspace<'gctx>,\n\n /// The cargo context.\n pub gctx: &'gctx GlobalContext,\n\n /// Build logger for `-Zbuild-analysis`.\n pub logger: Option<&'a BuildLogger>,\n\n /// This contains a collection of compiler flags presets.\n pub profiles: Profiles,\n\n /// Configuration information for a rustc build.\n pub build_config: &'a BuildConfig,\n\n /// Extra compiler args for either `rustc` or `rustdoc`.\n pub extra_compiler_args: HashMap>,\n\n /// Package downloader.\n ///\n /// This holds ownership of the `Package` objects.\n pub packages: PackageSet<'gctx>,\n\n /// Information about rustc and the target platform.\n pub target_data: RustcTargetData<'gctx>,\n\n /// The root units of `unit_graph` (units requested on the command-line).\n pub roots: Vec,\n\n /// The dependency graph of units to compile.\n pub unit_graph: UnitGraph,\n\n /// A map from unit to index.\n pub unit_to_index: HashMap,\n\n /// Reverse-dependencies of documented units, used by the `rustdoc --scrape-examples` flag.\n pub scrape_units: Vec,\n\n /// The list of all kinds that are involved in this build\n pub all_kinds: HashSet,\n}\n\nimpl<'a, 'gctx> BuildContext<'a, 'gctx> {\n pub fn new(\n ws: &'a Workspace<'gctx>,\n logger: Option<&'a BuildLogger>,\n packages: PackageSet<'gctx>,\n build_config: &'a BuildConfig,\n profiles: Profiles,\n extra_compiler_args: HashMap>,\n target_data: RustcTargetData<'gctx>,\n roots: Vec,\n unit_graph: UnitGraph,\n unit_to_index: HashMap,\n scrape_units: Vec,\n ) -> CargoResult> {\n let all_kinds = unit_graph\n .keys()\n .map(|u| u.kind)\n .chain(build_config.requested_kinds.iter().copied())\n .chain(std::iter::once(CompileKind::Host))\n .collect();\n\n Ok(BuildContext {\n ws,\n gctx: ws.gctx(),\n logger,\n packages,\n build_config,\n profiles,\n extra_compiler_args,\n target_data,\n roots,\n unit_graph,\n unit_to_index,\n scrape_units,\n all_kinds,\n })\n }\n\n /// Information of the `rustc` this build task will use.\n pub fn rustc(&self) -> &Rustc {\n &self.target_data.rustc\n }\n\n /// Gets the host architecture triple.\n ///\n /// For example, `x86_64-unknown-linux-gnu`, would be\n /// - machine: `x86_64`,\n /// - hardware-platform: `unknown`,\n /// - operating system: `linux-gnu`.\n pub fn host_triple(&self) -> InternedString {\n self.target_data.rustc.host\n }\n\n /// Gets the number of jobs specified for this build.\n pub fn jobs(&self) -> u32 {\n self.build_config.jobs\n }\n\n /// Extra compiler args for either `rustc` or `rustdoc`.\n ///\n /// As of now, these flags come from the trailing args of either\n /// `cargo rustc` or `cargo rustdoc`.\n pub fn extra_args_for(&self, unit: &Unit) -> Option<&Vec> {\n self.extra_compiler_args.get(unit)\n }\n}\n" }, { "path": "src/cargo/core/compiler/build_context/target_info.rs", "content": "//! This modules contains types storing information of target platforms.\n//!\n//! Normally, call [`RustcTargetData::new`] to construct all the target\n//! platform once, and then query info on your demand. For example,\n//!\n//! * [`RustcTargetData::dep_platform_activated`] to check if platform is activated.\n//! * [`RustcTargetData::info`] to get a [`TargetInfo`] for an in-depth query.\n//! * [`TargetInfo::rustc_outputs`] to get a list of supported file types.\n\nuse crate::core::compiler::CompileKind;\nuse crate::core::compiler::CompileMode;\nuse crate::core::compiler::CompileTarget;\nuse crate::core::compiler::CrateType;\nuse crate::core::compiler::apply_env_config;\nuse crate::core::{Dependency, Package, Target, TargetKind, Workspace};\nuse crate::util::context::{GlobalContext, StringList, TargetConfig};\nuse crate::util::interning::InternedString;\nuse crate::util::{CargoResult, Rustc};\n\nuse anyhow::Context as _;\nuse cargo_platform::{Cfg, CfgExpr};\nuse cargo_util::ProcessBuilder;\nuse serde::Deserialize;\n\nuse std::cell::RefCell;\nuse std::collections::hash_map::{Entry, HashMap};\nuse std::path::PathBuf;\nuse std::rc::Rc;\nuse std::str::{self, FromStr};\n\n/// Information about the platform target gleaned from querying rustc.\n///\n/// [`RustcTargetData`] keeps several of these, one for the host and the others\n/// for other specified targets. If no target is specified, it uses a clone from\n/// the host.\n#[derive(Clone)]\npub struct TargetInfo {\n /// A base process builder for discovering crate type information. In\n /// particular, this is used to determine the output filename prefix and\n /// suffix for a crate type.\n crate_type_process: ProcessBuilder,\n /// Cache of output filename prefixes and suffixes.\n ///\n /// The key is the crate type name (like `cdylib`) and the value is\n /// `Some((prefix, suffix))`, for example `libcargo.so` would be\n /// `Some((\"lib\", \".so\"))`. The value is `None` if the crate type is not\n /// supported.\n crate_types: RefCell>>,\n /// `cfg` information extracted from `rustc --print=cfg`.\n cfg: Vec,\n /// `supports_std` information extracted from `rustc --print=target-spec-json`\n pub supports_std: Option,\n /// Supported values for `-Csplit-debuginfo=` flag, queried from rustc\n support_split_debuginfo: Vec,\n /// Path to the sysroot.\n pub sysroot: PathBuf,\n /// Path to the \"lib\" directory in the sysroot which rustc uses for linking\n /// target libraries.\n pub sysroot_target_libdir: PathBuf,\n /// Extra flags to pass to `rustc`, see [`extra_args`].\n pub rustflags: Rc<[String]>,\n /// Extra flags to pass to `rustdoc`, see [`extra_args`].\n pub rustdocflags: Rc<[String]>,\n}\n\n/// Kind of each file generated by a Unit, part of `FileType`.\n#[derive(Clone, PartialEq, Eq, Debug)]\npub enum FileFlavor {\n /// Not a special file type.\n Normal,\n /// Like `Normal`, but not directly executable.\n /// For example, a `.wasm` file paired with the \"normal\" `.js` file.\n Auxiliary,\n /// Something you can link against (e.g., a library).\n Linkable,\n /// An `.rmeta` Rust metadata file.\n Rmeta,\n /// Piece of external debug information (e.g., `.dSYM`/`.pdb` file).\n DebugInfo,\n /// SBOM (Software Bill of Materials pre-cursor) file (e.g. cargo-sbon.json).\n Sbom,\n /// Cross-crate info JSON files generated by rustdoc.\n DocParts,\n}\n\n/// Type of each file generated by a Unit.\n#[derive(Debug)]\npub struct FileType {\n /// The kind of file.\n pub flavor: FileFlavor,\n /// The crate-type that generates this file.\n ///\n /// `None` for things that aren't associated with a specific crate type,\n /// for example `rmeta` files.\n pub crate_type: Option,\n /// The suffix for the file (for example, `.rlib`).\n /// This is an empty string for executables on Unix-like platforms.\n suffix: String,\n /// The prefix for the file (for example, `lib`).\n /// This is an empty string for things like executables.\n prefix: String,\n /// Flag to convert hyphen to underscore when uplifting.\n should_replace_hyphens: bool,\n}\n\nimpl FileType {\n /// The filename for this `FileType` created by rustc.\n pub fn output_filename(&self, target: &Target, metadata: Option<&str>) -> String {\n match metadata {\n Some(metadata) => format!(\n \"{}{}-{}{}\",\n self.prefix,\n target.crate_name(),\n metadata,\n self.suffix\n ),\n None => format!(\"{}{}{}\", self.prefix, target.crate_name(), self.suffix),\n }\n }\n\n /// The filename for this `FileType` that Cargo should use when \"uplifting\"\n /// it to the destination directory.\n pub fn uplift_filename(&self, target: &Target) -> String {\n let name = match target.binary_filename() {\n Some(name) => name,\n None => {\n // For binary crate type, `should_replace_hyphens` will always be false.\n if self.should_replace_hyphens {\n target.crate_name()\n } else {\n target.name().to_string()\n }\n }\n };\n\n format!(\"{}{}{}\", self.prefix, name, self.suffix)\n }\n\n /// Creates a new instance representing a `.rmeta` file.\n pub fn new_rmeta() -> FileType {\n // Note that even binaries use the `lib` prefix.\n FileType {\n flavor: FileFlavor::Rmeta,\n crate_type: None,\n suffix: \".rmeta\".to_string(),\n prefix: \"lib\".to_string(),\n should_replace_hyphens: true,\n }\n }\n\n pub fn output_prefix_suffix(&self, target: &Target) -> (String, String) {\n (\n format!(\"{}{}-\", self.prefix, target.crate_name()),\n self.suffix.clone(),\n )\n }\n}\n\nimpl TargetInfo {\n /// Learns the information of target platform from `rustc` invocation(s).\n ///\n /// Generally, the first time calling this function is expensive, as it may\n /// query `rustc` several times. To reduce the cost, output of each `rustc`\n /// invocation is cached by [`Rustc::cached_output`].\n ///\n /// Search `Tricky` to learn why querying `rustc` several times is needed.\n #[tracing::instrument(skip_all)]\n pub fn new(\n gctx: &GlobalContext,\n requested_kinds: &[CompileKind],\n rustc: &Rustc,\n kind: CompileKind,\n ) -> CargoResult {\n let mut rustflags =\n extra_args(gctx, requested_kinds, &rustc.host, None, kind, Flags::Rust)?;\n let mut turn = 0;\n loop {\n let extra_fingerprint = kind.fingerprint_hash();\n\n // Query rustc for several kinds of info from each line of output:\n // 0) file-names (to determine output file prefix/suffix for given crate type)\n // 1) sysroot\n // 2) split-debuginfo\n // 3) cfg\n //\n // Search `--print` to see what we query so far.\n let mut process = rustc.workspace_process();\n apply_env_config(gctx, &mut process)?;\n process\n .arg(\"-\")\n .arg(\"--crate-name\")\n .arg(\"___\")\n .arg(\"--print=file-names\")\n .args(&rustflags)\n .env_remove(\"RUSTC_LOG\");\n\n // Removes `FD_CLOEXEC` set by `jobserver::Client` to pass jobserver\n // as environment variables specify.\n if let Some(client) = gctx.jobserver_from_env() {\n process.inherit_jobserver(client);\n }\n\n kind.add_target_arg(&mut process);\n\n let crate_type_process = process.clone();\n const KNOWN_CRATE_TYPES: &[CrateType] = &[\n CrateType::Bin,\n CrateType::Rlib,\n CrateType::Dylib,\n CrateType::Cdylib,\n CrateType::Staticlib,\n CrateType::ProcMacro,\n ];\n for crate_type in KNOWN_CRATE_TYPES.iter() {\n process.arg(\"--crate-type\").arg(crate_type.as_str());\n }\n\n process.arg(\"--print=sysroot\");\n process.arg(\"--print=split-debuginfo\");\n process.arg(\"--print=crate-name\"); // `___` as a delimiter.\n process.arg(\"--print=cfg\");\n\n // parse_crate_type() relies on \"unsupported/unknown crate type\" error message,\n // so make warnings always emitted as warnings.\n process.arg(\"-Wwarnings\");\n\n let (output, error) = rustc\n .cached_output(&process, extra_fingerprint)\n .with_context(\n || \"failed to run `rustc` to learn about target-specific information\",\n )?;\n\n let mut lines = output.lines();\n let mut map = HashMap::new();\n for crate_type in KNOWN_CRATE_TYPES {\n let out = parse_crate_type(crate_type, &process, &output, &error, &mut lines)?;\n map.insert(crate_type.clone(), out);\n }\n\n let Some(line) = lines.next() else {\n return error_missing_print_output(\"sysroot\", &process, &output, &error);\n };\n let sysroot = PathBuf::from(line);\n let sysroot_target_libdir = {\n let mut libdir = sysroot.clone();\n libdir.push(\"lib\");\n libdir.push(\"rustlib\");\n libdir.push(match &kind {\n CompileKind::Host => rustc.host.as_str(),\n CompileKind::Target(target) => target.short_name(),\n });\n libdir.push(\"lib\");\n libdir\n };\n\n let support_split_debuginfo = {\n // HACK: abuse `--print=crate-name` to use `___` as a delimiter.\n let mut res = Vec::new();\n loop {\n match lines.next() {\n Some(line) if line == \"___\" => break,\n Some(line) => res.push(line.into()),\n None => {\n return error_missing_print_output(\n \"split-debuginfo\",\n &process,\n &output,\n &error,\n );\n }\n }\n }\n res\n };\n\n let cfg = lines\n .map(|line| Ok(Cfg::from_str(line)?))\n .filter(TargetInfo::not_user_specific_cfg)\n .collect::>>()\n .with_context(|| {\n format!(\n \"failed to parse the cfg from `rustc --print=cfg`, got:\\n{}\",\n output\n )\n })?;\n\n // recalculate `rustflags` from above now that we have `cfg`\n // information\n let new_flags = extra_args(\n gctx,\n requested_kinds,\n &rustc.host,\n Some(&cfg),\n kind,\n Flags::Rust,\n )?;\n\n // Tricky: `RUSTFLAGS` defines the set of active `cfg` flags, active\n // `cfg` flags define which `.cargo/config` sections apply, and they\n // in turn can affect `RUSTFLAGS`! This is a bona fide mutual\n // dependency, and it can even diverge (see `cfg_paradox` test).\n //\n // So what we do here is running at most *two* iterations of\n // fixed-point iteration, which should be enough to cover\n // practically useful cases, and warn if that's not enough for\n // convergence.\n let reached_fixed_point = new_flags == rustflags;\n if !reached_fixed_point && turn == 0 {\n turn += 1;\n rustflags = new_flags;\n continue;\n }\n if !reached_fixed_point {\n gctx.shell().warn(\"non-trivial mutual dependency between target-specific configuration and RUSTFLAGS\")?;\n }\n\n let mut supports_std: Option = None;\n\n // The '--print=target-spec-json' is an unstable option of rustc, therefore only\n // try to fetch this information if rustc allows nightly features. Additionally,\n // to avoid making two rustc queries when not required, only try to fetch the\n // target-spec when the '-Zbuild-std' option is passed.\n if gctx.cli_unstable().build_std.is_some() {\n let mut target_spec_process = rustc.workspace_process();\n apply_env_config(gctx, &mut target_spec_process)?;\n target_spec_process\n .arg(\"--print=target-spec-json\")\n .arg(\"-Zunstable-options\")\n .args(&rustflags)\n .env_remove(\"RUSTC_LOG\");\n\n kind.add_target_arg(&mut target_spec_process);\n\n #[derive(Deserialize)]\n struct Metadata {\n pub std: Option,\n }\n\n #[derive(Deserialize)]\n struct TargetSpec {\n pub metadata: Metadata,\n }\n\n if let Ok(output) = target_spec_process.output() {\n if let Ok(spec) = serde_json::from_slice::(&output.stdout) {\n supports_std = spec.metadata.std;\n }\n }\n }\n\n return Ok(TargetInfo {\n crate_type_process,\n crate_types: RefCell::new(map),\n sysroot,\n sysroot_target_libdir,\n rustflags: rustflags.into(),\n rustdocflags: extra_args(\n gctx,\n requested_kinds,\n &rustc.host,\n Some(&cfg),\n kind,\n Flags::Rustdoc,\n )?\n .into(),\n cfg,\n supports_std,\n support_split_debuginfo,\n });\n }\n }\n\n fn not_user_specific_cfg(cfg: &CargoResult) -> bool {\n if let Ok(Cfg::Name(cfg_name)) = cfg {\n // This should also include \"debug_assertions\", but it causes\n // regressions. Maybe some day in the distant future it can be\n // added (and possibly change the warning to an error).\n if cfg_name == \"proc_macro\" {\n return false;\n }\n }\n true\n }\n\n /// All the target [`Cfg`] settings.\n pub fn cfg(&self) -> &[Cfg] {\n &self.cfg\n }\n\n /// Returns the list of file types generated by the given crate type.\n ///\n /// Returns `None` if the target does not support the given crate type.\n fn file_types(\n &self,\n crate_type: &CrateType,\n flavor: FileFlavor,\n target_triple: &str,\n ) -> CargoResult>> {\n let crate_type = if *crate_type == CrateType::Lib {\n CrateType::Rlib\n } else {\n crate_type.clone()\n };\n\n let mut crate_types = self.crate_types.borrow_mut();\n let entry = crate_types.entry(crate_type.clone());\n let crate_type_info = match entry {\n Entry::Occupied(o) => &*o.into_mut(),\n Entry::Vacant(v) => {\n let value = self.discover_crate_type(v.key())?;\n &*v.insert(value)\n }\n };\n let Some((prefix, suffix)) = crate_type_info else {\n return Ok(None);\n };\n let mut ret = vec![FileType {\n suffix: suffix.clone(),\n prefix: prefix.clone(),\n flavor,\n crate_type: Some(crate_type.clone()),\n should_replace_hyphens: crate_type != CrateType::Bin,\n }];\n\n // Window shared library import/export files.\n if crate_type.is_dynamic() {\n // Note: Custom JSON specs can alter the suffix. For now, we'll\n // just ignore non-DLL suffixes.\n if target_triple.ends_with(\"-windows-msvc\") && suffix == \".dll\" {\n // See https://docs.microsoft.com/en-us/cpp/build/reference/working-with-import-libraries-and-export-files\n // for more information about DLL import/export files.\n ret.push(FileType {\n suffix: \".dll.lib\".to_string(),\n prefix: prefix.clone(),\n flavor: FileFlavor::Auxiliary,\n crate_type: Some(crate_type.clone()),\n should_replace_hyphens: true,\n });\n // NOTE: lld does not produce these\n ret.push(FileType {\n suffix: \".dll.exp\".to_string(),\n prefix: prefix.clone(),\n flavor: FileFlavor::Auxiliary,\n crate_type: Some(crate_type.clone()),\n should_replace_hyphens: true,\n });\n } else if suffix == \".dll\"\n && (target_triple.ends_with(\"windows-gnu\")\n || target_triple.ends_with(\"windows-gnullvm\")\n || target_triple.ends_with(\"cygwin\"))\n {\n // See https://cygwin.com/cygwin-ug-net/dll.html for more\n // information about GNU import libraries.\n // LD can link DLL directly, but LLD requires the import library.\n ret.push(FileType {\n suffix: \".dll.a\".to_string(),\n prefix: \"lib\".to_string(),\n flavor: FileFlavor::Auxiliary,\n crate_type: Some(crate_type.clone()),\n should_replace_hyphens: true,\n })\n }\n }\n\n if target_triple.starts_with(\"wasm32-\") && crate_type == CrateType::Bin && suffix == \".js\" {\n // emscripten binaries generate a .js file, which loads a .wasm\n // file.\n ret.push(FileType {\n suffix: \".wasm\".to_string(),\n prefix: prefix.clone(),\n flavor: FileFlavor::Auxiliary,\n crate_type: Some(crate_type.clone()),\n // Name `foo-bar` will generate a `foo_bar.js` and\n // `foo_bar.wasm`. Cargo will translate the underscore and\n // copy `foo_bar.js` to `foo-bar.js`. However, the wasm\n // filename is embedded in the .js file with an underscore, so\n // it should not contain hyphens.\n should_replace_hyphens: true,\n });\n // And a map file for debugging. This is only emitted with debug=2\n // (-g4 for emcc).\n ret.push(FileType {\n suffix: \".wasm.map\".to_string(),\n prefix: prefix.clone(),\n flavor: FileFlavor::DebugInfo,\n crate_type: Some(crate_type.clone()),\n should_replace_hyphens: true,\n });\n }\n\n // Handle separate debug files.\n let is_apple = target_triple.contains(\"-apple-\");\n if matches!(\n crate_type,\n CrateType::Bin | CrateType::Dylib | CrateType::Cdylib | CrateType::ProcMacro\n ) {\n if is_apple {\n let suffix = if crate_type == CrateType::Bin {\n \".dSYM\".to_string()\n } else {\n \".dylib.dSYM\".to_string()\n };\n ret.push(FileType {\n suffix,\n prefix: prefix.clone(),\n flavor: FileFlavor::DebugInfo,\n crate_type: Some(crate_type),\n // macOS tools like lldb use all sorts of magic to locate\n // dSYM files. See https://lldb.llvm.org/use/symbols.html\n // for some details. It seems like a `.dSYM` located next\n // to the executable with the same name is one method. The\n // dSYM should have the same hyphens as the executable for\n // the names to match.\n should_replace_hyphens: false,\n })\n } else if target_triple.ends_with(\"-msvc\") || target_triple.ends_with(\"-uefi\") {\n ret.push(FileType {\n suffix: \".pdb\".to_string(),\n prefix: prefix.clone(),\n flavor: FileFlavor::DebugInfo,\n crate_type: Some(crate_type),\n // The absolute path to the pdb file is embedded in the\n // executable. If the exe/pdb pair is moved to another\n // machine, then debuggers will look in the same directory\n // of the exe with the original pdb filename. Since the\n // original name contains underscores, they need to be\n // preserved.\n should_replace_hyphens: true,\n })\n } else {\n // Because DWARF Package (dwp) files are produced after the\n // fact by another tool, there is nothing in the binary that\n // provides a means to locate them. By convention, debuggers\n // take the binary filename and append \".dwp\" (including to\n // binaries that already have an extension such as shared libs)\n // to find the dwp.\n ret.push(FileType {\n // It is important to preserve the existing suffix for\n // e.g. shared libraries, where the dwp for libfoo.so is\n // expected to be at libfoo.so.dwp.\n suffix: format!(\"{suffix}.dwp\"),\n prefix: prefix.clone(),\n flavor: FileFlavor::DebugInfo,\n crate_type: Some(crate_type.clone()),\n // Likewise, the dwp needs to match the primary artifact's\n // hyphenation exactly.\n should_replace_hyphens: crate_type != CrateType::Bin,\n })\n }\n }\n\n Ok(Some(ret))\n }\n\n fn discover_crate_type(&self, crate_type: &CrateType) -> CargoResult> {\n let mut process = self.crate_type_process.clone();\n\n process.arg(\"--crate-type\").arg(crate_type.as_str());\n\n let output = process.exec_with_output().with_context(|| {\n format!(\n \"failed to run `rustc` to learn about crate-type {} information\",\n crate_type\n )\n })?;\n\n let error = str::from_utf8(&output.stderr).unwrap();\n let output = str::from_utf8(&output.stdout).unwrap();\n parse_crate_type(crate_type, &process, output, error, &mut output.lines())\n }\n\n /// Returns all the file types generated by rustc for the given `mode`/`target_kind`.\n ///\n /// The first value is a Vec of file types generated, the second value is\n /// a list of `CrateTypes` that are not supported by the given target.\n pub fn rustc_outputs(\n &self,\n mode: CompileMode,\n target_kind: &TargetKind,\n target_triple: &str,\n gctx: &GlobalContext,\n ) -> CargoResult<(Vec, Vec)> {\n match mode {\n CompileMode::Build => self.calc_rustc_outputs(target_kind, target_triple, gctx),\n CompileMode::Test => {\n match self.file_types(&CrateType::Bin, FileFlavor::Normal, target_triple)? {\n Some(fts) => Ok((fts, Vec::new())),\n None => Ok((Vec::new(), vec![CrateType::Bin])),\n }\n }\n CompileMode::Check { .. } => Ok((vec![FileType::new_rmeta()], Vec::new())),\n CompileMode::Doc { .. }\n | CompileMode::Doctest\n | CompileMode::Docscrape\n | CompileMode::RunCustomBuild => {\n panic!(\"asked for rustc output for non-rustc mode\")\n }\n }\n }\n\n fn calc_rustc_outputs(\n &self,\n target_kind: &TargetKind,\n target_triple: &str,\n gctx: &GlobalContext,\n ) -> CargoResult<(Vec, Vec)> {\n let mut unsupported = Vec::new();\n let mut result = Vec::new();\n let crate_types = target_kind.rustc_crate_types();\n for crate_type in &crate_types {\n let flavor = if crate_type.is_linkable() {\n FileFlavor::Linkable\n } else {\n FileFlavor::Normal\n };\n let file_types = self.file_types(crate_type, flavor, target_triple)?;\n match file_types {\n Some(types) => {\n result.extend(types);\n }\n None => {\n unsupported.push(crate_type.clone());\n }\n }\n }\n if !result.is_empty() {\n if gctx.cli_unstable().no_embed_metadata\n && crate_types\n .iter()\n .any(|ct| ct.benefits_from_no_embed_metadata())\n {\n // Add .rmeta when we apply -Zembed-metadata=no to the unit.\n result.push(FileType::new_rmeta());\n } else if !crate_types.iter().any(|ct| ct.requires_upstream_objects()) {\n // Only add rmeta if pipelining\n result.push(FileType::new_rmeta());\n }\n }\n Ok((result, unsupported))\n }\n\n /// Checks if the debuginfo-split value is supported by this target\n pub fn supports_debuginfo_split(&self, split: InternedString) -> bool {\n self.support_split_debuginfo\n .iter()\n .any(|sup| sup.as_str() == split.as_str())\n }\n\n /// Checks if a target maybe support std.\n ///\n /// If no explicitly stated in target spec json, we treat it as \"maybe support\".\n ///\n /// This is only useful for `-Zbuild-std` to determine the default set of\n /// crates it is going to build.\n pub fn maybe_support_std(&self) -> bool {\n matches!(self.supports_std, Some(true) | None)\n }\n}\n\n/// Takes rustc output (using specialized command line args), and calculates the file prefix and\n/// suffix for the given crate type, or returns `None` if the type is not supported. (e.g., for a\n/// Rust library like `libcargo.rlib`, we have prefix \"lib\" and suffix \"rlib\").\n///\n/// The caller needs to ensure that the lines object is at the correct line for the given crate\n/// type: this is not checked.\n///\n/// This function can not handle more than one file per type (with wasm32-unknown-emscripten, there\n/// are two files for bin (`.wasm` and `.js`)).\nfn parse_crate_type(\n crate_type: &CrateType,\n cmd: &ProcessBuilder,\n output: &str,\n error: &str,\n lines: &mut str::Lines<'_>,\n) -> CargoResult> {\n let not_supported = error.lines().any(|line| {\n (line.contains(\"unsupported crate type\") || line.contains(\"unknown crate type\"))\n && line.contains(&format!(\"crate type `{}`\", crate_type))\n });\n if not_supported {\n return Ok(None);\n }\n let Some(line) = lines.next() else {\n anyhow::bail!(\n \"malformed output when learning about crate-type {} information\\n{}\",\n crate_type,\n output_err_info(cmd, output, error)\n )\n };\n let mut parts = line.trim().split(\"___\");\n let prefix = parts.next().unwrap();\n let Some(suffix) = parts.next() else {\n return error_missing_print_output(\"file-names\", cmd, output, error);\n };\n\n Ok(Some((prefix.to_string(), suffix.to_string())))\n}\n\n/// Helper for creating an error message for missing output from a certain `--print` request.\nfn error_missing_print_output(\n request: &str,\n cmd: &ProcessBuilder,\n stdout: &str,\n stderr: &str,\n) -> CargoResult {\n let err_info = output_err_info(cmd, stdout, stderr);\n anyhow::bail!(\n \"output of --print={request} missing when learning about \\\n target-specific information from rustc\\n{err_info}\",\n )\n}\n\n/// Helper for creating an error message when parsing rustc output fails.\nfn output_err_info(cmd: &ProcessBuilder, stdout: &str, stderr: &str) -> String {\n let mut result = format!(\"command was: {}\\n\", cmd);\n if !stdout.is_empty() {\n result.push_str(\"\\n--- stdout\\n\");\n result.push_str(stdout);\n }\n if !stderr.is_empty() {\n result.push_str(\"\\n--- stderr\\n\");\n result.push_str(stderr);\n }\n if stdout.is_empty() && stderr.is_empty() {\n result.push_str(\"(no output received)\");\n }\n result\n}\n\n/// Compiler flags for either rustc or rustdoc.\n#[derive(Debug, Copy, Clone)]\nenum Flags {\n Rust,\n Rustdoc,\n}\n\nimpl Flags {\n fn as_key(self) -> &'static str {\n match self {\n Flags::Rust => \"rustflags\",\n Flags::Rustdoc => \"rustdocflags\",\n }\n }\n\n fn as_env(self) -> &'static str {\n match self {\n Flags::Rust => \"RUSTFLAGS\",\n Flags::Rustdoc => \"RUSTDOCFLAGS\",\n }\n }\n}\n\n/// Acquire extra flags to pass to the compiler from various locations.\n///\n/// The locations are:\n///\n/// - the `CARGO_ENCODED_RUSTFLAGS` environment variable\n/// - the `RUSTFLAGS` environment variable\n///\n/// then if none of those were found\n///\n/// - `target.*.rustflags` from the config (.cargo/config)\n/// - `target.cfg(..).rustflags` from the config\n/// - `host.*.rustflags` from the config if compiling a host artifact or without `--target`\n/// (requires `-Zhost-config`)\n///\n/// then if none of those were found\n///\n/// - `build.rustflags` from the config\n///\n/// The behavior differs slightly when cross-compiling (or, specifically, when `--target` is\n/// provided) for artifacts that are always built for the host (plugins, build scripts, ...).\n/// For those artifacts, _only_ `host.*.rustflags` is respected, and no other configuration\n/// sources, _regardless of the value of `target-applies-to-host`_. This is counterintuitive, but\n/// necessary to retain backwards compatibility with older versions of Cargo.\n///\n/// Rules above also applies to rustdoc. Just the key would be `rustdocflags`/`RUSTDOCFLAGS`.\nfn extra_args(\n gctx: &GlobalContext,\n requested_kinds: &[CompileKind],\n host_triple: &str,\n target_cfg: Option<&[Cfg]>,\n kind: CompileKind,\n flags: Flags,\n) -> CargoResult> {\n let target_applies_to_host = gctx.target_applies_to_host()?;\n\n // Host artifacts should not generally pick up rustflags from anywhere except [host].\n //\n // The one exception to this is if `target-applies-to-host = true`, which opts into a\n // particular (inconsistent) past Cargo behavior where host artifacts _do_ pick up rustflags\n // set elsewhere when `--target` isn't passed.\n if kind.is_host() {\n if target_applies_to_host && requested_kinds == [CompileKind::Host] {\n // This is the past Cargo behavior where we fall back to the same logic as for other\n // artifacts without --target.\n } else {\n // In all other cases, host artifacts just get flags from [host], regardless of\n // --target. Or, phrased differently, no `--target` behaves the same as `--target\n // `, and host artifacts are always \"special\" (they don't pick up `RUSTFLAGS` for\n // example).\n return Ok(rustflags_from_host(gctx, flags, host_triple)?.unwrap_or_else(Vec::new));\n }\n }\n\n // All other artifacts pick up the RUSTFLAGS, [target.*], and [build], in that order.\n // NOTE: It is impossible to have a [host] section and reach this logic with kind.is_host(),\n // since [host] implies `target-applies-to-host = false`, which always early-returns above.\n\n if let Some(rustflags) = rustflags_from_env(gctx, flags) {\n Ok(rustflags)\n } else if let Some(rustflags) =\n rustflags_from_target(gctx, host_triple, target_cfg, kind, flags)?\n {\n Ok(rustflags)\n } else if let Some(rustflags) = rustflags_from_build(gctx, flags)? {\n Ok(rustflags)\n } else {\n Ok(Vec::new())\n }\n}\n\n/// Gets compiler flags from environment variables.\n/// See [`extra_args`] for more.\nfn rustflags_from_env(gctx: &GlobalContext, flags: Flags) -> Option> {\n // First try CARGO_ENCODED_RUSTFLAGS from the environment.\n // Prefer this over RUSTFLAGS since it's less prone to encoding errors.\n if let Ok(a) = gctx.get_env(format!(\"CARGO_ENCODED_{}\", flags.as_env())) {\n if a.is_empty() {\n return Some(Vec::new());\n }\n return Some(a.split('\\x1f').map(str::to_string).collect());\n }\n\n // Then try RUSTFLAGS from the environment\n if let Ok(a) = gctx.get_env(flags.as_env()) {\n let args = a\n .split(' ')\n .map(str::trim)\n .filter(|s| !s.is_empty())\n .map(str::to_string);\n return Some(args.collect());\n }\n\n // No rustflags to be collected from the environment\n None\n}\n\n/// Gets compiler flags from `[target]` section in the config.\n/// See [`extra_args`] for more.\nfn rustflags_from_target(\n gctx: &GlobalContext,\n host_triple: &str,\n target_cfg: Option<&[Cfg]>,\n kind: CompileKind,\n flag: Flags,\n) -> CargoResult>> {\n let mut rustflags = Vec::new();\n\n // Then the target.*.rustflags value...\n let target = match &kind {\n CompileKind::Host => host_triple,\n CompileKind::Target(target) => target.short_name(),\n };\n let key = format!(\"target.{}.{}\", target, flag.as_key());\n if let Some(args) = gctx.get::>(&key)? {\n rustflags.extend(args.as_slice().iter().cloned());\n }\n // ...including target.'cfg(...)'.rustflags\n if let Some(target_cfg) = target_cfg {\n gctx.target_cfgs()?\n .iter()\n .filter_map(|(key, cfg)| {\n match flag {\n Flags::Rust => cfg\n .rustflags\n .as_ref()\n .map(|rustflags| (key, &rustflags.val)),\n // `target.cfg(ā€¦).rustdocflags` is currently not supported.\n Flags::Rustdoc => None,\n }\n })\n .filter(|(key, _rustflags)| CfgExpr::matches_key(key, target_cfg))\n .for_each(|(_key, cfg_rustflags)| {\n rustflags.extend(cfg_rustflags.as_slice().iter().cloned());\n });\n }\n\n if rustflags.is_empty() {\n Ok(None)\n } else {\n Ok(Some(rustflags))\n }\n}\n\n/// Gets compiler flags from `[host]` section in the config.\n/// See [`extra_args`] for more.\nfn rustflags_from_host(\n gctx: &GlobalContext,\n flag: Flags,\n host_triple: &str,\n) -> CargoResult>> {\n let target_cfg = gctx.host_cfg_triple(host_triple)?;\n let list = match flag {\n Flags::Rust => &target_cfg.rustflags,\n Flags::Rustdoc => {\n // host.rustdocflags is not a thing, since it does not make sense\n return Ok(None);\n }\n };\n Ok(list.as_ref().map(|l| l.val.as_slice().to_vec()))\n}\n\n/// Gets compiler flags from `[build]` section in the config.\n/// See [`extra_args`] for more.\nfn rustflags_from_build(gctx: &GlobalContext, flag: Flags) -> CargoResult>> {\n // Then the `build.rustflags` value.\n let build = gctx.build_config()?;\n let list = match flag {\n Flags::Rust => &build.rustflags,\n Flags::Rustdoc => &build.rustdocflags,\n };\n Ok(list.as_ref().map(|l| l.as_slice().to_vec()))\n}\n\n/// Collection of information about `rustc` and the host and target.\npub struct RustcTargetData<'gctx> {\n /// Information about `rustc` itself.\n pub rustc: Rustc,\n\n /// Config\n pub gctx: &'gctx GlobalContext,\n requested_kinds: Vec,\n\n /// Build information for the \"host\", which is information about when\n /// `rustc` is invoked without a `--target` flag. This is used for\n /// selecting a linker, and applying link overrides.\n ///\n /// The configuration read into this depends on whether or not\n /// `target-applies-to-host=true`.\n host_config: TargetConfig,\n /// Information about the host platform.\n host_info: TargetInfo,\n\n /// Build information for targets that we're building for.\n target_config: HashMap,\n /// Information about the target platform that we're building for.\n target_info: HashMap,\n}\n\nimpl<'gctx> RustcTargetData<'gctx> {\n #[tracing::instrument(skip_all)]\n pub fn new(\n ws: &Workspace<'gctx>,\n requested_kinds: &[CompileKind],\n ) -> CargoResult> {\n let gctx = ws.gctx();\n let rustc = gctx.load_global_rustc(Some(ws))?;\n let mut target_config = HashMap::new();\n let mut target_info = HashMap::new();\n let target_applies_to_host = gctx.target_applies_to_host()?;\n let host_target = CompileTarget::new(&rustc.host, gctx.cli_unstable().json_target_spec)?;\n let host_info = TargetInfo::new(gctx, requested_kinds, &rustc, CompileKind::Host)?;\n\n // This config is used for link overrides and choosing a linker.\n let host_config = if target_applies_to_host {\n gctx.target_cfg_triple(&rustc.host)?\n } else {\n gctx.host_cfg_triple(&rustc.host)?\n };\n\n // This is a hack. The unit_dependency graph builder \"pretends\" that\n // `CompileKind::Host` is `CompileKind::Target(host)` if the\n // `--target` flag is not specified. Since the unit_dependency code\n // needs access to the target config data, create a copy so that it\n // can be found. See `rebuild_unit_graph_shared` for why this is done.\n if requested_kinds.iter().any(CompileKind::is_host) {\n target_config.insert(host_target, gctx.target_cfg_triple(&rustc.host)?);\n\n // If target_applies_to_host is true, the host_info is the target info,\n // otherwise we need to build target info for the target.\n if target_applies_to_host {\n target_info.insert(host_target, host_info.clone());\n } else {\n let host_target_info = TargetInfo::new(\n gctx,\n requested_kinds,\n &rustc,\n CompileKind::Target(host_target),\n )?;\n target_info.insert(host_target, host_target_info);\n }\n };\n\n let mut res = RustcTargetData {\n rustc,\n gctx,\n requested_kinds: requested_kinds.into(),\n host_config,\n host_info,\n target_config,\n target_info,\n };\n\n // Get all kinds we currently know about.\n //\n // For now, targets can only ever come from the root workspace\n // units and artifact dependencies, so this\n // correctly represents all the kinds that can happen. When we have\n // other ways for targets to appear at places that are not the root units,\n // we may have to revisit this.\n fn artifact_targets(package: &Package) -> impl Iterator + '_ {\n package\n .manifest()\n .dependencies()\n .iter()\n .filter_map(|d| d.artifact()?.target()?.to_compile_kind())\n }\n let all_kinds = requested_kinds\n .iter()\n .copied()\n .chain(ws.members().flat_map(|p| {\n p.manifest()\n .default_kind()\n .into_iter()\n .chain(p.manifest().forced_kind())\n .chain(artifact_targets(p))\n }));\n for kind in all_kinds {\n res.merge_compile_kind(kind)?;\n }\n\n Ok(res)\n }\n\n /// Insert `kind` into our `target_info` and `target_config` members if it isn't present yet.\n pub fn merge_compile_kind(&mut self, kind: CompileKind) -> CargoResult<()> {\n if let CompileKind::Target(target) = kind {\n if !self.target_config.contains_key(&target) {\n self.target_config\n .insert(target, self.gctx.target_cfg_triple(target.short_name())?);\n }\n if !self.target_info.contains_key(&target) {\n self.target_info.insert(\n target,\n TargetInfo::new(self.gctx, &self.requested_kinds, &self.rustc, kind)?,\n );\n }\n }\n Ok(())\n }\n\n /// Returns a \"short\" name for the given kind, suitable for keying off\n /// configuration in Cargo or presenting to users.\n pub fn short_name<'a>(&'a self, kind: &'a CompileKind) -> &'a str {\n match kind {\n CompileKind::Host => &self.rustc.host,\n CompileKind::Target(target) => target.short_name(),\n }\n }\n\n /// Whether a dependency should be compiled for the host or target platform,\n /// specified by `CompileKind`.\n pub fn dep_platform_activated(&self, dep: &Dependency, kind: CompileKind) -> bool {\n // If this dependency is only available for certain platforms,\n // make sure we're only enabling it for that platform.\n let Some(platform) = dep.platform() else {\n return true;\n };\n let name = self.short_name(&kind);\n platform.matches(name, self.cfg(kind))\n }\n\n /// Gets the list of `cfg`s printed out from the compiler for the specified kind.\n pub fn cfg(&self, kind: CompileKind) -> &[Cfg] {\n self.info(kind).cfg()\n }\n\n /// Information about the given target platform, learned by querying rustc.\n ///\n /// # Panics\n ///\n /// Panics, if the target platform described by `kind` can't be found.\n /// See [`get_info`](Self::get_info) for a non-panicking alternative.\n pub fn info(&self, kind: CompileKind) -> &TargetInfo {\n self.get_info(kind).unwrap()\n }\n\n /// Information about the given target platform, learned by querying rustc.\n ///\n /// Returns `None` if the target platform described by `kind` can't be found.\n pub fn get_info(&self, kind: CompileKind) -> Option<&TargetInfo> {\n match kind {\n CompileKind::Host => Some(&self.host_info),\n CompileKind::Target(s) => self.target_info.get(&s),\n }\n }\n\n /// Gets the target configuration for a particular host or target.\n pub fn target_config(&self, kind: CompileKind) -> &TargetConfig {\n match kind {\n CompileKind::Host => &self.host_config,\n CompileKind::Target(s) => &self.target_config[&s],\n }\n }\n\n pub fn get_unsupported_std_targets(&self) -> Vec<&str> {\n let mut unsupported = Vec::new();\n for (target, target_info) in &self.target_info {\n if target_info.supports_std == Some(false) {\n unsupported.push(target.short_name());\n }\n }\n unsupported\n }\n\n pub fn requested_kinds(&self) -> &[CompileKind] {\n &self.requested_kinds\n }\n}\n" }, { "path": "src/cargo/core/compiler/build_runner/compilation_files.rs", "content": "//! See [`CompilationFiles`].\n\nuse std::cell::OnceCell;\nuse std::collections::HashMap;\nuse std::fmt;\nuse std::hash::{Hash, Hasher};\nuse std::path::{Path, PathBuf};\nuse std::sync::Arc;\n\nuse tracing::debug;\n\nuse super::{BuildContext, BuildRunner, CompileKind, FileFlavor, Layout};\nuse crate::core::compiler::{CompileMode, CompileTarget, CrateType, FileType, Unit};\nuse crate::core::{Target, TargetKind, Workspace};\nuse crate::util::{self, CargoResult, OnceExt, StableHasher};\n\n/// This is a generic version number that can be changed to make\n/// backwards-incompatible changes to any file structures in the output\n/// directory. For example, the fingerprint files or the build-script\n/// output files.\n///\n/// Normally cargo updates ship with rustc updates which will\n/// cause a new hash due to the rustc version changing, but this allows\n/// cargo to be extra careful to deal with different versions of cargo that\n/// use the same rustc version.\nconst METADATA_VERSION: u8 = 2;\n\n/// Uniquely identify a [`Unit`] under specific circumstances, see [`Metadata`] for more.\n#[derive(Copy, Clone, Hash, Eq, PartialEq, Ord, PartialOrd)]\npub struct UnitHash(u64);\n\nimpl fmt::Display for UnitHash {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"{:016x}\", self.0)\n }\n}\n\nimpl fmt::Debug for UnitHash {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"UnitHash({:016x})\", self.0)\n }\n}\n\n/// [`Metadata`] tracks several [`UnitHash`]s, including\n/// [`Metadata::unit_id`], [`Metadata::c_metadata`], and [`Metadata::c_extra_filename`].\n///\n/// We use a hash because it is an easy way to guarantee\n/// that all the inputs can be converted to a valid path.\n///\n/// [`Metadata::unit_id`] is used to uniquely identify a unit in the build graph.\n/// This serves as a similar role as [`Metadata::c_extra_filename`] in that it uniquely identifies output\n/// on the filesystem except that its always present.\n///\n/// [`Metadata::c_extra_filename`] is needed for cases like:\n/// - A project may depend on crate `A` and crate `B`, so the package name must be in the file name.\n/// - Similarly a project may depend on two versions of `A`, so the version must be in the file name.\n///\n/// This also acts as the main layer of caching provided by Cargo\n/// so this must include all things that need to be distinguished in different parts of\n/// the same build. This is absolutely required or we override things before\n/// we get chance to use them.\n///\n/// For example, we want to cache `cargo build` and `cargo doc` separately, so that running one\n/// does not invalidate the artifacts for the other. We do this by including [`CompileMode`] in the\n/// hash, thus the artifacts go in different folders and do not override each other.\n/// If we don't add something that we should have, for this reason, we get the\n/// correct output but rebuild more than is needed.\n///\n/// Some things that need to be tracked to ensure the correct output should definitely *not*\n/// go in the `Metadata`. For example, the modification time of a file, should be tracked to make a\n/// rebuild when the file changes. However, it would be wasteful to include in the `Metadata`. The\n/// old artifacts are never going to be needed again. We can save space by just overwriting them.\n/// If we add something that we should not have, for this reason, we get the correct output but take\n/// more space than needed. This makes not including something in `Metadata`\n/// a form of cache invalidation.\n///\n/// Note that the `Fingerprint` is in charge of tracking everything needed to determine if a\n/// rebuild is needed.\n///\n/// [`Metadata::c_metadata`] is used for symbol mangling, because if you have two versions of\n/// the same crate linked together, their symbols need to be differentiated.\n///\n/// You should avoid anything that would interfere with reproducible\n/// builds. For example, *any* absolute path should be avoided. This is one\n/// reason that `RUSTFLAGS` is not in [`Metadata::c_metadata`], because it often has\n/// absolute paths (like `--remap-path-prefix` which is fundamentally used for\n/// reproducible builds and has absolute paths in it). Also, in some cases the\n/// mangled symbols need to be stable between different builds with different\n/// settings. For example, profile-guided optimizations need to swap\n/// `RUSTFLAGS` between runs, but needs to keep the same symbol names.\n#[derive(Copy, Clone, Debug)]\npub struct Metadata {\n unit_id: UnitHash,\n c_metadata: UnitHash,\n c_extra_filename: bool,\n pkg_dir: bool,\n}\n\nimpl Metadata {\n /// A hash to identify a given [`Unit`] in the build graph\n pub fn unit_id(&self) -> UnitHash {\n self.unit_id\n }\n\n /// A hash to add to symbol naming through `-C metadata`\n pub fn c_metadata(&self) -> UnitHash {\n self.c_metadata\n }\n\n /// A hash to add to file names through `-C extra-filename`\n pub fn c_extra_filename(&self) -> Option {\n self.c_extra_filename.then_some(self.unit_id)\n }\n\n /// A hash to add to Cargo directory names\n pub fn pkg_dir(&self) -> Option {\n self.pkg_dir.then_some(self.unit_id)\n }\n}\n\n/// Collection of information about the files emitted by the compiler, and the\n/// output directory structure.\npub struct CompilationFiles<'a, 'gctx> {\n /// The target directory layout for the host (and target if it is the same as host).\n pub(super) host: Layout,\n /// The target directory layout for the target (if different from then host).\n pub(super) target: HashMap,\n /// Additional directory to include a copy of the outputs.\n export_dir: Option,\n /// The root targets requested by the user on the command line (does not\n /// include dependencies).\n roots: Vec,\n ws: &'a Workspace<'gctx>,\n /// Metadata hash to use for each unit.\n metas: HashMap,\n /// For each Unit, a list all files produced.\n outputs: HashMap>>>,\n}\n\n/// Info about a single file emitted by the compiler.\n#[derive(Debug)]\npub struct OutputFile {\n /// Absolute path to the file that will be produced by the build process.\n pub path: PathBuf,\n /// If it should be linked into `target`, and what it should be called\n /// (e.g., without metadata).\n pub hardlink: Option,\n /// If `--artifact-dir` is specified, the absolute path to the exported file.\n pub export_path: Option,\n /// Type of the file (library / debug symbol / else).\n pub flavor: FileFlavor,\n}\n\nimpl OutputFile {\n /// Gets the hard link if present; otherwise, returns the path.\n pub fn bin_dst(&self) -> &PathBuf {\n match self.hardlink {\n Some(ref link_dst) => link_dst,\n None => &self.path,\n }\n }\n}\n\nimpl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {\n pub(super) fn new(\n build_runner: &BuildRunner<'a, 'gctx>,\n host: Layout,\n target: HashMap,\n ) -> CompilationFiles<'a, 'gctx> {\n let mut metas = HashMap::new();\n for unit in &build_runner.bcx.roots {\n metadata_of(unit, build_runner, &mut metas);\n }\n let outputs = metas\n .keys()\n .cloned()\n .map(|unit| (unit, OnceCell::new()))\n .collect();\n CompilationFiles {\n ws: build_runner.bcx.ws,\n host,\n target,\n export_dir: build_runner.bcx.build_config.export_dir.clone(),\n roots: build_runner.bcx.roots.clone(),\n metas,\n outputs,\n }\n }\n\n /// Returns the appropriate directory layout for either a plugin or not.\n pub fn layout(&self, kind: CompileKind) -> &Layout {\n match kind {\n CompileKind::Host => &self.host,\n CompileKind::Target(target) => &self.target[&target],\n }\n }\n\n /// Gets the metadata for the given unit.\n ///\n /// See [`Metadata`] and [`fingerprint`] module for more.\n ///\n /// [`fingerprint`]: super::super::fingerprint#fingerprints-and-metadata\n pub fn metadata(&self, unit: &Unit) -> Metadata {\n self.metas[unit]\n }\n\n /// Gets the short hash based only on the `PackageId`.\n /// Used for the metadata when `c_extra_filename` returns `None`.\n fn target_short_hash(&self, unit: &Unit) -> String {\n let hashable = unit.pkg.package_id().stable_hash(self.ws.root());\n util::short_hash(&(METADATA_VERSION, hashable))\n }\n\n /// Returns the directory where the artifacts for the given unit are\n /// initially created.\n pub fn output_dir(&self, unit: &Unit) -> PathBuf {\n // Docscrape units need to have doc/ set as the out_dir so sources for reverse-dependencies\n // will be put into doc/ and not into deps/ where the *.examples files are stored.\n if unit.mode.is_doc() || unit.mode.is_doc_scrape() {\n self.layout(unit.kind)\n .artifact_dir()\n .expect(\"artifact-dir was not locked\")\n .doc()\n .to_path_buf()\n } else if unit.mode.is_doc_test() {\n panic!(\"doc tests do not have an out dir\");\n } else if unit.target.is_custom_build() {\n self.build_script_dir(unit)\n } else if unit.target.is_example() && !self.ws.gctx().cli_unstable().build_dir_new_layout {\n self.layout(unit.kind).build_dir().examples().to_path_buf()\n } else if unit.artifact.is_true() {\n self.artifact_dir(unit)\n } else {\n self.deps_dir(unit).to_path_buf()\n }\n }\n\n /// Additional export directory from `--artifact-dir`.\n pub fn export_dir(&self) -> Option {\n self.export_dir.clone()\n }\n\n /// Directory name to use for a package in the form `{NAME}/{HASH}`.\n ///\n /// Note that some units may share the same directory, so care should be\n /// taken in those cases!\n fn pkg_dir(&self, unit: &Unit) -> String {\n let separator = match self.ws.gctx().cli_unstable().build_dir_new_layout {\n true => \"/\",\n false => \"-\",\n };\n let name = unit.pkg.package_id().name();\n let hash = self.unit_hash(unit);\n format!(\"{name}{separator}{hash}\")\n }\n\n /// The directory hash to use for a given unit\n pub fn unit_hash(&self, unit: &Unit) -> String {\n self.metas[unit]\n .pkg_dir()\n .map(|h| h.to_string())\n .unwrap_or_else(|| self.target_short_hash(unit))\n }\n\n /// Returns the final artifact path for the host (`/ā€¦/target/debug`)\n pub fn host_dest(&self) -> Option<&Path> {\n self.host.artifact_dir().map(|v| v.dest())\n }\n\n /// Returns the root of the build output tree for the host (`/ā€¦/build-dir`)\n pub fn host_build_root(&self) -> &Path {\n self.host.build_dir().root()\n }\n\n /// Returns the host `deps` directory path for a given build unit.\n pub fn host_deps(&self, unit: &Unit) -> PathBuf {\n let dir = self.pkg_dir(unit);\n self.host.build_dir().deps(&dir)\n }\n\n /// Returns the directories where Rust crate dependencies are found for the\n /// specified unit.\n pub fn deps_dir(&self, unit: &Unit) -> PathBuf {\n let dir = self.pkg_dir(unit);\n self.layout(unit.kind).build_dir().deps(&dir)\n }\n\n /// Returns the directories where Rust crate dependencies are found for the\n /// specified unit. (new layout)\n ///\n /// New features should consider using this so we can avoid their migrations.\n pub fn out_dir_new_layout(&self, unit: &Unit) -> PathBuf {\n let dir = self.pkg_dir(unit);\n self.layout(unit.kind)\n .build_dir()\n .out_force_new_layout(&dir)\n }\n\n /// Directory where the fingerprint for the given unit should go.\n pub fn fingerprint_dir(&self, unit: &Unit) -> PathBuf {\n let dir = self.pkg_dir(unit);\n self.layout(unit.kind).build_dir().fingerprint(&dir)\n }\n\n /// The lock location for a given build unit.\n pub fn build_unit_lock(&self, unit: &Unit) -> PathBuf {\n let dir = self.pkg_dir(unit);\n self.layout(unit.kind)\n .build_dir()\n .build_unit(&dir)\n .join(\".lock\")\n }\n\n /// Directory where incremental output for the given unit should go.\n pub fn incremental_dir(&self, unit: &Unit) -> &Path {\n self.layout(unit.kind).build_dir().incremental()\n }\n\n /// Directory where timing output should go.\n pub fn timings_dir(&self) -> Option<&Path> {\n self.host.artifact_dir().map(|v| v.timings())\n }\n\n /// Returns the path for a file in the fingerprint directory.\n ///\n /// The \"prefix\" should be something to distinguish the file from other\n /// files in the fingerprint directory.\n pub fn fingerprint_file_path(&self, unit: &Unit, prefix: &str) -> PathBuf {\n // Different targets need to be distinguished in the\n let kind = unit.target.kind().description();\n let flavor = if unit.mode.is_any_test() {\n \"test-\"\n } else if unit.mode.is_doc() {\n \"doc-\"\n } else if unit.mode.is_run_custom_build() {\n \"run-\"\n } else {\n \"\"\n };\n let name = format!(\"{}{}{}-{}\", prefix, flavor, kind, unit.target.name());\n self.fingerprint_dir(unit).join(name)\n }\n\n /// Path where compiler output is cached.\n pub fn message_cache_path(&self, unit: &Unit) -> PathBuf {\n self.fingerprint_file_path(unit, \"output-\")\n }\n\n /// Returns the directory where a compiled build script is stored.\n /// `/path/to/target/{debug,release}/build/PKG-HASH`\n pub fn build_script_dir(&self, unit: &Unit) -> PathBuf {\n assert!(unit.target.is_custom_build());\n assert!(!unit.mode.is_run_custom_build());\n assert!(self.metas.contains_key(unit));\n let dir = self.pkg_dir(unit);\n self.layout(CompileKind::Host)\n .build_dir()\n .build_script(&dir)\n }\n\n /// Returns the directory for compiled artifacts files.\n /// `/path/to/target/{debug,release}/deps/artifact/KIND/PKG-HASH`\n fn artifact_dir(&self, unit: &Unit) -> PathBuf {\n assert!(self.metas.contains_key(unit));\n assert!(unit.artifact.is_true());\n let dir = self.pkg_dir(unit);\n let kind = match unit.target.kind() {\n TargetKind::Bin => \"bin\",\n TargetKind::Lib(lib_kinds) => match lib_kinds.as_slice() {\n &[CrateType::Cdylib] => \"cdylib\",\n &[CrateType::Staticlib] => \"staticlib\",\n invalid => unreachable!(\n \"BUG: unexpected artifact library type(s): {:?} - these should have been split\",\n invalid\n ),\n },\n invalid => unreachable!(\n \"BUG: {:?} are not supposed to be used as artifacts\",\n invalid\n ),\n };\n self.layout(unit.kind).build_dir().artifact(&dir, kind)\n }\n\n /// Returns the directory where information about running a build script\n /// is stored.\n /// `/path/to/target/{debug,release}/build/PKG-HASH`\n pub fn build_script_run_dir(&self, unit: &Unit) -> PathBuf {\n assert!(unit.target.is_custom_build());\n assert!(unit.mode.is_run_custom_build());\n let dir = self.pkg_dir(unit);\n self.layout(unit.kind)\n .build_dir()\n .build_script_execution(&dir)\n }\n\n /// Returns the \"`OUT_DIR`\" directory for running a build script.\n /// `/path/to/target/{debug,release}/build/PKG-HASH/out`\n pub fn build_script_out_dir(&self, unit: &Unit) -> PathBuf {\n self.build_script_run_dir(unit).join(\"out\")\n }\n\n /// Returns the path to the executable binary for the given bin target.\n ///\n /// This should only to be used when a `Unit` is not available.\n pub fn bin_link_for_target(\n &self,\n target: &Target,\n kind: CompileKind,\n bcx: &BuildContext<'_, '_>,\n ) -> CargoResult> {\n assert!(target.is_bin());\n let Some(dest) = self.layout(kind).artifact_dir().map(|v| v.dest()) else {\n return Ok(None);\n };\n let info = bcx.target_data.info(kind);\n let (file_types, _) = info\n .rustc_outputs(\n CompileMode::Build,\n &TargetKind::Bin,\n bcx.target_data.short_name(&kind),\n bcx.gctx,\n )\n .expect(\"target must support `bin`\");\n\n let file_type = file_types\n .iter()\n .find(|file_type| file_type.flavor == FileFlavor::Normal)\n .expect(\"target must support `bin`\");\n\n Ok(Some(dest.join(file_type.uplift_filename(target))))\n }\n\n /// Returns the filenames that the given unit will generate.\n ///\n /// Note: It is not guaranteed that all of the files will be generated.\n pub(super) fn outputs(\n &self,\n unit: &Unit,\n bcx: &BuildContext<'a, 'gctx>,\n ) -> CargoResult>> {\n self.outputs[unit]\n .try_borrow_with(|| self.calc_outputs(unit, bcx))\n .map(Arc::clone)\n }\n\n /// Returns the path where the output for the given unit and `FileType`\n /// should be uplifted to.\n ///\n /// Returns `None` if the unit shouldn't be uplifted (for example, a\n /// dependent rlib).\n fn uplift_to(&self, unit: &Unit, file_type: &FileType, from_path: &Path) -> Option {\n // Tests, check, doc, etc. should not be uplifted.\n if unit.mode != CompileMode::Build || file_type.flavor == FileFlavor::Rmeta {\n return None;\n }\n\n // Artifact dependencies are never uplifted.\n if unit.artifact.is_true() {\n return None;\n }\n\n // - Binaries: The user always wants to see these, even if they are\n // implicitly built (for example for integration tests).\n // - dylibs: This ensures that the dynamic linker pulls in all the\n // latest copies (even if the dylib was built from a previous cargo\n // build). There are complex reasons for this, see #8139, #6167, #6162.\n // - Things directly requested from the command-line (the \"roots\").\n // This one is a little questionable for rlibs (see #6131), but is\n // historically how Cargo has operated. This is primarily useful to\n // give the user access to staticlibs and cdylibs.\n if !unit.target.is_bin()\n && !unit.target.is_custom_build()\n && file_type.crate_type != Some(CrateType::Dylib)\n && !self.roots.contains(unit)\n {\n return None;\n }\n\n let filename = file_type.uplift_filename(&unit.target);\n let uplift_path = if unit.target.is_example() {\n // Examples live in their own little world.\n self.layout(unit.kind)\n .artifact_dir()?\n .examples()\n .join(filename)\n } else if unit.target.is_custom_build() {\n self.build_script_dir(unit).join(filename)\n } else {\n self.layout(unit.kind).artifact_dir()?.dest().join(filename)\n };\n if from_path == uplift_path {\n // This can happen with things like examples that reside in the\n // same directory, do not have a metadata hash (like on Windows),\n // and do not have hyphens.\n return None;\n }\n Some(uplift_path)\n }\n\n /// Calculates the filenames that the given unit will generate.\n /// Should use [`CompilationFiles::outputs`] instead\n /// as it caches the result of this function.\n fn calc_outputs(\n &self,\n unit: &Unit,\n bcx: &BuildContext<'a, 'gctx>,\n ) -> CargoResult>> {\n let ret = match unit.mode {\n _ if unit.skip_non_compile_time_dep => {\n // This skips compilations so no outputs\n vec![]\n }\n CompileMode::Doc => {\n let path = if bcx.build_config.intent.wants_doc_json_output() {\n self.output_dir(unit)\n .join(format!(\"{}.json\", unit.target.crate_name()))\n } else {\n self.output_dir(unit)\n .join(unit.target.crate_name())\n .join(\"index.html\")\n };\n\n let mut outputs = vec![OutputFile {\n path,\n hardlink: None,\n export_path: None,\n flavor: FileFlavor::Normal,\n }];\n\n if bcx.gctx.cli_unstable().rustdoc_mergeable_info {\n // `-Zrustdoc-mergeable-info` always uses the new layout.\n outputs.push(OutputFile {\n path: self\n .out_dir_new_layout(unit)\n .join(unit.target.crate_name())\n .with_extension(\"json\"),\n hardlink: None,\n export_path: None,\n flavor: FileFlavor::DocParts,\n })\n }\n\n outputs\n }\n CompileMode::RunCustomBuild => {\n // At this time, this code path does not handle build script\n // outputs.\n vec![]\n }\n CompileMode::Doctest => {\n // Doctests are built in a temporary directory and then\n // deleted. There is the `--persist-doctests` unstable flag,\n // but Cargo does not know about that.\n vec![]\n }\n CompileMode::Docscrape => {\n // The file name needs to be stable across Cargo sessions.\n // This originally used unit.buildkey(), but that isn't stable,\n // so we use metadata instead (prefixed with name for debugging).\n let file_name = format!(\n \"{}-{}.examples\",\n unit.pkg.name(),\n self.metadata(unit).unit_id()\n );\n let path = self.deps_dir(unit).join(file_name);\n vec![OutputFile {\n path,\n hardlink: None,\n export_path: None,\n flavor: FileFlavor::Normal,\n }]\n }\n CompileMode::Test | CompileMode::Build | CompileMode::Check { .. } => {\n let mut outputs = self.calc_outputs_rustc(unit, bcx)?;\n if bcx.build_config.sbom && bcx.gctx.cli_unstable().sbom {\n let sbom_files: Vec<_> = outputs\n .iter()\n .filter(|o| matches!(o.flavor, FileFlavor::Normal | FileFlavor::Linkable))\n .map(|output| OutputFile {\n path: Self::append_sbom_suffix(&output.path),\n hardlink: output.hardlink.as_ref().map(Self::append_sbom_suffix),\n export_path: output.export_path.as_ref().map(Self::append_sbom_suffix),\n flavor: FileFlavor::Sbom,\n })\n .collect();\n outputs.extend(sbom_files.into_iter());\n }\n outputs\n }\n };\n debug!(\"Target filenames: {:?}\", ret);\n\n Ok(Arc::new(ret))\n }\n\n /// Append the SBOM suffix to the file name.\n fn append_sbom_suffix(link: &PathBuf) -> PathBuf {\n const SBOM_FILE_EXTENSION: &str = \".cargo-sbom.json\";\n let mut link_buf = link.clone().into_os_string();\n link_buf.push(SBOM_FILE_EXTENSION);\n PathBuf::from(link_buf)\n }\n\n /// Computes the actual, full pathnames for all the files generated by rustc.\n ///\n /// The `OutputFile` also contains the paths where those files should be\n /// \"uplifted\" to.\n fn calc_outputs_rustc(\n &self,\n unit: &Unit,\n bcx: &BuildContext<'a, 'gctx>,\n ) -> CargoResult> {\n let out_dir = self.output_dir(unit);\n\n let info = bcx.target_data.info(unit.kind);\n let triple = bcx.target_data.short_name(&unit.kind);\n let (file_types, unsupported) =\n info.rustc_outputs(unit.mode, unit.target.kind(), triple, bcx.gctx)?;\n if file_types.is_empty() {\n if !unsupported.is_empty() {\n let unsupported_strs: Vec<_> = unsupported.iter().map(|ct| ct.as_str()).collect();\n anyhow::bail!(\n \"cannot produce {} for `{}` as the target `{}` \\\n does not support these crate types\",\n unsupported_strs.join(\", \"),\n unit.pkg,\n triple,\n )\n }\n anyhow::bail!(\n \"cannot compile `{}` as the target `{}` does not \\\n support any of the output crate types\",\n unit.pkg,\n triple,\n );\n }\n\n // Convert FileType to OutputFile.\n let mut outputs = Vec::new();\n for file_type in file_types {\n let meta = self.metas[unit];\n let meta_opt = meta.c_extra_filename().map(|h| h.to_string());\n let path = out_dir.join(file_type.output_filename(&unit.target, meta_opt.as_deref()));\n\n // If, the `different_binary_name` feature is enabled, the name of the hardlink will\n // be the name of the binary provided by the user in `Cargo.toml`.\n let hardlink = self.uplift_to(unit, &file_type, &path);\n let export_path = if unit.target.is_custom_build() {\n None\n } else {\n self.export_dir.as_ref().and_then(|export_dir| {\n hardlink\n .as_ref()\n .map(|hardlink| export_dir.join(hardlink.file_name().unwrap()))\n })\n };\n outputs.push(OutputFile {\n path,\n hardlink,\n export_path,\n flavor: file_type.flavor,\n });\n }\n Ok(outputs)\n }\n}\n\n/// Gets the metadata hash for the given [`Unit`].\n///\n/// When a metadata hash doesn't exist for the given unit,\n/// this calls itself recursively to compute metadata hashes of all its dependencies.\n/// See [`compute_metadata`] for how a single metadata hash is computed.\nfn metadata_of<'a>(\n unit: &Unit,\n build_runner: &BuildRunner<'_, '_>,\n metas: &'a mut HashMap,\n) -> &'a Metadata {\n if !metas.contains_key(unit) {\n let meta = compute_metadata(unit, build_runner, metas);\n metas.insert(unit.clone(), meta);\n for dep in build_runner.unit_deps(unit) {\n metadata_of(&dep.unit, build_runner, metas);\n }\n }\n &metas[unit]\n}\n\n/// Computes the metadata hash for the given [`Unit`].\nfn compute_metadata(\n unit: &Unit,\n build_runner: &BuildRunner<'_, '_>,\n metas: &mut HashMap,\n) -> Metadata {\n let bcx = &build_runner.bcx;\n let deps_metadata = build_runner\n .unit_deps(unit)\n .iter()\n .map(|dep| *metadata_of(&dep.unit, build_runner, metas))\n .collect::>();\n let c_extra_filename = use_extra_filename(bcx, unit);\n let pkg_dir = use_pkg_dir(bcx, unit);\n\n let mut shared_hasher = StableHasher::new();\n\n METADATA_VERSION.hash(&mut shared_hasher);\n\n let ws_root = if unit.is_std {\n // SourceId for stdlib crates is an absolute path inside the sysroot.\n // Pass the sysroot as workspace root so that we hash a relative path.\n // This avoids the metadata hash changing depending on where the user installed rustc.\n &bcx.target_data.get_info(unit.kind).unwrap().sysroot\n } else {\n bcx.ws.root()\n };\n\n // Unique metadata per (name, source, version) triple. This'll allow us\n // to pull crates from anywhere without worrying about conflicts.\n unit.pkg\n .package_id()\n .stable_hash(ws_root)\n .hash(&mut shared_hasher);\n\n // Also mix in enabled features to our metadata. This'll ensure that\n // when changing feature sets each lib is separately cached.\n unit.features.hash(&mut shared_hasher);\n\n // Throw in the profile we're compiling with. This helps caching\n // `panic=abort` and `panic=unwind` artifacts, additionally with various\n // settings like debuginfo and whatnot.\n unit.profile.hash(&mut shared_hasher);\n unit.mode.hash(&mut shared_hasher);\n build_runner.lto[unit].hash(&mut shared_hasher);\n\n // Artifacts compiled for the host should have a different\n // metadata piece than those compiled for the target, so make sure\n // we throw in the unit's `kind` as well. Use `fingerprint_hash`\n // so that the StableHash doesn't change based on the pathnames\n // of the custom target JSON spec files.\n unit.kind.fingerprint_hash().hash(&mut shared_hasher);\n\n // Finally throw in the target name/kind. This ensures that concurrent\n // compiles of targets in the same crate don't collide.\n unit.target.name().hash(&mut shared_hasher);\n unit.target.kind().hash(&mut shared_hasher);\n\n hash_rustc_version(bcx, &mut shared_hasher, unit);\n\n if build_runner.bcx.ws.is_member(&unit.pkg) {\n // This is primarily here for clippy. This ensures that the clippy\n // artifacts are separate from the `check` ones.\n if let Some(path) = &build_runner.bcx.rustc().workspace_wrapper {\n path.hash(&mut shared_hasher);\n }\n }\n\n // Seed the contents of `__CARGO_DEFAULT_LIB_METADATA` to the hasher if present.\n // This should be the release channel, to get a different hash for each channel.\n if let Ok(ref channel) = build_runner\n .bcx\n .gctx\n .get_env(\"__CARGO_DEFAULT_LIB_METADATA\")\n {\n channel.hash(&mut shared_hasher);\n }\n\n // std units need to be kept separate from user dependencies. std crates\n // are differentiated in the Unit with `is_std` (for things like\n // `-Zforce-unstable-if-unmarked`), so they are always built separately.\n // This isn't strictly necessary for build dependencies which probably\n // don't need unstable support. A future experiment might be to set\n // `is_std` to false for build dependencies so that they can be shared\n // with user dependencies.\n unit.is_std.hash(&mut shared_hasher);\n\n // While we don't hash RUSTFLAGS because it may contain absolute paths that\n // hurts reproducibility, we track whether a unit's RUSTFLAGS is from host\n // config, so that we can generate a different metadata hash for runtime\n // and compile-time units.\n //\n // HACK: This is a temporary hack for fixing rust-lang/cargo#14253\n // Need to find a long-term solution to replace this fragile workaround.\n // See https://github.com/rust-lang/cargo/pull/14432#discussion_r1725065350\n if unit.kind.is_host() && !bcx.gctx.target_applies_to_host().unwrap_or_default() {\n let host_info = bcx.target_data.info(CompileKind::Host);\n let target_configs_are_different = unit.rustflags != host_info.rustflags\n || unit.rustdocflags != host_info.rustdocflags\n || bcx\n .target_data\n .target_config(CompileKind::Host)\n .links_overrides\n != unit.links_overrides;\n target_configs_are_different.hash(&mut shared_hasher);\n }\n\n let mut c_metadata_hasher = shared_hasher.clone();\n // Mix in the target-metadata of all the dependencies of this target.\n let mut dep_c_metadata_hashes = deps_metadata\n .iter()\n .map(|m| m.c_metadata)\n .collect::>();\n dep_c_metadata_hashes.sort();\n dep_c_metadata_hashes.hash(&mut c_metadata_hasher);\n\n let mut unit_id_hasher = shared_hasher.clone();\n // Mix in the target-metadata of all the dependencies of this target.\n let mut dep_unit_id_hashes = deps_metadata.iter().map(|m| m.unit_id).collect::>();\n dep_unit_id_hashes.sort();\n dep_unit_id_hashes.hash(&mut unit_id_hasher);\n // Avoid trashing the caches on RUSTFLAGS changing via `unit_id`\n //\n // Limited to `unit_id` to help with reproducible build / PGO issues.\n let default = Vec::new();\n let extra_args = build_runner.bcx.extra_args_for(unit).unwrap_or(&default);\n if !has_remap_path_prefix(&extra_args) {\n extra_args.hash(&mut unit_id_hasher);\n }\n if unit.mode.is_doc() || unit.mode.is_doc_scrape() {\n if !has_remap_path_prefix(&unit.rustdocflags) {\n unit.rustdocflags.hash(&mut unit_id_hasher);\n }\n } else {\n if !has_remap_path_prefix(&unit.rustflags) {\n unit.rustflags.hash(&mut unit_id_hasher);\n }\n }\n\n let c_metadata = UnitHash(Hasher::finish(&c_metadata_hasher));\n let unit_id = UnitHash(Hasher::finish(&unit_id_hasher));\n\n Metadata {\n unit_id,\n c_metadata,\n c_extra_filename,\n pkg_dir,\n }\n}\n\n/// HACK: Detect the *potential* presence of `--remap-path-prefix`\n///\n/// As CLI parsing is contextual and dependent on the CLI definition to understand the context, we\n/// can't say for sure whether `--remap-path-prefix` is present, so we guess if anything looks like\n/// it.\n/// If we could, we'd strip it out for hashing.\n/// Instead, we use this to avoid hashing rustflags if it might be present to avoid the risk of taking\n/// a flag that is trying to make things reproducible and making things less reproducible by the\n/// `-Cextra-filename` showing up in the rlib, even with `split-debuginfo`.\nfn has_remap_path_prefix(args: &[String]) -> bool {\n args.iter()\n .any(|s| s.starts_with(\"--remap-path-prefix=\") || s == \"--remap-path-prefix\")\n}\n\n/// Hash the version of rustc being used during the build process.\nfn hash_rustc_version(bcx: &BuildContext<'_, '_>, hasher: &mut StableHasher, unit: &Unit) {\n let vers = &bcx.rustc().version;\n if vers.pre.is_empty() || bcx.gctx.cli_unstable().separate_nightlies {\n // For stable, keep the artifacts separate. This helps if someone is\n // testing multiple versions, to avoid recompiles. Note though that for\n // cross-compiled builds the `host:` line of `verbose_version` is\n // omitted since rustc should produce the same output for each target\n // regardless of the host.\n for line in bcx.rustc().verbose_version.lines() {\n if unit.kind.is_host() || !line.starts_with(\"host: \") {\n line.hash(hasher);\n }\n }\n return;\n }\n // On \"nightly\"/\"beta\"/\"dev\"/etc, keep each \"channel\" separate. Don't hash\n // the date/git information, so that whenever someone updates \"nightly\",\n // they won't have a bunch of stale artifacts in the target directory.\n //\n // This assumes that the first segment is the important bit (\"nightly\",\n // \"beta\", \"dev\", etc.). Skip other parts like the `.3` in `-beta.3`.\n vers.pre.split('.').next().hash(hasher);\n // Keep \"host\" since some people switch hosts to implicitly change\n // targets, (like gnu vs musl or gnu vs msvc). In the future, we may want\n // to consider hashing `unit.kind.short_name()` instead.\n if unit.kind.is_host() {\n bcx.rustc().host.hash(hasher);\n }\n // None of the other lines are important. Currently they are:\n // binary: rustc <-- or \"rustdoc\"\n // commit-hash: 38114ff16e7856f98b2b4be7ab4cd29b38bed59a\n // commit-date: 2020-03-21\n // host: x86_64-apple-darwin\n // release: 1.44.0-nightly\n // LLVM version: 9.0\n //\n // The backend version (\"LLVM version\") might become more relevant in\n // the future when cranelift sees more use, and people want to switch\n // between different backends without recompiling.\n}\n\n/// Returns whether or not this unit should use a hash in the filename to make it unique.\nfn use_extra_filename(bcx: &BuildContext<'_, '_>, unit: &Unit) -> bool {\n if unit.mode.is_doc_test() || unit.mode.is_doc() {\n // Doc tests do not have metadata.\n return false;\n }\n if bcx.gctx.cli_unstable().build_dir_new_layout {\n if unit.mode.is_any_test() || unit.mode.is_check() {\n // These always use metadata.\n return true;\n }\n // No metadata in these cases:\n //\n // - dylib, cdylib, executable: `pkg_dir` avoids collisions for us and rustc isn't looking these\n // up by `-Cextra-filename`\n //\n // The __CARGO_DEFAULT_LIB_METADATA env var is used to override this to\n // force metadata in the hash. This is only used for building libstd. For\n // example, if libstd is placed in a common location, we don't want a file\n // named /usr/lib/libstd.so which could conflict with other rustc\n // installs. In addition it prevents accidentally loading a libstd of a\n // different compiler at runtime.\n // See https://github.com/rust-lang/cargo/issues/3005\n if (unit.target.is_dylib() || unit.target.is_cdylib() || unit.target.is_executable())\n && bcx.gctx.get_env(\"__CARGO_DEFAULT_LIB_METADATA\").is_err()\n {\n return false;\n }\n } else {\n if unit.mode.is_any_test() || unit.mode.is_check() {\n // These always use metadata.\n return true;\n }\n // No metadata in these cases:\n //\n // - dylibs:\n // - if any dylib names are encoded in executables, so they can't be renamed.\n // - TODO: Maybe use `-install-name` on macOS or `-soname` on other UNIX systems\n // to specify the dylib name to be used by the linker instead of the filename.\n // - Windows MSVC executables: The path to the PDB is embedded in the\n // executable, and we don't want the PDB path to include the hash in it.\n // - wasm32-unknown-emscripten executables: When using emscripten, the path to the\n // .wasm file is embedded in the .js file, so we don't want the hash in there.\n //\n // This is only done for local packages, as we don't expect to export\n // dependencies.\n //\n // The __CARGO_DEFAULT_LIB_METADATA env var is used to override this to\n // force metadata in the hash. This is only used for building libstd. For\n // example, if libstd is placed in a common location, we don't want a file\n // named /usr/lib/libstd.so which could conflict with other rustc\n // installs. In addition it prevents accidentally loading a libstd of a\n // different compiler at runtime.\n // See https://github.com/rust-lang/cargo/issues/3005\n let short_name = bcx.target_data.short_name(&unit.kind);\n if (unit.target.is_dylib()\n || unit.target.is_cdylib()\n || (unit.target.is_executable() && short_name == \"wasm32-unknown-emscripten\")\n || (unit.target.is_executable() && short_name.contains(\"msvc\")))\n && unit.pkg.package_id().source_id().is_path()\n && bcx.gctx.get_env(\"__CARGO_DEFAULT_LIB_METADATA\").is_err()\n {\n return false;\n }\n }\n true\n}\n\n/// Returns whether or not this unit should use a hash in the pkg_dir to make it unique.\nfn use_pkg_dir(bcx: &BuildContext<'_, '_>, unit: &Unit) -> bool {\n if unit.mode.is_doc_test() || unit.mode.is_doc() {\n // Doc tests do not have metadata.\n return false;\n }\n if bcx.gctx.cli_unstable().build_dir_new_layout {\n // These always use metadata.\n return true;\n }\n if unit.mode.is_any_test() || unit.mode.is_check() {\n // These always use metadata.\n return true;\n }\n // No metadata in these cases:\n //\n // - dylibs:\n // - if any dylib names are encoded in executables, so they can't be renamed.\n // - TODO: Maybe use `-install-name` on macOS or `-soname` on other UNIX systems\n // to specify the dylib name to be used by the linker instead of the filename.\n // - Windows MSVC executables: The path to the PDB is embedded in the\n // executable, and we don't want the PDB path to include the hash in it.\n // - wasm32-unknown-emscripten executables: When using emscripten, the path to the\n // .wasm file is embedded in the .js file, so we don't want the hash in there.\n //\n // This is only done for local packages, as we don't expect to export\n // dependencies.\n //\n // The __CARGO_DEFAULT_LIB_METADATA env var is used to override this to\n // force metadata in the hash. This is only used for building libstd. For\n // example, if libstd is placed in a common location, we don't want a file\n // named /usr/lib/libstd.so which could conflict with other rustc\n // installs. In addition it prevents accidentally loading a libstd of a\n // different compiler at runtime.\n // See https://github.com/rust-lang/cargo/issues/3005\n let short_name = bcx.target_data.short_name(&unit.kind);\n if (unit.target.is_dylib()\n || unit.target.is_cdylib()\n || (unit.target.is_executable() && short_name == \"wasm32-unknown-emscripten\")\n || (unit.target.is_executable() && short_name.contains(\"msvc\")))\n && unit.pkg.package_id().source_id().is_path()\n && bcx.gctx.get_env(\"__CARGO_DEFAULT_LIB_METADATA\").is_err()\n {\n return false;\n }\n true\n}\n" }, { "path": "src/cargo/core/compiler/build_runner/mod.rs", "content": "//! [`BuildRunner`] is the mutable state used during the build process.\n\nuse std::collections::{HashMap, HashSet};\nuse std::path::{Path, PathBuf};\nuse std::sync::{Arc, Mutex};\n\nuse crate::core::PackageId;\nuse crate::core::compiler::compilation::{self, UnitOutput};\nuse crate::core::compiler::locking::LockManager;\nuse crate::core::compiler::{self, Unit, UserIntent, artifact};\nuse crate::util::cache_lock::CacheLockMode;\nuse crate::util::errors::CargoResult;\nuse annotate_snippets::{Level, Message};\nuse anyhow::{Context as _, bail};\nuse cargo_util::paths;\nuse filetime::FileTime;\nuse itertools::Itertools;\nuse jobserver::Client;\n\nuse super::RustdocFingerprint;\nuse super::custom_build::{self, BuildDeps, BuildScriptOutputs, BuildScripts};\nuse super::fingerprint::{Checksum, Fingerprint};\nuse super::job_queue::JobQueue;\nuse super::layout::Layout;\nuse super::lto::Lto;\nuse super::unit_graph::UnitDep;\nuse super::{BuildContext, Compilation, CompileKind, CompileMode, Executor, FileFlavor};\n\nmod compilation_files;\nuse self::compilation_files::CompilationFiles;\npub use self::compilation_files::{Metadata, OutputFile, UnitHash};\n\n/// Collection of all the stuff that is needed to perform a build.\n///\n/// Different from the [`BuildContext`], `Context` is a _mutable_ state used\n/// throughout the entire build process. Everything is coordinated through this.\n///\n/// [`BuildContext`]: crate::core::compiler::BuildContext\npub struct BuildRunner<'a, 'gctx> {\n /// Mostly static information about the build task.\n pub bcx: &'a BuildContext<'a, 'gctx>,\n /// A large collection of information about the result of the entire compilation.\n pub compilation: Compilation<'gctx>,\n /// Output from build scripts, updated after each build script runs.\n pub build_script_outputs: Arc>,\n /// Dependencies (like rerun-if-changed) declared by a build script.\n /// This is *only* populated from the output from previous runs.\n /// If the build script hasn't ever been run, then it must be run.\n pub build_explicit_deps: HashMap,\n /// Fingerprints used to detect if a unit is out-of-date.\n pub fingerprints: HashMap>,\n /// Cache of file mtimes to reduce filesystem hits.\n pub mtime_cache: HashMap,\n /// Cache of file checksums to reduce filesystem reads.\n pub checksum_cache: HashMap,\n /// A set used to track which units have been compiled.\n /// A unit may appear in the job graph multiple times as a dependency of\n /// multiple packages, but it only needs to run once.\n pub compiled: HashSet,\n /// Linking information for each `Unit`.\n /// See `build_map` for details.\n pub build_scripts: HashMap>,\n /// Job server client to manage concurrency with other processes.\n pub jobserver: Client,\n /// \"Primary\" packages are the ones the user selected on the command-line\n /// with `-p` flags. If no flags are specified, then it is the defaults\n /// based on the current directory and the default workspace members.\n primary_packages: HashSet,\n /// An abstraction of the files and directories that will be generated by\n /// the compilation. This is `None` until after `unit_dependencies` has\n /// been computed.\n files: Option>,\n\n /// A set of units which are compiling rlibs and are expected to produce\n /// metadata files in addition to the rlib itself.\n rmeta_required: HashSet,\n\n /// Map of the LTO-status of each unit. This indicates what sort of\n /// compilation is happening (only object, only bitcode, both, etc), and is\n /// precalculated early on.\n pub lto: HashMap,\n\n /// Map of Doc/Docscrape units to metadata for their -Cmetadata flag.\n /// See `Context::find_metadata_units` for more details.\n pub metadata_for_doc_units: HashMap,\n\n /// Set of metadata of Docscrape units that fail before completion, e.g.\n /// because the target has a type error. This is in an Arc>\n /// because it is continuously updated as the job progresses.\n pub failed_scrape_units: Arc>>,\n\n /// Manages locks for build units when fine grain locking is enabled.\n pub lock_manager: Arc,\n}\n\nimpl<'a, 'gctx> BuildRunner<'a, 'gctx> {\n pub fn new(bcx: &'a BuildContext<'a, 'gctx>) -> CargoResult {\n // Load up the jobserver that we'll use to manage our parallelism. This\n // is the same as the GNU make implementation of a jobserver, and\n // intentionally so! It's hoped that we can interact with GNU make and\n // all share the same jobserver.\n //\n // Note that if we don't have a jobserver in our environment then we\n // create our own, and we create it with `n` tokens, but immediately\n // acquire one, because one token is ourself, a running process.\n let jobserver = match bcx.gctx.jobserver_from_env() {\n Some(c) => c.clone(),\n None => {\n let client =\n Client::new(bcx.jobs() as usize).context(\"failed to create jobserver\")?;\n client.acquire_raw()?;\n client\n }\n };\n\n Ok(Self {\n bcx,\n compilation: Compilation::new(bcx)?,\n build_script_outputs: Arc::new(Mutex::new(BuildScriptOutputs::default())),\n fingerprints: HashMap::new(),\n mtime_cache: HashMap::new(),\n checksum_cache: HashMap::new(),\n compiled: HashSet::new(),\n build_scripts: HashMap::new(),\n build_explicit_deps: HashMap::new(),\n jobserver,\n primary_packages: HashSet::new(),\n files: None,\n rmeta_required: HashSet::new(),\n lto: HashMap::new(),\n metadata_for_doc_units: HashMap::new(),\n failed_scrape_units: Arc::new(Mutex::new(HashSet::new())),\n lock_manager: Arc::new(LockManager::new()),\n })\n }\n\n /// Dry-run the compilation without actually running it.\n ///\n /// This is expected to collect information like the location of output artifacts.\n /// Please keep in sync with non-compilation part in [`BuildRunner::compile`].\n pub fn dry_run(mut self) -> CargoResult> {\n let _lock = self\n .bcx\n .gctx\n .acquire_package_cache_lock(CacheLockMode::Shared)?;\n self.lto = super::lto::generate(self.bcx)?;\n self.prepare_units()?;\n self.prepare()?;\n self.check_collisions()?;\n\n for unit in &self.bcx.roots {\n self.collect_tests_and_executables(unit)?;\n }\n\n Ok(self.compilation)\n }\n\n /// Starts compilation, waits for it to finish, and returns information\n /// about the result of compilation.\n ///\n /// See [`ops::cargo_compile`] for a higher-level view of the compile process.\n ///\n /// [`ops::cargo_compile`]: crate::ops::cargo_compile\n #[tracing::instrument(skip_all)]\n pub fn compile(mut self, exec: &Arc) -> CargoResult> {\n // A shared lock is held during the duration of the build since rustc\n // needs to read from the `src` cache, and we don't want other\n // commands modifying the `src` cache while it is running.\n let _lock = self\n .bcx\n .gctx\n .acquire_package_cache_lock(CacheLockMode::Shared)?;\n let mut queue = JobQueue::new(self.bcx);\n self.lto = super::lto::generate(self.bcx)?;\n self.prepare_units()?;\n self.prepare()?;\n custom_build::build_map(&mut self)?;\n self.check_collisions()?;\n self.compute_metadata_for_doc_units();\n\n // We need to make sure that if there were any previous docs already compiled,\n // they were compiled with the same Rustc version that we're currently using.\n // See the function doc comment for more.\n if self.bcx.build_config.intent.is_doc() {\n RustdocFingerprint::check_rustdoc_fingerprint(&self)?\n }\n\n for unit in &self.bcx.roots {\n let force_rebuild = self.bcx.build_config.force_rebuild;\n super::compile(&mut self, &mut queue, unit, exec, force_rebuild)?;\n }\n\n // Now that we've got the full job queue and we've done all our\n // fingerprint analysis to determine what to run, bust all the memoized\n // fingerprint hashes to ensure that during the build they all get the\n // most up-to-date values. In theory we only need to bust hashes that\n // transitively depend on a dirty build script, but it shouldn't matter\n // that much for performance anyway.\n for fingerprint in self.fingerprints.values() {\n fingerprint.clear_memoized();\n }\n\n // Now that we've figured out everything that we're going to do, do it!\n queue.execute(&mut self)?;\n\n // Add `OUT_DIR` to env vars if unit has a build script.\n let units_with_build_script = &self\n .bcx\n .roots\n .iter()\n .filter(|unit| self.build_scripts.contains_key(unit))\n .dedup_by(|x, y| x.pkg.package_id() == y.pkg.package_id())\n .collect::>();\n for unit in units_with_build_script {\n for dep in &self.bcx.unit_graph[unit] {\n if dep.unit.mode.is_run_custom_build() {\n let out_dir = if self.bcx.gctx.cli_unstable().build_dir_new_layout {\n self.files().out_dir_new_layout(&dep.unit)\n } else {\n self.files().build_script_out_dir(&dep.unit)\n };\n let script_meta = self.get_run_build_script_metadata(&dep.unit);\n self.compilation\n .extra_env\n .entry(script_meta)\n .or_insert_with(Vec::new)\n .push((\"OUT_DIR\".to_string(), out_dir.display().to_string()));\n }\n }\n }\n\n self.collect_doc_merge_info()?;\n\n // Collect the result of the build into `self.compilation`.\n for unit in &self.bcx.roots {\n self.collect_tests_and_executables(unit)?;\n\n // Collect information for `rustdoc --test`.\n if unit.mode.is_doc_test() {\n let mut unstable_opts = false;\n let mut args = compiler::extern_args(&self, unit, &mut unstable_opts)?;\n args.extend(compiler::lib_search_paths(&self, unit)?);\n args.extend(compiler::lto_args(&self, unit));\n args.extend(compiler::features_args(unit));\n args.extend(compiler::check_cfg_args(unit));\n\n let script_metas = self.find_build_script_metadatas(unit);\n if let Some(meta_vec) = script_metas.clone() {\n for meta in meta_vec {\n if let Some(output) = self.build_script_outputs.lock().unwrap().get(meta) {\n for cfg in &output.cfgs {\n args.push(\"--cfg\".into());\n args.push(cfg.into());\n }\n\n for check_cfg in &output.check_cfgs {\n args.push(\"--check-cfg\".into());\n args.push(check_cfg.into());\n }\n\n for (lt, arg) in &output.linker_args {\n if lt.applies_to(&unit.target, unit.mode) {\n args.push(\"-C\".into());\n args.push(format!(\"link-arg={}\", arg).into());\n }\n }\n }\n }\n }\n args.extend(unit.rustdocflags.iter().map(Into::into));\n\n use super::MessageFormat;\n let format = match self.bcx.build_config.message_format {\n MessageFormat::Short => \"short\",\n MessageFormat::Human => \"human\",\n MessageFormat::Json { .. } => \"json\",\n };\n args.push(\"--error-format\".into());\n args.push(format.into());\n\n self.compilation.to_doc_test.push(compilation::Doctest {\n unit: unit.clone(),\n args,\n unstable_opts,\n linker: self\n .compilation\n .target_linker(unit.kind)\n .map(|p| p.to_path_buf()),\n script_metas,\n env: artifact::get_env(&self, unit, self.unit_deps(unit))?,\n });\n }\n\n super::output_depinfo(&mut self, unit)?;\n }\n\n for (script_meta, output) in self.build_script_outputs.lock().unwrap().iter() {\n self.compilation\n .extra_env\n .entry(*script_meta)\n .or_insert_with(Vec::new)\n .extend(output.env.iter().cloned());\n\n for dir in output.library_paths.iter() {\n self.compilation\n .native_dirs\n .insert(dir.clone().into_path_buf());\n }\n }\n Ok(self.compilation)\n }\n\n fn collect_tests_and_executables(&mut self, unit: &Unit) -> CargoResult<()> {\n for output in self.outputs(unit)?.iter() {\n if matches!(\n output.flavor,\n FileFlavor::DebugInfo | FileFlavor::Auxiliary | FileFlavor::Sbom\n ) {\n continue;\n }\n\n let bindst = output.bin_dst();\n\n if unit.mode == CompileMode::Test {\n self.compilation\n .tests\n .push(self.unit_output(unit, &output.path)?);\n } else if unit.target.is_executable() {\n self.compilation\n .binaries\n .push(self.unit_output(unit, bindst)?);\n } else if unit.target.is_cdylib()\n && !self.compilation.cdylibs.iter().any(|uo| uo.unit == *unit)\n {\n self.compilation\n .cdylibs\n .push(self.unit_output(unit, bindst)?);\n }\n }\n Ok(())\n }\n\n fn collect_doc_merge_info(&mut self) -> CargoResult<()> {\n if !self.bcx.gctx.cli_unstable().rustdoc_mergeable_info {\n return Ok(());\n }\n\n if !self.bcx.build_config.intent.is_doc() {\n return Ok(());\n }\n\n if self.bcx.build_config.intent.wants_doc_json_output() {\n // rustdoc JSON output doesn't support merge (yet?)\n return Ok(());\n }\n\n let mut doc_parts_map: HashMap<_, Vec<_>> = HashMap::new();\n\n let unit_iter = if self.bcx.build_config.intent.wants_deps_docs() {\n itertools::Either::Left(self.bcx.unit_graph.keys())\n } else {\n itertools::Either::Right(self.bcx.roots.iter())\n };\n\n for unit in unit_iter {\n if !unit.mode.is_doc() {\n continue;\n }\n // Assumption: one `rustdoc` call generates only one cross-crate info JSON.\n let outputs = self.outputs(unit)?;\n\n let Some(doc_parts) = outputs\n .iter()\n .find(|o| matches!(o.flavor, FileFlavor::DocParts))\n else {\n continue;\n };\n\n doc_parts_map\n .entry(unit.kind)\n .or_default()\n .push(doc_parts.path.to_owned());\n }\n\n self.compilation.rustdoc_fingerprints = Some(\n doc_parts_map\n .into_iter()\n .map(|(kind, doc_parts)| (kind, RustdocFingerprint::new(self, kind, doc_parts)))\n .collect(),\n );\n\n Ok(())\n }\n\n /// Returns the executable for the specified unit (if any).\n pub fn get_executable(&mut self, unit: &Unit) -> CargoResult> {\n let is_binary = unit.target.is_executable();\n let is_test = unit.mode.is_any_test();\n if !unit.mode.generates_executable() || !(is_binary || is_test) {\n return Ok(None);\n }\n Ok(self\n .outputs(unit)?\n .iter()\n .find(|o| o.flavor == FileFlavor::Normal)\n .map(|output| output.bin_dst().clone()))\n }\n\n #[tracing::instrument(skip_all)]\n pub fn prepare_units(&mut self) -> CargoResult<()> {\n let dest = self.bcx.profiles.get_dir_name();\n // We try to only lock the artifact-dir if we need to.\n // For example, `cargo check` does not write any files to the artifact-dir so we don't need\n // to lock it.\n let must_take_artifact_dir_lock = match self.bcx.build_config.intent {\n UserIntent::Check { .. } => {\n // Generally cargo check does not need to take the artifact-dir lock but there is\n // one exception: If check has `--timings` we still need to lock artifact-dir since\n // we will output the report files.\n self.bcx.build_config.timing_report\n }\n UserIntent::Build\n | UserIntent::Test\n | UserIntent::Doc { .. }\n | UserIntent::Doctest\n | UserIntent::Bench => true,\n };\n let host_layout =\n Layout::new(self.bcx.ws, None, &dest, must_take_artifact_dir_lock, false)?;\n let mut targets = HashMap::new();\n for kind in self.bcx.all_kinds.iter() {\n if let CompileKind::Target(target) = *kind {\n let layout = Layout::new(\n self.bcx.ws,\n Some(target),\n &dest,\n must_take_artifact_dir_lock,\n false,\n )?;\n targets.insert(target, layout);\n }\n }\n self.primary_packages\n .extend(self.bcx.roots.iter().map(|u| u.pkg.package_id()));\n self.compilation\n .root_crate_names\n .extend(self.bcx.roots.iter().map(|u| u.target.crate_name()));\n\n self.record_units_requiring_metadata();\n\n let files = CompilationFiles::new(self, host_layout, targets);\n self.files = Some(files);\n Ok(())\n }\n\n /// Prepare this context, ensuring that all filesystem directories are in\n /// place.\n #[tracing::instrument(skip_all)]\n pub fn prepare(&mut self) -> CargoResult<()> {\n self.files\n .as_mut()\n .unwrap()\n .host\n .prepare()\n .context(\"couldn't prepare build directories\")?;\n for target in self.files.as_mut().unwrap().target.values_mut() {\n target\n .prepare()\n .context(\"couldn't prepare build directories\")?;\n }\n\n let files = self.files.as_ref().unwrap();\n for &kind in self.bcx.all_kinds.iter() {\n let layout = files.layout(kind);\n if let Some(artifact_dir) = layout.artifact_dir() {\n self.compilation\n .root_output\n .insert(kind, artifact_dir.dest().to_path_buf());\n }\n if self.bcx.gctx.cli_unstable().build_dir_new_layout {\n for (unit, _) in self.bcx.unit_graph.iter() {\n let dep_dir = self.files().deps_dir(unit);\n paths::create_dir_all(&dep_dir)?;\n self.compilation.deps_output.insert(kind, dep_dir);\n }\n } else {\n self.compilation\n .deps_output\n .insert(kind, layout.build_dir().legacy_deps().to_path_buf());\n }\n }\n Ok(())\n }\n\n pub fn files(&self) -> &CompilationFiles<'a, 'gctx> {\n self.files.as_ref().unwrap()\n }\n\n /// Returns the filenames that the given unit will generate.\n pub fn outputs(&self, unit: &Unit) -> CargoResult>> {\n self.files.as_ref().unwrap().outputs(unit, self.bcx)\n }\n\n /// Direct dependencies for the given unit.\n pub fn unit_deps(&self, unit: &Unit) -> &[UnitDep] {\n &self.bcx.unit_graph[unit]\n }\n\n /// Returns the `RunCustomBuild` Units associated with the given Unit.\n ///\n /// If the package does not have a build script, this returns None.\n pub fn find_build_script_units(&self, unit: &Unit) -> Option> {\n if unit.mode.is_run_custom_build() {\n return Some(vec![unit.clone()]);\n }\n\n let build_script_units: Vec = self.bcx.unit_graph[unit]\n .iter()\n .filter(|unit_dep| {\n unit_dep.unit.mode.is_run_custom_build()\n && unit_dep.unit.pkg.package_id() == unit.pkg.package_id()\n })\n .map(|unit_dep| unit_dep.unit.clone())\n .collect();\n if build_script_units.is_empty() {\n None\n } else {\n Some(build_script_units)\n }\n }\n\n /// Returns the metadata hash for the `RunCustomBuild` Unit associated with\n /// the given unit.\n ///\n /// If the package does not have a build script, this returns None.\n pub fn find_build_script_metadatas(&self, unit: &Unit) -> Option> {\n self.find_build_script_units(unit).map(|units| {\n units\n .iter()\n .map(|u| self.get_run_build_script_metadata(u))\n .collect()\n })\n }\n\n /// Returns the metadata hash for a `RunCustomBuild` unit.\n pub fn get_run_build_script_metadata(&self, unit: &Unit) -> UnitHash {\n assert!(unit.mode.is_run_custom_build());\n self.files().metadata(unit).unit_id()\n }\n\n /// Returns the list of SBOM output file paths for a given [`Unit`].\n pub fn sbom_output_files(&self, unit: &Unit) -> CargoResult> {\n Ok(self\n .outputs(unit)?\n .iter()\n .filter(|o| o.flavor == FileFlavor::Sbom)\n .map(|o| o.path.clone())\n .collect())\n }\n\n pub fn is_primary_package(&self, unit: &Unit) -> bool {\n self.primary_packages.contains(&unit.pkg.package_id())\n }\n\n /// Returns a [`UnitOutput`] which represents some information about the\n /// output of a unit.\n pub fn unit_output(&self, unit: &Unit, path: &Path) -> CargoResult {\n let script_metas = self.find_build_script_metadatas(unit);\n let env = artifact::get_env(&self, unit, self.unit_deps(unit))?;\n Ok(UnitOutput {\n unit: unit.clone(),\n path: path.to_path_buf(),\n script_metas,\n env,\n })\n }\n\n /// Check if any output file name collision happens.\n /// See for more.\n #[tracing::instrument(skip_all)]\n fn check_collisions(&self) -> CargoResult<()> {\n let mut output_collisions = HashMap::new();\n let describe_collision = |unit: &Unit, other_unit: &Unit| -> String {\n format!(\n \"the {} target `{}` in package `{}` has the same output filename as the {} target `{}` in package `{}`\",\n unit.target.kind().description(),\n unit.target.name(),\n unit.pkg.package_id(),\n other_unit.target.kind().description(),\n other_unit.target.name(),\n other_unit.pkg.package_id(),\n )\n };\n let suggestion = [\n Level::NOTE.message(\"this may become a hard error in the future; see \"),\n Level::HELP.message(\"consider changing their names to be unique or compiling them separately\")\n ];\n let rustdoc_suggestion = [\n Level::NOTE.message(\"this is a known bug where multiple crates with the same name use the same path; see \")\n ];\n let report_collision = |unit: &Unit,\n other_unit: &Unit,\n path: &PathBuf,\n messages: &[Message<'_>]|\n -> CargoResult<()> {\n if unit.target.name() == other_unit.target.name() {\n self.bcx.gctx.shell().print_report(\n &[Level::WARNING\n .secondary_title(format!(\"output filename collision at {}\", path.display()))\n .elements(\n [Level::NOTE.message(describe_collision(unit, other_unit))]\n .into_iter()\n .chain(messages.iter().cloned()),\n )],\n false,\n )\n } else {\n self.bcx.gctx.shell().print_report(\n &[Level::WARNING\n .secondary_title(format!(\"output filename collision at {}\", path.display()))\n .elements([\n Level::NOTE.message(describe_collision(unit, other_unit)),\n Level::NOTE.message(\"if this looks unexpected, it may be a bug in Cargo. Please file a bug \\\n report at https://github.com/rust-lang/cargo/issues/ with as much information as you \\\n can provide.\"),\n Level::NOTE.message(format!(\"cargo {} running on `{}` target `{}`\",\n crate::version(), self.bcx.host_triple(), self.bcx.target_data.short_name(&unit.kind))),\n Level::NOTE.message(format!(\"first unit: {unit:?}\")),\n Level::NOTE.message(format!(\"second unit: {other_unit:?}\")),\n ])],\n false,\n )\n }\n };\n\n fn doc_collision_error(unit: &Unit, other_unit: &Unit) -> CargoResult<()> {\n bail!(\n \"document output filename collision\\n\\\n The {} `{}` in package `{}` has the same name as the {} `{}` in package `{}`.\\n\\\n Only one may be documented at once since they output to the same path.\\n\\\n Consider documenting only one, renaming one, \\\n or marking one with `doc = false` in Cargo.toml.\",\n unit.target.kind().description(),\n unit.target.name(),\n unit.pkg,\n other_unit.target.kind().description(),\n other_unit.target.name(),\n other_unit.pkg,\n );\n }\n\n let mut keys = self\n .bcx\n .unit_graph\n .keys()\n .filter(|unit| !unit.mode.is_run_custom_build())\n .collect::>();\n // Sort for consistent error messages.\n keys.sort_unstable();\n // These are kept separate to retain compatibility with older\n // versions, which generated an error when there was a duplicate lib\n // or bin (but the old code did not check bin<->lib collisions). To\n // retain backwards compatibility, this only generates an error for\n // duplicate libs or duplicate bins (but not both). Ideally this\n // shouldn't be here, but since there isn't a complete workaround,\n // yet, this retains the old behavior.\n let mut doc_libs = HashMap::new();\n let mut doc_bins = HashMap::new();\n for unit in keys {\n if unit.mode.is_doc() && self.is_primary_package(unit) {\n // These situations have been an error since before 1.0, so it\n // is not a warning like the other situations.\n if unit.target.is_lib() {\n if let Some(prev) = doc_libs.insert((unit.target.crate_name(), unit.kind), unit)\n {\n doc_collision_error(unit, prev)?;\n }\n } else if let Some(prev) =\n doc_bins.insert((unit.target.crate_name(), unit.kind), unit)\n {\n doc_collision_error(unit, prev)?;\n }\n }\n for output in self.outputs(unit)?.iter() {\n if let Some(other_unit) = output_collisions.insert(output.path.clone(), unit) {\n if unit.mode.is_doc() {\n // See https://github.com/rust-lang/rust/issues/56169\n // and https://github.com/rust-lang/rust/issues/61378\n report_collision(unit, other_unit, &output.path, &rustdoc_suggestion)?;\n } else {\n report_collision(unit, other_unit, &output.path, &suggestion)?;\n }\n }\n if let Some(hardlink) = output.hardlink.as_ref() {\n if let Some(other_unit) = output_collisions.insert(hardlink.clone(), unit) {\n report_collision(unit, other_unit, hardlink, &suggestion)?;\n }\n }\n if let Some(ref export_path) = output.export_path {\n if let Some(other_unit) = output_collisions.insert(export_path.clone(), unit) {\n self.bcx.gctx.shell().print_report(\n &[Level::WARNING\n .secondary_title(format!(\n \"`--artifact-dir` filename collision at {}\",\n export_path.display()\n ))\n .elements(\n [Level::NOTE.message(describe_collision(unit, other_unit))]\n .into_iter()\n .chain(suggestion.iter().cloned()),\n )],\n false,\n )?;\n }\n }\n }\n }\n Ok(())\n }\n\n /// Records the list of units which are required to emit metadata.\n ///\n /// Units which depend only on the metadata of others requires the others to\n /// actually produce metadata, so we'll record that here.\n fn record_units_requiring_metadata(&mut self) {\n for (key, deps) in self.bcx.unit_graph.iter() {\n for dep in deps {\n if self.only_requires_rmeta(key, &dep.unit) {\n self.rmeta_required.insert(dep.unit.clone());\n }\n }\n }\n }\n\n /// Returns whether when `parent` depends on `dep` if it only requires the\n /// metadata file from `dep`.\n pub fn only_requires_rmeta(&self, parent: &Unit, dep: &Unit) -> bool {\n // We're only a candidate for requiring an `rmeta` file if we\n // ourselves are building an rlib,\n !parent.requires_upstream_objects()\n && parent.mode == CompileMode::Build\n // Our dependency must also be built as an rlib, otherwise the\n // object code must be useful in some fashion\n && !dep.requires_upstream_objects()\n && dep.mode == CompileMode::Build\n }\n\n /// Returns whether when `unit` is built whether it should emit metadata as\n /// well because some compilations rely on that.\n pub fn rmeta_required(&self, unit: &Unit) -> bool {\n self.rmeta_required.contains(unit)\n }\n\n /// Finds metadata for Doc/Docscrape units.\n ///\n /// rustdoc needs a -Cmetadata flag in order to recognize StableCrateIds that refer to\n /// items in the crate being documented. The -Cmetadata flag used by reverse-dependencies\n /// will be the metadata of the Cargo unit that generated the current library's rmeta file,\n /// which should be a Check unit.\n ///\n /// If the current crate has reverse-dependencies, such a Check unit should exist, and so\n /// we use that crate's metadata. If not, we use the crate's Doc unit so at least examples\n /// scraped from the current crate can be used when documenting the current crate.\n #[tracing::instrument(skip_all)]\n pub fn compute_metadata_for_doc_units(&mut self) {\n for unit in self.bcx.unit_graph.keys() {\n if !unit.mode.is_doc() && !unit.mode.is_doc_scrape() {\n continue;\n }\n\n let matching_units = self\n .bcx\n .unit_graph\n .keys()\n .filter(|other| {\n unit.pkg == other.pkg\n && unit.target == other.target\n && !other.mode.is_doc_scrape()\n })\n .collect::>();\n let metadata_unit = matching_units\n .iter()\n .find(|other| other.mode.is_check())\n .or_else(|| matching_units.iter().find(|other| other.mode.is_doc()))\n .unwrap_or(&unit);\n self.metadata_for_doc_units\n .insert(unit.clone(), self.files().metadata(metadata_unit));\n }\n }\n}\n" }, { "path": "src/cargo/core/compiler/compilation.rs", "content": "//! Type definitions for the result of a compilation.\n\nuse std::collections::{BTreeSet, HashMap};\nuse std::ffi::{OsStr, OsString};\nuse std::path::Path;\nuse std::path::PathBuf;\n\nuse cargo_platform::CfgExpr;\nuse cargo_util::{ProcessBuilder, paths};\n\nuse crate::core::Package;\nuse crate::core::compiler::BuildContext;\nuse crate::core::compiler::CompileTarget;\nuse crate::core::compiler::RustdocFingerprint;\nuse crate::core::compiler::apply_env_config;\nuse crate::core::compiler::{CompileKind, Unit, UnitHash};\nuse crate::util::{CargoResult, GlobalContext};\n\n/// Represents the kind of process we are creating.\n#[derive(Debug)]\nenum ToolKind {\n /// See [`Compilation::rustc_process`].\n Rustc,\n /// See [`Compilation::rustdoc_process`].\n Rustdoc,\n /// See [`Compilation::host_process`].\n HostProcess,\n /// See [`Compilation::target_process`].\n TargetProcess,\n}\n\nimpl ToolKind {\n fn is_rustc_tool(&self) -> bool {\n matches!(self, ToolKind::Rustc | ToolKind::Rustdoc)\n }\n}\n\n/// Structure with enough information to run `rustdoc --test`.\npub struct Doctest {\n /// What's being doctested\n pub unit: Unit,\n /// Arguments needed to pass to rustdoc to run this test.\n pub args: Vec,\n /// Whether or not -Zunstable-options is needed.\n pub unstable_opts: bool,\n /// The -Clinker value to use.\n pub linker: Option,\n /// The script metadata, if this unit's package has a build script.\n ///\n /// This is used for indexing [`Compilation::extra_env`].\n pub script_metas: Option>,\n\n /// Environment variables to set in the rustdoc process.\n pub env: HashMap,\n}\n\n/// Information about the output of a unit.\npub struct UnitOutput {\n /// The unit that generated this output.\n pub unit: Unit,\n /// Path to the unit's primary output (an executable or cdylib).\n pub path: PathBuf,\n /// The script metadata, if this unit's package has a build script.\n ///\n /// This is used for indexing [`Compilation::extra_env`].\n pub script_metas: Option>,\n\n /// Environment variables to set in the unit's process.\n pub env: HashMap,\n}\n\n/// A structure returning the result of a compilation.\npub struct Compilation<'gctx> {\n /// An array of all tests created during this compilation.\n pub tests: Vec,\n\n /// An array of all binaries created.\n pub binaries: Vec,\n\n /// An array of all cdylibs created.\n pub cdylibs: Vec,\n\n /// The crate names of the root units specified on the command-line.\n pub root_crate_names: Vec,\n\n /// All directories for the output of native build commands.\n ///\n /// This is currently used to drive some entries which are added to the\n /// `LD_LIBRARY_PATH` as appropriate.\n ///\n /// The order should be deterministic.\n pub native_dirs: BTreeSet,\n\n /// Root output directory (for the local package's artifacts)\n pub root_output: HashMap,\n\n /// Output directory for rust dependencies.\n /// May be for the host or for a specific target.\n pub deps_output: HashMap,\n\n /// The path to libstd for each target\n sysroot_target_libdir: HashMap,\n\n /// Extra environment variables that were passed to compilations and should\n /// be passed to future invocations of programs.\n ///\n /// The key is the build script metadata for uniquely identifying the\n /// `RunCustomBuild` unit that generated these env vars.\n pub extra_env: HashMap>,\n\n /// Libraries to test with rustdoc.\n pub to_doc_test: Vec,\n\n /// Rustdoc fingerprint files to determine whether we need to run `rustdoc --merge=finalize`.\n ///\n /// See `-Zrustdoc-mergeable-info` for more.\n pub rustdoc_fingerprints: Option>,\n\n /// The target host triple.\n pub host: String,\n\n gctx: &'gctx GlobalContext,\n\n /// Rustc process to be used by default\n rustc_process: ProcessBuilder,\n /// Rustc process to be used for workspace crates instead of `rustc_process`\n rustc_workspace_wrapper_process: ProcessBuilder,\n /// Optional rustc process to be used for primary crates instead of either `rustc_process` or\n /// `rustc_workspace_wrapper_process`\n primary_rustc_process: Option,\n\n /// The runner to use for each host or target process.\n runners: HashMap)>>,\n /// The linker to use for each host or target.\n linkers: HashMap>,\n\n /// The total number of lint warnings emitted by the compilation.\n pub lint_warning_count: usize,\n}\n\nimpl<'gctx> Compilation<'gctx> {\n pub fn new<'a>(bcx: &BuildContext<'a, 'gctx>) -> CargoResult> {\n let rustc_process = bcx.rustc().process();\n let primary_rustc_process = bcx.build_config.primary_unit_rustc.clone();\n let rustc_workspace_wrapper_process = bcx.rustc().workspace_process();\n let host = bcx.host_triple().to_string();\n\n // When `target-applies-to-host=false`, and without `--target`,\n // there will be only `CompileKind::Host` in requested_kinds.\n // Need to insert target config explicitly for target-applies-to-host=false\n // to find the correct configs.\n let insert_explicit_host_runner = !bcx.gctx.target_applies_to_host()?\n && bcx\n .build_config\n .requested_kinds\n .iter()\n .any(CompileKind::is_host);\n let mut runners = bcx\n .build_config\n .requested_kinds\n .iter()\n .chain(Some(&CompileKind::Host))\n .map(|kind| Ok((*kind, target_runner(bcx, *kind)?)))\n .collect::>>()?;\n if insert_explicit_host_runner {\n let kind = explicit_host_kind(&host);\n runners.insert(kind, target_runner(bcx, kind)?);\n }\n\n let mut linkers = bcx\n .build_config\n .requested_kinds\n .iter()\n .chain(Some(&CompileKind::Host))\n .map(|kind| Ok((*kind, target_linker(bcx, *kind)?)))\n .collect::>>()?;\n if insert_explicit_host_runner {\n let kind = explicit_host_kind(&host);\n linkers.insert(kind, target_linker(bcx, kind)?);\n }\n Ok(Compilation {\n native_dirs: BTreeSet::new(),\n root_output: HashMap::new(),\n deps_output: HashMap::new(),\n sysroot_target_libdir: get_sysroot_target_libdir(bcx)?,\n tests: Vec::new(),\n binaries: Vec::new(),\n cdylibs: Vec::new(),\n root_crate_names: Vec::new(),\n extra_env: HashMap::new(),\n to_doc_test: Vec::new(),\n rustdoc_fingerprints: None,\n gctx: bcx.gctx,\n host,\n rustc_process,\n rustc_workspace_wrapper_process,\n primary_rustc_process,\n runners,\n linkers,\n lint_warning_count: 0,\n })\n }\n\n /// Returns a [`ProcessBuilder`] for running `rustc`.\n ///\n /// `is_primary` is true if this is a \"primary package\", which means it\n /// was selected by the user on the command-line (such as with a `-p`\n /// flag), see [`crate::core::compiler::BuildRunner::primary_packages`].\n ///\n /// `is_workspace` is true if this is a workspace member.\n pub fn rustc_process(\n &self,\n unit: &Unit,\n is_primary: bool,\n is_workspace: bool,\n ) -> CargoResult {\n let mut rustc = if is_primary && self.primary_rustc_process.is_some() {\n self.primary_rustc_process.clone().unwrap()\n } else if is_workspace {\n self.rustc_workspace_wrapper_process.clone()\n } else {\n self.rustc_process.clone()\n };\n if self.gctx.extra_verbose() {\n rustc.display_env_vars();\n }\n let cmd = fill_rustc_tool_env(rustc, unit);\n self.fill_env(cmd, &unit.pkg, None, unit.kind, ToolKind::Rustc)\n }\n\n /// Returns a [`ProcessBuilder`] for running `rustdoc`.\n pub fn rustdoc_process(\n &self,\n unit: &Unit,\n script_metas: Option<&Vec>,\n ) -> CargoResult {\n let mut rustdoc = ProcessBuilder::new(&*self.gctx.rustdoc()?);\n if self.gctx.extra_verbose() {\n rustdoc.display_env_vars();\n }\n let cmd = fill_rustc_tool_env(rustdoc, unit);\n let mut cmd = self.fill_env(cmd, &unit.pkg, script_metas, unit.kind, ToolKind::Rustdoc)?;\n cmd.retry_with_argfile(true);\n unit.target.edition().cmd_edition_arg(&mut cmd);\n\n for crate_type in unit.target.rustc_crate_types() {\n cmd.arg(\"--crate-type\").arg(crate_type.as_str());\n }\n\n Ok(cmd)\n }\n\n /// Returns a [`ProcessBuilder`] appropriate for running a process for the\n /// host platform.\n ///\n /// This is currently only used for running build scripts. If you use this\n /// for anything else, please be extra careful on how environment\n /// variables are set!\n pub fn host_process>(\n &self,\n cmd: T,\n pkg: &Package,\n ) -> CargoResult {\n // Only use host runner when -Zhost-config is enabled\n // to ensure `target..runner` does not wrap build scripts.\n let builder = if !self.gctx.target_applies_to_host()?\n && let Some((runner, args)) = self\n .runners\n .get(&CompileKind::Host)\n .and_then(|x| x.as_ref())\n {\n let mut builder = ProcessBuilder::new(runner);\n builder.args(args);\n builder.arg(cmd);\n builder\n } else {\n ProcessBuilder::new(cmd)\n };\n self.fill_env(builder, pkg, None, CompileKind::Host, ToolKind::HostProcess)\n }\n\n pub fn target_runner(&self, kind: CompileKind) -> Option<&(PathBuf, Vec)> {\n let target_applies_to_host = self.gctx.target_applies_to_host().unwrap_or(true);\n let kind = if !target_applies_to_host && kind.is_host() {\n // Use explicit host target triple when `target-applies-to-host=false`\n // This ensures `host.runner` won't be accidentally applied to `cargo run` / `cargo test`.\n explicit_host_kind(&self.host)\n } else {\n kind\n };\n self.runners.get(&kind).and_then(|x| x.as_ref())\n }\n\n /// Gets the `[host.linker]` for host build target (build scripts and proc macros).\n pub fn host_linker(&self) -> Option<&Path> {\n self.linkers\n .get(&CompileKind::Host)\n .and_then(|x| x.as_ref())\n .map(|x| x.as_path())\n }\n\n /// Gets the user-specified linker for a particular host or target.\n pub fn target_linker(&self, kind: CompileKind) -> Option<&Path> {\n let target_applies_to_host = self.gctx.target_applies_to_host().unwrap_or(true);\n let kind = if !target_applies_to_host && kind.is_host() {\n // Use explicit host target triple when `target-applies-to-host=false`\n // This ensures `host.linker` won't be accidentally applied to normal builds\n explicit_host_kind(&self.host)\n } else {\n kind\n };\n self.linkers\n .get(&kind)\n .and_then(|x| x.as_ref())\n .map(|x| x.as_path())\n }\n\n /// Returns a [`ProcessBuilder`] appropriate for running a process for the\n /// target platform. This is typically used for `cargo run` and `cargo\n /// test`.\n ///\n /// `script_metas` is the metadata for the `RunCustomBuild` unit that this\n /// unit used for its build script. Use `None` if the package did not have\n /// a build script.\n pub fn target_process>(\n &self,\n cmd: T,\n kind: CompileKind,\n pkg: &Package,\n script_metas: Option<&Vec>,\n ) -> CargoResult {\n let builder = if let Some((runner, args)) = self.target_runner(kind) {\n let mut builder = ProcessBuilder::new(runner);\n builder.args(args);\n builder.arg(cmd);\n builder\n } else {\n ProcessBuilder::new(cmd)\n };\n let tool_kind = ToolKind::TargetProcess;\n let mut builder = self.fill_env(builder, pkg, script_metas, kind, tool_kind)?;\n\n if let Some(client) = self.gctx.jobserver_from_env() {\n builder.inherit_jobserver(client);\n }\n\n Ok(builder)\n }\n\n /// Prepares a new process with an appropriate environment to run against\n /// the artifacts produced by the build process.\n ///\n /// The package argument is also used to configure environment variables as\n /// well as the working directory of the child process.\n fn fill_env(\n &self,\n mut cmd: ProcessBuilder,\n pkg: &Package,\n script_metas: Option<&Vec>,\n kind: CompileKind,\n tool_kind: ToolKind,\n ) -> CargoResult {\n let mut search_path = Vec::new();\n if tool_kind.is_rustc_tool() {\n if matches!(tool_kind, ToolKind::Rustdoc) {\n // HACK: `rustdoc --test` not only compiles but executes doctests.\n // Ideally only execution phase should have search paths appended,\n // so the executions can find native libs just like other tests.\n // However, there is no way to separate these two phase, so this\n // hack is added for both phases.\n // TODO: handle doctest-xcompile\n search_path.extend(super::filter_dynamic_search_path(\n self.native_dirs.iter(),\n &self.root_output[&CompileKind::Host],\n ));\n }\n search_path.push(self.deps_output[&CompileKind::Host].clone());\n } else {\n if let Some(path) = self.root_output.get(&kind) {\n search_path.extend(super::filter_dynamic_search_path(\n self.native_dirs.iter(),\n path,\n ));\n search_path.push(path.clone());\n }\n search_path.push(self.deps_output[&kind].clone());\n // For build-std, we don't want to accidentally pull in any shared\n // libs from the sysroot that ships with rustc. This may not be\n // required (at least I cannot craft a situation where it\n // matters), but is here to be safe.\n if self.gctx.cli_unstable().build_std.is_none() ||\n // Proc macros dynamically link to std, so set it anyway.\n pkg.proc_macro()\n {\n search_path.push(self.sysroot_target_libdir[&kind].clone());\n }\n }\n\n let dylib_path = paths::dylib_path();\n let dylib_path_is_empty = dylib_path.is_empty();\n if dylib_path.starts_with(&search_path) {\n search_path = dylib_path;\n } else {\n search_path.extend(dylib_path.into_iter());\n }\n if cfg!(target_os = \"macos\") && dylib_path_is_empty {\n // These are the defaults when DYLD_FALLBACK_LIBRARY_PATH isn't\n // set or set to an empty string. Since Cargo is explicitly setting\n // the value, make sure the defaults still work.\n if let Some(home) = self.gctx.get_env_os(\"HOME\") {\n search_path.push(PathBuf::from(home).join(\"lib\"));\n }\n search_path.push(PathBuf::from(\"/usr/local/lib\"));\n search_path.push(PathBuf::from(\"/usr/lib\"));\n }\n let search_path = paths::join_paths(&search_path, paths::dylib_path_envvar())?;\n\n cmd.env(paths::dylib_path_envvar(), &search_path);\n if let Some(meta_vec) = script_metas {\n for meta in meta_vec {\n if let Some(env) = self.extra_env.get(meta) {\n for (k, v) in env {\n cmd.env(k, v);\n }\n }\n }\n }\n\n let cargo_exe = self.gctx.cargo_exe()?;\n cmd.env(crate::CARGO_ENV, cargo_exe);\n\n // When adding new environment variables depending on\n // crate properties which might require rebuild upon change\n // consider adding the corresponding properties to the hash\n // in BuildContext::target_metadata()\n cmd.env(\"CARGO_MANIFEST_DIR\", pkg.root())\n .env(\"CARGO_MANIFEST_PATH\", pkg.manifest_path())\n .env(\"CARGO_PKG_VERSION_MAJOR\", &pkg.version().major.to_string())\n .env(\"CARGO_PKG_VERSION_MINOR\", &pkg.version().minor.to_string())\n .env(\"CARGO_PKG_VERSION_PATCH\", &pkg.version().patch.to_string())\n .env(\"CARGO_PKG_VERSION_PRE\", pkg.version().pre.as_str())\n .env(\"CARGO_PKG_VERSION\", &pkg.version().to_string())\n .env(\"CARGO_PKG_NAME\", &*pkg.name());\n\n for (key, value) in pkg.manifest().metadata().env_vars() {\n cmd.env(key, value.as_ref());\n }\n\n cmd.cwd(pkg.root());\n\n apply_env_config(self.gctx, &mut cmd)?;\n\n Ok(cmd)\n }\n}\n\n/// Prepares a `rustc_tool` process with additional environment variables\n/// that are only relevant in a context that has a unit\nfn fill_rustc_tool_env(mut cmd: ProcessBuilder, unit: &Unit) -> ProcessBuilder {\n if unit.target.is_executable() {\n let name = unit\n .target\n .binary_filename()\n .unwrap_or(unit.target.name().to_string());\n\n cmd.env(\"CARGO_BIN_NAME\", name);\n }\n cmd.env(\"CARGO_CRATE_NAME\", unit.target.crate_name());\n cmd\n}\n\nfn get_sysroot_target_libdir(\n bcx: &BuildContext<'_, '_>,\n) -> CargoResult> {\n bcx.all_kinds\n .iter()\n .map(|&kind| {\n let Some(info) = bcx.target_data.get_info(kind) else {\n let target = match kind {\n CompileKind::Host => \"host\".to_owned(),\n CompileKind::Target(s) => s.short_name().to_owned(),\n };\n\n let dependency = bcx\n .unit_graph\n .iter()\n .find_map(|(u, _)| (u.kind == kind).then_some(u.pkg.summary().package_id()))\n .unwrap();\n\n anyhow::bail!(\n \"could not find specification for target `{target}`.\\n \\\n Dependency `{dependency}` requires to build for target `{target}`.\"\n )\n };\n\n Ok((kind, info.sysroot_target_libdir.clone()))\n })\n .collect()\n}\n\nfn target_runner(\n bcx: &BuildContext<'_, '_>,\n kind: CompileKind,\n) -> CargoResult)>> {\n if let Some(runner) = bcx.target_data.target_config(kind).runner.as_ref() {\n let path = runner.val.path.clone().resolve_program(bcx.gctx);\n return Ok(Some((path, runner.val.args.clone())));\n }\n\n // try target.'cfg(...)'.runner\n let target_cfg = bcx.target_data.info(kind).cfg();\n let mut cfgs = bcx\n .gctx\n .target_cfgs()?\n .iter()\n .filter_map(|(key, cfg)| cfg.runner.as_ref().map(|runner| (key, runner)))\n .filter(|(key, _runner)| CfgExpr::matches_key(key, target_cfg));\n let matching_runner = cfgs.next();\n if let Some((key, runner)) = cfgs.next() {\n anyhow::bail!(\n \"several matching instances of `target.'cfg(..)'.runner` in configurations\\n\\\n first match `{}` located in {}\\n\\\n second match `{}` located in {}\",\n matching_runner.unwrap().0,\n matching_runner.unwrap().1.definition,\n key,\n runner.definition\n );\n }\n Ok(matching_runner.map(|(_k, runner)| {\n (\n runner.val.path.clone().resolve_program(bcx.gctx),\n runner.val.args.clone(),\n )\n }))\n}\n\n/// Gets the user-specified linker for a particular host or target from the configuration.\nfn target_linker(bcx: &BuildContext<'_, '_>, kind: CompileKind) -> CargoResult> {\n // Try host.linker and target.{}.linker.\n if let Some(path) = bcx\n .target_data\n .target_config(kind)\n .linker\n .as_ref()\n .map(|l| l.val.clone().resolve_program(bcx.gctx))\n {\n return Ok(Some(path));\n }\n\n // Try target.'cfg(...)'.linker.\n let target_cfg = bcx.target_data.info(kind).cfg();\n let mut cfgs = bcx\n .gctx\n .target_cfgs()?\n .iter()\n .filter_map(|(key, cfg)| cfg.linker.as_ref().map(|linker| (key, linker)))\n .filter(|(key, _linker)| CfgExpr::matches_key(key, target_cfg));\n let matching_linker = cfgs.next();\n if let Some((key, linker)) = cfgs.next() {\n anyhow::bail!(\n \"several matching instances of `target.'cfg(..)'.linker` in configurations\\n\\\n first match `{}` located in {}\\n\\\n second match `{}` located in {}\",\n matching_linker.unwrap().0,\n matching_linker.unwrap().1.definition,\n key,\n linker.definition\n );\n }\n Ok(matching_linker.map(|(_k, linker)| linker.val.clone().resolve_program(bcx.gctx)))\n}\n\nfn explicit_host_kind(host: &str) -> CompileKind {\n let target = CompileTarget::new(host, false).expect(\"must be a host tuple\");\n CompileKind::Target(target)\n}\n" }, { "path": "src/cargo/core/compiler/compile_kind.rs", "content": "//! Type definitions for cross-compilation.\n\nuse crate::core::Target;\nuse crate::util::errors::CargoResult;\nuse crate::util::interning::InternedString;\nuse crate::util::{GlobalContext, StableHasher, try_canonicalize};\nuse anyhow::Context as _;\nuse anyhow::bail;\nuse cargo_util::ProcessBuilder;\nuse serde::Serialize;\nuse std::collections::BTreeSet;\nuse std::fs;\nuse std::hash::{Hash, Hasher};\nuse std::path::Path;\n\n/// Indicator for how a unit is being compiled.\n///\n/// This is used primarily for organizing cross compilations vs host\n/// compilations, where cross compilations happen at the request of `--target`\n/// and host compilations happen for things like build scripts and procedural\n/// macros.\n#[derive(PartialEq, Eq, Hash, Debug, Clone, Copy, PartialOrd, Ord)]\npub enum CompileKind {\n /// Attached to a unit that is compiled for the \"host\" system or otherwise\n /// is compiled without a `--target` flag. This is used for procedural\n /// macros and build scripts, or if the `--target` flag isn't passed.\n Host,\n\n /// Attached to a unit to be compiled for a particular target. This is used\n /// for units when the `--target` flag is passed.\n Target(CompileTarget),\n}\n\n/// Fallback behavior in the\n/// [`CompileKind::from_requested_targets_with_fallback`] function when\n/// no targets are specified.\npub enum CompileKindFallback {\n /// The build configuration is consulted to find the default target, such as\n /// `$CARGO_BUILD_TARGET` or reading `build.target`.\n BuildConfig,\n\n /// Only the host should be returned when targets aren't explicitly\n /// specified. This is used by `cargo metadata` for example where \"only\n /// host\" has a special meaning in terms of the returned metadata.\n JustHost,\n}\n\nimpl CompileKind {\n pub fn is_host(&self) -> bool {\n matches!(self, CompileKind::Host)\n }\n\n pub fn for_target(self, target: &Target) -> CompileKind {\n // Once we start compiling for the `Host` kind we continue doing so, but\n // if we are a `Target` kind and then we start compiling for a target\n // that needs to be on the host we lift ourselves up to `Host`.\n match self {\n CompileKind::Host => CompileKind::Host,\n CompileKind::Target(_) if target.for_host() => CompileKind::Host,\n CompileKind::Target(n) => CompileKind::Target(n),\n }\n }\n\n /// Creates a new list of `CompileKind` based on the requested list of\n /// targets.\n ///\n /// If no targets are given then this returns a single-element vector with\n /// `CompileKind::Host`.\n pub fn from_requested_targets(\n gctx: &GlobalContext,\n targets: &[String],\n ) -> CargoResult> {\n CompileKind::from_requested_targets_with_fallback(\n gctx,\n targets,\n CompileKindFallback::BuildConfig,\n )\n }\n\n /// Same as [`CompileKind::from_requested_targets`] except that if `targets`\n /// doesn't explicitly mention anything the behavior of what to return is\n /// controlled by the `fallback` argument.\n pub fn from_requested_targets_with_fallback(\n gctx: &GlobalContext,\n targets: &[String],\n fallback: CompileKindFallback,\n ) -> CargoResult> {\n let dedup = |targets: &[String]| {\n let deduplicated_targets = targets\n .iter()\n .map(|value| {\n // This neatly substitutes the manually-specified `host-tuple` target directive\n // with the compiling machine's target triple.\n\n if value.as_str() == \"host-tuple\" {\n let host_triple = env!(\"RUST_HOST_TARGET\");\n Ok(CompileKind::Target(CompileTarget::new(\n host_triple,\n gctx.cli_unstable().json_target_spec,\n )?))\n } else {\n Ok(CompileKind::Target(CompileTarget::new(\n value.as_str(),\n gctx.cli_unstable().json_target_spec,\n )?))\n }\n })\n // First collect into a set to deduplicate any `--target` passed\n // more than once...\n .collect::>>()?\n // ... then generate a flat list for everything else to use.\n .into_iter()\n .collect();\n\n Ok(deduplicated_targets)\n };\n\n if !targets.is_empty() {\n return dedup(targets);\n }\n\n let kinds = match (fallback, &gctx.build_config()?.target) {\n (_, None) | (CompileKindFallback::JustHost, _) => Ok(vec![CompileKind::Host]),\n (CompileKindFallback::BuildConfig, Some(build_target_config)) => {\n dedup(&build_target_config.values(gctx.cwd())?)\n }\n };\n\n kinds\n }\n\n /// Hash used for fingerprinting.\n ///\n /// Metadata hashing uses the normal Hash trait, which does not\n /// differentiate on `.json` file contents. The fingerprint hash does\n /// check the contents.\n pub fn fingerprint_hash(&self) -> u64 {\n match self {\n CompileKind::Host => 0,\n CompileKind::Target(target) => target.fingerprint_hash(),\n }\n }\n\n /// Adds the `--target` flag to the given [`ProcessBuilder`] if this is a\n /// non-host build.\n pub fn add_target_arg(&self, builder: &mut ProcessBuilder) {\n if let CompileKind::Target(target) = self {\n builder.arg(\"--target\").arg(target.rustc_target());\n if matches!(target, CompileTarget::Json { .. }) {\n builder.arg(\"-Zunstable-options\");\n }\n }\n }\n}\n\nimpl serde::ser::Serialize for CompileKind {\n fn serialize(&self, s: S) -> Result\n where\n S: serde::ser::Serializer,\n {\n match self {\n CompileKind::Host => None::<&str>.serialize(s),\n CompileKind::Target(t) => Some(t.rustc_target()).serialize(s),\n }\n }\n}\n\n/// Abstraction for the representation of a compilation target that Cargo has.\n///\n/// Compilation targets are one of two things right now:\n///\n/// 1. A raw target string, like `x86_64-unknown-linux-gnu`.\n/// 2. The path to a JSON file, such as `/path/to/my-target.json`.\n///\n/// Raw target strings are typically dictated by `rustc` itself and represent\n/// built-in targets. Custom JSON files are somewhat unstable, but supported\n/// here in Cargo. Note that for JSON target files this `CompileTarget` stores a\n/// full canonicalized path to the target.\n///\n/// The main reason for this existence is to handle JSON target files where when\n/// we call rustc we pass full paths but when we use it for Cargo's purposes\n/// like naming directories or looking up configuration keys we only check the\n/// file stem of JSON target files. For built-in rustc targets this is just an\n/// uninterpreted string basically.\n#[derive(PartialEq, Eq, Hash, Debug, Clone, Copy, PartialOrd, Ord, Serialize)]\npub enum CompileTarget {\n Tuple(InternedString),\n Json {\n short: InternedString,\n path: InternedString,\n },\n}\n\nimpl CompileTarget {\n pub fn new(name: &str, unstable_json: bool) -> CargoResult {\n let name = name.trim();\n if name.is_empty() {\n bail!(\"target was empty\");\n }\n if !name.ends_with(\".json\") {\n return Ok(CompileTarget::Tuple(name.into()));\n }\n\n if !unstable_json {\n bail!(\"`.json` target specs require -Zjson-target-spec\");\n }\n\n // If `name` ends in `.json` then it's likely a custom target\n // specification. Canonicalize the path to ensure that different builds\n // with different paths always produce the same result.\n let p = try_canonicalize(Path::new(name))\n .with_context(|| format!(\"target path `{name}` is not a valid file\"))?;\n let path = p\n .to_str()\n .ok_or_else(|| anyhow::format_err!(\"target path `{name}` is not valid unicode\"))?\n .into();\n let short = p.file_stem().unwrap().to_str().unwrap().into();\n Ok(CompileTarget::Json { short, path })\n }\n\n /// Returns the full unqualified name of this target, suitable for passing\n /// to `rustc` directly.\n ///\n /// Typically this is pretty much the same as `short_name`, but for the case\n /// of JSON target files this will be a full canonicalized path name for the\n /// current filesystem.\n pub fn rustc_target(&self) -> InternedString {\n match self {\n CompileTarget::Tuple(name) => *name,\n CompileTarget::Json { path, .. } => *path,\n }\n }\n\n /// Returns a \"short\" version of the target name suitable for usage within\n /// Cargo for configuration and such.\n ///\n /// This is typically the same as `rustc_target`, or the full name, but for\n /// JSON target files this returns just the file stem (e.g. `foo` out of\n /// `foo.json`) instead of the full path.\n pub fn short_name(&self) -> &str {\n match self {\n CompileTarget::Tuple(name) => name,\n CompileTarget::Json { short, .. } => short,\n }\n }\n\n /// See [`CompileKind::fingerprint_hash`].\n pub fn fingerprint_hash(&self) -> u64 {\n let mut hasher = StableHasher::new();\n match self {\n CompileTarget::Tuple(name) => name.hash(&mut hasher),\n CompileTarget::Json { path, .. } => {\n // This may have some performance concerns, since it is called\n // fairly often. If that ever seems worth fixing, consider\n // embedding this in `CompileTarget`.\n match fs::read_to_string(path) {\n Ok(contents) => contents.hash(&mut hasher),\n Err(_) => path.hash(&mut hasher),\n }\n }\n }\n Hasher::finish(&hasher)\n }\n}\n" }, { "path": "src/cargo/core/compiler/crate_type.rs", "content": "use std::fmt;\n\n/// Types of the output artifact that the compiler emits.\n/// Usually distributable or linkable either statically or dynamically.\n///\n/// See .\n#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]\npub enum CrateType {\n Bin,\n Lib,\n Rlib,\n Dylib,\n Cdylib,\n Staticlib,\n ProcMacro,\n Other(String),\n}\n\nimpl CrateType {\n pub fn as_str(&self) -> &str {\n match self {\n CrateType::Bin => \"bin\",\n CrateType::Lib => \"lib\",\n CrateType::Rlib => \"rlib\",\n CrateType::Dylib => \"dylib\",\n CrateType::Cdylib => \"cdylib\",\n CrateType::Staticlib => \"staticlib\",\n CrateType::ProcMacro => \"proc-macro\",\n CrateType::Other(s) => s,\n }\n }\n\n pub fn can_lto(&self) -> bool {\n match self {\n CrateType::Bin | CrateType::Staticlib | CrateType::Cdylib => true,\n CrateType::Lib\n | CrateType::Rlib\n | CrateType::Dylib\n | CrateType::ProcMacro\n | CrateType::Other(..) => false,\n }\n }\n\n pub fn is_linkable(&self) -> bool {\n match self {\n CrateType::Lib | CrateType::Rlib | CrateType::Dylib | CrateType::ProcMacro => true,\n CrateType::Bin | CrateType::Cdylib | CrateType::Staticlib | CrateType::Other(..) => {\n false\n }\n }\n }\n\n pub fn is_dynamic(&self) -> bool {\n match self {\n CrateType::Dylib | CrateType::Cdylib | CrateType::ProcMacro => true,\n CrateType::Lib\n | CrateType::Rlib\n | CrateType::Bin\n | CrateType::Staticlib\n | CrateType::Other(..) => false,\n }\n }\n\n /// Returns whether production of this crate type requires the object files\n /// from dependencies to be available.\n ///\n /// See also [`TargetKind::requires_upstream_objects`].\n ///\n /// [`TargetKind::requires_upstream_objects`]: crate::core::manifest::TargetKind::requires_upstream_objects\n pub fn requires_upstream_objects(&self) -> bool {\n // \"lib\" == \"rlib\" and is a compilation that doesn't actually\n // require upstream object files to exist, only upstream metadata\n // files. As a result, it doesn't require upstream artifacts\n\n !matches!(self, CrateType::Lib | CrateType::Rlib)\n // Everything else, however, is some form of \"linkable output\" or\n // something that requires upstream object files.\n }\n\n /// Returns whether production of this crate type could benefit from splitting metadata\n /// into a .rmeta file.\n ///\n /// See also [`TargetKind::benefits_from_no_embed_metadata`].\n ///\n /// [`TargetKind::benefits_from_no_embed_metadata`]: crate::core::manifest::TargetKind::benefits_from_no_embed_metadata\n pub fn benefits_from_no_embed_metadata(&self) -> bool {\n match self {\n // rlib/libs generate .rmeta files for pipelined compilation.\n // If we also include metadata inside of them, we waste disk space, since the metadata\n // will be located both in the lib/rlib and the .rmeta file.\n CrateType::Lib |\n CrateType::Rlib |\n // Dylibs do not have to contain metadata when they are used as a runtime dependency.\n // If we split the metadata into a separate .rmeta file, the dylib file (that\n // can be shipped as a runtime dependency) can be smaller.\n CrateType::Dylib => true,\n // Proc macros contain metadata that specifies what macro functions are available in\n // it, but the metadata is typically very small. The metadata of proc macros is also\n // self-contained (unlike rlibs/dylibs), so let's not unnecessarily split it into\n // multiple files.\n CrateType::ProcMacro |\n // cdylib and staticlib produce artifacts that are used through the C ABI and do not\n // contain Rust-specific metadata.\n CrateType::Cdylib |\n CrateType::Staticlib |\n // Binaries also do not contain metadata\n CrateType::Bin |\n CrateType::Other(_) => false\n }\n }\n}\n\nimpl fmt::Display for CrateType {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n self.as_str().fmt(f)\n }\n}\n\nimpl<'a> From<&'a String> for CrateType {\n fn from(s: &'a String) -> Self {\n match s.as_str() {\n \"bin\" => CrateType::Bin,\n \"lib\" => CrateType::Lib,\n \"rlib\" => CrateType::Rlib,\n \"dylib\" => CrateType::Dylib,\n \"cdylib\" => CrateType::Cdylib,\n \"staticlib\" => CrateType::Staticlib,\n \"procmacro\" => CrateType::ProcMacro,\n _ => CrateType::Other(s.clone()),\n }\n }\n}\n\nimpl fmt::Debug for CrateType {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n self.to_string().fmt(f)\n }\n}\n\nimpl serde::Serialize for CrateType {\n fn serialize(&self, s: S) -> Result\n where\n S: serde::ser::Serializer,\n {\n self.to_string().serialize(s)\n }\n}\n" }, { "path": "src/cargo/core/compiler/custom_build.rs", "content": "//! How to execute a build script and parse its output.\n//!\n//! ## Preparing a build script run\n//!\n//! A [build script] is an optional Rust script Cargo will run before building\n//! your package. As of this writing, two kinds of special [`Unit`]s will be\n//! constructed when there is a build script in a package.\n//!\n//! * Build script compilation --- This unit is generally the same as units\n//! that would compile other Cargo targets. It will recursively creates units\n//! of its dependencies. One biggest difference is that the [`Unit`] of\n//! compiling a build script is flagged as [`TargetKind::CustomBuild`].\n//! * Build script execution --- During the construction of the [`UnitGraph`],\n//! Cargo inserts a [`Unit`] with [`CompileMode::RunCustomBuild`]. This unit\n//! depends on the unit of compiling the associated build script, to ensure\n//! the executable is available before running. The [`Work`] of running the\n//! build script is prepared in the function [`prepare`].\n//!\n//! ## Running a build script\n//!\n//! When running a build script, Cargo is aware of the progress and the result\n//! of a build script. Standard output is the chosen interprocess communication\n//! between Cargo and build script processes. A set of strings is defined for\n//! that purpose. These strings, a.k.a. instructions, are interpreted by\n//! [`BuildOutput::parse`] and stored in [`BuildRunner::build_script_outputs`].\n//! The entire execution work is constructed by [`build_work`].\n//!\n//! [build script]: https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html\n//! [`TargetKind::CustomBuild`]: crate::core::manifest::TargetKind::CustomBuild\n//! [`UnitGraph`]: super::unit_graph::UnitGraph\n//! [`CompileMode::RunCustomBuild`]: crate::core::compiler::CompileMode::RunCustomBuild\n//! [instructions]: https://doc.rust-lang.org/cargo/reference/build-scripts.html#outputs-of-the-build-script\n\nuse super::{BuildRunner, Job, Unit, Work, fingerprint, get_dynamic_search_path};\nuse crate::core::compiler::CompileMode;\nuse crate::core::compiler::artifact;\nuse crate::core::compiler::build_runner::UnitHash;\nuse crate::core::compiler::job_queue::JobState;\nuse crate::core::{PackageId, Target, profiles::ProfileRoot};\nuse crate::util::errors::CargoResult;\nuse crate::util::internal;\nuse crate::util::machine_message::{self, Message};\nuse anyhow::{Context as _, bail};\nuse cargo_platform::Cfg;\nuse cargo_util::paths;\nuse cargo_util_schemas::manifest::RustVersion;\nuse std::collections::hash_map::{Entry, HashMap};\nuse std::collections::{BTreeSet, HashSet};\nuse std::path::{Path, PathBuf};\nuse std::str;\nuse std::sync::{Arc, Mutex};\n\n/// A build script instruction that tells Cargo to display an error after the\n/// build script has finished running. Read [the doc] for more.\n///\n/// [the doc]: https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html#cargo-error\nconst CARGO_ERROR_SYNTAX: &str = \"cargo::error=\";\n/// Deprecated: A build script instruction that tells Cargo to display a warning after the\n/// build script has finished running. Read [the doc] for more.\n///\n/// [the doc]: https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html#cargo-warning\nconst OLD_CARGO_WARNING_SYNTAX: &str = \"cargo:warning=\";\n/// A build script instruction that tells Cargo to display a warning after the\n/// build script has finished running. Read [the doc] for more.\n///\n/// [the doc]: https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html#cargo-warning\nconst NEW_CARGO_WARNING_SYNTAX: &str = \"cargo::warning=\";\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub enum Severity {\n Error,\n Warning,\n}\n\npub type LogMessage = (Severity, String);\n\n/// Represents a path added to the library search path.\n///\n/// We need to keep track of requests to add search paths within the cargo build directory\n/// separately from paths outside of Cargo. The reason is that we want to give precedence to linking\n/// against libraries within the Cargo build directory even if a similar library exists in the\n/// system (e.g. crate A adds `/usr/lib` to the search path and then a later build of crate B adds\n/// `target/debug/...` to satisfy its request to link against the library B that it built, but B is\n/// also found in `/usr/lib`).\n///\n/// There's some nuance here because we want to preserve relative order of paths of the same type.\n/// For example, if the build process would in declaration order emit the following linker line:\n/// ```bash\n/// -L/usr/lib -Ltarget/debug/build/crate1/libs -L/lib -Ltarget/debug/build/crate2/libs)\n/// ```\n///\n/// we want the linker to actually receive:\n/// ```bash\n/// -Ltarget/debug/build/crate1/libs -Ltarget/debug/build/crate2/libs) -L/usr/lib -L/lib\n/// ```\n///\n/// so that the library search paths within the crate artifacts directory come first but retain\n/// relative ordering while the system library paths come after while still retaining relative\n/// ordering among them; ordering is the order they are emitted within the build process,\n/// not lexicographic order.\n///\n/// WARNING: Even though this type implements PartialOrd + Ord, this is a lexicographic ordering.\n/// The linker line will require an explicit sorting algorithm. PartialOrd + Ord is derived because\n/// BuildOutput requires it but that ordering is different from the one for the linker search path,\n/// at least today. It may be worth reconsidering & perhaps it's ok if BuildOutput doesn't have\n/// a lexicographic ordering for the library_paths? I'm not sure the consequence of that.\n#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]\npub enum LibraryPath {\n /// The path is pointing within the output folder of the crate and takes priority over\n /// external paths when passed to the linker.\n CargoArtifact(PathBuf),\n /// The path is pointing outside of the crate's build location. The linker will always\n /// receive such paths after `CargoArtifact`.\n External(PathBuf),\n}\n\nimpl LibraryPath {\n fn new(p: PathBuf, script_out_dir: &Path) -> Self {\n let search_path = get_dynamic_search_path(&p);\n if search_path.starts_with(script_out_dir) {\n Self::CargoArtifact(p)\n } else {\n Self::External(p)\n }\n }\n\n pub fn into_path_buf(self) -> PathBuf {\n match self {\n LibraryPath::CargoArtifact(p) | LibraryPath::External(p) => p,\n }\n }\n}\n\nimpl AsRef for LibraryPath {\n fn as_ref(&self) -> &PathBuf {\n match self {\n LibraryPath::CargoArtifact(p) | LibraryPath::External(p) => p,\n }\n }\n}\n\n/// Contains the parsed output of a custom build script.\n#[derive(Clone, Debug, Hash, Default, PartialEq, Eq, PartialOrd, Ord)]\npub struct BuildOutput {\n /// Paths to pass to rustc with the `-L` flag.\n pub library_paths: Vec,\n /// Names and link kinds of libraries, suitable for the `-l` flag.\n pub library_links: Vec,\n /// Linker arguments suitable to be passed to `-C link-arg=`\n pub linker_args: Vec<(LinkArgTarget, String)>,\n /// Various `--cfg` flags to pass to the compiler.\n pub cfgs: Vec,\n /// Various `--check-cfg` flags to pass to the compiler.\n pub check_cfgs: Vec,\n /// Additional environment variables to run the compiler with.\n pub env: Vec<(String, String)>,\n /// Metadata to pass to the immediate dependencies.\n pub metadata: Vec<(String, String)>,\n /// Paths to trigger a rerun of this build script.\n /// May be absolute or relative paths (relative to package root).\n pub rerun_if_changed: Vec,\n /// Environment variables which, when changed, will cause a rebuild.\n pub rerun_if_env_changed: Vec,\n /// Errors and warnings generated by this build.\n ///\n /// These are only displayed if this is a \"local\" package, `-vv` is used, or\n /// there is a build error for any target in this package. Note that any log\n /// message of severity `Error` will by itself cause a build error, and will\n /// cause all log messages to be displayed.\n pub log_messages: Vec,\n}\n\n/// Map of packages to build script output.\n///\n/// This initially starts out as empty. Overridden build scripts get\n/// inserted during `build_map`. The rest of the entries are added\n/// immediately after each build script runs.\n///\n/// The [`UnitHash`] is the unique metadata hash for the `RunCustomBuild` Unit of\n/// the package. It needs a unique key, since the build script can be run\n/// multiple times with different profiles or features. We can't embed a\n/// `Unit` because this structure needs to be shareable between threads.\n#[derive(Default)]\npub struct BuildScriptOutputs {\n outputs: HashMap,\n}\n\n/// Linking information for a `Unit`.\n///\n/// See [`build_map`] for more details.\n#[derive(Default)]\npub struct BuildScripts {\n /// List of build script outputs this Unit needs to include for linking. Each\n /// element is an index into `BuildScriptOutputs`.\n ///\n /// Cargo will use this `to_link` vector to add `-L` flags to compiles as we\n /// propagate them upwards towards the final build. Note, however, that we\n /// need to preserve the ordering of `to_link` to be topologically sorted.\n /// This will ensure that build scripts which print their paths properly will\n /// correctly pick up the files they generated (if there are duplicates\n /// elsewhere).\n ///\n /// To preserve this ordering, the (id, metadata) is stored in two places, once\n /// in the `Vec` and once in `seen_to_link` for a fast lookup. We maintain\n /// this as we're building interactively below to ensure that the memory\n /// usage here doesn't blow up too much.\n ///\n /// For more information, see #2354.\n pub to_link: Vec<(PackageId, UnitHash)>,\n /// This is only used while constructing `to_link` to avoid duplicates.\n seen_to_link: HashSet<(PackageId, UnitHash)>,\n /// Host-only dependencies that have build scripts. Each element is an\n /// index into `BuildScriptOutputs`.\n ///\n /// This is the set of transitive dependencies that are host-only\n /// (proc-macro, plugin, build-dependency) that contain a build script.\n /// Any `BuildOutput::library_paths` path relative to `target` will be\n /// added to `LD_LIBRARY_PATH` so that the compiler can find any dynamic\n /// libraries a build script may have generated.\n pub plugins: BTreeSet<(PackageId, UnitHash)>,\n}\n\n/// Dependency information as declared by a build script that might trigger\n/// a recompile of itself.\n#[derive(Debug)]\npub struct BuildDeps {\n /// Absolute path to the file in the target directory that stores the\n /// output of the build script.\n pub build_script_output: PathBuf,\n /// Files that trigger a rebuild if they change.\n pub rerun_if_changed: Vec,\n /// Environment variables that trigger a rebuild if they change.\n pub rerun_if_env_changed: Vec,\n}\n\n/// Represents one of the instructions from `cargo::rustc-link-arg-*` build\n/// script instruction family.\n///\n/// In other words, indicates targets that custom linker arguments applies to.\n///\n/// See the [build script documentation][1] for more.\n///\n/// [1]: https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html#cargorustc-link-argflag\n#[derive(Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord)]\npub enum LinkArgTarget {\n /// Represents `cargo::rustc-link-arg=FLAG`.\n All,\n /// Represents `cargo::rustc-cdylib-link-arg=FLAG`.\n Cdylib,\n /// Represents `cargo::rustc-link-arg-bins=FLAG`.\n Bin,\n /// Represents `cargo::rustc-link-arg-bin=BIN=FLAG`.\n SingleBin(String),\n /// Represents `cargo::rustc-link-arg-tests=FLAG`.\n Test,\n /// Represents `cargo::rustc-link-arg-benches=FLAG`.\n Bench,\n /// Represents `cargo::rustc-link-arg-examples=FLAG`.\n Example,\n}\n\nimpl LinkArgTarget {\n /// Checks if this link type applies to a given [`Target`].\n pub fn applies_to(&self, target: &Target, mode: CompileMode) -> bool {\n let is_test = mode.is_any_test();\n match self {\n LinkArgTarget::All => true,\n LinkArgTarget::Cdylib => !is_test && target.is_cdylib(),\n LinkArgTarget::Bin => target.is_bin(),\n LinkArgTarget::SingleBin(name) => target.is_bin() && target.name() == name,\n LinkArgTarget::Test => target.is_test(),\n LinkArgTarget::Bench => target.is_bench(),\n LinkArgTarget::Example => target.is_exe_example(),\n }\n }\n}\n\n/// Prepares a `Work` that executes the target as a custom build script.\n#[tracing::instrument(skip_all)]\npub fn prepare(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResult {\n let metadata = build_runner.get_run_build_script_metadata(unit);\n if build_runner\n .build_script_outputs\n .lock()\n .unwrap()\n .contains_key(metadata)\n {\n // The output is already set, thus the build script is overridden.\n fingerprint::prepare_target(build_runner, unit, false)\n } else {\n build_work(build_runner, unit)\n }\n}\n\n/// Emits the output of a build script as a [`machine_message::BuildScript`]\n/// JSON string to standard output.\nfn emit_build_output(\n state: &JobState<'_, '_>,\n output: &BuildOutput,\n out_dir: &Path,\n package_id: PackageId,\n) -> CargoResult<()> {\n let library_paths = output\n .library_paths\n .iter()\n .map(|l| l.as_ref().display().to_string())\n .collect::>();\n\n let msg = machine_message::BuildScript {\n package_id: package_id.to_spec(),\n linked_libs: &output.library_links,\n linked_paths: &library_paths,\n cfgs: &output.cfgs,\n env: &output.env,\n out_dir,\n }\n .to_json_string();\n state.stdout(msg)?;\n Ok(())\n}\n\n/// Constructs the unit of work of running a build script.\n///\n/// The construction includes:\n///\n/// * Set environment variables for the build script run.\n/// * Create the output dir (`OUT_DIR`) for the build script output.\n/// * Determine if the build script needs a re-run.\n/// * Run the build script and store its output.\nfn build_work(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResult {\n assert!(unit.mode.is_run_custom_build());\n let bcx = &build_runner.bcx;\n let dependencies = build_runner.unit_deps(unit);\n let build_script_unit = dependencies\n .iter()\n .find(|d| !d.unit.mode.is_run_custom_build() && d.unit.target.is_custom_build())\n .map(|d| &d.unit)\n .expect(\"running a script not depending on an actual script\");\n let script_dir = build_runner.files().build_script_dir(build_script_unit);\n\n let script_out_dir = if bcx.gctx.cli_unstable().build_dir_new_layout {\n build_runner.files().out_dir_new_layout(unit)\n } else {\n build_runner.files().build_script_out_dir(unit)\n };\n\n if let Some(deps) = unit.pkg.manifest().metabuild() {\n prepare_metabuild(build_runner, build_script_unit, deps)?;\n }\n\n // Building the command to execute\n let to_exec = script_dir.join(unit.target.name());\n\n // Start preparing the process to execute, starting out with some\n // environment variables. Note that the profile-related environment\n // variables are not set with this the build script's profile but rather the\n // package's library profile.\n // NOTE: if you add any profile flags, be sure to update\n // `Profiles::get_profile_run_custom_build` so that those flags get\n // carried over.\n let to_exec = to_exec.into_os_string();\n let mut cmd = build_runner.compilation.host_process(to_exec, &unit.pkg)?;\n let debug = unit.profile.debuginfo.is_turned_on();\n cmd.env(\"OUT_DIR\", &script_out_dir)\n .env(\"CARGO_MANIFEST_DIR\", unit.pkg.root())\n .env(\"CARGO_MANIFEST_PATH\", unit.pkg.manifest_path())\n .env(\"NUM_JOBS\", &bcx.jobs().to_string())\n .env(\"TARGET\", bcx.target_data.short_name(&unit.kind))\n .env(\"DEBUG\", debug.to_string())\n .env(\"OPT_LEVEL\", &unit.profile.opt_level)\n .env(\n \"PROFILE\",\n match unit.profile.root {\n ProfileRoot::Release => \"release\",\n ProfileRoot::Debug => \"debug\",\n },\n )\n .env(\"HOST\", &bcx.host_triple())\n .env(\"RUSTC\", &bcx.rustc().path)\n .env(\"RUSTDOC\", &*bcx.gctx.rustdoc()?)\n .inherit_jobserver(&build_runner.jobserver);\n\n // Find all artifact dependencies and make their file and containing directory discoverable using environment variables.\n for (var, value) in artifact::get_env(build_runner, unit, dependencies)? {\n cmd.env(&var, value);\n }\n\n if let Some(linker) = &build_runner.compilation.target_linker(unit.kind) {\n cmd.env(\"RUSTC_LINKER\", linker);\n }\n\n if let Some(links) = unit.pkg.manifest().links() {\n cmd.env(\"CARGO_MANIFEST_LINKS\", links);\n }\n\n if let Some(trim_paths) = unit.profile.trim_paths.as_ref() {\n cmd.env(\"CARGO_TRIM_PATHS\", trim_paths.to_string());\n }\n\n // Be sure to pass along all enabled features for this package, this is the\n // last piece of statically known information that we have.\n for feat in &unit.features {\n cmd.env(&format!(\"CARGO_FEATURE_{}\", super::envify(feat)), \"1\");\n }\n\n let mut cfg_map = HashMap::new();\n cfg_map.insert(\n \"feature\",\n unit.features.iter().map(|s| s.as_str()).collect::>(),\n );\n // Manually inject debug_assertions based on the profile setting.\n // The cfg query from rustc doesn't include profile settings and would always be true,\n // so we override it with the actual profile setting.\n if unit.profile.debug_assertions {\n cfg_map.insert(\"debug_assertions\", Vec::new());\n }\n for cfg in bcx.target_data.cfg(unit.kind) {\n match *cfg {\n Cfg::Name(ref n) => {\n // Skip debug_assertions from rustc query; we use the profile setting instead\n if n.as_str() == \"debug_assertions\" {\n continue;\n }\n cfg_map.insert(n.as_str(), Vec::new());\n }\n Cfg::KeyPair(ref k, ref v) => {\n let values = cfg_map.entry(k.as_str()).or_default();\n values.push(v.as_str());\n }\n }\n }\n for (k, v) in cfg_map {\n // FIXME: We should handle raw-idents somehow instead of pretending they\n // don't exist here\n let k = format!(\"CARGO_CFG_{}\", super::envify(k));\n cmd.env(&k, v.join(\",\"));\n }\n\n // Also inform the build script of the rustc compiler context.\n if let Some(wrapper) = bcx.rustc().wrapper.as_ref() {\n cmd.env(\"RUSTC_WRAPPER\", wrapper);\n } else {\n cmd.env_remove(\"RUSTC_WRAPPER\");\n }\n cmd.env_remove(\"RUSTC_WORKSPACE_WRAPPER\");\n if build_runner.bcx.ws.is_member(&unit.pkg) {\n if let Some(wrapper) = bcx.rustc().workspace_wrapper.as_ref() {\n cmd.env(\"RUSTC_WORKSPACE_WRAPPER\", wrapper);\n }\n }\n cmd.env(\"CARGO_ENCODED_RUSTFLAGS\", unit.rustflags.join(\"\\x1f\"));\n cmd.env_remove(\"RUSTFLAGS\");\n\n if build_runner.bcx.ws.gctx().extra_verbose() {\n cmd.display_env_vars();\n }\n\n let any_build_script_metadata = bcx.gctx.cli_unstable().any_build_script_metadata;\n\n // Gather the set of native dependencies that this package has along with\n // some other variables to close over.\n //\n // This information will be used at build-time later on to figure out which\n // sorts of variables need to be discovered at that time.\n let lib_deps = dependencies\n .iter()\n .filter_map(|dep| {\n if dep.unit.mode.is_run_custom_build() {\n let dep_metadata = build_runner.get_run_build_script_metadata(&dep.unit);\n\n let dep_name = dep.dep_name.unwrap_or(dep.unit.pkg.name());\n\n Some((\n dep_name,\n dep.unit\n .pkg\n .manifest()\n .links()\n .map(|links| links.to_string()),\n dep.unit.pkg.package_id(),\n dep_metadata,\n ))\n } else {\n None\n }\n })\n .collect::>();\n let library_name = unit.pkg.library().map(|t| t.crate_name());\n let pkg_descr = unit.pkg.to_string();\n let build_script_outputs = Arc::clone(&build_runner.build_script_outputs);\n let id = unit.pkg.package_id();\n let run_files = BuildScriptRunFiles::for_unit(build_runner, unit);\n let host_target_root = build_runner.files().host_dest().map(|v| v.to_path_buf());\n let all = (\n id,\n library_name.clone(),\n pkg_descr.clone(),\n Arc::clone(&build_script_outputs),\n run_files.stdout.clone(),\n script_out_dir.clone(),\n );\n let build_scripts = build_runner.build_scripts.get(unit).cloned();\n let json_messages = bcx.build_config.emit_json();\n let extra_verbose = bcx.gctx.extra_verbose();\n let (prev_output, prev_script_out_dir) = prev_build_output(build_runner, unit);\n let metadata_hash = build_runner.get_run_build_script_metadata(unit);\n\n paths::create_dir_all(&script_dir)?;\n paths::create_dir_all(&script_out_dir)?;\n paths::create_dir_all(&run_files.root)?;\n\n let nightly_features_allowed = build_runner.bcx.gctx.nightly_features_allowed;\n let targets: Vec = unit.pkg.targets().to_vec();\n let msrv = unit.pkg.rust_version().cloned();\n // Need a separate copy for the fresh closure.\n let targets_fresh = targets.clone();\n let msrv_fresh = msrv.clone();\n\n let env_profile_name = unit.profile.name.to_uppercase();\n let built_with_debuginfo = build_runner\n .bcx\n .unit_graph\n .get(unit)\n .and_then(|deps| deps.iter().find(|dep| dep.unit.target == unit.target))\n .map(|dep| dep.unit.profile.debuginfo.is_turned_on())\n .unwrap_or(false);\n\n // Prepare the unit of \"dirty work\" which will actually run the custom build\n // command.\n //\n // Note that this has to do some extra work just before running the command\n // to determine extra environment variables and such.\n let dirty = Work::new(move |state| {\n // Make sure that OUT_DIR exists.\n //\n // If we have an old build directory, then just move it into place,\n // otherwise create it!\n paths::create_dir_all(&script_out_dir)\n .context(\"failed to create script output directory for build command\")?;\n\n // For all our native lib dependencies, pick up their metadata to pass\n // along to this custom build command. We're also careful to augment our\n // dynamic library search path in case the build script depended on any\n // native dynamic libraries.\n {\n let build_script_outputs = build_script_outputs.lock().unwrap();\n for (name, links, dep_id, dep_metadata) in lib_deps {\n let script_output = build_script_outputs.get(dep_metadata).ok_or_else(|| {\n internal(format!(\n \"failed to locate build state for env vars: {}/{}\",\n dep_id, dep_metadata\n ))\n })?;\n let data = &script_output.metadata;\n for (key, value) in data.iter() {\n if let Some(ref links) = links {\n cmd.env(\n &format!(\"DEP_{}_{}\", super::envify(&links), super::envify(key)),\n value,\n );\n }\n if any_build_script_metadata {\n cmd.env(\n &format!(\"CARGO_DEP_{}_{}\", super::envify(&name), super::envify(key)),\n value,\n );\n }\n }\n }\n if let Some(build_scripts) = build_scripts\n && let Some(ref host_target_root) = host_target_root\n {\n super::add_plugin_deps(\n &mut cmd,\n &build_script_outputs,\n &build_scripts,\n host_target_root,\n )?;\n }\n }\n\n // And now finally, run the build command itself!\n state.running(&cmd);\n let timestamp = paths::set_invocation_time(&run_files.root)?;\n let prefix = format!(\"[{} {}] \", id.name(), id.version());\n let mut log_messages_in_case_of_panic = Vec::new();\n let span = tracing::debug_span!(\"build_script\", process = cmd.to_string());\n let output = span.in_scope(|| {\n cmd.exec_with_streaming(\n &mut |stdout| {\n if let Some(error) = stdout.strip_prefix(CARGO_ERROR_SYNTAX) {\n log_messages_in_case_of_panic.push((Severity::Error, error.to_owned()));\n }\n if let Some(warning) = stdout\n .strip_prefix(OLD_CARGO_WARNING_SYNTAX)\n .or(stdout.strip_prefix(NEW_CARGO_WARNING_SYNTAX))\n {\n log_messages_in_case_of_panic.push((Severity::Warning, warning.to_owned()));\n }\n if extra_verbose {\n state.stdout(format!(\"{}{}\", prefix, stdout))?;\n }\n Ok(())\n },\n &mut |stderr| {\n if extra_verbose {\n state.stderr(format!(\"{}{}\", prefix, stderr))?;\n }\n Ok(())\n },\n true,\n )\n .with_context(|| {\n let mut build_error_context =\n format!(\"failed to run custom build command for `{}`\", pkg_descr);\n\n // If we're opting into backtraces, mention that build dependencies' backtraces can\n // be improved by requesting debuginfo to be built, if we're not building with\n // debuginfo already.\n #[expect(clippy::disallowed_methods, reason = \"consistency with rustc\")]\n if let Ok(show_backtraces) = std::env::var(\"RUST_BACKTRACE\") {\n if !built_with_debuginfo && show_backtraces != \"0\" {\n build_error_context.push_str(&format!(\n \"\\n\\\n note: To improve backtraces for build dependencies, set the \\\n CARGO_PROFILE_{env_profile_name}_BUILD_OVERRIDE_DEBUG=true environment \\\n variable to enable debug information generation.\",\n ));\n }\n }\n\n build_error_context\n })\n });\n\n // If the build failed\n if let Err(error) = output {\n insert_log_messages_in_build_outputs(\n build_script_outputs,\n id,\n metadata_hash,\n log_messages_in_case_of_panic,\n );\n return Err(error);\n }\n // ... or it logged any errors\n else if log_messages_in_case_of_panic\n .iter()\n .any(|(severity, _)| *severity == Severity::Error)\n {\n insert_log_messages_in_build_outputs(\n build_script_outputs,\n id,\n metadata_hash,\n log_messages_in_case_of_panic,\n );\n anyhow::bail!(\"build script logged errors\");\n }\n\n let output = output.unwrap();\n\n // After the build command has finished running, we need to be sure to\n // remember all of its output so we can later discover precisely what it\n // was, even if we don't run the build command again (due to freshness).\n //\n // This is also the location where we provide feedback into the build\n // state informing what variables were discovered via our script as\n // well.\n paths::write(&run_files.stdout, &output.stdout)?;\n // This mtime shift allows Cargo to detect if a source file was\n // modified in the middle of the build.\n paths::set_file_time_no_err(run_files.stdout, timestamp);\n paths::write(&run_files.stderr, &output.stderr)?;\n paths::write(&run_files.root_output, paths::path2bytes(&script_out_dir)?)?;\n let parsed_output = BuildOutput::parse(\n &output.stdout,\n library_name,\n &pkg_descr,\n &script_out_dir,\n &script_out_dir,\n nightly_features_allowed,\n &targets,\n &msrv,\n )?;\n\n if json_messages {\n emit_build_output(state, &parsed_output, script_out_dir.as_path(), id)?;\n }\n build_script_outputs\n .lock()\n .unwrap()\n .insert(id, metadata_hash, parsed_output);\n Ok(())\n });\n\n // Now that we've prepared our work-to-do, we need to prepare the fresh work\n // itself to run when we actually end up just discarding what we calculated\n // above.\n let fresh = Work::new(move |state| {\n let (id, library_name, pkg_descr, build_script_outputs, output_file, script_out_dir) = all;\n let output = match prev_output {\n Some(output) => output,\n None => BuildOutput::parse_file(\n &output_file,\n library_name,\n &pkg_descr,\n &prev_script_out_dir,\n &script_out_dir,\n nightly_features_allowed,\n &targets_fresh,\n &msrv_fresh,\n )?,\n };\n\n if json_messages {\n emit_build_output(state, &output, script_out_dir.as_path(), id)?;\n }\n\n build_script_outputs\n .lock()\n .unwrap()\n .insert(id, metadata_hash, output);\n Ok(())\n });\n\n let mut job = fingerprint::prepare_target(build_runner, unit, false)?;\n if job.freshness().is_dirty() {\n job.before(dirty);\n } else {\n job.before(fresh);\n }\n Ok(job)\n}\n\n/// When a build script run fails, store only log messages, and nuke other\n/// outputs, as they are likely broken.\nfn insert_log_messages_in_build_outputs(\n build_script_outputs: Arc>,\n id: PackageId,\n metadata_hash: UnitHash,\n log_messages: Vec,\n) {\n let build_output_with_only_log_messages = BuildOutput {\n log_messages,\n ..BuildOutput::default()\n };\n build_script_outputs.lock().unwrap().insert(\n id,\n metadata_hash,\n build_output_with_only_log_messages,\n );\n}\n\nimpl BuildOutput {\n /// Like [`BuildOutput::parse`] but from a file path.\n pub fn parse_file(\n path: &Path,\n library_name: Option,\n pkg_descr: &str,\n script_out_dir_when_generated: &Path,\n script_out_dir: &Path,\n nightly_features_allowed: bool,\n targets: &[Target],\n msrv: &Option,\n ) -> CargoResult {\n let contents = paths::read_bytes(path)?;\n BuildOutput::parse(\n &contents,\n library_name,\n pkg_descr,\n script_out_dir_when_generated,\n script_out_dir,\n nightly_features_allowed,\n targets,\n msrv,\n )\n }\n\n /// Parses the output instructions of a build script.\n ///\n /// * `pkg_descr` --- for error messages\n /// * `library_name` --- for determining if `RUSTC_BOOTSTRAP` should be allowed\n pub fn parse(\n input: &[u8],\n // Takes String instead of InternedString so passing `unit.pkg.name()` will give a compile error.\n library_name: Option,\n pkg_descr: &str,\n script_out_dir_when_generated: &Path,\n script_out_dir: &Path,\n nightly_features_allowed: bool,\n targets: &[Target],\n msrv: &Option,\n ) -> CargoResult {\n let mut library_paths = Vec::new();\n let mut library_links = Vec::new();\n let mut linker_args = Vec::new();\n let mut cfgs = Vec::new();\n let mut check_cfgs = Vec::new();\n let mut env = Vec::new();\n let mut metadata = Vec::new();\n let mut rerun_if_changed = Vec::new();\n let mut rerun_if_env_changed = Vec::new();\n let mut log_messages = Vec::new();\n let whence = format!(\"build script of `{}`\", pkg_descr);\n // Old syntax:\n // cargo:rustc-flags=VALUE\n // cargo:KEY=VALUE (for other unreserved keys)\n // New syntax:\n // cargo::rustc-flags=VALUE\n // cargo::metadata=KEY=VALUE (for other unreserved keys)\n // Due to backwards compatibility, no new keys can be added to this old format.\n const RESERVED_PREFIXES: &[&str] = &[\n \"rustc-flags=\",\n \"rustc-link-lib=\",\n \"rustc-link-search=\",\n \"rustc-link-arg-cdylib=\",\n \"rustc-cdylib-link-arg=\",\n \"rustc-link-arg-bins=\",\n \"rustc-link-arg-bin=\",\n \"rustc-link-arg-tests=\",\n \"rustc-link-arg-benches=\",\n \"rustc-link-arg-examples=\",\n \"rustc-link-arg=\",\n \"rustc-cfg=\",\n \"rustc-check-cfg=\",\n \"rustc-env=\",\n \"warning=\",\n \"rerun-if-changed=\",\n \"rerun-if-env-changed=\",\n ];\n const DOCS_LINK_SUGGESTION: &str = \"See https://doc.rust-lang.org/cargo/reference/build-scripts.html#outputs-of-the-build-script \\\n for more information about build script outputs.\";\n\n fn has_reserved_prefix(flag: &str) -> bool {\n RESERVED_PREFIXES\n .iter()\n .any(|reserved_prefix| flag.starts_with(reserved_prefix))\n }\n\n fn check_minimum_supported_rust_version_for_new_syntax(\n pkg_descr: &str,\n msrv: &Option,\n flag: &str,\n ) -> CargoResult<()> {\n if let Some(msrv) = msrv {\n let new_syntax_added_in = RustVersion::new(1, 77, 0);\n if !new_syntax_added_in.is_compatible_with(&msrv.to_partial()) {\n let old_syntax_suggestion = if has_reserved_prefix(flag) {\n format!(\n \"Switch to the old `cargo:{flag}` syntax (note the single colon).\\n\"\n )\n } else if flag.starts_with(\"metadata=\") {\n let old_format_flag = flag.strip_prefix(\"metadata=\").unwrap();\n format!(\n \"Switch to the old `cargo:{old_format_flag}` syntax instead of `cargo::{flag}` (note the single colon).\\n\"\n )\n } else {\n String::new()\n };\n\n bail!(\n \"the `cargo::` syntax for build script output instructions was added in \\\n Rust 1.77.0, but the minimum supported Rust version of `{pkg_descr}` is {msrv}.\\n\\\n {old_syntax_suggestion}\\\n {DOCS_LINK_SUGGESTION}\"\n );\n }\n }\n\n Ok(())\n }\n\n fn parse_directive<'a>(\n whence: &str,\n line: &str,\n data: &'a str,\n old_syntax: bool,\n ) -> CargoResult<(&'a str, &'a str)> {\n let mut iter = data.splitn(2, \"=\");\n let key = iter.next();\n let value = iter.next();\n match (key, value) {\n (Some(a), Some(b)) => Ok((a, b.trim_end())),\n _ => bail!(\n \"invalid output in {whence}: `{line}`\\n\\\n Expected a line with `{syntax}KEY=VALUE` with an `=` character, \\\n but none was found.\\n\\\n {DOCS_LINK_SUGGESTION}\",\n syntax = if old_syntax { \"cargo:\" } else { \"cargo::\" },\n ),\n }\n }\n\n fn parse_metadata<'a>(\n whence: &str,\n line: &str,\n data: &'a str,\n old_syntax: bool,\n ) -> CargoResult<(&'a str, &'a str)> {\n let mut iter = data.splitn(2, \"=\");\n let key = iter.next();\n let value = iter.next();\n match (key, value) {\n (Some(a), Some(b)) => Ok((a, b.trim_end())),\n _ => bail!(\n \"invalid output in {whence}: `{line}`\\n\\\n Expected a line with `{syntax}KEY=VALUE` with an `=` character, \\\n but none was found.\\n\\\n {DOCS_LINK_SUGGESTION}\",\n syntax = if old_syntax {\n \"cargo:\"\n } else {\n \"cargo::metadata=\"\n },\n ),\n }\n }\n\n for line in input.split(|b| *b == b'\\n') {\n let line = match str::from_utf8(line) {\n Ok(line) => line.trim(),\n Err(..) => continue,\n };\n let mut old_syntax = false;\n let (key, value) = if let Some(data) = line.strip_prefix(\"cargo::\") {\n check_minimum_supported_rust_version_for_new_syntax(pkg_descr, msrv, data)?;\n // For instance, `cargo::rustc-flags=foo` or `cargo::metadata=foo=bar`.\n parse_directive(whence.as_str(), line, data, old_syntax)?\n } else if let Some(data) = line.strip_prefix(\"cargo:\") {\n old_syntax = true;\n // For instance, `cargo:rustc-flags=foo`.\n if has_reserved_prefix(data) {\n parse_directive(whence.as_str(), line, data, old_syntax)?\n } else {\n // For instance, `cargo:foo=bar`.\n (\"metadata\", data)\n }\n } else {\n // Skip this line since it doesn't start with \"cargo:\" or \"cargo::\".\n continue;\n };\n // This will rewrite paths if the target directory has been moved.\n let value = value.replace(\n script_out_dir_when_generated.to_str().unwrap(),\n script_out_dir.to_str().unwrap(),\n );\n\n let syntax_prefix = if old_syntax { \"cargo:\" } else { \"cargo::\" };\n macro_rules! check_and_add_target {\n ($target_kind: expr, $is_target_kind: expr, $link_type: expr) => {\n if !targets.iter().any(|target| $is_target_kind(target)) {\n bail!(\n \"invalid instruction `{}{}` from {}\\n\\\n The package {} does not have a {} target.\",\n syntax_prefix,\n key,\n whence,\n pkg_descr,\n $target_kind\n );\n }\n linker_args.push(($link_type, value));\n };\n }\n\n // Keep in sync with TargetConfig::parse_links_overrides.\n match key {\n \"rustc-flags\" => {\n let (paths, links) = BuildOutput::parse_rustc_flags(&value, &whence)?;\n library_links.extend(links.into_iter());\n library_paths.extend(\n paths\n .into_iter()\n .map(|p| LibraryPath::new(p, script_out_dir)),\n );\n }\n \"rustc-link-lib\" => library_links.push(value.to_string()),\n \"rustc-link-search\" => {\n library_paths.push(LibraryPath::new(PathBuf::from(value), script_out_dir))\n }\n \"rustc-link-arg-cdylib\" | \"rustc-cdylib-link-arg\" => {\n if !targets.iter().any(|target| target.is_cdylib()) {\n log_messages.push((\n Severity::Warning,\n format!(\n \"{}{} was specified in the build script of {}, \\\n but that package does not contain a cdylib target\\n\\\n \\n\\\n Allowing this was an unintended change in the 1.50 \\\n release, and may become an error in the future. \\\n For more information, see \\\n .\",\n syntax_prefix, key, pkg_descr\n ),\n ));\n }\n linker_args.push((LinkArgTarget::Cdylib, value))\n }\n \"rustc-link-arg-bins\" => {\n check_and_add_target!(\"bin\", Target::is_bin, LinkArgTarget::Bin);\n }\n \"rustc-link-arg-bin\" => {\n let (bin_name, arg) = value.split_once('=').ok_or_else(|| {\n anyhow::format_err!(\n \"invalid instruction `{}{}={}` from {}\\n\\\n The instruction should have the form {}{}=BIN=ARG\",\n syntax_prefix,\n key,\n value,\n whence,\n syntax_prefix,\n key\n )\n })?;\n if !targets\n .iter()\n .any(|target| target.is_bin() && target.name() == bin_name)\n {\n bail!(\n \"invalid instruction `{}{}` from {}\\n\\\n The package {} does not have a bin target with the name `{}`.\",\n syntax_prefix,\n key,\n whence,\n pkg_descr,\n bin_name\n );\n }\n linker_args.push((\n LinkArgTarget::SingleBin(bin_name.to_owned()),\n arg.to_string(),\n ));\n }\n \"rustc-link-arg-tests\" => {\n check_and_add_target!(\"test\", Target::is_test, LinkArgTarget::Test);\n }\n \"rustc-link-arg-benches\" => {\n check_and_add_target!(\"benchmark\", Target::is_bench, LinkArgTarget::Bench);\n }\n \"rustc-link-arg-examples\" => {\n check_and_add_target!(\"example\", Target::is_example, LinkArgTarget::Example);\n }\n \"rustc-link-arg\" => {\n linker_args.push((LinkArgTarget::All, value));\n }\n \"rustc-cfg\" => cfgs.push(value.to_string()),\n \"rustc-check-cfg\" => check_cfgs.push(value.to_string()),\n \"rustc-env\" => {\n let (key, val) = BuildOutput::parse_rustc_env(&value, &whence)?;\n // Build scripts aren't allowed to set RUSTC_BOOTSTRAP.\n // See https://github.com/rust-lang/cargo/issues/7088.\n if key == \"RUSTC_BOOTSTRAP\" {\n // If RUSTC_BOOTSTRAP is already set, the user of Cargo knows about\n // bootstrap and still wants to override the channel. Give them a way to do\n // so, but still emit a warning that the current crate shouldn't be trying\n // to set RUSTC_BOOTSTRAP.\n // If this is a nightly build, setting RUSTC_BOOTSTRAP wouldn't affect the\n // behavior, so still only give a warning.\n // NOTE: cargo only allows nightly features on RUSTC_BOOTSTRAP=1, but we\n // want setting any value of RUSTC_BOOTSTRAP to downgrade this to a warning\n // (so that `RUSTC_BOOTSTRAP=library_name` will work)\n let rustc_bootstrap_allows = |name: Option<&str>| {\n let name = match name {\n // as of 2021, no binaries on crates.io use RUSTC_BOOTSTRAP, so\n // fine-grained opt-outs aren't needed. end-users can always use\n // RUSTC_BOOTSTRAP=1 from the top-level if it's really a problem.\n None => return false,\n Some(n) => n,\n };\n #[expect(\n clippy::disallowed_methods,\n reason = \"consistency with rustc, not specified behavior\"\n )]\n std::env::var(\"RUSTC_BOOTSTRAP\")\n .map_or(false, |var| var.split(',').any(|s| s == name))\n };\n if nightly_features_allowed\n || rustc_bootstrap_allows(library_name.as_deref())\n {\n log_messages.push((Severity::Warning, format!(\"cannot set `RUSTC_BOOTSTRAP={}` from {}.\\n\\\n note: crates cannot set `RUSTC_BOOTSTRAP` themselves, as doing so would subvert the stability guarantees of Rust for your project.\",\n val, whence\n )));\n } else {\n // Setting RUSTC_BOOTSTRAP would change the behavior of the crate.\n // Abort with an error.\n bail!(\n \"cannot set `RUSTC_BOOTSTRAP={}` from {}.\\n\\\n note: crates cannot set `RUSTC_BOOTSTRAP` themselves, as doing so would subvert the stability guarantees of Rust for your project.\\n\\\n help: If you're sure you want to do this in your project, set the environment variable `RUSTC_BOOTSTRAP={}` before running cargo instead.\",\n val,\n whence,\n library_name.as_deref().unwrap_or(\"1\"),\n );\n }\n } else {\n env.push((key, val));\n }\n }\n \"error\" => log_messages.push((Severity::Error, value.to_string())),\n \"warning\" => log_messages.push((Severity::Warning, value.to_string())),\n \"rerun-if-changed\" => rerun_if_changed.push(PathBuf::from(value)),\n \"rerun-if-env-changed\" => rerun_if_env_changed.push(value.to_string()),\n \"metadata\" => {\n let (key, value) = parse_metadata(whence.as_str(), line, &value, old_syntax)?;\n metadata.push((key.to_owned(), value.to_owned()));\n }\n _ => bail!(\n \"invalid output in {whence}: `{line}`\\n\\\n Unknown key: `{key}`.\\n\\\n {DOCS_LINK_SUGGESTION}\",\n ),\n }\n }\n\n Ok(BuildOutput {\n library_paths,\n library_links,\n linker_args,\n cfgs,\n check_cfgs,\n env,\n metadata,\n rerun_if_changed,\n rerun_if_env_changed,\n log_messages,\n })\n }\n\n /// Parses [`cargo::rustc-flags`] instruction.\n ///\n /// [`cargo::rustc-flags`]: https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html#cargorustc-flagsflags\n pub fn parse_rustc_flags(\n value: &str,\n whence: &str,\n ) -> CargoResult<(Vec, Vec)> {\n let value = value.trim();\n let mut flags_iter = value\n .split(|c: char| c.is_whitespace())\n .filter(|w| w.chars().any(|c| !c.is_whitespace()));\n let (mut library_paths, mut library_links) = (Vec::new(), Vec::new());\n\n while let Some(flag) = flags_iter.next() {\n if flag.starts_with(\"-l\") || flag.starts_with(\"-L\") {\n // Check if this flag has no space before the value as is\n // common with tools like pkg-config\n // e.g. -L/some/dir/local/lib or -licui18n\n let (flag, mut value) = flag.split_at(2);\n if value.is_empty() {\n value = match flags_iter.next() {\n Some(v) => v,\n None => bail! {\n \"flag in rustc-flags has no value in {}: {}\",\n whence,\n value\n },\n }\n }\n\n match flag {\n \"-l\" => library_links.push(value.to_string()),\n \"-L\" => library_paths.push(PathBuf::from(value)),\n\n // This was already checked above\n _ => unreachable!(),\n };\n } else {\n bail!(\n \"only `-l` and `-L` flags are allowed in {}: `{}`\",\n whence,\n value\n )\n }\n }\n Ok((library_paths, library_links))\n }\n\n /// Parses [`cargo::rustc-env`] instruction.\n ///\n /// [`cargo::rustc-env`]: https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html#rustc-env\n pub fn parse_rustc_env(value: &str, whence: &str) -> CargoResult<(String, String)> {\n match value.split_once('=') {\n Some((n, v)) => Ok((n.to_owned(), v.to_owned())),\n _ => bail!(\"Variable rustc-env has no value in {whence}: {value}\"),\n }\n }\n}\n\n/// Prepares the Rust script for the unstable feature [metabuild].\n///\n/// [metabuild]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#metabuild\nfn prepare_metabuild(\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n deps: &[String],\n) -> CargoResult<()> {\n let mut output = Vec::new();\n let available_deps = build_runner.unit_deps(unit);\n // Filter out optional dependencies, and look up the actual lib name.\n let meta_deps: Vec<_> = deps\n .iter()\n .filter_map(|name| {\n available_deps\n .iter()\n .find(|d| d.unit.pkg.name().as_str() == name.as_str())\n .map(|d| d.unit.target.crate_name())\n })\n .collect();\n output.push(\"fn main() {\\n\".to_string());\n for dep in &meta_deps {\n output.push(format!(\" {}::metabuild();\\n\", dep));\n }\n output.push(\"}\\n\".to_string());\n let output = output.join(\"\");\n let path = unit\n .pkg\n .manifest()\n .metabuild_path(build_runner.bcx.ws.build_dir());\n paths::create_dir_all(path.parent().unwrap())?;\n paths::write_if_changed(path, &output)?;\n Ok(())\n}\n\nimpl BuildDeps {\n /// Creates a build script dependency information from a previous\n /// build script output path and the content.\n pub fn new(output_file: &Path, output: Option<&BuildOutput>) -> BuildDeps {\n BuildDeps {\n build_script_output: output_file.to_path_buf(),\n rerun_if_changed: output\n .map(|p| &p.rerun_if_changed)\n .cloned()\n .unwrap_or_default(),\n rerun_if_env_changed: output\n .map(|p| &p.rerun_if_env_changed)\n .cloned()\n .unwrap_or_default(),\n }\n }\n}\n\n/// Computes several maps in [`BuildRunner`].\n///\n/// - [`build_scripts`]: A map that tracks which build scripts each package\n/// depends on.\n/// - [`build_explicit_deps`]: Dependency statements emitted by build scripts\n/// from a previous run.\n/// - [`build_script_outputs`]: Pre-populates this with any overridden build\n/// scripts.\n///\n/// The important one here is [`build_scripts`], which for each `(package,\n/// metadata)` stores a [`BuildScripts`] object which contains a list of\n/// dependencies with build scripts that the unit should consider when linking.\n/// For example this lists all dependencies' `-L` flags which need to be\n/// propagated transitively.\n///\n/// The given set of units to this function is the initial set of\n/// targets/profiles which are being built.\n///\n/// [`build_scripts`]: BuildRunner::build_scripts\n/// [`build_explicit_deps`]: BuildRunner::build_explicit_deps\n/// [`build_script_outputs`]: BuildRunner::build_script_outputs\npub fn build_map(build_runner: &mut BuildRunner<'_, '_>) -> CargoResult<()> {\n let mut ret = HashMap::new();\n for unit in &build_runner.bcx.roots {\n build(&mut ret, build_runner, unit)?;\n }\n build_runner\n .build_scripts\n .extend(ret.into_iter().map(|(k, v)| (k, Arc::new(v))));\n return Ok(());\n\n // Recursive function to build up the map we're constructing. This function\n // memoizes all of its return values as it goes along.\n fn build<'a>(\n out: &'a mut HashMap,\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n ) -> CargoResult<&'a BuildScripts> {\n // Do a quick pre-flight check to see if we've already calculated the\n // set of dependencies.\n if out.contains_key(unit) {\n return Ok(&out[unit]);\n }\n\n // If there is a build script override, pre-fill the build output.\n if unit.mode.is_run_custom_build() {\n if let Some(links) = unit.pkg.manifest().links() {\n if let Some(output) = unit.links_overrides.get(links) {\n let metadata = build_runner.get_run_build_script_metadata(unit);\n build_runner.build_script_outputs.lock().unwrap().insert(\n unit.pkg.package_id(),\n metadata,\n output.clone(),\n );\n }\n }\n }\n\n let mut ret = BuildScripts::default();\n\n // If a package has a build script, add itself as something to inspect for linking.\n if !unit.target.is_custom_build() && unit.pkg.has_custom_build() {\n let script_metas = build_runner\n .find_build_script_metadatas(unit)\n .expect(\"has_custom_build should have RunCustomBuild\");\n for script_meta in script_metas {\n add_to_link(&mut ret, unit.pkg.package_id(), script_meta);\n }\n }\n\n if unit.mode.is_run_custom_build() {\n parse_previous_explicit_deps(build_runner, unit);\n }\n\n // We want to invoke the compiler deterministically to be cache-friendly\n // to rustc invocation caching schemes, so be sure to generate the same\n // set of build script dependency orderings via sorting the targets that\n // come out of the `Context`.\n let mut dependencies: Vec = build_runner\n .unit_deps(unit)\n .iter()\n .map(|d| d.unit.clone())\n .collect();\n dependencies.sort_by_key(|u| u.pkg.package_id());\n\n for dep_unit in dependencies.iter() {\n let dep_scripts = build(out, build_runner, dep_unit)?;\n\n if dep_unit.target.for_host() {\n ret.plugins.extend(dep_scripts.to_link.iter().cloned());\n } else if dep_unit.target.is_linkable() {\n for &(pkg, metadata) in dep_scripts.to_link.iter() {\n add_to_link(&mut ret, pkg, metadata);\n }\n }\n }\n\n match out.entry(unit.clone()) {\n Entry::Vacant(entry) => Ok(entry.insert(ret)),\n Entry::Occupied(_) => panic!(\"cyclic dependencies in `build_map`\"),\n }\n }\n\n // When adding an entry to 'to_link' we only actually push it on if the\n // script hasn't seen it yet (e.g., we don't push on duplicates).\n fn add_to_link(scripts: &mut BuildScripts, pkg: PackageId, metadata: UnitHash) {\n if scripts.seen_to_link.insert((pkg, metadata)) {\n scripts.to_link.push((pkg, metadata));\n }\n }\n\n /// Load any dependency declarations from a previous build script run.\n fn parse_previous_explicit_deps(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) {\n let run_files = BuildScriptRunFiles::for_unit(build_runner, unit);\n let (prev_output, _) = prev_build_output(build_runner, unit);\n let deps = BuildDeps::new(&run_files.stdout, prev_output.as_ref());\n build_runner.build_explicit_deps.insert(unit.clone(), deps);\n }\n}\n\n/// Returns the previous parsed `BuildOutput`, if any, from a previous\n/// execution.\n///\n/// Also returns the directory containing the output, typically used later in\n/// processing.\nfn prev_build_output(\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n) -> (Option, PathBuf) {\n let script_out_dir = if build_runner.bcx.gctx.cli_unstable().build_dir_new_layout {\n build_runner.files().out_dir_new_layout(unit)\n } else {\n build_runner.files().build_script_out_dir(unit)\n };\n let run_files = BuildScriptRunFiles::for_unit(build_runner, unit);\n\n let prev_script_out_dir = paths::read_bytes(&run_files.root_output)\n .and_then(|bytes| paths::bytes2path(&bytes))\n .unwrap_or_else(|_| script_out_dir.clone());\n\n (\n BuildOutput::parse_file(\n &run_files.stdout,\n unit.pkg.library().map(|t| t.crate_name()),\n &unit.pkg.to_string(),\n &prev_script_out_dir,\n &script_out_dir,\n build_runner.bcx.gctx.nightly_features_allowed,\n unit.pkg.targets(),\n &unit.pkg.rust_version().cloned(),\n )\n .ok(),\n prev_script_out_dir,\n )\n}\n\nimpl BuildScriptOutputs {\n /// Inserts a new entry into the map.\n fn insert(&mut self, pkg_id: PackageId, metadata: UnitHash, parsed_output: BuildOutput) {\n match self.outputs.entry(metadata) {\n Entry::Vacant(entry) => {\n entry.insert(parsed_output);\n }\n Entry::Occupied(entry) => panic!(\n \"build script output collision for {}/{}\\n\\\n old={:?}\\nnew={:?}\",\n pkg_id,\n metadata,\n entry.get(),\n parsed_output\n ),\n }\n }\n\n /// Returns `true` if the given key already exists.\n fn contains_key(&self, metadata: UnitHash) -> bool {\n self.outputs.contains_key(&metadata)\n }\n\n /// Gets the build output for the given key.\n pub fn get(&self, meta: UnitHash) -> Option<&BuildOutput> {\n self.outputs.get(&meta)\n }\n\n /// Returns an iterator over all entries.\n pub fn iter(&self) -> impl Iterator {\n self.outputs.iter()\n }\n}\n\n/// Files with information about a running build script.\nstruct BuildScriptRunFiles {\n /// The directory containing files related to running a build script.\n root: PathBuf,\n /// The stdout produced by the build script\n stdout: PathBuf,\n /// The stderr produced by the build script\n stderr: PathBuf,\n /// A file that contains the path to the `out` dir of the build script.\n /// This is used for detect if the directory was moved since the previous run.\n root_output: PathBuf,\n}\n\nimpl BuildScriptRunFiles {\n pub fn for_unit(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> Self {\n let root = build_runner.files().build_script_run_dir(unit);\n let stdout = if build_runner.bcx.gctx.cli_unstable().build_dir_new_layout {\n root.join(\"stdout\")\n } else {\n root.join(\"output\")\n };\n let stderr = root.join(\"stderr\");\n let root_output = root.join(\"root-output\");\n Self {\n root,\n stdout,\n stderr,\n root_output,\n }\n }\n}\n" }, { "path": "src/cargo/core/compiler/fingerprint/dep_info.rs", "content": "//! Types and functions managing dep-info files.\n//! For more, see [the documentation] in the `fingerprint` module.\n//!\n//! [the documentation]: crate::core::compiler::fingerprint#dep-info-files\n\nuse std::collections::HashMap;\nuse std::ffi::OsString;\nuse std::fmt;\nuse std::io;\nuse std::io::Read;\nuse std::path::Path;\nuse std::path::PathBuf;\nuse std::str;\nuse std::str::FromStr;\nuse std::sync::Arc;\n\nuse anyhow::bail;\nuse cargo_util::ProcessBuilder;\nuse cargo_util::Sha256;\nuse cargo_util::paths;\nuse serde::Serialize;\n\nuse crate::CARGO_ENV;\nuse crate::CargoResult;\nuse crate::core::manifest::ManifestMetadata;\n\n/// The current format version of [`EncodedDepInfo`].\nconst CURRENT_ENCODED_DEP_INFO_VERSION: u8 = 1;\n\n/// The representation of the `.d` dep-info file generated by rustc\n#[derive(Default)]\npub struct RustcDepInfo {\n /// The list of files that the main target in the dep-info file depends on.\n ///\n /// The optional checksums are parsed from the special `# checksum:...` comments.\n pub files: HashMap>,\n /// The list of environment variables we found that the rustc compilation\n /// depends on.\n ///\n /// The first element of the pair is the name of the env var and the second\n /// item is the value. `Some` means that the env var was set, and `None`\n /// means that the env var wasn't actually set and the compilation depends\n /// on it not being set.\n ///\n /// These are from the special `# env-var:...` comments.\n pub env: Vec<(String, Option)>,\n}\n\n/// Tells the associated path in [`EncodedDepInfo::files`] is relative to package root,\n/// target root, or absolute.\n#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)]\npub enum DepInfoPathType {\n /// src/, e.g. src/lib.rs\n PackageRootRelative,\n /// {build-dir}/debug/deps/lib...\n /// or an absolute path /.../sysroot/...\n BuildRootRelative,\n}\n\n/// Same as [`RustcDepInfo`] except avoids absolute paths as much as possible to\n/// allow moving around the target directory.\n///\n/// This is also stored in an optimized format to make parsing it fast because\n/// Cargo will read it for crates on all future compilations.\n///\n/// Currently the format looks like:\n///\n/// ```text\n/// +--------+---------+------------+------------+---------------+---------------+\n/// | marker | version | # of files | file paths | # of env vars | env var pairs |\n/// +--------+---------+------------+------------+---------------+---------------+\n/// ```\n///\n/// Each field represents\n///\n/// * _Marker_ --- A magic marker to ensure that older Cargoes, which only\n/// recognize format v0 (prior to checksum support in [`f4ca7390`]), do not\n/// proceed with parsing newer formats. Since [`EncodedDepInfo`] is merely\n/// an optimization, and to avoid adding complexity, Cargo recognizes only\n/// one version of [`CURRENT_ENCODED_DEP_INFO_VERSION`].\n/// The current layout looks like this\n/// ```text\n/// +----------------------------+\n/// | [0x01 0x00 0x00 0x00 0xff] |\n/// +----------------------------+\n/// ```\n/// These bytes will be interpreted as \"one file tracked and an invalid\n/// [`DepInfoPathType`] variant with 255\" by older Cargoes, causing them to\n/// stop parsing. This could prevent problematic parsing as noted in\n/// rust-lang/cargo#14712.\n/// * _Version_ --- The current format version.\n/// * _Number of files/envs_ --- A `u32` representing the number of things.\n/// * _File paths_ --- Zero or more paths of files the dep-info file depends on.\n/// Each path is encoded as the following:\n///\n/// ```text\n/// +-----------+-------------+------------+---------------+-----------+-------+\n/// | path type | len of path | path bytes | cksum exists? | file size | cksum |\n/// +-----------+-------------+------------+---------------+-----------+-------+\n/// ```\n/// * _Env var pairs_ --- Zero or more env vars the dep-info file depends on.\n/// Each env key-value pair is encoded as the following:\n/// ```text\n/// +------------+-----------+---------------+--------------+-------------+\n/// | len of key | key bytes | value exists? | len of value | value bytes |\n/// +------------+-----------+---------------+--------------+-------------+\n/// ```\n///\n/// [`f4ca7390`]: https://github.com/rust-lang/cargo/commit/f4ca739073185ea5e1148ff100bb4a06d3bf721d\n#[derive(Default, Debug, PartialEq, Eq)]\npub struct EncodedDepInfo {\n pub files: Vec<(DepInfoPathType, PathBuf, Option<(u64, String)>)>,\n pub env: Vec<(String, Option)>,\n}\n\nimpl EncodedDepInfo {\n pub fn parse(mut bytes: &[u8]) -> Option {\n let bytes = &mut bytes;\n read_magic_marker(bytes)?;\n let version = read_u8(bytes)?;\n if version != CURRENT_ENCODED_DEP_INFO_VERSION {\n return None;\n }\n\n let nfiles = read_usize(bytes)?;\n let mut files = Vec::with_capacity(nfiles);\n for _ in 0..nfiles {\n let ty = match read_u8(bytes)? {\n 0 => DepInfoPathType::PackageRootRelative,\n 1 => DepInfoPathType::BuildRootRelative,\n _ => return None,\n };\n let path_bytes = read_bytes(bytes)?;\n let path = paths::bytes2path(path_bytes).ok()?;\n let has_checksum = read_bool(bytes)?;\n let checksum_info = has_checksum\n .then(|| {\n let file_len = read_u64(bytes);\n let checksum_string = read_bytes(bytes)\n .map(Vec::from)\n .and_then(|v| String::from_utf8(v).ok());\n file_len.zip(checksum_string)\n })\n .flatten();\n files.push((ty, path, checksum_info));\n }\n\n let nenv = read_usize(bytes)?;\n let mut env = Vec::with_capacity(nenv);\n for _ in 0..nenv {\n let key = str::from_utf8(read_bytes(bytes)?).ok()?.to_string();\n let val = match read_u8(bytes)? {\n 0 => None,\n 1 => Some(str::from_utf8(read_bytes(bytes)?).ok()?.to_string()),\n _ => return None,\n };\n env.push((key, val));\n }\n return Some(EncodedDepInfo { files, env });\n\n /// See [`EncodedDepInfo`] for why a magic marker exists.\n fn read_magic_marker(bytes: &mut &[u8]) -> Option<()> {\n let _size = read_usize(bytes)?;\n let path_type = read_u8(bytes)?;\n if path_type != u8::MAX {\n // Old depinfo. Give up parsing it.\n None\n } else {\n Some(())\n }\n }\n\n fn read_usize(bytes: &mut &[u8]) -> Option {\n let ret = bytes.get(..4)?;\n *bytes = &bytes[4..];\n Some(u32::from_le_bytes(ret.try_into().unwrap()) as usize)\n }\n\n fn read_u64(bytes: &mut &[u8]) -> Option {\n let ret = bytes.get(..8)?;\n *bytes = &bytes[8..];\n Some(u64::from_le_bytes(ret.try_into().unwrap()))\n }\n\n fn read_bool(bytes: &mut &[u8]) -> Option {\n read_u8(bytes).map(|b| b != 0)\n }\n\n fn read_u8(bytes: &mut &[u8]) -> Option {\n let ret = *bytes.get(0)?;\n *bytes = &bytes[1..];\n Some(ret)\n }\n\n fn read_bytes<'a>(bytes: &mut &'a [u8]) -> Option<&'a [u8]> {\n let n = read_usize(bytes)? as usize;\n let ret = bytes.get(..n)?;\n *bytes = &bytes[n..];\n Some(ret)\n }\n }\n\n pub fn serialize(&self) -> CargoResult> {\n let mut ret = Vec::new();\n let dst = &mut ret;\n\n write_magic_marker(dst);\n dst.push(CURRENT_ENCODED_DEP_INFO_VERSION);\n\n write_usize(dst, self.files.len());\n for (ty, file, checksum_info) in self.files.iter() {\n match ty {\n DepInfoPathType::PackageRootRelative => dst.push(0),\n DepInfoPathType::BuildRootRelative => dst.push(1),\n }\n write_bytes(dst, paths::path2bytes(file)?);\n write_bool(dst, checksum_info.is_some());\n if let Some((len, checksum)) = checksum_info {\n write_u64(dst, *len);\n write_bytes(dst, checksum);\n }\n }\n\n write_usize(dst, self.env.len());\n for (key, val) in self.env.iter() {\n write_bytes(dst, key);\n match val {\n None => dst.push(0),\n Some(val) => {\n dst.push(1);\n write_bytes(dst, val);\n }\n }\n }\n return Ok(ret);\n\n /// See [`EncodedDepInfo`] for why a magic marker exists.\n ///\n /// There is an assumption that there is always at least a file.\n fn write_magic_marker(dst: &mut Vec) {\n write_usize(dst, 1);\n dst.push(u8::MAX);\n }\n\n fn write_bytes(dst: &mut Vec, val: impl AsRef<[u8]>) {\n let val = val.as_ref();\n write_usize(dst, val.len());\n dst.extend_from_slice(val);\n }\n\n fn write_usize(dst: &mut Vec, val: usize) {\n dst.extend(&u32::to_le_bytes(val as u32));\n }\n\n fn write_u64(dst: &mut Vec, val: u64) {\n dst.extend(&u64::to_le_bytes(val));\n }\n\n fn write_bool(dst: &mut Vec, val: bool) {\n dst.push(u8::from(val));\n }\n }\n}\n\n/// Parses the dep-info file coming out of rustc into a Cargo-specific format.\n///\n/// This function will parse `rustc_dep_info` as a makefile-style dep info to\n/// learn about the all files which a crate depends on. This is then\n/// re-serialized into the `cargo_dep_info` path in a Cargo-specific format.\n///\n/// The `pkg_root` argument here is the absolute path to the directory\n/// containing `Cargo.toml` for this crate that was compiled. The paths listed\n/// in the rustc dep-info file may or may not be absolute but we'll want to\n/// consider all of them relative to the `root` specified.\n///\n/// The `rustc_cwd` argument is the absolute path to the cwd of the compiler\n/// when it was invoked.\n///\n/// If the `allow_package` argument is true, then package-relative paths are\n/// included. If it is false, then package-relative paths are skipped and\n/// ignored (typically used for registry or git dependencies where we assume\n/// the source never changes, and we don't want the cost of running `stat` on\n/// all those files). See the module-level docs for the note about\n/// `-Zbinary-dep-depinfo` for more details on why this is done.\n///\n/// The serialized Cargo format will contain a list of files, all of which are\n/// relative if they're under `root`. or absolute if they're elsewhere.\n///\n/// The `env_config` argument is a set of environment variables that are\n/// defined in `[env]` table of the `config.toml`.\npub fn translate_dep_info(\n rustc_dep_info: &Path,\n cargo_dep_info: &Path,\n rustc_cwd: &Path,\n pkg_root: &Path,\n build_root: &Path,\n rustc_cmd: &ProcessBuilder,\n allow_package: bool,\n env_config: &Arc>,\n) -> CargoResult<()> {\n let depinfo = parse_rustc_dep_info(rustc_dep_info)?;\n\n let build_root = crate::util::try_canonicalize(build_root)?;\n let pkg_root = crate::util::try_canonicalize(pkg_root)?;\n let mut on_disk_info = EncodedDepInfo::default();\n on_disk_info.env = depinfo.env;\n\n // This is a bit of a tricky statement, but here we're *removing* the\n // dependency on environment variables that were defined specifically for\n // the command itself. Environment variables returned by `get_envs` includes\n // environment variables like:\n //\n // * `OUT_DIR` if applicable\n // * env vars added by a build script, if any\n //\n // The general idea here is that the dep info file tells us what, when\n // changed, should cause us to rebuild the crate. These environment\n // variables are synthesized by Cargo and/or the build script, and the\n // intention is that their values are tracked elsewhere for whether the\n // crate needs to be rebuilt.\n //\n // For example a build script says when it needs to be rerun and otherwise\n // it's assumed to produce the same output, so we're guaranteed that env\n // vars defined by the build script will always be the same unless the build\n // script itself reruns, in which case the crate will rerun anyway.\n //\n // For things like `OUT_DIR` it's a bit sketchy for now. Most of the time\n // that's used for code generation but this is technically buggy where if\n // you write a binary that does `println!(\"{}\", env!(\"OUT_DIR\"))` we won't\n // recompile that if you move the target directory. Hopefully that's not too\n // bad of an issue for now...\n //\n // This also includes `CARGO` since if the code is explicitly wanting to\n // know that path, it should be rebuilt if it changes. The CARGO path is\n // not tracked elsewhere in the fingerprint.\n //\n // For cargo#13280, We trace env vars that are defined in the `[env]` config table.\n on_disk_info.env.retain(|(key, _)| {\n ManifestMetadata::should_track(key)\n || env_config.contains_key(key)\n || !rustc_cmd.get_envs().contains_key(key)\n || key == CARGO_ENV\n });\n\n let serialize_path = |file| {\n // The path may be absolute or relative, canonical or not. Make sure\n // it is canonicalized so we are comparing the same kinds of paths.\n let abs_file = rustc_cwd.join(file);\n // If canonicalization fails, just use the abs path. There is currently\n // a bug where --remap-path-prefix is affecting .d files, causing them\n // to point to non-existent paths.\n let canon_file =\n crate::util::try_canonicalize(&abs_file).unwrap_or_else(|_| abs_file.clone());\n\n let (ty, path) = if let Ok(stripped) = canon_file.strip_prefix(&build_root) {\n (DepInfoPathType::BuildRootRelative, stripped)\n } else if let Ok(stripped) = canon_file.strip_prefix(&pkg_root) {\n if !allow_package {\n return None;\n }\n (DepInfoPathType::PackageRootRelative, stripped)\n } else {\n // It's definitely not target root relative, but this is an absolute path (since it was\n // joined to rustc_cwd) and as such re-joining it later to the target root will have no\n // effect.\n (DepInfoPathType::BuildRootRelative, &*abs_file)\n };\n Some((ty, path.to_owned()))\n };\n\n for (file, checksum_info) in depinfo.files {\n let Some((path_type, path)) = serialize_path(file) else {\n continue;\n };\n on_disk_info.files.push((\n path_type,\n path,\n checksum_info.map(|(len, checksum)| (len, checksum.to_string())),\n ));\n }\n paths::write(cargo_dep_info, on_disk_info.serialize()?)?;\n Ok(())\n}\n\n/// Parse the `.d` dep-info file generated by rustc.\npub fn parse_rustc_dep_info(rustc_dep_info: &Path) -> CargoResult {\n let contents = paths::read(rustc_dep_info)?;\n let mut ret = RustcDepInfo::default();\n let mut found_deps = false;\n\n for line in contents.lines() {\n if let Some(rest) = line.strip_prefix(\"# env-dep:\") {\n let mut parts = rest.splitn(2, '=');\n let Some(env_var) = parts.next() else {\n continue;\n };\n let env_val = match parts.next() {\n Some(s) => Some(unescape_env(s)?),\n None => None,\n };\n ret.env.push((unescape_env(env_var)?, env_val));\n } else if let Some(pos) = line.find(\": \") {\n if found_deps {\n continue;\n }\n found_deps = true;\n let mut deps = line[pos + 2..].split_whitespace();\n\n while let Some(s) = deps.next() {\n let mut file = s.to_string();\n while file.ends_with('\\\\') {\n file.pop();\n file.push(' ');\n file.push_str(deps.next().ok_or_else(|| {\n crate::util::internal(\"malformed dep-info format, trailing \\\\\")\n })?);\n }\n ret.files.entry(file.into()).or_default();\n }\n } else if let Some(rest) = line.strip_prefix(\"# checksum:\") {\n let mut parts = rest.splitn(3, ' ');\n let Some(checksum) = parts.next().map(Checksum::from_str).transpose()? else {\n continue;\n };\n let Some(Ok(file_len)) = parts\n .next()\n .and_then(|s| s.strip_prefix(\"file_len:\").map(|s| s.parse::()))\n else {\n continue;\n };\n let Some(path) = parts.next().map(PathBuf::from) else {\n continue;\n };\n\n ret.files.insert(path, Some((file_len, checksum)));\n }\n }\n return Ok(ret);\n\n // rustc tries to fit env var names and values all on a single line, which\n // means it needs to escape `\\r` and `\\n`. The escape syntax used is \"\\n\"\n // which means that `\\` also needs to be escaped.\n fn unescape_env(s: &str) -> CargoResult {\n let mut ret = String::with_capacity(s.len());\n let mut chars = s.chars();\n while let Some(c) = chars.next() {\n if c != '\\\\' {\n ret.push(c);\n continue;\n }\n match chars.next() {\n Some('\\\\') => ret.push('\\\\'),\n Some('n') => ret.push('\\n'),\n Some('r') => ret.push('\\r'),\n Some(c) => bail!(\"unknown escape character `{}`\", c),\n None => bail!(\"unterminated escape character\"),\n }\n }\n Ok(ret)\n }\n}\n\n/// Parses Cargo's internal [`EncodedDepInfo`] structure that was previously\n/// serialized to disk.\n///\n/// Note that this is not rustc's `*.d` files.\n///\n/// Also note that rustc's `*.d` files are translated to Cargo-specific\n/// `EncodedDepInfo` files after compilations have finished in\n/// [`translate_dep_info`].\n///\n/// Returns `None` if the file is corrupt or couldn't be read from disk. This\n/// indicates that the crate should likely be rebuilt.\npub fn parse_dep_info(\n pkg_root: &Path,\n build_root: &Path,\n dep_info: &Path,\n) -> CargoResult> {\n let Ok(data) = paths::read_bytes(dep_info) else {\n return Ok(None);\n };\n let Some(info) = EncodedDepInfo::parse(&data) else {\n tracing::warn!(\"failed to parse cargo's dep-info at {:?}\", dep_info);\n return Ok(None);\n };\n let mut ret = RustcDepInfo::default();\n ret.env = info.env;\n ret.files\n .extend(info.files.into_iter().map(|(ty, path, checksum_info)| {\n (\n make_absolute_path(ty, pkg_root, build_root, path),\n checksum_info.and_then(|(file_len, checksum)| {\n Checksum::from_str(&checksum).ok().map(|c| (file_len, c))\n }),\n )\n }));\n Ok(Some(ret))\n}\n\nfn make_absolute_path(\n ty: DepInfoPathType,\n pkg_root: &Path,\n build_root: &Path,\n path: PathBuf,\n) -> PathBuf {\n let relative_to = match ty {\n DepInfoPathType::PackageRootRelative => pkg_root,\n // N.B. path might be absolute here in which case the join below will have no effect\n DepInfoPathType::BuildRootRelative => build_root,\n };\n\n if path.as_os_str().is_empty() {\n // Joining with an empty path causes Rust to add a trailing path separator. On Windows, this\n // would add an invalid trailing backslash to the .d file.\n return relative_to.to_path_buf();\n }\n\n relative_to.join(path)\n}\n\n/// Some algorithms are here to ensure compatibility with possible rustc outputs.\n/// The presence of an algorithm here is not a suggestion that it's fit for use.\n#[derive(Copy, Clone, Debug, Eq, PartialEq)]\npub enum ChecksumAlgo {\n Sha256,\n Blake3,\n}\n\nimpl ChecksumAlgo {\n fn hash_len(&self) -> usize {\n match self {\n ChecksumAlgo::Sha256 | ChecksumAlgo::Blake3 => 32,\n }\n }\n}\n\nimpl FromStr for ChecksumAlgo {\n type Err = InvalidChecksum;\n\n fn from_str(s: &str) -> Result {\n match s {\n \"sha256\" => Ok(Self::Sha256),\n \"blake3\" => Ok(Self::Blake3),\n _ => Err(InvalidChecksum::InvalidChecksumAlgo),\n }\n }\n}\n\nimpl fmt::Display for ChecksumAlgo {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n f.write_str(match self {\n ChecksumAlgo::Sha256 => \"sha256\",\n ChecksumAlgo::Blake3 => \"blake3\",\n })\n }\n}\n\n#[derive(Copy, Clone, Debug, Eq, PartialEq)]\npub struct Checksum {\n algo: ChecksumAlgo,\n /// If the algorithm uses fewer than 32 bytes, then the remaining bytes will be zero.\n value: [u8; 32],\n}\n\nimpl Checksum {\n pub fn new(algo: ChecksumAlgo, value: [u8; 32]) -> Self {\n Self { algo, value }\n }\n\n pub fn compute(algo: ChecksumAlgo, contents: impl Read) -> Result {\n // Buffer size is the recommended amount to fully leverage SIMD instructions on AVX-512 as per\n // blake3 documentation.\n let mut buf = vec![0; 16 * 1024];\n let mut ret = Self {\n algo,\n value: [0; 32],\n };\n let len = algo.hash_len();\n let value = &mut ret.value[..len];\n\n fn digest(\n mut hasher: T,\n mut update: impl FnMut(&mut T, &[u8]),\n finish: impl FnOnce(T, &mut [u8]),\n mut contents: impl Read,\n buf: &mut [u8],\n value: &mut [u8],\n ) -> Result<(), io::Error> {\n loop {\n let bytes_read = contents.read(buf)?;\n if bytes_read == 0 {\n break;\n }\n update(&mut hasher, &buf[0..bytes_read]);\n }\n finish(hasher, value);\n Ok(())\n }\n\n match algo {\n ChecksumAlgo::Sha256 => {\n digest(\n Sha256::new(),\n |h, b| {\n h.update(b);\n },\n |mut h, out| out.copy_from_slice(&h.finish()),\n contents,\n &mut buf,\n value,\n )?;\n }\n ChecksumAlgo::Blake3 => {\n digest(\n blake3::Hasher::new(),\n |h, b| {\n h.update(b);\n },\n |h, out| out.copy_from_slice(h.finalize().as_bytes()),\n contents,\n &mut buf,\n value,\n )?;\n }\n }\n Ok(ret)\n }\n\n pub fn algo(&self) -> ChecksumAlgo {\n self.algo\n }\n\n pub fn value(&self) -> &[u8; 32] {\n &self.value\n }\n}\n\nimpl FromStr for Checksum {\n type Err = InvalidChecksum;\n\n fn from_str(s: &str) -> Result {\n let mut parts = s.split('=');\n let Some(algo) = parts.next().map(ChecksumAlgo::from_str).transpose()? else {\n return Err(InvalidChecksum::InvalidFormat);\n };\n let Some(checksum) = parts.next() else {\n return Err(InvalidChecksum::InvalidFormat);\n };\n let mut value = [0; 32];\n if hex::decode_to_slice(checksum, &mut value[0..algo.hash_len()]).is_err() {\n return Err(InvalidChecksum::InvalidChecksum(algo));\n }\n Ok(Self { algo, value })\n }\n}\n\nimpl fmt::Display for Checksum {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n let mut checksum = [0; 64];\n let hash_len = self.algo.hash_len();\n hex::encode_to_slice(&self.value[0..hash_len], &mut checksum[0..(hash_len * 2)])\n .map_err(|_| fmt::Error)?;\n write!(\n f,\n \"{}={}\",\n self.algo,\n str::from_utf8(&checksum[0..(hash_len * 2)]).unwrap_or_default()\n )\n }\n}\n\nimpl Serialize for Checksum {\n fn serialize(&self, serializer: S) -> Result\n where\n S: serde::Serializer,\n {\n serializer.serialize_str(&self.to_string())\n }\n}\n\nimpl<'de> serde::Deserialize<'de> for Checksum {\n fn deserialize(deserializer: D) -> Result\n where\n D: serde::Deserializer<'de>,\n {\n let s = String::deserialize(deserializer)?;\n s.parse().map_err(serde::de::Error::custom)\n }\n}\n\n#[derive(Debug, thiserror::Error)]\npub enum InvalidChecksum {\n #[error(\"algorithm portion incorrect, expected `sha256`, or `blake3`\")]\n InvalidChecksumAlgo,\n #[error(\"expected {} hexadecimal digits in checksum portion\", .0.hash_len() * 2)]\n InvalidChecksum(ChecksumAlgo),\n #[error(\"expected a string with format \\\"algorithm=hex_checksum\\\"\")]\n InvalidFormat,\n}\n\n#[cfg(test)]\nmod encoded_dep_info {\n use super::*;\n\n #[track_caller]\n fn gen_test(checksum: bool) {\n let checksum = checksum.then_some((768, \"c01efc669f09508b55eced32d3c88702578a7c3e\".into()));\n let lib_rs = (\n DepInfoPathType::BuildRootRelative,\n PathBuf::from(\"src/lib.rs\"),\n checksum.clone(),\n );\n\n let depinfo = EncodedDepInfo {\n files: vec![lib_rs.clone()],\n env: Vec::new(),\n };\n let data = depinfo.serialize().unwrap();\n assert_eq!(EncodedDepInfo::parse(&data).unwrap(), depinfo);\n\n let mod_rs = (\n DepInfoPathType::BuildRootRelative,\n PathBuf::from(\"src/mod.rs\"),\n checksum.clone(),\n );\n let depinfo = EncodedDepInfo {\n files: vec![lib_rs.clone(), mod_rs.clone()],\n env: Vec::new(),\n };\n let data = depinfo.serialize().unwrap();\n assert_eq!(EncodedDepInfo::parse(&data).unwrap(), depinfo);\n\n let depinfo = EncodedDepInfo {\n files: vec![lib_rs, mod_rs],\n env: vec![\n (\"Gimli\".into(), Some(\"Legolas\".into())),\n (\"Beren\".into(), Some(\"LĆŗthien\".into())),\n ],\n };\n let data = depinfo.serialize().unwrap();\n assert_eq!(EncodedDepInfo::parse(&data).unwrap(), depinfo);\n }\n\n #[test]\n fn round_trip() {\n gen_test(false);\n }\n\n #[test]\n fn round_trip_with_checksums() {\n gen_test(true);\n }\n\n #[test]\n fn path_type_is_u8_max() {\n #[rustfmt::skip]\n let data = [\n 0x01, 0x00, 0x00, 0x00, 0xff, // magic marker\n CURRENT_ENCODED_DEP_INFO_VERSION, // version\n 0x01, 0x00, 0x00, 0x00, // # of files\n 0x00, // path type\n 0x04, 0x00, 0x00, 0x00, // len of path\n 0x72, 0x75, 0x73, 0x74, // path bytes (\"rust\")\n 0x00, // cksum exists?\n 0x00, 0x00, 0x00, 0x00, // # of env vars\n ];\n // The current cargo doesn't recognize the magic marker.\n assert_eq!(\n EncodedDepInfo::parse(&data).unwrap(),\n EncodedDepInfo {\n files: vec![(DepInfoPathType::PackageRootRelative, \"rust\".into(), None)],\n env: Vec::new(),\n }\n );\n }\n\n #[test]\n fn parse_v0_fingerprint_dep_info() {\n #[rustfmt::skip]\n let data = [\n 0x01, 0x00, 0x00, 0x00, // # of files\n 0x00, // path type\n 0x04, 0x00, 0x00, 0x00, // len of path\n 0x72, 0x75, 0x73, 0x74, // path bytes: \"rust\"\n 0x00, 0x00, 0x00, 0x00, // # of env vars\n ];\n // Cargo can't recognize v0 after `-Zchecksum-freshness` added.\n assert!(EncodedDepInfo::parse(&data).is_none());\n }\n}\n" }, { "path": "src/cargo/core/compiler/fingerprint/dirty_reason.rs", "content": "use std::collections::HashMap;\nuse std::fmt;\nuse std::fmt::Debug;\n\nuse serde::Serialize;\n\nuse super::*;\nuse crate::core::Shell;\nuse crate::core::compiler::UnitIndex;\n\n/// Tells a better story of why a build is considered \"dirty\" that leads\n/// to a recompile. Usually constructed via [`Fingerprint::compare`].\n///\n/// [`Fingerprint::compare`]: super::Fingerprint::compare\n#[derive(Clone, Debug, Serialize, Deserialize)]\n#[serde(tag = \"dirty_reason\", rename_all = \"kebab-case\")]\npub enum DirtyReason {\n RustcChanged,\n FeaturesChanged {\n old: String,\n new: String,\n },\n DeclaredFeaturesChanged {\n old: String,\n new: String,\n },\n TargetConfigurationChanged,\n PathToSourceChanged,\n ProfileConfigurationChanged,\n RustflagsChanged {\n old: Vec,\n new: Vec,\n },\n ConfigSettingsChanged,\n CompileKindChanged,\n LocalLengthsChanged,\n PrecalculatedComponentsChanged {\n old: String,\n new: String,\n },\n ChecksumUseChanged {\n old: bool,\n },\n DepInfoOutputChanged {\n old: PathBuf,\n new: PathBuf,\n },\n RerunIfChangedOutputFileChanged {\n old: PathBuf,\n new: PathBuf,\n },\n RerunIfChangedOutputPathsChanged {\n old: Vec,\n new: Vec,\n },\n EnvVarsChanged {\n old: String,\n new: String,\n },\n EnvVarChanged {\n name: String,\n old_value: Option,\n new_value: Option,\n },\n LocalFingerprintTypeChanged {\n old: String,\n new: String,\n },\n NumberOfDependenciesChanged {\n old: usize,\n new: usize,\n },\n UnitDependencyNameChanged {\n old: InternedString,\n new: InternedString,\n },\n UnitDependencyInfoChanged {\n unit: UnitIndex,\n },\n FsStatusOutdated(FsStatus),\n NothingObvious,\n Forced,\n /// First time to build something.\n FreshBuild,\n}\n\ntrait ShellExt {\n fn dirty_because(&mut self, unit: &Unit, s: impl fmt::Display) -> CargoResult<()>;\n}\n\nimpl ShellExt for Shell {\n fn dirty_because(&mut self, unit: &Unit, s: impl fmt::Display) -> CargoResult<()> {\n self.status(\"Dirty\", format_args!(\"{}: {s}\", &unit.pkg))\n }\n}\n\nstruct FileTimeDiff {\n old_time: FileTime,\n new_time: FileTime,\n}\n\nimpl fmt::Display for FileTimeDiff {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n let s_diff = self.new_time.seconds() - self.old_time.seconds();\n if s_diff >= 1 {\n write!(f, \"{:#}\", jiff::SignedDuration::from_secs(s_diff))\n } else {\n // format nanoseconds as it is, jiff would display ms, us and ns\n let ns_diff = self.new_time.nanoseconds() - self.old_time.nanoseconds();\n write!(f, \"{ns_diff}ns\")\n }\n }\n}\n\n#[derive(Copy, Clone)]\nstruct After {\n old_time: FileTime,\n new_time: FileTime,\n what: &'static str,\n}\n\nimpl fmt::Display for After {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n let Self {\n old_time,\n new_time,\n what,\n } = *self;\n let diff = FileTimeDiff { old_time, new_time };\n\n write!(f, \"{new_time}, {diff} after {what} at {old_time}\")\n }\n}\n\nimpl DirtyReason {\n /// Whether a build is dirty because it is a fresh build being kicked off.\n pub fn is_fresh_build(&self) -> bool {\n matches!(self, DirtyReason::FreshBuild)\n }\n\n fn after(old_time: FileTime, new_time: FileTime, what: &'static str) -> After {\n After {\n old_time,\n new_time,\n what,\n }\n }\n\n pub fn present_to(\n &self,\n s: &mut Shell,\n unit: &Unit,\n root: &Path,\n index_to_unit: &HashMap,\n ) -> CargoResult<()> {\n match self {\n DirtyReason::RustcChanged => s.dirty_because(unit, \"the toolchain changed\"),\n DirtyReason::FeaturesChanged { .. } => {\n s.dirty_because(unit, \"the list of features changed\")\n }\n DirtyReason::DeclaredFeaturesChanged { .. } => {\n s.dirty_because(unit, \"the list of declared features changed\")\n }\n DirtyReason::TargetConfigurationChanged => {\n s.dirty_because(unit, \"the target configuration changed\")\n }\n DirtyReason::PathToSourceChanged => {\n s.dirty_because(unit, \"the path to the source changed\")\n }\n DirtyReason::ProfileConfigurationChanged => {\n s.dirty_because(unit, \"the profile configuration changed\")\n }\n DirtyReason::RustflagsChanged { .. } => s.dirty_because(unit, \"the rustflags changed\"),\n DirtyReason::ConfigSettingsChanged => {\n s.dirty_because(unit, \"the config settings changed\")\n }\n DirtyReason::CompileKindChanged => {\n s.dirty_because(unit, \"the rustc compile kind changed\")\n }\n DirtyReason::LocalLengthsChanged => {\n s.dirty_because(unit, \"the local lengths changed\")?;\n s.note(\n \"this could happen because of added/removed `cargo::rerun-if` instructions in the build script\",\n )?;\n\n Ok(())\n }\n DirtyReason::PrecalculatedComponentsChanged { .. } => {\n s.dirty_because(unit, \"the precalculated components changed\")\n }\n DirtyReason::ChecksumUseChanged { old } => {\n if *old {\n s.dirty_because(\n unit,\n \"the prior compilation used checksum freshness and this one does not\",\n )\n } else {\n s.dirty_because(unit, \"checksum freshness requested, prior compilation did not use checksum freshness\")\n }\n }\n DirtyReason::DepInfoOutputChanged { .. } => {\n s.dirty_because(unit, \"the dependency info output changed\")\n }\n DirtyReason::RerunIfChangedOutputFileChanged { .. } => {\n s.dirty_because(unit, \"rerun-if-changed output file path changed\")\n }\n DirtyReason::RerunIfChangedOutputPathsChanged { .. } => {\n s.dirty_because(unit, \"the rerun-if-changed instructions changed\")\n }\n DirtyReason::EnvVarsChanged { .. } => {\n s.dirty_because(unit, \"the environment variables changed\")\n }\n DirtyReason::EnvVarChanged { name, .. } => {\n s.dirty_because(unit, format_args!(\"the env variable {name} changed\"))\n }\n DirtyReason::LocalFingerprintTypeChanged { .. } => {\n s.dirty_because(unit, \"the local fingerprint type changed\")\n }\n DirtyReason::NumberOfDependenciesChanged { old, new } => s.dirty_because(\n unit,\n format_args!(\"number of dependencies changed ({old} => {new})\",),\n ),\n DirtyReason::UnitDependencyNameChanged { old, new } => s.dirty_because(\n unit,\n format_args!(\"name of dependency changed ({old} => {new})\"),\n ),\n DirtyReason::UnitDependencyInfoChanged { unit: dep_unit } => {\n let dep_name = index_to_unit.get(dep_unit).map(|u| u.pkg.name()).unwrap();\n s.dirty_because(\n unit,\n format_args!(\"info of dependency `{dep_name}` changed\"),\n )\n }\n DirtyReason::FsStatusOutdated(status) => match status {\n FsStatus::Stale => s.dirty_because(unit, \"stale, unknown reason\"),\n FsStatus::StaleItem(item) => match item {\n StaleItem::MissingFile { path } => {\n let file = path.strip_prefix(root).unwrap_or(&path);\n s.dirty_because(\n unit,\n format_args!(\"the file `{}` is missing\", file.display()),\n )\n }\n StaleItem::UnableToReadFile { path } => {\n let file = path.strip_prefix(root).unwrap_or(&path);\n s.dirty_because(\n unit,\n format_args!(\"the file `{}` could not be read\", file.display()),\n )\n }\n StaleItem::FailedToReadMetadata { path } => {\n let file = path.strip_prefix(root).unwrap_or(&path);\n s.dirty_because(\n unit,\n format_args!(\"couldn't read metadata for file `{}`\", file.display()),\n )\n }\n StaleItem::ChangedFile {\n stale,\n stale_mtime,\n reference_mtime,\n ..\n } => {\n let file = stale.strip_prefix(root).unwrap_or(&stale);\n let after = Self::after(*reference_mtime, *stale_mtime, \"last build\");\n s.dirty_because(\n unit,\n format_args!(\"the file `{}` has changed ({after})\", file.display()),\n )\n }\n StaleItem::ChangedChecksum {\n source,\n stored_checksum,\n new_checksum,\n } => {\n let file = source.strip_prefix(root).unwrap_or(&source);\n s.dirty_because(\n unit,\n format_args!(\n \"the file `{}` has changed (checksum didn't match, {stored_checksum} != {new_checksum})\",\n file.display(),\n ),\n )\n }\n StaleItem::FileSizeChanged {\n path,\n old_size,\n new_size,\n } => {\n let file = path.strip_prefix(root).unwrap_or(&path);\n s.dirty_because(\n unit,\n format_args!(\n \"file size changed ({old_size} != {new_size}) for `{}`\",\n file.display()\n ),\n )\n }\n StaleItem::MissingChecksum { path } => {\n let file = path.strip_prefix(root).unwrap_or(&path);\n s.dirty_because(\n unit,\n format_args!(\"the checksum for file `{}` is missing\", file.display()),\n )\n }\n StaleItem::ChangedEnv { var, .. } => s.dirty_because(\n unit,\n format_args!(\"the environment variable {var} changed\"),\n ),\n },\n FsStatus::StaleDependency {\n unit: dep_unit,\n dep_mtime,\n max_mtime,\n } => {\n let dep_name = index_to_unit.get(dep_unit).map(|u| u.pkg.name()).unwrap();\n let after = Self::after(*max_mtime, *dep_mtime, \"last build\");\n s.dirty_because(\n unit,\n format_args!(\"the dependency `{dep_name}` was rebuilt ({after})\"),\n )\n }\n FsStatus::StaleDepFingerprint { unit: dep_unit } => {\n let dep_name = index_to_unit.get(dep_unit).map(|u| u.pkg.name()).unwrap();\n s.dirty_because(\n unit,\n format_args!(\"the dependency `{dep_name}` was rebuilt\"),\n )\n }\n FsStatus::UpToDate { .. } => {\n unreachable!()\n }\n },\n DirtyReason::NothingObvious => {\n // See comment in fingerprint compare method.\n s.dirty_because(unit, \"the fingerprint comparison turned up nothing obvious\")\n }\n DirtyReason::Forced => s.dirty_because(unit, \"forced\"),\n DirtyReason::FreshBuild => s.dirty_because(unit, \"fresh build\"),\n }\n }\n}\n\n// These test the actual JSON structure that will be logged.\n// In the future we might decouple this from the actual log message schema.\n#[cfg(test)]\nmod json_schema {\n use super::*;\n use snapbox::IntoData;\n use snapbox::assert_data_eq;\n use snapbox::str;\n\n fn to_json(value: &T) -> String {\n serde_json::to_string_pretty(value).unwrap()\n }\n\n #[test]\n fn rustc_changed() {\n let reason = DirtyReason::RustcChanged;\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"rustc-changed\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn fresh_build() {\n let reason = DirtyReason::FreshBuild;\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fresh-build\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn forced() {\n let reason = DirtyReason::Forced;\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"forced\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn nothing_obvious() {\n let reason = DirtyReason::NothingObvious;\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"nothing-obvious\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn features_changed() {\n let reason = DirtyReason::FeaturesChanged {\n old: \"f1\".to_string(),\n new: \"f1,f2\".to_string(),\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"features-changed\",\n \"new\": \"f1,f2\",\n \"old\": \"f1\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn rustflags_changed() {\n let reason = DirtyReason::RustflagsChanged {\n old: vec![\"-C\".into(), \"opt-level=2\".into()],\n new: vec![\"--cfg\".into(), \"tokio_unstable\".into()],\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"rustflags-changed\",\n \"old\": [\n \"-C\",\n \"opt-level=2\"\n ],\n \"new\": [\n \"--cfg\",\n \"tokio_unstable\"\n ]\n}\n\"#]]\n );\n }\n\n #[test]\n fn env_var_changed_both_some() {\n let reason = DirtyReason::EnvVarChanged {\n name: \"VAR\".into(),\n old_value: Some(\"old\".into()),\n new_value: Some(\"new\".into()),\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"env-var-changed\",\n \"name\": \"VAR\",\n \"new_value\": \"new\",\n \"old_value\": \"old\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn env_var_changed_old_none() {\n let reason = DirtyReason::EnvVarChanged {\n name: \"VAR\".into(),\n old_value: None,\n new_value: Some(\"new\".into()),\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"env-var-changed\",\n \"name\": \"VAR\",\n \"new_value\": \"new\",\n \"old_value\": null\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn dep_info_output_changed() {\n let reason = DirtyReason::DepInfoOutputChanged {\n old: \"target/debug/old.d\".into(),\n new: \"target/debug/new.d\".into(),\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"dep-info-output-changed\",\n \"old\": \"target/debug/old.d\",\n \"new\": \"target/debug/new.d\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn number_of_dependencies_changed() {\n let reason = DirtyReason::NumberOfDependenciesChanged { old: 5, new: 7 };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"number-of-dependencies-changed\",\n \"old\": 5,\n \"new\": 7\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn unit_dependency_name_changed() {\n let reason = DirtyReason::UnitDependencyNameChanged {\n old: \"old_dep\".into(),\n new: \"new_dep\".into(),\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"unit-dependency-name-changed\",\n \"new\": \"new_dep\",\n \"old\": \"old_dep\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn unit_dependency_info_changed() {\n let reason = DirtyReason::UnitDependencyInfoChanged {\n unit: UnitIndex(15),\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"unit-dependency-info-changed\",\n \"unit\": 15\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn fs_status_stale() {\n let reason = DirtyReason::FsStatusOutdated(FsStatus::Stale);\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn fs_status_missing_file() {\n let reason = DirtyReason::FsStatusOutdated(FsStatus::StaleItem(StaleItem::MissingFile {\n path: \"src/lib.rs\".into(),\n }));\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-item\",\n \"path\": \"src/lib.rs\",\n \"stale_item\": \"missing-file\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn fs_status_changed_file() {\n let reason = DirtyReason::FsStatusOutdated(FsStatus::StaleItem(StaleItem::ChangedFile {\n reference: \"target/debug/deps/libfoo-abc123.rmeta\".into(),\n reference_mtime: FileTime::from_unix_time(1730567890, 123000000),\n stale: \"src/lib.rs\".into(),\n stale_mtime: FileTime::from_unix_time(1730567891, 456000000),\n }));\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-item\",\n \"reference\": \"target/debug/deps/libfoo-abc123.rmeta\",\n \"reference_mtime\": 1730567890123.0,\n \"stale\": \"src/lib.rs\",\n \"stale_item\": \"changed-file\",\n \"stale_mtime\": 1730567891456.0\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn fs_status_changed_checksum() {\n use super::dep_info::ChecksumAlgo;\n let reason =\n DirtyReason::FsStatusOutdated(FsStatus::StaleItem(StaleItem::ChangedChecksum {\n source: \"src/main.rs\".into(),\n stored_checksum: Checksum::new(ChecksumAlgo::Sha256, [0xaa; 32]),\n new_checksum: Checksum::new(ChecksumAlgo::Sha256, [0xbb; 32]),\n }));\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-item\",\n \"new_checksum\": \"sha256=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\",\n \"source\": \"src/main.rs\",\n \"stale_item\": \"changed-checksum\",\n \"stored_checksum\": \"sha256=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn fs_status_stale_dependency() {\n let reason = DirtyReason::FsStatusOutdated(FsStatus::StaleDependency {\n unit: UnitIndex(42),\n dep_mtime: FileTime::from_unix_time(1730567892, 789000000),\n max_mtime: FileTime::from_unix_time(1730567890, 123000000),\n });\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dep_mtime\": 1730567892789.0,\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-dependency\",\n \"max_mtime\": 1730567890123.0,\n \"unit\": 42\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn fs_status_stale_dep_fingerprint() {\n let reason = DirtyReason::FsStatusOutdated(FsStatus::StaleDepFingerprint {\n unit: UnitIndex(42),\n });\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-dep-fingerprint\",\n \"unit\": 42\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn fs_status_unable_to_read_file() {\n let reason =\n DirtyReason::FsStatusOutdated(FsStatus::StaleItem(StaleItem::UnableToReadFile {\n path: \"src/lib.rs\".into(),\n }));\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-item\",\n \"stale_item\": \"unable-to-read-file\",\n \"path\": \"src/lib.rs\"\n}\n\"#]]\n );\n }\n\n #[test]\n fn fs_status_failed_to_read_metadata() {\n let reason =\n DirtyReason::FsStatusOutdated(FsStatus::StaleItem(StaleItem::FailedToReadMetadata {\n path: \"src/lib.rs\".into(),\n }));\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-item\",\n \"stale_item\": \"failed-to-read-metadata\",\n \"path\": \"src/lib.rs\"\n}\n\"#]]\n );\n }\n\n #[test]\n fn fs_status_file_size_changed() {\n let reason =\n DirtyReason::FsStatusOutdated(FsStatus::StaleItem(StaleItem::FileSizeChanged {\n path: \"src/lib.rs\".into(),\n old_size: 1024,\n new_size: 2048,\n }));\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-item\",\n \"stale_item\": \"file-size-changed\",\n \"path\": \"src/lib.rs\",\n \"old_size\": 1024,\n \"new_size\": 2048\n}\n\"#]]\n );\n }\n\n #[test]\n fn fs_status_missing_checksum() {\n let reason =\n DirtyReason::FsStatusOutdated(FsStatus::StaleItem(StaleItem::MissingChecksum {\n path: \"src/lib.rs\".into(),\n }));\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-item\",\n \"stale_item\": \"missing-checksum\",\n \"path\": \"src/lib.rs\"\n}\n\"#]]\n );\n }\n\n #[test]\n fn fs_status_changed_env() {\n let reason = DirtyReason::FsStatusOutdated(FsStatus::StaleItem(StaleItem::ChangedEnv {\n var: \"VAR\".into(),\n previous: Some(\"old\".into()),\n current: Some(\"new\".into()),\n }));\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"fs-status-outdated\",\n \"fs_status\": \"stale-item\",\n \"stale_item\": \"changed-env\",\n \"var\": \"VAR\",\n \"previous\": \"old\",\n \"current\": \"new\"\n}\n\"#]]\n );\n }\n\n #[test]\n fn checksum_use_changed() {\n let reason = DirtyReason::ChecksumUseChanged { old: false };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"checksum-use-changed\",\n \"old\": false\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn rerun_if_changed_output_paths_changed() {\n let reason = DirtyReason::RerunIfChangedOutputPathsChanged {\n old: vec![\"file1.txt\".into(), \"file2.txt\".into()],\n new: vec![\"file1.txt\".into(), \"file2.txt\".into(), \"file3.txt\".into()],\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"rerun-if-changed-output-paths-changed\",\n \"old\": [\n \"file1.txt\",\n \"file2.txt\"\n ],\n \"new\": [\n \"file1.txt\",\n \"file2.txt\",\n \"file3.txt\"\n ]\n}\n\"#]]\n .is_json()\n );\n }\n\n #[test]\n fn local_fingerprint_type_changed() {\n let reason = DirtyReason::LocalFingerprintTypeChanged {\n old: \"precalculated\".to_owned(),\n new: \"rerun-if-changed\".to_owned(),\n };\n assert_data_eq!(\n to_json(&reason),\n str![[r#\"\n{\n \"dirty_reason\": \"local-fingerprint-type-changed\",\n \"new\": \"rerun-if-changed\",\n \"old\": \"precalculated\"\n}\n\"#]]\n .is_json()\n );\n }\n}\n" }, { "path": "src/cargo/core/compiler/fingerprint/mod.rs", "content": "//! Tracks changes to determine if something needs to be recompiled.\n//!\n//! This module implements change-tracking so that Cargo can know whether or\n//! not something needs to be recompiled. A Cargo [`Unit`] can be either \"dirty\"\n//! (needs to be recompiled) or \"fresh\" (it does not need to be recompiled).\n//!\n//! ## Mechanisms affecting freshness\n//!\n//! There are several mechanisms that influence a Unit's freshness:\n//!\n//! - The [`Fingerprint`] is a hash, saved to the filesystem in the\n//! `.fingerprint` directory, that tracks information about the Unit. If the\n//! fingerprint is missing (such as the first time the unit is being\n//! compiled), then the unit is dirty. If any of the fingerprint fields\n//! change (like the name of the source file), then the Unit is considered\n//! dirty.\n//!\n//! The `Fingerprint` also tracks the fingerprints of all its dependencies,\n//! so a change in a dependency will propagate the \"dirty\" status up.\n//!\n//! - Filesystem mtime tracking is also used to check if a unit is dirty.\n//! See the section below on \"Mtime comparison\" for more details. There\n//! are essentially two parts to mtime tracking:\n//!\n//! 1. The mtime of a Unit's output files is compared to the mtime of all\n//! its dependencies' output file mtimes (see\n//! [`check_filesystem`]). If any output is missing, or is\n//! older than a dependency's output, then the unit is dirty.\n//! 2. The mtime of a Unit's source files is compared to the mtime of its\n//! dep-info file in the fingerprint directory (see [`find_stale_file`]).\n//! The dep-info file is used as an anchor to know when the last build of\n//! the unit was done. See the \"dep-info files\" section below for more\n//! details. If any input files are missing, or are newer than the\n//! dep-info, then the unit is dirty.\n//!\n//! - Alternatively if you're using the unstable feature `checksum-freshness`\n//! mtimes are ignored entirely in favor of comparing first the file size, and\n//! then the checksum with a known prior value emitted by rustc. Only nightly\n//! rustc will emit the needed metadata at the time of writing. This is dependent\n//! on the unstable feature `-Z checksum-hash-algorithm`.\n//!\n//! Note: Fingerprinting is not a perfect solution. Filesystem mtime tracking\n//! is notoriously imprecise and problematic. Only a small part of the\n//! environment is captured. This is a balance of performance, simplicity, and\n//! completeness. Sandboxing, hashing file contents, tracking every file\n//! access, environment variable, and network operation would ensure more\n//! reliable and reproducible builds at the cost of being complex, slow, and\n//! platform-dependent.\n//!\n//! ## Fingerprints and [`UnitHash`]s\n//!\n//! [`Metadata`] tracks several [`UnitHash`]s, including\n//! [`Metadata::unit_id`], [`Metadata::c_metadata`], and [`Metadata::c_extra_filename`].\n//! See its documentation for more details.\n//!\n//! NOTE: Not all output files are isolated via filename hashes (like dylibs).\n//! The fingerprint directory uses a hash, but sometimes units share the same\n//! fingerprint directory (when they don't have Metadata) so care should be\n//! taken to handle this!\n//!\n//! Fingerprints and [`UnitHash`]s are similar, and track some of the same things.\n//! [`UnitHash`]s contains information that is required to keep Units separate.\n//! The Fingerprint includes additional information that should cause a\n//! recompile, but it is desired to reuse the same filenames. A comparison\n//! of what is tracked:\n//!\n//! Value | Fingerprint | `Metadata::unit_id` [^8] | `Metadata::c_metadata`\n//! -------------------------------------------|-------------|--------------------------|-----------------------\n//! rustc | āœ“ | āœ“ | āœ“\n//! [`Profile`] | āœ“ | āœ“ | āœ“\n//! `cargo rustc` extra args | āœ“ | āœ“[^7] |\n//! [`CompileMode`] | āœ“ | āœ“ | āœ“\n//! Target Name | āœ“ | āœ“ | āœ“\n//! `TargetKind` (bin/lib/etc.) | āœ“ | āœ“ | āœ“\n//! Enabled Features | āœ“ | āœ“ | āœ“\n//! Declared Features | āœ“ | |\n//! Immediate dependencyā€™s hashes | āœ“[^1] | āœ“ | āœ“\n//! [`CompileKind`] (host/target) | āœ“ | āœ“ | āœ“\n//! `__CARGO_DEFAULT_LIB_METADATA`[^4] | | āœ“ | āœ“\n//! `package_id` | | āœ“ | āœ“\n//! Target src path relative to ws | āœ“ | |\n//! Target flags (test/bench/for_host/edition) | āœ“ | |\n//! -C incremental=ā€¦ flag | āœ“ | |\n//! mtime of sources | āœ“[^3] | |\n//! RUSTFLAGS/RUSTDOCFLAGS | āœ“ | āœ“[^7] |\n//! [`Lto`] flags | āœ“ | āœ“ | āœ“\n//! config settings[^5] | āœ“ | |\n//! `is_std` | | āœ“ | āœ“\n//! `[lints]` table[^6] | āœ“ | |\n//! `[lints.rust.unexpected_cfgs.check-cfg]` | āœ“ | |\n//!\n//! [^1]: Bin dependencies are not included.\n//!\n//! [^3]: See below for details on mtime tracking.\n//!\n//! [^4]: `__CARGO_DEFAULT_LIB_METADATA` is set by rustbuild to embed the\n//! release channel (bootstrap/stable/beta/nightly) in libstd.\n//!\n//! [^5]: Config settings that are not otherwise captured anywhere else.\n//! Currently, this is only `doc.extern-map`.\n//!\n//! [^6]: Via [`Manifest::lint_rustflags`][crate::core::Manifest::lint_rustflags]\n//!\n//! [^7]: extra-flags and RUSTFLAGS are conditionally excluded when `--remap-path-prefix` is\n//! present to avoid breaking build reproducibility while we wait for trim-paths\n//!\n//! [^8]: including `-Cextra-filename`\n//!\n//! When deciding what should go in the Metadata vs the Fingerprint, consider\n//! that some files (like dylibs) do not have a hash in their filename. Thus,\n//! if a value changes, only the fingerprint will detect the change (consider,\n//! for example, swapping between different features). Fields that are only in\n//! Metadata generally aren't relevant to the fingerprint because they\n//! fundamentally change the output (like target vs host changes the directory\n//! where it is emitted).\n//!\n//! ## Fingerprint files\n//!\n//! Fingerprint information is stored in the\n//! `target/{debug,release}/.fingerprint/` directory. Each Unit is stored in a\n//! separate directory. Each Unit directory contains:\n//!\n//! - A file with a 16 hex-digit hash. This is the Fingerprint hash, used for\n//! quick loading and comparison.\n//! - A `.json` file that contains details about the Fingerprint. This is only\n//! used to log details about *why* a fingerprint is considered dirty.\n//! `CARGO_LOG=cargo::core::compiler::fingerprint=trace cargo build` can be\n//! used to display this log information.\n//! - A \"dep-info\" file which is a translation of rustc's `*.d` dep-info files\n//! to a Cargo-specific format that tweaks file names and is optimized for\n//! reading quickly.\n//! - An `invoked.timestamp` file whose filesystem mtime is updated every time\n//! the Unit is built. This is used for capturing the time when the build\n//! starts, to detect if files are changed in the middle of the build. See\n//! below for more details.\n//!\n//! Note that some units are a little different. A Unit for *running* a build\n//! script or for `rustdoc` does not have a dep-info file (it's not\n//! applicable). Build script `invoked.timestamp` files are in the build\n//! output directory.\n//!\n//! ## Fingerprint calculation\n//!\n//! After the list of Units has been calculated, the Units are added to the\n//! [`JobQueue`]. As each one is added, the fingerprint is calculated, and the\n//! dirty/fresh status is recorded. A closure is used to update the fingerprint\n//! on-disk when the Unit successfully finishes. The closure will recompute the\n//! Fingerprint based on the updated information. If the Unit fails to compile,\n//! the fingerprint is not updated.\n//!\n//! Fingerprints are cached in the [`BuildRunner`]. This makes computing\n//! Fingerprints faster, but also is necessary for properly updating\n//! dependency information. Since a Fingerprint includes the Fingerprints of\n//! all dependencies, when it is updated, by using `Arc` clones, it\n//! automatically picks up the updates to its dependencies.\n//!\n//! ### dep-info files\n//!\n//! Cargo has several kinds of \"dep info\" files:\n//!\n//! * dep-info files generated by `rustc`.\n//! * Fingerprint dep-info files translated from the first one.\n//! * dep-info for external build system integration.\n//! * Unstable `-Zbinary-dep-depinfo`.\n//!\n//! #### `rustc` dep-info files\n//!\n//! Cargo passes the `--emit=dep-info` flag to `rustc` so that `rustc` will\n//! generate a \"dep info\" file (with the `.d` extension). This is a\n//! Makefile-like syntax that includes all of the source files used to build\n//! the crate. This file is used by Cargo to know which files to check to see\n//! if the crate will need to be rebuilt. Example:\n//!\n//! ```makefile\n//! /path/to/target/debug/deps/cargo-b6219d178925203d: src/bin/main.rs src/bin/cargo/cli.rs # ā€¦ etc.\n//! ```\n//!\n//! #### Fingerprint dep-info files\n//!\n//! After `rustc` exits successfully, Cargo will read the first kind of dep\n//! info file and translate it into a binary format that is stored in the\n//! fingerprint directory ([`translate_dep_info`]).\n//!\n//! These are used to quickly scan for any changed files. The mtime of the\n//! fingerprint dep-info file itself is used as the reference for comparing the\n//! source files to determine if any of the source files have been modified\n//! (see [below](#mtime-comparison) for more detail).\n//!\n//! Note that Cargo parses the special `# env-var:...` comments in dep-info\n//! files to learn about environment variables that the rustc compile depends on.\n//! Cargo then later uses this to trigger a recompile if a referenced env var\n//! changes (even if the source didn't change).\n//! This also includes env vars generated from Cargo metadata like `CARGO_PKG_DESCRIPTION`.\n//! (See [`crate::core::manifest::ManifestMetadata`]\n//!\n//! #### dep-info files for build system integration.\n//!\n//! There is also a third dep-info file. Cargo will extend the file created by\n//! rustc with some additional information and saves this into the output\n//! directory. This is intended for build system integration. See the\n//! [`output_depinfo`] function for more detail.\n//!\n//! #### -Zbinary-dep-depinfo\n//!\n//! `rustc` has an experimental flag `-Zbinary-dep-depinfo`. This causes\n//! `rustc` to include binary files (like rlibs) in the dep-info file. This is\n//! primarily to support rustc development, so that Cargo can check the\n//! implicit dependency to the standard library (which lives in the sysroot).\n//! We want Cargo to recompile whenever the standard library rlib/dylibs\n//! change, and this is a generic mechanism to make that work.\n//!\n//! ### Mtime comparison\n//!\n//! The use of modification timestamps is the most common way a unit will be\n//! determined to be dirty or fresh between builds. There are many subtle\n//! issues and edge cases with mtime comparisons. This gives a high-level\n//! overview, but you'll need to read the code for the gritty details. Mtime\n//! handling is different for different unit kinds. The different styles are\n//! driven by the [`Fingerprint::local`] field, which is set based on the unit\n//! kind.\n//!\n//! The status of whether or not the mtime is \"stale\" or \"up-to-date\" is\n//! stored in [`Fingerprint::fs_status`].\n//!\n//! All units will compare the mtime of its newest output file with the mtimes\n//! of the outputs of all its dependencies. If any output file is missing,\n//! then the unit is stale. If any dependency is newer, the unit is stale.\n//!\n//! #### Normal package mtime handling\n//!\n//! [`LocalFingerprint::CheckDepInfo`] is used for checking the mtime of\n//! packages. It compares the mtime of the input files (the source files) to\n//! the mtime of the dep-info file (which is written last after a build is\n//! finished). If the dep-info is missing, the unit is stale (it has never\n//! been built). The list of input files comes from the dep-info file. See the\n//! section above for details on dep-info files.\n//!\n//! Also note that although registry and git packages use [`CheckDepInfo`], none\n//! of their source files are included in the dep-info (see\n//! [`translate_dep_info`]), so for those kinds no mtime checking is done\n//! (unless `-Zbinary-dep-depinfo` is used). Repository and git packages are\n//! static, so there is no need to check anything.\n//!\n//! When a build is complete, the mtime of the dep-info file in the\n//! fingerprint directory is modified to rewind it to the time when the build\n//! started. This is done by creating an `invoked.timestamp` file when the\n//! build starts to capture the start time. The mtime is rewound to the start\n//! to handle the case where the user modifies a source file while a build is\n//! running. Cargo can't know whether or not the file was included in the\n//! build, so it takes a conservative approach of assuming the file was *not*\n//! included, and it should be rebuilt during the next build.\n//!\n//! #### Rustdoc mtime handling\n//!\n//! Rustdoc does not emit a dep-info file, so Cargo currently has a relatively\n//! simple system for detecting rebuilds. [`LocalFingerprint::Precalculated`] is\n//! used for rustdoc units. For registry packages, this is the package\n//! version. For git packages, it is the git hash. For path packages, it is\n//! a string of the mtime of the newest file in the package.\n//!\n//! There are some known bugs with how this works, so it should be improved at\n//! some point.\n//!\n//! #### Build script mtime handling\n//!\n//! Build script mtime handling runs in different modes. There is the \"old\n//! style\" where the build script does not emit any `rerun-if` directives. In\n//! this mode, Cargo will use [`LocalFingerprint::Precalculated`]. See the\n//! \"rustdoc\" section above how it works.\n//!\n//! In the new-style, each `rerun-if` directive is translated to the\n//! corresponding [`LocalFingerprint`] variant. The [`RerunIfChanged`] variant\n//! compares the mtime of the given filenames against the mtime of the\n//! \"output\" file.\n//!\n//! Similar to normal units, the build script \"output\" file mtime is rewound\n//! to the time just before the build script is executed to handle mid-build\n//! modifications.\n//!\n//! ## Considerations for inclusion in a fingerprint\n//!\n//! Over time we've realized a few items which historically were included in\n//! fingerprint hashings should not actually be included. Examples are:\n//!\n//! * Modification time values. We strive to never include a modification time\n//! inside a `Fingerprint` to get hashed into an actual value. While\n//! theoretically fine to do, in practice this causes issues with common\n//! applications like Docker. Docker, after a layer is built, will zero out\n//! the nanosecond part of all filesystem modification times. This means that\n//! the actual modification time is different for all build artifacts, which\n//! if we tracked the actual values of modification times would cause\n//! unnecessary recompiles. To fix this we instead only track paths which are\n//! relevant. These paths are checked dynamically to see if they're up to\n//! date, and the modification time doesn't make its way into the fingerprint\n//! hash.\n//!\n//! * Absolute path names. We strive to maintain a property where if you rename\n//! a project directory Cargo will continue to preserve all build artifacts\n//! and reuse the cache. This means that we can't ever hash an absolute path\n//! name. Instead we always hash relative path names and the \"root\" is passed\n//! in at runtime dynamically. Some of this is best effort, but the general\n//! idea is that we assume all accesses within a crate stay within that\n//! crate.\n//!\n//! These are pretty tricky to test for unfortunately, but we should have a good\n//! test suite nowadays and lord knows Cargo gets enough testing in the wild!\n//!\n//! ## Build scripts\n//!\n//! The *running* of a build script ([`CompileMode::RunCustomBuild`]) is treated\n//! significantly different than all other Unit kinds. It has its own function\n//! for calculating the Fingerprint ([`calculate_run_custom_build`]) and has some\n//! unique considerations. It does not track the same information as a normal\n//! Unit. The information tracked depends on the `rerun-if-changed` and\n//! `rerun-if-env-changed` statements produced by the build script. If the\n//! script does not emit either of these statements, the Fingerprint runs in\n//! \"old style\" mode where an mtime change of *any* file in the package will\n//! cause the build script to be re-run. Otherwise, the fingerprint *only*\n//! tracks the individual \"rerun-if\" items listed by the build script.\n//!\n//! The \"rerun-if\" statements from a *previous* build are stored in the build\n//! output directory in a file called `output`. Cargo parses this file when\n//! the Unit for that build script is prepared for the [`JobQueue`]. The\n//! Fingerprint code can then use that information to compute the Fingerprint\n//! and compare against the old fingerprint hash.\n//!\n//! Care must be taken with build script Fingerprints because the\n//! [`Fingerprint::local`] value may be changed after the build script runs\n//! (such as if the build script adds or removes \"rerun-if\" items).\n//!\n//! Another complication is if a build script is overridden. In that case, the\n//! fingerprint is the hash of the output of the override.\n//!\n//! ## Special considerations\n//!\n//! Registry dependencies do not track the mtime of files. This is because\n//! registry dependencies are not expected to change (if a new version is\n//! used, the Package ID will change, causing a rebuild). Cargo currently\n//! partially works with Docker caching. When a Docker image is built, it has\n//! normal mtime information. However, when a step is cached, the nanosecond\n//! portions of all files is zeroed out. Currently this works, but care must\n//! be taken for situations like these.\n//!\n//! HFS on macOS only supports 1 second timestamps. This causes a significant\n//! number of problems, particularly with Cargo's testsuite which does rapid\n//! builds in succession. Other filesystems have various degrees of\n//! resolution.\n//!\n//! Various weird filesystems (such as network filesystems) also can cause\n//! complications. Network filesystems may track the time on the server\n//! (except when the time is set manually such as with\n//! `filetime::set_file_times`). Not all filesystems support modifying the\n//! mtime.\n//!\n//! See the [`A-rebuild-detection`] label on the issue tracker for more.\n//!\n//! [`check_filesystem`]: Fingerprint::check_filesystem\n//! [`Metadata`]: crate::core::compiler::Metadata\n//! [`Metadata::unit_id`]: crate::core::compiler::Metadata::unit_id\n//! [`Metadata::c_metadata`]: crate::core::compiler::Metadata::c_metadata\n//! [`Metadata::c_extra_filename`]: crate::core::compiler::Metadata::c_extra_filename\n//! [`UnitHash`]: crate::core::compiler::UnitHash\n//! [`Profile`]: crate::core::profiles::Profile\n//! [`CompileMode`]: crate::core::compiler::CompileMode\n//! [`Lto`]: crate::core::compiler::Lto\n//! [`CompileKind`]: crate::core::compiler::CompileKind\n//! [`JobQueue`]: super::job_queue::JobQueue\n//! [`output_depinfo`]: super::output_depinfo()\n//! [`CheckDepInfo`]: LocalFingerprint::CheckDepInfo\n//! [`RerunIfChanged`]: LocalFingerprint::RerunIfChanged\n//! [`CompileMode::RunCustomBuild`]: crate::core::compiler::CompileMode::RunCustomBuild\n//! [`A-rebuild-detection`]: https://github.com/rust-lang/cargo/issues?q=is%3Aissue+is%3Aopen+label%3AA-rebuild-detection\n\nmod dep_info;\nmod dirty_reason;\nmod rustdoc;\n\nuse std::collections::hash_map::{Entry, HashMap};\nuse std::env;\nuse std::ffi::OsString;\nuse std::fs;\nuse std::fs::File;\nuse std::hash::{self, Hash, Hasher};\nuse std::io::{self};\nuse std::path::{Path, PathBuf};\nuse std::sync::{Arc, Mutex};\nuse std::time::SystemTime;\n\nuse anyhow::Context as _;\nuse anyhow::format_err;\nuse cargo_util::paths;\nuse filetime::FileTime;\nuse serde::de;\nuse serde::ser;\nuse serde::{Deserialize, Serialize};\nuse tracing::{debug, info};\n\nuse crate::core::Package;\nuse crate::core::compiler::unit_graph::UnitDep;\nuse crate::util;\nuse crate::util::errors::CargoResult;\nuse crate::util::interning::InternedString;\nuse crate::util::log_message::LogMessage;\nuse crate::util::{StableHasher, internal, path_args};\nuse crate::{CARGO_ENV, GlobalContext};\n\nuse super::BuildContext;\nuse super::BuildRunner;\nuse super::FileFlavor;\nuse super::Job;\nuse super::Unit;\nuse super::UnitIndex;\nuse super::Work;\nuse super::custom_build::BuildDeps;\n\npub use self::dep_info::Checksum;\npub use self::dep_info::parse_dep_info;\npub use self::dep_info::parse_rustc_dep_info;\npub use self::dep_info::translate_dep_info;\npub use self::dirty_reason::DirtyReason;\npub use self::rustdoc::RustdocFingerprint;\n\n/// Result of comparing fingerprints between the current and previous builds.\nenum FingerprintComparison {\n /// The unit does not need rebuilding.\n Fresh,\n /// The unit needs rebuilding.\n Dirty {\n /// The reason why the unit is dirty.\n reason: DirtyReason,\n },\n}\n\n/// Determines if a [`Unit`] is up-to-date, and if not prepares necessary work to\n/// update the persisted fingerprint.\n///\n/// This function will inspect `Unit`, calculate a fingerprint for it, and then\n/// return an appropriate [`Job`] to run. The returned `Job` will be a noop if\n/// `unit` is considered \"fresh\", or if it was previously built and cached.\n/// Otherwise the `Job` returned will write out the true fingerprint to the\n/// filesystem, to be executed after the unit's work has completed.\n///\n/// The `force` flag is a way to force the `Job` to be \"dirty\", or always\n/// update the fingerprint. **Beware using this flag** because it does not\n/// transitively propagate throughout the dependency graph, it only forces this\n/// one unit which is very unlikely to be what you want unless you're\n/// exclusively talking about top-level units.\n#[tracing::instrument(\n skip(build_runner, unit),\n fields(package_id = %unit.pkg.package_id(), target = unit.target.name())\n)]\npub fn prepare_target(\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n force: bool,\n) -> CargoResult {\n let bcx = build_runner.bcx;\n let loc = build_runner.files().fingerprint_file_path(unit, \"\");\n\n debug!(\"fingerprint at: {}\", loc.display());\n\n // Figure out if this unit is up to date. After calculating the fingerprint\n // compare it to an old version, if any, and attempt to print diagnostic\n // information about failed comparisons to aid in debugging.\n let fingerprint = calculate(build_runner, unit)?;\n let mtime_on_use = build_runner.bcx.gctx.cli_unstable().mtime_on_use;\n let dirty_reason = match compare_old_fingerprint(unit, &loc, &*fingerprint, mtime_on_use, force)\n {\n FingerprintComparison::Fresh => None,\n FingerprintComparison::Dirty { reason } => Some(reason),\n };\n\n if let Some(logger) = bcx.logger {\n let index = bcx.unit_to_index[unit];\n let mut cause = None;\n let status = match dirty_reason.as_ref() {\n Some(reason) if reason.is_fresh_build() => util::log_message::FingerprintStatus::New,\n Some(reason) => {\n cause = Some(reason.clone());\n util::log_message::FingerprintStatus::Dirty\n }\n None => util::log_message::FingerprintStatus::Fresh,\n };\n logger.log(LogMessage::UnitFingerprint {\n index,\n status,\n cause,\n });\n }\n\n let Some(dirty_reason) = dirty_reason else {\n return Ok(Job::new_fresh());\n };\n\n // We're going to rebuild, so ensure the source of the crate passes all\n // verification checks before we build it.\n //\n // The `Source::verify` method is intended to allow sources to execute\n // pre-build checks to ensure that the relevant source code is all\n // up-to-date and as expected. This is currently used primarily for\n // directory sources which will use this hook to perform an integrity check\n // on all files in the source to ensure they haven't changed. If they have\n // changed then an error is issued.\n let source_id = unit.pkg.package_id().source_id();\n let sources = bcx.packages.sources();\n let source = sources\n .get(source_id)\n .ok_or_else(|| internal(\"missing package source\"))?;\n source.verify(unit.pkg.package_id())?;\n\n // Clear out the old fingerprint file if it exists. This protects when\n // compilation is interrupted leaving a corrupt file. For example, a\n // project with a lib.rs and integration test (two units):\n //\n // 1. Build the library and integration test.\n // 2. Make a change to lib.rs (NOT the integration test).\n // 3. Build the integration test, hit Ctrl-C while linking. With gcc, this\n // will leave behind an incomplete executable (zero size, or partially\n // written). NOTE: The library builds successfully, it is the linking\n // of the integration test that we are interrupting.\n // 4. Build the integration test again.\n //\n // Without the following line, then step 3 will leave a valid fingerprint\n // on the disk. Then step 4 will think the integration test is \"fresh\"\n // because:\n //\n // - There is a valid fingerprint hash on disk (written in step 1).\n // - The mtime of the output file (the corrupt integration executable\n // written in step 3) is newer than all of its dependencies.\n // - The mtime of the integration test fingerprint dep-info file (written\n // in step 1) is newer than the integration test's source files, because\n // we haven't modified any of its source files.\n //\n // But the executable is corrupt and needs to be rebuilt. Clearing the\n // fingerprint at step 3 ensures that Cargo never mistakes a partially\n // written output as up-to-date.\n if loc.exists() {\n // Truncate instead of delete so that compare_old_fingerprint will\n // still log the reason for the fingerprint failure instead of just\n // reporting \"failed to read fingerprint\" during the next build if\n // this build fails.\n paths::write(&loc, b\"\")?;\n }\n\n let write_fingerprint = if unit.mode.is_run_custom_build() {\n // For build scripts the `local` field of the fingerprint may change\n // while we're executing it. For example it could be in the legacy\n // \"consider everything a dependency mode\" and then we switch to \"deps\n // are explicitly specified\" mode.\n //\n // To handle this movement we need to regenerate the `local` field of a\n // build script's fingerprint after it's executed. We do this by\n // using the `build_script_local_fingerprints` function which returns a\n // thunk we can invoke on a foreign thread to calculate this.\n let build_script_outputs = Arc::clone(&build_runner.build_script_outputs);\n let metadata = build_runner.get_run_build_script_metadata(unit);\n let (gen_local, _overridden) = build_script_local_fingerprints(build_runner, unit)?;\n let output_path = build_runner.build_explicit_deps[unit]\n .build_script_output\n .clone();\n Work::new(move |_| {\n let outputs = build_script_outputs.lock().unwrap();\n let output = outputs\n .get(metadata)\n .expect(\"output must exist after running\");\n let deps = BuildDeps::new(&output_path, Some(output));\n\n // FIXME: it's basically buggy that we pass `None` to `call_box`\n // here. See documentation on `build_script_local_fingerprints`\n // below for more information. Despite this just try to proceed and\n // hobble along if it happens to return `Some`.\n if let Some(new_local) = (gen_local)(&deps, None)? {\n *fingerprint.local.lock().unwrap() = new_local;\n }\n\n write_fingerprint(&loc, &fingerprint)\n })\n } else {\n Work::new(move |_| write_fingerprint(&loc, &fingerprint))\n };\n\n Ok(Job::new_dirty(write_fingerprint, dirty_reason))\n}\n\n/// Dependency edge information for fingerprints. This is generated for each\n/// dependency and is stored in a [`Fingerprint`].\n#[derive(Clone)]\nstruct DepFingerprint {\n /// The hash of the package id that this dependency points to\n pkg_id: u64,\n /// The crate name we're using for this dependency, which if we change we'll\n /// need to recompile!\n name: InternedString,\n /// Whether or not this dependency is flagged as a public dependency or not.\n public: bool,\n /// Whether or not this dependency is an rmeta dependency or a \"full\"\n /// dependency. In the case of an rmeta dependency our dependency edge only\n /// actually requires the rmeta from what we depend on, so when checking\n /// mtime information all files other than the rmeta can be ignored.\n only_requires_rmeta: bool,\n /// The dependency's fingerprint we recursively point to, containing all the\n /// other hash information we'd otherwise need.\n fingerprint: Arc,\n}\n\n/// A fingerprint can be considered to be a \"short string\" representing the\n/// state of a world for a package.\n///\n/// If a fingerprint ever changes, then the package itself needs to be\n/// recompiled. Inputs to the fingerprint include source code modifications,\n/// compiler flags, compiler version, etc. This structure is not simply a\n/// `String` due to the fact that some fingerprints cannot be calculated lazily.\n///\n/// Path sources, for example, use the mtime of the corresponding dep-info file\n/// as a fingerprint (all source files must be modified *before* this mtime).\n/// This dep-info file is not generated, however, until after the crate is\n/// compiled. As a result, this structure can be thought of as a fingerprint\n/// to-be. The actual value can be calculated via [`hash_u64()`], but the operation\n/// may fail as some files may not have been generated.\n///\n/// Note that dependencies are taken into account for fingerprints because rustc\n/// requires that whenever an upstream crate is recompiled that all downstream\n/// dependents are also recompiled. This is typically tracked through\n/// [`DependencyQueue`], but it also needs to be retained here because Cargo can\n/// be interrupted while executing, losing the state of the [`DependencyQueue`]\n/// graph.\n///\n/// [`hash_u64()`]: crate::core::compiler::fingerprint::Fingerprint::hash_u64\n/// [`DependencyQueue`]: crate::util::DependencyQueue\n#[derive(Serialize, Deserialize)]\npub struct Fingerprint {\n /// Hash of the version of `rustc` used.\n rustc: u64,\n /// Sorted list of cfg features enabled.\n features: String,\n /// Sorted list of all the declared cfg features.\n declared_features: String,\n /// Hash of the `Target` struct, including the target name,\n /// package-relative source path, edition, etc.\n target: u64,\n /// Hash of the [`Profile`], [`CompileMode`], and any extra flags passed via\n /// `cargo rustc` or `cargo rustdoc`.\n ///\n /// [`Profile`]: crate::core::profiles::Profile\n /// [`CompileMode`]: crate::core::compiler::CompileMode\n profile: u64,\n /// Hash of the path to the base source file. This is relative to the\n /// workspace root for path members, or absolute for other sources.\n path: u64,\n /// Fingerprints of dependencies.\n deps: Vec,\n /// Information about the inputs that affect this Unit (such as source\n /// file mtimes or build script environment variables).\n local: Mutex>,\n /// Cached hash of the [`Fingerprint`] struct. Used to improve performance\n /// for hashing.\n #[serde(skip)]\n memoized_hash: Mutex>,\n /// RUSTFLAGS/RUSTDOCFLAGS environment variable value (or config value).\n rustflags: Vec,\n /// Hash of various config settings that change how things are compiled.\n config: u64,\n /// The rustc target. This is only relevant for `.json` files, otherwise\n /// the metadata hash segregates the units.\n compile_kind: u64,\n /// Unit index for this fingerprint, used for tracing cascading rebuilds.\n /// Not persisted to disk as indices can change between builds.\n #[serde(skip)]\n index: UnitIndex,\n /// Description of whether the filesystem status for this unit is up to date\n /// or should be considered stale.\n #[serde(skip)]\n fs_status: FsStatus,\n /// Files, relative to `target_root`, that are produced by the step that\n /// this `Fingerprint` represents. This is used to detect when the whole\n /// fingerprint is out of date if this is missing, or if previous\n /// fingerprints output files are regenerated and look newer than this one.\n #[serde(skip)]\n outputs: Vec,\n}\n\n/// Indication of the status on the filesystem for a particular unit.\n#[derive(Clone, Default, Debug, Serialize, Deserialize)]\n#[serde(tag = \"fs_status\", rename_all = \"kebab-case\")]\npub enum FsStatus {\n /// This unit is to be considered stale, even if hash information all\n /// matches.\n #[default]\n Stale,\n\n /// File system inputs have changed (or are missing), or there were\n /// changes to the environment variables that affect this unit. See\n /// the variants of [`StaleItem`] for more information.\n StaleItem(StaleItem),\n\n /// A dependency was stale.\n StaleDependency {\n unit: UnitIndex,\n #[serde(with = \"serde_file_time\")]\n dep_mtime: FileTime,\n #[serde(with = \"serde_file_time\")]\n max_mtime: FileTime,\n },\n\n /// A dependency's fingerprint was stale.\n StaleDepFingerprint { unit: UnitIndex },\n\n /// This unit is up-to-date. All outputs and their corresponding mtime are\n /// listed in the payload here for other dependencies to compare against.\n #[serde(skip)]\n UpToDate { mtimes: HashMap },\n}\n\nimpl FsStatus {\n fn up_to_date(&self) -> bool {\n match self {\n FsStatus::UpToDate { .. } => true,\n FsStatus::Stale\n | FsStatus::StaleItem(_)\n | FsStatus::StaleDependency { .. }\n | FsStatus::StaleDepFingerprint { .. } => false,\n }\n }\n}\n\nmod serde_file_time {\n use filetime::FileTime;\n use serde::Deserialize;\n use serde::Serialize;\n\n /// Serialize FileTime as milliseconds with nano.\n pub(super) fn serialize(ft: &FileTime, s: S) -> Result\n where\n S: serde::Serializer,\n {\n let secs_as_millis = ft.unix_seconds() as f64 * 1000.0;\n let nanos_as_millis = ft.nanoseconds() as f64 / 1_000_000.0;\n (secs_as_millis + nanos_as_millis).serialize(s)\n }\n\n /// Deserialize FileTime from milliseconds with nano.\n pub(super) fn deserialize<'de, D>(d: D) -> Result\n where\n D: serde::Deserializer<'de>,\n {\n let millis = f64::deserialize(d)?;\n let secs = (millis / 1000.0) as i64;\n let nanos = ((millis % 1000.0) * 1_000_000.0) as u32;\n Ok(FileTime::from_unix_time(secs, nanos))\n }\n}\n\nimpl Serialize for DepFingerprint {\n fn serialize(&self, ser: S) -> Result\n where\n S: ser::Serializer,\n {\n (\n &self.pkg_id,\n &self.name,\n &self.public,\n &self.fingerprint.hash_u64(),\n )\n .serialize(ser)\n }\n}\n\nimpl<'de> Deserialize<'de> for DepFingerprint {\n fn deserialize(d: D) -> Result\n where\n D: de::Deserializer<'de>,\n {\n let (pkg_id, name, public, hash) = <(u64, String, bool, u64)>::deserialize(d)?;\n Ok(DepFingerprint {\n pkg_id,\n name: name.into(),\n public,\n fingerprint: Arc::new(Fingerprint {\n memoized_hash: Mutex::new(Some(hash)),\n ..Fingerprint::new()\n }),\n // This field is never read since it's only used in\n // `check_filesystem` which isn't used by fingerprints loaded from\n // disk.\n only_requires_rmeta: false,\n })\n }\n}\n\n/// A `LocalFingerprint` represents something that we use to detect direct\n/// changes to a `Fingerprint`.\n///\n/// This is where we track file information, env vars, etc. This\n/// `LocalFingerprint` struct is hashed and if the hash changes will force a\n/// recompile of any fingerprint it's included into. Note that the \"local\"\n/// terminology comes from the fact that it only has to do with one crate, and\n/// `Fingerprint` tracks the transitive propagation of fingerprint changes.\n///\n/// Note that because this is hashed its contents are carefully managed. Like\n/// mentioned in the above module docs, we don't want to hash absolute paths or\n/// mtime information.\n///\n/// Also note that a `LocalFingerprint` is used in `check_filesystem` to detect\n/// when the filesystem contains stale information (based on mtime currently).\n/// The paths here don't change much between compilations but they're used as\n/// inputs when we probe the filesystem looking at information.\n#[derive(Debug, Serialize, Deserialize, Hash)]\nenum LocalFingerprint {\n /// This is a precalculated fingerprint which has an opaque string we just\n /// hash as usual. This variant is primarily used for rustdoc where we\n /// don't have a dep-info file to compare against.\n ///\n /// This is also used for build scripts with no `rerun-if-*` statements, but\n /// that's overall a mistake and causes bugs in Cargo. We shouldn't use this\n /// for build scripts.\n Precalculated(String),\n\n /// This is used for crate compilations. The `dep_info` file is a relative\n /// path anchored at `target_root(...)` to the dep-info file that Cargo\n /// generates (which is a custom serialization after parsing rustc's own\n /// `dep-info` output).\n ///\n /// The `dep_info` file, when present, also lists a number of other files\n /// for us to look at. If any of those files are newer than this file then\n /// we need to recompile.\n ///\n /// If the `checksum` bool is true then the `dep_info` file is expected to\n /// contain file checksums instead of file mtimes.\n CheckDepInfo { dep_info: PathBuf, checksum: bool },\n\n /// This represents a nonempty set of `rerun-if-changed` annotations printed\n /// out by a build script. The `output` file is a relative file anchored at\n /// `target_root(...)` which is the actual output of the build script. That\n /// output has already been parsed and the paths printed out via\n /// `rerun-if-changed` are listed in `paths`. The `paths` field is relative\n /// to `pkg.root()`\n ///\n /// This is considered up-to-date if all of the `paths` are older than\n /// `output`, otherwise we need to recompile.\n RerunIfChanged {\n output: PathBuf,\n paths: Vec,\n },\n\n /// This represents a single `rerun-if-env-changed` annotation printed by a\n /// build script. The exact env var and value are hashed here. There's no\n /// filesystem dependence here, and if the values are changed the hash will\n /// change forcing a recompile.\n RerunIfEnvChanged { var: String, val: Option },\n}\n\n/// See [`FsStatus::StaleItem`].\n#[derive(Clone, Debug, Serialize, Deserialize)]\n#[serde(tag = \"stale_item\", rename_all = \"kebab-case\")]\npub enum StaleItem {\n MissingFile {\n path: PathBuf,\n },\n UnableToReadFile {\n path: PathBuf,\n },\n FailedToReadMetadata {\n path: PathBuf,\n },\n FileSizeChanged {\n path: PathBuf,\n old_size: u64,\n new_size: u64,\n },\n ChangedFile {\n reference: PathBuf,\n #[serde(with = \"serde_file_time\")]\n reference_mtime: FileTime,\n stale: PathBuf,\n #[serde(with = \"serde_file_time\")]\n stale_mtime: FileTime,\n },\n ChangedChecksum {\n source: PathBuf,\n stored_checksum: Checksum,\n new_checksum: Checksum,\n },\n MissingChecksum {\n path: PathBuf,\n },\n ChangedEnv {\n var: String,\n previous: Option,\n current: Option,\n },\n}\n\nimpl LocalFingerprint {\n /// Read the environment variable of the given env `key`, and creates a new\n /// [`LocalFingerprint::RerunIfEnvChanged`] for it. The `env_config` is used firstly\n /// to check if the env var is set in the config system as some envs need to be overridden.\n /// If not, it will fallback to `std::env::var`.\n ///\n // TODO: `std::env::var` is allowed at this moment. Should figure out\n // if it makes sense if permitting to read env from the env snapshot.\n #[allow(clippy::disallowed_methods)]\n fn from_env>(\n key: K,\n env_config: &Arc>,\n ) -> LocalFingerprint {\n let key = key.as_ref();\n let var = key.to_owned();\n let val = if let Some(val) = env_config.get(key) {\n val.to_str().map(ToOwned::to_owned)\n } else {\n env::var(key).ok()\n };\n LocalFingerprint::RerunIfEnvChanged { var, val }\n }\n\n /// Checks dynamically at runtime if this `LocalFingerprint` has a stale\n /// item inside of it.\n ///\n /// The main purpose of this function is to handle two different ways\n /// fingerprints can be invalidated:\n ///\n /// * One is a dependency listed in rustc's dep-info files is invalid. Note\n /// that these could either be env vars or files. We check both here.\n ///\n /// * Another is the `rerun-if-changed` directive from build scripts. This\n /// is where we'll find whether files have actually changed\n fn find_stale_item(\n &self,\n mtime_cache: &mut HashMap,\n checksum_cache: &mut HashMap,\n pkg: &Package,\n build_root: &Path,\n cargo_exe: &Path,\n gctx: &GlobalContext,\n ) -> CargoResult> {\n let pkg_root = pkg.root();\n match self {\n // We need to parse `dep_info`, learn about the crate's dependencies.\n //\n // For each env var we see if our current process's env var still\n // matches, and for each file we see if any of them are newer than\n // the `dep_info` file itself whose mtime represents the start of\n // rustc.\n LocalFingerprint::CheckDepInfo { dep_info, checksum } => {\n let dep_info = build_root.join(dep_info);\n let Some(info) = parse_dep_info(pkg_root, build_root, &dep_info)? else {\n return Ok(Some(StaleItem::MissingFile { path: dep_info }));\n };\n for (key, previous) in info.env.iter() {\n if let Some(value) = pkg.manifest().metadata().env_var(key.as_str()) {\n if Some(value.as_ref()) == previous.as_deref() {\n continue;\n }\n }\n\n let current = if key == CARGO_ENV {\n Some(cargo_exe.to_str().ok_or_else(|| {\n format_err!(\n \"cargo exe path {} must be valid UTF-8\",\n cargo_exe.display()\n )\n })?)\n } else {\n if let Some(value) = gctx.env_config()?.get(key) {\n value.to_str()\n } else {\n gctx.get_env(key).ok()\n }\n };\n if current == previous.as_deref() {\n continue;\n }\n return Ok(Some(StaleItem::ChangedEnv {\n var: key.clone(),\n previous: previous.clone(),\n current: current.map(Into::into),\n }));\n }\n if *checksum {\n Ok(find_stale_file(\n mtime_cache,\n checksum_cache,\n &dep_info,\n info.files.iter().map(|(file, checksum)| (file, *checksum)),\n *checksum,\n ))\n } else {\n Ok(find_stale_file(\n mtime_cache,\n checksum_cache,\n &dep_info,\n info.files.into_keys().map(|p| (p, None)),\n *checksum,\n ))\n }\n }\n\n // We need to verify that no paths listed in `paths` are newer than\n // the `output` path itself, or the last time the build script ran.\n LocalFingerprint::RerunIfChanged { output, paths } => Ok(find_stale_file(\n mtime_cache,\n checksum_cache,\n &build_root.join(output),\n paths.iter().map(|p| (pkg_root.join(p), None)),\n false,\n )),\n\n // These have no dependencies on the filesystem, and their values\n // are included natively in the `Fingerprint` hash so nothing\n // tocheck for here.\n LocalFingerprint::RerunIfEnvChanged { .. } => Ok(None),\n LocalFingerprint::Precalculated(..) => Ok(None),\n }\n }\n\n fn kind(&self) -> &'static str {\n match self {\n LocalFingerprint::Precalculated(..) => \"precalculated\",\n LocalFingerprint::CheckDepInfo { .. } => \"dep-info\",\n LocalFingerprint::RerunIfChanged { .. } => \"rerun-if-changed\",\n LocalFingerprint::RerunIfEnvChanged { .. } => \"rerun-if-env-changed\",\n }\n }\n}\n\nimpl Fingerprint {\n fn new() -> Fingerprint {\n Fingerprint {\n rustc: 0,\n target: 0,\n profile: 0,\n path: 0,\n features: String::new(),\n declared_features: String::new(),\n deps: Vec::new(),\n local: Mutex::new(Vec::new()),\n memoized_hash: Mutex::new(None),\n rustflags: Vec::new(),\n config: 0,\n compile_kind: 0,\n index: UnitIndex::default(),\n fs_status: FsStatus::Stale,\n outputs: Vec::new(),\n }\n }\n\n /// For performance reasons fingerprints will memoize their own hash, but\n /// there's also internal mutability with its `local` field which can\n /// change, for example with build scripts, during a build.\n ///\n /// This method can be used to bust all memoized hashes just before a build\n /// to ensure that after a build completes everything is up-to-date.\n pub fn clear_memoized(&self) {\n *self.memoized_hash.lock().unwrap() = None;\n }\n\n fn hash_u64(&self) -> u64 {\n if let Some(s) = *self.memoized_hash.lock().unwrap() {\n return s;\n }\n let ret = util::hash_u64(self);\n *self.memoized_hash.lock().unwrap() = Some(ret);\n ret\n }\n\n /// Compares this fingerprint with an old version which was previously\n /// serialized to filesystem.\n ///\n /// The purpose of this is exclusively to produce a diagnostic message\n /// [`DirtyReason`], indicating why we're recompiling something.\n fn compare(&self, old: &Fingerprint) -> DirtyReason {\n if self.rustc != old.rustc {\n return DirtyReason::RustcChanged;\n }\n if self.features != old.features {\n return DirtyReason::FeaturesChanged {\n old: old.features.clone(),\n new: self.features.clone(),\n };\n }\n if self.declared_features != old.declared_features {\n return DirtyReason::DeclaredFeaturesChanged {\n old: old.declared_features.clone(),\n new: self.declared_features.clone(),\n };\n }\n if self.target != old.target {\n return DirtyReason::TargetConfigurationChanged;\n }\n if self.path != old.path {\n return DirtyReason::PathToSourceChanged;\n }\n if self.profile != old.profile {\n return DirtyReason::ProfileConfigurationChanged;\n }\n if self.rustflags != old.rustflags {\n return DirtyReason::RustflagsChanged {\n old: old.rustflags.clone(),\n new: self.rustflags.clone(),\n };\n }\n if self.config != old.config {\n return DirtyReason::ConfigSettingsChanged;\n }\n if self.compile_kind != old.compile_kind {\n return DirtyReason::CompileKindChanged;\n }\n let my_local = self.local.lock().unwrap();\n let old_local = old.local.lock().unwrap();\n if my_local.len() != old_local.len() {\n return DirtyReason::LocalLengthsChanged;\n }\n for (new, old) in my_local.iter().zip(old_local.iter()) {\n match (new, old) {\n (LocalFingerprint::Precalculated(a), LocalFingerprint::Precalculated(b)) => {\n if a != b {\n return DirtyReason::PrecalculatedComponentsChanged {\n old: b.to_string(),\n new: a.to_string(),\n };\n }\n }\n (\n LocalFingerprint::CheckDepInfo {\n dep_info: a_dep,\n checksum: checksum_a,\n },\n LocalFingerprint::CheckDepInfo {\n dep_info: b_dep,\n checksum: checksum_b,\n },\n ) => {\n if a_dep != b_dep {\n return DirtyReason::DepInfoOutputChanged {\n old: b_dep.clone(),\n new: a_dep.clone(),\n };\n }\n if checksum_a != checksum_b {\n return DirtyReason::ChecksumUseChanged { old: *checksum_b };\n }\n }\n (\n LocalFingerprint::RerunIfChanged {\n output: a_out,\n paths: a_paths,\n },\n LocalFingerprint::RerunIfChanged {\n output: b_out,\n paths: b_paths,\n },\n ) => {\n if a_out != b_out {\n return DirtyReason::RerunIfChangedOutputFileChanged {\n old: b_out.clone(),\n new: a_out.clone(),\n };\n }\n if a_paths != b_paths {\n return DirtyReason::RerunIfChangedOutputPathsChanged {\n old: b_paths.clone(),\n new: a_paths.clone(),\n };\n }\n }\n (\n LocalFingerprint::RerunIfEnvChanged {\n var: a_key,\n val: a_value,\n },\n LocalFingerprint::RerunIfEnvChanged {\n var: b_key,\n val: b_value,\n },\n ) => {\n if *a_key != *b_key {\n return DirtyReason::EnvVarsChanged {\n old: b_key.clone(),\n new: a_key.clone(),\n };\n }\n if *a_value != *b_value {\n return DirtyReason::EnvVarChanged {\n name: a_key.clone(),\n old_value: b_value.clone(),\n new_value: a_value.clone(),\n };\n }\n }\n (a, b) => {\n return DirtyReason::LocalFingerprintTypeChanged {\n old: b.kind().to_owned(),\n new: a.kind().to_owned(),\n };\n }\n }\n }\n\n if self.deps.len() != old.deps.len() {\n return DirtyReason::NumberOfDependenciesChanged {\n old: old.deps.len(),\n new: self.deps.len(),\n };\n }\n for (a, b) in self.deps.iter().zip(old.deps.iter()) {\n if a.name != b.name {\n return DirtyReason::UnitDependencyNameChanged {\n old: b.name,\n new: a.name,\n };\n }\n\n if a.fingerprint.hash_u64() != b.fingerprint.hash_u64() {\n return DirtyReason::UnitDependencyInfoChanged {\n unit: a.fingerprint.index,\n };\n }\n }\n\n if !self.fs_status.up_to_date() {\n return DirtyReason::FsStatusOutdated(self.fs_status.clone());\n }\n\n // This typically means some filesystem modifications happened or\n // something transitive was odd. In general we should strive to provide\n // a better error message than this, so if you see this message a lot it\n // likely means this method needs to be updated!\n DirtyReason::NothingObvious\n }\n\n /// Dynamically inspect the local filesystem to update the `fs_status` field\n /// of this `Fingerprint`.\n ///\n /// This function is used just after a `Fingerprint` is constructed to check\n /// the local state of the filesystem and propagate any dirtiness from\n /// dependencies up to this unit as well. This function assumes that the\n /// unit starts out as [`FsStatus::Stale`] and then it will optionally switch\n /// it to `UpToDate` if it can.\n fn check_filesystem(\n &mut self,\n mtime_cache: &mut HashMap,\n checksum_cache: &mut HashMap,\n pkg: &Package,\n build_root: &Path,\n cargo_exe: &Path,\n gctx: &GlobalContext,\n ) -> CargoResult<()> {\n assert!(!self.fs_status.up_to_date());\n\n let pkg_root = pkg.root();\n let mut mtimes = HashMap::new();\n\n // Get the `mtime` of all outputs. Optionally update their mtime\n // afterwards based on the `mtime_on_use` flag. Afterwards we want the\n // minimum mtime as it's the one we'll be comparing to inputs and\n // dependencies.\n for output in self.outputs.iter() {\n let Ok(mtime) = paths::mtime(output) else {\n // This path failed to report its `mtime`. It probably doesn't\n // exists, so leave ourselves as stale and bail out.\n let item = StaleItem::FailedToReadMetadata {\n path: output.clone(),\n };\n self.fs_status = FsStatus::StaleItem(item);\n return Ok(());\n };\n assert!(mtimes.insert(output.clone(), mtime).is_none());\n }\n\n let opt_max = mtimes.iter().max_by_key(|kv| kv.1);\n let Some((max_path, max_mtime)) = opt_max else {\n // We had no output files. This means we're an overridden build\n // script and we're just always up to date because we aren't\n // watching the filesystem.\n self.fs_status = FsStatus::UpToDate { mtimes };\n return Ok(());\n };\n debug!(\n \"max output mtime for {:?} is {:?} {}\",\n pkg_root, max_path, max_mtime\n );\n\n for dep in self.deps.iter() {\n let dep_mtimes = match &dep.fingerprint.fs_status {\n FsStatus::UpToDate { mtimes } => mtimes,\n // If our dependency is stale, so are we, so bail out.\n FsStatus::Stale\n | FsStatus::StaleItem(_)\n | FsStatus::StaleDependency { .. }\n | FsStatus::StaleDepFingerprint { .. } => {\n self.fs_status = FsStatus::StaleDepFingerprint {\n unit: dep.fingerprint.index,\n };\n return Ok(());\n }\n };\n\n // If our dependency edge only requires the rmeta file to be present\n // then we only need to look at that one output file, otherwise we\n // need to consider all output files to see if we're out of date.\n let (dep_path, dep_mtime) = if dep.only_requires_rmeta {\n dep_mtimes\n .iter()\n .find(|(path, _mtime)| {\n path.extension().and_then(|s| s.to_str()) == Some(\"rmeta\")\n })\n .expect(\"failed to find rmeta\")\n } else {\n match dep_mtimes.iter().max_by_key(|kv| kv.1) {\n Some(dep_mtime) => dep_mtime,\n // If our dependencies is up to date and has no filesystem\n // interactions, then we can move on to the next dependency.\n None => continue,\n }\n };\n debug!(\n \"max dep mtime for {:?} is {:?} {}\",\n pkg_root, dep_path, dep_mtime\n );\n\n // If the dependency is newer than our own output then it was\n // recompiled previously. We transitively become stale ourselves in\n // that case, so bail out.\n //\n // Note that this comparison should probably be `>=`, not `>`, but\n // for a discussion of why it's `>` see the discussion about #5918\n // below in `find_stale`.\n if dep_mtime > max_mtime {\n info!(\n \"dependency on `{}` is newer than we are {} > {} {:?}\",\n dep.name, dep_mtime, max_mtime, pkg_root\n );\n\n self.fs_status = FsStatus::StaleDependency {\n unit: dep.fingerprint.index,\n dep_mtime: *dep_mtime,\n max_mtime: *max_mtime,\n };\n\n return Ok(());\n }\n }\n\n // If we reached this far then all dependencies are up to date. Check\n // all our `LocalFingerprint` information to see if we have any stale\n // files for this package itself. If we do find something log a helpful\n // message and bail out so we stay stale.\n for local in self.local.get_mut().unwrap().iter() {\n if let Some(item) = local.find_stale_item(\n mtime_cache,\n checksum_cache,\n pkg,\n build_root,\n cargo_exe,\n gctx,\n )? {\n item.log();\n self.fs_status = FsStatus::StaleItem(item);\n return Ok(());\n }\n }\n\n // Everything was up to date! Record such.\n self.fs_status = FsStatus::UpToDate { mtimes };\n debug!(\"filesystem up-to-date {:?}\", pkg_root);\n\n Ok(())\n }\n}\n\nimpl hash::Hash for Fingerprint {\n fn hash(&self, h: &mut H) {\n let Fingerprint {\n rustc,\n ref features,\n ref declared_features,\n target,\n path,\n profile,\n ref deps,\n ref local,\n config,\n compile_kind,\n ref rustflags,\n ..\n } = *self;\n let local = local.lock().unwrap();\n (\n rustc,\n features,\n declared_features,\n target,\n path,\n profile,\n &*local,\n config,\n compile_kind,\n rustflags,\n )\n .hash(h);\n\n h.write_usize(deps.len());\n for DepFingerprint {\n pkg_id,\n name,\n public,\n fingerprint,\n only_requires_rmeta: _, // static property, no need to hash\n } in deps\n {\n pkg_id.hash(h);\n name.hash(h);\n public.hash(h);\n // use memoized dep hashes to avoid exponential blowup\n h.write_u64(fingerprint.hash_u64());\n }\n }\n}\n\nimpl DepFingerprint {\n fn new(\n build_runner: &mut BuildRunner<'_, '_>,\n parent: &Unit,\n dep: &UnitDep,\n ) -> CargoResult {\n let fingerprint = calculate(build_runner, &dep.unit)?;\n // We need to be careful about what we hash here. We have a goal of\n // supporting renaming a project directory and not rebuilding\n // everything. To do that, however, we need to make sure that the cwd\n // doesn't make its way into any hashes, and one source of that is the\n // `SourceId` for `path` packages.\n //\n // We already have a requirement that `path` packages all have unique\n // names (sort of for this same reason), so if the package source is a\n // `path` then we just hash the name, but otherwise we hash the full\n // id as it won't change when the directory is renamed.\n let pkg_id = if dep.unit.pkg.package_id().source_id().is_path() {\n util::hash_u64(dep.unit.pkg.package_id().name())\n } else {\n util::hash_u64(dep.unit.pkg.package_id())\n };\n\n Ok(DepFingerprint {\n pkg_id,\n name: dep.extern_crate_name,\n public: dep.public,\n fingerprint,\n only_requires_rmeta: build_runner.only_requires_rmeta(parent, &dep.unit),\n })\n }\n}\n\nimpl StaleItem {\n /// Use the `log` crate to log a hopefully helpful message in diagnosing\n /// what file is considered stale and why. This is intended to be used in\n /// conjunction with `CARGO_LOG` to determine why Cargo is recompiling\n /// something. Currently there's no user-facing usage of this other than\n /// that.\n fn log(&self) {\n match self {\n StaleItem::MissingFile { path } => {\n info!(\"stale: missing {:?}\", path);\n }\n StaleItem::UnableToReadFile { path } => {\n info!(\"stale: unable to read {:?}\", path);\n }\n StaleItem::FailedToReadMetadata { path } => {\n info!(\"stale: couldn't read metadata {:?}\", path);\n }\n StaleItem::ChangedFile {\n reference,\n reference_mtime,\n stale,\n stale_mtime,\n } => {\n info!(\"stale: changed {:?}\", stale);\n info!(\" (vs) {:?}\", reference);\n info!(\" {:?} < {:?}\", reference_mtime, stale_mtime);\n }\n StaleItem::FileSizeChanged {\n path,\n new_size,\n old_size,\n } => {\n info!(\"stale: changed {:?}\", path);\n info!(\"prior file size {old_size}\");\n info!(\" new file size {new_size}\");\n }\n StaleItem::ChangedChecksum {\n source,\n stored_checksum,\n new_checksum,\n } => {\n info!(\"stale: changed {:?}\", source);\n info!(\"prior checksum {stored_checksum}\");\n info!(\" new checksum {new_checksum}\");\n }\n StaleItem::MissingChecksum { path } => {\n info!(\"stale: no prior checksum {:?}\", path);\n }\n StaleItem::ChangedEnv {\n var,\n previous,\n current,\n } => {\n info!(\"stale: changed env {:?}\", var);\n info!(\" {:?} != {:?}\", previous, current);\n }\n }\n }\n}\n\n/// Calculates the fingerprint for a [`Unit`].\n///\n/// This fingerprint is used by Cargo to learn about when information such as:\n///\n/// * A non-path package changes (changes version, changes revision, etc).\n/// * Any dependency changes\n/// * The compiler changes\n/// * The set of features a package is built with changes\n/// * The profile a target is compiled with changes (e.g., opt-level changes)\n/// * Any other compiler flags change that will affect the result\n///\n/// Information like file modification time is only calculated for path\n/// dependencies.\nfn calculate(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResult> {\n // This function is slammed quite a lot, so the result is memoized.\n if let Some(s) = build_runner.fingerprints.get(unit) {\n return Ok(Arc::clone(s));\n }\n let mut fingerprint = if unit.mode.is_run_custom_build() {\n calculate_run_custom_build(build_runner, unit)?\n } else if unit.mode.is_doc_test() {\n panic!(\"doc tests do not fingerprint\");\n } else {\n calculate_normal(build_runner, unit)?\n };\n\n // After we built the initial `Fingerprint` be sure to update the\n // `fs_status` field of it.\n let build_root = build_root(build_runner);\n let cargo_exe = build_runner.bcx.gctx.cargo_exe()?;\n fingerprint.check_filesystem(\n &mut build_runner.mtime_cache,\n &mut build_runner.checksum_cache,\n &unit.pkg,\n &build_root,\n cargo_exe,\n build_runner.bcx.gctx,\n )?;\n\n let fingerprint = Arc::new(fingerprint);\n build_runner\n .fingerprints\n .insert(unit.clone(), Arc::clone(&fingerprint));\n Ok(fingerprint)\n}\n\n/// Calculate a fingerprint for a \"normal\" unit, or anything that's not a build\n/// script. This is an internal helper of [`calculate`], don't call directly.\nfn calculate_normal(\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n) -> CargoResult {\n let deps = {\n // Recursively calculate the fingerprint for all of our dependencies.\n //\n // Skip fingerprints of binaries because they don't actually induce a\n // recompile, they're just dependencies in the sense that they need to be\n // built. The only exception here are artifact dependencies,\n // which is an actual dependency that needs a recompile.\n //\n // Create Vec since mutable build_runner is needed in closure.\n let deps = Vec::from(build_runner.unit_deps(unit));\n let mut deps = deps\n .into_iter()\n .filter(|dep| !dep.unit.target.is_bin() || dep.unit.artifact.is_true())\n .map(|dep| DepFingerprint::new(build_runner, unit, &dep))\n .collect::>>()?;\n deps.sort_by(|a, b| a.pkg_id.cmp(&b.pkg_id));\n deps\n };\n\n // Afterwards calculate our own fingerprint information.\n let build_root = build_root(build_runner);\n let is_any_doc_gen = unit.mode.is_doc() || unit.mode.is_doc_scrape();\n let rustdoc_depinfo_enabled = build_runner.bcx.gctx.cli_unstable().rustdoc_depinfo;\n let local = if is_any_doc_gen && !rustdoc_depinfo_enabled {\n // rustdoc does not have dep-info files.\n let fingerprint = pkg_fingerprint(build_runner.bcx, &unit.pkg).with_context(|| {\n format!(\n \"failed to determine package fingerprint for documenting {}\",\n unit.pkg\n )\n })?;\n vec![LocalFingerprint::Precalculated(fingerprint)]\n } else {\n let dep_info = dep_info_loc(build_runner, unit);\n let dep_info = dep_info.strip_prefix(&build_root).unwrap().to_path_buf();\n vec![LocalFingerprint::CheckDepInfo {\n dep_info,\n checksum: build_runner.bcx.gctx.cli_unstable().checksum_freshness,\n }]\n };\n\n // Figure out what the outputs of our unit is, and we'll be storing them\n // into the fingerprint as well.\n let outputs = build_runner\n .outputs(unit)?\n .iter()\n .filter(|output| {\n !matches!(\n output.flavor,\n FileFlavor::DebugInfo | FileFlavor::Auxiliary | FileFlavor::Sbom\n )\n })\n .map(|output| output.path.clone())\n .collect();\n\n // Fill out a bunch more information that we'll be tracking typically\n // hashed to take up less space on disk as we just need to know when things\n // change.\n let extra_flags = if unit.mode.is_doc() || unit.mode.is_doc_scrape() {\n &unit.rustdocflags\n } else {\n &unit.rustflags\n }\n .to_vec();\n\n let profile_hash = util::hash_u64((\n &unit.profile,\n unit.mode,\n build_runner.bcx.extra_args_for(unit),\n build_runner.lto[unit],\n unit.pkg.manifest().lint_rustflags(),\n ));\n let mut config = StableHasher::new();\n let linker = if unit.target.for_host() && !build_runner.bcx.gctx.target_applies_to_host()? {\n build_runner.compilation.host_linker()\n } else {\n build_runner.compilation.target_linker(unit.kind)\n };\n if let Some(linker) = linker {\n linker.hash(&mut config);\n }\n if unit.mode.is_doc() && build_runner.bcx.gctx.cli_unstable().rustdoc_map {\n if let Ok(map) = build_runner.bcx.gctx.doc_extern_map() {\n map.hash(&mut config);\n }\n }\n if let Some(allow_features) = &build_runner.bcx.gctx.cli_unstable().allow_features {\n allow_features.hash(&mut config);\n }\n // -Zno-embed-metadata changes how all units are compiled, and it also changes how we tell\n // rustc to link to deps using `--extern`. If it changes, we should rebuild everything.\n build_runner\n .bcx\n .gctx\n .cli_unstable()\n .no_embed_metadata\n .hash(&mut config);\n\n let compile_kind = unit.kind.fingerprint_hash();\n let mut declared_features = unit.pkg.summary().features().keys().collect::>();\n declared_features.sort(); // to avoid useless rebuild if the user orders it's features\n // differently\n Ok(Fingerprint {\n rustc: util::hash_u64(&build_runner.bcx.rustc().verbose_version),\n target: util::hash_u64(&unit.target),\n profile: profile_hash,\n // Note that .0 is hashed here, not .1 which is the cwd. That doesn't\n // actually affect the output artifact so there's no need to hash it.\n path: util::hash_u64(path_args(build_runner.bcx.ws, unit).0),\n features: format!(\"{:?}\", unit.features),\n declared_features: format!(\"{declared_features:?}\"),\n deps,\n local: Mutex::new(local),\n memoized_hash: Mutex::new(None),\n config: Hasher::finish(&config),\n compile_kind,\n index: build_runner.bcx.unit_to_index[unit],\n rustflags: extra_flags,\n fs_status: FsStatus::Stale,\n outputs,\n })\n}\n\n/// Calculate a fingerprint for an \"execute a build script\" unit. This is an\n/// internal helper of [`calculate`], don't call directly.\nfn calculate_run_custom_build(\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n) -> CargoResult {\n assert!(unit.mode.is_run_custom_build());\n // Using the `BuildDeps` information we'll have previously parsed and\n // inserted into `build_explicit_deps` built an initial snapshot of the\n // `LocalFingerprint` list for this build script. If we previously executed\n // the build script this means we'll be watching files and env vars.\n // Otherwise if we haven't previously executed it we'll just start watching\n // the whole crate.\n let (gen_local, overridden) = build_script_local_fingerprints(build_runner, unit)?;\n let deps = &build_runner.build_explicit_deps[unit];\n let local = (gen_local)(\n deps,\n Some(&|| {\n const IO_ERR_MESSAGE: &str = \"\\\nAn I/O error happened. Please make sure you can access the file.\n\nBy default, if your project contains a build script, cargo scans all files in\nit to determine whether a rebuild is needed. If you don't expect to access the\nfile, specify `rerun-if-changed` in your build script.\nSee https://doc.rust-lang.org/cargo/reference/build-scripts.html#rerun-if-changed for more information.\";\n pkg_fingerprint(build_runner.bcx, &unit.pkg).map_err(|err| {\n let mut message = format!(\"failed to determine package fingerprint for build script for {}\", unit.pkg);\n if err.root_cause().is::() {\n message = format!(\"{}\\n{}\", message, IO_ERR_MESSAGE)\n }\n err.context(message)\n })\n }),\n )?\n .unwrap();\n let output = deps.build_script_output.clone();\n\n // Include any dependencies of our execution, which is typically just the\n // compilation of the build script itself. (if the build script changes we\n // should be rerun!). Note though that if we're an overridden build script\n // we have no dependencies so no need to recurse in that case.\n let deps = if overridden {\n // Overridden build scripts don't need to track deps.\n vec![]\n } else {\n // Create Vec since mutable build_runner is needed in closure.\n let deps = Vec::from(build_runner.unit_deps(unit));\n deps.into_iter()\n .map(|dep| DepFingerprint::new(build_runner, unit, &dep))\n .collect::>>()?\n };\n\n let rustflags = unit.rustflags.to_vec();\n\n Ok(Fingerprint {\n local: Mutex::new(local),\n rustc: util::hash_u64(&build_runner.bcx.rustc().verbose_version),\n deps,\n outputs: if overridden { Vec::new() } else { vec![output] },\n rustflags,\n index: build_runner.bcx.unit_to_index[unit],\n\n // Most of the other info is blank here as we don't really include it\n // in the execution of the build script, but... this may be a latent\n // bug in Cargo.\n ..Fingerprint::new()\n })\n}\n\n/// Get ready to compute the [`LocalFingerprint`] values\n/// for a [`RunCustomBuild`] unit.\n///\n/// This function has, what's on the surface, a seriously wonky interface.\n/// You'll call this function and it'll return a closure and a boolean. The\n/// boolean is pretty simple in that it indicates whether the `unit` has been\n/// overridden via `.cargo/config.toml`. The closure is much more complicated.\n///\n/// This closure is intended to capture any local state necessary to compute\n/// the `LocalFingerprint` values for this unit. It is `Send` and `'static` to\n/// be sent to other threads as well (such as when we're executing build\n/// scripts). That deduplication is the rationale for the closure at least.\n///\n/// The arguments to the closure are a bit weirder, though, and I'll apologize\n/// in advance for the weirdness too. The first argument to the closure is a\n/// `&BuildDeps`. This is the parsed version of a build script, and when Cargo\n/// starts up this is cached from previous runs of a build script. After a\n/// build script executes the output file is reparsed and passed in here.\n///\n/// The second argument is the weirdest, it's *optionally* a closure to\n/// call [`pkg_fingerprint`]. The `pkg_fingerprint` requires access to\n/// \"source map\" located in `Context`. That's very non-`'static` and\n/// non-`Send`, so it can't be used on other threads, such as when we invoke\n/// this after a build script has finished. The `Option` allows us to for sure\n/// calculate it on the main thread at the beginning, and then swallow the bug\n/// for now where a worker thread after a build script has finished doesn't\n/// have access. Ideally there would be no second argument or it would be more\n/// \"first class\" and not an `Option` but something that can be sent between\n/// threads. In any case, it's a bug for now.\n///\n/// This isn't the greatest of interfaces, and if there's suggestions to\n/// improve please do so!\n///\n/// FIXME(#6779) - see all the words above\n///\n/// [`RunCustomBuild`]: crate::core::compiler::CompileMode::RunCustomBuild\nfn build_script_local_fingerprints(\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n) -> CargoResult<(\n Box<\n dyn FnOnce(\n &BuildDeps,\n Option<&dyn Fn() -> CargoResult>,\n ) -> CargoResult>>\n + Send,\n >,\n bool,\n)> {\n assert!(unit.mode.is_run_custom_build());\n // First up, if this build script is entirely overridden, then we just\n // return the hash of what we overrode it with. This is the easy case!\n if let Some(fingerprint) = build_script_override_fingerprint(build_runner, unit) {\n debug!(\"override local fingerprints deps {}\", unit.pkg);\n return Ok((\n Box::new(\n move |_: &BuildDeps, _: Option<&dyn Fn() -> CargoResult>| {\n Ok(Some(vec![fingerprint]))\n },\n ),\n true, // this is an overridden build script\n ));\n }\n\n // ... Otherwise this is a \"real\" build script and we need to return a real\n // closure. Our returned closure classifies the build script based on\n // whether it prints `rerun-if-*`. If it *doesn't* print this it's where the\n // magical second argument comes into play, which fingerprints a whole\n // package. Remember that the fact that this is an `Option` is a bug, but a\n // longstanding bug, in Cargo. Recent refactorings just made it painfully\n // obvious.\n let pkg_root = unit.pkg.root().to_path_buf();\n let build_dir = build_root(build_runner);\n let env_config = Arc::clone(build_runner.bcx.gctx.env_config()?);\n let calculate =\n move |deps: &BuildDeps, pkg_fingerprint: Option<&dyn Fn() -> CargoResult>| {\n if deps.rerun_if_changed.is_empty() && deps.rerun_if_env_changed.is_empty() {\n match pkg_fingerprint {\n // FIXME: this is somewhat buggy with respect to docker and\n // weird filesystems. The `Precalculated` variant\n // constructed below will, for `path` dependencies, contain\n // a stringified version of the mtime for the local crate.\n // This violates one of the things we describe in this\n // module's doc comment, never hashing mtimes. We should\n // figure out a better scheme where a package fingerprint\n // may be a string (like for a registry) or a list of files\n // (like for a path dependency). Those list of files would\n // be stored here rather than the mtime of them.\n Some(f) => {\n let s = f()?;\n debug!(\n \"old local fingerprints deps {:?} precalculated={:?}\",\n pkg_root, s\n );\n return Ok(Some(vec![LocalFingerprint::Precalculated(s)]));\n }\n None => return Ok(None),\n }\n }\n\n // Ok so now we're in \"new mode\" where we can have files listed as\n // dependencies as well as env vars listed as dependencies. Process\n // them all here.\n Ok(Some(local_fingerprints_deps(\n deps,\n &build_dir,\n &pkg_root,\n &env_config,\n )))\n };\n\n // Note that `false` == \"not overridden\"\n Ok((Box::new(calculate), false))\n}\n\n/// Create a [`LocalFingerprint`] for an overridden build script.\n/// Returns None if it is not overridden.\nfn build_script_override_fingerprint(\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n) -> Option {\n // Build script output is only populated at this stage when it is\n // overridden.\n let build_script_outputs = build_runner.build_script_outputs.lock().unwrap();\n let metadata = build_runner.get_run_build_script_metadata(unit);\n // Returns None if it is not overridden.\n let output = build_script_outputs.get(metadata)?;\n let s = format!(\n \"overridden build state with hash: {}\",\n util::hash_u64(output)\n );\n Some(LocalFingerprint::Precalculated(s))\n}\n\n/// Compute the [`LocalFingerprint`] values for a [`RunCustomBuild`] unit for\n/// non-overridden new-style build scripts only. This is only used when `deps`\n/// is already known to have a nonempty `rerun-if-*` somewhere.\n///\n/// [`RunCustomBuild`]: crate::core::compiler::CompileMode::RunCustomBuild\nfn local_fingerprints_deps(\n deps: &BuildDeps,\n build_root: &Path,\n pkg_root: &Path,\n env_config: &Arc>,\n) -> Vec {\n debug!(\"new local fingerprints deps {:?}\", pkg_root);\n let mut local = Vec::new();\n\n if !deps.rerun_if_changed.is_empty() {\n // Note that like the module comment above says we are careful to never\n // store an absolute path in `LocalFingerprint`, so ensure that we strip\n // absolute prefixes from them.\n let output = deps\n .build_script_output\n .strip_prefix(build_root)\n .unwrap()\n .to_path_buf();\n let paths = deps\n .rerun_if_changed\n .iter()\n .map(|p| p.strip_prefix(pkg_root).unwrap_or(p).to_path_buf())\n .collect();\n local.push(LocalFingerprint::RerunIfChanged { output, paths });\n }\n\n local.extend(\n deps.rerun_if_env_changed\n .iter()\n .map(|s| LocalFingerprint::from_env(s, env_config)),\n );\n\n local\n}\n\n/// Writes the short fingerprint hash value to ``\n/// and logs detailed JSON information to `.json`.\nfn write_fingerprint(loc: &Path, fingerprint: &Fingerprint) -> CargoResult<()> {\n debug_assert_ne!(fingerprint.rustc, 0);\n // fingerprint::new().rustc == 0, make sure it doesn't make it to the file system.\n // This is mostly so outside tools can reliably find out what rust version this file is for,\n // as we can use the full hash.\n let hash = fingerprint.hash_u64();\n debug!(\"write fingerprint ({:x}) : {}\", hash, loc.display());\n paths::write(loc, util::to_hex(hash).as_bytes())?;\n\n let json = serde_json::to_string(fingerprint).unwrap();\n if cfg!(debug_assertions) {\n let f: Fingerprint = serde_json::from_str(&json).unwrap();\n assert_eq!(f.hash_u64(), hash);\n }\n paths::write(&loc.with_extension(\"json\"), json.as_bytes())?;\n Ok(())\n}\n\n/// Prepare for work when a package starts to build\npub fn prepare_init(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResult<()> {\n let new1 = build_runner.files().fingerprint_dir(unit);\n\n // Doc tests have no output, thus no fingerprint.\n if !new1.exists() && !unit.mode.is_doc_test() {\n paths::create_dir_all(&new1)?;\n }\n\n Ok(())\n}\n\n/// Returns the location that the dep-info file will show up at\n/// for the [`Unit`] specified.\npub fn dep_info_loc(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> PathBuf {\n build_runner.files().fingerprint_file_path(unit, \"dep-\")\n}\n\n/// Returns an absolute path that build directory.\n/// All paths are rewritten to be relative to this.\nfn build_root(build_runner: &BuildRunner<'_, '_>) -> PathBuf {\n build_runner.bcx.ws.build_dir().into_path_unlocked()\n}\n\n/// Reads the value from the old fingerprint hash file and compare.\n///\n/// If dirty, it then restores the detailed information\n/// from the fingerprint JSON file, and provides an rich dirty reason.\nfn compare_old_fingerprint(\n unit: &Unit,\n old_hash_path: &Path,\n new_fingerprint: &Fingerprint,\n mtime_on_use: bool,\n forced: bool,\n) -> FingerprintComparison {\n if mtime_on_use {\n // update the mtime so other cleaners know we used it\n let t = FileTime::from_system_time(SystemTime::now());\n debug!(\"mtime-on-use forcing {:?} to {}\", old_hash_path, t);\n paths::set_file_time_no_err(old_hash_path, t);\n }\n\n let compare = _compare_old_fingerprint(old_hash_path, new_fingerprint);\n\n match compare.as_ref() {\n Ok(FingerprintComparison::Fresh) => {}\n Ok(FingerprintComparison::Dirty { reason }) => {\n info!(\n \"fingerprint dirty for {}/{:?}/{:?}\",\n unit.pkg, unit.mode, unit.target,\n );\n info!(\" dirty: {reason:?}\");\n }\n Err(e) => {\n info!(\n \"fingerprint error for {}/{:?}/{:?}\",\n unit.pkg, unit.mode, unit.target,\n );\n info!(\" err: {e:?}\");\n }\n }\n\n match compare {\n Ok(FingerprintComparison::Fresh) if forced => FingerprintComparison::Dirty {\n reason: DirtyReason::Forced,\n },\n Ok(cmp) => cmp,\n Err(_) => FingerprintComparison::Dirty {\n reason: DirtyReason::FreshBuild,\n },\n }\n}\n\nfn _compare_old_fingerprint(\n old_hash_path: &Path,\n new_fingerprint: &Fingerprint,\n) -> CargoResult {\n let old_fingerprint_short = paths::read(old_hash_path)?;\n\n let new_hash = new_fingerprint.hash_u64();\n\n if util::to_hex(new_hash) == old_fingerprint_short && new_fingerprint.fs_status.up_to_date() {\n return Ok(FingerprintComparison::Fresh);\n }\n\n let old_fingerprint_json = paths::read(&old_hash_path.with_extension(\"json\"))?;\n let old_fingerprint: Fingerprint = serde_json::from_str(&old_fingerprint_json)\n .with_context(|| internal(\"failed to deserialize json\"))?;\n // Fingerprint can be empty after a failed rebuild (see comment in prepare_target).\n if !old_fingerprint_short.is_empty() {\n debug_assert_eq!(\n util::to_hex(old_fingerprint.hash_u64()),\n old_fingerprint_short\n );\n }\n\n let reason = new_fingerprint.compare(&old_fingerprint);\n Ok(FingerprintComparison::Dirty { reason })\n}\n\n/// Calculates the fingerprint of a unit thats contains no dep-info files.\nfn pkg_fingerprint(bcx: &BuildContext<'_, '_>, pkg: &Package) -> CargoResult {\n let source_id = pkg.package_id().source_id();\n let sources = bcx.packages.sources();\n\n let source = sources\n .get(source_id)\n .ok_or_else(|| internal(\"missing package source\"))?;\n source.fingerprint(pkg)\n}\n\n/// The `reference` file is considered as \"stale\" if any file from `paths` has a newer mtime.\nfn find_stale_file(\n mtime_cache: &mut HashMap,\n checksum_cache: &mut HashMap,\n reference: &Path,\n paths: I,\n use_checksums: bool,\n) -> Option\nwhere\n I: IntoIterator)>,\n P: AsRef,\n{\n let reference_mtime = match paths::mtime(reference) {\n Ok(mtime) => mtime,\n Err(..) => {\n return Some(StaleItem::MissingFile {\n path: reference.to_path_buf(),\n });\n }\n };\n\n let skippable_dirs = if let Ok(cargo_home) = home::cargo_home() {\n let skippable_dirs: Vec<_> = [\"git\", \"registry\"]\n .into_iter()\n .map(|subfolder| cargo_home.join(subfolder))\n .collect();\n Some(skippable_dirs)\n } else {\n None\n };\n for (path, prior_checksum) in paths {\n let path = path.as_ref();\n\n // Assuming anything in cargo_home/{git, registry} is immutable\n // (see also #9455 about marking the src directory readonly) which avoids rebuilds when CI\n // caches $CARGO_HOME/registry/{index, cache} and $CARGO_HOME/git/db across runs, keeping\n // the content the same but changing the mtime.\n if let Some(ref skippable_dirs) = skippable_dirs {\n if skippable_dirs.iter().any(|dir| path.starts_with(dir)) {\n continue;\n }\n }\n if use_checksums {\n let Some((file_len, prior_checksum)) = prior_checksum else {\n return Some(StaleItem::MissingChecksum {\n path: path.to_path_buf(),\n });\n };\n let path_buf = path.to_path_buf();\n\n let path_checksum = match checksum_cache.entry(path_buf) {\n Entry::Occupied(o) => *o.get(),\n Entry::Vacant(v) => {\n let Ok(current_file_len) = fs::metadata(&path).map(|m| m.len()) else {\n return Some(StaleItem::FailedToReadMetadata {\n path: path.to_path_buf(),\n });\n };\n if current_file_len != file_len {\n return Some(StaleItem::FileSizeChanged {\n path: path.to_path_buf(),\n new_size: current_file_len,\n old_size: file_len,\n });\n }\n let Ok(file) = File::open(path) else {\n return Some(StaleItem::MissingFile {\n path: path.to_path_buf(),\n });\n };\n let Ok(checksum) = Checksum::compute(prior_checksum.algo(), file) else {\n return Some(StaleItem::UnableToReadFile {\n path: path.to_path_buf(),\n });\n };\n *v.insert(checksum)\n }\n };\n if path_checksum == prior_checksum {\n continue;\n }\n return Some(StaleItem::ChangedChecksum {\n source: path.to_path_buf(),\n stored_checksum: prior_checksum,\n new_checksum: path_checksum,\n });\n } else {\n let path_mtime = match mtime_cache.entry(path.to_path_buf()) {\n Entry::Occupied(o) => *o.get(),\n Entry::Vacant(v) => {\n let Ok(mtime) = paths::mtime_recursive(path) else {\n return Some(StaleItem::MissingFile {\n path: path.to_path_buf(),\n });\n };\n *v.insert(mtime)\n }\n };\n\n // TODO: fix #5918.\n // Note that equal mtimes should be considered \"stale\". For filesystems with\n // not much timestamp precision like 1s this is would be a conservative approximation\n // to handle the case where a file is modified within the same second after\n // a build starts. We want to make sure that incremental rebuilds pick that up!\n //\n // For filesystems with nanosecond precision it's been seen in the wild that\n // its \"nanosecond precision\" isn't really nanosecond-accurate. It turns out that\n // kernels may cache the current time so files created at different times actually\n // list the same nanosecond precision. Some digging on #5919 picked up that the\n // kernel caches the current time between timer ticks, which could mean that if\n // a file is updated at most 10ms after a build starts then Cargo may not\n // pick up the build changes.\n //\n // All in all, an equality check here would be a conservative assumption that,\n // if equal, files were changed just after a previous build finished.\n // Unfortunately this became problematic when (in #6484) cargo switch to more accurately\n // measuring the start time of builds.\n if path_mtime <= reference_mtime {\n continue;\n }\n\n return Some(StaleItem::ChangedFile {\n reference: reference.to_path_buf(),\n reference_mtime,\n stale: path.to_path_buf(),\n stale_mtime: path_mtime,\n });\n }\n }\n\n debug!(\n \"all paths up-to-date relative to {:?} mtime={}\",\n reference, reference_mtime\n );\n None\n}\n" }, { "path": "src/cargo/core/compiler/fingerprint/rustdoc.rs", "content": "use std::collections::HashMap;\nuse std::path::Path;\nuse std::path::PathBuf;\n\nuse anyhow::Context as _;\nuse cargo_util::paths;\nuse serde::Deserialize;\nuse serde::Serialize;\n\nuse crate::CargoResult;\nuse crate::core::compiler::BuildRunner;\nuse crate::core::compiler::CompileKind;\n\n/// JSON Schema of the [`RustdocFingerprint`] file.\n#[derive(Debug, Serialize, Deserialize)]\nstruct RustdocFingerprintJson {\n /// `rustc -vV` verbose version output.\n pub rustc_vv: String,\n\n /// Relative paths to cross crate info JSON files from previous `cargo doc` invocations.\n #[serde(default, skip_serializing_if = \"Vec::is_empty\")]\n pub doc_parts: Vec,\n}\n\n/// Structure used to deal with Rustdoc fingerprinting\n///\n/// This is important because the `.js`/`.html` & `.css` files\n/// that are generated by Rustc don't have any versioning yet\n/// (see ).\n/// Therefore, we can end up with weird bugs and behaviours\n/// if we mix different versions of these files.\n///\n/// We need to make sure that if there were any previous docs already compiled,\n/// they were compiled with the same Rustc version that we're currently using.\n/// Otherwise we must remove the `doc/` folder and compile again forcing a rebuild.\n#[derive(Debug)]\npub struct RustdocFingerprint {\n /// Path to the fingerprint file.\n path: PathBuf,\n /// `rustc -vV` verbose version output for the current session.\n rustc_vv: String,\n /// Absolute paths to new cross crate info JSON files generated in the current session.\n doc_parts: Vec,\n /// The fingerprint file on disk.\n on_disk: Option,\n}\n\nimpl RustdocFingerprint {\n /// Checks whether the latest version of rustc used to compile this workspace's docs\n /// was the same as the one is currently being used in this `cargo doc` call.\n ///\n /// In case it's not,\n /// it takes care of removing the `/doc/` folder\n /// as well as overwriting the rustdoc fingerprint info.\n /// This is to guarantee that we won't end up with mixed versions of the `js/html/css` files\n /// which `rustdoc` autogenerates without any versioning.\n ///\n /// Each requested target platform maintains its own fingerprint file.\n /// That is, if you run `cargo doc` and then `cargo doc --target wasm32-wasip1`,\n /// you will have two separate fingerprint files:\n ///\n /// * `/.rustdoc_fingerprint.json` for host\n /// * `/wasm32-wasip1/.rustdoc_fingerprint.json`\n pub fn check_rustdoc_fingerprint(build_runner: &BuildRunner<'_, '_>) -> CargoResult<()> {\n if build_runner\n .bcx\n .gctx\n .cli_unstable()\n .skip_rustdoc_fingerprint\n {\n return Ok(());\n }\n let new_fingerprint = RustdocFingerprintJson {\n rustc_vv: build_runner.bcx.rustc().verbose_version.clone(),\n doc_parts: Vec::new(),\n };\n\n for kind in &build_runner.bcx.build_config.requested_kinds {\n check_fingerprint(build_runner, &new_fingerprint, *kind)?;\n }\n\n Ok(())\n }\n\n /// Creates a new fingerprint with given doc parts paths.\n pub fn new(\n build_runner: &BuildRunner<'_, '_>,\n kind: CompileKind,\n doc_parts: Vec,\n ) -> Self {\n let path = fingerprint_path(build_runner, kind);\n let rustc_vv = build_runner.bcx.rustc().verbose_version.clone();\n let on_disk = load_on_disk(&path);\n Self {\n path,\n rustc_vv,\n doc_parts,\n on_disk,\n }\n }\n\n /// Persists the fingerprint.\n ///\n /// The closure will run before persisting the fingerprint,\n /// and will be given a list of doc parts directories for passing to\n /// `rustdoc --include-parts-dir`.\n pub fn persist(&self, exec: F) -> CargoResult<()>\n where\n // 1. paths for `--include-parts-dir`\n F: Fn(&[&Path]) -> CargoResult<()>,\n {\n // Dedupe crate with the same name by file stem (which is effectively crate name),\n // since rustdoc doesn't distinguish different crate versions.\n //\n // Rules applied here:\n //\n // * If name collides, favor the one selected via CLI over cached ones\n // (done by the insertion order)\n let base = self.path.parent().unwrap();\n let on_disk_doc_parts: Vec<_> = self\n .on_disk\n .iter()\n .flat_map(|on_disk| {\n on_disk\n .doc_parts\n .iter()\n // Make absolute so that we can pass to rustdoc\n .map(|p| base.join(p))\n // Doc parts may be selectively cleaned by `cargo clean -p `.\n // We should stop caching those no-exist.\n .filter(|p| p.exists())\n })\n .collect();\n let dedup_map = on_disk_doc_parts\n .iter()\n .chain(self.doc_parts.iter())\n .map(|p| (p.file_stem(), p))\n .collect::>();\n let mut doc_parts: Vec<_> = dedup_map.into_values().collect();\n doc_parts.sort_unstable();\n\n // Prepare args for `rustdoc --include-parts-dir`\n let doc_parts_dirs: Vec<_> = doc_parts.iter().map(|p| p.parent().unwrap()).collect();\n exec(&doc_parts_dirs)?;\n\n // Persist with relative paths to the directory where fingerprint file is at.\n let json = RustdocFingerprintJson {\n rustc_vv: self.rustc_vv.clone(),\n doc_parts: doc_parts\n .iter()\n .map(|p| p.strip_prefix(base).unwrap_or(p).to_owned())\n .collect(),\n };\n paths::write(&self.path, serde_json::to_string(&json)?)?;\n\n Ok(())\n }\n\n /// Checks if the fingerprint is outdated comparing against given doc parts file paths.\n pub fn is_dirty(&self) -> bool {\n let Some(on_disk) = self.on_disk.as_ref() else {\n return true;\n };\n\n let Some(fingerprint_mtime) = paths::mtime(&self.path).ok() else {\n return true;\n };\n\n if self.rustc_vv != on_disk.rustc_vv {\n return true;\n }\n\n for path in &self.doc_parts {\n let parts_mtime = match paths::mtime(&path) {\n Ok(mtime) => mtime,\n Err(e) => {\n tracing::debug!(\"failed to read mtime of {}: {e}\", path.display());\n return true;\n }\n };\n\n if parts_mtime > fingerprint_mtime {\n return true;\n }\n }\n\n false\n }\n}\n\n/// Returns the path to rustdoc fingerprint file for a given [`CompileKind`].\nfn fingerprint_path(build_runner: &BuildRunner<'_, '_>, kind: CompileKind) -> PathBuf {\n build_runner\n .files()\n .layout(kind)\n .build_dir()\n .root()\n .join(\".rustdoc_fingerprint.json\")\n}\n\n/// Checks rustdoc fingerprint file for a given [`CompileKind`].\nfn check_fingerprint(\n build_runner: &BuildRunner<'_, '_>,\n new_fingerprint: &RustdocFingerprintJson,\n kind: CompileKind,\n) -> CargoResult<()> {\n let fingerprint_path = fingerprint_path(build_runner, kind);\n\n let write_fingerprint = || -> CargoResult<()> {\n paths::write(&fingerprint_path, serde_json::to_string(new_fingerprint)?)\n };\n\n let Ok(rustdoc_data) = paths::read(&fingerprint_path) else {\n // If the fingerprint does not exist, do not clear out the doc\n // directories. Otherwise this ran into problems where projects\n // like bootstrap were creating the doc directory before running\n // `cargo doc` in a way that deleting it would break it.\n return write_fingerprint();\n };\n\n match serde_json::from_str::(&rustdoc_data) {\n Ok(on_disk_fingerprint) => {\n if on_disk_fingerprint.rustc_vv == new_fingerprint.rustc_vv {\n return Ok(());\n } else {\n tracing::debug!(\n \"doc fingerprint changed:\\noriginal:\\n{}\\nnew:\\n{}\",\n on_disk_fingerprint.rustc_vv,\n new_fingerprint.rustc_vv\n );\n }\n }\n Err(e) => {\n tracing::debug!(\"could not deserialize {:?}: {}\", fingerprint_path, e);\n }\n };\n // Fingerprint does not match, delete the doc directories and write a new fingerprint.\n tracing::debug!(\n \"fingerprint {:?} mismatch, clearing doc directories\",\n fingerprint_path\n );\n let doc_dir = build_runner\n .files()\n .layout(kind)\n .artifact_dir()\n .expect(\"artifact-dir was not locked\")\n .doc();\n if doc_dir.exists() {\n clean_doc(doc_dir)?;\n }\n\n write_fingerprint()?;\n\n Ok(())\n}\n\n/// Loads an on-disk fingerprint JSON file.\nfn load_on_disk(path: &Path) -> Option {\n let on_disk = match paths::read(path) {\n Ok(data) => data,\n Err(e) => {\n tracing::debug!(\"failed to read rustdoc fingerprint at {path:?}: {e}\");\n return None;\n }\n };\n\n match serde_json::from_str::(&on_disk) {\n Ok(on_disk) => Some(on_disk),\n Err(e) => {\n tracing::debug!(\"could not deserialize {path:?}: {e}\");\n None\n }\n }\n}\n\nfn clean_doc(path: &Path) -> CargoResult<()> {\n let entries = path\n .read_dir()\n .with_context(|| format!(\"failed to read directory `{}`\", path.display()))?;\n for entry in entries {\n let entry = entry?;\n // Don't remove hidden files. Rustdoc does not create them,\n // but the user might have.\n if entry\n .file_name()\n .to_str()\n .map_or(false, |name| name.starts_with('.'))\n {\n continue;\n }\n let path = entry.path();\n if entry.file_type()?.is_dir() {\n paths::remove_dir_all(path)?;\n } else {\n paths::remove_file(path)?;\n }\n }\n Ok(())\n}\n" }, { "path": "src/cargo/core/compiler/future_incompat.rs", "content": "//! Support for [future-incompatible warning reporting][1].\n//!\n//! Here is an overview of how Cargo handles future-incompatible reports.\n//!\n//! ## Receive reports from the compiler\n//!\n//! When receiving a compiler message during a build, if it is effectively\n//! a [`FutureIncompatReport`], Cargo gathers and forwards it as a\n//! `Message::FutureIncompatReport` to the main thread.\n//!\n//! To have the correct layout of structures for deserializing a report\n//! emitted by the compiler, most of structure definitions, for example\n//! [`FutureIncompatReport`], are copied either partially or entirely from\n//! [compiler/rustc_errors/src/json.rs][2] in rust-lang/rust repository.\n//!\n//! ## Persist reports on disk\n//!\n//! When a build comes to an end, by calling [`save_and_display_report`]\n//! Cargo saves the report on disk, and displays it directly if requested\n//! via command line or configuration. The information of the on-disk file can\n//! be found in [`FUTURE_INCOMPAT_FILE`].\n//!\n//! During the persistent process, Cargo will attempt to query the source of\n//! each package emitting the report, for the sake of providing an upgrade\n//! information as a solution to fix the incompatibility.\n//!\n//! ## Display reports to users\n//!\n//! Users can run `cargo report future-incompat` to retrieve a report. This is\n//! done by [`OnDiskReports::load`]. Cargo simply prints reports to the\n//! standard output.\n//!\n//! [1]: https://doc.rust-lang.org/nightly/cargo/reference/future-incompat-report.html\n//! [2]: https://github.com/rust-lang/rust/blob/9bb6e60d1f1360234aae90c97964c0fa5524f141/compiler/rustc_errors/src/json.rs#L312-L315\n\nuse crate::core::compiler::BuildContext;\nuse crate::core::{Dependency, PackageId, Workspace};\nuse crate::sources::SourceConfigMap;\nuse crate::sources::source::QueryKind;\nuse crate::util::CargoResult;\nuse crate::util::cache_lock::CacheLockMode;\nuse anyhow::{Context, bail, format_err};\nuse serde::{Deserialize, Serialize};\nuse std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};\nuse std::fmt::Write as _;\nuse std::io::{Read, Write};\nuse std::task::Poll;\n\npub const REPORT_PREAMBLE: &str = \"\\\nThe following warnings were discovered during the build. These warnings are an\nindication that the packages contain code that will become an error in a\nfuture release of Rust. These warnings typically cover changes to close\nsoundness problems, unintended or undocumented behavior, or critical problems\nthat cannot be fixed in a backwards-compatible fashion, and are not expected\nto be in wide use.\n\nEach warning should contain a link for more information on what the warning\nmeans and how to resolve it.\n\";\n\n/// Current version of the on-disk format.\nconst ON_DISK_VERSION: u32 = 0;\n\n/// The future incompatibility report, emitted by the compiler as a JSON message.\n#[derive(serde::Deserialize)]\npub struct FutureIncompatReport {\n pub future_incompat_report: Vec,\n}\n\n/// Structure used for collecting reports in-memory.\npub struct FutureIncompatReportPackage {\n pub package_id: PackageId,\n /// Whether or not this is a local package, or a remote dependency.\n pub is_local: bool,\n pub items: Vec,\n}\n\n/// A single future-incompatible warning emitted by rustc.\n#[derive(Serialize, Deserialize)]\npub struct FutureBreakageItem {\n /// The date at which this lint will become an error.\n /// Currently unused\n pub future_breakage_date: Option,\n /// The original diagnostic emitted by the compiler\n pub diagnostic: Diagnostic,\n}\n\n/// A diagnostic emitted by the compiler as a JSON message.\n/// We only care about the 'rendered' field\n#[derive(Serialize, Deserialize)]\npub struct Diagnostic {\n pub rendered: String,\n pub level: String,\n}\n\n/// The filename in the top-level `build-dir` directory where we store\n/// the report\nconst FUTURE_INCOMPAT_FILE: &str = \".future-incompat-report.json\";\n/// Max number of reports to save on disk.\nconst MAX_REPORTS: usize = 5;\n\n/// The structure saved to disk containing the reports.\n#[derive(Serialize, Deserialize)]\npub struct OnDiskReports {\n /// A schema version number, to handle older cargo's from trying to read\n /// something that they don't understand.\n version: u32,\n /// The report ID to use for the next report to save.\n next_id: u32,\n /// Available reports.\n reports: Vec,\n}\n\n/// A single report for a given compilation session.\n#[derive(Serialize, Deserialize)]\nstruct OnDiskReport {\n /// Unique reference to the report for the `--id` CLI flag.\n id: u32,\n /// A message describing suggestions for fixing the\n /// reported issues\n suggestion_message: String,\n /// Report, suitable for printing to the console.\n /// Maps package names to the corresponding report\n /// We use a `BTreeMap` so that the iteration order\n /// is stable across multiple runs of `cargo`\n per_package: BTreeMap,\n}\n\nimpl Default for OnDiskReports {\n fn default() -> OnDiskReports {\n OnDiskReports {\n version: ON_DISK_VERSION,\n next_id: 1,\n reports: Vec::new(),\n }\n }\n}\n\nimpl OnDiskReports {\n /// Saves a new report returning its id\n pub fn save_report(\n mut self,\n ws: &Workspace<'_>,\n suggestion_message: String,\n per_package: BTreeMap,\n ) -> u32 {\n if let Some(existing_id) = self.has_report(&per_package) {\n return existing_id;\n }\n\n let report = OnDiskReport {\n id: self.next_id,\n suggestion_message,\n per_package,\n };\n\n let saved_id = report.id;\n self.next_id += 1;\n self.reports.push(report);\n if self.reports.len() > MAX_REPORTS {\n self.reports.remove(0);\n }\n let on_disk = serde_json::to_vec(&self).unwrap();\n if let Err(e) = ws\n .build_dir()\n .open_rw_exclusive_create(\n FUTURE_INCOMPAT_FILE,\n ws.gctx(),\n \"Future incompatibility report\",\n )\n .and_then(|file| {\n let mut file = file.file();\n file.set_len(0)?;\n file.write_all(&on_disk)?;\n Ok(())\n })\n {\n crate::display_warning_with_error(\n \"failed to write on-disk future incompatible report\",\n &e,\n &mut ws.gctx().shell(),\n );\n }\n\n saved_id\n }\n\n /// Returns the ID of a report if it is already on disk.\n fn has_report(&self, rendered_per_package: &BTreeMap) -> Option {\n self.reports\n .iter()\n .find(|existing| &existing.per_package == rendered_per_package)\n .map(|report| report.id)\n }\n\n /// Loads the on-disk reports.\n pub fn load(ws: &Workspace<'_>) -> CargoResult {\n let report_file = match ws.build_dir().open_ro_shared(\n FUTURE_INCOMPAT_FILE,\n ws.gctx(),\n \"Future incompatible report\",\n ) {\n Ok(r) => r,\n Err(e) => {\n if let Some(io_err) = e.downcast_ref::() {\n if io_err.kind() == std::io::ErrorKind::NotFound {\n bail!(\"no reports are currently available\");\n }\n }\n return Err(e);\n }\n };\n\n let mut file_contents = String::new();\n report_file\n .file()\n .read_to_string(&mut file_contents)\n .context(\"failed to read report\")?;\n let on_disk_reports: OnDiskReports =\n serde_json::from_str(&file_contents).context(\"failed to load report\")?;\n if on_disk_reports.version != ON_DISK_VERSION {\n bail!(\"unable to read reports; reports were saved from a future version of Cargo\");\n }\n Ok(on_disk_reports)\n }\n\n /// Returns the most recent report ID.\n pub fn last_id(&self) -> u32 {\n self.reports.last().map(|r| r.id).unwrap()\n }\n\n /// Returns an ANSI-styled report\n pub fn get_report(&self, id: u32, package: Option<&str>) -> CargoResult {\n let report = self.reports.iter().find(|r| r.id == id).ok_or_else(|| {\n let available = itertools::join(self.reports.iter().map(|r| r.id), \", \");\n format_err!(\n \"could not find report with ID {}\\n\\\n Available IDs are: {}\",\n id,\n available\n )\n })?;\n\n let mut to_display = report.suggestion_message.clone();\n to_display += \"\\n\";\n\n let package_report = if let Some(package) = package {\n report\n .per_package\n .get(package)\n .ok_or_else(|| {\n format_err!(\n \"could not find package with ID `{}`\\n\n Available packages are: {}\\n\n Omit the `--package` flag to display a report for all packages\",\n package,\n itertools::join(report.per_package.keys(), \", \")\n )\n })?\n .to_string()\n } else {\n report\n .per_package\n .values()\n .cloned()\n .collect::>()\n .join(\"\\n\")\n };\n to_display += &package_report;\n\n Ok(to_display)\n }\n}\n\nfn render_report(per_package_reports: &[FutureIncompatReportPackage]) -> BTreeMap {\n let mut report: BTreeMap = BTreeMap::new();\n for per_package in per_package_reports {\n let package_spec = format!(\n \"{}@{}\",\n per_package.package_id.name(),\n per_package.package_id.version()\n );\n let rendered = report.entry(package_spec).or_default();\n rendered.push_str(&format!(\n \"The package `{}` currently triggers the following future incompatibility lints:\\n\",\n per_package.package_id\n ));\n for item in &per_package.items {\n rendered.extend(\n item.diagnostic\n .rendered\n .lines()\n .map(|l| format!(\"> {}\\n\", l)),\n );\n }\n }\n report\n}\n\n/// Returns a user-readable message explaining which of\n/// the packages in `package_ids` have updates available.\n/// This is best-effort - if an error occurs, `None` will be returned.\nfn get_updates(ws: &Workspace<'_>, package_ids: &BTreeSet) -> Option {\n // This in general ignores all errors since this is opportunistic.\n let _lock = ws\n .gctx()\n .acquire_package_cache_lock(CacheLockMode::DownloadExclusive)\n .ok()?;\n // Create a set of updated registry sources.\n let map = SourceConfigMap::new(ws.gctx()).ok()?;\n let mut package_ids: BTreeSet<_> = package_ids\n .iter()\n .filter(|pkg_id| pkg_id.source_id().is_registry())\n .collect();\n let source_ids: HashSet<_> = package_ids\n .iter()\n .map(|pkg_id| pkg_id.source_id())\n .collect();\n let mut sources: HashMap<_, _> = source_ids\n .into_iter()\n .filter_map(|sid| {\n let source = map.load(sid, &HashSet::new()).ok()?;\n Some((sid, source))\n })\n .collect();\n\n // Query the sources for new versions, mapping `package_ids` into `summaries`.\n let mut summaries = Vec::new();\n while !package_ids.is_empty() {\n package_ids.retain(|&pkg_id| {\n let Some(source) = sources.get_mut(&pkg_id.source_id()) else {\n return false;\n };\n let Ok(dep) = Dependency::parse(pkg_id.name(), None, pkg_id.source_id()) else {\n return false;\n };\n match source.query_vec(&dep, QueryKind::Exact) {\n Poll::Ready(Ok(sum)) => {\n summaries.push((pkg_id, sum));\n false\n }\n Poll::Ready(Err(_)) => false,\n Poll::Pending => true,\n }\n });\n for (_, source) in sources.iter_mut() {\n source.block_until_ready().ok()?;\n }\n }\n\n let mut updates = String::new();\n for (pkg_id, summaries) in summaries {\n let mut updated_versions: Vec<_> = summaries\n .iter()\n .map(|summary| summary.as_summary().version())\n .filter(|version| *version > pkg_id.version())\n .collect();\n updated_versions.sort();\n\n if !updated_versions.is_empty() {\n let updated_versions = itertools::join(updated_versions, \", \");\n write!(\n updates,\n \"\n - {} has the following newer versions available: {}\",\n pkg_id, updated_versions\n )\n .unwrap();\n }\n }\n Some(updates)\n}\n\n/// Writes a future-incompat report to disk, using the per-package\n/// reports gathered during the build. If requested by the user,\n/// a message is also displayed in the build output.\npub fn save_and_display_report(\n bcx: &BuildContext<'_, '_>,\n per_package_future_incompat_reports: &[FutureIncompatReportPackage],\n) {\n let should_display_message = match bcx.gctx.future_incompat_config() {\n Ok(config) => config.should_display_message(),\n Err(e) => {\n crate::display_warning_with_error(\n \"failed to read future-incompat config from disk\",\n &e,\n &mut bcx.gctx.shell(),\n );\n true\n }\n };\n\n if per_package_future_incompat_reports.is_empty() {\n // Explicitly passing a command-line flag overrides\n // `should_display_message` from the config file\n if bcx.build_config.future_incompat_report {\n drop(\n bcx.gctx\n .shell()\n .note(\"0 dependencies had future-incompatible warnings\"),\n );\n }\n return;\n }\n\n let current_reports = match OnDiskReports::load(bcx.ws) {\n Ok(r) => r,\n Err(e) => {\n tracing::debug!(\n \"saving future-incompatible reports failed to load current reports: {:?}\",\n e\n );\n OnDiskReports::default()\n }\n };\n\n let rendered_report = render_report(per_package_future_incompat_reports);\n\n // If the report is already on disk, then it will reuse the same ID,\n // otherwise prepare for the next ID.\n let report_id = current_reports\n .has_report(&rendered_report)\n .unwrap_or(current_reports.next_id);\n\n // Get a list of unique and sorted package name/versions.\n let package_ids: BTreeSet<_> = per_package_future_incompat_reports\n .iter()\n .map(|r| r.package_id)\n .collect();\n let package_vers: Vec<_> = package_ids.iter().map(|pid| pid.to_string()).collect();\n\n let updated_versions = get_updates(bcx.ws, &package_ids).unwrap_or(String::new());\n\n let update_message = if !updated_versions.is_empty() {\n format!(\n \"\\\nupdate to a newer version to see if the issue has been fixed{updated_versions}\",\n updated_versions = updated_versions\n )\n } else {\n String::new()\n };\n\n let upstream_info = package_ids\n .iter()\n .map(|package_id| {\n let manifest = bcx.packages.get_one(*package_id).unwrap().manifest();\n format!(\n \" - {package_spec}\n - repository: {url}\n - detailed warning command: `cargo report future-incompatibilities --id {id} --package {package_spec}`\",\n package_spec = format!(\"{}@{}\", package_id.name(), package_id.version()),\n url = manifest\n .metadata()\n .repository\n .as_deref()\n .unwrap_or(\"\"),\n id = report_id,\n )\n })\n .collect::>()\n .join(\"\\n\\n\");\n\n let all_is_local = per_package_future_incompat_reports\n .iter()\n .all(|report| report.is_local);\n\n let suggestion_header = \"to solve this problem, you can try the following approaches:\";\n let mut suggestions = Vec::new();\n if !all_is_local {\n if !update_message.is_empty() {\n suggestions.push(update_message);\n }\n suggestions.push(format!(\n \"\\\nensure the maintainers know of this problem (e.g. creating a bug report if needed)\nor even helping with a fix (e.g. by creating a pull request)\n{upstream_info}\"\n ));\n suggestions.push(\n \"\\\nuse your own version of the dependency with the `[patch]` section in `Cargo.toml`\nFor more information, see:\nhttps://doc.rust-lang.org/cargo/reference/overriding-dependencies.html#the-patch-section\"\n .to_owned(),\n );\n }\n\n let suggestion_message = if suggestions.is_empty() {\n String::new()\n } else {\n let mut suggestion_message = String::new();\n writeln!(&mut suggestion_message, \"{suggestion_header}\").unwrap();\n for suggestion in &suggestions {\n writeln!(\n &mut suggestion_message,\n \"\n- {suggestion}\"\n )\n .unwrap();\n }\n suggestion_message\n };\n let saved_report_id =\n current_reports.save_report(bcx.ws, suggestion_message.clone(), rendered_report);\n\n if should_display_message || bcx.build_config.future_incompat_report {\n use annotate_snippets::*;\n let mut report = vec![Group::with_title(Level::WARNING.secondary_title(format!(\n \"the following packages contain code that will be rejected by a future \\\n version of Rust: {}\",\n package_vers.join(\", \")\n )))];\n if bcx.build_config.future_incompat_report {\n for suggestion in &suggestions {\n report.push(Group::with_title(Level::HELP.secondary_title(suggestion)));\n }\n report.push(Group::with_title(Level::NOTE.secondary_title(format!(\n \"this report can be shown with `cargo report \\\n future-incompatibilities --id {}`\",\n saved_report_id\n ))));\n } else if should_display_message {\n report.push(Group::with_title(Level::NOTE.secondary_title(format!(\n \"to see what the problems were, use the option \\\n `--future-incompat-report`, or run `cargo report \\\n future-incompatibilities --id {}`\",\n saved_report_id\n ))));\n }\n drop(bcx.gctx.shell().print_report(&report, false))\n }\n}\n" }, { "path": "src/cargo/core/compiler/job_queue/job.rs", "content": "//! See [`Job`] and [`Work`].\n\nuse std::fmt;\nuse std::mem;\n\nuse super::JobState;\nuse crate::core::compiler::fingerprint::DirtyReason;\nuse crate::util::CargoResult;\n\n/// Represents a unit of [`Work`] with a [`Freshness`] for caller\n/// to determine whether to re-execute or not.\npub struct Job {\n work: Work,\n fresh: Freshness,\n}\n\n/// The basic unit of work.\n///\n/// Each proc should send its description before starting.\n/// It should send either once or close immediately.\npub struct Work {\n inner: Box) -> CargoResult<()> + Send>,\n}\n\nimpl Work {\n /// Creates a unit of work.\n pub fn new(f: F) -> Work\n where\n F: FnOnce(&JobState<'_, '_>) -> CargoResult<()> + Send + 'static,\n {\n Work { inner: Box::new(f) }\n }\n\n /// Creates a unit of work that does nothing.\n pub fn noop() -> Work {\n Work::new(|_| Ok(()))\n }\n\n /// Consumes this work by running it.\n pub fn call(self, tx: &JobState<'_, '_>) -> CargoResult<()> {\n (self.inner)(tx)\n }\n\n /// Creates a new unit of work that chains `next` after ourself.\n pub fn then(self, next: Work) -> Work {\n Work::new(move |state| {\n self.call(state)?;\n next.call(state)\n })\n }\n}\n\nimpl Job {\n /// Creates a new job that does nothing.\n pub fn new_fresh() -> Job {\n Job {\n work: Work::noop(),\n fresh: Freshness::Fresh,\n }\n }\n\n /// Creates a new job representing a unit of work.\n pub fn new_dirty(work: Work, dirty_reason: DirtyReason) -> Job {\n Job {\n work,\n fresh: Freshness::Dirty(dirty_reason),\n }\n }\n\n /// Consumes this job by running it, returning the result of the\n /// computation.\n pub fn run(self, state: &JobState<'_, '_>) -> CargoResult<()> {\n self.work.call(state)\n }\n\n /// Returns whether this job was fresh/dirty, where \"fresh\" means we're\n /// likely to perform just some small bookkeeping where \"dirty\" means we'll\n /// probably do something slow like invoke rustc.\n pub fn freshness(&self) -> &Freshness {\n &self.fresh\n }\n\n /// Chains the given work by putting it in front of our own unit of work.\n pub fn before(&mut self, next: Work) {\n let prev = mem::replace(&mut self.work, Work::noop());\n self.work = next.then(prev);\n }\n\n /// Chains the given work by putting it after of our own unit of work.\n pub fn after(&mut self, next: Work) {\n let prev = mem::replace(&mut self.work, Work::noop());\n self.work = prev.then(next);\n }\n}\n\nimpl fmt::Debug for Job {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"Job {{ ... }}\")\n }\n}\n\n/// Indication of the freshness of a package.\n///\n/// A fresh package does not necessarily need to be rebuilt (unless a dependency\n/// was also rebuilt), and a dirty package must always be rebuilt.\n#[derive(Debug, Clone)]\npub enum Freshness {\n Fresh,\n Dirty(DirtyReason),\n}\n\nimpl Freshness {\n pub fn is_dirty(&self) -> bool {\n matches!(self, Freshness::Dirty(_))\n }\n\n pub fn is_fresh(&self) -> bool {\n matches!(self, Freshness::Fresh)\n }\n}\n" }, { "path": "src/cargo/core/compiler/job_queue/job_state.rs", "content": "//! See [`JobState`].\n\nuse std::{cell::Cell, marker, sync::Arc};\n\nuse cargo_util::ProcessBuilder;\n\nuse crate::core::compiler::future_incompat::FutureBreakageItem;\nuse crate::core::compiler::locking::LockKey;\nuse crate::core::compiler::timings::SectionTiming;\nuse crate::util::Queue;\nuse crate::{CargoResult, core::compiler::locking::LockManager};\n\nuse super::{Artifact, DiagDedupe, Job, JobId, Message};\n\n/// A `JobState` is constructed by `JobQueue::run` and passed to `Job::run`. It includes everything\n/// necessary to communicate between the main thread and the execution of the job.\n///\n/// The job may execute on either a dedicated thread or the main thread. If the job executes on the\n/// main thread, the `output` field must be set to prevent a deadlock.\npub struct JobState<'a, 'gctx> {\n /// Channel back to the main thread to coordinate messages and such.\n ///\n /// When the `output` field is `Some`, care must be taken to avoid calling `push_bounded` on\n /// the message queue to prevent a deadlock.\n messages: Arc>,\n\n /// Normally output is sent to the job queue with backpressure. When the job is fresh\n /// however we need to immediately display the output to prevent a deadlock as the\n /// output messages are processed on the same thread as they are sent from. `output`\n /// defines where to output in this case.\n ///\n /// Currently the [`Shell`] inside [`GlobalContext`] is wrapped in a `RefCell` and thus can't\n /// be passed between threads. This means that it isn't possible for multiple output messages\n /// to be interleaved. In the future, it may be wrapped in a `Mutex` instead. In this case\n /// interleaving is still prevented as the lock would be held for the whole printing of an\n /// output message.\n ///\n /// [`Shell`]: crate::core::Shell\n /// [`GlobalContext`]: crate::GlobalContext\n output: Option<&'a DiagDedupe<'gctx>>,\n\n /// The job id that this state is associated with, used when sending\n /// messages back to the main thread.\n id: JobId,\n\n /// Whether or not we're expected to have a call to `rmeta_produced`. Once\n /// that method is called this is dynamically set to `false` to prevent\n /// sending a double message later on.\n rmeta_required: Cell,\n\n /// Manages locks for build units when fine grain locking is enabled.\n lock_manager: Arc,\n\n // Historical versions of Cargo made use of the `'a` argument here, so to\n // leave the door open to future refactorings keep it here.\n _marker: marker::PhantomData<&'a ()>,\n}\n\nimpl<'a, 'gctx> JobState<'a, 'gctx> {\n pub(super) fn new(\n id: JobId,\n messages: Arc>,\n output: Option<&'a DiagDedupe<'gctx>>,\n rmeta_required: bool,\n lock_manager: Arc,\n ) -> Self {\n Self {\n id,\n messages,\n output,\n rmeta_required: Cell::new(rmeta_required),\n lock_manager,\n _marker: marker::PhantomData,\n }\n }\n\n pub fn running(&self, cmd: &ProcessBuilder) {\n self.messages.push(Message::Run(self.id, cmd.to_string()));\n }\n\n pub fn stdout(&self, stdout: String) -> CargoResult<()> {\n if let Some(dedupe) = self.output {\n writeln!(dedupe.gctx.shell().out(), \"{}\", stdout)?;\n } else {\n self.messages.push_bounded(Message::Stdout(stdout));\n }\n Ok(())\n }\n\n pub fn stderr(&self, stderr: String) -> CargoResult<()> {\n if let Some(dedupe) = self.output {\n let mut shell = dedupe.gctx.shell();\n shell.print_ansi_stderr(stderr.as_bytes())?;\n shell.err().write_all(b\"\\n\")?;\n } else {\n self.messages.push_bounded(Message::Stderr(stderr));\n }\n Ok(())\n }\n\n /// See [`Message::Diagnostic`] and [`Message::WarningCount`].\n pub fn emit_diag(\n &self,\n level: &str,\n diag: String,\n lint: bool,\n fixable: bool,\n ) -> CargoResult<()> {\n if let Some(dedupe) = self.output {\n let emitted = dedupe.emit_diag(&diag)?;\n if level == \"warning\" {\n self.messages.push(Message::WarningCount {\n id: self.id,\n lint,\n emitted,\n fixable,\n });\n }\n } else {\n self.messages.push_bounded(Message::Diagnostic {\n id: self.id,\n level: level.to_string(),\n diag,\n lint,\n fixable,\n });\n }\n Ok(())\n }\n\n /// See [`Message::Warning`].\n pub fn warning(&self, warning: String) {\n self.messages.push_bounded(Message::Warning {\n id: self.id,\n warning,\n });\n }\n\n /// A method used to signal to the coordinator thread that the rmeta file\n /// for an rlib has been produced. This is only called for some rmeta\n /// builds when required, and can be called at any time before a job ends.\n /// This should only be called once because a metadata file can only be\n /// produced once!\n pub fn rmeta_produced(&self) {\n self.rmeta_required.set(false);\n self.messages\n .push(Message::Finish(self.id, Artifact::Metadata, Ok(())));\n }\n\n pub fn lock_exclusive(&self, lock: &LockKey) -> CargoResult<()> {\n self.lock_manager.lock(lock)\n }\n\n pub fn downgrade_to_shared(&self, lock: &LockKey) -> CargoResult<()> {\n self.lock_manager.downgrade_to_shared(lock)\n }\n\n pub fn on_section_timing_emitted(&self, section: SectionTiming) {\n self.messages.push(Message::SectionTiming(self.id, section));\n }\n\n /// Drives a [`Job`] to finish. This ensures that a [`Message::Finish`] is\n /// sent even if our job panics.\n pub(super) fn run_to_finish(self, job: Job) {\n let mut sender = FinishOnDrop {\n messages: &self.messages,\n id: self.id,\n result: None,\n };\n sender.result = Some(job.run(&self));\n\n // If the `rmeta_required` wasn't consumed but it was set\n // previously, then we either have:\n //\n // 1. The `job` didn't do anything because it was \"fresh\".\n // 2. The `job` returned an error and didn't reach the point where\n // it called `rmeta_produced`.\n // 3. We forgot to call `rmeta_produced` and there's a bug in Cargo.\n //\n // Ruling out the third, the other two are pretty common for 2\n // we'll just naturally abort the compilation operation but for 1\n // we need to make sure that the metadata is flagged as produced so\n // send a synthetic message here.\n if self.rmeta_required.get() && sender.result.as_ref().unwrap().is_ok() {\n self.messages\n .push(Message::Finish(self.id, Artifact::Metadata, Ok(())));\n }\n\n // Use a helper struct with a `Drop` implementation to guarantee\n // that a `Finish` message is sent even if our job panics. We\n // shouldn't panic unless there's a bug in Cargo, so we just need\n // to make sure nothing hangs by accident.\n struct FinishOnDrop<'a> {\n messages: &'a Queue,\n id: JobId,\n result: Option>,\n }\n\n impl Drop for FinishOnDrop<'_> {\n fn drop(&mut self) {\n let result = self\n .result\n .take()\n .unwrap_or_else(|| Err(anyhow::format_err!(\"worker panicked\")));\n self.messages\n .push(Message::Finish(self.id, Artifact::All, result));\n }\n }\n }\n\n pub fn future_incompat_report(&self, report: Vec) {\n self.messages\n .push(Message::FutureIncompatReport(self.id, report));\n }\n}\n" }, { "path": "src/cargo/core/compiler/job_queue/mod.rs", "content": "//! Management of the interaction between the main `cargo` and all spawned jobs.\n//!\n//! ## Overview\n//!\n//! This module implements a job queue. A job here represents a unit of work,\n//! which is roughly a rustc invocation, a build script run, or just a no-op.\n//! The job queue primarily handles the following things:\n//!\n//! * Spawns concurrent jobs. Depending on its [`Freshness`], a job could be\n//! either executed on a spawned thread or ran on the same thread to avoid\n//! the threading overhead.\n//! * Controls the number of concurrency. It allocates and manages [`jobserver`]\n//! tokens to each spawned off rustc and build scripts.\n//! * Manages the communication between the main `cargo` process and its\n//! spawned jobs. Those [`Message`]s are sent over a [`Queue`] shared\n//! across threads.\n//! * Schedules the execution order of each [`Job`]. Priorities are determined\n//! when calling [`JobQueue::enqueue`] to enqueue a job. The scheduling is\n//! relatively rudimentary and could likely be improved.\n//!\n//! A rough outline of building a queue and executing jobs is:\n//!\n//! 1. [`JobQueue::new`] to simply create one queue.\n//! 2. [`JobQueue::enqueue`] to add new jobs onto the queue.\n//! 3. Consumes the queue and executes all jobs via [`JobQueue::execute`].\n//!\n//! The primary loop happens insides [`JobQueue::execute`], which is effectively\n//! [`DrainState::drain_the_queue`]. [`DrainState`] is, as its name tells,\n//! the running state of the job queue getting drained.\n//!\n//! ## Jobserver\n//!\n//! As of Feb. 2023, Cargo and rustc have a relatively simple jobserver\n//! relationship with each other. They share a single jobserver amongst what\n//! is potentially hundreds of threads of work on many-cored systems.\n//! The jobserver could come from either the environment (e.g., from a `make`\n//! invocation), or from Cargo creating its own jobserver server if there is no\n//! jobserver to inherit from.\n//!\n//! Cargo wants to complete the build as quickly as possible, fully saturating\n//! all cores (as constrained by the `-j=N`) parameter. Cargo also must not spawn\n//! more than N threads of work: the total amount of tokens we have floating\n//! around must always be limited to N.\n//!\n//! It is not really possible to optimally choose which crate should build\n//! first or last; nor is it possible to decide whether to give an additional\n//! token to rustc first or rather spawn a new crate of work. The algorithm in\n//! Cargo prioritizes spawning as many crates (i.e., rustc processes) as\n//! possible. In short, the jobserver relationship among Cargo and rustc\n//! processes is **1 `cargo` to N `rustc`**. Cargo knows nothing beyond rustc\n//! processes in terms of parallelism[^parallel-rustc].\n//!\n//! We integrate with the [jobserver] crate, originating from GNU make\n//! [POSIX jobserver], to make sure that build scripts which use make to\n//! build C code can cooperate with us on the number of used tokens and\n//! avoid overfilling the system we're on.\n//!\n//! ## Scheduling\n//!\n//! The current scheduling algorithm is not really polished. It is simply based\n//! on a dependency graph [`DependencyQueue`]. We continue adding nodes onto\n//! the graph until we finalize it. When the graph gets finalized, it finds the\n//! sum of the cost of each dependencies of each node, including transitively.\n//! The sum of dependency cost turns out to be the cost of each given node.\n//!\n//! At the time being, the cost is just passed as a fixed placeholder in\n//! [`JobQueue::enqueue`]. In the future, we could explore more possibilities\n//! around it. For instance, we start persisting timing information for each\n//! build somewhere. For a subsequent build, we can look into the historical\n//! data and perform a PGO-like optimization to prioritize jobs, making a build\n//! fully pipelined.\n//!\n//! ## Message queue\n//!\n//! Each spawned thread running a process uses the message queue [`Queue`] to\n//! send messages back to the main thread (the one running `cargo`).\n//! The main thread coordinates everything, and handles printing output.\n//!\n//! It is important to be careful which messages use [`push`] vs [`push_bounded`].\n//! `push` is for priority messages (like tokens, or \"finished\") where the\n//! sender shouldn't block. We want to handle those so real work can proceed\n//! ASAP.\n//!\n//! `push_bounded` is only for messages being printed to stdout/stderr. Being\n//! bounded prevents a flood of messages causing a large amount of memory\n//! being used.\n//!\n//! `push` also avoids blocking which helps avoid deadlocks. For example, when\n//! the diagnostic server thread is dropped, it waits for the thread to exit.\n//! But if the thread is blocked on a full queue, and there is a critical\n//! error, the drop will deadlock. This should be fixed at some point in the\n//! future. The jobserver thread has a similar problem, though it will time\n//! out after 1 second.\n//!\n//! To access the message queue, each running `Job` is given its own [`JobState`],\n//! containing everything it needs to communicate with the main thread.\n//!\n//! See [`Message`] for all available message kinds.\n//!\n//! [^parallel-rustc]: In fact, `jobserver` that Cargo uses also manages the\n//! allocation of tokens to rustc beyond the implicit token each rustc owns\n//! (i.e., the ones used for parallel LLVM work and parallel rustc threads).\n//! See also [\"Rust Compiler Development Guide: Parallel Compilation\"]\n//! and [this comment][rustc-codegen] in rust-lang/rust.\n//!\n//! [\"Rust Compiler Development Guide: Parallel Compilation\"]: https://rustc-dev-guide.rust-lang.org/parallel-rustc.html\n//! [rustc-codegen]: https://github.com/rust-lang/rust/blob/5423745db8b434fcde54888b35f518f00cce00e4/compiler/rustc_codegen_ssa/src/back/write.rs#L1204-L1217\n//! [jobserver]: https://docs.rs/jobserver\n//! [POSIX jobserver]: https://www.gnu.org/software/make/manual/html_node/POSIX-Jobserver.html\n//! [`push`]: Queue::push\n//! [`push_bounded`]: Queue::push_bounded\n\nmod job;\nmod job_state;\n\nuse std::cell::RefCell;\nuse std::collections::{HashMap, HashSet};\nuse std::fmt::Write as _;\nuse std::path::{Path, PathBuf};\nuse std::sync::Arc;\nuse std::thread::{self, Scope};\nuse std::time::Duration;\nuse std::{env, io};\n\nuse anyhow::{Context as _, format_err};\nuse jobserver::{Acquired, HelperThread};\nuse semver::Version;\nuse tracing::{debug, trace};\n\npub use self::job::Freshness::{self, Dirty, Fresh};\npub use self::job::{Job, Work};\npub use self::job_state::JobState;\nuse super::BuildContext;\nuse super::BuildRunner;\nuse super::CompileMode;\nuse super::Unit;\nuse super::UnitIndex;\nuse super::custom_build::Severity;\nuse super::timings::SectionTiming;\nuse super::timings::Timings;\nuse crate::core::compiler::descriptive_pkg_name;\nuse crate::core::compiler::future_incompat::{\n self, FutureBreakageItem, FutureIncompatReportPackage,\n};\nuse crate::core::resolver::ResolveBehavior;\nuse crate::core::{PackageId, Shell, TargetKind};\nuse crate::util::CargoResult;\nuse crate::util::context::WarningHandling;\nuse crate::util::diagnostic_server::{self, DiagnosticPrinter};\nuse crate::util::errors::AlreadyPrintedError;\nuse crate::util::machine_message::{self, Message as _};\nuse crate::util::{self, internal};\nuse crate::util::{DependencyQueue, GlobalContext, Progress, ProgressStyle, Queue};\n\n/// This structure is backed by the `DependencyQueue` type and manages the\n/// queueing of compilation steps for each package. Packages enqueue units of\n/// work and then later on the entire graph is converted to `DrainState` and\n/// executed.\npub struct JobQueue<'gctx> {\n queue: DependencyQueue,\n counts: HashMap,\n timings: Timings<'gctx>,\n}\n\n/// This structure is backed by the `DependencyQueue` type and manages the\n/// actual compilation step of each package. Packages enqueue units of work and\n/// then later on the entire graph is processed and compiled.\n///\n/// It is created from `JobQueue` when we have fully assembled the crate graph\n/// (i.e., all package dependencies are known).\nstruct DrainState<'gctx> {\n // This is the length of the DependencyQueue when starting out\n total_units: usize,\n\n queue: DependencyQueue,\n messages: Arc>,\n /// Diagnostic deduplication support.\n diag_dedupe: DiagDedupe<'gctx>,\n /// Count of warnings, used to print a summary after the job succeeds\n warning_count: HashMap,\n active: HashMap,\n compiled: HashSet,\n documented: HashSet,\n scraped: HashSet,\n counts: HashMap,\n progress: Progress<'gctx>,\n next_id: u32,\n timings: Timings<'gctx>,\n\n /// Map from unit index to unit, for looking up dependency information.\n index_to_unit: HashMap,\n\n /// Tokens that are currently owned by this Cargo, and may be \"associated\"\n /// with a rustc process. They may also be unused, though if so will be\n /// dropped on the next loop iteration.\n ///\n /// Note that the length of this may be zero, but we will still spawn work,\n /// as we share the implicit token given to this Cargo process with a\n /// single rustc process.\n tokens: Vec,\n\n /// The list of jobs that we have not yet started executing, but have\n /// retrieved from the `queue`. We eagerly pull jobs off the main queue to\n /// allow us to request jobserver tokens pretty early.\n pending_queue: Vec<(Unit, Job, usize)>,\n print: DiagnosticPrinter<'gctx>,\n\n /// How many jobs we've finished\n finished: usize,\n per_package_future_incompat_reports: Vec,\n}\n\n/// Count of warnings, used to print a summary after the job succeeds\n#[derive(Default, Clone)]\npub struct WarningCount {\n /// total number of warnings\n pub total: usize,\n /// number of lint warnings\n pub lints: usize,\n /// number of warnings that were suppressed because they\n /// were duplicates of a previous warning\n pub duplicates: usize,\n /// number of fixable warnings set to `NotAllowed`\n /// if any errors have been seen for the current\n /// target\n pub fixable: FixableWarnings,\n}\n\nimpl WarningCount {\n /// If an error is seen this should be called\n /// to set `fixable` to `NotAllowed`\n fn disallow_fixable(&mut self) {\n self.fixable = FixableWarnings::NotAllowed;\n }\n\n /// Checks fixable if warnings are allowed\n /// fixable warnings are allowed if no\n /// errors have been seen for the current\n /// target. If an error was seen `fixable`\n /// will be `NotAllowed`.\n fn fixable_allowed(&self) -> bool {\n match &self.fixable {\n FixableWarnings::NotAllowed => false,\n _ => true,\n }\n }\n}\n\n/// Used to keep track of how many fixable warnings there are\n/// and if fixable warnings are allowed\n#[derive(Default, Copy, Clone)]\npub enum FixableWarnings {\n NotAllowed,\n #[default]\n Zero,\n Positive(usize),\n}\n\npub struct ErrorsDuringDrain {\n pub count: usize,\n}\n\nstruct ErrorToHandle {\n error: anyhow::Error,\n\n /// This field is true for \"interesting\" errors and false for \"mundane\"\n /// errors. If false, we print the above error only if it's the first one\n /// encountered so far while draining the job queue.\n ///\n /// At most places that an error is propagated, we set this to false to\n /// avoid scenarios where Cargo might end up spewing tons of redundant error\n /// messages. For example if an i/o stream got closed somewhere, we don't\n /// care about individually reporting every thread that it broke; just the\n /// first is enough.\n ///\n /// The exception where `print_always` is true is that we do report every\n /// instance of a rustc invocation that failed with diagnostics. This\n /// corresponds to errors from `Message::Finish`.\n print_always: bool,\n}\n\nimpl From for ErrorToHandle\nwhere\n anyhow::Error: From,\n{\n fn from(error: E) -> Self {\n ErrorToHandle {\n error: anyhow::Error::from(error),\n print_always: false,\n }\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]\npub struct JobId(pub u32);\n\nimpl std::fmt::Display for JobId {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n\n/// Handler for deduplicating diagnostics.\nstruct DiagDedupe<'gctx> {\n seen: RefCell>,\n gctx: &'gctx GlobalContext,\n}\n\nimpl<'gctx> DiagDedupe<'gctx> {\n fn new(gctx: &'gctx GlobalContext) -> Self {\n DiagDedupe {\n seen: RefCell::new(HashSet::new()),\n gctx,\n }\n }\n\n /// Emits a diagnostic message.\n ///\n /// Returns `true` if the message was emitted, or `false` if it was\n /// suppressed for being a duplicate.\n fn emit_diag(&self, diag: &str) -> CargoResult {\n let h = util::hash_u64(diag);\n if !self.seen.borrow_mut().insert(h) {\n return Ok(false);\n }\n let mut shell = self.gctx.shell();\n shell.print_ansi_stderr(diag.as_bytes())?;\n shell.err().write_all(b\"\\n\")?;\n Ok(true)\n }\n}\n\n/// Possible artifacts that can be produced by compilations, used as edge values\n/// in the dependency graph.\n///\n/// As edge values we can have multiple kinds of edges depending on one node,\n/// for example some units may only depend on the metadata for an rlib while\n/// others depend on the full rlib. This `Artifact` enum is used to distinguish\n/// this case and track the progress of compilations as they proceed.\n#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]\nenum Artifact {\n /// A generic placeholder for \"depends on everything run by a step\" and\n /// means that we can't start the next compilation until the previous has\n /// finished entirely.\n All,\n\n /// A node indicating that we only depend on the metadata of a compilation,\n /// but the compilation is typically also producing an rlib. We can start\n /// our step, however, before the full rlib is available.\n Metadata,\n}\n\nenum Message {\n Run(JobId, String),\n Stdout(String),\n Stderr(String),\n\n // This is for general stderr output from subprocesses\n Diagnostic {\n id: JobId,\n level: String,\n diag: String,\n lint: bool,\n fixable: bool,\n },\n // This handles duplicate output that is suppressed, for showing\n // only a count of duplicate messages instead\n WarningCount {\n id: JobId,\n lint: bool,\n emitted: bool,\n fixable: bool,\n },\n // This is for warnings generated by Cargo's interpretation of the\n // subprocess output, e.g. scrape-examples prints a warning if a\n // unit fails to be scraped\n Warning {\n id: JobId,\n warning: String,\n },\n\n FixDiagnostic(diagnostic_server::Message),\n Token(io::Result),\n Finish(JobId, Artifact, CargoResult<()>),\n FutureIncompatReport(JobId, Vec),\n SectionTiming(JobId, SectionTiming),\n}\n\nimpl<'gctx> JobQueue<'gctx> {\n pub fn new(bcx: &BuildContext<'_, 'gctx>) -> JobQueue<'gctx> {\n JobQueue {\n queue: DependencyQueue::new(),\n counts: HashMap::new(),\n timings: Timings::new(bcx),\n }\n }\n\n pub fn enqueue(\n &mut self,\n build_runner: &BuildRunner<'_, 'gctx>,\n unit: &Unit,\n job: Job,\n ) -> CargoResult<()> {\n let dependencies = build_runner.unit_deps(unit);\n let mut queue_deps = dependencies\n .iter()\n .filter(|dep| {\n // Binaries aren't actually needed to *compile* tests, just to run\n // them, so we don't include this dependency edge in the job graph.\n // But we shouldn't filter out dependencies being scraped for Rustdoc.\n (!dep.unit.target.is_test() && !dep.unit.target.is_bin())\n || dep.unit.artifact.is_true()\n || dep.unit.mode.is_doc_scrape()\n })\n .map(|dep| {\n // Handle the case here where our `unit -> dep` dependency may\n // only require the metadata, not the full compilation to\n // finish. Use the tables in `build_runner` to figure out what\n // kind of artifact is associated with this dependency.\n let artifact = if build_runner.only_requires_rmeta(unit, &dep.unit) {\n Artifact::Metadata\n } else {\n Artifact::All\n };\n (dep.unit.clone(), artifact)\n })\n .collect::>();\n\n // This is somewhat tricky, but we may need to synthesize some\n // dependencies for this target if it requires full upstream\n // compilations to have completed. Because of pipelining, some\n // dependency edges may be `Metadata` due to the above clause (as\n // opposed to everything being `All`). For example consider:\n //\n // a (binary)\n // ā”” b (lib)\n // ā”” c (lib)\n //\n // Here the dependency edge from B to C will be `Metadata`, and the\n // dependency edge from A to B will be `All`. For A to be compiled,\n // however, it currently actually needs the full rlib of C. This means\n // that we need to synthesize a dependency edge for the dependency graph\n // from A to C. That's done here.\n //\n // This will walk all dependencies of the current target, and if any of\n // *their* dependencies are `Metadata` then we depend on the `All` of\n // the target as well. This should ensure that edges changed to\n // `Metadata` propagate upwards `All` dependencies to anything that\n // transitively contains the `Metadata` edge.\n if unit.requires_upstream_objects() {\n for dep in dependencies {\n depend_on_deps_of_deps(build_runner, &mut queue_deps, dep.unit.clone());\n }\n\n fn depend_on_deps_of_deps(\n build_runner: &BuildRunner<'_, '_>,\n deps: &mut HashMap,\n unit: Unit,\n ) {\n for dep in build_runner.unit_deps(&unit) {\n if deps.insert(dep.unit.clone(), Artifact::All).is_none() {\n depend_on_deps_of_deps(build_runner, deps, dep.unit.clone());\n }\n }\n }\n }\n\n // For now we use a fixed placeholder value for the cost of each unit, but\n // in the future this could be used to allow users to provide hints about\n // relative expected costs of units, or this could be automatically set in\n // a smarter way using timing data from a previous compilation.\n self.queue.queue(unit.clone(), job, queue_deps, 100);\n *self.counts.entry(unit.pkg.package_id()).or_insert(0) += 1;\n Ok(())\n }\n\n /// Executes all jobs necessary to build the dependency graph.\n ///\n /// This function will spawn off `config.jobs()` workers to build all of the\n /// necessary dependencies, in order. Freshness is propagated as far as\n /// possible along each dependency chain.\n #[tracing::instrument(skip_all)]\n pub fn execute(mut self, build_runner: &mut BuildRunner<'_, '_>) -> CargoResult<()> {\n self.queue.queue_finished();\n\n let progress =\n Progress::with_style(\"Building\", ProgressStyle::Ratio, build_runner.bcx.gctx);\n let state = DrainState {\n total_units: self.queue.len(),\n queue: self.queue,\n // 100 here is somewhat arbitrary. It is a few screenfulls of\n // output, and hopefully at most a few megabytes of memory for\n // typical messages. If you change this, please update the test\n // caching_large_output, too.\n messages: Arc::new(Queue::new(100)),\n diag_dedupe: DiagDedupe::new(build_runner.bcx.gctx),\n warning_count: HashMap::new(),\n active: HashMap::new(),\n compiled: HashSet::new(),\n documented: HashSet::new(),\n scraped: HashSet::new(),\n counts: self.counts,\n progress,\n next_id: 0,\n timings: self.timings,\n index_to_unit: build_runner\n .bcx\n .unit_to_index\n .iter()\n .map(|(unit, &index)| (index, unit.clone()))\n .collect(),\n tokens: Vec::new(),\n pending_queue: Vec::new(),\n print: DiagnosticPrinter::new(\n build_runner.bcx.gctx,\n &build_runner.bcx.rustc().workspace_wrapper,\n ),\n finished: 0,\n per_package_future_incompat_reports: Vec::new(),\n };\n\n // Create a helper thread for acquiring jobserver tokens\n let messages = state.messages.clone();\n let helper = build_runner\n .jobserver\n .clone()\n .into_helper_thread(move |token| {\n messages.push(Message::Token(token));\n })\n .context(\"failed to create helper thread for jobserver management\")?;\n\n // Create a helper thread to manage the diagnostics for rustfix if\n // necessary.\n let messages = state.messages.clone();\n // It is important that this uses `push` instead of `push_bounded` for\n // now. If someone wants to fix this to be bounded, the `drop`\n // implementation needs to be changed to avoid possible deadlocks.\n let _diagnostic_server = build_runner\n .bcx\n .build_config\n .rustfix_diagnostic_server\n .borrow_mut()\n .take()\n .map(move |srv| srv.start(move |msg| messages.push(Message::FixDiagnostic(msg))));\n\n thread::scope(\n move |scope| match state.drain_the_queue(build_runner, scope, &helper) {\n Some(err) => Err(err),\n None => Ok(()),\n },\n )\n }\n}\n\nimpl<'gctx> DrainState<'gctx> {\n fn spawn_work_if_possible<'s>(\n &mut self,\n build_runner: &mut BuildRunner<'_, '_>,\n jobserver_helper: &HelperThread,\n scope: &'s Scope<'s, '_>,\n ) -> CargoResult<()> {\n // Dequeue as much work as we can, learning about everything\n // possible that can run. Note that this is also the point where we\n // start requesting job tokens. Each job after the first needs to\n // request a token.\n while let Some((unit, job, priority)) = self.queue.dequeue() {\n // We want to keep the pieces of work in the `pending_queue` sorted\n // by their priorities, and insert the current job at its correctly\n // sorted position: following the lower priority jobs, and the ones\n // with the same priority (since they were dequeued before the\n // current one, we also keep that relation).\n let idx = self\n .pending_queue\n .partition_point(|&(_, _, p)| p <= priority);\n self.pending_queue.insert(idx, (unit, job, priority));\n if self.active.len() + self.pending_queue.len() > 1 {\n jobserver_helper.request_token();\n }\n }\n\n // Now that we've learned of all possible work that we can execute\n // try to spawn it so long as we've got a jobserver token which says\n // we're able to perform some parallel work.\n // The `pending_queue` is sorted in ascending priority order, and we\n // remove items from its end to schedule the highest priority items\n // sooner.\n while self.has_extra_tokens() && !self.pending_queue.is_empty() {\n let (unit, job, _) = self.pending_queue.pop().unwrap();\n *self.counts.get_mut(&unit.pkg.package_id()).unwrap() -= 1;\n // Print out some nice progress information.\n // NOTE: An error here will drop the job without starting it.\n // That should be OK, since we want to exit as soon as\n // possible during an error.\n self.note_working_on(\n build_runner.bcx.gctx,\n build_runner.bcx.ws.root(),\n &unit,\n job.freshness(),\n )?;\n self.run(&unit, job, build_runner, scope);\n }\n\n Ok(())\n }\n\n fn has_extra_tokens(&self) -> bool {\n self.active.len() < self.tokens.len() + 1\n }\n\n fn handle_event(\n &mut self,\n build_runner: &mut BuildRunner<'_, '_>,\n event: Message,\n ) -> Result<(), ErrorToHandle> {\n let warning_handling = build_runner.bcx.gctx.warning_handling()?;\n match event {\n Message::Run(id, cmd) => {\n build_runner\n .bcx\n .gctx\n .shell()\n .verbose(|c| c.status(\"Running\", &cmd))?;\n self.timings\n .unit_start(build_runner, id, self.active[&id].clone());\n }\n Message::Stdout(out) => {\n writeln!(build_runner.bcx.gctx.shell().out(), \"{}\", out)?;\n }\n Message::Stderr(err) => {\n let mut shell = build_runner.bcx.gctx.shell();\n shell.print_ansi_stderr(err.as_bytes())?;\n shell.err().write_all(b\"\\n\")?;\n }\n Message::Diagnostic {\n id,\n level,\n diag,\n lint,\n fixable,\n } => {\n let emitted = self.diag_dedupe.emit_diag(&diag)?;\n if level == \"warning\" {\n self.bump_warning_count(id, lint, emitted, fixable);\n }\n if level == \"error\" {\n let count = self.warning_count.entry(id).or_default();\n // If there is an error, the `cargo fix` message should not show\n count.disallow_fixable();\n }\n }\n Message::Warning { id, warning } => {\n if warning_handling != WarningHandling::Allow {\n build_runner.bcx.gctx.shell().warn(warning)?;\n }\n let lint = false;\n let emitted = true;\n let fixable = false;\n self.bump_warning_count(id, lint, emitted, fixable);\n }\n Message::WarningCount {\n id,\n lint,\n emitted,\n fixable,\n } => {\n self.bump_warning_count(id, lint, emitted, fixable);\n }\n Message::FixDiagnostic(msg) => {\n self.print.print(&msg)?;\n }\n Message::Finish(id, artifact, mut result) => {\n let unit = match artifact {\n // If `id` has completely finished we remove it\n // from the `active` map ...\n Artifact::All => {\n trace!(\"end: {:?}\", id);\n self.finished += 1;\n let unit = self.active.remove(&id).unwrap();\n // An error could add an entry for a `Unit`\n // with 0 warnings but having fixable\n // warnings be disallowed\n let count = self\n .warning_count\n .get(&id)\n .filter(|count| 0 < count.total)\n .cloned();\n if let Some(count) = count {\n self.report_warning_count(\n build_runner,\n &unit,\n &count,\n &build_runner.bcx.rustc().workspace_wrapper,\n warning_handling,\n );\n let stop_on_warnings = warning_handling == WarningHandling::Deny\n && 0 < count.lints\n && !build_runner.bcx.build_config.keep_going;\n if stop_on_warnings {\n result = Err(anyhow::format_err!(\n \"warnings are denied by `build.warnings` configuration\"\n ))\n }\n }\n unit\n }\n // ... otherwise if it hasn't finished we leave it\n // in there as we'll get another `Finish` later on.\n Artifact::Metadata => {\n trace!(\"end (meta): {:?}\", id);\n self.active[&id].clone()\n }\n };\n debug!(\"end ({:?}): {:?}\", unit, result);\n match result {\n Ok(()) => self.finish(id, &unit, artifact, build_runner)?,\n Err(_) if build_runner.bcx.unit_can_fail_for_docscraping(&unit) => {\n build_runner\n .failed_scrape_units\n .lock()\n .unwrap()\n .insert(build_runner.files().metadata(&unit).unit_id());\n self.queue.finish(&unit, &artifact);\n }\n Err(error) => {\n let show_warnings = true;\n self.emit_log_messages(&unit, build_runner, show_warnings)?;\n self.back_compat_notice(build_runner, &unit)?;\n return Err(ErrorToHandle {\n error,\n print_always: true,\n });\n }\n }\n }\n Message::FutureIncompatReport(id, items) => {\n let unit = &self.active[&id];\n let package_id = unit.pkg.package_id();\n let is_local = unit.is_local();\n self.per_package_future_incompat_reports\n .push(FutureIncompatReportPackage {\n package_id,\n is_local,\n items,\n });\n }\n Message::Token(acquired_token) => {\n let token = acquired_token.context(\"failed to acquire jobserver token\")?;\n self.tokens.push(token);\n }\n Message::SectionTiming(id, section) => {\n self.timings.unit_section_timing(build_runner, id, §ion);\n }\n }\n\n Ok(())\n }\n\n // This will also tick the progress bar as appropriate\n fn wait_for_events(&mut self) -> Vec {\n // Drain all events at once to avoid displaying the progress bar\n // unnecessarily. If there's no events we actually block waiting for\n // an event, but we keep a \"heartbeat\" going to allow `record_cpu`\n // to run above to calculate CPU usage over time. To do this we\n // listen for a message with a timeout, and on timeout we run the\n // previous parts of the loop again.\n let mut events = self.messages.try_pop_all();\n if events.is_empty() {\n loop {\n self.tick_progress();\n self.tokens.truncate(self.active.len() - 1);\n match self.messages.pop(Duration::from_millis(500)) {\n Some(message) => {\n events.push(message);\n break;\n }\n None => continue,\n }\n }\n }\n events\n }\n\n /// This is the \"main\" loop, where Cargo does all work to run the\n /// compiler.\n ///\n /// This returns an Option to prevent the use of `?` on `Result` types\n /// because it is important for the loop to carefully handle errors.\n fn drain_the_queue<'s>(\n mut self,\n build_runner: &mut BuildRunner<'_, '_>,\n scope: &'s Scope<'s, '_>,\n jobserver_helper: &HelperThread,\n ) -> Option {\n trace!(\"queue: {:#?}\", self.queue);\n\n // Iteratively execute the entire dependency graph. Each turn of the\n // loop starts out by scheduling as much work as possible (up to the\n // maximum number of parallel jobs we have tokens for). A local queue\n // is maintained separately from the main dependency queue as one\n // dequeue may actually dequeue quite a bit of work (e.g., 10 binaries\n // in one package).\n //\n // After a job has finished we update our internal state if it was\n // successful and otherwise wait for pending work to finish if it failed\n // and then immediately return (or keep going, if requested by the build\n // config).\n let mut errors = ErrorsDuringDrain { count: 0 };\n // CAUTION! Do not use `?` or break out of the loop early. Every error\n // must be handled in such a way that the loop is still allowed to\n // drain event messages.\n loop {\n if errors.count == 0 || build_runner.bcx.build_config.keep_going {\n if let Err(e) = self.spawn_work_if_possible(build_runner, jobserver_helper, scope) {\n self.handle_error(&mut build_runner.bcx.gctx.shell(), &mut errors, e);\n }\n }\n\n // If after all that we're not actually running anything then we're\n // done!\n if self.active.is_empty() {\n break;\n }\n\n // And finally, before we block waiting for the next event, drop any\n // excess tokens we may have accidentally acquired. Due to how our\n // jobserver interface is architected we may acquire a token that we\n // don't actually use, and if this happens just relinquish it back\n // to the jobserver itself.\n for event in self.wait_for_events() {\n if let Err(event_err) = self.handle_event(build_runner, event) {\n self.handle_error(&mut build_runner.bcx.gctx.shell(), &mut errors, event_err);\n }\n }\n }\n self.progress.clear();\n\n let profile_name = build_runner.bcx.build_config.requested_profile;\n // NOTE: this may be a bit inaccurate, since this may not display the\n // profile for what was actually built. Profile overrides can change\n // these settings, and in some cases different targets are built with\n // different profiles. To be accurate, it would need to collect a\n // list of Units built, and maybe display a list of the different\n // profiles used. However, to keep it simple and compatible with old\n // behavior, we just display what the base profile is.\n let profile = build_runner.bcx.profiles.base_profile();\n let mut opt_type = String::from(if profile.opt_level.as_str() == \"0\" {\n \"unoptimized\"\n } else {\n \"optimized\"\n });\n if profile.debuginfo.is_turned_on() {\n opt_type += \" + debuginfo\";\n }\n\n let time_elapsed = util::elapsed(build_runner.bcx.gctx.creation_time().elapsed());\n if let Err(e) = self\n .timings\n .finished(build_runner, &errors.to_error())\n .context(\"failed to render timing report\")\n {\n self.handle_error(&mut build_runner.bcx.gctx.shell(), &mut errors, e);\n }\n if build_runner.bcx.build_config.emit_json() {\n let mut shell = build_runner.bcx.gctx.shell();\n let msg = machine_message::BuildFinished {\n success: errors.count == 0,\n }\n .to_json_string();\n if let Err(e) = writeln!(shell.out(), \"{}\", msg) {\n self.handle_error(&mut shell, &mut errors, e);\n }\n }\n\n if let Some(error) = errors.to_error() {\n // Any errors up to this point have already been printed via the\n // `display_error` inside `handle_error`.\n Some(anyhow::Error::new(AlreadyPrintedError::new(error)))\n } else if self.queue.is_empty() && self.pending_queue.is_empty() {\n let profile_link = build_runner.bcx.gctx.shell().err_hyperlink(\n \"https://doc.rust-lang.org/cargo/reference/profiles.html#default-profiles\",\n );\n let message = format!(\n \"{profile_link}`{profile_name}` profile [{opt_type}]{profile_link:#} target(s) in {time_elapsed}\",\n );\n // It doesn't really matter if this fails.\n let _ = build_runner.bcx.gctx.shell().status(\"Finished\", message);\n future_incompat::save_and_display_report(\n build_runner.bcx,\n &self.per_package_future_incompat_reports,\n );\n\n None\n } else {\n debug!(\"queue: {:#?}\", self.queue);\n Some(internal(\"finished with jobs still left in the queue\"))\n }\n }\n\n fn handle_error(\n &mut self,\n shell: &mut Shell,\n err_state: &mut ErrorsDuringDrain,\n new_err: impl Into,\n ) {\n let new_err = new_err.into();\n if new_err.print_always || err_state.count == 0 {\n crate::display_error(&new_err.error, shell);\n if err_state.count == 0 && !self.active.is_empty() {\n self.progress.indicate_error();\n let _ = shell.warn(\"build failed, waiting for other jobs to finish...\");\n }\n err_state.count += 1;\n } else {\n tracing::warn!(\"{:?}\", new_err.error);\n }\n }\n\n // This also records CPU usage and marks concurrency; we roughly want to do\n // this as often as we spin on the events receiver (at least every 500ms or\n // so).\n fn tick_progress(&mut self) {\n // Record some timing information if `--timings` is enabled, and\n // this'll end up being a noop if we're not recording this\n // information.\n self.timings.record_cpu();\n\n let active_names = self\n .active\n .values()\n .map(|u| self.name_for_progress(u))\n .collect::>();\n let _ = self.progress.tick_now(\n self.finished,\n self.total_units,\n &format!(\": {}\", active_names.join(\", \")),\n );\n }\n\n fn name_for_progress(&self, unit: &Unit) -> String {\n let pkg_name = unit.pkg.name();\n let target_name = unit.target.name();\n match unit.mode {\n CompileMode::Doc { .. } => format!(\"{}(doc)\", pkg_name),\n CompileMode::RunCustomBuild => format!(\"{}(build)\", pkg_name),\n CompileMode::Test | CompileMode::Check { test: true } => match unit.target.kind() {\n TargetKind::Lib(_) => format!(\"{}(test)\", target_name),\n TargetKind::CustomBuild => panic!(\"cannot test build script\"),\n TargetKind::Bin => format!(\"{}(bin test)\", target_name),\n TargetKind::Test => format!(\"{}(test)\", target_name),\n TargetKind::Bench => format!(\"{}(bench)\", target_name),\n TargetKind::ExampleBin | TargetKind::ExampleLib(_) => {\n format!(\"{}(example test)\", target_name)\n }\n },\n _ => match unit.target.kind() {\n TargetKind::Lib(_) => pkg_name.to_string(),\n TargetKind::CustomBuild => format!(\"{}(build.rs)\", pkg_name),\n TargetKind::Bin => format!(\"{}(bin)\", target_name),\n TargetKind::Test => format!(\"{}(test)\", target_name),\n TargetKind::Bench => format!(\"{}(bench)\", target_name),\n TargetKind::ExampleBin | TargetKind::ExampleLib(_) => {\n format!(\"{}(example)\", target_name)\n }\n },\n }\n }\n\n /// Executes a job.\n ///\n /// Fresh jobs block until finished (which should be very fast!), Dirty\n /// jobs will spawn a thread in the background and return immediately.\n fn run<'s>(\n &mut self,\n unit: &Unit,\n job: Job,\n build_runner: &BuildRunner<'_, '_>,\n scope: &'s Scope<'s, '_>,\n ) {\n let id = JobId(self.next_id);\n self.next_id = self.next_id.checked_add(1).unwrap();\n\n debug!(\"start {}: {:?}\", id, unit);\n\n assert!(self.active.insert(id, unit.clone()).is_none());\n\n let messages = self.messages.clone();\n let is_fresh = job.freshness().is_fresh();\n let rmeta_required = build_runner.rmeta_required(unit);\n let lock_manager = build_runner.lock_manager.clone();\n\n let doit = move |diag_dedupe| {\n let state = JobState::new(id, messages, diag_dedupe, rmeta_required, lock_manager);\n state.run_to_finish(job);\n };\n\n match is_fresh {\n true => {\n // Running a fresh job on the same thread is often much faster than spawning a new\n // thread to run the job.\n doit(Some(&self.diag_dedupe));\n }\n false => {\n scope.spawn(move || doit(None));\n }\n }\n }\n\n fn emit_log_messages(\n &self,\n unit: &Unit,\n build_runner: &mut BuildRunner<'_, '_>,\n show_warnings: bool,\n ) -> CargoResult<()> {\n let outputs = build_runner.build_script_outputs.lock().unwrap();\n let Some(metadata_vec) = build_runner.find_build_script_metadatas(unit) else {\n return Ok(());\n };\n let bcx = &mut build_runner.bcx;\n for metadata in metadata_vec {\n if let Some(output) = outputs.get(metadata) {\n if !output.log_messages.is_empty()\n && (show_warnings\n || output\n .log_messages\n .iter()\n .any(|(severity, _)| *severity == Severity::Error))\n {\n let msg_with_package =\n |msg: &str| format!(\"{}@{}: {}\", unit.pkg.name(), unit.pkg.version(), msg);\n\n for (severity, message) in output.log_messages.iter() {\n match severity {\n Severity::Error => {\n bcx.gctx.shell().error(msg_with_package(message))?;\n }\n Severity::Warning => {\n bcx.gctx.shell().warn(msg_with_package(message))?;\n }\n }\n }\n }\n }\n }\n\n Ok(())\n }\n\n fn bump_warning_count(&mut self, id: JobId, lint: bool, emitted: bool, fixable: bool) {\n let count = self.warning_count.entry(id).or_default();\n count.total += 1;\n if lint {\n let unit = self.active.get(&id).unwrap();\n // If this is an upstream dep but we *do* want warnings, make sure that they\n // don't fail compilation.\n if unit.is_local() {\n count.lints += 1;\n }\n }\n if !emitted {\n count.duplicates += 1;\n // Don't add to fixable if it's already been emitted\n } else if fixable {\n // Do not add anything to the fixable warning count if\n // is `NotAllowed` since that indicates there was an\n // error while building this `Unit`\n if count.fixable_allowed() {\n count.fixable = match count.fixable {\n FixableWarnings::NotAllowed => FixableWarnings::NotAllowed,\n FixableWarnings::Zero => FixableWarnings::Positive(1),\n FixableWarnings::Positive(fixable) => FixableWarnings::Positive(fixable + 1),\n };\n }\n }\n }\n\n /// Displays a final report of the warnings emitted by a particular job.\n fn report_warning_count(\n &mut self,\n runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n count: &WarningCount,\n rustc_workspace_wrapper: &Option,\n warning_handling: WarningHandling,\n ) {\n let gctx = runner.bcx.gctx;\n runner.compilation.lint_warning_count += count.lints;\n let mut message = descriptive_pkg_name(&unit.pkg.name(), &unit.target, &unit.mode);\n message.push_str(\" generated \");\n match count.total {\n 1 => message.push_str(\"1 warning\"),\n n => {\n let _ = write!(message, \"{} warnings\", n);\n }\n };\n match count.duplicates {\n 0 => {}\n 1 => message.push_str(\" (1 duplicate)\"),\n n => {\n let _ = write!(message, \" ({} duplicates)\", n);\n }\n }\n // Only show the `cargo fix` message if its a local `Unit`\n if unit.is_local() {\n // Do not show this if there are any errors or no fixable warnings\n if let FixableWarnings::Positive(fixable) = count.fixable {\n // `cargo fix` doesn't have an option for custom builds\n if !unit.target.is_custom_build() {\n // To make sure the correct command is shown for `clippy` we\n // check if `RUSTC_WORKSPACE_WRAPPER` is set and pointing towards\n // `clippy-driver`.\n let clippy = std::ffi::OsStr::new(\"clippy-driver\");\n let is_clippy = rustc_workspace_wrapper.as_ref().and_then(|x| x.file_stem())\n == Some(clippy);\n\n let command = if is_clippy {\n \"cargo clippy --fix\"\n } else {\n \"cargo fix\"\n };\n\n let mut args =\n format!(\"{} -p {}\", unit.target.description_named(), unit.pkg.name());\n if unit.mode.is_rustc_test()\n && !(unit.target.is_test() || unit.target.is_bench())\n {\n args.push_str(\" --tests\");\n }\n let mut suggestions = format!(\"{} suggestion\", fixable);\n if fixable > 1 {\n suggestions.push_str(\"s\")\n }\n\n #[expect(clippy::disallowed_methods, reason = \"consistency with clippy\")]\n let _ = write!(\n message,\n \" (run `{command} --{args}{}` to apply {suggestions})\",\n if let Some(cli_lints_os) = env::var_os(\"CLIPPY_ARGS\")\n && let Ok(cli_lints) = cli_lints_os.into_string()\n && is_clippy\n {\n // Clippy can take lints through the CLI, each lint flag is separated by \"__CLIPPY_HACKERY__\".\n let cli_lints = cli_lints.replace(\"__CLIPPY_HACKERY__\", \" \");\n let cli_lints = cli_lints.trim_ascii_end(); // Remove that last space left by __CLIPPY_HACKERY__\n format!(\" -- {cli_lints}\")\n } else {\n \"\".to_owned()\n }\n );\n }\n }\n }\n // Errors are ignored here because it is tricky to handle them\n // correctly, and they aren't important.\n let _ = if warning_handling == WarningHandling::Deny && 0 < count.lints {\n gctx.shell().error(message)\n } else {\n gctx.shell().warn(message)\n };\n }\n\n fn finish(\n &mut self,\n id: JobId,\n unit: &Unit,\n artifact: Artifact,\n build_runner: &mut BuildRunner<'_, '_>,\n ) -> CargoResult<()> {\n if unit.mode.is_run_custom_build() {\n self.emit_log_messages(\n unit,\n build_runner,\n unit.show_warnings(build_runner.bcx.gctx),\n )?;\n }\n let unblocked = self.queue.finish(unit, &artifact);\n match artifact {\n Artifact::All => self.timings.unit_finished(build_runner, id, unblocked),\n Artifact::Metadata => self\n .timings\n .unit_rmeta_finished(build_runner, id, unblocked),\n }\n Ok(())\n }\n\n // This isn't super trivial because we don't want to print loads and\n // loads of information to the console, but we also want to produce a\n // faithful representation of what's happening. This is somewhat nuanced\n // as a package can start compiling *very* early on because of custom\n // build commands and such.\n //\n // In general, we try to print \"Compiling\" for the first nontrivial task\n // run for a package, regardless of when that is. We then don't print\n // out any more information for a package after we've printed it once.\n fn note_working_on(\n &mut self,\n gctx: &GlobalContext,\n ws_root: &Path,\n unit: &Unit,\n fresh: &Freshness,\n ) -> CargoResult<()> {\n if (self.compiled.contains(&unit.pkg.package_id())\n && !unit.mode.is_doc()\n && !unit.mode.is_doc_scrape())\n || (self.documented.contains(&unit.pkg.package_id()) && unit.mode.is_doc())\n || (self.scraped.contains(&unit.pkg.package_id()) && unit.mode.is_doc_scrape())\n {\n return Ok(());\n }\n\n match fresh {\n // Any dirty stage which runs at least one command gets printed as\n // being a compiled package.\n Dirty(dirty_reason) => {\n if !dirty_reason.is_fresh_build() {\n gctx.shell().verbose(|shell| {\n dirty_reason.present_to(shell, unit, ws_root, &self.index_to_unit)\n })?;\n }\n\n if unit.mode.is_doc() {\n self.documented.insert(unit.pkg.package_id());\n gctx.shell().status(\"Documenting\", &unit.pkg)?;\n } else if unit.mode.is_doc_test() {\n // Skip doc test.\n } else if unit.mode.is_doc_scrape() {\n self.scraped.insert(unit.pkg.package_id());\n gctx.shell().status(\"Scraping\", &unit.pkg)?;\n } else {\n self.compiled.insert(unit.pkg.package_id());\n if unit.mode.is_check() {\n gctx.shell().status(\"Checking\", &unit.pkg)?;\n } else {\n gctx.shell().status(\"Compiling\", &unit.pkg)?;\n }\n }\n }\n Fresh => {\n // If doc test are last, only print \"Fresh\" if nothing has been printed.\n if self.counts[&unit.pkg.package_id()] == 0\n && !(unit.mode.is_doc_test() && self.compiled.contains(&unit.pkg.package_id()))\n {\n self.compiled.insert(unit.pkg.package_id());\n gctx.shell().verbose(|c| c.status(\"Fresh\", &unit.pkg))?;\n }\n }\n }\n Ok(())\n }\n\n fn back_compat_notice(\n &self,\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n ) -> CargoResult<()> {\n if unit.pkg.name() != \"diesel\"\n || unit.pkg.version() >= &Version::new(1, 4, 8)\n || build_runner.bcx.ws.resolve_behavior() == ResolveBehavior::V1\n || !unit.pkg.package_id().source_id().is_registry()\n || !unit.features.is_empty()\n {\n return Ok(());\n }\n if !build_runner\n .bcx\n .unit_graph\n .keys()\n .any(|unit| unit.pkg.name() == \"diesel\" && !unit.features.is_empty())\n {\n return Ok(());\n }\n build_runner.bcx.gctx.shell().note(\n \"\\\nThis error may be due to an interaction between diesel and Cargo's new\nfeature resolver. Try updating to diesel 1.4.8 to fix this error.\n\",\n )?;\n Ok(())\n }\n}\n\nimpl ErrorsDuringDrain {\n fn to_error(&self) -> Option {\n match self.count {\n 0 => None,\n 1 => Some(format_err!(\"1 job failed\")),\n n => Some(format_err!(\"{} jobs failed\", n)),\n }\n }\n}\n" }, { "path": "src/cargo/core/compiler/layout.rs", "content": "//! Management of the directory layout of a build\n//!\n//! The directory layout is a little tricky at times, hence a separate file to\n//! house this logic. Cargo stores build artifacts in two directories: `artifact-dir` and\n//! `build-dir`\n//!\n//! ## `artifact-dir` layout\n//!\n//! `artifact-dir` is where final artifacts like binaries are stored.\n//! The `artifact-dir` layout is consider part of the public API and\n//! cannot be easily changed.\n//!\n//! ```text\n//! /\n//!\n//! # Compilation files are grouped by build target and profile.\n//! # The target is omitted if not explicitly specified.\n//! []// # e.g. `debug` / `release`\n//!\n//! # File used to lock the directory to prevent multiple cargo processes\n//! # from using it at the same time.\n//! .cargo-lock\n//!\n//! # Root directory for all compiled examples.\n//! examples/\n//!\n//! # Output from rustdoc\n//! doc/\n//!\n//! # Output from `cargo package` to build a `.crate` file.\n//! package/\n//! ```\n//!\n//! ## `build-dir` layout\n//!\n//! `build-dir` is where intermediate build artifacts are stored.\n//! The `build-dir` layout is considered an internal implementation detail of Cargo\n//! meaning that we can change this if needed. However, in reality many tools rely on\n//! implementation details of Cargo so breaking changes need to be done carefully.\n//!\n//! ```text\n//! /\n//!\n//! # Cache of `rustc -Vv` output for performance.\n//! .rustc-info.json\n//!\n//! # Compilation files are grouped by build target and profile.\n//! # The target is omitted if not explicitly specified.\n//! []// # e.g. `debug` / `release`\n//!\n//! # File used to lock the directory to prevent multiple cargo processes\n//! # from using it at the same time.\n//! .cargo-lock\n//!\n//! # Hidden directory that holds all of the fingerprint files for all\n//! # packages\n//! .fingerprint/\n//! # Each package is in a separate directory.\n//! # Note that different target kinds have different filename prefixes.\n//! $pkgname-$META/\n//! # Set of source filenames for this package.\n//! dep-lib-$targetname\n//! # Timestamp when this package was last built.\n//! invoked.timestamp\n//! # The fingerprint hash.\n//! lib-$targetname\n//! # Detailed information used for logging the reason why\n//! # something is being recompiled.\n//! lib-$targetname.json\n//! # The console output from the compiler. This is cached\n//! # so that warnings can be redisplayed for \"fresh\" units.\n//! output-lib-$targetname\n//!\n//! # This is the root directory for all rustc artifacts except build\n//! # scripts, examples, and test and bench executables. Almost every\n//! # artifact should have a metadata hash added to its filename to\n//! # prevent collisions. One notable exception is dynamic libraries.\n//! deps/\n//!\n//! # Each artifact dependency gets in its own directory.\n//! /artifact/$pkgname-$META/$kind\n//!\n//! # Root directory for all compiled examples.\n//! examples/\n//!\n//! # Directory used to store incremental data for the compiler (when\n//! # incremental is enabled.\n//! incremental/\n//!\n//! # This is the location at which the output of all custom build\n//! # commands are rooted.\n//! build/\n//!\n//! # Each package gets its own directory where its build script and\n//! # script output are placed\n//! $pkgname-$META/ # For the build script itself.\n//! # The build script executable (name may be changed by user).\n//! build-script-build-$META\n//! # Hard link to build-script-build-$META.\n//! build-script-build\n//! # Dependency information generated by rustc.\n//! build-script-build-$META.d\n//! # Debug information, depending on platform and profile\n//! # settings.\n//! \n//!\n//! # The package shows up twice with two different metadata hashes.\n//! $pkgname-$META/ # For the output of the build script.\n//! # Timestamp when the build script was last executed.\n//! invoked.timestamp\n//! # Directory where script can output files ($OUT_DIR).\n//! out/\n//! # Output from the build script.\n//! output\n//! # Path to `out`, used to help when the target directory is\n//! # moved.\n//! root-output\n//! # Stderr output from the build script.\n//! stderr\n//!\n//! # Used by `cargo package` and `cargo publish` to build a `.crate` file.\n//! package/\n//!\n//! # Experimental feature for generated build scripts.\n//! .metabuild/\n//! ```\n//!\n//! ### New `build-dir` layout\n//!\n//! `build-dir` supports a new \"build unit\" based layout that is unstable.\n//! It can be enabled via `-Zbuild-dir-new-layout`.\n//! For more info about the layout transition see: [#15010](https://github.com/rust-lang/cargo/issues/15010)\n//!\n//! ```text\n//! /\n//!\n//! # Cache of `rustc -Vv` output for performance.\n//! .rustc-info.json\n//!\n//! # Compilation files are grouped by build target and profile.\n//! # The target is omitted if not explicitly specified.\n//! []// # e.g. `debug` / `release`\n//!\n//! # File used to lock the directory to prevent multiple cargo processes\n//! # from using it at the same time.\n//! .cargo-lock\n//!\n//! # Directory used to store incremental data for the compiler (when\n//! # incremental is enabled.\n//! incremental/\n//!\n//! # Main directory for storing build unit related files.\n//! # Files are organized by Cargo build unit (`$pkgname/$META`) so that\n//! # related files are stored in a single directory.\n//! build/\n//!\n//! # This is the location at which the output of all files related to\n//! # a given build unit. These files are organized together so that we can\n//! # treat this directly like a single unit for locking and caching.\n//! $pkgname/\n//! $META/\n//! # The general purpose output directory for build units.\n//! # For compilation units, the rustc artifact will be located here.\n//! # For build script run units, this is the $OUT_DIR\n//! out/\n//!\n//! # For artifact dependency units, the output is nested by the kind\n//! artifact/$kind\n//!\n//! # Directory that holds all of the fingerprint files for the build unit.\n//! fingerprint/\n//! # Set of source filenames for this package.\n//! dep-lib-$targetname\n//! # Timestamp when this package was last built.\n//! invoked.timestamp\n//! # The fingerprint hash.\n//! lib-$targetname\n//! # Detailed information used for logging the reason why\n//! # something is being recompiled.\n//! lib-$targetname.json\n//! # The console output from the compiler. This is cached\n//! # so that warnings can be redisplayed for \"fresh\" units.\n//! output-lib-$targetname\n//!\n//! # Directory for \"execution\" units that spawn a process (excluding compilation with\n//! # rustc). Contains the process execution details.\n//! # Currently the only execution unit Cargo supports is running build script\n//! # binaries.\n//! run/\n//! # Timestamp of last execution.\n//! invoked.timestamp\n//! # Stdout output from the process.\n//! stdout\n//! # Stderr output from the process.\n//! stderr\n//! # Path to `out`, used to help when the target directory is\n//! # moved. (build scripts)\n//! root-output\n//!\n//! # Used by `cargo package` and `cargo publish` to build a `.crate` file.\n//! package/\n//!\n//! # Experimental feature for generated build scripts.\n//! .metabuild/\n//! ```\n//!\n//! When cross-compiling, the layout is the same, except it appears in\n//! `target/$TRIPLE`.\n\nuse crate::core::Workspace;\nuse crate::core::compiler::CompileTarget;\nuse crate::util::flock::is_on_nfs_mount;\nuse crate::util::{CargoResult, FileLock};\nuse cargo_util::paths;\nuse std::path::{Path, PathBuf};\n\n/// Contains the paths of all target output locations.\n///\n/// See module docs for more information.\npub struct Layout {\n artifact_dir: Option,\n build_dir: BuildDirLayout,\n}\n\nimpl Layout {\n /// Calculate the paths for build output, lock the build directory, and return as a Layout.\n ///\n /// This function will block if the directory is already locked.\n ///\n /// `dest` should be the final artifact directory name. Currently either\n /// \"debug\" or \"release\".\n pub fn new(\n ws: &Workspace<'_>,\n target: Option,\n dest: &str,\n must_take_artifact_dir_lock: bool,\n must_take_build_dir_lock_exclusively: bool,\n ) -> CargoResult {\n let is_new_layout = ws.gctx().cli_unstable().build_dir_new_layout;\n let mut root = ws.target_dir();\n let mut build_root = ws.build_dir();\n if let Some(target) = target {\n root.push(target.short_name());\n build_root.push(target.short_name());\n }\n let build_dest = build_root.join(dest);\n let dest = root.join(dest);\n // If the root directory doesn't already exist go ahead and create it\n // here. Use this opportunity to exclude it from backups as well if the\n // system supports it since this is a freshly created folder.\n //\n paths::create_dir_all_excluded_from_backups_atomic(root.as_path_unlocked())?;\n if root != build_root {\n paths::create_dir_all_excluded_from_backups_atomic(build_root.as_path_unlocked())?;\n }\n\n // Now that the excluded from backups target root is created we can create the\n // actual destination (sub)subdirectory.\n paths::create_dir_all(dest.as_path_unlocked())?;\n\n let build_dir_lock = if is_on_nfs_mount(build_root.as_path_unlocked()) {\n None\n } else {\n if ws.gctx().cli_unstable().fine_grain_locking && !must_take_build_dir_lock_exclusively\n {\n Some(build_dest.open_ro_shared_create(\n \".cargo-build-lock\",\n ws.gctx(),\n \"build directory\",\n )?)\n } else {\n Some(build_dest.open_rw_exclusive_create(\n \".cargo-build-lock\",\n ws.gctx(),\n \"build directory\",\n )?)\n }\n };\n let build_root = build_root.into_path_unlocked();\n let build_dest = build_dest.as_path_unlocked();\n let deps = build_dest.join(\"deps\");\n let artifact = deps.join(\"artifact\");\n\n let artifact_dir = if must_take_artifact_dir_lock {\n // For now we don't do any more finer-grained locking on the artifact\n // directory, so just lock the entire thing for the duration of this\n // compile.\n let artifact_dir_lock = if is_on_nfs_mount(root.as_path_unlocked()) {\n None\n } else {\n Some(dest.open_rw_exclusive_create(\n \".cargo-lock\",\n ws.gctx(),\n \"artifact directory\",\n )?)\n };\n let root = root.into_path_unlocked();\n let dest = dest.into_path_unlocked();\n Some(ArtifactDirLayout {\n dest: dest.clone(),\n examples: dest.join(\"examples\"),\n doc: root.join(\"doc\"),\n timings: root.join(\"cargo-timings\"),\n _lock: artifact_dir_lock,\n })\n } else {\n None\n };\n Ok(Layout {\n artifact_dir,\n build_dir: BuildDirLayout {\n root: build_root.clone(),\n deps,\n build: build_dest.join(\"build\"),\n artifact,\n incremental: build_dest.join(\"incremental\"),\n fingerprint: build_dest.join(\".fingerprint\"),\n examples: build_dest.join(\"examples\"),\n tmp: build_root.join(\"tmp\"),\n _lock: build_dir_lock,\n is_new_layout,\n },\n })\n }\n\n /// Makes sure all directories stored in the Layout exist on the filesystem.\n pub fn prepare(&mut self) -> CargoResult<()> {\n if let Some(ref mut artifact_dir) = self.artifact_dir {\n artifact_dir.prepare()?;\n }\n self.build_dir.prepare()?;\n\n Ok(())\n }\n\n pub fn artifact_dir(&self) -> Option<&ArtifactDirLayout> {\n self.artifact_dir.as_ref()\n }\n\n pub fn build_dir(&self) -> &BuildDirLayout {\n &self.build_dir\n }\n}\n\npub struct ArtifactDirLayout {\n /// The final artifact destination: `/debug` (or `release`).\n dest: PathBuf,\n /// The directory for examples\n examples: PathBuf,\n /// The directory for rustdoc output\n doc: PathBuf,\n /// The directory for --timings output\n timings: PathBuf,\n /// The lockfile for a build (`.cargo-lock`). Will be unlocked when this\n /// struct is `drop`ped.\n _lock: Option,\n}\n\nimpl ArtifactDirLayout {\n /// Makes sure all directories stored in the Layout exist on the filesystem.\n pub fn prepare(&mut self) -> CargoResult<()> {\n paths::create_dir_all(&self.examples)?;\n\n Ok(())\n }\n /// Fetch the destination path for final artifacts (`/ā€¦/target/debug`).\n pub fn dest(&self) -> &Path {\n &self.dest\n }\n /// Fetch the examples path.\n pub fn examples(&self) -> &Path {\n &self.examples\n }\n /// Fetch the doc path.\n pub fn doc(&self) -> &Path {\n &self.doc\n }\n /// Fetch the cargo-timings path.\n pub fn timings(&self) -> &Path {\n &self.timings\n }\n}\n\npub struct BuildDirLayout {\n /// The root directory: `/path/to/build-dir`.\n /// If cross compiling: `/path/to/build-dir/$TRIPLE`.\n root: PathBuf,\n /// The directory with rustc artifacts\n deps: PathBuf,\n /// The primary directory for build files\n build: PathBuf,\n /// The directory for artifacts, i.e. binaries, cdylibs, staticlibs\n artifact: PathBuf,\n /// The directory for incremental files\n incremental: PathBuf,\n /// The directory for fingerprints\n fingerprint: PathBuf,\n /// The directory for pre-uplifted examples: `build-dir/debug/examples`\n examples: PathBuf,\n /// The directory for temporary data of integration tests and benches\n tmp: PathBuf,\n /// The lockfile for a build (`.cargo-lock`). Will be unlocked when this\n /// struct is `drop`ped.\n ///\n /// Will be `None` when the build-dir and target-dir are the same path as we cannot\n /// lock the same path twice.\n _lock: Option,\n is_new_layout: bool,\n}\n\nimpl BuildDirLayout {\n /// Makes sure all directories stored in the Layout exist on the filesystem.\n pub fn prepare(&mut self) -> CargoResult<()> {\n if !self.is_new_layout {\n paths::create_dir_all(&self.deps)?;\n paths::create_dir_all(&self.fingerprint)?;\n paths::create_dir_all(&self.examples)?;\n }\n paths::create_dir_all(&self.incremental)?;\n paths::create_dir_all(&self.build)?;\n\n Ok(())\n }\n /// Fetch the deps path.\n pub fn deps(&self, pkg_dir: &str) -> PathBuf {\n if self.is_new_layout {\n self.out_force_new_layout(pkg_dir)\n } else {\n self.legacy_deps().to_path_buf()\n }\n }\n /// Fetch the output path for build units. (new layout only)\n ///\n /// New features should consider using this so we can avoid their migrations.\n pub fn out_force_new_layout(&self, pkg_dir: &str) -> PathBuf {\n self.build_unit(pkg_dir).join(\"out\")\n }\n /// Fetch the deps path. (old layout)\n pub fn legacy_deps(&self) -> &Path {\n &self.deps\n }\n pub fn root(&self) -> &Path {\n &self.root\n }\n /// Fetch the build examples path.\n pub fn examples(&self) -> &Path {\n &self.examples\n }\n /// Fetch the incremental path.\n pub fn incremental(&self) -> &Path {\n &self.incremental\n }\n /// Fetch the fingerprint path.\n pub fn fingerprint(&self, pkg_dir: &str) -> PathBuf {\n if self.is_new_layout {\n self.build_unit(pkg_dir).join(\"fingerprint\")\n } else {\n self.legacy_fingerprint().to_path_buf().join(pkg_dir)\n }\n }\n /// Fetch the fingerprint path. (old layout)\n pub fn legacy_fingerprint(&self) -> &Path {\n &self.fingerprint\n }\n /// Fetch the build path.\n pub fn build(&self) -> &Path {\n &self.build\n }\n /// Fetch the build script path.\n pub fn build_script(&self, pkg_dir: &str) -> PathBuf {\n if self.is_new_layout {\n self.deps(pkg_dir)\n } else {\n self.build().join(pkg_dir)\n }\n }\n /// Fetch the build script execution path.\n pub fn build_script_execution(&self, pkg_dir: &str) -> PathBuf {\n if self.is_new_layout {\n self.build_unit(pkg_dir).join(\"run\")\n } else {\n self.build().join(pkg_dir)\n }\n }\n /// Fetch the artifact path.\n pub fn artifact(&self, pkg_dir: &str, kind: &str) -> PathBuf {\n if self.is_new_layout {\n self.build_unit(pkg_dir).join(\"artifact\").join(kind)\n } else {\n self.artifact.join(pkg_dir).join(kind)\n }\n }\n /// Fetch the build unit path\n pub fn build_unit(&self, pkg_dir: &str) -> PathBuf {\n self.build().join(pkg_dir)\n }\n /// Create and return the tmp path.\n pub fn prepare_tmp(&self) -> CargoResult<&Path> {\n paths::create_dir_all(&self.tmp)?;\n Ok(&self.tmp)\n }\n}\n" }, { "path": "src/cargo/core/compiler/links.rs", "content": "use super::unit_graph::UnitGraph;\nuse crate::core::resolver::errors::describe_path;\nuse crate::core::{PackageId, Resolve};\nuse crate::util::errors::CargoResult;\nuse std::collections::{HashMap, HashSet};\n\n/// Validates [`package.links`] field in the manifest file does not conflict\n/// between packages.\n///\n/// NOTE: This is the *old* links validator. Links are usually validated in the\n/// resolver. However, the `links` field was added to the index in early 2018\n/// (see [rust-lang/cargo#4978]). However, `links` has been around since 2014,\n/// so there are still many crates in the index that don't have `links`\n/// properly set in the index (over 600 at the time of this writing in 2019).\n/// This can probably be removed at some point in the future, though it might\n/// be worth considering fixing the index.\n///\n/// [rust-lang/cargo#4978]: https://github.com/rust-lang/cargo/pull/4978\n/// [`package.links`]: https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html#the-links-manifest-key\npub fn validate_links(resolve: &Resolve, unit_graph: &UnitGraph) -> CargoResult<()> {\n let mut validated: HashSet = HashSet::new();\n let mut links: HashMap = HashMap::new();\n let mut units: Vec<_> = unit_graph.keys().collect();\n // Sort primarily to make testing easier.\n units.sort_unstable();\n for unit in units {\n if !validated.insert(unit.pkg.package_id()) {\n continue;\n }\n let Some(lib) = unit.pkg.manifest().links() else {\n continue;\n };\n if let Some(&prev) = links.get(lib) {\n let prev_path = resolve\n .path_to_top(&prev)\n .into_iter()\n .map(|(p, d)| (p, d.and_then(|d| d.iter().next())));\n let pkg = unit.pkg.package_id();\n let path = resolve\n .path_to_top(&pkg)\n .into_iter()\n .map(|(p, d)| (p, d.and_then(|d| d.iter().next())));\n anyhow::bail!(\n \"multiple packages link to native library `{}`, \\\n but a native library can be linked only once\\n\\\n \\n\\\n {}\\nlinks to native library `{}`\\n\\\n \\n\\\n {}\\nalso links to native library `{}`\",\n lib,\n describe_path(prev_path),\n lib,\n describe_path(path),\n lib\n )\n }\n links.insert(lib.to_string(), unit.pkg.package_id());\n }\n Ok(())\n}\n" }, { "path": "src/cargo/core/compiler/locking.rs", "content": "//! This module handles the locking logic during compilation.\n\nuse crate::{\n CargoResult,\n core::compiler::{BuildRunner, Unit},\n util::{FileLock, Filesystem},\n};\nuse anyhow::bail;\nuse std::{\n collections::HashMap,\n fmt::{Display, Formatter},\n path::PathBuf,\n sync::RwLock,\n};\nuse tracing::instrument;\n\n/// A struct to store the lock handles for build units during compilation.\npub struct LockManager {\n locks: RwLock>,\n}\n\nimpl LockManager {\n pub fn new() -> Self {\n Self {\n locks: RwLock::new(HashMap::new()),\n }\n }\n\n /// Takes a shared lock on a given [`Unit`]\n /// This prevents other Cargo instances from compiling (writing) to\n /// this build unit.\n ///\n /// This function returns a [`LockKey`] which can be used to\n /// upgrade/unlock the lock.\n #[instrument(skip_all, fields(key))]\n pub fn lock_shared(\n &self,\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n ) -> CargoResult {\n let key = LockKey::from_unit(build_runner, unit);\n tracing::Span::current().record(\"key\", key.0.to_str());\n\n let mut locks = self.locks.write().unwrap();\n if let Some(lock) = locks.get_mut(&key) {\n lock.file().lock_shared()?;\n } else {\n let fs = Filesystem::new(key.0.clone());\n let lock_msg = format!(\n \"{} ({})\",\n unit.pkg.name(),\n build_runner.files().unit_hash(unit)\n );\n let lock = fs.open_ro_shared_create(&key.0, build_runner.bcx.gctx, &lock_msg)?;\n locks.insert(key.clone(), lock);\n }\n\n Ok(key)\n }\n\n #[instrument(skip(self))]\n pub fn lock(&self, key: &LockKey) -> CargoResult<()> {\n let locks = self.locks.read().unwrap();\n if let Some(lock) = locks.get(&key) {\n lock.file().lock()?;\n } else {\n bail!(\"lock was not found in lock manager: {key}\");\n }\n\n Ok(())\n }\n\n /// Upgrades an existing exclusive lock into a shared lock.\n #[instrument(skip(self))]\n pub fn downgrade_to_shared(&self, key: &LockKey) -> CargoResult<()> {\n let locks = self.locks.read().unwrap();\n let Some(lock) = locks.get(key) else {\n bail!(\"lock was not found in lock manager: {key}\");\n };\n lock.file().lock_shared()?;\n Ok(())\n }\n\n #[instrument(skip(self))]\n pub fn unlock(&self, key: &LockKey) -> CargoResult<()> {\n let locks = self.locks.read().unwrap();\n if let Some(lock) = locks.get(key) {\n lock.file().unlock()?;\n };\n\n Ok(())\n }\n}\n\n#[derive(Debug, Clone, Hash, Eq, PartialEq)]\npub struct LockKey(PathBuf);\n\nimpl LockKey {\n fn from_unit(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> Self {\n Self(build_runner.files().build_unit_lock(unit))\n }\n}\n\nimpl Display for LockKey {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{}\", self.0.display())\n }\n}\n" }, { "path": "src/cargo/core/compiler/lto.rs", "content": "use crate::core::compiler::{BuildContext, CompileMode, CrateType, Unit};\nuse crate::core::profiles;\nuse crate::util::interning::InternedString;\n\nuse crate::util::errors::CargoResult;\nuse std::collections::hash_map::{Entry, HashMap};\n\n/// Possible ways to run rustc and request various parts of [LTO].\n///\n/// Variant | Flag | Object Code | Bitcode\n/// -------------------|------------------------|-------------|--------\n/// `Run` | `-C lto=foo` | n/a | n/a\n/// `Off` | `-C lto=off` | n/a | n/a\n/// `OnlyBitcode` | `-C linker-plugin-lto` | | āœ“\n/// `ObjectAndBitcode` | | āœ“ | āœ“\n/// `OnlyObject` | `-C embed-bitcode=no` | āœ“ |\n///\n/// [LTO]: https://doc.rust-lang.org/nightly/cargo/reference/profiles.html#lto\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\npub enum Lto {\n /// LTO is run for this rustc, and it's `-Clto=foo`. If the given value is\n /// None, that corresponds to `-Clto` with no argument, which means do\n /// \"fat\" LTO.\n Run(Option),\n\n /// LTO has been explicitly listed as \"off\". This means no thin-local-LTO,\n /// no LTO anywhere, I really mean it!\n Off,\n\n /// This rustc invocation only needs to produce bitcode (it is *only* used\n /// for LTO), there's no need to produce object files, so we can pass\n /// `-Clinker-plugin-lto`\n OnlyBitcode,\n\n /// This rustc invocation needs to embed bitcode in object files. This means\n /// that object files may be used for a normal link, and the crate may be\n /// loaded for LTO later, so both are required.\n ObjectAndBitcode,\n\n /// This should not include bitcode. This is primarily to reduce disk\n /// space usage.\n OnlyObject,\n}\n\npub fn generate(bcx: &BuildContext<'_, '_>) -> CargoResult> {\n let mut map = HashMap::new();\n for unit in bcx.roots.iter() {\n let root_lto = match unit.profile.lto {\n // LTO not requested, no need for bitcode.\n profiles::Lto::Bool(false) => Lto::OnlyObject,\n profiles::Lto::Off => Lto::Off,\n _ => {\n let crate_types = unit.target.rustc_crate_types();\n if unit.target.for_host() {\n Lto::OnlyObject\n } else if needs_object(&crate_types) {\n lto_when_needs_object(&crate_types)\n } else {\n // This may or may not participate in LTO, let's start\n // with the minimum requirements. This may be expanded in\n // `calculate` below if necessary.\n Lto::OnlyBitcode\n }\n }\n };\n calculate(bcx, &mut map, unit, root_lto)?;\n }\n Ok(map)\n}\n\n/// Whether or not any of these crate types need object code.\nfn needs_object(crate_types: &[CrateType]) -> bool {\n crate_types.iter().any(|k| k.can_lto() || k.is_dynamic())\n}\n\n/// Lto setting to use when this unit needs object code.\nfn lto_when_needs_object(crate_types: &[CrateType]) -> Lto {\n if crate_types.iter().all(|ct| *ct == CrateType::Dylib) {\n // A dylib whose parent is running LTO. rustc currently\n // doesn't support LTO with dylibs, so bitcode is not\n // needed.\n Lto::OnlyObject\n } else {\n // Mixed rlib with a dylib or cdylib whose parent is running LTO. This\n // needs both: bitcode for the rlib (for LTO) and object code for the\n // dylib.\n Lto::ObjectAndBitcode\n }\n}\n\nfn calculate(\n bcx: &BuildContext<'_, '_>,\n map: &mut HashMap,\n unit: &Unit,\n parent_lto: Lto,\n) -> CargoResult<()> {\n let crate_types = match unit.mode {\n // Note: Doctest ignores LTO, but for now we'll compute it as-if it is\n // a Bin, in case it is ever supported in the future.\n CompileMode::Test | CompileMode::Doctest => vec![CrateType::Bin],\n // Notes on other modes:\n // - Check: Treat as the underlying type, it doesn't really matter.\n // - Doc: LTO is N/A for the Doc unit itself since rustdoc does not\n // support codegen flags. We still compute the dependencies, which\n // are mostly `Check`.\n // - RunCustomBuild is ignored because it is always \"for_host\".\n _ => unit.target.rustc_crate_types(),\n };\n // LTO can only be performed if *all* of the crate types support it.\n // For example, a cdylib/rlib combination won't allow LTO.\n let all_lto_types = crate_types.iter().all(CrateType::can_lto);\n // Compute the LTO based on the profile, and what our parent requires.\n let lto = if unit.target.for_host() {\n // Disable LTO for host builds since we only really want to perform LTO\n // for the final binary, and LTO on plugins/build scripts/proc macros is\n // largely not desired.\n Lto::OnlyObject\n } else if all_lto_types {\n // Note that this ignores the `parent_lto` because this isn't a\n // linkable crate type; this unit is not being embedded in the parent.\n match unit.profile.lto {\n profiles::Lto::Named(s) => Lto::Run(Some(s)),\n profiles::Lto::Off => Lto::Off,\n profiles::Lto::Bool(true) => Lto::Run(None),\n profiles::Lto::Bool(false) => Lto::OnlyObject,\n }\n } else {\n match (parent_lto, needs_object(&crate_types)) {\n // An rlib whose parent is running LTO, we only need bitcode.\n (Lto::Run(_), false) => Lto::OnlyBitcode,\n // LTO when something needs object code.\n (Lto::Run(_), true) | (Lto::OnlyBitcode, true) => lto_when_needs_object(&crate_types),\n // LTO is disabled, continue to disable it.\n (Lto::Off, _) => Lto::Off,\n // If this doesn't have any requirements, or the requirements are\n // already satisfied, then stay with our parent.\n (_, false) | (Lto::OnlyObject, true) | (Lto::ObjectAndBitcode, true) => parent_lto,\n }\n };\n\n // Merge the computed LTO. If this unit appears multiple times in the\n // graph, the merge may expand the requirements.\n let merged_lto = match map.entry(unit.clone()) {\n // If we haven't seen this unit before then insert our value and keep\n // going.\n Entry::Vacant(v) => *v.insert(lto),\n\n Entry::Occupied(mut v) => {\n let result = match (lto, v.get()) {\n // No change in requirements.\n (Lto::OnlyBitcode, Lto::OnlyBitcode) => Lto::OnlyBitcode,\n (Lto::OnlyObject, Lto::OnlyObject) => Lto::OnlyObject,\n\n // Once we're running LTO we keep running LTO. We should always\n // calculate the same thing here each iteration because if we\n // see this twice then it means, for example, two unit tests\n // depend on a binary, which is normal.\n (Lto::Run(s), _) | (_, &Lto::Run(s)) => Lto::Run(s),\n\n // Off means off! This has the same reasoning as `Lto::Run`.\n (Lto::Off, _) | (_, Lto::Off) => Lto::Off,\n\n // Once a target has requested both, that's the maximal amount\n // of work that can be done, so we just keep doing that work.\n (Lto::ObjectAndBitcode, _) | (_, Lto::ObjectAndBitcode) => Lto::ObjectAndBitcode,\n\n // Upgrade so that both requirements can be met.\n //\n // This is where the trickiness happens. This unit needs\n // bitcode and the previously calculated value for this unit\n // says it didn't need bitcode (or vice versa). This means that\n // we're a shared dependency between some targets which require\n // LTO and some which don't. This means that instead of being\n // either only-objects or only-bitcode we have to embed both in\n // rlibs (used for different compilations), so we switch to\n // including both.\n (Lto::OnlyObject, Lto::OnlyBitcode) | (Lto::OnlyBitcode, Lto::OnlyObject) => {\n Lto::ObjectAndBitcode\n }\n };\n // No need to recurse if we calculated the same value as before.\n if result == *v.get() {\n return Ok(());\n }\n v.insert(result);\n result\n }\n };\n\n for dep in &bcx.unit_graph[unit] {\n calculate(bcx, map, &dep.unit, merged_lto)?;\n }\n Ok(())\n}\n" }, { "path": "src/cargo/core/compiler/mod.rs", "content": "//! # Interact with the compiler\n//!\n//! If you consider [`ops::cargo_compile::compile`] as a `rustc` driver but on\n//! Cargo side, this module is kinda the `rustc_interface` for that merits.\n//! It contains all the interaction between Cargo and the rustc compiler,\n//! from preparing the context for the entire build process, to scheduling\n//! and executing each unit of work (e.g. running `rustc`), to managing and\n//! caching the output artifact of a build.\n//!\n//! However, it hasn't yet exposed a clear definition of each phase or session,\n//! like what rustc has done. Also, no one knows if Cargo really needs that.\n//! To be pragmatic, here we list a handful of items you may want to learn:\n//!\n//! * [`BuildContext`] is a static context containing all information you need\n//! before a build gets started.\n//! * [`BuildRunner`] is the center of the world, coordinating a running build and\n//! collecting information from it.\n//! * [`custom_build`] is the home of build script executions and output parsing.\n//! * [`fingerprint`] not only defines but also executes a set of rules to\n//! determine if a re-compile is needed.\n//! * [`job_queue`] is where the parallelism, job scheduling, and communication\n//! machinery happen between Cargo and the compiler.\n//! * [`layout`] defines and manages output artifacts of a build in the filesystem.\n//! * [`unit_dependencies`] is for building a dependency graph for compilation\n//! from a result of dependency resolution.\n//! * [`Unit`] contains sufficient information to build something, usually\n//! turning into a compiler invocation in a later phase.\n//!\n//! [`ops::cargo_compile::compile`]: crate::ops::compile\n\npub mod artifact;\nmod build_config;\npub(crate) mod build_context;\npub(crate) mod build_runner;\nmod compilation;\nmod compile_kind;\nmod crate_type;\nmod custom_build;\npub(crate) mod fingerprint;\npub mod future_incompat;\npub(crate) mod job_queue;\npub(crate) mod layout;\nmod links;\nmod locking;\nmod lto;\nmod output_depinfo;\nmod output_sbom;\npub mod rustdoc;\npub mod standard_lib;\npub mod timings;\nmod unit;\npub mod unit_dependencies;\npub mod unit_graph;\n\nuse std::borrow::Cow;\nuse std::cell::OnceCell;\nuse std::collections::{BTreeMap, HashMap, HashSet};\nuse std::env;\nuse std::ffi::{OsStr, OsString};\nuse std::fmt::Display;\nuse std::fs::{self, File};\nuse std::io::{BufRead, BufWriter, Write};\nuse std::ops::Range;\nuse std::path::{Path, PathBuf};\nuse std::sync::{Arc, LazyLock};\n\nuse annotate_snippets::{AnnotationKind, Group, Level, Renderer, Snippet};\nuse anyhow::{Context as _, Error};\nuse cargo_platform::{Cfg, Platform};\nuse itertools::Itertools;\nuse regex::Regex;\nuse tracing::{debug, instrument, trace};\n\npub use self::build_config::UserIntent;\npub use self::build_config::{BuildConfig, CompileMode, MessageFormat};\npub use self::build_context::BuildContext;\npub use self::build_context::FileFlavor;\npub use self::build_context::FileType;\npub use self::build_context::RustcTargetData;\npub use self::build_context::TargetInfo;\npub use self::build_runner::{BuildRunner, Metadata, UnitHash};\npub use self::compilation::{Compilation, Doctest, UnitOutput};\npub use self::compile_kind::{CompileKind, CompileKindFallback, CompileTarget};\npub use self::crate_type::CrateType;\npub use self::custom_build::LinkArgTarget;\npub use self::custom_build::{BuildOutput, BuildScriptOutputs, BuildScripts, LibraryPath};\npub(crate) use self::fingerprint::DirtyReason;\npub use self::fingerprint::RustdocFingerprint;\npub use self::job_queue::Freshness;\nuse self::job_queue::{Job, JobQueue, JobState, Work};\npub(crate) use self::layout::Layout;\npub use self::lto::Lto;\nuse self::output_depinfo::output_depinfo;\nuse self::output_sbom::build_sbom;\nuse self::unit_graph::UnitDep;\n\nuse crate::core::compiler::future_incompat::FutureIncompatReport;\nuse crate::core::compiler::locking::LockKey;\nuse crate::core::compiler::timings::SectionTiming;\npub use crate::core::compiler::unit::Unit;\npub use crate::core::compiler::unit::UnitIndex;\npub use crate::core::compiler::unit::UnitInterner;\nuse crate::core::manifest::TargetSourcePath;\nuse crate::core::profiles::{PanicStrategy, Profile, StripInner};\nuse crate::core::{Feature, PackageId, Target, Verbosity};\nuse crate::lints::get_key_value;\nuse crate::util::OnceExt;\nuse crate::util::context::WarningHandling;\nuse crate::util::errors::{CargoResult, VerboseError};\nuse crate::util::interning::InternedString;\nuse crate::util::machine_message::{self, Message};\nuse crate::util::{add_path_args, internal, path_args};\n\nuse cargo_util::{ProcessBuilder, ProcessError, paths};\nuse cargo_util_schemas::manifest::TomlDebugInfo;\nuse cargo_util_schemas::manifest::TomlTrimPaths;\nuse cargo_util_schemas::manifest::TomlTrimPathsValue;\nuse rustfix::diagnostics::Applicability;\n\nconst RUSTDOC_CRATE_VERSION_FLAG: &str = \"--crate-version\";\n\n/// A glorified callback for executing calls to rustc. Rather than calling rustc\n/// directly, we'll use an `Executor`, giving clients an opportunity to intercept\n/// the build calls.\npub trait Executor: Send + Sync + 'static {\n /// Called after a rustc process invocation is prepared up-front for a given\n /// unit of work (may still be modified for runtime-known dependencies, when\n /// the work is actually executed).\n fn init(&self, _build_runner: &BuildRunner<'_, '_>, _unit: &Unit) {}\n\n /// In case of an `Err`, Cargo will not continue with the build process for\n /// this package.\n fn exec(\n &self,\n cmd: &ProcessBuilder,\n id: PackageId,\n target: &Target,\n mode: CompileMode,\n on_stdout_line: &mut dyn FnMut(&str) -> CargoResult<()>,\n on_stderr_line: &mut dyn FnMut(&str) -> CargoResult<()>,\n ) -> CargoResult<()>;\n\n /// Queried when queuing each unit of work. If it returns true, then the\n /// unit will always be rebuilt, independent of whether it needs to be.\n fn force_rebuild(&self, _unit: &Unit) -> bool {\n false\n }\n}\n\n/// A `DefaultExecutor` calls rustc without doing anything else. It is Cargo's\n/// default behaviour.\n#[derive(Copy, Clone)]\npub struct DefaultExecutor;\n\nimpl Executor for DefaultExecutor {\n #[instrument(name = \"rustc\", skip_all, fields(package = id.name().as_str(), process = cmd.to_string()))]\n fn exec(\n &self,\n cmd: &ProcessBuilder,\n id: PackageId,\n _target: &Target,\n _mode: CompileMode,\n on_stdout_line: &mut dyn FnMut(&str) -> CargoResult<()>,\n on_stderr_line: &mut dyn FnMut(&str) -> CargoResult<()>,\n ) -> CargoResult<()> {\n cmd.exec_with_streaming(on_stdout_line, on_stderr_line, false)\n .map(drop)\n }\n}\n\n/// Builds up and enqueue a list of pending jobs onto the `job` queue.\n///\n/// Starting from the `unit`, this function recursively calls itself to build\n/// all jobs for dependencies of the `unit`. Each of these jobs represents\n/// compiling a particular package.\n///\n/// Note that **no actual work is executed as part of this**, that's all done\n/// next as part of [`JobQueue::execute`] function which will run everything\n/// in order with proper parallelism.\n#[tracing::instrument(skip(build_runner, jobs, exec))]\nfn compile<'gctx>(\n build_runner: &mut BuildRunner<'_, 'gctx>,\n jobs: &mut JobQueue<'gctx>,\n unit: &Unit,\n exec: &Arc,\n force_rebuild: bool,\n) -> CargoResult<()> {\n let bcx = build_runner.bcx;\n if !build_runner.compiled.insert(unit.clone()) {\n return Ok(());\n }\n\n let lock = if build_runner.bcx.gctx.cli_unstable().fine_grain_locking {\n Some(build_runner.lock_manager.lock_shared(build_runner, unit)?)\n } else {\n None\n };\n\n // If we are in `--compile-time-deps` and the given unit is not a compile time\n // dependency, skip compiling the unit and jumps to dependencies, which still\n // have chances to be compile time dependencies\n if !unit.skip_non_compile_time_dep {\n // Build up the work to be done to compile this unit, enqueuing it once\n // we've got everything constructed.\n fingerprint::prepare_init(build_runner, unit)?;\n\n let job = if unit.mode.is_run_custom_build() {\n custom_build::prepare(build_runner, unit)?\n } else if unit.mode.is_doc_test() {\n // We run these targets later, so this is just a no-op for now.\n Job::new_fresh()\n } else {\n let force = exec.force_rebuild(unit) || force_rebuild;\n let mut job = fingerprint::prepare_target(build_runner, unit, force)?;\n job.before(if job.freshness().is_dirty() {\n let work = if unit.mode.is_doc() || unit.mode.is_doc_scrape() {\n rustdoc(build_runner, unit)?\n } else {\n rustc(build_runner, unit, exec)?\n };\n work.then(link_targets(build_runner, unit, false)?)\n } else {\n // We always replay the output cache,\n // since it might contain future-incompat-report messages\n let show_diagnostics = unit.show_warnings(bcx.gctx)\n && build_runner.bcx.gctx.warning_handling()? != WarningHandling::Allow;\n let manifest = ManifestErrorContext::new(build_runner, unit);\n let work = replay_output_cache(\n unit.pkg.package_id(),\n manifest,\n &unit.target,\n build_runner.files().message_cache_path(unit),\n build_runner.bcx.build_config.message_format,\n show_diagnostics,\n );\n // Need to link targets on both the dirty and fresh.\n work.then(link_targets(build_runner, unit, true)?)\n });\n\n // If -Zfine-grain-locking is enabled, we wrap the job with an upgrade to exclusive\n // lock before starting, then downgrade to a shared lock after the job is finished.\n if build_runner.bcx.gctx.cli_unstable().fine_grain_locking && job.freshness().is_dirty()\n {\n if let Some(lock) = lock {\n // Here we unlock the current shared lock to avoid deadlocking with other cargo\n // processes. Then we configure our compile job to take an exclusive lock\n // before starting. Once we are done compiling (including both rmeta and rlib)\n // we downgrade to a shared lock to allow other cargo's to read the build unit.\n // We will hold this shared lock for the remainder of compilation to prevent\n // other cargo from re-compiling while we are still using the unit.\n build_runner.lock_manager.unlock(&lock)?;\n job.before(prebuild_lock_exclusive(lock.clone()));\n job.after(downgrade_lock_to_shared(lock));\n }\n }\n\n job\n };\n jobs.enqueue(build_runner, unit, job)?;\n }\n\n // Be sure to compile all dependencies of this target as well.\n let deps = Vec::from(build_runner.unit_deps(unit)); // Create vec due to mutable borrow.\n for dep in deps {\n compile(build_runner, jobs, &dep.unit, exec, false)?;\n }\n\n Ok(())\n}\n\n/// Generates the warning message used when fallible doc-scrape units fail,\n/// either for rustdoc or rustc.\nfn make_failed_scrape_diagnostic(\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n top_line: impl Display,\n) -> String {\n let manifest_path = unit.pkg.manifest_path();\n let relative_manifest_path = manifest_path\n .strip_prefix(build_runner.bcx.ws.root())\n .unwrap_or(&manifest_path);\n\n format!(\n \"\\\n{top_line}\n Try running with `--verbose` to see the error message.\n If an example should not be scanned, then consider adding `doc-scrape-examples = false` to its `[[example]]` definition in {}\",\n relative_manifest_path.display()\n )\n}\n\n/// Creates a unit of work invoking `rustc` for building the `unit`.\nfn rustc(\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n exec: &Arc,\n) -> CargoResult {\n let mut rustc = prepare_rustc(build_runner, unit)?;\n\n let name = unit.pkg.name();\n\n let outputs = build_runner.outputs(unit)?;\n let root = build_runner.files().output_dir(unit);\n\n // Prepare the native lib state (extra `-L` and `-l` flags).\n let build_script_outputs = Arc::clone(&build_runner.build_script_outputs);\n let current_id = unit.pkg.package_id();\n let manifest = ManifestErrorContext::new(build_runner, unit);\n let build_scripts = build_runner.build_scripts.get(unit).cloned();\n\n // If we are a binary and the package also contains a library, then we\n // don't pass the `-l` flags.\n let pass_l_flag = unit.target.is_lib() || !unit.pkg.targets().iter().any(|t| t.is_lib());\n\n let dep_info_name =\n if let Some(c_extra_filename) = build_runner.files().metadata(unit).c_extra_filename() {\n format!(\"{}-{}.d\", unit.target.crate_name(), c_extra_filename)\n } else {\n format!(\"{}.d\", unit.target.crate_name())\n };\n let rustc_dep_info_loc = root.join(dep_info_name);\n let dep_info_loc = fingerprint::dep_info_loc(build_runner, unit);\n\n let mut output_options = OutputOptions::new(build_runner, unit);\n let package_id = unit.pkg.package_id();\n let target = Target::clone(&unit.target);\n let mode = unit.mode;\n\n exec.init(build_runner, unit);\n let exec = exec.clone();\n\n let root_output = build_runner.files().host_dest().map(|v| v.to_path_buf());\n let build_dir = build_runner.bcx.ws.build_dir().into_path_unlocked();\n let pkg_root = unit.pkg.root().to_path_buf();\n let cwd = rustc\n .get_cwd()\n .unwrap_or_else(|| build_runner.bcx.gctx.cwd())\n .to_path_buf();\n let fingerprint_dir = build_runner.files().fingerprint_dir(unit);\n let script_metadatas = build_runner.find_build_script_metadatas(unit);\n let is_local = unit.is_local();\n let artifact = unit.artifact;\n let sbom_files = build_runner.sbom_output_files(unit)?;\n let sbom = build_sbom(build_runner, unit)?;\n\n let hide_diagnostics_for_scrape_unit = build_runner.bcx.unit_can_fail_for_docscraping(unit)\n && !matches!(\n build_runner.bcx.gctx.shell().verbosity(),\n Verbosity::Verbose\n );\n let failed_scrape_diagnostic = hide_diagnostics_for_scrape_unit.then(|| {\n // If this unit is needed for doc-scraping, then we generate a diagnostic that\n // describes the set of reverse-dependencies that cause the unit to be needed.\n let target_desc = unit.target.description_named();\n let mut for_scrape_units = build_runner\n .bcx\n .scrape_units_have_dep_on(unit)\n .into_iter()\n .map(|unit| unit.target.description_named())\n .collect::>();\n for_scrape_units.sort();\n let for_scrape_units = for_scrape_units.join(\", \");\n make_failed_scrape_diagnostic(build_runner, unit, format_args!(\"failed to check {target_desc} in package `{name}` as a prerequisite for scraping examples from: {for_scrape_units}\"))\n });\n if hide_diagnostics_for_scrape_unit {\n output_options.show_diagnostics = false;\n }\n let env_config = Arc::clone(build_runner.bcx.gctx.env_config()?);\n return Ok(Work::new(move |state| {\n // Artifacts are in a different location than typical units,\n // hence we must assure the crate- and target-dependent\n // directory is present.\n if artifact.is_true() {\n paths::create_dir_all(&root)?;\n }\n\n // Only at runtime have we discovered what the extra -L and -l\n // arguments are for native libraries, so we process those here. We\n // also need to be sure to add any -L paths for our plugins to the\n // dynamic library load path as a plugin's dynamic library may be\n // located somewhere in there.\n // Finally, if custom environment variables have been produced by\n // previous build scripts, we include them in the rustc invocation.\n if let Some(build_scripts) = build_scripts {\n let script_outputs = build_script_outputs.lock().unwrap();\n add_native_deps(\n &mut rustc,\n &script_outputs,\n &build_scripts,\n pass_l_flag,\n &target,\n current_id,\n mode,\n )?;\n if let Some(ref root_output) = root_output {\n add_plugin_deps(&mut rustc, &script_outputs, &build_scripts, root_output)?;\n }\n add_custom_flags(&mut rustc, &script_outputs, script_metadatas)?;\n }\n\n for output in outputs.iter() {\n // If there is both an rmeta and rlib, rustc will prefer to use the\n // rlib, even if it is older. Therefore, we must delete the rlib to\n // force using the new rmeta.\n if output.path.extension() == Some(OsStr::new(\"rmeta\")) {\n let dst = root.join(&output.path).with_extension(\"rlib\");\n if dst.exists() {\n paths::remove_file(&dst)?;\n }\n }\n\n // Some linkers do not remove the executable, but truncate and modify it.\n // That results in the old hard-link being modified even after renamed.\n // We delete the old artifact here to prevent this behavior from confusing users.\n // See rust-lang/cargo#8348.\n if output.hardlink.is_some() && output.path.exists() {\n _ = paths::remove_file(&output.path).map_err(|e| {\n tracing::debug!(\n \"failed to delete previous output file `{:?}`: {e:?}\",\n output.path\n );\n });\n }\n }\n\n state.running(&rustc);\n let timestamp = paths::set_invocation_time(&fingerprint_dir)?;\n for file in sbom_files {\n tracing::debug!(\"writing sbom to {}\", file.display());\n let outfile = BufWriter::new(paths::create(&file)?);\n serde_json::to_writer(outfile, &sbom)?;\n }\n\n let result = exec\n .exec(\n &rustc,\n package_id,\n &target,\n mode,\n &mut |line| on_stdout_line(state, line, package_id, &target),\n &mut |line| {\n on_stderr_line(\n state,\n line,\n package_id,\n &manifest,\n &target,\n &mut output_options,\n )\n },\n )\n .map_err(|e| {\n if output_options.errors_seen == 0 {\n // If we didn't expect an error, do not require --verbose to fail.\n // This is intended to debug\n // https://github.com/rust-lang/crater/issues/733, where we are seeing\n // Cargo exit unsuccessfully while seeming to not show any errors.\n e\n } else {\n verbose_if_simple_exit_code(e)\n }\n })\n .with_context(|| {\n // adapted from rustc_errors/src/lib.rs\n let warnings = match output_options.warnings_seen {\n 0 => String::new(),\n 1 => \"; 1 warning emitted\".to_string(),\n count => format!(\"; {} warnings emitted\", count),\n };\n let errors = match output_options.errors_seen {\n 0 => String::new(),\n 1 => \" due to 1 previous error\".to_string(),\n count => format!(\" due to {} previous errors\", count),\n };\n let name = descriptive_pkg_name(&name, &target, &mode);\n format!(\"could not compile {name}{errors}{warnings}\")\n });\n\n if let Err(e) = result {\n if let Some(diagnostic) = failed_scrape_diagnostic {\n state.warning(diagnostic);\n }\n\n return Err(e);\n }\n\n // Exec should never return with success *and* generate an error.\n debug_assert_eq!(output_options.errors_seen, 0);\n\n if rustc_dep_info_loc.exists() {\n fingerprint::translate_dep_info(\n &rustc_dep_info_loc,\n &dep_info_loc,\n &cwd,\n &pkg_root,\n &build_dir,\n &rustc,\n // Do not track source files in the fingerprint for registry dependencies.\n is_local,\n &env_config,\n )\n .with_context(|| {\n internal(format!(\n \"could not parse/generate dep info at: {}\",\n rustc_dep_info_loc.display()\n ))\n })?;\n // This mtime shift allows Cargo to detect if a source file was\n // modified in the middle of the build.\n paths::set_file_time_no_err(dep_info_loc, timestamp);\n }\n\n // This mtime shift for .rmeta is a workaround as rustc incremental build\n // since rust-lang/rust#114669 (1.90.0) skips unnecessary rmeta generation.\n //\n // The situation is like this:\n //\n // 1. When build script execution's external dependendies\n // (rerun-if-changed, rerun-if-env-changed) got updated,\n // the execution unit reran and got a newer mtime.\n // 2. rustc type-checked the associated crate, though with incremental\n // compilation, no rmeta regeneration. Its `.rmeta` stays old.\n // 3. Run `cargo check` again. Cargo found build script execution had\n // a new mtime than existing crate rmeta, so re-checking the crate.\n // However the check is a no-op (input has no change), so stuck.\n if mode.is_check() {\n for output in outputs.iter() {\n paths::set_file_time_no_err(&output.path, timestamp);\n }\n }\n\n Ok(())\n }));\n\n // Add all relevant `-L` and `-l` flags from dependencies (now calculated and\n // present in `state`) to the command provided.\n fn add_native_deps(\n rustc: &mut ProcessBuilder,\n build_script_outputs: &BuildScriptOutputs,\n build_scripts: &BuildScripts,\n pass_l_flag: bool,\n target: &Target,\n current_id: PackageId,\n mode: CompileMode,\n ) -> CargoResult<()> {\n let mut library_paths = vec![];\n\n for key in build_scripts.to_link.iter() {\n let output = build_script_outputs.get(key.1).ok_or_else(|| {\n internal(format!(\n \"couldn't find build script output for {}/{}\",\n key.0, key.1\n ))\n })?;\n library_paths.extend(output.library_paths.iter());\n }\n\n // NOTE: This very intentionally does not use the derived ord from LibraryPath because we need to\n // retain relative ordering within the same type (i.e. not lexicographic). The use of a stable sort\n // is also important here because it ensures that paths of the same type retain the same relative\n // ordering (for an unstable sort to work here, the list would need to retain the idx of each element\n // and then sort by that idx when the type is equivalent.\n library_paths.sort_by_key(|p| match p {\n LibraryPath::CargoArtifact(_) => 0,\n LibraryPath::External(_) => 1,\n });\n\n for path in library_paths.iter() {\n rustc.arg(\"-L\").arg(path.as_ref());\n }\n\n for key in build_scripts.to_link.iter() {\n let output = build_script_outputs.get(key.1).ok_or_else(|| {\n internal(format!(\n \"couldn't find build script output for {}/{}\",\n key.0, key.1\n ))\n })?;\n\n if key.0 == current_id {\n if pass_l_flag {\n for name in output.library_links.iter() {\n rustc.arg(\"-l\").arg(name);\n }\n }\n }\n\n for (lt, arg) in &output.linker_args {\n // There was an unintentional change where cdylibs were\n // allowed to be passed via transitive dependencies. This\n // clause should have been kept in the `if` block above. For\n // now, continue allowing it for cdylib only.\n // See https://github.com/rust-lang/cargo/issues/9562\n if lt.applies_to(target, mode)\n && (key.0 == current_id || *lt == LinkArgTarget::Cdylib)\n {\n rustc.arg(\"-C\").arg(format!(\"link-arg={}\", arg));\n }\n }\n }\n Ok(())\n }\n}\n\nfn verbose_if_simple_exit_code(err: Error) -> Error {\n // If a signal on unix (`code == None`) or an abnormal termination\n // on Windows (codes like `0xC0000409`), don't hide the error details.\n match err\n .downcast_ref::()\n .as_ref()\n .and_then(|perr| perr.code)\n {\n Some(n) if cargo_util::is_simple_exit_code(n) => VerboseError::new(err).into(),\n _ => err,\n }\n}\n\nfn prebuild_lock_exclusive(lock: LockKey) -> Work {\n Work::new(move |state| {\n state.lock_exclusive(&lock)?;\n Ok(())\n })\n}\n\nfn downgrade_lock_to_shared(lock: LockKey) -> Work {\n Work::new(move |state| {\n state.downgrade_to_shared(&lock)?;\n Ok(())\n })\n}\n\n/// Link the compiled target (often of form `foo-{metadata_hash}`) to the\n/// final target. This must happen during both \"Fresh\" and \"Compile\".\nfn link_targets(\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n fresh: bool,\n) -> CargoResult {\n let bcx = build_runner.bcx;\n let outputs = build_runner.outputs(unit)?;\n let export_dir = build_runner.files().export_dir();\n let package_id = unit.pkg.package_id();\n let manifest_path = PathBuf::from(unit.pkg.manifest_path());\n let profile = unit.profile.clone();\n let unit_mode = unit.mode;\n let features = unit.features.iter().map(|s| s.to_string()).collect();\n let json_messages = bcx.build_config.emit_json();\n let executable = build_runner.get_executable(unit)?;\n let mut target = Target::clone(&unit.target);\n if let TargetSourcePath::Metabuild = target.src_path() {\n // Give it something to serialize.\n let path = unit\n .pkg\n .manifest()\n .metabuild_path(build_runner.bcx.ws.build_dir());\n target.set_src_path(TargetSourcePath::Path(path));\n }\n\n Ok(Work::new(move |state| {\n // If we're a \"root crate\", e.g., the target of this compilation, then we\n // hard link our outputs out of the `deps` directory into the directory\n // above. This means that `cargo build` will produce binaries in\n // `target/debug` which one probably expects.\n let mut destinations = vec![];\n for output in outputs.iter() {\n let src = &output.path;\n // This may have been a `cargo rustc` command which changes the\n // output, so the source may not actually exist.\n if !src.exists() {\n continue;\n }\n let Some(dst) = output.hardlink.as_ref() else {\n destinations.push(src.clone());\n continue;\n };\n destinations.push(dst.clone());\n paths::link_or_copy(src, dst)?;\n if let Some(ref path) = output.export_path {\n let export_dir = export_dir.as_ref().unwrap();\n paths::create_dir_all(export_dir)?;\n\n paths::link_or_copy(src, path)?;\n }\n }\n\n if json_messages {\n let debuginfo = match profile.debuginfo.into_inner() {\n TomlDebugInfo::None => machine_message::ArtifactDebuginfo::Int(0),\n TomlDebugInfo::Limited => machine_message::ArtifactDebuginfo::Int(1),\n TomlDebugInfo::Full => machine_message::ArtifactDebuginfo::Int(2),\n TomlDebugInfo::LineDirectivesOnly => {\n machine_message::ArtifactDebuginfo::Named(\"line-directives-only\")\n }\n TomlDebugInfo::LineTablesOnly => {\n machine_message::ArtifactDebuginfo::Named(\"line-tables-only\")\n }\n };\n let art_profile = machine_message::ArtifactProfile {\n opt_level: profile.opt_level.as_str(),\n debuginfo: Some(debuginfo),\n debug_assertions: profile.debug_assertions,\n overflow_checks: profile.overflow_checks,\n test: unit_mode.is_any_test(),\n };\n\n let msg = machine_message::Artifact {\n package_id: package_id.to_spec(),\n manifest_path,\n target: &target,\n profile: art_profile,\n features,\n filenames: destinations,\n executable,\n fresh,\n }\n .to_json_string();\n state.stdout(msg)?;\n }\n Ok(())\n }))\n}\n\n// For all plugin dependencies, add their -L paths (now calculated and present\n// in `build_script_outputs`) to the dynamic library load path for the command\n// to execute.\nfn add_plugin_deps(\n rustc: &mut ProcessBuilder,\n build_script_outputs: &BuildScriptOutputs,\n build_scripts: &BuildScripts,\n root_output: &Path,\n) -> CargoResult<()> {\n let var = paths::dylib_path_envvar();\n let search_path = rustc.get_env(var).unwrap_or_default();\n let mut search_path = env::split_paths(&search_path).collect::>();\n for (pkg_id, metadata) in &build_scripts.plugins {\n let output = build_script_outputs\n .get(*metadata)\n .ok_or_else(|| internal(format!(\"couldn't find libs for plugin dep {}\", pkg_id)))?;\n search_path.append(&mut filter_dynamic_search_path(\n output.library_paths.iter().map(AsRef::as_ref),\n root_output,\n ));\n }\n let search_path = paths::join_paths(&search_path, var)?;\n rustc.env(var, &search_path);\n Ok(())\n}\n\nfn get_dynamic_search_path(path: &Path) -> &Path {\n match path.to_str().and_then(|s| s.split_once(\"=\")) {\n Some((\"native\" | \"crate\" | \"dependency\" | \"framework\" | \"all\", path)) => Path::new(path),\n _ => path,\n }\n}\n\n// Determine paths to add to the dynamic search path from -L entries\n//\n// Strip off prefixes like \"native=\" or \"framework=\" and filter out directories\n// **not** inside our output directory since they are likely spurious and can cause\n// clashes with system shared libraries (issue #3366).\nfn filter_dynamic_search_path<'a, I>(paths: I, root_output: &Path) -> Vec\nwhere\n I: Iterator,\n{\n let mut search_path = vec![];\n for dir in paths {\n let dir = get_dynamic_search_path(dir);\n if dir.starts_with(&root_output) {\n search_path.push(dir.to_path_buf());\n } else {\n debug!(\n \"Not including path {} in runtime library search path because it is \\\n outside target root {}\",\n dir.display(),\n root_output.display()\n );\n }\n }\n search_path\n}\n\n/// Prepares flags and environments we can compute for a `rustc` invocation\n/// before the job queue starts compiling any unit.\n///\n/// This builds a static view of the invocation. Flags depending on the\n/// completion of other units will be added later in runtime, such as flags\n/// from build scripts.\nfn prepare_rustc(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> CargoResult {\n let gctx = build_runner.bcx.gctx;\n let is_primary = build_runner.is_primary_package(unit);\n let is_workspace = build_runner.bcx.ws.is_member(&unit.pkg);\n\n let mut base = build_runner\n .compilation\n .rustc_process(unit, is_primary, is_workspace)?;\n build_base_args(build_runner, &mut base, unit)?;\n if unit.pkg.manifest().is_embedded() {\n if !gctx.cli_unstable().script {\n anyhow::bail!(\n \"parsing `{}` requires `-Zscript`\",\n unit.pkg.manifest_path().display()\n );\n }\n base.arg(\"-Z\").arg(\"crate-attr=feature(frontmatter)\");\n base.arg(\"-Z\").arg(\"crate-attr=allow(unused_features)\");\n }\n\n base.inherit_jobserver(&build_runner.jobserver);\n build_deps_args(&mut base, build_runner, unit)?;\n add_cap_lints(build_runner.bcx, unit, &mut base);\n if let Some(args) = build_runner.bcx.extra_args_for(unit) {\n base.args(args);\n }\n base.args(&unit.rustflags);\n if gctx.cli_unstable().binary_dep_depinfo {\n base.arg(\"-Z\").arg(\"binary-dep-depinfo\");\n }\n if build_runner.bcx.gctx.cli_unstable().checksum_freshness {\n base.arg(\"-Z\").arg(\"checksum-hash-algorithm=blake3\");\n }\n\n if is_primary {\n base.env(\"CARGO_PRIMARY_PACKAGE\", \"1\");\n let file_list = build_runner.sbom_output_files(unit)?;\n if !file_list.is_empty() {\n let file_list = std::env::join_paths(file_list)?;\n base.env(\"CARGO_SBOM_PATH\", file_list);\n }\n }\n\n if unit.target.is_test() || unit.target.is_bench() {\n let tmp = build_runner\n .files()\n .layout(unit.kind)\n .build_dir()\n .prepare_tmp()?;\n base.env(\"CARGO_TARGET_TMPDIR\", tmp.display().to_string());\n }\n\n Ok(base)\n}\n\n/// Prepares flags and environments we can compute for a `rustdoc` invocation\n/// before the job queue starts compiling any unit.\n///\n/// This builds a static view of the invocation. Flags depending on the\n/// completion of other units will be added later in runtime, such as flags\n/// from build scripts.\nfn prepare_rustdoc(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> CargoResult {\n let bcx = build_runner.bcx;\n // script_metadata is not needed here, it is only for tests.\n let mut rustdoc = build_runner.compilation.rustdoc_process(unit, None)?;\n if unit.pkg.manifest().is_embedded() {\n if !bcx.gctx.cli_unstable().script {\n anyhow::bail!(\n \"parsing `{}` requires `-Zscript`\",\n unit.pkg.manifest_path().display()\n );\n }\n rustdoc.arg(\"-Z\").arg(\"crate-attr=feature(frontmatter)\");\n rustdoc.arg(\"-Z\").arg(\"crate-attr=allow(unused_features)\");\n }\n rustdoc.inherit_jobserver(&build_runner.jobserver);\n let crate_name = unit.target.crate_name();\n rustdoc.arg(\"--crate-name\").arg(&crate_name);\n add_path_args(bcx.ws, unit, &mut rustdoc);\n add_cap_lints(bcx, unit, &mut rustdoc);\n\n unit.kind.add_target_arg(&mut rustdoc);\n let doc_dir = build_runner.files().output_dir(unit);\n rustdoc.arg(\"-o\").arg(&doc_dir);\n rustdoc.args(&features_args(unit));\n rustdoc.args(&check_cfg_args(unit));\n\n add_error_format_and_color(build_runner, &mut rustdoc);\n add_allow_features(build_runner, &mut rustdoc);\n\n if build_runner.bcx.gctx.cli_unstable().rustdoc_depinfo {\n // html-static-files is required for keeping the shared styling resources\n // html-non-static-files is required for keeping the original rustdoc emission\n let mut arg = if build_runner.bcx.gctx.cli_unstable().rustdoc_mergeable_info {\n // toolchain resources are written at the end, at the same time as merging\n OsString::from(\"--emit=html-non-static-files,dep-info=\")\n } else {\n // if not using mergeable CCI, everything is written every time\n OsString::from(\"--emit=html-static-files,html-non-static-files,dep-info=\")\n };\n arg.push(rustdoc_dep_info_loc(build_runner, unit));\n rustdoc.arg(arg);\n\n if build_runner.bcx.gctx.cli_unstable().checksum_freshness {\n rustdoc.arg(\"-Z\").arg(\"checksum-hash-algorithm=blake3\");\n }\n\n rustdoc.arg(\"-Zunstable-options\");\n } else if build_runner.bcx.gctx.cli_unstable().rustdoc_mergeable_info {\n // toolchain resources are written at the end, at the same time as merging\n rustdoc.arg(\"--emit=html-non-static-files\");\n rustdoc.arg(\"-Zunstable-options\");\n }\n\n if build_runner.bcx.gctx.cli_unstable().rustdoc_mergeable_info {\n // write out mergeable data to be imported\n rustdoc.arg(\"--merge=none\");\n let mut arg = OsString::from(\"--parts-out-dir=\");\n // `-Zrustdoc-mergeable-info` always uses the new layout.\n arg.push(build_runner.files().out_dir_new_layout(unit));\n rustdoc.arg(arg);\n }\n\n if let Some(trim_paths) = unit.profile.trim_paths.as_ref() {\n trim_paths_args_rustdoc(&mut rustdoc, build_runner, unit, trim_paths)?;\n }\n\n rustdoc.args(unit.pkg.manifest().lint_rustflags());\n\n let metadata = build_runner.metadata_for_doc_units[unit];\n rustdoc\n .arg(\"-C\")\n .arg(format!(\"metadata={}\", metadata.c_metadata()));\n\n if unit.mode.is_doc_scrape() {\n debug_assert!(build_runner.bcx.scrape_units.contains(unit));\n\n if unit.target.is_test() {\n rustdoc.arg(\"--scrape-tests\");\n }\n\n rustdoc.arg(\"-Zunstable-options\");\n\n rustdoc\n .arg(\"--scrape-examples-output-path\")\n .arg(scrape_output_path(build_runner, unit)?);\n\n // Only scrape example for items from crates in the workspace, to reduce generated file size\n for pkg in build_runner.bcx.packages.packages() {\n let names = pkg\n .targets()\n .iter()\n .map(|target| target.crate_name())\n .collect::>();\n for name in names {\n rustdoc.arg(\"--scrape-examples-target-crate\").arg(name);\n }\n }\n }\n\n if should_include_scrape_units(build_runner.bcx, unit) {\n rustdoc.arg(\"-Zunstable-options\");\n }\n\n build_deps_args(&mut rustdoc, build_runner, unit)?;\n rustdoc::add_root_urls(build_runner, unit, &mut rustdoc)?;\n\n rustdoc::add_output_format(build_runner, &mut rustdoc)?;\n\n if let Some(args) = build_runner.bcx.extra_args_for(unit) {\n rustdoc.args(args);\n }\n rustdoc.args(&unit.rustdocflags);\n\n if !crate_version_flag_already_present(&rustdoc) {\n append_crate_version_flag(unit, &mut rustdoc);\n }\n\n Ok(rustdoc)\n}\n\n/// Creates a unit of work invoking `rustdoc` for documenting the `unit`.\nfn rustdoc(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResult {\n let mut rustdoc = prepare_rustdoc(build_runner, unit)?;\n\n let crate_name = unit.target.crate_name();\n let doc_dir = build_runner.files().output_dir(unit);\n // Create the documentation directory ahead of time as rustdoc currently has\n // a bug where concurrent invocations will race to create this directory if\n // it doesn't already exist.\n paths::create_dir_all(&doc_dir)?;\n\n let target_desc = unit.target.description_named();\n let name = unit.pkg.name();\n let build_script_outputs = Arc::clone(&build_runner.build_script_outputs);\n let package_id = unit.pkg.package_id();\n let target = Target::clone(&unit.target);\n let manifest = ManifestErrorContext::new(build_runner, unit);\n\n let rustdoc_dep_info_loc = rustdoc_dep_info_loc(build_runner, unit);\n let dep_info_loc = fingerprint::dep_info_loc(build_runner, unit);\n let build_dir = build_runner.bcx.ws.build_dir().into_path_unlocked();\n let pkg_root = unit.pkg.root().to_path_buf();\n let cwd = rustdoc\n .get_cwd()\n .unwrap_or_else(|| build_runner.bcx.gctx.cwd())\n .to_path_buf();\n let fingerprint_dir = build_runner.files().fingerprint_dir(unit);\n let is_local = unit.is_local();\n let env_config = Arc::clone(build_runner.bcx.gctx.env_config()?);\n let rustdoc_depinfo_enabled = build_runner.bcx.gctx.cli_unstable().rustdoc_depinfo;\n\n let mut output_options = OutputOptions::new(build_runner, unit);\n let script_metadatas = build_runner.find_build_script_metadatas(unit);\n let scrape_outputs = if should_include_scrape_units(build_runner.bcx, unit) {\n Some(\n build_runner\n .bcx\n .scrape_units\n .iter()\n .map(|unit| {\n Ok((\n build_runner.files().metadata(unit).unit_id(),\n scrape_output_path(build_runner, unit)?,\n ))\n })\n .collect::>>()?,\n )\n } else {\n None\n };\n\n let failed_scrape_units = Arc::clone(&build_runner.failed_scrape_units);\n let hide_diagnostics_for_scrape_unit = build_runner.bcx.unit_can_fail_for_docscraping(unit)\n && !matches!(\n build_runner.bcx.gctx.shell().verbosity(),\n Verbosity::Verbose\n );\n let failed_scrape_diagnostic = hide_diagnostics_for_scrape_unit.then(|| {\n make_failed_scrape_diagnostic(\n build_runner,\n unit,\n format_args!(\"failed to scan {target_desc} in package `{name}` for example code usage\"),\n )\n });\n if hide_diagnostics_for_scrape_unit {\n output_options.show_diagnostics = false;\n }\n\n Ok(Work::new(move |state| {\n add_custom_flags(\n &mut rustdoc,\n &build_script_outputs.lock().unwrap(),\n script_metadatas,\n )?;\n\n // Add the output of scraped examples to the rustdoc command.\n // This action must happen after the unit's dependencies have finished,\n // because some of those deps may be Docscrape units which have failed.\n // So we dynamically determine which `--with-examples` flags to pass here.\n if let Some(scrape_outputs) = scrape_outputs {\n let failed_scrape_units = failed_scrape_units.lock().unwrap();\n for (metadata, output_path) in &scrape_outputs {\n if !failed_scrape_units.contains(metadata) {\n rustdoc.arg(\"--with-examples\").arg(output_path);\n }\n }\n }\n\n let crate_dir = doc_dir.join(&crate_name);\n if crate_dir.exists() {\n // Remove output from a previous build. This ensures that stale\n // files for removed items are removed.\n debug!(\"removing pre-existing doc directory {:?}\", crate_dir);\n paths::remove_dir_all(crate_dir)?;\n }\n state.running(&rustdoc);\n let timestamp = paths::set_invocation_time(&fingerprint_dir)?;\n\n let result = rustdoc\n .exec_with_streaming(\n &mut |line| on_stdout_line(state, line, package_id, &target),\n &mut |line| {\n on_stderr_line(\n state,\n line,\n package_id,\n &manifest,\n &target,\n &mut output_options,\n )\n },\n false,\n )\n .map_err(verbose_if_simple_exit_code)\n .with_context(|| format!(\"could not document `{}`\", name));\n\n if let Err(e) = result {\n if let Some(diagnostic) = failed_scrape_diagnostic {\n state.warning(diagnostic);\n }\n\n return Err(e);\n }\n\n if rustdoc_depinfo_enabled && rustdoc_dep_info_loc.exists() {\n fingerprint::translate_dep_info(\n &rustdoc_dep_info_loc,\n &dep_info_loc,\n &cwd,\n &pkg_root,\n &build_dir,\n &rustdoc,\n // Should we track source file for doc gen?\n is_local,\n &env_config,\n )\n .with_context(|| {\n internal(format_args!(\n \"could not parse/generate dep info at: {}\",\n rustdoc_dep_info_loc.display()\n ))\n })?;\n // This mtime shift allows Cargo to detect if a source file was\n // modified in the middle of the build.\n paths::set_file_time_no_err(dep_info_loc, timestamp);\n }\n\n Ok(())\n }))\n}\n\n// The --crate-version flag could have already been passed in RUSTDOCFLAGS\n// or as an extra compiler argument for rustdoc\nfn crate_version_flag_already_present(rustdoc: &ProcessBuilder) -> bool {\n rustdoc.get_args().any(|flag| {\n flag.to_str()\n .map_or(false, |flag| flag.starts_with(RUSTDOC_CRATE_VERSION_FLAG))\n })\n}\n\nfn append_crate_version_flag(unit: &Unit, rustdoc: &mut ProcessBuilder) {\n rustdoc\n .arg(RUSTDOC_CRATE_VERSION_FLAG)\n .arg(unit.pkg.version().to_string());\n}\n\n/// Adds [`--cap-lints`] to the command to execute.\n///\n/// [`--cap-lints`]: https://doc.rust-lang.org/nightly/rustc/lints/levels.html#capping-lints\nfn add_cap_lints(bcx: &BuildContext<'_, '_>, unit: &Unit, cmd: &mut ProcessBuilder) {\n // If this is an upstream dep we don't want warnings from, turn off all\n // lints.\n if !unit.show_warnings(bcx.gctx) {\n cmd.arg(\"--cap-lints\").arg(\"allow\");\n\n // If this is an upstream dep but we *do* want warnings, make sure that they\n // don't fail compilation.\n } else if !unit.is_local() {\n cmd.arg(\"--cap-lints\").arg(\"warn\");\n }\n}\n\n/// Forwards [`-Zallow-features`] if it is set for cargo.\n///\n/// [`-Zallow-features`]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#allow-features\nfn add_allow_features(build_runner: &BuildRunner<'_, '_>, cmd: &mut ProcessBuilder) {\n if let Some(allow) = &build_runner.bcx.gctx.cli_unstable().allow_features {\n use std::fmt::Write;\n let mut arg = String::from(\"-Zallow-features=\");\n for f in allow {\n let _ = write!(&mut arg, \"{f},\");\n }\n cmd.arg(arg.trim_end_matches(','));\n }\n}\n\n/// Adds [`--error-format`] to the command to execute.\n///\n/// Cargo always uses JSON output. This has several benefits, such as being\n/// easier to parse, handles changing formats (for replaying cached messages),\n/// ensures atomic output (so messages aren't interleaved), allows for\n/// intercepting messages like rmeta artifacts, etc. rustc includes a\n/// \"rendered\" field in the JSON message with the message properly formatted,\n/// which Cargo will extract and display to the user.\n///\n/// [`--error-format`]: https://doc.rust-lang.org/nightly/rustc/command-line-arguments.html#--error-format-control-how-errors-are-produced\nfn add_error_format_and_color(build_runner: &BuildRunner<'_, '_>, cmd: &mut ProcessBuilder) {\n let enable_timings =\n build_runner.bcx.gctx.cli_unstable().section_timings && build_runner.bcx.logger.is_some();\n if enable_timings {\n cmd.arg(\"-Zunstable-options\");\n }\n\n cmd.arg(\"--error-format=json\");\n let mut json = String::from(\"--json=diagnostic-rendered-ansi,artifacts,future-incompat\");\n\n if let MessageFormat::Short | MessageFormat::Json { short: true, .. } =\n build_runner.bcx.build_config.message_format\n {\n json.push_str(\",diagnostic-short\");\n } else if build_runner.bcx.gctx.shell().err_unicode()\n && build_runner.bcx.gctx.cli_unstable().rustc_unicode\n {\n json.push_str(\",diagnostic-unicode\");\n }\n\n if enable_timings {\n json.push_str(\",timings\");\n }\n\n cmd.arg(json);\n\n let gctx = build_runner.bcx.gctx;\n if let Some(width) = gctx.shell().err_width().diagnostic_terminal_width() {\n cmd.arg(format!(\"--diagnostic-width={width}\"));\n }\n}\n\n/// Adds essential rustc flags and environment variables to the command to execute.\nfn build_base_args(\n build_runner: &BuildRunner<'_, '_>,\n cmd: &mut ProcessBuilder,\n unit: &Unit,\n) -> CargoResult<()> {\n assert!(!unit.mode.is_run_custom_build());\n\n let bcx = build_runner.bcx;\n let Profile {\n ref opt_level,\n codegen_backend,\n codegen_units,\n debuginfo,\n debug_assertions,\n split_debuginfo,\n overflow_checks,\n rpath,\n ref panic,\n incremental,\n strip,\n rustflags: profile_rustflags,\n trim_paths,\n hint_mostly_unused: profile_hint_mostly_unused,\n ..\n } = unit.profile.clone();\n let hints = unit.pkg.hints().cloned().unwrap_or_default();\n let test = unit.mode.is_any_test();\n\n let warn = |msg: &str| {\n bcx.gctx.shell().warn(format!(\n \"{}@{}: {msg}\",\n unit.pkg.package_id().name(),\n unit.pkg.package_id().version()\n ))\n };\n let unit_capped_warn = |msg: &str| {\n if unit.show_warnings(bcx.gctx) {\n warn(msg)\n } else {\n Ok(())\n }\n };\n\n cmd.arg(\"--crate-name\").arg(&unit.target.crate_name());\n\n let edition = unit.target.edition();\n edition.cmd_edition_arg(cmd);\n\n add_path_args(bcx.ws, unit, cmd);\n add_error_format_and_color(build_runner, cmd);\n add_allow_features(build_runner, cmd);\n\n let mut contains_dy_lib = false;\n if !test {\n for crate_type in &unit.target.rustc_crate_types() {\n cmd.arg(\"--crate-type\").arg(crate_type.as_str());\n contains_dy_lib |= crate_type == &CrateType::Dylib;\n }\n }\n\n if unit.mode.is_check() {\n cmd.arg(\"--emit=dep-info,metadata\");\n } else if build_runner.bcx.gctx.cli_unstable().no_embed_metadata {\n // Nightly rustc supports the -Zembed-metadata=no flag, which tells it to avoid including\n // full metadata in rlib/dylib artifacts, to save space on disk. In this case, metadata\n // will only be stored in .rmeta files.\n // When we use this flag, we should also pass --emit=metadata to all artifacts that\n // contain useful metadata (rlib/dylib/proc macros), so that a .rmeta file is actually\n // generated. If we didn't do this, the full metadata would not get written anywhere.\n // However, we do not want to pass --emit=metadata to artifacts that never produce useful\n // metadata, such as binaries, because that would just unnecessarily create empty .rmeta\n // files on disk.\n if unit.benefits_from_no_embed_metadata() {\n cmd.arg(\"--emit=dep-info,metadata,link\");\n cmd.args(&[\"-Z\", \"embed-metadata=no\"]);\n } else {\n cmd.arg(\"--emit=dep-info,link\");\n }\n } else {\n // If we don't use -Zembed-metadata=no, we emit .rmeta files only for rlib outputs.\n // This metadata may be used in this session for a pipelined compilation, or it may\n // be used in a future Cargo session as part of a pipelined compile.\n if !unit.requires_upstream_objects() {\n cmd.arg(\"--emit=dep-info,metadata,link\");\n } else {\n cmd.arg(\"--emit=dep-info,link\");\n }\n }\n\n let prefer_dynamic = (unit.target.for_host() && !unit.target.is_custom_build())\n || (contains_dy_lib && !build_runner.is_primary_package(unit));\n if prefer_dynamic {\n cmd.arg(\"-C\").arg(\"prefer-dynamic\");\n }\n\n if opt_level.as_str() != \"0\" {\n cmd.arg(\"-C\").arg(&format!(\"opt-level={}\", opt_level));\n }\n\n if *panic != PanicStrategy::Unwind {\n cmd.arg(\"-C\").arg(format!(\"panic={}\", panic));\n }\n if *panic == PanicStrategy::ImmediateAbort {\n cmd.arg(\"-Z\").arg(\"unstable-options\");\n }\n\n cmd.args(<o_args(build_runner, unit));\n\n if let Some(backend) = codegen_backend {\n cmd.arg(\"-Z\").arg(&format!(\"codegen-backend={}\", backend));\n }\n\n if let Some(n) = codegen_units {\n cmd.arg(\"-C\").arg(&format!(\"codegen-units={}\", n));\n }\n\n let debuginfo = debuginfo.into_inner();\n // Shorten the number of arguments if possible.\n if debuginfo != TomlDebugInfo::None {\n cmd.arg(\"-C\").arg(format!(\"debuginfo={debuginfo}\"));\n // This is generally just an optimization on build time so if we don't\n // pass it then it's ok. The values for the flag (off, packed, unpacked)\n // may be supported or not depending on the platform, so availability is\n // checked per-value. For example, at the time of writing this code, on\n // Windows the only stable valid value for split-debuginfo is \"packed\",\n // while on Linux \"unpacked\" is also stable.\n if let Some(split) = split_debuginfo {\n if build_runner\n .bcx\n .target_data\n .info(unit.kind)\n .supports_debuginfo_split(split)\n {\n cmd.arg(\"-C\").arg(format!(\"split-debuginfo={split}\"));\n }\n }\n }\n\n if let Some(trim_paths) = trim_paths {\n trim_paths_args(cmd, build_runner, unit, &trim_paths)?;\n }\n\n cmd.args(unit.pkg.manifest().lint_rustflags());\n cmd.args(&profile_rustflags);\n\n // `-C overflow-checks` is implied by the setting of `-C debug-assertions`,\n // so we only need to provide `-C overflow-checks` if it differs from\n // the value of `-C debug-assertions` we would provide.\n if opt_level.as_str() != \"0\" {\n if debug_assertions {\n cmd.args(&[\"-C\", \"debug-assertions=on\"]);\n if !overflow_checks {\n cmd.args(&[\"-C\", \"overflow-checks=off\"]);\n }\n } else if overflow_checks {\n cmd.args(&[\"-C\", \"overflow-checks=on\"]);\n }\n } else if !debug_assertions {\n cmd.args(&[\"-C\", \"debug-assertions=off\"]);\n if overflow_checks {\n cmd.args(&[\"-C\", \"overflow-checks=on\"]);\n }\n } else if !overflow_checks {\n cmd.args(&[\"-C\", \"overflow-checks=off\"]);\n }\n\n if test && unit.target.harness() {\n cmd.arg(\"--test\");\n\n // Cargo has historically never compiled `--test` binaries with\n // `panic=abort` because the `test` crate itself didn't support it.\n // Support is now upstream, however, but requires an unstable flag to be\n // passed when compiling the test. We require, in Cargo, an unstable\n // flag to pass to rustc, so register that here. Eventually this flag\n // will simply not be needed when the behavior is stabilized in the Rust\n // compiler itself.\n if *panic == PanicStrategy::Abort || *panic == PanicStrategy::ImmediateAbort {\n cmd.arg(\"-Z\").arg(\"panic-abort-tests\");\n }\n } else if test {\n cmd.arg(\"--cfg\").arg(\"test\");\n }\n\n cmd.args(&features_args(unit));\n cmd.args(&check_cfg_args(unit));\n\n let meta = build_runner.files().metadata(unit);\n cmd.arg(\"-C\")\n .arg(&format!(\"metadata={}\", meta.c_metadata()));\n if let Some(c_extra_filename) = meta.c_extra_filename() {\n cmd.arg(\"-C\")\n .arg(&format!(\"extra-filename=-{c_extra_filename}\"));\n }\n\n if rpath {\n cmd.arg(\"-C\").arg(\"rpath\");\n }\n\n cmd.arg(\"--out-dir\")\n .arg(&build_runner.files().output_dir(unit));\n\n unit.kind.add_target_arg(cmd);\n\n add_codegen_linker(cmd, build_runner, unit, bcx.gctx.target_applies_to_host()?);\n\n if incremental {\n add_codegen_incremental(cmd, build_runner, unit)\n }\n\n let pkg_hint_mostly_unused = match hints.mostly_unused {\n None => None,\n Some(toml::Value::Boolean(b)) => Some(b),\n Some(v) => {\n unit_capped_warn(&format!(\n \"ignoring unsupported value type ({}) for 'hints.mostly-unused', which expects a boolean\",\n v.type_str()\n ))?;\n None\n }\n };\n if profile_hint_mostly_unused\n .or(pkg_hint_mostly_unused)\n .unwrap_or(false)\n {\n if bcx.gctx.cli_unstable().profile_hint_mostly_unused {\n cmd.arg(\"-Zhint-mostly-unused\");\n } else {\n if profile_hint_mostly_unused.is_some() {\n // Profiles come from the top-level unit, so we don't use `unit_capped_warn` here.\n warn(\n \"ignoring 'hint-mostly-unused' profile option, pass `-Zprofile-hint-mostly-unused` to enable it\",\n )?;\n } else if pkg_hint_mostly_unused.is_some() {\n unit_capped_warn(\n \"ignoring 'hints.mostly-unused', pass `-Zprofile-hint-mostly-unused` to enable it\",\n )?;\n }\n }\n }\n\n let strip = strip.into_inner();\n if strip != StripInner::None {\n cmd.arg(\"-C\").arg(format!(\"strip={}\", strip));\n }\n\n if unit.is_std {\n // -Zforce-unstable-if-unmarked prevents the accidental use of\n // unstable crates within the sysroot (such as \"extern crate libc\" or\n // any non-public crate in the sysroot).\n //\n // RUSTC_BOOTSTRAP allows unstable features on stable.\n cmd.arg(\"-Z\")\n .arg(\"force-unstable-if-unmarked\")\n .env(\"RUSTC_BOOTSTRAP\", \"1\");\n }\n\n Ok(())\n}\n\n/// All active features for the unit passed as `--cfg features=`.\nfn features_args(unit: &Unit) -> Vec {\n let mut args = Vec::with_capacity(unit.features.len() * 2);\n\n for feat in &unit.features {\n args.push(OsString::from(\"--cfg\"));\n args.push(OsString::from(format!(\"feature=\\\"{}\\\"\", feat)));\n }\n\n args\n}\n\n/// Like [`trim_paths_args`] but for rustdoc invocations.\nfn trim_paths_args_rustdoc(\n cmd: &mut ProcessBuilder,\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n trim_paths: &TomlTrimPaths,\n) -> CargoResult<()> {\n match trim_paths {\n // rustdoc supports diagnostics trimming only.\n TomlTrimPaths::Values(values) if !values.contains(&TomlTrimPathsValue::Diagnostics) => {\n return Ok(());\n }\n _ => {}\n }\n\n // feature gate was checked during manifest/config parsing.\n cmd.arg(\"-Zunstable-options\");\n\n // Order of `--remap-path-prefix` flags is important for `-Zbuild-std`.\n // We want to show `/rustc//library/std` instead of `std-0.0.0`.\n cmd.arg(package_remap(build_runner, unit));\n cmd.arg(build_dir_remap(build_runner));\n cmd.arg(sysroot_remap(build_runner, unit));\n\n Ok(())\n}\n\n/// Generates the `--remap-path-scope` and `--remap-path-prefix` for [RFC 3127].\n/// See also unstable feature [`-Ztrim-paths`].\n///\n/// [RFC 3127]: https://rust-lang.github.io/rfcs/3127-trim-paths.html\n/// [`-Ztrim-paths`]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#profile-trim-paths-option\nfn trim_paths_args(\n cmd: &mut ProcessBuilder,\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n trim_paths: &TomlTrimPaths,\n) -> CargoResult<()> {\n if trim_paths.is_none() {\n return Ok(());\n }\n\n // feature gate was checked during manifest/config parsing.\n cmd.arg(format!(\"--remap-path-scope={trim_paths}\"));\n\n // Order of `--remap-path-prefix` flags is important for `-Zbuild-std`.\n // We want to show `/rustc//library/std` instead of `std-0.0.0`.\n cmd.arg(package_remap(build_runner, unit));\n cmd.arg(build_dir_remap(build_runner));\n cmd.arg(sysroot_remap(build_runner, unit));\n\n Ok(())\n}\n\n/// Path prefix remap rules for sysroot.\n///\n/// This remap logic aligns with rustc:\n/// \nfn sysroot_remap(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> OsString {\n let mut remap = OsString::from(\"--remap-path-prefix=\");\n remap.push({\n // See also `detect_sysroot_src_path()`.\n let mut sysroot = build_runner.bcx.target_data.info(unit.kind).sysroot.clone();\n sysroot.push(\"lib\");\n sysroot.push(\"rustlib\");\n sysroot.push(\"src\");\n sysroot.push(\"rust\");\n sysroot\n });\n remap.push(\"=\");\n remap.push(\"/rustc/\");\n if let Some(commit_hash) = build_runner.bcx.rustc().commit_hash.as_ref() {\n remap.push(commit_hash);\n } else {\n remap.push(build_runner.bcx.rustc().version.to_string());\n }\n remap\n}\n\n/// Path prefix remap rules for dependencies.\n///\n/// * Git dependencies: remove `~/.cargo/git/checkouts` prefix.\n/// * Registry dependencies: remove `~/.cargo/registry/src` prefix.\n/// * Others (e.g. path dependencies):\n/// * relative paths to workspace root if inside the workspace directory.\n/// * otherwise remapped to `-`.\nfn package_remap(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> OsString {\n let pkg_root = unit.pkg.root();\n let ws_root = build_runner.bcx.ws.root();\n let mut remap = OsString::from(\"--remap-path-prefix=\");\n let source_id = unit.pkg.package_id().source_id();\n if source_id.is_git() {\n remap.push(\n build_runner\n .bcx\n .gctx\n .git_checkouts_path()\n .as_path_unlocked(),\n );\n remap.push(\"=\");\n } else if source_id.is_registry() {\n remap.push(\n build_runner\n .bcx\n .gctx\n .registry_source_path()\n .as_path_unlocked(),\n );\n remap.push(\"=\");\n } else if pkg_root.strip_prefix(ws_root).is_ok() {\n remap.push(ws_root);\n remap.push(\"=.\"); // remap to relative rustc work dir explicitly\n } else {\n remap.push(pkg_root);\n remap.push(\"=\");\n remap.push(unit.pkg.name());\n remap.push(\"-\");\n remap.push(unit.pkg.version().to_string());\n }\n remap\n}\n\n/// Remap all paths pointing to `build.build-dir`,\n/// i.e., `[BUILD_DIR]/debug/deps/foo-[HASH].dwo` would be remapped to\n/// `/cargo/build-dir/debug/deps/foo-[HASH].dwo`\n/// (note the `/cargo/build-dir` prefix).\n///\n/// This covers scenarios like:\n///\n/// * Build script generated code. For example, a build script may call `file!`\n/// macros, and the associated crate uses [`include!`] to include the expanded\n/// [`file!`] macro in-place via the `OUT_DIR` environment.\n/// * On Linux, `DW_AT_GNU_dwo_name` that contains paths to split debuginfo\n/// files (dwp and dwo).\nfn build_dir_remap(build_runner: &BuildRunner<'_, '_>) -> OsString {\n let build_dir = build_runner.bcx.ws.build_dir();\n let mut remap = OsString::from(\"--remap-path-prefix=\");\n remap.push(build_dir.as_path_unlocked());\n remap.push(\"=/cargo/build-dir\");\n remap\n}\n\n/// Generates the `--check-cfg` arguments for the `unit`.\nfn check_cfg_args(unit: &Unit) -> Vec {\n // The routine below generates the --check-cfg arguments. Our goals here are to\n // enable the checking of conditionals and pass the list of declared features.\n //\n // In the simplified case, it would resemble something like this:\n //\n // --check-cfg=cfg() --check-cfg=cfg(feature, values(...))\n //\n // but having `cfg()` is redundant with the second argument (as well-known names\n // and values are implicitly enabled when one or more `--check-cfg` argument is\n // passed) so we don't emit it and just pass:\n //\n // --check-cfg=cfg(feature, values(...))\n //\n // This way, even if there are no declared features, the config `feature` will\n // still be expected, meaning users would get \"unexpected value\" instead of name.\n // This wasn't always the case, see rust-lang#119930 for some details.\n\n let gross_cap_estimation = unit.pkg.summary().features().len() * 7 + 25;\n let mut arg_feature = OsString::with_capacity(gross_cap_estimation);\n\n arg_feature.push(\"cfg(feature, values(\");\n for (i, feature) in unit.pkg.summary().features().keys().enumerate() {\n if i != 0 {\n arg_feature.push(\", \");\n }\n arg_feature.push(\"\\\"\");\n arg_feature.push(feature);\n arg_feature.push(\"\\\"\");\n }\n arg_feature.push(\"))\");\n\n // In addition to the package features, we also include the `test` cfg (since\n // compiler-team#785, as to be able to someday apply it conditionally), as well\n // the `docsrs` cfg from the docs.rs service.\n //\n // We include `docsrs` here (in Cargo) instead of rustc, since there is a much closer\n // relationship between Cargo and docs.rs than rustc and docs.rs. In particular, all\n // users of docs.rs use Cargo, but not all users of rustc (like Rust-for-Linux) use docs.rs.\n\n vec![\n OsString::from(\"--check-cfg\"),\n OsString::from(\"cfg(docsrs,test)\"),\n OsString::from(\"--check-cfg\"),\n arg_feature,\n ]\n}\n\n/// Adds LTO related codegen flags.\nfn lto_args(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> Vec {\n let mut result = Vec::new();\n let mut push = |arg: &str| {\n result.push(OsString::from(\"-C\"));\n result.push(OsString::from(arg));\n };\n match build_runner.lto[unit] {\n lto::Lto::Run(None) => push(\"lto\"),\n lto::Lto::Run(Some(s)) => push(&format!(\"lto={}\", s)),\n lto::Lto::Off => {\n push(\"lto=off\");\n push(\"embed-bitcode=no\");\n }\n lto::Lto::ObjectAndBitcode => {} // this is rustc's default\n lto::Lto::OnlyBitcode => push(\"linker-plugin-lto\"),\n lto::Lto::OnlyObject => push(\"embed-bitcode=no\"),\n }\n result\n}\n\n/// Adds dependency-relevant rustc flags and environment variables\n/// to the command to execute, such as [`-L`] and [`--extern`].\n///\n/// [`-L`]: https://doc.rust-lang.org/nightly/rustc/command-line-arguments.html#-l-add-a-directory-to-the-library-search-path\n/// [`--extern`]: https://doc.rust-lang.org/nightly/rustc/command-line-arguments.html#--extern-specify-where-an-external-library-is-located\nfn build_deps_args(\n cmd: &mut ProcessBuilder,\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n) -> CargoResult<()> {\n let bcx = build_runner.bcx;\n\n for arg in lib_search_paths(build_runner, unit)? {\n cmd.arg(arg);\n }\n\n let deps = build_runner.unit_deps(unit);\n\n // If there is not one linkable target but should, rustc fails later\n // on if there is an `extern crate` for it. This may turn into a hard\n // error in the future (see PR #4797).\n if !deps\n .iter()\n .any(|dep| !dep.unit.mode.is_doc() && dep.unit.target.is_linkable())\n {\n if let Some(dep) = deps.iter().find(|dep| {\n !dep.unit.mode.is_doc() && dep.unit.target.is_lib() && !dep.unit.artifact.is_true()\n }) {\n let dep_name = dep.unit.target.crate_name();\n let name = unit.target.crate_name();\n bcx.gctx.shell().print_report(&[\n Level::WARNING.secondary_title(format!(\"the package `{dep_name}` provides no linkable target\"))\n .elements([\n Level::NOTE.message(format!(\"this might cause `{name}` to fail compilation\")),\n Level::NOTE.message(\"this warning might turn into a hard error in the future\"),\n Level::HELP.message(format!(\"consider adding 'dylib' or 'rlib' to key 'crate-type' in `{dep_name}`'s Cargo.toml\"))\n ])\n ], false)?;\n }\n }\n\n let mut unstable_opts = false;\n\n // Add `OUT_DIR` environment variables for build scripts\n let first_custom_build_dep = deps.iter().find(|dep| dep.unit.mode.is_run_custom_build());\n if let Some(dep) = first_custom_build_dep {\n let out_dir = if bcx.gctx.cli_unstable().build_dir_new_layout {\n build_runner.files().out_dir_new_layout(&dep.unit)\n } else {\n build_runner.files().build_script_out_dir(&dep.unit)\n };\n cmd.env(\"OUT_DIR\", &out_dir);\n }\n\n // Adding output directory for each build script\n let is_multiple_build_scripts_enabled = unit\n .pkg\n .manifest()\n .unstable_features()\n .require(Feature::multiple_build_scripts())\n .is_ok();\n\n if is_multiple_build_scripts_enabled {\n for dep in deps {\n if dep.unit.mode.is_run_custom_build() {\n let out_dir = if bcx.gctx.cli_unstable().build_dir_new_layout {\n build_runner.files().out_dir_new_layout(&dep.unit)\n } else {\n build_runner.files().build_script_out_dir(&dep.unit)\n };\n let target_name = dep.unit.target.name();\n let out_dir_prefix = target_name\n .strip_prefix(\"build-script-\")\n .unwrap_or(target_name);\n let out_dir_name = format!(\"{out_dir_prefix}_OUT_DIR\");\n cmd.env(&out_dir_name, &out_dir);\n }\n }\n }\n for arg in extern_args(build_runner, unit, &mut unstable_opts)? {\n cmd.arg(arg);\n }\n\n for (var, env) in artifact::get_env(build_runner, unit, deps)? {\n cmd.env(&var, env);\n }\n\n // This will only be set if we're already using a feature\n // requiring nightly rust\n if unstable_opts {\n cmd.arg(\"-Z\").arg(\"unstable-options\");\n }\n\n Ok(())\n}\n\nfn add_dep_arg<'a, 'b: 'a>(\n map: &mut BTreeMap<&'a Unit, PathBuf>,\n build_runner: &'b BuildRunner<'b, '_>,\n unit: &'a Unit,\n) {\n if map.contains_key(&unit) {\n return;\n }\n map.insert(&unit, build_runner.files().deps_dir(&unit));\n\n for dep in build_runner.unit_deps(unit) {\n add_dep_arg(map, build_runner, &dep.unit);\n }\n}\n\n/// Adds extra rustc flags and environment variables collected from the output\n/// of a build-script to the command to execute, include custom environment\n/// variables and `cfg`.\nfn add_custom_flags(\n cmd: &mut ProcessBuilder,\n build_script_outputs: &BuildScriptOutputs,\n metadata_vec: Option>,\n) -> CargoResult<()> {\n if let Some(metadata_vec) = metadata_vec {\n for metadata in metadata_vec {\n if let Some(output) = build_script_outputs.get(metadata) {\n for cfg in output.cfgs.iter() {\n cmd.arg(\"--cfg\").arg(cfg);\n }\n for check_cfg in &output.check_cfgs {\n cmd.arg(\"--check-cfg\").arg(check_cfg);\n }\n for (name, value) in output.env.iter() {\n cmd.env(name, value);\n }\n }\n }\n }\n\n Ok(())\n}\n\n/// Generate a list of `-L` arguments\npub fn lib_search_paths(\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n) -> CargoResult> {\n let mut lib_search_paths = Vec::new();\n if build_runner.bcx.gctx.cli_unstable().build_dir_new_layout {\n let mut map = BTreeMap::new();\n\n // Recursively add all dependency args to rustc process\n add_dep_arg(&mut map, build_runner, unit);\n\n let paths = map.into_iter().map(|(_, path)| path).sorted_unstable();\n\n for path in paths {\n let mut deps = OsString::from(\"dependency=\");\n deps.push(path);\n lib_search_paths.extend([\"-L\".into(), deps]);\n }\n } else {\n let mut deps = OsString::from(\"dependency=\");\n deps.push(build_runner.files().deps_dir(unit));\n lib_search_paths.extend([\"-L\".into(), deps]);\n }\n\n // Be sure that the host path is also listed. This'll ensure that proc macro\n // dependencies are correctly found (for reexported macros).\n if !unit.kind.is_host() {\n let mut deps = OsString::from(\"dependency=\");\n deps.push(build_runner.files().host_deps(unit));\n lib_search_paths.extend([\"-L\".into(), deps]);\n }\n\n Ok(lib_search_paths)\n}\n\n/// Generates a list of `--extern` arguments.\npub fn extern_args(\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n unstable_opts: &mut bool,\n) -> CargoResult> {\n let mut result = Vec::new();\n let deps = build_runner.unit_deps(unit);\n\n let no_embed_metadata = build_runner.bcx.gctx.cli_unstable().no_embed_metadata;\n\n // Closure to add one dependency to `result`.\n let mut link_to = |dep: &UnitDep,\n extern_crate_name: InternedString,\n noprelude: bool,\n nounused: bool|\n -> CargoResult<()> {\n let mut value = OsString::new();\n let mut opts = Vec::new();\n let is_public_dependency_enabled = unit\n .pkg\n .manifest()\n .unstable_features()\n .require(Feature::public_dependency())\n .is_ok()\n || build_runner.bcx.gctx.cli_unstable().public_dependency;\n if !dep.public && unit.target.is_lib() && is_public_dependency_enabled {\n opts.push(\"priv\");\n *unstable_opts = true;\n }\n if noprelude {\n opts.push(\"noprelude\");\n *unstable_opts = true;\n }\n if nounused {\n opts.push(\"nounused\");\n *unstable_opts = true;\n }\n if !opts.is_empty() {\n value.push(opts.join(\",\"));\n value.push(\":\");\n }\n value.push(extern_crate_name.as_str());\n value.push(\"=\");\n\n let mut pass = |file| {\n let mut value = value.clone();\n value.push(file);\n result.push(OsString::from(\"--extern\"));\n result.push(value);\n };\n\n let outputs = build_runner.outputs(&dep.unit)?;\n\n if build_runner.only_requires_rmeta(unit, &dep.unit) || dep.unit.mode.is_check() {\n // Example: rlib dependency for an rlib, rmeta is all that is required.\n let output = outputs\n .iter()\n .find(|output| output.flavor == FileFlavor::Rmeta)\n .expect(\"failed to find rmeta dep for pipelined dep\");\n pass(&output.path);\n } else {\n // Example: a bin needs `rlib` for dependencies, it cannot use rmeta.\n for output in outputs.iter() {\n if output.flavor == FileFlavor::Linkable {\n pass(&output.path);\n }\n // If we use -Zembed-metadata=no, we also need to pass the path to the\n // corresponding .rmeta file to the linkable artifact, because the\n // normal dependency (rlib) doesn't contain the full metadata.\n else if no_embed_metadata && output.flavor == FileFlavor::Rmeta {\n pass(&output.path);\n }\n }\n }\n Ok(())\n };\n\n for dep in deps {\n if dep.unit.target.is_linkable() && !dep.unit.mode.is_doc() {\n link_to(dep, dep.extern_crate_name, dep.noprelude, dep.nounused)?;\n }\n }\n if unit.target.proc_macro() {\n // Automatically import `proc_macro`.\n result.push(OsString::from(\"--extern\"));\n result.push(OsString::from(\"proc_macro\"));\n }\n\n Ok(result)\n}\n\n/// Adds `-C linker=` if specified.\nfn add_codegen_linker(\n cmd: &mut ProcessBuilder,\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n target_applies_to_host: bool,\n) {\n let linker = if unit.target.for_host() && !target_applies_to_host {\n build_runner\n .compilation\n .host_linker()\n .map(|s| s.as_os_str())\n } else {\n build_runner\n .compilation\n .target_linker(unit.kind)\n .map(|s| s.as_os_str())\n };\n\n if let Some(linker) = linker {\n let mut arg = OsString::from(\"linker=\");\n arg.push(linker);\n cmd.arg(\"-C\").arg(arg);\n }\n}\n\n/// Adds `-C incremental=`.\nfn add_codegen_incremental(\n cmd: &mut ProcessBuilder,\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n) {\n let dir = build_runner.files().incremental_dir(&unit);\n let mut arg = OsString::from(\"incremental=\");\n arg.push(dir.as_os_str());\n cmd.arg(\"-C\").arg(arg);\n}\n\nfn envify(s: &str) -> String {\n s.chars()\n .flat_map(|c| c.to_uppercase())\n .map(|c| if c == '-' { '_' } else { c })\n .collect()\n}\n\n/// Configuration of the display of messages emitted by the compiler,\n/// e.g. diagnostics, warnings, errors, and message caching.\nstruct OutputOptions {\n /// What format we're emitting from Cargo itself.\n format: MessageFormat,\n /// Where to write the JSON messages to support playback later if the unit\n /// is fresh. The file is created lazily so that in the normal case, lots\n /// of empty files are not created. If this is None, the output will not\n /// be cached (such as when replaying cached messages).\n cache_cell: Option<(PathBuf, OnceCell)>,\n /// If `true`, display any diagnostics.\n /// Other types of JSON messages are processed regardless\n /// of the value of this flag.\n ///\n /// This is used primarily for cache replay. If you build with `-vv`, the\n /// cache will be filled with diagnostics from dependencies. When the\n /// cache is replayed without `-vv`, we don't want to show them.\n show_diagnostics: bool,\n /// Tracks the number of warnings we've seen so far.\n warnings_seen: usize,\n /// Tracks the number of errors we've seen so far.\n errors_seen: usize,\n}\n\nimpl OutputOptions {\n fn new(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> OutputOptions {\n let path = build_runner.files().message_cache_path(unit);\n // Remove old cache, ignore ENOENT, which is the common case.\n drop(fs::remove_file(&path));\n let cache_cell = Some((path, OnceCell::new()));\n let show_diagnostics =\n build_runner.bcx.gctx.warning_handling().unwrap_or_default() != WarningHandling::Allow;\n OutputOptions {\n format: build_runner.bcx.build_config.message_format,\n cache_cell,\n show_diagnostics,\n warnings_seen: 0,\n errors_seen: 0,\n }\n }\n}\n\n/// Cloned and sendable context about the manifest file.\n///\n/// Sometimes we enrich rustc's errors with some locations in the manifest file; this\n/// contains a `Send`-able copy of the manifest information that we need for the\n/// enriched errors.\nstruct ManifestErrorContext {\n /// The path to the manifest.\n path: PathBuf,\n /// The locations of various spans within the manifest.\n spans: Option>>,\n /// The raw manifest contents.\n contents: Option,\n /// A lookup for all the unambiguous renamings, mapping from the original package\n /// name to the renamed one.\n rename_table: HashMap,\n /// A list of targets we're compiling for, to determine which of the `[target..dependencies]`\n /// tables might be of interest.\n requested_kinds: Vec,\n /// A list of all the collections of cfg values, one collection for each target, to determine\n /// which of the `[target.'cfg(...)'.dependencies]` tables might be of interest.\n cfgs: Vec>,\n host_name: InternedString,\n /// Cargo's working directory (for printing out a more friendly manifest path).\n cwd: PathBuf,\n /// Terminal width for formatting diagnostics.\n term_width: usize,\n}\n\nfn on_stdout_line(\n state: &JobState<'_, '_>,\n line: &str,\n _package_id: PackageId,\n _target: &Target,\n) -> CargoResult<()> {\n state.stdout(line.to_string())?;\n Ok(())\n}\n\nfn on_stderr_line(\n state: &JobState<'_, '_>,\n line: &str,\n package_id: PackageId,\n manifest: &ManifestErrorContext,\n target: &Target,\n options: &mut OutputOptions,\n) -> CargoResult<()> {\n if on_stderr_line_inner(state, line, package_id, manifest, target, options)? {\n // Check if caching is enabled.\n if let Some((path, cell)) = &mut options.cache_cell {\n // Cache the output, which will be replayed later when Fresh.\n let f = cell.try_borrow_mut_with(|| paths::create(path))?;\n debug_assert!(!line.contains('\\n'));\n f.write_all(line.as_bytes())?;\n f.write_all(&[b'\\n'])?;\n }\n }\n Ok(())\n}\n\n/// Returns true if the line should be cached.\nfn on_stderr_line_inner(\n state: &JobState<'_, '_>,\n line: &str,\n package_id: PackageId,\n manifest: &ManifestErrorContext,\n target: &Target,\n options: &mut OutputOptions,\n) -> CargoResult {\n // We primarily want to use this function to process JSON messages from\n // rustc. The compiler should always print one JSON message per line, and\n // otherwise it may have other output intermingled (think RUST_LOG or\n // something like that), so skip over everything that doesn't look like a\n // JSON message.\n if !line.starts_with('{') {\n state.stderr(line.to_string())?;\n return Ok(true);\n }\n\n let mut compiler_message: Box = match serde_json::from_str(line) {\n Ok(msg) => msg,\n\n // If the compiler produced a line that started with `{` but it wasn't\n // valid JSON, maybe it wasn't JSON in the first place! Forward it along\n // to stderr.\n Err(e) => {\n debug!(\"failed to parse json: {:?}\", e);\n state.stderr(line.to_string())?;\n return Ok(true);\n }\n };\n\n let count_diagnostic = |level, options: &mut OutputOptions| {\n if level == \"warning\" {\n options.warnings_seen += 1;\n } else if level == \"error\" {\n options.errors_seen += 1;\n }\n };\n\n if let Ok(report) = serde_json::from_str::(compiler_message.get()) {\n for item in &report.future_incompat_report {\n count_diagnostic(&*item.diagnostic.level, options);\n }\n state.future_incompat_report(report.future_incompat_report);\n return Ok(true);\n }\n\n let res = serde_json::from_str::(compiler_message.get());\n if let Ok(timing_record) = res {\n state.on_section_timing_emitted(timing_record);\n return Ok(false);\n }\n\n // Returns `true` if the diagnostic was modified.\n let add_pub_in_priv_diagnostic = |diag: &mut String| -> bool {\n // We are parsing the compiler diagnostic here, as this information isn't\n // currently exposed elsewhere.\n // At the time of writing this comment, rustc emits two different\n // \"exported_private_dependencies\" errors:\n // - type `FromPriv` from private dependency 'priv_dep' in public interface\n // - struct `FromPriv` from private dependency 'priv_dep' is re-exported\n // This regex matches them both. To see if it needs to be updated, grep the rust\n // source for \"EXPORTED_PRIVATE_DEPENDENCIES\".\n static PRIV_DEP_REGEX: LazyLock =\n LazyLock::new(|| Regex::new(\"from private dependency '([A-Za-z0-9-_]+)'\").unwrap());\n if let Some(crate_name) = PRIV_DEP_REGEX.captures(diag).and_then(|m| m.get(1))\n && let Some(ref contents) = manifest.contents\n && let Some(span) = manifest.find_crate_span(crate_name.as_str())\n {\n let rel_path = pathdiff::diff_paths(&manifest.path, &manifest.cwd)\n .unwrap_or_else(|| manifest.path.clone())\n .display()\n .to_string();\n let report = [Group::with_title(Level::NOTE.secondary_title(format!(\n \"dependency `{}` declared here\",\n crate_name.as_str()\n )))\n .element(\n Snippet::source(contents)\n .path(rel_path)\n .annotation(AnnotationKind::Context.span(span)),\n )];\n\n let rendered = Renderer::styled()\n .term_width(manifest.term_width)\n .render(&report);\n diag.push_str(&rendered);\n diag.push('\\n');\n return true;\n }\n false\n };\n\n // Depending on what we're emitting from Cargo itself, we figure out what to\n // do with this JSON message.\n match options.format {\n // In the \"human\" output formats (human/short) or if diagnostic messages\n // from rustc aren't being included in the output of Cargo's JSON\n // messages then we extract the diagnostic (if present) here and handle\n // it ourselves.\n MessageFormat::Human\n | MessageFormat::Short\n | MessageFormat::Json {\n render_diagnostics: true,\n ..\n } => {\n #[derive(serde::Deserialize)]\n struct CompilerMessage<'a> {\n // `rendered` contains escape sequences, which can't be\n // zero-copy deserialized by serde_json.\n // See https://github.com/serde-rs/json/issues/742\n rendered: String,\n #[serde(borrow)]\n message: Cow<'a, str>,\n #[serde(borrow)]\n level: Cow<'a, str>,\n children: Vec,\n code: Option,\n }\n\n // A partial rustfix::diagnostics::Diagnostic. We deserialize only a\n // subset of the fields because rustc's output can be extremely\n // deeply nested JSON in pathological cases involving macro\n // expansion. Rustfix's Diagnostic struct is recursive containing a\n // field `children: Vec`, and it can cause deserialization to\n // hit serde_json's default recursion limit, or overflow the stack\n // if we turn that off. Cargo only cares about the 1 field listed\n // here.\n #[derive(serde::Deserialize)]\n struct PartialDiagnostic {\n spans: Vec,\n }\n\n // A partial rustfix::diagnostics::DiagnosticSpan.\n #[derive(serde::Deserialize)]\n struct PartialDiagnosticSpan {\n suggestion_applicability: Option,\n }\n\n #[derive(serde::Deserialize)]\n struct DiagnosticCode {\n code: String,\n }\n\n if let Ok(mut msg) = serde_json::from_str::>(compiler_message.get())\n {\n if msg.message.starts_with(\"aborting due to\")\n || msg.message.ends_with(\"warning emitted\")\n || msg.message.ends_with(\"warnings emitted\")\n {\n // Skip this line; we'll print our own summary at the end.\n return Ok(true);\n }\n // state.stderr will add a newline\n if msg.rendered.ends_with('\\n') {\n msg.rendered.pop();\n }\n let mut rendered = msg.rendered;\n if options.show_diagnostics {\n let machine_applicable: bool = msg\n .children\n .iter()\n .map(|child| {\n child\n .spans\n .iter()\n .filter_map(|span| span.suggestion_applicability)\n .any(|app| app == Applicability::MachineApplicable)\n })\n .any(|b| b);\n count_diagnostic(&msg.level, options);\n if msg\n .code\n .as_ref()\n .is_some_and(|c| c.code == \"exported_private_dependencies\")\n && options.format != MessageFormat::Short\n {\n add_pub_in_priv_diagnostic(&mut rendered);\n }\n let lint = msg.code.is_some();\n state.emit_diag(&msg.level, rendered, lint, machine_applicable)?;\n }\n return Ok(true);\n }\n }\n\n MessageFormat::Json { ansi, .. } => {\n #[derive(serde::Deserialize, serde::Serialize)]\n struct CompilerMessage<'a> {\n rendered: String,\n #[serde(flatten, borrow)]\n other: std::collections::BTreeMap, serde_json::Value>,\n code: Option>,\n }\n\n #[derive(serde::Deserialize, serde::Serialize)]\n struct DiagnosticCode<'a> {\n code: String,\n #[serde(flatten, borrow)]\n other: std::collections::BTreeMap, serde_json::Value>,\n }\n\n if let Ok(mut error) =\n serde_json::from_str::>(compiler_message.get())\n {\n let modified_diag = if error\n .code\n .as_ref()\n .is_some_and(|c| c.code == \"exported_private_dependencies\")\n {\n add_pub_in_priv_diagnostic(&mut error.rendered)\n } else {\n false\n };\n\n // Remove color information from the rendered string if color is not\n // enabled. Cargo always asks for ANSI colors from rustc. This allows\n // cached replay to enable/disable colors without re-invoking rustc.\n if !ansi {\n error.rendered = anstream::adapter::strip_str(&error.rendered).to_string();\n }\n if !ansi || modified_diag {\n let new_line = serde_json::to_string(&error)?;\n compiler_message = serde_json::value::RawValue::from_string(new_line)?;\n }\n }\n }\n }\n\n // We always tell rustc to emit messages about artifacts being produced.\n // These messages feed into pipelined compilation, as well as timing\n // information.\n //\n // Look for a matching directive and inform Cargo internally that a\n // metadata file has been produced.\n #[derive(serde::Deserialize)]\n struct ArtifactNotification<'a> {\n #[serde(borrow)]\n artifact: Cow<'a, str>,\n }\n\n if let Ok(artifact) = serde_json::from_str::>(compiler_message.get()) {\n trace!(\"found directive from rustc: `{}`\", artifact.artifact);\n if artifact.artifact.ends_with(\".rmeta\") {\n debug!(\"looks like metadata finished early!\");\n state.rmeta_produced();\n }\n return Ok(false);\n }\n\n // And failing all that above we should have a legitimate JSON diagnostic\n // from the compiler, so wrap it in an external Cargo JSON message\n // indicating which package it came from and then emit it.\n\n if !options.show_diagnostics {\n return Ok(true);\n }\n\n #[derive(serde::Deserialize)]\n struct CompilerMessage<'a> {\n #[serde(borrow)]\n message: Cow<'a, str>,\n #[serde(borrow)]\n level: Cow<'a, str>,\n }\n\n if let Ok(msg) = serde_json::from_str::>(compiler_message.get()) {\n if msg.message.starts_with(\"aborting due to\")\n || msg.message.ends_with(\"warning emitted\")\n || msg.message.ends_with(\"warnings emitted\")\n {\n // Skip this line; we'll print our own summary at the end.\n return Ok(true);\n }\n count_diagnostic(&msg.level, options);\n }\n\n let msg = machine_message::FromCompiler {\n package_id: package_id.to_spec(),\n manifest_path: &manifest.path,\n target,\n message: compiler_message,\n }\n .to_json_string();\n\n // Switch json lines from rustc/rustdoc that appear on stderr to stdout\n // instead. We want the stdout of Cargo to always be machine parseable as\n // stderr has our colorized human-readable messages.\n state.stdout(msg)?;\n Ok(true)\n}\n\nimpl ManifestErrorContext {\n fn new(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> ManifestErrorContext {\n let mut duplicates = HashSet::new();\n let mut rename_table = HashMap::new();\n\n for dep in build_runner.unit_deps(unit) {\n let unrenamed_id = dep.unit.pkg.package_id().name();\n if duplicates.contains(&unrenamed_id) {\n continue;\n }\n match rename_table.entry(unrenamed_id) {\n std::collections::hash_map::Entry::Occupied(occ) => {\n occ.remove_entry();\n duplicates.insert(unrenamed_id);\n }\n std::collections::hash_map::Entry::Vacant(vac) => {\n vac.insert(dep.extern_crate_name);\n }\n }\n }\n\n let bcx = build_runner.bcx;\n ManifestErrorContext {\n path: unit.pkg.manifest_path().to_owned(),\n spans: unit.pkg.manifest().document().cloned(),\n contents: unit.pkg.manifest().contents().map(String::from),\n requested_kinds: bcx.target_data.requested_kinds().to_owned(),\n host_name: bcx.rustc().host,\n rename_table,\n cwd: path_args(build_runner.bcx.ws, unit).1,\n cfgs: bcx\n .target_data\n .requested_kinds()\n .iter()\n .map(|k| bcx.target_data.cfg(*k).to_owned())\n .collect(),\n term_width: bcx\n .gctx\n .shell()\n .err_width()\n .diagnostic_terminal_width()\n .unwrap_or(annotate_snippets::renderer::DEFAULT_TERM_WIDTH),\n }\n }\n\n fn requested_target_names(&self) -> impl Iterator {\n self.requested_kinds.iter().map(|kind| match kind {\n CompileKind::Host => &self.host_name,\n CompileKind::Target(target) => target.short_name(),\n })\n }\n\n /// Find a span for the dependency that specifies this unrenamed crate, if it's unique.\n ///\n /// rustc diagnostics (at least for public-in-private) mention the un-renamed\n /// crate: if you have `foo = { package = \"bar\" }`, the rustc diagnostic will\n /// say \"bar\".\n ///\n /// This function does its best to find a span for \"bar\", but it could fail if\n /// there are multiple candidates:\n ///\n /// ```toml\n /// foo = { package = \"bar\" }\n /// baz = { path = \"../bar\", package = \"bar\" }\n /// ```\n fn find_crate_span(&self, unrenamed: &str) -> Option> {\n let Some(ref spans) = self.spans else {\n return None;\n };\n\n let orig_name = self.rename_table.get(unrenamed)?.as_str();\n\n if let Some((k, v)) = get_key_value(&spans, &[\"dependencies\", orig_name]) {\n // We make some effort to find the unrenamed text: in\n //\n // ```\n // foo = { package = \"bar\" }\n // ```\n //\n // we try to find the \"bar\", but fall back to \"foo\" if we can't (which might\n // happen if the renaming took place in the workspace, for example).\n if let Some(package) = v.get_ref().as_table().and_then(|t| t.get(\"package\")) {\n return Some(package.span());\n } else {\n return Some(k.span());\n }\n }\n\n // The dependency could also be in a target-specific table, like\n // [target.x86_64-unknown-linux-gnu.dependencies] or\n // [target.'cfg(something)'.dependencies]. We filter out target tables\n // that don't match a requested target or a requested cfg.\n if let Some(target) = spans\n .as_ref()\n .get(\"target\")\n .and_then(|t| t.as_ref().as_table())\n {\n for (platform, platform_table) in target.iter() {\n match platform.as_ref().parse::() {\n Ok(Platform::Name(name)) => {\n if !self.requested_target_names().any(|n| n == name) {\n continue;\n }\n }\n Ok(Platform::Cfg(cfg_expr)) => {\n if !self.cfgs.iter().any(|cfgs| cfg_expr.matches(cfgs)) {\n continue;\n }\n }\n Err(_) => continue,\n }\n\n let Some(platform_table) = platform_table.as_ref().as_table() else {\n continue;\n };\n\n if let Some(deps) = platform_table\n .get(\"dependencies\")\n .and_then(|d| d.as_ref().as_table())\n {\n if let Some((k, v)) = deps.get_key_value(orig_name) {\n if let Some(package) = v.get_ref().as_table().and_then(|t| t.get(\"package\"))\n {\n return Some(package.span());\n } else {\n return Some(k.span());\n }\n }\n }\n }\n }\n None\n }\n}\n\n/// Creates a unit of work that replays the cached compiler message.\n///\n/// Usually used when a job is fresh and doesn't need to recompile.\nfn replay_output_cache(\n package_id: PackageId,\n manifest: ManifestErrorContext,\n target: &Target,\n path: PathBuf,\n format: MessageFormat,\n show_diagnostics: bool,\n) -> Work {\n let target = target.clone();\n let mut options = OutputOptions {\n format,\n cache_cell: None,\n show_diagnostics,\n warnings_seen: 0,\n errors_seen: 0,\n };\n Work::new(move |state| {\n if !path.exists() {\n // No cached output, probably didn't emit anything.\n return Ok(());\n }\n // We sometimes have gigabytes of output from the compiler, so avoid\n // loading it all into memory at once, as that can cause OOM where\n // otherwise there would be none.\n let file = paths::open(&path)?;\n let mut reader = std::io::BufReader::new(file);\n let mut line = String::new();\n loop {\n let length = reader.read_line(&mut line)?;\n if length == 0 {\n break;\n }\n let trimmed = line.trim_end_matches(&['\\n', '\\r'][..]);\n on_stderr_line(state, trimmed, package_id, &manifest, &target, &mut options)?;\n line.clear();\n }\n Ok(())\n })\n}\n\n/// Provides a package name with descriptive target information,\n/// e.g., '`foo` (bin \"bar\" test)', '`foo` (lib doctest)'.\nfn descriptive_pkg_name(name: &str, target: &Target, mode: &CompileMode) -> String {\n let desc_name = target.description_named();\n let mode = if mode.is_rustc_test() && !(target.is_test() || target.is_bench()) {\n \" test\"\n } else if mode.is_doc_test() {\n \" doctest\"\n } else if mode.is_doc() {\n \" doc\"\n } else {\n \"\"\n };\n format!(\"`{name}` ({desc_name}{mode})\")\n}\n\n/// Applies environment variables from config `[env]` to [`ProcessBuilder`].\npub(crate) fn apply_env_config(\n gctx: &crate::GlobalContext,\n cmd: &mut ProcessBuilder,\n) -> CargoResult<()> {\n for (key, value) in gctx.env_config()?.iter() {\n // never override a value that has already been set by cargo\n if cmd.get_envs().contains_key(key) {\n continue;\n }\n cmd.env(key, value);\n }\n Ok(())\n}\n\n/// Checks if there are some scrape units waiting to be processed.\nfn should_include_scrape_units(bcx: &BuildContext<'_, '_>, unit: &Unit) -> bool {\n unit.mode.is_doc() && bcx.scrape_units.len() > 0 && bcx.ws.unit_needs_doc_scrape(unit)\n}\n\n/// Gets the file path of function call information output from `rustdoc`.\nfn scrape_output_path(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> CargoResult {\n assert!(unit.mode.is_doc() || unit.mode.is_doc_scrape());\n build_runner\n .outputs(unit)\n .map(|outputs| outputs[0].path.clone())\n}\n\n/// Gets the dep-info file emitted by rustdoc.\nfn rustdoc_dep_info_loc(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> PathBuf {\n let mut loc = build_runner.files().fingerprint_file_path(unit, \"\");\n loc.set_extension(\"d\");\n loc\n}\n" }, { "path": "src/cargo/core/compiler/output_depinfo.rs", "content": "//! dep-info files for external build system integration.\n//! See [`output_depinfo`] for more.\n\nuse cargo_util::paths::normalize_path;\nuse std::collections::{BTreeSet, HashSet};\nuse std::io::{BufWriter, Write};\nuse std::path::{Path, PathBuf};\n\nuse super::{BuildRunner, FileFlavor, Unit, fingerprint};\nuse crate::util::{CargoResult, internal};\nuse cargo_util::paths;\nuse tracing::debug;\n\n/// Basically just normalizes a given path and converts it to a string.\nfn render_filename>(path: P, basedir: Option<&str>) -> CargoResult {\n fn wrap_path(path: &Path) -> CargoResult {\n path.to_str()\n .ok_or_else(|| internal(format!(\"path `{:?}` not utf-8\", path)))\n .map(|f| f.replace(\" \", \"\\\\ \"))\n }\n\n let path = path.as_ref();\n if let Some(basedir) = basedir {\n let norm_path = normalize_path(path);\n let norm_basedir = normalize_path(basedir.as_ref());\n match norm_path.strip_prefix(norm_basedir) {\n Ok(relpath) => wrap_path(relpath),\n _ => wrap_path(path),\n }\n } else {\n wrap_path(path)\n }\n}\n\n/// Collects all dependencies of the `unit` for the output dep info file.\n///\n/// Dependencies will be stored in `deps`, including:\n///\n/// * dependencies from [fingerprint dep-info]\n/// * paths from `rerun-if-changed` build script instruction\n/// * ...and traverse transitive dependencies recursively\n///\n/// [fingerprint dep-info]: super::fingerprint#fingerprint-dep-info-files\nfn add_deps_for_unit(\n deps: &mut BTreeSet,\n build_runner: &mut BuildRunner<'_, '_>,\n unit: &Unit,\n visited: &mut HashSet,\n) -> CargoResult<()> {\n if !visited.insert(unit.clone()) {\n return Ok(());\n }\n\n // units representing the execution of a build script don't actually\n // generate a dep info file, so we just keep on going below\n if !unit.mode.is_run_custom_build() {\n // Add dependencies from rustc dep-info output (stored in fingerprint directory)\n let dep_info_loc = fingerprint::dep_info_loc(build_runner, unit);\n if let Some(paths) = fingerprint::parse_dep_info(\n unit.pkg.root(),\n build_runner.files().host_build_root(),\n &dep_info_loc,\n )? {\n for path in paths.files.into_keys() {\n deps.insert(path);\n }\n } else {\n debug!(\n \"can't find dep_info for {:?} {}\",\n unit.pkg.package_id(),\n unit.target\n );\n return Err(internal(\"dep_info missing\"));\n }\n }\n\n // Add rerun-if-changed dependencies\n if let Some(metadata_vec) = build_runner.find_build_script_metadatas(unit) {\n for metadata in metadata_vec {\n if let Some(output) = build_runner\n .build_script_outputs\n .lock()\n .unwrap()\n .get(metadata)\n {\n for path in &output.rerun_if_changed {\n let package_root = unit.pkg.root();\n\n let path = if path.as_os_str().is_empty() {\n // Joining with an empty path causes Rust to add a trailing path separator.\n // On Windows, this would add an invalid trailing backslash to the .d file.\n package_root.to_path_buf()\n } else {\n // The paths we have saved from the unit are of arbitrary relativeness and\n // may be relative to the crate root of the dependency.\n package_root.join(path)\n };\n\n deps.insert(path);\n }\n }\n }\n }\n\n // Recursively traverse all transitive dependencies\n let unit_deps = Vec::from(build_runner.unit_deps(unit)); // Create vec due to mutable borrow.\n for dep in unit_deps {\n if dep.unit.is_local() {\n add_deps_for_unit(deps, build_runner, &dep.unit, visited)?;\n }\n }\n Ok(())\n}\n\n/// Save a `.d` dep-info file for the given unit. This is the third kind of\n/// dep-info mentioned in [`fingerprint`] module.\n///\n/// Argument `unit` is expected to be the root unit, which will be uplifted.\n///\n/// Cargo emits its own dep-info files in the output directory. This is\n/// only done for every \"uplifted\" artifact. These are intended to be used\n/// with external build systems so that they can detect if Cargo needs to be\n/// re-executed.\n///\n/// It includes all the entries from the `rustc` dep-info file, and extends it\n/// with any `rerun-if-changed` entries from build scripts. It also includes\n/// sources from any path dependencies. Registry dependencies are not included\n/// under the assumption that changes to them can be detected via changes to\n/// `Cargo.lock`.\n///\n/// [`fingerprint`]: super::fingerprint#dep-info-files\npub fn output_depinfo(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResult<()> {\n let bcx = build_runner.bcx;\n let mut deps = BTreeSet::new();\n let mut visited = HashSet::new();\n let success = add_deps_for_unit(&mut deps, build_runner, unit, &mut visited).is_ok();\n let basedir_string;\n let basedir = match bcx.gctx.build_config()?.dep_info_basedir.clone() {\n Some(value) => {\n basedir_string = value\n .resolve_path(bcx.gctx)\n .as_os_str()\n .to_str()\n .ok_or_else(|| anyhow::format_err!(\"build.dep-info-basedir path not utf-8\"))?\n .to_string();\n Some(basedir_string.as_str())\n }\n None => None,\n };\n let deps = deps\n .iter()\n .map(|f| render_filename(f, basedir))\n .collect::>>()?;\n\n for output in build_runner.outputs(unit)?.iter().filter(|o| {\n !matches!(\n o.flavor,\n FileFlavor::DebugInfo | FileFlavor::Auxiliary | FileFlavor::Sbom\n )\n }) {\n if let Some(ref link_dst) = output.hardlink {\n let output_path = link_dst.with_extension(\"d\");\n if success {\n let target_fn = render_filename(link_dst, basedir)?;\n\n // If nothing changed don't recreate the file which could alter\n // its mtime\n if let Ok(previous) = fingerprint::parse_rustc_dep_info(&output_path) {\n if previous\n .files\n .iter()\n .map(|(path, _checksum)| path)\n .eq(deps.iter().map(Path::new))\n {\n continue;\n }\n }\n\n // Otherwise write it all out\n let mut outfile = BufWriter::new(paths::create(output_path)?);\n write!(outfile, \"{}:\", target_fn)?;\n for dep in &deps {\n write!(outfile, \" {}\", dep)?;\n }\n writeln!(outfile)?;\n\n // dep-info generation failed, so delete output file. This will\n // usually cause the build system to always rerun the build\n // rule, which is correct if inefficient.\n } else if output_path.exists() {\n paths::remove_file(output_path)?;\n }\n }\n }\n Ok(())\n}\n" }, { "path": "src/cargo/core/compiler/output_sbom.rs", "content": "//! cargo-sbom precursor files for external tools to create SBOM files from.\n//! See [`build_sbom_graph`] for more.\n\nuse std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};\nuse std::path::PathBuf;\n\nuse cargo_util_schemas::core::PackageIdSpec;\nuse itertools::Itertools;\nuse serde::Serialize;\n\nuse crate::CargoResult;\nuse crate::core::TargetKind;\nuse crate::util::Rustc;\nuse crate::util::interning::InternedString;\n\nuse super::{BuildRunner, CompileMode, Unit};\n\n/// Typed version of a SBOM format version number.\n#[derive(Serialize, Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq)]\npub struct SbomFormatVersion(u32);\n\n#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Serialize)]\n#[serde(rename_all = \"snake_case\")]\nenum SbomDependencyType {\n /// A dependency linked to the artifact produced by this unit.\n Normal,\n /// A dependency needed to run the build for this unit (e.g. a build script or proc-macro).\n /// The dependency is not linked to the artifact produced by this unit.\n Build,\n}\n\n#[derive(Serialize, Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq)]\nstruct SbomIndex(usize);\n\n#[derive(Serialize, Clone, Debug)]\n#[serde(rename_all = \"snake_case\")]\nstruct SbomDependency {\n index: SbomIndex,\n kind: SbomDependencyType,\n}\n\n#[derive(Serialize, Clone, Debug)]\n#[serde(rename_all = \"snake_case\")]\nstruct SbomCrate {\n id: PackageIdSpec,\n features: Vec,\n dependencies: Vec,\n kind: TargetKind,\n}\n\nimpl SbomCrate {\n pub fn new(unit: &Unit) -> Self {\n let package_id = unit.pkg.package_id().to_spec();\n let features = unit.features.iter().map(|f| f.to_string()).collect_vec();\n Self {\n id: package_id,\n features,\n dependencies: Vec::new(),\n kind: unit.target.kind().clone(),\n }\n }\n}\n\n#[derive(Serialize, Clone)]\n#[serde(rename_all = \"snake_case\")]\nstruct SbomRustc {\n version: String,\n wrapper: Option,\n workspace_wrapper: Option,\n commit_hash: Option,\n host: String,\n verbose_version: String,\n}\n\nimpl From<&Rustc> for SbomRustc {\n fn from(rustc: &Rustc) -> Self {\n Self {\n version: rustc.version.to_string(),\n wrapper: rustc.wrapper.clone(),\n workspace_wrapper: rustc.workspace_wrapper.clone(),\n commit_hash: rustc.commit_hash.clone(),\n host: rustc.host.to_string(),\n verbose_version: rustc.verbose_version.clone(),\n }\n }\n}\n\n#[derive(Serialize)]\n#[serde(rename_all = \"snake_case\")]\npub struct Sbom {\n version: SbomFormatVersion,\n root: SbomIndex,\n crates: Vec,\n rustc: SbomRustc,\n target: InternedString,\n}\n\n/// Build an [`Sbom`] for the given [`Unit`].\npub fn build_sbom(build_runner: &BuildRunner<'_, '_>, root: &Unit) -> CargoResult {\n let bcx = build_runner.bcx;\n let rustc: SbomRustc = bcx.rustc().into();\n\n let mut crates = Vec::new();\n let sbom_graph = build_sbom_graph(build_runner, root);\n\n // Build set of indices for each node in the graph for fast lookup.\n let indices: HashMap<&Unit, SbomIndex> = sbom_graph\n .keys()\n .enumerate()\n .map(|(i, dep)| (*dep, SbomIndex(i)))\n .collect();\n\n // Add a item to the crates list for each node in the graph.\n for (unit, edges) in sbom_graph {\n let mut krate = SbomCrate::new(unit);\n for (dep, kind) in edges {\n krate.dependencies.push(SbomDependency {\n index: indices[dep],\n kind: kind,\n });\n }\n crates.push(krate);\n }\n let target = match root.kind {\n super::CompileKind::Host => build_runner.bcx.host_triple(),\n super::CompileKind::Target(target) => target.rustc_target(),\n };\n Ok(Sbom {\n version: SbomFormatVersion(1),\n crates,\n root: indices[root],\n rustc,\n target,\n })\n}\n\n/// List all dependencies, including transitive ones. A dependency can also appear multiple times\n/// if it's using different settings, e.g. profile, features or crate versions.\n///\n/// Returns a graph of dependencies.\nfn build_sbom_graph<'a>(\n build_runner: &'a BuildRunner<'_, '_>,\n root: &'a Unit,\n) -> BTreeMap<&'a Unit, BTreeSet<(&'a Unit, SbomDependencyType)>> {\n tracing::trace!(\"building sbom graph for {}\", root.pkg.package_id());\n\n let mut queue = Vec::new();\n let mut sbom_graph: BTreeMap<&Unit, BTreeSet<(&Unit, SbomDependencyType)>> = BTreeMap::new();\n let mut visited = HashSet::new();\n\n // Search to collect all dependencies of the root unit.\n queue.push((root, root, false));\n while let Some((node, parent, is_build_dep)) = queue.pop() {\n let dependencies = sbom_graph.entry(parent).or_default();\n for dep in build_runner.unit_deps(node) {\n let dep = &dep.unit;\n let (next_parent, next_is_build_dep) = if dep.mode == CompileMode::RunCustomBuild {\n // Nodes in the SBOM graph for building/running build scripts are moved on to their parent as build dependencies.\n (parent, true)\n } else {\n // Proc-macros and build scripts are marked as build dependencies.\n let dep_type = match is_build_dep || dep.target.proc_macro() {\n false => SbomDependencyType::Normal,\n true => SbomDependencyType::Build,\n };\n dependencies.insert((dep, dep_type));\n tracing::trace!(\n \"adding sbom edge {} -> {} ({:?})\",\n parent.pkg.package_id(),\n dep.pkg.package_id(),\n dep_type,\n );\n (dep, false)\n };\n if visited.insert(dep) {\n queue.push((dep, next_parent, next_is_build_dep));\n }\n }\n }\n sbom_graph\n}\n" }, { "path": "src/cargo/core/compiler/rustdoc.rs", "content": "//! Utilities for building with rustdoc.\n\nuse crate::core::compiler::build_runner::BuildRunner;\nuse crate::core::compiler::unit::Unit;\nuse crate::core::compiler::{BuildContext, CompileKind};\nuse crate::sources::CRATES_IO_REGISTRY;\nuse crate::util::errors::{CargoResult, internal};\nuse cargo_util::ProcessBuilder;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::fmt;\nuse std::hash;\nuse url::Url;\n\nconst DOCS_RS_URL: &'static str = \"https://docs.rs/\";\n\n/// Mode used for `std`. This is for unstable feature [`-Zrustdoc-map`][1].\n///\n/// [1]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#rustdoc-map\n#[derive(Debug, Hash)]\npub enum RustdocExternMode {\n /// Use a local `file://` URL.\n Local,\n /// Use a remote URL to (default).\n Remote,\n /// An arbitrary URL.\n Url(String),\n}\n\nimpl From for RustdocExternMode {\n fn from(s: String) -> RustdocExternMode {\n match s.as_ref() {\n \"local\" => RustdocExternMode::Local,\n \"remote\" => RustdocExternMode::Remote,\n _ => RustdocExternMode::Url(s),\n }\n }\n}\n\nimpl fmt::Display for RustdocExternMode {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n RustdocExternMode::Local => \"local\".fmt(f),\n RustdocExternMode::Remote => \"remote\".fmt(f),\n RustdocExternMode::Url(s) => s.fmt(f),\n }\n }\n}\n\nimpl<'de> serde::de::Deserialize<'de> for RustdocExternMode {\n fn deserialize(deserializer: D) -> Result\n where\n D: serde::de::Deserializer<'de>,\n {\n let s = String::deserialize(deserializer)?;\n Ok(s.into())\n }\n}\n\n/// A map of registry names to URLs where documentations are hosted.\n/// This is for unstable feature [`-Zrustdoc-map`][1].\n///\n/// [1]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#rustdoc-map\n#[derive(serde::Deserialize, Debug)]\n#[serde(default)]\npub struct RustdocExternMap {\n #[serde(deserialize_with = \"default_crates_io_to_docs_rs\")]\n /// * Key is the registry name in the configuration `[registries.]`.\n /// * Value is the URL where the documentation is hosted.\n registries: HashMap,\n std: Option,\n}\n\nimpl Default for RustdocExternMap {\n fn default() -> Self {\n Self {\n registries: HashMap::from([(CRATES_IO_REGISTRY.into(), DOCS_RS_URL.into())]),\n std: None,\n }\n }\n}\n\nfn default_crates_io_to_docs_rs<'de, D: serde::Deserializer<'de>>(\n de: D,\n) -> Result, D::Error> {\n use serde::Deserialize;\n let mut registries = HashMap::deserialize(de)?;\n if !registries.contains_key(CRATES_IO_REGISTRY) {\n registries.insert(CRATES_IO_REGISTRY.into(), DOCS_RS_URL.into());\n }\n Ok(registries)\n}\n\nimpl hash::Hash for RustdocExternMap {\n fn hash(&self, into: &mut H) {\n self.std.hash(into);\n for (key, value) in &self.registries {\n key.hash(into);\n value.hash(into);\n }\n }\n}\n\n/// Recursively generate html root url for all units and their children.\n///\n/// This is needed because in case there is a reexport of foreign reexport, you\n/// need to have information about grand-children deps level (deps of your deps).\nfn build_all_urls(\n build_runner: &BuildRunner<'_, '_>,\n rustdoc: &mut ProcessBuilder,\n unit: &Unit,\n name2url: &HashMap<&String, Url>,\n map: &RustdocExternMap,\n unstable_opts: &mut bool,\n seen: &mut HashSet,\n) {\n for dep in build_runner.unit_deps(unit) {\n if !seen.insert(dep.unit.clone()) {\n continue;\n }\n if !dep.unit.target.is_linkable() || dep.unit.mode.is_doc() {\n continue;\n }\n for (registry, location) in &map.registries {\n let sid = dep.unit.pkg.package_id().source_id();\n let matches_registry = || -> bool {\n if !sid.is_registry() {\n return false;\n }\n if sid.is_crates_io() {\n return registry == CRATES_IO_REGISTRY;\n }\n if let Some(index_url) = name2url.get(registry) {\n return index_url == sid.url();\n }\n false\n };\n if matches_registry() {\n let mut url = location.clone();\n if !url.contains(\"{pkg_name}\") && !url.contains(\"{version}\") {\n if !url.ends_with('/') {\n url.push('/');\n }\n url.push_str(\"{pkg_name}/{version}/\");\n }\n let url = url\n .replace(\"{pkg_name}\", &dep.unit.pkg.name())\n .replace(\"{version}\", &dep.unit.pkg.version().to_string());\n rustdoc.arg(\"--extern-html-root-url\");\n rustdoc.arg(format!(\"{}={}\", dep.unit.target.crate_name(), url));\n *unstable_opts = true;\n }\n }\n build_all_urls(\n build_runner,\n rustdoc,\n &dep.unit,\n name2url,\n map,\n unstable_opts,\n seen,\n );\n }\n}\n\n/// Adds unstable flag [`--extern-html-root-url`][1] to the given `rustdoc`\n/// invocation. This is for unstable feature [`-Zrustdoc-map`][2].\n///\n/// [1]: https://doc.rust-lang.org/nightly/rustdoc/unstable-features.html#--extern-html-root-url-control-how-rustdoc-links-to-non-local-crates\n/// [2]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#rustdoc-map\npub fn add_root_urls(\n build_runner: &BuildRunner<'_, '_>,\n unit: &Unit,\n rustdoc: &mut ProcessBuilder,\n) -> CargoResult<()> {\n let gctx = build_runner.bcx.gctx;\n if !gctx.cli_unstable().rustdoc_map {\n tracing::debug!(\"`doc.extern-map` ignored, requires -Zrustdoc-map flag\");\n return Ok(());\n }\n let map = gctx.doc_extern_map()?;\n let mut unstable_opts = false;\n // Collect mapping of registry name -> index url.\n let name2url: HashMap<&String, Url> = map\n .registries\n .keys()\n .filter_map(|name| {\n if let Ok(index_url) = gctx.get_registry_index(name) {\n Some((name, index_url))\n } else {\n tracing::warn!(\n \"`doc.extern-map.{}` specifies a registry that is not defined\",\n name\n );\n None\n }\n })\n .collect();\n build_all_urls(\n build_runner,\n rustdoc,\n unit,\n &name2url,\n map,\n &mut unstable_opts,\n &mut HashSet::new(),\n );\n let std_url = match &map.std {\n None | Some(RustdocExternMode::Remote) => None,\n Some(RustdocExternMode::Local) => {\n let sysroot = &build_runner.bcx.target_data.info(CompileKind::Host).sysroot;\n let html_root = sysroot.join(\"share\").join(\"doc\").join(\"rust\").join(\"html\");\n if html_root.exists() {\n let url = Url::from_file_path(&html_root).map_err(|()| {\n internal(format!(\n \"`{}` failed to convert to URL\",\n html_root.display()\n ))\n })?;\n Some(url.to_string())\n } else {\n tracing::warn!(\n \"`doc.extern-map.std` is \\\"local\\\", but local docs don't appear to exist at {}\",\n html_root.display()\n );\n None\n }\n }\n Some(RustdocExternMode::Url(s)) => Some(s.to_string()),\n };\n if let Some(url) = std_url {\n for name in &[\"std\", \"core\", \"alloc\", \"proc_macro\"] {\n rustdoc.arg(\"--extern-html-root-url\");\n rustdoc.arg(format!(\"{}={}\", name, url));\n unstable_opts = true;\n }\n }\n\n if unstable_opts {\n rustdoc.arg(\"-Zunstable-options\");\n }\n Ok(())\n}\n\n/// Adds unstable flag [`--output-format`][1] to the given `rustdoc`\n/// invocation. This is for unstable feature `-Zunstable-features`.\n///\n/// [1]: https://doc.rust-lang.org/nightly/rustdoc/unstable-features.html?highlight=output-format#-w--output-format-output-format\npub fn add_output_format(\n build_runner: &BuildRunner<'_, '_>,\n rustdoc: &mut ProcessBuilder,\n) -> CargoResult<()> {\n let gctx = build_runner.bcx.gctx;\n if !gctx.cli_unstable().unstable_options {\n tracing::debug!(\"`unstable-options` is ignored, required -Zunstable-options flag\");\n return Ok(());\n }\n\n if build_runner.bcx.build_config.intent.wants_doc_json_output() {\n rustdoc.arg(\"-Zunstable-options\");\n rustdoc.arg(\"--output-format=json\");\n }\n\n Ok(())\n}\n\n/// Indicates whether a target should have examples scraped from it by rustdoc.\n/// Configured within Cargo.toml and only for unstable feature\n/// [`-Zrustdoc-scrape-examples`][1].\n///\n/// [1]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#scrape-examples\n#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Copy)]\npub enum RustdocScrapeExamples {\n Enabled,\n Disabled,\n Unset,\n}\n\nimpl RustdocScrapeExamples {\n pub fn is_enabled(&self) -> bool {\n matches!(self, RustdocScrapeExamples::Enabled)\n }\n\n pub fn is_unset(&self) -> bool {\n matches!(self, RustdocScrapeExamples::Unset)\n }\n}\n\nimpl BuildContext<'_, '_> {\n /// Returns the set of [`Docscrape`] units that have a direct dependency on `unit`.\n ///\n /// [`RunCustomBuild`] units are excluded because we allow failures\n /// from type checks but not build script executions.\n /// A plain old `cargo doc` would just die if a build script execution fails,\n /// there is no reason for `-Zrustdoc-scrape-examples` to keep going.\n ///\n /// [`Docscrape`]: crate::core::compiler::CompileMode::Docscrape\n /// [`RunCustomBuild`]: crate::core::compiler::CompileMode::Docscrape\n pub fn scrape_units_have_dep_on<'a>(&'a self, unit: &'a Unit) -> Vec<&'a Unit> {\n self.scrape_units\n .iter()\n .filter(|scrape_unit| {\n self.unit_graph[scrape_unit]\n .iter()\n .any(|dep| &dep.unit == unit && !dep.unit.mode.is_run_custom_build())\n })\n .collect()\n }\n\n /// Returns true if this unit is needed for doing doc-scraping and is also\n /// allowed to fail without killing the build.\n pub fn unit_can_fail_for_docscraping(&self, unit: &Unit) -> bool {\n // If the unit is not a Docscrape unit, e.g. a Lib target that is\n // checked to scrape an Example target, then we need to get the doc-scrape-examples\n // configuration for the reverse-dependent Example target.\n let for_scrape_units = if unit.mode.is_doc_scrape() {\n vec![unit]\n } else {\n self.scrape_units_have_dep_on(unit)\n };\n\n if for_scrape_units.is_empty() {\n false\n } else {\n // All Docscrape units must have doc-scrape-examples unset. If any are true,\n // then the unit is not allowed to fail.\n for_scrape_units\n .iter()\n .all(|unit| unit.target.doc_scrape_examples().is_unset())\n }\n }\n}\n" }, { "path": "src/cargo/core/compiler/standard_lib.rs", "content": "//! Code for building the standard library.\n\nuse crate::core::compiler::UnitInterner;\nuse crate::core::compiler::unit_dependencies::IsArtifact;\nuse crate::core::compiler::{CompileKind, CompileMode, RustcTargetData, Unit};\nuse crate::core::profiles::{Profiles, UnitFor};\nuse crate::core::resolver::HasDevUnits;\nuse crate::core::resolver::features::{CliFeatures, FeaturesFor, ResolvedFeatures};\nuse crate::core::{PackageId, PackageSet, Resolve, Workspace};\nuse crate::ops::{self, Packages};\nuse crate::util::errors::CargoResult;\n\nuse std::collections::{HashMap, HashSet};\nuse std::path::PathBuf;\n\nuse super::BuildConfig;\n\nfn std_crates<'a>(crates: &'a [String], default: &'static str, units: &[Unit]) -> HashSet<&'a str> {\n let mut crates = HashSet::from_iter(crates.iter().map(|s| s.as_str()));\n // This is a temporary hack until there is a more principled way to\n // declare dependencies in Cargo.toml.\n if crates.is_empty() {\n crates.insert(default);\n }\n if crates.contains(\"std\") {\n crates.insert(\"core\");\n crates.insert(\"alloc\");\n crates.insert(\"proc_macro\");\n crates.insert(\"panic_unwind\");\n crates.insert(\"compiler_builtins\");\n // Only build libtest if it looks like it is needed (libtest depends on libstd)\n // If we know what units we're building, we can filter for libtest depending on the jobs.\n if units\n .iter()\n .any(|unit| unit.mode.is_rustc_test() && unit.target.harness())\n {\n crates.insert(\"test\");\n }\n } else if crates.contains(\"core\") {\n crates.insert(\"compiler_builtins\");\n }\n\n crates\n}\n\n/// Resolve the standard library dependencies.\n///\n/// * `crates` is the arg value from `-Zbuild-std`.\npub fn resolve_std<'gctx>(\n ws: &Workspace<'gctx>,\n target_data: &mut RustcTargetData<'gctx>,\n build_config: &BuildConfig,\n crates: &[String],\n kinds: &[CompileKind],\n) -> CargoResult<(PackageSet<'gctx>, Resolve, ResolvedFeatures)> {\n let src_path = detect_sysroot_src_path(target_data)?;\n let std_ws_manifest_path = src_path.join(\"Cargo.toml\");\n let gctx = ws.gctx();\n // TODO: Consider doing something to enforce --locked? Or to prevent the\n // lock file from being written, such as setting ephemeral.\n let mut std_ws = Workspace::new(&std_ws_manifest_path, gctx)?;\n // Don't require optional dependencies in this workspace, aka std's own\n // `[dev-dependencies]`. No need for us to generate a `Resolve` which has\n // those included because we'll never use them anyway.\n std_ws.set_require_optional_deps(false);\n let specs = {\n // If there is anything looks like needing std, resolve with it.\n // If not, we assume only `core` maye be needed, as `core the most fundamental crate.\n //\n // This may need a UI overhaul if `build-std` wants to fully support multi-targets.\n let maybe_std = kinds\n .iter()\n .any(|kind| target_data.info(*kind).maybe_support_std());\n let mut crates = std_crates(crates, if maybe_std { \"std\" } else { \"core\" }, &[]);\n // `sysroot` is not in the default set because it is optional, but it needs\n // to be part of the resolve in case we do need it or `libtest`.\n crates.insert(\"sysroot\");\n let specs = Packages::Packages(crates.into_iter().map(Into::into).collect());\n specs.to_package_id_specs(&std_ws)?\n };\n let features = match &gctx.cli_unstable().build_std_features {\n Some(list) => list.clone(),\n None => vec![\n \"panic-unwind\".to_string(),\n \"backtrace\".to_string(),\n \"default\".to_string(),\n ],\n };\n let cli_features = CliFeatures::from_command_line(\n &features, /*all_features*/ false, /*uses_default_features*/ false,\n )?;\n let dry_run = false;\n let mut resolve = ops::resolve_ws_with_opts(\n &std_ws,\n target_data,\n &build_config.requested_kinds,\n &cli_features,\n &specs,\n HasDevUnits::No,\n crate::core::resolver::features::ForceAllTargets::No,\n dry_run,\n )?;\n debug_assert_eq!(resolve.specs_and_features.len(), 1);\n Ok((\n resolve.pkg_set,\n resolve.targeted_resolve,\n resolve\n .specs_and_features\n .pop()\n .expect(\"resolve should have a single spec with resolved features\")\n .resolved_features,\n ))\n}\n\n/// Generates a map of root units for the standard library for each kind requested.\n///\n/// * `crates` is the arg value from `-Zbuild-std`.\n/// * `units` is the root units of the build.\npub fn generate_std_roots(\n crates: &[String],\n units: &[Unit],\n std_resolve: &Resolve,\n std_features: &ResolvedFeatures,\n kinds: &[CompileKind],\n package_set: &PackageSet<'_>,\n interner: &UnitInterner,\n profiles: &Profiles,\n target_data: &RustcTargetData<'_>,\n) -> CargoResult>> {\n // Generate a map of Units for each kind requested.\n let mut ret = HashMap::new();\n let (maybe_std, maybe_core): (Vec<&CompileKind>, Vec<_>) = kinds\n .iter()\n .partition(|kind| target_data.info(**kind).maybe_support_std());\n for (default_crate, kinds) in [(\"core\", maybe_core), (\"std\", maybe_std)] {\n if kinds.is_empty() {\n continue;\n }\n generate_roots(\n &mut ret,\n default_crate,\n crates,\n units,\n std_resolve,\n std_features,\n &kinds,\n package_set,\n interner,\n profiles,\n target_data,\n )?;\n }\n\n Ok(ret)\n}\n\nfn generate_roots(\n ret: &mut HashMap>,\n default: &'static str,\n crates: &[String],\n units: &[Unit],\n std_resolve: &Resolve,\n std_features: &ResolvedFeatures,\n kinds: &[&CompileKind],\n package_set: &PackageSet<'_>,\n interner: &UnitInterner,\n profiles: &Profiles,\n target_data: &RustcTargetData<'_>,\n) -> CargoResult<()> {\n let std_ids = std_crates(crates, default, units)\n .iter()\n .map(|crate_name| std_resolve.query(crate_name))\n .collect::>>()?;\n let std_pkgs = package_set.get_many(std_ids)?;\n\n for pkg in std_pkgs {\n let lib = pkg\n .targets()\n .iter()\n .find(|t| t.is_lib())\n .expect(\"std has a lib\");\n // I don't think we need to bother with Check here, the difference\n // in time is minimal, and the difference in caching is\n // significant.\n let mode = CompileMode::Build;\n let features = std_features.activated_features(pkg.package_id(), FeaturesFor::NormalOrDev);\n for kind in kinds {\n let kind = **kind;\n let list = ret.entry(kind).or_insert_with(Vec::new);\n let unit_for = UnitFor::new_normal(kind);\n let profile = profiles.get_profile(\n pkg.package_id(),\n /*is_member*/ false,\n /*is_local*/ false,\n unit_for,\n kind,\n );\n list.push(interner.intern(\n pkg,\n lib,\n profile,\n kind,\n mode,\n features.clone(),\n target_data.info(kind).rustflags.clone(),\n target_data.info(kind).rustdocflags.clone(),\n target_data.target_config(kind).links_overrides.clone(),\n /*is_std*/ true,\n /*dep_hash*/ 0,\n IsArtifact::No,\n None,\n false,\n ));\n }\n }\n Ok(())\n}\n\nfn detect_sysroot_src_path(target_data: &RustcTargetData<'_>) -> CargoResult {\n if let Some(s) = target_data.gctx.get_env_os(\"__CARGO_TESTS_ONLY_SRC_ROOT\") {\n return Ok(s.into());\n }\n\n // NOTE: This is temporary until we figure out how to acquire the source.\n let src_path = target_data\n .info(CompileKind::Host)\n .sysroot\n .join(\"lib\")\n .join(\"rustlib\")\n .join(\"src\")\n .join(\"rust\")\n .join(\"library\");\n let lock = src_path.join(\"Cargo.lock\");\n if !lock.exists() {\n let msg = format!(\n \"{:?} does not exist, unable to build with the standard \\\n library, try:\\n rustup component add rust-src\",\n lock\n );\n match target_data.gctx.get_env(\"RUSTUP_TOOLCHAIN\") {\n Ok(rustup_toolchain) => {\n anyhow::bail!(\"{} --toolchain {}\", msg, rustup_toolchain);\n }\n Err(_) => {\n anyhow::bail!(msg);\n }\n }\n }\n Ok(src_path)\n}\n" }, { "path": "src/cargo/core/compiler/timings/mod.rs", "content": "//! Timing tracking.\n//!\n//! This module implements some simple tracking information for timing of how\n//! long it takes for different units to compile.\n\npub mod report;\n\nuse super::CompileMode;\nuse super::Unit;\nuse super::UnitIndex;\nuse crate::core::compiler::BuildContext;\nuse crate::core::compiler::BuildRunner;\nuse crate::core::compiler::job_queue::JobId;\nuse crate::ops::cargo_report::timings::prepare_context;\nuse crate::util::cpu::State;\nuse crate::util::log_message::LogMessage;\nuse crate::util::style;\nuse crate::util::{CargoResult, GlobalContext};\n\nuse cargo_util::paths;\nuse std::collections::HashMap;\nuse std::io::BufWriter;\nuse std::time::{Duration, Instant};\n\n/// Tracking information for the entire build.\n///\n/// Methods on this structure are generally called from the main thread of a\n/// running [`JobQueue`] instance (`DrainState` in specific) when the queue\n/// receives messages from spawned off threads.\n///\n/// [`JobQueue`]: super::JobQueue\npub struct Timings<'gctx> {\n gctx: &'gctx GlobalContext,\n /// Whether or not timings should be captured.\n enabled: bool,\n /// When Cargo started.\n start: Instant,\n /// A summary of the root units.\n ///\n /// A map from unit to index.\n unit_to_index: HashMap,\n /// Units that are in the process of being built.\n /// When they finished, they are moved to `unit_times`.\n active: HashMap,\n /// Last recorded state of the system's CPUs and when it happened\n last_cpu_state: Option,\n last_cpu_recording: Instant,\n /// Recorded CPU states, stored as tuples. First element is when the\n /// recording was taken and second element is percentage usage of the\n /// system.\n cpu_usage: Vec<(f64, f64)>,\n}\n\n/// Section of compilation (e.g. frontend, backend, linking).\n#[derive(Copy, Clone, serde::Serialize)]\npub struct CompilationSection {\n /// Start of the section, as an offset in seconds from `UnitTime::start`.\n pub start: f64,\n /// End of the section, as an offset in seconds from `UnitTime::start`.\n pub end: Option,\n}\n\n/// Data for a single compilation unit, prepared for serialization to JSON.\n///\n/// This is used by the HTML report's JavaScript to render the pipeline graph.\n#[derive(serde::Serialize)]\npub struct UnitData {\n pub i: UnitIndex,\n pub name: String,\n pub version: String,\n pub mode: String,\n pub target: String,\n pub features: Vec,\n pub start: f64,\n pub duration: f64,\n pub unblocked_units: Vec,\n pub unblocked_rmeta_units: Vec,\n pub sections: Option>,\n}\n\nimpl<'gctx> Timings<'gctx> {\n pub fn new(bcx: &BuildContext<'_, 'gctx>) -> Timings<'gctx> {\n let start = bcx.gctx.creation_time();\n let enabled = bcx.logger.is_some();\n\n if !enabled {\n return Timings {\n gctx: bcx.gctx,\n enabled,\n start,\n unit_to_index: HashMap::new(),\n active: HashMap::new(),\n last_cpu_state: None,\n last_cpu_recording: Instant::now(),\n cpu_usage: Vec::new(),\n };\n }\n\n let last_cpu_state = match State::current() {\n Ok(state) => Some(state),\n Err(e) => {\n tracing::info!(\"failed to get CPU state, CPU tracking disabled: {:?}\", e);\n None\n }\n };\n\n Timings {\n gctx: bcx.gctx,\n enabled,\n start,\n unit_to_index: bcx.unit_to_index.clone(),\n active: HashMap::new(),\n last_cpu_state,\n last_cpu_recording: Instant::now(),\n cpu_usage: Vec::new(),\n }\n }\n\n /// Mark that a unit has started running.\n pub fn unit_start(&mut self, build_runner: &BuildRunner<'_, '_>, id: JobId, unit: Unit) {\n let Some(logger) = build_runner.bcx.logger else {\n return;\n };\n let mut target = if unit.target.is_lib()\n && matches!(unit.mode, CompileMode::Build | CompileMode::Check { .. })\n {\n // Special case for brevity, since most dependencies hit this path.\n \"\".to_string()\n } else {\n format!(\" {}\", unit.target.description_named())\n };\n match unit.mode {\n CompileMode::Test => target.push_str(\" (test)\"),\n CompileMode::Build => {}\n CompileMode::Check { test: true } => target.push_str(\" (check-test)\"),\n CompileMode::Check { test: false } => target.push_str(\" (check)\"),\n CompileMode::Doc { .. } => target.push_str(\" (doc)\"),\n CompileMode::Doctest => target.push_str(\" (doc test)\"),\n CompileMode::Docscrape => target.push_str(\" (doc scrape)\"),\n CompileMode::RunCustomBuild => target.push_str(\" (run)\"),\n }\n let start = self.start.elapsed().as_secs_f64();\n logger.log(LogMessage::UnitStarted {\n index: self.unit_to_index[&unit],\n elapsed: start,\n });\n\n assert!(self.active.insert(id, unit).is_none());\n }\n\n /// Mark that the `.rmeta` file as generated.\n pub fn unit_rmeta_finished(\n &mut self,\n build_runner: &BuildRunner<'_, '_>,\n id: JobId,\n unblocked: Vec<&Unit>,\n ) {\n let Some(logger) = build_runner.bcx.logger else {\n return;\n };\n // `id` may not always be active. \"fresh\" units unconditionally\n // generate `Message::Finish`, but this active map only tracks dirty\n // units.\n let Some(unit) = self.active.get(&id) else {\n return;\n };\n let elapsed = self.start.elapsed().as_secs_f64();\n\n let unblocked = unblocked.iter().map(|u| self.unit_to_index[u]).collect();\n logger.log(LogMessage::UnitRmetaFinished {\n index: self.unit_to_index[unit],\n elapsed,\n unblocked,\n });\n }\n\n /// Mark that a unit has finished running.\n pub fn unit_finished(\n &mut self,\n build_runner: &BuildRunner<'_, '_>,\n id: JobId,\n unblocked: Vec<&Unit>,\n ) {\n let Some(logger) = build_runner.bcx.logger else {\n return;\n };\n // See note above in `unit_rmeta_finished`, this may not always be active.\n let Some(unit) = self.active.remove(&id) else {\n return;\n };\n let elapsed = self.start.elapsed().as_secs_f64();\n\n let unblocked = unblocked.iter().map(|u| self.unit_to_index[u]).collect();\n logger.log(LogMessage::UnitFinished {\n index: self.unit_to_index[&unit],\n elapsed,\n unblocked,\n });\n }\n\n /// Handle the start/end of a compilation section.\n pub fn unit_section_timing(\n &mut self,\n build_runner: &BuildRunner<'_, '_>,\n id: JobId,\n section_timing: &SectionTiming,\n ) {\n let Some(logger) = build_runner.bcx.logger else {\n return;\n };\n let Some(unit) = self.active.get(&id) else {\n return;\n };\n let elapsed = self.start.elapsed().as_secs_f64();\n\n let index = self.unit_to_index[&unit];\n let section = section_timing.name.clone();\n logger.log(match section_timing.event {\n SectionTimingEvent::Start => LogMessage::UnitSectionStarted {\n index,\n elapsed,\n section,\n },\n SectionTimingEvent::End => LogMessage::UnitSectionFinished {\n index,\n elapsed,\n section,\n },\n })\n }\n\n /// Take a sample of CPU usage\n pub fn record_cpu(&mut self) {\n if !self.enabled {\n return;\n }\n let Some(prev) = &mut self.last_cpu_state else {\n return;\n };\n // Don't take samples too frequently, even if requested.\n let now = Instant::now();\n if self.last_cpu_recording.elapsed() < Duration::from_millis(100) {\n return;\n }\n let current = match State::current() {\n Ok(s) => s,\n Err(e) => {\n tracing::info!(\"failed to get CPU state: {:?}\", e);\n return;\n }\n };\n let pct_idle = current.idle_since(prev);\n *prev = current;\n self.last_cpu_recording = now;\n let dur = now.duration_since(self.start).as_secs_f64();\n self.cpu_usage.push((dur, 100.0 - pct_idle));\n }\n\n /// Call this when all units are finished.\n pub fn finished(\n &mut self,\n build_runner: &BuildRunner<'_, '_>,\n error: &Option,\n ) -> CargoResult<()> {\n if let Some(logger) = build_runner.bcx.logger\n && let Some(logs) = logger.get_logs()\n {\n let timings_path = build_runner\n .files()\n .timings_dir()\n .expect(\"artifact-dir was not locked\");\n paths::create_dir_all(&timings_path)?;\n let run_id = logger.run_id();\n let filename = timings_path.join(format!(\"cargo-timing-{run_id}.html\"));\n let mut f = BufWriter::new(paths::create(&filename)?);\n\n let mut ctx = prepare_context(logs.into_iter(), run_id)?;\n ctx.error = error;\n ctx.cpu_usage = &self.cpu_usage;\n report::write_html(ctx, &mut f)?;\n\n let unstamped_filename = timings_path.join(\"cargo-timing.html\");\n paths::link_or_copy(&filename, &unstamped_filename)?;\n\n let mut shell = self.gctx.shell();\n let timing_path = std::env::current_dir().unwrap_or_default().join(&filename);\n let link = shell.err_file_hyperlink(&timing_path);\n let msg = format!(\"report saved to {link}{}{link:#}\", timing_path.display(),);\n shell.status_with_color(\"Timing\", msg, &style::NOTE)?;\n }\n Ok(())\n }\n}\n\n/// Start or end of a section timing.\n#[derive(serde::Deserialize, Debug)]\n#[serde(rename_all = \"kebab-case\")]\npub enum SectionTimingEvent {\n Start,\n End,\n}\n\n/// Represents a certain section (phase) of rustc compilation.\n/// It is emitted by rustc when the `--json=timings` flag is used.\n#[derive(serde::Deserialize, Debug)]\npub struct SectionTiming {\n pub name: String,\n pub event: SectionTimingEvent,\n}\n" }, { "path": "src/cargo/core/compiler/timings/report.rs", "content": "//! Render HTML report from timing tracking data.\n\nuse std::borrow::Cow;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::Write;\n\nuse indexmap::IndexMap;\nuse itertools::Itertools as _;\n\nuse crate::CargoResult;\nuse crate::core::compiler::UnitIndex;\n\nuse super::CompilationSection;\nuse super::UnitData;\n\n/// Name of an individual compilation section.\n#[derive(Clone, Hash, Eq, PartialEq)]\npub enum SectionName {\n Frontend,\n Codegen,\n Named(String),\n Other,\n}\n\nimpl SectionName {\n /// Lower case name.\n fn name(&self) -> Cow<'static, str> {\n match self {\n SectionName::Frontend => \"frontend\".into(),\n SectionName::Codegen => \"codegen\".into(),\n SectionName::Named(n) => n.to_lowercase().into(),\n SectionName::Other => \"other\".into(),\n }\n }\n\n fn capitalized_name(&self) -> String {\n // Make the first \"letter\" uppercase. We could probably just assume ASCII here, but this\n // should be Unicode compatible.\n fn capitalize(s: &str) -> String {\n let first_char = s\n .chars()\n .next()\n .map(|c| c.to_uppercase().to_string())\n .unwrap_or_default();\n format!(\"{first_char}{}\", s.chars().skip(1).collect::())\n }\n capitalize(&self.name())\n }\n}\n\nimpl serde::ser::Serialize for SectionName {\n fn serialize(&self, serializer: S) -> Result\n where\n S: serde::Serializer,\n {\n self.name().serialize(serializer)\n }\n}\n\n/// Postprocessed section data that has both start and an end.\n#[derive(Copy, Clone, serde::Serialize)]\npub struct SectionData {\n /// Start (relative to the start of the unit)\n pub start: f64,\n /// End (relative to the start of the unit)\n pub end: f64,\n}\n\nimpl SectionData {\n fn duration(&self) -> f64 {\n (self.end - self.start).max(0.0)\n }\n}\n\n/// Concurrency tracking information.\n#[derive(serde::Serialize)]\npub struct Concurrency {\n /// Time as an offset in seconds from `Timings::start`.\n t: f64,\n /// Number of units currently running.\n active: usize,\n /// Number of units that could run, but are waiting for a jobserver token.\n waiting: usize,\n /// Number of units that are not yet ready, because they are waiting for\n /// dependencies to finish.\n inactive: usize,\n}\n\npub struct RenderContext<'a> {\n /// A rendered string of when compilation started.\n pub start_str: String,\n /// A summary of the root units.\n ///\n /// Tuples of `(package_description, target_descriptions)`.\n pub root_units: Vec<(String, Vec)>,\n /// The build profile.\n pub profile: String,\n /// Total number of fresh units.\n pub total_fresh: u32,\n /// Total number of dirty units.\n pub total_dirty: u32,\n /// Time tracking for each individual unit.\n pub unit_data: Vec,\n /// Concurrency-tracking information. This is periodically updated while\n /// compilation progresses.\n pub concurrency: Vec,\n /// Recorded CPU states, stored as tuples. First element is when the\n /// recording was taken and second element is percentage usage of the\n /// system.\n pub cpu_usage: &'a [(f64, f64)],\n /// Compiler version info, i.e., `rustc 1.92.0-beta.2 (0a411606e 2025-10-31)`.\n pub rustc_version: String,\n /// The host triple (arch-platform-OS).\n pub host: String,\n /// The requested target platforms of compilation for this build.\n pub requested_targets: Vec,\n /// The number of jobs specified for this build.\n pub jobs: u32,\n /// Available parallelism of the compilation environment.\n pub num_cpus: Option,\n /// Fatal error during the build.\n pub error: &'a Option,\n}\n\n/// Writes an HTML report.\npub fn write_html(ctx: RenderContext<'_>, f: &mut impl Write) -> CargoResult<()> {\n // The last concurrency record should equal to the last unit finished time.\n let duration = ctx.concurrency.last().map(|c| c.t).unwrap_or(0.0);\n let roots: Vec<&str> = ctx\n .root_units\n .iter()\n .map(|(name, _targets)| name.as_str())\n .collect();\n f.write_all(HTML_TMPL.replace(\"{ROOTS}\", &roots.join(\", \")).as_bytes())?;\n write_summary_table(&ctx, f, duration)?;\n f.write_all(HTML_CANVAS.as_bytes())?;\n write_unit_table(&ctx, f)?;\n // It helps with pixel alignment to use whole numbers.\n writeln!(\n f,\n \"\\n\\\n \\n\\\n \\n\\\n \",\n include_str!(\"timings.js\")\n )?;\n\n Ok(())\n}\n\n/// Render the summary table.\nfn write_summary_table(\n ctx: &RenderContext<'_>,\n f: &mut impl Write,\n duration: f64,\n) -> CargoResult<()> {\n let targets = ctx\n .root_units\n .iter()\n .map(|(name, targets)| format!(\"{} ({})\", name, targets.join(\", \")))\n .collect::>()\n .join(\"
\");\n\n let total_units = ctx.total_fresh + ctx.total_dirty;\n\n let time_human = if duration > 60.0 {\n format!(\" ({}m {:.1}s)\", duration as u32 / 60, duration % 60.0)\n } else {\n \"\".to_string()\n };\n let total_time = format!(\"{:.1}s{}\", duration, time_human);\n\n let max_concurrency = ctx.concurrency.iter().map(|c| c.active).max().unwrap_or(0);\n let num_cpus = ctx\n .num_cpus\n .map(|x| x.to_string())\n .unwrap_or_else(|| \"n/a\".into());\n\n let requested_targets = ctx.requested_targets.join(\", \");\n\n let error_msg = match ctx.error {\n Some(e) => format!(r#\"Error:{e}\"#),\n None => \"\".to_string(),\n };\n\n let RenderContext {\n start_str,\n profile,\n total_fresh,\n total_dirty,\n rustc_version,\n host,\n jobs,\n ..\n } = &ctx;\n\n write!(\n f,\n r#\"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n{error_msg}\n
Targets:{targets}
Profile:{profile}
Fresh units:{total_fresh}
Dirty units:{total_dirty}
Total units:{total_units}
Max concurrency:{max_concurrency} (jobs={jobs} ncpu={num_cpus})
Build start:{start_str}
Total time:{total_time}
rustc:{rustc_version}
Host: {host}
Target: {requested_targets}
\n\"#,\n )?;\n Ok(())\n}\n\n/// Write timing data in JavaScript. Primarily for `timings.js` to put data\n/// in a `\n pub struct Bar;\n \"#,\n )\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"0.0.1\"\n\n [profile.dev]\n trim-paths = \"object\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"doc -vv -Ztrim-paths\")\n .masquerade_as_nightly_cargo(&[\"-Ztrim-paths\"])\n .with_stderr_data(str![[r#\"\n...\n[WARNING] unopened HTML tag `script`\n --> [ROOT]/home/.cargo/registry/src/-[HASH]/bar-0.0.1/src/lib.rs:2:17\n...\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"rustdoc --remap-path-prefix is unstable\")]\nfn rustdoc_diagnostics_works() {\n // This is expected to work after rust-lang/rust#128736\n Package::new(\"bar\", \"0.0.1\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\n \"src/lib.rs\",\n r#\"\n /// \n pub struct Bar;\n \"#,\n )\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"0.0.1\"\n\n [profile.dev]\n trim-paths = \"diagnostics\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"doc -vv -Ztrim-paths\")\n .masquerade_as_nightly_cargo(&[\"-Ztrim-paths\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `[..]rustc [..]--remap-path-scope=diagnostics --remap-path-prefix=[ROOT]/home/.cargo/registry/src= --remap-path-prefix=[..]/lib/rustlib/src/rust=/rustc/[..]`\n...\n[WARNING] unopened HTML tag `script`\n --> -[..]/bar-0.0.1/src/lib.rs:2:17\n...\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/profiles.rs", "content": "//! Tests for profiles.\n\nuse std::env;\n\nuse crate::prelude::*;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::{project, rustc_host, str};\n\n#[cargo_test]\nfn profile_overrides() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n\n name = \"test\"\n version = \"0.0.0\"\n edition = \"2015\"\n authors = []\n\n [profile.dev]\n opt-level = 1\n debug = false\n rpath = true\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"build -v\").with_stderr_data(str![[r#\"\n[COMPILING] test v0.0.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name test --edition=2015 src/lib.rs [..]--crate-type lib --emit=[..]link[..] -C opt-level=1[..] -C debug-assertions=on[..] -C metadata=[..] -C rpath --out-dir [ROOT]/foo/target/debug/deps [..] -L dependency=[ROOT]/foo/target/debug/deps`\n[FINISHED] `dev` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn opt_level_override_0() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n\n name = \"test\"\n version = \"0.0.0\"\n edition = \"2015\"\n authors = []\n\n [profile.dev]\n opt-level = 0\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"build -v\").with_stderr_data(str![[r#\"\n[COMPILING] test v0.0.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name test --edition=2015 src/lib.rs [..]--crate-type lib --emit=[..]link[..]-C debuginfo=2 [..] -C metadata=[..] --out-dir [ROOT]/foo/target/debug/deps -L dependency=[ROOT]/foo/target/debug/deps`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn debug_override_1() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"test\"\n version = \"0.0.0\"\n edition = \"2015\"\n authors = []\n\n [profile.dev]\n debug = 1\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"build -v\").with_stderr_data(str![[r#\"\n[COMPILING] test v0.0.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name test --edition=2015 src/lib.rs [..]--crate-type lib --emit=[..]link[..]-C debuginfo=1 [..]-C metadata=[..] --out-dir [ROOT]/foo/target/debug/deps -L dependency=[ROOT]/foo/target/debug/deps`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]).run();\n}\n\nfn check_opt_level_override(profile_level: &str, rustc_level: &str) {\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n\n name = \"test\"\n version = \"0.0.0\"\n edition = \"2015\"\n authors = []\n\n [profile.dev]\n opt-level = {level}\n \"#,\n level = profile_level\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"build -v\")\n .with_stderr_data(&format!(\n \"\\\n[COMPILING] test v0.0.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name test --edition=2015 src/lib.rs [..]--crate-type lib \\\n --emit=[..]link \\\n -C opt-level={level}[..]\\\n -C debuginfo=2 [..]\\\n -C debug-assertions=on[..] \\\n -C metadata=[..] \\\n --out-dir [..] \\\n -L dependency=[ROOT]/foo/target/debug/deps`\n[FINISHED] `dev` profile [..]+ debuginfo] target(s) in [ELAPSED]s\n\",\n level = rustc_level\n ))\n .run();\n}\n\n#[cargo_test]\nfn opt_level_overrides() {\n for &(profile_level, rustc_level) in &[\n (\"1\", \"1\"),\n (\"2\", \"2\"),\n (\"3\", \"3\"),\n (\"\\\"s\\\"\", \"s\"),\n (\"\\\"z\\\"\", \"z\"),\n ] {\n check_opt_level_override(profile_level, rustc_level)\n }\n}\n\n#[cargo_test]\nfn top_level_overrides_deps() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n\n name = \"test\"\n version = \"0.0.0\"\n edition = \"2015\"\n authors = []\n\n [profile.release]\n opt-level = 1\n debug = true\n\n [dependencies.foo]\n path = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n\n name = \"foo\"\n version = \"0.0.0\"\n edition = \"2015\"\n authors = []\n\n [profile.release]\n opt-level = 0\n debug = false\n\n [lib]\n name = \"foo\"\n crate-type = [\"dylib\", \"rlib\"]\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n p.cargo(\"build -v --release\")\n .with_stderr_data(&format!(\n \"\\\n[LOCKING] 1 package to latest compatible version\n[COMPILING] foo v0.0.0 ([ROOT]/foo/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 foo/src/lib.rs [..]\\\n --crate-type dylib --crate-type rlib \\\n --emit=[..]link \\\n -C prefer-dynamic \\\n -C opt-level=1[..]\\\n -C debuginfo=2 [..]\\\n -C metadata=[..] \\\n --out-dir [ROOT]/foo/target/release/deps \\\n -L dependency=[ROOT]/foo/target/release/deps`\n[COMPILING] test v0.0.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name test --edition=2015 src/lib.rs [..]--crate-type lib \\\n --emit=[..]link \\\n -C opt-level=1[..]\\\n -C debuginfo=2 [..]\\\n -C metadata=[..] \\\n --out-dir [..] \\\n -L dependency=[ROOT]/foo/target/release/deps \\\n --extern foo=[ROOT]/foo/target/release/deps/\\\n {prefix}foo[..]{suffix} \\\n --extern foo=[ROOT]/foo/target/release/deps/libfoo.rlib`\n[FINISHED] `release` profile [optimized + debuginfo] target(s) in [ELAPSED]s\n\",\n prefix = env::consts::DLL_PREFIX,\n suffix = env::consts::DLL_SUFFIX\n ))\n .run();\n}\n\n#[cargo_test]\nfn profile_in_non_root_manifest_triggers_a_warning() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n\n [profile.dev]\n debug = false\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"..\"\n\n [profile.dev]\n opt-level = 1\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build -v\")\n .cwd(\"bar\")\n .with_stderr_data(str![[r#\"\n[WARNING] profiles for the non root package will be ignored, specify profiles at the workspace root:\npackage: [ROOT]/foo/bar/Cargo.toml\nworkspace: [ROOT]/foo/Cargo.toml\n[COMPILING] bar v0.1.0 ([ROOT]/foo/bar)\n[RUNNING] `rustc [..]`\n[FINISHED] `dev` profile [unoptimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn profile_in_virtual_manifest_works() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n\n [profile.dev]\n opt-level = 1\n debug = false\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"..\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build -v\")\n .cwd(\"bar\")\n .with_stderr_data(str![[r#\"\n[COMPILING] bar v0.1.0 ([ROOT]/foo/bar)\n[RUNNING] `rustc [..]`\n[FINISHED] `dev` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn profile_lto_string_bool_dev() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [profile.dev]\n lto = \"true\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n `lto` setting of string `\"true\"` for `dev` profile is not a valid setting, must be a boolean (`true`/`false`) or a string (`\"thin\"`/`\"fat\"`/`\"off\"`) or omitted.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn profile_panic_test_bench() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [profile.test]\n panic = \"abort\"\n\n [profile.bench]\n panic = \"abort\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build\")\n .with_stderr_data(str![[r#\"\n[WARNING] `panic` setting is ignored for `bench` profile\n[WARNING] `panic` setting is ignored for `test` profile\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn profile_doc_deprecated() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [profile.doc]\n opt-level = 0\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build\")\n .with_stderr_data(str![[r#\"\n[WARNING] profile `doc` is deprecated and has no effect\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn panic_unwind_does_not_build_twice() {\n // Check for a bug where `lib` was built twice, once with panic set and\n // once without. Since \"unwind\" is the default, they are the same and\n // should only be built once.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [profile.dev]\n panic = \"unwind\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"tests/t1.rs\", \"\")\n .build();\n\n p.cargo(\"test -v --tests --no-run\")\n .with_stderr_data(\n str![[r#\"\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib [..]`\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..] --test [..]`\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]--crate-type bin [..]`\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..] --test [..]`\n[RUNNING] `rustc --crate-name t1 --edition=2015 tests/t1.rs [..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/t1-[HASH][EXE]`\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn debug_0_report() {\n // The finished line handles 0 correctly.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [profile.dev]\n debug = 0\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]`\n[FINISHED] `dev` profile [unoptimized] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stderr_does_not_contain(\"-C debuginfo\")\n .run();\n}\n\n#[cargo_test]\nfn thin_lto_works() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"top\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [profile.release]\n lto = 'thin'\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --release -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] top v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] -C lto=thin [..]`\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn strip_works() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [profile.release]\n strip = 'symbols'\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --release -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] -C strip=symbols [..]`\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn strip_passes_unknown_option_to_rustc() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [profile.release]\n strip = 'unknown'\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --release -v\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] -C strip=unknown [..]`\n[ERROR] incorrect value `unknown` for [..] `strip` [..] was expected\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn strip_accepts_true_to_strip_symbols() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [profile.release]\n strip = true\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --release -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] -C strip=symbols [..]`\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn strip_accepts_false_to_disable_strip() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [profile.release]\n strip = false\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --release -v\")\n .with_stderr_does_not_contain(\"[RUNNING] `rustc [..] -C strip[..]`\")\n .run();\n}\n\n#[cargo_test]\nfn strip_debuginfo_in_release() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --release -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] -C strip=debuginfo[..]`\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n p.cargo(\"build --release -v --target\")\n .arg(rustc_host())\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] -C strip=debuginfo[..]`\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn strip_debuginfo_without_debug() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n \n [profile.dev]\n debug = 0\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] -C strip=debuginfo[..]`\n[FINISHED] `dev` profile [unoptimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn do_not_strip_debuginfo_with_requested_debug() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = { path = \"bar\" }\n\n [profile.release.package.bar]\n debug = 1\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build --release -v\")\n .with_stderr_does_not_contain(\"[RUNNING] `rustc [..] -C strip=debuginfo[..]`\")\n .run();\n}\n\n#[cargo_test]\nfn rustflags_works() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"profile-rustflags\"]\n\n [profile.dev]\n rustflags = [\"-C\", \"link-dead-code=yes\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build -v\")\n .masquerade_as_nightly_cargo(&[\"profile-rustflags\"])\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] -C link-dead-code=yes [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustflags_works_with_env() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"profile-rustflags\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build -v\")\n .env(\"CARGO_PROFILE_DEV_RUSTFLAGS\", \"-C link-dead-code=yes\")\n .masquerade_as_nightly_cargo(&[\"profile-rustflags\"])\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] -C link-dead-code=yes [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustflags_requires_cargo_feature() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [profile.dev]\n rustflags = [\"-C\", \"link-dead-code=yes\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build -v\")\n .masquerade_as_nightly_cargo(&[\"profile-rustflags\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n feature `profile-rustflags` is required\n\n The package requires the Cargo feature called `profile-rustflags`, but that feature is not stabilized in this version of Cargo (1.[..]).\n Consider adding `cargo-features = [\"profile-rustflags\"]` to the top of Cargo.toml (above the [package] table) to tell Cargo you are opting in to use this unstable feature.\n See https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#profile-rustflags-option for more information about the status of this feature.\n\n\"#]])\n .run();\n\n Package::new(\"bar\", \"1.0.0\").publish();\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n\n [profile.dev.package.bar]\n rustflags = [\"-C\", \"link-dead-code=yes\"]\n \"#,\n );\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"profile-rustflags\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n feature `profile-rustflags` is required\n\n The package requires the Cargo feature called `profile-rustflags`, but that feature is not stabilized in this version of Cargo (1.[..]).\n Consider adding `cargo-features = [\"profile-rustflags\"]` to the top of Cargo.toml (above the [package] table) to tell Cargo you are opting in to use this unstable feature.\n See https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#profile-rustflags-option for more information about the status of this feature.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn debug_options_valid() {\n let build = |option| {\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n authors = []\n version = \"0.0.0\"\n edition = \"2015\"\n\n [profile.dev]\n debug = \"{option}\"\n \"#\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build -v\")\n };\n\n for (option, cli) in [\n (\"line-directives-only\", \"line-directives-only\"),\n (\"line-tables-only\", \"line-tables-only\"),\n (\"limited\", \"1\"),\n (\"full\", \"2\"),\n ] {\n build(option)\n .with_stderr_data(&format!(\n \"\\\n...\n[RUNNING] `rustc [..]-C debuginfo={cli} [..]`\n...\n\"\n ))\n .run();\n }\n build(\"none\")\n .with_stderr_does_not_contain(\"[..]-C debuginfo[..]\")\n .run();\n}\n\n#[cargo_test]\nfn profile_hint_mostly_unused_warn_without_gate() {\n Package::new(\"bar\", \"1.0.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n\n [profile.dev.package.bar]\n hint-mostly-unused = true\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n p.cargo(\"check -v\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n[WARNING] bar@1.0.0: ignoring 'hint-mostly-unused' profile option, pass `-Zprofile-hint-mostly-unused` to enable it\n[CHECKING] bar v1.0.0\n[RUNNING] `rustc --crate-name bar [..]`\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stderr_does_not_contain(\"-Zhint-mostly-unused\")\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zhint-mostly-unused is unstable\")]\nfn profile_hint_mostly_unused_nightly() {\n Package::new(\"bar\", \"1.0.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n\n [profile.dev.package.bar]\n hint-mostly-unused = true\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n p.cargo(\"check -Zprofile-hint-mostly-unused -v\")\n .masquerade_as_nightly_cargo(&[\"profile-hint-mostly-unused\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n[CHECKING] bar v1.0.0\n[RUNNING] `rustc --crate-name bar [..] -Zhint-mostly-unused [..]`\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stderr_does_not_contain(\n \"[RUNNING] `rustc --crate-name foo [..] -Zhint-mostly-unused [..]\",\n )\n .run();\n}\n" }, { "path": "tests/testsuite/progress.rs", "content": "//! Tests for progress bar.\n\nuse crate::prelude::*;\nuse cargo_test_support::project;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::str;\n\n#[cargo_test]\nfn bad_progress_config_unknown_when() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n progress = { when = 'unknown' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] error in [ROOT]/foo/.cargo/config.toml: could not load config key `term.progress.when`\n\nCaused by:\n unknown variant `unknown`, expected one of `auto`, `never`, `always`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bad_progress_config_missing_width() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n progress = { when = 'always' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] \"always\" progress requires a `width` key\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn default_progress_is_auto() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n progress = { width = 1000 }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn always_shows_progress() {\n const N: usize = 3;\n let mut deps = String::new();\n for i in 1..=N {\n Package::new(&format!(\"dep{}\", i), \"1.0.0\").publish();\n deps.push_str(&format!(\"dep{} = \\\"1.0\\\"\\n\", i));\n }\n\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n progress = { when = 'always', width = 100 }\n \"#,\n )\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n {}\n \"#,\n deps\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(\n str![[r#\"\n[DOWNLOADING] [..] crate [..]\n[DOWNLOADED] 3 crates ([..]) in [..]s\n[BUILDING] [..] [..]/4: [..]\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn never_progress() {\n const N: usize = 3;\n let mut deps = String::new();\n for i in 1..=N {\n Package::new(&format!(\"dep{}\", i), \"1.0.0\").publish();\n deps.push_str(&format!(\"dep{} = \\\"1.0\\\"\\n\", i));\n }\n\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n progress = { when = 'never' }\n \"#,\n )\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n {}\n \"#,\n deps\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_stderr_does_not_contain(\"[DOWNLOADING] [..] crates [..]\")\n .with_stderr_does_not_contain(\"[..][DOWNLOADED] 3 crates ([..]) in [..]\")\n .with_stderr_does_not_contain(\"[BUILDING] [..] [..]/4: [..]\")\n .run();\n}\n\n#[cargo_test]\nfn plain_string_when_doesnt_work() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n progress = \"never\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] invalid configuration for key `term.progress`\nexpected a table, but found a string for `term.progress` in [ROOT]/foo/.cargo/config.toml\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/pub_priv.rs", "content": "//! Tests for public/private dependencies.\n\nuse crate::prelude::*;\nuse cargo_test_support::registry::{Dependency, Package};\nuse cargo_test_support::{git, str};\nuse cargo_test_support::{project, registry};\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn exported_priv_warning() {\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n priv_dep = \"0.1.0\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate priv_dep;\n pub fn use_priv(_: priv_dep::FromPriv) {}\n \",\n )\n .build();\n\n p.cargo(\"check --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n...\nsrc/lib.rs:3:13: [WARNING] type `FromPriv` from private dependency 'priv_dep' in public interface\n...\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn exported_pub_dep() {\n Package::new(\"pub_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPub;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n pub_dep = {version = \"0.1.0\", public = true}\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate pub_dep;\n pub fn use_pub(_: pub_dep::FromPub) {}\n \",\n )\n .build();\n\n p.cargo(\"check --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] pub_dep v0.1.0 (registry `dummy-registry`)\n[CHECKING] pub_dep v0.1.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\npub fn requires_nightly_cargo() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check --message-format=short\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n the cargo feature `public-dependency` requires a nightly version of Cargo, but this is the `stable` channel\n See https://doc.rust-lang.org/book/appendix-07-nightly-rust.html for more information about Rust release channels.\n See https://doc.rust-lang.org/[..]cargo/reference/unstable.html#public-dependency for more information about using this feature.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn requires_feature() {\n Package::new(\"pub_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n pub_dep = { version = \"0.1.0\", public = true }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n[WARNING] ignoring `public` on dependency pub_dep, pass `-Zpublic-dependency` to enable support for it\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] pub_dep v0.1.0 (registry `dummy-registry`)\n[CHECKING] pub_dep v0.1.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn pub_dev_dependency() {\n Package::new(\"pub_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPub;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dev-dependencies]\n pub_dep = {version = \"0.1.0\", public = true}\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate pub_dep;\n pub fn use_pub(_: pub_dep::FromPub) {}\n \",\n )\n .build();\n\n p.cargo(\"check --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n 'public' specifier can only be used on regular dependencies, not dev-dependencies\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn pub_dev_dependency_without_feature() {\n Package::new(\"pub_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPub;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dev-dependencies]\n pub_dep = {version = \"0.1.0\", public = true}\n \"#,\n )\n .file(\n \"tests/mod.rs\",\n \"\n extern crate pub_dep;\n pub fn use_pub(_: pub_dep::FromPub) {}\n \",\n )\n .build();\n\n p.cargo(\"check --message-format=short\")\n .with_stderr_data(str![[r#\"\n[WARNING] 'public' specifier can only be used on regular dependencies, not dev-dependencies\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn workspace_pub_disallowed() {\n Package::new(\"foo1\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromFoo;\")\n .publish();\n Package::new(\"foo2\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromFoo;\")\n .publish();\n Package::new(\"foo3\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromFoo;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [workspace.dependencies]\n foo1 = \"0.1.0\"\n foo2 = { version = \"0.1.0\", public = true }\n foo3 = { version = \"0.1.0\", public = false }\n\n [dependencies]\n foo1 = { workspace = true, public = true }\n foo2 = { workspace = true }\n foo3 = { workspace = true, public = true }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n #![deny(exported_private_dependencies)]\n pub fn use_priv1(_: foo1::FromFoo) {}\n pub fn use_priv2(_: foo2::FromFoo) {}\n pub fn use_priv3(_: foo3::FromFoo) {}\n \",\n )\n .build();\n\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n foo2 is public, but workspace dependencies cannot be public\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn allow_priv_in_tests() {\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n priv_dep = {version = \"0.1.0\", public = false}\n \"#,\n )\n .file(\n \"tests/mod.rs\",\n \"\n extern crate priv_dep;\n pub fn use_priv(_: priv_dep::FromPriv) {}\n \",\n )\n .build();\n\n p.cargo(\"check --tests --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] priv_dep v0.1.0 (registry `dummy-registry`)\n[CHECKING] priv_dep v0.1.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn allow_priv_in_benches() {\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n priv_dep = {version = \"0.1.0\", public = false}\n \"#,\n )\n .file(\n \"benches/mod.rs\",\n \"\n extern crate priv_dep;\n pub fn use_priv(_: priv_dep::FromPriv) {}\n \",\n )\n .build();\n\n p.cargo(\"check --benches --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] priv_dep v0.1.0 (registry `dummy-registry`)\n[CHECKING] priv_dep v0.1.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn allow_priv_in_bins() {\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n priv_dep = {version = \"0.1.0\", public = false}\n \"#,\n )\n .file(\n \"src/main.rs\",\n \"\n extern crate priv_dep;\n pub fn use_priv(_: priv_dep::FromPriv) {}\n fn main() {}\n \",\n )\n .build();\n\n p.cargo(\"check --bins --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] priv_dep v0.1.0 (registry `dummy-registry`)\n[CHECKING] priv_dep v0.1.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn allow_priv_in_examples() {\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n priv_dep = {version = \"0.1.0\", public = false}\n \"#,\n )\n .file(\n \"examples/lib.rs\",\n \"\n extern crate priv_dep;\n pub fn use_priv(_: priv_dep::FromPriv) {}\n fn main() {}\n \",\n )\n .build();\n\n p.cargo(\"check --examples --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] priv_dep v0.1.0 (registry `dummy-registry`)\n[CHECKING] priv_dep v0.1.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn allow_priv_in_custom_build() {\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [build-dependencies]\n priv_dep = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"build.rs\",\n \"\n extern crate priv_dep;\n pub fn use_priv(_: priv_dep::FromPriv) {}\n fn main() {}\n \",\n )\n .build();\n\n p.cargo(\"check --all-targets --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] priv_dep v0.1.0 (registry `dummy-registry`)\n[COMPILING] priv_dep v0.1.0\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn publish_package_with_public_dependency() {\n Package::new(\"pub_bar\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPub;\")\n .publish();\n Package::new(\"bar\", \"0.1.0\")\n .cargo_feature(\"public-dependency\")\n .add_dep(Dependency::new(\"pub_bar\", \"0.1.0\").public(true))\n .file(\n \"src/lib.rs\",\n \"\n extern crate pub_bar;\n pub use pub_bar::FromPub as BarFromPub;\n \",\n )\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n [dependencies]\n bar = {version = \"0.1.0\", public = true}\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate bar;\n pub fn use_pub(_: bar::BarFromPub) {}\n \",\n )\n .build();\n\n p.cargo(\"check --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] pub_bar v0.1.0 (registry `dummy-registry`)\n[DOWNLOADED] bar v0.1.0 (registry `dummy-registry`)\n[CHECKING] pub_bar v0.1.0\n[CHECKING] bar v0.1.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn verify_mix_cargo_feature_z() {\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromDep;\")\n .publish();\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n Package::new(\"pub_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPub;\")\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"public-dependency\"]\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n dep = \"0.1.0\"\n priv_dep = {version = \"0.1.0\", public = false}\n pub_dep = {version = \"0.1.0\", public = true}\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate dep;\n extern crate priv_dep;\n extern crate pub_dep;\n pub fn use_dep(_: dep::FromDep) {}\n pub fn use_priv(_: priv_dep::FromPriv) {}\n pub fn use_pub(_: pub_dep::FromPub) {}\n \",\n )\n .build();\n\n p.cargo(\"check -Zpublic-dependency --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n...\nsrc/lib.rs:5:13: [WARNING] type `FromDep` from private dependency 'dep' in public interface\nsrc/lib.rs:6:13: [WARNING] type `FromPriv` from private dependency 'priv_dep' in public interface\n...\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn verify_z_public_dependency() {\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromDep;\")\n .publish();\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n Package::new(\"pub_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPub;\")\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n dep = \"0.1.0\"\n priv_dep = {version = \"0.1.0\", public = false}\n pub_dep = {version = \"0.1.0\", public = true}\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate dep;\n extern crate priv_dep;\n extern crate pub_dep;\n pub fn use_dep(_: dep::FromDep) {}\n pub fn use_priv(_: priv_dep::FromPriv) {}\n pub fn use_pub(_: pub_dep::FromPub) {}\n \",\n )\n .build();\n\n p.cargo(\"check -Zpublic-dependency --message-format=short\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(\n str![[r#\"\n...\nsrc/lib.rs:5:13: [WARNING] type `FromDep` from private dependency 'dep' in public interface\nsrc/lib.rs:6:13: [WARNING] type `FromPriv` from private dependency 'priv_dep' in public interface\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn manifest_location() {\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromDep;\")\n .publish();\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n dep = \"0.1.0\"\n priv_dep = \"0.1.0\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate dep;\n extern crate priv_dep;\n pub fn use_dep(_: dep::FromDep) {}\n pub use priv_dep::FromPriv;\n \",\n )\n .build();\n\n p.cargo(\"check -Zpublic-dependency\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(\n str![[r#\"\n...\n[WARNING] struct `FromPriv` from private dependency 'priv_dep' is re-exported\n --> src/lib.rs:5:21\n |\n5 | pub use priv_dep::FromPriv;\n | ^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n[NOTE] dependency `priv_dep` declared here\n --> Cargo.toml:9:17\n |\n9 | priv_dep = \"0.1.0\"\n | --------\n\n[WARNING] type `FromDep` from private dependency 'dep' in public interface\n --> src/lib.rs:4:13\n |\n4 | pub fn use_dep(_: dep::FromDep) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n[NOTE] dependency `dep` declared here\n --> Cargo.toml:8:17\n |\n8 | dep = \"0.1.0\"\n | ---\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn renamed_dependency() {\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromDep;\")\n .publish();\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n dep = { version = \"0.1.0\", package = \"dep\" }\n renamed_dep = {version = \"0.1.0\", package = \"priv_dep\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate dep;\n extern crate renamed_dep;\n pub fn use_dep(_: dep::FromDep) {}\n pub fn use_priv(_: renamed_dep::FromPriv) {}\n \",\n )\n .build();\n\n p.cargo(\"check -Zpublic-dependency\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(\n str![[r#\"\n...\n[WARNING] type `FromDep` from private dependency 'dep' in public interface\n --> src/lib.rs:4:13\n |\n4 | pub fn use_dep(_: dep::FromDep) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n[NOTE] dependency `dep` declared here\n --> Cargo.toml:8:54\n |\n8 | dep = { version = \"0.1.0\", package = \"dep\" }\n | -----\n\n[WARNING] type `FromPriv` from private dependency 'priv_dep' in public interface\n --> src/lib.rs:5:13\n |\n5 | pub fn use_priv(_: renamed_dep::FromPriv) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n[NOTE] dependency `priv_dep` declared here\n --> Cargo.toml:9:61\n |\n9 | renamed_dep = {version = \"0.1.0\", package = \"priv_dep\" }\n | ----------\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n// We don't point to the toml locations if the crate is ambiguous.\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn duplicate_renamed_dependency() {\n registry::alt_init();\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromDep;\")\n .publish();\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .alternative(true)\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n dep = { version = \"0.1.0\", package = \"dep\" }\n renamed_dep = {version = \"0.1.0\", package = \"dep\", registry = \"alternative\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate dep;\n extern crate renamed_dep;\n pub fn use_dep(_: dep::FromDep) {}\n pub fn use_priv(_: renamed_dep::FromPriv) {}\n \",\n )\n .build();\n\n p.cargo(\"check -Zpublic-dependency\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(\n str![[r#\"\n...\n[WARNING] type `FromDep` from private dependency 'dep' in public interface\n --> src/lib.rs:4:13\n |\n4 | pub fn use_dep(_: dep::FromDep) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n\n[WARNING] type `FromPriv` from private dependency 'dep' in public interface\n --> src/lib.rs:5:13\n |\n5 | pub fn use_priv(_: renamed_dep::FromPriv) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn dependency_location_in_target_table() {\n if crate::utils::cross_compile::disabled() {\n return;\n }\n\n let native = cargo_test_support::cross_compile::native();\n let alt = cargo_test_support::cross_compile::alternate();\n\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromDep;\")\n .publish();\n Package::new(\"native_priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n Package::new(\"alt_priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [target.{native}.dependencies]\n dep = {{ version = \"0.1.0\" }}\n renamed_dep = {{ version = \"0.1.0\", package = \"native_priv_dep\" }}\n\n [target.{alt}.dependencies]\n dep = {{ version = \"0.1.0\" }}\n renamed_dep = {{ version = \"0.1.0\", package = \"alt_priv_dep\" }}\n \"#\n ),\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate dep;\n extern crate renamed_dep;\n pub fn use_dep(_: dep::FromDep) {}\n pub fn use_priv(_: renamed_dep::FromPriv) {}\n \",\n )\n .build();\n\n p.cargo(\"check -Zpublic-dependency\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(\n str![[r#\"\n...\n[WARNING] type `FromDep` from private dependency 'dep' in public interface\n --> src/lib.rs:4:13\n |\n4 | pub fn use_dep(_: dep::FromDep) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n[NOTE] dependency `dep` declared here\n --> Cargo.toml:8:17\n |\n8 | dep = { version = \"0.1.0\" }\n | ---\n\n[WARNING] type `FromPriv` from private dependency 'native_priv_dep' in public interface\n --> src/lib.rs:5:13\n |\n5 | pub fn use_priv(_: renamed_dep::FromPriv) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n[NOTE] dependency `native_priv_dep` declared here\n --> Cargo.toml:9:62\n |\n9 | renamed_dep = { version = \"0.1.0\", package = \"native_priv_dep\" }\n | -----------------\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(&format!(\"check -Zpublic-dependency --target={alt}\"))\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(\n str![[r#\"\n...\n[WARNING] type `FromDep` from private dependency 'dep' in public interface\n --> src/lib.rs:4:13\n |\n4 | pub fn use_dep(_: dep::FromDep) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n[NOTE] dependency `dep` declared here\n --> Cargo.toml:12:17\n |\n12 | dep = { version = \"0.1.0\" }\n | ---\n\n[WARNING] type `FromPriv` from private dependency 'alt_priv_dep' in public interface\n --> src/lib.rs:5:13\n |\n5 | pub fn use_priv(_: renamed_dep::FromPriv) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n[NOTE] dependency `alt_priv_dep` declared here\n --> Cargo.toml:13:62\n |\n13 | renamed_dep = { version = \"0.1.0\", package = \"alt_priv_dep\" }\n | --------------\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn dependency_location_in_target_table_with_cfg() {\n if crate::utils::cross_compile::disabled() {\n return;\n }\n\n let native_arch = cargo_test_support::cross_compile::native_arch();\n let alt = cargo_test_support::cross_compile::alternate();\n\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromDep;\")\n .publish();\n Package::new(\"native_priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n Package::new(\"alt_priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [target.'cfg(target_arch = \"{native_arch}\")'.dependencies]\n dep = {{ version = \"0.1.0\" }}\n renamed_dep = {{ version = \"0.1.0\", package = \"native_priv_dep\" }}\n\n [target.'cfg(not(target_arch = \"{native_arch}\"))'.dependencies]\n dep = {{ version = \"0.1.0\" }}\n renamed_dep = {{ version = \"0.1.0\", package = \"alt_priv_dep\" }}\n \"#\n ),\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate dep;\n extern crate renamed_dep;\n pub fn use_dep(_: dep::FromDep) {}\n pub fn use_priv(_: renamed_dep::FromPriv) {}\n \",\n )\n .build();\n\n p.cargo(\"check -Zpublic-dependency\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(\n str![[r#\"\n...\n[WARNING] type `FromDep` from private dependency 'dep' in public interface\n --> src/lib.rs:4:13\n |\n4 | pub fn use_dep(_: dep::FromDep) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n[NOTE] dependency `dep` declared here\n --> Cargo.toml:8:17\n |\n8 | dep = { version = \"0.1.0\" }\n | ---\n\n[WARNING] type `FromPriv` from private dependency 'native_priv_dep' in public interface\n --> src/lib.rs:5:13\n |\n5 | pub fn use_priv(_: renamed_dep::FromPriv) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n[NOTE] dependency `native_priv_dep` declared here\n --> Cargo.toml:9:62\n |\n9 | renamed_dep = { version = \"0.1.0\", package = \"native_priv_dep\" }\n | -----------------\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(&format!(\"check -Zpublic-dependency --target={alt}\"))\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(\n str![[r#\"\n...\n[WARNING] type `FromDep` from private dependency 'dep' in public interface\n --> src/lib.rs:4:13\n |\n4 | pub fn use_dep(_: dep::FromDep) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n[NOTE] dependency `dep` declared here\n --> Cargo.toml:12:17\n |\n12 | dep = { version = \"0.1.0\" }\n | ---\n\n[WARNING] type `FromPriv` from private dependency 'alt_priv_dep' in public interface\n --> src/lib.rs:5:13\n |\n5 | pub fn use_priv(_: renamed_dep::FromPriv) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n[NOTE] dependency `alt_priv_dep` declared here\n --> Cargo.toml:13:62\n |\n13 | renamed_dep = { version = \"0.1.0\", package = \"alt_priv_dep\" }\n | --------------\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn dependency_location_in_workspace() {\n Package::new(\"dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromDep;\")\n .publish();\n let (p, repo) = git::new_repo(\"foo\", |p| {\n p.file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"pkg\"]\n [workspace.package]\n edition = \"2015\"\n [workspace.dependencies]\n dep = \"0.1.0\"\n \"#,\n )\n .file(\n \"pkg/Cargo.toml\",\n r#\"\n [package]\n name = \"pkg\"\n edition.workspace = true\n [dependencies]\n dep.workspace = true\n \"#,\n )\n .file(\n \"pkg/src/lib.rs\",\n \"\n extern crate dep;\n pub fn use_dep(_: dep::FromDep) {}\n \",\n )\n });\n git::commit(&repo);\n p.cargo(&format!(\"check -Zpublic-dependency\"))\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n...\n[WARNING] type `FromDep` from private dependency 'dep' in public interface\n --> pkg/src/lib.rs:3:13\n |\n3 | pub fn use_dep(_: dep::FromDep) {}\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n...\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"exported_private_dependencies lint is unstable\")]\nfn relative_display_path() {\n Package::new(\"priv_dep\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub struct FromPriv;\")\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\"]\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n priv_dep = \"0.1.0\"\n \"#,\n )\n .file(\n \"foo/src/lib.rs\",\n \"\n extern crate priv_dep;\n pub use priv_dep::FromPriv;\n \",\n )\n .build();\n p.cargo(\"check -Zpublic-dependency\")\n .cwd(\"foo\")\n .masquerade_as_nightly_cargo(&[\"public-dependency\"])\n .with_stderr_data(str![[r#\"\n...\n[WARNING] struct `FromPriv` from private dependency 'priv_dep' is re-exported\n --> foo/src/lib.rs:3:21\n |\n3 | pub use priv_dep::FromPriv;\n | ^^^^^^^^^^^^^^^^^^\n |\n = [NOTE] `#[warn(exported_private_dependencies)]` on by default\n[NOTE] dependency `priv_dep` declared here\n --> foo/Cargo.toml:8:17\n |\n8 | priv_dep = \"0.1.0\"\n | --------\n...\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/publish.rs", "content": "//! Tests for the `cargo publish` command.\n\nuse std::fs;\nuse std::sync::{Arc, Mutex};\n\nuse crate::prelude::*;\nuse cargo_test_support::git::{self, repo};\nuse cargo_test_support::registry::{self, Package, RegistryBuilder, Response};\nuse cargo_test_support::{Project, paths};\nuse cargo_test_support::{basic_manifest, project, publish, str};\n\nconst CLEAN_FOO_JSON: &str = r#\"\n {\n \"authors\": [],\n \"badges\": {},\n \"categories\": [],\n \"deps\": [],\n \"description\": \"foo\",\n \"documentation\": \"foo\",\n \"features\": {},\n \"homepage\": \"foo\",\n \"keywords\": [],\n \"license\": \"MIT\",\n \"license_file\": null,\n \"links\": null,\n \"name\": \"foo\",\n \"readme\": null,\n \"readme_file\": null,\n \"repository\": \"foo\",\n \"rust_version\": null,\n \"vers\": \"0.0.1\"\n }\n\"#;\n\nfn validate_upload_foo() {\n publish::validate_upload(\n r#\"\n {\n \"authors\": [],\n \"badges\": {},\n \"categories\": [],\n \"deps\": [],\n \"description\": \"foo\",\n \"documentation\": null,\n \"features\": {},\n \"homepage\": null,\n \"keywords\": [],\n \"license\": \"MIT\",\n \"license_file\": null,\n \"links\": null,\n \"name\": \"foo\",\n \"readme\": null,\n \"readme_file\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"vers\": \"0.0.1\"\n }\n \"#,\n \"foo-0.0.1.crate\",\n &[\"Cargo.lock\", \"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\"],\n );\n}\n\nfn validate_upload_li() {\n publish::validate_upload(\n r#\"\n {\n \"authors\": [],\n \"badges\": {},\n \"categories\": [],\n \"deps\": [],\n \"description\": \"li\",\n \"documentation\": null,\n \"features\": {},\n \"homepage\": null,\n \"keywords\": [],\n \"license\": \"MIT\",\n \"license_file\": null,\n \"links\": null,\n \"name\": \"li\",\n \"readme\": null,\n \"readme_file\": null,\n \"repository\": null,\n \"rust_version\": \"1.69\",\n \"vers\": \"0.0.1\"\n }\n \"#,\n \"li-0.0.1.crate\",\n &[\"Cargo.lock\", \"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\"],\n );\n}\n\n#[cargo_test]\nfn simple() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n validate_upload_foo();\n}\n\n#[cargo_test]\nfn duplicate_version() {\n let registry_dupl = RegistryBuilder::new().http_api().http_index().build();\n Package::new(\"foo\", \"0.0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --dry-run\")\n .replace_crates_io(registry_dupl.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] crate foo@0.0.1 already exists on crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] aborting upload due to dry run\n\n\"#]])\n .run();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry_dupl.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] crate foo@0.0.1 already exists on crates.io index\n\n\"#]])\n .run();\n}\n\n// Check that the `token` key works at the root instead of under a\n// `[registry]` table.\n#[cargo_test]\nfn simple_publish_with_http() {\n let _reg = registry::RegistryBuilder::new()\n .http_api()\n .token(registry::Token::Plaintext(\"sekrit\".to_string()))\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify --token sekrit --registry dummy-registry\")\n .with_stderr_data(str![[r#\"\n[WARNING] `cargo publish --token` is deprecated in favor of using `cargo login` and environment variables\n[UPDATING] `dummy-registry` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `dummy-registry`\n[NOTE] waiting for foo v0.0.1 to be available at registry `dummy-registry`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `dummy-registry`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn simple_publish_with_asymmetric() {\n let _reg = registry::RegistryBuilder::new()\n .http_api()\n .http_index()\n .alternative_named(\"dummy-registry\")\n .token(registry::Token::rfc_key())\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify -Zasymmetric-token --registry dummy-registry\")\n .masquerade_as_nightly_cargo(&[\"asymmetric-token\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `dummy-registry`\n[NOTE] waiting for foo v0.0.1 to be available at registry `dummy-registry`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `dummy-registry`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn old_token_location() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n let credentials = paths::home().join(\".cargo/credentials.toml\");\n fs::remove_file(&credentials).unwrap();\n\n // Verify can't publish without a token.\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] no token found, please run `cargo login`\nor use environment variable CARGO_REGISTRY_TOKEN\n\n\"#]])\n .run();\n\n fs::write(&credentials, format!(r#\"token = \"{}\"\"#, registry.token())).unwrap();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Skip `validate_upload_foo` as we just cared we got far enough for verify the token behavior.\n // Other tests will verify the endpoint gets the right payload.\n}\n\n#[cargo_test]\nfn simple_with_index() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .arg(\"--token\")\n .arg(registry.token())\n .arg(\"--index\")\n .arg(registry.index_url().as_str())\n .with_stderr_data(str![[r#\"\n[WARNING] `cargo publish --token` is deprecated in favor of using `cargo login` and environment variables\n[UPDATING] `[ROOT]/registry` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `[ROOT]/registry`\n[NOTE] waiting for foo v0.0.1 to be available at registry `[ROOT]/registry`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `[ROOT]/registry`\n\n\"#]])\n .run();\n\n // Skip `validate_upload_foo` as we just cared we got far enough for verify the VCS behavior.\n // Other tests will verify the endpoint gets the right payload.\n}\n\n#[cargo_test]\nfn git_deps() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [dependencies.foo]\n git = \"git://path/to/nowhere\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] failed to verify manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n all dependencies must have a version requirement specified when publishing.\n dependency `foo` does not specify a version\n Note: The published dependency will use the version from crates.io,\n the `git` specification will be removed from the dependency declaration.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn path_dependency_no_version() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [dependencies.bar]\n path = \"bar\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] failed to verify manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n all dependencies must have a version requirement specified when publishing.\n dependency `bar` does not specify a version\n Note: The published dependency will use the version from crates.io,\n the `path` specification will be removed from the dependency declaration.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn unpublishable_crate() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n publish = false\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --index\")\n .arg(registry.index_url().as_str())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `foo` cannot be published.\n`package.publish` must be set to `true` or a non-empty list in Cargo.toml to publish.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn dont_publish_dirty() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project().file(\"bar\", \"\").build();\n\n let _ = git::repo(&paths::root().join(\"foo\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] 1 files in the working directory contain changes that were not yet committed into git:\n\nbar\n\nto proceed despite this and include the uncommitted changes, pass the `--allow-dirty` flag\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_clean() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project().build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Skip `validate_upload_foo_clean` as we just cared we got far enough for verify the VCS behavior.\n // Other tests will verify the endpoint gets the right payload.\n}\n\n#[cargo_test]\nfn publish_in_sub_repo() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project().no_manifest().file(\"baz\", \"\").build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .cwd(\"bar\")\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo/bar)\n[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo/bar)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/bar/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo/bar)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Skip `validate_upload_foo_clean` as we just cared we got far enough for verify the VCS behavior.\n // Other tests will verify the endpoint gets the right payload.\n}\n\n#[cargo_test]\nfn publish_when_ignored() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project().file(\"baz\", \"\").build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\".gitignore\", \"baz\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 6 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Skip `validate_upload` as we just cared we got far enough for verify the VCS behavior.\n // Other tests will verify the endpoint gets the right payload.\n}\n\n#[cargo_test]\nfn ignore_when_crate_ignored() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project().no_manifest().file(\"bar/baz\", \"\").build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\".gitignore\", \"bar\")\n .nocommit_file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .nocommit_file(\"bar/src/main.rs\", \"fn main() {}\");\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .cwd(\"bar\")\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo/bar)\n[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo/bar)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/bar/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo/bar)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Skip `validate_upload` as we just cared we got far enough for verify the VCS behavior.\n // Other tests will verify the endpoint gets the right payload.\n}\n\n#[cargo_test]\nfn new_crate_rejected() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project().file(\"baz\", \"\").build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .nocommit_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .nocommit_file(\"src/main.rs\", \"fn main() {}\");\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] 3 files in the working directory contain changes that were not yet committed into git:\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn dry_run() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --dry-run --index\")\n .arg(registry.index_url().as_str())\n .with_stderr_data(str![[r#\"\n[UPDATING] `[ROOT]/registry` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] aborting upload due to dry run\n\n\"#]])\n .run();\n\n // Ensure the API request wasn't actually made\n assert!(registry::api_path().join(\"api/v1/crates\").exists());\n assert!(!registry::api_path().join(\"api/v1/crates/new\").exists());\n}\n\n#[cargo_test]\nfn registry_not_in_publish_list() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n publish = [\n \"test\"\n ]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .arg(\"--registry\")\n .arg(\"alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `foo` cannot be published.\nThe registry `alternative` is not listed in the `package.publish` value in Cargo.toml.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_empty_list() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n publish = []\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --registry alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `foo` cannot be published.\n`package.publish` must be set to `true` or a non-empty list in Cargo.toml to publish.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_allowed_registry() {\n let _registry = RegistryBuilder::new()\n .http_api()\n .http_index()\n .alternative()\n .build();\n\n let p = project().build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n publish = [\"alternative\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --registry alternative\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `alternative`\n[NOTE] waiting for foo v0.0.1 to be available at registry `alternative`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `alternative`\n\n\"#]])\n .run();\n\n publish::validate_alt_upload(\n CLEAN_FOO_JSON,\n \"foo-0.0.1.crate\",\n &[\n \"Cargo.lock\",\n \"Cargo.toml\",\n \"Cargo.toml.orig\",\n \"src/main.rs\",\n \".cargo_vcs_info.json\",\n ],\n );\n}\n\n#[cargo_test]\nfn publish_implicitly_to_only_allowed_registry() {\n let _registry = RegistryBuilder::new()\n .http_api()\n .http_index()\n .alternative()\n .build();\n\n let p = project().build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n publish = [\"alternative\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .with_stderr_data(str![[r#\"\n[NOTE] found `alternative` as only allowed registry. Publishing to it automatically.\n[UPDATING] `alternative` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `alternative`\n[NOTE] waiting for foo v0.0.1 to be available at registry `alternative`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `alternative`\n\n\"#]])\n .run();\n\n publish::validate_alt_upload(\n CLEAN_FOO_JSON,\n \"foo-0.0.1.crate\",\n &[\n \"Cargo.lock\",\n \"Cargo.toml\",\n \"Cargo.toml.orig\",\n \"src/main.rs\",\n \".cargo_vcs_info.json\",\n ],\n );\n}\n\n#[cargo_test]\nfn publish_when_both_publish_and_index_specified() {\n let registry = RegistryBuilder::new()\n .http_api()\n .http_index()\n .alternative()\n .build();\n\n let p = project().build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n publish = [\"registry\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .arg(\"--index\")\n .arg(registry.index_url().as_str())\n .arg(\"--token\")\n .arg(registry.token())\n .with_stderr_data(str![[r#\"\n[WARNING] `cargo publish --token` is deprecated in favor of using `cargo login` and environment variables\n[WARNING] `--index` will ignore registries set by `package.publish` in Cargo.toml, and may cause unexpected push to prohibited registry\n[HELP] use `--registry` instead or set `publish = true` in Cargo.toml to suppress this warning\n[UPDATING] [..] index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry [..]\n[NOTE] waiting for foo v0.0.1 to be available at registry [..]\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry [..]\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_failed_with_index_and_only_allowed_registry() {\n let registry = RegistryBuilder::new()\n .http_api()\n .http_index()\n .alternative()\n .build();\n\n let p = project().build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n publish = [\"alternative\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .arg(\"--index\")\n .arg(registry.index_url().as_str())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\n[ERROR] command-line argument --index requires --token to be specified\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_fail_with_no_registry_specified() {\n let p = project().build();\n\n let _ = repo(&paths::root().join(\"foo\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n publish = [\"alternative\", \"test\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] --registry is required to disambiguate between \"alternative\" or \"test\" registries\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn block_publish_no_registry() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n publish = []\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --registry alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `foo` cannot be published.\n`package.publish` must be set to `true` or a non-empty list in Cargo.toml to publish.\n\n\"#]])\n .run();\n}\n\n// Explicitly setting `crates-io` in the publish list.\n#[cargo_test]\nfn publish_with_crates_io_explicit() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n publish = [\"crates-io\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --registry alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `foo` cannot be published.\nThe registry `alternative` is not listed in the `package.publish` value in Cargo.toml.\n\n\"#]])\n .run();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_with_select_features() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [features]\n required = []\n optional = []\n \"#,\n )\n .file(\n \"src/main.rs\",\n \"#[cfg(not(feature = \\\"required\\\"))]\n compile_error!(\\\"This crate requires `required` feature!\\\");\n fn main() {}\",\n )\n .build();\n\n p.cargo(\"publish --features required\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_with_all_features() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [features]\n required = []\n optional = []\n \"#,\n )\n .file(\n \"src/main.rs\",\n \"#[cfg(not(feature = \\\"required\\\"))]\n compile_error!(\\\"This crate requires `required` feature!\\\");\n fn main() {}\",\n )\n .build();\n\n p.cargo(\"publish --all-features\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_with_no_default_features() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [features]\n default = [\"required\"]\n required = []\n \"#,\n )\n .file(\n \"src/main.rs\",\n \"#[cfg(not(feature = \\\"required\\\"))]\n compile_error!(\\\"This crate requires `required` feature!\\\");\n fn main() {}\",\n )\n .build();\n\n p.cargo(\"publish --no-default-features\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\n[ERROR] This crate requires `required` feature!\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_with_patch() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n Package::new(\"bar\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n [dependencies]\n bar = \"1.0\"\n [patch.crates-io]\n bar = { path = \"bar\" }\n \"#,\n )\n .file(\n \"src/main.rs\",\n \"extern crate bar;\n fn main() {\n bar::newfunc();\n }\",\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"1.0.0\"))\n .file(\"bar/src/lib.rs\", \"pub fn newfunc() {}\")\n .build();\n\n // Check that it works with the patched crate.\n p.cargo(\"build\").run();\n\n // Check that verify fails with patched crate which has new functionality.\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\nerror[E0425]: cannot find function `newfunc` in crate `bar`\n...\n\"#]])\n .run();\n\n // Remove the usage of new functionality and try again.\n p.change_file(\"src/main.rs\", \"extern crate bar; pub fn main() {}\");\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n publish::validate_upload(\n r#\"\n {\n \"authors\": [],\n \"badges\": {},\n \"categories\": [],\n \"deps\": [\n {\n \"default_features\": true,\n \"features\": [],\n \"kind\": \"normal\",\n \"name\": \"bar\",\n \"optional\": false,\n \"target\": null,\n \"version_req\": \"^1.0\"\n }\n ],\n \"description\": \"foo\",\n \"documentation\": null,\n \"features\": {},\n \"homepage\": null,\n \"keywords\": [],\n \"license\": \"MIT\",\n \"license_file\": null,\n \"links\": null,\n \"name\": \"foo\",\n \"readme\": null,\n \"readme_file\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"vers\": \"0.0.1\"\n }\n \"#,\n \"foo-0.0.1.crate\",\n &[\"Cargo.lock\", \"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\"],\n );\n}\n\n#[cargo_test]\nfn publish_checks_for_token_before_verify() {\n let registry = registry::RegistryBuilder::new()\n .no_configure_token()\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // Assert upload token error before the package is verified\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] no token found, please run `cargo login`\nor use environment variable CARGO_REGISTRY_TOKEN\n\n\"#]])\n .with_stderr_does_not_contain(\"[VERIFYING] foo v0.0.1 ([CWD])\")\n .run();\n\n // Assert package verified successfully on dry run\n p.cargo(\"publish --dry-run\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] aborting upload due to dry run\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_with_bad_source() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [source.crates-io]\n replace-with = 'local-registry'\n\n [source.local-registry]\n local-registry = 'registry'\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] crates-io is replaced with non-remote-registry source registry `[ROOT]/foo/registry`;\ninclude `--registry crates-io` to use crates.io\n\n\"#]])\n .run();\n\n p.change_file(\n \".cargo/config.toml\",\n r#\"\n [source.crates-io]\n replace-with = \"vendored-sources\"\n\n [source.vendored-sources]\n directory = \"vendor\"\n \"#,\n );\n\n p.cargo(\"publish\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] crates-io is replaced with non-remote-registry source dir [ROOT]/foo/vendor;\ninclude `--registry crates-io` to use crates.io\n\n\"#]])\n .run();\n}\n\n// A dependency with both `git` and `version`.\n#[cargo_test]\nfn publish_git_with_version() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n Package::new(\"dep1\", \"1.0.1\")\n .file(\"src/lib.rs\", \"pub fn f() -> i32 {1}\")\n .publish();\n\n let git_project = git::new(\"dep1\", |project| {\n project\n .file(\"Cargo.toml\", &basic_manifest(\"dep1\", \"1.0.0\"))\n .file(\"src/lib.rs\", \"pub fn f() -> i32 {2}\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n authors = []\n edition = \"2018\"\n license = \"MIT\"\n description = \"foo\"\n\n [dependencies]\n dep1 = {{version = \"1.0\", git=\"{}\"}}\n \"#,\n git_project.url()\n ),\n )\n .file(\n \"src/main.rs\",\n r#\"\n pub fn main() {\n println!(\"{}\", dep1::f());\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run\")\n .with_stdout_data(str![[r#\"\n2\n\n\"#]])\n .run();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.1.0 ([ROOT]/foo)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.1.0 ([ROOT]/foo)\n[UPLOADED] foo v0.1.0 to registry `crates-io`\n[NOTE] waiting for foo v0.1.0 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.1.0 at registry `crates-io`\n\n\"#]])\n .run();\n\n publish::validate_upload_with_contents(\n r#\"\n {\n \"authors\": [],\n \"badges\": {},\n \"categories\": [],\n \"deps\": [\n {\n \"default_features\": true,\n \"features\": [],\n \"kind\": \"normal\",\n \"name\": \"dep1\",\n \"optional\": false,\n \"target\": null,\n \"version_req\": \"^1.0\"\n }\n ],\n \"description\": \"foo\",\n \"documentation\": null,\n \"features\": {},\n \"homepage\": null,\n \"keywords\": [],\n \"license\": \"MIT\",\n \"license_file\": null,\n \"links\": null,\n \"name\": \"foo\",\n \"readme\": null,\n \"readme_file\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"vers\": \"0.1.0\"\n }\n \"#,\n \"foo-0.1.0.crate\",\n &[\"Cargo.lock\", \"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\"],\n [\n (\n \"Cargo.toml\",\n // Check that only `version` is included in Cargo.toml.\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2018\"\nname = \"foo\"\nversion = \"0.1.0\"\nauthors = []\nbuild = false\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\nreadme = false\nlicense = \"MIT\"\n\n[[bin]]\nname = \"foo\"\npath = \"src/main.rs\"\n\n[dependencies.dep1]\nversion = \"1.0\"\n\n\"##]],\n ),\n (\n \"Cargo.lock\",\n // The important check here is that it is 1.0.1 in the registry.\n str![[r##\"\n# This file is automatically @generated by Cargo.\n# It is not intended for manual editing.\nversion = 4\n\n[[package]]\nname = \"dep1\"\nversion = \"1.0.1\"\nsource = \"registry+https://github.com/rust-lang/crates.io-index\"\nchecksum = \"[..]\"\n\n[[package]]\nname = \"foo\"\nversion = \"0.1.0\"\ndependencies = [\n \"dep1\",\n]\n\n\"##]],\n ),\n ],\n );\n}\n\n#[cargo_test]\nfn publish_dev_dep_stripping() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n Package::new(\"normal-only\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"optional-dep-feature\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"optional-namespaced\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"optional-renamed-dep-feature\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"optional-renamed-namespaced\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"build-only\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"normal-and-dev\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"target-normal-only\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"target-build-only\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n Package::new(\"target-normal-and-dev\", \"1.0.0\")\n .feature(\"cat\", &[])\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n\n\n [features]\n foo_feature = [\n \"normal-only/cat\",\n \"build-only/cat\",\n \"dev-only/cat\",\n \"renamed-dev-only01/cat\",\n \"normal-and-dev/cat\",\n \"target-normal-only/cat\",\n \"target-build-only/cat\",\n \"target-dev-only/cat\",\n \"target-normal-and-dev/cat\",\n \"optional-dep-feature/cat\",\n \"dep:optional-namespaced\",\n \"optional-renamed-dep-feature10/cat\",\n \"dep:optional-renamed-namespaced10\",\n ]\n\n [dependencies]\n normal-only = { version = \"1.0\", features = [\"cat\"] }\n normal-and-dev = { version = \"1.0\", features = [\"cat\"] }\n optional-dep-feature = { version = \"1.0\", features = [\"cat\"], optional = true }\n optional-namespaced = { version = \"1.0\", features = [\"cat\"], optional = true }\n optional-renamed-dep-feature10 = { version = \"1.0\", features = [\"cat\"], optional = true, package = \"optional-renamed-dep-feature\" }\n optional-renamed-namespaced10 = { version = \"1.0\", features = [\"cat\"], optional = true, package = \"optional-renamed-namespaced\" }\n\n [build-dependencies]\n build-only = { version = \"1.0\", features = [\"cat\"] }\n\n [dev-dependencies]\n dev-only = { path = \"../dev-only\", features = [\"cat\"] }\n renamed-dev-only01 = { path = \"../renamed-dev-only\", features = [\"cat\"], package = \"renamed-dev-only\" }\n normal-and-dev = { version = \"1.0\", features = [\"cat\"] }\n\n [target.'cfg(unix)'.dependencies]\n target-normal-only = { version = \"1.0\", features = [\"cat\"] }\n target-normal-and-dev = { version = \"1.0\", features = [\"cat\"] }\n\n [target.'cfg(unix)'.build-dependencies]\n target-build-only = { version = \"1.0\", features = [\"cat\"] }\n\n [target.'cfg(unix)'.dev-dependencies]\n target-dev-only = { path = \"../dev-only\", features = [\"cat\"] }\n target-normal-and-dev = { version = \"1.0\", features = [\"cat\"] }\n \"#,\n )\n .file(\"src/main.rs\", \"\")\n .file(\n \"dev-only/Cargo.toml\",\n r#\"\n [package]\n name = \"dev-only\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [features]\n cat = []\n \"#,\n )\n .file(\n \"dev-only/src/lib.rs\",\n r#\"\n #[cfg(feature = \"cat\")]\n pub fn cat() {}\n \"#,\n )\n .file(\n \"renamed-dev-only/Cargo.toml\",\n r#\"\n [package]\n name = \"renamed-dev-only\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [features]\n cat = []\n \"#,\n )\n .file(\n \"renamed-dev-only/src/lib.rs\",\n r#\"\n #[cfg(feature = \"cat\")]\n pub fn cat() {}\n \"#,\n )\n .build();\n\n p.cargo(\"publish --no-verify\")\n .env(\"RUSTFLAGS\", \"--cfg unix\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] foo v0.1.0 ([ROOT]/foo)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.1.0 ([ROOT]/foo)\n[UPLOADED] foo v0.1.0 to registry `crates-io`\n[NOTE] waiting for foo v0.1.0 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.1.0 at registry `crates-io`\n\n\"#]])\n .run();\n\n publish::validate_upload_with_contents(\n r#\"\n {\n \"authors\": [],\n \"badges\": {},\n \"categories\": [],\n \"deps\": [\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"normal\",\n \"name\": \"normal-and-dev\",\n \"optional\": false,\n \"target\": null,\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"normal\",\n \"name\": \"normal-only\",\n \"optional\": false,\n \"target\": null,\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"normal\",\n \"name\": \"optional-dep-feature\",\n \"optional\": true,\n \"target\": null,\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"normal\",\n \"name\": \"optional-namespaced\",\n \"optional\": true,\n \"target\": null,\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"explicit_name_in_toml\": \"optional-renamed-dep-feature10\",\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"normal\",\n \"name\": \"optional-renamed-dep-feature\",\n \"optional\": true,\n \"target\": null,\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"explicit_name_in_toml\": \"optional-renamed-namespaced10\",\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"normal\",\n \"name\": \"optional-renamed-namespaced\",\n \"optional\": true,\n \"target\": null,\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"dev\",\n \"name\": \"normal-and-dev\",\n \"optional\": false,\n \"target\": null,\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"build\",\n \"name\": \"build-only\",\n \"optional\": false,\n \"target\": null,\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"normal\",\n \"name\": \"target-normal-and-dev\",\n \"optional\": false,\n \"target\": \"cfg(unix)\",\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"normal\",\n \"name\": \"target-normal-only\",\n \"optional\": false,\n \"target\": \"cfg(unix)\",\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"build\",\n \"name\": \"target-build-only\",\n \"optional\": false,\n \"target\": \"cfg(unix)\",\n \"version_req\": \"^1.0\"\n },\n {\n \"default_features\": true,\n \"features\": [\n \"cat\"\n ],\n \"kind\": \"dev\",\n \"name\": \"target-normal-and-dev\",\n \"optional\": false,\n \"target\": \"cfg(unix)\",\n \"version_req\": \"^1.0\"\n }\n ],\n \"description\": \"foo\",\n \"documentation\": \"foo\",\n \"features\": {\n \"foo_feature\": [\n \"normal-only/cat\",\n \"build-only/cat\",\n \"normal-and-dev/cat\",\n \"target-normal-only/cat\",\n \"target-build-only/cat\",\n \"target-normal-and-dev/cat\",\n \"optional-dep-feature/cat\",\n \"dep:optional-namespaced\",\n \"optional-renamed-dep-feature10/cat\",\n \"dep:optional-renamed-namespaced10\"\n ]\n },\n \"homepage\": \"foo\",\n \"keywords\": [],\n \"license\": \"MIT\",\n \"license_file\": null,\n \"links\": null,\n \"name\": \"foo\",\n \"readme\": null,\n \"readme_file\": null,\n \"repository\": \"foo\",\n \"rust_version\": null,\n \"vers\": \"0.1.0\"\n }\n \"#,\n \"foo-0.1.0.crate\",\n &[\"Cargo.lock\", \"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\"],\n [(\n \"Cargo.toml\",\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2015\"\nname = \"foo\"\nversion = \"0.1.0\"\nauthors = []\nbuild = false\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\nhomepage = \"foo\"\ndocumentation = \"foo\"\nreadme = false\nlicense = \"MIT\"\nrepository = \"foo\"\n\n[features]\nfoo_feature = [\n \"normal-only/cat\",\n \"build-only/cat\",\n \"normal-and-dev/cat\",\n \"target-normal-only/cat\",\n \"target-build-only/cat\",\n \"target-normal-and-dev/cat\",\n \"optional-dep-feature/cat\",\n \"dep:optional-namespaced\",\n \"optional-renamed-dep-feature10/cat\",\n \"dep:optional-renamed-namespaced10\",\n]\n\n[[bin]]\nname = \"foo\"\npath = \"src/main.rs\"\n\n[dependencies.normal-and-dev]\nversion = \"1.0\"\nfeatures = [\"cat\"]\n\n[dependencies.normal-only]\nversion = \"1.0\"\nfeatures = [\"cat\"]\n\n[dependencies.optional-dep-feature]\nversion = \"1.0\"\nfeatures = [\"cat\"]\noptional = true\n\n[dependencies.optional-namespaced]\nversion = \"1.0\"\nfeatures = [\"cat\"]\noptional = true\n\n[dependencies.optional-renamed-dep-feature10]\nversion = \"1.0\"\nfeatures = [\"cat\"]\noptional = true\npackage = \"optional-renamed-dep-feature\"\n\n[dependencies.optional-renamed-namespaced10]\nversion = \"1.0\"\nfeatures = [\"cat\"]\noptional = true\npackage = \"optional-renamed-namespaced\"\n\n[dev-dependencies.normal-and-dev]\nversion = \"1.0\"\nfeatures = [\"cat\"]\n\n[build-dependencies.build-only]\nversion = \"1.0\"\nfeatures = [\"cat\"]\n\n[target.\"cfg(unix)\".dependencies.target-normal-and-dev]\nversion = \"1.0\"\nfeatures = [\"cat\"]\n\n[target.\"cfg(unix)\".dependencies.target-normal-only]\nversion = \"1.0\"\nfeatures = [\"cat\"]\n\n[target.\"cfg(unix)\".build-dependencies.target-build-only]\nversion = \"1.0\"\nfeatures = [\"cat\"]\n\n[target.\"cfg(unix)\".dev-dependencies.target-normal-and-dev]\nversion = \"1.0\"\nfeatures = [\"cat\"]\n\n\"##]],\n )],\n );\n}\n\n#[cargo_test]\nfn credentials_ambiguous_filename() {\n // `publish` generally requires a remote registry\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n // Make token in `credentials.toml` incorrect to ensure it is not read.\n let credentials_toml = paths::home().join(\".cargo/credentials.toml\");\n fs::write(credentials_toml, r#\"token = \"wrong-token\"\"#).unwrap();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\n Unauthorized message from server.\n\n\"#]])\n .run();\n\n // Favor `credentials` if exists.\n let credentials = paths::home().join(\".cargo/credentials\");\n fs::write(credentials, r#\"token = \"sekrit\"\"#).unwrap();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] both `[ROOT]/home/.cargo/credentials` and `[ROOT]/home/.cargo/credentials.toml` exist. Using `[ROOT]/home/.cargo/credentials`\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n// --index will not load registry.token to avoid possibly leaking\n// crates.io token to another server.\n#[cargo_test]\nfn index_requires_token() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let credentials = paths::home().join(\".cargo/credentials.toml\");\n fs::remove_file(&credentials).unwrap();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify --index\")\n .arg(registry.index_url().as_str())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] command-line argument --index requires --token to be specified\n\n\"#]])\n .run();\n}\n\n// publish with source replacement without --registry\n#[cargo_test]\nfn cratesio_source_replacement() {\n registry::init();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] crates-io is replaced with remote registry dummy-registry;\ninclude `--registry dummy-registry` or `--registry crates-io`\n\n\"#]])\n .run();\n}\n\n// Registry returns an API error.\n#[cargo_test]\nfn api_error_json() {\n let _registry = registry::RegistryBuilder::new()\n .alternative()\n .http_api()\n .add_responder(\"/api/v1/crates/new\", |_, _| Response {\n body: br#\"{\"errors\": [{\"detail\": \"you must be logged in\"}]}\"#.to_vec(),\n code: 403,\n headers: vec![],\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify --registry alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] failed to publish foo v0.0.1 to registry at http://127.0.0.1:[..]/\n\nCaused by:\n the remote server responded with an error (status 403 Forbidden): you must be logged in\n\n\"#]])\n .run();\n}\n\n// Registry returns an API error with a 200 status code.\n#[cargo_test]\nfn api_error_200() {\n let _registry = registry::RegistryBuilder::new()\n .alternative()\n .http_api()\n .add_responder(\"/api/v1/crates/new\", |_, _| Response {\n body: br#\"{\"errors\": [{\"detail\": \"max upload size is 123\"}]}\"#.to_vec(),\n code: 200,\n headers: vec![],\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify --registry alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] failed to publish foo v0.0.1 to registry at http://127.0.0.1:[..]/\n\nCaused by:\n the remote server responded with an [ERROR] max upload size is 123\n\n\"#]])\n .run();\n}\n\n// Registry returns an error code without a JSON message.\n#[cargo_test]\nfn api_error_code() {\n let _registry = registry::RegistryBuilder::new()\n .alternative()\n .http_api()\n .add_responder(\"/api/v1/crates/new\", |_, _| Response {\n body: br#\"go away\"#.to_vec(),\n code: 400,\n headers: vec![],\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify --registry alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] failed to publish foo v0.0.1 to registry at http://127.0.0.1:[..]/\n\nCaused by:\n failed to get a 200 OK response, got 400\n headers:\n \tHTTP/1.1 400\n \tContent-Length: 7\n \tConnection: close\n \t\n body:\n go away\n\n\"#]])\n .run();\n}\n\n// Registry has a network error.\n#[cargo_test]\nfn api_curl_error() {\n let _registry = registry::RegistryBuilder::new()\n .alternative()\n .http_api()\n .add_responder(\"/api/v1/crates/new\", |_, _| {\n panic!(\"broke\");\n })\n .build();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n // This doesn't check for the exact text of the error in the remote\n // possibility that cargo is linked with a weird version of libcurl, or\n // curl changes the text of the message. Currently the message 52\n // (CURLE_GOT_NOTHING) is:\n // Server returned nothing (no headers, no data) (Empty reply from server)\n p.cargo(\"publish --no-verify --registry alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] failed to publish foo v0.0.1 to registry at http://127.0.0.1:[..]/\n\nCaused by:\n [52] Server returned nothing (no headers, no data) (Empty reply from server)\n\n\"#]])\n .run();\n}\n\n// Registry returns an invalid response.\n#[cargo_test]\nfn api_other_error() {\n let _registry = registry::RegistryBuilder::new()\n .alternative()\n .http_api()\n .add_responder(\"/api/v1/crates/new\", |_, _| Response {\n body: b\"\\xff\".to_vec(),\n code: 200,\n headers: vec![],\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify --registry alternative\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] failed to publish foo v0.0.1 to registry at http://127.0.0.1:[..]/\n\nCaused by:\n invalid response body from server\n\nCaused by:\n invalid utf-8 sequence of 1 bytes from index 0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn in_package_workspace() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n [workspace]\n members = [\"li\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"li/Cargo.toml\",\n r#\"\n [package]\n name = \"li\"\n version = \"0.0.1\"\n edition = \"2015\"\n rust-version = \"1.69\"\n description = \"li\"\n license = \"MIT\"\n \"#,\n )\n .file(\"li/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish -p li --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] li v0.0.1 ([ROOT]/foo/li)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] li v0.0.1 ([ROOT]/foo/li)\n[UPLOADED] li v0.0.1 to registry `crates-io`\n[NOTE] waiting for li v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] li v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n validate_upload_li();\n}\n\n#[cargo_test]\nfn with_duplicate_spec_in_members() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n [workspace]\n resolver = \"2\"\n members = [\"li\",\"bar\"]\n default-members = [\"li\",\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"li/Cargo.toml\",\n r#\"\n [package]\n name = \"li\"\n version = \"0.0.1\"\n edition = \"2015\"\n description = \"li\"\n license = \"MIT\"\n \"#,\n )\n .file(\"li/src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n description = \"bar\"\n license = \"MIT\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] bar v0.0.1 ([ROOT]/foo/bar)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] li v0.0.1 ([ROOT]/foo/li)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] bar v0.0.1 ([ROOT]/foo/bar)\n[UPLOADED] bar v0.0.1 to registry `crates-io`\n[UPLOADING] li v0.0.1 ([ROOT]/foo/li)\n[UPLOADED] li v0.0.1 to registry `crates-io`\n[NOTE] waiting for bar v0.0.1 or li v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crates should be available shortly\n[PUBLISHED] bar v0.0.1 and li v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn in_package_workspace_with_members_with_features_old() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n [workspace]\n members = [\"li\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"li/Cargo.toml\",\n r#\"\n [package]\n name = \"li\"\n version = \"0.0.1\"\n edition = \"2015\"\n rust-version = \"1.69\"\n description = \"li\"\n license = \"MIT\"\n \"#,\n )\n .file(\"li/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish -p li --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] li v0.0.1 ([ROOT]/foo/li)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] li v0.0.1 ([ROOT]/foo/li)\n[UPLOADED] li v0.0.1 to registry `crates-io`\n[NOTE] waiting for li v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] li v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n validate_upload_li();\n}\n\n#[cargo_test]\nfn in_virtual_workspace() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\"]\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"foo/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn in_virtual_workspace_with_p() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\",\"li\"]\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"foo/src/main.rs\", \"fn main() {}\")\n .file(\n \"li/Cargo.toml\",\n r#\"\n [package]\n name = \"li\"\n version = \"0.0.1\"\n edition = \"2015\"\n rust-version = \"1.69\"\n description = \"li\"\n license = \"MIT\"\n \"#,\n )\n .file(\"li/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish -p li --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] li v0.0.1 ([ROOT]/foo/li)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] li v0.0.1 ([ROOT]/foo/li)\n[UPLOADED] li v0.0.1 to registry `crates-io`\n[NOTE] waiting for li v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] li v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn in_package_workspace_not_found() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n [workspace]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"li/Cargo.toml\",\n r#\"\n [package]\n name = \"li\"\n version = \"0.0.1\"\n edition = \"2021\"\n authors = []\n license = \"MIT\"\n description = \"li\"\n \"#,\n )\n .file(\"li/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish -p li --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specification `li` did not match any packages\n\n[HELP] a package with a similar name exists: `foo`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn in_package_workspace_found_multiple() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n [workspace]\n members = [\"li\",\"lii\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"li/Cargo.toml\",\n r#\"\n [package]\n name = \"li\"\n version = \"0.0.1\"\n edition = \"2021\"\n authors = []\n license = \"MIT\"\n description = \"li\"\n \"#,\n )\n .file(\"li/src/main.rs\", \"fn main() {}\")\n .file(\n \"lii/Cargo.toml\",\n r#\"\n [package]\n name = \"lii\"\n version = \"0.0.1\"\n edition = \"2021\"\n authors = []\n license = \"MIT\"\n description = \"lii\"\n \"#,\n )\n .file(\"lii/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish -p li* --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] li v0.0.1 ([ROOT]/foo/li)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] lii v0.0.1 ([ROOT]/foo/lii)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] li v0.0.1 ([ROOT]/foo/li)\n[UPLOADED] li v0.0.1 to registry `crates-io`\n[UPLOADING] lii v0.0.1 ([ROOT]/foo/lii)\n[UPLOADED] lii v0.0.1 to registry `crates-io`\n[NOTE] waiting for li v0.0.1 or lii v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crates should be available shortly\n[PUBLISHED] li v0.0.1 and lii v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_path_dependency_without_workspace() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n [dependencies.bar]\n path = \"bar\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2021\"\n authors = []\n license = \"MIT\"\n description = \"bar\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish -p bar --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specification `bar` did not match any packages\n\n[HELP] a package with a similar name exists: `foo`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn http_api_not_noop() {\n let registry = registry::RegistryBuilder::new().http_api().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [project]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [dependencies]\n foo = \"0.0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build\").run();\n}\n\n#[cargo_test]\nfn wait_for_first_publish() {\n // Counter for number of tries before the package is \"published\"\n let arc: Arc> = Arc::new(Mutex::new(0));\n let arc2 = arc.clone();\n\n // Registry returns an invalid response.\n let registry = registry::RegistryBuilder::new()\n .http_index()\n .http_api()\n .add_responder(\"/index/de/la/delay\", move |req, server| {\n let mut lock = arc.lock().unwrap();\n *lock += 1;\n if *lock <= 1 {\n server.not_found(req)\n } else {\n server.index(req)\n }\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"delay\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(0)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] delay v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] delay v0.0.1 ([ROOT]/foo)\n[UPLOADED] delay v0.0.1 to registry `crates-io`\n[NOTE] waiting for delay v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] delay v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Verify the responder has been pinged\n let lock = arc2.lock().unwrap();\n assert_eq!(*lock, 2);\n drop(lock);\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n [dependencies]\n delay = \"0.0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build\").with_status(0).run();\n}\n\n/// A separate test is needed for package names with - or _ as they hit\n/// the responder twice per cargo invocation. If that ever gets changed\n/// this test will need to be changed accordingly.\n#[cargo_test]\nfn wait_for_first_publish_underscore() {\n // Counter for number of tries before the package is \"published\"\n let arc: Arc> = Arc::new(Mutex::new(0));\n let arc2 = arc.clone();\n let misses = Arc::new(Mutex::new(Vec::new()));\n let misses2 = misses.clone();\n\n // Registry returns an invalid response.\n let registry = registry::RegistryBuilder::new()\n .http_index()\n .http_api()\n .add_responder(\"/index/de/la/delay_with_underscore\", move |req, server| {\n let mut lock = arc.lock().unwrap();\n *lock += 1;\n if *lock <= 1 {\n server.not_found(req)\n } else {\n server.index(req)\n }\n })\n .not_found_handler(move |req, _| {\n misses.lock().unwrap().push(req.url.to_string());\n Response {\n body: b\"not found\".to_vec(),\n code: 404,\n headers: vec![],\n }\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"delay_with_underscore\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(0)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] delay_with_underscore v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] delay_with_underscore v0.0.1 ([ROOT]/foo)\n[UPLOADED] delay_with_underscore v0.0.1 to registry `crates-io`\n[NOTE] waiting for delay_with_underscore v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] delay_with_underscore v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Verify the repsponder has been pinged\n let lock = arc2.lock().unwrap();\n assert_eq!(*lock, 2);\n drop(lock);\n {\n let misses = misses2.lock().unwrap();\n assert!(\n misses.len() == 1,\n \"should only have 1 not found URL; instead found {misses:?}\"\n );\n }\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n [dependencies]\n delay_with_underscore = \"0.0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build\").with_status(0).run();\n}\n\n#[cargo_test]\nfn wait_for_subsequent_publish() {\n // Counter for number of tries before the package is \"published\"\n let arc: Arc> = Arc::new(Mutex::new(0));\n let arc2 = arc.clone();\n let publish_req = Arc::new(Mutex::new(None));\n let publish_req2 = publish_req.clone();\n\n let registry = registry::RegistryBuilder::new()\n .http_index()\n .http_api()\n .add_responder(\"/api/v1/crates/new\", move |req, server| {\n // Capture the publish request, but defer publishing\n *publish_req.lock().unwrap() = Some(req.clone());\n server.ok(req)\n })\n .add_responder(\"/index/de/la/delay\", move |req, server| {\n let mut lock = arc.lock().unwrap();\n *lock += 1;\n if *lock == 3 {\n // Run the publish on the 3rd attempt\n let rep = server\n .check_authorized_publish(&publish_req2.lock().unwrap().as_ref().unwrap());\n assert_eq!(rep.code, 200);\n }\n server.index(req)\n })\n .build();\n\n // Publish an earlier version\n Package::new(\"delay\", \"0.0.1\")\n .file(\"src/lib.rs\", \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"delay\"\n version = \"0.0.2\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(0)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] delay v0.0.2 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] delay v0.0.2 ([ROOT]/foo)\n[UPLOADED] delay v0.0.2 to registry `crates-io`\n[NOTE] waiting for delay v0.0.2 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] delay v0.0.2 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Verify the responder has been pinged\n let lock = arc2.lock().unwrap();\n assert_eq!(*lock, 3);\n drop(lock);\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n [dependencies]\n delay = \"0.0.2\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\").with_status(0).run();\n}\n\n#[cargo_test]\nfn skip_wait_for_publish() {\n // Intentionally using local registry so the crate never makes it to the index\n let registry = registry::init();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n \"\n [publish]\n timeout = 0\n \",\n )\n .build();\n\n p.cargo(\"publish --no-verify -Zpublish-timeout\")\n .replace_crates_io(registry.index_url())\n .masquerade_as_nightly_cargo(&[\"publish-timeout\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn timeout_waiting_for_publish() {\n // Publish doesn't happen within the timeout window.\n let registry = registry::RegistryBuilder::new()\n .http_api()\n .delayed_index_update(20)\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"delay\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [publish]\n timeout = 2\n \"#,\n )\n .build();\n\n p.cargo(\"publish --no-verify -Zpublish-timeout\")\n .replace_crates_io(registry.index_url())\n .masquerade_as_nightly_cargo(&[\"publish-timeout\"])\n .with_status(0)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] delay v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] delay v0.0.1 ([ROOT]/foo)\n[UPLOADED] delay v0.0.1 to registry `crates-io`\n[NOTE] waiting for delay v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[WARNING] timed out waiting for delay v0.0.1 to be available in registry `crates-io`\n |\n = [NOTE] the registry may have a backlog that is delaying making the crate available. The crate should be available soon.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn timeout_waiting_for_dependency_publish() {\n // Publish doesn't happen within the timeout window.\n let registry = registry::RegistryBuilder::new()\n .http_api()\n .delayed_index_update(20)\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"main\", \"other\", \"dep\"]\n \"#,\n )\n .file(\n \"main/Cargo.toml\",\n r#\"\n [package]\n name = \"main\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [dependencies]\n dep = { version = \"0.0.1\", path = \"../dep\" }\n \"#,\n )\n .file(\"main/src/main.rs\", \"fn main() {}\")\n .file(\n \"other/Cargo.toml\",\n r#\"\n [package]\n name = \"other\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [dependencies]\n dep = { version = \"0.0.1\", path = \"../dep\" }\n \"#,\n )\n .file(\"other/src/main.rs\", \"fn main() {}\")\n .file(\n \"dep/Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"dep/src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [publish]\n timeout = 2\n \"#,\n )\n .build();\n\n p.cargo(\"publish --no-verify -Zpublish-timeout\")\n .replace_crates_io(registry.index_url())\n .masquerade_as_nightly_cargo(&[\"publish-timeout\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] dep v0.0.1 ([ROOT]/foo/dep)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] main v0.0.1 ([ROOT]/foo/main)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] other v0.0.1 ([ROOT]/foo/other)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] dep v0.0.1 ([ROOT]/foo/dep)\n[UPLOADED] dep v0.0.1 to registry `crates-io`\n[NOTE] waiting for dep v0.0.1 to be available at registry `crates-io`.\n 2 remaining crates to be published\n[WARNING] timed out waiting for dep v0.0.1 to be available in registry `crates-io`\n |\n = [NOTE] the registry may have a backlog that is delaying making the crate available. The crate should be available soon.\n[ERROR] unable to publish main v0.0.1 and other v0.0.1 due to a timeout while waiting for published dependencies to be available.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn package_selection() {\n let registry = registry::RegistryBuilder::new().http_api().build();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\"]\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"#[test] fn a() {}\")\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.1.0\"))\n .file(\"b/src/lib.rs\", \"#[test] fn b() {}\")\n .build();\n\n p.cargo(\"publish --no-verify --dry-run --workspace\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no description, license, license-file, documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] a v0.1.0 ([ROOT]/foo/a)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[WARNING] manifest has no description, license, license-file, documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] b v0.1.0 ([ROOT]/foo/b)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] a v0.1.0 ([ROOT]/foo/a)\n[WARNING] aborting upload due to dry run\n[UPLOADING] b v0.1.0 ([ROOT]/foo/b)\n[WARNING] aborting upload due to dry run\n\n\"#]])\n .with_stdout_data(str![[r#\"\"#]])\n .run();\n\n p.cargo(\"publish --no-verify --dry-run --package a --package b\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no description, license, license-file, documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] a v0.1.0 ([ROOT]/foo/a)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[WARNING] manifest has no description, license, license-file, documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] b v0.1.0 ([ROOT]/foo/b)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] a v0.1.0 ([ROOT]/foo/a)\n[WARNING] aborting upload due to dry run\n[UPLOADING] b v0.1.0 ([ROOT]/foo/b)\n[WARNING] aborting upload due to dry run\n\n\"#]])\n .with_stdout_data(str![[r#\"\"#]])\n .run();\n\n p.cargo(\"publish --no-verify --dry-run --workspace --exclude b\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no description, license, license-file, documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] a v0.1.0 ([ROOT]/foo/a)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] a v0.1.0 ([ROOT]/foo/a)\n[WARNING] aborting upload due to dry run\n\n\"#]])\n .with_stdout_data(str![[r#\"\"#]])\n .run();\n}\n\n#[cargo_test]\nfn wait_for_git_publish() {\n // Slow publish to an index with a git index.\n let registry = registry::RegistryBuilder::new()\n .http_api()\n .delayed_index_update(5)\n .build();\n\n // Publish an earlier version\n Package::new(\"delay\", \"0.0.1\")\n .file(\"src/lib.rs\", \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"delay\"\n version = \"0.0.2\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(0)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] delay v0.0.2 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] delay v0.0.2 ([ROOT]/foo)\n[UPLOADED] delay v0.0.2 to registry `crates-io`\n[NOTE] waiting for delay v0.0.2 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] delay v0.0.2 at registry `crates-io`\n\n\"#]])\n .run();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n [dependencies]\n delay = \"0.0.2\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\").with_status(0).run();\n}\n\n#[cargo_test]\nfn invalid_token() {\n // Checks publish behavior with an invalid token.\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .env(\"CARGO_REGISTRY_TOKEN\", \"\\x16\")\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] failed to publish foo v0.0.1 to registry at http://127.0.0.1:[..]/\n\nCaused by:\n token contains invalid characters.\n Only printable ISO-8859-1 characters are allowed as it is sent in a HTTPS header.\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn versionless_package() {\n // Use local registry for faster test times since no publish will occur\n let registry = registry::init();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `foo` cannot be published.\n`package.publish` must be set to `true` or a non-empty list in Cargo.toml to publish.\n\n\"#]])\n .run();\n}\n\n// A workspace with three projects that depend on one another (level1 -> level2 -> level3).\n// level1 is a binary package, to test lockfile generation.\nfn workspace_with_local_deps_project() -> Project {\n project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"level1\", \"level2\", \"level3\"]\n\n [workspace.dependencies]\n level2 = { path = \"level2\", version = \"0.0.1\" }\n \"#\n )\n .file(\n \"level1/Cargo.toml\",\n r#\"\n [package]\n name = \"level1\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"level1\"\n repository = \"bar\"\n\n [dependencies]\n # Let one dependency also specify features, for the added test coverage when generating package files.\n level2 = { workspace = true, features = [\"foo\"] }\n \"#,\n )\n .file(\"level1/src/main.rs\", \"fn main() {}\")\n .file(\n \"level2/Cargo.toml\",\n r#\"\n [package]\n name = \"level2\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"level2\"\n repository = \"bar\"\n\n [features]\n foo = []\n\n [dependencies]\n level3 = { path = \"../level3\", version = \"0.0.1\" }\n \"#\n )\n .file(\"level2/src/lib.rs\", \"\")\n .file(\n \"level3/Cargo.toml\",\n r#\"\n [package]\n name = \"level3\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"level3\"\n repository = \"bar\"\n \"#,\n )\n .file(\"level3/src/lib.rs\", \"\")\n .build()\n}\n\n#[cargo_test]\nfn workspace_with_local_deps() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n let p = workspace_with_local_deps_project();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] level3 v0.0.1 ([ROOT]/foo/level3)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] level2 v0.0.1 ([ROOT]/foo/level2)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] level3 v0.0.1 ([ROOT]/foo/level3)\n[COMPILING] level3 v0.0.1 ([ROOT]/foo/target/package/level3-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[VERIFYING] level2 v0.0.1 ([ROOT]/foo/level2)\n[UPDATING] crates.io index\n[UNPACKING] level3 v0.0.1 (registry `[ROOT]/foo/target/package/tmp-registry`)\n[COMPILING] level3 v0.0.1\n[COMPILING] level2 v0.0.1 ([ROOT]/foo/target/package/level2-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[VERIFYING] level1 v0.0.1 ([ROOT]/foo/level1)\n[UPDATING] crates.io index\n[UNPACKING] level2 v0.0.1 (registry `[ROOT]/foo/target/package/tmp-registry`)\n[COMPILING] level2 v0.0.1\n[COMPILING] level1 v0.0.1 ([ROOT]/foo/target/package/level1-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] level3 v0.0.1 ([ROOT]/foo/level3)\n[UPLOADED] level3 v0.0.1 to registry `crates-io`\n[NOTE] waiting for level3 v0.0.1 to be available at registry `crates-io`.\n 2 remaining crates to be published\n[PUBLISHED] level3 v0.0.1 at registry `crates-io`\n[UPLOADING] level2 v0.0.1 ([ROOT]/foo/level2)\n[UPLOADED] level2 v0.0.1 to registry `crates-io`\n[NOTE] waiting for level2 v0.0.1 to be available at registry `crates-io`.\n 1 remaining crate to be published\n[PUBLISHED] level2 v0.0.1 at registry `crates-io`\n[UPLOADING] level1 v0.0.1 ([ROOT]/foo/level1)\n[UPLOADED] level1 v0.0.1 to registry `crates-io`\n[NOTE] waiting for level1 v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] level1 v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn workspace_parallel() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\", \"c\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"a\"\n repository = \"bar\"\n \"#,\n )\n .file(\"a/src/lib.rs\", \"\")\n .file(\n \"b/Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"b\"\n repository = \"bar\"\n \"#,\n )\n .file(\"b/src/lib.rs\", \"\")\n .file(\n \"c/Cargo.toml\",\n r#\"\n [package]\n name = \"c\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"c\"\n repository = \"bar\"\n\n [dependencies]\n a = { path = \"../a\", version = \"0.0.1\" }\n b = { path = \"../b\", version = \"0.0.1\" }\n \"#,\n )\n .file(\"c/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(\n str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] a v0.0.1 ([ROOT]/foo/a)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] b v0.0.1 ([ROOT]/foo/b)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] c v0.0.1 ([ROOT]/foo/c)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] a v0.0.1 ([ROOT]/foo/a)\n[COMPILING] a v0.0.1 ([ROOT]/foo/target/package/a-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[VERIFYING] b v0.0.1 ([ROOT]/foo/b)\n[COMPILING] b v0.0.1 ([ROOT]/foo/target/package/b-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[VERIFYING] c v0.0.1 ([ROOT]/foo/c)\n[UPDATING] crates.io index\n[UNPACKING] a v0.0.1 (registry `[ROOT]/foo/target/package/tmp-registry`)\n[UNPACKING] b v0.0.1 (registry `[ROOT]/foo/target/package/tmp-registry`)\n[COMPILING] a v0.0.1\n[COMPILING] b v0.0.1\n[COMPILING] c v0.0.1 ([ROOT]/foo/target/package/c-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADED] b v0.0.1 to registry `crates-io`\n[UPLOADED] a v0.0.1 to registry `crates-io`\n[NOTE] waiting for a v0.0.1 or b v0.0.1 to be available at registry `crates-io`.\n 1 remaining crate to be published\n[PUBLISHED] a v0.0.1 and b v0.0.1 at registry `crates-io`\n[UPLOADING] c v0.0.1 ([ROOT]/foo/c)\n[UPLOADED] c v0.0.1 to registry `crates-io`\n[NOTE] waiting for c v0.0.1 to be available at registry `crates-io`\n[PUBLISHED] c v0.0.1 at registry `crates-io`\n[UPLOADING] a v0.0.1 ([ROOT]/foo/a)\n[UPLOADING] b v0.0.1 ([ROOT]/foo/b)\n[UPDATING] crates.io index\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn workspace_missing_dependency() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"a\"\n repository = \"bar\"\n \"#,\n )\n .file(\"a/src/lib.rs\", \"\")\n .file(\n \"b/Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"b\"\n repository = \"bar\"\n\n [dependencies]\n a = { path = \"../a\", version = \"0.0.1\" }\n \"#,\n )\n .file(\"b/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish -p b\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] b v0.0.1 ([ROOT]/foo/b)\n[UPDATING] crates.io index\n[ERROR] failed to prepare local package for uploading\n\nCaused by:\n no matching package named `a` found\n location searched: crates.io index\n required by package `b v0.0.1 ([ROOT]/foo/b)`\n\n\"#]])\n .run();\n\n p.cargo(\"publish -p a\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] a v0.0.1 ([ROOT]/foo/a)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] a v0.0.1 ([ROOT]/foo/a)\n[COMPILING] a v0.0.1 ([ROOT]/foo/target/package/a-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] a v0.0.1 ([ROOT]/foo/a)\n[UPLOADED] a v0.0.1 to registry `crates-io`\n[NOTE] waiting for a v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] a v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n\n // Publishing the whole workspace now will fail, as `a` is already published.\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] crate a@0.0.1 already exists on crates.io index\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn one_unpublishable_package() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"dep\", \"main\"]\n \"#,\n )\n .file(\n \"main/Cargo.toml\",\n r#\"\n [package]\n name = \"main\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"main\"\n repository = \"bar\"\n publish = false\n\n [dependencies]\n dep = { path = \"../dep\", version = \"0.1.0\" }\n \"#,\n )\n .file(\"main/src/main.rs\", \"fn main() {}\")\n .file(\n \"dep/Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"dep\"\n repository = \"bar\"\n \"#,\n )\n .file(\"dep/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] dep v0.1.0 ([ROOT]/foo/dep)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] dep v0.1.0 ([ROOT]/foo/dep)\n[COMPILING] dep v0.1.0 ([ROOT]/foo/target/package/dep-0.1.0)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] dep v0.1.0 ([ROOT]/foo/dep)\n[UPLOADED] dep v0.1.0 to registry `crates-io`\n[NOTE] waiting for dep v0.1.0 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] dep v0.1.0 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn virtual_ws_with_multiple_unpublishable_package() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"dep\", \"main\", \"publishable\"]\n \"#,\n )\n .file(\n \"main/Cargo.toml\",\n r#\"\n [package]\n name = \"main\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"main\"\n repository = \"bar\"\n publish = false\n\n [dependencies]\n dep = { path = \"../dep\", version = \"0.1.0\" }\n \"#,\n )\n .file(\"main/src/main.rs\", \"fn main() {}\")\n .file(\n \"dep/Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"dep\"\n repository = \"bar\"\n publish = false\n \"#,\n )\n .file(\"dep/src/lib.rs\", \"\")\n .file(\n \"publishable/Cargo.toml\",\n r#\"\n [package]\n name = \"publishable\"\n version = \"0.1.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"publishable/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] publishable v0.1.0 ([ROOT]/foo/publishable)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] publishable v0.1.0 ([ROOT]/foo/publishable)\n[COMPILING] publishable v0.1.0 ([ROOT]/foo/target/package/publishable-0.1.0)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] publishable v0.1.0 ([ROOT]/foo/publishable)\n[UPLOADED] publishable v0.1.0 to registry `crates-io`\n[NOTE] waiting for publishable v0.1.0 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] publishable v0.1.0 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn workspace_flag_with_unpublishable_packages() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"publishable\", \"non-publishable\"]\n\n [package]\n name = \"cwd\"\n version = \"0.0.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n repository = \"foo\"\n publish = false\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"publishable/Cargo.toml\",\n r#\"\n [package]\n name = \"publishable\"\n version = \"0.0.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n repository = \"foo\"\n publish = true\n \"#,\n )\n .file(\"publishable/src/lib.rs\", \"\")\n .file(\n \"non-publishable/Cargo.toml\",\n r#\"\n [package]\n name = \"non-publishable\"\n version = \"0.0.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n repository = \"foo\"\n publish = false\n \"#,\n )\n .file(\"non-publishable/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --workspace\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] publishable v0.0.0 ([ROOT]/foo/publishable)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] publishable v0.0.0 ([ROOT]/foo/publishable)\n[COMPILING] publishable v0.0.0 ([ROOT]/foo/target/package/publishable-0.0.0)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] publishable v0.0.0 ([ROOT]/foo/publishable)\n[UPLOADED] publishable v0.0.0 to registry `crates-io`\n[NOTE] waiting for publishable v0.0.0 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] publishable v0.0.0 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn unpublishable_package_as_versioned_dev_dep() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"dep\", \"main\"]\n \"#,\n )\n .file(\n \"main/Cargo.toml\",\n r#\"\n [package]\n name = \"main\"\n version = \"0.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"main\"\n repository = \"bar\"\n\n [dev-dependencies]\n dep = { path = \"../dep\", version = \"0.1.0\" }\n \"#,\n )\n .file(\"main/src/main.rs\", \"fn main() {}\")\n .file(\n \"dep/Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.1.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"dep\"\n repository = \"bar\"\n publish = false\n \"#,\n )\n .file(\"dep/src/lib.rs\", \"\")\n .build();\n\n // It is expected to find the versioned dev dep not being published,\n // regardless with `--dry-run` or `--no-verify`.\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] main v0.0.1 ([ROOT]/foo/main)\n[UPDATING] crates.io index\n[ERROR] failed to prepare local package for uploading\n\nCaused by:\n no matching package named `dep` found\n location searched: crates.io index\n required by package `main v0.0.1 ([ROOT]/foo/main)`\n\n\"#]])\n .run();\n\n p.cargo(\"publish --dry-run\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] main v0.0.1 ([ROOT]/foo/main)\n[UPDATING] crates.io index\n[ERROR] failed to prepare local package for uploading\n\nCaused by:\n no matching package named `dep` found\n location searched: crates.io index\n required by package `main v0.0.1 ([ROOT]/foo/main)`\n\n\"#]])\n .run();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] main v0.0.1 ([ROOT]/foo/main)\n[UPDATING] crates.io index\n[ERROR] failed to prepare local package for uploading\n\nCaused by:\n no matching package named `dep` found\n location searched: crates.io index\n required by package `main v0.0.1 ([ROOT]/foo/main)`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn all_unpublishable_packages() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"non-publishable1\", \"non-publishable2\"]\n \"#,\n )\n .file(\n \"non-publishable1/Cargo.toml\",\n r#\"\n [package]\n name = \"non-publishable1\"\n version = \"0.0.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n repository = \"foo\"\n publish = false\n \"#,\n )\n .file(\"non-publishable1/src/lib.rs\", \"\")\n .file(\n \"non-publishable2/Cargo.toml\",\n r#\"\n [package]\n name = \"non-publishable2\"\n version = \"0.0.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n repository = \"foo\"\n publish = false\n \"#,\n )\n .file(\"non-publishable2/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --workspace\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[WARNING] nothing to publish, but found 2 unpublishable packages\n |\n = [HELP] to publish packages, set `package.publish` to `true` or a non-empty list\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn checksum_changed() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n Package::new(\"dep\", \"1.0.0\").publish();\n Package::new(\"transitive\", \"1.0.0\")\n .dep(\"dep\", \"1.0.0\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"dep\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n\n [dependencies]\n dep = { path = \"./dep\", version = \"1.0.0\" }\n transitive = \"1.0.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"dep/Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"1.0.0\"\n edition = \"2015\"\n \"#,\n )\n .file(\"dep/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n p.cargo(\"publish --dry-run --workspace\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] crate dep@1.0.0 already exists on crates.io index\n[WARNING] manifest has no description, license, license-file, documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] dep v1.0.0 ([ROOT]/foo/dep)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] dep v1.0.0 ([ROOT]/foo/dep)\n[COMPILING] dep v1.0.0 ([ROOT]/foo/target/package/dep-1.0.0)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[UNPACKING] dep v1.0.0 (registry `[ROOT]/foo/target/package/tmp-registry`)\n[COMPILING] dep v1.0.0\n[COMPILING] transitive v1.0.0\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] dep v1.0.0 ([ROOT]/foo/dep)\n[WARNING] aborting upload due to dry run\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] aborting upload due to dry run\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn workspace_publish_rate_limit_error() {\n let registry = registry::RegistryBuilder::new()\n .http_api()\n .http_index()\n .add_responder(\"/api/v1/crates/new\", |_req, _| {\n // For simplicity, let's just return rate limit error for all requests\n // This simulates hitting rate limit during workspace publish\n Response {\n code: 429,\n headers: vec![\"Retry-After: 3600\".to_string()],\n body: format!(\n \"You have published too many new crates in a short period of time. Please try again after Fri, 18 Jul 2025 20:00:34 GMT or email help@crates.io to have your limit increased.\"\n ).into_bytes(),\n }\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"package_a\", \"package_b\", \"package_c\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"package_a/Cargo.toml\",\n r#\"\n [package]\n name = \"package_a\"\n version = \"0.1.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"package a\"\n repository = \"https://github.com/test/package_a\"\n \"#,\n )\n .file(\"package_a/src/lib.rs\", \"\")\n .file(\n \"package_b/Cargo.toml\",\n r#\"\n [package]\n name = \"package_b\"\n version = \"0.1.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"package b\"\n repository = \"https://github.com/test/package_b\"\n \"#,\n )\n .file(\"package_b/src/lib.rs\", \"\")\n .file(\n \"package_c/Cargo.toml\",\n r#\"\n [package]\n name = \"package_c\"\n version = \"0.1.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"package c\"\n repository = \"https://github.com/test/package_c\"\n\n [dependencies]\n package_a = { version = \"0.1.0\", path = \"../package_a\" }\n \"#,\n )\n .file(\"package_c/src/lib.rs\", \"\")\n .build();\n\n // This demonstrates the improved error message after the fix\n // The user now knows which package failed and what packages remain to be published\n p.cargo(\"publish --workspace --no-verify\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] package_a v0.1.0 ([ROOT]/foo/package_a)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] package_b v0.1.0 ([ROOT]/foo/package_b)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] package_c v0.1.0 ([ROOT]/foo/package_c)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[UPLOADING] package_a v0.1.0 ([ROOT]/foo/package_a)\n[ERROR] failed to publish package_a v0.1.0 to registry at http://127.0.0.1:[..]/\n\n[NOTE] the following crates have not been published yet:\n package_b v0.1.0 ([ROOT]/foo/package_b)\n package_c v0.1.0 ([ROOT]/foo/package_c)\n\nCaused by:\n failed to get a 200 OK response, got 429\n headers:\n \tHTTP/1.1 429\n \tContent-Length: 172\n \tConnection: close\n \tRetry-After: 3600\n \t\n body:\n You have published too many new crates in a short period of time. Please try again after Fri, 18 Jul 2025 20:00:34 GMT or email help@crates.io to have your limit increased.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn workspace_circular_publish_dependency() {\n // Verify detection and reporting of workspace circular dependencies.\n let registry = registry::RegistryBuilder::new()\n .http_api()\n .http_index()\n .build();\n\n cargo_test_support::registry::Package::new(\"foo\", \"0.1.0\").publish();\n cargo_test_support::registry::Package::new(\"bar\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\", \"bar\"]\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n repository = \"foo\"\n\n [dependencies]\n bar = { version = \"0.1\", path = \"../bar\" }\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"bar\"\n repository = \"bar\"\n\n [dev-dependencies]\n foo = { version = \"0.1\", path = \"../foo\" }\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n // Ensure the circular dependency is caught and reported clearly.\n p.cargo(\"publish --workspace --no-verify -Zpublish-timeout --config publish.timeout=1\")\n .masquerade_as_nightly_cargo(&[\"publish-timeout\"])\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] foo v0.1.1 ([ROOT]/foo/foo)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] bar v0.1.1 ([ROOT]/foo/bar)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[ERROR] circular dependency detected while publishing bar v0.1.1 and foo v0.1.1\n[HELP] to break a cycle between dev-dependencies and other dependencies, remove the version field on the dev-dependency so it will be implicitly stripped on publish\n\n\"#]])\n .run();\n}\n#[cargo_test]\nfn workspace_circular_publish_dependency_with_non_cycle_package() {\n // Verify that circular dependency errors only report packages actively involved in the cycle.\n // Package 'c' is independent and should be excluded from the error message,\n // even though the cycle between 'a' and 'b' blocks the overall workspace publish.\n let registry = registry::RegistryBuilder::new()\n .http_api()\n .http_index()\n .build();\n\n cargo_test_support::registry::Package::new(\"a\", \"1.0.0\").publish();\n cargo_test_support::registry::Package::new(\"b\", \"1.0.0\").publish();\n cargo_test_support::registry::Package::new(\"c\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\", \"c\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"1.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"a\"\n repository = \"a\"\n\n [dependencies]\n b = { version = \"1.0\", path = \"../b\" }\n c = { version = \"1.0\", path = \"../c\" }\n \"#,\n )\n .file(\"a/src/lib.rs\", \"\")\n .file(\n \"b/Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"1.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"b\"\n repository = \"b\"\n\n [dependencies]\n c = { version = \"1.0\", path = \"../c\" }\n\n [dev-dependencies]\n a = { version = \"1.0\", path = \"../a\" }\n \"#,\n )\n .file(\"b/src/lib.rs\", \"\")\n .file(\n \"c/Cargo.toml\",\n r#\"\n [package]\n name = \"c\"\n version = \"1.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"c\"\n repository = \"c\"\n \"#,\n )\n .file(\"c/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --workspace --no-verify -Zpublish-timeout --config publish.timeout=1\")\n .masquerade_as_nightly_cargo(&[\"publish-timeout\"])\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] c v1.0.1 ([ROOT]/foo/c)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] b v1.0.1 ([ROOT]/foo/b)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[PACKAGING] a v1.0.1 ([ROOT]/foo/a)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[ERROR] circular dependency detected while publishing a v1.0.1 and b v1.0.1\n[HELP] to break a cycle between dev-dependencies and other dependencies, remove the version field on the dev-dependency so it will be implicitly stripped on publish\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/publish_lockfile.rs", "content": "//! Tests for including `Cargo.lock` when publishing/packaging.\n\nuse std::fs::File;\n\nuse crate::prelude::*;\nuse crate::utils::cargo_process;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::{\n basic_manifest, git, paths, project, publish::validate_crate_contents, str,\n};\n\nfn pl_manifest(name: &str, version: &str, extra: &str) -> String {\n format!(\n r#\"\n [package]\n name = \"{}\"\n version = \"{}\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n\n {}\n \"#,\n name, version, extra\n )\n}\n\n#[cargo_test]\nfn removed() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"publish-lockfile\"]\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n publish-lockfile = true\n license = \"MIT\"\n description = \"foo\"\n documentation = \"foo\"\n homepage = \"foo\"\n repository = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"package\")\n .masquerade_as_nightly_cargo(&[\"publish-lockfile\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n the cargo feature `publish-lockfile` has been removed in the 1.37 release\n\n Remove the feature from Cargo.toml to remove this error.\n See https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#publish-lockfile for more information about using this feature.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn package_lockfile() {\n let p = project()\n .file(\"Cargo.toml\", &pl_manifest(\"foo\", \"0.0.1\", \"\"))\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"package\")\n .with_stderr_data(str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n assert!(p.root().join(\"target/package/foo-0.0.1.crate\").is_file());\n p.cargo(\"package -l\")\n .with_stdout_data(str![[r#\"\nCargo.lock\nCargo.toml\nCargo.toml.orig\nsrc/main.rs\n\n\"#]])\n .run();\n p.cargo(\"package\")\n .with_stderr_data(str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n let f = File::open(&p.root().join(\"target/package/foo-0.0.1.crate\")).unwrap();\n validate_crate_contents(\n f,\n \"foo-0.0.1.crate\",\n &[\"Cargo.toml\", \"Cargo.toml.orig\", \"Cargo.lock\", \"src/main.rs\"],\n (),\n );\n}\n\n#[cargo_test]\nfn package_lockfile_git_repo() {\n // Create a Git repository containing a minimal Rust project.\n let g = git::repo(&paths::root().join(\"foo\"))\n .file(\"Cargo.toml\", &pl_manifest(\"foo\", \"0.0.1\", \"\"))\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n cargo_process(\"package -l\")\n .cwd(g.root())\n .with_stdout_data(str![[r#\"\n.cargo_vcs_info.json\nCargo.lock\nCargo.toml\nCargo.toml.orig\nsrc/main.rs\n\n\"#]])\n .run();\n cargo_process(\"package -v\")\n .cwd(g.root())\n .with_stderr_data(str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[ARCHIVING] .cargo_vcs_info.json\n[ARCHIVING] Cargo.lock\n[ARCHIVING] Cargo.toml\n[ARCHIVING] Cargo.toml.orig\n[ARCHIVING] src/main.rs\n[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn lock_file_with_library() {\n let p = project()\n .file(\"Cargo.toml\", &pl_manifest(\"foo\", \"0.0.1\", \"\"))\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"package\").run();\n\n let f = File::open(&p.root().join(\"target/package/foo-0.0.1.crate\")).unwrap();\n validate_crate_contents(\n f,\n \"foo-0.0.1.crate\",\n &[\"Cargo.toml\", \"Cargo.toml.orig\", \"src/lib.rs\", \"Cargo.lock\"],\n (),\n );\n}\n\n#[cargo_test]\nfn lock_file_and_workspace() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\"]\n \"#,\n )\n .file(\"foo/Cargo.toml\", &pl_manifest(\"foo\", \"0.0.1\", \"\"))\n .file(\"foo/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"package\").cwd(\"foo\").run();\n\n let f = File::open(&p.root().join(\"target/package/foo-0.0.1.crate\")).unwrap();\n validate_crate_contents(\n f,\n \"foo-0.0.1.crate\",\n &[\"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\", \"Cargo.lock\"],\n (),\n );\n}\n\n#[cargo_test]\nfn note_resolve_changes() {\n // `multi` has multiple sources (path and registry).\n Package::new(\"multi\", \"0.1.0\").publish();\n // `updated` is always from registry, but should not change.\n Package::new(\"updated\", \"1.0.0\").publish();\n // `patched` is [patch]ed.\n Package::new(\"patched\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &pl_manifest(\n \"foo\",\n \"0.0.1\",\n r#\"\n [dependencies]\n multi = { path = \"multi\", version = \"0.1\" }\n updated = \"1.0\"\n patched = \"1.0\"\n\n [patch.crates-io]\n patched = { path = \"patched\" }\n \"#,\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"multi/Cargo.toml\", &basic_manifest(\"multi\", \"0.1.0\"))\n .file(\"multi/src/lib.rs\", \"\")\n .file(\"patched/Cargo.toml\", &basic_manifest(\"patched\", \"1.0.0\"))\n .file(\"patched/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n // Make sure this does not change or warn.\n Package::new(\"updated\", \"1.0.1\").publish();\n\n p.cargo(\"package --no-verify -v --allow-dirty\")\n .with_stderr_data(str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[ARCHIVING] Cargo.lock\n[UPDATING] `dummy-registry` index\n[NOTE] package `multi v0.1.0` added to the packaged Cargo.lock file, was originally sourced from `[ROOT]/foo/multi`\n[NOTE] package `patched v1.0.0` added to the packaged Cargo.lock file, was originally sourced from `[ROOT]/foo/patched`\n[ARCHIVING] Cargo.toml\n[ARCHIVING] Cargo.toml.orig\n[ARCHIVING] src/main.rs\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n...\n\n\"#]].unordered())\n .run();\n}\n\n#[cargo_test]\nfn outdated_lock_version_change_does_not_warn() {\n // If the version of the package being packaged changes, but Cargo.lock is\n // not updated, don't bother warning about it.\n let p = project()\n .file(\"Cargo.toml\", &pl_manifest(\"foo\", \"0.1.0\", \"\"))\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n p.change_file(\"Cargo.toml\", &pl_manifest(\"foo\", \"0.2.0\", \"\"));\n\n p.cargo(\"package --no-verify\")\n .with_stderr_data(str![[r#\"\n[PACKAGING] foo v0.2.0 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn no_warn_workspace_extras() {\n // Other entries in workspace lock file should be ignored.\n Package::new(\"dep1\", \"1.0.0\").publish();\n Package::new(\"dep2\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n &pl_manifest(\n \"a\",\n \"0.1.0\",\n r#\"\n [dependencies]\n dep1 = \"1.0\"\n \"#,\n ),\n )\n .file(\"a/src/main.rs\", \"fn main() {}\")\n .file(\n \"b/Cargo.toml\",\n &pl_manifest(\n \"b\",\n \"0.1.0\",\n r#\"\n [dependencies]\n dep2 = \"1.0\"\n \"#,\n ),\n )\n .file(\"b/src/main.rs\", \"fn main() {}\")\n .build();\n p.cargo(\"generate-lockfile\").run();\n p.cargo(\"package --no-verify\")\n .cwd(\"a\")\n .with_stderr_data(str![[r#\"\n[PACKAGING] a v0.1.0 ([ROOT]/foo/a)\n[UPDATING] `dummy-registry` index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn warn_package_with_yanked() {\n Package::new(\"bar\", \"0.1.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n &pl_manifest(\n \"foo\",\n \"0.0.1\",\n r#\"\n [dependencies]\n bar = \"0.1\"\n \"#,\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n p.cargo(\"generate-lockfile\").run();\n Package::new(\"bar\", \"0.1.0\").yanked(true).publish();\n // Make sure it sticks with the locked (yanked) version.\n Package::new(\"bar\", \"0.1.1\").publish();\n p.cargo(\"package --no-verify\")\n .with_stderr_data(str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[UPDATING] `dummy-registry` index\n[WARNING] package `bar v0.1.0` in Cargo.lock is yanked in registry `crates-io`, consider updating to a version that is not yanked\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn warn_install_with_yanked() {\n Package::new(\"bar\", \"0.1.0\").yanked(true).publish();\n Package::new(\"bar\", \"0.1.1\").publish();\n Package::new(\"foo\", \"0.1.0\")\n .dep(\"bar\", \"0.1\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"Cargo.lock\",\n r#\"\n[[package]]\nname = \"bar\"\nversion = \"0.1.0\"\nsource = \"registry+https://github.com/rust-lang/crates.io-index\"\n\n[[package]]\nname = \"foo\"\nversion = \"0.1.0\"\ndependencies = [\n \"bar 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)\",\n]\n \"#,\n )\n .publish();\n\n cargo_process(\"install --locked foo\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n[DOWNLOADED] foo v0.1.0 (registry `dummy-registry`)\n[INSTALLING] foo v0.1.0\n[WARNING] package `bar v0.1.0` in Cargo.lock is yanked in registry `crates-io`, consider running without --locked\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.1.0 (registry `dummy-registry`)\n[COMPILING] bar v0.1.0\n[COMPILING] foo v0.1.0\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]\n[INSTALLED] package `foo v0.1.0` (executable `foo[EXE]`)\n[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries\n\n\"#]])\n .run();\n\n // Try again without --locked, make sure it uses 0.1.1 and does not warn.\n cargo_process(\"install --force foo\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[INSTALLING] foo v0.1.0\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.1.1 (registry `dummy-registry`)\n[COMPILING] bar v0.1.1\n[COMPILING] foo v0.1.0\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[REPLACING] [ROOT]/home/.cargo/bin/foo[EXE]\n[REPLACED] package `foo v0.1.0` with `foo v0.1.0` (executable `foo[EXE]`)\n[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn ignore_lockfile() {\n // With an explicit `include` list, but Cargo.lock in .gitignore, don't\n // complain about `Cargo.lock` being ignored. Note that it is still\n // included in the packaged regardless.\n let p = git::new(\"foo\", |p| {\n p.file(\n \"Cargo.toml\",\n &pl_manifest(\n \"foo\",\n \"0.0.1\",\n r#\"\n include = [\n \"src/main.rs\"\n ]\n \"#,\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\".gitignore\", \"Cargo.lock\")\n });\n p.cargo(\"package -l\")\n .with_stdout_data(str![[r#\"\n.cargo_vcs_info.json\nCargo.lock\nCargo.toml\nCargo.toml.orig\nsrc/main.rs\n\n\"#]])\n .run();\n p.cargo(\"generate-lockfile\").run();\n p.cargo(\"package -v\")\n .with_stderr_data(str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[ARCHIVING] .cargo_vcs_info.json\n[ARCHIVING] Cargo.lock\n[ARCHIVING] Cargo.toml\n[ARCHIVING] Cargo.toml.orig\n[ARCHIVING] src/main.rs\n[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn ignore_lockfile_inner() {\n // Ignore `Cargo.lock` if in .gitignore in a git subdirectory.\n let p = git::new(\"foo\", |p| {\n p.no_manifest()\n .file(\"bar/Cargo.toml\", &pl_manifest(\"bar\", \"0.0.1\", \"\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .file(\"bar/.gitignore\", \"Cargo.lock\")\n });\n p.cargo(\"generate-lockfile\").cwd(\"bar\").run();\n p.cargo(\"package -v --no-verify\")\n .cwd(\"bar\")\n .with_stderr_data(str![[r#\"\n[PACKAGING] bar v0.0.1 ([ROOT]/foo/bar)\n[ARCHIVING] .cargo_vcs_info.json\n[ARCHIVING] .gitignore\n[ARCHIVING] Cargo.lock\n[ARCHIVING] Cargo.toml\n[ARCHIVING] Cargo.toml.orig\n[ARCHIVING] src/main.rs\n[PACKAGED] 6 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn use_workspace_root_lockfile() {\n // Issue #11148\n // Workspace members should use `Cargo.lock` at workspace root\n\n Package::new(\"serde\", \"0.2.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [dependencies]\n serde = \"0.2\"\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"bar\"\n workspace = \"..\"\n\n [dependencies]\n serde = \"0.2\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .build();\n\n // Create `Cargo.lock` in the workspace root.\n p.cargo(\"generate-lockfile\").run();\n\n // Now, add a newer version of `serde`.\n Package::new(\"serde\", \"0.2.1\").publish();\n\n // Expect: package `bar` uses `serde v0.2.0` as required by workspace `Cargo.lock`.\n p.cargo(\"package --workspace\")\n .with_stderr_data(str![[r#\"\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] bar v0.0.1 ([ROOT]/foo/bar)\n[UPDATING] `dummy-registry` index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] bar v0.0.1 ([ROOT]/foo/bar)\n[DOWNLOADING] crates ...\n[DOWNLOADED] serde v0.2.0 (registry `dummy-registry`)\n[COMPILING] serde v0.2.0\n[COMPILING] bar v0.0.1 ([ROOT]/foo/target/package/bar-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n let package_path = p.root().join(\"target/package/foo-0.0.1.crate\");\n assert!(package_path.is_file());\n let f = File::open(&package_path).unwrap();\n validate_crate_contents(\n f,\n \"foo-0.0.1.crate\",\n &[\"Cargo.lock\", \"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\"],\n (),\n );\n\n let package_path = p.root().join(\"target/package/bar-0.0.1.crate\");\n assert!(package_path.is_file());\n let f = File::open(&package_path).unwrap();\n validate_crate_contents(\n f,\n \"bar-0.0.1.crate\",\n &[\"Cargo.lock\", \"Cargo.toml\", \"Cargo.toml.orig\", \"src/main.rs\"],\n (),\n );\n}\n" }, { "path": "tests/testsuite/read_manifest.rs", "content": "//! Tests for the `cargo read-manifest` command.\n\nuse crate::prelude::*;\nuse cargo_test_support::{basic_bin_manifest, main_file, project, str};\n\npub fn basic_bin_manifest_with_readme(name: &str, readme_filename: &str) -> String {\n format!(\n r#\"\n [package]\n\n name = \"{}\"\n version = \"0.5.0\"\n authors = [\"wycats@example.com\"]\n readme = {}\n\n [[bin]]\n\n name = \"{}\"\n \"#,\n name, readme_filename, name\n )\n}\n\n#[cargo_test]\nfn cargo_read_manifest_path_to_cargo_toml_relative() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest --manifest-path foo/Cargo.toml\")\n .cwd(p.root().parent().unwrap())\n .with_stdout_data(\n str![[r#\"\n{\n \"readme\": null,\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n )\n .run();\n}\n\n#[cargo_test]\nfn cargo_read_manifest_path_to_cargo_toml_absolute() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest --manifest-path\")\n .arg(p.root().join(\"Cargo.toml\"))\n .cwd(p.root().parent().unwrap())\n .with_stdout_data(\n str![[r#\"\n{\n \"readme\": null,\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n )\n .run();\n}\n\n#[cargo_test]\nfn cargo_read_manifest_path_to_cargo_toml_parent_relative() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest --manifest-path foo\")\n .cwd(p.root().parent().unwrap())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `foo` is a directory but expected a file\n[HELP] [ROOT]/foo/Cargo.toml exists\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_read_manifest_path_to_cargo_toml_parent_absolute() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest --manifest-path\")\n .arg(p.root())\n .cwd(p.root().parent().unwrap())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `[ROOT]/foo` is a directory but expected a file\n[HELP] [ROOT]/foo/Cargo.toml exists\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_read_manifest_cwd() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest\")\n .with_stdout_data(\n str![[r#\"\n{\n \"readme\": null,\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n )\n .run();\n}\n\n#[cargo_test]\nfn cargo_read_manifest_with_specified_readme() {\n let p = project()\n .file(\n \"Cargo.toml\",\n &basic_bin_manifest_with_readme(\"foo\", r#\"\"SomeReadme.txt\"\"#),\n )\n .file(\"SomeReadme.txt\", \"Sample Project\")\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest\")\n .with_stdout_data(\n str![[r#\"\n{\n \"readme\": \"SomeReadme.txt\",\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n )\n .run();\n}\n\n#[cargo_test]\nfn cargo_read_manifest_default_readme() {\n let assert_output = |readme, expected| {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(readme, \"Sample project\")\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest\").with_stdout_data(expected).run();\n };\n\n assert_output(\n \"README.md\",\n str![[r#\"\n{\n \"readme\": \"README.md\",\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n );\n\n assert_output(\n \"README.txt\",\n str![[r#\"\n{\n \"readme\": \"README.txt\",\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n );\n\n assert_output(\n \"README\",\n str![[r#\"\n{\n \"readme\": \"README\",\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn cargo_read_manifest_suppress_default_readme() {\n let p = project()\n .file(\n \"Cargo.toml\",\n &basic_bin_manifest_with_readme(\"foo\", \"false\"),\n )\n .file(\"README.txt\", \"Sample project\")\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest\")\n .with_stdout_data(\n str![[r#\"\n{\n \"readme\": null,\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n )\n .run();\n}\n\n// If a file named README.md exists, and `readme = true`, the value `README.md` should be defaulted in.\n#[cargo_test]\nfn cargo_read_manifest_defaults_readme_if_true() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest_with_readme(\"foo\", \"true\"))\n .file(\"README.md\", \"Sample project\")\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"read-manifest\")\n .with_stdout_data(\n str![[r#\"\n{\n \"readme\": \"README.md\",\n \"...\": \"{...}\"\n}\n\"#]]\n .is_json(),\n )\n .run();\n}\n" }, { "path": "tests/testsuite/registry.rs", "content": "//! Tests for normal registry dependencies.\n\nuse std::fmt::Write;\nuse std::fs::{self, File};\nuse std::path::{Path, PathBuf};\nuse std::sync::Arc;\nuse std::sync::Mutex;\n\nuse crate::prelude::*;\nuse crate::utils::cargo_process;\nuse cargo::core::SourceId;\nuse cargo_test_support::assert_deterministic_mtime;\nuse cargo_test_support::paths;\nuse cargo_test_support::registry::{\n self, Dependency, Package, RegistryBuilder, Response, TestRegistry, registry_path,\n};\nuse cargo_test_support::{basic_manifest, project, str};\nuse cargo_test_support::{git, t};\nuse cargo_util::paths::remove_dir_all;\n\nfn setup_http() -> TestRegistry {\n RegistryBuilder::new().http_index().build()\n}\n\n#[cargo_test]\nfn test_server_stops() {\n let server = setup_http();\n server.join(); // ensure the server fully shuts down\n}\n\n#[cargo_test]\nfn simple_http() {\n let _server = setup_http();\n simple(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn simple_git() {\n simple(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn simple(pre_clean_expected: impl IntoData, post_clean_expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n\n p.cargo(\"check\").with_stderr_data(pre_clean_expected).run();\n\n p.cargo(\"clean\").run();\n\n assert!(paths::home().join(\".cargo/registry/CACHEDIR.TAG\").is_file());\n\n // Don't download a second time\n p.cargo(\"check\").with_stderr_data(post_clean_expected).run();\n}\n\n#[cargo_test]\nfn deps_http() {\n let _server = setup_http();\n deps(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[CHECKING] baz v0.0.1\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn deps_git() {\n deps(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[CHECKING] baz v0.0.1\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn deps(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"baz\", \"0.0.1\").publish();\n Package::new(\"bar\", \"0.0.1\").dep(\"baz\", \"*\").publish();\n\n p.cargo(\"check\").with_stderr_data(expected).run();\n\n assert!(paths::home().join(\".cargo/registry/CACHEDIR.TAG\").is_file());\n}\n\n#[cargo_test]\nfn nonexistent_http() {\n let _server = setup_http();\n nonexistent(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `nonexistent` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]]);\n}\n\n#[cargo_test]\nfn nonexistent_git() {\n nonexistent(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `nonexistent` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]]);\n}\n\nfn nonexistent(expected: impl IntoData) {\n Package::new(\"init\", \"0.0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n nonexistent = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn wrong_case_http() {\n let _server = setup_http();\n wrong_case(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package found\nsearched package name: `Init`\nperhaps you meant: init\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]]);\n}\n\n#[cargo_test]\nfn wrong_case_git() {\n wrong_case(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package found\nsearched package name: `Init`\nperhaps you meant: init\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]]);\n}\n\nfn wrong_case(expected: impl IntoData) {\n Package::new(\"init\", \"0.0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n Init = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // #5678 to make this work\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn mis_hyphenated_http() {\n let _server = setup_http();\n mis_hyphenated(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package found\nsearched package name: `mis_hyphenated`\nperhaps you meant: mis-hyphenated\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]]);\n}\n\n#[cargo_test]\nfn mis_hyphenated_git() {\n mis_hyphenated(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package found\nsearched package name: `mis_hyphenated`\nperhaps you meant: mis-hyphenated\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]]);\n}\n\nfn mis_hyphenated(expected: impl IntoData) {\n Package::new(\"mis-hyphenated\", \"0.0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n mis_hyphenated = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // #2775 to make this work\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn wrong_version_http() {\n let _server = setup_http();\n wrong_version(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `foo = \">=1.0.0\"`\ncandidate versions found which didn't match: 0.0.2, 0.0.1\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\nperhaps a crate was updated and forgotten to be re-vendored?\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `foo = \">=1.0.0\"`\ncandidate versions found which didn't match: 0.0.4, 0.0.3, 0.0.2, ...\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\nperhaps a crate was updated and forgotten to be re-vendored?\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn wrong_version_git() {\n wrong_version(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `foo = \">=1.0.0\"`\ncandidate versions found which didn't match: 0.0.2, 0.0.1\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\nperhaps a crate was updated and forgotten to be re-vendored?\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `foo = \">=1.0.0\"`\ncandidate versions found which didn't match: 0.0.4, 0.0.3, 0.0.2, ...\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\nperhaps a crate was updated and forgotten to be re-vendored?\n\n\"#]],\n );\n}\n\nfn wrong_version(pre_publish_expected: impl IntoData, post_publish_expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \">= 1.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"foo\", \"0.0.1\").publish();\n Package::new(\"foo\", \"0.0.2\").publish();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(pre_publish_expected)\n .run();\n\n Package::new(\"foo\", \"0.0.3\").publish();\n Package::new(\"foo\", \"0.0.4\").publish();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(post_publish_expected)\n .run();\n}\n\n#[cargo_test]\nfn bad_cksum_http() {\n let _server = setup_http();\n bad_cksum(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bad-cksum v0.0.1 (registry `dummy-registry`)\n[ERROR] failed to download replaced source registry `crates-io`\n\nCaused by:\n failed to verify the checksum of `bad-cksum v0.0.1 (registry `dummy-registry`)`\n\n\"#]]);\n}\n\n#[cargo_test]\nfn bad_cksum_git() {\n bad_cksum(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bad-cksum v0.0.1 (registry `dummy-registry`)\n[ERROR] failed to download replaced source registry `crates-io`\n\nCaused by:\n failed to verify the checksum of `bad-cksum v0.0.1 (registry `dummy-registry`)`\n\n\"#]]);\n}\n\nfn bad_cksum(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bad-cksum = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n let pkg = Package::new(\"bad-cksum\", \"0.0.1\");\n pkg.publish();\n t!(File::create(&pkg.archive_dst()));\n\n p.cargo(\"check -v\")\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn update_registry_http() {\n let _server = setup_http();\n update_registry(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `notyet` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] notyet v0.0.1 (registry `dummy-registry`)\n[CHECKING] notyet v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn update_registry_git() {\n update_registry(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `notyet` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] notyet v0.0.1 (registry `dummy-registry`)\n[CHECKING] notyet v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn update_registry(pre_publish_expected: impl IntoData, post_publish_expected: impl IntoData) {\n Package::new(\"init\", \"0.0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n notyet = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(pre_publish_expected)\n .run();\n\n Package::new(\"notyet\", \"0.0.1\").publish();\n\n p.cargo(\"check\")\n .with_stderr_data(post_publish_expected)\n .run();\n}\n\n#[cargo_test]\nfn package_with_path_deps_http() {\n let _server = setup_http();\n package_with_path_deps(\n str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[UPDATING] `dummy-registry` index\n[ERROR] failed to prepare local package for uploading\n\nCaused by:\n no matching package named `notyet` found\n location searched: `dummy-registry` index (which is replacing registry `crates-io`)\n required by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]],\n str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[UPDATING] `dummy-registry` index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[DOWNLOADING] crates ...\n[DOWNLOADED] notyet v0.0.1 (registry `dummy-registry`)\n[COMPILING] notyet v0.0.1\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn package_with_path_deps_git() {\n package_with_path_deps(\n str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[UPDATING] `dummy-registry` index\n[ERROR] failed to prepare local package for uploading\n\nCaused by:\n no matching package named `notyet` found\n location searched: `dummy-registry` index (which is replacing registry `crates-io`)\n required by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]],\n str![[r#\"\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[UPDATING] `dummy-registry` index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[DOWNLOADING] crates ...\n[DOWNLOADED] notyet v0.0.1 (registry `dummy-registry`)\n[COMPILING] notyet v0.0.1\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn package_with_path_deps(\n pre_publish_expected: impl IntoData,\n post_publish_expected: impl IntoData,\n) {\n Package::new(\"init\", \"0.0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n repository = \"bar\"\n\n [dependencies.notyet]\n version = \"0.0.1\"\n path = \"notyet\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"notyet/Cargo.toml\", &basic_manifest(\"notyet\", \"0.0.1\"))\n .file(\"notyet/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"package\")\n .with_status(101)\n .with_stderr_data(pre_publish_expected)\n .run();\n\n Package::new(\"notyet\", \"0.0.1\").publish();\n\n p.cargo(\"package\")\n .with_stderr_data(post_publish_expected)\n .run();\n}\n\n#[cargo_test]\nfn lockfile_locks_http() {\n let _server = setup_http();\n lockfile_locks(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn lockfile_locks_git() {\n lockfile_locks(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn lockfile_locks(pre_publish_expected: impl IntoData, post_publish_expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n\n p.cargo(\"check\")\n .with_stderr_data(pre_publish_expected)\n .run();\n\n p.root().move_into_the_past();\n Package::new(\"bar\", \"0.0.2\").publish();\n\n p.cargo(\"check\")\n .with_stderr_data(post_publish_expected)\n .run();\n}\n\n#[cargo_test]\nfn lockfile_locks_transitively_http() {\n let _server = setup_http();\n lockfile_locks_transitively(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[CHECKING] baz v0.0.1\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn lockfile_locks_transitively_git() {\n lockfile_locks_transitively(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[CHECKING] baz v0.0.1\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn lockfile_locks_transitively(\n pre_publish_expected: impl IntoData,\n post_publish_expected: impl IntoData,\n) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"baz\", \"0.0.1\").publish();\n Package::new(\"bar\", \"0.0.1\").dep(\"baz\", \"*\").publish();\n\n p.cargo(\"check\")\n .with_stderr_data(pre_publish_expected)\n .run();\n\n p.root().move_into_the_past();\n Package::new(\"baz\", \"0.0.2\").publish();\n Package::new(\"bar\", \"0.0.2\").dep(\"baz\", \"*\").publish();\n\n p.cargo(\"check\")\n .with_stderr_data(post_publish_expected)\n .run();\n}\n\n#[cargo_test]\nfn yanks_are_not_used_http() {\n let _server = setup_http();\n yanks_are_not_used(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[CHECKING] baz v0.0.1\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn yanks_are_not_used_git() {\n yanks_are_not_used(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[DOWNLOADED] ba[..] v0.0.1 (registry `dummy-registry`)\n[CHECKING] baz v0.0.1\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn yanks_are_not_used(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"baz\", \"0.0.1\").publish();\n Package::new(\"baz\", \"0.0.2\").yanked(true).publish();\n Package::new(\"bar\", \"0.0.1\").dep(\"baz\", \"*\").publish();\n Package::new(\"bar\", \"0.0.2\")\n .dep(\"baz\", \"*\")\n .yanked(true)\n .publish();\n\n p.cargo(\"check\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn relying_on_a_yank_is_bad_http() {\n let _server = setup_http();\n relying_on_a_yank_is_bad(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `baz = \"=0.0.2\"`\n version 0.0.2 is yanked\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `bar v0.0.1`\n ... which satisfies dependency `bar = \"*\"` of package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]]);\n}\n\n#[cargo_test]\nfn relying_on_a_yank_is_bad_git() {\n relying_on_a_yank_is_bad(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `baz = \"=0.0.2\"`\n version 0.0.2 is yanked\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `bar v0.0.1`\n ... which satisfies dependency `bar = \"*\"` of package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]]);\n}\n\nfn relying_on_a_yank_is_bad(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"baz\", \"0.0.1\").publish();\n Package::new(\"baz\", \"0.0.2\").yanked(true).publish();\n Package::new(\"bar\", \"0.0.1\").dep(\"baz\", \"=0.0.2\").publish();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn yanks_in_lockfiles_are_ok_http() {\n let _server = setup_http();\n yanks_in_lockfiles_are_ok(\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `bar = \"*\"`\n version 0.0.1 is yanked\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn yanks_in_lockfiles_are_ok_git() {\n yanks_in_lockfiles_are_ok(\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `bar = \"*\"`\n version 0.0.1 is yanked\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]],\n );\n}\n\nfn yanks_in_lockfiles_are_ok(expected_check: impl IntoData, expected_update: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n\n p.cargo(\"check\").run();\n\n registry_path().join(\"3\").rm_rf();\n\n Package::new(\"bar\", \"0.0.1\").yanked(true).publish();\n\n p.cargo(\"check\").with_stderr_data(expected_check).run();\n\n p.cargo(\"update\")\n .with_status(101)\n .with_stderr_data(expected_update)\n .run();\n}\n\n#[cargo_test]\nfn yanks_in_lockfiles_are_ok_for_other_update_http() {\n let _server = setup_http();\n yanks_in_lockfiles_are_ok_for_other_update(\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `bar = \"*\"`\n version 0.0.1 is yanked\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] baz v0.0.1 -> v0.0.2\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn yanks_in_lockfiles_are_ok_for_other_update_git() {\n yanks_in_lockfiles_are_ok_for_other_update(\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `bar = \"*\"`\n version 0.0.1 is yanked\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] baz v0.0.1 -> v0.0.2\n\n\"#]],\n );\n}\n\nfn yanks_in_lockfiles_are_ok_for_other_update(\n expected_check: impl IntoData,\n expected_update: impl IntoData,\n expected_other_update: impl IntoData,\n) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n baz = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n Package::new(\"baz\", \"0.0.1\").publish();\n\n p.cargo(\"check\").run();\n\n registry_path().join(\"3\").rm_rf();\n\n Package::new(\"bar\", \"0.0.1\").yanked(true).publish();\n Package::new(\"baz\", \"0.0.1\").publish();\n\n p.cargo(\"check\").with_stderr_data(expected_check).run();\n\n Package::new(\"baz\", \"0.0.2\").publish();\n\n p.cargo(\"update\")\n .with_status(101)\n .with_stderr_data(expected_update)\n .run();\n\n p.cargo(\"update baz\")\n .with_stderr_data(expected_other_update)\n .run();\n}\n\n#[cargo_test]\nfn yanks_in_lockfiles_are_ok_with_new_dep_http() {\n let _server = setup_http();\n yanks_in_lockfiles_are_ok_with_new_dep(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[ADDING] baz v0.0.1\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.0.1 (registry `dummy-registry`)\n[CHECKING] baz v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn yanks_in_lockfiles_are_ok_with_new_dep_git() {\n yanks_in_lockfiles_are_ok_with_new_dep(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[ADDING] baz v0.0.1\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.0.1 (registry `dummy-registry`)\n[CHECKING] baz v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn yanks_in_lockfiles_are_ok_with_new_dep(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n\n p.cargo(\"check\").run();\n\n registry_path().join(\"3\").rm_rf();\n\n Package::new(\"bar\", \"0.0.1\").yanked(true).publish();\n Package::new(\"baz\", \"0.0.1\").publish();\n\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n baz = \"*\"\n \"#,\n );\n\n p.cargo(\"check\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn update_with_lockfile_if_packages_missing_http() {\n let _server = setup_http();\n update_with_lockfile_if_packages_missing(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn update_with_lockfile_if_packages_missing_git() {\n update_with_lockfile_if_packages_missing(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn update_with_lockfile_if_packages_missing(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n p.cargo(\"check\").run();\n p.root().move_into_the_past();\n\n paths::home().join(\".cargo/registry\").rm_rf();\n p.cargo(\"check\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn update_lockfile_http() {\n let _server = setup_http();\n update_lockfile(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] bar v0.0.1 -> v0.0.2\n\n\"#]],\n str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.2 (registry `dummy-registry`)\n[CHECKING] bar v0.0.2\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v0.0.2 -> v0.0.3\n\n\"#]],\n str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.3 (registry `dummy-registry`)\n[CHECKING] bar v0.0.3\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] bar v0.0.3 -> v0.0.4\n[ADDING] spam v0.2.5\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v0.0.4 -> v0.0.5\n[REMOVING] spam v0.2.5\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn update_lockfile_git() {\n update_lockfile(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] bar v0.0.1 -> v0.0.2\n\n\"#]],\n str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.2 (registry `dummy-registry`)\n[CHECKING] bar v0.0.2\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v0.0.2 -> v0.0.3\n\n\"#]],\n str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.3 (registry `dummy-registry`)\n[CHECKING] bar v0.0.3\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] bar v0.0.3 -> v0.0.4\n[ADDING] spam v0.2.5\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v0.0.4 -> v0.0.5\n[REMOVING] spam v0.2.5\n\n\"#]],\n );\n}\n\nfn update_lockfile(\n expected_update: impl IntoData,\n expected_check: impl IntoData,\n expected_other_update: impl IntoData,\n expected_other_check: impl IntoData,\n expected_new_update: impl IntoData,\n expected_new_check: impl IntoData,\n) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n println!(\"0.0.1\");\n Package::new(\"bar\", \"0.0.1\").publish();\n p.cargo(\"check\").run();\n\n Package::new(\"bar\", \"0.0.2\").publish();\n Package::new(\"bar\", \"0.0.3\").publish();\n paths::home().join(\".cargo/registry\").rm_rf();\n println!(\"0.0.2 update\");\n p.cargo(\"update bar --precise 0.0.2\")\n .with_stderr_data(expected_update)\n .run();\n\n println!(\"0.0.2 build\");\n p.cargo(\"check\").with_stderr_data(expected_check).run();\n\n println!(\"0.0.3 update\");\n p.cargo(\"update bar\")\n .with_stderr_data(expected_other_update)\n .run();\n\n println!(\"0.0.3 build\");\n p.cargo(\"check\")\n .with_stderr_data(expected_other_check)\n .run();\n\n println!(\"new dependencies update\");\n Package::new(\"bar\", \"0.0.4\").dep(\"spam\", \"0.2.5\").publish();\n Package::new(\"spam\", \"0.2.5\").publish();\n p.cargo(\"update bar\")\n .with_stderr_data(expected_new_update)\n .run();\n\n println!(\"new dependencies update\");\n Package::new(\"bar\", \"0.0.5\").publish();\n p.cargo(\"update bar\")\n .with_stderr_data(expected_new_check)\n .run();\n}\n\n#[cargo_test]\nfn dev_dependency_not_used_http() {\n let _server = setup_http();\n dev_dependency_not_used(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn dev_dependency_not_used_git() {\n dev_dependency_not_used(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn dev_dependency_not_used(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"baz\", \"0.0.1\").publish();\n Package::new(\"bar\", \"0.0.1\").dev_dep(\"baz\", \"*\").publish();\n\n p.cargo(\"check\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn bad_license_file_http() {\n let registry = setup_http();\n bad_license_file(\n ®istry,\n str![[r#\"\n...\n[ERROR] license-file `foo` does not appear to exist (relative to `[ROOT]/foo`).\n...\n\"#]],\n );\n}\n\n#[cargo_test]\nfn bad_license_file_git() {\n let registry = registry::init();\n bad_license_file(\n ®istry,\n str![[r#\"\n...\n[ERROR] license-file `foo` does not appear to exist (relative to `[ROOT]/foo`).\n...\n\"#]],\n );\n}\n\nfn bad_license_file(registry: &TestRegistry, expected: impl IntoData) {\n Package::new(\"foo\", \"1.0.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license-file = \"foo\"\n description = \"bar\"\n repository = \"baz\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n p.cargo(\"publish -v\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn updating_a_dep_http() {\n let _server = setup_http();\n updating_a_dep(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] a v0.0.1 ([ROOT]/foo/a)\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v0.0.1 -> v0.1.0\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.1.0 (registry `dummy-registry`)\n[CHECKING] bar v0.1.0\n[CHECKING] a v0.0.1 ([ROOT]/foo/a)\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn updating_a_dep_git() {\n updating_a_dep(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] a v0.0.1 ([ROOT]/foo/a)\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v0.0.1 -> v0.1.0\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.1.0 (registry `dummy-registry`)\n[CHECKING] bar v0.1.0\n[CHECKING] a v0.0.1 ([ROOT]/foo/a)\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn updating_a_dep(pre_update_expected: impl IntoData, post_update_expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.a]\n path = \"a\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"a/src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n\n p.cargo(\"check\").with_stderr_data(pre_update_expected).run();\n assert!(paths::home().join(\".cargo/registry/CACHEDIR.TAG\").is_file());\n\n // Now delete the CACHEDIR.TAG file: this is the situation we'll be in after\n // upgrading from a version of Cargo that doesn't mark this directory, to one that\n // does. It should be recreated.\n fs::remove_file(paths::home().join(\".cargo/registry/CACHEDIR.TAG\"))\n .expect(\"remove CACHEDIR.TAG\");\n\n p.change_file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n \"#,\n );\n Package::new(\"bar\", \"0.1.0\").publish();\n\n println!(\"second\");\n p.cargo(\"check\")\n .with_stderr_data(post_update_expected)\n .run();\n\n assert!(\n paths::home().join(\".cargo/registry/CACHEDIR.TAG\").is_file(),\n \"CACHEDIR.TAG recreated in existing registry\"\n );\n}\n\n#[cargo_test]\nfn git_and_registry_dep_http() {\n let _server = setup_http();\n git_and_registry_dep(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/b`\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] a v0.0.1 (registry `dummy-registry`)\n[CHECKING] a v0.0.1\n[CHECKING] b v0.0.1 ([ROOTURL]/b#[..])\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn git_and_registry_dep_git() {\n git_and_registry_dep(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/b`\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] a v0.0.1 (registry `dummy-registry`)\n[CHECKING] a v0.0.1\n[CHECKING] b v0.0.1 ([ROOTURL]/b#[..])\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn git_and_registry_dep(pre_move_expected: impl IntoData, post_move_expected: impl IntoData) {\n let b = git::repo(&paths::root().join(\"b\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = \"0.0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = \"0.0.1\"\n\n [dependencies.b]\n git = '{}'\n \"#,\n b.url()\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"a\", \"0.0.1\").publish();\n\n p.root().move_into_the_past();\n p.cargo(\"check\").with_stderr_data(pre_move_expected).run();\n p.root().move_into_the_past();\n\n println!(\"second\");\n p.cargo(\"check\").with_stderr_data(post_move_expected).run();\n}\n\n#[cargo_test]\nfn update_publish_then_update_http() {\n let _server = setup_http();\n update_publish_then_update(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n[DOWNLOADED] a v0.1.1 (registry `dummy-registry`)\n[COMPILING] a v0.1.1\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn update_publish_then_update_git() {\n update_publish_then_update(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n[DOWNLOADED] a v0.1.1 (registry `dummy-registry`)\n[COMPILING] a v0.1.1\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn update_publish_then_update(expected: impl IntoData) {\n // First generate a Cargo.lock and a clone of the registry index at the\n // \"head\" of the current registry.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n Package::new(\"a\", \"0.1.0\").publish();\n p.cargo(\"build\").run();\n\n // Next, publish a new package and back up the copy of the registry we just\n // created.\n Package::new(\"a\", \"0.1.1\").publish();\n let registry = paths::home().join(\".cargo/registry\");\n let backup = paths::root().join(\"registry-backup\");\n t!(fs::rename(®istry, &backup));\n\n // Generate a Cargo.lock with the newer version, and then move the old copy\n // of the registry back into place.\n let p2 = project()\n .at(\"foo2\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = \"0.1.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n p2.cargo(\"build\").run();\n registry.rm_rf();\n t!(fs::rename(&backup, ®istry));\n t!(fs::rename(\n p2.root().join(\"Cargo.lock\"),\n p.root().join(\"Cargo.lock\")\n ));\n\n // Finally, build the first project again (with our newer Cargo.lock) which\n // should force an update of the old registry, download the new crate, and\n // then build everything again.\n p.cargo(\"build\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn fetch_downloads_http() {\n let _server = setup_http();\n fetch_downloads(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] a v0.1.0 (registry `dummy-registry`)\n\n\"#]]);\n}\n\n#[cargo_test]\nfn fetch_downloads_git() {\n fetch_downloads(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] a v0.1.0 (registry `dummy-registry`)\n\n\"#]]);\n}\n\nfn fetch_downloads(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"a\", \"0.1.0\").publish();\n\n p.cargo(\"fetch\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn update_transitive_dependency_http() {\n let _server = setup_http();\n update_transitive_dependency(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] b v0.1.0 -> v0.1.1\n\n\"#]],\n str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] b v0.1.1 (registry `dummy-registry`)\n[CHECKING] b v0.1.1\n[CHECKING] a v0.1.0\n[CHECKING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn update_transitive_dependency_git() {\n update_transitive_dependency(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] b v0.1.0 -> v0.1.1\n\n\"#]],\n str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] b v0.1.1 (registry `dummy-registry`)\n[CHECKING] b v0.1.1\n[CHECKING] a v0.1.0\n[CHECKING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn update_transitive_dependency(expected_update: impl IntoData, expected_check: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"a\", \"0.1.0\").dep(\"b\", \"*\").publish();\n Package::new(\"b\", \"0.1.0\").publish();\n\n p.cargo(\"fetch\").run();\n\n Package::new(\"b\", \"0.1.1\").publish();\n\n p.cargo(\"update b\").with_stderr_data(expected_update).run();\n\n p.cargo(\"check\").with_stderr_data(expected_check).run();\n}\n\n#[cargo_test]\nfn update_backtracking_ok_http() {\n let _server = setup_http();\n update_backtracking_ok(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] hyper v0.6.5 -> v0.6.6\n[UPDATING] openssl v0.1.0 -> v0.1.1\n\n\"#]]);\n}\n\n#[cargo_test]\nfn update_backtracking_ok_git() {\n update_backtracking_ok(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] hyper v0.6.5 -> v0.6.6\n[UPDATING] openssl v0.1.0 -> v0.1.1\n\n\"#]]);\n}\n\nfn update_backtracking_ok(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n webdriver = \"0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"webdriver\", \"0.1.0\")\n .dep(\"hyper\", \"0.6\")\n .publish();\n Package::new(\"hyper\", \"0.6.5\")\n .dep(\"openssl\", \"0.1\")\n .dep(\"cookie\", \"0.1\")\n .publish();\n Package::new(\"cookie\", \"0.1.0\")\n .dep(\"openssl\", \"0.1\")\n .publish();\n Package::new(\"openssl\", \"0.1.0\").publish();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"openssl\", \"0.1.1\").publish();\n Package::new(\"hyper\", \"0.6.6\")\n .dep(\"openssl\", \"0.1.1\")\n .dep(\"cookie\", \"0.1.0\")\n .publish();\n\n p.cargo(\"update hyper\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn update_multiple_packages_http() {\n let _server = setup_http();\n update_multiple_packages(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] a v0.1.0 -> v0.1.1\n[UPDATING] b v0.1.0 -> v0.1.1\n[NOTE] pass `--verbose` to see 1 unchanged dependencies behind latest\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] c v0.1.0 -> v0.1.1\n\n\"#]],\n str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] a v0.1.1 (registry `dummy-registry`)\n[DOWNLOADED] b v0.1.1 (registry `dummy-registry`)\n[DOWNLOADED] c v0.1.1 (registry `dummy-registry`)\n[CHECKING] a v0.1.1\n[CHECKING] c v0.1.1\n[CHECKING] b v0.1.1\n[CHECKING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn update_multiple_packages_git() {\n update_multiple_packages(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] a v0.1.0 -> v0.1.1\n[UPDATING] b v0.1.0 -> v0.1.1\n[NOTE] pass `--verbose` to see 1 unchanged dependencies behind latest\n\n\"#]],\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] c v0.1.0 -> v0.1.1\n\n\"#]],\n str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] c v0.1.1 (registry `dummy-registry`)\n[DOWNLOADED] b v0.1.1 (registry `dummy-registry`)\n[DOWNLOADED] a v0.1.1 (registry `dummy-registry`)\n[CHECKING] b v0.1.1\n[CHECKING] a v0.1.1\n[CHECKING] c v0.1.1\n[CHECKING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]],\n );\n}\n\nfn update_multiple_packages(\n expected_update: impl IntoData,\n expected_other_update: impl IntoData,\n expected_check: impl IntoData,\n) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = \"*\"\n b = \"*\"\n c = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"a\", \"0.1.0\").publish();\n Package::new(\"b\", \"0.1.0\").publish();\n Package::new(\"c\", \"0.1.0\").publish();\n\n p.cargo(\"fetch\").run();\n\n Package::new(\"a\", \"0.1.1\").publish();\n Package::new(\"b\", \"0.1.1\").publish();\n Package::new(\"c\", \"0.1.1\").publish();\n\n p.cargo(\"update a b\")\n .with_stderr_data(expected_update)\n .run();\n\n p.cargo(\"update b c\")\n .with_stderr_data(expected_other_update)\n .run();\n\n p.cargo(\"check\")\n .with_stderr_data(IntoData::unordered(expected_check))\n .run();\n}\n\n#[cargo_test]\nfn bundled_crate_in_registry_http() {\n let _server = setup_http();\n bundled_crate_in_registry();\n}\n\n#[cargo_test]\nfn bundled_crate_in_registry_git() {\n bundled_crate_in_registry();\n}\n\nfn bundled_crate_in_registry() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1\"\n baz = \"0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"baz\", \"0.1.0\")\n .dep(\"bar\", \"0.1.0\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"baz\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"bar\", version = \"0.1.0\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"\")\n .publish();\n\n p.cargo(\"run\").run();\n}\n\n#[cargo_test]\nfn update_same_prefix_oh_my_how_was_this_a_bug_http() {\n let _server = setup_http();\n update_same_prefix_oh_my_how_was_this_a_bug();\n}\n\n#[cargo_test]\nfn update_same_prefix_oh_my_how_was_this_a_bug_git() {\n update_same_prefix_oh_my_how_was_this_a_bug();\n}\n\nfn update_same_prefix_oh_my_how_was_this_a_bug() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"ugh\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"foobar\", \"0.2.0\").publish();\n Package::new(\"foo\", \"0.1.0\")\n .dep(\"foobar\", \"0.2.0\")\n .publish();\n\n p.cargo(\"generate-lockfile\").run();\n p.cargo(\"update foobar --precise=0.2.0\").run();\n}\n\n#[cargo_test]\nfn use_semver_http() {\n let _server = setup_http();\n use_semver();\n}\n\n#[cargo_test]\nfn use_semver_git() {\n use_semver();\n}\n\nfn use_semver() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"1.2.3-alpha.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"foo\", \"1.2.3-alpha.0\").publish();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn use_semver_package_incorrectly_http() {\n let _server = setup_http();\n use_semver_package_incorrectly(str![[r#\"\n[ERROR] failed to select a version for the requirement `a = \"^0.1\"`\ncandidate versions found which didn't match: 0.1.1-alpha.0\nlocation searched: [ROOT]/foo/a\nrequired by package `b v0.1.0 ([ROOT]/foo/b)`\nif you are looking for the prerelease package it needs to be specified explicitly\n a = { version = \"0.1.1-alpha.0\" }\n\n\"#]]);\n}\n\n#[cargo_test]\nfn use_semver_package_incorrectly_git() {\n use_semver_package_incorrectly(str![[r#\"\n[ERROR] failed to select a version for the requirement `a = \"^0.1\"`\ncandidate versions found which didn't match: 0.1.1-alpha.0\nlocation searched: [ROOT]/foo/a\nrequired by package `b v0.1.0 ([ROOT]/foo/b)`\nif you are looking for the prerelease package it needs to be specified explicitly\n a = { version = \"0.1.1-alpha.0\" }\n\n\"#]]);\n}\n\nfn use_semver_package_incorrectly(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.1-alpha.0\"\n edition = \"2015\"\n authors = []\n \"#,\n )\n .file(\n \"b/Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = { version = \"^0.1\", path = \"../a\" }\n \"#,\n )\n .file(\"a/src/main.rs\", \"fn main() {}\")\n .file(\"b/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn only_download_relevant_http() {\n let _server = setup_http();\n only_download_relevant(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 3 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.1.0 (registry `dummy-registry`)\n[CHECKING] baz v0.1.0\n[CHECKING] bar v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn only_download_relevant_git() {\n only_download_relevant(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 3 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.1.0 (registry `dummy-registry`)\n[CHECKING] baz v0.1.0\n[CHECKING] bar v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn only_download_relevant(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [target.foo.dependencies]\n foo = \"*\"\n [dev-dependencies]\n bar = \"*\"\n [dependencies]\n baz = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"foo\", \"0.1.0\").publish();\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"baz\", \"0.1.0\").publish();\n\n p.cargo(\"check\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn resolve_and_backtracking_http() {\n let _server = setup_http();\n resolve_and_backtracking();\n}\n\n#[cargo_test]\nfn resolve_and_backtracking_git() {\n resolve_and_backtracking();\n}\n\nfn resolve_and_backtracking() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"foo\", \"0.1.1\")\n .feature_dep(\"bar\", \"0.1\", &[\"a\", \"b\"])\n .publish();\n Package::new(\"foo\", \"0.1.0\").publish();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn upstream_warnings_on_extra_verbose_http() {\n let _server = setup_http();\n upstream_warnings_on_extra_verbose(str![[r#\"\n...\n[WARNING] function `unused` is never used\n...\n\"#]]);\n}\n\n#[cargo_test]\nfn upstream_warnings_on_extra_verbose_git() {\n upstream_warnings_on_extra_verbose(str![[r#\"\n...\n[WARNING] function `unused` is never used\n...\n\"#]]);\n}\n\nfn upstream_warnings_on_extra_verbose(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"foo\", \"0.1.0\")\n .file(\"src/lib.rs\", \"fn unused() {}\")\n .publish();\n\n p.cargo(\"check -vv\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn disallow_network_http() {\n let _server = setup_http();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check --frozen\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no matching package named `foo` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `bar v0.5.0 ([ROOT]/foo)`\nAs a reminder, you're using offline mode (--frozen) which can sometimes cause surprising resolution failures, if this error is too confusing you may wish to retry without `--frozen`.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn disallow_network_git() {\n let _server = RegistryBuilder::new().build();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check --frozen\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no matching package named `foo` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `bar v0.5.0 ([ROOT]/foo)`\nAs a reminder, you're using offline mode (--frozen) which can sometimes cause surprising resolution failures, if this error is too confusing you may wish to retry without `--frozen`.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn add_dep_dont_update_registry_http() {\n let _server = setup_http();\n add_dep_dont_update_registry(str![[r#\"\n[CHECKING] bar v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn add_dep_dont_update_registry_git() {\n add_dep_dont_update_registry(str![[r#\"\n[CHECKING] bar v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn add_dep_dont_update_registry(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { path = \"baz\" }\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"baz/Cargo.toml\",\n r#\"\n [package]\n name = \"baz\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n remote = \"0.3\"\n \"#,\n )\n .file(\"baz/src/lib.rs\", \"\")\n .build();\n\n Package::new(\"remote\", \"0.3.4\").publish();\n\n p.cargo(\"check\").run();\n\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { path = \"baz\" }\n remote = \"0.3\"\n \"#,\n );\n\n p.cargo(\"check\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn bump_version_dont_update_registry_http() {\n let _server = setup_http();\n bump_version_dont_update_registry(str![[r#\"\n[CHECKING] bar v0.6.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\n#[cargo_test]\nfn bump_version_dont_update_registry_git() {\n bump_version_dont_update_registry(str![[r#\"\n[CHECKING] bar v0.6.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]);\n}\n\nfn bump_version_dont_update_registry(expected: impl IntoData) {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { path = \"baz\" }\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"baz/Cargo.toml\",\n r#\"\n [package]\n name = \"baz\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n remote = \"0.3\"\n \"#,\n )\n .file(\"baz/src/lib.rs\", \"\")\n .build();\n\n Package::new(\"remote\", \"0.3.4\").publish();\n\n p.cargo(\"check\").run();\n\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.6.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { path = \"baz\" }\n \"#,\n );\n\n p.cargo(\"check\").with_stderr_data(expected).run();\n}\n\n#[cargo_test]\nfn toml_lies_but_index_is_truth_http() {\n let _server = setup_http();\n toml_lies_but_index_is_truth();\n}\n\n#[cargo_test]\nfn toml_lies_but_index_is_truth_git() {\n toml_lies_but_index_is_truth();\n}\n\nfn toml_lies_but_index_is_truth() {\n Package::new(\"foo\", \"0.2.0\").publish();\n Package::new(\"bar\", \"0.3.0\")\n .dep(\"foo\", \"0.2.0\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.3.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"0.1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"extern crate foo;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.3\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check -v\").run();\n}\n\n#[cargo_test]\nfn vv_prints_warnings_http() {\n let _server = setup_http();\n vv_prints_warnings();\n}\n\n#[cargo_test]\nfn vv_prints_warnings_git() {\n vv_prints_warnings();\n}\n\nfn vv_prints_warnings() {\n Package::new(\"foo\", \"0.2.0\")\n .file(\n \"src/lib.rs\",\n \"#![deny(warnings)] fn foo() {} // unused function\",\n )\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"fo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"0.2\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check -vv\").run();\n}\n\n#[cargo_test]\nfn bad_and_or_malicious_packages_rejected_http() {\n let _server = setup_http();\n bad_and_or_malicious_packages_rejected(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] foo v0.2.0 (registry `dummy-registry`)\n[ERROR] failed to download replaced source registry `crates-io`\n\nCaused by:\n failed to unpack package `foo v0.2.0 (registry `dummy-registry`)`\n\nCaused by:\n invalid tarball downloaded, contains a file at \"foo-0.1.0/src/lib.rs\" which isn't under \"foo-0.2.0\"\n\n\"#]]);\n}\n\n#[cargo_test]\nfn bad_and_or_malicious_packages_rejected_git() {\n bad_and_or_malicious_packages_rejected(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] foo v0.2.0 (registry `dummy-registry`)\n[ERROR] failed to download replaced source registry `crates-io`\n\nCaused by:\n failed to unpack package `foo v0.2.0 (registry `dummy-registry`)`\n\nCaused by:\n invalid tarball downloaded, contains a file at \"foo-0.1.0/src/lib.rs\" which isn't under \"foo-0.2.0\"\n\n\"#]]);\n}\n\nfn bad_and_or_malicious_packages_rejected(expected: impl IntoData) {\n Package::new(\"foo\", \"0.2.0\")\n .extra_file(\"foo-0.1.0/src/lib.rs\", \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"fo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"0.2\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check -vv\")\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn git_init_templatedir_missing_http() {\n let _server = setup_http();\n git_init_templatedir_missing();\n}\n\n#[cargo_test]\nfn git_init_templatedir_missing_git() {\n git_init_templatedir_missing();\n}\n\nfn git_init_templatedir_missing() {\n Package::new(\"foo\", \"0.2.0\").dep(\"bar\", \"*\").publish();\n Package::new(\"bar\", \"0.2.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"fo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"0.2\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\").run();\n\n remove_dir_all(paths::home().join(\".cargo/registry\")).unwrap();\n fs::write(\n paths::home().join(\".gitconfig\"),\n r#\"\n [init]\n templatedir = nowhere\n \"#,\n )\n .unwrap();\n\n p.cargo(\"check\").run();\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn rename_deps_and_features_http() {\n let _server = setup_http();\n rename_deps_and_features();\n}\n\n#[cargo_test]\nfn rename_deps_and_features_git() {\n rename_deps_and_features();\n}\n\nfn rename_deps_and_features() {\n Package::new(\"foo\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub fn f1() {}\")\n .publish();\n Package::new(\"foo\", \"0.2.0\")\n .file(\"src/lib.rs\", \"pub fn f2() {}\")\n .publish();\n Package::new(\"bar\", \"0.2.0\")\n .add_dep(\n Dependency::new(\"foo01\", \"0.1.0\")\n .package(\"foo\")\n .optional(true),\n )\n .add_dep(Dependency::new(\"foo02\", \"0.2.0\").package(\"foo\"))\n .feature(\"another\", &[\"foo01\"])\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate foo02;\n #[cfg(feature = \"foo01\")]\n extern crate foo01;\n\n pub fn foo() {\n foo02::f2();\n #[cfg(feature = \"foo01\")]\n foo01::f1();\n }\n \"#,\n )\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.2\"\n \"#,\n )\n .file(\n \"src/main.rs\",\n \"\n extern crate bar;\n fn main() { bar::foo(); }\n \",\n )\n .build();\n\n p.cargo(\"check\").run();\n p.cargo(\"check --features bar/foo01\").run();\n p.cargo(\"check --features bar/another\").run();\n}\n\n#[cargo_test]\nfn ignore_invalid_json_lines_http() {\n let _server = setup_http();\n ignore_invalid_json_lines();\n}\n\n#[cargo_test]\nfn ignore_invalid_json_lines_git() {\n ignore_invalid_json_lines();\n}\n\nfn ignore_invalid_json_lines() {\n Package::new(\"foo\", \"0.1.0\").publish();\n Package::new(\"foo\", \"0.1.1\")\n .invalid_index_line(true)\n .publish();\n Package::new(\"foo\", \"0.2.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = '0.1.0'\n foo02 = { version = '0.2.0', package = 'foo' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn invalid_json_lines_error() {\n Package::new(\"foo\", \"0.1.0\")\n .rust_version(\"1.0\")\n .schema_version(2)\n .publish();\n Package::new(\"foo\", \"0.1.1\")\n // Bad name field, too corrupt to use\n .invalid_index_line(true)\n .publish();\n Package::new(\"foo\", \"0.1.2\")\n // Bad version field, too corrupt to use\n .index_line(\n r#\"{\"cksum\":\"7ca5fc2301ad96ade45356faf53225aea36437d99930bbfa951155c01faecf79\",\"deps\":[],\"features\":{},\"links\":null,\"name\":\"foo\",\"vers\":\"bad\",\"yanked\":false,\"rust_version\":\"1.2345\",\"v\":1000000000}\"#,\n )\n .publish();\n Package::new(\"foo\", \"0.1.3\")\n // Bad field, report rust version\n .index_line(\n r#\"{\"cksum\":\"7ca5fc2301ad96ade45356faf53225aea36437d99930bbfa951155c01faecf79\",\"deps\":[],\"features\":\"bad\",\"links\":null,\"name\":\"foo\",\"vers\":\"0.1.3\",\"yanked\":false,\"rust_version\":\"1.2345\",\"v\":1000000000}\"#,\n )\n .publish();\n Package::new(\"foo\", \"0.1.4\")\n // Bad field, report schema\n .index_line(\n r#\"{\"cksum\":\"7ca5fc2301ad96ade45356faf53225aea36437d99930bbfa951155c01faecf79\",\"deps\":[],\"features\":\"bad\",\"links\":null,\"name\":\"foo\",\"vers\":\"0.1.4\",\"yanked\":false,\"v\":1000000000}\"#,\n )\n .publish();\n Package::new(\"foo\", \"0.1.5\")\n // Bad field, report error\n .index_line(\n r#\"{\"cksum\":\"7ca5fc2301ad96ade45356faf53225aea36437d99930bbfa951155c01faecf79\",\"deps\":[],\"features\":\"bad\",\"links\":null,\"name\":\"foo\",\"vers\":\"0.1.5\",\"yanked\":false}\"#,\n )\n .publish();\n Package::new(\"foo\", \"0.1.6\")\n // Bad field with bad rust version, report schema\n .index_line(\n r#\"{\"cksum\":\"7ca5fc2301ad96ade45356faf53225aea36437d99930bbfa951155c01faecf79\",\"deps\":[],\"features\":\"bad\",\"links\":null,\"name\":\"foo\",\"vers\":\"0.1.6\",\"yanked\":false,\"rust_version\":\"bad\",\"v\":1000000000}\"#,\n )\n .publish();\n Package::new(\"foo\", \"0.1.7\")\n // Bad field with bad rust version and schema, report error\n .index_line(\n r#\"{\"cksum\":\"7ca5fc2301ad96ade45356faf53225aea36437d99930bbfa951155c01faecf79\",\"deps\":[],\"features\":\"bad\",\"links\":null,\"name\":\"foo\",\"vers\":\"0.1.7\",\"yanked\":false,\"rust_version\":\"bad\",\"v\":\"bad\"}\"#,\n )\n .publish();\n Package::new(\"foo\", \"0.2.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"0.1.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `foo = \"^0.1.1\"`\n version 0.1.3 requires cargo 1.2345\n version 0.1.4 requires a Cargo version that supports index version 1000000000\n version 0.1.5's index entry is invalid\n version 0.1.6 requires a Cargo version that supports index version 1000000000\n version 0.1.7's index entry is invalid\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `a v0.5.0 ([ROOT]/foo)`\n\n\"#]])\n .run();\n p.cargo(\"generate-lockfile\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `foo = \"^0.1.1\"`\n version 0.1.3 requires cargo 1.2345\n version 0.1.4 requires a Cargo version that supports index version 1000000000\n version 0.1.5's index entry is invalid\n version 0.1.6 requires a Cargo version that supports index version 1000000000\n version 0.1.7's index entry is invalid\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `a v0.5.0 ([ROOT]/foo)`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn readonly_registry_still_works_http() {\n let _server = setup_http();\n readonly_registry_still_works();\n}\n\n#[cargo_test]\nfn readonly_registry_still_works_git() {\n readonly_registry_still_works();\n}\n\nfn readonly_registry_still_works() {\n Package::new(\"foo\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = '0.1.0'\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n p.cargo(\"fetch --locked\").run();\n chmod_readonly(&paths::home(), true);\n p.cargo(\"check\").run();\n // make sure we un-readonly the files afterwards so \"cargo clean\" can remove them (#6934)\n chmod_readonly(&paths::home(), false);\n\n fn chmod_readonly(path: &Path, readonly: bool) {\n for entry in t!(path.read_dir()) {\n let entry = t!(entry);\n let path = entry.path();\n if t!(entry.file_type()).is_dir() {\n chmod_readonly(&path, readonly);\n } else {\n set_readonly(&path, readonly);\n }\n }\n set_readonly(path, readonly);\n }\n\n fn set_readonly(path: &Path, readonly: bool) {\n let mut perms = t!(path.metadata()).permissions();\n perms.set_readonly(readonly);\n t!(fs::set_permissions(path, perms));\n }\n}\n\n#[cargo_test(ignore_windows = \"On Windows setting file attributes is a bit complicated\")]\nfn inaccessible_registry_cache_still_works() {\n Package::new(\"foo\", \"0.1.0\").publish();\n Package::new(\"fo2\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = '0.1.0'\n fo2 = '0.1.0'\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n p.cargo(\"fetch --locked\").run();\n\n let cache_path = inner_dir(&paths::cargo_home().join(\"registry/index\")).join(\".cache\");\n let f_cache_path = cache_path.join(\"3/f\");\n\n // Remove the permissions from the cache path that contains the \"foo\" crate\n set_permissions(&f_cache_path, 0o000);\n\n // Now run a build and make sure we properly build and warn the user\n p.cargo(\"build\")\n .with_stderr_data(str![[r#\"\n[WARNING] failed to write cache, path: [ROOT]/home/.cargo/registry/index/-[HASH]/.cache/3/f/fo[..], [ERROR] Permission denied (os error 13)\n[COMPILING] fo[..] v0.1.0\n[COMPILING] fo[..] v0.1.0\n[COMPILING] a v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n // make sure we add the permissions to the files afterwards so \"cargo clean\" can remove them (#6934)\n set_permissions(&f_cache_path, 0o777);\n\n #[cfg_attr(windows, allow(unused_variables))]\n fn set_permissions(path: &Path, permissions: u32) {\n #[cfg(not(windows))]\n {\n use std::os::unix::fs::PermissionsExt;\n let mut perms = t!(path.metadata()).permissions();\n perms.set_mode(permissions);\n t!(fs::set_permissions(path, perms));\n }\n\n #[cfg(windows)]\n panic!(\"This test is not supported on windows. See the reason in the #[cargo_test] macro\");\n }\n\n fn inner_dir(path: &Path) -> PathBuf {\n for entry in t!(path.read_dir()) {\n let path = t!(entry).path();\n\n if path.is_dir() {\n return path;\n }\n }\n\n panic!(\"could not find inner directory of {path:?}\");\n }\n}\n\n#[cargo_test]\nfn registry_index_rejected_http() {\n let _server = setup_http();\n registry_index_rejected(\n str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n the `registry.index` config value is no longer supported\n Use `[source]` replacement to alter the default index for crates.io.\n\n\"#]],\n str![[r#\"\n[ERROR] the `registry.index` config value is no longer supported\nUse `[source]` replacement to alter the default index for crates.io.\n\n\"#]],\n );\n}\n\n#[cargo_test]\nfn registry_index_rejected_git() {\n registry_index_rejected(\n str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n the `registry.index` config value is no longer supported\n Use `[source]` replacement to alter the default index for crates.io.\n\n\"#]],\n str![[r#\"\n[ERROR] the `registry.index` config value is no longer supported\nUse `[source]` replacement to alter the default index for crates.io.\n\n\"#]],\n );\n}\n\nfn registry_index_rejected(expected_check: impl IntoData, expected_login: impl IntoData) {\n Package::new(\"dep\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [registry]\n index = \"https://example.com/\"\n \"#,\n )\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n dep = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(expected_check)\n .run();\n\n p.cargo(\"login\")\n .with_status(101)\n .with_stderr_data(expected_login)\n .run();\n}\n\n#[cargo_test]\nfn package_lock_inside_package_is_overwritten() {\n let registry = registry::init();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\")\n .file(\"src/lib.rs\", \"\")\n .file(\".cargo-ok\", \"\")\n .publish();\n\n p.cargo(\"check\").run();\n\n let id = SourceId::for_registry(registry.index_url()).unwrap();\n let hash = cargo::util::hex::short_hash(&id);\n let ok = paths::cargo_home()\n .join(\"registry\")\n .join(\"src\")\n .join(format!(\"-{}\", hash))\n .join(\"bar-0.0.1\")\n .join(\".cargo-ok\");\n\n assert_eq!(ok.metadata().unwrap().len(), 7);\n}\n\n#[cargo_test]\nfn package_lock_as_a_symlink_inside_package_is_overwritten() {\n let registry = registry::init();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\")\n .file(\"src/lib.rs\", \"pub fn f() {}\")\n .symlink(\".cargo-ok\", \"src/lib.rs\")\n .publish();\n\n p.cargo(\"check\").run();\n\n let id = SourceId::for_registry(registry.index_url()).unwrap();\n let hash = cargo::util::hex::short_hash(&id);\n let pkg_root = paths::cargo_home()\n .join(\"registry\")\n .join(\"src\")\n .join(format!(\"-{}\", hash))\n .join(\"bar-0.0.1\");\n let ok = pkg_root.join(\".cargo-ok\");\n let librs = pkg_root.join(\"src/lib.rs\");\n\n // Is correctly overwritten and doesn't affect the file linked to\n assert_eq!(ok.metadata().unwrap().len(), 7);\n assert_eq!(fs::read_to_string(librs).unwrap(), \"pub fn f() {}\");\n}\n\n#[cargo_test]\nfn ignores_unknown_index_version_http() {\n let _server = setup_http();\n ignores_unknown_index_version(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\nā””ā”€ā”€ bar v1.0.0\n\n\"#]]);\n}\n\n#[cargo_test]\nfn ignores_unknown_index_version_git() {\n ignores_unknown_index_version(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\nā””ā”€ā”€ bar v1.0.0\n\n\"#]]);\n}\n\nfn ignores_unknown_index_version(expected: impl IntoData) {\n // If the version field is not understood, it is ignored.\n Package::new(\"bar\", \"1.0.0\").publish();\n Package::new(\"bar\", \"1.0.1\")\n .schema_version(u32::MAX)\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"tree\").with_stdout_data(expected).run();\n}\n\n#[cargo_test]\nfn unknown_index_version_error() {\n Package::new(\"bar\", \"0.0.1\").publish();\n // If the version field is not understood, it is ignored.\n Package::new(\"bar\", \"1.0.1\")\n .schema_version(u32::MAX)\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `bar = \"^1.0\"`\n version 1.0.1 requires a Cargo version that supports index version 4294967295\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.1.0 ([ROOT]/foo)`\n\n\"#]])\n .run();\n p.cargo(\"generate-lockfile\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `bar = \"^1.0\"`\n version 1.0.1 requires a Cargo version that supports index version 4294967295\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.1.0 ([ROOT]/foo)`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn unknown_index_version_with_msrv_error() {\n Package::new(\"bar\", \"0.0.1\").publish();\n // If the version field is not understood, it is ignored.\n Package::new(\"bar\", \"1.0.1\")\n .schema_version(u32::MAX)\n .rust_version(\"1.2345\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `bar = \"^1.0\"`\n version 1.0.1 requires cargo 1.2345\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.1.0 ([ROOT]/foo)`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn protocol() {\n cargo_process(\"install bar\")\n .with_status(101)\n .env(\"CARGO_REGISTRIES_CRATES_IO_PROTOCOL\", \"invalid\")\n .with_stderr_data(str![[r#\"\n[ERROR] unsupported registry protocol `invalid` (defined in environment variable `CARGO_REGISTRIES_CRATES_IO_PROTOCOL`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn http_requires_trailing_slash() {\n cargo_process(\"install bar --index sparse+https://invalid.crates.io/test\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] sparse registry url must end in a slash `/`: sparse+https://invalid.crates.io/test\n\n\"#]])\n .run();\n}\n\n// Limit the test to debug builds so that `__CARGO_TEST_MAX_UNPACK_SIZE` will take affect.\n#[cfg(debug_assertions)]\n#[cargo_test]\nfn reach_max_unpack_size() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bar = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // Size of bar.crate is around 180 bytes.\n Package::new(\"bar\", \"0.0.1\").publish();\n\n p.cargo(\"check\")\n .env(\"__CARGO_TEST_MAX_UNPACK_SIZE\", \"8\") // hit 8 bytes limit and boom!\n .env(\"__CARGO_TEST_MAX_UNPACK_RATIO\", \"0\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[ERROR] failed to download replaced source registry `crates-io`\n\nCaused by:\n failed to unpack package `bar v0.0.1 (registry `dummy-registry`)`\n\nCaused by:\n failed to iterate over archive\n\nCaused by:\n maximum limit reached when reading\n\n\"#]])\n .run();\n\n // Restore to the default ratio and it should compile.\n p.cargo(\"check\")\n .env(\"__CARGO_TEST_MAX_UNPACK_SIZE\", \"8\")\n .with_stderr_data(str![[r#\"\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn sparse_blocking_count() {\n let fail_count = Mutex::new(0);\n let _registry = RegistryBuilder::new()\n .http_index()\n .add_responder(\"/index/3/b/bar\", move |req, server| {\n let mut fail_count = fail_count.lock().unwrap();\n if *fail_count < 1 {\n *fail_count += 1;\n server.internal_server_error(req)\n } else {\n server.index(req)\n }\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n\n // Ensure we have the expected number of `block_until_ready` calls.\n // The 1st (0 transfers pending), is the deliberate extra call in `ensure_loaded` for a source.\n // The 2nd (1 transfers pending), is the registry `config.json`.\n // the 3rd (1 transfers pending), is the package metadata for `bar`.\n\n p.cargo(\"check\")\n .env(\"CARGO_LOG\", \"network::HttpRegistry::block_until_ready=trace\")\n .with_stderr_data(str![[r#\"\n [..] TRACE network::HttpRegistry::block_until_ready: 0 transfers pending\n[UPDATING] `dummy-registry` index\n [..] TRACE network::HttpRegistry::block_until_ready: 1 transfers pending\n [..] TRACE network::HttpRegistry::block_until_ready: 1 transfers pending\n[WARNING] spurious network error (3 tries remaining): failed to get successful HTTP response from `[..]/index/3/b/bar` ([..]), got 500\nbody:\ninternal server error\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn sparse_retry_single() {\n let fail_count = Mutex::new(0);\n let _registry = RegistryBuilder::new()\n .http_index()\n .add_responder(\"/index/3/b/bar\", move |req, server| {\n let mut fail_count = fail_count.lock().unwrap();\n if *fail_count < 2 {\n *fail_count += 1;\n server.internal_server_error(req)\n } else {\n server.index(req)\n }\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n\n p.cargo(\"check\").with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[WARNING] spurious network error (3 tries remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/index/3/b/bar` (127.0.0.1), got 500\nbody:\ninternal server error\n[WARNING] spurious network error (2 tries remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/index/3/b/bar` (127.0.0.1), got 500\nbody:\ninternal server error\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn sparse_retry_multiple() {\n // Tests retry behavior of downloading lots of packages with various\n // failure rates accessing the sparse index.\n\n // The index is the number of retries, the value is the number of packages\n // that retry that number of times. Thus 50 packages succeed on first try,\n // 25 on second, etc.\n const RETRIES: &[u32] = &[50, 25, 12, 6];\n\n let pkgs: Vec<_> = RETRIES\n .iter()\n .enumerate()\n .flat_map(|(retries, num)| {\n (0..*num)\n .into_iter()\n .map(move |n| (retries as u32, format!(\"{}-{n}-{retries}\", rand_prefix())))\n })\n .collect();\n\n let mut builder = RegistryBuilder::new().http_index();\n let fail_counts: Arc>> = Arc::new(Mutex::new(vec![0; pkgs.len()]));\n let mut cargo_toml = r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n \"#\n .to_string();\n // The expected stderr output.\n let mut expected = \"\\\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n\"\n .to_string();\n for (n, (retries, name)) in pkgs.iter().enumerate() {\n let count_clone = fail_counts.clone();\n let retries = *retries;\n let ab = &name[..2];\n let cd = &name[2..4];\n builder = builder.add_responder(format!(\"/index/{ab}/{cd}/{name}\"), move |req, server| {\n let mut fail_counts = count_clone.lock().unwrap();\n if fail_counts[n] < retries {\n fail_counts[n] += 1;\n server.internal_server_error(req)\n } else {\n server.index(req)\n }\n });\n write!(&mut cargo_toml, \"{name} = \\\"1.0.0\\\"\\n\").unwrap();\n for retry in 0..retries {\n let remain = 3 - retry;\n write!(\n &mut expected,\n \"[WARNING] spurious network error ({remain} {} remaining): \\\n failed to get successful HTTP response from \\\n `http://127.0.0.1:[..]/{ab}/{cd}/{name}` (127.0.0.1), got 500\\n\\\n body:\\n\\\n internal server error\\n\",\n if remain != 1 { \"tries\" } else { \"try\" }\n )\n .unwrap();\n }\n write!(\n &mut expected,\n \"\\\n[DOWNLOADED] {name} v1.0.0 (registry `dummy-registry`)\n\"\n )\n .unwrap();\n }\n write!(\n &mut expected,\n \"\\\n[LOCKING] 93 packages to latest compatible versions\n\"\n )\n .unwrap();\n let _server = builder.build();\n for (_, name) in &pkgs {\n Package::new(name, \"1.0.0\").publish();\n }\n let p = project()\n .file(\"Cargo.toml\", &cargo_toml)\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"fetch\")\n .with_stderr_data(IntoData::unordered(expected))\n .run();\n}\n\n#[cargo_test]\nfn dl_retry_single() {\n // Tests retry behavior of downloading a package.\n // This tests a single package which exercises the code path that causes\n // it to block.\n let fail_count = Mutex::new(0);\n let _server = RegistryBuilder::new()\n .http_index()\n .add_responder(\"/dl/bar/1.0.0/download\", move |req, server| {\n let mut fail_count = fail_count.lock().unwrap();\n if *fail_count < 2 {\n *fail_count += 1;\n server.internal_server_error(req)\n } else {\n server.dl(req)\n }\n })\n .build();\n Package::new(\"bar\", \"1.0.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"fetch\").with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[WARNING] spurious network error (3 tries remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/dl/bar/1.0.0/download` (127.0.0.1), got 500\nbody:\ninternal server error\n[WARNING] spurious network error (2 tries remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/dl/bar/1.0.0/download` (127.0.0.1), got 500\nbody:\ninternal server error\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n\n\"#]]).run();\n}\n\n/// Creates a random prefix to randomly spread out the package names\n/// to somewhat evenly distribute the different failures at different\n/// points.\nfn rand_prefix() -> String {\n use rand::RngExt;\n const CHARS: &[u8] = b\"abcdefghijklmnopqrstuvwxyz\";\n let mut rng = rand::rng();\n (0..5)\n .map(|_| CHARS[rng.random_range(0..CHARS.len())] as char)\n .collect()\n}\n\n#[cargo_test]\nfn dl_retry_multiple() {\n // Tests retry behavior of downloading lots of packages with various\n // failure rates.\n\n // The index is the number of retries, the value is the number of packages\n // that retry that number of times. Thus 50 packages succeed on first try,\n // 25 on second, etc.\n const RETRIES: &[u32] = &[50, 25, 12, 6];\n\n let pkgs: Vec<_> = RETRIES\n .iter()\n .enumerate()\n .flat_map(|(retries, num)| {\n (0..*num)\n .into_iter()\n .map(move |n| (retries as u32, format!(\"{}-{n}-{retries}\", rand_prefix())))\n })\n .collect();\n\n let mut builder = RegistryBuilder::new().http_index();\n let fail_counts: Arc>> = Arc::new(Mutex::new(vec![0; pkgs.len()]));\n let mut cargo_toml = r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n \"#\n .to_string();\n // The expected stderr output.\n let mut expected = \"\\\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n\"\n .to_string();\n for (n, (retries, name)) in pkgs.iter().enumerate() {\n let count_clone = fail_counts.clone();\n let retries = *retries;\n builder =\n builder.add_responder(format!(\"/dl/{name}/1.0.0/download\"), move |req, server| {\n let mut fail_counts = count_clone.lock().unwrap();\n if fail_counts[n] < retries {\n fail_counts[n] += 1;\n server.internal_server_error(req)\n } else {\n server.dl(req)\n }\n });\n write!(&mut cargo_toml, \"{name} = \\\"1.0.0\\\"\\n\").unwrap();\n for retry in 0..retries {\n let remain = 3 - retry;\n write!(\n &mut expected,\n \"[WARNING] spurious network error ({remain} {} remaining): \\\n failed to get successful HTTP response from \\\n `http://127.0.0.1:[..]/dl/{name}/1.0.0/download` (127.0.0.1), got 500\\n\\\n body:\\n\\\n internal server error\\n\",\n if remain != 1 { \"tries\" } else { \"try\" }\n )\n .unwrap();\n }\n write!(\n &mut expected,\n \"[DOWNLOADED] {name} v1.0.0 (registry `dummy-registry`)\\n\"\n )\n .unwrap();\n }\n write!(\n &mut expected,\n \"[LOCKING] 93 packages to latest compatible versions\\n\"\n )\n .unwrap();\n let _server = builder.build();\n for (_, name) in &pkgs {\n Package::new(name, \"1.0.0\").publish();\n }\n let p = project()\n .file(\"Cargo.toml\", &cargo_toml)\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"fetch\")\n .with_stderr_data(IntoData::unordered(expected))\n .run();\n}\n\n#[cargo_test]\nfn retry_too_many_requests() {\n let fail_count = Mutex::new(0);\n let _registry = RegistryBuilder::new()\n .http_index()\n .add_responder(\"/index/3/b/bar\", move |req, server| {\n let mut fail_count = fail_count.lock().unwrap();\n if *fail_count < 1 {\n *fail_count += 1;\n server.too_many_requests(req, std::time::Duration::from_secs(1))\n } else {\n server.index(req)\n }\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"bar\", \"0.0.1\").publish();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[WARNING] spurious network error (3 tries remaining): failed to get successful HTTP response from `[..]/index/3/b/bar` ([..]), got 429\nbody:\ntoo many requests, try again in 1 seconds\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn deleted_entry() {\n // Checks the behavior when a package is removed from the index.\n // This is done occasionally on crates.io to handle things like\n // copyright takedowns.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n // First, test removing a single version, but leaving an older version.\n Package::new(\"bar\", \"0.1.0\").publish();\n let bar_path = Path::new(\"3/b/bar\");\n let bar_reg_path = registry_path().join(&bar_path);\n let old_index = fs::read_to_string(&bar_reg_path).unwrap();\n Package::new(\"bar\", \"0.1.1\").publish();\n p.cargo(\"tree\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.1.1 (registry `dummy-registry`)\n\n\"#]])\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\nā””ā”€ā”€ bar v0.1.1\n\n\"#]])\n .run();\n\n // Remove 0.1.1\n fs::remove_file(paths::root().join(\"dl/bar/0.1.1/download\")).unwrap();\n let repo = git2::Repository::open(registry_path()).unwrap();\n let mut index = repo.index().unwrap();\n fs::write(&bar_reg_path, &old_index).unwrap();\n index.add_path(&bar_path).unwrap();\n index.write().unwrap();\n git::commit(&repo);\n\n // With `Cargo.lock` unchanged, it shouldn't have an impact.\n p.cargo(\"tree\")\n .with_stderr_data(\"\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\nā””ā”€ā”€ bar v0.1.1\n\n\"#]])\n .run();\n\n // Regenerating Cargo.lock should switch to old version.\n fs::remove_file(p.root().join(\"Cargo.lock\")).unwrap();\n p.cargo(\"tree\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.1.0 (registry `dummy-registry`)\n\n\"#]])\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\nā””ā”€ā”€ bar v0.1.0\n\n\"#]])\n .run();\n\n // Remove the package entirely.\n fs::remove_file(paths::root().join(\"dl/bar/0.1.0/download\")).unwrap();\n let mut index = repo.index().unwrap();\n index.remove(&bar_path, 0).unwrap();\n index.write().unwrap();\n git::commit(&repo);\n fs::remove_file(&bar_reg_path).unwrap();\n\n // With `Cargo.lock` unchanged, it shouldn't have an impact.\n p.cargo(\"tree\")\n .with_stderr_data(\"\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\nā””ā”€ā”€ bar v0.1.0\n\n\"#]])\n .run();\n\n // Regenerating Cargo.lock should fail.\n fs::remove_file(p.root().join(\"Cargo.lock\")).unwrap();\n p.cargo(\"tree\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `bar` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.1.0 ([ROOT]/foo)`\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn corrupted_ok_overwritten() {\n // Checks what happens if .cargo-ok gets truncated, such as if the file is\n // created, but the flush/close is interrupted.\n Package::new(\"bar\", \"1.0.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"fetch\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n\n\"#]])\n .run();\n let ok = glob::glob(\n paths::home()\n .join(\".cargo/registry/src/*/bar-1.0.0/.cargo-ok\")\n .to_str()\n .unwrap(),\n )\n .unwrap()\n .next()\n .unwrap()\n .unwrap();\n // Simulate cargo being interrupted, or filesystem corruption.\n fs::write(&ok, \"\").unwrap();\n assert_eq!(fs::read_to_string(&ok).unwrap(), \"\");\n p.cargo(\"fetch\").with_stderr_data(\"\").run();\n assert_eq!(fs::read_to_string(&ok).unwrap(), r#\"{\"v\":1}\"#);\n}\n\n#[cargo_test]\nfn not_found_permutations() {\n // Test for querying permutations for a missing dependency.\n let misses = Arc::new(Mutex::new(Vec::new()));\n let misses2 = misses.clone();\n let _registry = RegistryBuilder::new()\n .http_index()\n .not_found_handler(move |req, _server| {\n let mut misses = misses2.lock().unwrap();\n misses.push(req.url.path().to_string());\n Response {\n code: 404,\n headers: vec![],\n body: b\"not found\".to_vec(),\n }\n })\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a-b_c = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `a-b_c` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]])\n .run();\n let mut misses = misses.lock().unwrap();\n misses.sort();\n assert_eq!(\n &*misses,\n &[\n \"/index/a-/b-/a-b-c\",\n \"/index/a-/b_/a-b_c\",\n \"/index/a_/b_/a_b_c\"\n ]\n );\n}\n\n#[cargo_test]\nfn default_auth_error() {\n // Check for the error message for an authentication error when default is set.\n let crates_io = RegistryBuilder::new().http_api().build();\n let _alternative = RegistryBuilder::new().http_api().alternative().build();\n\n paths::home().join(\".cargo/credentials.toml\").rm_rf();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n // Test output before setting the default.\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] no token found, please run `cargo login`\nor use environment variable CARGO_REGISTRY_TOKEN\n\n\"#]])\n .with_status(101)\n .run();\n\n p.cargo(\"publish --no-verify --registry alternative\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[ERROR] no token found for `alternative`, please run `cargo login --registry alternative`\nor use environment variable CARGO_REGISTRIES_ALTERNATIVE_TOKEN\n\n\"#]])\n .with_status(101)\n .run();\n\n // Test the output with the default.\n cargo_util::paths::append(\n &paths::cargo_home().join(\"config.toml\"),\n br#\"\n [registry]\n default = \"alternative\"\n \"#,\n )\n .unwrap();\n\n p.cargo(\"publish --no-verify\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[ERROR] no token found for `alternative`, please run `cargo login --registry alternative`\nor use environment variable CARGO_REGISTRIES_ALTERNATIVE_TOKEN\n\n\"#]])\n .with_status(101)\n .run();\n\n p.cargo(\"publish --no-verify --registry crates-io\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] no token found, please run `cargo login --registry crates-io`\nor use environment variable CARGO_REGISTRY_TOKEN\n\n\"#]])\n .with_status(101)\n .run();\n}\n\nconst SAMPLE_HEADERS: &[&str] = &[\n \"x-amz-cf-pop: SFO53-P2\",\n \"x-amz-cf-id: vEc3osJrCAXVaciNnF4Vev-hZFgnYwmNZtxMKRJ5bF6h9FTOtbTMnA==\",\n \"x-cache: Hit from cloudfront\",\n \"server: AmazonS3\",\n \"x-amz-version-id: pvsJYY_JGsWiSETZvLJKb7DeEW5wWq1W\",\n \"x-amz-server-side-encryption: AES256\",\n \"content-type: text/plain\",\n \"via: 1.1 bcbc5b46216015493e082cfbcf77ef10.cloudfront.net (CloudFront)\",\n];\n\n#[cargo_test]\nfn debug_header_message_index() {\n // The error message should include some headers for debugging purposes.\n let _server = RegistryBuilder::new()\n .http_index()\n .add_responder(\"/index/3/b/bar\", |_, _| Response {\n code: 503,\n headers: SAMPLE_HEADERS.iter().map(|s| s.to_string()).collect(),\n body: b\"Please slow down\".to_vec(),\n })\n .build();\n Package::new(\"bar\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"fetch\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[WARNING] spurious network error (3 tries remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/index/3/b/bar` (127.0.0.1), got 503\nbody:\nPlease slow down\n[WARNING] spurious network error (2 tries remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/index/3/b/bar` (127.0.0.1), got 503\nbody:\nPlease slow down\n[WARNING] spurious network error (1 try remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/index/3/b/bar` (127.0.0.1), got 503\nbody:\nPlease slow down\n[ERROR] failed to get `bar` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to query replaced source registry `crates-io`\n\nCaused by:\n download of 3/b/bar failed\n\nCaused by:\n failed to get successful HTTP response from `http://127.0.0.1:[..]/index/3/b/bar` (127.0.0.1), got 503\n debug headers:\n x-amz-cf-pop: SFO53-P2\n x-amz-cf-id: vEc3osJrCAXVaciNnF4Vev-hZFgnYwmNZtxMKRJ5bF6h9FTOtbTMnA==\n x-cache: Hit from cloudfront\n body:\n Please slow down\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn debug_header_message_dl() {\n // Same as debug_header_message_index, but for the dl endpoint which goes\n // through a completely different code path.\n let _server = RegistryBuilder::new()\n .http_index()\n .add_responder(\"/dl/bar/1.0.0/download\", |_, _| Response {\n code: 503,\n headers: SAMPLE_HEADERS.iter().map(|s| s.to_string()).collect(),\n body: b\"Please slow down\".to_vec(),\n })\n .build();\n Package::new(\"bar\", \"1.0.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"fetch\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[WARNING] spurious network error (3 tries remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/dl/bar/1.0.0/download` (127.0.0.1), got 503\nbody:\nPlease slow down\n[WARNING] spurious network error (2 tries remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/dl/bar/1.0.0/download` (127.0.0.1), got 503\nbody:\nPlease slow down\n[WARNING] spurious network error (1 try remaining): failed to get successful HTTP response from `http://127.0.0.1:[..]/dl/bar/1.0.0/download` (127.0.0.1), got 503\nbody:\nPlease slow down\n[ERROR] failed to download from `http://127.0.0.1:[..]/dl/bar/1.0.0/download`\n\nCaused by:\n failed to get successful HTTP response from `http://127.0.0.1:[..]/dl/bar/1.0.0/download` (127.0.0.1), got 503\n debug headers:\n x-amz-cf-pop: SFO53-P2\n x-amz-cf-id: vEc3osJrCAXVaciNnF4Vev-hZFgnYwmNZtxMKRJ5bF6h9FTOtbTMnA==\n x-cache: Hit from cloudfront\n body:\n Please slow down\n\n\"#]])\n .run();\n}\n\n#[cfg(unix)]\n#[cargo_test]\nfn set_mask_during_unpacking() {\n use std::os::unix::fs::MetadataExt;\n\n Package::new(\"bar\", \"1.0.0\")\n .file_with_mode(\"example.sh\", 0o777, \"#!/bin/sh\")\n .file_with_mode(\"src/lib.rs\", 0o666, \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"fetch\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n\n\"#]])\n .run();\n let src_file_path = |path: &str| {\n glob::glob(\n paths::home()\n .join(\".cargo/registry/src/*/bar-1.0.0/\")\n .join(path)\n .to_str()\n .unwrap(),\n )\n .unwrap()\n .next()\n .unwrap()\n .unwrap()\n };\n\n let umask = cargo::util::get_umask();\n let metadata = fs::metadata(src_file_path(\"src/lib.rs\")).unwrap();\n assert_eq!(metadata.mode() & 0o777, 0o666 & !umask);\n let metadata = fs::metadata(src_file_path(\"example.sh\")).unwrap();\n assert_eq!(metadata.mode() & 0o777, 0o777 & !umask);\n}\n\n#[cargo_test]\nfn unpack_again_when_cargo_ok_is_unrecognized() {\n Package::new(\"bar\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"fetch\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n\n\"#]])\n .run();\n\n let src_file_path = |path: &str| {\n glob::glob(\n paths::home()\n .join(\".cargo/registry/src/*/bar-1.0.0/\")\n .join(path)\n .to_str()\n .unwrap(),\n )\n .unwrap()\n .next()\n .unwrap()\n .unwrap()\n };\n\n // Change permissions to simulate the old behavior not respecting umask.\n let lib_rs = src_file_path(\"src/lib.rs\");\n let cargo_ok = src_file_path(\".cargo-ok\");\n let mut perms = fs::metadata(&lib_rs).unwrap().permissions();\n assert!(!perms.readonly());\n perms.set_readonly(true);\n fs::set_permissions(&lib_rs, perms).unwrap();\n let ok = fs::read_to_string(&cargo_ok).unwrap();\n assert_eq!(&ok, r#\"{\"v\":1}\"#);\n\n p.cargo(\"fetch\").with_stderr_data(\"\").run();\n\n // Without changing `.cargo-ok`, a unpack won't be triggered.\n let perms = fs::metadata(&lib_rs).unwrap().permissions();\n assert!(perms.readonly());\n\n // Write \"ok\" to simulate the old behavior and trigger the unpack again.\n fs::write(&cargo_ok, \"ok\").unwrap();\n\n p.cargo(\"fetch\").with_stderr_data(\"\").run();\n\n // Permission has been restored and `.cargo-ok` is in the new format.\n let perms = fs::metadata(lib_rs).unwrap().permissions();\n assert!(!perms.readonly());\n let ok = fs::read_to_string(&cargo_ok).unwrap();\n assert_eq!(&ok, r#\"{\"v\":1}\"#);\n}\n\n#[cargo_test]\nfn differ_only_by_metadata() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"=0.0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"baz\", \"0.0.1+b\").publish();\n Package::new(\"baz\", \"0.0.1+c\").yanked(true).publish();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.0.1+b (registry `dummy-registry`)\n[CHECKING] baz v0.0.1+b\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n Package::new(\"baz\", \"0.0.1+d\").publish();\n\n p.cargo(\"clean\").run();\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[CHECKING] baz v0.0.1+b\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn differ_only_by_metadata_with_lockfile() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"=0.0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"baz\", \"0.0.1+a\").publish();\n Package::new(\"baz\", \"0.0.1+b\").publish();\n Package::new(\"baz\", \"0.0.1+c\").publish();\n\n p.cargo(\"update --package baz --precise 0.0.1+b\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] baz v0.0.1+c -> v0.0.1+b\n\n\"#]])\n .run();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.0.1+b (registry `dummy-registry`)\n[CHECKING] baz v0.0.1+b\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn builtin_source_replacement() {\n // errors for builtin source replacement of crates.io\n // should not include mention of source replacement in the error message.\n let server = RegistryBuilder::new().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bad-cksum = \">= 0.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n let pkg = Package::new(\"bad-cksum\", \"0.0.1\");\n pkg.publish();\n t!(File::create(&pkg.archive_dst()));\n\n p.cargo(\"check -v\")\n .replace_crates_io(&server.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bad-cksum v0.0.1\n[ERROR] failed to verify the checksum of `bad-cksum v0.0.1`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn builtin_source_replacement_no_vendor_error() {\n // errors for builtin source replacement of crates.io\n // should not mention outdated vendor dependencies\n let server = RegistryBuilder::new().build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n\n [dependencies]\n dep = \"0.2.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n let pkg = Package::new(\"dep\", \"0.1.0\");\n pkg.publish();\n\n p.cargo(\"check -v\")\n .replace_crates_io(&server.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] failed to select a version for the requirement `dep = \"^0.2.0\"`\ncandidate versions found which didn't match: 0.1.0\nlocation searched: crates.io index\nrequired by package `foo v0.0.1 ([ROOT]/foo)`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn deterministic_mtime() {\n let registry = registry::init();\n Package::new(\"foo\", \"0.1.0\")\n // content doesn't matter, we just want to check mtime\n .file(\"Cargo.lock\", \"\")\n .file(\".cargo_vcs_info.json\", \"\")\n .file(\"src/lib.rs\", \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n edition = \"2015\"\n\n [dependencies]\n foo = '0.1.0'\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"fetch\").run();\n\n let id = SourceId::for_registry(registry.index_url()).unwrap();\n let hash = cargo::util::hex::short_hash(&id);\n let pkg_root = paths::cargo_home()\n .join(\"registry\")\n .join(\"src\")\n .join(format!(\"-{hash}\"))\n .join(\"foo-0.1.0\");\n\n // Generated files should have deterministic mtime after unpacking.\n assert_deterministic_mtime(pkg_root.join(\"Cargo.lock\"));\n assert_deterministic_mtime(pkg_root.join(\"Cargo.toml\"));\n assert_deterministic_mtime(pkg_root.join(\".cargo_vcs_info.json\"));\n}\n\n#[cargo_test]\nfn symlink_and_directory() {\n // Tests for symlink and directory entry in a tar file. The tar crate\n // would incorrectly change the permissions of the symlink destination,\n // which could be anywhere on the filesystem.\n let victim = paths::root().join(\"victim\");\n fs::create_dir(&victim).unwrap();\n #[cfg(unix)]\n {\n use std::os::unix::fs::PermissionsExt;\n let perm = fs::Permissions::from_mode(0o700);\n fs::set_permissions(&victim, perm).unwrap();\n assert_eq!(\n victim.metadata().unwrap().permissions().mode() & 0o777,\n 0o700\n );\n }\n\n Package::new(\"bar\", \"1.0.0\")\n .file(\"src/lib.rs\", \"\")\n .symlink(\"smuggled\", victim.to_str().unwrap())\n .directory(\"smuggled\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"fetch\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n[ERROR] failed to download replaced source registry `crates-io`\n\nCaused by:\n failed to unpack package `bar v1.0.0 (registry `dummy-registry`)`\n\nCaused by:\n failed to unpack entry at `bar-1.0.0/smuggled`\n\nCaused by:\n failed to unpack `[ROOT]/home/.cargo/registry/src/-[HASH]/bar-1.0.0/smuggled`\n\nCaused by:\n [..] when creating dir [ROOT]/home/.cargo/registry/src/-[HASH]/bar-1.0.0/smuggled\n\n\"#]])\n .run();\n\n #[cfg(unix)]\n {\n // Permissions should not change.\n use std::os::unix::fs::PermissionsExt;\n assert_eq!(\n victim.metadata().unwrap().permissions().mode() & 0o777,\n 0o700\n );\n }\n}\n" }, { "path": "tests/testsuite/registry_auth.rs", "content": "//! Tests for registry authentication.\n\nuse crate::prelude::*;\nuse cargo_test_support::compare::assert_e2e;\nuse cargo_test_support::registry::{Package, RegistryBuilder, Token};\nuse cargo_test_support::str;\nuse cargo_test_support::{Execs, Project, project};\n\nfn cargo(p: &Project, s: &str) -> Execs {\n let mut e = p.cargo(s);\n e.masquerade_as_nightly_cargo(&[\"asymmetric-token\"])\n .arg(\"-Zasymmetric-token\");\n e.env(\n \"CARGO_REGISTRY_GLOBAL_CREDENTIAL_PROVIDERS\",\n \"cargo:paseto cargo:token\",\n );\n e\n}\n\nfn make_project() -> Project {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n version = \"0.0.1\"\n registry = \"alternative\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n Package::new(\"bar\", \"0.0.1\").alternative(true).publish();\n p\n}\n\n#[cargo_test]\nfn requires_credential_provider() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .http_api()\n .build();\n\n let p = make_project();\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[ERROR] failed to download `bar v0.0.1 (registry `alternative`)`\n\nCaused by:\n unable to get packages from source\n\nCaused by:\n authenticated registries require a credential-provider to be configured\n see https://doc.rust-lang.org/cargo/reference/registry-authentication.html for details\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn simple() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .http_index()\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `alternative`)\n[COMPILING] bar v0.0.1 (registry `alternative`)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn simple_with_asymmetric() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .http_index()\n .token(cargo_test_support::registry::Token::rfc_key())\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `alternative`)\n[COMPILING] bar v0.0.1 (registry `alternative`)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn environment_config() {\n let registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_registry()\n .no_configure_token()\n .http_index()\n .build();\n let p = make_project();\n cargo(&p, \"build\")\n .env(\n \"CARGO_REGISTRIES_ALTERNATIVE_INDEX\",\n registry.index_url().as_str(),\n )\n .env(\"CARGO_REGISTRIES_ALTERNATIVE_TOKEN\", registry.token())\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `alternative`)\n[COMPILING] bar v0.0.1 (registry `alternative`)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn environment_token() {\n let registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .http_index()\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .env(\"CARGO_REGISTRIES_ALTERNATIVE_TOKEN\", registry.token())\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `alternative`)\n[COMPILING] bar v0.0.1 (registry `alternative`)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn environment_token_with_asymmetric() {\n let registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .http_index()\n .token(cargo_test_support::registry::Token::Keys(\n \"k3.secret.fNYVuMvBgOlljt9TDohnaYLblghqaHoQquVZwgR6X12cBFHZLFsaU3q7X3k1Zn36\"\n .to_string(),\n None,\n ))\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .env(\"CARGO_REGISTRIES_ALTERNATIVE_SECRET_KEY\", registry.key())\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `alternative`)\n[COMPILING] bar v0.0.1 (registry `alternative`)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bad_environment_token_with_asymmetric_subject() {\n let registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .http_index()\n .token(cargo_test_support::registry::Token::Keys(\n \"k3.secret.fNYVuMvBgOlljt9TDohnaYLblghqaHoQquVZwgR6X12cBFHZLFsaU3q7X3k1Zn36\"\n .to_string(),\n None,\n ))\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .env(\"CARGO_REGISTRIES_ALTERNATIVE_SECRET_KEY\", registry.key())\n .env(\n \"CARGO_REGISTRIES_ALTERNATIVE_SECRET_KEY_SUBJECT\",\n \"incorrect\",\n )\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[ERROR] failed to get `bar` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n token rejected for `alternative`, please run `cargo login --registry alternative`\n or use environment variable CARGO_REGISTRIES_ALTERNATIVE_TOKEN\n\nCaused by:\n failed to get successful HTTP response from `http://127.0.0.1:[..]/index/config.json`, got 401\n body:\n Unauthorized message from server.\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn bad_environment_token_with_asymmetric_incorrect_subject() {\n let registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .http_index()\n .token(cargo_test_support::registry::Token::rfc_key())\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .env(\"CARGO_REGISTRIES_ALTERNATIVE_SECRET_KEY\", registry.key())\n .env(\n \"CARGO_REGISTRIES_ALTERNATIVE_SECRET_KEY_SUBJECT\",\n \"incorrect\",\n )\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[ERROR] failed to get `bar` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n token rejected for `alternative`, please run `cargo login --registry alternative`\n or use environment variable CARGO_REGISTRIES_ALTERNATIVE_TOKEN\n\nCaused by:\n failed to get successful HTTP response from `http://127.0.0.1:[..]/index/config.json`, got 401\n body:\n Unauthorized message from server.\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn bad_environment_token_with_incorrect_asymmetric() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .http_index()\n .token(cargo_test_support::registry::Token::Keys(\n \"k3.secret.fNYVuMvBgOlljt9TDohnaYLblghqaHoQquVZwgR6X12cBFHZLFsaU3q7X3k1Zn36\"\n .to_string(),\n None,\n ))\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .env(\n \"CARGO_REGISTRIES_ALTERNATIVE_SECRET_KEY\",\n \"k3.secret.9Vxr5hVlI_g_orBZN54vPz20bmB4O76wB_MVqUSuJJJqHFLwP8kdn_RY5g6J6pQG\",\n )\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[ERROR] failed to get `bar` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n token rejected for `alternative`, please run `cargo login --registry alternative`\n or use environment variable CARGO_REGISTRIES_ALTERNATIVE_TOKEN\n\nCaused by:\n failed to get successful HTTP response from `http://127.0.0.1:[..]/index/config.json`, got 401\n body:\n Unauthorized message from server.\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn missing_token() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .http_index()\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[ERROR] failed to get `bar` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n no token found for `alternative`, please run `cargo login --registry alternative`\n or use environment variable CARGO_REGISTRIES_ALTERNATIVE_TOKEN\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn missing_token_git() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[ERROR] failed to download `bar v0.0.1 (registry `alternative`)`\n\nCaused by:\n unable to get packages from source\n\nCaused by:\n no token found for `alternative`, please run `cargo login --registry alternative`\n or use environment variable CARGO_REGISTRIES_ALTERNATIVE_TOKEN\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn incorrect_token() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .http_index()\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .env(\"CARGO_REGISTRIES_ALTERNATIVE_TOKEN\", \"incorrect\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[ERROR] failed to get `bar` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n token rejected for `alternative`, please run `cargo login --registry alternative`\n or use environment variable CARGO_REGISTRIES_ALTERNATIVE_TOKEN\n\nCaused by:\n failed to get successful HTTP response from `http://127.0.0.1:[..]/index/config.json`, got 401\n body:\n Unauthorized message from server.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn incorrect_token_git() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .http_api()\n .build();\n\n let p = make_project();\n cargo(&p, \"build\")\n .env(\"CARGO_REGISTRIES_ALTERNATIVE_TOKEN\", \"incorrect\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[ERROR] failed to download from `http://127.0.0.1:[..]/dl/bar/0.0.1/download`\n\nCaused by:\n failed to get successful HTTP response from `http://127.0.0.1:[..]/dl/bar/0.0.1/download` (127.0.0.1), got 401\n body:\n Unauthorized message from server.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn anonymous_alt_registry() {\n // An alternative registry that requires auth, but is not in the config.\n let registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .no_configure_token()\n .no_configure_registry()\n .http_index()\n .build();\n\n let p = make_project();\n cargo(&p, &format!(\"install --index {} bar\", registry.index_url()))\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `sparse+http://127.0.0.1:[..]/index/` index\n[ERROR] no token found for `sparse+http://127.0.0.1:[..]/index/`\nconsider setting up an alternate registry in Cargo's configuration\nas described by https://doc.rust-lang.org/cargo/reference/registries.html\n\n[registries]\nmy-registry = { index = \"sparse+http://127.0.0.1:[..]/index/\" }\n\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn login() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .no_configure_token()\n .auth_required()\n .http_index()\n .build();\n\n let p = make_project();\n cargo(&p, \"login --registry alternative\")\n .with_stdin(\"sekrit\")\n .run();\n}\n\n#[cargo_test]\nfn login_existing_token() {\n let _registry = RegistryBuilder::new()\n .alternative()\n .auth_required()\n .http_index()\n .build();\n\n let p = make_project();\n cargo(&p, \"login --registry alternative\")\n .with_stdin(\"sekrit\")\n .run();\n}\n\n#[cargo_test]\nfn duplicate_index() {\n let server = RegistryBuilder::new()\n .alternative()\n .no_configure_token()\n .auth_required()\n .build();\n let p = make_project();\n\n // Two alternative registries with the same index.\n cargo(&p, \"build\")\n .env(\n \"CARGO_REGISTRIES_ALTERNATIVE1_INDEX\",\n server.index_url().as_str(),\n )\n .env(\n \"CARGO_REGISTRIES_ALTERNATIVE2_INDEX\",\n server.index_url().as_str(),\n )\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[LOCKING] 1 package to latest compatible version\n[ERROR] failed to download `bar v0.0.1 (registry `alternative`)`\n\nCaused by:\n unable to get packages from source\n\nCaused by:\n multiple registries are configured with the same index url 'registry+[ROOTURL]/alternative-registry': alternative1, alternative2\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn token_not_logged() {\n // Checks that the token isn't displayed in debug output (for both HTTP\n // index and registry API). Note that this doesn't fully verify the\n // correct behavior since we don't have an HTTP2 server, and curl behaves\n // significantly differently when using HTTP2.\n let crates_io = RegistryBuilder::new()\n .http_api()\n .http_index()\n .auth_required()\n .token(Token::Plaintext(\"a-unique_token\".to_string()))\n .build();\n Package::new(\"bar\", \"1.0.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n let output = cargo(&p, \"publish\")\n .replace_crates_io(crates_io.index_url())\n .env(\"CARGO_HTTP_DEBUG\", \"true\")\n .env(\"CARGO_LOG\", \"trace\")\n .run();\n let log = String::from_utf8(output.stderr).unwrap();\n assert_e2e().eq(\n &log,\n str![[r#\"\n...\n[PUBLISHED] foo v0.1.0 at registry `crates-io`\n\n\"#]],\n );\n let authorizations: Vec<_> = log\n .lines()\n .filter(|line| {\n line.contains(\"http-debug:\") && line.to_lowercase().contains(\"authorization\")\n })\n .collect();\n assert!(authorizations.iter().all(|line| line.contains(\"REDACTED\")));\n // Total authorizations:\n // 1. Initial config.json\n // 2. /index/3/f/foo\n // 3. config.json again for verification\n // 4. /index/3/b/bar\n // 5. config.json again for verification\n // 6. /index/3/b/bar\n // 7. /dl/bar/1.0.0/download\n // 8. /api/v1/crates/new\n // 9. config.json again for verification\n // 10. /index/3/f/foo for the \"wait for publish\"\n assert_eq!(authorizations.len(), 10);\n assert!(!log.contains(\"a-unique_token\"));\n}\n" }, { "path": "tests/testsuite/registry_overlay.rs", "content": "//! Tests for local-registry sources.\n\nuse crate::prelude::*;\nuse cargo_test_support::project;\nuse cargo_test_support::registry::{Package, RegistryBuilder, TestRegistry};\nuse cargo_test_support::str;\n\nfn setup() -> (TestRegistry, String) {\n let alt = RegistryBuilder::new().alternative().build();\n (\n RegistryBuilder::new().http_index().build(),\n alt.index_url()\n .to_file_path()\n .unwrap()\n .into_os_string()\n .into_string()\n .unwrap(),\n )\n}\n\n#[cargo_test]\nfn overlay_hit() {\n let (reg, alt_path) = setup();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // baz is only in the local registry, but it gets found\n Package::new(\"baz\", \"0.1.1\")\n .alternative(true)\n .local(true)\n .publish();\n\n p.cargo(\"check\")\n .overlay_registry(®.index_url(), &alt_path)\n .run();\n}\n\n#[cargo_test]\nfn registry_version_wins() {\n let (reg, alt_path) = setup();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // The latest one is in the main registry, so it will get chosen.\n Package::new(\"baz\", \"0.1.1\").publish();\n Package::new(\"baz\", \"0.1.0\")\n .alternative(true)\n .local(true)\n .publish();\n\n p.cargo(\"check\")\n .overlay_registry(®.index_url(), &alt_path)\n .with_stderr_data(str![[r#\"\n[UPDATING] `sparse+http://127.0.0.1:[..]/index/` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.1.1 (registry `sparse+http://127.0.0.1:[..]/index/`)\n[CHECKING] baz v0.1.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn overlay_version_wins() {\n let (reg, alt_path) = setup();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // The latest one is in the overlay registry, so it will get chosen.\n Package::new(\"baz\", \"0.1.0\").publish();\n Package::new(\"baz\", \"0.1.1\")\n .alternative(true)\n .local(true)\n .publish();\n\n p.cargo(\"check\")\n .overlay_registry(®.index_url(), &alt_path)\n .with_stderr_data(str![[r#\"\n[UPDATING] `sparse+http://127.0.0.1:[..]/index/` index\n[LOCKING] 1 package to latest compatible version\n[UNPACKING] baz v0.1.1 (registry `[ROOT]/alternative-registry`)\n[CHECKING] baz v0.1.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn version_precedence() {\n let (reg, alt_path) = setup();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // The one we want is in the main registry.\n Package::new(\"baz\", \"0.1.1\").publish();\n Package::new(\"baz\", \"0.1.1\")\n .alternative(true)\n .local(true)\n .publish();\n\n p.cargo(\"check\")\n .overlay_registry(®.index_url(), &alt_path)\n .with_stderr_data(str![[r#\"\n[UPDATING] `sparse+http://127.0.0.1:[..]/index/` index\n[LOCKING] 1 package to latest compatible version\n[UNPACKING] baz v0.1.1 (registry `[ROOT]/alternative-registry`)\n[CHECKING] baz v0.1.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn local_depends_on_old_registry_package() {\n let (reg, alt_path) = setup();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"baz\", \"0.0.1\").publish();\n // A new local package can depend on an older version in the registry.\n Package::new(\"baz\", \"0.1.1\")\n .dep(\"baz\", \"=0.0.1\")\n .alternative(true)\n .local(true)\n .publish();\n\n p.cargo(\"check\")\n .overlay_registry(®.index_url(), &alt_path)\n .run();\n}\n\n#[cargo_test]\nfn registry_dep_depends_on_new_local_package() {\n let (reg, alt_path) = setup();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n registry-package = \"0.1.0\"\n workspace-package = \"0.0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n Package::new(\"registry-package\", \"0.1.0\")\n .dep(\"workspace-package\", \"0.1.0\")\n .publish();\n // The local overlay contains an updated version of workspace-package\n Package::new(\"workspace-package\", \"0.1.1\")\n .alternative(true)\n .local(true)\n .publish();\n\n // The registry contains older versions of workspace-package (one of which\n // we depend on directly).\n Package::new(\"workspace-package\", \"0.1.0\").publish();\n Package::new(\"workspace-package\", \"0.0.1\").publish();\n\n p.cargo(\"check\")\n .overlay_registry(®.index_url(), &alt_path)\n .with_stderr_data(\n str![[r#\"\n[UPDATING] `sparse+http://127.0.0.1:[..]/index/` index\n[LOCKING] 3 packages to latest compatible versions\n[ADDING] workspace-package v0.0.1 (available: v0.1.1)\n[DOWNLOADING] crates ...\n[UNPACKING] workspace-package v0.1.1 (registry `[ROOT]/alternative-registry`)\n[DOWNLOADED] registry-package v0.1.0 (registry `sparse+http://127.0.0.1:[..]/index/`)\n[DOWNLOADED] workspace-package v0.0.1 (registry `sparse+http://127.0.0.1:[..]/index/`)\n[CHECKING] workspace-package v0.1.1\n[CHECKING] workspace-package v0.0.1\n[CHECKING] registry-package v0.1.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n// Test that we can overlay on top of alternate registries, not just crates-io.\n// Since the test framework only supports a single alternate registry, we repurpose\n// the dummy crates-io as the registry to overlay on top.\n#[cargo_test]\nfn alt_registry() {\n let alt = RegistryBuilder::new().http_index().alternative().build();\n let crates_io = RegistryBuilder::new().build();\n let crates_io_path = crates_io\n .index_url()\n .to_file_path()\n .unwrap()\n .into_os_string()\n .into_string()\n .unwrap();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { version = \"0.1.0\", registry = \"alternative\" }\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // This package isn't used, but publishing it forces the creation of the registry index.\n Package::new(\"bar\", \"0.0.1\").local(true).publish();\n Package::new(\"baz\", \"0.1.1\").alternative(true).publish();\n\n p.cargo(\"check\")\n .overlay_registry(&alt.index_url(), &crates_io_path)\n .run();\n}\n" }, { "path": "tests/testsuite/rename_deps.rs", "content": "//! Tests for renaming dependencies.\n\nuse crate::prelude::*;\nuse cargo_test_support::git;\nuse cargo_test_support::paths;\nuse cargo_test_support::registry::{self, Package};\nuse cargo_test_support::{basic_manifest, project, str};\n\n#[cargo_test]\nfn rename_dependency() {\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"bar\", \"0.2.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { version = \"0.1.0\" }\n baz = { version = \"0.2.0\", package = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"extern crate bar; extern crate baz;\")\n .build();\n\n p.cargo(\"build\").run();\n}\n\n#[cargo_test]\nfn rename_with_different_names() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { path = \"bar\", package = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"extern crate baz;\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"random_name\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build\").run();\n}\n\n#[cargo_test]\nfn lots_of_names() {\n registry::alt_init();\n Package::new(\"foo\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub fn foo1() {}\")\n .publish();\n Package::new(\"foo\", \"0.2.0\")\n .file(\"src/lib.rs\", \"pub fn foo() {}\")\n .publish();\n Package::new(\"foo\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub fn foo2() {}\")\n .alternative(true)\n .publish();\n\n let g = git::repo(&paths::root().join(\"another\"))\n .file(\"Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn foo3() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"test\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"0.2\"\n foo1 = {{ version = \"0.1\", package = \"foo\" }}\n foo2 = {{ version = \"0.1\", registry = \"alternative\", package = \"foo\" }}\n foo3 = {{ git = '{}', package = \"foo\" }}\n foo4 = {{ path = \"foo\", package = \"foo\" }}\n \"#,\n g.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate foo;\n extern crate foo1;\n extern crate foo2;\n extern crate foo3;\n extern crate foo4;\n\n pub fn foo() {\n foo::foo();\n foo1::foo1();\n foo2::foo2();\n foo3::foo3();\n foo4::foo4();\n }\n \",\n )\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"pub fn foo4() {}\")\n .build();\n\n p.cargo(\"build -v\").run();\n}\n\n#[cargo_test]\nfn rename_and_patch() {\n Package::new(\"foo\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"test\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { version = \"0.1\", package = \"foo\" }\n\n [patch.crates-io]\n foo = { path = \"foo\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::foo(); }\",\n )\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"pub fn foo() {}\")\n .build();\n\n p.cargo(\"build -v\").run();\n}\n\n#[cargo_test]\nfn rename_twice() {\n Package::new(\"foo\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"test\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { version = \"0.1\", package = \"foo\" }\n [build-dependencies]\n foo = { version = \"0.1\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build -v\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] foo v0.1.0 (registry `dummy-registry`)\n[ERROR] the crate `test v0.1.0 ([ROOT]/foo)` depends on crate `foo v0.1.0` multiple times with different names\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rename_affects_fingerprint() {\n Package::new(\"foo\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"test\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = { version = \"0.1\", package = \"foo\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"extern crate foo;\")\n .build();\n\n p.cargo(\"build -v\").run();\n\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"test\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { version = \"0.1\", package = \"foo\" }\n \"#,\n );\n\n p.cargo(\"build -v\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[FRESH] foo v0.1.0\n[DIRTY] test v0.1.0 ([ROOT]/foo): name of dependency changed (foo => bar)\n[COMPILING] test v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\nerror[E0463]: can't find crate for `foo`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn can_run_doc_tests() {\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"bar\", \"0.2.0\").publish();\n\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bar = { version = \"0.1.0\" }\n baz = { version = \"0.2.0\", package = \"bar\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate bar;\n extern crate baz;\n \",\n )\n .build();\n\n foo.cargo(\"test -v\").with_stderr_data(str![[r#\"\n...\n[DOCTEST] foo\n[RUNNING] `rustdoc [..]--test src/lib.rs [..] --extern bar=[ROOT]/foo/target/debug/deps/libbar-[HASH].rlib --extern baz=[ROOT]/foo/target/debug/deps/libbar-[HASH].rlib [..]`\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn features_still_work() {\n Package::new(\"foo\", \"0.1.0\").publish();\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"test\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n p1 = { path = 'a', features = ['b'] }\n p2 = { path = 'b' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"p1\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n b = { version = \"0.1\", package = \"foo\", optional = true }\n \"#,\n )\n .file(\"a/src/lib.rs\", \"extern crate b;\")\n .file(\n \"b/Cargo.toml\",\n r#\"\n [package]\n name = \"p2\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n b = { version = \"0.1\", package = \"bar\", optional = true }\n\n [features]\n default = ['b']\n \"#,\n )\n .file(\"b/src/lib.rs\", \"extern crate b;\")\n .build();\n\n p.cargo(\"build -v\").run();\n}\n\n#[cargo_test]\nfn features_not_working() {\n Package::new(\"foo\", \"0.1.0\").publish();\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"test\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = { path = 'a', package = 'p1', optional = true }\n\n [features]\n default = ['p1']\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"a/Cargo.toml\", &basic_manifest(\"p1\", \"0.1.0\"))\n .build();\n\n p.cargo(\"build -v\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n feature `default` includes `p1` which is neither a dependency nor another feature\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rename_with_dash() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"qwerty\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n foo-bar = { path = 'a', package = 'a' }\n \"#,\n )\n .file(\"src/lib.rs\", \"extern crate foo_bar;\")\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build\").run();\n}\n" }, { "path": "tests/testsuite/replace.rs", "content": "//! Tests for `[replace]` table source replacement.\n\nuse crate::prelude::*;\nuse cargo_test_support::git;\nuse cargo_test_support::paths;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::{basic_manifest, project, str};\n\n#[cargo_test]\nfn override_simple() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}' }}\n \"#,\n bar.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::bar(); }\",\n )\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 2 packages to latest compatible versions\n[CHECKING] bar v0.1.0 ([ROOTURL]/override#[..])\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn override_with_features() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}', features = [\"some_feature\"] }}\n \"#,\n bar.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::bar(); }\",\n )\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 2 packages to latest compatible versions\n[WARNING] unused field in replacement for `bar`: `features`\n |\n = [NOTE] configure `features` in the `dependencies` entry\n[CHECKING] bar v0.1.0 ([ROOTURL]/override#[..])\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn override_with_setting_default_features() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}', default-features = false, features = [\"none_default_feature\"] }}\n \"#,\n bar.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::bar(); }\",\n )\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 2 packages to latest compatible versions\n[WARNING] unused field in replacement for `bar`: `features`, `default-features`\n |\n = [NOTE] configure `features`, `default-features` in the `dependencies` entry\n[CHECKING] bar v0.1.0 ([ROOTURL]/override#[..])\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn missing_version() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n bar = { git = 'https://example.com' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").with_status(101).with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n replacements must specify a version to replace, but `https://github.com/rust-lang/crates.io-index#bar` does not\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn invalid_semver_version() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n\n [replace]\n \"bar:*\" = { git = 'https://example.com' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n replacements must specify a valid semver version to replace, but `bar:*` does not\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn different_version() {\n Package::new(\"bar\", \"0.2.0\").publish();\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = \"0.2.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").with_status(101).with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n replacements cannot specify a version requirement, but found one for `https://github.com/rust-lang/crates.io-index#bar@0.1.0`\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn transitive() {\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"baz\", \"0.2.0\")\n .dep(\"bar\", \"0.1.0\")\n .file(\"src/lib.rs\", \"extern crate bar; fn baz() { bar::bar(); }\")\n .publish();\n\n let foo = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"0.2.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}' }}\n \"#,\n foo.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 3 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.2.0 (registry `dummy-registry`)\n[CHECKING] bar v0.1.0 ([ROOTURL]/override#[..])\n[CHECKING] baz v0.2.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn persists_across_rebuilds() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let foo = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}' }}\n \"#,\n foo.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::bar(); }\",\n )\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 2 packages to latest compatible versions\n[CHECKING] bar v0.1.0 ([ROOTURL]/override#[..])\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn replace_registry_with_path() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let _ = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = { path = \"../bar\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::bar(); }\",\n )\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[CHECKING] bar v0.1.0 ([ROOT]/bar)\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn use_a_spec_to_select() {\n Package::new(\"baz\", \"0.1.1\")\n .file(\"src/lib.rs\", \"pub fn baz1() {}\")\n .publish();\n Package::new(\"baz\", \"0.2.0\").publish();\n Package::new(\"bar\", \"0.1.1\")\n .dep(\"baz\", \"0.2\")\n .file(\n \"src/lib.rs\",\n \"extern crate baz; pub fn bar() { baz::baz3(); }\",\n )\n .publish();\n\n let foo = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"baz\", \"0.2.0\"))\n .file(\"src/lib.rs\", \"pub fn baz3() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1\"\n baz = \"0.1\"\n\n [replace]\n \"baz:0.2.0\" = {{ git = '{}' }}\n \"#,\n foo.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate bar;\n extern crate baz;\n\n pub fn local() {\n baz::baz1();\n bar::bar();\n }\n \",\n )\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 4 packages to latest compatible versions\n[ADDING] baz v0.1.1 (available: v0.2.0)\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.1.1 (registry `dummy-registry`)\n[DOWNLOADED] bar v0.1.1 (registry `dummy-registry`)\n[CHECKING] baz v0.2.0 ([ROOTURL]/override#[..])\n[CHECKING] baz v0.1.1\n[CHECKING] bar v0.1.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn override_adds_some_deps() {\n Package::new(\"baz\", \"0.1.1\").publish();\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let foo = git::repo(&paths::root().join(\"override\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}' }}\n \"#,\n foo.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 3 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] baz v0.1.1 (registry `dummy-registry`)\n[CHECKING] baz v0.1.1\n[CHECKING] bar v0.1.0 ([ROOTURL]/override#[..])\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n Package::new(\"baz\", \"0.1.2\").publish();\n p.cargo(\"update\")\n .arg(&format!(\"{}#bar\", foo.url()))\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `[ROOTURL]/override`\n[UPDATING] `dummy-registry` index\n[LOCKING] 0 packages to latest compatible versions\n[NOTE] pass `--verbose` to see 1 unchanged dependencies behind latest\n\n\"#]])\n .run();\n p.cargo(\"update https://github.com/rust-lang/crates.io-index#bar\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 0 packages to latest compatible versions\n[NOTE] pass `--verbose` to see 1 unchanged dependencies behind latest\n\n\"#]])\n .run();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn locked_means_locked_yes_no_seriously_i_mean_locked() {\n // this in theory exercises #2041\n Package::new(\"baz\", \"0.1.0\").publish();\n Package::new(\"baz\", \"0.2.0\").publish();\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let foo = git::repo(&paths::root().join(\"override\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"*\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1\"\n baz = \"0.1\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}' }}\n \"#,\n foo.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn override_wrong_name() {\n Package::new(\"baz\", \"0.1.0\").publish();\n\n let foo = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = \"0.1\"\n\n [replace]\n \"baz:0.1.0\" = {{ git = '{}' }}\n \"#,\n foo.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[ERROR] failed to get `baz` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n no matching package for override `https://github.com/rust-lang/crates.io-index#baz@0.1.0` found\n location searched: [ROOTURL]/override\n version required: =0.1.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn override_with_nothing() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let foo = git::repo(&paths::root().join(\"override\"))\n .file(\"src/lib.rs\", \"\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}' }}\n \"#,\n foo.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[ERROR] failed to get `bar` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `bar`\n\nCaused by:\n unable to update [ROOTURL]/override\n\nCaused by:\n could not find `Cargo.toml` in `[ROOT]/home/.cargo/git/checkouts/override-[HASH]/[..]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn override_wrong_version() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [replace]\n \"bar:0.1.0\" = { git = 'https://example.com', version = '0.2.0' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").with_status(101).with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n replacements cannot specify a version requirement, but found one for `https://github.com/rust-lang/crates.io-index#bar@0.1.0`\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn multiple_specs() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{0}' }}\n\n [replace.\"https://github.com/rust-lang/crates.io-index#bar:0.1.0\"]\n git = '{0}'\n \"#,\n bar.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[ERROR] failed to get `bar` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n overlapping replacement specifications found:\n\n * https://github.com/rust-lang/crates.io-index#bar@0.1.0\n * https://github.com/rust-lang/crates.io-index#bar@0.1.0\n\n both specifications match: bar v0.1.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_override_dep() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{0}' }}\n \"#,\n bar.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test -p bar\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 2 packages to latest compatible versions\n[ERROR] specification `bar` is ambiguous\n[HELP] re-run this command with one of the following specifications\n registry+https://github.com/rust-lang/crates.io-index#bar@0.1.0\n git+[ROOTURL]/override#bar@0.1.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{0}' }}\n \"#,\n bar.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n p.cargo(\"update\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 0 packages to latest compatible versions\n\n\"#]])\n .run();\n}\n\n// foo -> near -> far\n// near is overridden with itself\n#[cargo_test]\nfn no_override_self() {\n let deps = git::repo(&paths::root().join(\"override\"))\n .file(\"far/Cargo.toml\", &basic_manifest(\"far\", \"0.1.0\"))\n .file(\"far/src/lib.rs\", \"\")\n .file(\n \"near/Cargo.toml\",\n r#\"\n [package]\n name = \"near\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n far = { path = \"../far\" }\n \"#,\n )\n .file(\"near/src/lib.rs\", \"#![no_std] pub extern crate far;\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n near = {{ git = '{0}' }}\n\n [replace]\n \"near:0.1.0\" = {{ git = '{0}' }}\n \"#,\n deps.url()\n ),\n )\n .file(\"src/lib.rs\", \"#![no_std] pub extern crate near;\")\n .build();\n\n p.cargo(\"check --verbose\").run();\n}\n\n#[cargo_test]\nfn override_an_override() {\n Package::new(\"chrono\", \"0.2.0\")\n .dep(\"serde\", \"< 0.9\")\n .publish();\n Package::new(\"serde\", \"0.7.0\")\n .file(\"src/lib.rs\", \"pub fn serde07() {}\")\n .publish();\n Package::new(\"serde\", \"0.8.0\")\n .file(\"src/lib.rs\", \"pub fn serde08() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n chrono = \"0.2\"\n serde = \"0.8\"\n\n [replace]\n \"chrono:0.2.0\" = { path = \"chrono\" }\n \"serde:0.8.0\" = { path = \"serde\" }\n \"#,\n )\n .file(\n \"Cargo.lock\",\n r#\"\n [[package]]\n name = \"foo\"\n version = \"0.0.1\"\n dependencies = [\n \"chrono 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)\",\n \"serde 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)\",\n ]\n\n [[package]]\n name = \"chrono\"\n version = \"0.2.0\"\n source = \"registry+https://github.com/rust-lang/crates.io-index\"\n replace = \"chrono 0.2.0\"\n\n [[package]]\n name = \"chrono\"\n version = \"0.2.0\"\n dependencies = [\n \"serde 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)\",\n ]\n\n [[package]]\n name = \"serde\"\n version = \"0.7.0\"\n source = \"registry+https://github.com/rust-lang/crates.io-index\"\n\n [[package]]\n name = \"serde\"\n version = \"0.8.0\"\n source = \"registry+https://github.com/rust-lang/crates.io-index\"\n replace = \"serde 0.8.0\"\n\n [[package]]\n name = \"serde\"\n version = \"0.8.0\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate chrono;\n extern crate serde;\n\n pub fn foo() {\n chrono::chrono();\n serde::serde08_override();\n }\n \",\n )\n .file(\n \"chrono/Cargo.toml\",\n r#\"\n [package]\n name = \"chrono\"\n version = \"0.2.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"< 0.9\"\n \"#,\n )\n .file(\n \"chrono/src/lib.rs\",\n \"\n extern crate serde;\n pub fn chrono() {\n serde::serde07();\n }\n \",\n )\n .file(\"serde/Cargo.toml\", &basic_manifest(\"serde\", \"0.8.0\"))\n .file(\"serde/src/lib.rs\", \"pub fn serde08_override() {}\")\n .build();\n\n p.cargo(\"check -v\").run();\n}\n\n#[cargo_test]\nfn overriding_nonexistent_no_spurious() {\n Package::new(\"bar\", \"0.1.0\").dep(\"baz\", \"0.1\").publish();\n Package::new(\"baz\", \"0.1.0\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { path = \"baz\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{url}' }}\n \"baz:0.1.0\" = {{ git = '{url}' }}\n \"#,\n url = bar.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[WARNING] package replacement is not used: https://github.com/rust-lang/crates.io-index#baz@0.1.0\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stdout_data(\"\")\n .run();\n}\n\n#[cargo_test]\nfn no_warnings_when_replace_is_used_in_another_workspace_member() {\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"baz\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [ \"first_crate\", \"second_crate\"]\n\n [replace]\n \"bar:0.1.0\" = { path = \"local_bar\" }\n \"#,\n )\n .file(\n \"first_crate/Cargo.toml\",\n r#\"\n [package]\n name = \"first_crate\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"0.1.0\"\n \"#,\n )\n .file(\"first_crate/src/lib.rs\", \"\")\n .file(\n \"second_crate/Cargo.toml\",\n &basic_manifest(\"second_crate\", \"0.1.0\"),\n )\n .file(\"second_crate/src/lib.rs\", \"\")\n .file(\"local_bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"local_bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .cwd(\"first_crate\")\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[CHECKING] bar v0.1.0 ([ROOT]/foo/local_bar)\n[CHECKING] first_crate v0.1.0 ([ROOT]/foo/first_crate)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check\")\n .cwd(\"second_crate\")\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[CHECKING] second_crate v0.1.0 ([ROOT]/foo/second_crate)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn replace_to_path_dep() {\n Package::new(\"bar\", \"0.1.0\").dep(\"baz\", \"0.1\").publish();\n Package::new(\"baz\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = { path = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"extern crate bar;\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { path = \"baz\" }\n \"#,\n )\n .file(\n \"bar/src/lib.rs\",\n \"extern crate baz; pub fn bar() { baz::baz(); }\",\n )\n .file(\"bar/baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"bar/baz/src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn override_with_default_feature() {\n Package::new(\"another\", \"0.1.0\").publish();\n Package::new(\"another\", \"0.1.1\").dep(\"bar\", \"0.1\").publish();\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"bar\", default-features = false }\n another = \"0.1\"\n another2 = { path = \"another2\" }\n\n [replace]\n 'bar:0.1.0' = { path = \"bar\" }\n \"#,\n )\n .file(\"src/main.rs\", \"extern crate bar; fn main() { bar::bar(); }\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = []\n \"#,\n )\n .file(\n \"bar/src/lib.rs\",\n r#\"\n #[cfg(feature = \"default\")]\n pub fn bar() {}\n \"#,\n )\n .file(\n \"another2/Cargo.toml\",\n r#\"\n [package]\n name = \"another2\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { version = \"0.1\", default-features = false }\n \"#,\n )\n .file(\"another2/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"run\").run();\n}\n\n#[cargo_test]\nfn override_plus_dep() {\n Package::new(\"bar\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1\"\n\n [replace]\n 'bar:0.1.0' = { path = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = { path = \"..\" }\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] cyclic package dependency: package `bar v0.1.0 ([ROOT]/foo/bar)` depends on itself. Cycle:\npackage `bar v0.1.0 ([ROOT]/foo/bar)`\n ... which satisfies dependency `bar = \"^0.1\"` of package `foo v0.0.1 ([ROOT]/foo)`\n ... which satisfies path dependency `foo` of package `bar v0.1.0 ([ROOT]/foo/bar)`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn override_generic_matching_other_versions() {\n Package::new(\"bar\", \"0.1.0+a\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}' }}\n \"#,\n bar.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::bar(); }\",\n )\n .build();\n\n p.cargo(\"check\").with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[ERROR] failed to get `bar` as a dependency of package `foo v0.0.1 ([ROOT]/foo)`\n\nCaused by:\n replacement specification `https://github.com/rust-lang/crates.io-index#bar@0.1.0` matched 0.1.0+a and tried to override it with 0.1.0\n avoid matching unrelated packages by being more specific\n\n\"#]]).with_status(101).run();\n}\n\n#[cargo_test]\nfn override_respects_spec_metadata() {\n Package::new(\"bar\", \"0.1.0+a\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0+a\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0+notTheBuild\" = {{ git = '{}' }}\n \"#,\n bar.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::bar(); }\",\n )\n .build();\n\n p.cargo(\"check\").with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[WARNING] package replacement is not used: https://github.com/rust-lang/crates.io-index#bar@0.1.0+notTheBuild\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.1.0+a (registry `dummy-registry`)\n[CHECKING] bar v0.1.0+a\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\nerror[E0425]: cannot find function `bar`[..]\n...\n[ERROR] could not compile `foo` (lib) due to 1 previous error\n\n\"#]]).with_status(101).run();\n}\n\n#[cargo_test]\nfn override_spec_metadata_is_optional() {\n Package::new(\"bar\", \"0.1.0+a\").publish();\n\n let bar = git::repo(&paths::root().join(\"override\"))\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0+a\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"0.1.0\"\n\n [replace]\n \"bar:0.1.0\" = {{ git = '{}' }}\n \"#,\n bar.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n \"extern crate bar; pub fn foo() { bar::bar(); }\",\n )\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] git repository `[ROOTURL]/override`\n[LOCKING] 2 packages to latest compatible versions\n[CHECKING] bar v0.1.0+a ([ROOTURL]/override#[..])\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/required_features.rs", "content": "//! Tests for targets with `required-features`.\n\nuse crate::prelude::*;\nuse cargo_test_support::install::{assert_has_installed_exe, assert_has_not_installed_exe};\nuse cargo_test_support::is_nightly;\nuse cargo_test_support::paths;\nuse cargo_test_support::project;\nuse cargo_test_support::str;\n\n#[cargo_test]\nfn build_bin_default_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\"]\n a = []\n\n [[bin]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n extern crate foo;\n\n #[cfg(feature = \"a\")]\n fn test() {\n foo::foo();\n }\n\n fn main() {}\n \"#,\n )\n .file(\"src/lib.rs\", r#\"#[cfg(feature = \"a\")] pub fn foo() {}\"#)\n .build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n\n p.cargo(\"build --no-default-features\").run();\n\n p.cargo(\"build --bin=foo\").run();\n assert!(p.bin(\"foo\").is_file());\n\n p.cargo(\"build --bin=foo --no-default-features\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo` in package `foo` requires the features: `a`\nConsider enabling them by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_bin_arg_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n a = []\n\n [[bin]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --features a\").run();\n assert!(p.bin(\"foo\").is_file());\n}\n\n#[cargo_test]\nfn build_bin_multiple_required_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\", \"b\"]\n a = []\n b = [\"a\"]\n c = []\n\n [[bin]]\n name = \"foo_1\"\n path = \"src/foo_1.rs\"\n required-features = [\"b\", \"c\"]\n\n [[bin]]\n name = \"foo_2\"\n path = \"src/foo_2.rs\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"src/foo_1.rs\", \"fn main() {}\")\n .file(\"src/foo_2.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build\").run();\n\n assert!(!p.bin(\"foo_1\").is_file());\n assert!(p.bin(\"foo_2\").is_file());\n\n p.cargo(\"build --features c\").run();\n\n assert!(p.bin(\"foo_1\").is_file());\n assert!(p.bin(\"foo_2\").is_file());\n\n p.cargo(\"build --no-default-features\").run();\n}\n\n#[cargo_test]\nfn build_example_default_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\"]\n a = []\n\n [[example]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"examples/foo.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --example=foo\").run();\n assert!(p.bin(\"examples/foo\").is_file());\n\n p.cargo(\"build --example=foo --no-default-features\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo` in package `foo` requires the features: `a`\nConsider enabling them by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_example_arg_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n a = []\n\n [[example]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"examples/foo.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --example=foo --features a\").run();\n assert!(p.bin(\"examples/foo\").is_file());\n}\n\n#[cargo_test]\nfn build_example_multiple_required_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\", \"b\"]\n a = []\n b = [\"a\"]\n c = []\n\n [[example]]\n name = \"foo_1\"\n required-features = [\"b\", \"c\"]\n\n [[example]]\n name = \"foo_2\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"examples/foo_1.rs\", \"fn main() {}\")\n .file(\"examples/foo_2.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --example=foo_1\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo_1` in package `foo` requires the features: `b`, `c`\nConsider enabling them by passing, e.g., `--features=\"b c\"`\n\n\"#]])\n .run();\n p.cargo(\"build --example=foo_2\").run();\n\n assert!(!p.bin(\"examples/foo_1\").is_file());\n assert!(p.bin(\"examples/foo_2\").is_file());\n\n p.cargo(\"build --example=foo_1 --features c\").run();\n p.cargo(\"build --example=foo_2 --features c\").run();\n\n assert!(p.bin(\"examples/foo_1\").is_file());\n assert!(p.bin(\"examples/foo_2\").is_file());\n\n p.cargo(\"build --example=foo_1 --no-default-features\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo_1` in package `foo` requires the features: `b`, `c`\nConsider enabling them by passing, e.g., `--features=\"b c\"`\n\n\"#]])\n .run();\n p.cargo(\"build --example=foo_2 --no-default-features\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo_2` in package `foo` requires the features: `a`\nConsider enabling them by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_default_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\"]\n a = []\n\n [[test]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"tests/foo.rs\", \"#[test]\\nfn test() {}\")\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"test --no-default-features\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stdout_data(\"\")\n .run();\n\n p.cargo(\"test --test=foo\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"test --test=foo --no-default-features\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo` in package `foo` requires the features: `a`\nConsider enabling them by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_arg_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n a = []\n\n [[test]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"tests/foo.rs\", \"#[test]\\nfn test() {}\")\n .build();\n\n p.cargo(\"test --features a\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_multiple_required_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\", \"b\"]\n a = []\n b = [\"a\"]\n c = []\n\n [[test]]\n name = \"foo_1\"\n required-features = [\"b\", \"c\"]\n\n [[test]]\n name = \"foo_2\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"tests/foo_1.rs\", \"#[test]\\nfn test() {}\")\n .file(\"tests/foo_2.rs\", \"#[test]\\nfn test() {}\")\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo_2.rs (target/debug/deps/foo_2-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"test --features c\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo_1.rs (target/debug/deps/foo_1-[HASH][EXE])\n[RUNNING] tests/foo_2.rs (target/debug/deps/foo_2-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\nrunning 1 test\ntest test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"test --no-default-features\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stdout_data(\"\")\n .run();\n}\n\n#[cargo_test(nightly, reason = \"bench\")]\nfn bench_default_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\"]\n a = []\n\n [[bench]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\n \"benches/foo.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n\n #[bench]\n fn bench(_: &mut test::Bencher) {\n }\n \"#,\n )\n .build();\n\n p.cargo(\"bench\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] benches/foo.rs (target/release/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest bench ... bench: [AVG_ELAPSED] ns/iter (+/- [JITTER])\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"bench --no-default-features\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stdout_data(\"\")\n .run();\n\n p.cargo(\"bench --bench=foo\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] benches/foo.rs (target/release/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest bench ... bench: [AVG_ELAPSED] ns/iter (+/- [JITTER])\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"bench --bench=foo --no-default-features\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo` in package `foo` requires the features: `a`\nConsider enabling them by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"bench\")]\nfn bench_arg_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n a = []\n\n [[bench]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\n \"benches/foo.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n\n #[bench]\n fn bench(_: &mut test::Bencher) {\n }\n \"#,\n )\n .build();\n\n p.cargo(\"bench --features a\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] benches/foo.rs (target/release/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest bench ... bench: [AVG_ELAPSED] ns/iter (+/- [JITTER])\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"bench\")]\nfn bench_multiple_required_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\", \"b\"]\n a = []\n b = [\"a\"]\n c = []\n\n [[bench]]\n name = \"foo_1\"\n required-features = [\"b\", \"c\"]\n\n [[bench]]\n name = \"foo_2\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\n \"benches/foo_1.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n\n #[bench]\n fn bench(_: &mut test::Bencher) {\n }\n \"#,\n )\n .file(\n \"benches/foo_2.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n\n #[bench]\n fn bench(_: &mut test::Bencher) {\n }\n \"#,\n )\n .build();\n\n p.cargo(\"bench\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] benches/foo_2.rs (target/release/deps/foo_2-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest bench ... bench: [AVG_ELAPSED] ns/iter (+/- [JITTER])\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"bench --features c\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] benches/foo_1.rs (target/release/deps/foo_1-[HASH][EXE])\n[RUNNING] benches/foo_2.rs (target/release/deps/foo_2-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest bench ... bench: [AVG_ELAPSED] ns/iter (+/- [JITTER])\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in [ELAPSED]s\n\n\nrunning 1 test\ntest bench ... bench: [AVG_ELAPSED] ns/iter (+/- [JITTER])\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"bench --no-default-features\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stdout_data(\"\")\n .run();\n}\n\n#[cargo_test]\nfn install_default_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\"]\n a = []\n\n [[bin]]\n name = \"foo\"\n required-features = [\"a\"]\n\n [[example]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"examples/foo.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"install --path .\").run();\n assert_has_installed_exe(paths::cargo_home(), \"foo\");\n p.cargo(\"uninstall foo\").run();\n\n p.cargo(\"install --path . --no-default-features\")\n .with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[WARNING] none of the package's binaries are available for install using the selected features\n bin \"foo\" requires the features: `a`\n example \"foo\" requires the features: `a`\nConsider enabling some of the needed features by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n assert_has_not_installed_exe(paths::cargo_home(), \"foo\");\n\n p.cargo(\"install --path . --bin=foo\").run();\n assert_has_installed_exe(paths::cargo_home(), \"foo\");\n p.cargo(\"uninstall foo\").run();\n\n p.cargo(\"install --path . --bin=foo --no-default-features\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] failed to compile `foo v0.0.1 ([ROOT]/foo)`, intermediate artifacts can be found at `[ROOT]/foo/target`.\nTo reuse those artifacts with a future compilation, set the environment variable `CARGO_BUILD_BUILD_DIR` to that path.\n\nCaused by:\n target `foo` in package `foo` requires the features: `a`\n Consider enabling them by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n assert_has_not_installed_exe(paths::cargo_home(), \"foo\");\n\n p.cargo(\"install --path . --example=foo\").run();\n assert_has_installed_exe(paths::cargo_home(), \"foo\");\n p.cargo(\"uninstall foo\").run();\n\n p.cargo(\"install --path . --example=foo --no-default-features\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] failed to compile `foo v0.0.1 ([ROOT]/foo)`, intermediate artifacts can be found at `[ROOT]/foo/target`.\nTo reuse those artifacts with a future compilation, set the environment variable `CARGO_BUILD_BUILD_DIR` to that path.\n\nCaused by:\n target `foo` in package `foo` requires the features: `a`\n Consider enabling them by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n assert_has_not_installed_exe(paths::cargo_home(), \"foo\");\n}\n\n#[cargo_test]\nfn install_arg_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n a = []\n\n [[bin]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"install --features a\").run();\n assert_has_installed_exe(paths::cargo_home(), \"foo\");\n p.cargo(\"uninstall foo\").run();\n}\n\n#[cargo_test]\nfn install_multiple_required_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\", \"b\"]\n a = []\n b = [\"a\"]\n c = []\n\n [[bin]]\n name = \"foo_1\"\n path = \"src/foo_1.rs\"\n required-features = [\"b\", \"c\"]\n\n [[bin]]\n name = \"foo_2\"\n path = \"src/foo_2.rs\"\n required-features = [\"a\"]\n\n [[example]]\n name = \"foo_3\"\n path = \"src/foo_3.rs\"\n required-features = [\"b\", \"c\"]\n\n [[example]]\n name = \"foo_4\"\n path = \"src/foo_4.rs\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"src/foo_1.rs\", \"fn main() {}\")\n .file(\"src/foo_2.rs\", \"fn main() {}\")\n .file(\"src/foo_3.rs\", \"fn main() {}\")\n .file(\"src/foo_4.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"install --path .\").run();\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_1\");\n assert_has_installed_exe(paths::cargo_home(), \"foo_2\");\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_3\");\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_4\");\n p.cargo(\"uninstall foo\").run();\n\n p.cargo(\"install --path . --bins --examples\").run();\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_1\");\n assert_has_installed_exe(paths::cargo_home(), \"foo_2\");\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_3\");\n assert_has_installed_exe(paths::cargo_home(), \"foo_4\");\n p.cargo(\"uninstall foo\").run();\n\n p.cargo(\"install --path . --features c\").run();\n assert_has_installed_exe(paths::cargo_home(), \"foo_1\");\n assert_has_installed_exe(paths::cargo_home(), \"foo_2\");\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_3\");\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_4\");\n p.cargo(\"uninstall foo\").run();\n\n p.cargo(\"install --path . --features c --bins --examples\")\n .run();\n assert_has_installed_exe(paths::cargo_home(), \"foo_1\");\n assert_has_installed_exe(paths::cargo_home(), \"foo_2\");\n assert_has_installed_exe(paths::cargo_home(), \"foo_3\");\n assert_has_installed_exe(paths::cargo_home(), \"foo_4\");\n p.cargo(\"uninstall foo\").run();\n\n p.cargo(\"install --path . --no-default-features\")\n .with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[WARNING] none of the package's binaries are available for install using the selected features\n bin \"foo_1\" requires the features: `b`, `c`\n bin \"foo_2\" requires the features: `a`\n example \"foo_3\" requires the features: `b`, `c`\n example \"foo_4\" requires the features: `a`\nConsider enabling some of the needed features by passing, e.g., `--features=\"b c\"`\n\n\"#]])\n .run();\n p.cargo(\"install --path . --no-default-features --bins\")\n .with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] target filter `bins` specified, but no targets matched; this is a no-op\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[WARNING] none of the package's binaries are available for install using the selected features\n bin \"foo_1\" requires the features: `b`, `c`\n bin \"foo_2\" requires the features: `a`\n example \"foo_3\" requires the features: `b`, `c`\n example \"foo_4\" requires the features: `a`\nConsider enabling some of the needed features by passing, e.g., `--features=\"b c\"`\n\n\"#]])\n .run();\n p.cargo(\"install --path . --no-default-features --examples\")\n .with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] target filter `examples` specified, but no targets matched; this is a no-op\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[WARNING] none of the package's binaries are available for install using the selected features\n bin \"foo_1\" requires the features: `b`, `c`\n bin \"foo_2\" requires the features: `a`\n example \"foo_3\" requires the features: `b`, `c`\n example \"foo_4\" requires the features: `a`\nConsider enabling some of the needed features by passing, e.g., `--features=\"b c\"`\n\n\"#]])\n .run();\n p.cargo(\"install --path . --no-default-features --bins --examples\")\n .with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] target filters `bins`, `examples` specified, but no targets matched; this is a no-op\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[WARNING] none of the package's binaries are available for install using the selected features\n bin \"foo_1\" requires the features: `b`, `c`\n bin \"foo_2\" requires the features: `a`\n example \"foo_3\" requires the features: `b`, `c`\n example \"foo_4\" requires the features: `a`\nConsider enabling some of the needed features by passing, e.g., `--features=\"b c\"`\n\n\"#]])\n .run();\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_1\");\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_2\");\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_3\");\n assert_has_not_installed_exe(paths::cargo_home(), \"foo_4\");\n}\n\n#[cargo_test]\nfn dep_feature_in_toml() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"bar\", features = [\"a\"] }\n\n [[bin]]\n name = \"foo\"\n required-features = [\"bar/a\"]\n\n [[example]]\n name = \"foo\"\n required-features = [\"bar/a\"]\n\n [[test]]\n name = \"foo\"\n required-features = [\"bar/a\"]\n\n [[bench]]\n name = \"foo\"\n required-features = [\"bar/a\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"examples/foo.rs\", \"fn main() {}\")\n .file(\"tests/foo.rs\", \"#[test]\\nfn test() {}\")\n .file(\n \"benches/foo.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n\n #[bench]\n fn bench(_: &mut test::Bencher) {\n }\n \"#,\n )\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n a = []\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build\").run();\n\n // bin\n p.cargo(\"build --bin=foo\").run();\n assert!(p.bin(\"foo\").is_file());\n\n // example\n p.cargo(\"build --example=foo\").run();\n assert!(p.bin(\"examples/foo\").is_file());\n\n // test\n p.cargo(\"test --test=foo\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n // bench\n if is_nightly() {\n p.cargo(\"bench --bench=foo\")\n .with_stderr_data(str![[r#\"\n[COMPILING] bar v0.0.1 ([ROOT]/foo/bar)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] benches/foo.rs (target/release/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest bench ... bench: [AVG_ELAPSED] ns/iter (+/- [JITTER])\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n }\n\n // install\n p.cargo(\"install\").run();\n assert_has_installed_exe(paths::cargo_home(), \"foo\");\n p.cargo(\"uninstall foo\").run();\n}\n\n#[cargo_test]\nfn dep_feature_in_cmd_line() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"bar\" }\n\n [[bin]]\n name = \"foo\"\n required-features = [\"bar/a\"]\n\n [[example]]\n name = \"foo\"\n required-features = [\"bar/a\"]\n\n [[test]]\n name = \"foo\"\n required-features = [\"bar/a\"]\n\n [[bench]]\n name = \"foo\"\n required-features = [\"bar/a\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"examples/foo.rs\", \"fn main() {}\")\n .file(\n \"tests/foo.rs\",\n r#\"\n #[test]\n fn bin_is_built() {\n let s = format!(\"target/debug/foo{}\", std::env::consts::EXE_SUFFIX);\n let p = std::path::Path::new(&s);\n assert!(p.exists(), \"foo does not exist\");\n }\n \"#,\n )\n .file(\n \"benches/foo.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n\n #[bench]\n fn bench(_: &mut test::Bencher) {\n }\n \"#,\n )\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n a = []\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n // This is a no-op\n p.cargo(\"build\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n assert!(!p.bin(\"foo\").is_file());\n\n // bin\n p.cargo(\"build --bin=foo\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo` in package `foo` requires the features: `bar/a`\nConsider enabling them by passing, e.g., `--features=\"bar/a\"`\n\n\"#]])\n .run();\n\n p.cargo(\"build --bin=foo --features bar/a\").run();\n assert!(p.bin(\"foo\").is_file());\n\n // example\n p.cargo(\"build --example=foo\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo` in package `foo` requires the features: `bar/a`\nConsider enabling them by passing, e.g., `--features=\"bar/a\"`\n\n\"#]])\n .run();\n\n p.cargo(\"build --example=foo --features bar/a\").run();\n assert!(p.bin(\"examples/foo\").is_file());\n\n // test\n // This is a no-op, since no tests are enabled\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stdout_data(\"\")\n .run();\n\n // Delete the target directory so this can check if the main.rs gets built.\n p.build_dir().rm_rf();\n p.cargo(\"test --test=foo --features bar/a\")\n .with_stderr_data(str![[r#\"\n[COMPILING] bar v0.0.1 ([ROOT]/foo/bar)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest bin_is_built ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n // bench\n if is_nightly() {\n p.cargo(\"bench\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .with_stdout_data(\"\")\n .run();\n\n p.cargo(\"bench --bench=foo --features bar/a\")\n .with_stderr_data(str![[r#\"\n[COMPILING] bar v0.0.1 ([ROOT]/foo/bar)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] benches/foo.rs (target/release/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest bench ... bench: [AVG_ELAPSED] ns/iter (+/- [JITTER])\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n }\n\n // install\n p.cargo(\"install --path .\")\n .with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.0.1 ([ROOT]/foo)\n[LOCKING] 1 package to latest compatible version\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[WARNING] none of the package's binaries are available for install using the selected features\n bin \"foo\" requires the features: `bar/a`\n example \"foo\" requires the features: `bar/a`\nConsider enabling some of the needed features by passing, e.g., `--features=\"bar/a\"`\n\n\"#]])\n .run();\n assert_has_not_installed_exe(paths::cargo_home(), \"foo\");\n\n p.cargo(\"install --features bar/a\").run();\n assert_has_installed_exe(paths::cargo_home(), \"foo\");\n p.cargo(\"uninstall foo\").run();\n}\n\n#[cargo_test]\nfn test_skips_compiling_bin_with_missing_required_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n a = []\n\n [[bin]]\n name = \"bin_foo\"\n path = \"src/bin/foo.rs\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"src/bin/foo.rs\", \"extern crate bar; fn main() {}\")\n .file(\"tests/foo.rs\", \"\")\n .file(\"benches/foo.rs\", \"\")\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 0 tests\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"test --features a -j 1\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\nerror[E0463]: can't find crate for `bar`\n...\n\"#]])\n .run();\n\n if is_nightly() {\n p.cargo(\"bench\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] benches/foo.rs (target/release/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 0 tests\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"bench --features a -j 1\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\nerror[E0463]: can't find crate for `bar`\n...\n\"#]])\n .run();\n }\n}\n\n#[cargo_test]\nfn run_default() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = []\n a = []\n\n [[bin]]\n name = \"foo\"\n required-features = [\"a\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"src/main.rs\", \"extern crate foo; fn main() {}\")\n .build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] target `foo` in package `foo` requires the features: `a`\nConsider enabling them by passing, e.g., `--features=\"a\"`\n\n\"#]])\n .run();\n\n p.cargo(\"run --features a\").run();\n}\n\n#[cargo_test]\nfn run_default_multiple_required_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"a\"]\n a = []\n b = []\n\n [[bin]]\n name = \"foo1\"\n path = \"src/foo1.rs\"\n required-features = [\"a\"]\n\n [[bin]]\n name = \"foo3\"\n path = \"src/foo3.rs\"\n required-features = [\"b\"]\n\n [[bin]]\n name = \"foo2\"\n path = \"src/foo2.rs\"\n required-features = [\"b\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"src/foo1.rs\", \"extern crate foo; fn main() {}\")\n .file(\"src/foo3.rs\", \"extern crate foo; fn main() {}\")\n .file(\"src/foo2.rs\", \"extern crate foo; fn main() {}\")\n .build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `cargo run` could not determine which binary to run. Use the `--bin` option to specify a binary, or the `default-run` manifest key.\navailable binaries: foo1, foo2, foo3\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn renamed_required_features() {\n // Test that required-features uses renamed package feature names.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2018\"\n\n [[bin]]\n name = \"x\"\n required-features = [\"a1/f1\"]\n\n [dependencies]\n a1 = {path=\"a1\", package=\"a\"}\n a2 = {path=\"a2\", package=\"a\"}\n \"#,\n )\n .file(\n \"src/bin/x.rs\",\n r#\"\n fn main() {\n a1::f();\n a2::f();\n }\n \"#,\n )\n .file(\n \"a1/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n\n [features]\n f1 = []\n \"#,\n )\n .file(\n \"a1/src/lib.rs\",\n r#\"\n pub fn f() {\n if cfg!(feature=\"f1\") {\n println!(\"a1 f1\");\n }\n }\n \"#,\n )\n .file(\n \"a2/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.2.0\"\n\n [features]\n f2 = []\n \"#,\n )\n .file(\n \"a2/src/lib.rs\",\n r#\"\n pub fn f() {\n if cfg!(feature=\"f2\") {\n println!(\"a2 f2\");\n }\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[LOCKING] 2 packages to latest compatible versions\n[ERROR] target `x` in package `foo` requires the features: `a1/f1`\nConsider enabling them by passing, e.g., `--features=\"a1/f1\"`\n\n\"#]])\n .run();\n\n p.cargo(\"build --features a1/f1\").run();\n p.rename_run(\"x\", \"x_with_f1\")\n .with_stdout_data(str![[r#\"\na1 f1\n\n\"#]])\n .run();\n\n p.cargo(\"build --features a1/f1,a2/f2\").run();\n p.rename_run(\"x\", \"x_with_f1_f2\")\n .with_stdout_data(str![[r#\"\na1 f1\na2 f2\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn truncated_install_warning_message() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n\n [features]\n feature1 = []\n feature2 = []\n feature3 = []\n feature4 = []\n feature5 = []\n\n [[bin]]\n name = \"foo1\"\n required-features = [\"feature1\", \"feature2\", \"feature3\"]\n\n [[bin]]\n name = \"foo2\"\n required-features = [\"feature2\"]\n\n [[bin]]\n name = \"foo3\"\n required-features = [\"feature3\"]\n\n [[bin]]\n name = \"foo4\"\n required-features = [\"feature4\", \"feature1\"]\n\n [[bin]]\n name = \"foo5\"\n required-features = [\"feature1\", \"feature2\", \"feature3\", \"feature4\", \"feature5\"]\n\n [[bin]]\n name = \"foo6\"\n required-features = [\"feature1\", \"feature2\", \"feature3\", \"feature4\", \"feature5\"]\n\n [[bin]]\n name = \"foo7\"\n required-features = [\"feature1\", \"feature2\", \"feature3\", \"feature4\", \"feature5\"]\n\n [[bin]]\n name = \"foo8\"\n required-features = [\"feature1\", \"feature2\", \"feature3\", \"feature4\", \"feature5\"]\n\n [[bin]]\n name = \"foo9\"\n required-features = [\"feature1\", \"feature2\", \"feature3\", \"feature4\", \"feature5\"]\n\n [[bin]]\n name = \"foo10\"\n required-features = [\"feature1\", \"feature2\", \"feature3\", \"feature4\", \"feature5\"]\n\n [[example]]\n name = \"example1\"\n required-features = [\"feature1\", \"feature2\"]\n \"#,\n )\n .file(\"src/bin/foo1.rs\", \"fn main() {}\")\n .file(\"src/bin/foo2.rs\", \"fn main() {}\")\n .file(\"src/bin/foo3.rs\", \"fn main() {}\")\n .file(\"src/bin/foo4.rs\", \"fn main() {}\")\n .file(\"src/bin/foo5.rs\", \"fn main() {}\")\n .file(\"src/bin/foo6.rs\", \"fn main() {}\")\n .file(\"src/bin/foo7.rs\", \"fn main() {}\")\n .file(\"src/bin/foo8.rs\", \"fn main() {}\")\n .file(\"src/bin/foo9.rs\", \"fn main() {}\")\n .file(\"src/bin/foo10.rs\", \"fn main() {}\")\n .file(\"examples/example1.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"install --path .\").with_stderr_data(str![[r#\"\n[INSTALLING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[WARNING] none of the package's binaries are available for install using the selected features\n bin \"foo1\" requires the features: `feature1`, `feature2`, `feature3`\n bin \"foo10\" requires the features: `feature1`, `feature2`, `feature3`, `feature4`, `feature5`\n bin \"foo2\" requires the features: `feature2`\n bin \"foo3\" requires the features: `feature3`\n bin \"foo4\" requires the features: `feature4`, `feature1`\n bin \"foo5\" requires the features: `feature1`, `feature2`, `feature3`, `feature4`, `feature5`\n bin \"foo6\" requires the features: `feature1`, `feature2`, `feature3`, `feature4`, `feature5`\n4 more targets also requires features not enabled. See them in the Cargo.toml file.\nConsider enabling some of the needed features by passing, e.g., `--features=\"feature1 feature2 feature3\"`\n\n\"#]]).run();\n}\n" }, { "path": "tests/testsuite/run.rs", "content": "//! Tests for the `cargo run` command.\n\nuse crate::prelude::*;\nuse cargo_test_support::{\n Project, basic_bin_manifest, basic_lib_manifest, basic_manifest, project, str,\n};\nuse cargo_util::paths::dylib_path_envvar;\n\n#[cargo_test]\nfn simple() {\n let p = project()\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n assert!(p.bin(\"foo\").is_file());\n}\n\n#[cargo_test]\nfn quiet_arg() {\n let p = project()\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run -q\")\n .with_stderr_data(\"\")\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n\n p.cargo(\"run --quiet\")\n .with_stderr_data(\"\")\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn unsupported_silent_arg() {\n let p = project()\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run -s\")\n .with_stderr_data(str![[r#\"\n[ERROR] unexpected argument '--silent' found\n\n tip: a similar argument exists: '--quiet'\n\nUsage: cargo[EXE] run [OPTIONS] [ARGS]...\n\nFor more information, try '--help'.\n\n\"#]])\n .with_status(1)\n .run();\n\n p.cargo(\"run --silent\")\n .with_stderr_data(str![[r#\"\n[ERROR] unexpected argument '--silent' found\n\n tip: a similar argument exists: '--quiet'\n\nUsage: cargo[EXE] run [OPTIONS] [ARGS]...\n\nFor more information, try '--help'.\n\n\"#]])\n .with_status(1)\n .run();\n}\n\n#[cargo_test]\nfn quiet_arg_and_verbose_arg() {\n let p = project()\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run -q -v\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] cannot set both --verbose and --quiet\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn quiet_arg_and_verbose_config() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n verbose = true\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run -q\")\n .with_stderr_data(\"\")\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn verbose_arg_and_quiet_config() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n quiet = true\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn quiet_config_alone() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n quiet = true\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_stderr_data(\"\")\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn verbose_config_alone() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n verbose = true\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn quiet_config_and_verbose_config() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [term]\n verbose = true\n quiet = true\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] cannot set both `term.verbose` and `term.quiet`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn simple_with_args() {\n let p = project()\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n assert_eq!(std::env::args().nth(1).unwrap(), \"hello\");\n assert_eq!(std::env::args().nth(2).unwrap(), \"world\");\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run hello world\").run();\n}\n\n#[cfg(unix)]\n#[cargo_test]\nfn simple_with_non_utf8_args() {\n use std::os::unix::ffi::OsStrExt;\n\n let p = project()\n .file(\n \"src/main.rs\",\n r#\"\n use std::ffi::OsStr;\n use std::os::unix::ffi::OsStrExt;\n\n fn main() {\n assert_eq!(std::env::args_os().nth(1).unwrap(), OsStr::from_bytes(b\"hello\"));\n assert_eq!(std::env::args_os().nth(2).unwrap(), OsStr::from_bytes(b\"ab\\xffcd\"));\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run\")\n .arg(\"hello\")\n .arg(std::ffi::OsStr::from_bytes(b\"ab\\xFFcd\"))\n .run();\n}\n\n#[cargo_test]\nfn exit_code() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() { std::process::exit(2); }\")\n .build();\n\n let expected = if !cfg!(unix) {\n str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n[ERROR] process didn't exit successfully: `target/debug/foo[EXE]` ([EXIT_STATUS]: 2)\n\n\"#]]\n } else {\n str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo`\n\n\"#]]\n };\n p.cargo(\"run\")\n .with_status(2)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn exit_code_verbose() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() { std::process::exit(2); }\")\n .build();\n\n let expected = if !cfg!(unix) {\n str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n[ERROR] process didn't exit successfully: `target/debug/foo[EXE]` ([EXIT_STATUS]: 2)\n\n\"#]]\n } else {\n str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n\n\"#]]\n };\n\n p.cargo(\"run -v\")\n .with_status(2)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test]\nfn no_main_file() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] a bin target must be available for `cargo run`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn too_many_bins() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", \"\")\n .file(\"src/bin/b.rs\", \"\")\n .build();\n\n // Using [..] here because the order is not stable\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `cargo run` could not determine which binary to run. Use the `--bin` option to specify a binary, or the `default-run` manifest key.\navailable binaries: a, b\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn specify_name() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"src/bin/a.rs\",\n r#\"\n #[allow(unused_extern_crates)]\n extern crate foo;\n fn main() { println!(\"hello a.rs\"); }\n \"#,\n )\n .file(\n \"src/bin/b.rs\",\n r#\"\n #[allow(unused_extern_crates)]\n extern crate foo;\n fn main() { println!(\"hello b.rs\"); }\n \"#,\n )\n .build();\n\n p.cargo(\"run --bin a -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..] src/lib.rs [..]`\n[RUNNING] `rustc [..] src/bin/a.rs [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/a[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello a.rs\n\n\"#]])\n .run();\n\n p.cargo(\"run --bin b -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..] src/bin/b.rs [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/b[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello b.rs\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn specify_default_run() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n default-run = \"a\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", r#\"fn main() { println!(\"hello A\"); }\"#)\n .file(\"src/bin/b.rs\", r#\"fn main() { println!(\"hello B\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_stdout_data(str![[r#\"\nhello A\n\n\"#]])\n .run();\n p.cargo(\"run --bin a\")\n .with_stdout_data(str![[r#\"\nhello A\n\n\"#]])\n .run();\n p.cargo(\"run --bin b\")\n .with_stdout_data(str![[r#\"\nhello B\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bogus_default_run() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n default-run = \"b\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", r#\"fn main() { println!(\"hello A\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n default-run target `b` not found\n\n [HELP] a target with a similar name exists: `a`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_example() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/a.rs\", r#\"fn main() { println!(\"example\"); }\"#)\n .file(\"src/bin/a.rs\", r#\"fn main() { println!(\"bin\"); }\"#)\n .build();\n\n p.cargo(\"run --example a\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/examples/a[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nexample\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_library_example() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n [[example]]\n name = \"bar\"\n crate-type = [\"lib\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/bar.rs\", \"fn foo() {}\")\n .build();\n\n p.cargo(\"run --example bar\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] example target `bar` is a library and cannot be executed\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_bin_example() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n [[example]]\n name = \"bar\"\n crate-type = [\"bin\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/bar.rs\", r#\"fn main() { println!(\"example\"); }\"#)\n .build();\n\n p.cargo(\"run --example bar\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/examples/bar[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nexample\n\n\"#]])\n .run();\n}\n\nfn autodiscover_examples_project(rust_edition: &str, autoexamples: Option) -> Project {\n let autoexamples = match autoexamples {\n None => \"\".to_string(),\n Some(bool) => format!(\"autoexamples = {}\", bool),\n };\n project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n edition = \"{rust_edition}\"\n {autoexamples}\n\n [features]\n magic = []\n\n [[example]]\n name = \"do_magic\"\n required-features = [\"magic\"]\n \"#,\n rust_edition = rust_edition,\n autoexamples = autoexamples\n ),\n )\n .file(\"examples/a.rs\", r#\"fn main() { println!(\"example\"); }\"#)\n .file(\n \"examples/do_magic.rs\",\n r#\"\n fn main() { println!(\"magic example\"); }\n \"#,\n )\n .build()\n}\n\n#[cargo_test]\nfn run_example_autodiscover_2015() {\n let p = autodiscover_examples_project(\"2015\", None);\n p.cargo(\"run --example a\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[WARNING] An explicit [[example]] section is specified in Cargo.toml which currently\ndisables Cargo from automatically inferring other example targets.\nThis inference behavior will change in the Rust 2018 edition and the following\nfiles will be included as a example target:\n\n* examples/a.rs\n\nThis is likely to break cargo build or cargo test as these files may not be\nready to be compiled as a example target today. You can future-proof yourself\nand disable this warning by adding `autoexamples = false` to your [package]\nsection. You may also move the files to a location where Cargo would not\nautomatically infer them to be a target, such as in subfolders.\n\nFor more information on this warning you can consult\nhttps://github.com/rust-lang/cargo/issues/5330\n[ERROR] no example target named `a` in default-run packages\n[HELP] available example targets:\n do_magic\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_example_autodiscover_2015_with_autoexamples_enabled() {\n let p = autodiscover_examples_project(\"2015\", Some(true));\n p.cargo(\"run --example a\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/examples/a[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nexample\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_example_autodiscover_2015_with_autoexamples_disabled() {\n let p = autodiscover_examples_project(\"2015\", Some(false));\n p.cargo(\"run --example a\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no example target named `a` in default-run packages\n[HELP] available example targets:\n do_magic\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_example_autodiscover_2018() {\n let p = autodiscover_examples_project(\"2018\", None);\n p.cargo(\"run --example a\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/examples/a[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nexample\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn autobins_disables() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n autobins = false\n \"#,\n )\n .file(\"src/lib.rs\", \"pub mod bin;\")\n .file(\"src/bin/mod.rs\", \"// empty\")\n .build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] a bin target must be available for `cargo run`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_bins() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/a.rs\", r#\"fn main() { println!(\"example\"); }\"#)\n .file(\"src/bin/a.rs\", r#\"fn main() { println!(\"bin\"); }\"#)\n .build();\n\n p.cargo(\"run --bins\")\n .with_status(1)\n .with_stderr_data(str![[r#\"\n[ERROR] unexpected argument '--bins' found\n\n tip: a similar argument exists: '--bin'\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_with_filename() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"src/bin/a.rs\",\n r#\"\n extern crate foo;\n fn main() { println!(\"hello a.rs\"); }\n \"#,\n )\n .file(\"examples/a.rs\", r#\"fn main() { println!(\"example\"); }\"#)\n .build();\n\n p.cargo(\"run --bin bin.rs\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `bin.rs` in default-run packages\n[HELP] available bin targets:\n a\n\n\"#]])\n .run();\n\n p.cargo(\"run --bin a.rs\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `a.rs` in default-run packages\n\n[HELP] a target with a similar name exists: `a`\n\n\"#]])\n .run();\n\n p.cargo(\"run --example example.rs\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no example target named `example.rs` in default-run packages\n[HELP] available example targets:\n a\n\n\"#]])\n .run();\n\n p.cargo(\"run --example a.rs\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no example target named `a.rs` in default-run packages\n\n[HELP] a target with a similar name exists: `a`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn ambiguous_bin_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n resolver = \"3\"\n members = [\"crate1\", \"crate2\", \"crate3\", \"crate4\"]\n \"#,\n )\n .file(\"crate1/src/bin/ambiguous.rs\", \"fn main(){}\")\n .file(\n \"crate1/Cargo.toml\",\n r#\"\n [package]\n name = \"crate1\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n )\n .file(\"crate2/src/bin/ambiguous.rs\", \"fn main(){}\")\n .file(\n \"crate2/Cargo.toml\",\n r#\"\n [package]\n name = \"crate2\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n )\n .file(\"crate3/src/bin/ambiguous.rs\", \"fn main(){}\")\n .file(\n \"crate3/Cargo.toml\",\n r#\"\n [package]\n name = \"crate3\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n )\n .file(\"crate4/src/bin/ambiguous.rs\", \"fn main(){}\")\n .file(\n \"crate4/Cargo.toml\",\n r#\"\n [package]\n name = \"crate4\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n );\n let p = p.build();\n\n p.cargo(\"run --bin ambiguous\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `cargo run` can run at most one executable, but multiple were specified\n[HELP] available targets:\n bin `ambiguous` in package `crate1`\n bin `ambiguous` in package `crate2`\n bin `ambiguous` in package `crate3`\n bin `ambiguous` in package `crate4`\n\n\"#]])\n .run();\n\n p.cargo(\"run --bin crate1/ambiguous\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `crate1/ambiguous` in default-run packages\n[HELP] available bin targets:\n ambiguous in package crate1\n ambiguous in package crate2\n ambiguous in package crate3\n ambiguous in package crate4\n\n\"#]])\n .run();\n}\n\n// See rust-lang/cargo#14544\n#[cargo_test]\nfn print_available_targets_within_virtual_workspace() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n resolver = \"3\"\n members = [\"crate1\", \"crate2\", \"pattern1\", \"pattern2\"]\n\n default-members = [\"crate1\"]\n \"#,\n )\n .file(\"crate1/src/main.rs\", \"fn main(){}\")\n .file(\n \"crate1/Cargo.toml\",\n r#\"\n [package]\n name = \"crate1\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n )\n .file(\"crate2/src/main.rs\", \"fn main(){}\")\n .file(\n \"crate2/Cargo.toml\",\n r#\"\n [package]\n name = \"crate2\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n )\n .file(\"pattern1/src/main.rs\", \"fn main(){}\")\n .file(\n \"pattern1/Cargo.toml\",\n r#\"\n [package]\n name = \"pattern1\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n )\n .file(\"pattern2/src/main.rs\", \"fn main(){}\")\n .file(\n \"pattern2/Cargo.toml\",\n r#\"\n [package]\n name = \"pattern2\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n )\n .file(\"another/src/main.rs\", \"fn main(){}\")\n .file(\n \"another/Cargo.toml\",\n r#\"\n [package]\n name = \"another\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n );\n\n let p = p.build();\n p.cargo(\"run --bin\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] \"--bin\" takes one argument.\nAvailable binaries:\n crate1\n\n\n\"#]])\n .run();\n\n p.cargo(\"run -p crate1 --bin crate2\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `crate2` in `crate1` package\n\n[HELP] a target with a similar name exists: `crate1`\n[HELP] available bin in `crate2` package:\n crate2\n\n\"#]])\n .run();\n\n p.cargo(\"check -p crate1 -p pattern1 -p pattern2 --bin crate2\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `crate2` in `crate1`, ... packages\n\n[HELP] a target with a similar name exists: `crate1`\n[HELP] available bin in `crate2` package:\n crate2\n\n\"#]])\n .run();\n\n p.cargo(\"run --bin crate2\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `crate2` in default-run packages\n\n[HELP] a target with a similar name exists: `crate1`\n[HELP] available bin in `crate2` package:\n crate2\n\n\"#]])\n .run();\n\n p.cargo(\"check --bin pattern*\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target matches pattern `pattern*` in default-run packages\n[HELP] available bin in `pattern1` package:\n pattern1\n[HELP] available bin in `pattern2` package:\n pattern2\n\n\"#]])\n .run();\n\n // This another branch that none of similar name exists, and print available targets in the\n // default-members.\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n resolver = \"3\"\n members = [\"crate1\", \"crate2\", \"another\"]\n\n default-members = [\"another\"]\n \"#,\n );\n\n p.cargo(\"run --bin crate2\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `crate2` in default-run packages\n[HELP] available bin in `crate2` package:\n crate2\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn either_name_or_example() {\n let p = project()\n .file(\"src/bin/a.rs\", r#\"fn main() { println!(\"hello a.rs\"); }\"#)\n .file(\"examples/b.rs\", r#\"fn main() { println!(\"hello b.rs\"); }\"#)\n .build();\n\n p.cargo(\"run --bin a --example b\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `cargo run` can run at most one executable, but multiple were specified\n[HELP] available targets:\n bin `a` in package `foo`\n example `b` in package `foo`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn one_bin_multiple_examples() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"src/bin/main.rs\",\n r#\"fn main() { println!(\"hello main.rs\"); }\"#,\n )\n .file(\"examples/a.rs\", r#\"fn main() { println!(\"hello a.rs\"); }\"#)\n .file(\"examples/b.rs\", r#\"fn main() { println!(\"hello b.rs\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/main[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello main.rs\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn example_with_release_flag() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n version = \"*\"\n path = \"bar\"\n \"#,\n )\n .file(\n \"examples/a.rs\",\n r#\"\n extern crate bar;\n\n fn main() {\n if cfg!(debug_assertions) {\n println!(\"slow1\")\n } else {\n println!(\"fast1\")\n }\n bar::baz();\n }\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_lib_manifest(\"bar\"))\n .file(\n \"bar/src/bar.rs\",\n r#\"\n pub fn baz() {\n if cfg!(debug_assertions) {\n println!(\"slow2\")\n } else {\n println!(\"fast2\")\n }\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run -v --release --example a\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] bar v0.5.0 ([ROOT]/foo/bar)\n[RUNNING] `rustc --crate-name bar --edition=2015 bar/src/bar.rs [..]--crate-type lib --emit=[..]link -C opt-level=3[..] -C metadata=[..] --out-dir [ROOT]/foo/target/release/deps -C strip=debuginfo -L dependency=[ROOT]/foo/target/release/deps`\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name a --edition=2015 examples/a.rs [..]--crate-type bin --emit=[..]link -C opt-level=3[..] -C metadata=[..] --out-dir [ROOT]/foo/target/release/examples -C strip=debuginfo -L dependency=[ROOT]/foo/target/release/deps --extern bar=[ROOT]/foo/target/release/deps/libbar-[HASH].rlib`\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] `target/release/examples/a[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nfast1\nfast2\n\n\"#]])\n .run();\n\n p.cargo(\"run -v --example a\")\n .with_stderr_data(str![[r#\"\n[COMPILING] bar v0.5.0 ([ROOT]/foo/bar)\n[RUNNING] `rustc --crate-name bar --edition=2015 bar/src/bar.rs [..]--crate-type lib --emit=[..]link [..]-C debuginfo=2 [..]-C metadata=[..] --out-dir [ROOT]/foo/target/debug/deps -L dependency=[ROOT]/foo/target/debug/deps`\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name a --edition=2015 examples/a.rs [..]--crate-type bin --emit=[..]link [..]-C debuginfo=2 [..]-C metadata=[..] --out-dir [ROOT]/foo/target/debug/examples -L dependency=[ROOT]/foo/target/debug/deps --extern bar=[ROOT]/foo/target/debug/deps/libbar-[HASH].rlib`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/examples/a[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nslow1\nslow2\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_dylib_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n path = \"bar\"\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"extern crate bar; fn main() { bar::bar(); }\"#,\n )\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n authors = []\n\n [lib]\n name = \"bar\"\n crate-type = [\"dylib\"]\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n p.cargo(\"run hello world\").run();\n}\n\n#[cargo_test]\nfn run_with_bin_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies.bar]\n path = \"bar\"\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"bar\"\n \"#,\n )\n .file(\"bar/src/main.rs\", r#\"fn main() { println!(\"bar\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[WARNING] foo v0.0.1 ([ROOT]/foo) ignoring invalid dependency `bar` which is missing a lib target\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_with_bin_deps() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies.bar1]\n path = \"bar1\"\n [dependencies.bar2]\n path = \"bar2\"\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .file(\n \"bar1/Cargo.toml\",\n r#\"\n [package]\n name = \"bar1\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"bar1\"\n \"#,\n )\n .file(\"bar1/src/main.rs\", r#\"fn main() { println!(\"bar1\"); }\"#)\n .file(\n \"bar2/Cargo.toml\",\n r#\"\n [package]\n name = \"bar2\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"bar2\"\n \"#,\n )\n .file(\"bar2/src/main.rs\", r#\"fn main() { println!(\"bar2\"); }\"#)\n .build();\n\n p.cargo(\"run\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 2 packages to latest compatible versions\n[WARNING] foo v0.0.1 ([ROOT]/foo) ignoring invalid dependency `bar1` which is missing a lib target\n[WARNING] foo v0.0.1 ([ROOT]/foo) ignoring invalid dependency `bar2` which is missing a lib target\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_with_bin_dep_in_workspace() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo1\", \"foo2\"]\n \"#,\n )\n .file(\n \"foo1/Cargo.toml\",\n r#\"\n [package]\n name = \"foo1\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies.bar1]\n path = \"bar1\"\n \"#,\n )\n .file(\"foo1/src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .file(\n \"foo1/bar1/Cargo.toml\",\n r#\"\n [package]\n name = \"bar1\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"bar1\"\n \"#,\n )\n .file(\n \"foo1/bar1/src/main.rs\",\n r#\"fn main() { println!(\"bar1\"); }\"#,\n )\n .file(\n \"foo2/Cargo.toml\",\n r#\"\n [package]\n name = \"foo2\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies.bar2]\n path = \"bar2\"\n \"#,\n )\n .file(\"foo2/src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .file(\n \"foo2/bar2/Cargo.toml\",\n r#\"\n [package]\n name = \"bar2\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"bar2\"\n \"#,\n )\n .file(\n \"foo2/bar2/src/main.rs\",\n r#\"fn main() { println!(\"bar2\"); }\"#,\n )\n .build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `cargo run` could not determine which binary to run. Use the `--bin` option to specify a binary, or the `default-run` manifest key.\navailable binaries: bar1, bar2, foo1, foo2\n\n\"#]])\n .run();\n\n p.cargo(\"run --bin foo1\")\n .with_stderr_data(str![[r#\"\n[WARNING] foo1 v0.0.1 ([ROOT]/foo/foo1) ignoring invalid dependency `bar1` which is missing a lib target\n[WARNING] foo2 v0.0.1 ([ROOT]/foo/foo2) ignoring invalid dependency `bar2` which is missing a lib target\n[COMPILING] foo1 v0.0.1 ([ROOT]/foo/foo1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo1[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn release_works() {\n let p = project()\n .file(\n \"src/main.rs\",\n r#\"\n fn main() { if cfg!(debug_assertions) { panic!() } }\n \"#,\n )\n .build();\n\n p.cargo(\"run --release\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] `target/release/foo[EXE]`\n\n\"#]])\n .run();\n assert!(p.release_bin(\"foo\").is_file());\n}\n\n#[cargo_test]\nfn release_short_works() {\n let p = project()\n .file(\n \"src/main.rs\",\n r#\"\n fn main() { if cfg!(debug_assertions) { panic!() } }\n \"#,\n )\n .build();\n\n p.cargo(\"run -r\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] `target/release/foo[EXE]`\n\n\"#]])\n .run();\n assert!(p.release_bin(\"foo\").is_file());\n}\n\n#[cargo_test]\nfn run_bin_different_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"bar\"\n \"#,\n )\n .file(\"src/bar.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"run\").run();\n}\n\n#[cargo_test]\nfn dashes_are_forwarded() {\n let p = project()\n .file(\n \"src/bin/bar.rs\",\n r#\"\n fn main() {\n let s: Vec = std::env::args().collect();\n assert_eq!(s[1], \"--\");\n assert_eq!(s[2], \"a\");\n assert_eq!(s[3], \"--\");\n assert_eq!(s[4], \"b\");\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run -- -- a -- b\").run();\n}\n\n#[cargo_test]\nfn run_from_executable_folder() {\n let p = project()\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n let cwd = p.root().join(\"target\").join(\"debug\");\n p.cargo(\"build\").run();\n\n p.cargo(\"run\")\n .cwd(cwd)\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `./foo[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn run_with_library_paths() {\n let p = project();\n\n // Only link search directories within the target output directory are\n // propagated through to dylib_path_envvar() (see #3366).\n let mut dir1 = p.target_debug_dir();\n dir1.push(\"foo\\\\backslash\");\n\n let mut dir2 = p.target_debug_dir();\n dir2.push(\"dir=containing=equal=signs\");\n\n let p = p\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n build = \"build.rs\"\n \"#,\n )\n .file(\n \"build.rs\",\n &format!(\n r##\"\n fn main() {{\n println!(r#\"cargo::rustc-link-search=native={}\"#);\n println!(r#\"cargo::rustc-link-search={}\"#);\n }}\n \"##,\n dir1.display(),\n dir2.display()\n ),\n )\n .file(\n \"src/main.rs\",\n &format!(\n r##\"\n fn main() {{\n let search_path = std::env::var_os(\"{}\").unwrap();\n let paths = std::env::split_paths(&search_path).collect::>();\n println!(\"{{:#?}}\", paths);\n assert!(paths.contains(&r#\"{}\"#.into()));\n assert!(paths.contains(&r#\"{}\"#.into()));\n }}\n \"##,\n dylib_path_envvar(),\n dir1.display(),\n dir2.display()\n ),\n )\n .build();\n\n p.cargo(\"run\").run();\n}\n\n#[cargo_test]\nfn library_paths_sorted_alphabetically() {\n let p = project();\n\n let mut dir1 = p.target_debug_dir();\n dir1.push(\"zzzzzzz\");\n\n let mut dir2 = p.target_debug_dir();\n dir2.push(\"BBBBBBB\");\n\n let mut dir3 = p.target_debug_dir();\n dir3.push(\"aaaaaaa\");\n\n let p = p\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n build = \"build.rs\"\n \"#,\n )\n .file(\n \"build.rs\",\n &format!(\n r##\"\n fn main() {{\n println!(r#\"cargo::rustc-link-search=native={}\"#);\n println!(r#\"cargo::rustc-link-search=native={}\"#);\n println!(r#\"cargo::rustc-link-search=native={}\"#);\n }}\n \"##,\n dir1.display(),\n dir2.display(),\n dir3.display()\n ),\n )\n .file(\n \"src/main.rs\",\n &format!(\n r##\"\n fn main() {{\n let search_path = std::env::var_os(\"{}\").unwrap();\n let paths = std::env::split_paths(&search_path).collect::>();\n // ASCII case-sensitive sort\n assert_eq!(\"BBBBBBB\", paths[0].file_name().unwrap().to_string_lossy());\n assert_eq!(\"aaaaaaa\", paths[1].file_name().unwrap().to_string_lossy());\n assert_eq!(\"zzzzzzz\", paths[2].file_name().unwrap().to_string_lossy());\n }}\n \"##,\n dylib_path_envvar()\n ),\n )\n .build();\n\n p.cargo(\"run\").run();\n}\n\n#[cargo_test]\nfn fail_no_extra_verbose() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() { std::process::exit(1); }\")\n .build();\n\n p.cargo(\"run -q\")\n .with_status(1)\n .with_stdout_data(\"\")\n .with_stderr_data(\"\")\n .run();\n}\n\n#[cargo_test]\nfn run_multiple_packages() {\n let p = project()\n .no_manifest()\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n\n [dependencies]\n d1 = { path = \"d1\" }\n d2 = { path = \"d2\" }\n d3 = { path = \"../d3\" } # outside of the workspace\n\n [[bin]]\n name = \"foo\"\n \"#,\n )\n .file(\"foo/src/foo.rs\", \"fn main() { println!(\\\"foo\\\"); }\")\n .file(\"foo/d1/Cargo.toml\", &basic_bin_manifest(\"d1\"))\n .file(\"foo/d1/src/lib.rs\", \"\")\n .file(\"foo/d1/src/main.rs\", \"fn main() { println!(\\\"d1\\\"); }\")\n .file(\"foo/d2/Cargo.toml\", &basic_bin_manifest(\"d2\"))\n .file(\"foo/d2/src/main.rs\", \"fn main() { println!(\\\"d2\\\"); }\")\n .file(\"d3/Cargo.toml\", &basic_bin_manifest(\"d3\"))\n .file(\"d3/src/main.rs\", \"fn main() { println!(\\\"d2\\\"); }\")\n .build();\n\n let cargo = || {\n let mut process_builder = p.cargo(\"run\");\n process_builder.cwd(\"foo\");\n process_builder\n };\n\n cargo()\n .arg(\"-p\")\n .arg(\"d1\")\n .with_stdout_data(str![[r#\"\nd1\n\n\"#]])\n .run();\n\n cargo()\n .arg(\"-p\")\n .arg(\"d2\")\n .arg(\"--bin\")\n .arg(\"d2\")\n .with_stdout_data(str![[r#\"\nd2\n\n\"#]])\n .run();\n\n cargo()\n .with_stdout_data(str![[r#\"\nfoo\n\n\"#]])\n .run();\n\n cargo()\n .arg(\"-p\")\n .arg(\"d1\")\n .arg(\"-p\")\n .arg(\"d2\")\n .with_status(1)\n .with_stderr_data(str![[r#\"\n[ERROR] the argument '--package []' cannot be used multiple times\n...\n\"#]])\n .run();\n\n cargo()\n .arg(\"-p\")\n .arg(\"d3\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package(s) `d3` not found in workspace `[ROOT]/foo/foo`\n\n\"#]])\n .run();\n\n cargo()\n .arg(\"-p\")\n .arg(\"d*\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `cargo run` does not support glob pattern `d*` on package selection\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn explicit_bin_with_args() {\n let p = project()\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n assert_eq!(std::env::args().nth(1).unwrap(), \"hello\");\n assert_eq!(std::env::args().nth(2).unwrap(), \"world\");\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run --bin foo hello world\").run();\n}\n\n#[cargo_test]\nfn run_workspace() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\"]\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_bin_manifest(\"a\"))\n .file(\"a/src/main.rs\", r#\"fn main() {println!(\"run-a\");}\"#)\n .file(\"b/Cargo.toml\", &basic_bin_manifest(\"b\"))\n .file(\"b/src/main.rs\", r#\"fn main() {println!(\"run-b\");}\"#)\n .build();\n\n p.cargo(\"run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `cargo run` could not determine which binary to run. Use the `--bin` option to specify a binary, or the `default-run` manifest key.\navailable binaries: a, b\n\n\"#]])\n .run();\n p.cargo(\"run --bin a\")\n .with_stdout_data(str![[r#\"\nrun-a\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn default_run_workspace() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.0.1\"\n edition = \"2015\"\n default-run = \"a\"\n \"#,\n )\n .file(\"a/src/main.rs\", r#\"fn main() {println!(\"run-a\");}\"#)\n .file(\"b/Cargo.toml\", &basic_bin_manifest(\"b\"))\n .file(\"b/src/main.rs\", r#\"fn main() {println!(\"run-b\");}\"#)\n .build();\n\n p.cargo(\"run\")\n .with_stdout_data(str![[r#\"\nrun-a\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn print_env_verbose() {\n let p = project()\n .file(\"Cargo.toml\", &basic_manifest(\"a\", \"0.0.1\"))\n .file(\"src/main.rs\", r#\"fn main() {println!(\"run-a\");}\"#)\n .build();\n\n p.cargo(\"run -vv\")\n .with_stderr_data(str![[r#\"\n[COMPILING] a v0.0.1 ([ROOT]/foo)\n[RUNNING] `[..]CARGO_MANIFEST_DIR=[ROOT]/foo[..] rustc --crate-name a[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[..]CARGO_MANIFEST_DIR=[ROOT]/foo[..] target/debug/a[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\n#[cfg(target_os = \"macos\")]\nfn run_link_system_path_macos() {\n use cargo_test_support::paths;\n use std::fs;\n // Check that the default system library path is honored.\n // First, build a shared library that will be accessed from\n // DYLD_FALLBACK_LIBRARY_PATH.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n [lib]\n crate-type = [\"cdylib\"]\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"#[no_mangle] pub extern fn something_shared() {}\",\n )\n .build();\n p.cargo(\"build\").run();\n\n // This is convoluted. Since this test can't modify things in /usr,\n // this needs to dance around to check that things work.\n //\n // The default DYLD_FALLBACK_LIBRARY_PATH is:\n // $(HOME)/lib:/usr/local/lib:/lib:/usr/lib\n //\n // This will make use of ~/lib in the path, but the default cc link\n // path is /usr/lib:/usr/local/lib. So first need to build in one\n // location, and then move it to ~/lib.\n //\n // 1. Build with rustc-link-search pointing to libfoo so the initial\n // binary can be linked.\n // 2. Move the library to ~/lib\n // 3. Run `cargo run` to make sure it can still find the library in\n // ~/lib.\n //\n // This should be equivalent to having the library in /usr/local/lib.\n let p2 = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_bin_manifest(\"bar\"))\n .file(\n \"src/main.rs\",\n r#\"\n extern {\n fn something_shared();\n }\n fn main() {\n unsafe { something_shared(); }\n }\n \"#,\n )\n .file(\n \"build.rs\",\n &format!(\n r#\"\n fn main() {{\n println!(\"cargo::rustc-link-lib=foo\");\n println!(\"cargo::rustc-link-search={}\");\n }}\n \"#,\n p.target_debug_dir().display()\n ),\n )\n .build();\n p2.cargo(\"build\").run();\n p2.cargo(\"test\").run();\n\n let libdir = paths::home().join(\"lib\");\n fs::create_dir(&libdir).unwrap();\n fs::rename(\n p.target_debug_dir().join(\"libfoo.dylib\"),\n libdir.join(\"libfoo.dylib\"),\n )\n .unwrap();\n p.root().rm_rf();\n const VAR: &str = \"DYLD_FALLBACK_LIBRARY_PATH\";\n // Reset DYLD_FALLBACK_LIBRARY_PATH so that we don't inherit anything that\n // was set by the cargo that invoked the test.\n p2.cargo(\"run\").env_remove(VAR).run();\n p2.cargo(\"test\").env_remove(VAR).run();\n // Ensure this still works when DYLD_FALLBACK_LIBRARY_PATH has\n // a value set.\n p2.cargo(\"run\").env(VAR, &libdir).run();\n p2.cargo(\"test\").env(VAR, &libdir).run();\n}\n\n#[cargo_test]\nfn run_binary_with_same_name_as_dependency() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = { path = \"foo\" }\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {}\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"foo\"\n path = \"foo.rs\"\n \"#,\n )\n .file(\"foo/foo.rs\", \"\")\n .build();\n p.cargo(\"run\").run();\n p.cargo(\"check -p foo@0.5.0\").run();\n p.cargo(\"run -p foo@0.5.0\").run();\n p.cargo(\"run -p foo@0.5\").run();\n p.cargo(\"run -p foo@0.4\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package(s) `foo@0.4` not found in workspace `[ROOT]/foo`\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/rust_version.rs", "content": "//! Tests for targets with `rust-version`.\n\nuse crate::prelude::*;\nuse crate::utils::cargo_process;\nuse cargo_test_support::{project, registry::Package, str};\n\n#[cargo_test]\nfn rust_version_satisfied() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.1.1\"\n [[bin]]\n name = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\").run();\n p.cargo(\"check --ignore-rust-version\").run();\n}\n\n#[cargo_test]\nfn rust_version_error() {\n project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"^1.43\"\n [[bin]]\n name = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build()\n .cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] unexpected version requirement, expected a version like \"1.32\"\n --> Cargo.toml:7:28\n |\n7 | rust-version = \"^1.43\"\n | ^^^^^^^\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rust_version_older_than_edition() {\n project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n rust-version = \"1.1\"\n edition = \"2018\"\n [[bin]]\n name = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build()\n .cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n rust-version 1.1 is incompatible with the version (1.31.0) required by the specified edition (2018)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn lint_self_incompatible_with_rust_version() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.9876.0\"\n [[bin]]\n name = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] rustc [..] is not supported by the following package:\n foo@0.0.1 requires rustc 1.9876.0\n\n\n\"#]])\n .run();\n p.cargo(\"check --ignore-rust-version\").run();\n}\n\n#[cargo_test]\nfn lint_dep_incompatible_with_rust_version() {\n Package::new(\"too_new_parent\", \"0.0.1\")\n .dep(\"too_new_child\", \"0.0.1\")\n .rust_version(\"1.2345.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"too_new_child\", \"0.0.1\")\n .rust_version(\"1.2345.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"rustc_compatible\", \"0.0.1\")\n .rust_version(\"1.60.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n rust-version = \"1.50\"\n authors = []\n [dependencies]\n too_new_parent = \"0.0.1\"\n rustc_compatible = \"0.0.1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n p.cargo(\"generate-lockfile\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 3 packages to latest compatible versions\n[ADDING] too_new_child v0.0.1 (requires Rust 1.2345.0)\n[ADDING] too_new_parent v0.0.1 (requires Rust 1.2345.0)\n\n\"#]])\n .run();\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] too_new_parent v0.0.1 (registry `dummy-registry`)\n[DOWNLOADED] too_new_child v0.0.1 (registry `dummy-registry`)\n[DOWNLOADED] rustc_compatible v0.0.1 (registry `dummy-registry`)\n[ERROR] rustc [..] is not supported by the following packages:\n too_new_child@0.0.1 requires rustc 1.2345.0\n too_new_parent@0.0.1 requires rustc 1.2345.0\nEither upgrade rustc or select compatible dependency versions with\n`cargo update @ --precise `\nwhere `` is the latest version supporting rustc [..]\n\n\n\"#]])\n .run();\n p.cargo(\"check --ignore-rust-version\").run();\n}\n\n#[cargo_test]\nfn resolve_with_rust_version() {\n Package::new(\"only-newer\", \"1.6.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.5.0\")\n .rust_version(\"1.55.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.6.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.60.0\"\n\n [dependencies]\n only-newer = \"1.0.0\"\n newer-and-older = \"1.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n p.cargo(\"generate-lockfile --ignore-rust-version\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.6.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n\n p.cargo(\"generate-lockfile\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest Rust 1.60.0 compatible versions\n[ADDING] newer-and-older v1.5.0 (available: v1.6.0, requires Rust 1.65.0)\n[ADDING] only-newer v1.6.0 (requires Rust 1.65.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.5.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn resolve_with_rustc() {\n Package::new(\"only-newer\", \"1.6.0\")\n .rust_version(\"1.2345\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.5.0\")\n .rust_version(\"1.55.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.6.0\")\n .rust_version(\"1.2345\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.60.0\"\n\n [dependencies]\n only-newer = \"1.0.0\"\n newer-and-older = \"1.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n p.cargo(\"generate-lockfile --ignore-rust-version\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[ADDING] newer-and-older v1.6.0 (requires Rust 1.2345)\n[ADDING] only-newer v1.6.0 (requires Rust 1.2345)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.6.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n\n p.cargo(\"generate-lockfile\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest Rust 1.60.0 compatible versions\n[ADDING] newer-and-older v1.5.0 (available: v1.6.0, requires Rust 1.2345)\n[ADDING] only-newer v1.6.0 (requires Rust 1.2345)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.5.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn resolve_with_backtracking() {\n Package::new(\"has-rust-version\", \"1.6.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"no-rust-version\", \"2.1.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"no-rust-version\", \"2.2.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .dep(\"has-rust-version\", \"1.6.0\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.60.0\"\n\n [dependencies]\n no-rust-version = \"2\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n p.cargo(\"generate-lockfile --ignore-rust-version\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā””ā”€ā”€ no-rust-version v2.2.0\n ā””ā”€ā”€ has-rust-version v1.6.0\n\n\"#]])\n .run();\n\n // Ideally we'd pick `has-rust-version` 1.6.0 which requires backtracking\n p.cargo(\"generate-lockfile\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest Rust 1.60.0 compatible versions\n[ADDING] has-rust-version v1.6.0 (requires Rust 1.65.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā””ā”€ā”€ no-rust-version v2.2.0\n ā””ā”€ā”€ has-rust-version v1.6.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn resolve_with_multiple_rust_versions() {\n Package::new(&format!(\"shared-only-newer\"), \"1.65.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n for ver in [\"1.45.0\", \"1.55.0\", \"1.65.0\"] {\n Package::new(&format!(\"shared-newer-and-older\"), ver)\n .rust_version(ver)\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n }\n Package::new(&format!(\"lower-only-newer\"), \"1.65.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n for ver in [\"1.45.0\", \"1.55.0\"] {\n Package::new(&format!(\"lower-newer-and-older\"), ver)\n .rust_version(ver)\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n }\n Package::new(&format!(\"higher-only-newer\"), \"1.65.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n for ver in [\"1.55.0\", \"1.65.0\"] {\n Package::new(&format!(\"higher-newer-and-older\"), ver)\n .rust_version(ver)\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n }\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"lower\"]\n\n [package]\n name = \"higher\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.60.0\"\n\n [dependencies]\n higher-only-newer = \"1\"\n higher-newer-and-older = \"1\"\n shared-only-newer = \"1\"\n shared-newer-and-older = \"1\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"lower/Cargo.toml\",\n r#\"\n [package]\n name = \"lower\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.50.0\"\n\n [dependencies]\n lower-only-newer = \"1\"\n lower-newer-and-older = \"1\"\n shared-only-newer = \"1\"\n shared-newer-and-older = \"1\"\n \"#,\n )\n .file(\"lower/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"generate-lockfile --ignore-rust-version\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 6 packages to latest compatible versions\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nhigher v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ higher-newer-and-older v1.65.0\nā”œā”€ā”€ higher-only-newer v1.65.0\nā”œā”€ā”€ shared-newer-and-older v1.65.0\nā””ā”€ā”€ shared-only-newer v1.65.0\n\n\"#]])\n .run();\n\n p.cargo(\"generate-lockfile\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 6 packages to latest Rust 1.50.0 compatible versions\n[ADDING] higher-newer-and-older v1.55.0 (available: v1.65.0, requires Rust 1.65.0)\n[ADDING] higher-only-newer v1.65.0 (requires Rust 1.65.0)\n[ADDING] lower-newer-and-older v1.45.0 (available: v1.55.0, requires Rust 1.55.0)\n[ADDING] lower-only-newer v1.65.0 (requires Rust 1.65.0)\n[ADDING] shared-newer-and-older v1.45.0 (available: v1.65.0, requires Rust 1.65.0)\n[ADDING] shared-only-newer v1.65.0 (requires Rust 1.65.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nhigher v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ higher-newer-and-older v1.55.0\nā”œā”€ā”€ higher-only-newer v1.65.0\nā”œā”€ā”€ shared-newer-and-older v1.45.0\nā””ā”€ā”€ shared-only-newer v1.65.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn resolve_edition2024() {\n Package::new(\"only-newer\", \"1.6.0\")\n .rust_version(\"1.999.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.5.0\")\n .rust_version(\"1.80.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.6.0\")\n .rust_version(\"1.999.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2024\"\n authors = []\n rust-version = \"1.85.0\"\n\n [dependencies]\n only-newer = \"1.0.0\"\n newer-and-older = \"1.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n // Edition2024 should resolve for MSRV\n p.cargo(\"generate-lockfile\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest Rust 1.85.0 compatible versions\n[ADDING] newer-and-older v1.5.0 (available: v1.6.0, requires Rust 1.999.0)\n[ADDING] only-newer v1.6.0 (requires Rust 1.999.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.5.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n\n // `--ignore-rust-version` has precedence over Edition2024\n p.cargo(\"generate-lockfile --ignore-rust-version\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[ADDING] newer-and-older v1.6.0 (requires Rust 1.999.0)\n[ADDING] only-newer v1.6.0 (requires Rust 1.999.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.6.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n\n // config has precedence over Edition2024\n p.cargo(\"generate-lockfile\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"allow\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[ADDING] newer-and-older v1.6.0 (requires Rust 1.999.0)\n[ADDING] only-newer v1.6.0 (requires Rust 1.999.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.6.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn resolve_v3() {\n Package::new(\"only-newer\", \"1.6.0\")\n .rust_version(\"1.999.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.5.0\")\n .rust_version(\"1.80.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.6.0\")\n .rust_version(\"1.999.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.85.0\"\n resolver = \"3\"\n\n [dependencies]\n only-newer = \"1.0.0\"\n newer-and-older = \"1.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n // v3 should resolve for MSRV\n p.cargo(\"generate-lockfile\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest Rust 1.85.0 compatible versions\n[ADDING] newer-and-older v1.5.0 (available: v1.6.0, requires Rust 1.999.0)\n[ADDING] only-newer v1.6.0 (requires Rust 1.999.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.5.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n\n // `--ignore-rust-version` has precedence over v3\n p.cargo(\"generate-lockfile --ignore-rust-version\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[ADDING] newer-and-older v1.6.0 (requires Rust 1.999.0)\n[ADDING] only-newer v1.6.0 (requires Rust 1.999.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.6.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n\n // config has precedence over v3\n p.cargo(\"generate-lockfile\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"allow\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[ADDING] newer-and-older v1.6.0 (requires Rust 1.999.0)\n[ADDING] only-newer v1.6.0 (requires Rust 1.999.0)\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.6.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_msrv_resolve() {\n Package::new(\"bar\", \"1.5.0\")\n .rust_version(\"1.55.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"bar\", \"1.6.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.60.0\"\n [dependencies]\n bar = \"1.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n p.cargo(\"update\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest Rust 1.60.0 compatible version\n[ADDING] bar v1.5.0 (available: v1.6.0, requires Rust 1.65.0)\n\n\"#]])\n .run();\n p.cargo(\"update --ignore-rust-version\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v1.5.0 -> v1.6.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_precise_overrides_msrv_resolver() {\n Package::new(\"bar\", \"1.5.0\")\n .rust_version(\"1.55.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"bar\", \"1.6.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.60.0\"\n [dependencies]\n bar = \"1.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n p.cargo(\"update\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest Rust 1.60.0 compatible version\n[ADDING] bar v1.5.0 (available: v1.6.0, requires Rust 1.65.0)\n\n\"#]])\n .run();\n p.cargo(\"update --precise 1.6.0 bar\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] bar v1.5.0 -> v1.6.0 (requires Rust 1.65.0)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn check_msrv_resolve() {\n Package::new(\"only-newer\", \"1.6.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.5.0\")\n .rust_version(\"1.55.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"newer-and-older\", \"1.6.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n rust-version = \"1.60.0\"\n\n [dependencies]\n only-newer = \"1.0.0\"\n newer-and-older = \"1.0.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main(){}\")\n .build();\n\n p.cargo(\"check --ignore-rust-version\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] only-newer v1.6.0 (registry `dummy-registry`)\n[DOWNLOADED] newer-and-older v1.6.0 (registry `dummy-registry`)\n[CHECKING] only-newer v1.6.0\n[CHECKING] newer-and-older v1.6.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.6.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n\n std::fs::remove_file(p.root().join(\"Cargo.lock\")).unwrap();\n p.cargo(\"check\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest Rust 1.60.0 compatible versions\n[ADDING] newer-and-older v1.5.0 (available: v1.6.0, requires Rust 1.65.0)\n[ADDING] only-newer v1.6.0 (requires Rust 1.65.0)\n[DOWNLOADING] crates ...\n[DOWNLOADED] newer-and-older v1.5.0 (registry `dummy-registry`)\n[CHECKING] newer-and-older v1.5.0\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n p.cargo(\"tree\")\n .with_stdout_data(str![[r#\"\nfoo v0.0.1 ([ROOT]/foo)\nā”œā”€ā”€ newer-and-older v1.5.0\nā””ā”€ā”€ only-newer v1.6.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_install_ignores_msrv_config() {\n Package::new(\"dep\", \"1.0.0\")\n .rust_version(\"1.50\")\n .file(\"src/lib.rs\", \"fn hello() {}\")\n .publish();\n Package::new(\"dep\", \"1.1.0\")\n .rust_version(\"1.70\")\n .file(\"src/lib.rs\", \"fn hello() {}\")\n .publish();\n Package::new(\"foo\", \"0.0.1\")\n .rust_version(\"1.60\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .dep(\"dep\", \"1\")\n .publish();\n\n cargo_process(\"install foo\")\n .env(\n \"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\",\n \"fallback\",\n )\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)\n[INSTALLING] foo v0.0.1\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] dep v1.1.0 (registry `dummy-registry`)\n[COMPILING] dep v1.1.0\n[COMPILING] foo v0.0.1\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]\n[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)\n[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_install_ignores_resolver_v3_msrv_change() {\n Package::new(\"dep\", \"1.0.0\")\n .rust_version(\"1.50\")\n .file(\"src/lib.rs\", \"fn hello() {}\")\n .publish();\n Package::new(\"dep\", \"1.1.0\")\n .rust_version(\"1.70\")\n .file(\"src/lib.rs\", \"fn hello() {}\")\n .publish();\n Package::new(\"foo\", \"0.0.1\")\n .rust_version(\"1.60\")\n .resolver(\"3\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .dep(\"dep\", \"1\")\n .publish();\n\n cargo_process(\"install foo\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)\n[INSTALLING] foo v0.0.1\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] dep v1.1.0 (registry `dummy-registry`)\n[COMPILING] dep v1.1.0\n[COMPILING] foo v0.0.1\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]\n[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)\n[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn report_rust_versions() {\n Package::new(\"dep-only-low-compatible\", \"1.55.0\")\n .rust_version(\"1.55.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"dep-only-low-incompatible\", \"1.75.0\")\n .rust_version(\"1.75.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"dep-only-high-compatible\", \"1.65.0\")\n .rust_version(\"1.65.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"dep-only-high-incompatible\", \"1.75.0\")\n .rust_version(\"1.75.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"dep-only-unset-unset\", \"1.0.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"dep-only-unset-compatible\", \"1.75.0\")\n .rust_version(\"1.75.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"dep-only-unset-incompatible\", \"1.2345.0\")\n .rust_version(\"1.2345.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"dep-shared-compatible\", \"1.55.0\")\n .rust_version(\"1.55.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n Package::new(\"dep-shared-incompatible\", \"1.75.0\")\n .rust_version(\"1.75.0\")\n .file(\"src/lib.rs\", \"fn other_stuff() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"high\", \"low\", \"unset\"]\n \"#,\n )\n .file(\n \"high/Cargo.toml\",\n r#\"\n [package]\n name = \"high\"\n edition = \"2015\"\n rust-version = \"1.70.0\"\n\n [dependencies]\n dep-only-high-compatible = \"1\"\n dep-only-high-incompatible = \"1\"\n dep-shared-compatible = \"1\"\n dep-shared-incompatible = \"1\"\n \"#,\n )\n .file(\"high/src/main.rs\", \"fn main(){}\")\n .file(\n \"low/Cargo.toml\",\n r#\"\n [package]\n name = \"low\"\n edition = \"2015\"\n rust-version = \"1.60.0\"\n\n [dependencies]\n dep-only-low-compatible = \"1\"\n dep-only-low-incompatible = \"1\"\n dep-shared-compatible = \"1\"\n dep-shared-incompatible = \"1\"\n \"#,\n )\n .file(\"low/src/main.rs\", \"fn main(){}\")\n .file(\n \"unset/Cargo.toml\",\n r#\"\n [package]\n name = \"unset\"\n edition = \"2015\"\n\n [dependencies]\n dep-only-unset-unset = \"1\"\n dep-only-unset-compatible = \"1\"\n dep-only-unset-incompatible = \"1\"\n dep-shared-compatible = \"1\"\n dep-shared-incompatible = \"1\"\n \"#,\n )\n .file(\"unset/src/main.rs\", \"fn main(){}\")\n .build();\n\n p.cargo(\"update\")\n .env(\"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS\", \"fallback\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 9 packages to latest Rust 1.60.0 compatible versions\n[ADDING] dep-only-high-incompatible v1.75.0 (requires Rust 1.75.0)\n[ADDING] dep-only-low-incompatible v1.75.0 (requires Rust 1.75.0)\n[ADDING] dep-only-unset-incompatible v1.2345.0 (requires Rust 1.2345.0)\n[ADDING] dep-shared-incompatible v1.75.0 (requires Rust 1.75.0)\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/rustc.rs", "content": "//! Tests for the `cargo rustc` command.\n\nuse crate::prelude::*;\nuse cargo_test_support::basic_bin_manifest;\nuse cargo_test_support::basic_lib_manifest;\nuse cargo_test_support::basic_manifest;\nuse cargo_test_support::project;\nuse cargo_test_support::str;\nuse cargo_test_support::target_spec_json;\n\n#[cargo_test]\nfn build_lib_for_foo() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustc --lib -v\").with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib --emit=[..]link[..]-C debuginfo=2 [..]-C metadata=[..] [..]--out-dir [ROOT]/foo/target/debug/deps -L dependency=[ROOT]/foo/target/debug/deps`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn lib() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustc --lib -v -- -C debug-assertions=off\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib --emit=[..]link[..]-C debuginfo=2 [..]-C metadata=[..] [..]--out-dir [ROOT]/foo/target/debug/deps -L dependency=[ROOT]/foo/target/debug/deps[..]-C debug-assertions=off[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_main_and_allow_unstable_options() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustc -v --bin foo -- -C debug-assertions\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib --emit=[..]link[..]-C debuginfo=2 [..]-C metadata=[..] --out-dir [ROOT]/foo/target/debug/deps -L dependency=[ROOT]/foo/target/debug/deps`\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]--crate-type bin --emit=[..]link[..]-C debuginfo=2 [..]-C metadata=[..] --out-dir [ROOT]/foo/target/debug/deps -L dependency=[ROOT]/foo/target/debug/deps --extern foo=[ROOT]/foo/target/debug/deps/libfoo-[HASH].rlib[..]-C debug-assertions[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fails_when_trying_to_build_main_and_lib_with_args() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustc -v -- -C debug-assertions\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] extra arguments to `rustc` can only be passed to one target, consider filtering\nthe package by passing, e.g., `--lib` or `--bin NAME` to specify a single target\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_args_to_one_of_multiple_binaries() {\n let p = project()\n .file(\"src/bin/foo.rs\", \"fn main() {}\")\n .file(\"src/bin/bar.rs\", \"fn main() {}\")\n .file(\"src/bin/baz.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustc -v --bin bar -- -C debug-assertions\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib --emit=[..]link[..]-C debuginfo=2 [..]-C metadata=[..] --out-dir [..]`\n[RUNNING] `rustc --crate-name bar --edition=2015 src/bin/bar.rs [..]--crate-type bin --emit=[..]link[..]-C debuginfo=2 [..]-C debug-assertions[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fails_with_args_to_all_binaries() {\n let p = project()\n .file(\"src/bin/foo.rs\", \"fn main() {}\")\n .file(\"src/bin/bar.rs\", \"fn main() {}\")\n .file(\"src/bin/baz.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustc -v -- -C debug-assertions\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] extra arguments to `rustc` can only be passed to one target, consider filtering\nthe package by passing, e.g., `--lib` or `--bin NAME` to specify a single target\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fails_with_crate_type_to_multi_binaries() {\n let p = project()\n .file(\"src/bin/foo.rs\", \"fn main() {}\")\n .file(\"src/bin/bar.rs\", \"fn main() {}\")\n .file(\"src/bin/baz.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustc --crate-type lib\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] crate types to rustc can only be passed to one target, consider filtering\nthe package by passing, e.g., `--lib` or `--example` to specify a single target\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fails_with_crate_type_to_multi_examples() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[example]]\n name = \"ex1\"\n crate-type = [\"rlib\"]\n [[example]]\n name = \"ex2\"\n crate-type = [\"rlib\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/ex1.rs\", \"\")\n .file(\"examples/ex2.rs\", \"\")\n .build();\n\n p.cargo(\"rustc -v --example ex1 --example ex2 --crate-type lib,cdylib\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] crate types to rustc can only be passed to one target, consider filtering\nthe package by passing, e.g., `--lib` or `--example` to specify a single target\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fails_with_crate_type_to_binary() {\n let p = project().file(\"src/bin/foo.rs\", \"fn main() {}\").build();\n\n p.cargo(\"rustc --crate-type lib\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] crate types can only be specified for libraries and example libraries.\nBinaries, tests, and benchmarks are always the `bin` crate type\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_crate_type_for_foo() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustc -v --crate-type cdylib\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type cdylib [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_crate_type_for_foo_with_deps() {\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate a;\n pub fn foo() { a::hello(); }\n \"#,\n )\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = { path = \"a\" }\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"pub fn hello() {}\")\n .build();\n\n p.cargo(\"rustc -v --crate-type cdylib\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] a v0.1.0 ([ROOT]/foo/a)\n[RUNNING] `rustc --crate-name a --edition=2015 a/src/lib.rs [..]--crate-type lib [..]`\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type cdylib [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_crate_types_for_foo() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustc -v --crate-type lib,cdylib\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib --crate-type cdylib [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_crate_type_to_example() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[example]]\n name = \"ex\"\n crate-type = [\"rlib\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/ex.rs\", \"\")\n .build();\n\n p.cargo(\"rustc -v --example ex --crate-type cdylib\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib [..]`\n[RUNNING] `rustc --crate-name ex --edition=2015 examples/ex.rs [..]--crate-type cdylib [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_crate_types_to_example() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[example]]\n name = \"ex\"\n crate-type = [\"rlib\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/ex.rs\", \"\")\n .build();\n\n p.cargo(\"rustc -v --example ex --crate-type lib,cdylib\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib [..]`\n[RUNNING] `rustc --crate-name ex --edition=2015 examples/ex.rs [..]--crate-type lib --crate-type cdylib [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_crate_types_to_one_of_multi_examples() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[example]]\n name = \"ex1\"\n crate-type = [\"rlib\"]\n [[example]]\n name = \"ex2\"\n crate-type = [\"rlib\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/ex1.rs\", \"\")\n .file(\"examples/ex2.rs\", \"\")\n .build();\n\n p.cargo(\"rustc -v --example ex1 --crate-type lib,cdylib\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib [..]`\n[RUNNING] `rustc --crate-name ex1 --edition=2015 examples/ex1.rs [..]--crate-type lib --crate-type cdylib [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_args_to_one_of_multiple_tests() {\n let p = project()\n .file(\"tests/foo.rs\", r#\" \"#)\n .file(\"tests/bar.rs\", r#\" \"#)\n .file(\"tests/baz.rs\", r#\" \"#)\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustc -v --test bar -- -C debug-assertions\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..]--crate-type lib --emit=[..]link[..]-C debuginfo=2 [..]-C metadata=[..] --out-dir [..]`\n[RUNNING] `rustc --crate-name bar --edition=2015 tests/bar.rs [..]--emit=[..]link[..]-C debuginfo=2 [..]--test[..]-C debug-assertions[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_foo_with_bar_dependency() {\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\"src/main.rs\", \"extern crate bar; fn main() { bar::baz() }\")\n .build();\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n foo.cargo(\"rustc -v -- -C debug-assertions\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] bar v0.1.0 ([ROOT]/bar)\n[RUNNING] `rustc --crate-name bar [..] -C debuginfo=2[..]`\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] -C debuginfo=2 [..]-C debug-assertions[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_only_bar_dependency() {\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\"src/main.rs\", \"extern crate bar; fn main() { bar::baz() }\")\n .build();\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n foo.cargo(\"rustc -v -p bar -- -C debug-assertions\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] bar v0.1.0 ([ROOT]/bar)\n[RUNNING] `rustc --crate-name bar [..]--crate-type lib [..] -C debug-assertions[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn targets_selected_default() {\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n p.cargo(\"rustc -v\")\n // bin\n .with_stderr_contains(\n \"[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]--crate-type bin \\\n --emit=[..]link[..]\",\n )\n // bench\n .with_stderr_does_not_contain(\n \"[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]--emit=[..]link \\\n -C opt-level=3 --test [..]\",\n )\n // unit test\n .with_stderr_does_not_contain(\n \"[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]--emit=[..]link \\\n -C debuginfo=2 [..]--test [..]\",\n )\n .run();\n}\n\n#[cargo_test]\nfn targets_selected_all() {\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n p.cargo(\"rustc -v --all-targets\")\n // bin and unit test\n .with_stderr_data(\n str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]--crate-type bin --emit=[..]link[..]`\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]--emit[..]link[..] -C debuginfo=2 [..]--test [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]].unordered()\n )\n .run();\n}\n\n#[cargo_test]\nfn fail_with_multiple_packages() {\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n path = \"../bar\"\n\n [dependencies.baz]\n path = \"../baz\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n if cfg!(flag = \"1\") { println!(\"Yeah from bar!\"); }\n }\n \"#,\n )\n .build();\n\n let _baz = project()\n .at(\"baz\")\n .file(\"Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n if cfg!(flag = \"1\") { println!(\"Yeah from baz!\"); }\n }\n \"#,\n )\n .build();\n\n foo.cargo(\"rustc -v -p bar -p baz\")\n .with_status(1)\n .with_stderr_data(str![[r#\"\n[ERROR] the argument '--package []' cannot be used multiple times\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fail_with_bad_bin_no_package() {\n let p = project()\n .file(\n \"src/main.rs\",\n r#\"\n fn main() { println!(\"hello a.rs\"); }\n \"#,\n )\n .build();\n\n p.cargo(\"rustc --bin main\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `main`\n[HELP] available bin targets:\n foo\n...\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fail_with_glob() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"pub fn bar() { break_the_build(); }\")\n .build();\n\n p.cargo(\"rustc -p '*z'\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] glob patterns on package selection are not supported.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustc_with_other_profile() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dev-dependencies]\n a = { path = \"a\" }\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n #[cfg(test)] extern crate a;\n\n #[test]\n fn foo() {}\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"rustc --profile test\").run();\n}\n\n#[cargo_test]\nfn rustc_fingerprint() {\n // Verify that the fingerprint includes the rustc args.\n let p = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"rustc -v -- -C debug-assertions\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..]-C debug-assertions[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"rustc -v -- -C debug-assertions\")\n .with_stderr_data(str![[r#\"\n[FRESH] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"rustc -v\")\n .with_stderr_does_not_contain(\"-C debug-assertions\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"rustc -v\")\n .with_stderr_data(str![[r#\"\n[FRESH] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustc_test_with_implicit_bin() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\n \"src/main.rs\",\n r#\"\n #[cfg(foo)]\n fn f() { compile_fail!(\"Foo shouldn't be set.\"); }\n fn main() {}\n \"#,\n )\n .file(\n \"tests/test1.rs\",\n r#\"\n #[cfg(not(foo))]\n fn f() { compile_fail!(\"Foo should be set.\"); }\n \"#,\n )\n .build();\n\n p.cargo(\"rustc --test test1 -v -- --cfg foo\")\n .with_stderr_data(\n str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name test1 --edition=2015 tests/test1.rs [..] --cfg foo[..]`\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]`\n...\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn rustc_with_print_cfg_single_target() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/main.rs\", r#\"fn main() {} \"#)\n .build();\n\n p.cargo(\"rustc -Z unstable-options --target x86_64-pc-windows-msvc --print cfg\")\n .masquerade_as_nightly_cargo(&[\"print\"])\n .with_stdout_data(\n str![[r#\"\ndebug_assertions\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"msvc\"\ntarget_family=\"windows\"\ntarget_os=\"windows\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"pc\"\nwindows\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn rustc_with_print_cfg_multiple_targets() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/main.rs\", r#\"fn main() {} \"#)\n .build();\n\n p.cargo(\"rustc -Z unstable-options --target x86_64-pc-windows-msvc --target i686-unknown-linux-gnu --print cfg\")\n .masquerade_as_nightly_cargo(&[\"print\"])\n .with_stdout_data(str![[r#\"\ndebug_assertions\ntarget_arch=\"x86\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"32\"\ntarget_vendor=\"unknown\"\nunix\ndebug_assertions\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"msvc\"\ntarget_family=\"windows\"\ntarget_os=\"windows\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"pc\"\nwindows\n...\n\"#]].unordered())\n .run();\n}\n\n#[cargo_test]\nfn rustc_with_print_cfg_rustflags_env_var() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/main.rs\", r#\"fn main() {} \"#)\n .build();\n\n p.cargo(\"rustc -Z unstable-options --target x86_64-pc-windows-msvc --print cfg\")\n .masquerade_as_nightly_cargo(&[\"print\"])\n .env(\"RUSTFLAGS\", \"-C target-feature=+crt-static\")\n .with_stdout_data(\n str![[r#\"\ndebug_assertions\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"msvc\"\ntarget_family=\"windows\"\ntarget_feature=\"crt-static\"\ntarget_os=\"windows\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"pc\"\nwindows\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn rustc_with_print_cfg_config_toml() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\n \".cargo/config.toml\",\n r#\"\n[target.x86_64-pc-windows-msvc]\nrustflags = [\"-C\", \"target-feature=+crt-static\"]\n\"#,\n )\n .file(\"src/main.rs\", r#\"fn main() {} \"#)\n .build();\n\n p.cargo(\"rustc -Z unstable-options --target x86_64-pc-windows-msvc --print cfg\")\n .masquerade_as_nightly_cargo(&[\"print\"])\n .env(\"RUSTFLAGS\", \"-C target-feature=+crt-static\")\n .with_stdout_data(\n str![[r#\"\ndebug_assertions\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"msvc\"\ntarget_family=\"windows\"\ntarget_feature=\"crt-static\"\ntarget_os=\"windows\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"pc\"\nwindows\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test(nightly, reason = \"custom targets are unstable in rustc\")]\nfn rustc_with_print_cfg_config_toml_env() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"targets/best-target.json\", target_spec_json())\n .file(\n \".cargo/config.toml\",\n r#\"\n[build]\ntarget = \"best-target\"\n[env]\nRUST_TARGET_PATH = { value = \"./targets\", relative = true }\n\"#,\n )\n .file(\"src/main.rs\", r#\"fn main() {} \"#)\n .build();\n\n p.cargo(\"rustc -Z unstable-options --print cfg\")\n .masquerade_as_nightly_cargo(&[\"print\"])\n .with_stdout_data(str![\"...\"].unordered())\n .env(\"RUSTFLAGS\", \"-Z unstable-options\")\n .run();\n}\n\n#[cargo_test]\nfn precedence() {\n // Ensure that the precedence of cargo-rustc is only lower than RUSTFLAGS,\n // but higher than most flags set by cargo.\n //\n // See rust-lang/cargo#14346\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n edition = \"2021\"\n\n [lints.rust]\n unexpected_cfgs = \"allow\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"rustc --release -v -- --cfg cargo_rustc -C strip=symbols\")\n .env(\"RUSTFLAGS\", \"--cfg from_rustflags\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.0 ([ROOT]/foo)\n[RUNNING] `rustc [..]-C strip=debuginfo [..]--cfg cargo_rustc -C strip=symbols --cfg from_rustflags`\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_with_duplicate_crate_types() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustc -v --crate-type staticlib --crate-type staticlib\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..] --crate-type staticlib --emit[..]\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"rustc -v --crate-type staticlib --crate-type staticlib\")\n .with_stderr_data(str![[r#\"\n[FRESH] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/rustc_info_cache.rs", "content": "//! Tests for the cache file for the rustc version info.\n\nuse std::env;\n\nuse crate::prelude::*;\nuse cargo_test_support::basic_bin_manifest;\nuse cargo_test_support::{basic_manifest, project};\n\nconst MISS: &str = \"[..] rustc info cache miss[..]\";\nconst HIT: &str = \"[..]rustc info cache hit[..]\";\nconst UPDATE: &str = \"[..]updated rustc info cache[..]\";\n\n#[cargo_test]\nfn rustc_info_cache() {\n let p = project()\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .with_stderr_contains(\"[..]failed to read rustc info cache[..]\")\n .with_stderr_contains(MISS)\n .with_stderr_does_not_contain(HIT)\n .with_stderr_contains(UPDATE)\n .run();\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .with_stderr_contains(\"[..]reusing existing rustc info cache[..]\")\n .with_stderr_contains(HIT)\n .with_stderr_does_not_contain(MISS)\n .with_stderr_does_not_contain(UPDATE)\n .run();\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(\"CARGO_CACHE_RUSTC_INFO\", \"0\")\n .with_stderr_contains(\"[..]rustc info cache disabled[..]\")\n .with_stderr_does_not_contain(UPDATE)\n .run();\n\n let other_rustc = {\n let p = project()\n .at(\"compiler\")\n .file(\"Cargo.toml\", &basic_manifest(\"compiler\", \"0.1.0\"))\n .file(\n \"src/main.rs\",\n r#\"\n use std::process::Command;\n use std::env;\n\n fn main() {\n let mut cmd = Command::new(\"rustc\");\n for arg in env::args_os().skip(1) {\n cmd.arg(arg);\n }\n std::process::exit(cmd.status().unwrap().code().unwrap());\n }\n \"#,\n )\n .build();\n p.cargo(\"build\").run();\n\n p.root()\n .join(\"target/debug/compiler\")\n .with_extension(env::consts::EXE_EXTENSION)\n };\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(\"RUSTC\", other_rustc.display().to_string())\n .with_stderr_contains(\"[..]different compiler, creating new rustc info cache[..]\")\n .with_stderr_contains(MISS)\n .with_stderr_does_not_contain(HIT)\n .with_stderr_contains(UPDATE)\n .run();\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(\"RUSTC\", other_rustc.display().to_string())\n .with_stderr_contains(\"[..]reusing existing rustc info cache[..]\")\n .with_stderr_contains(HIT)\n .with_stderr_does_not_contain(MISS)\n .with_stderr_does_not_contain(UPDATE)\n .run();\n\n other_rustc.move_into_the_future();\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(\"RUSTC\", other_rustc.display().to_string())\n .with_stderr_contains(\"[..]different compiler, creating new rustc info cache[..]\")\n .with_stderr_contains(MISS)\n .with_stderr_does_not_contain(HIT)\n .with_stderr_contains(UPDATE)\n .run();\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(\"RUSTC\", other_rustc.display().to_string())\n .with_stderr_contains(\"[..]reusing existing rustc info cache[..]\")\n .with_stderr_contains(HIT)\n .with_stderr_does_not_contain(MISS)\n .with_stderr_does_not_contain(UPDATE)\n .run();\n}\n\n#[cargo_test]\nfn rustc_info_cache_with_wrappers() {\n let wrapper_project = project()\n .at(\"wrapper\")\n .file(\"Cargo.toml\", &basic_bin_manifest(\"wrapper\"))\n .file(\"src/main.rs\", r#\"fn main() { }\"#)\n .build();\n let wrapper = wrapper_project.bin(\"wrapper\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"test\"\n version = \"0.0.0\"\n authors = []\n [workspace]\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { println!(\"hello\"); }\"#)\n .build();\n\n for &wrapper_env in [\"RUSTC_WRAPPER\", \"RUSTC_WORKSPACE_WRAPPER\"].iter() {\n p.cargo(\"clean\").with_status(0).run();\n wrapper_project.change_file(\n \"src/main.rs\",\n r#\"\n fn main() {\n let mut args = std::env::args_os();\n let _me = args.next().unwrap();\n let rustc = args.next().unwrap();\n let status = std::process::Command::new(rustc).args(args).status().unwrap();\n std::process::exit(if status.success() { 0 } else { 1 })\n }\n \"#,\n );\n wrapper_project.cargo(\"build\").with_status(0).run();\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(wrapper_env, &wrapper)\n .with_stderr_contains(\"[..]failed to read rustc info cache[..]\")\n .with_stderr_contains(MISS)\n .with_stderr_contains(UPDATE)\n .with_stderr_does_not_contain(HIT)\n .with_status(0)\n .run();\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(wrapper_env, &wrapper)\n .with_stderr_contains(\"[..]reusing existing rustc info cache[..]\")\n .with_stderr_contains(HIT)\n .with_stderr_does_not_contain(UPDATE)\n .with_stderr_does_not_contain(MISS)\n .with_status(0)\n .run();\n\n wrapper_project.change_file(\"src/main.rs\", r#\"fn main() { panic!() }\"#);\n wrapper_project.cargo(\"build\").with_status(0).run();\n\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(wrapper_env, &wrapper)\n .with_stderr_contains(\"[..]different compiler, creating new rustc info cache[..]\")\n .with_stderr_contains(MISS)\n .with_stderr_contains(UPDATE)\n .with_stderr_does_not_contain(HIT)\n .with_status(101)\n .run();\n p.cargo(\"build\")\n .env(\"CARGO_LOG\", \"cargo::util::rustc=debug\")\n .env(wrapper_env, &wrapper)\n .with_stderr_contains(\"[..]reusing existing rustc info cache[..]\")\n .with_stderr_contains(HIT)\n .with_stderr_does_not_contain(UPDATE)\n .with_stderr_does_not_contain(MISS)\n .with_status(101)\n .run();\n }\n}\n" }, { "path": "tests/testsuite/rustdoc.rs", "content": "//! Tests for the `cargo rustdoc` command.\n\nuse crate::prelude::*;\nuse cargo_test_support::str;\nuse cargo_test_support::{basic_manifest, cross_compile, project};\n\nuse crate::utils::cross_compile::disabled as cross_compile_disabled;\n\n#[cargo_test]\nfn rustdoc_simple() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustdoc -v\")\n .with_stderr_data(str![[r#\"\n[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustdoc [..] --crate-name foo src/lib.rs -o [ROOT]/foo/target/doc [..] -L dependency=[ROOT]/foo/target/debug/deps [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_simple_html() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustdoc --output-format html --open -v\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] the `--output-format` flag is unstable, and only available on the nightly channel of Cargo, but this is the `stable` channel\nSee https://doc.rust-lang.org/book/[..].html for more information about Rust release channels.\nSee https://github.com/rust-lang/cargo/issues/12103 for more information about the `--output-format` flag.\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"--output-format is unstable\")]\nfn rustdoc_simple_json() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustdoc -Z unstable-options --output-format json -v\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-output-format\"])\n .with_stderr_data(str![[r#\"\n[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustdoc [..] --crate-name foo [..]-o [ROOT]/foo/target/doc [..] --output-format=json[..]\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo.json\n\n\"#]])\n .run();\n assert!(p.root().join(\"target/doc/foo.json\").is_file());\n}\n\n#[cargo_test]\nfn rustdoc_invalid_output_format() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustdoc -Z unstable-options --output-format pdf -v\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-output-format\"])\n .with_status(1)\n .with_stderr_data(str![[r#\"\n[ERROR] invalid value 'pdf' for '--output-format '\n [possible values: html, json]\n\nFor more information, try '--help'.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_json_stable() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustdoc -Z unstable-options --output-format json -v\")\n .with_status(101)\n .with_stderr_data(\n str![[r#\"\n[ERROR] the `-Z` flag is only accepted on the nightly channel of Cargo, but this is the `stable` channel\nSee https://doc.rust-lang.org/book/[..].html for more information about Rust release channels.\n\n\"#]]\n\t )\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_json_without_unstable_options() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustdoc --output-format json -v\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-output-format\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] the `--output-format` flag is unstable, pass `-Z unstable-options` to enable it\nSee https://github.com/rust-lang/cargo/issues/12103 for more information about the `--output-format` flag.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_args() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustdoc -v -- --cfg=foo\")\n .with_stderr_data(str![[r#\"\n[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustdoc [..] --crate-name foo src/lib.rs -o [ROOT]/foo/target/doc [..]-C metadata=[..] -L dependency=[ROOT]/foo/target/debug/deps [..]--cfg=foo[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_binary_args_passed() {\n let p = project().file(\"src/main.rs\", \"\").build();\n\n p.cargo(\"rustdoc -v\")\n .arg(\"--\")\n .arg(\"--markdown-no-toc\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..] --markdown-no-toc[..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_foo_with_bar_dependency() {\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\"src/lib.rs\", \"extern crate bar; pub fn foo() {}\")\n .build();\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\"src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n foo.cargo(\"rustdoc -v -- --cfg=foo\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[CHECKING] bar v0.0.1 ([ROOT]/bar)\n[RUNNING] `rustc [..] [ROOT]/bar/src/lib.rs [..]`\n[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustdoc [..] --crate-name foo src/lib.rs -o [ROOT]/foo/target/doc [..]-C metadata=[..] -L dependency=[ROOT]/foo/target/debug/deps --extern [..]--cfg=foo[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_only_bar_dependency() {\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\"src/main.rs\", \"extern crate bar; fn main() { bar::baz() }\")\n .build();\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\"src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n foo.cargo(\"rustdoc -v -p bar -- --cfg=foo\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[DOCUMENTING] bar v0.0.1 ([ROOT]/bar)\n[RUNNING] `rustdoc [..] --crate-name bar [ROOT]/bar/src/lib.rs -o [ROOT]/foo/target/doc [..]-C metadata=[..] -L dependency=[ROOT]/foo/target/debug/deps [..]--cfg=foo[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/bar/index.html\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_same_name_documents_lib() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", r#\" \"#)\n .build();\n\n p.cargo(\"rustdoc -v -- --cfg=foo\")\n .with_stderr_data(str![[r#\"\n[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustdoc [..] --crate-name foo src/lib.rs -o [ROOT]/foo/target/doc [..]-C metadata=[..] -L dependency=[ROOT]/foo/target/debug/deps [..]--cfg=foo[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [features]\n quux = []\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"rustdoc --verbose --features quux\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]feature=[..]quux[..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn proc_macro_crate_type() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n proc-macro = true\n\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"rustdoc --verbose\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc --edition=2015 --crate-type proc-macro [..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdoc_target() {\n if cross_compile_disabled() {\n return;\n }\n\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"rustdoc --verbose --target\")\n .arg(cross_compile::alternate())\n .with_stderr_data(str![[r#\"\n[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustdoc [..]--crate-name foo src/lib.rs [..]--target [ALT_TARGET] -o [ROOT]/foo/target/[ALT_TARGET]/doc [..] -L dependency=[ROOT]/foo/target/[ALT_TARGET]/debug/deps -L dependency=[ROOT]/foo/target/debug/deps[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/[..]/doc/foo/index.html\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fail_with_glob() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"pub fn bar() { break_the_build(); }\")\n .build();\n\n p.cargo(\"rustdoc -p '*z'\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] glob patterns on package selection are not supported.\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/rustdoc_extern_html.rs", "content": "//! Tests for the -Zrustdoc-map feature.\n\nuse crate::prelude::*;\nuse cargo_test_support::registry::{self, Package};\nuse cargo_test_support::{Project, paths, project, str};\n\nfn basic_project() -> Project {\n Package::new(\"bar\", \"1.0.0\")\n .file(\"src/lib.rs\", \"pub struct Straw;\")\n .publish();\n\n project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2018\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn myfun() -> Option {\n None\n }\n \"#,\n )\n .build()\n}\n\n#[cargo_test]\nfn ignores_on_stable() {\n // Requires -Zrustdoc-map to use.\n let p = basic_project();\n p.cargo(\"doc -v --no-deps\")\n .with_stderr_does_not_contain(\"[..]--extern-html-root-url[..]\")\n .run();\n}\n\n#[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn simple() {\n // Basic test that it works with crates.io.\n let p = basic_project();\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]--crate-name foo [..]--extern-html-root-url [..]bar=https://docs.rs/bar/1.0.0/[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n let myfun = p.read_file(\"target/doc/foo/fn.myfun.html\");\n assert!(myfun.contains(r#\"href=\"https://docs.rs/bar/1.0.0/bar/struct.Straw.html\"\"#));\n}\n\n#[ignore = \"Broken, temporarily disabled until https://github.com/rust-lang/rust/pull/82776 is resolved.\"]\n#[cargo_test]\n// #[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn std_docs() {\n // Mapping std docs somewhere else.\n // For local developers, skip this test if docs aren't installed.\n let docs = std::path::Path::new(&paths::sysroot()).join(\"share/doc/rust/html\");\n if !docs.exists() {\n if cargo_util::is_ci() {\n panic!(\"std docs are not installed, check that the rust-docs component is installed\");\n } else {\n eprintln!(\n \"documentation not found at {}, \\\n skipping test (run `rustdoc component add rust-docs` to install\",\n docs.display()\n );\n return;\n }\n }\n let p = basic_project();\n p.change_file(\n \".cargo/config.toml\",\n r#\"\n [doc.extern-map]\n std = \"local\"\n \"#,\n );\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_contains(\"[RUNNING] `rustdoc [..]--crate-name foo [..]std=file://[..]\")\n .run();\n let myfun = p.read_file(\"target/doc/foo/fn.myfun.html\");\n assert!(myfun.contains(r#\"share/doc/rust/html/core/option/enum.Option.html\"\"#));\n\n p.change_file(\n \".cargo/config.toml\",\n r#\"\n [doc.extern-map]\n std = \"https://example.com/rust/\"\n \"#,\n );\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_contains(\n \"[RUNNING] `rustdoc [..]--crate-name foo [..]std=https://example.com/rust/[..]\",\n )\n .run();\n let myfun = p.read_file(\"target/doc/foo/fn.myfun.html\");\n assert!(myfun.contains(r#\"href=\"https://example.com/rust/core/option/enum.Option.html\"\"#));\n}\n\n#[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn renamed_dep() {\n // Handles renamed dependencies.\n Package::new(\"bar\", \"1.0.0\")\n .file(\"src/lib.rs\", \"pub struct Straw;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2018\"\n\n [dependencies]\n groovy = { version = \"1.0\", package = \"bar\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn myfun() -> Option {\n None\n }\n \"#,\n )\n .build();\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]--crate-name foo [..]--extern-html-root-url [..]bar=https://docs.rs/bar/1.0.0/[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n let myfun = p.read_file(\"target/doc/foo/fn.myfun.html\");\n assert!(myfun.contains(r#\"href=\"https://docs.rs/bar/1.0.0/bar/struct.Straw.html\"\"#));\n}\n\n#[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn lib_name() {\n // Handles lib name != package name.\n Package::new(\"bar\", \"1.0.0\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"1.0.0\"\n\n [lib]\n name = \"rumpelstiltskin\"\n \"#,\n )\n .file(\"src/lib.rs\", \"pub struct Straw;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn myfun() -> Option {\n None\n }\n \"#,\n )\n .build();\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]--crate-name foo [..]--extern-html-root-url [..]rumpelstiltskin=https://docs.rs/bar/1.0.0/[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n let myfun = p.read_file(\"target/doc/foo/fn.myfun.html\");\n assert!(\n myfun.contains(r#\"href=\"https://docs.rs/bar/1.0.0/rumpelstiltskin/struct.Straw.html\"\"#)\n );\n}\n\n#[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn alt_registry() {\n // Supports other registry names.\n registry::alt_init();\n Package::new(\"bar\", \"1.0.0\")\n .alternative(true)\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate baz;\n pub struct Queen;\n pub use baz::King;\n \"#,\n )\n .registry_dep(\"baz\", \"1.0\")\n .publish();\n Package::new(\"baz\", \"1.0.0\")\n .alternative(true)\n .file(\"src/lib.rs\", \"pub struct King;\")\n .publish();\n Package::new(\"grimm\", \"1.0.0\")\n .file(\"src/lib.rs\", \"pub struct Gold;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2018\"\n\n [dependencies]\n bar = { version = \"1.0\", registry=\"alternative\" }\n grimm = \"1.0\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn queen() -> bar::Queen { bar::Queen }\n pub fn king() -> bar::King { bar::King }\n pub fn gold() -> grimm::Gold { grimm::Gold }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n r#\"\n [doc.extern-map.registries]\n alternative = \"https://example.com/{pkg_name}/{version}/\"\n crates-io = \"https://docs.rs/\"\n \"#,\n )\n .build();\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]--crate-name foo [..]--extern-html-root-url [..]bar=https://example.com/bar/1.0.0/[..] --extern-html-root-url [..]baz=https://example.com/baz/1.0.0/[..] --extern-html-root-url [..]grimm=https://docs.rs/grimm/1.0.0/[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n let queen = p.read_file(\"target/doc/foo/fn.queen.html\");\n assert!(queen.contains(r#\"href=\"https://example.com/bar/1.0.0/bar/struct.Queen.html\"\"#));\n\n let king = p.read_file(\"target/doc/foo/fn.king.html\");\n assert!(king.contains(r#\"href=\"https://example.com/baz/1.0.0/baz/struct.King.html\"\"#));\n\n let gold = p.read_file(\"target/doc/foo/fn.gold.html\");\n assert!(gold.contains(r#\"href=\"https://docs.rs/grimm/1.0.0/grimm/struct.Gold.html\"\"#));\n}\n\n#[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn multiple_versions() {\n // What happens when there are multiple versions.\n // NOTE: This is currently broken behavior. Rustdoc does not provide a way\n // to match renamed dependencies.\n Package::new(\"bar\", \"1.0.0\")\n .file(\"src/lib.rs\", \"pub struct Spin;\")\n .publish();\n Package::new(\"bar\", \"2.0.0\")\n .file(\"src/lib.rs\", \"pub struct Straw;\")\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2018\"\n\n [dependencies]\n bar = \"1.0\"\n bar2 = {version=\"2.0\", package=\"bar\"}\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n pub fn fn1() -> bar::Spin {bar::Spin}\n pub fn fn2() -> bar2::Straw {bar2::Straw}\n \",\n )\n .build();\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]--crate-name foo [..]--extern-html-root-url [..]bar=https://docs.rs/bar/1.0.0/[..] --extern-html-root-url [..]bar=https://docs.rs/bar/2.0.0/[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n let fn1 = p.read_file(\"target/doc/foo/fn.fn1.html\");\n // This should be 1.0.0, rustdoc seems to use the last entry when there\n // are duplicates.\n assert!(fn1.contains(r#\"href=\"https://docs.rs/bar/2.0.0/bar/struct.Spin.html\"\"#));\n let fn2 = p.read_file(\"target/doc/foo/fn.fn2.html\");\n assert!(fn2.contains(r#\"href=\"https://docs.rs/bar/2.0.0/bar/struct.Straw.html\"\"#));\n}\n\n#[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn rebuilds_when_changing() {\n // Make sure it rebuilds if the map changes.\n let p = basic_project();\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]--extern-html-root-url[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n\n // This also tests that the map for docs.rs can be overridden.\n p.change_file(\n \".cargo/config.toml\",\n r#\"\n [doc.extern-map.registries]\n crates-io = \"https://example.com/\"\n \"#,\n );\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]--extern-html-root-url [..]bar=https://example.com/bar/1.0.0/[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn alt_sparse_registry() {\n // Supports other registry names.\n\n registry::init();\n let _registry = registry::RegistryBuilder::new()\n .http_index()\n .alternative()\n .build();\n\n Package::new(\"bar\", \"1.0.0\")\n .alternative(true)\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate baz;\n pub struct Queen;\n pub use baz::King;\n \"#,\n )\n .registry_dep(\"baz\", \"1.0\")\n .publish();\n Package::new(\"baz\", \"1.0.0\")\n .alternative(true)\n .file(\"src/lib.rs\", \"pub struct King;\")\n .publish();\n Package::new(\"grimm\", \"1.0.0\")\n .file(\"src/lib.rs\", \"pub struct Gold;\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2018\"\n\n [dependencies]\n bar = { version = \"1.0\", registry=\"alternative\" }\n grimm = \"1.0\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn queen() -> bar::Queen { bar::Queen }\n pub fn king() -> bar::King { bar::King }\n pub fn gold() -> grimm::Gold { grimm::Gold }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n r#\"\n [doc.extern-map.registries]\n alternative = \"https://example.com/{pkg_name}/{version}/\"\n crates-io = \"https://docs.rs/\"\n \"#,\n )\n .build();\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..]--crate-name foo [..]--extern-html-root-url [..]bar=https://example.com/bar/1.0.0/[..] --extern-html-root-url [..]baz=https://example.com/baz/1.0.0/[..] --extern-html-root-url [..]grimm=https://docs.rs/grimm/1.0.0/[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n let queen = p.read_file(\"target/doc/foo/fn.queen.html\");\n assert!(queen.contains(r#\"href=\"https://example.com/bar/1.0.0/bar/struct.Queen.html\"\"#));\n\n let king = p.read_file(\"target/doc/foo/fn.king.html\");\n assert!(king.contains(r#\"href=\"https://example.com/baz/1.0.0/baz/struct.King.html\"\"#));\n\n let gold = p.read_file(\"target/doc/foo/fn.gold.html\");\n assert!(gold.contains(r#\"href=\"https://docs.rs/grimm/1.0.0/grimm/struct.Gold.html\"\"#));\n}\n\n#[cargo_test(nightly, reason = \"--extern-html-root-url is unstable\")]\nfn same_deps_multi_occurrence_in_dep_tree() {\n // rust-lang/cargo#13543\n Package::new(\"baz\", \"1.0.0\")\n .file(\"src/lib.rs\", \"\")\n .publish();\n Package::new(\"bar\", \"1.0.0\")\n .file(\"src/lib.rs\", \"\")\n .dep(\"baz\", \"1.0\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n edition = \"2018\"\n\n [dependencies]\n bar = \"1.0\"\n baz = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [doc.extern-map.registries]\n crates-io = \"https://docs.rs/\"\n \"#,\n )\n .build();\n p.cargo(\"doc -v --no-deps -Zrustdoc-map\")\n .masquerade_as_nightly_cargo(&[\"rustdoc-map\"])\n .with_stderr_does_not_contain(\n \"[..]--extern-html-root-url[..]bar=https://docs.rs\\\n [..]--extern-html-root-url[..]baz=https://docs.rs\\\n [..]--extern-html-root-url[..]baz=https://docs.rs[..]\",\n )\n .with_stderr_contains(\n \"[..]--extern-html-root-url[..]bar=https://docs.rs\\\n [..]--extern-html-root-url[..]baz=https://docs.rs[..]\",\n )\n .run();\n}\n" }, { "path": "tests/testsuite/rustdocflags.rs", "content": "//! Tests for setting custom rustdoc flags.\n\nuse crate::prelude::*;\nuse cargo_test_support::project;\nuse cargo_test_support::rustc_host;\nuse cargo_test_support::rustc_host_env;\nuse cargo_test_support::str;\n\n#[cargo_test]\nfn parses_env() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"doc -v\")\n .env(\"RUSTDOCFLAGS\", \"--cfg=foo\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..] --cfg=foo[..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn parses_config() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustdocflags = [\"--cfg\", \"foo\"]\n \"#,\n )\n .build();\n\n p.cargo(\"doc -v\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..] --cfg foo [..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bad_flags() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"doc\")\n .env(\"RUSTDOCFLAGS\", \"--bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\n[ERROR] Unrecognized option: 'bogus'\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rerun() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"doc\").env(\"RUSTDOCFLAGS\", \"--cfg=foo\").run();\n p.cargo(\"doc\")\n .env(\"RUSTDOCFLAGS\", \"--cfg=foo\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n p.cargo(\"doc\")\n .env(\"RUSTDOCFLAGS\", \"--cfg=bar\")\n .with_stderr_data(str![[r#\"\n[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[GENERATED] [ROOT]/foo/target/doc/foo/index.html\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustdocflags_passed_to_rustdoc_through_cargo_test() {\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n //! ```\n //! assert!(cfg!(do_not_choke));\n //! ```\n \"#,\n )\n .build();\n\n p.cargo(\"test --doc\")\n .env(\"RUSTDOCFLAGS\", \"--cfg do_not_choke\")\n .run();\n}\n\n#[cargo_test]\nfn rustdocflags_passed_to_rustdoc_through_cargo_test_only_once() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"test --doc\")\n .env(\"RUSTDOCFLAGS\", \"--markdown-no-toc\")\n .run();\n}\n\n#[cargo_test]\nfn rustdocflags_misspelled() {\n let p = project().file(\"src/main.rs\", \"fn main() { }\").build();\n\n p.cargo(\"doc\")\n .env(\"RUSTDOC_FLAGS\", \"foo\")\n .with_stderr_data(str![[r#\"\n[WARNING] ignoring environment variable `RUSTDOC_FLAGS`\n |\n = [HELP] rustdoc flags are passed via `RUSTDOCFLAGS`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn whitespace() {\n // Checks behavior of different whitespace characters.\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n // \"too many operands\"\n p.cargo(\"doc\")\n .env(\"RUSTDOCFLAGS\", \"--crate-version this has spaces\")\n .with_stderr_data(str![[r#\"\n...\n[ERROR] could not document `foo`\n...\n\"#]])\n .with_status(101)\n .run();\n\n p.cargo(\"doc\")\n .env_remove(\"__CARGO_TEST_FORCE_ARGFILE\") // Not applicable for argfile.\n .env(\n \"RUSTDOCFLAGS\",\n \"--crate-version 1111\\n2222\\t3333\\u{00a0}4444\",\n )\n .run();\n\n let contents = p.read_file(\"target/doc/foo/index.html\");\n assert!(contents.contains(\"1111\"));\n assert!(contents.contains(\"2222\"));\n assert!(contents.contains(\"3333\"));\n assert!(contents.contains(\"4444\"));\n}\n\n#[cargo_test]\nfn not_affected_by_target_rustflags() {\n let cfg = if cfg!(windows) { \"windows\" } else { \"unix\" };\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.'cfg({cfg})']\n rustflags = [\"-D\", \"missing-docs\"]\n\n [build]\n rustdocflags = [\"--cfg\", \"foo\"]\n \"#,\n ),\n )\n .build();\n\n // `cargo build` should fail due to missing docs.\n p.cargo(\"build -v\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustc [..] -D missing-docs`\n...\n\"#]])\n .run();\n\n // `cargo doc` shouldn't fail.\n p.cargo(\"doc -v\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..] --cfg foo[..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn target_triple_rustdocflags_works() {\n let host = rustc_host();\n let host_env = rustc_host_env();\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n // target.triple.rustdocflags in env works\n p.cargo(\"doc -v\")\n .env(\n &format!(\"CARGO_TARGET_{host_env}_RUSTDOCFLAGS\"),\n \"--cfg=foo\",\n )\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc[..]--cfg[..]foo[..]`\n...\n\"#]])\n .run();\n\n // target.triple.rustdocflags in config works\n p.cargo(\"doc -v\")\n .arg(\"--config\")\n .arg(format!(\"target.{host}.rustdocflags=['--cfg', 'foo']\"))\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc [..] --cfg foo [..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn target_triple_rustdocflags_works_through_cargo_test() {\n let host = rustc_host();\n let host_env = rustc_host_env();\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n //! ```\n //! assert!(cfg!(foo));\n //! ```\n \"#,\n )\n .build();\n\n // target.triple.rustdocflags in env works\n p.cargo(\"test --doc -v\")\n .env(\n &format!(\"CARGO_TARGET_{host_env}_RUSTDOCFLAGS\"),\n \"--cfg=foo\",\n )\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc[..]--test[..]--cfg[..]foo[..]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest src/lib.rs - (line 2) ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n // target.triple.rustdocflags in config works\n p.cargo(\"test --doc -v\")\n .arg(\"--config\")\n .arg(format!(\"target.{host}.rustdocflags=['--cfg', 'foo']\"))\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `rustdoc[..]--test[..]--cfg[..]foo[..]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest src/lib.rs - (line 2) ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/rustflags.rs", "content": "//! Tests for setting custom rustc flags.\n\nuse std::fs;\n\nuse crate::prelude::*;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::{\n RawOutput, basic_manifest, paths, project, project_in_home, rustc_host, str,\n};\nuse snapbox::assert_data_eq;\n\n#[cargo_test]\nfn env_rustflags_normal_source() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"tests/c.rs\", \"#[test] fn f() { }\")\n .file(\n \"benches/d.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n #[bench] fn run1(_ben: &mut test::Bencher) { }\n \"#,\n )\n .build();\n\n // Use RUSTFLAGS to pass an argument that will generate an error\n p.cargo(\"check --lib\")\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --bin=a\")\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --example=b\")\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"test\")\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"bench\")\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn env_rustflags_build_script() {\n // RUSTFLAGS should be passed to rustc for build scripts\n // when --target is not specified.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() { assert!(cfg!(foo)); }\n \"#,\n )\n .build();\n\n p.cargo(\"check\").env(\"RUSTFLAGS\", \"--cfg foo\").run();\n}\n\n#[cargo_test]\nfn env_rustflags_build_script_dep() {\n // RUSTFLAGS should be passed to rustc for build scripts\n // when --target is not specified.\n // In this test if --cfg foo is not passed the build will fail.\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n\n [build-dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() {}\")\n .build();\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\n \"src/lib.rs\",\n r#\"\n fn bar() { }\n #[cfg(not(foo))]\n fn bar() { }\n \"#,\n )\n .build();\n\n foo.cargo(\"check\").env(\"RUSTFLAGS\", \"--cfg foo\").run();\n}\n\n#[cargo_test]\nfn env_rustflags_normal_source_with_target() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"tests/c.rs\", \"#[test] fn f() { }\")\n .file(\n \"benches/d.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n #[bench] fn run1(_ben: &mut test::Bencher) { }\n \"#,\n )\n .build();\n\n let host = &rustc_host();\n\n // Use RUSTFLAGS to pass an argument that will generate an error\n p.cargo(\"check --lib --target\")\n .arg(host)\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --bin=a --target\")\n .arg(host)\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --example=b --target\")\n .arg(host)\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"test --target\")\n .arg(host)\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"bench --target\")\n .arg(host)\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn env_rustflags_build_script_with_target() {\n // RUSTFLAGS should not be passed to rustc for build scripts\n // when --target is specified.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() { assert!(!cfg!(foo)); }\n \"#,\n )\n .build();\n\n let host = rustc_host();\n p.cargo(\"check --target\")\n .arg(host)\n .env(\"RUSTFLAGS\", \"--cfg foo\")\n .run();\n}\n\n#[cargo_test]\nfn env_rustflags_build_script_with_target_doesnt_apply_to_host_kind() {\n // RUSTFLAGS should *not* be passed to rustc for build scripts when --target is specified as the\n // host triple even if target-applies-to-host-kind is enabled, to match legacy Cargo behavior.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() { assert!(!cfg!(foo)); }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n r#\"\n target-applies-to-host = true\n \"#,\n )\n .build();\n\n let host = rustc_host();\n p.cargo(\"check --target\")\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(host)\n .arg(\"-Ztarget-applies-to-host\")\n .env(\"RUSTFLAGS\", \"--cfg foo\")\n .run();\n}\n\n#[cargo_test]\nfn env_rustflags_build_script_dep_with_target() {\n // RUSTFLAGS should not be passed to rustc for build scripts\n // when --target is specified.\n // In this test if --cfg foo is passed the build will fail.\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n\n [build-dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() {}\")\n .build();\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\n \"src/lib.rs\",\n r#\"\n fn bar() { }\n #[cfg(foo)]\n fn bar() { }\n \"#,\n )\n .build();\n\n let host = rustc_host();\n foo.cargo(\"check --target\")\n .arg(host)\n .env(\"RUSTFLAGS\", \"--cfg foo\")\n .run();\n}\n\n#[cargo_test]\nfn env_rustflags_recompile() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"check\").run();\n // Setting RUSTFLAGS forces a recompile\n p.cargo(\"check\")\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn env_rustflags_recompile2() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"check\").env(\"RUSTFLAGS\", \"--cfg foo\").run();\n // Setting RUSTFLAGS forces a recompile\n p.cargo(\"check\")\n .env(\"RUSTFLAGS\", \"-Z bogus\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn env_rustflags_no_recompile() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"check\").env(\"RUSTFLAGS\", \"--cfg foo\").run();\n p.cargo(\"check\")\n .env(\"RUSTFLAGS\", \"--cfg foo\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_rustflags_normal_source() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"tests/c.rs\", \"#[test] fn f() { }\")\n .file(\n \"benches/d.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n #[bench] fn run1(_ben: &mut test::Bencher) { }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = [\"-Z\", \"bogus\"]\n \"#,\n )\n .build();\n\n p.cargo(\"check --lib\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --bin=a\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --example=b\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"test\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"bench\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_rustflags_build_script() {\n // RUSTFLAGS should be passed to rustc for build scripts\n // when --target is not specified.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() { assert!(cfg!(foo)); }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = [\"--cfg\", \"foo\"]\n \"#,\n )\n .build();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn build_rustflags_build_script_dep() {\n // RUSTFLAGS should be passed to rustc for build scripts\n // when --target is not specified.\n // In this test if --cfg foo is not passed the build will fail.\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n\n [build-dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = [\"--cfg\", \"foo\"]\n \"#,\n )\n .build();\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\n \"src/lib.rs\",\n r#\"\n fn bar() { }\n #[cfg(not(foo))]\n fn bar() { }\n \"#,\n )\n .build();\n\n foo.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn build_rustflags_normal_source_with_target() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"tests/c.rs\", \"#[test] fn f() { }\")\n .file(\n \"benches/d.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n #[bench] fn run1(_ben: &mut test::Bencher) { }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = [\"-Z\", \"bogus\"]\n \"#,\n )\n .build();\n\n let host = &rustc_host();\n\n // Use build.rustflags to pass an argument that will generate an error\n p.cargo(\"check --lib --target\")\n .arg(host)\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --bin=a --target\")\n .arg(host)\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --example=b --target\")\n .arg(host)\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"test --target\")\n .arg(host)\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"bench --target\")\n .arg(host)\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_rustflags_build_script_with_target() {\n // RUSTFLAGS should not be passed to rustc for build scripts\n // when --target is specified.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() { assert!(!cfg!(foo)); }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = [\"--cfg\", \"foo\"]\n \"#,\n )\n .build();\n\n let host = rustc_host();\n p.cargo(\"check --target\").arg(host).run();\n}\n\n#[cargo_test]\nfn build_rustflags_build_script_dep_with_target() {\n // RUSTFLAGS should not be passed to rustc for build scripts\n // when --target is specified.\n // In this test if --cfg foo is passed the build will fail.\n let foo = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n\n [build-dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = [\"--cfg\", \"foo\"]\n \"#,\n )\n .build();\n let _bar = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\n \"src/lib.rs\",\n r#\"\n fn bar() { }\n #[cfg(foo)]\n fn bar() { }\n \"#,\n )\n .build();\n\n let host = rustc_host();\n foo.cargo(\"check --target\").arg(host).run();\n}\n\n#[cargo_test]\nfn build_rustflags_recompile() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"check\").run();\n\n // Setting RUSTFLAGS forces a recompile\n let config = r#\"\n [build]\n rustflags = [\"-Z\", \"bogus\"]\n \"#;\n let config_file = paths::root().join(\"foo/.cargo/config.toml\");\n fs::create_dir_all(config_file.parent().unwrap()).unwrap();\n fs::write(config_file, config).unwrap();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_rustflags_recompile2() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"check\").env(\"RUSTFLAGS\", \"--cfg foo\").run();\n\n // Setting RUSTFLAGS forces a recompile\n let config = r#\"\n [build]\n rustflags = [\"-Z\", \"bogus\"]\n \"#;\n let config_file = paths::root().join(\"foo/.cargo/config.toml\");\n fs::create_dir_all(config_file.parent().unwrap()).unwrap();\n fs::write(config_file, config).unwrap();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_rustflags_no_recompile() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = [\"--cfg\", \"foo\"]\n \"#,\n )\n .build();\n\n p.cargo(\"check\").env(\"RUSTFLAGS\", \"--cfg foo\").run();\n p.cargo(\"check\")\n .env(\"RUSTFLAGS\", \"--cfg foo\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn build_rustflags_with_home_config() {\n // We need a config file inside the home directory\n let home = paths::home();\n let home_config = home.join(\".cargo\");\n fs::create_dir(&home_config).unwrap();\n fs::write(\n &home_config.join(\"config\"),\n r#\"\n [build]\n rustflags = [\"-Cllvm-args=-x86-asm-syntax=intel\"]\n \"#,\n )\n .unwrap();\n\n // And we need the project to be inside the home directory\n // so the walking process finds the home project twice.\n let p = project_in_home(\"foo\").file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"check -v\").run();\n}\n\n#[cargo_test]\nfn target_rustflags_normal_source() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"tests/c.rs\", \"#[test] fn f() { }\")\n .file(\n \"benches/d.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n #[bench] fn run1(_ben: &mut test::Bencher) { }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n &format!(\n \"\n [target.{}]\n rustflags = [\\\"-Z\\\", \\\"bogus\\\"]\n \",\n rustc_host()\n ),\n )\n .build();\n\n p.cargo(\"check --lib\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --bin=a\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --example=b\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"test\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"bench\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn target_rustflags_also_for_build_scripts() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() { assert!(cfg!(foo)); }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n &format!(\n \"\n [target.{}]\n rustflags = [\\\"--cfg=foo\\\"]\n \",\n rustc_host()\n ),\n )\n .build();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn target_rustflags_not_for_build_scripts_with_target() {\n let host = rustc_host();\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() { assert!(!cfg!(foo)); }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n &format!(\n \"\n [target.{}]\n rustflags = [\\\"--cfg=foo\\\"]\n \",\n host\n ),\n )\n .build();\n\n p.cargo(\"check --target\").arg(host).run();\n\n // Enabling -Ztarget-applies-to-host should not make a difference without the config setting\n p.cargo(\"check --target\")\n .arg(host)\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .run();\n\n // Even with the setting, the rustflags from `target.` should not apply, to match the legacy\n // Cargo behavior.\n p.change_file(\n \".cargo/config.toml\",\n &format!(\n \"\n target-applies-to-host = true\n\n [target.{}]\n rustflags = [\\\"--cfg=foo\\\"]\n \",\n host\n ),\n );\n p.cargo(\"check --target\")\n .arg(host)\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .run();\n}\n\n#[cargo_test]\nfn build_rustflags_for_build_scripts() {\n let host = rustc_host();\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() { assert!(cfg!(foo), \"CFG FOO!\"); }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n \"\n [build]\n rustflags = [\\\"--cfg=foo\\\"]\n \",\n )\n .build();\n\n // With \"legacy\" behavior, build.rustflags should apply to build scripts without --target\n p.cargo(\"check\").run();\n\n // But should _not_ apply _with_ --target\n p.cargo(\"check --target\")\n .arg(host)\n .with_status(101)\n .with_stderr_data(\"...\\n[..]CFG FOO![..]\\n...\")\n .run();\n\n // Enabling -Ztarget-applies-to-host should not make a difference without the config setting\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .run();\n p.cargo(\"check --target\")\n .arg(host)\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .with_status(101)\n .with_stderr_data(\"...\\n[..]CFG FOO![..]\\n...\")\n .run();\n\n // When set to false though, the \"proper\" behavior where host artifacts _only_ pick up on\n // [host] should be applied.\n p.change_file(\n \".cargo/config.toml\",\n \"\n target-applies-to-host = false\n\n [build]\n rustflags = [\\\"--cfg=foo\\\"]\n \",\n );\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .with_status(101)\n .with_stderr_data(\"...\\n[..]CFG FOO![..]\\n...\")\n .run();\n p.cargo(\"check --target\")\n .arg(host)\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .with_status(101)\n .with_stderr_data(\"...\\n[..]CFG FOO![..]\\n...\")\n .run();\n}\n\n#[cargo_test]\nfn host_rustflags_for_build_scripts() {\n let host = rustc_host();\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n // Ensure that --cfg=foo is passed.\n fn main() { assert!(cfg!(foo)); }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n &format!(\n \"\n target-applies-to-host = false\n\n [host.{}]\n rustflags = [\\\"--cfg=foo\\\"]\n \",\n host\n ),\n )\n .build();\n\n p.cargo(\"check --target\")\n .arg(host)\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\", \"host-config\"])\n .arg(\"-Ztarget-applies-to-host\")\n .arg(\"-Zhost-config\")\n .run();\n}\n\n// target.{}.rustflags takes precedence over build.rustflags\n#[cargo_test]\nfn target_rustflags_precedence() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/a.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"tests/c.rs\", \"#[test] fn f() { }\")\n .file(\n \".cargo/config.toml\",\n &format!(\n \"\n [build]\n rustflags = [\\\"--cfg\\\", \\\"foo\\\"]\n\n [target.{}]\n rustflags = [\\\"-Z\\\", \\\"bogus\\\"]\n \",\n rustc_host()\n ),\n )\n .build();\n\n p.cargo(\"check --lib\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --bin=a\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"check --example=b\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"test\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n p.cargo(\"bench\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to run `rustc` to learn about target-specific information\n\nCaused by:\n [..]bogus[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cfg_rustflags_normal_source() {\n let p = project()\n .file(\"src/lib.rs\", \"pub fn t() {}\")\n .file(\"src/bin/a.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"tests/c.rs\", \"#[test] fn f() { }\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.'cfg({})']\n rustflags = [\"--cfg\", \"bar\"]\n \"#,\n if rustc_host().contains(\"-windows-\") {\n \"windows\"\n } else {\n \"not(windows)\"\n }\n ),\n )\n .build();\n\n p.cargo(\"build --lib -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] --cfg bar`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"build --bin=a -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name a [..] --cfg bar`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"build --example=b -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name b [..] --cfg bar`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"test --no-run -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..] --cfg bar`\n[RUNNING] `rustc [..] --cfg bar`\n[RUNNING] `rustc [..] --cfg bar`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/a-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/c-[HASH][EXE]`\n\n\"#]])\n .run();\n\n p.cargo(\"bench --no-run -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..] --cfg bar`\n[RUNNING] `rustc [..] --cfg bar`\n[RUNNING] `rustc [..] --cfg bar`\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[EXECUTABLE] `[ROOT]/foo/target/release/deps/foo-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/release/deps/a-[HASH][EXE]`\n\n\"#]])\n .run();\n}\n\n// target.'cfg(...)'.rustflags takes precedence over build.rustflags\n#[cargo_test]\nfn cfg_rustflags_precedence() {\n let p = project()\n .file(\"src/lib.rs\", \"pub fn t() {}\")\n .file(\"src/bin/a.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"tests/c.rs\", \"#[test] fn f() { }\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [build]\n rustflags = [\"--cfg\", \"foo\"]\n\n [target.'cfg({})']\n rustflags = [\"--cfg\", \"bar\"]\n \"#,\n if rustc_host().contains(\"-windows-\") {\n \"windows\"\n } else {\n \"not(windows)\"\n }\n ),\n )\n .build();\n\n p.cargo(\"build --lib -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] --cfg bar`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"build --bin=a -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name a [..] --cfg bar`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"build --example=b -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name b [..] --cfg bar`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"test --no-run -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..] --cfg bar`\n[RUNNING] `rustc [..] --cfg bar`\n[RUNNING] `rustc [..] --cfg bar`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/a-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/c-[HASH][EXE]`\n\n\"#]])\n .run();\n\n p.cargo(\"bench --no-run -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..] --cfg bar`\n[RUNNING] `rustc [..] --cfg bar`\n[RUNNING] `rustc [..] --cfg bar`\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[EXECUTABLE] `[ROOT]/foo/target/release/deps/foo-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/release/deps/a-[HASH][EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn target_rustflags_string_and_array_form1() {\n let p1 = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = [\"--cfg\", \"foo\"]\n \"#,\n )\n .build();\n\n p1.cargo(\"check -v\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] --cfg foo`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n let p2 = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n rustflags = \"--cfg foo\"\n \"#,\n )\n .build();\n\n p2.cargo(\"check -v\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] --cfg foo`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn target_rustflags_string_and_array_form2() {\n let p1 = project()\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.{}]\n rustflags = [\"--cfg\", \"foo\"]\n \"#,\n rustc_host()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p1.cargo(\"check -v\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] --cfg foo`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n let p2 = project()\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.{}]\n rustflags = \"--cfg foo\"\n \"#,\n rustc_host()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p2.cargo(\"check -v\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo [..] --cfg foo`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn two_matching_in_config() {\n let p1 = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [target.'cfg(unix)']\n rustflags = [\"--cfg\", 'foo=\"a\"']\n [target.'cfg(windows)']\n rustflags = [\"--cfg\", 'foo=\"a\"']\n [target.'cfg(target_pointer_width = \"32\")']\n rustflags = [\"--cfg\", 'foo=\"b\"']\n [target.'cfg(target_pointer_width = \"64\")']\n rustflags = [\"--cfg\", 'foo=\"b\"']\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n #![allow(unexpected_cfgs)]\n fn main() {\n if cfg!(foo = \"a\") {\n println!(\"a\");\n } else if cfg!(foo = \"b\") {\n println!(\"b\");\n } else {\n panic!()\n }\n }\n \"#,\n )\n .build();\n\n p1.cargo(\"run\").run();\n p1.cargo(\"build\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn env_rustflags_misspelled() {\n let p = project().file(\"src/main.rs\", \"fn main() { }\").build();\n\n for cmd in &[\"check\", \"build\", \"run\", \"test\", \"bench\"] {\n p.cargo(cmd)\n .env(\"RUST_FLAGS\", \"foo\")\n .with_stderr_data(str![[r#\"\n[WARNING] ignoring environment variable `RUST_FLAGS`\n |\n = [HELP] rust flags are passed via `RUSTFLAGS`\n...\n\"#]])\n .run();\n }\n}\n\n#[cargo_test]\nfn env_rustflags_misspelled_build_script() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n build = \"build.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() { }\")\n .build();\n\n p.cargo(\"check\")\n .env(\"RUST_FLAGS\", \"foo\")\n .with_stderr_data(str![[r#\"\n[WARNING] ignoring environment variable `RUST_FLAGS`\n |\n = [HELP] rust flags are passed via `RUSTFLAGS`\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn remap_path_prefix_works() {\n // Check that remap-path-prefix works.\n Package::new(\"bar\", \"0.1.0\")\n .file(\"src/lib.rs\", \"pub fn f() -> &'static str { file!() }\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bar = \"0.1\"\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n println!(\"{}\", bar::f());\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run\")\n .env(\n \"RUSTFLAGS\",\n format!(\"--remap-path-prefix={}=/foo\", paths::root().display()),\n )\n .with_stdout_data(str![[r#\"\n/foo/home/.cargo/registry/src/-[HASH]/bar-0.1.0/src/lib.rs\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn rustflags_remap_path_prefix_ignored_for_c_metadata() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n let build_output = p\n .cargo(\"build -v\")\n .env(\n \"RUSTFLAGS\",\n \"--remap-path-prefix=/abc=/zoo --remap-path-prefix /spaced=/zoo\",\n )\n .run();\n let first_c_metadata = dbg!(get_c_metadata(build_output));\n\n p.cargo(\"clean\").run();\n\n let build_output = p\n .cargo(\"build -v\")\n .env(\n \"RUSTFLAGS\",\n \"--remap-path-prefix=/def=/zoo --remap-path-prefix /earth=/zoo\",\n )\n .run();\n let second_c_metadata = dbg!(get_c_metadata(build_output));\n\n assert_data_eq!(first_c_metadata, second_c_metadata);\n}\n\n#[cargo_test]\nfn rustc_remap_path_prefix_ignored_for_c_metadata() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n let build_output = p\n .cargo(\"rustc -v -- --remap-path-prefix=/abc=/zoo --remap-path-prefix /spaced=/zoo\")\n .run();\n let first_c_metadata = dbg!(get_c_metadata(build_output));\n\n p.cargo(\"clean\").run();\n\n let build_output = p\n .cargo(\"rustc -v -- --remap-path-prefix=/def=/zoo --remap-path-prefix /earth=/zoo\")\n .run();\n let second_c_metadata = dbg!(get_c_metadata(build_output));\n\n assert_data_eq!(first_c_metadata, second_c_metadata);\n}\n\n// `--remap-path-prefix` is meant to take two different binaries and make them the same but the\n// rlib name, including `-Cextra-filename`, can still end up in the binary so it can't change\n#[cargo_test]\nfn rustflags_remap_path_prefix_ignored_for_c_extra_filename() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n let build_output = p\n .cargo(\"build -v\")\n .env(\n \"RUSTFLAGS\",\n \"--remap-path-prefix=/abc=/zoo --remap-path-prefix /spaced=/zoo\",\n )\n .run();\n let first_c_extra_filename = dbg!(get_c_extra_filename(build_output));\n\n p.cargo(\"clean\").run();\n\n let build_output = p\n .cargo(\"build -v\")\n .env(\n \"RUSTFLAGS\",\n \"--remap-path-prefix=/def=/zoo --remap-path-prefix /earth=/zoo\",\n )\n .run();\n let second_c_extra_filename = dbg!(get_c_extra_filename(build_output));\n\n assert_data_eq!(first_c_extra_filename, second_c_extra_filename);\n}\n\n// `--remap-path-prefix` is meant to take two different binaries and make them the same but the\n// rlib name, including `-Cextra-filename`, can still end up in the binary so it can't change\n#[cargo_test]\nfn rustc_remap_path_prefix_ignored_for_c_extra_filename() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n let build_output = p\n .cargo(\"rustc -v -- --remap-path-prefix=/abc=/zoo --remap-path-prefix /spaced=/zoo\")\n .run();\n let first_c_extra_filename = dbg!(get_c_extra_filename(build_output));\n\n p.cargo(\"clean\").run();\n\n let build_output = p\n .cargo(\"rustc -v -- --remap-path-prefix=/def=/zoo --remap-path-prefix /earth=/zoo\")\n .run();\n let second_c_extra_filename = dbg!(get_c_extra_filename(build_output));\n\n assert_data_eq!(first_c_extra_filename, second_c_extra_filename);\n}\n\nfn get_c_metadata(output: RawOutput) -> String {\n let get_c_metadata_re =\n regex::Regex::new(r\".* (--crate-name [^ ]+).* (-C ?metadata=[^ ]+).*\").unwrap();\n\n let stderr = String::from_utf8(output.stderr).unwrap();\n let mut c_metadata = get_c_metadata_re\n .captures_iter(&stderr)\n .map(|c| {\n let (_, [name, c_metadata]) = c.extract();\n format!(\"{name} {c_metadata}\")\n })\n .collect::>();\n assert!(\n !c_metadata.is_empty(),\n \"`{get_c_metadata_re:?}` did not match:\\n```\\n{stderr}\\n```\"\n );\n c_metadata.sort();\n c_metadata.join(\"\\n\")\n}\n\nfn get_c_extra_filename(output: RawOutput) -> String {\n let get_c_extra_filename_re =\n regex::Regex::new(r\".* (--crate-name [^ ]+).* (-C ?extra-filename=[^ ]+).*\").unwrap();\n\n let stderr = String::from_utf8(output.stderr).unwrap();\n let mut c_extra_filename = get_c_extra_filename_re\n .captures_iter(&stderr)\n .map(|c| {\n let (_, [name, c_extra_filename]) = c.extract();\n format!(\"{name} {c_extra_filename}\")\n })\n .collect::>();\n assert!(\n !c_extra_filename.is_empty(),\n \"`{get_c_extra_filename_re:?}` did not match:\\n```\\n{stderr}\\n```\"\n );\n c_extra_filename.sort();\n c_extra_filename.join(\"\\n\")\n}\n\n#[cargo_test]\nfn host_config_rustflags_with_target() {\n // regression test for https://github.com/rust-lang/cargo/issues/10206\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() { assert!(cfg!(foo)); }\")\n .file(\".cargo/config.toml\", \"target-applies-to-host = false\")\n .build();\n\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\", \"host-config\"])\n .arg(\"-Zhost-config\")\n .arg(\"-Ztarget-applies-to-host\")\n .arg(\"-Zunstable-options\")\n .arg(\"--config\")\n .arg(\"host.rustflags=[\\\"--cfg=foo\\\"]\")\n .run();\n}\n\n#[cargo_test]\nfn target_applies_to_host_rustflags_works() {\n // Ensures that rustflags are passed to the target when\n // target_applies_to_host=false\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"#[cfg(feature = \"flag\")] compile_error!(\"flag passed\");\"#,\n )\n .build();\n\n // Use RUSTFLAGS to pass an argument that will generate an error.\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .env(\"CARGO_TARGET_APPLIES_TO_HOST\", \"false\")\n .env(\"RUSTFLAGS\", r#\"--cfg feature=\"flag\"\"#)\n .with_status(101)\n .with_stderr_data(\n \"[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] flag passed\n...\",\n )\n .run();\n}\n\n#[cargo_test]\nfn target_applies_to_host_rustdocflags_works() {\n // Ensures that rustflags are passed to the target when\n // target_applies_to_host=false\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"#[cfg(feature = \"flag\")] compile_error!(\"flag passed\");\"#,\n )\n .build();\n\n // Use RUSTFLAGS to pass an argument that would generate an error\n // but it is ignored.\n p.cargo(\"doc\")\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .env(\"CARGO_TARGET_APPLIES_TO_HOST\", \"false\")\n .env(\"RUSTDOCFLAGS\", r#\"--cfg feature=\"flag\"\"#)\n .with_status(101)\n .with_stderr_data(\n \"[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)\n[ERROR] flag passed\n...\",\n )\n .run();\n}\n\n#[cargo_test]\nfn host_config_shared_build_dep() {\n // rust-lang/cargo#14253\n Package::new(\"cc\", \"1.0.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bootstrap\"\n edition = \"2021\"\n\n [dependencies]\n cc = \"1.0.0\"\n\n [build-dependencies]\n cc = \"1.0.0\"\n\n [profile.dev]\n debug = 0\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n \"\n target-applies-to-host=false\n\n [host]\n rustflags = ['--cfg', 'from_host']\n\n [build]\n rustflags = ['--cfg', 'from_target']\n \",\n )\n .build();\n\n p.cargo(\"build -v\")\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .arg(\"-Ztarget-applies-to-host\")\n .arg(\"-Zhost-config\")\n .with_stderr_data(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] cc v1.0.0 (registry `dummy-registry`)\n[COMPILING] cc v1.0.0\n[RUNNING] `rustc --crate-name cc [..]--cfg from_host[..]`\n[RUNNING] `rustc --crate-name cc [..]--cfg from_target[..]`\n[COMPILING] bootstrap v0.0.0 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name build_script_build [..]--cfg from_host[..]`\n[RUNNING] `[ROOT]/foo/target/debug/build/bootstrap-[HASH]/build-script-build`\n[RUNNING] `rustc --crate-name bootstrap[..]--cfg from_target[..]`\n[FINISHED] `dev` profile [unoptimized] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n" }, { "path": "tests/testsuite/rustup.rs", "content": "//! Tests for Cargo's behavior under Rustup.\n\nuse std::env;\nuse std::env::consts::EXE_EXTENSION;\nuse std::ffi::OsString;\nuse std::fs;\nuse std::path::{Path, PathBuf};\n\nuse crate::prelude::*;\nuse crate::utils::cargo_process;\nuse cargo_test_support::paths::{home, root};\nuse cargo_test_support::{process, project, str};\n\n/// Helper to generate an executable.\nfn make_exe(dest: &Path, name: &str, contents: &str, env: &[(&str, PathBuf)]) -> PathBuf {\n let rs_name = format!(\"{name}.rs\");\n fs::write(\n root().join(&rs_name),\n &format!(\"fn main() {{ {contents} }}\"),\n )\n .unwrap();\n let mut pb = process(\"rustc\");\n env.iter().for_each(|(key, value)| {\n pb.env(key, value);\n });\n pb.arg(\"--edition=2021\")\n .arg(root().join(&rs_name))\n .exec()\n .unwrap();\n let exe = Path::new(name).with_extension(EXE_EXTENSION);\n let output = dest.join(&exe);\n fs::rename(root().join(&exe), &output).unwrap();\n output\n}\n\nfn prepend_path(path: &Path) -> OsString {\n let mut paths = vec![path.to_path_buf()];\n paths.extend(env::split_paths(&env::var_os(\"PATH\").unwrap_or_default()));\n env::join_paths(paths).unwrap()\n}\n\nstruct RustupEnvironment {\n /// Path for ~/.cargo/bin\n cargo_bin: PathBuf,\n /// Path for ~/.rustup\n rustup_home: PathBuf,\n /// Path to the cargo executable in the toolchain directory\n /// (~/.rustup/toolchain/test-toolchain/bin/cargo.exe).\n cargo_toolchain_exe: PathBuf,\n}\n\n/// Creates an executable which prints a message and then runs the *real* rustc.\nfn real_rustc_wrapper(bin_dir: &Path, message: &str) -> PathBuf {\n let real_rustc = cargo_util::paths::resolve_executable(\"rustc\".as_ref()).unwrap();\n // The toolchain rustc needs to call the real rustc. In order to do that,\n // it needs to restore or clear the RUSTUP environment variables so that\n // if rustup is installed, it will call the correct rustc.\n let rustup_toolchain_setup = match std::env::var_os(\"RUSTUP_TOOLCHAIN\") {\n Some(t) => format!(\n \".env(\\\"RUSTUP_TOOLCHAIN\\\", \\\"{}\\\")\",\n t.into_string().unwrap()\n ),\n None => format!(\".env_remove(\\\"RUSTUP_TOOLCHAIN\\\")\"),\n };\n let mut env = vec![(\"CARGO_RUSTUP_TEST_real_rustc\", real_rustc)];\n let rustup_home_setup = match std::env::var_os(\"RUSTUP_HOME\") {\n Some(h) => {\n env.push((\"CARGO_RUSTUP_TEST_RUSTUP_HOME\", h.into()));\n format!(\".env(\\\"RUSTUP_HOME\\\", env!(\\\"CARGO_RUSTUP_TEST_RUSTUP_HOME\\\"))\")\n }\n None => format!(\".env_remove(\\\"RUSTUP_HOME\\\")\"),\n };\n make_exe(\n bin_dir,\n \"rustc\",\n &format!(\n r#\"\n eprintln!(\"{message}\");\n let r = std::process::Command::new(env!(\"CARGO_RUSTUP_TEST_real_rustc\"))\n .args(std::env::args_os().skip(1))\n {rustup_toolchain_setup}\n {rustup_home_setup}\n .status();\n std::process::exit(r.unwrap().code().unwrap_or(2));\n \"#\n ),\n &env,\n )\n}\n\n/// Creates a simulation of a rustup environment with `~/.cargo/bin` and\n/// `~/.rustup` directories populated with some executables that simulate\n/// rustup.\nfn simulated_rustup_environment() -> RustupEnvironment {\n // Set up ~/.rustup/toolchains/test-toolchain/bin with a custom rustc and cargo.\n let rustup_home = home().join(\".rustup\");\n let toolchain_bin = rustup_home\n .join(\"toolchains\")\n .join(\"test-toolchain\")\n .join(\"bin\");\n toolchain_bin.mkdir_p();\n let rustc_toolchain_exe = real_rustc_wrapper(&toolchain_bin, \"real rustc running\");\n let cargo_toolchain_exe = make_exe(\n &toolchain_bin,\n \"cargo\",\n r#\"panic!(\"cargo toolchain should not be called\");\"#,\n &[],\n );\n\n // Set up ~/.cargo/bin with a typical set of rustup proxies.\n let cargo_bin = home().join(\".cargo\").join(\"bin\");\n cargo_bin.mkdir_p();\n\n let rustc_proxy = make_exe(\n &cargo_bin,\n \"rustc\",\n &format!(\n r#\"\n match std::env::args().next().unwrap().as_ref() {{\n \"rustc\" => {{}}\n arg => panic!(\"proxy only supports rustc, got {{arg:?}}\"),\n }}\n eprintln!(\"rustc proxy running\");\n let r = std::process::Command::new(env!(\"CARGO_RUSTUP_TEST_rustc_toolchain_exe\"))\n .args(std::env::args_os().skip(1))\n .status();\n std::process::exit(r.unwrap().code().unwrap_or(2));\n \"#\n ),\n &[(\"CARGO_RUSTUP_TEST_rustc_toolchain_exe\", rustc_toolchain_exe)],\n );\n fs::hard_link(\n &rustc_proxy,\n cargo_bin.join(\"cargo\").with_extension(EXE_EXTENSION),\n )\n .unwrap();\n fs::hard_link(\n &rustc_proxy,\n cargo_bin.join(\"rustup\").with_extension(EXE_EXTENSION),\n )\n .unwrap();\n\n RustupEnvironment {\n cargo_bin,\n rustup_home,\n cargo_toolchain_exe,\n }\n}\n\n#[cargo_test]\nfn typical_rustup() {\n // Test behavior under a typical rustup setup with a normal toolchain.\n let RustupEnvironment {\n cargo_bin,\n rustup_home,\n cargo_toolchain_exe,\n } = simulated_rustup_environment();\n\n // Set up a project and run a normal cargo build.\n let p = project().file(\"src/lib.rs\", \"\").build();\n // The path is modified so that cargo will call `rustc` from\n // `~/.cargo/bin/rustc to use our custom rustup proxies.\n let path = prepend_path(&cargo_bin);\n p.cargo(\"check\")\n .env(\"RUSTUP_TOOLCHAIN\", \"test-toolchain\")\n .env(\"RUSTUP_HOME\", &rustup_home)\n .env(\"PATH\", &path)\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\nreal rustc running\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n // Do a similar test, but with a toolchain link that does not have cargo\n // (which normally would do a fallback to nightly/beta/stable).\n cargo_toolchain_exe.rm_rf();\n p.build_dir().rm_rf();\n\n p.cargo(\"check\")\n .env(\"RUSTUP_TOOLCHAIN\", \"test-toolchain\")\n .env(\"RUSTUP_HOME\", &rustup_home)\n .env(\"PATH\", &path)\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\nreal rustc running\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n// This doesn't work on Windows because Cargo forces the PATH to contain the\n// sysroot_libdir, which is actually `bin`, preventing the test from\n// overriding the bin directory.\n#[cargo_test(ignore_windows = \"PATH can't be overridden on Windows\")]\nfn custom_calls_other_cargo() {\n // Test behavior when a custom subcommand tries to manipulate PATH to use\n // a different toolchain.\n let RustupEnvironment {\n cargo_bin,\n rustup_home,\n cargo_toolchain_exe: _,\n } = simulated_rustup_environment();\n\n // Create a directory with a custom toolchain (outside of the rustup universe).\n let custom_bin = root().join(\"custom-bin\");\n custom_bin.mkdir_p();\n // `cargo` points to the real cargo.\n let cargo_exe = crate::utils::cargo_exe();\n fs::hard_link(&cargo_exe, custom_bin.join(cargo_exe.file_name().unwrap())).unwrap();\n // `rustc` executes the real rustc.\n real_rustc_wrapper(&custom_bin, \"custom toolchain rustc running\");\n\n // A project that cargo-custom will try to build.\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n // Create a custom cargo subcommand.\n // This will modify PATH to a custom toolchain and call cargo from that.\n make_exe(\n &cargo_bin,\n \"cargo-custom\",\n r#\"\n use std::env;\n use std::process::Command;\n\n eprintln!(\"custom command running\");\n\n let mut paths = vec![std::path::PathBuf::from(env!(\"CARGO_RUSTUP_TEST_custom_bin\"))];\n paths.extend(env::split_paths(&env::var_os(\"PATH\").unwrap_or_default()));\n let path = env::join_paths(paths).unwrap();\n\n let status = Command::new(\"cargo\")\n .arg(\"check\")\n .current_dir(env!(\"CARGO_RUSTUP_TEST_project_dir\"))\n .env(\"PATH\", path)\n .status()\n .unwrap();\n assert!(status.success());\n \"#,\n &[\n (\"CARGO_RUSTUP_TEST_custom_bin\", custom_bin),\n (\"CARGO_RUSTUP_TEST_project_dir\", p.root()),\n ],\n );\n\n cargo_process(\"custom\")\n // Set these to simulate what would happen when running under rustup.\n // We want to make sure that cargo-custom does not try to use the\n // rustup proxies.\n .env(\"RUSTUP_TOOLCHAIN\", \"test-toolchain\")\n .env(\"RUSTUP_HOME\", &rustup_home)\n .with_stderr_data(str![[r#\"\ncustom command running\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\ncustom toolchain rustc running\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/sbom.rs", "content": "//! Tests for cargo-sbom precursor files.\n\nuse std::path::PathBuf;\n\nuse crate::prelude::*;\nuse cargo_test_support::basic_bin_manifest;\nuse cargo_test_support::cargo_test;\nuse cargo_test_support::compare::assert_e2e;\nuse cargo_test_support::project;\nuse cargo_test_support::registry::Package;\nuse snapbox::IntoData;\n\nconst SBOM_FILE_EXTENSION: &str = \".cargo-sbom.json\";\n\nfn append_sbom_suffix(link: &PathBuf) -> PathBuf {\n let mut link_buf = link.clone().into_os_string();\n link_buf.push(SBOM_FILE_EXTENSION);\n PathBuf::from(link_buf)\n}\n\n#[cargo_test]\nfn warn_without_passing_unstable_flag() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\n \"src/main.rs\",\n r#\"fn main() {\n eprintln!(\"{:?}\", option_env!(\"CARGO_SBOM_PATH\"));\n}\"#,\n )\n .build();\n\n p.cargo(\"run\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .masquerade_as_nightly_cargo(&[\"sbom\"])\n .with_stderr_data(snapbox::str![[r#\"\n[WARNING] ignoring 'sbom' config, pass `-Zsbom` to enable it\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\nNone\n\n\"#]])\n .run();\n\n let file = append_sbom_suffix(&p.bin(\"foo\"));\n assert!(!file.exists());\n}\n\n#[cargo_test]\nfn simple() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/main.rs\", r#\"fn main() {}\"#)\n .build();\n\n p.cargo(\"build -Zsbom\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .masquerade_as_nightly_cargo(&[\"sbom\"])\n .run();\n\n let file = append_sbom_suffix(&p.bin(\"foo\"));\n let output = std::fs::read_to_string(file).unwrap();\n // The expected test does contain the \"rustc\" section\n // but other tests omit them for brevity.\n assert_e2e().eq(\n output,\n snapbox::str![[r#\"\n{\n \"crates\": [\n {\n \"dependencies\": [],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#0.5.0\",\n \"kind\": [\n \"bin\"\n ]\n }\n ],\n \"root\": 0,\n \"rustc\": {\n \"commit_hash\": \"{...}\",\n \"host\": \"[HOST_TARGET]\",\n \"verbose_version\": \"{...}\",\n \"version\": \"{...}\",\n \"workspace_wrapper\": null,\n \"wrapper\": null\n },\n \"target\": \"[HOST_TARGET]\",\n \"version\": 1\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn with_multiple_crate_types() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"1.2.3\"\n\n [lib]\n crate-type = [\"dylib\", \"rlib\"]\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() { let _i = foo::give_five(); }\"#)\n .file(\"src/lib.rs\", r#\"pub fn give_five() -> i32 { 5 }\"#)\n .build();\n\n p.cargo(\"build -Zsbom\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .masquerade_as_nightly_cargo(&[\"sbom\"])\n .run();\n\n assert_eq!(\n 3,\n p.glob(p.target_debug_dir().join(\"*.cargo-sbom.json\"))\n .count()\n );\n\n let sbom_path = append_sbom_suffix(&p.dylib(\"foo\"));\n assert!(sbom_path.is_file());\n\n let output = std::fs::read_to_string(sbom_path).unwrap();\n assert_e2e().eq(\n output,\n snapbox::str![[r#\"\n{\n \"crates\": [\n {\n \"dependencies\": [],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#1.2.3\",\n \"kind\": [\n \"dylib\",\n \"rlib\"\n ]\n }\n ],\n \"root\": 0,\n \"rustc\": \"{...}\",\n \"target\": \"[HOST_TARGET]\",\n \"version\": 1\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn with_simple_build_script() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n build = \"build.rs\"\n \"#,\n )\n .file(\"src/main.rs\", \"#[cfg(foo)] fn main() {}\")\n .file(\n \"build.rs\",\n r#\"fn main() {\n println!(\"cargo::rustc-check-cfg=cfg(foo)\");\n println!(\"cargo::rustc-cfg=foo\");\n }\"#,\n )\n .build();\n\n p.cargo(\"build -Zsbom\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .masquerade_as_nightly_cargo(&[\"sbom\"])\n .run();\n\n let path = append_sbom_suffix(&p.bin(\"foo\"));\n assert!(path.is_file());\n\n let output = std::fs::read_to_string(path).unwrap();\n assert_e2e().eq(\n output,\n snapbox::str![[r#\"\n{\n \"crates\": [\n {\n \"dependencies\": [\n {\n \"index\": 1,\n \"kind\": \"build\"\n }\n ],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#0.0.1\",\n \"kind\": [\n \"bin\"\n ]\n },\n {\n \"dependencies\": [],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#0.0.1\",\n \"kind\": [\n \"custom-build\"\n ]\n }\n ],\n \"root\": 0,\n \"rustc\": \"{...}\",\n \"target\": \"[HOST_TARGET]\",\n \"version\": 1\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn with_build_dependencies() {\n Package::new(\"baz\", \"0.1.0\").publish();\n Package::new(\"bar\", \"0.1.0\")\n .build_dep(\"baz\", \"0.1.0\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n build = \"build.rs\"\n\n [build-dependencies]\n baz = \"0.1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"pub fn bar() -> i32 { 2 }\")\n .file(\n \"build.rs\",\n r#\"fn main() {\n println!(\"cargo::rustc-check-cfg=cfg(foo)\");\n println!(\"cargo::rustc-cfg=foo\");\n }\"#,\n )\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n\n [dependencies]\n bar = \"0.1.0\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() { let _i = bar::bar(); }\")\n .build();\n\n p.cargo(\"build -Zsbom\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .masquerade_as_nightly_cargo(&[\"sbom\"])\n .run();\n\n let path = append_sbom_suffix(&p.bin(\"foo\"));\n let output = std::fs::read_to_string(path).unwrap();\n assert_e2e().eq(\n output,\n snapbox::str![[r#\"\n{\n \"crates\": [\n {\n \"dependencies\": [\n {\n \"index\": 1,\n \"kind\": \"build\"\n }\n ],\n \"features\": [],\n \"id\": \"registry+https://github.com/rust-lang/crates.io-index#bar@0.1.0\",\n \"kind\": [\n \"lib\"\n ]\n },\n {\n \"dependencies\": [\n {\n \"index\": 2,\n \"kind\": \"normal\"\n }\n ],\n \"features\": [],\n \"id\": \"registry+https://github.com/rust-lang/crates.io-index#bar@0.1.0\",\n \"kind\": [\n \"custom-build\"\n ]\n },\n {\n \"dependencies\": [],\n \"features\": [],\n \"id\": \"registry+https://github.com/rust-lang/crates.io-index#baz@0.1.0\",\n \"kind\": [\n \"lib\"\n ]\n },\n {\n \"dependencies\": [\n {\n \"index\": 0,\n \"kind\": \"normal\"\n }\n ],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#0.0.1\",\n \"kind\": [\n \"bin\"\n ]\n }\n ],\n \"root\": 3,\n \"rustc\": \"{...}\",\n \"target\": \"[HOST_TARGET]\",\n \"version\": 1\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn crate_uses_different_features_for_build_and_normal_dependencies() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n edition = \"2021\"\n\n [dependencies]\n b = { path = \"b/\", features = [\"f1\"] }\n\n [build-dependencies]\n b = { path = \"b/\", features = [\"f2\"] }\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n fn main() { b::f1(); }\n \"#,\n )\n .file(\n \"build.rs\",\n r#\"\n fn main() { b::f2(); }\n \"#,\n )\n .file(\n \"b/Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"0.0.1\"\n edition = \"2021\"\n\n [features]\n f1 = []\n f2 = []\n \"#,\n )\n .file(\n \"b/src/lib.rs\",\n r#\"\n #[cfg(feature = \"f1\")]\n pub fn f1() {}\n\n #[cfg(feature = \"f2\")]\n pub fn f2() {}\n \"#,\n )\n .build();\n\n p.cargo(\"build -Zsbom\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .masquerade_as_nightly_cargo(&[\"sbom\"])\n .run();\n\n let path = append_sbom_suffix(&p.bin(\"a\"));\n assert!(path.is_file());\n let output = std::fs::read_to_string(path).unwrap();\n assert_e2e().eq(\n output,\n snapbox::str![[r#\"\n{\n \"crates\": [\n {\n \"dependencies\": [\n {\n \"index\": 1,\n \"kind\": \"build\"\n },\n {\n \"index\": 3,\n \"kind\": \"normal\"\n }\n ],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#a@0.1.0\",\n \"kind\": [\n \"bin\"\n ]\n },\n {\n \"dependencies\": [\n {\n \"index\": 2,\n \"kind\": \"normal\"\n }\n ],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#a@0.1.0\",\n \"kind\": [\n \"custom-build\"\n ]\n },\n {\n \"dependencies\": [],\n \"features\": [\n \"f2\"\n ],\n \"id\": \"path+[ROOTURL]/foo/b#0.0.1\",\n \"kind\": [\n \"lib\"\n ]\n },\n {\n \"dependencies\": [],\n \"features\": [\n \"f1\"\n ],\n \"id\": \"path+[ROOTURL]/foo/b#0.0.1\",\n \"kind\": [\n \"lib\"\n ]\n }\n ],\n \"root\": 0,\n \"rustc\": \"{...}\",\n \"target\": \"[HOST_TARGET]\",\n \"version\": 1\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn artifact_dep() {\n Package::new(\"bar\", \"0.5.0\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"Cargo.toml\", &basic_bin_manifest(\"bar\"))\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.0\"\n edition = \"2021\"\n\n [lib]\n crate-type = [\"dylib\"] \n\n [dependencies]\n bar = { version = \"0.5.0\", artifact = \"bin\" }\n\n [build-dependencies]\n bar = { version = \"0.5.0\", artifact = \"bin\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", r#\"\n fn main() {\n let bar: std::path::PathBuf = std::env::var(\"CARGO_BIN_FILE_BAR\").expect(\"CARGO_BIN_FILE_BAR\").into();\n assert!(&bar.is_file());\n }\"#)\n .build();\n p.cargo(\"build -Z bindeps -Z sbom\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .masquerade_as_nightly_cargo(&[\"bindeps\", \"sbom\"])\n .run();\n\n let output = std::fs::read_to_string(append_sbom_suffix(&p.dylib(\"foo\"))).unwrap();\n assert_e2e().eq(\n output,\n snapbox::str![[r#\"\n{\n \"crates\": [\n {\n \"dependencies\": [],\n \"features\": [],\n \"id\": \"registry+https://github.com/rust-lang/crates.io-index#bar@0.5.0\",\n \"kind\": [\n \"bin\"\n ]\n },\n {\n \"dependencies\": [\n {\n \"index\": 0,\n \"kind\": \"normal\"\n },\n {\n \"index\": 0,\n \"kind\": \"build\"\n },\n {\n \"index\": 2,\n \"kind\": \"build\"\n }\n ],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#0.0.0\",\n \"kind\": [\n \"dylib\"\n ]\n },\n {\n \"dependencies\": [],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#0.0.0\",\n \"kind\": [\n \"custom-build\"\n ]\n }\n ],\n \"root\": 1,\n \"rustc\": \"{...}\",\n \"target\": \"[HOST_TARGET]\",\n \"version\": 1\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn proc_macro() {\n Package::new(\"noop\", \"0.0.1\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"noop\"\n version = \"0.0.1\"\n edition = \"2021\"\n\n [lib]\n proc-macro = true\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate proc_macro;\n use proc_macro::TokenStream;\n\n #[proc_macro_derive(Noop)]\n pub fn noop(_input: TokenStream) -> TokenStream {\n \"\".parse().unwrap()\n }\n \"#,\n )\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n\n [dependencies]\n noop = \"0.0.1\"\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n #[macro_use]\n extern crate noop;\n\n #[derive(Noop)]\n struct X;\n\n fn main() {}\n \"#,\n )\n .build();\n\n p.cargo(\"build -Z sbom\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .masquerade_as_nightly_cargo(&[\"sbom\"])\n .run();\n\n let output = std::fs::read_to_string(append_sbom_suffix(&p.bin(\"foo\"))).unwrap();\n assert_e2e().eq(\n output,\n snapbox::str![[r#\"\n{\n \"crates\": [\n {\n \"dependencies\": [\n {\n \"index\": 1,\n \"kind\": \"build\"\n }\n ],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#0.0.1\",\n \"kind\": [\n \"bin\"\n ]\n },\n {\n \"dependencies\": [],\n \"features\": [],\n \"id\": \"registry+https://github.com/rust-lang/crates.io-index#noop@0.0.1\",\n \"kind\": [\n \"proc-macro\"\n ]\n }\n ],\n \"root\": 0,\n \"rustc\": \"{...}\",\n \"target\": \"[HOST_TARGET]\",\n \"version\": 1\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn workspace_wrapper() {\n let wrapper = project()\n .at(\"wrapper\")\n .file(\"Cargo.toml\", &basic_bin_manifest(\"wrapper\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n let mut args = std::env::args().skip(1);\n if let Some(sbom) = std::env::var_os(\"CARGO_SBOM_PATH\") {\n for sbom in std::env::split_paths(&sbom) {\n eprintln!(\"found sbom\");\n assert!(sbom.exists());\n }\n }\n let status = std::process::Command::new(&args.next().unwrap())\n .args(args).status().unwrap();\n std::process::exit(status.code().unwrap_or(1));\n }\n \"#,\n )\n .build();\n wrapper.cargo(\"build\").run();\n\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/main.rs\", r#\"fn main() {}\"#)\n .build();\n p.cargo(\"build -Zsbom\")\n .env(\"CARGO_BUILD_SBOM\", \"true\")\n .env(\"RUSTC_WRAPPER\", wrapper.bin(\"wrapper\"))\n .masquerade_as_nightly_cargo(&[\"sbom\"])\n .with_stderr_data(snapbox::str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\nfound sbom\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n let file = append_sbom_suffix(&p.bin(\"foo\"));\n let output = std::fs::read_to_string(file).unwrap();\n assert_e2e().eq(\n output,\n snapbox::str![[r#\"\n{\n \"crates\": [\n {\n \"dependencies\": [],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#0.5.0\",\n \"kind\": [\n \"bin\"\n ]\n }\n ],\n \"root\": 0,\n \"rustc\": \"{...}\",\n \"target\": \"[HOST_TARGET]\",\n \"version\": 1\n}\n\"#]]\n .is_json(),\n );\n}\n" }, { "path": "tests/testsuite/script/cargo.rs", "content": "use crate::prelude::*;\nuse cargo_test_support::basic_manifest;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::str;\n\nconst ECHO_SCRIPT: &str = r#\"#!/usr/bin/env cargo\n\nfn main() {\n let current_exe = std::env::current_exe().unwrap().to_str().unwrap().to_owned();\n let mut args = std::env::args_os();\n let arg0 = args.next().unwrap().to_str().unwrap().to_owned();\n let args = args.collect::>();\n println!(\"current_exe: {current_exe}\");\n println!(\"arg0: {arg0}\");\n println!(\"args: {args:?}\");\n}\n\n#[test]\nfn test () {}\n\"#;\n\n#[cfg(unix)]\nfn path() -> Vec {\n std::env::split_paths(&std::env::var_os(\"PATH\").unwrap_or_default()).collect()\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn basic_rs() {\n let p = cargo_test_support::project()\n .file(\"echo.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript -v echo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] echo v0.0.0 ([ROOT]/foo/echo.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cfg(unix)]\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn arg0() {\n let p = cargo_test_support::project()\n .file(\"echo.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript -v echo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]\narg0: [ROOT]/foo/echo.rs\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] echo v0.0.0 ([ROOT]/foo/echo.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cfg(windows)]\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn arg0() {\n let p = cargo_test_support::project()\n .file(\"echo.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript -v echo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]\narg0: [ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] echo v0.0.0 ([ROOT]/foo/echo.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn basic_path() {\n let p = cargo_test_support::project()\n .file(\"echo\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript -v ./echo\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] echo v0.0.0 ([ROOT]/foo/echo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn path_required() {\n let p = cargo_test_support::project()\n .file(\"echo\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript -v echo\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] no such command: `echo`\n\n[HELP] a command with a similar name exists: `bench`\n\n[HELP] view all installed commands with `cargo --list`\n[HELP] find a package to install `echo` with `cargo search cargo-echo`\n[HELP] to run the file `echo`, provide a relative path like `./echo`\n\n\"#]])\n .run();\n}\n\n#[cfg(unix)]\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn manifest_precedence_over_plugins() {\n let p = cargo_test_support::project()\n .file(\"echo.rs\", ECHO_SCRIPT)\n .executable(std::path::Path::new(\"path-test\").join(\"cargo-echo.rs\"), \"\")\n .build();\n\n // With path - fmt is there with known description\n let mut path = path();\n path.push(p.root().join(\"path-test\"));\n let path = std::env::join_paths(path.iter()).unwrap();\n\n p.cargo(\"-Zscript -v echo.rs\")\n .env(\"PATH\", &path)\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] echo v0.0.0 ([ROOT]/foo/echo.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cfg(unix)]\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn warn_when_plugin_masks_manifest_on_stable() {\n let p = cargo_test_support::project()\n .file(\"echo.rs\", ECHO_SCRIPT)\n .executable(std::path::Path::new(\"path-test\").join(\"cargo-echo.rs\"), \"\")\n .build();\n\n let mut path = path();\n path.push(p.root().join(\"path-test\"));\n let path = std::env::join_paths(path.iter()).unwrap();\n\n p.cargo(\"-v echo.rs\")\n .env(\"PATH\", &path)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[WARNING] external subcommand `echo.rs` has the appearance of a manifest-command\n |\n = [NOTE] this was previously accepted but will be phased out when `-Zscript` is stabilized; see \n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn requires_nightly() {\n let p = cargo_test_support::project()\n .file(\"echo.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-v echo.rs\")\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] running the file `echo.rs` requires `-Zscript`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn requires_z_flag() {\n let p = cargo_test_support::project()\n .file(\"echo.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-v echo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] running the file `echo.rs` requires `-Zscript`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn manifest_parse_error() {\n // Exaggerate the newlines to make it more obvious if the error's line number is off\n let script = r#\"#!/usr/bin/env cargo\n\n\n\n\n\n---\n[dependencies]\nbar = 3\n---\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(str![\"\"])\n .with_stderr_data(str![[r#\"\n[ERROR] invalid type: integer `3`, expected a version string like \"0.9.8\" or a detailed dependency like { version = \"0.9.8\" }\n --> script.rs:9:7\n |\n9 | bar = 3\n | ^\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn clean_output_with_edition() {\n let script = r#\"#!/usr/bin/env cargo\n---\n[package]\nedition = \"2018\"\n---\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nHello world!\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn warning_without_edition() {\n let script = r#\"#!/usr/bin/env cargo\n---\n[package]\n---\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nHello world!\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn rebuild() {\n let script = r#\"#!/usr/bin/env cargo-eval\n\nfn main() {\n let msg = option_env!(\"_MESSAGE\").unwrap_or(\"undefined\");\n println!(\"msg = {}\", msg);\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nmsg = undefined\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n\n // Verify we don't rebuild\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nmsg = undefined\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n\n // Verify we do rebuild\n p.cargo(\"-Zscript -v script.rs\")\n .env(\"_MESSAGE\", \"hello\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nmsg = hello\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn use_script_config() {\n let script = ECHO_SCRIPT;\n let _ = cargo_test_support::project()\n .at(\"script\")\n .file(\"script.rs\", script)\n .build();\n\n let p = cargo_test_support::project()\n .file(\n \".cargo/config.toml\",\n r#\"\n[build]\nrustc = \"non-existent-rustc\"\n\"#,\n )\n .file(\"script.rs\", script)\n .build();\n\n // Verify the config is bad\n p.cargo(\"-Zscript script.rs -NotAnArg\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] could not execute process `non-existent-rustc -vV` (never executed)\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n\n // Verify that the config isn't used\n p.cargo(\"-Zscript ../script/script.rs -NotAnArg\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: [\"-NotAnArg\"]\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn default_programmatic_verbosity() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript script.rs -NotAnArg\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: [\"-NotAnArg\"]\n\n\"#]])\n .with_stderr_data(\"\")\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn quiet() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -q script.rs -NotAnArg\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: [\"-NotAnArg\"]\n\n\"#]])\n .with_stderr_data(\"\")\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_line_numbering_preserved() {\n let script = r#\"#!/usr/bin/env cargo\n\nfn main() {\n println!(\"line: {}\", line!());\n}\n\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nline: 4\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_escaped_hyphen_arg() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v -- script.rs -NotAnArg\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: [\"-NotAnArg\"]\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE] -NotAnArg`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_unescaped_hyphen_arg() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs -NotAnArg\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: [\"-NotAnArg\"]\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE] -NotAnArg`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_same_flags() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs --help\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: [\"--help\"]\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE] --help`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_name_has_weird_chars() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"s-h.wĀ§c!.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v s-h.wĀ§c!.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/s-h-w-c-[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] s-h-w-c- v0.0.0 ([ROOT]/foo/s-h.wĀ§c!.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/s-h-w-c-[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_name_has_leading_number() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"42answer.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v 42answer.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/answer[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] answer v0.0.0 ([ROOT]/foo/42answer.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/answer[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_name_is_number() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project().file(\"42.rs\", script).build();\n\n p.cargo(\"-Zscript -v 42.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/package[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] package v0.0.0 ([ROOT]/foo/42.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/package[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[cfg(not(windows))]\nfn test_name_is_windows_reserved_name() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project().file(\"con\", script).build();\n\n p.cargo(\"-Zscript -v ./con\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/con[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] con v0.0.0 ([ROOT]/foo/con)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/con[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_name_is_sysroot_package_name() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project().file(\"test\", script).build();\n\n p.cargo(\"-Zscript -v ./test\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/test[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] test v0.0.0 ([ROOT]/foo/test)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/test[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_name_is_keyword() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project().file(\"self\", script).build();\n\n p.cargo(\"-Zscript -v ./self\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/self[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] self v0.0.0 ([ROOT]/foo/self)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/self[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_name_is_deps_dir_implicit() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"deps.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v deps.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(str![\"\"])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[ERROR] failed to parse manifest at `[ROOT]/foo/deps.rs`\n\nCaused by:\n the binary target name `deps` is forbidden, it conflicts with cargo's build directory names\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_name_is_deps_dir_explicit() {\n let script = r#\"#!/usr/bin/env cargo\n---\npackage.name = \"deps\"\n---\n\nfn main() {\n let current_exe = std::env::current_exe().unwrap().to_str().unwrap().to_owned();\n let mut args = std::env::args_os();\n let arg0 = args.next().unwrap().to_str().unwrap().to_owned();\n let args = args.collect::>();\n println!(\"current_exe: {current_exe}\");\n println!(\"arg0: {arg0}\");\n println!(\"args: {args:?}\");\n}\n\n#[test]\nfn test () {}\n\"#;\n let p = cargo_test_support::project()\n .file(\"deps.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v deps.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(str![\"\"])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[ERROR] failed to parse manifest at `[ROOT]/foo/deps.rs`\n\nCaused by:\n the binary target name `deps` is forbidden, it conflicts with cargo's build directory names\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn script_like_dir() {\n let p = cargo_test_support::project()\n .file(\"foo.rs/foo\", \"something\")\n .build();\n\n p.cargo(\"-Zscript -v foo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no such file or subcommand `foo.rs`: `foo.rs` is a directory\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn non_existent_rs() {\n let p = cargo_test_support::project().build();\n\n p.cargo(\"-Zscript -v foo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no such file or subcommand `foo.rs`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn non_existent_rs_stable() {\n let p = cargo_test_support::project().build();\n\n p.cargo(\"-v foo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] no such subcommand `foo.rs`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn did_you_mean_file() {\n let p = cargo_test_support::project()\n .file(\"food.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript -v foo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] no such file or subcommand `foo.rs`\n[HELP] there is a script with a similar name: `./food.rs`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn did_you_mean_file_stable() {\n let p = cargo_test_support::project()\n .file(\"food.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-v foo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] no such subcommand `foo.rs`\n[HELP] there is a script with a similar name: `./food.rs` (requires `-Zscript`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn did_you_mean_command() {\n let p = cargo_test_support::project().build();\n\n p.cargo(\"-Zscript -v build--manifest-path=./Cargo.toml\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] no such file or subcommand `build--manifest-path=./Cargo.toml`\n[HELP] there is a command with a similar name: `build --manifest-path=./Cargo.toml`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn did_you_mean_command_stable() {\n let p = cargo_test_support::project().build();\n\n p.cargo(\"-v build--manifest-path=./Cargo.toml\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] no such subcommand `build--manifest-path=./Cargo.toml`\n[HELP] there is a command with a similar name: `build --manifest-path=./Cargo.toml`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_name_same_as_dependency() {\n Package::new(\"script\", \"1.0.0\").publish();\n let script = r#\"#!/usr/bin/env cargo\n---\n[dependencies]\nscript = \"1.0.0\"\n---\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs --help\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nHello world!\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest Rust [..] compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] script v1.0.0 (registry `dummy-registry`)\n[COMPILING] script v1.0.0\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE] --help`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_path_dep() {\n let script = r#\"#!/usr/bin/env cargo\n---\n[dependencies]\nbar.path = \"./bar\"\n---\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .file(\"src/lib.rs\", \"pub fn foo() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\"bar/src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n p.cargo(\"-Zscript -v script.rs --help\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nHello world!\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[LOCKING] 1 package to latest Rust [..] compatible version\n[COMPILING] bar v0.0.1 ([ROOT]/foo/bar)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE] --help`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_no_build_rs() {\n let script = r#\"#!/usr/bin/env cargo\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .file(\"build.rs\", \"broken\")\n .build();\n\n p.cargo(\"-Zscript -v script.rs --help\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nHello world!\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE] --help`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_no_autobins() {\n let script = r#\"#!/usr/bin/env cargo\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .file(\"src/bin/not-script/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"-Zscript -v script.rs --help\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nHello world!\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE] --help`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn test_no_autolib() {\n let script = r#\"#!/usr/bin/env cargo\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .file(\"src/lib.rs\", r#\"compile_error!{\"must not be built\"}\"#)\n .build();\n\n p.cargo(\"-Zscript -v script.rs --help\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nHello world!\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE] --help`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_workspace() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\npackage.edition = \"2021\"\n\n[workspace]\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `workspace` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn workspace_members_mentions_script() {\n let p = cargo_test_support::project()\n .file(\n \"Cargo.toml\",\n r#\"\n[workspace]\nmembers = [\"scripts/nop.rs\"]\n\"#,\n )\n .file(\n \"scripts/nop.rs\",\n r#\"\n----\npackage.edition = \"2021\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript check\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `[ROOT]/foo` contains no package: The manifest is virtual, and the workspace has no members.\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn workspace_members_glob_matches_script() {\n let p = cargo_test_support::project()\n .file(\n \"Cargo.toml\",\n r#\"\n[workspace]\nmembers = [\"scripts/*\"]\n\"#,\n )\n .file(\n \"scripts/nop.rs\",\n r#\"\n----\npackage.edition = \"2021\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript check\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `[ROOT]/foo` contains no package: The manifest is virtual, and the workspace has no members.\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn package_workspace() {\n let p = cargo_test_support::project()\n .file(\n \"Cargo.toml\",\n r#\"\n[workspace]\nmembers = [\"scripts/*\"]\n\n[package]\nname = \"foo\"\n\"#,\n )\n .file(\n \"scripts/nop.rs\",\n r#\"\n----\npackage.edition = \"2021\"\npackage.workspace = \"../\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript ./scripts/nop.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/scripts/nop.rs`\n\nCaused by:\n `package.workspace` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_lib() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\npackage.edition = \"2021\"\n\n[lib]\nname = \"script\"\npath = \"script.rs\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `lib` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_bin() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\npackage.edition = \"2021\"\n\n[[bin]]\nname = \"script\"\npath = \"script.rs\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `bin` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_example() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\npackage.edition = \"2021\"\n\n[[example]]\nname = \"script\"\npath = \"script.rs\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `example` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_test() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\npackage.edition = \"2021\"\n\n[[test]]\nname = \"script\"\npath = \"script.rs\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `test` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_bench() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\npackage.edition = \"2021\"\n\n[[bench]]\nname = \"script\"\npath = \"script.rs\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `bench` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_package_build() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\n[package]\nedition = \"2021\"\nbuild = \"script.rs\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `package.build` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_package_links() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\n[package]\nedition = \"2021\"\nlinks = \"script\"\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `package.links` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_package_autolib() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\n[package]\nedition = \"2021\"\nautolib = true\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `package.autolib` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_package_autobins() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\n[package]\nedition = \"2021\"\nautobins = true\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `package.autobins` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_package_autoexamples() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\n[package]\nedition = \"2021\"\nautoexamples = true\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `package.autoexamples` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_package_autotests() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\n[package]\nedition = \"2021\"\nautotests = true\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `package.autotests` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn disallow_explicit_package_autobenches() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"\n----\n[package]\nedition = \"2021\"\nautobenches = true\n----\n\nfn main() {}\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/script.rs`\n\nCaused by:\n `package.autobenches` is not allowed in embedded manifests\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn implicit_target_dir() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn no_local_lockfile() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n let local_lockfile_path = p.root().join(\"Cargo.lock\");\n\n assert!(!local_lockfile_path.exists());\n\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n\n assert!(!local_lockfile_path.exists());\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_check_requires_nightly() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"check --manifest-path script.rs\")\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] embedded manifest `[ROOT]/foo/script.rs` requires `-Zscript`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_check_requires_z_flag() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"check --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] embedded manifest `[ROOT]/foo/script.rs` requires `-Zscript`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_check_with_embedded() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript check --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[CHECKING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_check_with_missing_script_rs() {\n let p = cargo_test_support::project().build();\n\n p.cargo(\"-Zscript check --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `script.rs` does not exist\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_check_with_missing_script() {\n let p = cargo_test_support::project().build();\n\n p.cargo(\"-Zscript check --manifest-path script\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `script` does not exist\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_build_with_embedded() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript build --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_test_with_embedded() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript test --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests script.rs ([ROOT]/home/.cargo/build/[HASH]/debug/deps/script-[HASH][EXE])\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_clean_with_embedded() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n // Ensure there is something to clean\n p.cargo(\"-Zscript script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .run();\n\n p.cargo(\"-Zscript clean --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[REMOVED] [FILE_NUM] files, [FILE_SIZE]B total\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_generate_lockfile_with_embedded() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript generate-lockfile --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_metadata_with_embedded() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript metadata --manifest-path script.rs --format-version=1\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(\n str![[r#\"\n{\n \"metadata\": null,\n \"packages\": [\n {\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script.rs#script@0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script.rs\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script.rs\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n }\n ],\n \"resolve\": {\n \"nodes\": [\n {\n \"dependencies\": [],\n \"deps\": [],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo/script.rs#script@0.0.0\"\n }\n ],\n \"root\": \"path+[ROOTURL]/foo/script.rs#script@0.0.0\"\n },\n \"target_directory\": \"[ROOT]/home/.cargo/build/[HASH]/target\",\n \"build_directory\": \"[ROOT]/home/.cargo/build/[HASH]\",\n \"version\": 1,\n \"workspace_default_members\": [\n \"path+[ROOTURL]/foo/script.rs#script@0.0.0\"\n ],\n \"workspace_members\": [\n \"path+[ROOTURL]/foo/script.rs#script@0.0.0\"\n ],\n \"workspace_root\": \"[ROOT]/foo\"\n}\n\"#]]\n .is_json(),\n )\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_read_manifest_with_embedded() {\n let script = ECHO_SCRIPT;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript read-manifest --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(\n str![[r#\"\n{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script.rs#script@0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script.rs\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script.rs\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}\n\"#]]\n .is_json(),\n )\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_run_with_embedded() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript run --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_tree_with_embedded() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript tree --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nscript v0.0.0 ([ROOT]/foo/script.rs)\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_update_with_embedded() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript update --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(\"\")\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_verify_project_with_embedded() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript verify-project --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(\n str![[r#\"\n{\n \"success\": \"true\"\n}\n\"#]]\n .is_json(),\n )\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_pkgid_with_embedded() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .run();\n\n p.cargo(\"-Zscript pkgid --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\npath+[ROOTURL]/foo/script.rs#script@0.0.0\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_pkgid_with_embedded_no_lock_file() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript pkgid --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[ERROR] a Cargo.lock must exist for this command\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_pkgid_with_embedded_dep() {\n Package::new(\"dep\", \"1.0.0\").publish();\n let script = r#\"#!/usr/bin/env cargo\n---\n[dependencies]\ndep = \"1.0.0\"\n---\n\nfn main() {\n println!(\"Hello world!\");\n}\"#;\n let p = cargo_test_support::project()\n .file(\"script.rs\", script)\n .build();\n\n p.cargo(\"-Zscript script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .run();\n\n p.cargo(\"-Zscript pkgid --manifest-path script.rs -p dep\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nregistry+https://github.com/rust-lang/crates.io-index#dep@1.0.0\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn script_as_dep() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .file(\"src/lib.rs\", \"pub fn foo() {}\")\n .file(\n \"Cargo.toml\",\n r#\"\n[package]\nname = \"foo\"\nversion = \"0.1.0\"\n\n[dependencies]\nscript.path = \"script.rs\"\n\"#,\n )\n .build();\n\n p.cargo(\"build\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to `2015` while the latest is `[..]`\n[ERROR] failed to get `script` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `script`\n\nCaused by:\n unable to update [ROOT]/foo/script.rs\n\nCaused by:\n single file packages cannot be used as dependencies\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_install_with_embedded() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript install --path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `[ROOT]/foo/script.rs` is not a directory. --path must point to a directory containing a Cargo.toml file.\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_package_with_embedded() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript package --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[ERROR] [ROOT]/foo/script.rs is unsupported by `cargo package`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn cmd_publish_with_embedded() {\n let p = cargo_test_support::project()\n .file(\"script.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(\"-Zscript publish --manifest-path script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[ERROR] [ROOT]/foo/script.rs is unsupported by `cargo publish`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn manifest_path_env() {\n let p = cargo_test_support::project()\n .file(\n \"script.rs\",\n r#\"#!/usr/bin/env cargo\n\nfn main() {\n let path = env!(\"CARGO_MANIFEST_PATH\");\n println!(\"CARGO_MANIFEST_PATH: {}\", path);\n}\n\"#,\n )\n .build();\n p.cargo(\"-Zscript -v script.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\nCARGO_MANIFEST_PATH: [ROOT]/foo/script.rs\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] script v0.0.0 ([ROOT]/foo/script.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/script[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\nfn ignore_surrounding_workspace() {\n let p = cargo_test_support::project()\n .file(\n std::path::Path::new(\".cargo\").join(\"config.toml\"),\n r#\"\n[registries.test-reg]\nindex = \"https://github.com/rust-lang/crates.io-index\"\n\"#,\n )\n .file(\n std::path::Path::new(\"inner\").join(\"Cargo.toml\"),\n r#\"\n[package]\nname = \"inner\"\nversion = \"0.1.0\"\n\n[dependencies]\nserde = { version = \"1.0\", registry = \"test-reg\" }\n\"#,\n )\n .file(std::path::Path::new(\"inner\").join(\"src\").join(\"lib.rs\"), \"\")\n .file(std::path::Path::new(\"script\").join(\"echo.rs\"), ECHO_SCRIPT)\n .file(\n \"Cargo.toml\",\n r#\"\n[workspace]\nmembers = [\n \"inner\",\n]\n\"#,\n )\n .build();\n\n p.cargo(\"-Zscript -v script/echo.rs\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]\narg0: [..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] echo v0.0.0 ([ROOT]/foo/script/echo.rs)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/echo[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[cfg(target_os = \"linux\")]\nfn memfd_script() {\n use std::io::Write;\n use std::os::fd::AsRawFd;\n\n let fd = memfd::MemfdOptions::new()\n .close_on_exec(false)\n .create(\"otkeep-script\")\n .unwrap();\n let mut file = fd.into_file();\n file.write_all(ECHO_SCRIPT.as_bytes()).unwrap();\n file.flush().unwrap();\n\n let raw_fd = file.as_raw_fd();\n\n let p = cargo_test_support::project()\n .file(\"echo.rs\", ECHO_SCRIPT)\n .build();\n\n p.cargo(&format!(\"-Zscript -v /proc/self/fd/{raw_fd}\"))\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(str![[r#\"\ncurrent_exe: [ROOT]/home/.cargo/build/[HASH]/target/debug/package\narg0: /proc/self/fd/[..]\nargs: []\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[WARNING] `package.edition` is unspecified, defaulting to the latest edition (currently `[..]`)\n[COMPILING] package v0.0.0 (/proc/self/fd/[..])\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/home/.cargo/build/[HASH]/target/debug/package`\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/script/mod.rs", "content": "mod cargo;\nmod rustc;\n" }, { "path": "tests/testsuite/script/rustc.rs", "content": "use std::collections::BTreeMap;\n\nuse snapbox::assert_data_eq;\n\nuse crate::prelude::*;\n\n#[test]\nfn ensure_all_fixtures_have_tests() {\n let mut code_gen_divider = \"//\".to_owned();\n code_gen_divider.push_str(\" START CODE GENERATION\");\n\n let self_path = snapbox::utils::current_rs!();\n let self_source = std::fs::read_to_string(&self_path).unwrap();\n\n let (header, _) = self_source\n .split_once(&code_gen_divider)\n .expect(\"code-gen divider is present\");\n let header = header.trim();\n\n let fixture_root = snapbox::utils::current_dir!().join(\"rustc_fixtures\");\n let mut fixtures = BTreeMap::new();\n for entry in std::fs::read_dir(fixture_root).unwrap() {\n let entry = entry.unwrap();\n let path = entry.path();\n let fn_name = file_to_fn(&path);\n fixtures\n .entry(fn_name.clone())\n .or_insert_with(|| Fixture::new(fn_name))\n .add_path(path);\n }\n\n let fixtures = fixtures\n .into_values()\n .filter(Fixture::is_valid)\n .map(|f| f.to_string())\n .collect::();\n let actual = format!(\n \"{header}\n\n{code_gen_divider}\n{fixtures}\"\n );\n assert_data_eq!(actual, snapbox::Data::read_from(&self_path, None).raw());\n}\n\nfn file_to_fn(path: &std::path::Path) -> String {\n let name = path.file_stem().unwrap().to_str().unwrap();\n name.replace(\"-\", \"_\")\n}\n\nfn sanitize_path(path: &std::path::Path) -> String {\n path.strip_prefix(env!(\"CARGO_MANIFEST_DIR\"))\n .unwrap()\n .as_os_str()\n .to_string_lossy()\n .replace(\"\\\\\", \"/\")\n}\n\nstruct Fixture {\n fn_name: String,\n input: std::path::PathBuf,\n output: Option,\n}\n\nimpl Fixture {\n fn new(fn_name: String) -> Self {\n Self {\n fn_name,\n input: Default::default(),\n output: Default::default(),\n }\n }\n\n fn is_valid(&self) -> bool {\n !self.input.as_os_str().is_empty()\n }\n\n fn add_path(&mut self, path: std::path::PathBuf) {\n if path.extension().map(|ext| ext.to_str().unwrap()) == Some(\"rs\") {\n assert!(\n self.input.as_os_str().is_empty(),\n \"similarly named fixtures:/n{}/n{}\",\n self.input.display(),\n path.display()\n );\n self.input = path;\n } else {\n assert!(\n self.output.is_none(),\n \"conflicting assertions:/n{}/n{}\",\n self.output.as_ref().unwrap().display(),\n path.display()\n );\n self.output = Some(path);\n }\n }\n}\n\nimpl std::fmt::Display for Fixture {\n fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let fn_name = &self.fn_name;\n let fixture_path = sanitize_path(&self.input);\n match self\n .output\n .as_ref()\n .map(|path| path.extension().unwrap().to_str().unwrap())\n {\n Some(\"stderr\") => {\n let assertion_path = sanitize_path(self.output.as_ref().unwrap());\n write!(\n fmt,\n r#\"\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn {fn_name}() {{\n let fixture_path = {fixture_path:?};\n let assertion_path = {assertion_path:?};\n assert_failure(fixture_path, assertion_path);\n}}\n\"#\n )\n }\n Some(\"stdout\") | None => {\n let mut backup_path = self.input.clone();\n backup_path.set_extension(\"stdout\");\n let assertion_path = sanitize_path(self.output.as_ref().unwrap_or(&backup_path));\n write!(\n fmt,\n r#\"\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn {fn_name}() {{\n let fixture_path = {fixture_path:?};\n let assertion_path = {assertion_path:?};\n assert_success(fixture_path, assertion_path);\n}}\n\"#\n )\n }\n Some(_) => {\n panic!(\n \"unsupported assertiong: {}\",\n self.output.as_ref().unwrap().display()\n )\n }\n }\n }\n}\n\n#[track_caller]\nfn assert_success(fixture_path: &str, assertion_path: &str) {\n let p = cargo_test_support::project()\n .file(\"script\", &std::fs::read_to_string(fixture_path).unwrap())\n .build();\n\n // `read-manifest` to validate frontmatter content without processing deps, compiling\n p.cargo(\"-Zscript read-manifest --manifest-path script\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_stdout_data(snapbox::Data::read_from(\n std::path::Path::new(assertion_path),\n Some(snapbox::data::DataFormat::Json),\n ))\n .run();\n}\n\n#[track_caller]\nfn assert_failure(fixture_path: &str, assertion_path: &str) {\n let p = cargo_test_support::project()\n .file(\"script\", &std::fs::read_to_string(fixture_path).unwrap())\n .build();\n\n // `read-manifest` to validate frontmatter content without processing deps, compiling\n p.cargo(\"-Zscript read-manifest --manifest-path script\")\n .masquerade_as_nightly_cargo(&[\"script\"])\n .with_status(101)\n .with_stderr_data(snapbox::Data::read_from(\n std::path::Path::new(assertion_path),\n None,\n ))\n .run();\n}\n\n// START CODE GENERATION\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn content_contains_whitespace() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/content-contains-whitespace.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/content-contains-whitespace.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn content_non_lexible_tokens() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/content-non-lexible-tokens.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/content-non-lexible-tokens.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn escape_hyphens_leading() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/escape-hyphens-leading.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/escape-hyphens-leading.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn escape_hyphens_nonleading_1() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-1.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-1.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn escape_hyphens_nonleading_2() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-2.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-2.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn escape_hyphens_nonleading_3() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-3.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-3.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_close_extra_after() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-close-extra-after.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-close-extra-after.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_indented() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-indented.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-indented.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_indented_mismatch() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-indented-mismatch.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-indented-mismatch.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_mismatch_1() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-mismatch-1.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-mismatch-1.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_mismatch_2() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-mismatch-2.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-mismatch-2.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_too_many_dashes() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-too-many-dashes.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-too-many-dashes.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_unclosed_1() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-1.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-1.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_unclosed_2() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-2.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-2.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_unclosed_3() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-3.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-3.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_unclosed_4() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-4.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-4.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_unclosed_5() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-5.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-5.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_unclosed_6() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-6.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-unclosed-6.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_whitespace_trailing_1() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-whitespace-trailing-1.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-whitespace-trailing-1.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn fence_whitespace_trailing_2() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/fence-whitespace-trailing-2.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/fence-whitespace-trailing-2.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn frontmatter_crlf() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/frontmatter-crlf.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/frontmatter-crlf.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn infostring_comma() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/infostring-comma.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/infostring-comma.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn infostring_dot_leading() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/infostring-dot-leading.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/infostring-dot-leading.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn infostring_dot_nonleading() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/infostring-dot-nonleading.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/infostring-dot-nonleading.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn infostring_hyphen_leading() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/infostring-hyphen-leading.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/infostring-hyphen-leading.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn infostring_hyphen_nonleading() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/infostring-hyphen-nonleading.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/infostring-hyphen-nonleading.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn infostring_space() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/infostring-space.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/infostring-space.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn location_after_shebang() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/location-after-shebang.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/location-after-shebang.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn location_after_tokens() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/location-after-tokens.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/location-after-tokens.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn location_include_in_expr_ctxt() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/location-include-in-expr-ctxt.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/location-include-in-expr-ctxt.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn location_include_in_item_ctxt() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/location-include-in-item-ctxt.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/location-include-in-item-ctxt.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn location_proc_macro_observer() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/location-proc-macro-observer.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/location-proc-macro-observer.stdout\";\n assert_success(fixture_path, assertion_path);\n}\n\n#[cargo_test(nightly, reason = \"-Zscript is unstable\")]\n#[rustfmt::skip] // code-generated\nfn multifrontmatter() {\n let fixture_path = \"tests/testsuite/script/rustc_fixtures/multifrontmatter.rs\";\n let assertion_path = \"tests/testsuite/script/rustc_fixtures/multifrontmatter.stderr\";\n assert_failure(fixture_path, assertion_path);\n}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/README.md", "content": "Canonical home for these tests is https://github.com/rust-lang/rust/tree/master/tests/ui/frontmatter\n\nTo update\n1. Sync changes to this directory\n2. Run `SNAPSHOTS=overwrite cargo test --test testsuite -- script::rustc` to register new test cases\n2. Run `SNAPSHOTS=overwrite cargo test --test testsuite -- script::rustc` to update snapshots for new test cases\n\nNote:\n- A `.stderr` file is assumed that the test fill fail\n- A `.stdout` file is assumed that the test fill succeed\n" }, { "path": "tests/testsuite/script/rustc_fixtures/auxiliary/expr.rs", "content": "---\n-\n---\n1\n" }, { "path": "tests/testsuite/script/rustc_fixtures/auxiliary/lib.rs", "content": "---something\n---\n\npub fn foo(x: i32) -> i32 {\n -x\n}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/auxiliary/makro.rs", "content": "extern crate proc_macro;\nuse proc_macro::{Literal, TokenStream};\n\n#[proc_macro]\npub fn check(_: TokenStream) -> TokenStream {\n // In the following test cases, the `---` may look like the start of frontmatter but it is not!\n // That's because it would be backward incompatible to interpret them as such in the latest\n // stable edition. That's not only the case due to the feature gate error but also due to the\n // fact that we \"eagerly\" emit errors on malformed frontmatter.\n\n // issue: \n _ = \"---\".parse::();\n // Just a sequence of regular Rust punctuation tokens.\n assert_eq!(6, \"---\\n---\".parse::().unwrap().into_iter().count());\n\n // issue: \n assert!(\"---\".parse::().is_err());\n\n Default::default()\n}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/content-contains-whitespace.rs", "content": "#!/usr/bin/env -S cargo -Zscript\n---cargo\n# Beware editing: it has numerous whitespace characters which are important.\n# It contains one ranges from the 'PATTERN_WHITE_SPACE' property outlined in\n# https://unicode.org/Public/UNIDATA/PropList.txt\n#\n# The characters in the first expression of the assertion can be generated\n# from: \"4\\u{0C}+\\n\\t\\r7\\t*\\u{20}2\\u{85}/\\u{200E}3\\u{200F}*\\u{2028}2\\u{2029}\"\npackage.description = \"\"\"\n4\f+\n\n7 * 2Ā…/ā€Ž3ā€*ā€Ø2\n\"\"\"\n---\n\n//@ check-pass\n\n// Ensure the frontmatter can contain any whitespace\n// CARGO(fail): However, TOML cannot\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/content-contains-whitespace.stderr", "content": "[ERROR] invalid multi-line basic string, expected `/`, characters\n --> script:10:2\n |\n10 | 4āŒ+\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/content-non-lexible-tokens.rs", "content": "--- cargo\npackage.description = \"\"\"\nšŸ³ļøā€āš§ļø\n\"\"\"\n---\n\n//@ check-pass\n\n#![feature(frontmatter)]\n\n// check that frontmatter blocks can have tokens that are otherwise not accepted by\n// the lexer as Rust code.\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/content-non-lexible-tokens.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": \"šŸ³ļøā€āš§ļø\\n\",\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/escape-hyphens-leading.rs", "content": "----\npackage.description = \"\"\"\n\n---\n\n\"\"\"\n----\n\n//@ check-pass\n\n// This test checks that longer dashes for opening and closing can be used to\n// escape sequences such as three dashes inside the frontmatter block.\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/escape-hyphens-leading.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": \"\\n---\\n\\n\",\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-1.rs", "content": "---\npackage.description = \"\"\"\n ---\n\n ---\n\"\"\"\n---\n\n// hyphens only need to be escaped when at the start of a line\n//@ check-pass\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-1.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": \" ---\\n\\n ---\\n\",\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-2.rs", "content": "---\npackage.description = \"\"\"\nx ---šŸš§ļø\n\"\"\"\n---\n\n// Regression test for #141483\n//@check-pass\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-2.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": \"x ---šŸš§ļø\\n\",\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-3.rs", "content": "---\npackage.description = \"\"\"\nx ---y\n\"\"\"\n---\n\n// Test that hyphens are allowed inside frontmatters if there is some\n// non-whitespace character preceding them.\n//@check-pass\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/escape-hyphens-nonleading-3.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": \"x ---y\\n\",\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-close-extra-after.rs", "content": "---\n---cargo\n//~^ ERROR: extra characters after frontmatter close are not allowed\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-close-extra-after.stderr", "content": "[ERROR] unexpected characters after frontmatter close\n --> script:2:4\n |\n1 | ---\n2 | ---cargo\n | ^^^^^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-indented-mismatch.rs", "content": "---cargo\n//~^ ERROR: unclosed frontmatter\n\n//@ compile-flags: --crate-type lib\n\n#![feature(frontmatter)]\n\nfn foo(x: i32) -> i32 {\n ---x\n //~^ WARNING: use of a double negation [double_negations]\n}\n\n// this test is for the weird case that valid Rust code can have three dashes\n// within them and get treated as a frontmatter close.\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-indented-mismatch.stderr", "content": "[ERROR] unclosed frontmatter; expected `---`\n --> script:14:56\n |\n 1 | ---cargo\n...\n14 | // within them and get treated as a frontmatter close.\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-indented.rs", "content": " ---\n//~^ ERROR: invalid preceding whitespace for frontmatter opening\n//~^^ ERROR: unclosed frontmatter\n ---\n\n#![feature(frontmatter)]\n\n// check that whitespaces should not precede the frontmatter opening or close.\n// CARGO(pass): not technitcally a frontmatter, so defer to rustc to error\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-indented.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-mismatch-1.rs", "content": "---cargo\n//~^ ERROR: frontmatter close does not match the opening\n----\n\n// there must be the same number of dashes for both the opening and the close\n// of the frontmatter.\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-mismatch-1.stderr", "content": "[ERROR] closing code fence has 1 more `-` than the opening fence\n --> script:3:4\n |\n1 | ---cargo\n2 | //~^ ERROR: frontmatter close does not match the opening\n3 | ----\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-mismatch-2.rs", "content": "----cargo\n//~^ ERROR: frontmatter close does not match the opening\n---cargo\n//~^ ERROR: extra characters after frontmatter close are not allowed\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-mismatch-2.stderr", "content": "[ERROR] closing code fence has 1 less `-` than the opening fence\n --> script:3:1\n |\n1 | ----cargo\n2 | //~^ ERROR: frontmatter close does not match the opening\n3 | ---cargo\n | ^^^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-too-many-dashes.rs", "content": "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n[dependencies]\n----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\n#![feature(frontmatter)]\n\n// check that we limit fence lengths\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-too-many-dashes.stderr", "content": "[ERROR] too many `-` symbols: frontmatter openings may be delimited by up to 255 `-` symbols, but found 256\n --> script:1:1\n |\n1 | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-1.rs", "content": "----cargo\n//~^ ERROR: unclosed frontmatter\n\n// This test checks that the #! characters can help us recover a frontmatter\n// close. There should not be a \"missing `main` function\" error as the rest\n// are properly parsed.\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-1.stderr", "content": "[ERROR] unclosed frontmatter; expected `----`\n --> script:10:14\n |\n 1 | ----cargo\n...\n10 | fn main() {}\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-2.rs", "content": "----cargo\n//~^ ERROR: unclosed frontmatter\n//~| ERROR: frontmatters are experimental\n\n//@ compile-flags: --crate-type lib\n\n// Leading whitespace on the feature line prevents recovery. However\n// the dashes quoted will not be used for recovery and the entire file\n// should be treated as within the frontmatter block.\n\n #![feature(frontmatter)]\n\nfn foo() -> &str {\n \"----\"\n}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-2.stderr", "content": "[ERROR] unclosed frontmatter; expected `----`\n --> script:15:3\n |\n 1 | ----cargo\n...\n15 | }\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-3.rs", "content": "----cargo\n//~^ ERROR: frontmatter close does not match the opening\n\n//@ compile-flags: --crate-type lib\n\n// Unfortunate recovery situation. Not really preventable with improving the\n// recovery strategy, but this type of code is rare enough already.\n\n #![feature(frontmatter)]\n\nfn foo(x: i32) -> i32 {\n ---x\n //~^ ERROR: invalid preceding whitespace for frontmatter close\n //~| ERROR: extra characters after frontmatter close are not allowed\n}\n//~^ ERROR: unexpected closing delimiter: `}`\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-3.stderr", "content": "[ERROR] unclosed frontmatter; expected `----`\n --> script:16:47\n |\n 1 | ----cargo\n...\n16 | //~^ ERROR: unexpected closing delimiter: `}`\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-4.rs", "content": "----cargo\n//~^ ERROR: unclosed frontmatter\n\n//! Similarly, a module-level content should allow for recovery as well (as\n//! per unclosed-1.rs)\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-4.stderr", "content": "[ERROR] unclosed frontmatter; expected `----`\n --> script:9:14\n |\n 1 | ----cargo\n...\n 9 | fn main() {}\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-5.rs", "content": "----cargo\n//~^ ERROR: unclosed frontmatter\n//~| ERROR: frontmatters are experimental\n\n// Similarly, a use statement should allow for recovery as well (as\n// per unclosed-1.rs)\n\nuse std::env;\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-5.stderr", "content": "[ERROR] unclosed frontmatter; expected `----`\n --> script:10:14\n |\n 1 | ----cargo\n...\n10 | fn main() {}\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-6.rs", "content": "---\n//~^ ERROR unclosed frontmatter\nšŸ¦€---\n ---\n\n// This test checks the location of the --- recovered by the parser is not\n// incorrectly tracked during the less fortunate recovery case and multiple\n// candidates are found, as seen with #146847\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-unclosed-6.stderr", "content": "[ERROR] unclosed frontmatter; expected `---`\n --> script:12:14\n |\n 1 | ---\n...\n12 | fn main() {}\n | ^\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-whitespace-trailing-1.rs", "content": "\n\n---cargo \t\n--- \t\n\n// please note the whitespace characters after the first four lines.\n// This ensures that we accept whitespaces before the frontmatter, after\n// the frontmatter opening and the frontmatter close.\n\n//@ check-pass\n// ignore-tidy-end-whitespace\n// ignore-tidy-leading-newlines\n// ignore-tidy-tab\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-whitespace-trailing-1.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-whitespace-trailing-2.rs", "content": "--- \tcargo\n---\n\n//@ check-pass\n// ignore-tidy-tab\n// A frontmatter infostring can have leading whitespace.\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/fence-whitespace-trailing-2.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/frontmatter-crlf.rs", "content": "#!/usr/bin/env -S cargo -Zscript\r\n---\r\n[dependencies]\r\nclap = \"4\"\r\n---\r\n\r\n//@ check-pass\r\n// ignore-tidy-cr\r\n\r\n// crlf line endings should be accepted\r\n\r\n#![feature(frontmatter)]\r\n\r\nfn main() {}\r\n" }, { "path": "tests/testsuite/script/rustc_fixtures/frontmatter-crlf.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [\n {\n \"features\": [],\n \"kind\": null,\n \"name\": \"clap\",\n \"optional\": false,\n \"registry\": null,\n \"rename\": null,\n \"req\": \"^4\",\n \"source\": \"registry+https://github.com/rust-lang/crates.io-index\",\n \"target\": null,\n \"uses_default_features\": true\n }\n ],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-comma.rs", "content": "---cargo,clippy\n//~^ ERROR: invalid infostring for frontmatter\n---\n\n// infostrings can only be a single identifier.\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-comma.stderr", "content": "[ERROR] unsupported frontmatter infostring attributes: `clippy`\n --> script:1:4\n |\n1 | ---cargo,clippy\n | ^^^^^^^^^^^^\n2 | //~^ ERROR: invalid infostring for frontmatter\n3 | ---\n |\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-dot-leading.rs", "content": "---.toml\n//~^ ERROR: invalid infostring for frontmatter\n---\n\n// infostrings cannot have leading dots\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-dot-leading.stderr", "content": "[ERROR] unsupported frontmatter infostring `.toml`; specify `cargo` for embedding a manifest\n --> script:1:4\n |\n1 | ---.toml\n | ^^^^^\n2 | //~^ ERROR: invalid infostring for frontmatter\n3 | ---\n |\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-dot-nonleading.rs", "content": "---Cargo.toml\n---\n\n// infostrings can contain dots as long as a dot isn't the first character.\n//@ check-pass\n// CARGO(fail): unsupported infostring\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-dot-nonleading.stderr", "content": "[ERROR] unsupported frontmatter infostring `Cargo.toml`; specify `cargo` for embedding a manifest\n --> script:1:4\n |\n1 | ---Cargo.toml\n | ^^^^^^^^^^\n2 | ---\n |\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-hyphen-leading.rs", "content": "--- -toml\n//~^ ERROR: invalid infostring for frontmatter\n---\n\n// infostrings cannot have leading hyphens\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-hyphen-leading.stderr", "content": "[ERROR] unsupported frontmatter infostring `-toml`; specify `cargo` for embedding a manifest\n --> script:1:5\n |\n1 | --- -toml\n | ^^^^^\n2 | //~^ ERROR: invalid infostring for frontmatter\n3 | ---\n |\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-hyphen-nonleading.rs", "content": "--- Cargo-toml\n---\n\n// infostrings can contain hyphens as long as a hyphen isn't the first character.\n//@ check-pass\n// CARGO(fail): unsupported infostring\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-hyphen-nonleading.stderr", "content": "[ERROR] unsupported frontmatter infostring `Cargo-toml`; specify `cargo` for embedding a manifest\n --> script:1:5\n |\n1 | --- Cargo-toml\n | ^^^^^^^^^^\n2 | ---\n |\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-space.rs", "content": "--- cargo clippy\n//~^ ERROR: invalid infostring for frontmatter\n---\n\n// infostrings cannot have spaces\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/infostring-space.stderr", "content": "[ERROR] unsupported frontmatter infostring `cargo clippy`; specify `cargo` for embedding a manifest\n --> script:1:5\n |\n1 | --- cargo clippy\n | ^^^^^^^^^^^^\n2 | //~^ ERROR: invalid infostring for frontmatter\n3 | ---\n |\n" }, { "path": "tests/testsuite/script/rustc_fixtures/location-after-shebang.rs", "content": "#!/usr/bin/env -S cargo -Zscript\n---\n[dependencies]\nclap = \"4\"\n---\n\n//@ check-pass\n\n// Shebangs on a file can precede a frontmatter.\n\n#![feature(frontmatter)]\n\nfn main () {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/location-after-shebang.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [\n {\n \"features\": [],\n \"kind\": null,\n \"name\": \"clap\",\n \"optional\": false,\n \"registry\": null,\n \"rename\": null,\n \"req\": \"^4\",\n \"source\": \"registry+https://github.com/rust-lang/crates.io-index\",\n \"target\": null,\n \"uses_default_features\": true\n }\n ],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/location-after-tokens.rs", "content": "#![feature(frontmatter)]\n\n---\n//~^ ERROR: expected item, found `-`\n// FIXME(frontmatter): make this diagnostic better\n---\n\n// frontmatters must be at the start of a file. This test ensures that.\n// CARGO(pass): not technitcally a frontmatter, so defer to rustc to error\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/location-after-tokens.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/location-include-in-expr-ctxt.rs", "content": "// Check that an expr-ctxt `include` doesn't try to parse frontmatter and instead\n// treats it as a regular Rust token sequence.\n//@ check-pass\n#![expect(double_negations)]\n\nfn main() {\n // issue: \n const _: () = assert!(-1 == include!(\"auxiliary/expr.rs\"));\n}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/location-include-in-expr-ctxt.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/location-include-in-item-ctxt.rs", "content": "// Ensure that in item ctxts we can `include` files that contain frontmatter.\n//@ check-pass\n\n#![feature(frontmatter)]\n\ninclude!(\"auxiliary/lib.rs\");\n\nfn main() {\n foo(1);\n}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/location-include-in-item-ctxt.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/location-proc-macro-observer.rs", "content": "//@ check-pass\n//@ proc-macro: makro.rs\n//@ edition: 2021\n//@ ignore-backends: gcc\n\n// Check that a proc-macro doesn't try to parse frontmatter and instead treats\n// it as a regular Rust token sequence. See `auxiliary/makro.rs` for details.\n\nmakro::check!();\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/location-proc-macro-observer.stdout", "content": "{\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2024\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo/script#0.0.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/script\",\n \"metadata\": null,\n \"name\": \"script\",\n \"publish\": [],\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": true,\n \"doctest\": false,\n \"edition\": \"2024\",\n \"kind\": [\n \"bin\"\n ],\n \"name\": \"script\",\n \"src_path\": \"[ROOT]/foo/script\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.0\"\n}" }, { "path": "tests/testsuite/script/rustc_fixtures/multifrontmatter.rs", "content": "---\n---\n\n---\n//~^ ERROR: expected item, found `-`\n// FIXME(frontmatter): make this diagnostic better\n---\n\n// test that we do not parse another frontmatter block after the first one.\n\n#![feature(frontmatter)]\n\nfn main() {}\n" }, { "path": "tests/testsuite/script/rustc_fixtures/multifrontmatter.stderr", "content": "[ERROR] only one frontmatter is supported\n --> script:4:1\n |\n1 | ---\n2 | ---\n3 |\n4 | ---\n | ^^^\n" }, { "path": "tests/testsuite/search.rs", "content": "//! Tests for the `cargo search` command.\n\nuse crate::prelude::*;\nuse crate::utils::cargo_process;\nuse cargo_test_support::registry::{RegistryBuilder, Response};\nuse cargo_test_support::str;\n\nconst SEARCH_API_RESPONSE: &[u8] = br#\"\n{\n \"crates\": [{\n \"created_at\": \"2014-11-16T20:17:35Z\",\n \"description\": \"Design by contract style assertions for Rust\",\n \"documentation\": null,\n \"downloads\": 2,\n \"homepage\": null,\n \"id\": \"hoare\",\n \"keywords\": [],\n \"license\": null,\n \"links\": {\n \"owners\": \"/api/v1/crates/hoare/owners\",\n \"reverse_dependencies\": \"/api/v1/crates/hoare/reverse_dependencies\",\n \"version_downloads\": \"/api/v1/crates/hoare/downloads\",\n \"versions\": \"/api/v1/crates/hoare/versions\"\n },\n \"max_version\": \"0.1.1\",\n \"name\": \"hoare\",\n \"repository\": \"https://github.com/nick29581/libhoare\",\n \"updated_at\": \"2014-11-20T21:49:21Z\",\n \"versions\": null\n },\n {\n \"id\": \"postgres\",\n \"name\": \"postgres\",\n \"updated_at\": \"2020-05-01T23:17:54.335921+00:00\",\n \"versions\": null,\n \"keywords\": null,\n \"categories\": null,\n \"badges\": [\n {\n \"badge_type\": \"circle-ci\",\n \"attributes\": {\n \"repository\": \"sfackler/rust-postgres\",\n \"branch\": null\n }\n }\n ],\n \"created_at\": \"2014-11-24T02:34:44.756689+00:00\",\n \"downloads\": 535491,\n \"recent_downloads\": 88321,\n \"max_version\": \"0.17.3\",\n \"newest_version\": \"0.17.3\",\n \"description\": \"A native, synchronous PostgreSQL client\",\n \"homepage\": null,\n \"documentation\": null,\n \"repository\": \"https://github.com/sfackler/rust-postgres\",\n \"links\": {\n \"version_downloads\": \"/api/v1/crates/postgres/downloads\",\n \"versions\": \"/api/v1/crates/postgres/versions\",\n \"owners\": \"/api/v1/crates/postgres/owners\",\n \"owner_team\": \"/api/v1/crates/postgres/owner_team\",\n \"owner_user\": \"/api/v1/crates/postgres/owner_user\",\n \"reverse_dependencies\": \"/api/v1/crates/postgres/reverse_dependencies\"\n },\n \"exact_match\": true\n }\n ],\n \"meta\": {\n \"total\": 2\n }\n}\"#;\n\nconst SEARCH_RESULTS: &str = \"\\\nhoare = \\\"0.1.1\\\" # Design by contract style assertions for Rust\npostgres = \\\"0.17.3\\\" # A native, synchronous PostgreSQL client\n\";\n\n#[must_use]\nfn setup() -> RegistryBuilder {\n RegistryBuilder::new()\n .http_api()\n .add_responder(\"/api/v1/crates\", |_, _| Response {\n code: 200,\n headers: vec![],\n body: SEARCH_API_RESPONSE.to_vec(),\n })\n}\n\n#[cargo_test]\nfn not_update() {\n let registry = setup().build();\n\n cargo_process(\"search postgres\")\n .replace_crates_io(registry.index_url())\n .with_stdout_data(SEARCH_RESULTS)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[NOTE] to learn more about a package, run `cargo info `\n\n\"#]])\n .run();\n\n cargo_process(\"search postgres\")\n .replace_crates_io(registry.index_url())\n .with_stdout_data(SEARCH_RESULTS)\n // without \"Updating ... index\"\n .with_stderr_data(str![[r#\"\n[NOTE] to learn more about a package, run `cargo info `\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn replace_default() {\n let registry = setup().build();\n\n cargo_process(\"search postgres\")\n .replace_crates_io(registry.index_url())\n .with_stdout_data(SEARCH_RESULTS)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[NOTE] to learn more about a package, run `cargo info `\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn simple() {\n let registry = setup().build();\n\n cargo_process(\"search postgres --index\")\n .arg(registry.index_url().as_str())\n .with_stdout_data(SEARCH_RESULTS)\n .with_stderr_data(str![[r#\"\n[UPDATING] `[ROOT]/registry` index\n[NOTE] to learn more about a package, run `cargo info `\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn multiple_query_params() {\n let registry = setup().build();\n\n cargo_process(\"search postgres sql --index\")\n .arg(registry.index_url().as_str())\n .with_stdout_data(SEARCH_RESULTS)\n .with_stderr_data(str![[r#\"\n[UPDATING] `[ROOT]/registry` index\n[NOTE] to learn more about a package, run `cargo info `\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn ignore_quiet() {\n let registry = setup().build();\n\n cargo_process(\"search -q postgres\")\n .replace_crates_io(registry.index_url())\n .with_stdout_data(SEARCH_RESULTS)\n .run();\n}\n\n#[cargo_test]\nfn colored_results() {\n let registry = setup().build();\n\n cargo_process(\"search --color=never postgres\")\n .replace_crates_io(registry.index_url())\n .with_stdout_does_not_contain(\"[..]\\x1b[[..]\")\n .run();\n\n cargo_process(\"search --color=always postgres\")\n .replace_crates_io(registry.index_url())\n .with_stdout_data(\n \"\\\n...\n[..]\\x1b[[..]\n...\n\",\n )\n .run();\n}\n\n#[cargo_test]\nfn auth_required_failure() {\n let server = setup().auth_required().no_configure_token().build();\n\n cargo_process(\"search postgres\")\n .replace_crates_io(server.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[ERROR] no token found, please run `cargo login`\nor use environment variable CARGO_REGISTRY_TOKEN\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn auth_required() {\n let server = setup().auth_required().build();\n\n cargo_process(\"search postgres\")\n .replace_crates_io(server.index_url())\n .with_stdout_data(SEARCH_RESULTS)\n .run();\n}\n" }, { "path": "tests/testsuite/shell_quoting.rs", "content": "//! This file tests that when the commands being run are shown\n//! in the output, their arguments are quoted properly\n//! so that the command can be run in a terminal.\n\nuse crate::prelude::*;\nuse cargo_test_support::project;\nuse cargo_test_support::str;\n\n#[cargo_test]\nfn features_are_quoted() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n authors = [\"mikeyhew@example.com\"]\n edition = \"2015\"\n\n [features]\n some_feature = []\n default = [\"some_feature\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {error}\")\n .build();\n\n p.cargo(\"check -v\")\n .env(\"MSYSTEM\", \"1\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] --cfg 'feature=\"default\"' --cfg 'feature=\"some_feature\"' [..]`\n...\n[ERROR] could not compile `foo` (bin \"foo\") due to 1 previous error\n\nCaused by:\n process didn't exit successfully: [..] --cfg 'feature=\"default\"' --cfg 'feature=\"some_feature\"' [..]\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/source_replacement.rs", "content": "//! Tests for `[source]` table (source replacement).\n\nuse std::fs;\n\nuse crate::prelude::*;\nuse crate::utils::cargo_process;\nuse cargo_test_support::registry::{Package, RegistryBuilder, TestRegistry};\nuse cargo_test_support::{paths, project, str, t};\n\nfn setup_replacement(config: &str) -> TestRegistry {\n let crates_io = RegistryBuilder::new()\n .no_configure_registry()\n .http_api()\n .build();\n\n let root = paths::root();\n t!(fs::create_dir(&root.join(\".cargo\")));\n t!(fs::write(root.join(\".cargo/config.toml\"), config,));\n crates_io\n}\n\n#[cargo_test]\nfn crates_io_token_not_sent_to_replacement() {\n // verifies that the crates.io token is not sent to a replacement registry during publish.\n let crates_io = setup_replacement(\n r#\"\n [source.crates-io]\n replace-with = 'alternative'\n \"#,\n );\n let _alternative = RegistryBuilder::new()\n .alternative()\n .http_api()\n .no_configure_token()\n .build();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish --no-verify --registry crates-io\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn token_sent_to_correct_registry() {\n // verifies that the crates.io token is not sent to a replacement registry during yank.\n let crates_io = setup_replacement(\n r#\"\n [source.crates-io]\n replace-with = 'alternative'\n \"#,\n );\n let _alternative = RegistryBuilder::new().alternative().http_api().build();\n\n cargo_process(\"yank foo@0.0.1 --registry crates-io\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[YANK] foo@0.0.1\n\n\"#]])\n .run();\n\n cargo_process(\"yank foo@0.0.1 --registry alternative\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[YANK] foo@0.0.1\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn ambiguous_registry() {\n // verifies that an error is issued when a source-replacement is configured\n // and no --registry argument is given.\n let crates_io = setup_replacement(\n r#\"\n [source.crates-io]\n replace-with = 'alternative'\n \"#,\n );\n let _alternative = RegistryBuilder::new()\n .alternative()\n .http_api()\n .no_configure_token()\n .build();\n\n cargo_process(\"yank foo@0.0.1\")\n .replace_crates_io(crates_io.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] crates-io is replaced with remote registry alternative;\ninclude `--registry alternative` or `--registry crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn yank_with_default_crates_io() {\n // verifies that no error is given when registry.default is used.\n let crates_io = setup_replacement(\n r#\"\n [source.crates-io]\n replace-with = 'alternative'\n\n [registry]\n default = 'crates-io'\n \"#,\n );\n let _alternative = RegistryBuilder::new().alternative().http_api().build();\n\n cargo_process(\"yank foo@0.0.1\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[YANK] foo@0.0.1\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn yank_with_default_alternative() {\n // verifies that no error is given when registry.default is an alt registry.\n let crates_io = setup_replacement(\n r#\"\n [source.crates-io]\n replace-with = 'alternative'\n\n [registry]\n default = 'alternative'\n \"#,\n );\n let _alternative = RegistryBuilder::new().alternative().http_api().build();\n\n cargo_process(\"yank foo@0.0.1\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[YANK] foo@0.0.1\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_with_replacement() {\n // verifies that the crates.io token is not sent to a replacement registry during publish.\n let crates_io = setup_replacement(\n r#\"\n [source.crates-io]\n replace-with = 'alternative'\n \"#,\n );\n let _alternative = RegistryBuilder::new()\n .alternative()\n .http_api()\n .no_configure_token()\n .build();\n\n // Publish bar only to alternative. This tests that the publish verification build\n // does uses the source replacement.\n Package::new(\"bar\", \"1.0.0\").alternative(true).publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n // Verifies that the crates.io index is used to find the publishing endpoint\n // and that the crate is sent to crates.io. The source replacement is only used\n // for the verification step.\n p.cargo(\"publish --registry crates-io\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[WARNING] manifest has no documentation, homepage or repository\n |\n = [NOTE] see https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info\n[PACKAGING] foo v0.0.1 ([ROOT]/foo)\n[UPDATING] `alternative` index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.0.1 ([ROOT]/foo)\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `alternative`)\n[COMPILING] bar v1.0.0\n[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.0.1 ([ROOT]/foo)\n[UPLOADED] foo v0.0.1 to registry `crates-io`\n[NOTE] waiting for foo v0.0.1 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.0.1 at registry `crates-io`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn undefined_default() {\n // verifies that no error is given when registry.default is used.\n let crates_io = setup_replacement(\n r#\"\n [registry]\n default = 'undefined'\n \"#,\n );\n\n cargo_process(\"yank foo@0.0.1\")\n .replace_crates_io(crates_io.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] registry index was not found in any configuration: `undefined`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn source_replacement_with_registry_url() {\n let alternative = RegistryBuilder::new().alternative().http_api().build();\n Package::new(\"bar\", \"0.0.1\").alternative(true).publish();\n\n let crates_io = setup_replacement(&format!(\n r#\"\n [source.crates-io]\n replace-with = 'using-registry-url'\n\n [source.using-registry-url]\n registry = '{}'\n \"#,\n alternative.index_url()\n ));\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n [dependencies.bar]\n version = \"0.0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .replace_crates_io(crates_io.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] `using-registry-url` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `using-registry-url`)\n[CHECKING] bar v0.0.1\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn source_replacement_with_no_package_in_directory() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n\n [dependencies]\n bar = { version = \"^0.8.9\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n let root = paths::root();\n t!(fs::create_dir(&root.join(\"vendor\")));\n\n let crates_io = setup_replacement(&format!(\n r#\"\n [source.crates-io]\n replace-with = \"vendored-sources\"\n\n [source.vendored-sources]\n directory = \"vendor\"\n \"#\n ));\n\n p.cargo(\"build\")\n .replace_crates_io(crates_io.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no matching package named `bar` found\nlocation searched: directory source `[ROOT]/vendor` (which is replacing registry `crates-io`)\nrequired by package `foo v0.1.0 ([ROOT]/foo)`\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/ssh.rs", "content": "//! Network tests for SSH connections.\n//!\n//! Note that these tests will generally require setting `CARGO_CONTAINER_TESTS`\n//! or `CARGO_PUBLIC_NETWORK_TESTS`.\n//!\n//! NOTE: The container tests almost certainly won't work on Windows.\n\nuse std::fs;\nuse std::io::Write;\nuse std::path::PathBuf;\n\nuse crate::prelude::*;\nuse cargo_test_support::containers::{Container, ContainerHandle, MkFile};\nuse cargo_test_support::git::cargo_uses_gitoxide;\nuse cargo_test_support::{Project, paths, process, project, str};\n\nfn ssh_repo_url(container: &ContainerHandle, name: &str) -> String {\n let port = container.port_mappings[&22];\n format!(\"ssh://testuser@127.0.0.1:{port}/repos/{name}.git\")\n}\n\n/// The path to the client's private key.\nfn key_path() -> PathBuf {\n paths::home().join(\".ssh/id_ed25519\")\n}\n\n/// Generates the SSH keys for authenticating into the container.\nfn gen_ssh_keys() -> String {\n let path = key_path();\n process(\"ssh-keygen\")\n .args(&[\"-t\", \"ed25519\", \"-N\", \"\", \"-f\"])\n .arg(&path)\n .exec_with_output()\n .unwrap();\n let pub_key = path.with_extension(\"pub\");\n fs::read_to_string(pub_key).unwrap()\n}\n\n/// Handler for running ssh-agent for SSH authentication.\n///\n/// Be sure to set `SSH_AUTH_SOCK` when running a process in order to use the\n/// agent. Keys will need to be copied into the container with the\n/// `authorized_keys()` method.\nstruct Agent {\n sock: PathBuf,\n pid: String,\n ssh_dir: PathBuf,\n pub_key: String,\n}\n\nimpl Agent {\n fn launch() -> Agent {\n let ssh_dir = paths::home().join(\".ssh\");\n fs::create_dir(&ssh_dir).unwrap();\n let pub_key = gen_ssh_keys();\n\n let sock = paths::root().join(\"agent\");\n let output = process(\"ssh-agent\")\n .args(&[\"-s\", \"-a\"])\n .arg(&sock)\n .exec_with_output()\n .unwrap();\n let stdout = std::str::from_utf8(&output.stdout).unwrap();\n let start = stdout.find(\"SSH_AGENT_PID=\").unwrap() + 14;\n let end = &stdout[start..].find(';').unwrap();\n let pid = (&stdout[start..start + end]).to_string();\n eprintln!(\"SSH_AGENT_PID={pid}\");\n process(\"ssh-add\")\n .arg(key_path())\n .env(\"SSH_AUTH_SOCK\", &sock)\n .exec_with_output()\n .unwrap();\n Agent {\n sock,\n pid,\n ssh_dir,\n pub_key,\n }\n }\n\n /// Returns a `MkFile` which can be passed into the `Container` builder to\n /// copy an `authorized_keys` file containing this agent's public key.\n fn authorized_keys(&self) -> MkFile {\n MkFile::path(\"home/testuser/.ssh/authorized_keys\")\n .contents(self.pub_key.as_bytes())\n .mode(0o600)\n .uid(100)\n .gid(101)\n }\n}\n\nimpl Drop for Agent {\n fn drop(&mut self) {\n if let Err(e) = process(\"ssh-agent\")\n .args(&[\"-k\", \"-a\"])\n .arg(&self.sock)\n .env(\"SSH_AGENT_PID\", &self.pid)\n .exec_with_output()\n {\n eprintln!(\"failed to stop ssh-agent: {e:?}\");\n }\n }\n}\n\n/// Common project used for several tests.\nfn foo_bar_project(url: &str) -> Project {\n project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = {{ git = \"{url}\" }}\n \"#\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build()\n}\n\n#[cargo_test(container_test)]\nfn no_known_host() {\n // When host is not known, it should show an error.\n let sshd = Container::new(\"sshd\").launch();\n let url = ssh_repo_url(&sshd, \"bar\");\n let p = foo_bar_project(&url);\n p.cargo(\"fetch\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `ssh://testuser@127.0.0.1:[..]/repos/bar.git`\n[ERROR] failed to get `bar` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `bar`\n\nCaused by:\n unable to update ssh://testuser@127.0.0.1:[..]/repos/bar.git\n\nCaused by:\n failed to clone into: [ROOT]/home/.cargo/git/db/bar-[HASH]\n\nCaused by:\n [ERROR] unknown SSH host key\n The SSH host key for `[127.0.0.1]:[..]` is not known and cannot be validated.\n\n To resolve this issue, add the host key to the `net.ssh.known-hosts` array in your Cargo configuration (such as [ROOT]/home/.cargo/config.toml) or in your OpenSSH known_hosts file at [ROOT]/home/.ssh/known_hosts\n\n The key to add is:\n\n [127.0.0.1]:[..] ecdsa-sha2-nistp256 AAAA[..]\n\n The ECDSA key fingerprint is: SHA256:[..]\n This fingerprint should be validated with the server administrator that it is correct.\n\n See https://doc.rust-lang.org/stable/cargo/appendix/git-authentication.html#ssh-known-hosts for more information.\n\n\"#]])\n .run();\n}\n\n#[cargo_test(container_test)]\nfn known_host_works() {\n // The key displayed in the error message should work when added to known_hosts.\n let agent = Agent::launch();\n let sshd = Container::new(\"sshd\")\n .file(agent.authorized_keys())\n .launch();\n let url = ssh_repo_url(&sshd, \"bar\");\n let p = foo_bar_project(&url);\n let output = p\n .cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &agent.sock)\n .build_command()\n .output()\n .unwrap();\n let stderr = std::str::from_utf8(&output.stderr).unwrap();\n\n // Validate the fingerprint while we're here.\n let fingerprint = stderr\n .lines()\n .find_map(|line| line.strip_prefix(\" The ECDSA key fingerprint is: \"))\n .unwrap()\n .trim();\n let finger_out = sshd.exec(&[\"ssh-keygen\", \"-l\", \"-f\", \"/etc/ssh/ssh_host_ecdsa_key.pub\"]);\n let gen_finger = std::str::from_utf8(&finger_out.stdout).unwrap();\n // \n let gen_finger = gen_finger.split_whitespace().nth(1).unwrap();\n assert_eq!(fingerprint, gen_finger);\n\n // Add the key to known_hosts, and try again.\n let key = stderr\n .lines()\n .find(|line| line.starts_with(\" [127.0.0.1]:\"))\n .unwrap()\n .trim();\n fs::write(agent.ssh_dir.join(\"known_hosts\"), key).unwrap();\n p.cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &agent.sock)\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `ssh://testuser@127.0.0.1:[..]/repos/bar.git`\n[LOCKING] 1 package to latest compatible version\n\n\"#]])\n .run();\n}\n\n#[cargo_test(container_test)]\nfn same_key_different_hostname() {\n // The error message should mention if an identical key was found.\n let agent = Agent::launch();\n let sshd = Container::new(\"sshd\").launch();\n\n let hostkey = sshd.read_file(\"/etc/ssh/ssh_host_ecdsa_key.pub\");\n let known_hosts = format!(\"example.com {hostkey}\");\n fs::write(agent.ssh_dir.join(\"known_hosts\"), known_hosts).unwrap();\n\n let url = ssh_repo_url(&sshd, \"bar\");\n let p = foo_bar_project(&url);\n p.cargo(\"fetch\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `ssh://testuser@127.0.0.1:[..]/repos/bar.git`\n[ERROR] failed to get `bar` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `bar`\n\nCaused by:\n unable to update ssh://testuser@127.0.0.1:[..]/repos/bar.git\n\nCaused by:\n failed to clone into: [ROOT]/home/.cargo/git/db/bar-[HASH]\n\nCaused by:\n [ERROR] unknown SSH host key\n The SSH host key for `[127.0.0.1]:[..]` is not known and cannot be validated.\n\n To resolve this issue, add the host key to the `net.ssh.known-hosts` array in your Cargo configuration (such as [ROOT]/home/.cargo/config.toml) or in your OpenSSH known_hosts file at [ROOT]/home/.ssh/known_hosts\n\n The key to add is:\n\n [127.0.0.1]:[..] ecdsa-sha2-nistp256 AAAA[..]\n\n The ECDSA key fingerprint is: SHA256:[..]\n This fingerprint should be validated with the server administrator that it is correct.\n Note: This host key was found, but is associated with a different host:\n [ROOT]/home/.ssh/known_hosts line 1: example.com\n\n See https://doc.rust-lang.org/stable/cargo/appendix/git-authentication.html#ssh-known-hosts for more information.\n\n\"#]])\n .run();\n}\n\n#[cargo_test(container_test)]\nfn known_host_without_port() {\n // A known_host entry without a port should match a connection to a non-standard port.\n let agent = Agent::launch();\n let sshd = Container::new(\"sshd\")\n .file(agent.authorized_keys())\n .launch();\n\n let hostkey = sshd.read_file(\"/etc/ssh/ssh_host_ecdsa_key.pub\");\n // The important part of this test is that this line does not have a port.\n let known_hosts = format!(\"127.0.0.1 {hostkey}\");\n fs::write(agent.ssh_dir.join(\"known_hosts\"), known_hosts).unwrap();\n let url = ssh_repo_url(&sshd, \"bar\");\n let p = foo_bar_project(&url);\n p.cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &agent.sock)\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `ssh://testuser@127.0.0.1:[..]/repos/bar.git`\n[LOCKING] 1 package to latest compatible version\n\n\"#]])\n .run();\n}\n\n#[cargo_test(container_test)]\nfn hostname_case_insensitive() {\n // hostname checking should be case-insensitive.\n let agent = Agent::launch();\n let sshd = Container::new(\"sshd\")\n .file(agent.authorized_keys())\n .launch();\n\n // Consider using `gethostname-rs` instead?\n let hostname = process(\"hostname\").exec_with_output().unwrap();\n let hostname = std::str::from_utf8(&hostname.stdout).unwrap().trim();\n let inv_hostname = if hostname.chars().any(|c| c.is_lowercase()) {\n hostname.to_uppercase()\n } else {\n // There should be *some* chars in the name.\n assert!(hostname.chars().any(|c| c.is_uppercase()));\n hostname.to_lowercase()\n };\n eprintln!(\"converted {hostname} to {inv_hostname}\");\n\n let hostkey = sshd.read_file(\"/etc/ssh/ssh_host_ecdsa_key.pub\");\n let known_hosts = format!(\"{inv_hostname} {hostkey}\");\n fs::write(agent.ssh_dir.join(\"known_hosts\"), known_hosts).unwrap();\n let port = sshd.port_mappings[&22];\n let url = format!(\"ssh://testuser@{hostname}:{port}/repos/bar.git\");\n let p = foo_bar_project(&url);\n p.cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &agent.sock)\n .with_stderr_data(&format!(\n \"\\\n[UPDATING] git repository `ssh://testuser@{hostname}:{port}/repos/bar.git`\n[LOCKING] 1 package to latest compatible version\n\"\n ))\n .run();\n}\n\n#[cargo_test(container_test)]\nfn invalid_key_error() {\n // An error when a known_host value doesn't match.\n let agent = Agent::launch();\n let sshd = Container::new(\"sshd\")\n .file(agent.authorized_keys())\n .launch();\n\n let port = sshd.port_mappings[&22];\n let known_hosts = format!(\n \"[127.0.0.1]:{port} ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBLqLMclVr7MDuaVsm3sEnnq2OrGxTFiHSw90wd6N14BU8xVC9cZldC3rJ58Wmw6bEVKPjk7foNG0lHwS5bCKX+U=\\n\"\n );\n fs::write(agent.ssh_dir.join(\"known_hosts\"), known_hosts).unwrap();\n let url = ssh_repo_url(&sshd, \"bar\");\n let p = foo_bar_project(&url);\n p.cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &agent.sock)\n .with_status(101)\n .with_stderr_data(&format!(\"\\\n[UPDATING] git repository `ssh://testuser@127.0.0.1:{port}/repos/bar.git`\n[ERROR] failed to get `bar` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `bar`\n\nCaused by:\n unable to update ssh://testuser@127.0.0.1:{port}/repos/bar.git\n\nCaused by:\n failed to clone into: [ROOT]/home/.cargo/git/db/bar-[HASH]\n\nCaused by:\n [ERROR] SSH host key has changed for `[127.0.0.1]:{port}`\n *********************************\n * WARNING: HOST KEY HAS CHANGED *\n *********************************\n This may be caused by a man-in-the-middle attack, or the server may have changed its host key.\n\n The ECDSA fingerprint for the key from the remote host is:\n SHA256:[..]\n\n You are strongly encouraged to contact the server administrator for `[127.0.0.1]:{port}` to verify that this new key is correct.\n\n If you can verify that the server has a new key, you can resolve this error by removing the old ecdsa-sha2-nistp256 key for `[127.0.0.1]:{port}` located at [ROOT]/home/.ssh/known_hosts line 1, and adding the new key to the `net.ssh.known-hosts` array in your Cargo configuration (such as [ROOT]/home/.cargo/config.toml) or in your OpenSSH known_hosts file at [ROOT]/home/.ssh/known_hosts\n\n The key provided by the remote host is:\n\n [127.0.0.1]:{port} ecdsa-sha2-nistp256 [..]\n\n See https://doc.rust-lang.org/stable/cargo/appendix/git-authentication.html#ssh-known-hosts for more information.\n\"))\n .run();\n // Add the key, it should work even with the old key left behind.\n let hostkey = sshd.read_file(\"/etc/ssh/ssh_host_ecdsa_key.pub\");\n let known_hosts_path = agent.ssh_dir.join(\"known_hosts\");\n let mut f = fs::OpenOptions::new()\n .append(true)\n .open(known_hosts_path)\n .unwrap();\n write!(f, \"[127.0.0.1]:{port} {hostkey}\").unwrap();\n drop(f);\n p.cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &agent.sock)\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `ssh://testuser@127.0.0.1:[..]/repos/bar.git`\n[LOCKING] 1 package to latest compatible version\n\n\"#]])\n .run();\n}\n\n// For unknown reasons, this test occasionally fails on Windows with a\n// LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE error:\n// failed to start SSH session: Unable to exchange encryption keys; class=Ssh (23)\n#[cargo_test(public_network_test, ignore_windows = \"test is flaky on windows\")]\nfn invalid_github_key() {\n // A key for github.com in known_hosts should override the built-in key.\n // This uses a bogus key which should result in an error.\n let ssh_dir = paths::home().join(\".ssh\");\n fs::create_dir(&ssh_dir).unwrap();\n let known_hosts = \"\\\n github.com ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBLqLMclVr7MDuaVsm3sEnnq2OrGxTFiHSw90wd6N14BU8xVC9cZldC3rJ58Wmw6bEVKPjk7foNG0lHwS5bCKX+U=\\n\\\n github.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDgi+8rMcyFCBq5y7BXrb2aaYGhMjlU3QDy7YDvtNL5KSecYOsaqQHaXr87Bbx0EEkgbhK4kVMkmThlCoNITQS9Vc3zIMQ+Tg6+O4qXx719uCzywl50Tb5tDqPGMj54jcq3VUiu/dvse0yeehyvzoPNWewgGWLx11KI4A4wOwMnc6guhculEWe9DjGEjUQ34lPbmdfu/Hza7ZVu/RhgF/wc43uzXWB2KpMEqtuY1SgRlCZqTASoEtfKZi0AuM7AEdOwE5aTotS4CQZHWimb1bMFpF4DAq92CZ8Jhrm4rWETbO29WmjviCJEA3KNQyd3oA7H9AE9z/22PJaVEmjiZZ+wyLgwyIpOlsnHYNEdGeQMQ4SgLRkARLwcnKmByv1AAxsBW4LI3Os4FpwxVPdXHcBebydtvxIsbtUVkkq99nbsIlnSRFSTvb0alrdzRuKTdWpHtN1v9hagFqmeCx/kJfH76NXYBbtaWZhSOnxfEbhLYuOb+IS4jYzHAIkzy9FjVuk=\\n\\\n ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIEeMB6BUAW6FfvfLxRO3kGASe0yXnrRT4kpqncsup2b2\\n\";\n fs::write(ssh_dir.join(\"known_hosts\"), known_hosts).unwrap();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bitflags = { git = \"ssh://git@github.com/rust-lang/bitflags.git\", tag = \"1.3.2\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"fetch\")\n .with_status(101)\n .with_stderr_data(if cargo_uses_gitoxide() {\n str![[r#\"\n...\n git@github.com: Permission denied (publickey).\n...\n\"#]]\n } else {\n str![[r#\"\n...\n [ERROR] SSH host key has changed for `github.com`\n...\n\"#]]\n })\n .run();\n}\n\n// For unknown reasons, this test occasionally fails on Windows with a\n// LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE error:\n// failed to start SSH session: Unable to exchange encryption keys; class=Ssh (23)\n#[cargo_test(public_network_test, ignore_windows = \"test is flaky on windows\")]\nfn bundled_github_works() {\n // The bundled key for github.com works.\n //\n // Use a bogus auth sock to force an authentication error.\n // On Windows, if the agent service is running, it could allow a\n // successful authentication.\n //\n // If the bundled hostkey did not work, it would result in an \"unknown SSH\n // host key\" instead.\n let bogus_auth_sock = paths::home().join(\"ssh_auth_sock\");\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bitflags = { git = \"ssh://git@github.com/rust-lang/bitflags.git\", tag = \"1.3.2\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n let expected = if cargo_uses_gitoxide() {\n str![[r#\"\n[UPDATING] git repository `ssh://git@github.com/rust-lang/bitflags.git`\n[ERROR] failed to get `bitflags` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `bitflags`\n\nCaused by:\n unable to update ssh://git@github.com/rust-lang/bitflags.git?tag=1.3.2\n\nCaused by:\n failed to clone into: [ROOT]/home/.cargo/git/db/bitflags-[HASH]\n\nCaused by:\n failed to authenticate when downloading repository\n\n * attempted to find username/password via `credential.helper`, but maybe the found credentials were incorrect\n\n if the git CLI succeeds then `net.git-fetch-with-cli` may help here\n https://doc.rust-lang.org/cargo/reference/config.html#netgit-fetch-with-cli\n\nCaused by:\n[CREDENTIAL]s provided for \"ssh://git@github.com/rust-lang/bitflags.git\" were not accepted by the remote\n\nCaused by:\n git@github.com: Permission denied (publickey).\n\n\"#]]\n } else {\n str![[r#\"\n[UPDATING] git repository `ssh://git@github.com/rust-lang/bitflags.git`\n[ERROR] failed to get `bitflags` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `bitflags`\n\nCaused by:\n unable to update ssh://git@github.com/rust-lang/bitflags.git?tag=1.3.2\n\nCaused by:\n failed to clone into: [ROOT]/home/.cargo/git/db/bitflags-[HASH]\n\nCaused by:\n failed to authenticate when downloading repository\n\n * attempted ssh-agent authentication, but no usernames succeeded: `git`\n\n if the git CLI succeeds then `net.git-fetch-with-cli` may help here\n https://doc.rust-lang.org/cargo/reference/config.html#netgit-fetch-with-cli\n\nCaused by:\n no authentication methods succeeded\n\n\"#]]\n };\n p.cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &bogus_auth_sock)\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n\n let expected = if cargo_uses_gitoxide() {\n str![[r#\"\n[UPDATING] git repository `ssh://git@github.com:22/rust-lang/bitflags.git`\n[ERROR] failed to get `bitflags` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `bitflags`\n\nCaused by:\n unable to update ssh://git@github.com:22/rust-lang/bitflags.git?tag=1.3.2\n\nCaused by:\n failed to clone into: [ROOT]/home/.cargo/git/db/bitflags-[HASH]\n\nCaused by:\n failed to authenticate when downloading repository\n\n * attempted to find username/password via `credential.helper`, but maybe the found credentials were incorrect\n\n if the git CLI succeeds then `net.git-fetch-with-cli` may help here\n https://doc.rust-lang.org/cargo/reference/config.html#netgit-fetch-with-cli\n\nCaused by:\n[CREDENTIAL]s provided for \"ssh://git@github.com:22/rust-lang/bitflags.git\" were not accepted by the remote\n\nCaused by:\n git@github.com: Permission denied (publickey).\n\n\"#]]\n } else {\n str![[r#\"\n[UPDATING] git repository `ssh://git@github.com:22/rust-lang/bitflags.git`\n[ERROR] failed to get `bitflags` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `bitflags`\n\nCaused by:\n unable to update ssh://git@github.com:22/rust-lang/bitflags.git?tag=1.3.2\n\nCaused by:\n failed to clone into: [ROOT]/home/.cargo/git/db/bitflags-[HASH]\n\nCaused by:\n failed to authenticate when downloading repository\n\n * attempted ssh-agent authentication, but no usernames succeeded: `git`\n\n if the git CLI succeeds then `net.git-fetch-with-cli` may help here\n https://doc.rust-lang.org/cargo/reference/config.html#netgit-fetch-with-cli\n\nCaused by:\n no authentication methods succeeded\n\n\"#]]\n };\n\n // Explicit :22 should also work with bundled.\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bitflags = { git = \"ssh://git@github.com:22/rust-lang/bitflags.git\", tag = \"1.3.2\" }\n \"#,\n );\n p.cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &bogus_auth_sock)\n .with_status(101)\n .with_stderr_data(expected)\n .run();\n}\n\n#[cargo_test(container_test)]\nfn ssh_key_in_config() {\n // known_host in config works.\n let agent = Agent::launch();\n let sshd = Container::new(\"sshd\")\n .file(agent.authorized_keys())\n .launch();\n let hostkey = sshd.read_file(\"/etc/ssh/ssh_host_ecdsa_key.pub\");\n let url = ssh_repo_url(&sshd, \"bar\");\n let p = foo_bar_project(&url);\n p.change_file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [net.ssh]\n known-hosts = ['127.0.0.1 {}']\n \"#,\n hostkey.trim()\n ),\n );\n p.cargo(\"fetch\")\n .env(\"SSH_AUTH_SOCK\", &agent.sock)\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `ssh://testuser@127.0.0.1:[..]/repos/bar.git`\n[LOCKING] 1 package to latest compatible version\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/standard_lib.rs", "content": "//! Tests for building the standard library (-Zbuild-std).\n//!\n//! These tests all use a \"mock\" standard library so that we don't have to\n//! rebuild the real one. There is a separate integration test `build-std`\n//! which builds the real thing, but that should be avoided if possible.\n\nuse std::path::{Path, PathBuf};\n\nuse crate::prelude::*;\nuse cargo_test_support::ProjectBuilder;\nuse cargo_test_support::cross_compile;\nuse cargo_test_support::registry::{Dependency, Package};\nuse cargo_test_support::{Execs, paths, project, rustc_host, str};\n\nstruct Setup {\n rustc_wrapper: PathBuf,\n real_sysroot: String,\n}\n\nfn setup() -> Setup {\n // Our mock sysroot requires a few packages from crates.io, so make sure\n // they're \"published\" to crates.io. Also edit their code a bit to make sure\n // that they have access to our custom crates with custom apis.\n Package::new(\"registry-dep-using-core\", \"1.0.0\")\n .file(\n \"src/lib.rs\",\n \"\n #![no_std]\n\n #[cfg(feature = \\\"mockbuild\\\")]\n pub fn custom_api() {\n }\n\n #[cfg(not(feature = \\\"mockbuild\\\"))]\n pub fn non_sysroot_api() {\n core::custom_api();\n }\n \",\n )\n .add_dep(Dependency::new(\"rustc-std-workspace-core\", \"*\").optional(true))\n .feature(\"mockbuild\", &[\"rustc-std-workspace-core\"])\n .publish();\n Package::new(\"registry-dep-using-alloc\", \"1.0.0\")\n .file(\n \"src/lib.rs\",\n \"\n #![no_std]\n\n extern crate alloc;\n\n #[cfg(feature = \\\"mockbuild\\\")]\n pub fn custom_api() {\n }\n\n #[cfg(not(feature = \\\"mockbuild\\\"))]\n pub fn non_sysroot_api() {\n core::custom_api();\n alloc::custom_api();\n }\n \",\n )\n .add_dep(Dependency::new(\"rustc-std-workspace-core\", \"*\").optional(true))\n .add_dep(Dependency::new(\"rustc-std-workspace-alloc\", \"*\").optional(true))\n .feature(\n \"mockbuild\",\n &[\"rustc-std-workspace-core\", \"rustc-std-workspace-alloc\"],\n )\n .publish();\n Package::new(\"registry-dep-using-std\", \"1.0.0\")\n .file(\n \"src/lib.rs\",\n \"\n #[cfg(feature = \\\"mockbuild\\\")]\n pub fn custom_api() {\n }\n\n #[cfg(not(feature = \\\"mockbuild\\\"))]\n pub fn non_sysroot_api() {\n std::custom_api();\n }\n \",\n )\n .add_dep(Dependency::new(\"rustc-std-workspace-std\", \"*\").optional(true))\n .feature(\"mockbuild\", &[\"rustc-std-workspace-std\"])\n .publish();\n\n let p = ProjectBuilder::new(paths::root().join(\"rustc-wrapper\"))\n .file(\n \"src/main.rs\",\n &r#\"\n use std::process::Command;\n use std::env;\n fn main() {\n let mut args = env::args().skip(1).collect::>();\n\n let is_sysroot_crate = env::var_os(\"RUSTC_BOOTSTRAP\").is_some();\n if is_sysroot_crate {\n args.push(\"--sysroot\".to_string());\n args.push(env::var(\"REAL_SYSROOT\").unwrap());\n } else if let Some(pos) = args.iter().position(|arg| arg == \"--target\") {\n // build-std target unit\n\n // Set --sysroot only when the target is host\n if args.iter().nth(pos + 1) == Some(&\"__HOST_TARGET__\".to_string()) {\n // This `--sysroot` is here to disable the sysroot lookup,\n // to ensure nothing is required.\n // See https://github.com/rust-lang/wg-cargo-std-aware/issues/31\n // for more information on this.\n args.push(\"--sysroot\".to_string());\n args.push(\"/path/to/nowhere\".to_string());\n }\n } else {\n // host unit, do not use sysroot\n }\n\n let ret = Command::new(&args[0]).args(&args[1..]).status().unwrap();\n std::process::exit(ret.code().unwrap_or(1));\n }\n \"#\n .replace(\"__HOST_TARGET__\", rustc_host()),\n )\n .build();\n p.cargo(\"build\").run();\n\n Setup {\n rustc_wrapper: p.bin(\"foo\"),\n real_sysroot: paths::sysroot(),\n }\n}\n\nfn enable_build_std(e: &mut Execs, setup: &Setup) {\n // First up, force Cargo to use our \"mock sysroot\" which mimics what\n // libstd looks like upstream.\n let root = Path::new(env!(\"CARGO_MANIFEST_DIR\")).join(\"tests/testsuite/mock-std/library\");\n e.env(\"__CARGO_TESTS_ONLY_SRC_ROOT\", &root);\n\n e.masquerade_as_nightly_cargo(&[\"build-std\"]);\n\n // We do various shenanigans to ensure our \"mock sysroot\" actually links\n // with the real sysroot, so we don't have to actually recompile std for\n // each test. Perform all that logic here, namely:\n //\n // * RUSTC_WRAPPER - uses our shim executable built above to control rustc\n // * REAL_SYSROOT - used by the shim executable to swap out to the real\n // sysroot temporarily for some compilations\n // * RUST{,DOC}FLAGS - an extra `-L` argument to ensure we can always load\n // crates from the sysroot, but only indirectly through other crates.\n e.env(\"RUSTC_WRAPPER\", &setup.rustc_wrapper);\n e.env(\"REAL_SYSROOT\", &setup.real_sysroot);\n let libdir = format!(\"/lib/rustlib/{}/lib\", rustc_host());\n e.env(\n \"RUSTFLAGS\",\n format!(\"-Ldependency={}{}\", setup.real_sysroot, libdir),\n );\n e.env(\n \"RUSTDOCFLAGS\",\n format!(\"-Ldependency={}{}\", setup.real_sysroot, libdir),\n );\n}\n\n// Helper methods used in the tests below\ntrait BuildStd: Sized {\n fn build_std(&mut self, setup: &Setup) -> &mut Self;\n fn build_std_arg(&mut self, setup: &Setup, arg: &str) -> &mut Self;\n fn target_host(&mut self) -> &mut Self;\n}\n\nimpl BuildStd for Execs {\n fn build_std(&mut self, setup: &Setup) -> &mut Self {\n enable_build_std(self, setup);\n self.arg(\"-Zbuild-std\");\n self\n }\n\n fn build_std_arg(&mut self, setup: &Setup, arg: &str) -> &mut Self {\n enable_build_std(self, setup);\n self.arg(format!(\"-Zbuild-std={}\", arg));\n self\n }\n\n fn target_host(&mut self) -> &mut Self {\n self.arg(\"--target\").arg(rustc_host());\n self\n }\n}\n\n#[cargo_test(build_std_mock)]\nfn basic() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/main.rs\",\n \"\n fn main() {\n std::custom_api();\n foo::f();\n }\n\n #[test]\n fn smoke_bin_unit() {\n std::custom_api();\n foo::f();\n }\n \",\n )\n .file(\n \"src/lib.rs\",\n \"\n extern crate alloc;\n extern crate proc_macro;\n\n /// ```\n /// foo::f();\n /// ```\n pub fn f() {\n core::custom_api();\n std::custom_api();\n alloc::custom_api();\n proc_macro::custom_api();\n }\n\n #[test]\n fn smoke_lib_unit() {\n std::custom_api();\n f();\n }\n \",\n )\n .file(\n \"tests/smoke.rs\",\n \"\n #[test]\n fn smoke_integration() {\n std::custom_api();\n foo::f();\n }\n \",\n )\n .build();\n\n p.cargo(\"check -v\").build_std(&setup).target_host().run();\n p.cargo(\"build\").build_std(&setup).target_host().run();\n p.cargo(\"run\").build_std(&setup).target_host().run();\n p.cargo(\"test\").build_std(&setup).target_host().run();\n}\n\n#[cargo_test(build_std_mock)]\nfn shared_std_dependency_rebuild() {\n let manifest_dir = std::env::var(\"CARGO_MANIFEST_DIR\").unwrap();\n let setup = setup();\n let p = project()\n .file(\n \"Cargo.toml\",\n format!(\n \"\n [package]\n name = \\\"foo\\\"\n version = \\\"0.1.0\\\"\n edition = \\\"2021\\\"\n\n [build-dependencies]\n dep_test = {{ path = \\\"{}/tests/testsuite/mock-std/dep_test\\\" }}\n \",\n manifest_dir.replace('\\\\', \"/\")\n )\n .as_str(),\n )\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n println!(\"Hello, World!\");\n }\n \"#,\n )\n .file(\n \"build.rs\",\n r#\"\n fn main() {\n println!(\"cargo::rerun-if-changed=build.rs\");\n }\n \"#,\n )\n .build();\n\n p.cargo(\"build -v\")\n .build_std(&setup)\n .target_host()\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `[..] rustc --crate-name dep_test [..]`\n...\n[RUNNING] `[..] rustc --crate-name dep_test [..]`\n...\n\"#]])\n .run();\n\n p.cargo(\"build -v\")\n .build_std(&setup)\n .with_stderr_does_not_contain(str![[r#\"\n ...\n [RUNNING] `[..] rustc --crate-name dep_test [..]`\n ...\n [RUNNING] `[..] rustc --crate-name dep_test [..]`\n ...\n \"#]])\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn simple_lib_std() {\n let setup = setup();\n\n let p = project().file(\"src/lib.rs\", \"\").build();\n p.cargo(\"build -v\")\n .build_std(&setup)\n .target_host()\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `[..] rustc --crate-name std [..]`\n...\n\"#]])\n .run();\n // Check freshness.\n p.change_file(\"src/lib.rs\", \" \");\n p.cargo(\"build -v\")\n .build_std(&setup)\n .target_host()\n .with_stderr_data(str![[r#\"\n...\n[FRESH] std v0.1.0 ([..]/tests/testsuite/mock-std/library/std)\n...\n\"#]])\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn simple_bin_std() {\n let setup = setup();\n\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n p.cargo(\"run -v\").build_std(&setup).target_host().run();\n}\n\n#[cargo_test(build_std_mock)]\nfn lib_nostd() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n #![no_std]\n pub fn foo() {\n assert_eq!(u8::MIN, 0);\n }\n \"#,\n )\n .build();\n p.cargo(\"build -v --lib\")\n .build_std_arg(&setup, \"core\")\n .target_host()\n .with_stderr_does_not_contain(\"[..]libstd[..]\")\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn check_core() {\n let setup = setup();\n\n let p = project()\n .file(\"src/lib.rs\", \"#![no_std] fn unused_fn() {}\")\n .build();\n\n p.cargo(\"check -v\")\n .build_std_arg(&setup, \"core\")\n .target_host()\n .with_stderr_data(str![[r#\"\n...\n[WARNING] function `unused_fn` is never used\n...\n\"#]])\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn build_std_with_no_arg_for_core_only_target() {\n let target = \"aarch64-unknown-none\";\n if !cross_compile::requires_target_installed(target) {\n return;\n }\n\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n #![no_std]\n pub fn foo() {\n assert_eq!(u8::MIN, 0);\n }\n \"#,\n )\n .build();\n\n p.cargo(\"build -v\")\n .arg(\"--target\")\n .arg(target)\n .build_std(&setup)\n .with_stderr_data(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNLOADING] crates ...\n[DOWNLOADED] registry-dep-using-std v1.0.0 (registry `dummy-registry`)\n[DOWNLOADED] registry-dep-using-core v1.0.0 (registry `dummy-registry`)\n[DOWNLOADED] registry-dep-using-alloc v1.0.0 (registry `dummy-registry`)\n[COMPILING] compiler_builtins v0.1.0 ([..]/library/compiler_builtins)\n[COMPILING] core v0.1.0 ([..]/library/core)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `[..] rustc --crate-name build_script_build [..]/compiler_builtins/build.rs [..]`\n[RUNNING] `[ROOT]/foo/target/debug/build/compiler_builtins-[HASH]/build-script-build`\n[RUNNING] `[..] rustc --crate-name compiler_builtins [..]--target aarch64-unknown-none[..]`\n[RUNNING] `[..] rustc --crate-name core [..]--target aarch64-unknown-none[..]`\n[RUNNING] `[..] rustc --crate-name foo [..]--target aarch64-unknown-none[..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(\"clean\").run();\n\n // Also work for a mix of std and core-only targets,\n // though not sure how common it is...\n //\n // Note that we don't download std dependencies for the second call\n // because `-Zbuild-std` downloads them all also when building for core only.\n p.cargo(\"build -v\")\n .arg(\"--target\")\n .arg(target)\n .target_host()\n .build_std(&setup)\n .with_stderr_data(\n str![[r#\"\n[UPDATING] `dummy-registry` index\n[COMPILING] core v0.1.0 ([..]/library/core)\n[COMPILING] dep_test v0.1.0 ([..]/dep_test)\n[COMPILING] compiler_builtins v0.1.0 ([..]/library/compiler_builtins)\n[COMPILING] proc_macro v0.1.0 ([..]/library/proc_macro)\n[COMPILING] panic_unwind v0.1.0 ([..]/library/panic_unwind)\n[COMPILING] rustc-std-workspace-core v1.9.0 ([..]/library/rustc-std-workspace-core)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] registry-dep-using-core v1.0.0\n[COMPILING] alloc v0.1.0 ([..]/library/alloc)\n[COMPILING] rustc-std-workspace-alloc v1.9.0 ([..]/library/rustc-std-workspace-alloc)\n[COMPILING] registry-dep-using-alloc v1.0.0\n[COMPILING] std v0.1.0 ([..]/library/std)\n[RUNNING] `[..] rustc --crate-name build_script_build [..]/compiler_builtins/build.rs [..]`\n[RUNNING] `[ROOT]/foo/target/debug/build/compiler_builtins-[HASH]/build-script-build`\n[RUNNING] `[ROOT]/foo/target/debug/build/compiler_builtins-[HASH]/build-script-build`\n[RUNNING] `[..]rustc --crate-name compiler_builtins [..]--target aarch64-unknown-none[..]`\n[RUNNING] `[..]rustc --crate-name core [..]--target aarch64-unknown-none[..]`\n[RUNNING] `[..]rustc --crate-name foo [..]--target aarch64-unknown-none[..]`\n[RUNNING] `[..]rustc --crate-name core [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name dep_test [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name proc_macro [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name panic_unwind [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name compiler_builtins [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name rustc_std_workspace_core [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name registry_dep_using_core [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name alloc [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name rustc_std_workspace_alloc [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name registry_dep_using_alloc [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name std [..]--target [HOST_TARGET][..]`\n[RUNNING] `[..]rustc --crate-name foo [..]--target [HOST_TARGET][..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn depend_same_as_std() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn f() {\n registry_dep_using_core::non_sysroot_api();\n registry_dep_using_alloc::non_sysroot_api();\n registry_dep_using_std::non_sysroot_api();\n }\n \"#,\n )\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2018\"\n\n [dependencies]\n registry-dep-using-core = \"1.0\"\n registry-dep-using-alloc = \"1.0\"\n registry-dep-using-std = \"1.0\"\n \"#,\n )\n .build();\n\n p.cargo(\"build -v\").build_std(&setup).target_host().run();\n}\n\n#[cargo_test(build_std_mock)]\nfn test() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n #[cfg(test)]\n mod tests {\n #[test]\n fn it_works() {\n assert_eq!(2 + 2, 4);\n }\n }\n \"#,\n )\n .build();\n\n p.cargo(\"test -v\")\n .build_std(&setup)\n .target_host()\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest tests::it_works ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n...\n\"#]])\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn target_proc_macro() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate proc_macro;\n pub fn f() {\n let _ts = proc_macro::TokenStream::new();\n }\n \"#,\n )\n .build();\n\n p.cargo(\"build -v\").build_std(&setup).target_host().run();\n}\n\n#[cargo_test(build_std_mock)]\nfn bench() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n #![feature(test)]\n extern crate test;\n\n #[bench]\n fn b1(b: &mut test::Bencher) {\n b.iter(|| ())\n }\n \"#,\n )\n .build();\n\n p.cargo(\"bench -v\").build_std(&setup).target_host().run();\n}\n\n#[cargo_test(build_std_mock)]\nfn doc() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n /// Doc\n pub fn f() -> Result<(), ()> {Ok(())}\n \"#,\n )\n .build();\n\n p.cargo(\"doc -v\").build_std(&setup).target_host().run();\n}\n\n#[cargo_test(build_std_mock)]\nfn check_std() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n \"\n extern crate core;\n extern crate alloc;\n extern crate proc_macro;\n pub fn f() {}\n \",\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"tests/t1.rs\",\n r#\"\n #[test]\n fn t1() {\n assert_eq!(1, 2);\n }\n \"#,\n )\n .build();\n\n p.cargo(\"check -v --all-targets\")\n .build_std(&setup)\n .target_host()\n .run();\n p.cargo(\"check -v --all-targets --profile=test\")\n .build_std(&setup)\n .target_host()\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn doctest() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n /// Doc\n /// ```\n /// std::custom_api();\n /// ```\n pub fn f() {}\n \"#,\n )\n .build();\n\n p.cargo(\"test --doc -v\")\n .build_std(&setup)\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest src/lib.rs - f (line 3) ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .target_host()\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn no_implicit_alloc() {\n // Demonstrate that alloc is not implicitly in scope.\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn f() {\n let _: Vec = alloc::vec::Vec::new();\n }\n \"#,\n )\n .build();\n\n p.cargo(\"build -v\")\n .build_std(&setup)\n .target_host()\n .with_stderr_data(str![[r#\"\n...\nerror[E0433]: cannot find module or crate `alloc` in this scope\n...\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn macro_expanded_shadow() {\n // This tests a bug caused by the previous use of `--extern` to directly\n // load sysroot crates. This necessitated the switch to `--sysroot` to\n // retain existing behavior. See\n // https://github.com/rust-lang/wg-cargo-std-aware/issues/40 for more\n // detail.\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n macro_rules! a {\n () => (extern crate std as alloc;)\n }\n a!();\n \"#,\n )\n .build();\n\n p.cargo(\"build -v\").build_std(&setup).target_host().run();\n}\n\n#[cargo_test(build_std_mock)]\nfn ignores_incremental() {\n // Incremental is not really needed for std, make sure it is disabled.\n // Incremental also tends to have bugs that affect std libraries more than\n // any other crate.\n let setup = setup();\n\n let p = project().file(\"src/lib.rs\", \"\").build();\n p.cargo(\"build\")\n .env(\"CARGO_INCREMENTAL\", \"1\")\n .build_std(&setup)\n .target_host()\n .run();\n let incremental: Vec<_> = p\n .glob(format!(\"target/{}/debug/incremental/*\", rustc_host()))\n .map(|e| e.unwrap())\n .collect();\n assert_eq!(incremental.len(), 1);\n assert!(\n incremental[0]\n .file_name()\n .unwrap()\n .to_str()\n .unwrap()\n .starts_with(\"foo-\")\n );\n}\n\n#[cargo_test(build_std_mock)]\nfn cargo_config_injects_compiler_builtins() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n #![no_std]\n pub fn foo() {\n assert_eq!(u8::MIN, 0);\n }\n \"#,\n )\n .file(\n \".cargo/config.toml\",\n r#\"\n [unstable]\n build-std = ['core']\n \"#,\n )\n .build();\n let mut build = p.cargo(\"build -v --lib\");\n enable_build_std(&mut build, &setup);\n build\n .target_host()\n .with_stderr_does_not_contain(\"[..]libstd[..]\")\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn different_features() {\n let setup = setup();\n\n let p = project()\n .file(\n \"src/lib.rs\",\n \"\n pub fn foo() {\n std::conditional_function();\n }\n \",\n )\n .build();\n p.cargo(\"build\")\n .build_std(&setup)\n .arg(\"-Zbuild-std-features=feature1\")\n .target_host()\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn no_roots() {\n // Checks for a bug where it would panic if there are no roots.\n let setup = setup();\n\n let p = project().file(\"tests/t1.rs\", \"\").build();\n p.cargo(\"build\")\n .build_std(&setup)\n .target_host()\n .with_stderr_data(str![[r#\"\n...\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn proc_macro_only() {\n // Checks for a bug where it would panic if building a proc-macro only\n let setup = setup();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"pm\"\n version = \"0.1.0\"\n\n [lib]\n proc-macro = true\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"build\")\n .build_std(&setup)\n .target_host()\n .with_stderr_data(str![[r#\"\n...\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn fetch() {\n let setup = setup();\n\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n p.cargo(\"fetch\")\n .build_std(&setup)\n .target_host()\n .with_stderr_contains(\"[DOWNLOADED] [..]\")\n .run();\n p.cargo(\"build\")\n .build_std(&setup)\n .target_host()\n .with_stderr_does_not_contain(\"[DOWNLOADED] [..]\")\n .run();\n}\n\n#[cargo_test(build_std_mock)]\nfn std_build_script_metadata_propagate_to_user() {\n let setup = setup();\n\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n fn main() {\n assert_eq!(std::env::var(\"DEP_COMPILER_RT_COMPILER_RT\").unwrap(), \"foo\");\n }\n \"#,\n )\n .build();\n\n p.cargo(\"check\").build_std(&setup).target_host().run();\n}\n" }, { "path": "tests/testsuite/test.rs", "content": "//! Tests for the `cargo test` command.\n\nuse std::fs;\n\nuse crate::prelude::*;\nuse crate::utils::cargo_exe;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::{basic_bin_manifest, basic_lib_manifest, basic_manifest, project, str};\nuse cargo_test_support::{cross_compile, paths};\nuse cargo_test_support::{rustc_host, rustc_host_env, sleep_ms};\nuse cargo_util::paths::dylib_path_envvar;\n\nuse crate::utils::cross_compile::can_run_on_host as cross_compile_can_run_on_host;\n\n#[cargo_test]\nfn cargo_test_simple() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn hello() -> &'static str {\n \"hello\"\n }\n\n pub fn main() {\n println!(\"{}\", hello())\n }\n\n #[test]\n fn test_hello() {\n assert_eq!(hello(), \"hello\")\n }\n \"#,\n )\n .build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n\n p.process(&p.bin(\"foo\"))\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/main.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test_hello ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_release() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n authors = []\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = { path = \"bar\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate bar;\n pub fn foo() { bar::bar(); }\n\n #[test]\n fn test() { foo(); }\n \"#,\n )\n .file(\n \"tests/test.rs\",\n r#\"\n extern crate foo;\n\n #[test]\n fn test() { foo::foo(); }\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\"bar/src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n p.cargo(\"test -v --release\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] bar v0.0.1 ([ROOT]/foo/bar)\n[RUNNING] `rustc [..]-C opt-level=3 [..]`\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..]-C opt-level=3 [..]`\n[RUNNING] `rustc [..]-C opt-level=3 [..]`\n[RUNNING] `rustc [..]-C opt-level=3 [..]`\n[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/foo/target/release/deps/foo-[HASH][EXE]`\n[RUNNING] `[ROOT]/foo/target/release/deps/test-[HASH][EXE]`\n[DOCTEST] foo\n[RUNNING] `rustdoc [..]--test src/lib.rs[..]`\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest test ... ok\ntest test ... ok\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_overflow_checks() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"foo\"\n\n [profile.release]\n overflow-checks = true\n \"#,\n )\n .file(\n \"src/foo.rs\",\n r#\"\n use std::panic;\n pub fn main() {\n let r = panic::catch_unwind(|| {\n [1, i32::MAX].iter().sum::();\n });\n assert!(r.is_err());\n }\n \"#,\n )\n .build();\n\n p.cargo(\"build --release\").run();\n assert!(p.release_bin(\"foo\").is_file());\n\n p.process(&p.release_bin(\"foo\")).with_stdout_data(\"\").run();\n}\n\n#[cargo_test]\nfn cargo_test_quiet_with_harness() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [[test]]\n name = \"foo\"\n path = \"src/foo.rs\"\n harness = true\n \"#,\n )\n .file(\n \"src/foo.rs\",\n r#\"\n fn main() {}\n #[test] fn test_hello() {}\n \"#,\n )\n .build();\n\n p.cargo(\"test -q\")\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\n.\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .with_stderr_data(\"\")\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_quiet_no_harness() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"foo\"\n test = false\n\n [[test]]\n name = \"foo\"\n path = \"src/main.rs\"\n harness = false\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {}\n #[test] fn test_hello() {}\n \"#,\n )\n .build();\n\n p.cargo(\"test -q\")\n .with_stdout_data(\"\")\n .with_stderr_data(\"\")\n .run();\n}\n\n#[cargo_test]\nfn cargo_doc_test_quiet() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// let result = foo::add(2, 3);\n /// assert_eq!(result, 5);\n /// ```\n pub fn add(a: i32, b: i32) -> i32 {\n a + b\n }\n\n /// ```\n /// let result = foo::div(10, 2);\n /// assert_eq!(result, 5);\n /// ```\n ///\n /// # Panics\n ///\n /// The function panics if the second argument is zero.\n ///\n /// ```rust,should_panic\n /// // panics on division by zero\n /// foo::div(10, 0);\n /// ```\n pub fn div(a: i32, b: i32) -> i32 {\n if b == 0 {\n panic!(\"Divide-by-zero error\");\n }\n\n a / b\n }\n\n #[test] fn test_hello() {}\n \"#,\n )\n .build();\n\n p.cargo(\"test -q\")\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\n.\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\nrunning 3 tests\n...\ntest result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .with_stderr_data(\"\")\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_verbose() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {}\n #[test] fn test_hello() {}\n \"#,\n )\n .build();\n\n p.cargo(\"test -v hello\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] src/main.rs [..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE] hello`\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test_hello ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn many_similar_names() {\n let p = project()\n .file(\n \"src/lib.rs\",\n \"\n pub fn foo() {}\n #[test] fn lib_test() {}\n \",\n )\n .file(\n \"src/main.rs\",\n \"\n extern crate foo;\n fn main() {}\n #[test] fn bin_test() { foo::foo() }\n \",\n )\n .file(\n \"tests/foo.rs\",\n r#\"\n extern crate foo;\n #[test] fn test_test() { foo::foo() }\n \"#,\n )\n .build();\n\n p.cargo(\"test -v\")\n .with_stdout_data(\n str![[r#\"\ntest bin_test ... ok\ntest lib_test ... ok\ntest test_test ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_failing_test_in_bin() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn hello() -> &'static str {\n \"hello\"\n }\n\n pub fn main() {\n println!(\"{}\", hello())\n }\n\n #[test]\n fn test_hello() {\n assert_eq!(hello(), \"nope\", \"NOPE!\")\n }\n \"#,\n )\n .build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n\n p.process(&p.bin(\"foo\"))\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/main.rs (target/debug/deps/foo-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--bin foo`\n\n\"#]])\n .with_stdout_data(\"...\\n[..]NOPE![..]\\n...\")\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_failing_test_in_test() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/main.rs\", r#\"pub fn main() { println!(\"hello\"); }\"#)\n .file(\n \"tests/footest.rs\",\n r#\"#[test] fn test_hello() { assert!(false, \"FALSE!\") }\"#,\n )\n .build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n\n p.process(&p.bin(\"foo\"))\n .with_stdout_data(str![[r#\"\nhello\n\n\"#]])\n .run();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/main.rs (target/debug/deps/foo-[HASH][EXE])\n[RUNNING] tests/footest.rs (target/debug/deps/footest-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--test footest`\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\n...\nrunning 0 tests\n...\nrunning 1 test\ntest test_hello ... FAILED\n...\n[..]FALSE![..]\n...\n\n\"#]]\n .unordered(),\n )\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_failing_test_in_lib() {\n let p = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\n \"src/lib.rs\",\n r#\"#[test] fn test_hello() { assert!(false, \"FALSE!\") }\"#,\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--lib`\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test_hello ... FAILED\n...\n[..]FALSE![..]\n...\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn test_with_lib_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"baz\"\n path = \"src/main.rs\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n ///\n /// ```rust\n /// extern crate foo;\n /// fn main() {\n /// println!(\"{:?}\", foo::foo());\n /// }\n /// ```\n ///\n pub fn foo(){}\n #[test] fn lib_test() {}\n \"#,\n )\n .file(\n \"src/main.rs\",\n \"\n #[allow(unused_extern_crates)]\n extern crate foo;\n\n fn main() {}\n\n #[test]\n fn bin_test() {}\n \",\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[RUNNING] unittests src/main.rs (target/debug/deps/baz-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest lib_test ... ok\ntest bin_test ... ok\ntest [..] ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn test_with_deep_lib_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.bar]\n path = \"../bar\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"\n #[cfg(test)]\n extern crate bar;\n /// ```\n /// foo::foo();\n /// ```\n pub fn foo() {}\n\n #[test]\n fn bar_test() {\n bar::bar();\n }\n \",\n )\n .build();\n let _p2 = project()\n .at(\"bar\")\n .file(\"Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\"src/lib.rs\", \"pub fn bar() {} #[test] fn foo_test() {}\")\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] bar v0.0.1 ([ROOT]/bar)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest bar_test ... ok\ntest [..] ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn external_test_explicit() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[test]]\n name = \"test\"\n path = \"src/test.rs\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn get_hello() -> &'static str { \"Hello\" }\n\n #[test]\n fn internal_test() {}\n \"#,\n )\n .file(\n \"src/test.rs\",\n r#\"\n extern crate foo;\n\n #[test]\n fn external_test() { assert_eq!(foo::get_hello(), \"Hello\") }\n \"#,\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[RUNNING] src/test.rs (target/debug/deps/test-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest internal_test ... ok\ntest external_test ... ok\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn external_test_named_test() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[test]]\n name = \"test\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"tests/test.rs\", \"#[test] fn foo() {}\")\n .build();\n\n p.cargo(\"test\").run();\n}\n\n#[cargo_test]\nfn external_test_implicit() {\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn get_hello() -> &'static str { \"Hello\" }\n\n #[test]\n fn internal_test() {}\n \"#,\n )\n .file(\n \"tests/external.rs\",\n r#\"\n extern crate foo;\n\n #[test]\n fn external_test() { assert_eq!(foo::get_hello(), \"Hello\") }\n \"#,\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[RUNNING] tests/external.rs (target/debug/deps/external-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest internal_test ... ok\ntest external_test ... ok\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn dont_run_examples() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\n \"examples/dont-run-me-i-will-fail.rs\",\n r#\"\n fn main() { panic!(\"Examples should not be run by 'cargo test'\"); }\n \"#,\n )\n .build();\n p.cargo(\"test\").run();\n}\n\n#[cargo_test]\nfn pass_through_escaped() {\n let p = project()\n .file(\n \"src/lib.rs\",\n \"\n /// ```rust\n /// assert!(foo::foo());\n /// ```\n pub fn foo() -> bool {\n true\n }\n\n /// ```rust\n /// assert!(!foo::bar());\n /// ```\n pub fn bar() -> bool {\n false\n }\n\n #[test] fn test_foo() {\n assert!(foo());\n }\n #[test] fn test_bar() {\n assert!(!bar());\n }\n \",\n )\n .build();\n\n p.cargo(\"test -- bar\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nrunning 1 test\ntest test_bar ... ok\n...\n\"#]])\n .run();\n\n p.cargo(\"test -- foo\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nrunning 1 test\ntest test_foo ... ok\n...\n\"#]])\n .run();\n\n p.cargo(\"test -- foo bar\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\nrunning 2 tests\ntest test_foo ... ok\ntest test_bar ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n// Unlike `pass_through_escaped`, doctests won't run when using `testname` as an optimization\n#[cargo_test]\nfn pass_through_testname() {\n let p = project()\n .file(\n \"src/lib.rs\",\n \"\n /// ```rust\n /// assert!(foo::foo());\n /// ```\n pub fn foo() -> bool {\n true\n }\n\n /// ```rust\n /// assert!(!foo::bar());\n /// ```\n pub fn bar() -> bool {\n false\n }\n\n #[test] fn test_foo() {\n assert!(foo());\n }\n #[test] fn test_bar() {\n assert!(!bar());\n }\n \",\n )\n .build();\n\n p.cargo(\"test bar\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nrunning 1 test\ntest test_bar ... ok\n...\n\"#]])\n .run();\n\n p.cargo(\"test foo\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nrunning 1 test\ntest test_foo ... ok\n...\n\"#]])\n .run();\n\n p.cargo(\"test foo -- bar\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\nrunning 2 tests\ntest test_bar ... ok\ntest test_foo ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n// Regression test for running cargo-test twice with\n// tests in an rlib\n#[cargo_test]\nfn cargo_test_twice() {\n let p = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\n \"src/foo.rs\",\n r#\"\n #![crate_type = \"rlib\"]\n\n #[test]\n fn dummy_test() { }\n \"#,\n )\n .build();\n\n for _ in 0..2 {\n p.cargo(\"test\").run();\n }\n}\n\n#[cargo_test]\nfn lib_bin_same_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"foo\"\n [[bin]]\n name = \"foo\"\n \"#,\n )\n .file(\"src/lib.rs\", \"#[test] fn lib_test() {}\")\n .file(\n \"src/main.rs\",\n \"\n #[allow(unused_extern_crates)]\n extern crate foo;\n\n #[test]\n fn bin_test() {}\n \",\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[RUNNING] unittests src/main.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest lib_test ... ok\ntest bin_test ... ok\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn lib_with_standard_name() {\n let p = project()\n .file(\"Cargo.toml\", &basic_manifest(\"syntax\", \"0.0.1\"))\n .file(\n \"src/lib.rs\",\n \"\n /// ```\n /// syntax::foo();\n /// ```\n pub fn foo() {}\n\n #[test]\n fn foo_test() {}\n \",\n )\n .file(\n \"tests/test.rs\",\n \"\n extern crate syntax;\n\n #[test]\n fn test() { syntax::foo() }\n \",\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] syntax v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/syntax-[HASH][EXE])\n[RUNNING] tests/test.rs (target/debug/deps/test-[HASH][EXE])\n[DOCTEST] syntax\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest foo_test ... ok\ntest test ... ok\ntest [..] ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn lib_with_standard_name2() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"syntax\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"syntax\"\n test = false\n doctest = false\n \"#,\n )\n .file(\"src/lib.rs\", \"pub fn foo() {}\")\n .file(\n \"src/main.rs\",\n \"\n extern crate syntax;\n\n fn main() {}\n\n #[test]\n fn test() { syntax::foo() }\n \",\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] syntax v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/main.rs (target/debug/deps/syntax-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn lib_without_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"syntax\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n test = false\n doctest = false\n \"#,\n )\n .file(\"src/lib.rs\", \"pub fn foo() {}\")\n .file(\n \"src/main.rs\",\n \"\n extern crate syntax;\n\n fn main() {}\n\n #[test]\n fn test() { syntax::foo() }\n \",\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] syntax v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/main.rs (target/debug/deps/syntax-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bin_without_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"syntax\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n test = false\n doctest = false\n\n [[bin]]\n path = \"src/main.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"pub fn foo() {}\")\n .file(\n \"src/main.rs\",\n \"\n extern crate syntax;\n\n fn main() {}\n\n #[test]\n fn test() { syntax::foo() }\n \",\n )\n .build();\n\n p.cargo(\"test\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n binary target bin.name is required\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bench_without_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"syntax\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n test = false\n doctest = false\n\n [[bench]]\n path = \"src/bench.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"pub fn foo() {}\")\n .file(\n \"src/main.rs\",\n \"\n extern crate syntax;\n\n fn main() {}\n\n #[test]\n fn test() { syntax::foo() }\n \",\n )\n .file(\n \"src/bench.rs\",\n \"\n #![feature(test)]\n extern crate syntax;\n extern crate test;\n\n #[bench]\n fn external_bench(_b: &mut test::Bencher) {}\n \",\n )\n .build();\n\n p.cargo(\"test\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n benchmark target bench.name is required\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_without_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"syntax\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n test = false\n doctest = false\n\n [[test]]\n path = \"src/test.rs\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn foo() {}\n pub fn get_hello() -> &'static str { \"Hello\" }\n \"#,\n )\n .file(\n \"src/main.rs\",\n \"\n extern crate syntax;\n\n fn main() {}\n\n #[test]\n fn test() { syntax::foo() }\n \",\n )\n .file(\n \"src/test.rs\",\n r#\"\n extern crate syntax;\n\n #[test]\n fn external_test() { assert_eq!(syntax::get_hello(), \"Hello\") }\n \"#,\n )\n .build();\n\n p.cargo(\"test\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n test target test.name is required\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn example_without_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"syntax\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n test = false\n doctest = false\n\n [[example]]\n path = \"examples/example.rs\"\n \"#,\n )\n .file(\"src/lib.rs\", \"pub fn foo() {}\")\n .file(\n \"src/main.rs\",\n \"\n extern crate syntax;\n\n fn main() {}\n\n #[test]\n fn test() { syntax::foo() }\n \",\n )\n .file(\n \"examples/example.rs\",\n r#\"\n extern crate syntax;\n\n fn main() {\n println!(\"example1\");\n }\n \"#,\n )\n .build();\n\n p.cargo(\"test\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n example target example.name is required\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bin_there_for_integration() {\n let p = project()\n .file(\n \"src/main.rs\",\n \"\n fn main() { std::process::exit(101); }\n #[test] fn main_test() {}\n \",\n )\n .file(\n \"tests/foo.rs\",\n r#\"\n use std::process::Command;\n #[test]\n fn test_test() {\n let status = Command::new(\"target/debug/foo\").status().unwrap();\n assert_eq!(status.code(), Some(101));\n }\n \"#,\n )\n .build();\n\n p.cargo(\"test -v\")\n .with_stdout_data(\n str![[r#\"\ntest main_test ... ok\ntest test_test ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn test_dylib() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"foo\"\n crate-type = [\"dylib\"]\n\n [dependencies.bar]\n path = \"bar\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate bar as the_bar;\n\n pub fn bar() { the_bar::baz(); }\n\n #[test]\n fn foo() { bar(); }\n \"#,\n )\n .file(\n \"tests/test.rs\",\n r#\"\n extern crate foo as the_foo;\n\n #[test]\n fn foo() { the_foo::bar(); }\n \"#,\n )\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"bar\"\n crate-type = [\"dylib\"]\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] bar v0.0.1 ([ROOT]/foo/bar)\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[RUNNING] tests/test.rs (target/debug/deps/test-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest foo ... ok\ntest foo ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.root().move_into_the_past();\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[RUNNING] tests/test.rs (target/debug/deps/test-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest foo ... ok\ntest foo ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn test_twice_with_build_cmd() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n build = \"build.rs\"\n \"#,\n )\n .file(\"build.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", \"#[test] fn foo() {}\")\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest foo ... ok\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest foo ... ok\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn test_then_build() {\n let p = project().file(\"src/lib.rs\", \"#[test] fn foo() {}\").build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest foo ... ok\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(\"build\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_no_run() {\n let p = project()\n .file(\"src/lib.rs\", \"#[test] fn foo() { panic!() }\")\n .build();\n\n p.cargo(\"test --no-run\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[EXECUTABLE] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_no_run_emit_json() {\n let p = project()\n .file(\"src/lib.rs\", \"#[test] fn foo() { panic!() }\")\n .build();\n\n p.cargo(\"test --no-run --message-format json\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_run_specific_bin_target() {\n let prj = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name=\"bin1\"\n path=\"src/bin1.rs\"\n\n [[bin]]\n name=\"bin2\"\n path=\"src/bin2.rs\"\n \"#,\n )\n .file(\"src/bin1.rs\", \"#[test] fn test1() { }\")\n .file(\"src/bin2.rs\", \"#[test] fn test2() { }\")\n .build();\n\n prj.cargo(\"test --bin bin2\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/bin2.rs (target/debug/deps/bin2-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test2 ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_run_implicit_bin_target() {\n let prj = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name=\"mybin\"\n path=\"src/mybin.rs\"\n \"#,\n )\n .file(\n \"src/mybin.rs\",\n \"#[test] fn test_in_bin() { }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .file(\"tests/mytest.rs\", \"#[test] fn test_in_test() { }\")\n .file(\"benches/mybench.rs\", \"#[test] fn test_in_bench() { }\")\n .file(\n \"examples/myexm.rs\",\n \"#[test] fn test_in_exm() { }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .build();\n\n prj.cargo(\"test --bins\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/mybin.rs (target/debug/deps/mybin-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test_in_bin ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_run_specific_test_target() {\n let prj = project()\n .file(\"src/bin/a.rs\", \"fn main() { }\")\n .file(\"src/bin/b.rs\", \"#[test] fn test_b() { } fn main() { }\")\n .file(\"tests/a.rs\", \"#[test] fn test_a() { }\")\n .file(\"tests/b.rs\", \"#[test] fn test_b() { }\")\n .build();\n\n prj.cargo(\"test --test b\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/b.rs (target/debug/deps/b-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test_b ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_run_implicit_test_target() {\n let prj = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name=\"mybin\"\n path=\"src/mybin.rs\"\n \"#,\n )\n .file(\n \"src/mybin.rs\",\n \"#[test] fn test_in_bin() { }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .file(\"tests/mytest.rs\", \"#[test] fn test_in_test() { }\")\n .file(\"benches/mybench.rs\", \"#[test] fn test_in_bench() { }\")\n .file(\n \"examples/myexm.rs\",\n \"fn main() { compile_error!(\\\"Don't build me!\\\"); }\",\n )\n .build();\n\n prj.cargo(\"test --tests\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/mybin.rs (target/debug/deps/mybin-[HASH][EXE])\n[RUNNING] tests/mytest.rs (target/debug/deps/mytest-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test_in_test ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_run_implicit_bench_target() {\n let prj = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name=\"mybin\"\n path=\"src/mybin.rs\"\n \"#,\n )\n .file(\n \"src/mybin.rs\",\n \"#[test] fn test_in_bin() { }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .file(\"tests/mytest.rs\", \"#[test] fn test_in_test() { }\")\n .file(\"benches/mybench.rs\", \"#[test] fn test_in_bench() { }\")\n .file(\n \"examples/myexm.rs\",\n \"fn main() { compile_error!(\\\"Don't build me!\\\"); }\",\n )\n .build();\n\n prj.cargo(\"test --benches\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/mybin.rs (target/debug/deps/mybin-[HASH][EXE])\n[RUNNING] benches/mybench.rs (target/debug/deps/mybench-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest test_in_bench ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_run_implicit_example_target() {\n let prj = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"mybin\"\n path = \"src/mybin.rs\"\n\n [[example]]\n name = \"myexm1\"\n\n [[example]]\n name = \"myexm2\"\n test = true\n\n [profile.test]\n panic = \"abort\" # this should be ignored by default Cargo targets set.\n \"#,\n )\n .file(\n \"src/mybin.rs\",\n \"#[test] fn test_in_bin() { }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .file(\"tests/mytest.rs\", \"#[test] fn test_in_test() { }\")\n .file(\"benches/mybench.rs\", \"#[test] fn test_in_bench() { }\")\n .file(\n \"examples/myexm1.rs\",\n \"#[test] fn test_in_exm() { }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .file(\n \"examples/myexm2.rs\",\n \"#[test] fn test_in_exm() { }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .build();\n\n // Compiles myexm1 as normal binary (without --test), but does not run it.\n prj.cargo(\"test -v\")\n .with_stderr_contains(\"[RUNNING] `rustc [..]myexm1.rs [..]--crate-type bin[..]\")\n .with_stderr_contains(\"[RUNNING] `rustc [..]myexm2.rs [..]--test[..]\")\n .with_stderr_does_not_contain(\"[RUNNING] [..]myexm1-[..]\")\n // profile.test panic settings shouldn't be applied even to myexm1\n .with_stderr_line_without(&[\"[RUNNING] `rustc --crate-name myexm1\"], &[\"panic=abort\"])\n .with_stderr_contains(\"[RUNNING] [..]target/debug/examples/myexm2-[..]\")\n .run();\n\n // Only tests myexm2.\n prj.cargo(\"test --tests\")\n .with_stderr_does_not_contain(\"[RUNNING] [..]myexm1-[..]\")\n .with_stderr_contains(\"[RUNNING] [..]target/debug/examples/myexm2-[..]\")\n .run();\n\n // Tests all examples.\n prj.cargo(\"test --examples\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] unittests examples/myexm1.rs (target/debug/examples/myexm1-[HASH][EXE])\n[RUNNING] unittests examples/myexm2.rs (target/debug/examples/myexm2-[HASH][EXE])\n...\n\"#]])\n .run();\n\n // Test an example, even without `test` set.\n prj.cargo(\"test --example myexm1\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] unittests examples/myexm1.rs (target/debug/examples/myexm1-[HASH][EXE])\n...\n\"#]])\n .run();\n\n // Tests all examples.\n prj.cargo(\"test --all-targets\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] unittests examples/myexm1.rs (target/debug/examples/myexm1-[HASH][EXE])\n[RUNNING] unittests examples/myexm2.rs (target/debug/examples/myexm2-[HASH][EXE])\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_filtered_excludes_compiling_examples() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"mybin\"\n test = false\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"#[cfg(test)] mod tests { #[test] fn test_in_lib() { } }\",\n )\n .file(\n \"src/bin/mybin.rs\",\n \"#[test] fn test_in_bin() { }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .file(\"tests/mytest.rs\", \"#[test] fn test_in_test() { }\")\n .file(\n \"benches/mybench.rs\",\n \"#[test] fn test_in_bench() { assert!(false) }\",\n )\n .file(\n \"examples/myexm1.rs\",\n \"#[test] fn test_in_exm() { assert!(false) }\n fn main() { panic!(\\\"Don't execute me!\\\"); }\",\n )\n .build();\n\n p.cargo(\"test -v test_in_\")\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest tests::test_in_lib ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\nrunning 1 test\ntest test_in_test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .with_stderr_data(\n str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..] --crate-type lib [..]`\n[RUNNING] `rustc --crate-name foo --edition=2015 src/lib.rs [..] --test [..]`\n[RUNNING] `rustc --crate-name mybin --edition=2015 src/bin/mybin.rs [..] --crate-type bin [..]`\n[RUNNING] `rustc --crate-name mytest --edition=2015 tests/mytest.rs [..] --test [..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE] test_in_`\n[RUNNING] `[ROOT]/foo/target/debug/deps/mytest-[HASH][EXE] test_in_`\n\n\"#]]\n .unordered(),\n )\n .with_stderr_does_not_contain(\"[RUNNING][..]rustc[..]myexm1[..]\")\n .with_stderr_does_not_contain(\"[RUNNING][..]deps/mybin-[..] test_in_\")\n .run();\n}\n\n#[cargo_test]\nfn test_no_harness() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [[bin]]\n name = \"foo\"\n test = false\n\n [[test]]\n name = \"bar\"\n path = \"foo.rs\"\n harness = false\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"foo.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"test -- --no-capture\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] foo.rs (target/debug/deps/bar-[HASH][EXE])\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn selective_testing() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.d1]\n path = \"d1\"\n [dependencies.d2]\n path = \"d2\"\n\n [lib]\n name = \"foo\"\n doctest = false\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"d1/Cargo.toml\",\n r#\"\n [package]\n name = \"d1\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"d1\"\n doctest = false\n \"#,\n )\n .file(\"d1/src/lib.rs\", \"\")\n .file(\n \"d1/src/main.rs\",\n \"#[allow(unused_extern_crates)] extern crate d1; fn main() {}\",\n )\n .file(\n \"d2/Cargo.toml\",\n r#\"\n [package]\n name = \"d2\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"d2\"\n doctest = false\n \"#,\n )\n .file(\"d2/src/lib.rs\", \"\")\n .file(\n \"d2/src/main.rs\",\n \"#[allow(unused_extern_crates)] extern crate d2; fn main() {}\",\n );\n let p = p.build();\n\n println!(\"d1\");\n p.cargo(\"test -p d1\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 2 packages to latest compatible versions\n[COMPILING] d1 v0.0.1 ([ROOT]/foo/d1)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/d1-[HASH][EXE])\n[RUNNING] unittests src/main.rs (target/debug/deps/d1-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\nrunning 0 tests\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n println!(\"d2\");\n p.cargo(\"test -p d2\")\n .with_stderr_data(str![[r#\"\n[COMPILING] d2 v0.0.1 ([ROOT]/foo/d2)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/d2-[HASH][EXE])\n[RUNNING] unittests src/main.rs (target/debug/deps/d2-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\nrunning 0 tests\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n println!(\"whole\");\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nrunning 0 tests\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn almost_cyclic_but_not_quite() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dev-dependencies.b]\n path = \"b\"\n [dev-dependencies.c]\n path = \"c\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n #[cfg(test)] extern crate b;\n #[cfg(test)] extern crate c;\n \"#,\n )\n .file(\n \"b/Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.foo]\n path = \"..\"\n \"#,\n )\n .file(\n \"b/src/lib.rs\",\n r#\"\n #[allow(unused_extern_crates)]\n extern crate foo;\n \"#,\n )\n .file(\"c/Cargo.toml\", &basic_manifest(\"c\", \"0.0.1\"))\n .file(\"c/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build\").run();\n p.cargo(\"test\").run();\n}\n\n#[cargo_test]\nfn build_then_selective_test() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.b]\n path = \"b\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"#[allow(unused_extern_crates)] extern crate b;\",\n )\n .file(\n \"src/main.rs\",\n r#\"\n #[allow(unused_extern_crates)]\n extern crate b;\n #[allow(unused_extern_crates)]\n extern crate foo;\n fn main() {}\n \"#,\n )\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.0.1\"))\n .file(\"b/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build\").run();\n p.root().move_into_the_past();\n p.cargo(\"test -p b\").run();\n}\n\n#[cargo_test]\nfn example_dev_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dev-dependencies.bar]\n path = \"bar\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/e1.rs\", \"extern crate bar; fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\n \"bar/src/lib.rs\",\n r#\"\n // make sure this file takes awhile to compile\n macro_rules! f0( () => (1) );\n macro_rules! f1( () => ({(f0!()) + (f0!())}) );\n macro_rules! f2( () => ({(f1!()) + (f1!())}) );\n macro_rules! f3( () => ({(f2!()) + (f2!())}) );\n macro_rules! f4( () => ({(f3!()) + (f3!())}) );\n macro_rules! f5( () => ({(f4!()) + (f4!())}) );\n macro_rules! f6( () => ({(f5!()) + (f5!())}) );\n macro_rules! f7( () => ({(f6!()) + (f6!())}) );\n macro_rules! f8( () => ({(f7!()) + (f7!())}) );\n pub fn bar() {\n f8!();\n }\n \"#,\n )\n .build();\n p.cargo(\"test\").run();\n p.cargo(\"run --example e1 --release -v\").run();\n}\n\n#[cargo_test]\nfn selective_testing_with_docs() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.d1]\n path = \"d1\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// not valid rust\n /// ```\n pub fn foo() {}\n \"#,\n )\n .file(\n \"d1/Cargo.toml\",\n r#\"\n [package]\n name = \"d1\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"d1\"\n path = \"d1.rs\"\n \"#,\n )\n .file(\"d1/d1.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"test -p d1\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] d1 v0.0.1 ([ROOT]/foo/d1)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests d1.rs (target/debug/deps/d1-[HASH][EXE])\n[DOCTEST] d1\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\nrunning 0 tests\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn example_bin_same_name() {\n let p = project()\n .file(\"src/bin/foo.rs\", r#\"fn main() { println!(\"bin\"); }\"#)\n .file(\"examples/foo.rs\", r#\"fn main() { println!(\"example\"); }\"#)\n .build();\n\n p.cargo(\"test --no-run -v\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\n[RUNNING] `rustc [..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n\n\"#]])\n .run();\n\n assert!(!p.bin(\"foo\").is_file());\n assert!(p.bin(\"examples/foo\").is_file());\n\n p.process(&p.bin(\"examples/foo\"))\n .with_stdout_data(str![[r#\"\nexample\n\n\"#]])\n .run();\n\n p.cargo(\"run\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nbin\n\n\"#]])\n .run();\n assert!(p.bin(\"foo\").is_file());\n}\n\n#[cargo_test]\nfn test_with_example_twice() {\n let p = project()\n .file(\"src/bin/foo.rs\", r#\"fn main() { println!(\"bin\"); }\"#)\n .file(\"examples/foo.rs\", r#\"fn main() { println!(\"example\"); }\"#)\n .build();\n\n println!(\"first\");\n p.cargo(\"test -v\").run();\n assert!(p.bin(\"examples/foo\").is_file());\n println!(\"second\");\n p.cargo(\"test -v\").run();\n assert!(p.bin(\"examples/foo\").is_file());\n}\n\n#[cargo_test]\nfn example_with_dev_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"foo\"\n test = false\n doctest = false\n\n [dev-dependencies.a]\n path = \"a\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"examples/ex.rs\",\n \"#[allow(unused_extern_crates)] extern crate a; fn main() {}\",\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.0.1\"))\n .file(\"a/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test -v\")\n .with_stderr_data(\n str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] a v0.0.1 ([ROOT]/foo/a)\n[RUNNING] `rustc --crate-name foo [..]`\n[RUNNING] `rustc --crate-name a [..]`\n[RUNNING] `rustc --crate-name ex [..] --extern a=[..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn bin_is_preserved() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build -v\").run();\n assert!(p.bin(\"foo\").is_file());\n\n println!(\"test\");\n p.cargo(\"test -v\").run();\n assert!(p.bin(\"foo\").is_file());\n}\n\n#[cargo_test]\nfn bad_example() {\n let p = project().file(\"src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"run --example foo\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no example target named `foo` in default-run packages\n\n\"#]])\n .run();\n p.cargo(\"run --bin foo\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] no bin target named `foo` in default-run packages\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn doctest_feature() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n [features]\n bar = []\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```rust\n /// assert_eq!(foo::foo(), 1);\n /// ```\n #[cfg(feature = \"bar\")]\n pub fn foo() -> i32 { 1 }\n \"#,\n )\n .build();\n\n p.cargo(\"test --features bar\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\nrunning 0 tests\ntest [..] ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn dashes_to_underscores() {\n let p = project()\n .file(\"Cargo.toml\", &basic_manifest(\"foo-bar\", \"0.0.1\"))\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// assert_eq!(foo_bar::foo(), 1);\n /// ```\n pub fn foo() -> i32 { 1 }\n \"#,\n )\n .build();\n\n p.cargo(\"test -v\").run();\n}\n\n#[cargo_test]\nfn doctest_dev_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dev-dependencies]\n b = { path = \"b\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// extern crate b;\n /// ```\n pub fn foo() {}\n \"#,\n )\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.0.1\"))\n .file(\"b/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test -v\").run();\n}\n\n#[cargo_test]\nfn doctest_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n b = { path = \"b\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// foo::foo();\n /// ```\n pub fn foo() {\n b::bar();\n }\n \"#,\n )\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.0.1\"))\n .file(\"b/src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n p.cargo(\"test -v\").run();\n}\n\n#[cargo_test]\nfn doctest_dep_new_layout() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n b = { path = \"b\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// foo::foo();\n /// ```\n pub fn foo() {\n b::bar();\n }\n \"#,\n )\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.0.1\"))\n .file(\"b/src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n p.cargo(\"-Zbuild-dir-new-layout test\")\n .masquerade_as_nightly_cargo(&[\"new build-dir layout\"])\n .run();\n}\n\n#[cargo_test]\nfn filter_no_doc_tests() {\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// extern crate b;\n /// ```\n pub fn foo() {}\n \"#,\n )\n .file(\"tests/foo.rs\", \"\")\n .build();\n\n p.cargo(\"test --test=foo\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/foo.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nrunning 0 tests\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn dylib_doctest() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"foo\"\n crate-type = [\"rlib\", \"dylib\"]\n test = false\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// foo::foo();\n /// ```\n pub fn foo() {}\n \"#,\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest [..] ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn dylib_doctest2() {\n // Can't doc-test dylibs, as they're statically linked together.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"foo\"\n crate-type = [\"dylib\"]\n test = false\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// foo::foo();\n /// ```\n pub fn foo() {}\n \"#,\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cyclic_dev_dep_doc_test() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dev-dependencies]\n bar = { path = \"bar\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n //! ```\n //! extern crate bar;\n //! ```\n \"#,\n )\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = { path = \"..\" }\n \"#,\n )\n .file(\n \"bar/src/lib.rs\",\n r#\"\n #[allow(unused_extern_crates)]\n extern crate foo;\n \"#,\n )\n .build();\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[COMPILING] bar v0.0.1 ([ROOT]/foo/bar)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(\n str![[r#\"\nrunning 0 tests\ntest [..] ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn dev_dep_with_build_script() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dev-dependencies]\n bar = { path = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/foo.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n build = \"build.rs\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .file(\"bar/build.rs\", \"fn main() {}\")\n .build();\n p.cargo(\"test\").run();\n}\n\n#[cargo_test]\nfn no_fail_fast() {\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn add_one(x: i32) -> i32{\n x + 1\n }\n\n /// ```rust\n /// use foo::sub_one;\n /// assert_eq!(sub_one(101), 100);\n /// ```\n pub fn sub_one(x: i32) -> i32{\n x - 1\n }\n \"#,\n )\n .file(\n \"tests/test_add_one.rs\",\n r#\"\n extern crate foo;\n use foo::*;\n\n #[test]\n fn add_one_test() {\n assert_eq!(add_one(1), 2);\n }\n\n #[test]\n fn fail_add_one_test() {\n assert_eq!(add_one(1), 1);\n }\n \"#,\n )\n .file(\n \"tests/test_sub_one.rs\",\n r#\"\n extern crate foo;\n use foo::*;\n\n #[test]\n fn sub_one_test() {\n assert_eq!(sub_one(1), 0);\n }\n \"#,\n )\n .build();\n p.cargo(\"test --no-fail-fast\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[RUNNING] tests/test_add_one.rs (target/debug/deps/test_add_one-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--test test_add_one`\n[RUNNING] tests/test_sub_one.rs (target/debug/deps/test_sub_one-[HASH][EXE])\n[DOCTEST] foo\n[ERROR] 1 target failed:\n `--test test_add_one`\n\n\"#]])\n .with_stdout_data(str![[r#\"\nrunning 0 tests\ntest add_one_test ... ok\ntest result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\ntest sub_one_test ... ok\ntest [..] ... ok\n...\n\"#]].unordered())\n .run();\n}\n\n#[cargo_test]\nfn test_multiple_packages() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies.d1]\n path = \"d1\"\n [dependencies.d2]\n path = \"d2\"\n\n [lib]\n name = \"foo\"\n doctest = false\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"d1/Cargo.toml\",\n r#\"\n [package]\n name = \"d1\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"d1\"\n doctest = false\n \"#,\n )\n .file(\"d1/src/lib.rs\", \"\")\n .file(\n \"d2/Cargo.toml\",\n r#\"\n [package]\n name = \"d2\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n name = \"d2\"\n doctest = false\n \"#,\n )\n .file(\"d2/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"test -p d1 -p d2\")\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] unittests src/lib.rs (target/debug/deps/d1-[HASH][EXE])\n[RUNNING] unittests src/lib.rs (target/debug/deps/d2-[HASH][EXE])\n...\n\"#]])\n .with_stdout_data(\n str![[r#\"\nrunning 0 tests\nrunning 0 tests\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn bin_does_not_rebuild_tests() {\n let p = project()\n .file(\"src/lib.rs\", \"\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"tests/foo.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"test -v\").run();\n\n sleep_ms(1000);\n fs::write(p.root().join(\"src/main.rs\"), \"fn main() { 3; }\").unwrap();\n\n p.cargo(\"test -v --no-run\")\n .with_stderr_data(str![[r#\"\n[DIRTY] foo v0.0.1 ([ROOT]/foo): the file `src/main.rs` has changed ([..])\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..] src/main.rs [..]`\n[RUNNING] `rustc [..] src/main.rs [..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn selective_test_wonky_profile() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [profile.release]\n opt-level = 2\n\n [dependencies]\n a = { path = \"a\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.0.1\"))\n .file(\"a/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"test -v --no-run --release -p foo -p a\").run();\n}\n\n#[cargo_test]\nfn selective_test_optional_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = { path = \"a\", optional = true }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.0.1\"))\n .file(\"a/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"test -v --no-run --features a -p a\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[COMPILING] a v0.0.1 ([ROOT]/foo/a)\n[RUNNING] `rustc [..] a/src/lib.rs [..]`\n[RUNNING] `rustc [..] a/src/lib.rs [..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[EXECUTABLE] `[ROOT]/foo/target/debug/deps/a-[HASH][EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn only_test_docs() {\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n #[test]\n fn foo() {\n let a: u32 = \"hello\";\n }\n\n /// ```\n /// foo::bar();\n /// println!(\"ok\");\n /// ```\n pub fn bar() {\n }\n \"#,\n )\n .file(\"tests/foo.rs\", \"this is not rust\");\n let p = p.build();\n\n p.cargo(\"test --doc\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\ntest [..] ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn doctest_with_library_paths() {\n let p = project();\n // Only link search directories within the target output directory are\n // propagated through to dylib_path_envvar() (see #3366).\n let dir1 = p.target_debug_dir().join(\"foo\\\\backslash\");\n let dir2 = p.target_debug_dir().join(\"dir=containing=equal=signs\");\n\n let p = p\n .file(\"Cargo.toml\", &basic_manifest(\"foo\", \"0.0.0\"))\n .file(\n \"build.rs\",\n &format!(\n r##\"\n fn main() {{\n println!(r#\"cargo::rustc-link-search=native={}\"#);\n println!(r#\"cargo::rustc-link-search={}\"#);\n }}\n \"##,\n dir1.display(),\n dir2.display()\n ),\n )\n .file(\n \"src/lib.rs\",\n &format!(\n r##\"\n /// ```\n /// foo::assert_search_path();\n /// ```\n pub fn assert_search_path() {{\n let search_path = std::env::var_os(\"{}\").unwrap();\n let paths = std::env::split_paths(&search_path).collect::>();\n assert!(paths.contains(&r#\"{}\"#.into()));\n assert!(paths.contains(&r#\"{}\"#.into()));\n }}\n \"##,\n dylib_path_envvar(),\n dir1.display(),\n dir2.display()\n ),\n )\n .build();\n\n p.cargo(\"test --doc\").run();\n}\n\n#[cargo_test]\nfn test_panic_abort_with_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"bar\" }\n\n [profile.dev]\n panic = 'abort'\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n extern crate bar;\n\n #[test]\n fn foo() {}\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.0.1\"))\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n p.cargo(\"test -v\").run();\n}\n\n#[cargo_test]\nfn cfg_test_even_with_no_harness() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [lib]\n harness = false\n doctest = false\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"#[cfg(test)] fn main() { println!(\"hello!\"); }\"#,\n )\n .build();\n p.cargo(\"test -v\")\n .with_stdout_data(str![[r#\"\nhello!\n\n\"#]])\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn panic_abort_multiple() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = { path = \"a\" }\n\n [profile.release]\n panic = 'abort'\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"#[allow(unused_extern_crates)] extern crate a;\",\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.0.1\"))\n .file(\"a/src/lib.rs\", \"\")\n .build();\n p.cargo(\"test --release -v -p foo -p a\").run();\n}\n\n#[cargo_test]\nfn pass_correct_cfgs_flags_to_rustdoc() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"feature_a/default\"]\n nightly = [\"feature_a/nightly\"]\n\n [dependencies.feature_a]\n path = \"libs/feature_a\"\n default-features = false\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n #[cfg(test)]\n mod tests {\n #[test]\n fn it_works() {\n assert!(true);\n }\n }\n \"#,\n )\n .file(\n \"libs/feature_a/Cargo.toml\",\n r#\"\n [package]\n name = \"feature_a\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [features]\n default = [\"mock_serde_codegen\"]\n nightly = [\"mock_serde_derive\"]\n\n [dependencies]\n mock_serde_derive = { path = \"../mock_serde_derive\", optional = true }\n\n [build-dependencies]\n mock_serde_codegen = { path = \"../mock_serde_codegen\", optional = true }\n \"#,\n )\n .file(\n \"libs/feature_a/src/lib.rs\",\n r#\"\n #[cfg(feature = \"mock_serde_derive\")]\n const MSG: &'static str = \"This is safe\";\n\n #[cfg(feature = \"mock_serde_codegen\")]\n const MSG: &'static str = \"This is risky\";\n\n pub fn get() -> &'static str {\n MSG\n }\n \"#,\n )\n .file(\n \"libs/mock_serde_derive/Cargo.toml\",\n &basic_manifest(\"mock_serde_derive\", \"0.1.0\"),\n )\n .file(\"libs/mock_serde_derive/src/lib.rs\", \"\")\n .file(\n \"libs/mock_serde_codegen/Cargo.toml\",\n &basic_manifest(\"mock_serde_codegen\", \"0.1.0\"),\n )\n .file(\"libs/mock_serde_codegen/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"test --package feature_a --verbose\")\n .with_stderr_data(str![[r#\"\n...\n[DOCTEST] feature_a\n[RUNNING] `rustdoc [..]--test [..]mock_serde_codegen[..]`\n...\n\"#]])\n .run();\n\n p.cargo(\"test --verbose\")\n .with_stderr_data(str![[r#\"\n...\n[DOCTEST] foo\n[RUNNING] `rustdoc [..]--test [..]feature_a[..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_release_ignore_panic() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = { path = \"a\" }\n\n [profile.test]\n panic = 'abort'\n [profile.release]\n panic = 'abort'\n \"#,\n )\n .file(\n \"src/lib.rs\",\n \"#[allow(unused_extern_crates)] extern crate a;\",\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.0.1\"))\n .file(\"a/src/lib.rs\", \"\");\n let p = p.build();\n println!(\"test\");\n p.cargo(\"test -v\").run();\n println!(\"bench\");\n p.cargo(\"bench -v\").run();\n}\n\n#[cargo_test]\nfn test_many_with_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n a = { path = \"a\" }\n\n [features]\n foo = []\n\n [workspace]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.0.1\"))\n .file(\"a/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test -v -p a -p foo --features foo\").run();\n}\n\n#[cargo_test]\nfn test_all_workspace() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = { path = \"bar\" }\n\n [workspace]\n \"#,\n )\n .file(\"src/main.rs\", \"#[test] fn foo_test() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] fn bar_test() {}\")\n .build();\n\n p.cargo(\"test --workspace\")\n .with_stdout_data(\n str![[r#\"\ntest foo_test ... ok\ntest bar_test ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn test_all_exclude() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = [\"bar\", \"baz\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] pub fn bar() {}\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/lib.rs\", \"#[test] pub fn baz() { assert!(false); }\")\n .build();\n\n p.cargo(\"test --workspace --exclude baz\")\n .with_stdout_data(str![[r#\"\n...\nrunning 1 test\ntest bar ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_all_exclude_not_found() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] pub fn bar() {}\")\n .build();\n\n p.cargo(\"test --workspace --exclude baz\")\n .with_stderr_data(str![[r#\"\n...\n[WARNING] excluded package(s) `baz` not found in workspace `[ROOT]/foo`\n...\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nrunning 1 test\ntest bar ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_all_exclude_glob() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = [\"bar\", \"baz\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] pub fn bar() {}\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/lib.rs\", \"#[test] pub fn baz() { assert!(false); }\")\n .build();\n\n p.cargo(\"test --workspace --exclude '*z'\")\n .with_stdout_data(str![[r#\"\n...\nrunning 1 test\ntest bar ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_all_exclude_glob_not_found() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] pub fn bar() {}\")\n .build();\n\n p.cargo(\"test --workspace --exclude '*z'\")\n .with_stderr_data(str![[r#\"\n...\n[WARNING] excluded package pattern(s) `*z` not found in workspace `[ROOT]/foo`\n...\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nrunning 1 test\ntest bar ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_all_exclude_broken_glob() {\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n\n p.cargo(\"test --workspace --exclude '[*z'\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\n[ERROR] cannot build glob pattern from `[*z`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_all_virtual_manifest() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\"]\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"#[test] fn a() {}\")\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.1.0\"))\n .file(\"b/src/lib.rs\", \"#[test] fn b() {}\")\n .build();\n\n p.cargo(\"test --workspace\")\n .with_stdout_data(\n str![[r#\"\nrunning 1 test\ntest a ... ok\nrunning 1 test\ntest b ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn test_virtual_manifest_all_implied() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\"]\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"#[test] fn a() {}\")\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.1.0\"))\n .file(\"b/src/lib.rs\", \"#[test] fn b() {}\")\n .build();\n\n p.cargo(\"test\")\n .with_stdout_data(\n str![[r#\"\nrunning 1 test\ntest a ... ok\nrunning 1 test\ntest b ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn test_virtual_manifest_one_project() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\", \"baz\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] fn bar() {}\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/lib.rs\", \"#[test] fn baz() { assert!(false); }\")\n .build();\n\n p.cargo(\"test -p bar\")\n .with_stdout_contains(\"running 1 test\\ntest bar ... ok\")\n .with_stdout_does_not_contain(\"running 1 test\\ntest baz ... ok\")\n .run();\n}\n\n#[cargo_test]\nfn test_virtual_manifest_glob() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\", \"baz\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] fn bar() { assert!(false); }\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/lib.rs\", \"#[test] fn baz() {}\")\n .build();\n\n p.cargo(\"test -p '*z'\")\n .with_stdout_does_not_contain(\"running 1 test\\ntest bar ... ok\")\n .with_stdout_contains(\"running 1 test\\ntest baz ... ok\")\n .run();\n}\n\n#[cargo_test]\nfn test_virtual_manifest_glob_not_found() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] fn bar() {}\")\n .build();\n\n p.cargo(\"test -p bar -p '*z'\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package pattern(s) `*z` not found in workspace `[ROOT]/foo`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_virtual_manifest_broken_glob() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"#[test] fn bar() {}\")\n .build();\n\n p.cargo(\"test -p '[*z'\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] cannot build glob pattern from `[*z`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_all_member_dependency_same_name() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n a = \"0.1.0\"\n \"#,\n )\n .file(\"a/src/lib.rs\", \"#[test] fn a() {}\")\n .build();\n\n Package::new(\"a\", \"0.1.0\").publish();\n\n p.cargo(\"test --workspace\")\n .with_stdout_data(str![[r#\"\n...\ntest a ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn doctest_only_with_dev_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dev-dependencies]\n b = { path = \"b\" }\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// extern crate b;\n ///\n /// b::b();\n /// ```\n pub fn a() {}\n \"#,\n )\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.1.0\"))\n .file(\"b/src/lib.rs\", \"pub fn b() {}\")\n .build();\n\n p.cargo(\"test --doc -v\").run();\n}\n\n#[cargo_test]\nfn test_many_targets() {\n let p = project()\n .file(\n \"src/bin/a.rs\",\n r#\"\n fn main() {}\n #[test] fn bin_a() {}\n \"#,\n )\n .file(\n \"src/bin/b.rs\",\n r#\"\n fn main() {}\n #[test] fn bin_b() {}\n \"#,\n )\n .file(\n \"src/bin/c.rs\",\n r#\"\n fn main() {}\n #[test] fn bin_c() { panic!(); }\n \"#,\n )\n .file(\n \"examples/a.rs\",\n r#\"\n fn main() {}\n #[test] fn example_a() {}\n \"#,\n )\n .file(\n \"examples/b.rs\",\n r#\"\n fn main() {}\n #[test] fn example_b() {}\n \"#,\n )\n .file(\"examples/c.rs\", \"#[test] fn example_c() { panic!(); }\")\n .file(\"tests/a.rs\", \"#[test] fn test_a() {}\")\n .file(\"tests/b.rs\", \"#[test] fn test_b() {}\")\n .file(\"tests/c.rs\", \"does not compile\")\n .build();\n\n p.cargo(\"test --verbose --bin a --bin b --example a --example b --test a --test b\")\n .with_stdout_data(\n str![[r#\"\ntest bin_a ... ok\ntest bin_b ... ok\ntest test_a ... ok\ntest test_b ... ok\n...\n\"#]]\n .unordered(),\n )\n .with_stderr_data(\n str![[r#\"\n[RUNNING] `rustc --crate-name a --edition=2015 examples/a.rs [..]`\n[RUNNING] `rustc --crate-name b --edition=2015 examples/b.rs [..]`\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn doctest_and_registry() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n b = { path = \"b\" }\n c = { path = \"c\" }\n\n [workspace]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.1.0\"))\n .file(\n \"b/src/lib.rs\",\n \"\n /// ```\n /// b::foo();\n /// ```\n pub fn foo() {}\n \",\n )\n .file(\n \"c/Cargo.toml\",\n r#\"\n [package]\n name = \"c\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n b = \"0.1\"\n \"#,\n )\n .file(\"c/src/lib.rs\", \"\")\n .build();\n\n Package::new(\"b\", \"0.1.0\").publish();\n\n p.cargo(\"test --workspace -v\").run();\n}\n\n#[cargo_test]\nfn cargo_test_env() {\n let rustc_host = rustc_host();\n let src = format!(\n r#\"\n #![crate_type = \"rlib\"]\n\n #[test]\n fn env_test() {{\n use std::env;\n eprintln!(\"{{}}\", env::var(\"{}\").unwrap());\n }}\n \"#,\n cargo::CARGO_ENV\n );\n\n let p = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\"src/lib.rs\", &src)\n .build();\n\n let cargo = format!(\n \"{}[EXE]\",\n cargo_exe()\n .with_extension(\"\")\n .to_str()\n .unwrap()\n .replace(rustc_host, \"[HOST_TARGET]\")\n );\n p.cargo(\"test --lib -- --no-capture\")\n .with_stderr_contains(cargo)\n .with_stdout_data(str![[r#\"\n...\ntest env_test ... ok\n...\n\"#]])\n .run();\n\n // Check that `cargo test` propagates the environment's $CARGO\n let cargo_exe = cargo_exe();\n let other_cargo_path = p.root().join(cargo_exe.file_name().unwrap());\n std::fs::hard_link(&cargo_exe, &other_cargo_path).unwrap();\n let stderr_other_cargo = format!(\n \"{}[EXE]\",\n other_cargo_path\n .with_extension(\"\")\n .to_str()\n .unwrap()\n .replace(p.root().parent().unwrap().to_str().unwrap(), \"[ROOT]\")\n );\n p.process(other_cargo_path)\n .args(&[\"test\", \"--lib\", \"--\", \"--no-capture\"])\n .with_stderr_contains(stderr_other_cargo)\n .with_stdout_data(str![[r#\"\n...\ntest env_test ... ok\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_order() {\n let p = project()\n .file(\"src/lib.rs\", \"#[test] fn test_lib() {}\")\n .file(\"tests/a.rs\", \"#[test] fn test_a() {}\")\n .file(\"tests/z.rs\", \"#[test] fn test_z() {}\")\n .build();\n\n p.cargo(\"test --workspace\")\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest test_lib ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\nrunning 1 test\ntest test_a ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\nrunning 1 test\ntest test_z ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cyclic_dev() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dev-dependencies]\n foo = { path = \".\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"#[test] fn test_lib() {}\")\n .file(\"tests/foo.rs\", \"extern crate foo;\")\n .build();\n\n p.cargo(\"test --workspace\").run();\n}\n\n#[cargo_test]\nfn cyclical_dep_with_missing_feature() {\n // Checks for error handling when a cyclical dev-dependency specify a\n // feature that doesn't exist.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dev-dependencies]\n foo = { path = \".\", features = [\"missing\"] }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to select a version for `foo`.\n ... required by package `foo v0.1.0 ([ROOT]/foo)`\nversions that meet the requirements `*` are: 0.1.0\n\npackage `foo` depends on `foo` with feature `missing` but `foo` does not have that feature.\n\n\nfailed to select a version for `foo` which could resolve this conflict\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish_a_crate_without_tests() {\n Package::new(\"testless\", \"0.1.0\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"testless\"\n version = \"0.1.0\"\n edition = \"2015\"\n exclude = [\"tests/*\"]\n\n [[test]]\n name = \"a_test\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n // In real life, the package will have a test,\n // which would be excluded from .crate file by the\n // `exclude` field. Our test harness does not honor\n // exclude though, so let's just not add the file!\n // .file(\"tests/a_test.rs\", \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n testless = \"0.1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test\").run();\n p.cargo(\"test --package testless\").run();\n}\n\n#[cargo_test]\nfn find_dependency_of_proc_macro_dependency_with_target() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"root\", \"proc_macro_dep\"]\n \"#,\n )\n .file(\n \"root/Cargo.toml\",\n r#\"\n [package]\n name = \"root\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n proc_macro_dep = { path = \"../proc_macro_dep\" }\n \"#,\n )\n .file(\n \"root/src/lib.rs\",\n r#\"\n #[macro_use]\n extern crate proc_macro_dep;\n\n #[derive(Noop)]\n pub struct X;\n \"#,\n )\n .file(\n \"proc_macro_dep/Cargo.toml\",\n r#\"\n [package]\n name = \"proc_macro_dep\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [lib]\n proc-macro = true\n\n [dependencies]\n baz = \"^0.1\"\n \"#,\n )\n .file(\n \"proc_macro_dep/src/lib.rs\",\n r#\"\n extern crate baz;\n extern crate proc_macro;\n use proc_macro::TokenStream;\n\n #[proc_macro_derive(Noop)]\n pub fn noop(_input: TokenStream) -> TokenStream {\n \"\".parse().unwrap()\n }\n \"#,\n )\n .build();\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"baz\", \"0.1.0\")\n .dep(\"bar\", \"0.1\")\n .file(\"src/lib.rs\", \"extern crate bar;\")\n .publish();\n p.cargo(\"test --workspace --target\").arg(rustc_host()).run();\n}\n\n#[cargo_test]\nfn test_hint_not_masked_by_doctest() {\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// assert_eq!(1, 1);\n /// ```\n pub fn this_works() {}\n \"#,\n )\n .file(\n \"tests/integ.rs\",\n r#\"\n #[test]\n fn this_fails() {\n panic!();\n }\n \"#,\n )\n .build();\n p.cargo(\"test --no-fail-fast\")\n .with_status(101)\n .with_stdout_data(\n str![[r#\"\ntest this_fails ... FAILED\ntest [..]this_works (line [..]) ... ok\n...\n\"#]]\n .unordered(),\n )\n .with_stderr_data(str![[r#\"\n...\n[ERROR] test failed, to rerun pass `--test integ`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_hint_workspace_virtual() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\", \"b\", \"c\"]\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"#[test] fn t1() {}\")\n .file(\"b/Cargo.toml\", &basic_manifest(\"b\", \"0.1.0\"))\n .file(\"b/src/lib.rs\", \"#[test] fn t1() {assert!(false)}\")\n .file(\"c/Cargo.toml\", &basic_manifest(\"c\", \"0.1.0\"))\n .file(\n \"c/src/lib.rs\",\n r#\"\n /// ```rust\n /// assert_eq!(1, 2);\n /// ```\n pub fn foo() {}\n \"#,\n )\n .file(\n \"c/src/main.rs\",\n r#\"\n fn main() {}\n\n #[test]\n fn from_main() { assert_eq!(1, 2); }\n \"#,\n )\n .file(\n \"c/tests/t1.rs\",\n r#\"\n #[test]\n fn from_int_test() { assert_eq!(1, 2); }\n \"#,\n )\n .file(\n \"c/examples/ex1.rs\",\n r#\"\n fn main() {}\n\n #[test]\n fn from_example() { assert_eq!(1, 2); }\n \"#,\n )\n // This does not use #[bench] since it is unstable. #[test] works just\n // the same for our purpose of checking the hint.\n .file(\n \"c/benches/b1.rs\",\n r#\"\n #[test]\n fn from_bench() { assert_eq!(1, 2); }\n \"#,\n )\n .build();\n\n // This depends on Units being sorted so that `b` fails first.\n p.cargo(\"test\")\n .with_stderr_data(\n str![[r#\"\n[COMPILING] c v0.1.0 ([ROOT]/foo/c)\n[COMPILING] a v0.1.0 ([ROOT]/foo/a)\n[COMPILING] b v0.1.0 ([ROOT]/foo/b)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/a-[HASH][EXE])\n[RUNNING] unittests src/lib.rs (target/debug/deps/b-[HASH][EXE])\n[ERROR] test failed, to rerun pass `-p b --lib`\n\n\"#]]\n .unordered(),\n )\n .with_status(101)\n .run();\n p.cargo(\"test\")\n .cwd(\"b\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs ([ROOT]/foo/target/debug/deps/b-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--lib`\n\n\"#]])\n .with_status(101)\n .run();\n p.cargo(\"test --no-fail-fast\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/a-[HASH][EXE])\n[RUNNING] unittests src/lib.rs (target/debug/deps/b-[HASH][EXE])\n[ERROR] test failed, to rerun pass `-p b --lib`\n[RUNNING] unittests src/lib.rs (target/debug/deps/c-[HASH][EXE])\n[RUNNING] unittests src/main.rs (target/debug/deps/c-[HASH][EXE])\n[ERROR] test failed, to rerun pass `-p c --bin c`\n[RUNNING] tests/t1.rs (target/debug/deps/t1-[HASH][EXE])\n[ERROR] test failed, to rerun pass `-p c --test t1`\n[DOCTEST] a\n[DOCTEST] b\n[DOCTEST] c\n[ERROR] doctest failed, to rerun pass `-p c --doc`\n[ERROR] 4 targets failed:\n `-p b --lib`\n `-p c --bin c`\n `-p c --test t1`\n `-p c --doc`\n\n\"#]])\n .with_status(101)\n .run();\n // Check others that are not in the default set.\n p.cargo(\"test -p c --examples --benches --no-fail-fast\")\n .with_stderr_data(str![[r#\"\n[COMPILING] c v0.1.0 ([ROOT]/foo/c)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/c-[HASH][EXE])\n[RUNNING] unittests src/main.rs (target/debug/deps/c-[HASH][EXE])\n[ERROR] test failed, to rerun pass `-p c --bin c`\n[RUNNING] benches/b1.rs (target/debug/deps/b1-[HASH][EXE])\n[ERROR] test failed, to rerun pass `-p c --bench b1`\n[RUNNING] unittests examples/ex1.rs (target/debug/examples/ex1-[HASH][EXE])\n[ERROR] test failed, to rerun pass `-p c --example ex1`\n[ERROR] 3 targets failed:\n `-p c --bin c`\n `-p c --bench b1`\n `-p c --example ex1`\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn test_hint_workspace_nonvirtual() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = [\"a\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"#[test] fn t1() {assert!(false)}\")\n .build();\n\n p.cargo(\"test --workspace\")\n .with_stderr_data(str![[r#\"\n...\n[ERROR] test failed, to rerun pass `-p a --lib`\n...\n\"#]])\n .with_status(101)\n .run();\n p.cargo(\"test -p a\")\n .with_stderr_data(str![[r#\"\n...\n[ERROR] test failed, to rerun pass `-p a --lib`\n...\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn json_artifact_includes_test_flag() {\n // Verify that the JSON artifact output includes `test` flag.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [profile.test]\n opt-level = 1\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test --lib -v --no-run --message-format=json\")\n .with_stdout_data(\n str![[r#\"\n[\n {\n \"executable\": \"[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]\",\n \"features\": [],\n \"filenames\": \"{...}\",\n \"fresh\": false,\n \"manifest_path\": \"[ROOT]/foo/Cargo.toml\",\n \"package_id\": \"path+[ROOTURL]/foo#0.0.1\",\n \"profile\": \"{...}\",\n \"reason\": \"compiler-artifact\",\n \"target\": {\n \"crate_types\": [\n \"lib\"\n ],\n \"doc\": true,\n \"doctest\": true,\n \"edition\": \"2015\",\n \"kind\": [\n \"lib\"\n ],\n \"name\": \"foo\",\n \"src_path\": \"[ROOT]/foo/src/lib.rs\",\n \"test\": true\n }\n },\n {\n \"reason\": \"build-finished\",\n \"success\": true\n }\n]\n\"#]]\n .is_json()\n .against_jsonlines(),\n )\n .run();\n}\n\n#[cargo_test]\nfn json_artifact_includes_executable_for_library_tests() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() { }\")\n .file(\"src/lib.rs\", r#\"#[test] fn lib_test() {}\"#)\n .build();\n\n p.cargo(\"test --lib -v --no-run --message-format=json\")\n .with_stdout_data(\n str![[r#\"\n[\n {\n \"executable\": \"[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]\",\n \"features\": [],\n \"filenames\": \"{...}\",\n \"fresh\": false,\n \"manifest_path\": \"[ROOT]/foo/Cargo.toml\",\n \"package_id\": \"path+[ROOTURL]/foo#0.0.1\",\n \"profile\": \"{...}\",\n \"reason\": \"compiler-artifact\",\n \"target\": {\n \"crate_types\": [\n \"lib\"\n ],\n \"doc\": true,\n \"doctest\": true,\n \"edition\": \"2015\",\n \"kind\": [\n \"lib\"\n ],\n \"name\": \"foo\",\n \"src_path\": \"[ROOT]/foo/src/lib.rs\",\n \"test\": true\n }\n },\n {\n \"reason\": \"build-finished\",\n \"success\": true\n }\n]\n\"#]]\n .is_json()\n .against_jsonlines(),\n )\n .run();\n}\n\n#[cargo_test]\nfn json_diagnostic_includes_explanation() {\n let p = project()\n .file(\n \"src/main.rs\",\n \"fn main() { const OH_NO: &'static mut usize = &mut 1; }\",\n )\n .build();\n\n p.cargo(\"check --message-format=json\")\n .with_stdout_data(\n str![[r#\"\n[\n {\n \"manifest_path\": \"[ROOT]/foo/Cargo.toml\",\n \"message\": {\n \"$message_type\": \"diagnostic\",\n \"children\": \"{...}\",\n \"code\": {\n \"code\": \"E0764\",\n \"explanation\": \"{...}\"\n },\n \"level\": \"error\",\n \"message\": \"{...}\",\n \"rendered\": \"{...}\",\n \"spans\": \"{...}\"\n },\n \"package_id\": \"{...}\",\n \"reason\": \"compiler-message\",\n \"target\": \"{...}\"\n },\n \"{...}\"\n]\n\"#]]\n .is_json()\n .against_jsonlines(),\n )\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn json_artifact_includes_executable_for_integration_tests() {\n let p = project()\n .file(\n \"tests/integration_test.rs\",\n r#\"#[test] fn integration_test() {}\"#,\n )\n .build();\n\n p.cargo(\"test -v --no-run --message-format=json --test integration_test\")\n .with_stdout_data(\n str![[r#\"\n[\n {\n \"executable\": \"[ROOT]/foo/target/debug/deps/integration_test-[HASH][EXE]\",\n \"features\": [],\n \"filenames\": \"{...}\",\n \"fresh\": false,\n \"manifest_path\": \"[ROOT]/foo/Cargo.toml\",\n \"package_id\": \"path+[ROOTURL]/foo#0.0.1\",\n \"profile\": \"{...}\",\n \"reason\": \"compiler-artifact\",\n \"target\": {\n \"crate_types\": [\n \"bin\"\n ],\n \"doc\": false,\n \"doctest\": false,\n \"edition\": \"2015\",\n \"kind\": [\n \"test\"\n ],\n \"name\": \"integration_test\",\n \"src_path\": \"[ROOT]/foo/tests/integration_test.rs\",\n \"test\": true\n }\n },\n {\n \"reason\": \"build-finished\",\n \"success\": true\n }\n]\n\"#]]\n .is_json()\n .against_jsonlines(),\n )\n .run();\n}\n\n#[cargo_test]\nfn test_build_script_links() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n links = 'something'\n\n [lib]\n test = false\n \"#,\n )\n .file(\"build.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test --no-run\").run();\n}\n\n#[cargo_test]\nfn doctest_skip_staticlib() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [lib]\n crate-type = [\"staticlib\"]\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n //! ```\n //! assert_eq!(1,2);\n //! ```\n \"#,\n )\n .build();\n\n p.cargo(\"test --doc\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[WARNING] doc tests are not supported for crate type(s) `staticlib` in package `foo`\n[ERROR] no library targets found in package `foo`\n\n\"#]])\n .run();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn can_not_mix_doc_tests_and_regular_tests() {\n let p = project()\n .file(\n \"src/lib.rs\",\n \"\\\n/// ```\n/// assert_eq!(1, 1)\n/// ```\npub fn foo() -> u8 { 1 }\n\n#[cfg(test)] mod tests {\n #[test] fn it_works() { assert_eq!(2 + 2, 4); }\n}\n\",\n )\n .build();\n\n p.cargo(\"test\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n[DOCTEST] foo\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest tests::it_works ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\nrunning 1 test\ntest src/lib.rs - foo (line 1) ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n p.cargo(\"test --lib\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest tests::it_works ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .run();\n\n // This has been modified to attempt to diagnose spurious errors on CI.\n // For some reason, this is recompiling the lib when it shouldn't. If the\n // root cause is ever found, the changes here should be reverted.\n // See https://github.com/rust-lang/cargo/issues/6887\n p.cargo(\"test --doc -vv\")\n .with_stderr_does_not_contain(\"[COMPILING] foo [..]\")\n .with_stderr_data(str![[r#\"\n...\n[DOCTEST] foo\n...\n\"#]])\n .with_stdout_data(str![[r#\"\n\nrunning 1 test\ntest src/lib.rs - foo (line 1) ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n\n\n\"#]])\n .env(\"CARGO_LOG\", \"cargo=trace\")\n .run();\n\n p.cargo(\"test --lib --doc\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] can't mix --doc with other target selecting options\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn can_not_no_run_doc_tests() {\n let p = project()\n .file(\n \"src/lib.rs\",\n r#\"\n /// ```\n /// let _x = 1 + \"foo\";\n /// ```\n pub fn foo() -> u8 { 1 }\n \"#,\n )\n .build();\n\n p.cargo(\"test --doc --no-run\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] can't skip running doc tests with --no-run\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_all_targets_lib() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"test --all-targets\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] unittests src/lib.rs (target/debug/deps/foo-[HASH][EXE])\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn test_dep_with_dev() {\n Package::new(\"devdep\", \"0.1.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n bar = { path = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dev-dependencies]\n devdep = \"0.1\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test -p bar\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[ERROR] package `bar` cannot be tested because it requires dev-dependencies and is not a member of the workspace\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_doctest_xcompile_ignores() {\n // Check ignore-TARGET syntax.\n let p = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\n \"src/lib.rs\",\n r#\"\n ///```ignore-x86_64\n ///assert!(cfg!(not(target_arch = \"x86_64\")));\n ///```\n pub fn foo() -> u8 {\n 4\n }\n \"#,\n )\n .build();\n\n p.cargo(\"build\").run();\n #[cfg(not(target_arch = \"x86_64\"))]\n p.cargo(\"test\")\n .with_stdout_data(str![[r#\"\n...\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n...\n\"#]])\n .run();\n #[cfg(target_arch = \"x86_64\")]\n p.cargo(\"test\")\n .with_stdout_data(str![[r#\"\n...\ntest result: ok. 0 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_doctest_xcompile_runner() {\n if !cross_compile_can_run_on_host() {\n return;\n }\n\n let runner = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"runner\"))\n .file(\n \"src/main.rs\",\n r#\"\n pub fn main() {\n eprintln!(\"this is a runner\");\n let args: Vec = std::env::args().collect();\n std::process::Command::new(&args[1]).spawn();\n }\n \"#,\n )\n .build();\n\n runner.cargo(\"build\").run();\n assert!(runner.bin(\"runner\").is_file());\n let runner_path = paths::root().join(\"runner\");\n fs::copy(&runner.bin(\"runner\"), &runner_path).unwrap();\n\n let config = paths::root().join(\".cargo/config.toml\");\n\n fs::create_dir_all(config.parent().unwrap()).unwrap();\n // Escape Windows backslashes for TOML config.\n let runner_str = runner_path.to_str().unwrap().replace('\\\\', \"\\\\\\\\\");\n fs::write(\n config,\n format!(\n r#\"\n [target.'cfg(target_arch = \"{}\")']\n runner = \"{}\"\n \"#,\n cross_compile::alternate_arch(),\n runner_str\n ),\n )\n .unwrap();\n\n let p = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\n \"src/lib.rs\",\n &format!(\n r#\"\n ///```\n ///assert!(cfg!(target_arch = \"{}\"));\n ///```\n pub fn foo() -> u8 {{\n 4\n }}\n \"#,\n cross_compile::alternate_arch()\n ),\n )\n .build();\n\n p.cargo(\"build\").run();\n p.cargo(&format!(\"test --target {}\", cross_compile::alternate()))\n .with_stdout_data(str![[r#\"\n...\nrunning 0 tests\n...\n\"#]])\n .run();\n p.cargo(&format!(\"test --target {}\", cross_compile::alternate()))\n .with_stdout_data(str![[r#\"\n...\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n...\n\"#]])\n .with_stderr_data(str![[r#\"\n...\nthis is a runner\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_doctest_xcompile_no_runner() {\n if !cross_compile_can_run_on_host() {\n return;\n }\n\n let p = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\n \"src/lib.rs\",\n &format!(\n r#\"\n ///```\n ///assert!(cfg!(target_arch = \"{}\"));\n ///```\n pub fn foo() -> u8 {{\n 4\n }}\n \"#,\n cross_compile::alternate_arch()\n ),\n )\n .build();\n\n p.cargo(\"build\").run();\n p.cargo(&format!(\"test --target {}\", cross_compile::alternate()))\n .with_stdout_data(str![[r#\"\n...\nrunning 0 tests\n...\n\"#]])\n .run();\n p.cargo(&format!(\"test --target {}\", cross_compile::alternate()))\n .with_stdout_data(str![[r#\"\n...\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in [ELAPSED]s\n...\n\"#]])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zpanic-abort-tests in rustc is unstable\")]\nfn panic_abort_tests() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = 'foo'\n version = '0.1.0'\n edition = \"2015\"\n\n [dependencies]\n a = { path = 'a' }\n\n [profile.dev]\n panic = 'abort'\n [profile.test]\n panic = 'abort'\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n #[test]\n fn foo() {\n a::foo();\n }\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_lib_manifest(\"a\"))\n .file(\"a/src/lib.rs\", \"pub fn foo() {}\")\n .build();\n\n // This uses -j1 because of a race condition. Otherwise it will build the\n // two copies of `foo` in parallel, and which one is first is random. If\n // `--test` is first, then the first line with `[..]` will match, and the\n // second line with `--test` will fail.\n p.cargo(\"test -Z panic-abort-tests -v -j1\")\n .with_stderr_data(\n str![[r#\"\n[RUNNING] `[..]--crate-name a [..]-C panic=abort[..]`\n[RUNNING] `[..]--crate-name foo [..]-C panic=abort[..]`\n[RUNNING] `[..]--crate-name foo [..]-C panic=abort[..]--test[..]`\n...\n\"#]]\n .unordered(),\n )\n .masquerade_as_nightly_cargo(&[\"panic-abort-tests\"])\n .run();\n}\n\n#[cargo_test] // Unlike with rustc, `rustdoc --test -Cpanic=abort` already works on stable\nfn panic_abort_doc_tests() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = 'foo'\n version = '0.1.0'\n edition = \"2015\"\n\n [profile.dev]\n panic = 'abort'\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n //! ```should_panic\n //! panic!();\n //! ```\n \"#,\n )\n .build();\n\n p.cargo(\"test --doc -Z panic-abort-tests -v\")\n .with_stderr_data(\n str![[r#\"\n[RUNNING] `[..]rustc[..] --crate-name foo [..]-C panic=abort[..]`\n[RUNNING] `[..]rustdoc[..] --crate-name foo [..]--test[..]-C panic=abort[..]`\n...\n\"#]]\n .unordered(),\n )\n .masquerade_as_nightly_cargo(&[\"panic-abort-tests\"])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zpanic-abort-tests in rustc is unstable\")]\nfn panic_abort_only_test() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = 'foo'\n version = '0.1.0'\n edition = \"2015\"\n\n [dependencies]\n a = { path = 'a' }\n\n [profile.test]\n panic = 'abort'\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n #[test]\n fn foo() {\n a::foo();\n }\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_lib_manifest(\"a\"))\n .file(\"a/src/lib.rs\", \"pub fn foo() {}\")\n .build();\n\n p.cargo(\"test -Z panic-abort-tests -v\")\n .with_stderr_data(str![[r#\"\n[WARNING] `panic` setting is ignored for `test` profile\n...\n\"#]])\n .masquerade_as_nightly_cargo(&[\"panic-abort-tests\"])\n .run();\n}\n\n#[cargo_test(nightly, reason = \"-Zpanic-abort-tests in rustc is unstable\")]\nfn panic_abort_test_profile_inherits() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = 'foo'\n version = '0.1.0'\n edition = \"2015\"\n\n [dependencies]\n a = { path = 'a' }\n\n [profile.dev]\n panic = 'abort'\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n #[test]\n fn foo() {\n a::foo();\n }\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_lib_manifest(\"a\"))\n .file(\"a/src/lib.rs\", \"pub fn foo() {}\")\n .build();\n\n p.cargo(\"test -Z panic-abort-tests -v\")\n .masquerade_as_nightly_cargo(&[\"panic-abort-tests\"])\n .with_status(0)\n .run();\n}\n\n#[cargo_test]\nfn bin_env_for_test() {\n // Test for the `CARGO_BIN_EXE_` environment variables for tests.\n //\n // Note: The Unicode binary uses a `[[bin]]` definition because different\n // filesystems normalize utf-8 in different ways. For example, HFS uses\n // \"gru\\u{308}Ɵen\" and APFS uses \"gr\\u{fc}Ɵen\". Defining it in TOML forces\n // one form to be used.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2018\"\n\n [[bin]]\n name = 'grĆ¼ĆŸen'\n path = 'src/bin/grussen.rs'\n \"#,\n )\n .file(\"src/bin/foo.rs\", \"fn main() {}\")\n .file(\"src/bin/with-dash.rs\", \"fn main() {}\")\n .file(\"src/bin/grussen.rs\", \"fn main() {}\")\n .file(\n \"src/lib.rs\",\n r#\"\n //! ```\n //! assert_eq!(option_env!(\"CARGO_BIN_EXE_foo\"), None);\n //! assert_eq!(option_env!(\"CARGO_BIN_EXE_with-dash\"), None);\n //! assert_eq!(option_env!(\"CARGO_BIN_EXE_grĆ¼ĆŸen\"), None);\n //! assert_eq!(std::env::var(\"CARGO_BIN_EXE_foo\").ok(), None);\n //! assert_eq!(std::env::var(\"CARGO_BIN_EXE_with-dash\").ok(), None);\n //! assert_eq!(std::env::var(\"CARGO_BIN_EXE_grĆ¼ĆŸen\").ok(), None);\n //! ```\n\n #[test]\n fn no_bins() {\n assert_eq!(option_env!(\"CARGO_BIN_EXE_foo\"), None);\n assert_eq!(option_env!(\"CARGO_BIN_EXE_with-dash\"), None);\n assert_eq!(option_env!(\"CARGO_BIN_EXE_grĆ¼ĆŸen\"), None);\n assert_eq!(std::env::var(\"CARGO_BIN_EXE_foo\").ok(), None);\n assert_eq!(std::env::var(\"CARGO_BIN_EXE_with-dash\").ok(), None);\n assert_eq!(std::env::var(\"CARGO_BIN_EXE_grĆ¼ĆŸen\").ok(), None);\n }\n\"#,\n )\n .build();\n\n let bin_path = |name| p.bin(name).to_string_lossy().replace(\"\\\\\", \"\\\\\\\\\");\n p.change_file(\n \"tests/check_env.rs\",\n &r#\"\n #[test]\n fn run_bins() {\n assert_eq!(env!(\"CARGO_BIN_EXE_foo\"), \"\");\n assert_eq!(env!(\"CARGO_BIN_EXE_with-dash\"), \"\");\n assert_eq!(env!(\"CARGO_BIN_EXE_grĆ¼ĆŸen\"), \"\");\n assert_eq!(std::env::var(\"CARGO_BIN_EXE_foo\").ok().as_deref(), Some(\"\"));\n assert_eq!(std::env::var(\"CARGO_BIN_EXE_with-dash\").ok().as_deref(), Some(\"\"));\n assert_eq!(std::env::var(\"CARGO_BIN_EXE_grĆ¼ĆŸen\").ok().as_deref(), Some(\"\"));\n }\n \"#\n .replace(\"\", &bin_path(\"foo\"))\n .replace(\"\", &bin_path(\"with-dash\"))\n .replace(\"\", &bin_path(\"grĆ¼ĆŸen\")),\n );\n\n p.cargo(\"test\").run();\n p.cargo(\"check --all-targets\").run();\n}\n\n#[cargo_test]\nfn test_workspaces_cwd() {\n // This tests that all the different test types are executed from the\n // crate directory (manifest_dir), and not from the workspace root.\n\n let make_lib_file = |expected| {\n format!(\n r#\"\n //! ```\n //! assert_eq!(\"{expected}\", std::fs::read_to_string(\"file.txt\").unwrap());\n //! assert_eq!(\"{expected}\", include_str!(\"../file.txt\"));\n //! assert_eq!(\n //! std::path::PathBuf::from(std::env!(\"CARGO_MANIFEST_DIR\")),\n //! std::env::current_dir().unwrap(),\n //! );\n //! ```\n\n #[test]\n fn test_unit_{expected}_cwd() {{\n assert_eq!(\"{expected}\", std::fs::read_to_string(\"file.txt\").unwrap());\n assert_eq!(\"{expected}\", include_str!(\"../file.txt\"));\n assert_eq!(\n std::path::PathBuf::from(std::env!(\"CARGO_MANIFEST_DIR\")),\n std::env::current_dir().unwrap(),\n );\n }}\n \"#,\n expected = expected\n )\n };\n let make_test_file = |expected| {\n format!(\n r#\"\n #[test]\n fn test_integration_{expected}_cwd() {{\n assert_eq!(\"{expected}\", std::fs::read_to_string(\"file.txt\").unwrap());\n assert_eq!(\"{expected}\", include_str!(\"../file.txt\"));\n assert_eq!(\n std::path::PathBuf::from(std::env!(\"CARGO_MANIFEST_DIR\")),\n std::env::current_dir().unwrap(),\n );\n }}\n \"#,\n expected = expected\n )\n };\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"root-crate\"\n version = \"0.0.0\"\n\n [workspace]\n members = [\".\", \"nested-crate\", \"very/deeply/nested/deep-crate\"]\n \"#,\n )\n .file(\"file.txt\", \"root\")\n .file(\"src/lib.rs\", &make_lib_file(\"root\"))\n .file(\"tests/integration.rs\", &make_test_file(\"root\"))\n .file(\n \"nested-crate/Cargo.toml\",\n r#\"\n [package]\n name = \"nested-crate\"\n version = \"0.0.0\"\n \"#,\n )\n .file(\"nested-crate/file.txt\", \"nested\")\n .file(\"nested-crate/src/lib.rs\", &make_lib_file(\"nested\"))\n .file(\n \"nested-crate/tests/integration.rs\",\n &make_test_file(\"nested\"),\n )\n .file(\n \"very/deeply/nested/deep-crate/Cargo.toml\",\n r#\"\n [package]\n name = \"deep-crate\"\n version = \"0.0.0\"\n \"#,\n )\n .file(\"very/deeply/nested/deep-crate/file.txt\", \"deep\")\n .file(\n \"very/deeply/nested/deep-crate/src/lib.rs\",\n &make_lib_file(\"deep\"),\n )\n .file(\n \"very/deeply/nested/deep-crate/tests/integration.rs\",\n &make_test_file(\"deep\"),\n )\n .build();\n\n p.cargo(\"test --workspace --all\")\n .with_stderr_data(\n str![[r#\"\n[DOCTEST] root_crate\n[DOCTEST] nested_crate\n[DOCTEST] deep_crate\n...\n\"#]]\n .unordered(),\n )\n .with_stdout_data(\n str![[r#\"\ntest test_unit_root_cwd ... ok\ntest test_unit_nested_cwd ... ok\ntest test_unit_deep_cwd ... ok\ntest test_integration_root_cwd ... ok\ntest test_integration_nested_cwd ... ok\ntest test_integration_deep_cwd ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(\"test -p root-crate --all\")\n .with_stderr_data(str![[r#\"\n...\n[DOCTEST] root_crate\n...\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest test_unit_root_cwd ... ok\ntest test_integration_root_cwd ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(\"test -p nested-crate --all\")\n .with_stderr_data(str![[r#\"\n...\n[DOCTEST] nested_crate\n...\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest test_unit_nested_cwd ... ok\ntest test_integration_nested_cwd ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(\"test -p deep-crate --all\")\n .with_stderr_data(str![[r#\"\n...\n[DOCTEST] deep_crate\n...\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest test_unit_deep_cwd ... ok\ntest test_integration_deep_cwd ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(\"test --all\")\n .cwd(\"nested-crate\")\n .with_stderr_data(str![[r#\"\n...\n[DOCTEST] nested_crate\n...\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest test_unit_nested_cwd ... ok\ntest test_integration_nested_cwd ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n\n p.cargo(\"test --all\")\n .cwd(\"very/deeply/nested/deep-crate\")\n .with_stderr_data(str![[r#\"\n...\n[DOCTEST] deep_crate\n...\n\"#]])\n .with_stdout_data(\n str![[r#\"\ntest test_unit_deep_cwd ... ok\ntest test_integration_deep_cwd ... ok\n...\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn execution_error() {\n // Checks the behavior when a test fails to launch.\n let p = project()\n .file(\n \"tests/t1.rs\",\n r#\"\n #[test]\n fn foo() {}\n \"#,\n )\n .build();\n let key = format!(\"CARGO_TARGET_{}_RUNNER\", rustc_host_env());\n p.cargo(\"test\")\n .env(&key, \"does_not_exist\")\n // The actual error is usually \"no such file\", but on Windows it has a\n // custom message. Since matching against the error string produced by\n // Rust is not very reliable, this just uses `[..]`.\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/t1.rs (target/debug/deps/t1-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--test t1`\n\nCaused by:\n could not execute process `does_not_exist [ROOT]/foo/target/debug/deps/t1-[HASH][EXE]` (never executed)\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn nonzero_exit_status() {\n // Tests for nonzero exit codes from tests.\n let p = project()\n .file(\n \"tests/t1.rs\",\n r#\"\n #[test]\n fn t() { panic!(\"this is a normal error\") }\n \"#,\n )\n .file(\n \"tests/t2.rs\",\n r#\"\n #[test]\n fn t() { std::process::exit(4) }\n \"#,\n )\n .build();\n\n p.cargo(\"test --test t1\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/t1.rs (target/debug/deps/t1-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--test t1`\n\n\"#]])\n .with_stdout_data(str![[r#\"\n...\nthis is a normal error\n...\n\"#]])\n .with_status(101)\n .run();\n\n p.cargo(\"test --test t2\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/t2.rs (target/debug/deps/t2-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--test t2`\n\nCaused by:\n process didn't exit successfully: `[ROOT]/foo/target/debug/deps/t2-[HASH][EXE]` ([EXIT_STATUS]: 4)\n[NOTE] test exited abnormally; to see the full output pass --no-capture to the harness.\n\n\"#]])\n .with_status(4)\n .run();\n\n p.cargo(\"test --test t2 -- --no-capture\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/t2.rs (target/debug/deps/t2-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--test t2`\n\nCaused by:\n process didn't exit successfully: `[ROOT]/foo/target/debug/deps/t2-[HASH][EXE] --no-capture` ([EXIT_STATUS]: 4)\n\n\"#]])\n .with_status(4)\n .run();\n\n // no-fail-fast always uses 101\n p.cargo(\"test --no-fail-fast\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] tests/t1.rs (target/debug/deps/t1-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--test t1`\n[RUNNING] tests/t2.rs (target/debug/deps/t2-[HASH][EXE])\n[ERROR] test failed, to rerun pass `--test t2`\n\nCaused by:\n process didn't exit successfully: `[ROOT]/foo/target/debug/deps/t2-[HASH][EXE]` ([EXIT_STATUS]: 4)\n[NOTE] test exited abnormally; to see the full output pass --no-capture to the harness.\n[ERROR] 2 targets failed:\n `--test t1`\n `--test t2`\n\n\"#]])\n .with_status(101)\n .run();\n\n p.cargo(\"test --no-fail-fast -- --no-capture\")\n .with_stderr_does_not_contain(\n \"test exited abnormally; to see the full output pass --no-capture to the harness.\",\n )\n .with_stderr_data(str![[r#\"\n[..]thread [..]panicked [..] tests/t1.rs[..]\n[NOTE] run with `RUST_BACKTRACE=1` environment variable to display a backtrace\nCaused by:\n process didn't exit successfully: `[ROOT]/foo/target/debug/deps/t2-[HASH][EXE] --no-capture` ([EXIT_STATUS]: 4)\n...\n\"#]].unordered())\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn cargo_test_print_env_verbose() {\n let p = project()\n .file(\"Cargo.toml\", &basic_manifest(\"foo\", \"0.0.1\"))\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"test -vv\").with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `[..]CARGO_MANIFEST_DIR=[ROOT]/foo[..] rustc --crate-name foo[..]`\n[RUNNING] `[..]CARGO_MANIFEST_DIR=[ROOT]/foo[..] rustc --crate-name foo[..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `[..]CARGO_MANIFEST_DIR=[ROOT]/foo[..] [ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`\n[DOCTEST] foo\n[RUNNING] `[..]CARGO_MANIFEST_DIR=[ROOT]/foo[..] rustdoc --edition=2015 --crate-type lib --color auto --crate-name foo[..]`\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn cargo_test_set_out_dir_env_var() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n \"#,\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn add(left: u64, right: u64) -> u64 {\n left + right\n }\n \"#,\n )\n .file(\n \"build.rs\",\n r#\"\n fn main() {}\n \"#,\n )\n .file(\n \"tests/case.rs\",\n r#\"\n #[cfg(test)]\n pub mod tests {\n #[test]\n fn test_add() {\n assert!(std::env::var(\"OUT_DIR\").is_ok());\n assert_eq!(foo::add(2, 5), 7);\n }\n }\n \"#,\n )\n .build();\n\n p.cargo(\"test\").run();\n p.cargo(\"test --package foo --test case -- tests::test_add --exact --no-capture\")\n .run();\n}\n" }, { "path": "tests/testsuite/timings.rs", "content": "//! Tests for --timings.\n\nuse crate::prelude::*;\nuse cargo_test_support::project;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::str;\n\n#[cargo_test]\nfn timings_works() {\n Package::new(\"dep\", \"0.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n dep = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"tests/t1.rs\", \"\")\n .file(\"examples/ex1.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"build --all-targets --timings\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] dep v0.1.0 (registry `dummy-registry`)\n[COMPILING] dep v0.1.0\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n Timing report saved to [ROOT]/foo/target/cargo-timings/cargo-timing-[..].html\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"clean\").run();\n\n p.cargo(\"test --timings\").run();\n\n p.cargo(\"clean\").run();\n\n p.cargo(\"check --timings\").run();\n\n p.cargo(\"clean\").run();\n\n p.cargo(\"doc --timings\").run();\n}\n" }, { "path": "tests/testsuite/tool_paths.rs", "content": "//! Tests for configuration values that point to programs.\n\nuse crate::prelude::*;\nuse cargo_test_support::{basic_lib_manifest, project, rustc_host, rustc_host_env, str};\n\n#[cargo_test]\nfn pathless_tools() {\n let target = rustc_host();\n\n let foo = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.{}]\n linker = \"nonexistent-linker\"\n \"#,\n target\n ),\n )\n .build();\n\n foo.cargo(\"build --verbose\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc [..]-C linker=nonexistent-linker [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n// can set a custom linker via `target.'cfg(..)'.linker`\n#[cargo_test]\nfn custom_linker_cfg() {\n let foo = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [target.'cfg(not(target_os = \"none\"))']\n linker = \"nonexistent-linker\"\n \"#,\n )\n .build();\n\n foo.cargo(\"build --verbose\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc [..]-C linker=nonexistent-linker [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n// custom linker set via `target.$triple.linker` have precede over `target.'cfg(..)'.linker`\n#[cargo_test]\nfn custom_linker_cfg_precedence() {\n let target = rustc_host();\n\n let foo = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.'cfg(not(target_os = \"none\"))']\n linker = \"ignored-linker\"\n [target.{}]\n linker = \"nonexistent-linker\"\n \"#,\n target\n ),\n )\n .build();\n\n foo.cargo(\"build --verbose\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc [..]-C linker=nonexistent-linker [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn custom_linker_cfg_collision() {\n let foo = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [target.'cfg(not(target_arch = \"avr\"))']\n linker = \"nonexistent-linker1\"\n [target.'cfg(not(target_os = \"none\"))']\n linker = \"nonexistent-linker2\"\n \"#,\n )\n .build();\n\n foo.cargo(\"build --verbose\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] several matching instances of `target.'cfg(..)'.linker` in configurations\nfirst match `cfg(not(target_arch = \"avr\"))` located in [ROOT]/foo/.cargo/config.toml\nsecond match `cfg(not(target_os = \"none\"))` located in [ROOT]/foo/.cargo/config.toml\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn absolute_tools() {\n let target = rustc_host();\n\n // Escaped as they appear within a TOML config file\n let linker = if cfg!(windows) {\n r#\"C:\\\\bogus\\\\nonexistent-linker\"#\n } else {\n r#\"/bogus/nonexistent-linker\"#\n };\n\n let foo = project()\n .file(\"Cargo.toml\", &basic_lib_manifest(\"foo\"))\n .file(\"src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.{target}]\n linker = \"{linker}\"\n \"#,\n target = target,\n linker = linker\n ),\n )\n .build();\n\n foo.cargo(\"build --verbose\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.5.0 ([ROOT]/foo)\n[RUNNING] `rustc [..]-C linker=[..]/bogus/nonexistent-linker [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn relative_tools() {\n let target = rustc_host();\n\n // Escaped as they appear within a TOML config file\n let linker = if cfg!(windows) {\n r#\".\\\\tools\\\\nonexistent-linker\"#\n } else {\n r#\"./tools/nonexistent-linker\"#\n };\n\n // Funky directory structure to test that relative tool paths are made absolute\n // by reference to the `.cargo/..` directory and not to (for example) the CWD.\n let p = project()\n .no_manifest()\n .file(\"bar/Cargo.toml\", &basic_lib_manifest(\"bar\"))\n .file(\"bar/src/lib.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.{target}]\n linker = \"{linker}\"\n \"#,\n target = target,\n linker = linker\n ),\n )\n .build();\n\n p.cargo(\"build --verbose\")\n .cwd(\"bar\")\n .with_stderr_data(str![[r#\"\n[COMPILING] bar v0.5.0 ([ROOT]/foo/bar)\n[RUNNING] `rustc [..]-C linker=[ROOT]/foo/./tools/nonexistent-linker [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn custom_runner() {\n let target = rustc_host();\n\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"tests/test.rs\", \"\")\n .file(\"benches/bench.rs\", \"\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.{}]\n runner = \"nonexistent-runner -r\"\n \"#,\n target\n ),\n )\n .build();\n\n p.cargo(\"run -- --param\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `nonexistent-runner -r target/debug/foo[EXE] --param`\n...\n\"#]])\n .run();\n\n p.cargo(\"test --test test --verbose -- --param\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\n[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `nonexistent-runner -r [ROOT]/foo/target/debug/deps/test-[HASH][EXE] --param`\n...\n\"#]])\n .run();\n\n p.cargo(\"bench --bench bench --verbose -- --param\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]`\n[RUNNING] `rustc [..]`\n[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s\n[RUNNING] `nonexistent-runner -r [ROOT]/foo/target/release/deps/bench-[HASH][EXE] --param --bench`\n...\n\"#]])\n .run();\n}\n\n// can set a custom runner via `target.'cfg(..)'.runner`\n#[cargo_test]\nfn custom_runner_cfg() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [target.'cfg(not(target_os = \"none\"))']\n runner = \"nonexistent-runner -r\"\n \"#,\n )\n .build();\n\n p.cargo(\"run -- --param\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `nonexistent-runner -r target/debug/foo[EXE] --param`\n...\n\"#]])\n .run();\n}\n\n// custom runner set via `target.$triple.runner` have precedence over `target.'cfg(..)'.runner`\n#[cargo_test]\nfn custom_runner_cfg_precedence() {\n let target = rustc_host();\n\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.'cfg(not(target_os = \"none\"))']\n runner = \"ignored-runner\"\n\n [target.{}]\n runner = \"nonexistent-runner -r\"\n \"#,\n target\n ),\n )\n .build();\n\n p.cargo(\"run -- --param\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `nonexistent-runner -r target/debug/foo[EXE] --param`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn custom_runner_cfg_collision() {\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n r#\"\n [target.'cfg(not(target_arch = \"avr\"))']\n runner = \"true\"\n\n [target.'cfg(not(target_os = \"none\"))']\n runner = \"false\"\n \"#,\n )\n .build();\n\n p.cargo(\"run -- --param\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] several matching instances of `target.'cfg(..)'.runner` in configurations\nfirst match `cfg(not(target_arch = \"avr\"))` located in [ROOT]/foo/.cargo/config.toml\nsecond match `cfg(not(target_os = \"none\"))` located in [ROOT]/foo/.cargo/config.toml\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn custom_runner_env() {\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n\n let key = format!(\"CARGO_TARGET_{}_RUNNER\", rustc_host_env());\n\n p.cargo(\"run\")\n .env(&key, \"nonexistent-runner --foo\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `nonexistent-runner --foo target/debug/foo[EXE]`\n[ERROR] could not execute process `nonexistent-runner --foo target/debug/foo[EXE]` (never executed)\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn custom_runner_env_overrides_config() {\n let target = rustc_host();\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.{}]\n runner = \"should-not-run -r\"\n \"#,\n target\n ),\n )\n .build();\n\n let key = format!(\"CARGO_TARGET_{}_RUNNER\", rustc_host_env());\n\n p.cargo(\"run\")\n .env(&key, \"should-run --foo\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\n[RUNNING] `should-run --foo target/debug/foo[EXE]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\n#[cfg(unix)] // Assumes `true` is in PATH.\nfn custom_runner_env_true() {\n // Check for a bug where \"true\" was interpreted as a boolean instead of\n // the executable.\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n\n let key = format!(\"CARGO_TARGET_{}_RUNNER\", rustc_host_env());\n\n p.cargo(\"run\")\n .env(&key, \"true\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `true target/debug/foo[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn custom_runner_target_applies_to_host() {\n // This ensures that without `--target` (non-cross-target mode)\n // Cargo still respects targe configuration.\n let target = rustc_host();\n\n let p = project()\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [target.{}]\n runner = \"nonexistent-runner -r\"\n \"#,\n target\n ),\n )\n .build();\n\n p.cargo(\"run -Z target-applies-to-host\")\n .masquerade_as_nightly_cargo(&[\"target-applies-to-host\"])\n .env(\"CARGO_TARGET_APPLIES_TO_HOST\", \"false\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `nonexistent-runner -r target/debug/foo[EXE]`\n[ERROR] could not execute process `nonexistent-runner -r target/debug/foo[EXE]` (never executed)\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn custom_linker_env() {\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n\n let key = format!(\"CARGO_TARGET_{}_LINKER\", rustc_host_env());\n\n p.cargo(\"build -v\")\n .env(&key, \"nonexistent-linker\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc [..]-C linker=nonexistent-linker [..]`\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn target_in_environment_contains_lower_case() {\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n\n let target = rustc_host();\n let env_key = format!(\n \"CARGO_TARGET_{}_LINKER\",\n target.to_lowercase().replace('-', \"_\")\n );\n\n p.cargo(\"build -v --target\")\n .arg(target)\n .env(&env_key, \"nonexistent-linker\")\n .with_stderr_data(format!(\"\\\n[WARNING] environment variables are expected to use uppercase letters and underscores, the variable `{env_key}` will be ignored and have no effect\n[WARNING] environment variables are expected to use uppercase letters and underscores, the variable `{env_key}` will be ignored and have no effect\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] `rustc --crate-name foo --edition=2015 src/main.rs [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\"\n ))\n .run();\n}\n\n#[cargo_test]\nfn cfg_ignored_fields() {\n // Test for some ignored fields in [target.'cfg()'] tables.\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n # Try some empty tables.\n [target.'cfg(not(foo))']\n [target.'cfg(not(bar))'.somelib]\n\n # A bunch of unused fields.\n [target.'cfg(not(target_os = \"none\"))']\n linker = 'false'\n ar = 'false'\n foo = {rustc-flags = \"-l foo\"}\n invalid = 1\n runner = 'false'\n rustflags = ''\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[WARNING] unused key `somelib` in [target] config table `cfg(not(bar))`\n[WARNING] unused key `ar` in [target] config table `cfg(not(target_os = \"none\"))`\n[WARNING] unused key `foo` in [target] config table `cfg(not(target_os = \"none\"))`\n[WARNING] unused key `invalid` in [target] config table `cfg(not(target_os = \"none\"))`\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/unit_graph.rs", "content": "//! Tests for --unit-graph option.\n\nuse crate::prelude::*;\nuse cargo_test_support::project;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::str;\n\n#[cargo_test]\nfn gated() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n p.cargo(\"build --unit-graph\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] the `--unit-graph` flag is unstable, and only available on the nightly channel of Cargo, but this is the `stable` channel\nSee https://doc.rust-lang.org/book/[..].html for more information about Rust release channels.\nSee https://github.com/rust-lang/cargo/issues/8002 for more information about the `--unit-graph` flag.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn simple() {\n Package::new(\"a\", \"1.0.0\")\n .dep(\"b\", \"1.0\")\n .feature(\"feata\", &[\"b/featb\"])\n .publish();\n Package::new(\"b\", \"1.0.0\")\n .dep(\"c\", \"1.0\")\n .feature(\"featb\", &[\"c/featc\"])\n .publish();\n Package::new(\"c\", \"1.0.0\").feature(\"featc\", &[]).publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"build --features a/feata --unit-graph -Zunstable-options\")\n .masquerade_as_nightly_cargo(&[\"unit-graph\"])\n .with_stdout_data(\n str![[r#\"\n{\n \"roots\": [\n 3\n ],\n \"units\": [\n {\n \"dependencies\": [\n {\n \"extern_crate_name\": \"b\",\n \"index\": 1,\n \"noprelude\": false,\n \"nounused\": false,\n \"public\": false\n }\n ],\n \"features\": [\n \"feata\"\n ],\n \"mode\": \"build\",\n \"pkg_id\": \"registry+https://github.com/rust-lang/crates.io-index#a@1.0.0\",\n \"platform\": null,\n \"profile\": {\n \"codegen_backend\": null,\n \"codegen_units\": null,\n \"debug_assertions\": true,\n \"debuginfo\": 2,\n \"incremental\": false,\n \"lto\": \"false\",\n \"name\": \"dev\",\n \"opt_level\": \"0\",\n \"overflow_checks\": true,\n \"panic\": \"unwind\",\n \"rpath\": false,\n \"split_debuginfo\": \"{...}\",\n \"strip\": \"{...}\"\n },\n \"target\": {\n \"crate_types\": [\n \"lib\"\n ],\n \"doc\": true,\n \"doctest\": true,\n \"edition\": \"2015\",\n \"kind\": [\n \"lib\"\n ],\n \"name\": \"a\",\n \"src_path\": \"[ROOT]/home/.cargo/registry/src/-[HASH]/a-1.0.0/src/lib.rs\",\n \"test\": true\n }\n },\n {\n \"dependencies\": [\n {\n \"extern_crate_name\": \"c\",\n \"index\": 2,\n \"noprelude\": false,\n \"nounused\": false,\n \"public\": false\n }\n ],\n \"features\": [\n \"featb\"\n ],\n \"mode\": \"build\",\n \"pkg_id\": \"registry+https://github.com/rust-lang/crates.io-index#b@1.0.0\",\n \"platform\": null,\n \"profile\": {\n \"codegen_backend\": null,\n \"codegen_units\": null,\n \"debug_assertions\": true,\n \"debuginfo\": 2,\n \"incremental\": false,\n \"lto\": \"false\",\n \"name\": \"dev\",\n \"opt_level\": \"0\",\n \"overflow_checks\": true,\n \"panic\": \"unwind\",\n \"rpath\": false,\n \"split_debuginfo\": \"{...}\",\n \"strip\": \"{...}\"\n },\n \"target\": {\n \"crate_types\": [\n \"lib\"\n ],\n \"doc\": true,\n \"doctest\": true,\n \"edition\": \"2015\",\n \"kind\": [\n \"lib\"\n ],\n \"name\": \"b\",\n \"src_path\": \"[ROOT]/home/.cargo/registry/src/-[HASH]/b-1.0.0/src/lib.rs\",\n \"test\": true\n }\n },\n {\n \"dependencies\": [],\n \"features\": [\n \"featc\"\n ],\n \"mode\": \"build\",\n \"pkg_id\": \"registry+https://github.com/rust-lang/crates.io-index#c@1.0.0\",\n \"platform\": null,\n \"profile\": {\n \"codegen_backend\": null,\n \"codegen_units\": null,\n \"debug_assertions\": true,\n \"debuginfo\": 2,\n \"incremental\": false,\n \"lto\": \"false\",\n \"name\": \"dev\",\n \"opt_level\": \"0\",\n \"overflow_checks\": true,\n \"panic\": \"unwind\",\n \"rpath\": false,\n \"split_debuginfo\": \"{...}\",\n \"strip\": \"{...}\"\n },\n \"target\": {\n \"crate_types\": [\n \"lib\"\n ],\n \"doc\": true,\n \"doctest\": true,\n \"edition\": \"2015\",\n \"kind\": [\n \"lib\"\n ],\n \"name\": \"c\",\n \"src_path\": \"[ROOT]/home/.cargo/registry/src/-[HASH]/c-1.0.0/src/lib.rs\",\n \"test\": true\n }\n },\n {\n \"dependencies\": [\n {\n \"extern_crate_name\": \"a\",\n \"index\": 0,\n \"noprelude\": false,\n \"nounused\": false,\n \"public\": false\n }\n ],\n \"features\": [],\n \"mode\": \"build\",\n \"pkg_id\": \"path+[ROOTURL]/foo#0.1.0\",\n \"platform\": null,\n \"profile\": {\n \"codegen_backend\": null,\n \"codegen_units\": null,\n \"debug_assertions\": true,\n \"debuginfo\": 2,\n \"incremental\": false,\n \"lto\": \"false\",\n \"name\": \"dev\",\n \"opt_level\": \"0\",\n \"overflow_checks\": true,\n \"panic\": \"unwind\",\n \"rpath\": false,\n \"split_debuginfo\": \"{...}\",\n \"strip\": \"{...}\"\n },\n \"target\": {\n \"crate_types\": [\n \"lib\"\n ],\n \"doc\": true,\n \"doctest\": true,\n \"edition\": \"2015\",\n \"kind\": [\n \"lib\"\n ],\n \"name\": \"foo\",\n \"src_path\": \"[ROOT]/foo/src/lib.rs\",\n \"test\": true\n }\n }\n ],\n \"version\": 1\n}\n\"#]]\n .is_json(),\n )\n .run();\n}\n" }, { "path": "tests/testsuite/update.rs", "content": "//! Tests for the `cargo update` command.\n\nuse crate::prelude::*;\nuse cargo_test_support::compare::assert_e2e;\nuse cargo_test_support::registry::{self};\nuse cargo_test_support::registry::{Dependency, Package};\nuse cargo_test_support::{basic_lib_manifest, basic_manifest, git, project, str};\n\n#[cargo_test]\nfn minor_update_two_places() {\n Package::new(\"log\", \"0.1.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n log = \"0.1\"\n foo = { path = \"foo\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n log = \"0.1\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n Package::new(\"log\", \"0.1.1\").publish();\n\n p.change_file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n log = \"0.1.1\"\n \"#,\n );\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn transitive_minor_update() {\n Package::new(\"log\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.1.0\").dep(\"log\", \"0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.1\"\n log = \"0.1\"\n foo = { path = \"foo\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.1\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"serde\", \"0.1.1\").dep(\"log\", \"0.1.1\").publish();\n\n // Note that `serde` isn't actually updated here! The default behavior for\n // `update` right now is to as conservatively as possible attempt to satisfy\n // an update. In this case we previously locked the dependency graph to `log\n // 0.1.0`, but nothing on the command line says we're allowed to update\n // that. As a result the update of `serde` here shouldn't update to `serde\n // 0.1.1` as that would also force an update to `log 0.1.1`.\n //\n // Also note that this is probably counterintuitive and weird. We may wish\n // to change this one day.\n p.cargo(\"update serde\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 0 packages to latest compatible versions\n[NOTE] pass `--verbose` to see 2 unchanged dependencies behind latest\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn conservative() {\n Package::new(\"log\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.1.0\").dep(\"log\", \"0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.1\"\n log = \"0.1\"\n foo = { path = \"foo\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.1\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"serde\", \"0.1.1\").dep(\"log\", \"0.1\").publish();\n\n p.cargo(\"update serde\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] serde v0.1.0 -> v0.1.1\n[NOTE] pass `--verbose` to see 1 unchanged dependencies behind latest\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_via_new_dep() {\n Package::new(\"log\", \"0.1.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n log = \"0.1\"\n # foo = { path = \"foo\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n log = \"0.1.1\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n Package::new(\"log\", \"0.1.1\").publish();\n\n p.uncomment_root_manifest();\n p.cargo(\"check\").env(\"CARGO_LOG\", \"cargo=trace\").run();\n}\n\n#[cargo_test]\nfn update_via_new_member() {\n Package::new(\"log\", \"0.1.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n # members = [ \"foo\" ]\n\n [dependencies]\n log = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n log = \"0.1.1\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n Package::new(\"log\", \"0.1.1\").publish();\n\n p.uncomment_root_manifest();\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn add_dep_deep_new_requirement() {\n Package::new(\"log\", \"0.1.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n log = \"0.1\"\n # bar = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"bar\", \"0.1.0\").dep(\"log\", \"0.1.1\").publish();\n\n p.uncomment_root_manifest();\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn everything_real_deep() {\n Package::new(\"log\", \"0.1.0\").publish();\n Package::new(\"foo\", \"0.1.0\").dep(\"log\", \"0.1\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = \"0.1\"\n # bar = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"bar\", \"0.1.0\").dep(\"log\", \"0.1.1\").publish();\n\n p.uncomment_root_manifest();\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn change_package_version() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a-foo\"\n version = \"0.2.0-alpha\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"bar\", version = \"0.2.0-alpha\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.2.0-alpha\"))\n .file(\"bar/src/lib.rs\", \"\")\n .file(\n \"Cargo.lock\",\n r#\"\n [[package]]\n name = \"foo\"\n version = \"0.2.0\"\n dependencies = [\"bar 0.2.0\"]\n\n [[package]]\n name = \"bar\"\n version = \"0.2.0\"\n \"#,\n )\n .build();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn update_precise() {\n Package::new(\"serde\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.2.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.2\"\n foo = { path = \"foo\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.1\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"serde\", \"0.2.0\").publish();\n\n p.cargo(\"update serde:0.2.1 --precise 0.2.0\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNGRADING] serde v0.2.1 -> v0.2.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_precise_mismatched() {\n Package::new(\"serde\", \"1.2.0\").publish();\n Package::new(\"serde\", \"1.2.1\").publish();\n Package::new(\"serde\", \"1.6.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"~1.2\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n // `1.6.0` does not match `\"~1.2\"`\n p.cargo(\"update serde:1.2 --precise 1.6.0\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] failed to select a version for the requirement `serde = \"~1.2\"`\ncandidate versions found which didn't match: 1.6.0\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `bar v0.0.1 ([ROOT]/foo)`\nperhaps a crate was updated and forgotten to be re-vendored?\n\n\"#]])\n .with_status(101)\n .run();\n\n // `1.9.0` does not exist\n p.cargo(\"update serde:1.2 --precise 1.9.0\")\n // This terrible error message has been the same for a long time. A fix is more than welcome!\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `serde` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `bar v0.0.1 ([ROOT]/foo)`\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn update_precise_build_metadata() {\n Package::new(\"serde\", \"0.0.1+first\").publish();\n Package::new(\"serde\", \"0.0.1+second\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.0\"\n edition = \"2015\"\n\n [dependencies]\n serde = \"0.0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n p.cargo(\"update serde --precise 0.0.1+first\").run();\n\n p.cargo(\"update serde --precise 0.0.1+second\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] serde v0.0.1+first -> v0.0.1+second\n\n\"#]])\n .run();\n\n // This is not considered \"Downgrading\". Build metadata are not assumed to\n // be ordered.\n p.cargo(\"update serde --precise 0.0.1+first\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] serde v0.0.1+second -> v0.0.1+first\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_precise_do_not_force_update_deps() {\n Package::new(\"log\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.2.1\").dep(\"log\", \"0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.2\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"serde\", \"0.2.2\").dep(\"log\", \"0.1\").publish();\n\n p.cargo(\"update serde:0.2.1 --precise 0.2.2\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] serde v0.2.1 -> v0.2.2\n[NOTE] pass `--verbose` to see 1 unchanged dependencies behind latest\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_recursive() {\n Package::new(\"log\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.2.1\").dep(\"log\", \"0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.2\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"serde\", \"0.2.2\").dep(\"log\", \"0.1\").publish();\n\n p.cargo(\"update serde:0.2.1 --recursive\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] log v0.1.0 -> v0.1.1\n[UPDATING] serde v0.2.1 -> v0.2.2\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_aggressive_alias_for_recursive() {\n Package::new(\"log\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.2.1\").dep(\"log\", \"0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.2\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"serde\", \"0.2.2\").dep(\"log\", \"0.1\").publish();\n\n p.cargo(\"update serde:0.2.1 --aggressive\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] log v0.1.0 -> v0.1.1\n[UPDATING] serde v0.2.1 -> v0.2.2\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_recursive_conflicts_with_precise() {\n Package::new(\"log\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.2.1\").dep(\"log\", \"0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.2\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"serde\", \"0.2.2\").dep(\"log\", \"0.1\").publish();\n\n p.cargo(\"update serde:0.2.1 --precise 0.2.2 --recursive\")\n .with_status(1)\n .with_stderr_data(str![[r#\"\n[ERROR] the argument '--precise ' cannot be used with '--recursive'\n\nUsage: cargo[EXE] update --precise ]>\n\nFor more information, try '--help'.\n\n\"#]])\n .run();\n}\n\n// cargo update should respect its arguments even without a lockfile.\n// See issue \"Running cargo update without a Cargo.lock ignores arguments\"\n// at .\n#[cargo_test]\nfn update_precise_first_run() {\n Package::new(\"serde\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.2.0\").publish();\n Package::new(\"serde\", \"0.2.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n\n [dependencies]\n serde = \"0.2\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"update serde --precise 0.2.0\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[DOWNGRADING] serde v0.2.1 -> v0.2.0\n\n\"#]])\n .run();\n\n // Assert `cargo metadata` shows serde 0.2.0\n p.cargo(\"metadata\")\n .with_stdout_data(\n str![[r#\"\n{\n \"metadata\": null,\n \"packages\": [\n {\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [\n {\n \"features\": [],\n \"kind\": null,\n \"name\": \"serde\",\n \"optional\": false,\n \"registry\": null,\n \"rename\": null,\n \"req\": \"^0.2\",\n \"source\": \"registry+https://github.com/rust-lang/crates.io-index\",\n \"target\": null,\n \"uses_default_features\": true\n }\n ],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2015\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"path+[ROOTURL]/foo#bar@0.0.1\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/foo/Cargo.toml\",\n \"metadata\": null,\n \"name\": \"bar\",\n \"publish\": null,\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": null,\n \"targets\": [\n {\n \"crate_types\": [\n \"lib\"\n ],\n \"doc\": true,\n \"doctest\": true,\n \"edition\": \"2015\",\n \"kind\": [\n \"lib\"\n ],\n \"name\": \"bar\",\n \"src_path\": \"[ROOT]/foo/src/lib.rs\",\n \"test\": true\n }\n ],\n \"version\": \"0.0.1\"\n },\n {\n \"authors\": [],\n \"categories\": [],\n \"default_run\": null,\n \"dependencies\": [],\n \"description\": null,\n \"documentation\": null,\n \"edition\": \"2015\",\n \"features\": {},\n \"homepage\": null,\n \"id\": \"registry+https://github.com/rust-lang/crates.io-index#serde@0.2.0\",\n \"keywords\": [],\n \"license\": null,\n \"license_file\": null,\n \"links\": null,\n \"manifest_path\": \"[ROOT]/home/.cargo/registry/src/-[HASH]/serde-0.2.0/Cargo.toml\",\n \"metadata\": null,\n \"name\": \"serde\",\n \"publish\": null,\n \"readme\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"source\": \"registry+https://github.com/rust-lang/crates.io-index\",\n \"targets\": [\n {\n \"crate_types\": [\n \"lib\"\n ],\n \"doc\": true,\n \"doctest\": true,\n \"edition\": \"2015\",\n \"kind\": [\n \"lib\"\n ],\n \"name\": \"serde\",\n \"src_path\": \"[ROOT]/home/.cargo/registry/src/-[HASH]/serde-0.2.0/src/lib.rs\",\n \"test\": true\n }\n ],\n \"version\": \"0.2.0\"\n }\n ],\n \"resolve\": {\n \"nodes\": [\n {\n \"dependencies\": [\n \"registry+https://github.com/rust-lang/crates.io-index#serde@0.2.0\"\n ],\n \"deps\": [\n {\n \"dep_kinds\": [\n {\n \"kind\": null,\n \"target\": null\n }\n ],\n \"name\": \"serde\",\n \"pkg\": \"registry+https://github.com/rust-lang/crates.io-index#serde@0.2.0\"\n }\n ],\n \"features\": [],\n \"id\": \"path+[ROOTURL]/foo#bar@0.0.1\"\n },\n {\n \"dependencies\": [],\n \"deps\": [],\n \"features\": [],\n \"id\": \"registry+https://github.com/rust-lang/crates.io-index#serde@0.2.0\"\n }\n ],\n \"root\": \"path+[ROOTURL]/foo#bar@0.0.1\"\n },\n \"target_directory\": \"[ROOT]/foo/target\",\n \"build_directory\": \"[ROOT]/foo/target\",\n \"version\": 1,\n \"workspace_default_members\": [\n \"path+[ROOTURL]/foo#bar@0.0.1\"\n ],\n \"workspace_members\": [\n \"path+[ROOTURL]/foo#bar@0.0.1\"\n ],\n \"workspace_root\": \"[ROOT]/foo\"\n}\n\"#]]\n .is_json(),\n )\n .run();\n\n p.cargo(\"update serde --precise 0.2.0\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn preserve_top_comment() {\n let p = project().file(\"src/lib.rs\", \"\").build();\n\n p.cargo(\"update\").run();\n\n let lockfile = p.read_lockfile();\n assert!(lockfile.starts_with(\"# This file is automatically @generated by Cargo.\\n# It is not intended for manual editing.\\n\"));\n\n let mut lines = lockfile.lines().collect::>();\n lines.insert(2, \"# some other comment\");\n let mut lockfile = lines.join(\"\\n\");\n lockfile.push('\\n'); // .lines/.join loses the last newline\n println!(\"saving Cargo.lock contents:\\n{}\", lockfile);\n\n p.change_file(\"Cargo.lock\", &lockfile);\n\n p.cargo(\"update\").run();\n\n let lockfile2 = p.read_lockfile();\n println!(\"loaded Cargo.lock contents:\\n{}\", lockfile2);\n\n assert_eq!(lockfile, lockfile2);\n}\n\n#[cargo_test]\nfn dry_run_update() {\n Package::new(\"log\", \"0.1.0\").publish();\n Package::new(\"serde\", \"0.1.0\").dep(\"log\", \"0.1\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.1\"\n log = \"0.1\"\n foo = { path = \"foo\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n serde = \"0.1\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").run();\n let old_lockfile = p.read_lockfile();\n\n Package::new(\"log\", \"0.1.1\").publish();\n Package::new(\"serde\", \"0.1.1\").dep(\"log\", \"0.1\").publish();\n\n p.cargo(\"update serde --dry-run\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] serde v0.1.0 -> v0.1.1\n[NOTE] pass `--verbose` to see 1 unchanged dependencies behind latest\n[WARNING] not updating lockfile due to dry run\n\n\"#]])\n .run();\n let new_lockfile = p.read_lockfile();\n assert_eq!(old_lockfile, new_lockfile)\n}\n\n#[cargo_test]\nfn workspace_only() {\n let p = project().file(\"src/main.rs\", \"fn main() {}\").build();\n p.cargo(\"generate-lockfile\").run();\n let lock1 = p.read_lockfile();\n\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n authors = []\n version = \"0.0.2\"\n edition = \"2015\"\n \"#,\n );\n p.cargo(\"update --workspace\").run();\n let lock2 = p.read_lockfile();\n\n assert_ne!(lock1, lock2);\n assert!(lock1.contains(\"0.0.1\"));\n assert!(lock2.contains(\"0.0.2\"));\n assert!(!lock1.contains(\"0.0.2\"));\n assert!(!lock2.contains(\"0.0.1\"));\n}\n\n#[cargo_test]\nfn precise_with_build_metadata() {\n // +foo syntax shouldn't be necessary with --precise\n Package::new(\"bar\", \"0.1.0+extra-stuff.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"generate-lockfile\").run();\n Package::new(\"bar\", \"0.1.1+extra-stuff.1\").publish();\n Package::new(\"bar\", \"0.1.2+extra-stuff.2\").publish();\n\n p.cargo(\"update bar --precise 0.1\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] invalid version format for precise version `0.1`\n\nCaused by:\n unexpected end of input while parsing minor version number\n\n\"#]])\n .run();\n\n p.cargo(\"update bar --precise 0.1.1+does-not-match\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `bar` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.1.0 ([ROOT]/foo)`\n\n\"#]])\n .run();\n\n p.cargo(\"update bar --precise 0.1.1\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] bar v0.1.0+extra-stuff.0 -> v0.1.1+extra-stuff.1\n\n\"#]])\n .run();\n\n Package::new(\"bar\", \"0.1.3\").publish();\n p.cargo(\"update bar --precise 0.1.3+foo\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] no matching package named `bar` found\nlocation searched: `dummy-registry` index (which is replacing registry `crates-io`)\nrequired by package `foo v0.1.0 ([ROOT]/foo)`\n\n\"#]])\n .run();\n\n p.cargo(\"update bar --precise 0.1.3\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPDATING] bar v0.1.1+extra-stuff.1 -> v0.1.3\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_only_members_order_one() {\n let git_project = git::new(\"rustdns\", |project| {\n project\n .file(\"Cargo.toml\", &basic_lib_manifest(\"rustdns\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n });\n\n let workspace_toml = format!(\n r#\"\n[workspace.package]\nversion = \"2.29.8\"\nedition = \"2021\"\npublish = false\n\n[workspace]\nmembers = [\n \"rootcrate\",\n \"subcrate\",\n]\nresolver = \"2\"\n\n[workspace.dependencies]\n# Internal crates\nsubcrate = {{ version = \"*\", path = \"./subcrate\" }}\n\n# External dependencies\nrustdns = {{ version = \"0.5.0\", default-features = false, git = \"{}\" }}\n \"#,\n git_project.url()\n );\n let p = project()\n .file(\"Cargo.toml\", &workspace_toml)\n .file(\n \"rootcrate/Cargo.toml\",\n r#\"\n[package]\nname = \"rootcrate\"\nversion.workspace = true\nedition.workspace = true\npublish.workspace = true\n\n[dependencies]\nsubcrate.workspace = true\n\"#,\n )\n .file(\"rootcrate/src/main.rs\", \"fn main() {}\")\n .file(\n \"subcrate/Cargo.toml\",\n r#\"\n[package]\nname = \"subcrate\"\nversion.workspace = true\nedition.workspace = true\npublish.workspace = true\n\n[dependencies]\nrustdns.workspace = true\n\"#,\n )\n .file(\"subcrate/src/lib.rs\", \"pub foo() {}\")\n .build();\n\n // First time around we should compile both foo and bar\n p.cargo(\"generate-lockfile\")\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `[ROOTURL]/rustdns`\n[LOCKING] 1 package to latest compatible version\n\n\"#]])\n .run();\n // Modify a file manually, shouldn't trigger a recompile\n git_project.change_file(\"src/lib.rs\", r#\"pub fn bar() { println!(\"hello!\"); }\"#);\n // Commit the changes and make sure we don't trigger a recompile because the\n // lock file says not to change\n let repo = git2::Repository::open(&git_project.root()).unwrap();\n git::add(&repo);\n git::commit(&repo);\n p.change_file(\"Cargo.toml\", &workspace_toml.replace(\"2.29.8\", \"2.29.81\"));\n\n p.cargo(\"update -p rootcrate\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] rootcrate v2.29.8 ([ROOT]/foo/rootcrate) -> v2.29.81\n[UPDATING] subcrate v2.29.8 ([ROOT]/foo/subcrate) -> v2.29.81\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_only_members_order_two() {\n let git_project = git::new(\"rustdns\", |project| {\n project\n .file(\"Cargo.toml\", &basic_lib_manifest(\"rustdns\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n });\n\n let workspace_toml = format!(\n r#\"\n[workspace.package]\nversion = \"2.29.8\"\nedition = \"2021\"\npublish = false\n\n[workspace]\nmembers = [\n \"crate2\",\n \"crate1\",\n]\nresolver = \"2\"\n\n[workspace.dependencies]\n# Internal crates\ncrate1 = {{ version = \"*\", path = \"./crate1\" }}\n\n# External dependencies\nrustdns = {{ version = \"0.5.0\", default-features = false, git = \"{}\" }}\n \"#,\n git_project.url()\n );\n let p = project()\n .file(\"Cargo.toml\", &workspace_toml)\n .file(\n \"crate2/Cargo.toml\",\n r#\"\n[package]\nname = \"crate2\"\nversion.workspace = true\nedition.workspace = true\npublish.workspace = true\n\n[dependencies]\ncrate1.workspace = true\n\"#,\n )\n .file(\"crate2/src/main.rs\", \"fn main() {}\")\n .file(\n \"crate1/Cargo.toml\",\n r#\"\n[package]\nname = \"crate1\"\nversion.workspace = true\nedition.workspace = true\npublish.workspace = true\n\n[dependencies]\nrustdns.workspace = true\n\"#,\n )\n .file(\"crate1/src/lib.rs\", \"pub foo() {}\")\n .build();\n\n // First time around we should compile both foo and bar\n p.cargo(\"generate-lockfile\")\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `[ROOTURL]/rustdns`\n[LOCKING] 1 package to latest compatible version\n\n\"#]])\n .run();\n // Modify a file manually, shouldn't trigger a recompile\n git_project.change_file(\"src/lib.rs\", r#\"pub fn bar() { println!(\"hello!\"); }\"#);\n // Commit the changes and make sure we don't trigger a recompile because the\n // lock file says not to change\n let repo = git2::Repository::open(&git_project.root()).unwrap();\n git::add(&repo);\n git::commit(&repo);\n p.change_file(\"Cargo.toml\", &workspace_toml.replace(\"2.29.8\", \"2.29.81\"));\n\n p.cargo(\"update -p crate2\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] crate1 v2.29.8 ([ROOT]/foo/crate1) -> v2.29.81\n[UPDATING] crate2 v2.29.8 ([ROOT]/foo/crate2) -> v2.29.81\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_only_members_with_workspace() {\n let git_project = git::new(\"rustdns\", |project| {\n project\n .file(\"Cargo.toml\", &basic_lib_manifest(\"rustdns\"))\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n });\n\n let workspace_toml = format!(\n r#\"\n[workspace.package]\nversion = \"2.29.8\"\nedition = \"2021\"\npublish = false\n\n[workspace]\nmembers = [\n \"crate2\",\n \"crate1\",\n]\nresolver = \"2\"\n\n[workspace.dependencies]\n# Internal crates\ncrate1 = {{ version = \"*\", path = \"./crate1\" }}\n\n# External dependencies\nrustdns = {{ version = \"0.5.0\", default-features = false, git = \"{}\" }}\n \"#,\n git_project.url()\n );\n let p = project()\n .file(\"Cargo.toml\", &workspace_toml)\n .file(\n \"crate2/Cargo.toml\",\n r#\"\n[package]\nname = \"crate2\"\nversion.workspace = true\nedition.workspace = true\npublish.workspace = true\n\n[dependencies]\ncrate1.workspace = true\n\"#,\n )\n .file(\"crate2/src/main.rs\", \"fn main() {}\")\n .file(\n \"crate1/Cargo.toml\",\n r#\"\n[package]\nname = \"crate1\"\nversion.workspace = true\nedition.workspace = true\npublish.workspace = true\n\n[dependencies]\nrustdns.workspace = true\n\"#,\n )\n .file(\"crate1/src/lib.rs\", \"pub foo() {}\")\n .build();\n\n // First time around we should compile both foo and bar\n p.cargo(\"generate-lockfile\")\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `[ROOTURL]/rustdns`\n[LOCKING] 1 package to latest compatible version\n\n\"#]])\n .run();\n // Modify a file manually, shouldn't trigger a recompile\n git_project.change_file(\"src/lib.rs\", r#\"pub fn bar() { println!(\"hello!\"); }\"#);\n // Commit the changes and make sure we don't trigger a recompile because the\n // lock file says not to change\n let repo = git2::Repository::open(&git_project.root()).unwrap();\n git::add(&repo);\n git::commit(&repo);\n p.change_file(\"Cargo.toml\", &workspace_toml.replace(\"2.29.8\", \"2.29.81\"));\n\n p.cargo(\"update --workspace\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] crate1 v2.29.8 ([ROOT]/foo/crate1) -> v2.29.81\n[UPDATING] crate2 v2.29.8 ([ROOT]/foo/crate2) -> v2.29.81\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_precise_git_revisions() {\n let (git_project, git_repo) = git::new_repo(\"git\", |p| {\n p.file(\"Cargo.toml\", &basic_lib_manifest(\"git\"))\n .file(\"src/lib.rs\", \"\")\n });\n let tag_name = \"NazgĆ»l\";\n git::tag(&git_repo, tag_name);\n let tag_commit_id = git_repo.head().unwrap().target().unwrap().to_string();\n\n git_project.change_file(\"src/lib.rs\", \"fn f() {}\");\n git::add(&git_repo);\n let head_id = git::commit(&git_repo).to_string();\n let short_id = &head_id[..8];\n let url = git_project.url();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n git = {{ git = '{url}' }}\n \"#\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"fetch\")\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `[ROOTURL]/git`\n[LOCKING] 1 package to latest compatible version\n\n\"#]])\n .run();\n\n assert!(p.read_lockfile().contains(&head_id));\n\n p.cargo(\"update git --precise\")\n .arg(tag_name)\n .with_stderr_data(format!(\n \"\\\n[UPDATING] git repository `[ROOTURL]/git`\n[UPDATING] git v0.5.0 ([ROOTURL]/git#[..]) -> #{}\n\",\n &tag_commit_id[..8],\n ))\n .run();\n\n assert!(p.read_lockfile().contains(&tag_commit_id));\n assert!(!p.read_lockfile().contains(&head_id));\n\n p.cargo(\"update git --precise\")\n .arg(short_id)\n .with_stderr_data(format!(\n \"\\\n[UPDATING] git repository `[ROOTURL]/git`\n[UPDATING] git v0.5.0 ([ROOTURL]/git[..]) -> #{short_id}\n\",\n ))\n .run();\n\n assert!(p.read_lockfile().contains(&head_id));\n assert!(!p.read_lockfile().contains(&tag_commit_id));\n\n // updating back to tag still requires a git fetch,\n // as the ref may change over time.\n p.cargo(\"update git --precise\")\n .arg(tag_name)\n .with_stderr_data(format!(\n \"\\\n[UPDATING] git repository `[ROOTURL]/git`\n[UPDATING] git v0.5.0 ([ROOTURL]/git#[..]) -> #{}\n\",\n &tag_commit_id[..8],\n ))\n .run();\n\n assert!(p.read_lockfile().contains(&tag_commit_id));\n assert!(!p.read_lockfile().contains(&head_id));\n\n // Now make a tag looks like an oid.\n // It requires a git fetch, as the oid cannot be found in preexisting git db.\n let arbitrary_tag: String = \"a\".repeat(head_id.len());\n git::tag(&git_repo, &arbitrary_tag);\n\n p.cargo(\"update git --precise\")\n .arg(&arbitrary_tag)\n .with_stderr_data(format!(\n \"\\\n[UPDATING] git repository `[ROOTURL]/git`\n[UPDATING] git v0.5.0 ([ROOTURL]/git#[..]) -> #{}\n\",\n &head_id[..8],\n ))\n .run();\n\n assert!(p.read_lockfile().contains(&head_id));\n assert!(!p.read_lockfile().contains(&tag_commit_id));\n}\n\n#[cargo_test]\nfn precise_yanked() {\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"bar\", \"0.1.1\").yanked(true).publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n\n [dependencies]\n bar = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n // Use non-yanked version.\n let lockfile = p.read_lockfile();\n assert!(lockfile.contains(\"\\nname = \\\"bar\\\"\\nversion = \\\"0.1.0\\\"\"));\n\n p.cargo(\"update --precise 0.1.1 bar\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[WARNING] selected package `bar@0.1.1` was yanked by the author\n |\n = [HELP] if possible, try a compatible non-yanked version\n[UPDATING] bar v0.1.0 -> v0.1.1\n\n\"#]])\n .run();\n\n // Use yanked version.\n let lockfile = p.read_lockfile();\n assert!(lockfile.contains(\"\\nname = \\\"bar\\\"\\nversion = \\\"0.1.1\\\"\"));\n}\n\n#[cargo_test]\nfn precise_yanked_multiple_presence() {\n Package::new(\"bar\", \"0.1.0\").publish();\n Package::new(\"bar\", \"0.1.1\").yanked(true).publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n\n [dependencies]\n bar = \"0.1\"\n baz = { package = \"bar\", version = \"0.1\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n // Use non-yanked version.\n let lockfile = p.read_lockfile();\n assert!(lockfile.contains(\"\\nname = \\\"bar\\\"\\nversion = \\\"0.1.0\\\"\"));\n\n p.cargo(\"update --precise 0.1.1 bar\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[WARNING] selected package `bar@0.1.1` was yanked by the author\n |\n = [HELP] if possible, try a compatible non-yanked version\n[UPDATING] bar v0.1.0 -> v0.1.1\n\n\"#]])\n .run();\n\n // Use yanked version.\n let lockfile = p.read_lockfile();\n assert!(lockfile.contains(\"\\nname = \\\"bar\\\"\\nversion = \\\"0.1.1\\\"\"));\n}\n\n#[cargo_test]\nfn report_behind() {\n Package::new(\"two-ver\", \"0.1.0\").publish();\n Package::new(\"two-ver\", \"0.2.0\").publish();\n Package::new(\"pre\", \"1.0.0-alpha.0\").publish();\n Package::new(\"pre\", \"1.0.0-alpha.1\").publish();\n Package::new(\"breaking\", \"0.1.0\").publish();\n Package::new(\"breaking\", \"0.2.0\").publish();\n Package::new(\"breaking\", \"0.2.1-alpha.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n\n [dependencies]\n breaking = \"0.1\"\n pre = \"=1.0.0-alpha.0\"\n two-ver = \"0.2.0\"\n two-ver-one = { version = \"0.1.0\", package = \"two-ver\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n Package::new(\"breaking\", \"0.1.1\").publish();\n\n p.cargo(\"update --dry-run\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] breaking v0.1.0 -> v0.1.1 (available: v0.2.0)\n[NOTE] pass `--verbose` to see 2 unchanged dependencies behind latest\n[WARNING] not updating lockfile due to dry run\n\n\"#]])\n .run();\n\n p.cargo(\"update --dry-run --verbose\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] breaking v0.1.0 -> v0.1.1 (available: v0.2.0)\n[UNCHANGED] pre v1.0.0-alpha.0 (available: v1.0.0-alpha.1)\n[UNCHANGED] two-ver v0.1.0 (available: v0.2.0)\n[NOTE] to see how you depend on a package, run `cargo tree --invert @`\n[WARNING] not updating lockfile due to dry run\n\n\"#]])\n .run();\n\n p.cargo(\"update\").run();\n\n p.cargo(\"update --dry-run\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 0 packages to latest compatible versions\n[NOTE] pass `--verbose` to see 3 unchanged dependencies behind latest\n[WARNING] not updating lockfile due to dry run\n\n\"#]])\n .run();\n\n p.cargo(\"update --dry-run --verbose\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 0 packages to latest compatible versions\n[UNCHANGED] breaking v0.1.1 (available: v0.2.0)\n[UNCHANGED] pre v1.0.0-alpha.0 (available: v1.0.0-alpha.1)\n[UNCHANGED] two-ver v0.1.0 (available: v0.2.0)\n[NOTE] to see how you depend on a package, run `cargo tree --invert @`\n[WARNING] not updating lockfile due to dry run\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_with_missing_feature() {\n // Attempting to update a package to a version with a missing feature\n // should produce a warning.\n Package::new(\"bar\", \"0.1.0\").feature(\"feat1\", &[]).publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = {version=\"0.1\", features=[\"feat1\"]}\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"generate-lockfile\").run();\n\n // Publish an update that is missing the feature.\n Package::new(\"bar\", \"0.1.1\").publish();\n\n p.cargo(\"update\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 0 packages to latest compatible versions\n[NOTE] pass `--verbose` to see 1 unchanged dependencies behind latest\n\n\"#]])\n .run();\n\n // Publish a fixed version, should not warn.\n Package::new(\"bar\", \"0.1.2\").feature(\"feat1\", &[]).publish();\n p.cargo(\"update\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v0.1.0 -> v0.1.2\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_unstable() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"update --breaking\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] the `--breaking` flag is unstable, pass `-Z unstable-options` to enable it\nSee https://github.com/rust-lang/cargo/issues/12425 for more information about the `--breaking` flag.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_dry_run() {\n Package::new(\"incompatible\", \"1.0.0\").publish();\n Package::new(\"ws\", \"1.0.0\").publish();\n\n let root_manifest = r#\"\n # Check if formatting is preserved. Nothing here should change, due to dry-run.\n\n [workspace]\n members = [\"foo\"]\n\n [workspace.dependencies]\n ws = \"1.0\" # Preserve formatting\n \"#;\n\n let crate_manifest = r#\"\n # Check if formatting is preserved. Nothing here should change, due to dry-run.\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n incompatible = \"1.0\" # Preserve formatting\n ws.workspace = true # Preserve formatting\n \"#;\n\n let p = project()\n .file(\"Cargo.toml\", root_manifest)\n .file(\"foo/Cargo.toml\", crate_manifest)\n .file(\"foo/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n let lock_file = p.read_file(\"Cargo.lock\");\n\n Package::new(\"incompatible\", \"1.0.1\").publish();\n Package::new(\"ws\", \"1.0.1\").publish();\n\n Package::new(\"incompatible\", \"2.0.0\").publish();\n Package::new(\"ws\", \"2.0.0\").publish();\n\n p.cargo(\"update -Zunstable-options --dry-run --breaking\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPGRADING] incompatible ^1.0 -> ^2.0\n[UPGRADING] ws ^1.0 -> ^2.0\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] incompatible v1.0.0 -> v2.0.0\n[UPDATING] ws v1.0.0 -> v2.0.0\n[WARNING] aborting update due to dry run\n\n\"#]])\n .run();\n\n let root_manifest_after = p.read_file(\"Cargo.toml\");\n assert_e2e().eq(&root_manifest_after, root_manifest);\n\n let crate_manifest_after = p.read_file(\"foo/Cargo.toml\");\n assert_e2e().eq(&crate_manifest_after, crate_manifest);\n\n let lock_file_after = p.read_file(\"Cargo.lock\");\n assert_e2e().eq(&lock_file_after, lock_file);\n}\n\n#[cargo_test]\nfn update_breaking() {\n registry::alt_init();\n Package::new(\"compatible\", \"1.0.0\").publish();\n Package::new(\"incompatible\", \"1.0.0\").publish();\n Package::new(\"pinned\", \"1.0.0\").publish();\n Package::new(\"less-than\", \"1.0.0\").publish();\n Package::new(\"renamed-from\", \"1.0.0\").publish();\n Package::new(\"pre-release\", \"1.0.0\").publish();\n Package::new(\"yanked\", \"1.0.0\").publish();\n Package::new(\"ws\", \"1.0.0\").publish();\n Package::new(\"shared\", \"1.0.0\").publish();\n Package::new(\"multiple-locations\", \"1.0.0\").publish();\n Package::new(\"multiple-versions\", \"1.0.0\").publish();\n Package::new(\"multiple-versions\", \"2.0.0\").publish();\n Package::new(\"alternative-1\", \"1.0.0\")\n .alternative(true)\n .publish();\n Package::new(\"alternative-2\", \"1.0.0\")\n .alternative(true)\n .publish();\n Package::new(\"bar\", \"1.0.0\").alternative(true).publish();\n Package::new(\"multiple-registries\", \"1.0.0\").publish();\n Package::new(\"multiple-registries\", \"2.0.0\")\n .alternative(true)\n .publish();\n Package::new(\"multiple-source-types\", \"1.0.0\").publish();\n Package::new(\"platform-specific\", \"1.0.0\").publish();\n Package::new(\"dev\", \"1.0.0\").publish();\n Package::new(\"build\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n # Check if formatting is preserved\n\n [workspace]\n members = [\"foo\", \"bar\"]\n\n [workspace.dependencies]\n ws = \"1.0\" # This line gets partially rewritten\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n # Check if formatting is preserved\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n compatible = \"1.0\" # Comment\n incompatible = \"1.0\" # Comment\n pinned = \"=1.0\" # Comment\n less-than = \"<99.0\" # Comment\n renamed-to = { package = \"renamed-from\", version = \"1.0\" } # Comment\n pre-release = \"1.0\" # Comment\n yanked = \"1.0\" # Comment\n ws.workspace = true # Comment\n shared = \"1.0\" # Comment\n multiple-locations = { path = \"../multiple-locations\", version = \"1.0\" } # Comment\n multiple-versions = \"1.0\" # Comment\n alternative-1 = { registry = \"alternative\", version = \"1.0\" } # Comment\n multiple-registries = \"1.0\" # Comment\n bar = { path = \"../bar\", registry = \"alternative\", version = \"1.0.0\" } # Comment\n multiple-source-types = { path = \"../multiple-source-types\", version = \"1.0.0\" } # Comment\n\n [dependencies.alternative-2] # Comment\n version = \"1.0\" # Comment\n registry = \"alternative\" # Comment\n\n [target.'cfg(unix)'.dependencies]\n platform-specific = \"1.0\" # Comment\n\n [dev-dependencies]\n dev = \"1.0\" # Comment\n\n [build-dependencies]\n build = \"1.0\" # Comment\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"1.0.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n shared = \"1.0\"\n multiple-versions = \"2.0\"\n multiple-registries = { registry = \"alternative\", version = \"2.0\" } # Comment\n multiple-source-types = \"1.0\" # Comment\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .file(\n \"multiple-locations/Cargo.toml\",\n r#\"\n [package]\n name = \"multiple-locations\"\n version = \"1.0.0\"\n edition = \"2015\"\n authors = []\n \"#,\n )\n .file(\"multiple-locations/src/lib.rs\", \"\")\n .file(\n \"multiple-source-types/Cargo.toml\",\n r#\"\n [package]\n name = \"multiple-source-types\"\n version = \"1.0.0\"\n edition = \"2015\"\n authors = []\n \"#,\n )\n .file(\"multiple-source-types/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"compatible\", \"1.0.1\").publish();\n Package::new(\"incompatible\", \"1.0.1\").publish();\n Package::new(\"pinned\", \"1.0.1\").publish();\n Package::new(\"less-than\", \"1.0.1\").publish();\n Package::new(\"renamed-from\", \"1.0.1\").publish();\n Package::new(\"ws\", \"1.0.1\").publish();\n Package::new(\"multiple-locations\", \"1.0.1\").publish();\n Package::new(\"multiple-versions\", \"1.0.1\").publish();\n Package::new(\"multiple-versions\", \"2.0.1\").publish();\n Package::new(\"alternative-1\", \"1.0.1\")\n .alternative(true)\n .publish();\n Package::new(\"alternative-2\", \"1.0.1\")\n .alternative(true)\n .publish();\n Package::new(\"platform-specific\", \"1.0.1\").publish();\n Package::new(\"dev\", \"1.0.1\").publish();\n Package::new(\"build\", \"1.0.1\").publish();\n\n Package::new(\"incompatible\", \"2.0.0\").publish();\n Package::new(\"pinned\", \"2.0.0\").publish();\n Package::new(\"less-than\", \"2.0.0\").publish();\n Package::new(\"renamed-from\", \"2.0.0\").publish();\n Package::new(\"pre-release\", \"2.0.0-alpha\").publish();\n Package::new(\"yanked\", \"2.0.0\").yanked(true).publish();\n Package::new(\"ws\", \"2.0.0\").publish();\n Package::new(\"shared\", \"2.0.0\").publish();\n Package::new(\"multiple-locations\", \"2.0.0\").publish();\n Package::new(\"multiple-versions\", \"3.0.0\").publish();\n Package::new(\"alternative-1\", \"2.0.0\")\n .alternative(true)\n .publish();\n Package::new(\"alternative-2\", \"2.0.0\")\n .alternative(true)\n .publish();\n Package::new(\"bar\", \"2.0.0\").alternative(true).publish();\n Package::new(\"multiple-registries\", \"2.0.0\").publish();\n Package::new(\"multiple-registries\", \"3.0.0\")\n .alternative(true)\n .publish();\n Package::new(\"multiple-source-types\", \"2.0.0\").publish();\n Package::new(\"platform-specific\", \"2.0.0\").publish();\n Package::new(\"dev\", \"2.0.0\").publish();\n Package::new(\"build\", \"2.0.0\").publish();\n\n p.cargo(\"update -Zunstable-options --breaking\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[UPGRADING] multiple-registries ^2.0 -> ^3.0\n[UPDATING] `dummy-registry` index\n[UPGRADING] multiple-source-types ^1.0 -> ^2.0\n[UPGRADING] multiple-versions ^2.0 -> ^3.0\n[UPGRADING] shared ^1.0 -> ^2.0\n[UPGRADING] alternative-1 ^1.0 -> ^2.0\n[UPGRADING] alternative-2 ^1.0 -> ^2.0\n[UPGRADING] incompatible ^1.0 -> ^2.0\n[UPGRADING] multiple-registries ^1.0 -> ^2.0\n[UPGRADING] multiple-versions ^1.0 -> ^3.0\n[UPGRADING] ws ^1.0 -> ^2.0\n[UPGRADING] dev ^1.0 -> ^2.0\n[UPGRADING] build ^1.0 -> ^2.0\n[UPGRADING] platform-specific ^1.0 -> ^2.0\n[LOCKING] 12 packages to latest compatible versions\n[UPDATING] alternative-1 v1.0.0 (registry `alternative`) -> v2.0.0\n[UPDATING] alternative-2 v1.0.0 (registry `alternative`) -> v2.0.0\n[UPDATING] build v1.0.0 -> v2.0.0\n[UPDATING] dev v1.0.0 -> v2.0.0\n[UPDATING] incompatible v1.0.0 -> v2.0.0\n[UPDATING] multiple-registries v2.0.0 (registry `alternative`) -> v3.0.0\n[UPDATING] multiple-registries v1.0.0 -> v2.0.0\n[UPDATING] multiple-source-types v1.0.0 -> v2.0.0\n[ADDING] multiple-versions v3.0.0\n[UPDATING] platform-specific v1.0.0 -> v2.0.0\n[UPDATING] shared v1.0.0 -> v2.0.0\n[UPDATING] ws v1.0.0 -> v2.0.0\n\n\"#]])\n .run();\n\n let root_manifest = p.read_file(\"Cargo.toml\");\n assert_e2e().eq(\n &root_manifest,\n str![[r#\"\n\n # Check if formatting is preserved\n\n [workspace]\n members = [\"foo\", \"bar\"]\n\n [workspace.dependencies]\n ws = \"2.0\" # This line gets partially rewritten\n \"#]],\n );\n\n let foo_manifest = p.read_file(\"foo/Cargo.toml\");\n\n assert_e2e().eq(\n &foo_manifest,\n str![[r#\"\n\n # Check if formatting is preserved\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n compatible = \"1.0\" # Comment\n incompatible = \"2.0\" # Comment\n pinned = \"=1.0\" # Comment\n less-than = \"<99.0\" # Comment\n renamed-to = { package = \"renamed-from\", version = \"1.0\" } # Comment\n pre-release = \"1.0\" # Comment\n yanked = \"1.0\" # Comment\n ws.workspace = true # Comment\n shared = \"2.0\" # Comment\n multiple-locations = { path = \"../multiple-locations\", version = \"1.0\" } # Comment\n multiple-versions = \"3.0\" # Comment\n alternative-1 = { registry = \"alternative\", version = \"2.0\" } # Comment\n multiple-registries = \"2.0\" # Comment\n bar = { path = \"../bar\", registry = \"alternative\", version = \"1.0.0\" } # Comment\n multiple-source-types = { path = \"../multiple-source-types\", version = \"1.0.0\" } # Comment\n\n [dependencies.alternative-2] # Comment\n version = \"2.0\" # Comment\n registry = \"alternative\" # Comment\n\n [target.'cfg(unix)'.dependencies]\n platform-specific = \"2.0\" # Comment\n\n [dev-dependencies]\n dev = \"2.0\" # Comment\n\n [build-dependencies]\n build = \"2.0\" # Comment\n \"#]],\n );\n\n let bar_manifest = p.read_file(\"bar/Cargo.toml\");\n\n assert_e2e().eq(\n &bar_manifest,\n str![[r#\"\n\n [package]\n name = \"bar\"\n version = \"1.0.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n shared = \"2.0\"\n multiple-versions = \"3.0\"\n multiple-registries = { registry = \"alternative\", version = \"3.0\" } # Comment\n multiple-source-types = \"2.0\" # Comment\n \"#]],\n );\n\n p.cargo(\"update\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `alternative` index\n[UPDATING] `dummy-registry` index\n[LOCKING] 4 packages to latest compatible versions\n[UPDATING] compatible v1.0.0 -> v1.0.1\n[UPDATING] less-than v1.0.0 -> v2.0.0\n[UPDATING] pinned v1.0.0 -> v1.0.1 (available: v2.0.0)\n[UPDATING] renamed-from v1.0.0 -> v1.0.1 (available: v2.0.0)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_specific_packages() {\n Package::new(\"just-foo\", \"1.0.0\")\n .add_dep(Dependency::new(\"transitive-compatible\", \"1.0.0\").build())\n .add_dep(Dependency::new(\"transitive-incompatible\", \"1.0.0\").build())\n .publish();\n Package::new(\"just-bar\", \"1.0.0\").publish();\n Package::new(\"shared\", \"1.0.0\").publish();\n Package::new(\"ws\", \"1.0.0\").publish();\n Package::new(\"transitive-compatible\", \"1.0.0\").publish();\n Package::new(\"transitive-incompatible\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\", \"bar\"]\n\n [workspace.dependencies]\n ws = \"1.0\"\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n just-foo = \"1.0\"\n shared = \"1.0\"\n ws.workspace = true\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n just-bar = \"1.0\"\n shared = \"1.0\"\n ws.workspace = true\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"just-foo\", \"1.0.1\")\n .add_dep(Dependency::new(\"transitive-compatible\", \"1.0.0\").build())\n .add_dep(Dependency::new(\"transitive-incompatible\", \"1.0.0\").build())\n .publish();\n Package::new(\"just-bar\", \"1.0.1\").publish();\n Package::new(\"shared\", \"1.0.1\").publish();\n Package::new(\"ws\", \"1.0.1\").publish();\n Package::new(\"transitive-compatible\", \"1.0.1\").publish();\n Package::new(\"transitive-incompatible\", \"1.0.1\").publish();\n\n Package::new(\"just-foo\", \"2.0.0\")\n // Upgrading just-foo implies accepting an update of transitive-compatible.\n .add_dep(Dependency::new(\"transitive-compatible\", \"1.0.1\").build())\n // Upgrading just-foo implies accepting a major update of transitive-incompatible.\n .add_dep(Dependency::new(\"transitive-incompatible\", \"2.0.0\").build())\n .publish();\n Package::new(\"just-bar\", \"2.0.0\").publish();\n Package::new(\"shared\", \"2.0.0\").publish();\n Package::new(\"ws\", \"2.0.0\").publish();\n Package::new(\"transitive-incompatible\", \"2.0.0\").publish();\n\n p.cargo(\"update -Zunstable-options --breaking just-foo shared ws\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPGRADING] shared ^1.0 -> ^2.0\n[UPGRADING] ws ^1.0 -> ^2.0\n[UPGRADING] just-foo ^1.0 -> ^2.0\n[LOCKING] 5 packages to latest compatible versions\n[UPDATING] just-foo v1.0.0 -> v2.0.0\n[UPDATING] shared v1.0.0 -> v2.0.0\n[UPDATING] transitive-compatible v1.0.0 -> v1.0.1\n[UPDATING] transitive-incompatible v1.0.0 -> v2.0.0\n[UPDATING] ws v1.0.0 -> v2.0.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_specific_packages_that_wont_update() {\n Package::new(\"compatible\", \"1.0.0\").publish();\n Package::new(\"renamed-from\", \"1.0.0\").publish();\n Package::new(\"non-semver\", \"1.0.0\").publish();\n Package::new(\"bar\", \"1.0.0\")\n .add_dep(Dependency::new(\"transitive-compatible\", \"1.0.0\").build())\n .add_dep(Dependency::new(\"transitive-incompatible\", \"1.0.0\").build())\n .publish();\n Package::new(\"transitive-compatible\", \"1.0.0\").publish();\n Package::new(\"transitive-incompatible\", \"1.0.0\").publish();\n\n let crate_manifest = r#\"\n # Check if formatting is preserved\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n compatible = \"1.0\" # Comment\n renamed-to = { package = \"renamed-from\", version = \"1.0\" } # Comment\n non-semver = \"~1.0\" # Comment\n bar = \"1.0\" # Comment\n \"#;\n\n let p = project()\n .file(\"Cargo.toml\", crate_manifest)\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n let lock_file = p.read_file(\"Cargo.lock\");\n\n Package::new(\"compatible\", \"1.0.1\").publish();\n Package::new(\"renamed-from\", \"1.0.1\").publish();\n Package::new(\"non-semver\", \"1.0.1\").publish();\n Package::new(\"transitive-compatible\", \"1.0.1\").publish();\n Package::new(\"transitive-incompatible\", \"1.0.1\").publish();\n\n Package::new(\"renamed-from\", \"2.0.0\").publish();\n Package::new(\"non-semver\", \"2.0.0\").publish();\n Package::new(\"transitive-incompatible\", \"2.0.0\").publish();\n\n // Test that transitive dependencies produce helpful errors\n p.cargo(\"update -Zunstable-options --breaking transitive-compatible transitive-incompatible\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specifications did not match any direct dependencies that could be upgraded\n transitive-compatible\n transitive-incompatible\n[NOTE] `transitive-compatible` exists as a transitive dependency but those are not available for upgrading through `--breaking`\n[NOTE] `transitive-incompatible` exists as a transitive dependency but those are not available for upgrading through `--breaking`\n\n\"#]])\n .run();\n\n // Test that renamed, non-semver, no-breaking-update dependencies produce errors\n p.cargo(\"update -Zunstable-options --breaking compatible renamed-from non-semver\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] package ID specifications did not match any direct dependencies that could be upgraded\n compatible\n renamed-from\n non-semver\n\n\"#]])\n .run();\n\n let crate_manifest_after = p.read_file(\"Cargo.toml\");\n assert_e2e().eq(&crate_manifest_after, crate_manifest);\n\n let lock_file_after = p.read_file(\"Cargo.lock\");\n assert_e2e().eq(&lock_file_after, lock_file);\n\n p.cargo(\n \"update compatible renamed-from non-semver transitive-compatible transitive-incompatible\",\n )\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[LOCKING] 5 packages to latest compatible versions\n[UPDATING] compatible v1.0.0 -> v1.0.1\n[UPDATING] non-semver v1.0.0 -> v1.0.1 (available: v2.0.0)\n[UPDATING] renamed-from v1.0.0 -> v1.0.1 (available: v2.0.0)\n[UPDATING] transitive-compatible v1.0.0 -> v1.0.1\n[UPDATING] transitive-incompatible v1.0.0 -> v1.0.1\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_without_lock_file() {\n Package::new(\"compatible\", \"1.0.0\").publish();\n Package::new(\"incompatible\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n compatible = \"1.0\" # Comment\n incompatible = \"1.0\" # Comment\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"compatible\", \"1.0.1\").publish();\n Package::new(\"incompatible\", \"1.0.1\").publish();\n\n Package::new(\"incompatible\", \"2.0.0\").publish();\n\n p.cargo(\"update -Zunstable-options --breaking\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[UPGRADING] incompatible ^1.0 -> ^2.0\n[LOCKING] 2 packages to latest compatible versions\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_spec_version() {\n Package::new(\"compatible\", \"1.0.0\").publish();\n Package::new(\"incompatible\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n compatible = \"1.0\" # Comment\n incompatible = \"1.0\" # Comment\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"compatible\", \"1.0.1\").publish();\n Package::new(\"incompatible\", \"1.0.1\").publish();\n\n Package::new(\"incompatible\", \"2.0.0\").publish();\n\n // Invalid spec\n p.cargo(\"update -Zunstable-options --breaking incompatible@foo\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] invalid package ID specification: `incompatible@foo`\n\nCaused by:\n expected a version like \"1.32\"\n\n\"#]])\n .run();\n\n // Spec version not matching our current dependencies\n p.cargo(\"update -Zunstable-options --breaking incompatible@2.0.0\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n incompatible@2.0.0\n\n\"#]])\n .run();\n\n // Spec source not matching our current dependencies\n p.cargo(\"update -Zunstable-options --breaking https://alternative.com#incompatible@1.0.0\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n https://alternative.com/#incompatible@1.0.0\n\n\"#]])\n .run();\n\n // Accepted spec\n p.cargo(\"update -Zunstable-options --breaking incompatible@1.0.0\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[UPGRADING] incompatible ^1.0 -> ^2.0\n[LOCKING] 1 package to latest compatible version\n[UPDATING] incompatible v1.0.0 -> v2.0.0\n\n\"#]])\n .run();\n\n // Accepted spec, full format\n Package::new(\"incompatible\", \"3.0.0\").publish();\n p.cargo(\"update -Zunstable-options --breaking https://github.com/rust-lang/crates.io-index#incompatible@2.0.0\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[UPGRADING] incompatible ^2.0 -> ^3.0\n[LOCKING] 1 package to latest compatible version\n[UPDATING] incompatible v2.0.0 -> v3.0.0\n\n\"#]])\n .run();\n\n // Spec matches a dependency that will not be upgraded\n p.cargo(\"update -Zunstable-options --breaking compatible@1.0.0\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n compatible@1.0.0\n\n\"#]])\n .run();\n\n // Non-existing versions\n p.cargo(\"update -Zunstable-options --breaking incompatible@9.0.0\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n incompatible@9.0.0\n\n\"#]])\n .run();\n\n p.cargo(\"update -Zunstable-options --breaking compatible@9.0.0\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n compatible@9.0.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_spec_version_transitive() {\n Package::new(\"dep\", \"1.0.0\").publish();\n Package::new(\"dep\", \"1.1.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n dep = \"1.0\"\n bar = { path = \"bar\", version = \"0.0.1\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n dep = \"1.1\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"dep\", \"1.1.1\").publish();\n Package::new(\"dep\", \"2.0.0\").publish();\n\n // Will upgrade the direct dependency\n p.cargo(\"update -Zunstable-options --breaking dep@1.0\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[UPGRADING] dep ^1.0 -> ^2.0\n[LOCKING] 1 package to latest compatible version\n[ADDING] dep v2.0.0\n\n\"#]])\n .run();\n\n // But not the transitive one, because bar is not a workspace member\n p.cargo(\"update -Zunstable-options --breaking dep@1.1\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n dep@1.1\n\n\"#]])\n .run();\n\n // A non-breaking update is different, as it will update transitive dependencies\n p.cargo(\"update dep@1.1\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[LOCKING] 1 package to latest compatible version\n[UPDATING] dep v1.1.0 -> v1.1.1\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_mixed_compatibility() {\n Package::new(\"mixed-compatibility\", \"1.0.0\").publish();\n Package::new(\"mixed-compatibility\", \"2.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\", \"bar\"]\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n mixed-compatibility = \"1.0\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n mixed-compatibility = \"2.0\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"mixed-compatibility\", \"2.0.1\").publish();\n\n p.cargo(\"update -Zunstable-options --breaking\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[UPGRADING] mixed-compatibility ^1.0 -> ^2.0\n[LOCKING] 1 package to latest compatible version\n[ADDING] mixed-compatibility v2.0.1\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_mixed_pinning_renaming() {\n Package::new(\"mixed-pinned\", \"1.0.0\").publish();\n Package::new(\"mixed-ws-pinned\", \"1.0.0\").publish();\n Package::new(\"renamed-from\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"pinned\", \"unpinned\", \"mixed\"]\n\n [workspace.dependencies]\n mixed-ws-pinned = \"=1.0\"\n \"#,\n )\n .file(\n \"pinned/Cargo.toml\",\n r#\"\n [package]\n name = \"pinned\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n mixed-pinned = \"=1.0\"\n mixed-ws-pinned.workspace = true\n renamed-to = { package = \"renamed-from\", version = \"1.0\" }\n \"#,\n )\n .file(\"pinned/src/lib.rs\", \"\")\n .file(\n \"unpinned/Cargo.toml\",\n r#\"\n [package]\n name = \"unpinned\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n mixed-pinned = \"1.0\"\n mixed-ws-pinned = \"1.0\"\n renamed-from = \"1.0\"\n \"#,\n )\n .file(\"unpinned/src/lib.rs\", \"\")\n .file(\n \"mixed/Cargo.toml\",\n r#\"\n [package]\n name = \"mixed\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [target.'cfg(windows)'.dependencies]\n mixed-pinned = \"1.0\"\n\n [target.'cfg(unix)'.dependencies]\n mixed-pinned = \"=1.0\"\n \"#,\n )\n .file(\"mixed/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"mixed-pinned\", \"2.0.0\").publish();\n Package::new(\"mixed-ws-pinned\", \"2.0.0\").publish();\n Package::new(\"renamed-from\", \"2.0.0\").publish();\n\n p.cargo(\"update -Zunstable-options --breaking\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `[..]` index\n[UPGRADING] mixed-pinned ^1.0 -> ^2.0\n[UPGRADING] mixed-ws-pinned ^1.0 -> ^2.0\n[UPGRADING] renamed-from ^1.0 -> ^2.0\n[LOCKING] 3 packages to latest compatible versions\n[ADDING] mixed-pinned v2.0.0\n[ADDING] mixed-ws-pinned v2.0.0\n[ADDING] renamed-from v2.0.0\n\n\"#]])\n .run();\n\n let root_manifest = p.read_file(\"Cargo.toml\");\n assert_e2e().eq(\n &root_manifest,\n str![[r#\"\n\n [workspace]\n members = [\"pinned\", \"unpinned\", \"mixed\"]\n\n [workspace.dependencies]\n mixed-ws-pinned = \"=1.0\"\n \"#]],\n );\n\n let pinned_manifest = p.read_file(\"pinned/Cargo.toml\");\n assert_e2e().eq(\n &pinned_manifest,\n str![[r#\"\n\n [package]\n name = \"pinned\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n mixed-pinned = \"=1.0\"\n mixed-ws-pinned.workspace = true\n renamed-to = { package = \"renamed-from\", version = \"1.0\" }\n \"#]],\n );\n\n let unpinned_manifest = p.read_file(\"unpinned/Cargo.toml\");\n assert_e2e().eq(\n &unpinned_manifest,\n str![[r#\"\n\n [package]\n name = \"unpinned\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n mixed-pinned = \"2.0\"\n mixed-ws-pinned = \"2.0\"\n renamed-from = \"2.0\"\n \"#]],\n );\n\n let mixed_manifest = p.read_file(\"mixed/Cargo.toml\");\n assert_e2e().eq(\n &mixed_manifest,\n str![[r#\"\n\n [package]\n name = \"mixed\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [target.'cfg(windows)'.dependencies]\n mixed-pinned = \"2.0\"\n\n [target.'cfg(unix)'.dependencies]\n mixed-pinned = \"=1.0\"\n \"#]],\n );\n}\n\n#[cargo_test]\nfn update_breaking_pre_release_downgrade() {\n Package::new(\"bar\", \"2.0.0-beta.21\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"2.0.0-beta.21\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n // The purpose of this test is\n // to demonstrate that `update --breaking` will not try to downgrade to the latest stable version (1.7.0),\n // but will error because the dependency uses an exact version (not caret).\n Package::new(\"bar\", \"1.7.0\").publish();\n p.cargo(\"update -Zunstable-options --breaking bar\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n bar\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_pre_release_upgrade() {\n Package::new(\"bar\", \"2.0.0-beta.21\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"2.0.0-beta.21\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n // `2.0.0-beta.21` cannot be upgraded with --breaking because it uses an exact version (not caret)\n Package::new(\"bar\", \"2.0.0-beta.22\").publish();\n p.cargo(\"update -Zunstable-options --breaking bar\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n bar\n\n\"#]])\n .run();\n // `2.0.0-beta.21` cannot be upgraded to `2.0.0` with --breaking because it uses an exact version (not caret)\n Package::new(\"bar\", \"2.0.0\").publish();\n p.cargo(\"update -Zunstable-options --breaking bar\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n bar\n\n\"#]])\n .run();\n\n Package::new(\"bar\", \"3.0.0\").publish();\n p.cargo(\"update -Zunstable-options --breaking bar\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPGRADING] bar ^2.0.0-beta.21 -> ^3.0.0\n[LOCKING] 1 package to latest compatible version\n[UPDATING] bar v2.0.0-beta.21 -> v3.0.0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn prefixed_v_in_version() {\n Package::new(\"bar\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"1.0.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"bar\", \"1.0.1\").publish();\n p.cargo(\"update bar --precise v1.0.1\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] the version provided, `v1.0.1` is not a valid SemVer version\n\n[HELP] try changing the version to `1.0.1`\n\nCaused by:\n unexpected character 'v' while parsing major version number\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn update_breaking_missing_package_error() {\n Package::new(\"bar\", \"1.0.0\").publish();\n Package::new(\"transitive\", \"1.0.0\").publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"generate-lockfile\").run();\n\n Package::new(\"bar\", \"2.0.0\")\n .add_dep(Dependency::new(\"transitive\", \"1.0.0\").build())\n .publish();\n\n // Non-existent package reports an error\n p.cargo(\"update -Zunstable-options --breaking no_such_crate\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n no_such_crate\n\n\"#]])\n .run();\n\n // Valid package processes, invalid package reports error\n p.cargo(\"update -Zunstable-options --breaking bar no_such_crate\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPGRADING] bar ^1.0 -> ^2.0\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n no_such_crate\n\n\"#]])\n .run();\n\n // Successfully upgrade bar to add transitive to lockfile\n p.cargo(\"update -Zunstable-options --breaking bar\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[UPGRADING] bar ^1.0 -> ^2.0\n[LOCKING] 2 packages to latest compatible versions\n[UPDATING] bar v1.0.0 -> v2.0.0\n[ADDING] transitive v1.0.0\n\n\"#]])\n .run();\n\n // Transitive dependency reports helpful error\n p.cargo(\"update -Zunstable-options --breaking transitive\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specification did not match any direct dependencies that could be upgraded\n transitive\n[NOTE] `transitive` exists as a transitive dependency but those are not available for upgrading through `--breaking`\n\n\"#]])\n .run();\n\n // Multiple error types reported together\n p.cargo(\"update -Zunstable-options --breaking no_such_crate transitive another_missing\")\n .masquerade_as_nightly_cargo(&[\"update-breaking\"])\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package ID specifications did not match any direct dependencies that could be upgraded\n no_such_crate\n transitive\n another_missing\n[NOTE] `transitive` exists as a transitive dependency but those are not available for upgrading through `--breaking`\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/utils/cross_compile.rs", "content": "//! Support for cross-compile tests with the `--target` flag.\n//!\n//! Note that cross-testing is very limited. You need to install the\n//! \"alternate\" target to the host (32-bit for 64-bit hosts or vice-versa).\n//!\n//! Set `CFG_DISABLE_CROSS_TESTS=1` environment variable to disable these tests\n//! if you are unable to use the alternate target. Unfortunately 32-bit\n//! support on macOS is going away, so macOS users are out of luck.\n//!\n//! These tests are all disabled on rust-lang/rust's CI, but run in Cargo's CI.\n\nuse crate::prelude::*;\nuse cargo_test_support::{basic_manifest, cross_compile::alternate, main_file, project};\nuse cargo_util::ProcessError;\nuse std::fmt::Write;\nuse std::{\n process::{Command, Output},\n sync::{\n Once,\n atomic::{AtomicBool, Ordering},\n },\n};\n\n/// Whether or not the resulting cross binaries can run on the host.\nstatic CAN_RUN_ON_HOST: AtomicBool = AtomicBool::new(false);\n\npub fn disabled() -> bool {\n // First, disable if requested.\n match std::env::var(\"CFG_DISABLE_CROSS_TESTS\") {\n Ok(ref s) if *s == \"1\" => return true,\n _ => {}\n }\n\n // It requires setting `target.linker` for cross-compilation to work on aarch64,\n // so not going to bother now.\n if cfg!(all(target_arch = \"aarch64\", target_os = \"linux\")) {\n return true;\n }\n\n // Cross tests are only tested to work on macos, linux, and MSVC windows.\n if !(cfg!(target_os = \"macos\") || cfg!(target_os = \"linux\") || cfg!(target_env = \"msvc\")) {\n return true;\n }\n\n // It's not particularly common to have a cross-compilation setup, so\n // try to detect that before we fail a bunch of tests through no fault\n // of the user.\n static CAN_BUILD_CROSS_TESTS: AtomicBool = AtomicBool::new(false);\n static CHECK: Once = Once::new();\n\n let cross_target = alternate();\n\n let run_cross_test = || -> anyhow::Result {\n let p = project()\n .at(\"cross_test\")\n .file(\"Cargo.toml\", &basic_manifest(\"cross_test\", \"1.0.0\"))\n .file(\"src/main.rs\", &main_file(r#\"\"testing!\"\"#, &[]))\n .build();\n\n let build_result = p\n .cargo(\"build --target\")\n .arg(&cross_target)\n .exec_with_output();\n\n if build_result.is_ok() {\n CAN_BUILD_CROSS_TESTS.store(true, Ordering::SeqCst);\n }\n\n let result = p\n .cargo(\"run --target\")\n .arg(&cross_target)\n .exec_with_output();\n\n if result.is_ok() {\n CAN_RUN_ON_HOST.store(true, Ordering::SeqCst);\n }\n build_result\n };\n\n CHECK.call_once(|| {\n drop(run_cross_test());\n });\n\n if CAN_BUILD_CROSS_TESTS.load(Ordering::SeqCst) {\n // We were able to compile a simple project, so the user has the\n // necessary `std::` bits installed. Therefore, tests should not\n // be disabled.\n return false;\n }\n\n // We can't compile a simple cross project. We want to warn the user\n // by failing a single test and having the remainder of the cross tests\n // pass. We don't use `std::sync::Once` here because panicking inside its\n // `call_once` method would poison the `Once` instance, which is not what\n // we want.\n static HAVE_WARNED: AtomicBool = AtomicBool::new(false);\n\n if HAVE_WARNED.swap(true, Ordering::SeqCst) {\n // We are some other test and somebody else is handling the warning.\n // Just disable the current test.\n return true;\n }\n\n // We are responsible for warning the user, which we do by panicking.\n let mut message = format!(\n \"\n Cannot cross compile to {}.\n\n This failure can be safely ignored. If you would prefer to not see this\n failure, you can set the environment variable CFG_DISABLE_CROSS_TESTS to \\\"1\\\".\n\n Alternatively, you can install the necessary libraries to enable cross\n compilation tests. Cross compilation tests depend on your host platform.\n \",\n cross_target\n );\n\n if cfg!(target_os = \"linux\") {\n message.push_str(\n \"\n Linux cross tests target i686-unknown-linux-gnu, which requires the ability to\n build and run 32-bit targets. This requires the 32-bit libraries to be\n installed. For example, on Ubuntu, run `sudo apt install gcc-multilib` to\n install the necessary libraries.\n \",\n );\n } else if cfg!(target_os = \"macos\") {\n message.push_str(\n \"\n macOS on aarch64 cross tests to target x86_64-apple-darwin.\n This should be natively supported via Xcode, nothing additional besides the\n rustup target should be needed.\n \",\n );\n } else if cfg!(target_os = \"windows\") {\n message.push_str(\n \"\n Windows cross tests target i686-pc-windows-msvc, which requires the ability\n to build and run 32-bit targets. This should work automatically if you have\n properly installed Visual Studio build tools.\n \",\n );\n } else {\n // The check at the top should prevent this.\n panic!(\"platform should have been skipped\");\n }\n\n let rustup_available = Command::new(\"rustup\").output().is_ok();\n if rustup_available {\n write!(\n message,\n \"\n Make sure that the appropriate `rustc` target is installed with rustup:\n\n rustup target add {}\n \",\n cross_target\n )\n .unwrap();\n } else {\n write!(\n message,\n \"\n rustup does not appear to be installed. Make sure that the appropriate\n `rustc` target is installed for the target `{}`.\n \",\n cross_target\n )\n .unwrap();\n }\n\n // Show the actual error message.\n match run_cross_test() {\n Ok(_) => message.push_str(\"\\nUh oh, second run succeeded?\\n\"),\n Err(err) => match err.downcast_ref::() {\n Some(proc_err) => write!(message, \"\\nTest error: {}\\n\", proc_err).unwrap(),\n None => write!(message, \"\\nUnexpected non-process error: {}\\n\", err).unwrap(),\n },\n }\n\n panic!(\"{}\", message);\n}\n\n/// Whether or not the host can run cross-compiled executables.\npub fn can_run_on_host() -> bool {\n if disabled() {\n return false;\n }\n assert!(CAN_RUN_ON_HOST.load(Ordering::SeqCst));\n return true;\n}\n" }, { "path": "tests/testsuite/utils/ext.rs", "content": "use std::path::PathBuf;\n\nuse cargo_test_support::{ArgLineCommandExt, Execs, Project, TestEnvCommandExt, compare};\n\npub trait CargoProjectExt {\n /// Creates a `ProcessBuilder` to run cargo.\n ///\n /// Arguments can be separated by spaces.\n ///\n /// For `cargo run`, see [`Project::rename_run`].\n ///\n /// # Example:\n ///\n /// ```no_run\n /// # let p = cargo_test_support::project().build();\n /// p.cargo(\"build --bin foo\").run();\n /// ```\n fn cargo(&self, cmd: &str) -> Execs;\n}\n\nimpl CargoProjectExt for Project {\n fn cargo(&self, cmd: &str) -> Execs {\n let cargo = cargo_exe();\n let mut execs = self.process(&cargo);\n execs.env(\"CARGO\", cargo);\n execs.arg_line(cmd);\n execs\n }\n}\n\n/// Path to the cargo binary\npub fn cargo_exe() -> PathBuf {\n snapbox::cmd::cargo_bin!(\"cargo\").to_path_buf()\n}\n\n/// Test the cargo command\npub trait CargoCommandExt {\n fn cargo_ui() -> Self;\n}\n\nimpl CargoCommandExt for snapbox::cmd::Command {\n fn cargo_ui() -> Self {\n Self::new(cargo_exe())\n .with_assert(compare::assert_ui())\n .env(\"CARGO_TERM_COLOR\", \"always\")\n .env(\"CARGO_TERM_HYPERLINKS\", \"true\")\n .test_env()\n }\n}\n" }, { "path": "tests/testsuite/utils/mod.rs", "content": "use std::path::PathBuf;\n\nuse cargo_test_support::{ArgLineCommandExt, Execs, execs, process};\n\npub mod cross_compile;\npub mod ext;\npub mod tools;\n\n/// Run `cargo $arg_line`, see [`Execs`]\npub fn cargo_process(arg_line: &str) -> Execs {\n let cargo = cargo_exe();\n let mut p = process(&cargo);\n p.env(\"CARGO\", cargo);\n p.arg_line(arg_line);\n execs().with_process_builder(p)\n}\n\n/// Path to the cargo binary\npub fn cargo_exe() -> PathBuf {\n snapbox::cmd::cargo_bin!(\"cargo\").to_path_buf()\n}\n" }, { "path": "tests/testsuite/utils/tools.rs", "content": "//! Common executables that can be reused by various tests.\n\nuse crate::prelude::*;\nuse cargo_test_support::{Project, basic_manifest, paths, project};\nuse std::path::{Path, PathBuf};\nuse std::sync::Mutex;\nuse std::sync::OnceLock;\n\nstatic ECHO_WRAPPER: OnceLock>> = OnceLock::new();\nstatic ECHO: OnceLock>> = OnceLock::new();\nstatic CLIPPY_DRIVER: OnceLock>> = OnceLock::new();\n\n/// Returns the path to an executable that works as a wrapper around rustc.\n///\n/// The wrapper will echo the command line it was called with to stderr.\npub fn echo_wrapper() -> PathBuf {\n let mut lock = ECHO_WRAPPER\n .get_or_init(|| Default::default())\n .lock()\n .unwrap();\n if let Some(path) = &*lock {\n return path.clone();\n }\n let p = project()\n .at(paths::global_root().join(\"rustc-echo-wrapper\"))\n .file(\"Cargo.toml\", &basic_manifest(\"rustc-echo-wrapper\", \"1.0.0\"))\n .file(\n \"src/main.rs\",\n r#\"\n use std::fs::read_to_string;\n use std::path::PathBuf;\n fn main() {\n // Handle args from `@path` argfile for rustc\n let args = std::env::args()\n .flat_map(|p| if let Some(p) = p.strip_prefix(\"@\") {\n read_to_string(p).unwrap().lines().map(String::from).collect()\n } else {\n vec![p]\n })\n .collect::>();\n eprintln!(\"WRAPPER CALLED: {}\", args[1..].join(\" \"));\n let status = std::process::Command::new(&args[1])\n .args(&args[2..]).status().unwrap();\n std::process::exit(status.code().unwrap_or(1));\n }\n \"#,\n )\n .build();\n p.cargo(\"build\").run();\n let path = p.bin(\"rustc-echo-wrapper\");\n *lock = Some(path.clone());\n path\n}\n\n/// Returns the path to an executable that prints its arguments.\n///\n/// Do not expect this to be anything fancy.\npub fn echo() -> PathBuf {\n let mut lock = ECHO.get_or_init(|| Default::default()).lock().unwrap();\n if let Some(path) = &*lock {\n return path.clone();\n }\n if let Ok(path) = cargo_util::paths::resolve_executable(Path::new(\"echo\")) {\n *lock = Some(path.clone());\n return path;\n }\n // Often on Windows, `echo` is not available.\n let p = project()\n .at(paths::global_root().join(\"basic-echo\"))\n .file(\"Cargo.toml\", &basic_manifest(\"basic-echo\", \"1.0.0\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n let mut s = String::new();\n let mut it = std::env::args().skip(1).peekable();\n while let Some(n) = it.next() {\n s.push_str(&n);\n if it.peek().is_some() {\n s.push(' ');\n }\n }\n println!(\"{}\", s);\n }\n \"#,\n )\n .build();\n p.cargo(\"build\").run();\n let path = p.bin(\"basic-echo\");\n *lock = Some(path.clone());\n path\n}\n\n/// Returns a project which builds a cargo-echo simple subcommand\npub fn echo_subcommand() -> Project {\n let p = project()\n .at(\"cargo-echo\")\n .file(\"Cargo.toml\", &basic_manifest(\"cargo-echo\", \"0.0.1\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n let args: Vec<_> = ::std::env::args().skip(1).collect();\n println!(\"{}\", args.join(\" \"));\n }\n \"#,\n )\n .build();\n p.cargo(\"build\").run();\n p\n}\n\n/// A wrapper around `rustc` instead of calling `clippy`.\npub fn wrapped_clippy_driver() -> PathBuf {\n let mut lock = CLIPPY_DRIVER\n .get_or_init(|| Default::default())\n .lock()\n .unwrap();\n if let Some(path) = &*lock {\n return path.clone();\n }\n let clippy_driver = project()\n .at(paths::global_root().join(\"clippy-driver\"))\n .file(\"Cargo.toml\", &basic_manifest(\"clippy-driver\", \"0.0.1\"))\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n let mut args = std::env::args_os();\n let _me = args.next().unwrap();\n let rustc = args.next().unwrap();\n let status = std::process::Command::new(rustc).args(args).status().unwrap();\n std::process::exit(status.code().unwrap_or(1));\n }\n \"#,\n )\n .build();\n clippy_driver.cargo(\"build\").run();\n let path = clippy_driver.bin(\"clippy-driver\");\n *lock = Some(path.clone());\n path\n}\n" }, { "path": "tests/testsuite/vendor.rs", "content": "//! Tests for the `cargo vendor` command.\n//!\n//! Note that every test here uses `--respect-source-config` so that the\n//! \"fake\" crates.io is used. Otherwise `vendor` would download the crates.io\n//! index from the network.\n\nuse std::fs;\n\nuse crate::prelude::*;\nuse cargo_test_support::assert_deterministic_mtime;\nuse cargo_test_support::compare::assert_e2e;\nuse cargo_test_support::git;\nuse cargo_test_support::registry::{self, Package, RegistryBuilder};\nuse cargo_test_support::str;\nuse cargo_test_support::{Project, basic_lib_manifest, basic_manifest, paths, project};\n\n#[cargo_test]\nfn vendor_simple() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n log = \"0.3.5\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"log\", \"0.3.5\").publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n let lock = p.read_file(\"vendor/log/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.3.5\\\"\"));\n\n add_crates_io_vendor_config(&p);\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn vendor_sample_config() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n log = \"0.3.5\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"log\", \"0.3.5\").publish();\n\n p.cargo(\"vendor --respect-source-config\")\n .with_stdout_data(str![[r#\"\n[source.crates-io]\nreplace-with = \"vendored-sources\"\n\n[source.vendored-sources]\ndirectory = \"vendor\"\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn vendor_sample_config_alt_registry() {\n let registry = RegistryBuilder::new().alternative().http_index().build();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n log = { version = \"0.3.5\", registry = \"alternative\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"log\", \"0.3.5\").alternative(true).publish();\n\n p.cargo(\"vendor --respect-source-config\")\n .with_stdout_data(format!(\n r#\"[source.\"{0}\"]\nregistry = \"{0}\"\nreplace-with = \"vendored-sources\"\n\n[source.vendored-sources]\ndirectory = \"vendor\"\n\"#,\n registry.index_url()\n ))\n .run();\n}\n\n#[cargo_test]\nfn vendor_path_specified() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n log = \"0.3.5\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"log\", \"0.3.5\").publish();\n\n let path = if cfg!(windows) {\n r#\"deps\\.vendor\"#\n } else {\n \"deps/.vendor\"\n };\n\n let output = p.cargo(\"vendor --respect-source-config\").arg(path).run();\n // Assert against original output to ensure that\n // path is normalized by `ops::vendor` on Windows.\n assert_eq!(\n &String::from_utf8(output.stdout).unwrap(),\n r#\"[source.crates-io]\nreplace-with = \"vendored-sources\"\n\n[source.vendored-sources]\ndirectory = \"deps/.vendor\"\n\"#\n );\n\n let lock = p.read_file(\"deps/.vendor/log/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.3.5\\\"\"));\n}\n\nfn add_crates_io_vendor_config(p: &Project) {\n p.change_file(\n \".cargo/config.toml\",\n r#\"\n [source.crates-io]\n replace-with = 'vendor'\n\n [source.vendor]\n directory = 'vendor'\n \"#,\n );\n}\n\nfn add_git_vendor_config(p: &Project, git_project: &Project) {\n p.change_file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [source.\"git+{url}\"]\n git = \"{url}\"\n replace-with = 'vendor'\n\n [source.vendor]\n directory = 'vendor'\n \"#,\n url = git_project.url()\n ),\n );\n}\n\n#[cargo_test]\nfn package_exclude() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bar = \"0.1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bar\", \"0.1.0\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n exclude = [\".*\", \"!.include\", \"!.dotdir/include\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\".exclude\", \"\")\n .file(\".include\", \"\")\n .file(\".dotdir/exclude\", \"\")\n .file(\".dotdir/include\", \"\")\n .publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n let csum = p.read_file(\"vendor/bar/.cargo-checksum.json\");\n // Everything is included because `cargo-vendor`\n // do direct extractions from tarballs\n // (Some are excluded like `.git` or `.cargo-ok` though.)\n assert!(csum.contains(\".include\"));\n assert!(csum.contains(\".exclude\"));\n assert!(csum.contains(\".dotdir/exclude\"));\n assert!(csum.contains(\".dotdir/include\"));\n}\n\n#[cargo_test]\nfn discovery_inferred_build_rs_included() {\n let git_project = git::new(\"dep\", |project| {\n project\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n documentation = \"docs.rs/foo\"\n authors = []\n include = [\"src/lib.rs\", \"build.rs\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() {}\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n\n [dependencies.dep]\n git = '{}'\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n add_git_vendor_config(&p, &git_project);\n\n let lock = p.read_file(\"vendor/dep/Cargo.toml\");\n assert_e2e().eq(\n lock,\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2015\"\nname = \"dep\"\nversion = \"0.0.1\"\nauthors = []\nbuild = \"build.rs\"\ninclude = [\n \"src/lib.rs\",\n \"build.rs\",\n]\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\ndocumentation = \"docs.rs/foo\"\nreadme = false\nlicense = \"MIT\"\n\n[lib]\nname = \"dep\"\npath = \"src/lib.rs\"\n\n\"##]],\n );\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn discovery_inferred_build_rs_excluded() {\n let git_project = git::new(\"dep\", |project| {\n project\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n documentation = \"docs.rs/foo\"\n authors = []\n include = [\"src/lib.rs\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"build.rs\", \"fn main() {}\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n\n [dependencies.dep]\n git = '{}'\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n add_git_vendor_config(&p, &git_project);\n\n let lock = p.read_file(\"vendor/dep/Cargo.toml\");\n assert_e2e().eq(\n lock,\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2015\"\nname = \"dep\"\nversion = \"0.0.1\"\nauthors = []\nbuild = false\ninclude = [\"src/lib.rs\"]\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\ndocumentation = \"docs.rs/foo\"\nreadme = false\nlicense = \"MIT\"\n\n[lib]\nname = \"dep\"\npath = \"src/lib.rs\"\n\n\"##]],\n );\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn discovery_inferred_lib_included() {\n let git_project = git::new(\"dep\", |project| {\n project\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n documentation = \"docs.rs/foo\"\n authors = []\n include = [\"src/main.rs\", \"src/lib.rs\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", \"\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n\n [dependencies.dep]\n git = '{}'\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n add_git_vendor_config(&p, &git_project);\n\n let lock = p.read_file(\"vendor/dep/Cargo.toml\");\n assert_e2e().eq(\n lock,\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2015\"\nname = \"dep\"\nversion = \"0.0.1\"\nauthors = []\nbuild = false\ninclude = [\n \"src/main.rs\",\n \"src/lib.rs\",\n]\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\ndocumentation = \"docs.rs/foo\"\nreadme = false\nlicense = \"MIT\"\n\n[lib]\nname = \"dep\"\npath = \"src/lib.rs\"\n\n[[bin]]\nname = \"dep\"\npath = \"src/main.rs\"\n\n\"##]],\n );\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn discovery_inferred_lib_excluded() {\n let git_project = git::new(\"dep\", |project| {\n project\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n documentation = \"docs.rs/foo\"\n authors = []\n include = [\"src/main.rs\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"src/lib.rs\", \"\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n\n [dependencies.dep]\n git = '{}'\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n add_git_vendor_config(&p, &git_project);\n\n let lock = p.read_file(\"vendor/dep/Cargo.toml\");\n assert_e2e().eq(\n lock,\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2015\"\nname = \"dep\"\nversion = \"0.0.1\"\nauthors = []\nbuild = false\ninclude = [\"src/main.rs\"]\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\ndocumentation = \"docs.rs/foo\"\nreadme = false\nlicense = \"MIT\"\n\n[[bin]]\nname = \"dep\"\npath = \"src/main.rs\"\n\n\"##]],\n );\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn discovery_inferred_other_included() {\n let git_project = git::new(\"dep\", |project| {\n project\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n documentation = \"docs.rs/foo\"\n authors = []\n include = [\"src/lib.rs\", \"src/bin/foo/main.rs\", \"examples/example_foo.rs\", \"tests/test_foo.rs\", \"benches/bench_foo.rs\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/foo/main.rs\", \"fn main() {}\")\n .file(\"examples/example_foo.rs\", \"fn main() {}\")\n .file(\"tests/test_foo.rs\", \"fn main() {}\")\n .file(\"benches/bench_foo.rs\", \"fn main() {}\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n\n [dependencies.dep]\n git = '{}'\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n add_git_vendor_config(&p, &git_project);\n\n let lock = p.read_file(\"vendor/dep/Cargo.toml\");\n assert_e2e().eq(\n lock,\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2015\"\nname = \"dep\"\nversion = \"0.0.1\"\nauthors = []\nbuild = false\ninclude = [\n \"src/lib.rs\",\n \"src/bin/foo/main.rs\",\n \"examples/example_foo.rs\",\n \"tests/test_foo.rs\",\n \"benches/bench_foo.rs\",\n]\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\ndocumentation = \"docs.rs/foo\"\nreadme = false\nlicense = \"MIT\"\n\n[lib]\nname = \"dep\"\npath = \"src/lib.rs\"\n\n[[bin]]\nname = \"foo\"\npath = \"src/bin/foo/main.rs\"\n\n[[example]]\nname = \"example_foo\"\npath = \"examples/example_foo.rs\"\n\n[[test]]\nname = \"test_foo\"\npath = \"tests/test_foo.rs\"\n\n[[bench]]\nname = \"bench_foo\"\npath = \"benches/bench_foo.rs\"\n\n\"##]],\n );\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn discovery_inferred_other_excluded() {\n let git_project = git::new(\"dep\", |project| {\n project\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"dep\"\n version = \"0.0.1\"\n edition = \"2015\"\n license = \"MIT\"\n description = \"foo\"\n documentation = \"docs.rs/foo\"\n authors = []\n include = [\"src/lib.rs\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"src/bin/foo/main.rs\", \"fn main() {}\")\n .file(\"examples/example_foo.rs\", \"fn main() {}\")\n .file(\"tests/test_foo.rs\", \"fn main() {}\")\n .file(\"benches/bench_foo.rs\", \"fn main() {}\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n\n [dependencies.dep]\n git = '{}'\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n add_git_vendor_config(&p, &git_project);\n\n let lock = p.read_file(\"vendor/dep/Cargo.toml\");\n assert_e2e().eq(\n lock,\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2015\"\nname = \"dep\"\nversion = \"0.0.1\"\nauthors = []\nbuild = false\ninclude = [\"src/lib.rs\"]\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\ndocumentation = \"docs.rs/foo\"\nreadme = false\nlicense = \"MIT\"\n\n[lib]\nname = \"dep\"\npath = \"src/lib.rs\"\n\n\"##]],\n );\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn two_versions() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"0.8.0\"\n bar = { path = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"0.7.0\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bitflags\", \"0.7.0\").publish();\n Package::new(\"bitflags\", \"0.8.0\").publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n\n let lock = p.read_file(\"vendor/bitflags/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.8.0\\\"\"));\n let lock = p.read_file(\"vendor/bitflags-0.7.0/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.7.0\\\"\"));\n\n add_crates_io_vendor_config(&p);\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn two_explicit_versions() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"0.8.0\"\n bar = { path = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"0.7.0\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bitflags\", \"0.7.0\").publish();\n Package::new(\"bitflags\", \"0.8.0\").publish();\n\n p.cargo(\"vendor --respect-source-config --versioned-dirs\")\n .run();\n\n let lock = p.read_file(\"vendor/bitflags-0.8.0/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.8.0\\\"\"));\n let lock = p.read_file(\"vendor/bitflags-0.7.0/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.7.0\\\"\"));\n\n add_crates_io_vendor_config(&p);\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn help() {\n let p = project().build();\n p.cargo(\"vendor -h\").run();\n}\n\n#[cargo_test]\nfn update_versions() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"0.7.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bitflags\", \"0.7.0\").publish();\n Package::new(\"bitflags\", \"0.8.0\").publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n\n let lock = p.read_file(\"vendor/bitflags/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.7.0\\\"\"));\n\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"0.8.0\"\n \"#,\n );\n p.cargo(\"vendor --respect-source-config\").run();\n\n let lock = p.read_file(\"vendor/bitflags/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.8.0\\\"\"));\n}\n\n#[cargo_test]\nfn two_lockfiles() {\n let p = project()\n .no_manifest()\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"=0.7.0\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"=0.8.0\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bitflags\", \"0.7.0\").publish();\n Package::new(\"bitflags\", \"0.8.0\").publish();\n\n p.cargo(\"vendor --respect-source-config -s bar/Cargo.toml --manifest-path foo/Cargo.toml\")\n .run();\n\n let lock = p.read_file(\"vendor/bitflags/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.8.0\\\"\"));\n let lock = p.read_file(\"vendor/bitflags-0.7.0/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.7.0\\\"\"));\n\n add_crates_io_vendor_config(&p);\n p.cargo(\"check\").cwd(\"foo\").run();\n p.cargo(\"check\").cwd(\"bar\").run();\n}\n\n#[cargo_test]\nfn test_sync_argument() {\n let p = project()\n .no_manifest()\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"=0.7.0\"\n \"#,\n )\n .file(\"foo/src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"=0.8.0\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .file(\n \"baz/Cargo.toml\",\n r#\"\n [package]\n name = \"baz\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"=0.8.0\"\n \"#,\n )\n .file(\"baz/src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bitflags\", \"0.7.0\").publish();\n Package::new(\"bitflags\", \"0.8.0\").publish();\n\n p.cargo(\"vendor --respect-source-config --manifest-path foo/Cargo.toml -s bar/Cargo.toml baz/Cargo.toml test_vendor\")\n .with_stderr_data(str![[r#\"\n[ERROR] unexpected argument 'test_vendor' found\n\nUsage: cargo[EXE] vendor [OPTIONS] [path]\n\nFor more information, try '--help'.\n\n\"#]]\n )\n .with_status(1)\n .run();\n\n p.cargo(\"vendor --respect-source-config --manifest-path foo/Cargo.toml -s bar/Cargo.toml -s baz/Cargo.toml test_vendor\")\n .run();\n\n let lock = p.read_file(\"test_vendor/bitflags/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.8.0\\\"\"));\n let lock = p.read_file(\"test_vendor/bitflags-0.7.0/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.7.0\\\"\"));\n}\n\n#[cargo_test]\nfn delete_old_crates() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bitflags = \"=0.7.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bitflags\", \"0.7.0\").publish();\n Package::new(\"log\", \"0.3.5\").publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n p.read_file(\"vendor/bitflags/Cargo.toml\");\n\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n log = \"=0.3.5\"\n \"#,\n );\n\n p.cargo(\"vendor --respect-source-config\").run();\n let lock = p.read_file(\"vendor/log/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.3.5\\\"\"));\n assert!(!p.root().join(\"vendor/bitflags/Cargo.toml\").exists());\n}\n\n#[cargo_test]\nfn ignore_files() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n url = \"1.4.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"url\", \"1.4.1\")\n // These will be vendored\n .file(\".cargo_vcs_info.json\", \"\")\n .file(\"Cargo.toml.orig\", \"\")\n .file(\"foo.orig\", \"\")\n .file(\"foo.rej\", \"\")\n .file(\"src/lib.rs\", \"\")\n // These will not be vendored\n .file(\".cargo-ok\", \"\")\n .file(\".gitattributes\", \"\")\n .file(\".gitignore\", \"\")\n .publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n let csum = p.read_file(\"vendor/url/.cargo-checksum.json\");\n assert_e2e().eq(\n csum,\n str![[r#\"\n{\n \"files\": {\n \".cargo_vcs_info.json\": \"[..]\",\n \"Cargo.toml\": \"[..]\",\n \"Cargo.toml.orig\": \"[..]\",\n \"foo.orig\": \"[..]\",\n \"foo.rej\": \"[..]\",\n \"src/lib.rs\": \"[..]\"\n },\n \"package\": \"[..]\"\n}\n\"#]]\n .is_json(),\n );\n}\n\n#[cargo_test]\nfn included_files_only() {\n let git = git::new(\"a\", |p| {\n p.file(\"Cargo.toml\", &basic_lib_manifest(\"a\"))\n .file(\"src/lib.rs\", \"\")\n .file(\".gitignore\", \"a\")\n .file(\"a/b.md\", \"\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a = {{ git = '{}' }}\n \"#,\n git.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n let csum = p.read_file(\"vendor/a/.cargo-checksum.json\");\n assert!(!csum.contains(\"a/b.md\"));\n}\n\n#[cargo_test]\nfn dependent_crates_in_crates() {\n let git = git::new(\"a\", |p| {\n p.file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n\n [dependencies]\n b = { path = 'b' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"b/Cargo.toml\", &basic_lib_manifest(\"b\"))\n .file(\"b/src/lib.rs\", \"\")\n });\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a = {{ git = '{}' }}\n \"#,\n git.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n p.read_file(\"vendor/a/.cargo-checksum.json\");\n p.read_file(\"vendor/b/.cargo-checksum.json\");\n}\n\n#[cargo_test]\nfn vendoring_git_crates() {\n let git = git::new(\"git\", |p| {\n p.file(\"Cargo.toml\", &basic_lib_manifest(\"serde_derive\"))\n .file(\"src/lib.rs\", \"\")\n .file(\"src/wut.rs\", \"\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies.serde]\n version = \"0.5.0\"\n\n [dependencies.serde_derive]\n version = \"0.5.0\"\n\n [patch.crates-io]\n serde_derive = {{ git = '{}' }}\n \"#,\n git.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n Package::new(\"serde\", \"0.5.0\")\n .dep(\"serde_derive\", \"0.5\")\n .publish();\n Package::new(\"serde_derive\", \"0.5.0\").publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n p.read_file(\"vendor/serde_derive/src/wut.rs\");\n\n add_crates_io_vendor_config(&p);\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn git_simple() {\n let git = git::new(\"git\", |p| {\n p.file(\"Cargo.toml\", &basic_lib_manifest(\"a\"))\n .file(\"src/lib.rs\", \"\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a = {{ git = '{}' }}\n \"#,\n git.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n let csum = p.read_file(\"vendor/a/.cargo-checksum.json\");\n assert!(csum.contains(\"\\\"package\\\":null\"));\n}\n\n#[cargo_test]\nfn git_diff_rev() {\n let (git_project, git_repo) = git::new_repo(\"git\", |p| {\n p.file(\"Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"\")\n });\n let url = git_project.url();\n let ref_1 = \"v0.1.0\";\n let ref_2 = \"v0.2.0\";\n\n git::tag(&git_repo, ref_1);\n\n git_project.change_file(\"Cargo.toml\", &basic_manifest(\"a\", \"0.2.0\"));\n git::add(&git_repo);\n git::commit(&git_repo);\n git::tag(&git_repo, ref_2);\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a_1 = {{ package = \"a\", git = '{url}', rev = '{ref_1}' }}\n a_2 = {{ package = \"a\", git = '{url}', rev = '{ref_2}' }}\n \"#\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\")\n .with_stdout_data(str![[r#\"\n[source.\"git+[ROOTURL]/git?rev=v0.1.0\"]\ngit = \"[ROOTURL]/git\"\nrev = \"v0.1.0\"\nreplace-with = \"vendored-sources\"\n\n[source.\"git+[ROOTURL]/git?rev=v0.2.0\"]\ngit = \"[ROOTURL]/git\"\nrev = \"v0.2.0\"\nreplace-with = \"vendored-sources\"\n\n[source.vendored-sources]\ndirectory = \"vendor\"\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn git_duplicate() {\n let git = git::new(\"a\", |p| {\n p.file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n\n [dependencies]\n b = { path = 'b' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"b/Cargo.toml\", &basic_lib_manifest(\"b\"))\n .file(\"b/src/lib.rs\", \"\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a = {{ git = '{}' }}\n b = '0.5.0'\n\n \"#,\n git.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n Package::new(\"b\", \"0.5.0\").publish();\n\n p.cargo(\"vendor --respect-source-config\")\n .with_stderr_data(str![[r#\"\n[UPDATING] git repository `[ROOTURL]/a`\n[UPDATING] `dummy-registry` index\n[LOCKING] 3 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] b v0.5.0 (registry `dummy-registry`)\n[ERROR] failed to sync\n\nCaused by:\n found duplicate version of package `b v0.5.0` vendored from two sources:\n\n \tsource 1: registry `crates-io`\n \tsource 2: [ROOTURL]/a#[..]\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn git_complex() {\n let git_b = git::new(\"git_b\", |p| {\n p.file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"0.1.0\"\n edition = \"2021\"\n\n [dependencies]\n dep_b = { path = 'dep_b' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"dep_b/Cargo.toml\", &basic_lib_manifest(\"dep_b\"))\n .file(\"dep_b/src/lib.rs\", \"\")\n });\n\n let git_a = git::new(\"git_a\", |p| {\n p.file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n edition = \"2021\"\n\n [dependencies]\n b = {{ git = '{}' }}\n dep_a = {{ path = 'dep_a' }}\n \"#,\n git_b.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"dep_a/Cargo.toml\", &basic_lib_manifest(\"dep_a\"))\n .file(\"dep_a/src/lib.rs\", \"\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n\n [dependencies]\n a = {{ git = '{}' }}\n \"#,\n git_a.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n let output = p.cargo(\"vendor --respect-source-config\").run();\n let output = String::from_utf8(output.stdout).unwrap();\n p.change_file(\".cargo/config.toml\", &output);\n\n p.cargo(\"check -v\")\n .with_stderr_data(\n str![[r#\"\n[CHECKING] dep_b v0.5.0 ([ROOTURL]/git_b#[..])\n[CHECKING] dep_a v0.5.0 ([ROOTURL]/git_a#[..])\n[RUNNING] `rustc [..] [ROOT]/foo/vendor/dep_b/src/lib.rs [..]`\n[RUNNING] `rustc [..] [ROOT]/foo/vendor/dep_a/src/lib.rs [..]`\n[CHECKING] b v0.1.0 ([ROOTURL]/git_b#[..])\n[RUNNING] `rustc [..] [ROOT]/foo/vendor/b/src/lib.rs [..]`\n[CHECKING] a v0.1.0 ([ROOTURL]/git_a#[..])\n[RUNNING] `rustc [..] [ROOT]/foo/vendor/a/src/lib.rs [..]`\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] src/lib.rs [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn git_deterministic() {\n let git_dep = git::new(\"git_dep\", |p| {\n p.file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"git_dep\"\n version = \"0.0.1\"\n edition = \"2021\"\n license = \"MIT\"\n description = \"foo\"\n documentation = \"docs.rs/foo\"\n authors = []\n\n [[example]]\n name = \"c\"\n\n [[example]]\n name = \"b\"\n\n [[example]]\n name = \"a\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"examples/z.rs\", \"fn main() {}\")\n .file(\"examples/y.rs\", \"fn main() {}\")\n .file(\"examples/x.rs\", \"fn main() {}\")\n .file(\"examples/c.rs\", \"fn main() {}\")\n .file(\"examples/b.rs\", \"fn main() {}\")\n .file(\"examples/a.rs\", \"fn main() {}\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n git_dep = {{ git = '{}' }}\n \"#,\n git_dep.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n let output = p.cargo(\"vendor --respect-source-config\").run();\n let output = String::from_utf8(output.stdout).unwrap();\n p.change_file(\".cargo/config.toml\", &output);\n\n let git_dep_manifest = p.read_file(\"vendor/git_dep/Cargo.toml\");\n assert_e2e().eq(\n git_dep_manifest,\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2021\"\nname = \"git_dep\"\nversion = \"0.0.1\"\nauthors = []\nbuild = false\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\ndocumentation = \"docs.rs/foo\"\nreadme = false\nlicense = \"MIT\"\n\n[lib]\nname = \"git_dep\"\npath = \"src/lib.rs\"\n\n[[example]]\nname = \"a\"\npath = \"examples/a.rs\"\n\n[[example]]\nname = \"b\"\npath = \"examples/b.rs\"\n\n[[example]]\nname = \"c\"\npath = \"examples/c.rs\"\n\n[[example]]\nname = \"x\"\npath = \"examples/x.rs\"\n\n[[example]]\nname = \"y\"\npath = \"examples/y.rs\"\n\n[[example]]\nname = \"z\"\npath = \"examples/z.rs\"\n\n\"##]],\n );\n}\n\n#[cargo_test]\nfn git_update_rev() {\n let (git_project, git_repo) = git::new_repo(\"git\", |p| {\n p.file(\"Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"\")\n });\n let url = git_project.url();\n let ref_1 = \"initial\";\n let ref_2 = \"update\";\n\n git::tag(&git_repo, ref_1);\n\n git_project.change_file(\"src/lib.rs\", \"pub fn f() {}\");\n git::add(&git_repo);\n git::commit(&git_repo);\n git::tag(&git_repo, ref_2);\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a = {{ git = '{url}', rev = '{ref_1}' }}\n \"#\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config --versioned-dirs\")\n .run();\n\n let lib = p.read_file(\"vendor/a-0.1.0/src/lib.rs\");\n assert_e2e().eq(lib, \"\");\n\n p.change_file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a = {{ git = '{url}', rev = '{ref_2}' }}\n \"#\n ),\n );\n\n p.cargo(\"vendor --respect-source-config --versioned-dirs\")\n .run();\n\n let lib = p.read_file(\"vendor/a-0.1.0/src/lib.rs\");\n assert_e2e().eq(lib, \"pub fn f() {}\");\n}\n\n#[cargo_test]\nfn depend_on_vendor_dir_not_deleted() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n libc = \"0.2.30\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"libc\", \"0.2.30\").publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n assert!(p.root().join(\"vendor/libc\").is_dir());\n\n p.change_file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n libc = \"0.2.30\"\n\n [patch.crates-io]\n libc = { path = 'vendor/libc' }\n \"#,\n );\n\n p.cargo(\"vendor --respect-source-config\").run();\n assert!(p.root().join(\"vendor/libc\").is_dir());\n}\n\n#[cargo_test]\nfn ignore_hidden() {\n // Don't delete files starting with `.`\n Package::new(\"bar\", \"0.1.0\").publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"1.0.0\"\n [dependencies]\n bar = \"0.1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n p.cargo(\"vendor --respect-source-config\").run();\n // Add a `.git` directory.\n let repo = git::init(&p.root().join(\"vendor\"));\n git::add(&repo);\n git::commit(&repo);\n assert!(p.root().join(\"vendor/.git\").exists());\n // Vendor again, shouldn't change anything.\n p.cargo(\"vendor --respect-source-config\").run();\n // .git should not be removed.\n assert!(p.root().join(\"vendor/.git\").exists());\n // And just for good measure, make sure no files changed.\n let mut opts = git2::StatusOptions::new();\n assert!(\n repo.statuses(Some(&mut opts))\n .unwrap()\n .iter()\n .all(|status| status.status() == git2::Status::CURRENT)\n );\n}\n\n#[cargo_test]\nfn config_instructions_works() {\n // Check that the config instructions work for all dependency kinds.\n registry::alt_init();\n Package::new(\"dep\", \"0.1.0\").publish();\n Package::new(\"altdep\", \"0.1.0\").alternative(true).publish();\n let git_project = git::new(\"gitdep\", |project| {\n project\n .file(\"Cargo.toml\", &basic_lib_manifest(\"gitdep\"))\n .file(\"src/lib.rs\", \"\")\n });\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n\n [dependencies]\n dep = \"0.1\"\n altdep = {{version=\"0.1\", registry=\"alternative\"}}\n gitdep = {{git='{}'}}\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n let output = p.cargo(\"vendor --respect-source-config\").run();\n let output = String::from_utf8(output.stdout).unwrap();\n p.change_file(\".cargo/config.toml\", &output);\n\n p.cargo(\"check -v\")\n .with_stderr_data(\n str![[r#\"\n[CHECKING] altdep v0.1.0 (registry `alternative`)\n[CHECKING] dep v0.1.0\n[RUNNING] `rustc [..] [ROOT]/foo/vendor/altdep/src/lib.rs [..]`\n[RUNNING] `rustc [..] [ROOT]/foo/vendor/gitdep/src/lib.rs [..]`\n[RUNNING] `rustc [..] [ROOT]/foo/vendor/dep/src/lib.rs [..]`\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] src/lib.rs [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[CHECKING] gitdep v0.5.0 ([ROOTURL]/gitdep#[..])\n\n\"#]]\n .unordered(),\n )\n .run();\n}\n\n#[cargo_test]\nfn git_crlf_preservation() {\n // Check that newlines don't get changed when you vendor\n // (will only fail if your system is setup with core.autocrlf=true on windows)\n let input = \"hello \\nthere\\nmy newline\\nfriends\";\n let git_project = git::new(\"git\", |p| {\n p.file(\"Cargo.toml\", &basic_lib_manifest(\"a\"))\n .file(\"src/lib.rs\", input)\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n a = {{ git = '{}' }}\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n fs::write(\n paths::home().join(\".gitconfig\"),\n r#\"\n [core]\n autocrlf = true\n \"#,\n )\n .unwrap();\n\n p.cargo(\"vendor --respect-source-config\").run();\n let output = p.read_file(\"vendor/a/src/lib.rs\");\n assert_eq!(input, output);\n}\n\n#[cargo_test]\n#[cfg(unix)]\nfn vendor_preserves_permissions() {\n use std::os::unix::fs::MetadataExt;\n\n Package::new(\"bar\", \"1.0.0\")\n .file_with_mode(\"example.sh\", 0o755, \"#!/bin/sh\")\n .file(\"src/lib.rs\", \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n\n let umask = cargo::util::get_umask();\n let metadata = fs::metadata(p.root().join(\"vendor/bar/src/lib.rs\")).unwrap();\n assert_eq!(metadata.mode() & 0o777, 0o644 & !umask);\n let metadata = fs::metadata(p.root().join(\"vendor/bar/example.sh\")).unwrap();\n assert_eq!(metadata.mode() & 0o777, 0o755 & !umask);\n}\n\n#[cargo_test]\nfn no_remote_dependency_no_vendor() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n [dependencies]\n bar = { path = \"bar\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\nThere is no dependency to vendor in this project.\n\n\"#]])\n .run();\n assert!(!p.root().join(\"vendor\").exists());\n}\n\n#[cargo_test]\nfn vendor_crate_with_ws_inherit() {\n let git = git::new(\"ws\", |p| {\n p.file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n [workspace.package]\n version = \"0.1.0\"\n \"#,\n )\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version.workspace = true\n edition = \"2021\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"\")\n });\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n\n [dependencies]\n bar = {{ git = '{}' }}\n \"#,\n git.url()\n ),\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n p.change_file(\n \".cargo/config.toml\",\n &format!(\n r#\"\n [source.\"{}\"]\n git = \"{}\"\n replace-with = \"vendor\"\n\n [source.vendor]\n directory = \"vendor\"\n \"#,\n git.url(),\n git.url()\n ),\n );\n\n p.cargo(\"check -v\")\n .with_stderr_data(str![[r#\"\n[CHECKING] bar v0.1.0 ([ROOTURL]/ws#[..])\n[RUNNING] `rustc [..] [ROOT]/foo/vendor/bar/src/lib.rs [..]`\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[RUNNING] `rustc [..] src/lib.rs [..]`\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn dont_delete_non_registry_sources_with_respect_source_config() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n log = \"0.3.5\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"log\", \"0.3.5\").publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n let lock = p.read_file(\"vendor/log/Cargo.toml\");\n assert!(lock.contains(\"version = \\\"0.3.5\\\"\"));\n\n add_crates_io_vendor_config(&p);\n p.cargo(\"vendor --respect-source-config new-vendor-dir\")\n .with_stderr_data(str![[r#\"\n Vendoring log v0.3.5 ([ROOT]/foo/vendor/log) to new-vendor-dir/log\nTo use vendored sources, add this to your .cargo/config.toml for this project:\n\n\n\"#]])\n .with_stdout_data(str![[r#\"\n[source.crates-io]\nreplace-with = \"vendored-sources\"\n\n[source.vendored-sources]\ndirectory = \"new-vendor-dir\"\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn error_loading_which_lock() {\n // Tests an error message to make sure it is clear which\n // manifest/workspace caused the problem. In this particular case, it was\n // because the 2024 edition wants to know which rust version is in use.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"b/Cargo.toml\",\n r#\"\n [package]\n name = \"b\"\n version = \"0.1.0\"\n edition = \"2024\"\n \"#,\n )\n .file(\"b/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config -s b/Cargo.toml\")\n .env(\"RUSTC\", \"does-not-exist\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to sync\n\nCaused by:\n failed to load lockfile for [ROOT]/foo/b\n\nCaused by:\n could not execute process `does-not-exist -vV` (never executed)\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn error_downloading() {\n // Tests the error message when downloading packages.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bar = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bar\", \"1.0.0\").publish();\n p.cargo(\"generate-lockfile\").run();\n std::fs::remove_file(cargo_test_support::paths::root().join(\"dl/bar/1.0.0/download\")).unwrap();\n p.cargo(\"vendor --respect-source-config\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[DOWNLOADING] crates ...\n[ERROR] failed to sync\n\nCaused by:\n failed to download packages for [ROOT]/foo\n\nCaused by:\n failed to download from `[ROOTURL]/dl/bar/1.0.0/download`\n\nCaused by:\n [37] Could[..]t read a file:// file (Could[..]t open file [ROOT]/dl/bar/1.0.0/download)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn vendor_rename_fallback() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n log = \"0.3.5\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"log\", \"0.3.5\").publish();\n\n p.cargo(\"vendor --respect-source-config --no-delete\")\n .env(\"CARGO_LOG\", \"cargo::ops::vendor=warn\")\n .env(\"__CARGO_TEST_VENDOR_FALLBACK_CP_SOURCES\", \"true\")\n .with_status(0)\n .with_stderr_data(str![[r#\"\n...\n[..]failed to `mv \"[..]vendor[..].vendor-staging[..]log-0.3.5\" \"[..]vendor[..]log\"`: simulated rename error for testing\n...\n\"#]])\n .run();\n\n assert!(p.root().join(\"vendor/log/Cargo.toml\").exists());\n}\n\n#[cargo_test]\nfn vendor_local_registry() {\n // A regression test for rust-lang/cargo#16412\n let root = paths::root();\n fs::create_dir(root.join(\".cargo\")).unwrap();\n fs::write(\n root.join(\".cargo/config.toml\"),\n r#\"\n [source.crates-io]\n registry = 'https://wut'\n replace-with = 'my-awesome-local-registry'\n\n [source.my-awesome-local-registry]\n local-registry = 'registry'\n \"#,\n )\n .unwrap();\n\n Package::new(\"bar\", \"0.0.0\")\n .local(true)\n .file(\"src/lib.rs\", \"pub fn bar() {}\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n edition = \"2021\"\n\n [dependencies]\n bar = \"0.0.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"pub fn foo() { bar::bar(); }\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\")\n .with_stderr_data(str![[r#\"\n[LOCKING] 1 package to latest compatible version\n[UNPACKING] bar v0.0.0 (registry `[ROOT]/registry`)\n Vendoring bar v0.0.0 ([ROOT]/home/.cargo/registry/src/-[HASH]/bar-0.0.0) to vendor/bar\nTo use vendored sources, add this to your .cargo/config.toml for this project:\n\n\n\"#]])\n .run();\n\n assert_e2e().eq(\n p.read_file(\"vendor/bar/Cargo.toml\"),\n str![[r#\"\n\n [package]\n name = \"bar\"\n version = \"0.0.0\"\n authors = []\n \n\"#]],\n );\n\n assert_e2e().eq(\n p.read_file(\"vendor/bar/src/lib.rs\"),\n str![\"pub fn bar() {}\"],\n );\n}\n\n#[cargo_test]\nfn deterministic_mtime() {\n Package::new(\"foo\", \"0.1.0\")\n // content doesn't matter, we just want to check mtime\n .file(\"Cargo.lock\", \"\")\n .file(\".cargo_vcs_info.json\", \"\")\n .file(\"src/lib.rs\", \"\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"a\"\n edition = \"2015\"\n\n [dependencies]\n foo = '0.1.0'\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"vendor --respect-source-config\").run();\n\n // Generated files should have deterministic mtime after unpacking.\n assert_deterministic_mtime(p.root().join(\"vendor/foo/Cargo.lock\"));\n assert_deterministic_mtime(p.root().join(\"vendor/foo/Cargo.toml\"));\n assert_deterministic_mtime(p.root().join(\"vendor/foo/.cargo_vcs_info.json\"));\n}\n\n#[cargo_test]\nfn vendor_filters_git_files_recursively() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n\n [dependencies]\n bar = \"0.1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n Package::new(\"bar\", \"0.1.0\")\n .file(\"src/lib.rs\", \"\")\n .file(\".gitattributes\", \"*.rs text\")\n .file(\"subdir/.gitattributes\", \"*.c text\")\n .file(\"subdir/.gitignore\", \"target/\")\n .file(\"deep/nested/.git/config\", \"\")\n .file(\"tests/.gitattributes\", \"*.txt text\")\n .publish();\n\n p.cargo(\"vendor --respect-source-config\").run();\n\n // After fix, these should be filtered\n assert!(!p.root().join(\"vendor/bar/subdir/.gitattributes\").exists());\n assert!(!p.root().join(\"vendor/bar/subdir/.gitignore\").exists());\n assert!(!p.root().join(\"vendor/bar/deep/nested/.git\").exists());\n assert!(!p.root().join(\"vendor/bar/tests/.gitattributes\").exists());\n assert!(!p.root().join(\"vendor/bar/.gitattributes\").exists());\n assert!(p.root().join(\"vendor/bar/src/lib.rs\").exists());\n}\n" }, { "path": "tests/testsuite/verify_project.rs", "content": "//! Tests for the `cargo verify-project` command.\n\nuse crate::prelude::*;\nuse cargo_test_support::{basic_bin_manifest, main_file, project, str};\n\n#[cargo_test]\nfn cargo_verify_project_path_to_cargo_toml_relative() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"verify-project --manifest-path foo/Cargo.toml\")\n .cwd(p.root().parent().unwrap())\n .with_stdout_data(str![[r#\"\n{\"success\":\"true\"}\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_verify_project_path_to_cargo_toml_absolute() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"verify-project --manifest-path\")\n .arg(p.root().join(\"Cargo.toml\"))\n .cwd(p.root().parent().unwrap())\n .with_stdout_data(str![[r#\"\n{\"success\":\"true\"}\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_verify_project_cwd() {\n let p = project()\n .file(\"Cargo.toml\", &basic_bin_manifest(\"foo\"))\n .file(\"src/foo.rs\", &main_file(r#\"\"i am foo\"\"#, &[]))\n .build();\n\n p.cargo(\"verify-project\")\n .with_stdout_data(str![[r#\"\n{\"success\":\"true\"}\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cargo_verify_project_honours_unstable_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n cargo-features = [\"test-dummy-unstable\"]\n\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"verify-project\")\n .masquerade_as_nightly_cargo(&[\"test-dummy-unstable\"])\n .with_stdout_data(str![[r#\"\n{\"success\":\"true\"}\n\n\"#]])\n .run();\n\n p.cargo(\"verify-project\")\n .with_status(1)\n .with_stdout_data(str![[r#\"\n{\"invalid\":\"failed to parse manifest at `[..]`\"}\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn verify_project_invalid_toml_syntax() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n[package]\nname = \"foo\"\nversion = \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"verify-project\")\n .with_status(1)\n .with_stdout_data(str![[r#\"\n{\"invalid\":\"TOML parse error at line 4, column 11/n |/n4 | version = /n | ^/nstring values must be quoted, expected literal string/n\"}\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/version.rs", "content": "//! Tests for displaying the cargo version.\n\nuse crate::prelude::*;\nuse crate::utils::cargo_process;\nuse cargo_test_support::project;\n\n#[cargo_test]\nfn simple() {\n let p = project().build();\n\n p.cargo(\"version\")\n .with_stdout_data(&format!(\"cargo {}\\n\", cargo::version()))\n .run();\n\n p.cargo(\"--version\")\n .with_stdout_data(&format!(\"cargo {}\\n\", cargo::version()))\n .run();\n\n p.cargo(\"-V\")\n .with_stdout_data(&format!(\"cargo {}\\n\", cargo::version()))\n .run();\n}\n\n#[cargo_test]\nfn version_works_without_rustc() {\n let p = project().build();\n p.cargo(\"version\").env(\"PATH\", \"\").run();\n}\n\n#[cargo_test]\nfn version_works_with_bad_config() {\n let p = project()\n .file(\".cargo/config.toml\", \"this is not toml\")\n .build();\n p.cargo(\"version\").run();\n}\n\n#[cargo_test]\nfn version_works_with_bad_target_dir() {\n let p = project()\n .file(\n \".cargo/config.toml\",\n r#\"\n [build]\n target-dir = 4\n \"#,\n )\n .build();\n p.cargo(\"version\").run();\n}\n\n#[cargo_test]\nfn verbose() {\n // This is mainly to check that it doesn't explode.\n cargo_process(\"-vV\")\n .with_stdout_data(format!(\n \"\\\ncargo {}\nrelease: [..]\ncommit-hash: [..]\ncommit-date: [..]\nhost: [HOST_TARGET]\nlibgit2: [..] (sys:[..] [..])\nlibcurl: [..] (sys:[..] [..])\n...\nos: [..]\n\",\n cargo::version()\n ))\n .run();\n}\n" }, { "path": "tests/testsuite/warn_on_failure.rs", "content": "//! Tests for whether or not warnings are displayed for build scripts.\n\nuse crate::prelude::*;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::{Project, project, str};\n\nstatic WARNING1: &str = \"Hello! I'm a warning. :)\";\nstatic WARNING2: &str = \"And one more!\";\n\nfn make_lib(lib_src: &str) {\n Package::new(\"bar\", \"0.0.1\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n authors = []\n version = \"0.0.1\"\n edition = \"2015\"\n build = \"build.rs\"\n \"#,\n )\n .file(\n \"build.rs\",\n &format!(\n r#\"\n fn main() {{\n use std::io::Write;\n println!(\"cargo::warning={{}}\", \"{}\");\n println!(\"hidden stdout\");\n write!(&mut ::std::io::stderr(), \"hidden stderr\");\n println!(\"cargo::warning={{}}\", \"{}\");\n }}\n \"#,\n WARNING1, WARNING2\n ),\n )\n .file(\"src/lib.rs\", &format!(\"fn f() {{ {} }}\", lib_src))\n .publish();\n}\n\nfn make_upstream(main_src: &str) -> Project {\n project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"src/main.rs\", &format!(\"fn main() {{ {} }}\", main_src))\n .build()\n}\n\n#[cargo_test]\nfn no_warning_on_success() {\n make_lib(\"\");\n let upstream = make_upstream(\"\");\n upstream\n .cargo(\"build\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[COMPILING] bar v0.0.1\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn no_warning_on_bin_failure() {\n make_lib(\"\");\n let upstream = make_upstream(\"hi()\");\n upstream\n .cargo(\"build\")\n .with_status(101)\n .with_stdout_does_not_contain(\"hidden stdout\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[COMPILING] bar v0.0.1\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\nerror[E0425]: cannot find function `hi` in this scope\n...\n[ERROR] could not compile `foo` (bin \"foo\") due to 1 previous error\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn warning_on_lib_failure() {\n make_lib(\"err()\");\n let upstream = make_upstream(\"\");\n upstream\n .cargo(\"build\")\n .with_status(101)\n .with_stdout_does_not_contain(\"hidden stdout\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v0.0.1 (registry `dummy-registry`)\n[COMPILING] bar v0.0.1\nerror[E0425]: cannot find function `err` in this scope\n...\n[WARNING] bar@0.0.1: Hello! I'm a warning. :)\n[WARNING] bar@0.0.1: And one more!\n[ERROR] could not compile `bar` (lib) due to 1 previous error\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/warning_override.rs", "content": "//! Tests for overriding warning behavior using `build.warnings` config option.\n\nuse crate::prelude::*;\nuse crate::utils::tools;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::{Project, cargo_test, project, str};\n\nfn make_project_with_rustc_warning() -> Project {\n project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n \"#\n ),\n )\n .file(\"src/main.rs\", \"fn main() { let x = 3; }\")\n .build()\n}\n\n#[cargo_test]\nfn rustc_caching_allow_first() {\n let p = make_project_with_rustc_warning();\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='allow'\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='deny'\")\n .with_stderr_data(str![[r#\"\n[WARNING] unused variable: `x`\n --> src/main.rs:1:17\n |\n1 | fn main() { let x = 3; }\n | ^ [HELP] if this is intentional, prefix it with an underscore: `_x`\n |\n = [NOTE] `#[warn(unused_variables)]` [..]on by default\n\n[ERROR] `foo` (bin \"foo\") generated 1 warning[..]\n[ERROR] warnings are denied by `build.warnings` configuration\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn rustc_caching_deny_first() {\n let p = make_project_with_rustc_warning();\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='deny'\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] unused variable: `x`\n --> src/main.rs:1:17\n |\n1 | fn main() { let x = 3; }\n | ^ [HELP] if this is intentional, prefix it with an underscore: `_x`\n |\n = [NOTE] `#[warn(unused_variables)]` [..]on by default\n\n[ERROR] `foo` (bin \"foo\") generated 1 warning[..]\n[ERROR] warnings are denied by `build.warnings` configuration\n\n\"#]])\n .with_status(101)\n .run();\n\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='allow'\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn config() {\n let p = make_project_with_rustc_warning();\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .env(\"CARGO_BUILD_WARNINGS\", \"deny\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] unused variable: `x`\n --> src/main.rs:1:17\n |\n1 | fn main() { let x = 3; }\n | ^ [HELP] if this is intentional, prefix it with an underscore: `_x`\n |\n = [NOTE] `#[warn(unused_variables)]` [..]on by default\n\n[ERROR] `foo` (bin \"foo\") generated 1 warning[..]\n[ERROR] warnings are denied by `build.warnings` configuration\n\n\"#]])\n .with_status(101)\n .run();\n\n // CLI has precedence over env\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='warn'\")\n .env(\"CARGO_BUILD_WARNINGS\", \"deny\")\n .with_stderr_data(str![[r#\"\n[WARNING] unused variable: `x`\n --> src/main.rs:1:17\n |\n1 | fn main() { let x = 3; }\n | ^ [HELP] if this is intentional, prefix it with an underscore: `_x`\n |\n = [NOTE] `#[warn(unused_variables)]` [..]on by default\n\n[WARNING] `foo` (bin \"foo\") generated 1 warning[..]\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn requires_nightly() {\n // build.warnings has no effect without -Zwarnings.\n let p = make_project_with_rustc_warning();\n p.cargo(\"check\")\n .arg(\"--config\")\n .arg(\"build.warnings='deny'\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] unused variable: `x`\n --> src/main.rs:1:17\n |\n1 | fn main() { let x = 3; }\n | ^ [HELP] if this is intentional, prefix it with an underscore: `_x`\n |\n = [NOTE] `#[warn(unused_variables)]` [..]on by default\n\n[WARNING] `foo` (bin \"foo\") generated 1 warning[..]\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn clippy() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2015\"\n \"#,\n )\n .file(\"src/lib.rs\", \"use std::io;\") // <-- unused import\n .build();\n\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='deny'\")\n .env(\"RUSTC_WORKSPACE_WRAPPER\", tools::wrapped_clippy_driver())\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] unused import: `std::io`\n...\n[ERROR] `foo` (lib) generated 1 warning (run `cargo clippy --fix --lib -p foo` to apply 1 suggestion)\n[ERROR] warnings are denied by `build.warnings` configuration\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn unknown_value() {\n let p = make_project_with_rustc_warning();\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='forbid'\")\n .with_stderr_data(str![[r#\"\n[ERROR] error in --config cli option: could not load config key `build.warnings`\n\nCaused by:\n unknown variant `forbid`, expected one of `warn`, `allow`, `deny`\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn hard_warning_deny() {\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n \"#\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n p.cargo(\"rustc\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='deny'\")\n .arg(\"--\")\n .arg(\"-ox.rs\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] [..]\n\n[WARNING] [..]\n\n[WARNING] `foo` (bin \"foo\") generated 2 warnings\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn hard_warning_allow() {\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n \"#\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n p.cargo(\"rustc\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='allow'\")\n .arg(\"--\")\n .arg(\"-ox.rs\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .with_status(0)\n .run();\n}\n\n#[cargo_test]\nfn keep_going() {\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n \"#\n ),\n )\n .file(\"build.rs\", \"fn main() { let x = 3; }\")\n .file(\"src/main.rs\", \"fn main() { let y = 4; }\")\n .build();\n\n p.cargo(\"check\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='deny'\")\n .with_stderr_data(str![[r#\"\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n[WARNING] unused variable: `x`\n...\n[ERROR] `foo` (build script) generated 1 warning\n[ERROR] warnings are denied by `build.warnings` configuration\n\n\"#]])\n .with_status(101)\n .run();\n\n p.cargo(\"check --keep-going\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='deny'\")\n .with_stderr_data(str![[r#\"\n[WARNING] unused variable: `x`\n...\n[ERROR] `foo` (build script) generated 1 warning\n[COMPILING] foo v0.0.1 ([ROOT]/foo)\n...\n[ERROR] `foo` (bin \"foo\") generated 1 warning (run `cargo fix --bin \"foo\" -p foo` to apply 1 suggestion)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[ERROR] warnings are denied by `build.warnings` configuration\n\n\"#]])\n .with_status(101)\n .run();\n}\n\n#[cargo_test]\nfn cap_lints() {\n Package::new(\"has_warning\", \"1.0.0\")\n .file(\"src/lib.rs\", \"pub fn foo() { let x = 3; }\")\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n edition = \"2021\"\n\n [dependencies]\n has_warning = \"1\"\n \"#\n ),\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check -vv\")\n .env(\"RUSTFLAGS\", \"-Dwarnings\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] has_warning v1.0.0 (registry `dummy-registry`)\n[CHECKING] has_warning v1.0.0\n[RUNNING] [..]\n[WARNING] unused variable: `x`\n...\n[WARNING] `has_warning` (lib) generated 1 warning\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] [..]\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check -vv\")\n .masquerade_as_nightly_cargo(&[\"warnings\"])\n .arg(\"-Zwarnings\")\n .arg(\"--config\")\n .arg(\"build.warnings='deny'\")\n .with_stderr_data(str![[r#\"\n[CHECKING] has_warning v1.0.0\n[RUNNING] [..]\n[WARNING] unused variable: `x`\n...\n[WARNING] `has_warning` (lib) generated 1 warning\n[CHECKING] foo v0.0.1 ([ROOT]/foo)\n[RUNNING] [..]\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/weak_dep_features.rs", "content": "//! Tests for weak-dep-features.\n\nuse std::fmt::Write;\n\nuse crate::prelude::*;\nuse cargo_test_support::registry::{Dependency, Package, RegistryBuilder};\nuse cargo_test_support::str;\nuse cargo_test_support::{project, publish};\n\nuse super::features2::switch_to_resolver_2;\n\n// Helper to create lib.rs files that check features.\nfn require(enabled_features: &[&str], disabled_features: &[&str]) -> String {\n let mut s = String::new();\n writeln!(s, \"#![allow(unexpected_cfgs)]\").unwrap();\n for feature in enabled_features {\n writeln!(s, \"#[cfg(not(feature=\\\"{feature}\\\"))] compile_error!(\\\"expected feature {feature} to be enabled\\\");\",\n feature=feature).unwrap();\n }\n for feature in disabled_features {\n writeln!(s, \"#[cfg(feature=\\\"{feature}\\\")] compile_error!(\\\"did not expect feature {feature} to be enabled\\\");\",\n feature=feature).unwrap();\n }\n s\n}\n\n#[cargo_test]\nfn simple() {\n Package::new(\"bar\", \"1.0.0\")\n .feature(\"feat\", &[])\n .file(\"src/lib.rs\", &require(&[\"feat\"], &[]))\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = { version = \"1.0\", optional = true }\n\n [features]\n f1 = [\"bar?/feat\"]\n \"#,\n )\n .file(\"src/lib.rs\", &require(&[\"f1\"], &[]))\n .build();\n\n // It's a bit unfortunate that this has to download `bar`, but avoiding\n // that is extremely difficult.\n p.cargo(\"check --features f1\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check --features f1,bar\")\n .with_stderr_data(str![[r#\"\n[CHECKING] bar v1.0.0\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn deferred() {\n // A complex chain that requires deferring enabling the feature due to\n // another dependency getting enabled.\n Package::new(\"bar\", \"1.0.0\")\n .feature(\"feat\", &[])\n .file(\"src/lib.rs\", &require(&[\"feat\"], &[]))\n .publish();\n Package::new(\"dep\", \"1.0.0\")\n .add_dep(Dependency::new(\"bar\", \"1.0\").optional(true))\n .feature(\"feat\", &[\"bar?/feat\"])\n .publish();\n Package::new(\"bar_activator\", \"1.0.0\")\n .feature_dep(\"dep\", \"1.0\", &[\"bar\"])\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n dep = { version = \"1.0\", features = [\"feat\"] }\n bar_activator = \"1.0\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 3 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] dep v1.0.0 (registry `dummy-registry`)\n[DOWNLOADED] bar_activator v1.0.0 (registry `dummy-registry`)\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n[CHECKING] bar v1.0.0\n[CHECKING] dep v1.0.0\n[CHECKING] bar_activator v1.0.0\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn not_optional_dep() {\n // Attempt to use dep_name?/feat where dep_name is not optional.\n Package::new(\"dep\", \"1.0.0\").feature(\"feat\", &[]).publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n dep = \"1.0\"\n\n [features]\n feat = [\"dep?/feat\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to parse manifest at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n feature `feat` includes `dep?/feat` with a `?`, but `dep` is not an optional dependency\n A non-optional dependency of the same name is defined; consider removing the `?` or changing the dependency to be optional\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn optional_cli_syntax() {\n // --features bar?/feat\n Package::new(\"bar\", \"1.0.0\")\n .feature(\"feat\", &[])\n .file(\"src/lib.rs\", &require(&[\"feat\"], &[]))\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = { version = \"1.0\", optional = true }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n // Does not build bar.\n p.cargo(\"check --features bar?/feat\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n // Builds bar.\n p.cargo(\"check --features bar?/feat,bar\")\n .with_stderr_data(str![[r#\"\n[CHECKING] bar v1.0.0\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n eprintln!(\"check V2 resolver\");\n switch_to_resolver_2(&p);\n p.build_dir().rm_rf();\n // Does not build bar.\n p.cargo(\"check --features bar?/feat\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n // Builds bar.\n p.cargo(\"check --features bar?/feat,bar\")\n .with_stderr_data(str![[r#\"\n[CHECKING] bar v1.0.0\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn required_features() {\n // required-features doesn't allow ?\n Package::new(\"bar\", \"1.0.0\").feature(\"feat\", &[]).publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = { version = \"1.0\", optional = true }\n\n [[bin]]\n name = \"foo\"\n required-features = [\"bar?/feat\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[ERROR] invalid feature `bar?/feat` in required-features of target `foo`: optional dependency with `?` is not allowed in required-features\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn weak_with_host_decouple() {\n // weak-dep-features with new resolver\n //\n // foo v0.1.0\n // ā””ā”€ā”€ common v1.0.0\n // ā””ā”€ā”€ bar v1.0.0 <-- does not have `feat` enabled\n // [build-dependencies]\n // ā””ā”€ā”€ bar_activator v1.0.0\n // ā””ā”€ā”€ common v1.0.0\n // ā””ā”€ā”€ bar v1.0.0 <-- does have `feat` enabled\n Package::new(\"bar\", \"1.0.0\")\n .feature(\"feat\", &[])\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn feat() -> bool {\n cfg!(feature = \"feat\")\n }\n \"#,\n )\n .publish();\n\n Package::new(\"common\", \"1.0.0\")\n .add_dep(Dependency::new(\"bar\", \"1.0\").optional(true))\n .feature(\"feat\", &[\"bar?/feat\"])\n .file(\n \"src/lib.rs\",\n r#\"\n #[cfg(feature = \"bar\")]\n pub fn feat() -> bool { bar::feat() }\n #[cfg(not(feature = \"bar\"))]\n pub fn feat() -> bool { false }\n \"#,\n )\n .publish();\n\n Package::new(\"bar_activator\", \"1.0.0\")\n .feature_dep(\"common\", \"1.0\", &[\"bar\", \"feat\"])\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn feat() -> bool {\n common::feat()\n }\n \"#,\n )\n .publish();\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n resolver = \"2\"\n\n [dependencies]\n common = { version = \"1.0\", features = [\"feat\"] }\n\n [build-dependencies]\n bar_activator = \"1.0\"\n \"#,\n )\n .file(\n \"src/main.rs\",\n r#\"\n fn main() {\n assert!(!common::feat());\n }\n \"#,\n )\n .file(\n \"build.rs\",\n r#\"\n fn main() {\n assert!(bar_activator::feat());\n }\n \"#,\n )\n .build();\n\n p.cargo(\"run\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 3 packages to latest compatible versions\n[DOWNLOADING] crates ...\n[DOWNLOADED] common v1.0.0 (registry `dummy-registry`)\n[DOWNLOADED] bar_activator v1.0.0 (registry `dummy-registry`)\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n[COMPILING] bar v1.0.0\n[COMPILING] common v1.0.0\n[COMPILING] bar_activator v1.0.0\n[COMPILING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[RUNNING] `target/debug/foo[EXE]`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn weak_namespaced() {\n // Behavior with a dep: dependency.\n Package::new(\"bar\", \"1.0.0\")\n .feature(\"feat\", &[])\n .file(\"src/lib.rs\", &require(&[\"feat\"], &[]))\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = { version = \"1.0\", optional = true }\n\n [features]\n f1 = [\"bar?/feat\"]\n f2 = [\"dep:bar\"]\n \"#,\n )\n .file(\"src/lib.rs\", &require(&[\"f1\"], &[\"f2\", \"bar\"]))\n .build();\n\n p.cargo(\"check --features f1\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] bar v1.0.0 (registry `dummy-registry`)\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"tree -f\")\n .arg(\"{p} feats:{f}\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo) feats:\n\n\"#]])\n .run();\n\n p.cargo(\"tree --features f1 -f\")\n .arg(\"{p} feats:{f}\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo) feats:f1\n\n\"#]])\n .run();\n\n p.cargo(\"tree --features f1,f2 -f\")\n .arg(\"{p} feats:{f}\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo) feats:f1,f2\nā””ā”€ā”€ bar v1.0.0 feats:feat\n\n\"#]])\n .run();\n\n // \"bar\" remains not-a-feature\n p.change_file(\"src/lib.rs\", &require(&[\"f1\", \"f2\"], &[\"bar\"]));\n\n p.cargo(\"check --features f1,f2\")\n .with_stderr_data(str![[r#\"\n[CHECKING] bar v1.0.0\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn tree() {\n Package::new(\"bar\", \"1.0.0\")\n .feature(\"feat\", &[])\n .file(\"src/lib.rs\", &require(&[\"feat\"], &[]))\n .publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n bar = { version = \"1.0\", optional = true }\n\n [features]\n f1 = [\"bar?/feat\"]\n \"#,\n )\n .file(\"src/lib.rs\", &require(&[\"f1\"], &[]))\n .build();\n\n p.cargo(\"tree --features f1\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\n\n\"#]])\n .run();\n\n p.cargo(\"tree --features f1,bar\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\nā””ā”€ā”€ bar v1.0.0\n\n\"#]])\n .run();\n\n p.cargo(\"tree --features f1,bar -e features\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\nā””ā”€ā”€ bar feature \"default\"\n ā””ā”€ā”€ bar v1.0.0\n\n\"#]])\n .run();\n\n p.cargo(\"tree --features f1,bar -e features -i bar\")\n .with_stdout_data(str![[r#\"\nbar v1.0.0\nā”œā”€ā”€ bar feature \"default\"\nā”‚ ā””ā”€ā”€ foo v0.1.0 ([ROOT]/foo)\nā”‚ ā”œā”€ā”€ foo feature \"bar\" (command-line)\nā”‚ ā”œā”€ā”€ foo feature \"default\" (command-line)\nā”‚ ā””ā”€ā”€ foo feature \"f1\" (command-line)\nā””ā”€ā”€ bar feature \"feat\"\n ā””ā”€ā”€ foo feature \"f1\" (command-line)\n\n\"#]])\n .run();\n\n p.cargo(\"tree -e features --features bar?/feat\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo)\n\n\"#]])\n .run();\n\n // This is a little strange in that it produces no output.\n // Maybe `cargo tree` should print a note about why?\n p.cargo(\"tree -e features -i bar --features bar?/feat\")\n .with_stdout_data(\"\")\n .run();\n\n p.cargo(\"tree -e features -i bar --features bar?/feat,bar\")\n .with_stdout_data(str![[r#\"\nbar v1.0.0\nā”œā”€ā”€ bar feature \"default\"\nā”‚ ā””ā”€ā”€ foo v0.1.0 ([ROOT]/foo)\nā”‚ ā”œā”€ā”€ foo feature \"bar\" (command-line)\nā”‚ ā””ā”€ā”€ foo feature \"default\" (command-line)\nā””ā”€ā”€ bar feature \"feat\" (command-line)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn publish() {\n let registry = RegistryBuilder::new().http_api().http_index().build();\n\n // Publish behavior with /? syntax.\n Package::new(\"bar\", \"1.0.0\").feature(\"feat\", &[]).publish();\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n description = \"foo\"\n license = \"MIT\"\n homepage = \"https://example.com/\"\n\n [dependencies]\n bar = { version = \"1.0\", optional = true }\n\n [features]\n feat1 = []\n feat2 = [\"bar?/feat\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"publish\")\n .replace_crates_io(registry.index_url())\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n[PACKAGING] foo v0.1.0 ([ROOT]/foo)\n[UPDATING] crates.io index\n[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)\n[VERIFYING] foo v0.1.0 ([ROOT]/foo)\n[COMPILING] foo v0.1.0 ([ROOT]/foo/target/package/foo-0.1.0)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n[UPLOADING] foo v0.1.0 ([ROOT]/foo)\n[UPLOADED] foo v0.1.0 to registry `crates-io`\n[NOTE] waiting for foo v0.1.0 to be available at registry `crates-io`\n[HELP] you may press ctrl-c to skip waiting; the crate should be available shortly\n[PUBLISHED] foo v0.1.0 at registry `crates-io`\n\n\"#]])\n .run();\n\n publish::validate_upload_with_contents(\n r#\"\n {\n \"authors\": [],\n \"badges\": {},\n \"categories\": [],\n \"deps\": [\n {\n \"default_features\": true,\n \"features\": [],\n \"kind\": \"normal\",\n \"name\": \"bar\",\n \"optional\": true,\n \"target\": null,\n \"version_req\": \"^1.0\"\n }\n ],\n \"description\": \"foo\",\n \"documentation\": null,\n \"features\": {\n \"feat1\": [],\n \"feat2\": [\"bar?/feat\"]\n },\n \"homepage\": \"https://example.com/\",\n \"keywords\": [],\n \"license\": \"MIT\",\n \"license_file\": null,\n \"links\": null,\n \"name\": \"foo\",\n \"readme\": null,\n \"readme_file\": null,\n \"repository\": null,\n \"rust_version\": null,\n \"vers\": \"0.1.0\"\n }\n \"#,\n \"foo-0.1.0.crate\",\n &[\"Cargo.toml\", \"Cargo.toml.orig\", \"src/lib.rs\", \"Cargo.lock\"],\n [(\n \"Cargo.toml\",\n str![[r##\"\n# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO\n#\n# When uploading crates to the registry Cargo will automatically\n# \"normalize\" Cargo.toml files for maximal compatibility\n# with all versions of Cargo and also rewrite `path` dependencies\n# to registry (e.g., crates.io) dependencies.\n#\n# If you are reading this file be aware that the original Cargo.toml\n# will likely look very different (and much more reasonable).\n# See Cargo.toml.orig for the original contents.\n\n[package]\nedition = \"2015\"\nname = \"foo\"\nversion = \"0.1.0\"\nbuild = false\nautolib = false\nautobins = false\nautoexamples = false\nautotests = false\nautobenches = false\ndescription = \"foo\"\nhomepage = \"https://example.com/\"\nreadme = false\nlicense = \"MIT\"\n\n[features]\nfeat1 = []\nfeat2 = [\"bar?/feat\"]\n\n[lib]\nname = \"foo\"\npath = \"src/lib.rs\"\n\n[dependencies.bar]\nversion = \"1.0\"\noptional = true\n\n\"##]],\n )],\n );\n}\n" }, { "path": "tests/testsuite/workspaces.rs", "content": "//! Tests for workspaces.\n\nuse std::env;\nuse std::fs;\n\nuse crate::prelude::*;\nuse cargo_test_support::registry::Package;\nuse cargo_test_support::str;\nuse cargo_test_support::{\n ProjectBuilder, basic_lib_manifest, basic_manifest, git, paths, project, project_in_home,\n sleep_ms,\n};\n\n#[cargo_test]\nfn simple_explicit() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"..\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(!p.bin(\"bar\").is_file());\n\n p.cargo(\"build\").cwd(\"bar\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"bar\").is_file());\n\n assert!(p.root().join(\"Cargo.lock\").is_file());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n}\n\n#[cargo_test]\nfn simple_explicit_default_members() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n default-members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"..\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"bar\").is_file());\n assert!(!p.bin(\"foo\").is_file());\n}\n\n#[cargo_test]\nfn non_virtual_default_members_build_other_member() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\".\", \"bar\", \"baz\"]\n default-members = [\"baz\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"pub fn bar() {}\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[CHECKING] baz v0.1.0 ([ROOT]/foo/baz)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check --manifest-path bar/Cargo.toml\")\n .with_stderr_data(str![[r#\"\n[CHECKING] bar v0.1.0 ([ROOT]/foo/bar)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn non_virtual_default_members_build_root_project() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n default-members = [\".\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"pub fn bar() {}\")\n .build();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn inferred_root() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(!p.bin(\"bar\").is_file());\n\n p.cargo(\"build\").cwd(\"bar\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"bar\").is_file());\n\n assert!(p.root().join(\"Cargo.lock\").is_file());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n}\n\n#[cargo_test]\nfn inferred_path_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"bar\" }\n\n [workspace]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .file(\"bar/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(!p.bin(\"bar\").is_file());\n\n p.cargo(\"build\").cwd(\"bar\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"bar\").is_file());\n\n assert!(p.root().join(\"Cargo.lock\").is_file());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n}\n\n#[cargo_test]\nfn transitive_path_dep() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"bar\" }\n\n [workspace]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n baz = { path = \"../baz\" }\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .file(\"bar/src/lib.rs\", \"\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/main.rs\", \"fn main() {}\")\n .file(\"baz/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(!p.bin(\"bar\").is_file());\n assert!(!p.bin(\"baz\").is_file());\n\n p.cargo(\"build\").cwd(\"bar\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"bar\").is_file());\n assert!(!p.bin(\"baz\").is_file());\n\n p.cargo(\"build\").cwd(\"baz\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"bar\").is_file());\n assert!(p.bin(\"baz\").is_file());\n\n assert!(p.root().join(\"Cargo.lock\").is_file());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n assert!(!p.root().join(\"baz/Cargo.lock\").is_file());\n}\n\n#[cargo_test]\nfn parent_pointer_works() {\n let p = project()\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"../bar\" }\n\n [workspace]\n \"#,\n )\n .file(\"foo/src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"../foo\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .file(\"bar/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"build\").cwd(\"foo\").run();\n p.cargo(\"build\").cwd(\"bar\").run();\n assert!(p.root().join(\"foo/Cargo.lock\").is_file());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n}\n\n#[cargo_test]\nfn same_names_in_workspace() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"..\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] two packages named `foo` in this workspace:\n- [ROOT]/foo/bar/Cargo.toml\n- [ROOT]/foo/Cargo.toml\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn parent_doesnt_point_to_child() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .cwd(\"bar\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] current package believes it's in a workspace when it's not:\ncurrent: [ROOT]/foo/bar/Cargo.toml\nworkspace: [ROOT]/foo/Cargo.toml\n\nthis may be fixable by ensuring that this crate is depended on by the workspace root: [ROOT]/foo/Cargo.toml\nAlternatively, to keep it out of the workspace, add the package to the `workspace.exclude` array, or add an empty `[workspace]` table to the package's manifest.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn invalid_parent_pointer() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to read `[ROOT]/foo/foo/Cargo.toml`\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn invalid_members() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"foo\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to load manifest for workspace member `[ROOT]/foo/foo`\nreferenced by workspace at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n failed to read `[ROOT]/foo/foo/Cargo.toml`\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bare_workspace_ok() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn two_roots() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"..\"]\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] multiple workspace roots found in the same workspace:\n [ROOT]/foo/bar\n [ROOT]/foo\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn workspace_isnt_root() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"bar\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] root of a workspace inferred but wasn't a root: [ROOT]/foo/bar/Cargo.toml\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn dangling_member() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"../baz\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .file(\n \"baz/Cargo.toml\",\n r#\"\n [package]\n name = \"baz\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"../baz\"\n \"#,\n )\n .file(\"baz/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package `[ROOT]/foo/bar/Cargo.toml` is a member of the wrong workspace\nexpected: [ROOT]/foo/Cargo.toml\nactual: [ROOT]/foo/baz/Cargo.toml\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn cycle() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"bar\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"..\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] root of a workspace inferred but wasn't a root: [ROOT]/foo/bar/Cargo.toml\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn share_dependencies() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n dep1 = \"0.1\"\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n dep1 = \"< 0.1.5\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n Package::new(\"dep1\", \"0.1.3\").publish();\n Package::new(\"dep1\", \"0.1.8\").publish();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[ADDING] dep1 v0.1.3 (available: v0.1.8)\n[DOWNLOADING] crates ...\n[DOWNLOADED] dep1 v0.1.3 (registry `dummy-registry`)\n[CHECKING] dep1 v0.1.3\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn fetch_fetches_all() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n dep1 = \"*\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n Package::new(\"dep1\", \"0.1.3\").publish();\n\n p.cargo(\"fetch\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 1 package to latest compatible version\n[DOWNLOADING] crates ...\n[DOWNLOADED] dep1 v0.1.3 (registry `dummy-registry`)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn lock_works_for_everyone() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n dep2 = \"0.1\"\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n dep1 = \"0.1\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n Package::new(\"dep1\", \"0.1.0\").publish();\n Package::new(\"dep2\", \"0.1.0\").publish();\n\n p.cargo(\"generate-lockfile\")\n .with_stderr_data(str![[r#\"\n[UPDATING] `dummy-registry` index\n[LOCKING] 2 packages to latest compatible versions\n\n\"#]])\n .run();\n\n Package::new(\"dep1\", \"0.1.1\").publish();\n Package::new(\"dep2\", \"0.1.1\").publish();\n\n p.cargo(\"check\")\n .with_stderr_data(str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] dep2 v0.1.0 (registry `dummy-registry`)\n[CHECKING] dep2 v0.1.0\n[CHECKING] foo v0.1.0 ([ROOT]/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n p.cargo(\"check\")\n .cwd(\"bar\")\n .with_stderr_data(str![[r#\"\n[DOWNLOADING] crates ...\n[DOWNLOADED] dep1 v0.1.0 (registry `dummy-registry`)\n[CHECKING] dep1 v0.1.0\n[CHECKING] bar v0.1.0 ([ROOT]/foo/bar)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn virtual_works() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n p.cargo(\"build\").cwd(\"bar\").run();\n assert!(p.root().join(\"Cargo.lock\").is_file());\n assert!(p.bin(\"bar\").is_file());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n}\n\n#[cargo_test]\nfn explicit_package_argument_works_with_virtual_manifest() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n p.cargo(\"build --package bar\").run();\n assert!(p.root().join(\"Cargo.lock\").is_file());\n assert!(p.bin(\"bar\").is_file());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n}\n\n#[cargo_test]\nfn virtual_misconfigure() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n p.cargo(\"check\")\n .cwd(\"bar\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] current package believes it's in a workspace when it's not:\ncurrent: [ROOT]/foo/bar/Cargo.toml\nworkspace: [ROOT]/foo/Cargo.toml\n\nthis may be fixable by adding `bar` to the `workspace.members` array of the manifest located at: [ROOT]/foo/Cargo.toml\nAlternatively, to keep it out of the workspace, add the package to the `workspace.exclude` array, or add an empty `[workspace]` table to the package's manifest.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn virtual_build_all_implied() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn virtual_default_members() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\", \"baz\"]\n default-members = [\"bar\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .file(\"baz/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n p.cargo(\"build\").run();\n assert!(p.bin(\"bar\").is_file());\n assert!(!p.bin(\"baz\").is_file());\n}\n\n#[cargo_test]\nfn virtual_default_member_is_not_a_member() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\"]\n default-members = [\"something-else\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package `[ROOT]/foo/something-else` is listed in default-members but is not a member\nfor workspace at `[ROOT]/foo/Cargo.toml`.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn virtual_default_members_build_other_member() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"bar\", \"baz\"]\n default-members = [\"baz\"]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", \"pub fn bar() {}\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/lib.rs\", \"pub fn baz() {}\")\n .build();\n\n p.cargo(\"check --manifest-path bar/Cargo.toml\")\n .with_stderr_data(str![[r#\"\n[CHECKING] bar v0.1.0 ([ROOT]/foo/bar)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn virtual_build_no_members() {\n let p = project().file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n \"#,\n );\n let p = p.build();\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `[ROOT]/foo` contains no package: The manifest is virtual, and the workspace has no members.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn include_virtual() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [workspace]\n \"#,\n );\n let p = p.build();\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] multiple workspace roots found in the same workspace:\n [ROOT]/foo/bar\n [ROOT]/foo\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn members_include_path_deps() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"p1\"]\n\n [dependencies]\n p3 = { path = \"p3\" }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"p1/Cargo.toml\",\n r#\"\n [package]\n name = \"p1\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n p2 = { path = \"../p2\" }\n \"#,\n )\n .file(\"p1/src/lib.rs\", \"\")\n .file(\"p2/Cargo.toml\", &basic_manifest(\"p2\", \"0.1.0\"))\n .file(\"p2/src/lib.rs\", \"\")\n .file(\"p3/Cargo.toml\", &basic_manifest(\"p3\", \"0.1.0\"))\n .file(\"p3/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"check\").cwd(\"p1\").run();\n p.cargo(\"check\").cwd(\"p2\").run();\n p.cargo(\"check\").cwd(\"p3\").run();\n p.cargo(\"check\").run();\n\n assert!(p.root().join(\"target\").is_dir());\n assert!(!p.root().join(\"p1/target\").is_dir());\n assert!(!p.root().join(\"p2/target\").is_dir());\n assert!(!p.root().join(\"p3/target\").is_dir());\n}\n\n#[cargo_test]\nfn new_creates_members_list() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n \"#,\n )\n .file(\"src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"new --lib bar\").with_stderr_data(str![[r#\"\n[CREATING] library `bar` package\n[ADDING] `bar` as member of workspace at `[ROOT]/foo`\n[NOTE] see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn new_warning_with_corrupt_ws() {\n let p = project().file(\"Cargo.toml\", \"asdf\").build();\n p.cargo(\"new bar\").with_stderr_data(str![[r#\"\n[CREATING] binary (application) `bar` package\n[ERROR] key with no value, expected `=`\n --> Cargo.toml:1:5\n |\n1 | asdf\n | ^\n[WARNING] compiling this new package may not work due to invalid workspace configuration\n\nfailed searching for potential workspace\npackage manifest: `[ROOT]/foo/bar/Cargo.toml`\ninvalid potential workspace manifest: `[ROOT]/foo/Cargo.toml`\n\n[HELP] to avoid searching for a non-existent workspace, add `[workspace]` to the package manifest\n[NOTE] see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn lock_doesnt_change_depending_on_crate() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = ['baz']\n\n [dependencies]\n foo = \"*\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"baz/Cargo.toml\",\n r#\"\n [package]\n name = \"baz\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = \"*\"\n \"#,\n )\n .file(\"baz/src/lib.rs\", \"\");\n let p = p.build();\n\n Package::new(\"foo\", \"1.0.0\").publish();\n Package::new(\"bar\", \"1.0.0\").publish();\n\n p.cargo(\"check\").run();\n\n let lockfile = p.read_lockfile();\n\n p.cargo(\"check\").cwd(\"baz\").run();\n\n let lockfile2 = p.read_lockfile();\n\n assert_eq!(lockfile, lockfile2);\n}\n\n#[cargo_test]\nfn rebuild_please() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = ['lib', 'bin']\n \"#,\n )\n .file(\"lib/Cargo.toml\", &basic_manifest(\"lib\", \"0.1.0\"))\n .file(\n \"lib/src/lib.rs\",\n r#\"\n pub fn foo() -> u32 { 0 }\n \"#,\n )\n .file(\n \"bin/Cargo.toml\",\n r#\"\n [package]\n name = \"bin\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n lib = { path = \"../lib\" }\n \"#,\n )\n .file(\n \"bin/src/main.rs\",\n r#\"\n extern crate lib;\n\n fn main() {\n assert_eq!(lib::foo(), 0);\n }\n \"#,\n );\n let p = p.build();\n\n p.cargo(\"run\").cwd(\"bin\").run();\n\n sleep_ms(1000);\n\n p.change_file(\"lib/src/lib.rs\", \"pub fn foo() -> u32 { 1 }\");\n\n p.cargo(\"build\").cwd(\"lib\").run();\n\n p.cargo(\"run\")\n .cwd(\"bin\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n...\nassertion[..]\n...\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn workspace_in_git() {\n let git_project = git::new(\"dep1\", |project| {\n project\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\"]\n \"#,\n )\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"\")\n });\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"lib\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies.foo]\n git = '{}'\n \"#,\n git_project.url()\n ),\n )\n .file(\n \"src/lib.rs\",\n r#\"\n pub fn foo() -> u32 { 0 }\n \"#,\n );\n let p = p.build();\n\n p.cargo(\"check\").run();\n}\n\n#[cargo_test]\nfn lockfile_can_specify_nonexistent_members() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\"]\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/main.rs\", \"fn main() {}\")\n .file(\n \"Cargo.lock\",\n r#\"\n [[package]]\n name = \"a\"\n version = \"0.1.0\"\n\n [[package]]\n name = \"b\"\n version = \"0.1.0\"\n \"#,\n );\n\n let p = p.build();\n\n p.cargo(\"check\").cwd(\"a\").run();\n}\n\n#[cargo_test]\nfn you_cannot_generate_lockfile_for_empty_workspaces() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n \"#,\n )\n .file(\"bar/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"update\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] you can't generate a lockfile for an empty workspace.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn workspace_with_transitive_dev_deps() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = [\"mbrubeck@example.com\"]\n\n [dependencies.bar]\n path = \"bar\"\n\n [workspace]\n \"#,\n )\n .file(\"src/main.rs\", r#\"fn main() {}\"#)\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.5.0\"\n edition = \"2015\"\n authors = [\"mbrubeck@example.com\"]\n\n [dev-dependencies.baz]\n path = \"../baz\"\n \"#,\n )\n .file(\n \"bar/src/lib.rs\",\n r#\"\n pub fn init() {}\n\n #[cfg(test)]\n\n #[test]\n fn test() {\n extern crate baz;\n baz::do_stuff();\n }\n \"#,\n )\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.5.0\"))\n .file(\"baz/src/lib.rs\", r#\"pub fn do_stuff() {}\"#);\n let p = p.build();\n\n p.cargo(\"test -p bar\").run();\n}\n\n#[cargo_test]\nfn error_if_parent_cargo_toml_is_invalid() {\n let p = project()\n .file(\"Cargo.toml\", \"Totally not a TOML file\")\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .cwd(\"bar\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] key with no value, expected `=`\n --> ../Cargo.toml:1:9\n |\n1 | Totally not a TOML file\n | ^\n[ERROR] failed searching for potential workspace\npackage manifest: `[ROOT]/foo/bar/Cargo.toml`\ninvalid potential workspace manifest: `[ROOT]/foo/Cargo.toml`\n\n[HELP] to avoid searching for a non-existent workspace, add `[workspace]` to the package manifest\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn relative_path_for_member_works() {\n let p = project()\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"../bar\"]\n \"#,\n )\n .file(\"foo/src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"../foo\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\").cwd(\"foo\").run();\n p.cargo(\"check\").cwd(\"bar\").run();\n}\n\n#[cargo_test]\nfn relative_path_for_root_works() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n\n [dependencies]\n subproj = { path = \"./subproj\" }\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"subproj/Cargo.toml\", &basic_manifest(\"subproj\", \"0.1.0\"))\n .file(\"subproj/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check --manifest-path ./Cargo.toml\").run();\n\n p.cargo(\"check --manifest-path ../Cargo.toml\")\n .cwd(\"subproj\")\n .run();\n}\n\n#[cargo_test]\nfn path_dep_outside_workspace_is_not_member() {\n let p = project()\n .no_manifest()\n .file(\n \"ws/Cargo.toml\",\n r#\"\n [package]\n name = \"ws\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = { path = \"../foo\" }\n\n [workspace]\n \"#,\n )\n .file(\"ws/src/lib.rs\", \"extern crate foo;\")\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"check\").cwd(\"ws\").run();\n}\n\n#[cargo_test]\nfn test_in_and_out_of_workspace() {\n let p = project()\n .no_manifest()\n .file(\n \"ws/Cargo.toml\",\n r#\"\n [package]\n name = \"ws\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = { path = \"../foo\" }\n\n [workspace]\n members = [ \"../bar\" ]\n \"#,\n )\n .file(\"ws/src/lib.rs\", \"extern crate foo; pub fn f() { foo::f() }\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"../bar\" }\n \"#,\n )\n .file(\n \"foo/src/lib.rs\",\n \"extern crate bar; pub fn f() { bar::f() }\",\n )\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n workspace = \"../ws\"\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n \"#,\n )\n .file(\"bar/src/lib.rs\", \"pub fn f() { }\");\n let p = p.build();\n\n p.cargo(\"check\").cwd(\"ws\").run();\n\n assert!(p.root().join(\"ws/Cargo.lock\").is_file());\n assert!(p.root().join(\"ws/target\").is_dir());\n assert!(!p.root().join(\"foo/Cargo.lock\").is_file());\n assert!(!p.root().join(\"foo/target\").is_dir());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n assert!(!p.root().join(\"bar/target\").is_dir());\n\n p.cargo(\"check\").cwd(\"foo\").run();\n assert!(p.root().join(\"foo/Cargo.lock\").is_file());\n assert!(p.root().join(\"foo/target\").is_dir());\n assert!(!p.root().join(\"bar/Cargo.lock\").is_file());\n assert!(!p.root().join(\"bar/target\").is_dir());\n}\n\n#[cargo_test]\nfn test_path_dependency_under_member() {\n let p = project()\n .file(\n \"ws/Cargo.toml\",\n r#\"\n [package]\n name = \"ws\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n foo = { path = \"../foo\" }\n\n [workspace]\n \"#,\n )\n .file(\"ws/src/lib.rs\", \"extern crate foo; pub fn f() { foo::f() }\")\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n workspace = \"../ws\"\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"./bar\" }\n \"#,\n )\n .file(\n \"foo/src/lib.rs\",\n \"extern crate bar; pub fn f() { bar::f() }\",\n )\n .file(\"foo/bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"foo/bar/src/lib.rs\", \"pub fn f() { }\");\n let p = p.build();\n\n p.cargo(\"check\").cwd(\"ws\").run();\n\n assert!(!p.root().join(\"foo/bar/Cargo.lock\").is_file());\n assert!(!p.root().join(\"foo/bar/target\").is_dir());\n\n p.cargo(\"check\").cwd(\"foo/bar\").run();\n\n assert!(!p.root().join(\"foo/bar/Cargo.lock\").is_file());\n assert!(!p.root().join(\"foo/bar/target\").is_dir());\n}\n\n#[cargo_test]\nfn excluded_simple() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"ws\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n exclude = [\"foo\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"check\").run();\n assert!(p.root().join(\"target\").is_dir());\n p.cargo(\"check\").cwd(\"foo\").run();\n assert!(p.root().join(\"foo/target\").is_dir());\n}\n\n#[cargo_test]\nfn exclude_members_preferred() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"ws\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"foo/bar\"]\n exclude = [\"foo\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"\")\n .file(\"foo/bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"foo/bar/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"check\").run();\n assert!(p.root().join(\"target\").is_dir());\n p.cargo(\"check\").cwd(\"foo\").run();\n assert!(p.root().join(\"foo/target\").is_dir());\n p.cargo(\"check\").cwd(\"foo/bar\").run();\n assert!(!p.root().join(\"foo/bar/target\").is_dir());\n}\n\n#[cargo_test]\nfn exclude_but_also_depend() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"ws\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"foo/bar\" }\n\n [workspace]\n exclude = [\"foo\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"\")\n .file(\"foo/bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"foo/bar/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"check\").run();\n assert!(p.root().join(\"target\").is_dir());\n p.cargo(\"check\").cwd(\"foo\").run();\n assert!(p.root().join(\"foo/target\").is_dir());\n p.cargo(\"check\").cwd(\"foo/bar\").run();\n assert!(p.root().join(\"foo/bar/target\").is_dir());\n}\n\n#[cargo_test]\nfn excluded_default_members_still_must_be_members() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\"]\n default-members = [\"foo\", \"bar\"]\n exclude = [\"bar\"]\n \"#,\n )\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"\")\n .file(\"bar/something.txt\", \"\");\n let p = p.build();\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package `[ROOT]/foo/bar` is listed in default-members but is not a member\nfor workspace at `[ROOT]/foo/Cargo.toml`.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn excluded_default_members_crate_glob() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\", \"bar/*\"]\n default-members = [\"bar/*\"]\n exclude = [\"bar/quux\"]\n \"#,\n )\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/main.rs\", \"fn main() {}\")\n .file(\"bar/baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"bar/baz/src/main.rs\", \"fn main() {}\")\n .file(\"bar/quux/Cargo.toml\", &basic_manifest(\"quux\", \"0.1.0\"))\n .file(\"bar/quux/src/main.rs\", \"fn main() {}\");\n\n let p = p.build();\n p.cargo(\"build\").run();\n\n assert!(p.root().join(\"target\").is_dir());\n assert!(!p.bin(\"foo\").is_file());\n assert!(p.bin(\"baz\").is_file());\n assert!(!p.bin(\"quux\").exists());\n\n p.cargo(\"build --workspace\").run();\n assert!(p.root().join(\"target\").is_dir());\n assert!(p.bin(\"foo\").is_file());\n assert!(!p.bin(\"quux\").exists());\n\n p.cargo(\"build\").cwd(\"bar/quux\").run();\n assert!(p.root().join(\"bar/quux/target\").is_dir());\n}\n\n#[cargo_test]\nfn excluded_default_members_not_crate_glob() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\", \"bar/*\"]\n default-members = [\"bar/*\"]\n exclude = [\"bar/docs\"]\n \"#,\n )\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/main.rs\", \"fn main() {}\")\n .file(\"bar/baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"bar/baz/src/main.rs\", \"fn main() {}\")\n .file(\"bar/docs/readme.txt\", \"This folder is not a crate!\");\n\n let p = p.build();\n p.cargo(\"build\").run();\n\n assert!(!p.bin(\"foo\").is_file());\n assert!(p.bin(\"baz\").is_file());\n p.cargo(\"build --workspace\").run();\n assert!(p.bin(\"foo\").is_file());\n}\n\n#[cargo_test]\nfn glob_syntax() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"crates/*\"]\n exclude = [\"crates/qux\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"crates/bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"../..\"\n \"#,\n )\n .file(\"crates/bar/src/main.rs\", \"fn main() {}\")\n .file(\n \"crates/baz/Cargo.toml\",\n r#\"\n [package]\n name = \"baz\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"../..\"\n \"#,\n )\n .file(\"crates/baz/src/main.rs\", \"fn main() {}\")\n .file(\n \"crates/qux/Cargo.toml\",\n r#\"\n [package]\n name = \"qux\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n \"#,\n )\n .file(\"crates/qux/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(!p.bin(\"bar\").is_file());\n assert!(!p.bin(\"baz\").is_file());\n\n p.cargo(\"build\").cwd(\"crates/bar\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"bar\").is_file());\n\n p.cargo(\"build\").cwd(\"crates/baz\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"baz\").is_file());\n\n p.cargo(\"build\").cwd(\"crates/qux\").run();\n assert!(!p.bin(\"qux\").is_file());\n\n assert!(p.root().join(\"Cargo.lock\").is_file());\n assert!(!p.root().join(\"crates/bar/Cargo.lock\").is_file());\n assert!(!p.root().join(\"crates/baz/Cargo.lock\").is_file());\n assert!(p.root().join(\"crates/qux/Cargo.lock\").is_file());\n}\n\n/*FIXME: This fails because of how workspace.exclude and workspace.members are working.\n#[cargo_test]\nfn glob_syntax_2() {\n let p = project()\n .file(\"Cargo.toml\", r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"crates/b*\"]\n exclude = [\"crates/q*\"]\n \"#)\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"crates/bar/Cargo.toml\", r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"../..\"\n \"#)\n .file(\"crates/bar/src/main.rs\", \"fn main() {}\")\n .file(\"crates/baz/Cargo.toml\", r#\"\n [package]\n name = \"baz\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"../..\"\n \"#)\n .file(\"crates/baz/src/main.rs\", \"fn main() {}\")\n .file(\"crates/qux/Cargo.toml\", r#\"\n [package]\n name = \"qux\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n \"#)\n .file(\"crates/qux/src/main.rs\", \"fn main() {}\");\n p.build();\n\n p.cargo(\"build\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(!p.bin(\"bar\").is_file());\n assert!(!p.bin(\"baz\").is_file());\n\n p.cargo(\"build\").cwd(\"crates/bar\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"bar\").is_file());\n\n p.cargo(\"build\").cwd(\"crates/baz\").run();\n assert!(p.bin(\"foo\").is_file());\n assert!(p.bin(\"baz\").is_file());\n\n p.cargo(\"build\").cwd(\"crates/qux\").run();\n assert!(!p.bin(\"qux\").is_file());\n\n assert!(p.root().join(\"Cargo.lock\").is_file());\n assert!(!p.root().join(\"crates/bar/Cargo.lock\").is_file());\n assert!(!p.root().join(\"crates/baz/Cargo.lock\").is_file());\n assert!(p.root().join(\"crates/qux/Cargo.lock\").is_file());\n}\n*/\n\n#[cargo_test]\nfn glob_syntax_invalid_members() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"crates/*\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"crates/bar/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to load manifest for workspace member `[ROOT]/foo/crates/bar`\nreferenced via `crates/*` by workspace at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n failed to read `[ROOT]/foo/crates/bar/Cargo.toml`\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n}\n\n/// This is a freshness test for feature use with workspaces.\n///\n/// `feat_lib` is used by `caller1` and `caller2`, but with different features enabled.\n/// This test ensures that alternating building `caller1`, `caller2` doesn't force\n/// recompile of `feat_lib`.\n///\n/// Ideally, once we solve rust-lang/cargo#3620, then a single Cargo build at the top level\n/// will be enough.\n#[cargo_test]\nfn dep_used_with_separate_features() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"feat_lib\", \"caller1\", \"caller2\"]\n \"#,\n )\n .file(\n \"feat_lib/Cargo.toml\",\n r#\"\n [package]\n name = \"feat_lib\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [features]\n myfeature = []\n \"#,\n )\n .file(\"feat_lib/src/lib.rs\", \"\")\n .file(\n \"caller1/Cargo.toml\",\n r#\"\n [package]\n name = \"caller1\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n feat_lib = { path = \"../feat_lib\" }\n \"#,\n )\n .file(\"caller1/src/main.rs\", \"fn main() {}\")\n .file(\"caller1/src/lib.rs\", \"\")\n .file(\n \"caller2/Cargo.toml\",\n r#\"\n [package]\n name = \"caller2\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n feat_lib = { path = \"../feat_lib\", features = [\"myfeature\"] }\n caller1 = { path = \"../caller1\" }\n \"#,\n )\n .file(\"caller2/src/main.rs\", \"fn main() {}\")\n .file(\"caller2/src/lib.rs\", \"\");\n let p = p.build();\n\n // Build the entire workspace.\n p.cargo(\"build --workspace\")\n .with_stderr_data(str![[r#\"\n[COMPILING] feat_lib v0.1.0 ([ROOT]/foo/feat_lib)\n[COMPILING] caller1 v0.1.0 ([ROOT]/foo/caller1)\n[COMPILING] caller2 v0.1.0 ([ROOT]/foo/caller2)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n assert!(p.bin(\"caller1\").is_file());\n assert!(p.bin(\"caller2\").is_file());\n\n // Build `caller1`. Should build the dep library. Because the features\n // are different than the full workspace, it rebuilds.\n // Ideally once we solve rust-lang/cargo#3620, then a single Cargo build at the top level\n // will be enough.\n p.cargo(\"build\")\n .cwd(\"caller1\")\n .with_stderr_data(str![[r#\"\n[COMPILING] feat_lib v0.1.0 ([ROOT]/foo/feat_lib)\n[COMPILING] caller1 v0.1.0 ([ROOT]/foo/caller1)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n\n // Alternate building `caller2`/`caller1` a few times, just to make sure\n // features are being built separately. Should not rebuild anything.\n p.cargo(\"build\")\n .cwd(\"caller2\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n p.cargo(\"build\")\n .cwd(\"caller1\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n p.cargo(\"build\")\n .cwd(\"caller2\")\n .with_stderr_data(str![[r#\"\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn dont_recurse_out_of_cargo_home() {\n let git_project = git::new(\"dep\", |project| {\n project\n .file(\"Cargo.toml\", &basic_manifest(\"dep\", \"0.1.0\"))\n .file(\"src/lib.rs\", \"\")\n .file(\n \"build.rs\",\n r#\"\n use std::env;\n use std::path::Path;\n use std::process::{self, Command};\n\n fn main() {\n let cargo = env::var_os(\"CARGO\").unwrap();\n let cargo_manifest_dir = env::var_os(\"CARGO_MANIFEST_DIR\").unwrap();\n let output = Command::new(cargo)\n .args(&[\"metadata\", \"--format-version\", \"1\", \"--manifest-path\"])\n .arg(&Path::new(&cargo_manifest_dir).join(\"Cargo.toml\"))\n .output()\n .unwrap();\n if !output.status.success() {\n eprintln!(\"{}\", String::from_utf8(output.stderr).unwrap());\n process::exit(1);\n }\n }\n \"#,\n )\n });\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies.dep]\n git = \"{}\"\n\n [workspace]\n \"#,\n git_project.url()\n ),\n )\n .file(\"src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"check\")\n .env(\"CARGO_HOME\", p.root().join(\".cargo\"))\n .run();\n}\n\n// FIXME: this fails because of how workspace.exclude and workspace.members are working.\n/*\n#[cargo_test]\nfn include_and_exclude() {\n let p = project()\n .file(\"Cargo.toml\", r#\"\n [workspace]\n members = [\"foo\"]\n exclude = [\"foo/bar\"]\n \"#)\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", \"\")\n .file(\"foo/bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"foo/bar/src/lib.rs\", \"\");\n p.build();\n\n p.cargo(\"build\").cwd(\"foo\").run();\n assert!(p.root().join(\"target\").is_dir());\n assert!(!p.root().join(\"foo/target\").is_dir());\n p.cargo(\"build\").cwd(\"foo/bar\").run();\n assert!(p.root().join(\"foo/bar/target\").is_dir());\n}\n*/\n\n#[cargo_test]\nfn cargo_home_at_root_works() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = [\"a\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"a/Cargo.toml\", &basic_manifest(\"a\", \"0.1.0\"))\n .file(\"a/src/lib.rs\", \"\");\n let p = p.build();\n\n p.cargo(\"check\").run();\n p.cargo(\"check --frozen\").env(\"CARGO_HOME\", p.root()).run();\n}\n\n#[cargo_test]\nfn parent_manifest_error_mentions_workspace_search() {\n ProjectBuilder::new(paths::home())\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"home-manifest\"\n version = \"0.1.0\"\n authors = []\n \"#,\n )\n .build();\n\n let p = project_in_home(\"stuff\")\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed searching for potential workspace\npackage manifest: `[ROOT]/home/stuff/Cargo.toml`\ninvalid potential workspace manifest: `[ROOT]/home/Cargo.toml`\n\n[HELP] to avoid searching for a non-existent workspace, add `[workspace]` to the package manifest\n\nCaused by:\n failed to parse manifest at `[ROOT]/home/Cargo.toml`\n\nCaused by:\n no targets specified in the manifest\n either src/lib.rs, src/main.rs, a [lib] section, or [[bin]] section must be present\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn relative_rustc() {\n let p = project()\n .file(\n \"src/main.rs\",\n r#\"\n use std::process::Command;\n use std::env;\n\n fn main() {\n let mut cmd = Command::new(\"rustc\");\n for arg in env::args_os().skip(1) {\n cmd.arg(arg);\n }\n std::process::exit(cmd.status().unwrap().code().unwrap());\n }\n \"#,\n )\n .build();\n p.cargo(\"build\").run();\n\n let src = p\n .root()\n .join(\"target/debug/foo\")\n .with_extension(env::consts::EXE_EXTENSION);\n\n Package::new(\"a\", \"0.1.0\").publish();\n\n let p = project()\n .at(\"lib\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"lib\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n a = \"0.1\"\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n fs::copy(&src, p.root().join(src.file_name().unwrap())).unwrap();\n\n let file = format!(\"./foo{}\", env::consts::EXE_SUFFIX);\n p.cargo(\"build\").env(\"RUSTC\", &file).run();\n}\n\n#[cargo_test]\nfn ws_rustc_err() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\"]\n \"#,\n )\n .file(\"a/Cargo.toml\", &basic_lib_manifest(\"a\"))\n .file(\"a/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"rustc\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `[ROOT]/foo/Cargo.toml` is a virtual manifest, but this command requires running against an actual package in this workspace\n\n\"#]])\n .run();\n\n p.cargo(\"rustdoc\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] manifest path `[ROOT]/foo/Cargo.toml` is a virtual manifest, but this command requires running against an actual package in this workspace\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn ws_err_unused() {\n for table in &[\n \"[lib]\",\n \"[[bin]]\",\n \"[[example]]\",\n \"[[test]]\",\n \"[[bench]]\",\n \"[dependencies]\",\n \"[dev-dependencies]\",\n \"[build-dependencies]\",\n \"[features]\",\n \"[target]\",\n \"[badges]\",\n \"[lints]\",\n ] {\n let key = table.trim_start_matches('[').trim_end_matches(']');\n let p = project()\n .file(\n \"Cargo.toml\",\n &format!(\n r#\"\n [workspace]\n members = [\"a\"]\n\n {table}\n \"#,\n ),\n )\n .file(\"a/Cargo.toml\", &basic_lib_manifest(\"a\"))\n .file(\"a/src/lib.rs\", \"\")\n .build();\n p.cargo(\"check\")\n .with_status(101)\n .with_stderr_data(&format!(\n \"\\\n[ERROR] failed to parse manifest at `[..]/foo/Cargo.toml`\n\nCaused by:\n this virtual manifest specifies a `{key}` section, which is not allowed\n\",\n ))\n .run();\n }\n}\n\n#[cargo_test]\nfn ws_warn_unused() {\n for (key, name) in &[\n (\"[profile.dev]\\nopt-level = 1\", \"profiles\"),\n (\"[replace]\\n\\\"bar:0.1.0\\\" = { path = \\\"bar\\\" }\", \"replace\"),\n (\"[patch.crates-io]\\nbar = { path = \\\"bar\\\" }\", \"patch\"),\n ] {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n &format!(\n r#\"\n [package]\n name = \"a\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n {}\n \"#,\n key\n ),\n )\n .file(\"a/src/lib.rs\", \"\")\n .build();\n p.cargo(\"check\")\n .with_stderr_data(&format!(\n \"\\\n[WARNING] {} for the non root package will be ignored, specify {} at the workspace root:\npackage: [ROOT]/foo/a/Cargo.toml\nworkspace: [ROOT]/foo/Cargo.toml\n[CHECKING] a v0.1.0 ([ROOT]/foo/a)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\",\n name, name\n ))\n .run();\n }\n}\n\n#[cargo_test]\nfn ws_warn_path() {\n // Warnings include path to manifest.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"a\"]\n \"#,\n )\n .file(\n \"a/Cargo.toml\",\n r#\"\n cargo-features = [\"edition\"]\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n \"#,\n )\n .file(\"a/src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check\").with_stderr_data(str![[r#\"\n[WARNING] [ROOT]/foo/a/Cargo.toml: the cargo feature `edition` has been stabilized in the 1.31 release and is no longer necessary to be listed in the manifest\n See https://doc.rust-lang.org/cargo/reference/manifest.html#the-edition-field for more information about using this feature.\n[CHECKING] foo v0.1.0 ([ROOT]/foo/a)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]]).run();\n}\n\n#[cargo_test]\nfn invalid_missing() {\n // Make sure errors are not suppressed with -q.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n x = { path = 'x' }\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .build();\n\n p.cargo(\"check -q\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to get `x` as a dependency of package `foo v0.1.0 ([ROOT]/foo)`\n\nCaused by:\n failed to load source for dependency `x`\n\nCaused by:\n unable to update [ROOT]/foo/x\n\nCaused by:\n failed to read `[ROOT]/foo/x/Cargo.toml`\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn member_dep_missing() {\n // Make sure errors are not suppressed with -q.\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [dependencies]\n baz = { path = \"baz\" }\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"check -q\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] failed to load manifest for workspace member `[ROOT]/foo/bar`\nreferenced by workspace at `[ROOT]/foo/Cargo.toml`\n\nCaused by:\n failed to load manifest for dependency `baz`\n\nCaused by:\n failed to read `[ROOT]/foo/bar/baz/Cargo.toml`\n\nCaused by:\n [NOT_FOUND]\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn simple_primary_package_env_var() {\n let is_primary_package = r#\"\n #[test]\n fn verify_primary_package() {{\n assert!(option_env!(\"CARGO_PRIMARY_PACKAGE\").is_some());\n }}\n \"#;\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [workspace]\n members = [\"bar\"]\n \"#,\n )\n .file(\"src/lib.rs\", is_primary_package)\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n workspace = \"..\"\n \"#,\n )\n .file(\"bar/src/lib.rs\", is_primary_package);\n let p = p.build();\n\n p.cargo(\"test\").run();\n\n // Again, this time selecting a specific crate\n p.cargo(\"clean\").run();\n p.cargo(\"test -p bar\").run();\n\n // Again, this time selecting all crates\n p.cargo(\"clean\").run();\n p.cargo(\"test --all\").run();\n}\n\n#[cargo_test]\nfn virtual_primary_package_env_var() {\n let is_primary_package = r#\"\n #[test]\n fn verify_primary_package() {{\n assert!(option_env!(\"CARGO_PRIMARY_PACKAGE\").is_some());\n }}\n \"#;\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\", \"bar\"]\n \"#,\n )\n .file(\"foo/Cargo.toml\", &basic_manifest(\"foo\", \"0.1.0\"))\n .file(\"foo/src/lib.rs\", is_primary_package)\n .file(\"bar/Cargo.toml\", &basic_manifest(\"bar\", \"0.1.0\"))\n .file(\"bar/src/lib.rs\", is_primary_package);\n let p = p.build();\n\n p.cargo(\"test\").run();\n\n // Again, this time selecting a specific crate\n p.cargo(\"clean\").run();\n p.cargo(\"test -p foo\").run();\n}\n\n#[cargo_test]\nfn ensure_correct_workspace_when_nested() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\n \"sub/Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\"]\n \"#,\n )\n .file(\n \"sub/foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2015\"\n authors = []\n\n [dependencies]\n bar = { path = \"../..\"}\n \"#,\n )\n .file(\"sub/foo/src/main.rs\", \"fn main() {}\");\n let p = p.build();\n p.cargo(\"tree\")\n .cwd(\"sub/foo\")\n .with_stdout_data(str![[r#\"\nfoo v0.1.0 ([ROOT]/foo/sub/foo)\nā””ā”€ā”€ bar v0.1.0 ([ROOT]/foo)\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn nonexistence_package_together_with_workspace() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n authors = []\n edition = \"2021\"\n\n [workspace]\n members = [\"baz\"]\n \"#,\n )\n .file(\"src/lib.rs\", \"\")\n .file(\"baz/Cargo.toml\", &basic_manifest(\"baz\", \"0.1.0\"))\n .file(\"baz/src/lib.rs\", \"\");\n\n let p = p.build();\n\n p.cargo(\"check --package nonexistence --workspace\")\n .with_status(101)\n .with_stderr_data(\n str![[r#\"\n[ERROR] package(s) `nonexistence` not found in workspace `[ROOT]/foo`\n\n\"#]]\n .unordered(),\n )\n .run();\n // With pattern *\n p.cargo(\"check --package nonpattern* --workspace\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package pattern(s) `nonpattern*` not found in workspace `[ROOT]/foo`\n\n\"#]])\n .run();\n\n p.cargo(\"package --package nonexistence --workspace\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package(s) `nonexistence` not found in workspace `[ROOT]/foo`\n\n\"#]])\n .run();\n // With pattern *\n p.cargo(\"package --package nonpattern* --workspace\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package pattern(s) `nonpattern*` not found in workspace `[ROOT]/foo`\n\n\"#]])\n .run();\n\n p.cargo(\"publish --dry-run --package nonexistence --workspace\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package(s) `nonexistence` not found in workspace `[ROOT]/foo`\n\n\"#]])\n .run();\n // With pattern *\n p.cargo(\"publish --dry-run --package nonpattern* --workspace\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package pattern(s) `nonpattern*` not found in workspace `[ROOT]/foo`\n\n\"#]])\n .run();\n\n p.cargo(\"tree --package nonexistence --workspace\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package(s) `nonexistence` not found in workspace `[ROOT]/foo`\n\n\"#]])\n .run();\n // With pattern *\n p.cargo(\"tree --package nonpattern* --workspace\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] package pattern(s) `nonpattern*` not found in workspace `[ROOT]/foo`\n\n\"#]])\n .run();\n}\n\n// A failing case from \n#[cargo_test]\nfn fix_only_check_manifest_path_member() {\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [workspace]\n members = [\"foo\", \"bar\"]\n resolver = \"3\"\n \"#,\n )\n .file(\n \"foo/Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.1.0\"\n edition = \"2021\"\n \"#,\n )\n .file(\"foo/src/main.rs\", \"fn main() {}\")\n .file(\n \"bar/Cargo.toml\",\n r#\"\n [package]\n name = \"bar\"\n version = \"0.1.0\"\n edition = \"2021\"\n \"#,\n )\n .file(\"bar/src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"fix --manifest-path foo/Cargo.toml --allow-no-vcs\")\n .with_stderr_data(str![[r#\"\n[CHECKING] foo v0.1.0 ([ROOT]/foo/foo)\n[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn error_if_member_is_outside_root() {\n // This test ensures that if a member is physically outside the workspace root,\n // we get a helpful error message.\n //\n // Setup:\n // root/Cargo.toml (workspace, members = [])\n // member/Cargo.toml (package, workspace = \"../root\")\n\n let _root = project()\n .at(\"root\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"root\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = []\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n let member = project()\n .at(\"member\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"member\"\n version = \"0.1.0\"\n edition = \"2015\"\n workspace = \"../root\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // The error message should reflect that these paths are unrelated (Old Behavior)\n member.cargo(\"build\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] current package believes it's in a workspace when it's not:\ncurrent: [ROOT]/member/Cargo.toml\nworkspace: [ROOT]/root/Cargo.toml\n\nthis may be fixable by adding `../member` to the `workspace.members` array of the manifest located at: [ROOT]/root/Cargo.toml\nAlternatively, to keep it out of the workspace, add the package to the `workspace.exclude` array, or add an empty `[workspace]` table to the package's manifest.\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn error_if_manifest_path_is_relative() {\n // This test simulates running cargo usage with a relative --manifest-path\n // that includes `..` to verify normalization and suggestions.\n //\n // Directory structure:\n // root/Cargo.toml\n // root/subdir/\n // outside/Cargo.toml (workspace = \"../root\")\n\n let root = project()\n .at(\"root\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"root\"\n version = \"0.1.0\"\n edition = \"2015\"\n\n [workspace]\n members = []\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .file(\"subdir/file\", \"\")\n .build();\n\n let _outside = project()\n .at(\"outside\")\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"outside\"\n version = \"0.1.0\"\n edition = \"2015\"\n workspace = \"../root\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // Run from `root/subdir` pointing to `../../outside/Cargo.toml`\n // The workspace root is at `root`.\n // The package is at `outside`.\n // Relative path from root to outside is `../outside`.\n\n // We execute inside `root`, but targeting the outside package.\n root.cargo(\"build\")\n .cwd(root.root().join(\"subdir\"))\n .arg(\"-v\")\n .arg(\"--manifest-path\")\n .arg(\"../../outside/Cargo.toml\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] current package believes it's in a workspace when it's not:\ncurrent: [ROOT]/outside/Cargo.toml\nworkspace: [ROOT]/root/Cargo.toml\n\nthis may be fixable by adding `../outside` to the `workspace.members` array of the manifest located at: [ROOT]/root/Cargo.toml\nAlternatively, to keep it out of the workspace, add the package to the `workspace.exclude` array, or add an empty `[workspace]` table to the package's manifest.\n\n\"#]])\n .run();\n}\n" }, { "path": "tests/testsuite/yank.rs", "content": "//! Tests for the `cargo yank` command.\n\nuse std::fs;\n\nuse crate::prelude::*;\nuse cargo_test_support::project;\nuse cargo_test_support::registry;\nuse cargo_test_support::str;\n\nfn setup(name: &str, version: &str) {\n let dir = registry::api_path().join(format!(\"api/v1/crates/{}/{}\", name, version));\n dir.mkdir_p();\n fs::write(dir.join(\"yank\"), r#\"{\"ok\": true}\"#).unwrap();\n}\n\n#[cargo_test]\nfn explicit_version() {\n let registry = registry::init();\n setup(\"foo\", \"0.0.1\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"yank --version 0.0.1\")\n .replace_crates_io(registry.index_url())\n .run();\n\n p.cargo(\"yank --undo --version 0.0.1\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n Unyank foo@0.0.1\n[ERROR] failed to undo a yank from the registry at [ROOTURL]/api\n\nCaused by:\n EOF while parsing a value at line 1 column 0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn explicit_version_with_asymmetric() {\n let registry = registry::RegistryBuilder::new()\n .http_api()\n .token(cargo_test_support::registry::Token::rfc_key())\n .build();\n setup(\"foo\", \"0.0.1\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [project]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n // The http_api server will check that the authorization is correct.\n // If the authorization was not sent then we would get an unauthorized error.\n p.cargo(\"yank --version 0.0.1\")\n .arg(\"-Zasymmetric-token\")\n .masquerade_as_nightly_cargo(&[\"asymmetric-token\"])\n .replace_crates_io(registry.index_url())\n .run();\n\n p.cargo(\"yank --undo --version 0.0.1\")\n .arg(\"-Zasymmetric-token\")\n .masquerade_as_nightly_cargo(&[\"asymmetric-token\"])\n .replace_crates_io(registry.index_url())\n .run();\n}\n\n#[cargo_test]\nfn inline_version() {\n let registry = registry::init();\n setup(\"foo\", \"0.0.1\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"yank foo@0.0.1\")\n .replace_crates_io(registry.index_url())\n .run();\n\n p.cargo(\"yank --undo foo@0.0.1\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[UPDATING] crates.io index\n Unyank foo@0.0.1\n[ERROR] failed to undo a yank from the registry at [ROOTURL]/api\n\nCaused by:\n EOF while parsing a value at line 1 column 0\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn version_required() {\n setup(\"foo\", \"0.0.1\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"yank foo\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] `--version` is required\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn inline_version_without_name() {\n setup(\"foo\", \"0.0.1\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"yank @0.0.1\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] missing crate name for `@0.0.1`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn inline_and_explicit_version() {\n setup(\"foo\", \"0.0.1\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"yank foo@0.0.1 --version 0.0.1\")\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] cannot specify both `@0.0.1` and `--version`\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn bad_version() {\n let registry = registry::init();\n setup(\"foo\", \"0.0.1\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"yank foo@bar\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] invalid version `bar`\n\nCaused by:\n unexpected character 'b' while parsing major version number\n\n\"#]])\n .run();\n}\n\n#[cargo_test]\nfn prefixed_v_in_version() {\n let registry = registry::init();\n setup(\"foo\", \"0.0.1\");\n\n let p = project()\n .file(\n \"Cargo.toml\",\n r#\"\n [package]\n name = \"foo\"\n version = \"0.0.1\"\n authors = []\n license = \"MIT\"\n description = \"foo\"\n \"#,\n )\n .file(\"src/main.rs\", \"fn main() {}\")\n .build();\n\n p.cargo(\"yank bar@v0.0.1\")\n .replace_crates_io(registry.index_url())\n .with_status(101)\n .with_stderr_data(str![[r#\"\n[ERROR] the version provided, `v0.0.1` is not a valid SemVer version\n\n[HELP] try changing the version to `0.0.1`\n\nCaused by:\n unexpected character 'v' while parsing major version number\n\n\"#]])\n .run();\n}\n" }, { "path": "triagebot.toml", "content": "[relabel]\nallow-unauthenticated = [\n \"A-*\",\n \"C-*\",\n \"Command-*\",\n \"E-*\",\n \"I-*\",\n \"O-*\",\n \"S-*\",\n \"Z-*\",\n \"beta-nominated\",\n \"regression-*\",\n \"relnotes\",\n]\n\n[ping.windows]\nmessage = \"\"\"\\\nHey Windows Group! This bug has been identified as a good \"Windows candidate\".\nIn case it's useful, here are some [instructions] for tackling these sorts of\nbugs. Maybe take a look?\nThanks! <3\n\n[instructions]: https://rustc-dev-guide.rust-lang.org/notification-groups/windows.html\n\"\"\"\nlabel = \"O-windows\"\n\n[shortcut]\n\n# Enable issue transfers within the org\n# Documentation at: https://forge.rust-lang.org/triagebot/transfer.html\n[transfer]\n\n# Enable `@rustbot note` functionality\n# Documentation at: https://forge.rust-lang.org/triagebot/note.html\n[note]\n\n# Enable comments linking to triagebot range-diff when a PR is rebased\n# onto a different base commit\n# Documentation at: https://forge.rust-lang.org/triagebot/range-diff.html\n[range-diff]\n\n# Adds at the end of a review body a link to view the changes that happened\n# since the review\n# Documentation at: https://forge.rust-lang.org/triagebot/review-changes-since.html\n[review-changes-since]\n\n# Adds a \"View all comments\" link on the issue body that shows all the comments of an issue/PR\n# Documentation at: https://forge.rust-lang.org/triagebot/view-all-comments-link.html\n[view-all-comments-link]\nthreshold = 20\n\n[merge-conflicts]\nremove = []\nadd = [\"S-waiting-on-author\"]\nunless = [\"S-blocked\", \"S-waiting-on-review\"]\n\n[autolabel.\"S-waiting-on-review\"]\nnew_pr = true\n\n[assign]\ncontributing_url = \"https://rust-lang.github.io/cargo/contrib/\"\nwarn_non_default_branch = true\n\n[assign.owners]\n\"*\" = [\"@ehuss\", \"@epage\", \"@weihanglo\"]\n\n[review-submitted]\nreviewed_label = \"S-waiting-on-author\"\nreview_labels = [\"S-waiting-on-review\"]\n\n[review-requested]\nremove_labels = [\"S-waiting-on-author\"]\nadd_labels = [\"S-waiting-on-review\"]\n\n[autolabel.\"A-build-execution\"]\ntrigger_files = [\n \"src/cargo/core/compiler/compilation.rs\",\n \"src/cargo/core/compiler/job_queue/\",\n \"src/cargo/core/compiler/mod.rs\",\n]\n\n[autolabel.\"A-build-scripts\"]\ntrigger_files = [\n \"crates/build-rs-test-lib/\",\n \"crates/build-rs/\",\n \"src/cargo/core/compiler/custom_build.rs\",\n]\n\n[autolabel.\"A-cache-messages\"]\ntrigger_files = [\"src/cargo/util/rustc.rs\"]\n\n[autolabel.\"A-cargo-targets\"]\ntrigger_files = [\n \"src/cargo/ops/cargo_compile/compile_filter.rs\",\n \"src/cargo/ops/cargo_compile/unit_generator.rs\",\n]\n\n[autolabel.\"A-cfg-expr\"]\ntrigger_files = [\n \"crates/cargo-platform/\",\n \"src/cargo/core/compiler/build_context/target_info.rs\",\n]\n\n[autolabel.\"A-cli\"]\ntrigger_files = [\"src/bin/\", \"src/cargo/util/command_prelude.rs\"]\n\n[autolabel.\"A-cli-help\"]\ntrigger_files = [\"crates/mdman/\", \"src/etc/man/\"]\n\n[autolabel.\"A-completions\"]\ntrigger_files = [\"src/etc/_cargo\", \"src/etc/cargo.bashcomp.sh\"]\n\n[autolabel.\"A-configuration\"]\ntrigger_files = [\"src/cargo/util/context/mod.rs\"]\n\n[autolabel.\"A-console-output\"]\ntrigger_files = [\n \"src/cargo/core/shell.rs\",\n \"src/cargo/util/progress.rs\",\n]\n\n[autolabel.\"A-crate-dependencies\"]\ntrigger_files = [\"src/cargo/core/dependency.rs\"]\n\n[autolabel.\"A-crate-types\"]\ntrigger_files = [\"src/cargo/core/compiler/crate_type.rs\"]\n\n[autolabel.\"A-credential-provider\"]\ntrigger_files = [\"credential/\"]\n\n[autolabel.\"A-dep-info\"]\ntrigger_files = [\"src/cargo/core/compiler/output_depinfo.rs\"]\n\n[autolabel.\"A-dependency-resolution\"]\ntrigger_files = [\n \"benches/benchsuite/benches/resolve.rs\",\n \"crates/resolver-tests/\",\n \"src/cargo/core/resolver/\",\n]\n\n[autolabel.\"A-directory-source\"]\ntrigger_files = [\"src/cargo/sources/directory.rs\"]\n\n[autolabel.\"A-documenting-cargo-itself\"]\ntrigger_files = [\"src/doc/\"]\n\n[autolabel.\"A-environment-variables\"]\ntrigger_files = [\n \"crates/home/\",\n \"src/cargo/util/context/environment.rs\",\n]\n\n[autolabel.\"A-features2\"]\ntrigger_files = [\"src/cargo/core/resolver/features.rs\"]\n\n[autolabel.\"A-filesystem\"]\ntrigger_files = [\"src/cargo/util/flock.rs\", \"src/cargo/util/important_paths.rs\"]\n\n[autolabel.\"A-future-incompat\"]\ntrigger_files = [\"src/cargo/core/compiler/future_incompat.rs\"]\n\n[autolabel.\"A-git\"]\ntrigger_files = [\"src/cargo/sources/git/\", \"src/cargo/ops/cargo_package/vcs.rs\"]\n\n[autolabel.\"A-home\"]\ntrigger_files = [\"crates/home/\"]\n\n[autolabel.\"A-infrastructure\"]\ntrigger_files = [\n \".cargo/\",\n \".github/\",\n \"build.rs\",\n \"ci/\",\n \"clippy.toml\",\n \"crates/xtask-\",\n \"deny.toml\",\n \"publish.py\",\n \"triagebot.toml\",\n]\n\n[autolabel.\"A-interacts-with-crates.io\"]\ntrigger_files = [\"crates/crates-io/\", \"src/cargo/ops/registry/\"]\n\n[autolabel.\"A-json-output\"]\ntrigger_files = [\"src/cargo/util/machine_message.rs\"]\n\n[autolabel.\"A-layout\"]\ntrigger_files = [\n \"src/cargo/core/compiler/build_runner/compilation_files.rs\",\n \"src/cargo/core/compiler/layout.rs\",\n]\n\n[autolabel.\"A-links\"]\ntrigger_files = [\"src/cargo/core/compiler/links.rs\"]\n\n[autolabel.\"A-local-registry-source\"]\ntrigger_files = [\"src/cargo/sources/registry/local.rs\"]\n\n[autolabel.\"A-lockfile\"]\ntrigger_files = [\"src/cargo/ops/lockfile.rs\", \"src/cargo/core/resolver/encode.rs\"]\n\n[autolabel.\"A-lto\"]\ntrigger_files = [\"src/cargo/core/compiler/lto.rs\"]\n\n[autolabel.\"A-manifest\"]\ntrigger_files = [\n \"crates/cargo-util-schemas/src/manifest/\",\n \"src/cargo/core/manifest.rs\",\n \"src/cargo/util/toml/mod.rs\",\n \"src/cargo/util/toml_mut/\",\n]\n\n[autolabel.\"A-networking\"]\ntrigger_files = [\"src/cargo/util/network/\"]\n\n[autolabel.\"A-overrides\"]\ntrigger_files = [\"src/cargo/sources/replaced.rs\"]\n\n[autolabel.\"A-profiles\"]\ntrigger_files = [\"src/cargo/core/profiles.rs\"]\n\n[autolabel.\"A-rebuild-detection\"]\ntrigger_files = [\"src/cargo/core/compiler/fingerprint/\"]\n\n[autolabel.\"A-registries\"]\ntrigger_files = [\"src/cargo/sources/registry/\", \"src/cargo/core/registry.rs\"]\n\n[autolabel.\"A-registry-authentication\"]\ntrigger_files = [\"src/cargo/util/auth/\"]\n\n[autolabel.\"A-semver\"]\ntrigger_files = [\n \"crates/semver-check\",\n \"src/cargo/util/semver_ext.rs\",\n]\n\n[autolabel.\"A-source-replacement\"]\ntrigger_files = [\"src/cargo/sources/replaced.rs\"]\n\n[autolabel.\"A-sparse-registry\"]\ntrigger_files = [\"src/cargo/sources/registry/http_remote.rs\"]\n\n[autolabel.\"A-testing-cargo-itself\"]\ntrigger_files = [\n \"benches/\",\n \"crates/cargo-test-macro/\",\n \"crates/cargo-test-support/\",\n]\n\n[autolabel.\"A-timings\"]\ntrigger_files = [\n \"src/cargo/core/compiler/timings/\",\n \"src/cargo/util/cpu.rs\",\n]\n\n[autolabel.\"A-unstable\"]\ntrigger_files = [\"src/cargo/core/features.rs\"]\n\n[autolabel.\"A-vcs\"]\ntrigger_files = [\"src/cargo/util/vcs.rs\"]\n\n[autolabel.\"A-workspaces\"]\ntrigger_files = [\n \"benches/benchsuite/benches/workspace_initialization.rs\",\n \"src/cargo/core/workspace.rs\",\n \"src/cargo/util/workspace.rs\"\n]\n\n[autolabel.\"Command-add\"]\ntrigger_files = [\"src/bin/cargo/commands/add.rs\", \"src/cargo/ops/cargo_add/\"]\n\n[autolabel.\"Command-bench\"]\ntrigger_files = [\"src/bin/cargo/commands/bench.rs\"]\n\n[autolabel.\"Command-build\"]\ntrigger_files = [\"src/bin/cargo/commands/build.rs\"]\n\n[autolabel.\"Command-check\"]\ntrigger_files = [\"src/bin/cargo/commands/check.rs\"]\n\n[autolabel.\"Command-clean\"]\ntrigger_files = [\"src/bin/cargo/commands/clean.rs\", \"src/cargo/ops/cargo_clean.rs\"]\n\n[autolabel.\"Command-doc\"]\ntrigger_files = [\"src/bin/cargo/commands/doc.rs\", \"src/cargo/ops/cargo_doc.rs\"]\n\n[autolabel.\"Command-fetch\"]\ntrigger_files = [\"src/bin/cargo/commands/fetch.rs\", \"src/cargo/ops/cargo_fetch.rs\"]\n\n[autolabel.\"Command-fix\"]\ntrigger_files = [\n \"crates/rustfix/\",\n \"src/bin/cargo/commands/fix.rs\",\n \"src/cargo/ops/fix/\",\n \"src/cargo/util/diagnostic_server.rs\",\n \"src/cargo/util/lockserver.rs\",\n]\n\n[autolabel.\"Command-generate-lockfile\"]\ntrigger_files = [\"src/bin/cargo/commands/generate_lockfile.rs\"]\n\n[autolabel.\"Command-git-checkout\"]\ntrigger_files = [\"src/bin/cargo/commands/git_checkout.rs\"]\n\n[autolabel.\"Command-info\"]\ntrigger_files = [\"src/bin/cargo/commands/info.rs\", \"src/cargo/ops/registry/info/\"]\n\n[autolabel.\"Command-init\"]\ntrigger_files = [\"src/bin/cargo/commands/init.rs\"]\n\n[autolabel.\"Command-install\"]\ntrigger_files = [\"src/bin/cargo/commands/install.rs\", \"src/cargo/ops/cargo_install.rs\"]\n\n[autolabel.\"Command-locate-project\"]\ntrigger_files = [\"src/bin/cargo/commands/locate_project.rs\"]\n\n[autolabel.\"Command-login\"]\ntrigger_files = [\"src/bin/cargo/commands/login.rs\", \"src/cargo/ops/registry/login.rs\"]\n\n[autolabel.\"Command-logout\"]\ntrigger_files = [\"src/bin/cargo/commands/logout.rs\", \"src/cargo/ops/registry/logout.rs\"]\n\n[autolabel.\"Command-metadata\"]\ntrigger_files = [\"src/bin/cargo/commands/metadata.rs\", \"src/cargo/ops/cargo_output_metadata.rs\"]\n\n[autolabel.\"Command-new\"]\ntrigger_files = [\"src/bin/cargo/commands/new.rs\", \"src/cargo/ops/cargo_new.rs\"]\n\n[autolabel.\"Command-owner\"]\ntrigger_files = [\"src/bin/cargo/commands/owner.rs\", \"src/cargo/ops/registry/owner.rs\"]\n\n[autolabel.\"Command-package\"]\ntrigger_files = [\"src/bin/cargo/commands/package.rs\", \"src/cargo/ops/cargo_package/\"]\n\n[autolabel.\"Command-pkgid\"]\ntrigger_files = [\"src/bin/cargo/commands/pkgid.rs\", \"src/cargo/ops/cargo_pkgid.rs\"]\n\n[autolabel.\"Command-publish\"]\ntrigger_files = [\"src/bin/cargo/commands/publish.rs\", \"src/cargo/ops/registry/publish.rs\"]\n\n[autolabel.\"Command-read-manifest\"]\ntrigger_files = [\"src/bin/cargo/commands/read_manifest.rs\", \"src/cargo/ops/cargo_read_manifest.rs\"]\n\n[autolabel.\"Command-remove\"]\ntrigger_files = [\"src/bin/cargo/commands/remove.rs\", \"src/cargo/ops/cargo_remove.rs\"]\n\n[autolabel.\"Command-report\"]\ntrigger_files = [\"src/bin/cargo/commands/report.rs\", \"src/cargo/ops/cargo_report/\"]\n\n[autolabel.\"Command-run\"]\ntrigger_files = [\"src/bin/cargo/commands/run.rs\", \"src/cargo/ops/cargo_run.rs\"]\n\n[autolabel.\"Command-rustc\"]\ntrigger_files = [\"src/bin/cargo/commands/rustc.rs\"]\n\n[autolabel.\"Command-rustdoc\"]\ntrigger_files = [\"src/bin/cargo/commands/rustdoc.rs\"]\n\n[autolabel.\"Command-search\"]\ntrigger_files = [\"src/bin/cargo/commands/search.rs\", \"src/cargo/ops/registry/search.rs\"]\n\n[autolabel.\"Command-test\"]\ntrigger_files = [\"src/bin/cargo/commands/test.rs\", \"src/cargo/ops/cargo_test.rs\"]\n\n[autolabel.\"Command-tree\"]\ntrigger_files = [\"src/bin/cargo/commands/tree.rs\", \"src/cargo/ops/tree/\"]\n\n[autolabel.\"Command-uninstall\"]\ntrigger_files = [\"src/bin/cargo/commands/uninstall.rs\", \"src/cargo/ops/cargo_uninstall.rs\"]\n\n[autolabel.\"Command-update\"]\ntrigger_files = [\"src/bin/cargo/commands/update.rs\", \"src/cargo/ops/cargo_update.rs\"]\n\n[autolabel.\"Command-vendor\"]\ntrigger_files = [\"src/bin/cargo/commands/vendor.rs\", \"src/cargo/ops/vendor.rs\"]\n\n[autolabel.\"Command-verify-project\"]\ntrigger_files = [\"src/bin/cargo/commands/verify_project.rs\"]\n\n[autolabel.\"Command-version\"]\ntrigger_files = [\"src/bin/cargo/commands/version.rs\"]\n\n[autolabel.\"Command-yank\"]\ntrigger_files = [\"src/bin/cargo/commands/yank.rs\", \"src/cargo/ops/registry/yank.rs\"]\n" }, { "path": "typos.toml", "content": "[files]\nextend-exclude = [\n \"crates/resolver-tests/*\",\n \"LICENSE-THIRD-PARTY\",\n \"tests/testsuite/script/rustc_fixtures\",\n]\n\n[default]\nextend-ignore-re = [\n # Handles ssh keys\n \"AAAA[0-9A-Za-z+/]+[=]{0,3}\",\n\n # Handles paseto from login tests\n \"k3[.](secret|public)[.][a-zA-Z0-9_-]+\",\n]\nextend-ignore-identifiers-re = [\n # Handles git short SHA-1 hashes\n \"[a-f0-9]{8,9}\",\n]\nextend-ignore-words-re = [\n # words with length <= 4 chars is likely noise\n \"^[a-zA-Z]{1,4}$\",\n]\n\n[default.extend-identifiers]\n# This comes from `windows_sys`\nERROR_FILENAME_EXCED_RANGE = \"ERROR_FILENAME_EXCED_RANGE\"\n# `-Wwarnings`\nWwarnings = \"Wwarnings\"\n\n# Name of a dependency\nflate2 = \"flate2\"\n\n[default.extend-words]\nfiletimes = \"filetimes\"\n\n[type.cargo_command]\nextend-glob = [\"cargo_command.rs\"]\n\n[type.cargo_command.extend-words]\nbiuld = \"biuld\"\n\n[type.random-sample]\nextend-glob = [\"random-sample\"]\n\n[type.random-sample.extend-words]\nobjekt = \"objekt\"\n" }, { "path": "windows.manifest.xml", "content": "\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n UTF-8\n \n \n \n \n \n true\n \n \n\n" } ]