--- /dev/null
- - name: Install Rust
- uses: actions-rs/toolchain@v1
- with:
- profile: minimal
- toolchain: ${{ matrix.rust }}
- override: true
+name: upload
+
+on:
++ push:
+ release:
+ types: [created]
++ workflow_dispatch:
+
+jobs:
+ build-release:
+ name: build-release
+ strategy:
+ matrix:
+ build: [linux-x86_64, macos-x86_64, windows-x86_64-gnu, windows-x86_64-msvc]
+ include:
+ - build: linux-x86_64
+ os: ubuntu-latest
+ rust: nightly
++ target: x86_64-unknown-linux-gnu
+ - build: macos-x86_64
+ os: macos-latest
+ rust: nightly
++ target: x86_64-apple-darwin
+ - build: windows-x86_64-gnu
+ os: windows-latest
+ rust: nightly-x86_64-gnu
++ target: x86_64-pc-windows-gnu
+ - build: windows-x86_64-msvc
+ os: windows-latest
+ rust: nightly-x86_64-msvc
++ target: x86_64-pc-windows-msvc
+ runs-on: ${{ matrix.os }}
+ steps:
+ - uses: actions/checkout@v2
+
- - name: Install cargo-make
- uses: actions-rs/cargo@v1
- with:
- command: install
- args: --force cargo-make
-
++ # Run build
++ - name: install rustup
++ run: |
++ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rustup-init.sh
++ sh rustup-init.sh -y --default-toolchain none
++ rustup target add ${{ matrix.target }}
+
+ - name: Add mingw64 to path for x86_64-gnu
+ run: echo "C:\msys64\mingw64\bin" >> $GITHUB_PATH
+ if: matrix.rust == 'nightly-x86_64-gnu'
+ shell: bash
+
- command: make
- args: release
+ - name: Build release binaries
+ uses: actions-rs/cargo@v1
+ with:
++ command: build
++ args: --release
+
+ - name: Build archive
+ shell: bash
+ run: |
+ staging="rustfmt_${{ matrix.build }}_${{ github.event.release.tag_name }}"
+ mkdir -p "$staging"
+
+ cp {README.md,Configurations.md,CHANGELOG.md,LICENSE-MIT,LICENSE-APACHE} "$staging/"
+
+ if [ "${{ matrix.os }}" = "windows-latest" ]; then
+ cp target/release/{rustfmt.exe,cargo-fmt.exe,rustfmt-format-diff.exe,git-rustfmt.exe} "$staging/"
+ 7z a "$staging.zip" "$staging"
+ echo "ASSET=$staging.zip" >> $GITHUB_ENV
+ else
+ cp target/release/{rustfmt,cargo-fmt,rustfmt-format-diff,git-rustfmt} "$staging/"
+ tar czf "$staging.tar.gz" "$staging"
+ echo "ASSET=$staging.tar.gz" >> $GITHUB_ENV
+ fi
+
+ - name: Upload Release Asset
++ if: github.event_name == 'release'
+ uses: actions/upload-release-asset@v1
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ with:
+ upload_url: ${{ github.event.release.upload_url }}
+ asset_path: ${{ env.ASSET }}
+ asset_name: ${{ env.ASSET }}
+ asset_content_type: application/octet-stream
--- /dev/null
- - name: cargo-make
- run: cargo install --force cargo-make
-
+name: windows
+on:
+ push:
+ branches:
+ - master
+ pull_request:
+
+jobs:
+ test:
+ runs-on: windows-latest
+ name: (${{ matrix.target }}, nightly)
+ strategy:
+ # https://help.github.com/en/actions/getting-started-with-github-actions/about-github-actions#usage-limits
+ # There's a limit of 60 concurrent jobs across all repos in the rust-lang organization.
+ # In order to prevent overusing too much of that 60 limit, we throttle the
+ # number of rustfmt jobs that will run concurrently.
+ max-parallel: 2
+ fail-fast: false
+ matrix:
+ target: [
+ i686-pc-windows-gnu,
+ i686-pc-windows-msvc,
+ x86_64-pc-windows-gnu,
+ x86_64-pc-windows-msvc,
+ ]
+
+ steps:
+ # The Windows runners have autocrlf enabled by default
+ # which causes failures for some of rustfmt's line-ending sensitive tests
+ - name: disable git eol translation
+ run: git config --global core.autocrlf false
+ - name: checkout
+ uses: actions/checkout@v2
+
+ # Run build
+ - name: Install Rustup using win.rustup.rs
+ run: |
+ # Disable the download progress bar which can cause perf issues
+ $ProgressPreference = "SilentlyContinue"
+ Invoke-WebRequest https://win.rustup.rs/ -OutFile rustup-init.exe
+ .\rustup-init.exe -y --default-host=x86_64-pc-windows-msvc --default-toolchain=none
+ del rustup-init.exe
+ rustup target add ${{ matrix.target }}
+ shell: powershell
+
+ - name: Add mingw32 to path for i686-gnu
+ run: |
+ echo "C:\msys64\mingw32\bin" >> $GITHUB_PATH
+ if: matrix.target == 'i686-pc-windows-gnu' && matrix.channel == 'nightly'
+ shell: bash
+
+ - name: Add mingw64 to path for x86_64-gnu
+ run: echo "C:\msys64\mingw64\bin" >> $GITHUB_PATH
+ if: matrix.target == 'x86_64-pc-windows-gnu' && matrix.channel == 'nightly'
+ shell: bash
+
+ - name: build
+ run: |
+ rustc -Vv
+ cargo -V
+ cargo build
+ shell: cmd
+
+ - name: test
+ run: cargo test
+ shell: cmd
--- /dev/null
+
+# Created by https://www.gitignore.io/api/rust
+
+### Rust ###
+# Generated by Cargo
+# will have compiled files and executables
+/target
++tests/cargo-fmt/**/target
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+# Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# End of https://www.gitignore.io/api/rust
+
+# Used by macOS' file system to track custom attributes of containing folder
+.DS_Store
+
+# Editors' specific files
+.idea/
+.vscode/
+*~
--- /dev/null
+# Changelog
+
+## [Unreleased]
+
++## [1.4.38] 2021-10-20
++
++### Changed
++
++- Switched from `rustc-ap-*` crates to `rustc_private` for consumption model of rustc internals
++- `annotate-snippets` updated to v0.8 [PR #4762](https://github.com/rust-lang/rustfmt/pull/4762)
++- Greatly improved the performance of `cargo fmt` in large workspaces utilizing the `--all` flag by updating to a newer version of `cargo_metadata` that leverages updated `cargo` output from v1.51+ [PR #4997](https://github.com/rust-lang/rustfmt/pull/4997)
++- Improved formatting of long slice patterns [#4530](https://github.com/rust-lang/rustfmt/issues/4530)
++ - **Note you must have `version = Two` in your configuration to take advantage of the new formatting**
++- Stabilized `match_block_trailing_comma` configuration option [#3380](https://github.com/rust-lang/rustfmt/issues/3380) - [https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#match_block_trailing_comma](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#match_block_trailing_comma)
++- Stabilized `disable_all_formatting` configuration option [#5026](https://github.com/rust-lang/rustfmt/pull/5026) - [https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#disable_all_formatting](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#disable_all_formatting)
++- Various improvements to the configuration documentation website [https://rust-lang.github.io/rustfmt/?version=v1.4.38]([https://rust-lang.github.io/rustfmt/?version=v1.4.38])
++- Addressed various clippy and rustc warnings
++
++
++### Fixed
++
++- Resolved issue where specious whitespace would be inserted when a block style comment was terminated within string literal processing [#4312](https://github.com/rust-lang/rustfmt/issues/4312)
++- Nested out-of-line mods are again parsed and formatted [#4874](https://github.com/rust-lang/rustfmt/issues/4874)
++- Accepts `2021` for edition value from rustfmt command line [PR #4847](https://github.com/rust-lang/rustfmt/pull/4847)
++- Unstable command line options are no longer displayed in `--help` text on stable [PR #4798](https://github.com/rust-lang/rustfmt/issues/4798)
++- Stopped panicking on patterns in match arms which start with non-ascii characters [#4868](https://github.com/rust-lang/rustfmt/issues/4868)
++- Stopped stripping defaults on const params [#4816](https://github.com/rust-lang/rustfmt/issues/4816)
++- Fixed issue with dropped content with GAT aliases with self bounds in impls [#4911](https://github.com/rust-lang/rustfmt/issues/4911)
++- Stopped removing generic args on associated type constraints [#4943](https://github.com/rust-lang/rustfmt/issues/4943)
++- Stopped dropping visibility on certain trait and impl items [#4960](https://github.com/rust-lang/rustfmt/issues/4960)
++- Fixed dropping of qualified paths in struct patterns [#4908](https://github.com/rust-lang/rustfmt/issues/4908) and [#5005](https://github.com/rust-lang/rustfmt/issues/5005)
++- Fixed bug in line width calculation that was causing specious formatting of certain patterns [#4031](https://github.com/rust-lang/rustfmt/issues/4031)
++ - **Note that this bug fix may cause observable formatting changes in cases where code had been formatted with prior versions of rustfmt that contained the bug**
++- Fixed bug where rustfmt would drop parameter attributes if they were too long in certain cases [#4579](https://github.com/rust-lang/rustfmt/issues/4579)
++- Resolved idempotency issue with extern body elements [#4963](https://github.com/rust-lang/rustfmt/issues/4963)
++- rustfmt will now handle doc-style comments on function parameters, since they could appear with certain macro usage patterns even though it's generally invalid syntax [#4936](https://github.com/rust-lang/rustfmt/issues/4936)
++- Fixed bug in `match_block_trailing_comma` where commas were not added to the blocks of bodies whose arm had a guard that did not fit on the same line as the pattern [#4998](https://github.com/rust-lang/rustfmt/pull/4998)
++- Fixed bug in cases where derive attributes started with a block style comment [#4984](https://github.com/rust-lang/rustfmt/issues/4984)
++- Fixed issue where the struct rest could be lost when `struct_field_align_threshold` was enabled [#4926](https://github.com/rust-lang/rustfmt/issues/4926)
++- Handles cases where certain control flow type expressions have comments between patterns/keywords and the pattern ident contains the keyword [#5009](https://github.com/rust-lang/rustfmt/issues/5009)
++- Handles tuple structs that have explicit visibilities and start with a block style comment [#5011](https://github.com/rust-lang/rustfmt/issues/5011)
++- Handles leading line-style comments in certain types of macro calls [#4615](https://github.com/rust-lang/rustfmt/issues/4615)
++
++
++### Added
++- Granular width heuristic options made available for user control [PR #4782](https://github.com/rust-lang/rustfmt/pull/4782). This includes the following:
++ - [`array_width`](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#array_width)
++ - [`attr_fn_like_width`](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#attr_fn_like_width)
++ - [`chain_width`](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#chain_width)
++ - [`fn_call_width`](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#fn_call_width)
++ - [`single_line_if_else_max_width`](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#single_line_if_else_max_width)
++ - [`struct_lit_width`](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#struct_lit_width)
++ - [`struct_variant_width`](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#struct_variant_width)
++
++Note this hit the rustup distributions prior to the v1.4.38 release as part of an out-of-cycle updates, but is listed in this version because the feature was not in the other v1.4.37 releases. See also the `use_small_heuristics` section on the configuration site for more information
++[https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#use_small_heuristics](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#use_small_heuristics)
++
++- New `One` variant added to `imports_granularity` configuration option which can be used to reformat all imports into a single use statement [#4669](https://github.com/rust-lang/rustfmt/issues/4669)
++- rustfmt will now skip files that are annotated with `@generated` at the top of the file [#3958](https://github.com/rust-lang/rustfmt/issues/3958)
++- New configuration option `hex_literal_case` that allows user to control the casing utilized for hex literals [PR #4903](https://github.com/rust-lang/rustfmt/pull/4903)
++
++See the section on the configuration site for more information
++https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#hex_literal_case
++
++- `cargo fmt` now directly supports the `--check` flag, which means it's now possible to run `cargo fmt --check` instead of the more verbose `cargo fmt -- --check` [#3888](https://github.com/rust-lang/rustfmt/issues/3888)
++
++### Install/Download Options
++- **rustup (nightly)** - *pending*
++- **GitHub Release Binaries** - [Release v1.4.38](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.38)
++- **Build from source** - [Tag v1.4.38](https://github.com/rust-lang/rustfmt/tree/v1.4.38), see instructions for how to [install rustfmt from source][install-from-source]
++
+## [1.4.37] 2021-04-03
+
+### Changed
+
+- `rustc-ap-*` crates updated to v712.0.0
+
+### Fixed
+- Resolve idempotence issue related to indentation of macro defs that contain or-patterns with inner comments ([#4603](https://github.com/rust-lang/rustfmt/issues/4603))
+- Addressed various clippy and rustc warnings
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - *pending*
+- **GitHub Release Binaries** - [Release v1.4.37](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.37)
+- **Build from source** - [Tag v1.4.37](https://github.com/rust-lang/rustfmt/tree/v1.4.37), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.36] 2021-02-07
+
+### Changed
+
+- `rustc-ap-*` crates updated to v705.0.0
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - *pending*
+- **GitHub Release Binaries** - [Release v1.4.36](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.36)
+- **Build from source** - [Tag v1.4.36](https://github.com/rust-lang/rustfmt/tree/v1.4.36), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.35] 2021-02-03
+
+### Changed
+
+- `rustc-ap-*` crates updated to v702.0.0
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - *n/a (superseded by [v1.4.36](#1436-2021-02-07))
+- **GitHub Release Binaries** - [Release v1.4.35](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.35)
+- **Build from source** - [Tag v1.4.35](https://github.com/rust-lang/rustfmt/tree/v1.4.35), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.34] 2021-01-28
+
+### Fixed
+- Don't insert trailing comma on (base-less) rest in struct literals within macros ([#4675](https://github.com/rust-lang/rustfmt/issues/4675))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2021-01-31`
+- **GitHub Release Binaries** - [Release v1.4.34](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.34)
+- **Build from source** - [Tag v1.4.34](https://github.com/rust-lang/rustfmt/tree/v1.4.34), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.33] 2021-01-27
+
+### Changed
+- `merge_imports` configuration has been deprecated in favor of the new `imports_granularity` option. Any existing usage of `merge_imports` will be automatically mapped to the corresponding value on `imports_granularity` with a warning message printed to encourage users to update their config files.
+
+### Added
+- New `imports_granularity` option has been added which succeeds `merge_imports`. This new option supports several additional variants which allow users to merge imports at different levels (crate or module), and even flatten imports to have a single use statement per item. ([PR #4634](https://github.com/rust-lang/rustfmt/pull/4634), [PR #4639](https://github.com/rust-lang/rustfmt/pull/4639))
+
+See the section on the configuration site for more information
+https://rust-lang.github.io/rustfmt/?version=v1.4.33&search=#imports_granularity
+
+### Fixed
+- Fix erroneous removal of `const` keyword on const trait impl ([#4084](https://github.com/rust-lang/rustfmt/issues/4084))
+- Fix incorrect span usage wit const generics in supertraits ([#4204](https://github.com/rust-lang/rustfmt/issues/4204))
+- Use correct span for const generic params ([#4263](https://github.com/rust-lang/rustfmt/issues/4263))
+- Correct span on const generics to include type bounds ([#4310](https://github.com/rust-lang/rustfmt/issues/4310))
+- Idempotence issue on blocks containing only empty statements ([#4627](https://github.com/rust-lang/rustfmt/issues/4627) and [#3868](https://github.com/rust-lang/rustfmt/issues/3868))
+- Fix issue with semicolon placement on required functions that have a trailing comment that ends in a line-style comment before the semicolon ([#4646](https://github.com/rust-lang/rustfmt/issues/4646))
+- Avoid shared interned cfg_if symbol since rustfmt can re-initialize the rustc_ast globals on multiple inputs ([#4656](https://github.com/rust-lang/rustfmt/issues/4656))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - n/a (superseded by [v1.4.34](#1434-2021-01-28))
+- **GitHub Release Binaries** - [Release v1.4.33](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.33)
+- **Build from source** - [Tag v1.4.33](https://github.com/rust-lang/rustfmt/tree/v1.4.33), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.32] 2021-01-16
+
+### Fixed
+- Indentation now correct on first bound in cases where the generic bounds are multiline formatted and the first bound itself is multiline formatted ([#4636](https://github.com/rust-lang/rustfmt/issues/4636))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2021-01-18`
+- **GitHub Release Binaries** - [Release v1.4.32](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.32)
+- **Build from source** - [Tag v1.4.32](https://github.com/rust-lang/rustfmt/tree/v1.4.32), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.31] 2021-01-09
+
+### Changed
+
+- `rustc-ap-*` crates updated to v697.0.0
+
+### Added
+- Support for 2021 Edition [#4618](https://github.com/rust-lang/rustfmt/pull/4618))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2021-01-16`
+- **GitHub Release Binaries** - [Release v1.4.31](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.31)
+- **Build from source** - [Tag v1.4.31](https://github.com/rust-lang/rustfmt/tree/v1.4.31), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.30] 2020-12-20
+
+### Fixed
+- Last character in derive no longer erroneously stripped when `indent_style` is overridden to `Visual`. ([#4584](https://github.com/rust-lang/rustfmt/issues/4584))
+- Brace wrapping of closure bodies maintained in cases where the closure has an explicit return type and the body consists of a single expression statement. ([#4577](https://github.com/rust-lang/rustfmt/issues/4577))
+- No more panics on invalid code with `err` and `typeof` types ([#4357](https://github.com/rust-lang/rustfmt/issues/4357), [#4586](https://github.com/rust-lang/rustfmt/issues/4586))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2020-12-25`
+- **GitHub Release Binaries** - [Release v1.4.30](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.30)
+- **Build from source** - [Tag v1.4.30](https://github.com/rust-lang/rustfmt/tree/v1.4.30), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.29] 2020-12-04
+
+### Fixed
+- Negative polarity on non-trait impl now preserved. ([#4566](https://github.com/rust-lang/rustfmt/issues/4566))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2020-12-07`
+- **GitHub Release Binaries** - [Release v1.4.29](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.29)
+- **Build from source** - [Tag v1.4.29](https://github.com/rust-lang/rustfmt/tree/v1.4.29), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.28] 2020-11-29
+
+### Changed
+
+- `rustc-ap-*` crates updated to v691.0.0
+- In the event of an invalid inner attribute on a `cfg_if` condition, rustfmt will now attempt to continue and format the imported modules. Previously rustfmt would emit the parser error about an inner attribute being invalid in this position, but for rustfmt's purposes the invalid attribute doesn't prevent nor impact module formatting.
+
+### Added
+
+- [`group_imports`][group-imports-config-docs] - a new configuration option that allows users to control the strategy used for grouping imports ([#4107](https://github.com/rust-lang/rustfmt/issues/4107))
+
+[group-imports-config-docs]: https://github.com/rust-lang/rustfmt/blob/v1.4.28/Configurations.md#group_imports
+
+### Fixed
+- Formatting of malformed derived attributes is no longer butchered. ([#3898](https://github.com/rust-lang/rustfmt/issues/3898), [#4029](https://github.com/rust-lang/rustfmt/issues/4029), [#4115](https://github.com/rust-lang/rustfmt/issues/4115), [#4545](https://github.com/rust-lang/rustfmt/issues/4545))
+- Correct indentation used in macro branches when `hard_tabs` is enabled. ([#4152](https://github.com/rust-lang/rustfmt/issues/4152))
+- Comments between the visibility modifier and item name are no longer dropped. ([#2781](https://github.com/rust-lang/rustfmt/issues/2781))
+- Comments preceding the assignment operator in type aliases are no longer dropped. ([#4244](https://github.com/rust-lang/rustfmt/issues/4244))
+- Comments between {`&` operator, lifetime, `mut` kw, type} are no longer dropped. ([#4245](https://github.com/rust-lang/rustfmt/issues/4245))
+- Comments between type bounds are no longer dropped. ([#4243](https://github.com/rust-lang/rustfmt/issues/4243))
+- Function headers are no longer dropped on foreign function items. ([#4288](https://github.com/rust-lang/rustfmt/issues/4288))
+- Foreign function blocks are no longer dropped. ([#4313](https://github.com/rust-lang/rustfmt/issues/4313))
+- `where_single_line` is no longer incorrectly applied to multiline function signatures that have no `where` clause. ([#4547](https://github.com/rust-lang/rustfmt/issues/4547))
+- `matches!` expressions with multiple patterns and a destructure pattern are now able to be formatted. ([#4512](https://github.com/rust-lang/rustfmt/issues/4512))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - n/a (superseded by [v1.4.29](#1429-2020-12-04))
+- **GitHub Release Binaries** - [Release v1.4.28](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.28)
+- **Build from source** - [Tag v1.4.28](https://github.com/rust-lang/rustfmt/tree/v1.4.28), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.27] 2020-11-16
+
+### Fixed
+
+- Leading comments in an extern block are no longer dropped (a bug that exists in v1.4.26). ([#4528](https://github.com/rust-lang/rustfmt/issues/4528))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2020-11-18`
+- **GitHub Release Binaries** - [Release v1.4.27](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.27)
+- **Build from source** - [Tag v1.4.27](https://github.com/rust-lang/rustfmt/tree/v1.4.27), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.26] 2020-11-14
+
+### Changed
+
+- Original comment indentation for trailing comments within an `if` is now taken into account when determining the indentation level to use for the trailing comment in formatted code. This does not modify any existing code formatted with rustfmt; it simply gives the programmer discretion to specify whether the comment is associated to the `else` block, or if the trailing comment is just a member of the `if` block. ([#1575](https://github.com/rust-lang/rustfmt/issues/1575), [#4120](https://github.com/rust-lang/rustfmt/issues/4120), [#4506](https://github.com/rust-lang/rustfmt/issues/4506))
+
+In this example the `// else comment` refers to the `else`:
+```rust
+// if comment
+if cond {
+ "if"
+// else comment
+} else {
+ "else"
+}
+```
+
+Whereas in this case the `// continue` comments are members of their respective blocks and do not refer to the `else` below.
+```rust
+if toks.eat_token(Token::Word("modify"))? && toks.eat_token(Token::Word("labels"))? {
+ if toks.eat_token(Token::Colon)? {
+ // ate the token
+ } else if toks.eat_token(Token::Word("to"))? {
+ // optionally eat the colon after to, e.g.:
+ // @rustbot modify labels to: -S-waiting-on-author, +S-waiting-on-review
+ toks.eat_token(Token::Colon)?;
+ } else {
+ // It's okay if there's no to or colon, we can just eat labels
+ // afterwards.
+ }
+ 1 + 2;
+ // continue
+} else if toks.eat_token(Token::Word("label"))? {
+ // continue
+} else {
+ return Ok(None);
+}
+```
+
+### Fixed
+- Formatting of empty blocks with attributes which only contained comments is no longer butchered.([#4475](https://github.com/rust-lang/rustfmt/issues/4475), [#4467](https://github.com/rust-lang/rustfmt/issues/4467), [#4452](https://github.com/rust-lang/rustfmt/issues/4452#issuecomment-705886282), [#4522](https://github.com/rust-lang/rustfmt/issues/4522))
+- Indentation of trailing comments in non-empty extern blocks is now correct. ([#4120](https://github.com/rust-lang/rustfmt/issues/4120#issuecomment-696491872))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2020-11-16`
+- **GitHub Release Binaries** - [Release v1.4.26](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.26)
+- **Build from source** - [Tag v1.4.26](https://github.com/rust-lang/rustfmt/tree/v1.4.26), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.25] 2020-11-10
+
+### Changed
+
+- Semicolons are no longer automatically inserted on trailing expressions in macro definition arms ([#4507](https://github.com/rust-lang/rustfmt/pull/4507)). This gives the programmer control and discretion over whether there should be semicolons in these scenarios so that potential expansion issues can be avoided.
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2020-11-14`
+- **GitHub Release Binaries** - [Release v1.4.25](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.25)
+- **Build from source** - [Tag v1.4.25](https://github.com/rust-lang/rustfmt/tree/v1.4.25), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.24] 2020-11-05
+
+### Changed
+
+- Block wrapped match arm bodies containing a single macro call expression are no longer flattened ([#4496](https://github.com/rust-lang/rustfmt/pull/4496)). This allows programmer discretion so that the block wrapping can be preserved in cases where needed to prevent issues in expansion, such as with trailing semicolons, and aligns with updated [Style Guide guidance](https://github.com/rust-dev-tools/fmt-rfcs/blob/master/guide/expressions.md#macro-call-expressions) for such scenarios.
+
+### Fixed
+- Remove useless `deprecated` attribute on a trait impl block in the rustfmt lib, as these now trigger errors ([rust-lang/rust/#78626](https://github.com/rust-lang/rust/pull/78626))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - Starting in `2020-11-09`
+- **GitHub Release Binaries** - [Release v1.4.24](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.24)
+- **Build from source** - [Tag v1.4.24](https://github.com/rust-lang/rustfmt/tree/v1.4.24), see instructions for how to [install rustfmt from source][install-from-source]
+
+## [1.4.23] 2020-10-30
+
+### Changed
+
+- Update `rustc-ap-*` crates to v686.0.0
+
+### Added
+- Initial support for formatting new ConstBlock syntax ([#4478](https://github.com/rust-lang/rustfmt/pull/4478))
+
+### Fixed
+- Handling of unclosed delimiter-only parsing errors in input files ([#4466](https://github.com/rust-lang/rustfmt/issues/4466))
+- Misc. minor parser bugs ([#4418](https://github.com/rust-lang/rustfmt/issues/4418) and [#4431](https://github.com/rust-lang/rustfmt/issues/4431))
+- Panic on nested tuple access ([#4355](https://github.com/rust-lang/rustfmt/issues/4355))
+- Unable to disable license template path via cli override ([#4487](https://github.com/rust-lang/rustfmt/issues/4487))
+- Preserve comments in empty statements [#4018](https://github.com/rust-lang/rustfmt/issues/4018))
+- Indentation on skipped code [#4398](https://github.com/rust-lang/rustfmt/issues/4398))
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - n/a (superseded by [v1.4.24](#1424-2020-11-05))
+- **GitHub Release Binaries** - [Release v1.4.23](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.23)
+- **Build from source** - [Tag v1.4.23](https://github.com/rust-lang/rustfmt/tree/v1.4.23), see instructions for how to [install rustfmt from source][install-from-source]
+
+
+
+## [1.4.22] 2020-10-04
+
+### Changed
+
+- Update `rustc-ap-*` crates to v679.0.0
+- Add config option to allow control of leading match arm pipes
+- Support `RUSTFMT` environment variable in `cargo fmt` to run specified `rustfmt` instance
+
+### Fixed
+
+- Fix preservation of type aliases within extern blocks
+
+
+## [1.4.9] 2019-10-07
+
+### Changed
+
+- Update `rustc-ap-*` crates to 606.0.0.
+
+### Fixed
+
+- Fix aligning comments of different group
+- Fix flattening imports with a single `self`.
+- Fix removing attributes on function parameters.
+- Fix removing `impl` keyword from opaque type.
+
+## [1.4.8] 2019-09-08
+
+### Changed
+
+- Update `rustc-ap-*` crates to 583.0.0.
+
+## [1.4.7] 2019-09-06
+
+### Added
+
+- Add `--config` command line option.
+
+### Changed
+
+- Update `rustc-ap-*` crates to 581.0.0.
+- rustfmt now do not warn against trailing whitespaces inside macro calls.
+
+### Fixed
+
+- Fix `merge_imports` generating invalid code.
+- Fix removing discriminant values on enum variants.
+- Fix modules defined inside `cfg_if!` not being formatted.
+- Fix minor formatting issues.
+
+## [1.4.6] 2019-08-28
+
+### Added
+
+- Add `--message-format` command line option to `cargo-fmt`.
+- Add `-l,--files-with-diff` command line option to `rustfmt`.
+- Add `json` emit mode.
+
+### Fixed
+
+- Fix removing attributes on struct pattern's fields.
+- Fix non-idempotent formatting of match arm.
+- Fix `merge_imports` generating invalid code.
+- Fix imports with `#![macro_use]` getting reordered with `reorder_imports`.
+- Fix calculation of line numbers in checkstyle output.
+- Fix poor formatting of complex fn type.
+
+## [1.4.5] 2019-08-13
+
+### Fixed
+
+- Fix generating invalid code when formatting an impl block with const generics inside a where clause.
+- Fix adding a trailing space after a `dyn` keyword which is used as a macro argument by itself.
+
+## [1.4.4] 2019-08-06
+
+### Fixed
+
+- Fix `cargo fmt` incorrectly formatting crates that is not part of the workspace or the path dependencies.
+- Fix removing a trailing comma from a tuple pattern.
+
+## [1.4.3] 2019-08-02
+
+### Changed
+
+- Update `rustc-ap-*` crates to 546.0.0.
+
+### Fixed
+
+- Fix an underscore pattern getting removed.
+
+## [1.4.2] 2019-07-31
+
+### Changed
+
+- Explicitly require the version of `rustfmt-config_proc_macro` to be 0.1.2 or later.
+
+## [1.4.1] 2019-07-30
+
+### Changed
+
+- Update `rustc-ap-*` crates to 542.0.0.
+
+## [1.4.0] 2019-07-29
+
+### Added
+
+- Add new attribute `rustfmt::skip::attributes` to prevent rustfmt
+from formatting an attribute #3665
+
+### Changed
+
+- Update `rustc-ap-*` crates to 541.0.0.
+- Remove multiple semicolons.
+
+## [1.3.3] 2019-07-15
+
+### Added
+
+- Add `--manifest-path` support to `cargo fmt` (#3683).
+
+### Fixed
+
+- Fix `cargo fmt -- --help` printing nothing (#3620).
+- Fix inserting an extra comma (#3677).
+- Fix incorrect handling of CRLF with `file-lines` (#3684).
+- Fix `print-config=minimal` option (#3687).
+
+## [1.3.2] 2019-07-06
+
+### Fixed
+
+- Fix rustfmt crashing when `await!` macro call is used in a method chain.
+- Fix rustfmt not recognizing a package whose name differs from its directory's name.
+
+## [1.3.1] 2019-06-30
+
+### Added
+
+- Implement the `Display` trait on the types of `Config`.
+
+### Changed
+
+- `ignore` configuration option now only supports paths separated by `/`. Windows-style paths are not supported.
+- Running `cargo fmt` in a sub-directory of a project is now supported.
+
+### Fixed
+
+- Fix bugs that may cause rustfmt to crash.
+
+## [1.3.0] 2019-06-09
+
+### Added
+
+- Format modules defined inside `cfg_if` macro calls #3600
+
+### Changed
+
+- Change option `format_doc_comment` to `format_code_in_doc_comment`.
+- `use_small_heuristics` changed to be an enum and stabilised. Configuration
+ options are now ready for 1.0.
+- Stabilise `fn_args_density` configuration option and rename it to `fn_args_layout` #3581
+- Update `rustc-ap-*` crates to 486.0.0
+- Ignore sub-modules when skip-children is used #3607
+- Removed bitrig support #3608
+
+### Fixed
+
+- `wrap_comments` should not imply `format_doc_comments` #3535
+- Incorrect handling of const generics #3555
+- Add the handling for `vec!` with paren inside macro #3576
+- Format trait aliases with where clauses #3586
+- Catch panics from the parser while rewriting macro calls #3589
+- Fix erasing inner attributes in struct #3593
+- Inline the attribute with its item even with the `macro_use` attribute or when `reorder_imports` is disabled #3598
+- Fix the bug add unwanted code to impl #3602
+
+## [1.2.2] 2019-04-24
+
+### Fixed
+
+- Fix processing of `ignore` paths #3522
+- Attempt to format attributes if only they exist #3523
+
+## [1.2.1] 2019-04-18
+
+### Added
+
+- Add `--print-config current` CLI option b473e65
+- Create GitHub [page](https://rust-lang.github.io/rustfmt/) for Configuration.md #3485
+
+### Fixed
+
+- Keep comment appearing between parameter's name and its type #3491
+- Do not delete semicolon after macro call with square brackets #3500
+- Fix `--version` CLI option #3506
+- Fix duplication of attributes on a match arm's body #3510
+- Avoid overflowing item with attributes #3511
+
+## [1.2.0] 2019-03-27
+
+### Added
+
+- Add new attribute `rustfmt::skip::macros` to prevent rustfmt from formatting a macro #3454
+
+### Changed
+
+- Discard error report in silent_emitter #3466
+
+### Fixed
+
+- Fix bad performance on deeply nested binary expressions #3467
+- Use BTreeMap to guarantee consistent ordering b4d4b57
+
+## [1.1.1] 2019-03-21
+
+### Fixed
+
+- Avoid panic on macro inside deeply nested block c9479de
+- Fix line numbering in missed spans and handle file_lines in edge cases cdd08da
+- Fix formatting of async blocks 1fa06ec
+- Avoid duplication on the presence of spaces between macro name and `!` #3464
+
+## [1.1.0] 2019-03-17
+
+### Added
+
+- Add `inline_attribute_width` configuration option to write an item and its attribute on the same line if their combined width is below a threshold #3409
+- Support `const` generics f0c861b
+- Support path clarity module #3448
+
+### Changed
+
+- Align loop and while formatting 7d9a2ef
+- Support `EmitMode::ModifiedLines` with stdin input #3424
+- Update `rustc-ap-*` crates to 407.0.0
+- Remove trailing whitespaces in missing spans 2d5bc69
+
+### Fixed
+
+- Do not remove comment in the case of no arg 8e3ef3e
+- Fix `Ident of macro+ident gets duplicated` error 40ff078
+- Format the if expression at the end of the block in a single line 5f3dfe6
+
+## [1.0.3] 2019-02-14
+
+### Added
+
+- Point unstable options to tracking issues 412dcc7
+
+### Changed
+
+- Update `rustc-ap-*` crates to 373.0.0
+
+## [1.0.2] 2019-02-12
+
+### Added
+
+- Add a [section](https://github.com/rust-lang/rustfmt/blob/ae331be/Contributing.md#version-gate-formatting-changes) to the Contributing.md file about version-gating formatting changes 36e2cb0
+- Allow specifying package with `-p` CLI option a8d2591
+- Support `rustfmt::skip` on imports #3289
+- Support global `rustfmt.toml` to be written in user config directory #3280
+- Format visibility on trait alias 96a3df3
+
+### Changed
+
+- Do not modify original source code inside macro call #3260
+- Recognize strings inside comments in order to avoid indenting them baa62c6
+- Use Unicode-standard char width to wrap comments or strings a01990c
+- Change new line point in the case of no args #3294
+- Use the same formatting rule between functions and macros #3298
+- Update rustc-ap-rustc_target to 366.0.0, rustc-ap-syntax to 366.0.0, and rustc-ap-syntax_pos to 366.0.0
+
+### Fixed
+
+- rewrite_comment: fix block fallback when failing to rewrite an itemized block ab7f4e1
+- Catch possible tokenizer panics #3240
+- Fix macro indentation on Windows #3266
+- Fix shape when formatting return or break expr on statement position #3259
+- rewrite_comment: fix block fallback when failing to rewrite an itemized block
+- Keep leading double-colon to respect the 2018 edition of rust's paths a2bfc02
+- Fix glob and nested global imports 2125ad2
+- Do not force trailing comma when using mixed layout #3306
+- Prioritize `single_line_fn` and `empty_item_single_line` over `brace_style` #3308
+- Fix `internal error: left behind trailing whitespace` with long lines c2534f5
+- Fix attribute duplication #3325
+- Fix formatting of strings within a macro 813aa79
+- Handle a macro argument with a single keyword 9a7ea6a
+
+## [1.0.1] 2018-12-09
+
+### Added
+
+- Add a `version` option 378994b
+
+### Changed
+
+- End expressions like return/continue/break with a semicolon #3223
+- Update rustc-ap-rustc_target to 306.0.0, rustc-ap-syntax to 306.0.0, and rustc-ap-syntax_pos to 306.0.0
+
+### Fixed
+
+- Allow to run a rustfmt command from cargo-fmt even when there is no target a2da636
+- Fix `un-closed delimiter` errors when formatting break labels 40174e9
+
+## [1.0.0] 2018-11-19
+
+### Changed
+
+- Preserve possibly one whitespace for brace macros 1a3bc79
+- Prefer to break arguments over putting output type on the next line 1dd54e6
+
+## [0.99.9] 2018-11-15
+
+### Changed
+
+- Update rustc-ap-rustc_target to 297.0.0, rustc-ap-syntax to 297.0.0, to rustc-ap-syntax_pos to 297.0.0
+- Don't align comments on `extern crate`s dd7add7
+
+## [0.99.8] 2018-11-14
+
+### Added
+
+- Add `overflow_delimited_expr` config option to more aggressively allow overflow #3175
+
+### Fixed
+
+- Fix the logic for retaining a comment before the arrow in a match #3181
+- Do not wrap comments in doctest to avoid failing doctest runs #3183
+- Fix comment rewriting that was wrapping code into a line comment #3188
+- Fix formatting of unit-struct with `where`-clause #3200
+
+## [0.99.7] 2018-11-07
+
+### Changed
+
+- Force a newline after the `if` condition if there is a different indentation level #3109
+- Use correct width when formatting type on local statement #3126
+- Treat crates non-alphabetically when ordering 799005f
+- Fix formatting of code that is annotated with rustfmt::skip #3113
+- Stabilize `edition` configuration option 9c3ae2d
+- cargo-fmt: detect Rust edition in use #3129
+- Trim the indentation on macros which heuristically appear to use block-style indentation #3178
+
+### Fixed
+
+- Do not remove path disambiugator inside macro #3142
+- Improve handling of Windows newlines #3141
+- Fix alignment of a struct's fields (`struct_field_align_threshold` option) with the Visual `indent_style` #3165
+- Fix a bug in formatting markdown lists within comments #3172
+
+## [0.99.6] 2018-10-18
+
+### Added
+
+- Add `enum_discrim_align_threshold` option to vertically align enum discriminants cc22869
+- Add `println!`-like heuristic to the `fail` attribute #3067
+- Handle itemized items inside comments #3083
+- Add `format_doc_comments` configuration option to control the formatting of code snippets inside comments #3089
+
+### Changed
+
+- Makes brace behavior consistent with empty bodies for traits and impls 2727d41
+- Consider a multi-lined array as a block-like expression #3969
+- Improve formatting of strings #3073
+- Get rid of extra commas in Visual struct literal formatting #3077
+- Update rustc-ap-rustc_target to 274.0.0, rustc-ap-syntax to 274.0.0, and rustc-ap-syntax_pos to 274.0.0
+- Format macro calls with item-like arguments #3080
+- Avoid control flow expressions conditions to go multi line ef59b34
+- Simplify multi-lining binop expressions #3101
+
+### Fixed
+
+- Do not format a code block in documentation if it is annotated with ignore or text 2bcc3a9
+- Fix inconsistent overflow behavior in Visual style #3078
+- Fix corner cases of the string formatting implementation #3083
+- Do not add parens around lifetimes 0ac68c9
+- Catch parser panic in format_snippet 8c4e92a
+
+## [0.99.5] 2018-09-25
+
+### Added
+
+- Handle leading module separator for 2018 Edition #2952
+- Add configuration option `normalize_doc_attributes`: convert doc attributes to comments #3002
+
+### Changed
+
+- Accept 2015 and 2018 instead of Edition2015 and Edition2018 for edition option eec7436
+- Support platforms without a timer 46e2a2e
+- Update rustc-ap-rustc_target to 263.0.0, rustc-ap-syntax to 263.0.0, and rustc-ap-syntax_pos to 263.0.0
+
+### Fixed
+
+- Format of attributes with commas #2971
+- Fix optional arg condensing #2972
+- Improve formatting of long function parameters #2981
+- Fix formatting of raw string literals #2983
+- Handle chain with try operators with spaces #2986
+- Use correct shape in Visual tuple rewriting #2987
+- Impove formatting of arguments with `visual_style = "Visual"` option #2988
+- Change `print_diff` to output the correct line number 992b179
+- Propagate errors about failing to rewrite a macro 6f318e3
+- Handle formatting of long function signature #3010
+- Fix indent computation of a macro with braces c3edf6d
+- Format generics on associated types #3035
+- Incorrect indentation of multiline block match expression #3042
+- Fix bug in import where two consecutive module separators were possible 98a0ef2
+- Prevent right-shifting of block comments with bare lines 5fdb6db
+
+## [0.99.4] 2018-08-27
+
+### Added
+
+- Handle formatting of underscore imports #2951
+- Handle formatting of try blocks #2965
+
+### Changed
+
+- Update rustc-ap-rustc_target to 237.0.0, rustc-ap-syntax to 237.0.0, and rustc-ap-syntax_pos to 237.0.0 ca19c9a
+- Consider `dev` channel as nightly for unstable features #2948
+
+### Fixed
+
+- Fix formatting of patterns with ellipsis # 2942
+
+## [0.99.3] 2018-08-23
+
+### Added
+
+- Use path attribute when searching for modules #2901
+- Expose FileLines JSON representation to allow external libraries to use the file_lines option #2915
+
+### Changed
+
+- Replace '--conifig-help' with '--config=help' cb10e06
+- Improve formatting of slice patterns #2912
+
+### Fixed
+
+- Format chains with comment #2899
+- Fix indentation of formatted macro body #2920
+- Fix indentation of block comments f23e6aa
+
+## [0.99.2] 2018-08-07
+
+### Changed
+
+- Update rustc-ap-rustc_target to 218.0.0, rustc-ap-syntax to 218.0.0, and rustc-ap-syntax_pos to 218.0.0 5c9a2b6
+- Combine function-like attributes #2900
+
+### Fixed
+
+- Explicitly handle semicolon after the item in statement position d96e3ca
+- Fix parsing '#'-hiding of rustdoc 2eca09e
+
+## [0.99.1] 2018-08-04
+
+### Fixed
+
+- fix use statements ordering when a number is present 1928ae7
+
+## [0.99.0] 2018-08-03
+
+- 1.0 RC release
+
+### Changed
+
+- Clarification in README.md 30fe66b
+
+## [0.9.0] 2018-08-01
+
+### Added
+
+- Handle raw identifiers 3027c21
+- Format async closure 60ce411
+- Add max_width option for all heuristics c2ae39e
+- Add config option `format_macro_matchers` to format the metavariable matching patterns in macros 79c5ee8
+- Add config option `format_macro_bodies` to format the bodies of macros 79c5ee8
+- Format exitential type fc307ff
+- Support raw identifiers in struct expressions f121b1a
+- Format Async block and async function 0b25f60
+
+### Changed
+
+- Update rustc-ap-rustc_target to 211.0.0, rustc-ap-syntax to 211.0.0, and rustc-ap-syntax_pos to 211.0.0
+- Put each nested import on its own line while putting non-nested imports on the same line as much as possible 42ab258
+- Respect `empty_item_single_line` config option when formatting empty impls. Put the `where` on its own line to improve readability #2771
+- Strip leading `|` in match arm patterns 1d4b988
+- Apply short function call heuristic to attributes 3abebf9
+- Indent a match guard if the pattern is multiline be4d37d
+- Change default newline style to `Native` 9d8f381
+- Improve formatting of series of binop expressions a4cdb68
+- Trigger an internal error if we skip formatting due to a lost comment b085113
+- Refactor chain formatting #2838
+
+### Fixed
+
+- Do not insert spaces around braces with empty body or multiple lines 2f65852
+- Allow using mixed layout with comments #2766
+- Handle break labels #2726
+- fix rewrite_string when a line feed is present 472a2ed
+- Fix an anomaly with comments and array literals b28a0cd
+- Check for comments after the `=>` in a match arm 6899471
+
+## [0.8.0,0.8.1,0.8.2] 2018-05-28
+
+### Added
+
+- Use scoped attributes for skip attribute https://github.com/rust-lang/rustfmt/pull/2703
+
+### Changed
+
+- Comment options `wrap_comments` and `normalize_comments` are reverted back to unstable 416bc4c
+- Stabilise `reorder_imports` and `reorder_modules` options 7b6d2b4
+- Remove `spaces_within_parens_and_brackets` option d726492
+- Stabilise shorthand options: `use_try_shorthand`, `use_field_init_shorthand`, and `force_explicit_abi` 8afe367
+- Stabilise `remove_nested_parens` and set default to true a70f716
+- Unstabilise `unstable_features` dd9c15a
+- Remove `remove_blank_lines_at_start_or_end_of_block` option 2ee8b0e
+- Update rustc-ap-syntax to 146.0.0 and rustc-ap-rustc_target to 146.0.0 2c275a2
+- Audit the public API #2639
+
+### Fixed
+
+- Handle code block in doc comment without rust prefix f1974e2
+
+## [0.7.0] 2018-05-14
+
+### Added
+
+- Add integration tests against crates in the rust-lang-nursery c79f39a
+
+### Changed
+
+- Update rustc-ap-syntax to 128.0.0 and ustc-ap-rustc_target to 128.0.0 195395f
+- Put operands on its own line when each fits in a single line f8439ce
+- Improve CLI options 55ac062 1869888 798bffb 4d9de48 eca7796 8396da1 5d9f5aa
+
+### Fixed
+
+- Use correct line width for list attribute 61a401a
+- Avoid flip-flopping impl items when reordering them 37c216c
+- Formatting breaks short lines when max_width is less than 100 9b36156
+- Fix variant "Mixed" of imports_layout option 8c8676c
+- Improve handling of long lines f885039
+- Fix up lines exceeding max width 51c07f4
+- Fix handling of modules in non_modrs_mods style cf573e8
+- Do not duplicate attributes on use items e59ceaf
+- Do not insert an extra brace in macros with native newlines 4c9ef93
+
+## [0.6.1] 2018-05-01
+
+### Changed
+
+- Change the default value of imports_indent to IndentStyle::Block https://github.com/rust-lang/rustfmt/pull/2662
+
+### Fixed
+
+- Handle formatting of auto traits 5b5a72c
+- Use consistent formatting for empty enum and struct https://github.com/rust-lang/rustfmt/pull/2656
+
+## [0.6.0] 2018-04-20
+
+### Changed
+
+- Improve public API 8669004
+
+## [0.5.0] 2018-04-20
+
+### Added
+
+- Add `verbose-diff` CLI option 5194984
+
+### Changed
+
+- Update rustc-ap-syntax to 103.0.0 dd807e2
+- Refactor to make a sensible public API ca610d3
+
+### Fixed
+
+- Add spaces between consecutive `..` `..=` 61d29eb
+
+## [0.4.2] 2018-04-12
+
+### Added
+
+- Handle binary operators and lifetimes 0fd174d
+- Add reorder_impl_items config option 94f5a05
+- Add `--unstable-features` CLI option to list unstable options from the `--help` output 8208f8a
+- Add merge_imports config option 5dd203e
+
+### Changed
+
+- Format macro arguments with vertical layout ec71459
+- Reorder imports by default 164cf7d
+- Do not collapse block around expr with condition on match arm 5b9b7d5
+- Use vertical layout for complex attributes c77708f
+- Format array using heuristics for function calls 98c6f7b
+- Implement stable ordering for impl items with the the following item priority: type, const, macro, then method fa80ddf
+- Reorder imports by default 164cf7d
+- Group `extern crate` by default 3a138a2
+- Make `error_on_line_overflow` false by default f146711
+- Merge imports with the same prefix into a single nested import 1954513
+- Squash the various 'reorder imports' option into one 911395a
+
+### Fixed
+
+- Print version is missing the channel ca6fc67
+- Do not add the beginning vert to the match arm 1e1d9d4
+- Follow indent style config when formatting attributes efd295a
+- Do not insert newline when item is empty a8022f3
+- Do not indent or unindent inside string literal ec1907b
+
+## [0.4.1] 2018-03-16
+
+### Added
+
+- Add `ignore` configuration option.
+- Add `license_template_path` configuration option.
+- Format `lazy_static!`.
+
+### Fixed
+
+- Fix formatting bugs.
+- Fix setting `reorder_modules` removing inline modules.
+- Format attributes on block expressions.
+- Support `dyn trait` syntax.
+- Support multiple patterns in `if let` and `while let`.
+- Support a pattern with parentheses.
+
+## [0.4.0] 2018-03-02
+
+### Changed
+
+- Do not print verbose outputs when formatting with stdin.
+- Preserve trailing whitespaces in doc comments.
+- Scale the values of width heuristics by `max_width`.
+
+### Fixed
+
+- Do not reorder items with `#[macro_use]`.
+- Fix formatting bugs.
+- Support the beginning `|` on a match arm.
+
+## [0.3.8] 2018-02-04
+
+### Added
+
+- Format (or at least try to format) `macro_rules!`.
+
+## [0.3.7] 2018-02-01
+
+### Added
+
+- Add `use_field_init_shorthand` config option.
+- Add `reorder_modules` configuration option.
+
+## [0.3.6] 2018-01-18
+
+### Fixed
+
+- Fix panicking on formatting certain macros (#2371).
+
+## [0.3.5] 2018-01-15
+
+### Changed
+
+- Format code block in comments when `wrap_comments` is set to `true`.
+- Remove `same_line_attributes` configuration option.
+- Rename `git-fmt` to `git-rustfmt`.
+
+### Fixed
+
+- Rustup to `rustc 1.25.0-nightly (e6072a7b3 2018-01-13)`.
+- Fix formatting bugs.
+
+## [0.3.4] 2017-12-23
+
+### Added
+
+- Add `--version` flag to `cargo-fmt`, allow `cargo fmt --version`.
+
+### Fixed
+
+- Rustup to `rustc 1.24.0-nightly (5165ee9e2 2017-12-22)`.
+
+## [0.3.3] 2017-12-22
+
+### Added
+
+- Format trait aliases.
+
+### Changed
+
+- `cargo fmt` will format every workspace member.
+
+### Fixed
+
+- Rustup to `rustc 1.24.0-nightly (250b49205 2017-12-21)`
+- Fix formatting bugs.
+
+## [0.3.2] 2017-12-15
+
+### Changed
+
+- Warn when unknown configuration option is used.
+
+### Fixed
+
+- Rustup to `rustc 1.24.0-nightly (0077d128d 2017-12-14)`.
+
+## [0.3.1] 2017-12-11
+
+### Added
+
+- Add `error_on_unformatted` configuration option.
+- Add `--error-on-unformatted` command line option.
+
+### Changed
+
+- Do not report formatting errors on comments or strings by default.
+- Rename `error_on_line_overflow_comments` to `error_on_unformatted`.
+
+### Fixed
+
+- Fix formatting bugs.
+- Fix adding a trailing whitespace inside code block when `wrap_comments = true`.
+
+## [0.3.0] 2017-12-11
+
+### Added
+
+- Support nested imports.
+
+### Changed
+
+- Do not report errors on skipped items.
+- Do not format code block inside comments when `wrap_comments = true`.
+- Keep vertical spaces between items within range.
+- Format `format!` and its variants using compressed style.
+- Format `write!` and its variants using compressed style.
+- Format **simple** array using compressed style.
+
+### Fixed
+
+- Fix `rustfmt --package package_name` not working properly.
+- Fix formatting bugs.
+
+## [0.2.17] 2017-12-03
+
+### Added
+
+- Add `blank_lines_lower_bound` and `blank_lines_upper_bound` configuration options.
+
+### Changed
+
+- Combine configuration options related to width heuristic into `width_heuristic`.
+- If the match arm's body is `if` expression, force to use block.
+
+### Fixed
+
+- Fix `cargo fmt --all` being trapped in an infinite loop.
+- Fix many formatting bugs.
+
+### Removed
+
+- Remove legacy configuration options.
+
+## [0.2.16] 2017-11-21
+
+### Added
+
+- Remove empty lines at the beginning of the file.
+- Soft wrapping on doc comments.
+
+### Changed
+
+- Break before `|` when using multiple lines for match arm patterns.
+- Combine `control_style`, `where_style` and `*_indent` config options into `indent_style`.
+- Combine `item_brace_style` and `fn_brace_style` config options into `brace_style`.
+- Combine config options related spacing around colons into `space_before_colon` and `space_after_colon`.
+
+### Fixed
+
+- Fix many bugs.
+
+## [0.2.15] 2017-11-08
+
+### Added
+
+- Add git-fmt tool
+- `where_single_line` configuration option.
+
+### Changed
+
+- Rename `chain_one_line_max` to `chain_width`.
+- Change the suffix of indent-related configuration options to `_indent`.
+
+## [0.2.14] 2017-11-06
+
+### Fixed
+
+- Rustup to the latest nightly.
+
+## [0.2.13] 2017-10-30
+
+### Fixed
+
+- Rustup to the latest nightly.
+
+## [0.2.12] 2017-10-29
+
+### Fixed
+
+- Fix a bug that `cargo fmt` hangs forever.
+
+## [0.2.11] 2017-10-29
+
+### Fixed
+
+- Fix a bug that `cargo fmt` crashes.
+
+## [0.2.10] 2017-10-28
+
+## [0.2.9] 2017-10-16
+
+## [0.2.8] 2017-09-28
+
+## [0.2.7] 2017-09-21
+
+### Added
+
+- `binop_separator` configuration option (#1964).
+
+### Changed
+
+- Use horizontal layout for function call with a single argument.
+
+### Fixed
+
+- Fix panicking when calling `cargo fmt --all` (#1963).
+- Refactorings & faster rustfmt.
+
+## [0.2.6] 2017-09-14
+
+### Fixed
+
+- Fix a performance issue with nested block (#1940).
+- Refactorings & faster rustfmt.
+
+## [0.2.5] 2017-08-31
+
+### Added
+
+- Format and preserve attributes on statements (#1933).
+
+### Fixed
+
+- Use getters to access `Span` fields (#1899).
+
+## [0.2.4] 2017-08-30
+
+### Added
+
+- Add support for `Yield` (#1928).
+
+## [0.2.3] 2017-08-30
+
+### Added
+
+- `multiline_closure_forces_block` configuration option (#1898).
+- `multiline_match_arm_forces_block` configuration option (#1898).
+- `merge_derives` configuration option (#1910).
+- `struct_remove_empty_braces` configuration option (#1930).
+- Various refactorings.
+
+### Changed
+
+- Put single-lined block comments on the same line with list-like structure's item (#1923).
+- Preserve blank line between doc comment and attribute (#1925).
+- Put the opening and the closing braces of enum and struct on the same line, even when `item_brace_style = "AlwaysNextLine"` (#1930).
+
+### Fixed
+
+- Format attributes on `ast::ForeignItem` and take max width into account (#1916).
+- Ignore empty lines when calculating the shortest indent width inside macro with braces (#1918).
+- Handle tabs properly inside macro with braces (#1918).
+- Fix a typo in `compute_budgets_for_args()` (#1924).
+- Recover comment between keyword (`impl` and `trait`) and `{` which used to get removed (#1925).
+
+
+[install-from-source]: https://github.com/rust-lang/rustfmt#installing-from-source
--- /dev/null
- [[package]]
- name = "arrayref"
- version = "0.3.5"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
-
- [[package]]
- name = "arrayvec"
- version = "0.4.12"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "cd9fd44efafa8690358b7408d253adf110036b88f55672a933f01d616ad9b1b9"
- dependencies = [
- "nodrop",
- ]
-
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58fb5e95d83b38284460a5fda7d6470aa0b8844d283a0b614b8535e880800d2d"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "annotate-snippets"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d78ea013094e5ea606b1c05fe35f1dd7ea1eb1ea259908d040b25bd5ec677ee5"
+dependencies = [
+ "yansi-term",
+]
+
+[[package]]
+name = "ansi_term"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9267dff192e68f3399525901e709a48c1d3982c9c072fa32f2127a0cb0babf14"
+
- version = "0.1.7"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2"
-
- [[package]]
- name = "backtrace"
- version = "0.3.40"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "924c76597f0d9ca25d762c25a4d369d51267536465dc5064bdf0eb073ed477ea"
- dependencies = [
- "backtrace-sys",
- "cfg-if 0.1.10",
- "libc",
- "rustc-demangle",
- ]
-
- [[package]]
- name = "backtrace-sys"
- version = "0.1.32"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "5d6575f128516de27e3ce99689419835fce9643a9b215a14d2b5b685be018491"
- dependencies = [
- "cc",
- "libc",
- ]
-
- [[package]]
- name = "base64"
- version = "0.10.1"
+[[package]]
+name = "atty"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1803c647a3ec87095e7ae7acfca019e98de5ec9a7d01343f611cf3152ed71a90"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
- checksum = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
- dependencies = [
- "byteorder",
- ]
++version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- [[package]]
- name = "blake2b_simd"
- version = "0.5.8"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "5850aeee1552f495dd0250014cf64b82b7c8879a89d83b33bbdace2cc4f63182"
- dependencies = [
- "arrayref",
- "arrayvec",
- "constant_time_eq",
- ]
-
++checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bitflags"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+
- version = "0.6.0"
+[[package]]
+name = "bstr"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d6c2c5b58ab920a4f5aeaaca34b4488074e8cc7596af94e6f8c6ff247c60245"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bytecount"
- checksum = "b0017894339f586ccb943b01b9555de56770c11cda818e7e3d8bd93f4ed7f46e"
++version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "packed_simd",
++checksum = "72feb31ffc86498dacdbd0fcebb56138e7177a8cc5cea4516031d15ae85a742e"
+dependencies = [
- name = "byteorder"
- version = "1.3.2"
++ "packed_simd_2",
+]
+
+[[package]]
- checksum = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5"
++name = "camino"
++version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- name = "cargo_metadata"
- version = "0.8.2"
++checksum = "52d74260d9bf6944e2208aa46841b4b8f0d7ffc0849a06837b2f510337f86b2b"
++dependencies = [
++ "serde",
++]
+
+[[package]]
- checksum = "700b3731fd7d357223d0000f4dbf1808401b694609035c3c411fbc0cd375c426"
++name = "cargo-platform"
++version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "semver",
++checksum = "0226944a63d1bf35a3b5f948dd7c59e263db83695c9e8bffc4037de02e30f1d7"
+dependencies = [
- "serde_derive",
- "serde_json",
+ "serde",
- name = "cc"
- version = "1.0.46"
+]
+
+[[package]]
- checksum = "0213d356d3c4ea2c18c40b037c3be23cd639825c18f25ee670ac7813beeef99c"
++name = "cargo_metadata"
++version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- [[package]]
- name = "cloudabi"
- version = "0.0.3"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
- dependencies = [
- "bitflags",
- ]
-
- [[package]]
- name = "constant_time_eq"
- version = "0.1.4"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "995a44c877f9212528ccc74b21a232f66ad69001e40ede5bcee2ac9ef2657120"
-
- [[package]]
- name = "crossbeam-channel"
- version = "0.4.0"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "acec9a3b0b3559f15aee4f90746c4e5e293b701c0f7d3925d24e01645267b68c"
- dependencies = [
- "crossbeam-utils 0.7.0",
- ]
-
++checksum = "c297bd3135f558552f99a0daa180876984ea2c4ffa7470314540dff8c654109a"
++dependencies = [
++ "camino",
++ "cargo-platform",
++ "semver",
++ "serde",
++ "serde_json",
++]
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clap"
+version = "2.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags",
+ "strsim",
+ "textwrap",
+ "unicode-width",
+ "vec_map",
+]
+
- version = "0.6.6"
+[[package]]
+name = "crossbeam-utils"
- checksum = "04973fa96e96579258a5091af6003abde64af786b860f18622b82e026cca60e6"
- dependencies = [
- "cfg-if 0.1.10",
- "lazy_static",
- ]
-
- [[package]]
- name = "crossbeam-utils"
- version = "0.7.0"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "ce446db02cdc3165b94ae73111e570793400d0794e46125cc4056c81cbb039f4"
++version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "cfg-if 0.1.10",
++checksum = "e7e9d99fa91428effe99c5c6d4634cdeba32b8cf784fc428a2a687f61a952c49"
+dependencies = [
+ "autocfg",
- version = "0.3.4"
++ "cfg-if 1.0.0",
+ "lazy_static",
+]
+
+[[package]]
+name = "derive-new"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71f31892cd5c62e414316f2963c5689242c43d8e7bbcaaeca97e5e28c95d91d9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c2b69f912779fbb121ceb775d74d51e915af17aaebc38d28a592843a2dd0a3a"
+
+[[package]]
+name = "dirs"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13aea89a5c93364a98e9b37b2fa237effbb694d5cfe01c5b70941f7eb087d5e3"
+dependencies = [
+ "cfg-if 0.1.10",
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
- checksum = "afa0b23de8fd801745c471deffa6e12d248f962c9fd4b4c33787b055599bde7b"
++version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "cfg-if 0.1.10",
++checksum = "03d86534ed367a67548dc68113a0f5db55432fdfbb6e6f9d77704397d95d5780"
+dependencies = [
- version = "0.6.2"
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "either"
+version = "1.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3"
+
+[[package]]
+name = "env_logger"
- checksum = "aafcde04e90a5226a6443b7aabdb016ba2f8307c847d524724bd9b346dd1a2d3"
++version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- [[package]]
- name = "failure"
- version = "0.1.6"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "f8273f13c977665c5db7eb2b99ae520952fe5ac831ae4cd09d80c4c7042b5ed9"
- dependencies = [
- "backtrace",
- "failure_derive",
- ]
-
- [[package]]
- name = "failure_derive"
- version = "0.1.8"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4"
- dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "synstructure",
- ]
-
++checksum = "54532e3223c5af90a6a757c90b5c5521564b07e5e7a958681bcd2afad421cdcd"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
- [[package]]
- name = "fuchsia-cprng"
- version = "0.1.1"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
-
+[[package]]
+name = "fnv"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"
+
- version = "0.4.4"
+[[package]]
+name = "getopts"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
+dependencies = [
+ "unicode-width",
+]
+
++[[package]]
++name = "getrandom"
++version = "0.2.3"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
++dependencies = [
++ "cfg-if 1.0.0",
++ "libc",
++ "wasi",
++]
++
+[[package]]
+name = "globset"
- checksum = "925aa2cac82d8834e2b2a4415b6f6879757fb5c0928fc445ae76461a12eed8f2"
++version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- version = "1.3.0"
++checksum = "c152169ef1e421390738366d2f796655fec62621dabbd0fd476f905934061e4a"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "fnv",
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "heck"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "humantime"
- checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
- dependencies = [
- "quick-error",
- ]
++version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- version = "0.4.11"
++checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "ignore"
- checksum = "522daefc3b69036f80c7d2990b28ff9e0471c683bad05ca258e0a01dd22c5a1e"
++version = "0.4.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "crossbeam-channel",
++checksum = "b287fb45c60bb826a0dc68ff08742b9d88a2fea13d6e0c286b3172065aaf878c"
+dependencies = [
- "thread_local 1.0.1",
++ "crossbeam-utils",
+ "globset",
+ "lazy_static",
+ "log",
+ "memchr",
+ "regex",
+ "same-file",
- version = "0.8.0"
++ "thread_local",
+ "walkdir",
+ "winapi-util",
+]
+
+[[package]]
+name = "itertools"
- checksum = "5b8467d9c1cebe26feb08c640139247fac215782d35371ade9a2136ed6085358"
++version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- name = "nodrop"
- version = "0.1.14"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
-
- [[package]]
- name = "packed_simd"
- version = "0.3.3"
++checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501266b7edd0174f8530248f87f99c88fbe60ca4ef3dd486835b8d8d53136f7f"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f96b10ec2560088a8e76961b00d47107b3a625fecb76dedb29ee7ccbf98235"
+
++[[package]]
++name = "libm"
++version = "0.1.4"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "7fc7aa29613bd6a620df431842069224d8bc9011086b1db4c0e0cd47fa03ec9a"
++
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "memchr"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88579771288728879b57485cc7d6b07d648c9f0141eb955f8ab7f9d45394468e"
+
+[[package]]
- checksum = "a85ea9fc0d4ac0deb6fe7911d38786b32fc11119afd9e9d38b84ff691ce64220"
++name = "packed_simd_2"
++version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- version = "1.0.6"
++checksum = "3278e0492f961fd4ae70909f56b2723a7e8d01a228427294e19cdfdebda89a17"
+dependencies = [
+ "cfg-if 0.1.10",
++ "libm",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7959c6467d962050d639361f7703b2051c43036d03493c36f01d440fdd3138a"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4002d9f55991d5e019fb940a90e1a95eb80c24e77cb2462dd4dc869604d543a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "syn-mid",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
- checksum = "9c9e470a8dc4aeae2dee2f335e8f533e2d4b347e1434e5671afc49b054592f27"
++version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- [[package]]
- name = "quick-error"
- version = "1.2.2"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0"
-
++checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec"
+dependencies = [
+ "unicode-xid",
+]
+
- name = "rand_core"
- version = "0.3.1"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
- dependencies = [
- "rand_core 0.4.2",
- ]
-
- [[package]]
- name = "rand_core"
- version = "0.4.2"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
-
- [[package]]
- name = "rand_os"
- version = "0.1.3"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
- dependencies = [
- "cloudabi",
- "fuchsia-cprng",
- "libc",
- "rand_core 0.4.2",
- "rdrand",
- "winapi",
- ]
-
- [[package]]
- name = "rdrand"
- version = "0.4.0"
+[[package]]
+name = "quote"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54a21852a652ad6f610c9510194f398ff6f8692e334fd1145fed931f7fbe44ea"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
- checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
++name = "redox_syscall"
++version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "rand_core 0.3.1",
++checksum = "05ec8ca9416c5ea37062b502703cd7fcb207736bc294f6e0cf367ac6fc234570"
+dependencies = [
- [[package]]
- name = "redox_syscall"
- version = "0.1.56"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
-
++ "bitflags",
+]
+
- version = "0.3.1"
+[[package]]
+name = "redox_users"
- checksum = "4ecedbca3bf205f8d8f5c2b44d83cd0690e39ee84b951ed649e9f1841132b66d"
++version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "failure",
- "rand_os",
++checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
+dependencies = [
- "rust-argon2",
++ "getrandom",
+ "redox_syscall",
- version = "1.3.1"
+]
+
+[[package]]
+name = "regex"
- checksum = "dc220bd33bdce8f093101afe22a037b8eb0e5af33592e6a9caafff0d4cb81cbd"
++version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "thread_local 0.3.6",
++checksum = "d9251239e129e16308e70d853559389de218ac275b515068abc96829d05b948a"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
- version = "0.6.12"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "11a7e20d1cce64ef2fed88b66d347f88bd9babb82845b2b858f3edbf59a4f716"
-
- [[package]]
- name = "rust-argon2"
- version = "0.5.1"
++ "thread_local",
+]
+
+[[package]]
+name = "regex-syntax"
- checksum = "4ca4eaef519b494d1f2848fc602d18816fed808a981aedf4f1f00ceb7c9d32cf"
- dependencies = [
- "base64",
- "blake2b_simd",
- "crossbeam-utils 0.6.6",
- ]
-
- [[package]]
- name = "rustc-demangle"
- version = "0.1.16"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783"
++version = "0.6.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- version = "1.4.37"
++checksum = "b5eb417147ba9860a96cfe72a0b93bf88fee1744b5636ec99ab20c1aa9376581"
+
+[[package]]
+name = "rustc-workspace-hack"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc71d2faa173b74b232dedc235e3ee1696581bb132fc116fa3626d6151a1a8fb"
+
+[[package]]
+name = "rustfmt-config_proc_macro"
+version = "0.2.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "rustfmt-nightly"
- version = "0.9.0"
++version = "1.4.38"
+dependencies = [
+ "annotate-snippets",
+ "anyhow",
+ "bytecount",
+ "cargo_metadata",
+ "derive-new",
+ "diff",
+ "dirs",
+ "env_logger",
+ "getopts",
+ "ignore",
+ "itertools",
+ "lazy_static",
+ "log",
+ "regex",
+ "rustc-workspace-hack",
+ "rustfmt-config_proc_macro",
+ "serde",
+ "serde_json",
+ "structopt",
+ "term",
+ "thiserror",
+ "toml",
+ "unicode-segmentation",
+ "unicode-width",
+ "unicode_categories",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa8506c1de11c9c4e4c38863ccbe02a305c8188e85a05a784c9e11e1c3910c8"
+
+[[package]]
+name = "same-file"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585e8ddcedc187886a30fa705c47985c3fa88d06624095856b36ca0b82ff4421"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "semver"
- checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
++version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- "semver-parser",
++checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012"
+dependencies = [
- [[package]]
- name = "semver-parser"
- version = "0.7.0"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-
+ "serde",
+]
+
- version = "1.0.101"
+[[package]]
+name = "serde"
- checksum = "9796c9b7ba2ffe7a9ce53c2287dfc48080f4b2b362fcc245a259b3a7201119dd"
++version = "1.0.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- version = "1.0.101"
++checksum = "ec7505abeacaec74ae4778d9d9328fe5a5d04253220a85c4ee022239fc996d03"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
- checksum = "4b133a43a1ecd55d4086bd5b4dc6c1751c68b1bfbeba7a5040442022c7e7c02e"
++version = "1.0.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- version = "1.0.41"
++checksum = "963a7dbc9895aeac7ac90e74f34a5d5261828f79df35cbed41e10189d3804d43"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
- checksum = "2f72eb2a68a7dc3f9a691bfda9305a1c017a6215e5a4545c258500d2099a37c2"
++version = "1.0.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- version = "1.0.11"
++checksum = "dcac07dbffa1c65e7f816ab9eba78eb142c6d44410f4eeba1e26e4f5dfa56b95"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
+[[package]]
+name = "structopt"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fe43617218c0805c6eb37160119dc3c548110a67786da7218d1c6555212f073"
+dependencies = [
+ "clap",
+ "lazy_static",
+ "structopt-derive",
+]
+
+[[package]]
+name = "structopt-derive"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6e79c80e0f4efd86ca960218d4e056249be189ff1c42824dcd9a7f51a56f0bd"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
- checksum = "dff0acdb207ae2fe6d5976617f887eb1e35a2ba52c13c7234c790960cdad9238"
++version = "1.0.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
- [[package]]
- name = "synstructure"
- version = "0.12.1"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "3f085a5855930c0441ca1288cf044ea4aecf4f43a91668abdb870b4ba546a203"
- dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "unicode-xid",
- ]
-
++checksum = "f3a1d708c221c5a612956ef9f75b37e454e88d1f7b899fbd3a18d4252012d663"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "syn-mid"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7be3539f6c128a931cf19dcee741c1af532c7fd387baa739c03dd2e96479338a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
- [[package]]
- name = "thread_local"
- version = "0.3.6"
- source = "registry+https://github.com/rust-lang/crates.io-index"
- checksum = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
- dependencies = [
- "lazy_static",
- ]
-
+[[package]]
+name = "term"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0863a3345e70f61d613eab32ee046ccd1bcc5f9105fe402c61fcd0c13eeb8b5"
+dependencies = [
+ "dirs",
+ "winapi",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96d6098003bde162e4277c70665bd87c326f5a0c3f3fbfb285787fa482d54e6e"
+dependencies = [
+ "wincolor",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc6b305ec0e323c7b6cfff6098a22516e0063d0bb7c3d88660a890217dca099a"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45ba8d810d9c48fc456b7ad54574e8bfb7c7918a57ad7a6e6a0985d7959e8597"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7aabe75941d914b72bf3e5d3932ed92ce0664d49d8432305a8b547c37227724"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1967f4cdfc355b37fd76d2a954fb2ed3871034eb4f26d60537d88795cfc332a9"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7007dbd421b92cc6e28410fe7362e2e0a2503394908f417b68ec8d1c364c4e20"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
+
+[[package]]
+name = "unicode_categories"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
+
+[[package]]
+name = "vec_map"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
+
+[[package]]
+name = "version_check"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "078775d0255232fb988e6fccf26ddc9d1ac274299aaedcedce21c6f72cc533ce"
+
+[[package]]
+name = "walkdir"
+version = "2.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9658c94fa8b940eab2250bd5a457f9c48b748420d71293b165c8cdbe2f55f71e"
+dependencies = [
+ "same-file",
+ "winapi",
+ "winapi-util",
+]
+
++[[package]]
++name = "wasi"
++version = "0.10.2+wasi-snapshot-preview1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
++
+[[package]]
+name = "winapi"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "wincolor"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96f5016b18804d24db43cebf3c77269e7569b8954a8464501c216cc5e070eaa9"
+dependencies = [
+ "winapi",
+ "winapi-util",
+]
+
+[[package]]
+name = "yansi-term"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe5c30ade05e61656247b2e334a031dfd0cc466fadef865bdcdea8d537951bf1"
+dependencies = [
+ "winapi",
+]
--- /dev/null
- version = "1.4.37"
+[package]
+
+name = "rustfmt-nightly"
- itertools = "0.8"
++version = "1.4.38"
+description = "Tool to find and fix Rust formatting issues"
+repository = "https://github.com/rust-lang/rustfmt"
+readme = "README.md"
+license = "Apache-2.0/MIT"
+build = "build.rs"
+categories = ["development-tools"]
+edition = "2021"
+
+[[bin]]
+name = "rustfmt"
+path = "src/bin/main.rs"
+
+[[bin]]
+name = "cargo-fmt"
+path = "src/cargo-fmt/main.rs"
+
+[[bin]]
+name = "rustfmt-format-diff"
+path = "src/format-diff/main.rs"
+
+[[bin]]
+name = "git-rustfmt"
+path = "src/git-rustfmt/main.rs"
+
+[features]
+default = ["cargo-fmt", "rustfmt-format-diff"]
+cargo-fmt = []
+rustfmt-format-diff = []
+generic-simd = ["bytecount/generic-simd"]
+
+[dependencies]
- env_logger = "0.6"
++itertools = "0.9"
+toml = "0.5"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+unicode-segmentation = "1.0.0"
+regex = "1.0"
+term = "0.6"
+diff = "0.1"
+log = "0.4.14"
- cargo_metadata = "0.8"
++env_logger = "0.8"
+getopts = "0.2"
+derive-new = "0.5"
- ignore = "0.4.11"
++cargo_metadata = "0.14"
+bytecount = "0.6"
+unicode-width = "0.1.5"
+unicode_categories = "0.1.1"
+dirs = "2.0.1"
++ignore = "0.4.17"
+annotate-snippets = { version = "0.8", features = ["color"] }
+structopt = "0.3"
+rustfmt-config_proc_macro = { version = "0.2", path = "config_proc_macro" }
+lazy_static = "1.0.0"
+anyhow = "1.0"
+thiserror = "1.0"
+
+# A noop dependency that changes in the Rust repository, it's a bit of a hack.
+# See the `src/tools/rustc-workspace-hack/README.md` file in `rust-lang/rust`
+# for more information.
+rustc-workspace-hack = "1.0.0"
+
+# Rustc dependencies are loaded from the sysroot, Cargo doesn't know about them.
--- /dev/null
- Don't reformat anything
+# Configuring Rustfmt
+
+Rustfmt is designed to be very configurable. You can create a TOML file called `rustfmt.toml` or `.rustfmt.toml`, place it in the project or any other parent directory and it will apply the options in that file. If none of these directories contain such a file, both your home directory and a directory called `rustfmt` in your [global config directory](https://docs.rs/dirs/1.0.4/dirs/fn.config_dir.html) (e.g. `.config/rustfmt/`) are checked as well.
+
+A possible content of `rustfmt.toml` or `.rustfmt.toml` might look like this:
+
+```toml
+indent_style = "Block"
+reorder_imports = false
+```
+
+Each configuration option is either stable or unstable.
+Stable options can be used directly, while unstable options are opt-in.
+To enable unstable options, set `unstable_features = true` in `rustfmt.toml` or pass `--unstable-features` to rustfmt.
+
+# Configuration Options
+
+Below you find a detailed visual guide on all the supported configuration options of rustfmt:
+
+## `array_width`
+
+Maximum width of an array literal before falling back to vertical formatting.
+
+- **Default value**: `60`
+- **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
+- **Stable**: Yes
+
+By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `array_width` will take precedence.
+
+See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
+
+## `attr_fn_like_width`
+
+Maximum width of the args of a function-like attributes before falling back to vertical formatting.
+
+- **Default value**: `70`
+- **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
+- **Stable**: Yes
+
+By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `attr_fn_like_width` will take precedence.
+
+See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
+
+## `binop_separator`
+
+Where to put a binary operator when a binary expression goes multiline.
+
+- **Default value**: `"Front"`
+- **Possible values**: `"Front"`, `"Back"`
+- **Stable**: No (tracking issue: #3368)
+
+#### `"Front"` (default):
+
+```rust
+fn main() {
+ let or = foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo
+ || barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar;
+
+ let sum = 123456789012345678901234567890
+ + 123456789012345678901234567890
+ + 123456789012345678901234567890;
+
+ let range = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+ ..bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
+}
+```
+
+#### `"Back"`:
+
+```rust
+fn main() {
+ let or = foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo ||
+ barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar;
+
+ let sum = 123456789012345678901234567890 +
+ 123456789012345678901234567890 +
+ 123456789012345678901234567890;
+
+ let range = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
+}
+```
+
+## `blank_lines_lower_bound`
+
+Minimum number of blank lines which must be put between items. If two items have fewer blank lines between
+them, additional blank lines are inserted.
+
+- **Default value**: `0`
+- **Possible values**: *unsigned integer*
+- **Stable**: No (tracking issue: #3382)
+
+### Example
+Original Code (rustfmt will not change it with the default value of `0`):
+
+```rust
+#![rustfmt::skip]
+
+fn foo() {
+ println!("a");
+}
+fn bar() {
+ println!("b");
+ println!("c");
+}
+```
+
+#### `1`
+```rust
+fn foo() {
+
+ println!("a");
+}
+
+fn bar() {
+
+ println!("b");
+
+ println!("c");
+}
+```
+
+
+## `blank_lines_upper_bound`
+
+Maximum number of blank lines which can be put between items. If more than this number of consecutive empty
+lines are found, they are trimmed down to match this integer.
+
+- **Default value**: `1`
+- **Possible values**: any non-negative integer
+- **Stable**: No (tracking issue: #3381)
+
+### Example
+Original Code:
+
+```rust
+#![rustfmt::skip]
+
+fn foo() {
+ println!("a");
+}
+
+
+
+fn bar() {
+ println!("b");
+
+
+ println!("c");
+}
+```
+
+#### `1` (default):
+```rust
+fn foo() {
+ println!("a");
+}
+
+fn bar() {
+ println!("b");
+
+ println!("c");
+}
+```
+
+#### `2`:
+```rust
+fn foo() {
+ println!("a");
+}
+
+
+fn bar() {
+ println!("b");
+
+
+ println!("c");
+}
+```
+
+See also: [`blank_lines_lower_bound`](#blank_lines_lower_bound)
+
+## `brace_style`
+
+Brace style for items
+
+- **Default value**: `"SameLineWhere"`
+- **Possible values**: `"AlwaysNextLine"`, `"PreferSameLine"`, `"SameLineWhere"`
+- **Stable**: No (tracking issue: #3376)
+
+### Functions
+
+#### `"SameLineWhere"` (default):
+
+```rust
+fn lorem() {
+ // body
+}
+
+fn lorem(ipsum: usize) {
+ // body
+}
+
+fn lorem<T>(ipsum: T)
+where
+ T: Add + Sub + Mul + Div,
+{
+ // body
+}
+```
+
+#### `"AlwaysNextLine"`:
+
+```rust
+fn lorem()
+{
+ // body
+}
+
+fn lorem(ipsum: usize)
+{
+ // body
+}
+
+fn lorem<T>(ipsum: T)
+where
+ T: Add + Sub + Mul + Div,
+{
+ // body
+}
+```
+
+#### `"PreferSameLine"`:
+
+```rust
+fn lorem() {
+ // body
+}
+
+fn lorem(ipsum: usize) {
+ // body
+}
+
+fn lorem<T>(ipsum: T)
+where
+ T: Add + Sub + Mul + Div, {
+ // body
+}
+```
+
+### Structs and enums
+
+#### `"SameLineWhere"` (default):
+
+```rust
+struct Lorem {
+ ipsum: bool,
+}
+
+struct Dolor<T>
+where
+ T: Eq,
+{
+ sit: T,
+}
+```
+
+#### `"AlwaysNextLine"`:
+
+```rust
+struct Lorem
+{
+ ipsum: bool,
+}
+
+struct Dolor<T>
+where
+ T: Eq,
+{
+ sit: T,
+}
+```
+
+#### `"PreferSameLine"`:
+
+```rust
+struct Lorem {
+ ipsum: bool,
+}
+
+struct Dolor<T>
+where
+ T: Eq, {
+ sit: T,
+}
+```
+
+## `chain_width`
+
+Maximum width of a chain to fit on one line.
+
+- **Default value**: `60`
+- **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
+- **Stable**: Yes
+
+By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `chain_width` will take precedence.
+
+See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
+
+## `color`
+
+Whether to use colored output or not.
+
+- **Default value**: `"Auto"`
+- **Possible values**: "Auto", "Always", "Never"
+- **Stable**: No (tracking issue: #3385)
+
+## `combine_control_expr`
+
+Combine control expressions with function calls.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3369)
+
+#### `true` (default):
+
+```rust
+fn example() {
+ // If
+ foo!(if x {
+ foo();
+ } else {
+ bar();
+ });
+
+ // IfLet
+ foo!(if let Some(..) = x {
+ foo();
+ } else {
+ bar();
+ });
+
+ // While
+ foo!(while x {
+ foo();
+ bar();
+ });
+
+ // WhileLet
+ foo!(while let Some(..) = x {
+ foo();
+ bar();
+ });
+
+ // ForLoop
+ foo!(for x in y {
+ foo();
+ bar();
+ });
+
+ // Loop
+ foo!(loop {
+ foo();
+ bar();
+ });
+}
+```
+
+#### `false`:
+
+```rust
+fn example() {
+ // If
+ foo!(
+ if x {
+ foo();
+ } else {
+ bar();
+ }
+ );
+
+ // IfLet
+ foo!(
+ if let Some(..) = x {
+ foo();
+ } else {
+ bar();
+ }
+ );
+
+ // While
+ foo!(
+ while x {
+ foo();
+ bar();
+ }
+ );
+
+ // WhileLet
+ foo!(
+ while let Some(..) = x {
+ foo();
+ bar();
+ }
+ );
+
+ // ForLoop
+ foo!(
+ for x in y {
+ foo();
+ bar();
+ }
+ );
+
+ // Loop
+ foo!(
+ loop {
+ foo();
+ bar();
+ }
+ );
+}
+```
+
+## `comment_width`
+
+Maximum length of comments. No effect unless`wrap_comments = true`.
+
+- **Default value**: `80`
+- **Possible values**: any positive integer
+- **Stable**: No (tracking issue: #3349)
+
+**Note:** A value of `0` results in [`wrap_comments`](#wrap_comments) being applied regardless of a line's width.
+
+#### `80` (default; comments shorter than `comment_width`):
+```rust
+// Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+```
+
+#### `60` (comments longer than `comment_width`):
+```rust
+// Lorem ipsum dolor sit amet,
+// consectetur adipiscing elit.
+```
+
+See also [`wrap_comments`](#wrap_comments).
+
+## `condense_wildcard_suffixes`
+
+Replace strings of _ wildcards by a single .. in tuple patterns
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3384)
+
+#### `false` (default):
+
+```rust
+fn main() {
+ let (lorem, ipsum, _, _) = (1, 2, 3, 4);
+ let (lorem, ipsum, ..) = (1, 2, 3, 4);
+}
+```
+
+#### `true`:
+
+```rust
+fn main() {
+ let (lorem, ipsum, ..) = (1, 2, 3, 4);
+}
+```
+
+## `control_brace_style`
+
+Brace style for control flow constructs
+
+- **Default value**: `"AlwaysSameLine"`
+- **Possible values**: `"AlwaysNextLine"`, `"AlwaysSameLine"`, `"ClosingNextLine"`
+- **Stable**: No (tracking issue: #3377)
+
+#### `"AlwaysSameLine"` (default):
+
+```rust
+fn main() {
+ if lorem {
+ println!("ipsum!");
+ } else {
+ println!("dolor!");
+ }
+}
+```
+
+#### `"AlwaysNextLine"`:
+
+```rust
+fn main() {
+ if lorem
+ {
+ println!("ipsum!");
+ }
+ else
+ {
+ println!("dolor!");
+ }
+}
+```
+
+#### `"ClosingNextLine"`:
+
+```rust
+fn main() {
+ if lorem {
+ println!("ipsum!");
+ }
+ else {
+ println!("dolor!");
+ }
+}
+```
+
+## `disable_all_formatting`
+
- - **Stable**: No (tracking issue: #3388)
++Don't reformat anything.
++
++Note that this option may be soft-deprecated in the future once the [ignore](#ignore) option is stabilized. Nightly toolchain users are encouraged to use [ignore](#ignore) instead when possible.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
- - **Stable**: No (tracking issue: #3380)
++- **Stable**: Yes
+
+## `edition`
+
+Specifies which edition is used by the parser.
+
+- **Default value**: `"2015"`
+- **Possible values**: `"2015"`, `"2018"`, `"2021"`
+- **Stable**: Yes
+
+Rustfmt is able to pick up the edition used by reading the `Cargo.toml` file if executed
+through the Cargo's formatting tool `cargo fmt`. Otherwise, the edition needs to be specified
+in your config file:
+
+```toml
+edition = "2018"
+```
+
+## `empty_item_single_line`
+
+Put empty-body functions and impls on a single line
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3356)
+
+#### `true` (default):
+
+```rust
+fn lorem() {}
+
+impl Lorem {}
+```
+
+#### `false`:
+
+```rust
+fn lorem() {
+}
+
+impl Lorem {
+}
+```
+
+See also [`brace_style`](#brace_style), [`control_brace_style`](#control_brace_style).
+
+
+## `enum_discrim_align_threshold`
+
+The maximum length of enum variant having discriminant, that gets vertically aligned with others.
+Variants without discriminants would be ignored for the purpose of alignment.
+
+Note that this is not how much whitespace is inserted, but instead the longest variant name that
+doesn't get ignored when aligning.
+
+- **Default value** : 0
+- **Possible values**: any positive integer
+- **Stable**: No (tracking issue: #3372)
+
+#### `0` (default):
+
+```rust
+enum Bar {
+ A = 0,
+ Bb = 1,
+ RandomLongVariantGoesHere = 10,
+ Ccc = 71,
+}
+
+enum Bar {
+ VeryLongVariantNameHereA = 0,
+ VeryLongVariantNameHereBb = 1,
+ VeryLongVariantNameHereCcc = 2,
+}
+```
+
+#### `20`:
+
+```rust
+enum Foo {
+ A = 0,
+ Bb = 1,
+ RandomLongVariantGoesHere = 10,
+ Ccc = 2,
+}
+
+enum Bar {
+ VeryLongVariantNameHereA = 0,
+ VeryLongVariantNameHereBb = 1,
+ VeryLongVariantNameHereCcc = 2,
+}
+```
+
+
+## `error_on_line_overflow`
+
+Error if Rustfmt is unable to get all lines within `max_width`, except for comments and string
+literals. If this happens, then it is a bug in Rustfmt. You might be able to work around the bug by
+refactoring your code to avoid long/complex expressions, usually by extracting a local variable or
+using a shorter name.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3391)
+
+See also [`max_width`](#max_width).
+
+## `error_on_unformatted`
+
+Error if unable to get comments or string literals within `max_width`, or they are left with
+trailing whitespaces.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3392)
+
+## `fn_args_layout`
+
+Control the layout of arguments in a function
+
+- **Default value**: `"Tall"`
+- **Possible values**: `"Compressed"`, `"Tall"`, `"Vertical"`
+- **Stable**: Yes
+
+#### `"Tall"` (default):
+
+```rust
+trait Lorem {
+ fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet);
+
+ fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet) {
+ // body
+ }
+
+ fn lorem(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ consectetur: Consectetur,
+ adipiscing: Adipiscing,
+ elit: Elit,
+ );
+
+ fn lorem(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ consectetur: Consectetur,
+ adipiscing: Adipiscing,
+ elit: Elit,
+ ) {
+ // body
+ }
+}
+```
+
+#### `"Compressed"`:
+
+```rust
+trait Lorem {
+ fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet);
+
+ fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet) {
+ // body
+ }
+
+ fn lorem(
+ ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
+ adipiscing: Adipiscing, elit: Elit,
+ );
+
+ fn lorem(
+ ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
+ adipiscing: Adipiscing, elit: Elit,
+ ) {
+ // body
+ }
+}
+```
+
+#### `"Vertical"`:
+
+```rust
+trait Lorem {
+ fn lorem(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ );
+
+ fn lorem(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ ) {
+ // body
+ }
+
+ fn lorem(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ consectetur: Consectetur,
+ adipiscing: Adipiscing,
+ elit: Elit,
+ );
+
+ fn lorem(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ consectetur: Consectetur,
+ adipiscing: Adipiscing,
+ elit: Elit,
+ ) {
+ // body
+ }
+}
+```
+
+## `fn_call_width`
+
+Maximum width of the args of a function call before falling back to vertical formatting.
+
+- **Default value**: `60`
+- **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
+- **Stable**: Yes
+
+By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `fn_call_width` will take precedence.
+
+See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
+
+## `fn_single_line`
+
+Put single-expression functions on a single line
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3358)
+
+#### `false` (default):
+
+```rust
+fn lorem() -> usize {
+ 42
+}
+
+fn lorem() -> usize {
+ let ipsum = 42;
+ ipsum
+}
+```
+
+#### `true`:
+
+```rust
+fn lorem() -> usize { 42 }
+
+fn lorem() -> usize {
+ let ipsum = 42;
+ ipsum
+}
+```
+
+See also [`control_brace_style`](#control_brace_style).
+
+
+## `force_explicit_abi`
+
+Always print the abi for extern items
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: Yes
+
+**Note:** Non-"C" ABIs are always printed. If `false` then "C" is removed.
+
+#### `true` (default):
+
+```rust
+extern "C" {
+ pub static lorem: c_int;
+}
+```
+
+#### `false`:
+
+```rust
+extern {
+ pub static lorem: c_int;
+}
+```
+
+## `force_multiline_blocks`
+
+Force multiline closure and match arm bodies to be wrapped in a block
+
+- **Default value**: `false`
+- **Possible values**: `false`, `true`
+- **Stable**: No (tracking issue: #3374)
+
+#### `false` (default):
+
+```rust
+fn main() {
+ result.and_then(|maybe_value| match maybe_value {
+ None => foo(),
+ Some(value) => bar(),
+ });
+
+ match lorem {
+ None => |ipsum| {
+ println!("Hello World");
+ },
+ Some(dolor) => foo(),
+ }
+}
+```
+
+#### `true`:
+
+```rust
+fn main() {
+ result.and_then(|maybe_value| {
+ match maybe_value {
+ None => foo(),
+ Some(value) => bar(),
+ }
+ });
+
+ match lorem {
+ None => {
+ |ipsum| {
+ println!("Hello World");
+ }
+ }
+ Some(dolor) => foo(),
+ }
+}
+```
+
+
+## `format_code_in_doc_comments`
+
+Format code snippet included in doc comments.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3348)
+
+#### `false` (default):
+
+```rust
+/// Adds one to the number given.
+///
+/// # Examples
+///
+/// ```rust
+/// let five=5;
+///
+/// assert_eq!(
+/// 6,
+/// add_one(5)
+/// );
+/// # fn add_one(x: i32) -> i32 {
+/// # x + 1
+/// # }
+/// ```
+fn add_one(x: i32) -> i32 {
+ x + 1
+}
+```
+
+#### `true`
+
+```rust
+/// Adds one to the number given.
+///
+/// # Examples
+///
+/// ```rust
+/// let five = 5;
+///
+/// assert_eq!(6, add_one(5));
+/// # fn add_one(x: i32) -> i32 {
+/// # x + 1
+/// # }
+/// ```
+fn add_one(x: i32) -> i32 {
+ x + 1
+}
+```
+
++## `format_generated_files`
++
++Format generated files. A file is considered generated
++if any of the first five lines contains `@generated` marker.
++
++- **Default value**: `false`
++- **Possible values**: `true`, `false`
++- **Stable**: No
++
+## `format_macro_matchers`
+
+Format the metavariable matching patterns in macros.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3354)
+
+#### `false` (default):
+
+```rust
+macro_rules! foo {
+ ($a: ident : $b: ty) => {
+ $a(42): $b;
+ };
+ ($a: ident $b: ident $c: ident) => {
+ $a = $b + $c;
+ };
+}
+```
+
+#### `true`:
+
+```rust
+macro_rules! foo {
+ ($a:ident : $b:ty) => {
+ $a(42): $b;
+ };
+ ($a:ident $b:ident $c:ident) => {
+ $a = $b + $c;
+ };
+}
+```
+
+See also [`format_macro_bodies`](#format_macro_bodies).
+
+
+## `format_macro_bodies`
+
+Format the bodies of macros.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3355)
+
+#### `true` (default):
+
+```rust
+macro_rules! foo {
+ ($a: ident : $b: ty) => {
+ $a(42): $b;
+ };
+ ($a: ident $b: ident $c: ident) => {
+ $a = $b + $c;
+ };
+}
+```
+
+#### `false`:
+
+```rust
+macro_rules! foo {
+ ($a: ident : $b: ty) => { $a(42): $b; };
+ ($a: ident $b: ident $c: ident) => { $a=$b+$c; };
+}
+```
+
+See also [`format_macro_matchers`](#format_macro_matchers).
+
+
+## `format_strings`
+
+Format string literals where necessary
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3353)
+
+#### `false` (default):
+
+```rust
+fn main() {
+ let lorem = "ipsum dolor sit amet consectetur adipiscing elit lorem ipsum dolor sit amet consectetur adipiscing";
+}
+```
+
+#### `true`:
+
+```rust
+fn main() {
+ let lorem = "ipsum dolor sit amet consectetur adipiscing elit lorem ipsum dolor sit amet \
+ consectetur adipiscing";
+}
+```
+
+See also [`max_width`](#max_width).
+
+## `hard_tabs`
+
+Use tab characters for indentation, spaces for alignment
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: Yes
+
+#### `false` (default):
+
+```rust
+fn lorem() -> usize {
+ 42 // spaces before 42
+}
+```
+
+#### `true`:
+
+```rust
+fn lorem() -> usize {
+ 42 // tabs before 42
+}
+```
+
+See also: [`tab_spaces`](#tab_spaces).
+
++## `hex_literal_case`
++
++Control the case of the letters in hexadecimal literal values
++
++- **Default value**: `Preserve`
++- **Possible values**: `Upper`, `Lower`
++- **Stable**: No
+
+## `hide_parse_errors`
+
+Do not show parse errors if the parser failed to parse files.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3390)
+
+## `ignore`
+
+Skip formatting files and directories that match the specified pattern.
+The pattern format is the same as [.gitignore](https://git-scm.com/docs/gitignore#_pattern_format). Be sure to use Unix/forwardslash `/` style paths. This path style will work on all platforms. Windows style paths with backslashes `\` are not supported.
+
+- **Default value**: format every file
+- **Possible values**: See an example below
+- **Stable**: No (tracking issue: #3395)
+
+### Example
+
+If you want to ignore specific files, put the following to your config file:
+
+```toml
+ignore = [
+ "src/types.rs",
+ "src/foo/bar.rs",
+]
+```
+
+If you want to ignore every file under `examples/`, put the following to your config file:
+
+```toml
+ignore = [
+ "examples",
+]
+```
+
+If you want to ignore every file under the directory where you put your rustfmt.toml:
+
+```toml
+ignore = ["/"]
+```
+
+## `imports_indent`
+
+Indent style of imports
+
+- **Default Value**: `"Block"`
+- **Possible values**: `"Block"`, `"Visual"`
+- **Stable**: No (tracking issue: #3360)
+
+#### `"Block"` (default):
+
+```rust
+use foo::{
+ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,
+ zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
+};
+```
+
+#### `"Visual"`:
+
+```rust
+use foo::{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,
+ zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz};
+```
+
+See also: [`imports_layout`](#imports_layout).
+
+## `imports_layout`
+
+Item layout inside a imports block
+
+- **Default value**: "Mixed"
+- **Possible values**: "Horizontal", "HorizontalVertical", "Mixed", "Vertical"
+- **Stable**: No (tracking issue: #3361)
+
+#### `"Mixed"` (default):
+
+```rust
+use foo::{xxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzzzz};
+
+use foo::{
+ aaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbb, cccccccccccccccccc, dddddddddddddddddd,
+ eeeeeeeeeeeeeeeeee, ffffffffffffffffff,
+};
+```
+
+#### `"Horizontal"`:
+
+**Note**: This option forces all imports onto one line and may exceed `max_width`.
+
+```rust
+use foo::{xxx, yyy, zzz};
+
+use foo::{aaa, bbb, ccc, ddd, eee, fff};
+```
+
+#### `"HorizontalVertical"`:
+
+```rust
+use foo::{xxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzzzz};
+
+use foo::{
+ aaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbb,
+ cccccccccccccccccc,
+ dddddddddddddddddd,
+ eeeeeeeeeeeeeeeeee,
+ ffffffffffffffffff,
+};
+```
+
+#### `"Vertical"`:
+
+```rust
+use foo::{
+ xxx,
+ yyy,
+ zzz,
+};
+
+use foo::{
+ aaa,
+ bbb,
+ ccc,
+ ddd,
+ eee,
+ fff,
+};
+```
+
+## `indent_style`
+
+Indent on expressions or items.
+
+- **Default value**: `"Block"`
+- **Possible values**: `"Block"`, `"Visual"`
+- **Stable**: No (tracking issue: #3346)
+
+### Array
+
+#### `"Block"` (default):
+
+```rust
+fn main() {
+ let lorem = vec![
+ "ipsum",
+ "dolor",
+ "sit",
+ "amet",
+ "consectetur",
+ "adipiscing",
+ "elit",
+ ];
+}
+```
+
+#### `"Visual"`:
+
+```rust
+fn main() {
+ let lorem = vec!["ipsum",
+ "dolor",
+ "sit",
+ "amet",
+ "consectetur",
+ "adipiscing",
+ "elit"];
+}
+```
+
+### Control flow
+
+#### `"Block"` (default):
+
+```rust
+fn main() {
+ if lorem_ipsum
+ && dolor_sit
+ && amet_consectetur
+ && lorem_sit
+ && dolor_consectetur
+ && amet_ipsum
+ && lorem_consectetur
+ {
+ // ...
+ }
+}
+```
+
+#### `"Visual"`:
+
+```rust
+fn main() {
+ if lorem_ipsum
+ && dolor_sit
+ && amet_consectetur
+ && lorem_sit
+ && dolor_consectetur
+ && amet_ipsum
+ && lorem_consectetur
+ {
+ // ...
+ }
+}
+```
+
+See also: [`control_brace_style`](#control_brace_style).
+
+### Function arguments
+
+#### `"Block"` (default):
+
+```rust
+fn lorem() {}
+
+fn lorem(ipsum: usize) {}
+
+fn lorem(
+ ipsum: usize,
+ dolor: usize,
+ sit: usize,
+ amet: usize,
+ consectetur: usize,
+ adipiscing: usize,
+ elit: usize,
+) {
+ // body
+}
+```
+
+#### `"Visual"`:
+
+```rust
+fn lorem() {}
+
+fn lorem(ipsum: usize) {}
+
+fn lorem(ipsum: usize,
+ dolor: usize,
+ sit: usize,
+ amet: usize,
+ consectetur: usize,
+ adipiscing: usize,
+ elit: usize) {
+ // body
+}
+```
+
+### Function calls
+
+#### `"Block"` (default):
+
+```rust
+fn main() {
+ lorem(
+ "lorem",
+ "ipsum",
+ "dolor",
+ "sit",
+ "amet",
+ "consectetur",
+ "adipiscing",
+ "elit",
+ );
+}
+```
+
+#### `"Visual"`:
+
+```rust
+fn main() {
+ lorem("lorem",
+ "ipsum",
+ "dolor",
+ "sit",
+ "amet",
+ "consectetur",
+ "adipiscing",
+ "elit");
+}
+```
+
+### Generics
+
+#### `"Block"` (default):
+
+```rust
+fn lorem<
+ Ipsum: Eq = usize,
+ Dolor: Eq = usize,
+ Sit: Eq = usize,
+ Amet: Eq = usize,
+ Adipiscing: Eq = usize,
+ Consectetur: Eq = usize,
+ Elit: Eq = usize,
+>(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ adipiscing: Adipiscing,
+ consectetur: Consectetur,
+ elit: Elit,
+) -> T {
+ // body
+}
+```
+
+#### `"Visual"`:
+
+```rust
+fn lorem<Ipsum: Eq = usize,
+ Dolor: Eq = usize,
+ Sit: Eq = usize,
+ Amet: Eq = usize,
+ Adipiscing: Eq = usize,
+ Consectetur: Eq = usize,
+ Elit: Eq = usize>(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ adipiscing: Adipiscing,
+ consectetur: Consectetur,
+ elit: Elit)
+ -> T {
+ // body
+}
+```
+
+#### Struct
+
+#### `"Block"` (default):
+
+```rust
+fn main() {
+ let lorem = Lorem {
+ ipsum: dolor,
+ sit: amet,
+ };
+}
+```
+
+#### `"Visual"`:
+
+```rust
+fn main() {
+ let lorem = Lorem { ipsum: dolor,
+ sit: amet };
+}
+```
+
+See also: [`struct_lit_single_line`](#struct_lit_single_line), [`indent_style`](#indent_style).
+
+### Where predicates
+
+#### `"Block"` (default):
+
+```rust
+fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
+where
+ Ipsum: Eq,
+ Dolor: Eq,
+ Sit: Eq,
+ Amet: Eq,
+{
+ // body
+}
+```
+
+#### `"Visual"`:
+
+```rust
+fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
+ where Ipsum: Eq,
+ Dolor: Eq,
+ Sit: Eq,
+ Amet: Eq
+{
+ // body
+}
+```
+
+## `inline_attribute_width`
+
+Write an item and its attribute on the same line if their combined width is below a threshold
+
+- **Default value**: 0
+- **Possible values**: any positive integer
+- **Stable**: No (tracking issue: #3343)
+
+### Example
+
+#### `0` (default):
+```rust
+#[cfg(feature = "alloc")]
+use core::slice;
+```
+
+#### `50`:
+```rust
+#[cfg(feature = "alloc")] use core::slice;
+```
+
+## `license_template_path`
+
+Check whether beginnings of files match a license template.
+
+- **Default value**: `""`
+- **Possible values**: path to a license template file
+- **Stable**: No (tracking issue: #3352)
+
+A license template is a plain text file which is matched literally against the
+beginning of each source file, except for `{}`-delimited blocks, which are
+matched as regular expressions. The following license template therefore
+matches strings like `// Copyright 2017 The Rust Project Developers.`, `//
+Copyright 2018 The Rust Project Developers.`, etc.:
+
+```
+// Copyright {\d+} The Rust Project Developers.
+```
+
+`\{`, `\}` and `\\` match literal braces / backslashes.
+
+## `match_arm_blocks`
+
+Controls whether arm bodies are wrapped in cases where the first line of the body cannot fit on the same line as the `=>` operator.
+
+The Style Guide requires that bodies are block wrapped by default if a line break is required after the `=>`, but this option can be used to disable that behavior to prevent wrapping arm bodies in that event, so long as the body does not contain multiple statements nor line comments.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3373)
+
+#### `true` (default):
+
+```rust
+fn main() {
+ match lorem {
+ ipsum => {
+ foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x)
+ }
+ dolor => println!("{}", sit),
+ sit => foo(
+ "foooooooooooooooooooooooo",
+ "baaaaaaaaaaaaaaaaaaaaaaaarr",
+ "baaaaaaaaaaaaaaaaaaaazzzzzzzzzzzzz",
+ "qqqqqqqqquuuuuuuuuuuuuuuuuuuuuuuuuuxxx",
+ ),
+ }
+}
+```
+
+#### `false`:
+
+```rust
+fn main() {
+ match lorem {
+ lorem =>
+ foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x),
+ ipsum => println!("{}", sit),
+ sit => foo(
+ "foooooooooooooooooooooooo",
+ "baaaaaaaaaaaaaaaaaaaaaaaarr",
+ "baaaaaaaaaaaaaaaaaaaazzzzzzzzzzzzz",
+ "qqqqqqqqquuuuuuuuuuuuuuuuuuuuuuuuuuxxx",
+ ),
+ }
+}
+```
+
+See also: [`match_block_trailing_comma`](#match_block_trailing_comma).
+
+## `match_arm_leading_pipes`
+
+Controls whether to include a leading pipe on match arms
+
+- **Default value**: `Never`
+- **Possible values**: `Always`, `Never`, `Preserve`
+- **Stable**: Yes
+
+#### `Never` (default):
+```rust
+// Leading pipes are removed from this:
+// fn foo() {
+// match foo {
+// | "foo" | "bar" => {}
+// | "baz"
+// | "something relatively long"
+// | "something really really really realllllllllllllly long" => println!("x"),
+// | "qux" => println!("y"),
+// _ => {}
+// }
+// }
+
+// Becomes
+fn foo() {
+ match foo {
+ "foo" | "bar" => {}
+ "baz"
+ | "something relatively long"
+ | "something really really really realllllllllllllly long" => println!("x"),
+ "qux" => println!("y"),
+ _ => {}
+ }
+}
+```
+
+#### `Always`:
+```rust
+// Leading pipes are emitted on all arms of this:
+// fn foo() {
+// match foo {
+// "foo" | "bar" => {}
+// "baz"
+// | "something relatively long"
+// | "something really really really realllllllllllllly long" => println!("x"),
+// "qux" => println!("y"),
+// _ => {}
+// }
+// }
+
+// Becomes:
+fn foo() {
+ match foo {
+ | "foo" | "bar" => {}
+ | "baz"
+ | "something relatively long"
+ | "something really really really realllllllllllllly long" => println!("x"),
+ | "qux" => println!("y"),
+ | _ => {}
+ }
+}
+```
+
+#### `Preserve`:
+```rust
+fn foo() {
+ match foo {
+ | "foo" | "bar" => {}
+ | "baz"
+ | "something relatively long"
+ | "something really really really realllllllllllllly long" => println!("x"),
+ | "qux" => println!("y"),
+ _ => {}
+ }
+
+ match baz {
+ "qux" => {}
+ "foo" | "bar" => {}
+ _ => {}
+ }
+}
+```
+
+## `match_block_trailing_comma`
+
+Put a trailing comma after a block based match arm (non-block arms are not affected)
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
- - **Possible values**: `Preserve`, `Crate`, `Module`, `Item`
++- **Stable**: Yes
+
+#### `false` (default):
+
+```rust
+fn main() {
+ match lorem {
+ Lorem::Ipsum => {
+ println!("ipsum");
+ }
+ Lorem::Dolor => println!("dolor"),
+ }
+}
+```
+
+#### `true`:
+
+```rust
+fn main() {
+ match lorem {
+ Lorem::Ipsum => {
+ println!("ipsum");
+ },
+ Lorem::Dolor => println!("dolor"),
+ }
+}
+```
+
+See also: [`trailing_comma`](#trailing_comma), [`match_arm_blocks`](#match_arm_blocks).
+
+## `max_width`
+
+Maximum width of each line
+
+- **Default value**: `100`
+- **Possible values**: any positive integer
+- **Stable**: Yes
+
+See also [`error_on_line_overflow`](#error_on_line_overflow).
+
+## `merge_derives`
+
+Merge multiple derives into a single one.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: Yes
+
+#### `true` (default):
+
+```rust
+#[derive(Eq, PartialEq, Debug, Copy, Clone)]
+pub enum Foo {}
+```
+
+#### `false`:
+
+```rust
++#[derive(Eq, PartialEq, Debug, Copy, Clone)]
++pub enum Bar {}
++
+#[derive(Eq, PartialEq)]
+#[derive(Debug)]
+#[derive(Copy, Clone)]
+pub enum Foo {}
+```
+
+## `imports_granularity`
+
+How imports should be grouped into `use` statements. Imports will be merged or split to the configured level of granularity.
+
+- **Default value**: `Preserve`
- let a = Foo { x: x, y: y, z: z };
++- **Possible values**: `Preserve`, `Crate`, `Module`, `Item`, `One`
+- **Stable**: No
+
+#### `Preserve` (default):
+
+Do not change the granularity of any imports and preserve the original structure written by the developer.
+
+```rust
+use foo::b;
+use foo::b::{f, g};
+use foo::{a, c, d::e};
+use qux::{h, i};
+```
+
+#### `Crate`:
+
+Merge imports from the same crate into a single `use` statement. Conversely, imports from different crates are split into separate statements.
+
+```rust
+use foo::{
+ a, b,
+ b::{f, g},
+ c,
+ d::e,
+};
+use qux::{h, i};
+```
+
+#### `Module`:
+
+Merge imports from the same module into a single `use` statement. Conversely, imports from different modules are split into separate statements.
+
+```rust
+use foo::b::{f, g};
+use foo::d::e;
+use foo::{a, b, c};
+use qux::{h, i};
+```
+
+#### `Item`:
+
+Flatten imports so that each has its own `use` statement.
+
+```rust
+use foo::a;
+use foo::b;
+use foo::b::f;
+use foo::b::g;
+use foo::c;
+use foo::d::e;
+use qux::h;
+use qux::i;
+```
+
++#### `One`:
++
++Merge all imports into a single `use` statement as long as they have the same visibility.
++
++```rust
++pub use foo::{x, y};
++use {
++ bar::{
++ a,
++ b::{self, f, g},
++ c,
++ d::e,
++ },
++ qux::{h, i},
++};
++```
++
+## `merge_imports`
+
+This option is deprecated. Use `imports_granularity = "Crate"` instead.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+
+#### `false` (default):
+
+```rust
+use foo::{a, c, d};
+use foo::{b, g};
+use foo::{e, f};
+```
+
+#### `true`:
+
+```rust
+use foo::{a, b, c, d, e, f, g};
+```
+
+
+## `newline_style`
+
+Unix or Windows line endings
+
+- **Default value**: `"Auto"`
+- **Possible values**: `"Auto"`, `"Native"`, `"Unix"`, `"Windows"`
+- **Stable**: Yes
+
+#### `Auto` (default):
+
+The newline style is detected automatically on a per-file basis. Files
+with mixed line endings will be converted to the first detected line
+ending style.
+
+#### `Native`
+
+Line endings will be converted to `\r\n` on Windows and `\n` on all
+other platforms.
+
+#### `Unix`
+
+Line endings will be converted to `\n`.
+
+#### `Windows`
+
+Line endings will be converted to `\r\n`.
+
+## `normalize_comments`
+
+Convert /* */ comments to // comments where possible
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3350)
+
+#### `false` (default):
+
+```rust
+// Lorem ipsum:
+fn dolor() -> usize {}
+
+/* sit amet: */
+fn adipiscing() -> usize {}
+```
+
+#### `true`:
+
+```rust
+// Lorem ipsum:
+fn dolor() -> usize {}
+
+// sit amet:
+fn adipiscing() -> usize {}
+```
+
+## `normalize_doc_attributes`
+
+Convert `#![doc]` and `#[doc]` attributes to `//!` and `///` doc comments.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3351)
+
+#### `false` (default):
+
+```rust
+#![doc = "Example documentation"]
+
+#[doc = "Example item documentation"]
++pub enum Bar {}
++
++/// Example item documentation
+pub enum Foo {}
+```
+
+#### `true`:
+
+```rust
+//! Example documentation
+
+/// Example item documentation
+pub enum Foo {}
+```
+
+## `overflow_delimited_expr`
+
+When structs, slices, arrays, and block/array-like macros are used as the last
+argument in an expression list, allow them to overflow (like blocks/closures)
+instead of being indented on a new line.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3370)
+
+#### `false` (default):
+
+```rust
+fn example() {
+ foo(ctx, |param| {
+ action();
+ foo(param)
+ });
+
+ foo(
+ ctx,
+ Bar {
+ x: value,
+ y: value2,
+ },
+ );
+
+ foo(
+ ctx,
+ &[
+ MAROON_TOMATOES,
+ PURPLE_POTATOES,
+ ORGANE_ORANGES,
+ GREEN_PEARS,
+ RED_APPLES,
+ ],
+ );
+
+ foo(
+ ctx,
+ vec![
+ MAROON_TOMATOES,
+ PURPLE_POTATOES,
+ ORGANE_ORANGES,
+ GREEN_PEARS,
+ RED_APPLES,
+ ],
+ );
+}
+```
+
+#### `true`:
+
+```rust
+fn example() {
+ foo(ctx, |param| {
+ action();
+ foo(param)
+ });
+
+ foo(ctx, Bar {
+ x: value,
+ y: value2,
+ });
+
+ foo(ctx, &[
+ MAROON_TOMATOES,
+ PURPLE_POTATOES,
+ ORGANE_ORANGES,
+ GREEN_PEARS,
+ RED_APPLES,
+ ]);
+
+ foo(ctx, vec![
+ MAROON_TOMATOES,
+ PURPLE_POTATOES,
+ ORGANE_ORANGES,
+ GREEN_PEARS,
+ RED_APPLES,
+ ]);
+}
+```
+
+## `remove_nested_parens`
+
+Remove nested parens.
+
+- **Default value**: `true`,
+- **Possible values**: `true`, `false`
+- **Stable**: Yes
+
+
+#### `true` (default):
+```rust
+fn main() {
+ (foo());
+}
+```
+
+#### `false`:
+```rust
+fn main() {
++ (foo());
++
+ ((((foo()))));
+}
+```
+
+
+## `reorder_impl_items`
+
+Reorder impl items. `type` and `const` are put first, then macros and methods.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3363)
+
+#### `false` (default)
+
+```rust
+struct Dummy;
+
+impl Iterator for Dummy {
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+
+ type Item = i32;
+}
++
++impl Iterator for Dummy {
++ type Item = i32;
++
++ fn next(&mut self) -> Option<Self::Item> {
++ None
++ }
++}
+```
+
+#### `true`
+
+```rust
+struct Dummy;
+
+impl Iterator for Dummy {
+ type Item = i32;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+```
+
+## `reorder_imports`
+
+Reorder import and extern crate statements alphabetically in groups (a group is
+separated by a newline).
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: Yes
+
+#### `true` (default):
+
+```rust
+use dolor;
+use ipsum;
+use lorem;
+use sit;
+```
+
+#### `false`:
+
+```rust
+use lorem;
+use ipsum;
+use dolor;
+use sit;
+```
+
+## `group_imports`
+
+Controls the strategy for how imports are grouped together.
+
+- **Default value**: `Preserve`
+- **Possible values**: `Preserve`, `StdExternalCrate`
+- **Stable**: No
+
+#### `Preserve` (default):
+
+Preserve the source file's import groups.
+
+```rust
+use super::update::convert_publish_payload;
+use chrono::Utc;
+
+use alloc::alloc::Layout;
+use juniper::{FieldError, FieldResult};
+use uuid::Uuid;
+
+use std::sync::Arc;
+
+use broker::database::PooledConnection;
+
+use super::schema::{Context, Payload};
+use crate::models::Event;
+use core::f32;
+```
+
+#### `StdExternalCrate`:
+
+Discard existing import groups, and create three groups for:
+1. `std`, `core` and `alloc`,
+2. external crates,
+3. `self`, `super` and `crate` imports.
+
+```rust
+use alloc::alloc::Layout;
+use core::f32;
+use std::sync::Arc;
+
+use broker::database::PooledConnection;
+use chrono::Utc;
+use juniper::{FieldError, FieldResult};
+use uuid::Uuid;
+
+use super::schema::{Context, Payload};
+use super::update::convert_publish_payload;
+use crate::models::Event;
+```
+
+## `reorder_modules`
+
+Reorder `mod` declarations alphabetically in group.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: Yes
+
+#### `true` (default)
+
+```rust
+mod a;
+mod b;
+
+mod dolor;
+mod ipsum;
+mod lorem;
+mod sit;
+```
+
+#### `false`
+
+```rust
+mod b;
+mod a;
+
+mod lorem;
+mod ipsum;
+mod dolor;
+mod sit;
+```
+
+**Note** `mod` with `#[macro_export]` will not be reordered since that could change the semantics
+of the original source code.
+
+## `report_fixme`
+
+Report `FIXME` items in comments.
+
+- **Default value**: `"Never"`
+- **Possible values**: `"Always"`, `"Unnumbered"`, `"Never"`
+- **Stable**: No (tracking issue: #3394)
+
+Warns about any comments containing `FIXME` in them when set to `"Always"`. If
+it contains a `#X` (with `X` being a number) in parentheses following the
+`FIXME`, `"Unnumbered"` will ignore it.
+
+See also [`report_todo`](#report_todo).
+
+
+## `report_todo`
+
+Report `TODO` items in comments.
+
+- **Default value**: `"Never"`
+- **Possible values**: `"Always"`, `"Unnumbered"`, `"Never"`
+- **Stable**: No (tracking issue: #3393)
+
+Warns about any comments containing `TODO` in them when set to `"Always"`. If
+it contains a `#X` (with `X` being a number) in parentheses following the
+`TODO`, `"Unnumbered"` will ignore it.
+
+See also [`report_fixme`](#report_fixme).
+
+## `required_version`
+
+Require a specific version of rustfmt. If you want to make sure that the
+specific version of rustfmt is used in your CI, use this option.
+
+- **Default value**: `CARGO_PKG_VERSION`
+- **Possible values**: any published version (e.g. `"0.3.8"`)
+- **Stable**: No (tracking issue: #3386)
+
+## `skip_children`
+
+Don't reformat out of line modules
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3389)
+
+## `single_line_if_else_max_width`
+
+Maximum line length for single line if-else expressions. A value of `0` (zero) results in if-else expressions always being broken into multiple lines. Note this occurs when `use_small_heuristics` is set to `Off`.
+
+- **Default value**: `50`
+- **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
+- **Stable**: Yes
+
+By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `single_line_if_else_max_width` will take precedence.
+
+See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
+
+## `space_after_colon`
+
+Leave a space after the colon.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3366)
+
+#### `true` (default):
+
+```rust
+fn lorem<T: Eq>(t: T) {
+ let lorem: Dolor = Lorem {
+ ipsum: dolor,
+ sit: amet,
+ };
+}
+```
+
+#### `false`:
+
+```rust
+fn lorem<T:Eq>(t:T) {
+ let lorem:Dolor = Lorem {
+ ipsum:dolor,
+ sit:amet,
+ };
+}
+```
+
+See also: [`space_before_colon`](#space_before_colon).
+
+## `space_before_colon`
+
+Leave a space before the colon.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3365)
+
+#### `false` (default):
+
+```rust
+fn lorem<T: Eq>(t: T) {
+ let lorem: Dolor = Lorem {
+ ipsum: dolor,
+ sit: amet,
+ };
+}
+```
+
+#### `true`:
+
+```rust
+fn lorem<T : Eq>(t : T) {
+ let lorem : Dolor = Lorem {
+ ipsum : dolor,
+ sit : amet,
+ };
+}
+```
+
+See also: [`space_after_colon`](#space_after_colon).
+
+## `spaces_around_ranges`
+
+Put spaces around the .., ..=, and ... range operators
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3367)
+
+#### `false` (default):
+
+```rust
+fn main() {
+ let lorem = 0..10;
+ let ipsum = 0..=10;
+
+ match lorem {
+ 1..5 => foo(),
+ _ => bar,
+ }
+
+ match lorem {
+ 1..=5 => foo(),
+ _ => bar,
+ }
+
+ match lorem {
+ 1...5 => foo(),
+ _ => bar,
+ }
+}
+```
+
+#### `true`:
+
+```rust
+fn main() {
+ let lorem = 0 .. 10;
+ let ipsum = 0 ..= 10;
+
+ match lorem {
+ 1 .. 5 => foo(),
+ _ => bar,
+ }
+
+ match lorem {
+ 1 ..= 5 => foo(),
+ _ => bar,
+ }
+
+ match lorem {
+ 1 ... 5 => foo(),
+ _ => bar,
+ }
+}
+```
+
+## `struct_field_align_threshold`
+
+The maximum diff of width between struct fields to be aligned with each other.
+
+- **Default value** : 0
+- **Possible values**: any non-negative integer
+- **Stable**: No (tracking issue: #3371)
+
+#### `0` (default):
+
+```rust
+struct Foo {
+ x: u32,
+ yy: u32,
+ zzz: u32,
+}
+```
+
+#### `20`:
+
+```rust
+struct Foo {
+ x: u32,
+ yy: u32,
+ zzz: u32,
+}
+```
+
+## `struct_lit_single_line`
+
+Put small struct literals on a single line
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3357)
+
+#### `true` (default):
+
+```rust
+fn main() {
+ let lorem = Lorem { foo: bar, baz: ofo };
+}
+```
+
+#### `false`:
+
+```rust
+fn main() {
+ let lorem = Lorem {
+ foo: bar,
+ baz: ofo,
+ };
+}
+```
+
+See also: [`indent_style`](#indent_style).
+
+## `struct_lit_width`
+
+Maximum width in the body of a struct literal before falling back to vertical formatting. A value of `0` (zero) results in struct literals always being broken into multiple lines. Note this occurs when `use_small_heuristics` is set to `Off`.
+
+- **Default value**: `18`
+- **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
+- **Stable**: Yes
+
+By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `struct_lit_width` will take precedence.
+
+See also [`max_width`](#max_width), [`use_small_heuristics`](#use_small_heuristics), and [`struct_lit_single_line`](#struct_lit_single_line)
+
+## `struct_variant_width`
+
+Maximum width in the body of a struct variant before falling back to vertical formatting. A value of `0` (zero) results in struct literals always being broken into multiple lines. Note this occurs when `use_small_heuristics` is set to `Off`.
+
+- **Default value**: `35`
+- **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
+- **Stable**: Yes
+
+By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `struct_variant_width` will take precedence.
+
+See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
+
+## `tab_spaces`
+
+Number of spaces per tab
+
+- **Default value**: `4`
+- **Possible values**: any positive integer
+- **Stable**: Yes
+
+#### `4` (default):
+
+```rust
+fn lorem() {
+ let ipsum = dolor();
+ let sit = vec![
+ "amet consectetur adipiscing elit amet",
+ "consectetur adipiscing elit amet consectetur.",
+ ];
+}
+```
+
+#### `2`:
+
+```rust
+fn lorem() {
+ let ipsum = dolor();
+ let sit = vec![
+ "amet consectetur adipiscing elit amet",
+ "consectetur adipiscing elit amet consectetur.",
+ ];
+}
+```
+
+See also: [`hard_tabs`](#hard_tabs).
+
+
+## `trailing_comma`
+
+How to handle trailing commas for lists
+
+- **Default value**: `"Vertical"`
+- **Possible values**: `"Always"`, `"Never"`, `"Vertical"`
+- **Stable**: No (tracking issue: #3379)
+
+#### `"Vertical"` (default):
+
+```rust
+fn main() {
+ let Lorem { ipsum, dolor, sit } = amet;
+ let Lorem {
+ ipsum,
+ dolor,
+ sit,
+ amet,
+ consectetur,
+ adipiscing,
+ } = elit;
+}
+```
+
+#### `"Always"`:
+
+```rust
+fn main() {
+ let Lorem { ipsum, dolor, sit, } = amet;
+ let Lorem {
+ ipsum,
+ dolor,
+ sit,
+ amet,
+ consectetur,
+ adipiscing,
+ } = elit;
+}
+```
+
+#### `"Never"`:
+
+```rust
+fn main() {
+ let Lorem { ipsum, dolor, sit } = amet;
+ let Lorem {
+ ipsum,
+ dolor,
+ sit,
+ amet,
+ consectetur,
+ adipiscing
+ } = elit;
+}
+```
+
+See also: [`match_block_trailing_comma`](#match_block_trailing_comma).
+
+## `trailing_semicolon`
+
+Add trailing semicolon after break, continue and return
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3378)
+
+#### `true` (default):
+```rust
+fn foo() -> usize {
+ return 0;
+}
+```
+
+#### `false`:
+```rust
+fn foo() -> usize {
+ return 0
+}
+```
+
+## `type_punctuation_density`
+
+Determines if `+` or `=` are wrapped in spaces in the punctuation of types
+
+- **Default value**: `"Wide"`
+- **Possible values**: `"Compressed"`, `"Wide"`
+- **Stable**: No (tracking issue: #3364)
+
+#### `"Wide"` (default):
+
+```rust
+fn lorem<Ipsum: Dolor + Sit = Amet>() {
+ // body
+}
+```
+
+#### `"Compressed"`:
+
+```rust
+fn lorem<Ipsum: Dolor+Sit=Amet>() {
+ // body
+}
+```
+
+## `unstable_features`
+
+Enable unstable features on the unstable channel.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3387)
+
+## `use_field_init_shorthand`
+
+Use field initialize shorthand if possible.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: Yes
+
+#### `false` (default):
+
+```rust
+struct Foo {
+ x: u32,
+ y: u32,
+ z: u32,
+}
+
+fn main() {
+ let x = 1;
+ let y = 2;
+ let z = 3;
++ let a = Foo { x, y, z };
++ let b = Foo { x: x, y: y, z: z };
+}
+```
+
+#### `true`:
+
+```rust
+struct Foo {
+ x: u32,
+ y: u32,
+ z: u32,
+}
+
+fn main() {
+ let x = 1;
+ let y = 2;
+ let z = 3;
+ let a = Foo { x, y, z };
+}
+```
+
+## `use_small_heuristics`
+
+This option can be used to simplify the management and bulk updates of the granular width configuration settings ([`fn_call_width`](#fn_call_width), [`attr_fn_like_width`](#attr_fn_like_width), [`struct_lit_width`](#struct_lit_width), [`struct_variant_width`](#struct_variant_width), [`array_width`](#array_width), [`chain_width`](#chain_width), [`single_line_if_else_max_width`](#single_line_if_else_max_width)), that respectively control when formatted constructs are multi-lined/vertical based on width.
+
+Note that explicitly provided values for the width configuration settings take precedence and override the calculated values determined by `use_small_heuristics`.
+
+- **Default value**: `"Default"`
+- **Possible values**: `"Default"`, `"Off"`, `"Max"`
+- **Stable**: Yes
+
+#### `Default` (default):
+When `use_small_heuristics` is set to `Default`, the values for the granular width settings are calculated as a ratio of the value for `max_width`.
+
+The ratios are:
+* [`fn_call_width`](#fn_call_width) - `60%`
+* [`attr_fn_like_width`](#attr_fn_like_width) - `70%`
+* [`struct_lit_width`](#struct_lit_width) - `18%`
+* [`struct_variant_width`](#struct_variant_width) - `35%`
+* [`array_width`](#array_width) - `60%`
+* [`chain_width`](#chain_width) - `60%`
+* [`single_line_if_else_max_width`](#single_line_if_else_max_width) - `50%`
+
+For example when `max_width` is set to `100`, the width settings are:
+* `fn_call_width=60`
+* `attr_fn_like_width=70`
+* `struct_lit_width=18`
+* `struct_variant_width=35`
+* `array_width=60`
+* `chain_width=60`
+* `single_line_if_else_max_width=50`
+
+and when `max_width` is set to `200`:
+* `fn_call_width=120`
+* `attr_fn_like_width=140`
+* `struct_lit_width=36`
+* `struct_variant_width=70`
+* `array_width=120`
+* `chain_width=120`
+* `single_line_if_else_max_width=100`
+
+```rust
+enum Lorem {
+ Ipsum,
+ Dolor(bool),
+ Sit { amet: Consectetur, adipiscing: Elit },
+}
+
+fn main() {
+ lorem(
+ "lorem",
+ "ipsum",
+ "dolor",
+ "sit",
+ "amet",
+ "consectetur",
+ "adipiscing",
+ );
+
+ let lorem = Lorem {
+ ipsum: dolor,
+ sit: amet,
+ };
+ let lorem = Lorem { ipsum: dolor };
+
+ let lorem = if ipsum { dolor } else { sit };
+}
+```
+
+#### `Off`:
+When `use_small_heuristics` is set to `Off`, the granular width settings are functionally disabled and ignored. See the documentation for the respective width config options for specifics.
+
+```rust
+enum Lorem {
+ Ipsum,
+ Dolor(bool),
+ Sit {
+ amet: Consectetur,
+ adipiscing: Elit,
+ },
+}
+
+fn main() {
+ lorem("lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing");
+
+ let lorem = Lorem {
+ ipsum: dolor,
+ sit: amet,
+ };
+
+ let lorem = if ipsum {
+ dolor
+ } else {
+ sit
+ };
+}
+```
+
+#### `Max`:
+When `use_small_heuristics` is set to `Max`, then each granular width setting is set to the same value as `max_width`.
+
+So if `max_width` is set to `200`, then all the width settings are also set to `200`.
+* `fn_call_width=200`
+* `attr_fn_like_width=200`
+* `struct_lit_width=200`
+* `struct_variant_width=200`
+* `array_width=200`
+* `chain_width=200`
+* `single_line_if_else_max_width=200`
+
+```rust
+enum Lorem {
+ Ipsum,
+ Dolor(bool),
+ Sit { amet: Consectetur, adipiscing: Elit },
+}
+
+fn main() {
+ lorem("lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing");
+
+ let lorem = Lorem { ipsum: dolor, sit: amet };
+
+ let lorem = if ipsum { dolor } else { sit };
+}
+```
+
+
+See also:
+* [`max_width`](#max_width)
+* [`fn_call_width`](#fn_call_width)
+* [`attr_fn_like_width`](#attr_fn_like_width)
+* [`struct_lit_width`](#struct_lit_width)
+* [`struct_variant_width`](#struct_variant_width)
+* [`array_width`](#array_width)
+* [`chain_width`](#chain_width)
+* [`single_line_if_else_max_width`](#single_line_if_else_max_width)
+
+## `use_try_shorthand`
+
+Replace uses of the try! macro by the ? shorthand
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: Yes
+
+#### `false` (default):
+
+```rust
+fn main() {
++ let lorem = ipsum.map(|dolor| dolor.sit())?;
++
+ let lorem = try!(ipsum.map(|dolor| dolor.sit()));
+}
+```
+
+#### `true`:
+
+```rust
+fn main() {
+ let lorem = ipsum.map(|dolor| dolor.sit())?;
+}
+```
+
+## `version`
+
+Which version of the formatting rules to use. `Version::One` is backwards-compatible
+with Rustfmt 1.0. Other versions are only backwards compatible within a major
+version number.
+
+- **Default value**: `One`
+- **Possible values**: `One`, `Two`
+- **Stable**: No (tracking issue: #3383)
+
+### Example
+
+```toml
+version = "Two"
+```
+
+## `where_single_line`
+
+Forces the `where` clause to be laid out on a single line.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3359)
+
+#### `false` (default):
+
+```rust
+impl<T> Lorem for T
+where
+ Option<T>: Ipsum,
+{
+ // body
+}
+```
+
+#### `true`:
+
+```rust
+impl<T> Lorem for T
+where Option<T>: Ipsum
+{
+ // body
+}
+```
+
+See also [`brace_style`](#brace_style), [`control_brace_style`](#control_brace_style).
+
+
+## `wrap_comments`
+
+Break comments to fit on the line
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: #3347)
+
+#### `false` (default):
+
+```rust
++// Lorem ipsum dolor sit amet, consectetur adipiscing elit,
++// sed do eiusmod tempor incididunt ut labore et dolore
++// magna aliqua. Ut enim ad minim veniam, quis nostrud
++// exercitation ullamco laboris nisi ut aliquip ex ea
++// commodo consequat.
++
+// Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+```
+
+#### `true`:
+
+```rust
+// Lorem ipsum dolor sit amet, consectetur adipiscing elit,
+// sed do eiusmod tempor incididunt ut labore et dolore
+// magna aliqua. Ut enim ad minim veniam, quis nostrud
+// exercitation ullamco laboris nisi ut aliquip ex ea
+// commodo consequat.
+```
+
+# Internal Options
+
+## `emit_mode`
+
+Internal option
+
+## `make_backup`
+
+Internal option, use `--backup`
+
+## `print_misformatted_file_names`
+
+Internal option, use `-l` or `--files-with-diff`
--- /dev/null
- # This is based on https://github.com/japaric/rust-everywhere/blob/master/appveyor.yml
- # and modified (mainly removal of deployment) to suit rustfmt.
-
+environment:
+ global:
+ PROJECT_NAME: rustfmt
- matrix:
- # Stable channel
- # - TARGET: i686-pc-windows-gnu
- # CHANNEL: stable
- # - TARGET: i686-pc-windows-msvc
- # CHANNEL: stable
- # - TARGET: x86_64-pc-windows-gnu
- # CHANNEL: stable
- # - TARGET: x86_64-pc-windows-msvc
- # CHANNEL: stable
- # Beta channel
- # - TARGET: i686-pc-windows-gnu
- # CHANNEL: beta
- # - TARGET: i686-pc-windows-msvc
- # CHANNEL: beta
- # - TARGET: x86_64-pc-windows-gnu
- # CHANNEL: beta
- # - TARGET: x86_64-pc-windows-msvc
- # CHANNEL: beta
- # Nightly channel
- - TARGET: i686-pc-windows-gnu
- CHANNEL: nightly
- - TARGET: i686-pc-windows-msvc
- CHANNEL: nightly
- - TARGET: x86_64-pc-windows-gnu
- CHANNEL: nightly
- - TARGET: x86_64-pc-windows-msvc
- CHANNEL: nightly
-
- # Install Rust and Cargo
- # (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
- install:
- - appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
- - if "%TARGET%" == "i686-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw32\bin
- - if "%TARGET%" == "x86_64-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw64\bin
- - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
- - rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
- - rustc -Vv
- - cargo -V
+
- # ???
+build: false
+
+test_script:
- - set CFG_RELEASE_CHANNEL=nightly
- - set CFG_RELEASE=nightly
- - cargo build --verbose
- - cargo test
- - cargo test -- --ignored
++ - echo Why does no one have access to delete me?
--- /dev/null
- const ConfigurationMdUrl = 'https://raw.githubusercontent.com/rust-lang/rustfmt/master/Configurations.md';
+<!doctype html>
+<html>
+ <head>
+ <meta name="viewport" content="width=device-width">
++ <title>Rustfmt</title>
+ <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/3.0.1/github-markdown.css" />
++ <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.0.0/styles/github-gist.min.css">
+ <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+ <script src="https://cdn.jsdelivr.net/npm/vue@2.6.10/dist/vue.js"></script>
++ <script src="https://unpkg.com/vue-async-computed@3.8.1"></script>
++ <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.0.0/highlight.min.js"></script>
+ <script src="https://cdnjs.cloudflare.com/ajax/libs/axios/0.18.0/axios.min.js"></script>
+ <style>
+ @media (max-width: 767px) {
+ .markdown-body {
+ padding: 15px;
+ }
+
+ #search {
+ max-width: 85%;
+ }
+ }
+ body {
+ overflow: scroll;
+ }
+ .markdown-body {
+ box-sizing: border-box;
+ min-width: 200px;
+ max-width: 980px;
+ margin: 0 auto;
+ padding: 45px;
+ }
+ #search {
+ border: 1px solid #d1d5da;
+ padding-left: 30px;
+ overflow: hidden;
+ }
+ .searchCondition {
+ display: flex;
+ flex-wrap: wrap;
+ }
+ .searchCondition > div {
+ margin-right: 30px;
+ }
++ .header-link {
++ position: relative;
++ }
++ .header-link:hover::before {
++ position: absolute;
++ left: -2em;
++ padding-right: 0.5em;
++ content: '\2002\00a7\2002';
++ }
+ </style>
+ </head>
+ <body>
+ <div id="app">
+ <article class="markdown-body">
+ <div class="searchCondition">
+ <div>
+ <form style="display:flex;">
+ <label for="search" style="margin-right: 3px;" >search:</label>
+ <div style="position: relative;">
+ <input id="search" placeholder="Search all options" v-model="searchCondition">
+ <svg style="position: absolute; left: 8px; top: 7px;" class="octicon octicon-search subnav-search-icon" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true">
+ <path fill-rule="evenodd" d="M15.7 13.3l-3.81-3.83A5.93 5.93 0 0 0 13 6c0-3.31-2.69-6-6-6S1 2.69 1 6s2.69 6 6 6c1.3 0 2.48-.41 3.47-1.11l3.83 3.81c.19.2.45.3.7.3.25 0 .52-.09.7-.3a.996.996 0 0 0 0-1.41v.01zM7 10.7c-2.59 0-4.7-2.11-4.7-4.7 0-2.59 2.11-4.7 4.7-4.7 2.59 0 4.7 2.11 4.7 4.7 0 2.59-2.11 4.7-4.7 4.7z"></path>
+ </svg>
+ </div>
+ </form>
+ </div>
+ <div>
+ <label for="stable">stable: </label>
+ <input type="checkbox" id="stable" v-model="shouldStable">
+ </div>
++ <div>
++ <label for="viewVersion">version: </label>
++ <select name="viewVersion" id="viewVersion" v-model="viewVersion">
++ <option v-for="option in versionOptions" v-bind:value="option">
++ {{ option }}
++ </option>
++ </select>
++ </div>
+ </div>
+ <div v-html="aboutHtml"></div>
+ <div v-html="configurationAboutHtml"></div>
+ <div v-html="outputHtml"></div>
+ </article>
+ </div>
+ <script>
- data() {
- const configurationDescriptions = [];
- configurationDescriptions.links = {};
- return {
- aboutHtml: '',
- configurationAboutHtml: '',
- searchCondition: UrlHash,
- configurationDescriptions,
- shouldStable: false
- }
++ const RusfmtTagsUrl = 'https://api.github.com/repos/rust-lang/rustfmt/tags';
++ const RustfmtLatestUrl = 'https://api.github.com/repos/rust-lang/rustfmt/releases/latest';
+ const UrlHash = window.location.hash.replace(/^#/, '');
++ const queryParams = new URLSearchParams(window.location.search);
++ const searchParam = queryParams.get('search');
++ const searchTerm = null !== searchParam ? searchParam : '';
++ const versionParam = queryParams.get('version');
++ const parseVersionParam = (version) => {
++ if (version === 'master') return 'master';
++ if (version.startsWith('v')) return version;
++ return `v${version}`;
++ };
++ const versionNumber = null !== versionParam ? parseVersionParam(versionParam) : 'master';
+ new Vue({
+ el: '#app',
- computed: {
- outputHtml() {
- const ast = this.configurationDescriptions
- .filter(({ head, text, stable }) => {
++ data: {
++ aboutHtml: '',
++ configurationAboutHtml: '',
++ configurationDescriptions: [],
++ searchCondition: searchTerm,
++ shouldStable: false,
++ viewVersion: versionNumber,
++ oldViewVersion: undefined,
++ versionOptions: ['master'],
++ scrolledOnce: false,
+ },
- if (
- text.includes(this.searchCondition) === false &&
- head.includes(this.searchCondition) === false
- ) {
- return false;
- }
- return (this.shouldStable)
- ? stable === true
- : true;
- })
- .reduce((stack, { value }) => {
- return stack.concat(value);
- }, []);
++ asyncComputed: {
++ async updateVersion() {
++ let latest;
++ try {
++ latest = (await axios.get(RustfmtLatestUrl)).data;
++ } catch(err) {
++ console.log(err);
++ return;
++ }
++ if (versionParam == null) {
++ this.viewVersion = latest.name;
++ }
++ },
++ async outputHtml() {
++ if (this.viewVersion !== this.oldViewVersion) {
++ const ConfigurationMdUrl =
++ `https://raw.githubusercontent.com/rust-lang/rustfmt/${this.viewVersion}/Configurations.md`;
++ let res;
++ try {
++ res = await axios.get(ConfigurationMdUrl).catch(e => { throw e });
++ } catch(e) {
++ this.handleReqFailure(e);
++ return;
++ }
++ const {
++ about,
++ configurationAbout,
++ configurationDescriptions
++ } = parseMarkdownAst(res.data);
++ this.aboutHtml = marked.parser(about);
++ this.configurationAboutHtml = marked.parser(configurationAbout);
++ this.configurationDescriptions = configurationDescriptions;
++ this.oldViewVersion = this.viewVersion;
++ }
+
- return marked.parser(ast);
++ const ast = this.configurationDescriptions
++ .filter(({ head, text, stable }) => {
++ if (text.includes(this.searchCondition) === false &&
++ head.includes(this.searchCondition) === false) {
++ return false;
++ }
++ return (this.shouldStable)
++ ? stable === true
++ : true;
++ })
++ .reduce((stack, { value }) => {
++ return stack.concat(value);
++ }, []);
+ ast.links = {};
- const res = await axios.get(ConfigurationMdUrl);
- const {
- about,
- configurationAbout,
- configurationDescriptions
- } = parseMarkdownAst(res.data);
- this.aboutHtml = marked.parser(about);
- this.configurationAboutHtml = marked.parser(configurationAbout);
- this.configurationDescriptions = configurationDescriptions;
++
++ queryParams.set('version', this.viewVersion);
++ queryParams.set('search', this.searchCondition);
++ const curUrl = window.location.pathname +
++ '?' + queryParams.toString() + window.location.hash;
++ history.pushState(null, '', curUrl);
++
++ const renderer = new marked.Renderer();
++ renderer.heading = function(text, level) {
++ const id = htmlToId(text);
++ return `<h${level}>
++ <a id="${id}" href="#${id}" name="${id}" class="header-link">${text}</a>
++ </h${level}>`;
++ };
++
++ return marked.parser(ast, {
++ highlight(code, lang) {
++ return hljs.highlight(lang ? lang : 'rust', code).value;
++ },
++ headerIds: true,
++ headerPrefix: '',
++ renderer,
++ });
+ }
+ },
+ created: async function() {
- mounted() {
++ let tags;
++ try {
++ tags = (await axios.get(RusfmtTagsUrl)).data;
++ } catch(e) {
++ this.handleReqFailure(e);
++ return;
++ }
++
++ const excludedTagVersions = new Set(['v0.7', 'v0.8.1']);
++
++ const tagOptions = tags
++ .map(tag => tag.name)
++ .filter(tag => tag.startsWith('v') && !excludedTagVersions.has(tag));
++ this.versionOptions = this.versionOptions.concat(tagOptions);
+ },
- const interval = setInterval(() => {
++ updated() {
+ if (UrlHash === '') return;
- if (target != null) {
++ this.$nextTick(() => {
+ const target = document.querySelector(`#${UrlHash}`);
- clearInterval(interval);
++ if (target != null && !this.scrolledOnce) {
+ target.scrollIntoView(true);
- }, 100);
++ this.scrolledOnce = true;
+ }
- return !!elem.text && elem.text.includes("**Stable**: Yes")
++ });
++ },
++ methods: {
++ handleReqFailure(e) {
++ if (e.response.status === 404) {
++ this.aboutHtml =
++ "<p>Failed to get configuration options for this version, please select the version from the dropdown above.</p>";
++ } else if (
++ e.response.status === 403 &&
++ e.response.headers["X-RateLimit-Remaining"] === 0
++ ) {
++ const resetDate = new Date(
++ e.response.headers['X-RateLimit-Reset'] * 1000
++ ).toLocaleString();
++ this.aboutHtml =
++ `<p>You have hit the GitHub API rate limit; documentation cannot be updated.` +
++ `<p>The rate limit will be reset at ${resetDate}.</p>`;
++ } else {
++ this.aboutHtml =
++ `<p>Ecountered an error when fetching documentation data:</p>` +
++ `<pre><code>${e.response.data}</code></pre>` +
++ `<p>We would appreciate <a href="https://github.com/rust-lang/rustfmt/issues/new?template=bug_report.md">a bug report</a>.` +
++ `<p>Try refreshing the page.</p>`;
++ }
++ }
+ }
+ });
+ const extractDepthOnes = (ast) => {
+ return ast.reduce((stack, next) => {
+ if (next.depth === 1) {
+ stack.push([]);
+ }
+ const lastIndex = stack.length - 1;
+ stack[lastIndex].push(next);
+ return stack;
+ }, []);
+ }
+ const extractDepthTwos = (ast) => {
+ return ast.map((elem) => {
+ return elem.reduce((stack, next) => {
+ if (next.depth === 2) {
+ stack.push([]);
+ }
+ const lastIndex = stack.length - 1;
+ stack[lastIndex].push(next);
+ return stack;
+ },
+ [[]]);
+ });
+ }
+ const createHeadAndValue = (ast) => {
+ return ast.map((elem) => {
+ return elem.map((val) => {
+ return {
+ head: val[0].text,
+ value: val,
+ stable: val.some((elem) => {
- </html>
++ return elem.type === "list" &&
++ !!elem.raw &&
++ elem.raw.includes("**Stable**: Yes");
+ }),
+ text: val.reduce((result, next) => {
+ return next.text != null
+ ? `${result} ${next.text}`
+ : result;
+ }, '')
+ }
+ });
+ })
+ }
+ const parseMarkdownAst = (rawMarkdown) => {
+ const ast = marked.lexer(rawMarkdown);
+ const depthOnes = extractDepthOnes(ast);
+ const depthTwos = extractDepthTwos(depthOnes);
+ const [
+ abouts, configurations
+ ] = createHeadAndValue(depthTwos);
+ const about = abouts[0].value;
+ about.links = {};
+ const [
+ configurationAbout, ...configurationDescriptions
+ ] = configurations;
+ configurationAbout.value.links = {};
+
+ return {
+ about,
+ configurationAbout: configurationAbout.value,
+ configurationDescriptions
+ };
+ }
++ function htmlToId(text) {
++ const tmpl = document.createElement('template');
++ tmpl.innerHTML = text.trim();
++ return encodeURIComponent(CSS.escape(tmpl.content.textContent));
++ }
+ </script>
+ </body>
++</html>
--- /dev/null
- channel = "nightly-2021-07-23"
+[toolchain]
++channel = "nightly-2021-10-20"
+components = ["rustc-dev"]
--- /dev/null
- attr.span.lo(),
+//! Format attributes and meta items.
+
+use rustc_ast::ast;
+use rustc_ast::AstLike;
+use rustc_span::{symbol::sym, Span, Symbol};
+
+use self::doc_comment::DocCommentFormatter;
+use crate::comment::{contains_comment, rewrite_doc_comment, CommentStyle};
+use crate::config::lists::*;
+use crate::config::IndentStyle;
+use crate::expr::rewrite_literal;
+use crate::lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
+use crate::overflow;
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::Shape;
++use crate::source_map::SpanUtils;
+use crate::types::{rewrite_path, PathContext};
+use crate::utils::{count_newlines, mk_sp};
+
+mod doc_comment;
+
+pub(crate) fn contains_name(attrs: &[ast::Attribute], name: Symbol) -> bool {
+ attrs.iter().any(|attr| attr.has_name(name))
+}
+
+pub(crate) fn first_attr_value_str_by_name(
+ attrs: &[ast::Attribute],
+ name: Symbol,
+) -> Option<Symbol> {
+ attrs
+ .iter()
+ .find(|attr| attr.has_name(name))
+ .and_then(|attr| attr.value_str())
+}
+
+/// Returns attributes on the given statement.
+pub(crate) fn get_attrs_from_stmt(stmt: &ast::Stmt) -> &[ast::Attribute] {
+ stmt.attrs()
+}
+
+pub(crate) fn get_span_without_attrs(stmt: &ast::Stmt) -> Span {
+ match stmt.kind {
+ ast::StmtKind::Local(ref local) => local.span,
+ ast::StmtKind::Item(ref item) => item.span,
+ ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => expr.span,
+ ast::StmtKind::MacCall(ref mac_stmt) => mac_stmt.mac.span(),
+ ast::StmtKind::Empty => stmt.span,
+ }
+}
+
+/// Returns attributes that are within `outer_span`.
+pub(crate) fn filter_inline_attrs(
+ attrs: &[ast::Attribute],
+ outer_span: Span,
+) -> Vec<ast::Attribute> {
+ attrs
+ .iter()
+ .filter(|a| outer_span.lo() <= a.span.lo() && a.span.hi() <= outer_span.hi())
+ .cloned()
+ .collect()
+}
+
+fn is_derive(attr: &ast::Attribute) -> bool {
+ attr.has_name(sym::derive)
+}
+
+// The shape of the arguments to a function-like attribute.
+fn argument_shape(
+ left: usize,
+ right: usize,
+ combine: bool,
+ shape: Shape,
+ context: &RewriteContext<'_>,
+) -> Option<Shape> {
+ match context.config.indent_style() {
+ IndentStyle::Block => {
+ if combine {
+ shape.offset_left(left)
+ } else {
+ Some(
+ shape
+ .block_indent(context.config.tab_spaces())
+ .with_max_width(context.config),
+ )
+ }
+ }
+ IndentStyle::Visual => shape
+ .visual_indent(0)
+ .shrink_left(left)
+ .and_then(|s| s.sub_width(right)),
+ }
+}
+
+fn format_derive(
+ derives: &[ast::Attribute],
+ shape: Shape,
+ context: &RewriteContext<'_>,
+) -> Option<String> {
+ // Collect all items from all attributes
+ let all_items = derives
+ .iter()
+ .map(|attr| {
+ // Parse the derive items and extract the span for each item; if any
+ // attribute is not parseable, none of the attributes will be
+ // reformatted.
+ let item_spans = attr.meta_item_list().map(|meta_item_list| {
+ meta_item_list
+ .into_iter()
+ .map(|nested_meta_item| nested_meta_item.span())
+ })?;
+
+ let items = itemize_list(
+ context.snippet_provider,
+ item_spans,
+ ")",
+ ",",
+ |span| span.lo(),
+ |span| span.hi(),
+ |span| Some(context.snippet(*span).to_owned()),
++ // We update derive attribute spans to start after the opening '('
++ // This helps us focus parsing to just what's inside #[derive(...)]
++ context.snippet_provider.span_after(attr.span, "("),
+ attr.span.hi(),
+ false,
+ );
+
+ Some(items)
+ })
+ // Fail if any attribute failed.
+ .collect::<Option<Vec<_>>>()?
+ // Collect the results into a single, flat, Vec.
+ .into_iter()
+ .flatten()
+ .collect::<Vec<_>>();
+
+ // Collect formatting parameters.
+ let prefix = attr_prefix(&derives[0]);
+ let argument_shape = argument_shape(
+ "[derive()]".len() + prefix.len(),
+ ")]".len(),
+ false,
+ shape,
+ context,
+ )?;
+ let one_line_shape = shape
+ .offset_left("[derive()]".len() + prefix.len())?
+ .sub_width("()]".len())?;
+ let one_line_budget = one_line_shape.width;
+
+ let tactic = definitive_tactic(
+ &all_items,
+ ListTactic::HorizontalVertical,
+ Separator::Comma,
+ argument_shape.width,
+ );
+ let trailing_separator = match context.config.indent_style() {
+ // We always add the trailing comma and remove it if it is not needed.
+ IndentStyle::Block => SeparatorTactic::Always,
+ IndentStyle::Visual => SeparatorTactic::Never,
+ };
+
+ // Format the collection of items.
+ let fmt = ListFormatting::new(argument_shape, context.config)
+ .tactic(tactic)
+ .trailing_separator(trailing_separator)
+ .ends_with_newline(false);
+ let item_str = write_list(&all_items, &fmt)?;
+
+ debug!("item_str: '{}'", item_str);
+
+ // Determine if the result will be nested, i.e. if we're using the block
+ // indent style and either the items are on multiple lines or we've exceeded
+ // our budget to fit on a single line.
+ let nested = context.config.indent_style() == IndentStyle::Block
+ && (item_str.contains('\n') || item_str.len() > one_line_budget);
+
+ // Format the final result.
+ let mut result = String::with_capacity(128);
+ result.push_str(prefix);
+ result.push_str("[derive(");
+ if nested {
+ let nested_indent = argument_shape.indent.to_string_with_newline(context.config);
+ result.push_str(&nested_indent);
+ result.push_str(&item_str);
+ result.push_str(&shape.indent.to_string_with_newline(context.config));
+ } else if let SeparatorTactic::Always = context.config.trailing_comma() {
+ // Retain the trailing comma.
+ result.push_str(&item_str);
+ } else if item_str.ends_with(',') {
+ // Remove the trailing comma.
+ result.push_str(&item_str[..item_str.len() - 1]);
+ } else {
+ result.push_str(&item_str);
+ }
+ result.push_str(")]");
+
+ Some(result)
+}
+
+/// Returns the first group of attributes that fills the given predicate.
+/// We consider two doc comments are in different group if they are separated by normal comments.
+fn take_while_with_pred<'a, P>(
+ context: &RewriteContext<'_>,
+ attrs: &'a [ast::Attribute],
+ pred: P,
+) -> &'a [ast::Attribute]
+where
+ P: Fn(&ast::Attribute) -> bool,
+{
+ let mut len = 0;
+ let mut iter = attrs.iter().peekable();
+
+ while let Some(attr) = iter.next() {
+ if pred(attr) {
+ len += 1;
+ } else {
+ break;
+ }
+ if let Some(next_attr) = iter.peek() {
+ // Extract comments between two attributes.
+ let span_between_attr = mk_sp(attr.span.hi(), next_attr.span.lo());
+ let snippet = context.snippet(span_between_attr);
+ if count_newlines(snippet) >= 2 || snippet.contains('/') {
+ break;
+ }
+ }
+ }
+
+ &attrs[..len]
+}
+
+/// Rewrite the any doc comments which come before any other attributes.
+fn rewrite_initial_doc_comments(
+ context: &RewriteContext<'_>,
+ attrs: &[ast::Attribute],
+ shape: Shape,
+) -> Option<(usize, Option<String>)> {
+ if attrs.is_empty() {
+ return Some((0, None));
+ }
+ // Rewrite doc comments
+ let sugared_docs = take_while_with_pred(context, attrs, |a| a.is_doc_comment());
+ if !sugared_docs.is_empty() {
+ let snippet = sugared_docs
+ .iter()
+ .map(|a| context.snippet(a.span))
+ .collect::<Vec<_>>()
+ .join("\n");
+ return Some((
+ sugared_docs.len(),
+ Some(rewrite_doc_comment(
+ &snippet,
+ shape.comment(context.config),
+ context.config,
+ )?),
+ ));
+ }
+
+ Some((0, None))
+}
+
+impl Rewrite for ast::NestedMetaItem {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match self {
+ ast::NestedMetaItem::MetaItem(ref meta_item) => meta_item.rewrite(context, shape),
+ ast::NestedMetaItem::Literal(ref l) => rewrite_literal(context, l, shape),
+ }
+ }
+}
+
+fn has_newlines_before_after_comment(comment: &str) -> (&str, &str) {
+ // Look at before and after comment and see if there are any empty lines.
+ let comment_begin = comment.find('/');
+ let len = comment_begin.unwrap_or_else(|| comment.len());
+ let mlb = count_newlines(&comment[..len]) > 1;
+ let mla = if comment_begin.is_none() {
+ mlb
+ } else {
+ comment
+ .chars()
+ .rev()
+ .take_while(|c| c.is_whitespace())
+ .filter(|&c| c == '\n')
+ .count()
+ > 1
+ };
+ (if mlb { "\n" } else { "" }, if mla { "\n" } else { "" })
+}
+
+impl Rewrite for ast::MetaItem {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ Some(match self.kind {
+ ast::MetaItemKind::Word => {
+ rewrite_path(context, PathContext::Type, None, &self.path, shape)?
+ }
+ ast::MetaItemKind::List(ref list) => {
+ let path = rewrite_path(context, PathContext::Type, None, &self.path, shape)?;
+ let has_trailing_comma = crate::expr::span_ends_with_comma(context, self.span);
+ overflow::rewrite_with_parens(
+ context,
+ &path,
+ list.iter(),
+ // 1 = "]"
+ shape.sub_width(1)?,
+ self.span,
+ context.config.attr_fn_like_width(),
+ Some(if has_trailing_comma {
+ SeparatorTactic::Always
+ } else {
+ SeparatorTactic::Never
+ }),
+ )?
+ }
+ ast::MetaItemKind::NameValue(ref literal) => {
+ let path = rewrite_path(context, PathContext::Type, None, &self.path, shape)?;
+ // 3 = ` = `
+ let lit_shape = shape.shrink_left(path.len() + 3)?;
+ // `rewrite_literal` returns `None` when `literal` exceeds max
+ // width. Since a literal is basically unformattable unless it
+ // is a string literal (and only if `format_strings` is set),
+ // we might be better off ignoring the fact that the attribute
+ // is longer than the max width and continue on formatting.
+ // See #2479 for example.
+ let value = rewrite_literal(context, literal, lit_shape)
+ .unwrap_or_else(|| context.snippet(literal.span).to_owned());
+ format!("{} = {}", path, value)
+ }
+ })
+ }
+}
+
+impl Rewrite for ast::Attribute {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ let snippet = context.snippet(self.span);
+ if self.is_doc_comment() {
+ rewrite_doc_comment(snippet, shape.comment(context.config), context.config)
+ } else {
+ let should_skip = self
+ .ident()
+ .map(|s| context.skip_context.skip_attribute(&s.name.as_str()))
+ .unwrap_or(false);
+ let prefix = attr_prefix(self);
+
+ if should_skip || contains_comment(snippet) {
+ return Some(snippet.to_owned());
+ }
+
+ if let Some(ref meta) = self.meta() {
+ // This attribute is possibly a doc attribute needing normalization to a doc comment
+ if context.config.normalize_doc_attributes() && meta.has_name(sym::doc) {
+ if let Some(ref literal) = meta.value_str() {
+ let comment_style = match self.style {
+ ast::AttrStyle::Inner => CommentStyle::Doc,
+ ast::AttrStyle::Outer => CommentStyle::TripleSlash,
+ };
+
+ let literal_str = literal.as_str();
+ let doc_comment_formatter =
+ DocCommentFormatter::new(&*literal_str, comment_style);
+ let doc_comment = format!("{}", doc_comment_formatter);
+ return rewrite_doc_comment(
+ &doc_comment,
+ shape.comment(context.config),
+ context.config,
+ );
+ }
+ }
+
+ // 1 = `[`
+ let shape = shape.offset_left(prefix.len() + 1)?;
+ Some(
+ meta.rewrite(context, shape)
+ .map_or_else(|| snippet.to_owned(), |rw| format!("{}[{}]", prefix, rw)),
+ )
+ } else {
+ Some(snippet.to_owned())
+ }
+ }
+ }
+}
+
+impl Rewrite for [ast::Attribute] {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ if self.is_empty() {
+ return Some(String::new());
+ }
+
+ // The current remaining attributes.
+ let mut attrs = self;
+ let mut result = String::new();
+
+ // This is not just a simple map because we need to handle doc comments
+ // (where we take as many doc comment attributes as possible) and possibly
+ // merging derives into a single attribute.
+ loop {
+ if attrs.is_empty() {
+ return Some(result);
+ }
+
+ // Handle doc comments.
+ let (doc_comment_len, doc_comment_str) =
+ rewrite_initial_doc_comments(context, attrs, shape)?;
+ if doc_comment_len > 0 {
+ let doc_comment_str = doc_comment_str.expect("doc comments, but no result");
+ result.push_str(&doc_comment_str);
+
+ let missing_span = attrs
+ .get(doc_comment_len)
+ .map(|next| mk_sp(attrs[doc_comment_len - 1].span.hi(), next.span.lo()));
+ if let Some(missing_span) = missing_span {
+ let snippet = context.snippet(missing_span);
+ let (mla, mlb) = has_newlines_before_after_comment(snippet);
+ let comment = crate::comment::recover_missing_comment_in_span(
+ missing_span,
+ shape.with_max_width(context.config),
+ context,
+ 0,
+ )?;
+ let comment = if comment.is_empty() {
+ format!("\n{}", mlb)
+ } else {
+ format!("{}{}\n{}", mla, comment, mlb)
+ };
+ result.push_str(&comment);
+ result.push_str(&shape.indent.to_string(context.config));
+ }
+
+ attrs = &attrs[doc_comment_len..];
+
+ continue;
+ }
+
+ // Handle derives if we will merge them.
+ if context.config.merge_derives() && is_derive(&attrs[0]) {
+ let derives = take_while_with_pred(context, attrs, is_derive);
+ let derive_str = format_derive(derives, shape, context)?;
+ result.push_str(&derive_str);
+
+ let missing_span = attrs
+ .get(derives.len())
+ .map(|next| mk_sp(attrs[derives.len() - 1].span.hi(), next.span.lo()));
+ if let Some(missing_span) = missing_span {
+ let comment = crate::comment::recover_missing_comment_in_span(
+ missing_span,
+ shape.with_max_width(context.config),
+ context,
+ 0,
+ )?;
+ result.push_str(&comment);
+ if let Some(next) = attrs.get(derives.len()) {
+ if next.is_doc_comment() {
+ let snippet = context.snippet(missing_span);
+ let (_, mlb) = has_newlines_before_after_comment(snippet);
+ result.push_str(&mlb);
+ }
+ }
+ result.push('\n');
+ result.push_str(&shape.indent.to_string(context.config));
+ }
+
+ attrs = &attrs[derives.len()..];
+
+ continue;
+ }
+
+ // If we get here, then we have a regular attribute, just handle one
+ // at a time.
+
+ let formatted_attr = attrs[0].rewrite(context, shape)?;
+ result.push_str(&formatted_attr);
+
+ let missing_span = attrs
+ .get(1)
+ .map(|next| mk_sp(attrs[0].span.hi(), next.span.lo()));
+ if let Some(missing_span) = missing_span {
+ let comment = crate::comment::recover_missing_comment_in_span(
+ missing_span,
+ shape.with_max_width(context.config),
+ context,
+ 0,
+ )?;
+ result.push_str(&comment);
+ if let Some(next) = attrs.get(1) {
+ if next.is_doc_comment() {
+ let snippet = context.snippet(missing_span);
+ let (_, mlb) = has_newlines_before_after_comment(snippet);
+ result.push_str(&mlb);
+ }
+ }
+ result.push('\n');
+ result.push_str(&shape.indent.to_string(context.config));
+ }
+
+ attrs = &attrs[1..];
+ }
+ }
+}
+
+fn attr_prefix(attr: &ast::Attribute) -> &'static str {
+ match attr.style {
+ ast::AttrStyle::Inner => "#!",
+ ast::AttrStyle::Outer => "#",
+ }
+}
+
+pub(crate) trait MetaVisitor<'ast> {
+ fn visit_meta_item(&mut self, meta_item: &'ast ast::MetaItem) {
+ match meta_item.kind {
+ ast::MetaItemKind::Word => self.visit_meta_word(meta_item),
+ ast::MetaItemKind::List(ref list) => self.visit_meta_list(meta_item, list),
+ ast::MetaItemKind::NameValue(ref lit) => self.visit_meta_name_value(meta_item, lit),
+ }
+ }
+
+ fn visit_meta_list(
+ &mut self,
+ _meta_item: &'ast ast::MetaItem,
+ list: &'ast [ast::NestedMetaItem],
+ ) {
+ for nm in list {
+ self.visit_nested_meta_item(nm);
+ }
+ }
+
+ fn visit_meta_word(&mut self, _meta_item: &'ast ast::MetaItem) {}
+
+ fn visit_meta_name_value(&mut self, _meta_item: &'ast ast::MetaItem, _lit: &'ast ast::Lit) {}
+
+ fn visit_nested_meta_item(&mut self, nm: &'ast ast::NestedMetaItem) {
+ match nm {
+ ast::NestedMetaItem::MetaItem(ref meta_item) => self.visit_meta_item(meta_item),
+ ast::NestedMetaItem::Literal(ref lit) => self.visit_literal(lit),
+ }
+ }
+
+ fn visit_literal(&mut self, _lit: &'ast ast::Lit) {}
+}
--- /dev/null
- opts.optopt("", "edition", "Rust edition to use", "[2015|2018]");
+use anyhow::{format_err, Result};
+
+use io::Error as IoError;
+use thiserror::Error;
+
+use rustfmt_nightly as rustfmt;
+
+use std::collections::HashMap;
+use std::env;
+use std::fs::File;
+use std::io::{self, stdout, Read, Write};
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+
+use getopts::{Matches, Options};
+
+use crate::rustfmt::{
+ load_config, CliOptions, Color, Config, Edition, EmitMode, FileLines, FileName,
+ FormatReportFormatterBuilder, Input, Session, Verbosity,
+};
+
+fn main() {
+ env_logger::init();
+ let opts = make_opts();
+
+ let exit_code = match execute(&opts) {
+ Ok(code) => code,
+ Err(e) => {
+ eprintln!("{}", e.to_string());
+ 1
+ }
+ };
+ // Make sure standard output is flushed before we exit.
+ std::io::stdout().flush().unwrap();
+
+ // Exit with given exit code.
+ //
+ // NOTE: this immediately terminates the process without doing any cleanup,
+ // so make sure to finish all necessary cleanup before this is called.
+ std::process::exit(exit_code);
+}
+
+/// Rustfmt operations.
+enum Operation {
+ /// Format files and their child modules.
+ Format {
+ files: Vec<PathBuf>,
+ minimal_config_path: Option<String>,
+ },
+ /// Print the help message.
+ Help(HelpOp),
+ /// Print version information
+ Version,
+ /// Output default config to a file, or stdout if None
+ ConfigOutputDefault { path: Option<String> },
+ /// Output current config (as if formatting to a file) to stdout
+ ConfigOutputCurrent { path: Option<String> },
+ /// No file specified, read from stdin
+ Stdin { input: String },
+}
+
+/// Rustfmt operations errors.
+#[derive(Error, Debug)]
+pub enum OperationError {
+ /// An unknown help topic was requested.
+ #[error("Unknown help topic: `{0}`.")]
+ UnknownHelpTopic(String),
+ /// An unknown print-config option was requested.
+ #[error("Unknown print-config option: `{0}`.")]
+ UnknownPrintConfigTopic(String),
+ /// Attempt to generate a minimal config from standard input.
+ #[error("The `--print-config=minimal` option doesn't work with standard input.")]
+ MinimalPathWithStdin,
+ /// An io error during reading or writing.
+ #[error("{0}")]
+ IoError(IoError),
+ /// Attempt to use --check with stdin, which isn't currently
+ /// supported.
+ #[error("The `--check` option is not supported with standard input.")]
+ CheckWithStdin,
+ /// Attempt to use --emit=json with stdin, which isn't currently
+ /// supported.
+ #[error("Using `--emit` other than stdout is not supported with standard input.")]
+ EmitWithStdin,
+}
+
+impl From<IoError> for OperationError {
+ fn from(e: IoError) -> OperationError {
+ OperationError::IoError(e)
+ }
+}
+
+/// Arguments to `--help`
+enum HelpOp {
+ None,
+ Config,
+ FileLines,
+}
+
+fn make_opts() -> Options {
+ let mut opts = Options::new();
+
+ opts.optflag(
+ "",
+ "check",
+ "Run in 'check' mode. Exits with 0 if input is formatted correctly. Exits \
+ with 1 and prints a diff if formatting is required.",
+ );
+ let is_nightly = is_nightly();
+ let emit_opts = if is_nightly {
+ "[files|stdout|coverage|checkstyle|json]"
+ } else {
+ "[files|stdout]"
+ };
+ opts.optopt("", "emit", "What data to emit and how", emit_opts);
+ opts.optflag("", "backup", "Backup any modified files.");
+ opts.optopt(
+ "",
+ "config-path",
+ "Recursively searches the given path for the rustfmt.toml config file. If not \
+ found reverts to the input file path",
+ "[Path for the configuration file]",
+ );
++ opts.optopt("", "edition", "Rust edition to use", "[2015|2018|2021]");
+ opts.optopt(
+ "",
+ "color",
+ "Use colored output (if supported)",
+ "[always|never|auto]",
+ );
+ opts.optopt(
+ "",
+ "print-config",
+ "Dumps a default or minimal config to PATH. A minimal config is the \
+ subset of the current config file used for formatting the current program. \
+ `current` writes to stdout current config as if formatting the file at PATH.",
+ "[default|minimal|current] PATH",
+ );
+ opts.optflag(
+ "l",
+ "files-with-diff",
+ "Prints the names of mismatched files that were formatted. Prints the names of \
+ files that would be formated when used with `--check` mode. ",
+ );
+ opts.optmulti(
+ "",
+ "config",
+ "Set options from command line. These settings take priority over .rustfmt.toml",
+ "[key1=val1,key2=val2...]",
+ );
+
+ if is_nightly {
+ opts.optflag(
+ "",
+ "unstable-features",
+ "Enables unstable features. Only available on nightly channel.",
+ );
+ opts.optopt(
+ "",
+ "file-lines",
+ "Format specified line ranges. Run with `--help=file-lines` for \
+ more detail (unstable).",
+ "JSON",
+ );
+ opts.optflag(
+ "",
+ "error-on-unformatted",
+ "Error if unable to get comments or string literals within max_width, \
+ or they are left with trailing whitespaces (unstable).",
+ );
+ opts.optflag(
+ "",
+ "skip-children",
+ "Don't reformat child modules (unstable).",
+ );
+ }
+
+ opts.optflag("v", "verbose", "Print verbose output");
+ opts.optflag("q", "quiet", "Print less output");
+ opts.optflag("V", "version", "Show version information");
+ let help_topics = if is_nightly {
+ "`config` or `file-lines`"
+ } else {
+ "`config`"
+ };
+ let mut help_topic_msg = "Show this message or help about a specific topic: ".to_owned();
+ help_topic_msg.push_str(help_topics);
+
+ opts.optflagopt("h", "help", &help_topic_msg, "=TOPIC");
+
+ opts
+}
+
+fn is_nightly() -> bool {
+ option_env!("CFG_RELEASE_CHANNEL").map_or(true, |c| c == "nightly" || c == "dev")
+}
+
+// Returned i32 is an exit code
+fn execute(opts: &Options) -> Result<i32> {
+ let matches = opts.parse(env::args().skip(1))?;
+ let options = GetOptsOptions::from_matches(&matches)?;
+
+ match determine_operation(&matches)? {
+ Operation::Help(HelpOp::None) => {
+ print_usage_to_stdout(opts, "");
+ Ok(0)
+ }
+ Operation::Help(HelpOp::Config) => {
+ Config::print_docs(&mut stdout(), options.unstable_features);
+ Ok(0)
+ }
+ Operation::Help(HelpOp::FileLines) => {
+ print_help_file_lines();
+ Ok(0)
+ }
+ Operation::Version => {
+ print_version();
+ Ok(0)
+ }
+ Operation::ConfigOutputDefault { path } => {
+ let toml = Config::default().all_options().to_toml()?;
+ if let Some(path) = path {
+ let mut file = File::create(path)?;
+ file.write_all(toml.as_bytes())?;
+ } else {
+ io::stdout().write_all(toml.as_bytes())?;
+ }
+ Ok(0)
+ }
+ Operation::ConfigOutputCurrent { path } => {
+ let path = match path {
+ Some(path) => path,
+ None => return Err(format_err!("PATH required for `--print-config current`")),
+ };
+
+ let file = PathBuf::from(path);
+ let file = file.canonicalize().unwrap_or(file);
+
+ let (config, _) = load_config(Some(file.parent().unwrap()), Some(options))?;
+ let toml = config.all_options().to_toml()?;
+ io::stdout().write_all(toml.as_bytes())?;
+
+ Ok(0)
+ }
+ Operation::Stdin { input } => format_string(input, options),
+ Operation::Format {
+ files,
+ minimal_config_path,
+ } => format(files, minimal_config_path, &options),
+ }
+}
+
+fn format_string(input: String, options: GetOptsOptions) -> Result<i32> {
+ // try to read config from local directory
+ let (mut config, _) = load_config(Some(Path::new(".")), Some(options.clone()))?;
+
+ if options.check {
+ return Err(OperationError::CheckWithStdin.into());
+ }
+ if let Some(emit_mode) = options.emit_mode {
+ if emit_mode != EmitMode::Stdout {
+ return Err(OperationError::EmitWithStdin.into());
+ }
+ }
+ // emit mode is always Stdout for Stdin.
+ config.set().emit_mode(EmitMode::Stdout);
+ config.set().verbose(Verbosity::Quiet);
+
+ // parse file_lines
+ config.set().file_lines(options.file_lines);
+ for f in config.file_lines().files() {
+ match *f {
+ FileName::Stdin => {}
+ _ => eprintln!("Warning: Extra file listed in file_lines option '{}'", f),
+ }
+ }
+
+ let out = &mut stdout();
+ let mut session = Session::new(config, Some(out));
+ format_and_emit_report(&mut session, Input::Text(input));
+
+ let exit_code = if session.has_operational_errors() || session.has_parsing_errors() {
+ 1
+ } else {
+ 0
+ };
+ Ok(exit_code)
+}
+
+fn format(
+ files: Vec<PathBuf>,
+ minimal_config_path: Option<String>,
+ options: &GetOptsOptions,
+) -> Result<i32> {
+ options.verify_file_lines(&files);
+ let (config, config_path) = load_config(None, Some(options.clone()))?;
+
+ if config.verbose() == Verbosity::Verbose {
+ if let Some(path) = config_path.as_ref() {
+ println!("Using rustfmt config file {}", path.display());
+ }
+ }
+
+ let out = &mut stdout();
+ let mut session = Session::new(config, Some(out));
+
+ for file in files {
+ if !file.exists() {
+ eprintln!("Error: file `{}` does not exist", file.to_str().unwrap());
+ session.add_operational_error();
+ } else if file.is_dir() {
+ eprintln!("Error: `{}` is a directory", file.to_str().unwrap());
+ session.add_operational_error();
+ } else {
+ // Check the file directory if the config-path could not be read or not provided
+ if config_path.is_none() {
+ let (local_config, config_path) =
+ load_config(Some(file.parent().unwrap()), Some(options.clone()))?;
+ if local_config.verbose() == Verbosity::Verbose {
+ if let Some(path) = config_path {
+ println!(
+ "Using rustfmt config file {} for {}",
+ path.display(),
+ file.display()
+ );
+ }
+ }
+
+ session.override_config(local_config, |sess| {
+ format_and_emit_report(sess, Input::File(file))
+ });
+ } else {
+ format_and_emit_report(&mut session, Input::File(file));
+ }
+ }
+ }
+
+ // If we were given a path via dump-minimal-config, output any options
+ // that were used during formatting as TOML.
+ if let Some(path) = minimal_config_path {
+ let mut file = File::create(path)?;
+ let toml = session.config.used_options().to_toml()?;
+ file.write_all(toml.as_bytes())?;
+ }
+
+ let exit_code = if session.has_operational_errors()
+ || session.has_parsing_errors()
+ || ((session.has_diff() || session.has_check_errors()) && options.check)
+ {
+ 1
+ } else {
+ 0
+ };
+ Ok(exit_code)
+}
+
+fn format_and_emit_report<T: Write>(session: &mut Session<'_, T>, input: Input) {
+ match session.format(input) {
+ Ok(report) => {
+ if report.has_warnings() {
+ eprintln!(
+ "{}",
+ FormatReportFormatterBuilder::new(&report)
+ .enable_colors(should_print_with_colors(session))
+ .build()
+ );
+ }
+ }
+ Err(msg) => {
+ eprintln!("Error writing files: {}", msg);
+ session.add_operational_error();
+ }
+ }
+}
+
+fn should_print_with_colors<T: Write>(session: &mut Session<'_, T>) -> bool {
+ match term::stderr() {
+ Some(ref t)
+ if session.config.color().use_colored_tty()
+ && t.supports_color()
+ && t.supports_attr(term::Attr::Bold) =>
+ {
+ true
+ }
+ _ => false,
+ }
+}
+
+fn print_usage_to_stdout(opts: &Options, reason: &str) {
+ let sep = if reason.is_empty() {
+ String::new()
+ } else {
+ format!("{}\n\n", reason)
+ };
+ let msg = format!(
+ "{}Format Rust code\n\nusage: {} [options] <file>...",
+ sep,
+ env::args_os().next().unwrap().to_string_lossy()
+ );
+ println!("{}", opts.usage(&msg));
+}
+
+fn print_help_file_lines() {
+ println!(
+ "If you want to restrict reformatting to specific sets of lines, you can
+use the `--file-lines` option. Its argument is a JSON array of objects
+with `file` and `range` properties, where `file` is a file name, and
+`range` is an array representing a range of lines like `[7,13]`. Ranges
+are 1-based and inclusive of both end points. Specifying an empty array
+will result in no files being formatted. For example,
+
+```
+rustfmt --file-lines '[
+ {{\"file\":\"src/lib.rs\",\"range\":[7,13]}},
+ {{\"file\":\"src/lib.rs\",\"range\":[21,29]}},
+ {{\"file\":\"src/foo.rs\",\"range\":[10,11]}},
+ {{\"file\":\"src/foo.rs\",\"range\":[15,15]}}]'
+```
+
+would format lines `7-13` and `21-29` of `src/lib.rs`, and lines `10-11`,
+and `15` of `src/foo.rs`. No other files would be formatted, even if they
+are included as out of line modules from `src/lib.rs`."
+ );
+}
+
+fn print_version() {
+ let version_info = format!(
+ "{}-{}",
+ option_env!("CARGO_PKG_VERSION").unwrap_or("unknown"),
+ include_str!(concat!(env!("OUT_DIR"), "/commit-info.txt"))
+ );
+
+ println!("rustfmt {}", version_info);
+}
+
+fn determine_operation(matches: &Matches) -> Result<Operation, OperationError> {
+ if matches.opt_present("h") {
+ let topic = matches.opt_str("h");
+ if topic == None {
+ return Ok(Operation::Help(HelpOp::None));
+ } else if topic == Some("config".to_owned()) {
+ return Ok(Operation::Help(HelpOp::Config));
+ } else if topic == Some("file-lines".to_owned()) && is_nightly() {
+ return Ok(Operation::Help(HelpOp::FileLines));
+ } else {
+ return Err(OperationError::UnknownHelpTopic(topic.unwrap()));
+ }
+ }
+ let mut free_matches = matches.free.iter();
+
+ let mut minimal_config_path = None;
+ if let Some(kind) = matches.opt_str("print-config") {
+ let path = free_matches.next().cloned();
+ match kind.as_str() {
+ "default" => return Ok(Operation::ConfigOutputDefault { path }),
+ "current" => return Ok(Operation::ConfigOutputCurrent { path }),
+ "minimal" => {
+ minimal_config_path = path;
+ if minimal_config_path.is_none() {
+ eprintln!("WARNING: PATH required for `--print-config minimal`.");
+ }
+ }
+ _ => {
+ return Err(OperationError::UnknownPrintConfigTopic(kind));
+ }
+ }
+ }
+
+ if matches.opt_present("version") {
+ return Ok(Operation::Version);
+ }
+
+ let files: Vec<_> = free_matches
+ .map(|s| {
+ let p = PathBuf::from(s);
+ // we will do comparison later, so here tries to canonicalize first
+ // to get the expected behavior.
+ p.canonicalize().unwrap_or(p)
+ })
+ .collect();
+
+ // if no file argument is supplied, read from stdin
+ if files.is_empty() {
+ if minimal_config_path.is_some() {
+ return Err(OperationError::MinimalPathWithStdin);
+ }
+ let mut buffer = String::new();
+ io::stdin().read_to_string(&mut buffer)?;
+
+ return Ok(Operation::Stdin { input: buffer });
+ }
+
+ Ok(Operation::Format {
+ files,
+ minimal_config_path,
+ })
+}
+
+const STABLE_EMIT_MODES: [EmitMode; 3] = [EmitMode::Files, EmitMode::Stdout, EmitMode::Diff];
+
+/// Parsed command line options.
+#[derive(Clone, Debug, Default)]
+struct GetOptsOptions {
+ skip_children: Option<bool>,
+ quiet: bool,
+ verbose: bool,
+ config_path: Option<PathBuf>,
+ inline_config: HashMap<String, String>,
+ emit_mode: Option<EmitMode>,
+ backup: bool,
+ check: bool,
+ edition: Option<Edition>,
+ color: Option<Color>,
+ file_lines: FileLines, // Default is all lines in all files.
+ unstable_features: bool,
+ error_on_unformatted: Option<bool>,
+ print_misformatted_file_names: bool,
+}
+
+impl GetOptsOptions {
+ pub fn from_matches(matches: &Matches) -> Result<GetOptsOptions> {
+ let mut options = GetOptsOptions::default();
+ options.verbose = matches.opt_present("verbose");
+ options.quiet = matches.opt_present("quiet");
+ if options.verbose && options.quiet {
+ return Err(format_err!("Can't use both `--verbose` and `--quiet`"));
+ }
+
+ let rust_nightly = is_nightly();
+
+ if rust_nightly {
+ options.unstable_features = matches.opt_present("unstable-features");
+
+ if options.unstable_features {
+ if matches.opt_present("skip-children") {
+ options.skip_children = Some(true);
+ }
+ if matches.opt_present("error-on-unformatted") {
+ options.error_on_unformatted = Some(true);
+ }
+ if let Some(ref file_lines) = matches.opt_str("file-lines") {
+ options.file_lines = file_lines.parse()?;
+ }
+ } else {
+ let mut unstable_options = vec![];
+ if matches.opt_present("skip-children") {
+ unstable_options.push("`--skip-children`");
+ }
+ if matches.opt_present("error-on-unformatted") {
+ unstable_options.push("`--error-on-unformatted`");
+ }
+ if matches.opt_present("file-lines") {
+ unstable_options.push("`--file-lines`");
+ }
+ if !unstable_options.is_empty() {
+ let s = if unstable_options.len() == 1 { "" } else { "s" };
+ return Err(format_err!(
+ "Unstable option{} ({}) used without `--unstable-features`",
+ s,
+ unstable_options.join(", "),
+ ));
+ }
+ }
+ }
+
+ options.config_path = matches.opt_str("config-path").map(PathBuf::from);
+
+ options.inline_config = matches
+ .opt_strs("config")
+ .iter()
+ .flat_map(|config| config.split(','))
+ .map(
+ |key_val| match key_val.char_indices().find(|(_, ch)| *ch == '=') {
+ Some((middle, _)) => {
+ let (key, val) = (&key_val[..middle], &key_val[middle + 1..]);
+ if !Config::is_valid_key_val(key, val) {
+ Err(format_err!("invalid key=val pair: `{}`", key_val))
+ } else {
+ Ok((key.to_string(), val.to_string()))
+ }
+ }
+
+ None => Err(format_err!(
+ "--config expects comma-separated list of key=val pairs, found `{}`",
+ key_val
+ )),
+ },
+ )
+ .collect::<Result<HashMap<_, _>, _>>()?;
+
+ options.check = matches.opt_present("check");
+ if let Some(ref emit_str) = matches.opt_str("emit") {
+ if options.check {
+ return Err(format_err!("Invalid to use `--emit` and `--check`"));
+ }
+
+ options.emit_mode = Some(emit_mode_from_emit_str(emit_str)?);
+ }
+
+ if let Some(ref edition_str) = matches.opt_str("edition") {
+ options.edition = Some(edition_from_edition_str(edition_str)?);
+ }
+
+ if matches.opt_present("backup") {
+ options.backup = true;
+ }
+
+ if matches.opt_present("files-with-diff") {
+ options.print_misformatted_file_names = true;
+ }
+
+ if !rust_nightly {
+ if let Some(ref emit_mode) = options.emit_mode {
+ if !STABLE_EMIT_MODES.contains(emit_mode) {
+ return Err(format_err!(
+ "Invalid value for `--emit` - using an unstable \
+ value without `--unstable-features`",
+ ));
+ }
+ }
+ }
+
+ if let Some(ref color) = matches.opt_str("color") {
+ match Color::from_str(color) {
+ Ok(color) => options.color = Some(color),
+ _ => return Err(format_err!("Invalid color: {}", color)),
+ }
+ }
+
+ Ok(options)
+ }
+
+ fn verify_file_lines(&self, files: &[PathBuf]) {
+ for f in self.file_lines.files() {
+ match *f {
+ FileName::Real(ref f) if files.contains(f) => {}
+ FileName::Real(_) => {
+ eprintln!("Warning: Extra file listed in file_lines option '{}'", f)
+ }
+ FileName::Stdin => eprintln!("Warning: Not a file '{}'", f),
+ }
+ }
+ }
+}
+
+impl CliOptions for GetOptsOptions {
+ fn apply_to(self, config: &mut Config) {
+ if self.verbose {
+ config.set().verbose(Verbosity::Verbose);
+ } else if self.quiet {
+ config.set().verbose(Verbosity::Quiet);
+ } else {
+ config.set().verbose(Verbosity::Normal);
+ }
+ config.set().file_lines(self.file_lines);
+ config.set().unstable_features(self.unstable_features);
+ if let Some(skip_children) = self.skip_children {
+ config.set().skip_children(skip_children);
+ }
+ if let Some(error_on_unformatted) = self.error_on_unformatted {
+ config.set().error_on_unformatted(error_on_unformatted);
+ }
+ if let Some(edition) = self.edition {
+ config.set().edition(edition);
+ }
+ if self.check {
+ config.set().emit_mode(EmitMode::Diff);
+ } else if let Some(emit_mode) = self.emit_mode {
+ config.set().emit_mode(emit_mode);
+ }
+ if self.backup {
+ config.set().make_backup(true);
+ }
+ if let Some(color) = self.color {
+ config.set().color(color);
+ }
+ if self.print_misformatted_file_names {
+ config.set().print_misformatted_file_names(true);
+ }
+
+ for (key, val) in self.inline_config {
+ config.override_value(&key, &val);
+ }
+ }
+
+ fn config_path(&self) -> Option<&Path> {
+ self.config_path.as_deref()
+ }
+}
+
+fn edition_from_edition_str(edition_str: &str) -> Result<Edition> {
+ match edition_str {
+ "2015" => Ok(Edition::Edition2015),
+ "2018" => Ok(Edition::Edition2018),
+ "2021" => Ok(Edition::Edition2021),
+ _ => Err(format_err!("Invalid value for `--edition`")),
+ }
+}
+
+fn emit_mode_from_emit_str(emit_str: &str) -> Result<EmitMode> {
+ match emit_str {
+ "files" => Ok(EmitMode::Files),
+ "stdout" => Ok(EmitMode::Stdout),
+ "coverage" => Ok(EmitMode::Coverage),
+ "checkstyle" => Ok(EmitMode::Checkstyle),
+ "json" => Ok(EmitMode::Json),
+ _ => Err(format_err!("Invalid value for `--emit`")),
+ }
+}
--- /dev/null
- /// Specify package to format (only usable in workspaces)
+// Inspired by Paul Woolcock's cargo-fmt (https://github.com/pwoolcoc/cargo-fmt/).
+
+#![deny(warnings)]
+#![allow(clippy::match_like_matches_macro)]
+
+use std::cmp::Ordering;
+use std::collections::{BTreeMap, BTreeSet};
+use std::env;
+use std::ffi::OsStr;
+use std::fs;
+use std::hash::{Hash, Hasher};
+use std::io::{self, Write};
+use std::iter::FromIterator;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::str;
+
+use structopt::StructOpt;
+
++#[path = "test/mod.rs"]
++#[cfg(test)]
++mod cargo_fmt_tests;
++
+#[derive(StructOpt, Debug)]
+#[structopt(
+ bin_name = "cargo fmt",
+ about = "This utility formats all bin and lib files of \
+ the current crate using rustfmt."
+)]
+pub struct Opts {
+ /// No output printed to stdout
+ #[structopt(short = "q", long = "quiet")]
+ quiet: bool,
+
+ /// Use verbose output
+ #[structopt(short = "v", long = "verbose")]
+ verbose: bool,
+
+ /// Print rustfmt version and exit
+ #[structopt(long = "version")]
+ version: bool,
+
- /// Format all packages (only usable in workspaces)
++ /// Specify package to format
+ #[structopt(short = "p", long = "package", value_name = "package")]
+ packages: Vec<String>,
+
+ /// Specify path to Cargo.toml
+ #[structopt(long = "manifest-path", value_name = "manifest-path")]
+ manifest_path: Option<String>,
+
+ /// Specify message-format: short|json|human
+ #[structopt(long = "message-format", value_name = "message-format")]
+ message_format: Option<String>,
+
+ /// Options passed to rustfmt
+ // 'raw = true' to make `--` explicit.
+ #[structopt(name = "rustfmt_options", raw(true))]
+ rustfmt_options: Vec<String>,
+
- let metadata = get_cargo_metadata(manifest_path, false)?;
++ /// Format all packages, and also their local path-based dependencies
+ #[structopt(long = "all")]
+ format_all: bool,
++
++ /// Run rustfmt in check mode
++ #[structopt(long = "check")]
++ check: bool,
+}
+
+fn main() {
+ let exit_status = execute();
+ std::io::stdout().flush().unwrap();
+ std::process::exit(exit_status);
+}
+
+const SUCCESS: i32 = 0;
+const FAILURE: i32 = 1;
+
+fn execute() -> i32 {
+ // Drop extra `fmt` argument provided by `cargo`.
+ let mut found_fmt = false;
+ let args = env::args().filter(|x| {
+ if found_fmt {
+ true
+ } else {
+ found_fmt = x == "fmt";
+ x != "fmt"
+ }
+ });
+
+ let opts = Opts::from_iter(args);
+
+ let verbosity = match (opts.verbose, opts.quiet) {
+ (false, false) => Verbosity::Normal,
+ (false, true) => Verbosity::Quiet,
+ (true, false) => Verbosity::Verbose,
+ (true, true) => {
+ print_usage_to_stderr("quiet mode and verbose mode are not compatible");
+ return FAILURE;
+ }
+ };
+
+ if opts.version {
+ return handle_command_status(get_rustfmt_info(&[String::from("--version")]));
+ }
+ if opts.rustfmt_options.iter().any(|s| {
+ ["--print-config", "-h", "--help", "-V", "--version"].contains(&s.as_str())
+ || s.starts_with("--help=")
+ || s.starts_with("--print-config=")
+ }) {
+ return handle_command_status(get_rustfmt_info(&opts.rustfmt_options));
+ }
+
+ let strategy = CargoFmtStrategy::from_opts(&opts);
+ let mut rustfmt_args = opts.rustfmt_options;
++ if opts.check {
++ let check_flag = "--check";
++ if !rustfmt_args.iter().any(|o| o == check_flag) {
++ rustfmt_args.push(check_flag.to_owned());
++ }
++ }
+ if let Some(message_format) = opts.message_format {
+ if let Err(msg) = convert_message_format_to_rustfmt_args(&message_format, &mut rustfmt_args)
+ {
+ print_usage_to_stderr(&msg);
+ return FAILURE;
+ }
+ }
+
+ if let Some(specified_manifest_path) = opts.manifest_path {
+ if !specified_manifest_path.ends_with("Cargo.toml") {
+ print_usage_to_stderr("the manifest-path must be a path to a Cargo.toml file");
+ return FAILURE;
+ }
+ let manifest_path = PathBuf::from(specified_manifest_path);
+ handle_command_status(format_crate(
+ verbosity,
+ &strategy,
+ rustfmt_args,
+ Some(&manifest_path),
+ ))
+ } else {
+ handle_command_status(format_crate(verbosity, &strategy, rustfmt_args, None))
+ }
+}
+
+fn rustfmt_command() -> Command {
+ let rustfmt_var = env::var_os("RUSTFMT");
+ let rustfmt = match &rustfmt_var {
+ Some(rustfmt) => rustfmt,
+ None => OsStr::new("rustfmt"),
+ };
+ Command::new(rustfmt)
+}
+
+fn convert_message_format_to_rustfmt_args(
+ message_format: &str,
+ rustfmt_args: &mut Vec<String>,
+) -> Result<(), String> {
+ let mut contains_emit_mode = false;
+ let mut contains_check = false;
+ let mut contains_list_files = false;
+ for arg in rustfmt_args.iter() {
+ if arg.starts_with("--emit") {
+ contains_emit_mode = true;
+ }
+ if arg == "--check" {
+ contains_check = true;
+ }
+ if arg == "-l" || arg == "--files-with-diff" {
+ contains_list_files = true;
+ }
+ }
+ match message_format {
+ "short" => {
+ if !contains_list_files {
+ rustfmt_args.push(String::from("-l"));
+ }
+ Ok(())
+ }
+ "json" => {
+ if contains_emit_mode {
+ return Err(String::from(
+ "cannot include --emit arg when --message-format is set to json",
+ ));
+ }
+ if contains_check {
+ return Err(String::from(
+ "cannot include --check arg when --message-format is set to json",
+ ));
+ }
+ rustfmt_args.push(String::from("--emit"));
+ rustfmt_args.push(String::from("json"));
+ Ok(())
+ }
+ "human" => Ok(()),
+ _ => {
+ return Err(format!(
+ "invalid --message-format value: {}. Allowed values are: short|json|human",
+ message_format
+ ));
+ }
+ }
+}
+
+fn print_usage_to_stderr(reason: &str) {
+ eprintln!("{}", reason);
+ let app = Opts::clap();
+ app.after_help("")
+ .write_help(&mut io::stderr())
+ .expect("failed to write to stderr");
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Verbosity {
+ Verbose,
+ Normal,
+ Quiet,
+}
+
+fn handle_command_status(status: Result<i32, io::Error>) -> i32 {
+ match status {
+ Err(e) => {
+ print_usage_to_stderr(&e.to_string());
+ FAILURE
+ }
+ Ok(status) => status,
+ }
+}
+
+fn get_rustfmt_info(args: &[String]) -> Result<i32, io::Error> {
+ let mut command = rustfmt_command()
+ .stdout(std::process::Stdio::inherit())
+ .args(args)
+ .spawn()
+ .map_err(|e| match e.kind() {
+ io::ErrorKind::NotFound => io::Error::new(
+ io::ErrorKind::Other,
+ "Could not run rustfmt, please make sure it is in your PATH.",
+ ),
+ _ => e,
+ })?;
+ let result = command.wait()?;
+ if result.success() {
+ Ok(SUCCESS)
+ } else {
+ Ok(result.code().unwrap_or(SUCCESS))
+ }
+}
+
+fn format_crate(
+ verbosity: Verbosity,
+ strategy: &CargoFmtStrategy,
+ rustfmt_args: Vec<String>,
+ manifest_path: Option<&Path>,
+) -> Result<i32, io::Error> {
+ let targets = get_targets(strategy, manifest_path)?;
+
+ // Currently only bin and lib files get formatted.
+ run_rustfmt(&targets, &rustfmt_args, verbosity)
+}
+
+/// Target uses a `path` field for equality and hashing.
+#[derive(Debug)]
+pub struct Target {
+ /// A path to the main source file of the target.
+ path: PathBuf,
+ /// A kind of target (e.g., lib, bin, example, ...).
+ kind: String,
+ /// Rust edition for this target.
+ edition: String,
+}
+
+impl Target {
+ pub fn from_target(target: &cargo_metadata::Target) -> Self {
+ let path = PathBuf::from(&target.src_path);
+ let canonicalized = fs::canonicalize(&path).unwrap_or(path);
+
+ Target {
+ path: canonicalized,
+ kind: target.kind[0].clone(),
+ edition: target.edition.clone(),
+ }
+ }
+}
+
+impl PartialEq for Target {
+ fn eq(&self, other: &Target) -> bool {
+ self.path == other.path
+ }
+}
+
+impl PartialOrd for Target {
+ fn partial_cmp(&self, other: &Target) -> Option<Ordering> {
+ Some(self.path.cmp(&other.path))
+ }
+}
+
+impl Ord for Target {
+ fn cmp(&self, other: &Target) -> Ordering {
+ self.path.cmp(&other.path)
+ }
+}
+
+impl Eq for Target {}
+
+impl Hash for Target {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.path.hash(state);
+ }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum CargoFmtStrategy {
+ /// Format every packages and dependencies.
+ All,
+ /// Format packages that are specified by the command line argument.
+ Some(Vec<String>),
+ /// Format the root packages only.
+ Root,
+}
+
+impl CargoFmtStrategy {
+ pub fn from_opts(opts: &Opts) -> CargoFmtStrategy {
+ match (opts.format_all, opts.packages.is_empty()) {
+ (false, true) => CargoFmtStrategy::Root,
+ (true, _) => CargoFmtStrategy::All,
+ (false, false) => CargoFmtStrategy::Some(opts.packages.clone()),
+ }
+ }
+}
+
+/// Based on the specified `CargoFmtStrategy`, returns a set of main source files.
+fn get_targets(
+ strategy: &CargoFmtStrategy,
+ manifest_path: Option<&Path>,
+) -> Result<BTreeSet<Target>, io::Error> {
+ let mut targets = BTreeSet::new();
+
+ match *strategy {
+ CargoFmtStrategy::Root => get_targets_root_only(manifest_path, &mut targets)?,
+ CargoFmtStrategy::All => {
+ get_targets_recursive(manifest_path, &mut targets, &mut BTreeSet::new())?
+ }
+ CargoFmtStrategy::Some(ref hitlist) => {
+ get_targets_with_hitlist(manifest_path, hitlist, &mut targets)?
+ }
+ }
+
+ if targets.is_empty() {
+ Err(io::Error::new(
+ io::ErrorKind::Other,
+ "Failed to find targets".to_owned(),
+ ))
+ } else {
+ Ok(targets)
+ }
+}
+
+fn get_targets_root_only(
+ manifest_path: Option<&Path>,
+ targets: &mut BTreeSet<Target>,
+) -> Result<(), io::Error> {
- let metadata = get_cargo_metadata(manifest_path, false)?;
- let metadata_with_deps = get_cargo_metadata(manifest_path, true)?;
-
- for package in metadata.packages {
++ let metadata = get_cargo_metadata(manifest_path)?;
+ let workspace_root_path = PathBuf::from(&metadata.workspace_root).canonicalize()?;
+ let (in_workspace_root, current_dir_manifest) = if let Some(target_manifest) = manifest_path {
+ (
+ workspace_root_path == target_manifest,
+ target_manifest.canonicalize()?,
+ )
+ } else {
+ let current_dir = env::current_dir()?.canonicalize()?;
+ (
+ workspace_root_path == current_dir,
+ current_dir.join("Cargo.toml"),
+ )
+ };
+
+ let package_targets = match metadata.packages.len() {
+ 1 => metadata.packages.into_iter().next().unwrap().targets,
+ _ => metadata
+ .packages
+ .into_iter()
+ .filter(|p| {
+ in_workspace_root
+ || PathBuf::from(&p.manifest_path)
+ .canonicalize()
+ .unwrap_or_default()
+ == current_dir_manifest
+ })
+ .map(|p| p.targets)
+ .flatten()
+ .collect(),
+ };
+
+ for target in package_targets {
+ targets.insert(Target::from_target(&target));
+ }
+
+ Ok(())
+}
+
+fn get_targets_recursive(
+ manifest_path: Option<&Path>,
+ mut targets: &mut BTreeSet<Target>,
+ visited: &mut BTreeSet<String>,
+) -> Result<(), io::Error> {
- // Look for local dependencies.
- for dependency in package.dependencies {
- if dependency.source.is_some() || visited.contains(&dependency.name) {
++ let metadata = get_cargo_metadata(manifest_path)?;
++ for package in &metadata.packages {
+ add_targets(&package.targets, &mut targets);
+
- let dependency_package = metadata_with_deps
- .packages
- .iter()
- .find(|p| p.name == dependency.name && p.source.is_none());
- let manifest_path = if let Some(dep_pkg) = dependency_package {
- PathBuf::from(&dep_pkg.manifest_path)
- } else {
- let mut package_manifest_path = PathBuf::from(&package.manifest_path);
- package_manifest_path.pop();
- package_manifest_path.push(&dependency.name);
- package_manifest_path.push("Cargo.toml");
- package_manifest_path
- };
-
- if manifest_path.exists() {
- visited.insert(dependency.name);
++ // Look for local dependencies using information available since cargo v1.51
++ // It's theoretically possible someone could use a newer version of rustfmt with
++ // a much older version of `cargo`, but we don't try to explicitly support that scenario.
++ // If someone reports an issue with path-based deps not being formatted, be sure to
++ // confirm their version of `cargo` (not `cargo-fmt`) is >= v1.51
++ // https://github.com/rust-lang/cargo/pull/8994
++ for dependency in &package.dependencies {
++ if dependency.path.is_none() || visited.contains(&dependency.name) {
+ continue;
+ }
+
- let metadata = get_cargo_metadata(manifest_path, false)?;
-
++ let manifest_path = PathBuf::from(dependency.path.as_ref().unwrap()).join("Cargo.toml");
++ if manifest_path.exists()
++ && !metadata
++ .packages
++ .iter()
++ .any(|p| p.manifest_path.eq(&manifest_path))
++ {
++ visited.insert(dependency.name.to_owned());
+ get_targets_recursive(Some(&manifest_path), &mut targets, visited)?;
+ }
+ }
+ }
+
+ Ok(())
+}
+
+fn get_targets_with_hitlist(
+ manifest_path: Option<&Path>,
+ hitlist: &[String],
+ targets: &mut BTreeSet<Target>,
+) -> Result<(), io::Error> {
- fn get_cargo_metadata(
- manifest_path: Option<&Path>,
- include_deps: bool,
- ) -> Result<cargo_metadata::Metadata, io::Error> {
++ let metadata = get_cargo_metadata(manifest_path)?;
+ let mut workspace_hitlist: BTreeSet<&String> = BTreeSet::from_iter(hitlist);
+
+ for package in metadata.packages {
+ if workspace_hitlist.remove(&package.name) {
+ for target in package.targets {
+ targets.insert(Target::from_target(&target));
+ }
+ }
+ }
+
+ if workspace_hitlist.is_empty() {
+ Ok(())
+ } else {
+ let package = workspace_hitlist.iter().next().unwrap();
+ Err(io::Error::new(
+ io::ErrorKind::InvalidInput,
+ format!("package `{}` is not a member of the workspace", package),
+ ))
+ }
+}
+
+fn add_targets(target_paths: &[cargo_metadata::Target], targets: &mut BTreeSet<Target>) {
+ for target in target_paths {
+ targets.insert(Target::from_target(target));
+ }
+}
+
+fn run_rustfmt(
+ targets: &BTreeSet<Target>,
+ fmt_args: &[String],
+ verbosity: Verbosity,
+) -> Result<i32, io::Error> {
+ let by_edition = targets
+ .iter()
+ .inspect(|t| {
+ if verbosity == Verbosity::Verbose {
+ println!("[{} ({})] {:?}", t.kind, t.edition, t.path)
+ }
+ })
+ .fold(BTreeMap::new(), |mut h, t| {
+ h.entry(&t.edition).or_insert_with(Vec::new).push(&t.path);
+ h
+ });
+
+ let mut status = vec![];
+ for (edition, files) in by_edition {
+ let stdout = if verbosity == Verbosity::Quiet {
+ std::process::Stdio::null()
+ } else {
+ std::process::Stdio::inherit()
+ };
+
+ if verbosity == Verbosity::Verbose {
+ print!("rustfmt");
+ print!(" --edition {}", edition);
+ fmt_args.iter().for_each(|f| print!(" {}", f));
+ files.iter().for_each(|f| print!(" {}", f.display()));
+ println!();
+ }
+
+ let mut command = rustfmt_command()
+ .stdout(stdout)
+ .args(files)
+ .args(&["--edition", edition])
+ .args(fmt_args)
+ .spawn()
+ .map_err(|e| match e.kind() {
+ io::ErrorKind::NotFound => io::Error::new(
+ io::ErrorKind::Other,
+ "Could not run rustfmt, please make sure it is in your PATH.",
+ ),
+ _ => e,
+ })?;
+
+ status.push(command.wait()?);
+ }
+
+ Ok(status
+ .iter()
+ .filter_map(|s| if s.success() { None } else { s.code() })
+ .next()
+ .unwrap_or(SUCCESS))
+}
+
- if !include_deps {
- cmd.no_deps();
- }
++fn get_cargo_metadata(manifest_path: Option<&Path>) -> Result<cargo_metadata::Metadata, io::Error> {
+ let mut cmd = cargo_metadata::MetadataCommand::new();
- cmd.other_options(&[String::from("--offline")]);
++ cmd.no_deps();
+ if let Some(manifest_path) = manifest_path {
+ cmd.manifest_path(manifest_path);
+ }
-
- #[cfg(test)]
- mod cargo_fmt_tests {
- use super::*;
-
- #[test]
- fn default_options() {
- let empty: Vec<String> = vec![];
- let o = Opts::from_iter(&empty);
- assert_eq!(false, o.quiet);
- assert_eq!(false, o.verbose);
- assert_eq!(false, o.version);
- assert_eq!(empty, o.packages);
- assert_eq!(empty, o.rustfmt_options);
- assert_eq!(false, o.format_all);
- assert_eq!(None, o.manifest_path);
- assert_eq!(None, o.message_format);
- }
-
- #[test]
- fn good_options() {
- let o = Opts::from_iter(&[
- "test",
- "-q",
- "-p",
- "p1",
- "-p",
- "p2",
- "--message-format",
- "short",
- "--",
- "--edition",
- "2018",
- ]);
- assert_eq!(true, o.quiet);
- assert_eq!(false, o.verbose);
- assert_eq!(false, o.version);
- assert_eq!(vec!["p1", "p2"], o.packages);
- assert_eq!(vec!["--edition", "2018"], o.rustfmt_options);
- assert_eq!(false, o.format_all);
- assert_eq!(Some(String::from("short")), o.message_format);
- }
-
- #[test]
- fn unexpected_option() {
- assert!(
- Opts::clap()
- .get_matches_from_safe(&["test", "unexpected"])
- .is_err()
- );
- }
-
- #[test]
- fn unexpected_flag() {
- assert!(
- Opts::clap()
- .get_matches_from_safe(&["test", "--flag"])
- .is_err()
- );
- }
-
- #[test]
- fn mandatory_separator() {
- assert!(
- Opts::clap()
- .get_matches_from_safe(&["test", "--check"])
- .is_err()
- );
- assert!(
- !Opts::clap()
- .get_matches_from_safe(&["test", "--", "--check"])
- .is_err()
- );
- }
-
- #[test]
- fn multiple_packages_one_by_one() {
- let o = Opts::from_iter(&[
- "test",
- "-p",
- "package1",
- "--package",
- "package2",
- "-p",
- "package3",
- ]);
- assert_eq!(3, o.packages.len());
- }
-
- #[test]
- fn multiple_packages_grouped() {
- let o = Opts::from_iter(&[
- "test",
- "--package",
- "package1",
- "package2",
- "-p",
- "package3",
- "package4",
- ]);
- assert_eq!(4, o.packages.len());
- }
-
- #[test]
- fn empty_packages_1() {
- assert!(Opts::clap().get_matches_from_safe(&["test", "-p"]).is_err());
- }
-
- #[test]
- fn empty_packages_2() {
- assert!(
- Opts::clap()
- .get_matches_from_safe(&["test", "-p", "--", "--check"])
- .is_err()
- );
- }
-
- #[test]
- fn empty_packages_3() {
- assert!(
- Opts::clap()
- .get_matches_from_safe(&["test", "-p", "--verbose"])
- .is_err()
- );
- }
-
- #[test]
- fn empty_packages_4() {
- assert!(
- Opts::clap()
- .get_matches_from_safe(&["test", "-p", "--check"])
- .is_err()
- );
- }
-
- mod convert_message_format_to_rustfmt_args_tests {
- use super::*;
-
- #[test]
- fn invalid_message_format() {
- assert_eq!(
- convert_message_format_to_rustfmt_args("awesome", &mut vec![]),
- Err(String::from(
- "invalid --message-format value: awesome. Allowed values are: short|json|human"
- )),
- );
- }
-
- #[test]
- fn json_message_format_and_check_arg() {
- let mut args = vec![String::from("--check")];
- assert_eq!(
- convert_message_format_to_rustfmt_args("json", &mut args),
- Err(String::from(
- "cannot include --check arg when --message-format is set to json"
- )),
- );
- }
-
- #[test]
- fn json_message_format_and_emit_arg() {
- let mut args = vec![String::from("--emit"), String::from("checkstyle")];
- assert_eq!(
- convert_message_format_to_rustfmt_args("json", &mut args),
- Err(String::from(
- "cannot include --emit arg when --message-format is set to json"
- )),
- );
- }
-
- #[test]
- fn json_message_format() {
- let mut args = vec![String::from("--edition"), String::from("2018")];
- assert!(convert_message_format_to_rustfmt_args("json", &mut args).is_ok());
- assert_eq!(
- args,
- vec![
- String::from("--edition"),
- String::from("2018"),
- String::from("--emit"),
- String::from("json")
- ]
- );
- }
-
- #[test]
- fn human_message_format() {
- let exp_args = vec![String::from("--emit"), String::from("json")];
- let mut act_args = exp_args.clone();
- assert!(convert_message_format_to_rustfmt_args("human", &mut act_args).is_ok());
- assert_eq!(act_args, exp_args);
- }
-
- #[test]
- fn short_message_format() {
- let mut args = vec![String::from("--check")];
- assert!(convert_message_format_to_rustfmt_args("short", &mut args).is_ok());
- assert_eq!(args, vec![String::from("--check"), String::from("-l")]);
- }
-
- #[test]
- fn short_message_format_included_short_list_files_flag() {
- let mut args = vec![String::from("--check"), String::from("-l")];
- assert!(convert_message_format_to_rustfmt_args("short", &mut args).is_ok());
- assert_eq!(args, vec![String::from("--check"), String::from("-l")]);
- }
-
- #[test]
- fn short_message_format_included_long_list_files_flag() {
- let mut args = vec![String::from("--check"), String::from("--files-with-diff")];
- assert!(convert_message_format_to_rustfmt_args("short", &mut args).is_ok());
- assert_eq!(
- args,
- vec![String::from("--check"), String::from("--files-with-diff")]
- );
- }
- }
- }
++ cmd.other_options(vec![String::from("--offline")]);
+
+ match cmd.exec() {
+ Ok(metadata) => Ok(metadata),
+ Err(_) => {
+ cmd.other_options(vec![]);
+ match cmd.exec() {
+ Ok(metadata) => Ok(metadata),
+ Err(error) => Err(io::Error::new(io::ErrorKind::Other, error.to_string())),
+ }
+ }
+ }
+}
--- /dev/null
--- /dev/null
++use super::*;
++
++#[test]
++fn invalid_message_format() {
++ assert_eq!(
++ convert_message_format_to_rustfmt_args("awesome", &mut vec![]),
++ Err(String::from(
++ "invalid --message-format value: awesome. Allowed values are: short|json|human"
++ )),
++ );
++}
++
++#[test]
++fn json_message_format_and_check_arg() {
++ let mut args = vec![String::from("--check")];
++ assert_eq!(
++ convert_message_format_to_rustfmt_args("json", &mut args),
++ Err(String::from(
++ "cannot include --check arg when --message-format is set to json"
++ )),
++ );
++}
++
++#[test]
++fn json_message_format_and_emit_arg() {
++ let mut args = vec![String::from("--emit"), String::from("checkstyle")];
++ assert_eq!(
++ convert_message_format_to_rustfmt_args("json", &mut args),
++ Err(String::from(
++ "cannot include --emit arg when --message-format is set to json"
++ )),
++ );
++}
++
++#[test]
++fn json_message_format() {
++ let mut args = vec![String::from("--edition"), String::from("2018")];
++ assert!(convert_message_format_to_rustfmt_args("json", &mut args).is_ok());
++ assert_eq!(
++ args,
++ vec![
++ String::from("--edition"),
++ String::from("2018"),
++ String::from("--emit"),
++ String::from("json")
++ ]
++ );
++}
++
++#[test]
++fn human_message_format() {
++ let exp_args = vec![String::from("--emit"), String::from("json")];
++ let mut act_args = exp_args.clone();
++ assert!(convert_message_format_to_rustfmt_args("human", &mut act_args).is_ok());
++ assert_eq!(act_args, exp_args);
++}
++
++#[test]
++fn short_message_format() {
++ let mut args = vec![String::from("--check")];
++ assert!(convert_message_format_to_rustfmt_args("short", &mut args).is_ok());
++ assert_eq!(args, vec![String::from("--check"), String::from("-l")]);
++}
++
++#[test]
++fn short_message_format_included_short_list_files_flag() {
++ let mut args = vec![String::from("--check"), String::from("-l")];
++ assert!(convert_message_format_to_rustfmt_args("short", &mut args).is_ok());
++ assert_eq!(args, vec![String::from("--check"), String::from("-l")]);
++}
++
++#[test]
++fn short_message_format_included_long_list_files_flag() {
++ let mut args = vec![String::from("--check"), String::from("--files-with-diff")];
++ assert!(convert_message_format_to_rustfmt_args("short", &mut args).is_ok());
++ assert_eq!(
++ args,
++ vec![String::from("--check"), String::from("--files-with-diff")]
++ );
++}
--- /dev/null
--- /dev/null
++use super::*;
++
++mod message_format;
++mod targets;
++
++#[test]
++fn default_options() {
++ let empty: Vec<String> = vec![];
++ let o = Opts::from_iter(&empty);
++ assert_eq!(false, o.quiet);
++ assert_eq!(false, o.verbose);
++ assert_eq!(false, o.version);
++ assert_eq!(false, o.check);
++ assert_eq!(empty, o.packages);
++ assert_eq!(empty, o.rustfmt_options);
++ assert_eq!(false, o.format_all);
++ assert_eq!(None, o.manifest_path);
++ assert_eq!(None, o.message_format);
++}
++
++#[test]
++fn good_options() {
++ let o = Opts::from_iter(&[
++ "test",
++ "-q",
++ "-p",
++ "p1",
++ "-p",
++ "p2",
++ "--message-format",
++ "short",
++ "--check",
++ "--",
++ "--edition",
++ "2018",
++ ]);
++ assert_eq!(true, o.quiet);
++ assert_eq!(false, o.verbose);
++ assert_eq!(false, o.version);
++ assert_eq!(true, o.check);
++ assert_eq!(vec!["p1", "p2"], o.packages);
++ assert_eq!(vec!["--edition", "2018"], o.rustfmt_options);
++ assert_eq!(false, o.format_all);
++ assert_eq!(Some(String::from("short")), o.message_format);
++}
++
++#[test]
++fn unexpected_option() {
++ assert!(
++ Opts::clap()
++ .get_matches_from_safe(&["test", "unexpected"])
++ .is_err()
++ );
++}
++
++#[test]
++fn unexpected_flag() {
++ assert!(
++ Opts::clap()
++ .get_matches_from_safe(&["test", "--flag"])
++ .is_err()
++ );
++}
++
++#[test]
++fn mandatory_separator() {
++ assert!(
++ Opts::clap()
++ .get_matches_from_safe(&["test", "--emit"])
++ .is_err()
++ );
++ assert!(
++ !Opts::clap()
++ .get_matches_from_safe(&["test", "--", "--emit"])
++ .is_err()
++ );
++}
++
++#[test]
++fn multiple_packages_one_by_one() {
++ let o = Opts::from_iter(&[
++ "test",
++ "-p",
++ "package1",
++ "--package",
++ "package2",
++ "-p",
++ "package3",
++ ]);
++ assert_eq!(3, o.packages.len());
++}
++
++#[test]
++fn multiple_packages_grouped() {
++ let o = Opts::from_iter(&[
++ "test",
++ "--package",
++ "package1",
++ "package2",
++ "-p",
++ "package3",
++ "package4",
++ ]);
++ assert_eq!(4, o.packages.len());
++}
++
++#[test]
++fn empty_packages_1() {
++ assert!(Opts::clap().get_matches_from_safe(&["test", "-p"]).is_err());
++}
++
++#[test]
++fn empty_packages_2() {
++ assert!(
++ Opts::clap()
++ .get_matches_from_safe(&["test", "-p", "--", "--check"])
++ .is_err()
++ );
++}
++
++#[test]
++fn empty_packages_3() {
++ assert!(
++ Opts::clap()
++ .get_matches_from_safe(&["test", "-p", "--verbose"])
++ .is_err()
++ );
++}
++
++#[test]
++fn empty_packages_4() {
++ assert!(
++ Opts::clap()
++ .get_matches_from_safe(&["test", "-p", "--check"])
++ .is_err()
++ );
++}
--- /dev/null
--- /dev/null
++use super::*;
++
++struct ExpTarget {
++ path: &'static str,
++ edition: &'static str,
++ kind: &'static str,
++}
++
++mod all_targets {
++ use super::*;
++
++ fn assert_correct_targets_loaded(
++ manifest_suffix: &str,
++ source_root: &str,
++ exp_targets: &[ExpTarget],
++ exp_num_targets: usize,
++ ) {
++ let root_path = Path::new("tests/cargo-fmt/source").join(source_root);
++ let get_path = |exp: &str| PathBuf::from(&root_path).join(exp).canonicalize().unwrap();
++ let manifest_path = Path::new(&root_path).join(manifest_suffix);
++ let targets = get_targets(&CargoFmtStrategy::All, Some(manifest_path.as_path()))
++ .expect("Targets should have been loaded");
++
++ assert_eq!(targets.len(), exp_num_targets);
++
++ for target in exp_targets {
++ assert!(targets.contains(&Target {
++ path: get_path(target.path),
++ edition: target.edition.to_owned(),
++ kind: target.kind.to_owned(),
++ }));
++ }
++ }
++
++ mod different_crate_and_dir_names {
++ use super::*;
++
++ fn assert_correct_targets_loaded(manifest_suffix: &str) {
++ let exp_targets = vec![
++ ExpTarget {
++ path: "dependency-dir-name/subdep-dir-name/src/lib.rs",
++ edition: "2018",
++ kind: "lib",
++ },
++ ExpTarget {
++ path: "dependency-dir-name/src/lib.rs",
++ edition: "2018",
++ kind: "lib",
++ },
++ ExpTarget {
++ path: "src/main.rs",
++ edition: "2018",
++ kind: "main",
++ },
++ ];
++ super::assert_correct_targets_loaded(
++ manifest_suffix,
++ "divergent-crate-dir-names",
++ &exp_targets,
++ 3,
++ );
++ }
++
++ #[test]
++ fn correct_targets_from_root() {
++ assert_correct_targets_loaded("Cargo.toml");
++ }
++
++ #[test]
++ fn correct_targets_from_sub_local_dep() {
++ assert_correct_targets_loaded("dependency-dir-name/Cargo.toml");
++ }
++ }
++
++ mod workspaces {
++ use super::*;
++
++ fn assert_correct_targets_loaded(manifest_suffix: &str) {
++ let exp_targets = vec![
++ ExpTarget {
++ path: "ws/a/src/main.rs",
++ edition: "2018",
++ kind: "bin",
++ },
++ ExpTarget {
++ path: "ws/b/src/main.rs",
++ edition: "2018",
++ kind: "bin",
++ },
++ ExpTarget {
++ path: "ws/c/src/lib.rs",
++ edition: "2018",
++ kind: "lib",
++ },
++ ExpTarget {
++ path: "ws/a/d/src/lib.rs",
++ edition: "2018",
++ kind: "lib",
++ },
++ ExpTarget {
++ path: "e/src/main.rs",
++ edition: "2018",
++ kind: "main",
++ },
++ ExpTarget {
++ path: "ws/a/d/f/src/lib.rs",
++ edition: "2018",
++ kind: "lib",
++ },
++ ];
++ super::assert_correct_targets_loaded(
++ manifest_suffix,
++ "workspaces/path-dep-above",
++ &exp_targets,
++ 6,
++ );
++ }
++
++ #[test]
++ fn includes_outside_workspace_deps() {
++ assert_correct_targets_loaded("ws/Cargo.toml");
++ }
++
++ #[test]
++ fn includes_workspace_from_dep_above() {
++ assert_correct_targets_loaded("e/Cargo.toml");
++ }
++
++ #[test]
++ fn includes_all_packages_from_workspace_subdir() {
++ assert_correct_targets_loaded("ws/a/d/f/Cargo.toml");
++ }
++ }
++}
--- /dev/null
- count_newlines, first_line_width, last_line_width, trim_left_preserve_layout, unicode_str_width,
+// Formatting and tools for comments.
+
+use std::{self, borrow::Cow, iter};
+
+use itertools::{multipeek, MultiPeek};
+use rustc_span::Span;
+
+use crate::config::Config;
+use crate::rewrite::RewriteContext;
+use crate::shape::{Indent, Shape};
+use crate::string::{rewrite_string, StringFormat};
+use crate::utils::{
- let first_sep = if prev_str.is_empty() || next_str.is_empty() {
- ""
- } else {
- " "
- };
++ count_newlines, first_line_width, last_line_width, trim_left_preserve_layout,
++ trimmed_last_line_width, unicode_str_width,
+};
+use crate::{ErrorKind, FormattingError};
+
+fn is_custom_comment(comment: &str) -> bool {
+ if !comment.starts_with("//") {
+ false
+ } else if let Some(c) = comment.chars().nth(2) {
+ !c.is_alphanumeric() && !c.is_whitespace()
+ } else {
+ false
+ }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub(crate) enum CommentStyle<'a> {
+ DoubleSlash,
+ TripleSlash,
+ Doc,
+ SingleBullet,
+ DoubleBullet,
+ Exclamation,
+ Custom(&'a str),
+}
+
+fn custom_opener(s: &str) -> &str {
+ s.lines().next().map_or("", |first_line| {
+ first_line
+ .find(' ')
+ .map_or(first_line, |space_index| &first_line[0..=space_index])
+ })
+}
+
+impl<'a> CommentStyle<'a> {
+ /// Returns `true` if the commenting style covers a line only.
+ pub(crate) fn is_line_comment(&self) -> bool {
+ match *self {
+ CommentStyle::DoubleSlash
+ | CommentStyle::TripleSlash
+ | CommentStyle::Doc
+ | CommentStyle::Custom(_) => true,
+ _ => false,
+ }
+ }
+
+ /// Returns `true` if the commenting style can span over multiple lines.
+ pub(crate) fn is_block_comment(&self) -> bool {
+ match *self {
+ CommentStyle::SingleBullet | CommentStyle::DoubleBullet | CommentStyle::Exclamation => {
+ true
+ }
+ _ => false,
+ }
+ }
+
+ /// Returns `true` if the commenting style is for documentation.
+ pub(crate) fn is_doc_comment(&self) -> bool {
+ matches!(*self, CommentStyle::TripleSlash | CommentStyle::Doc)
+ }
+
+ pub(crate) fn opener(&self) -> &'a str {
+ match *self {
+ CommentStyle::DoubleSlash => "// ",
+ CommentStyle::TripleSlash => "/// ",
+ CommentStyle::Doc => "//! ",
+ CommentStyle::SingleBullet => "/* ",
+ CommentStyle::DoubleBullet => "/** ",
+ CommentStyle::Exclamation => "/*! ",
+ CommentStyle::Custom(opener) => opener,
+ }
+ }
+
+ pub(crate) fn closer(&self) -> &'a str {
+ match *self {
+ CommentStyle::DoubleSlash
+ | CommentStyle::TripleSlash
+ | CommentStyle::Custom(..)
+ | CommentStyle::Doc => "",
+ CommentStyle::SingleBullet | CommentStyle::DoubleBullet | CommentStyle::Exclamation => {
+ " */"
+ }
+ }
+ }
+
+ pub(crate) fn line_start(&self) -> &'a str {
+ match *self {
+ CommentStyle::DoubleSlash => "// ",
+ CommentStyle::TripleSlash => "/// ",
+ CommentStyle::Doc => "//! ",
+ CommentStyle::SingleBullet | CommentStyle::DoubleBullet | CommentStyle::Exclamation => {
+ " * "
+ }
+ CommentStyle::Custom(opener) => opener,
+ }
+ }
+
+ pub(crate) fn to_str_tuplet(&self) -> (&'a str, &'a str, &'a str) {
+ (self.opener(), self.closer(), self.line_start())
+ }
+}
+
+pub(crate) fn comment_style(orig: &str, normalize_comments: bool) -> CommentStyle<'_> {
+ if !normalize_comments {
+ if orig.starts_with("/**") && !orig.starts_with("/**/") {
+ CommentStyle::DoubleBullet
+ } else if orig.starts_with("/*!") {
+ CommentStyle::Exclamation
+ } else if orig.starts_with("/*") {
+ CommentStyle::SingleBullet
+ } else if orig.starts_with("///") && orig.chars().nth(3).map_or(true, |c| c != '/') {
+ CommentStyle::TripleSlash
+ } else if orig.starts_with("//!") {
+ CommentStyle::Doc
+ } else if is_custom_comment(orig) {
+ CommentStyle::Custom(custom_opener(orig))
+ } else {
+ CommentStyle::DoubleSlash
+ }
+ } else if (orig.starts_with("///") && orig.chars().nth(3).map_or(true, |c| c != '/'))
+ || (orig.starts_with("/**") && !orig.starts_with("/**/"))
+ {
+ CommentStyle::TripleSlash
+ } else if orig.starts_with("//!") || orig.starts_with("/*!") {
+ CommentStyle::Doc
+ } else if is_custom_comment(orig) {
+ CommentStyle::Custom(custom_opener(orig))
+ } else {
+ CommentStyle::DoubleSlash
+ }
+}
+
+/// Returns true if the last line of the passed string finishes with a block-comment.
+pub(crate) fn is_last_comment_block(s: &str) -> bool {
+ s.trim_end().ends_with("*/")
+}
+
+/// Combine `prev_str` and `next_str` into a single `String`. `span` may contain
+/// comments between two strings. If there are such comments, then that will be
+/// recovered. If `allow_extend` is true and there is no comment between the two
+/// strings, then they will be put on a single line as long as doing so does not
+/// exceed max width.
+pub(crate) fn combine_strs_with_missing_comments(
+ context: &RewriteContext<'_>,
+ prev_str: &str,
+ next_str: &str,
+ span: Span,
+ shape: Shape,
+ allow_extend: bool,
+) -> Option<String> {
+ trace!(
+ "combine_strs_with_missing_comments `{}` `{}` {:?} {:?}",
+ prev_str,
+ next_str,
+ span,
+ shape
+ );
+
+ let mut result =
+ String::with_capacity(prev_str.len() + next_str.len() + shape.indent.width() + 128);
+ result.push_str(prev_str);
+ let mut allow_one_line = !prev_str.contains('\n') && !next_str.contains('\n');
- if allow_extend && prev_str.len() + first_sep.len() + next_str.len() <= shape.width {
++ let first_sep =
++ if prev_str.is_empty() || next_str.is_empty() || trimmed_last_line_width(prev_str) == 0 {
++ ""
++ } else {
++ " "
++ };
+ let mut one_line_width =
+ last_line_width(prev_str) + first_line_width(next_str) + first_sep.len();
+
+ let config = context.config;
+ let indent = shape.indent;
+ let missing_comment = rewrite_missing_comment(span, shape, context)?;
+
+ if missing_comment.is_empty() {
- /// Attributes for code blocks in rustdoc.
- /// See <https://doc.rust-lang.org/rustdoc/print.html#attributes>.
++ if allow_extend && one_line_width <= shape.width {
+ result.push_str(first_sep);
+ } else if !prev_str.is_empty() {
+ result.push_str(&indent.to_string_with_newline(config))
+ }
+ result.push_str(next_str);
+ return Some(result);
+ }
+
+ // We have a missing comment between the first expression and the second expression.
+
+ // Peek the the original source code and find out whether there is a newline between the first
+ // expression and the second expression or the missing comment. We will preserve the original
+ // layout whenever possible.
+ let original_snippet = context.snippet(span);
+ let prefer_same_line = if let Some(pos) = original_snippet.find('/') {
+ !original_snippet[..pos].contains('\n')
+ } else {
+ !original_snippet.contains('\n')
+ };
+
+ one_line_width -= first_sep.len();
+ let first_sep = if prev_str.is_empty() || missing_comment.is_empty() {
+ Cow::from("")
+ } else {
+ let one_line_width = last_line_width(prev_str) + first_line_width(&missing_comment) + 1;
+ if prefer_same_line && one_line_width <= shape.width {
+ Cow::from(" ")
+ } else {
+ indent.to_string_with_newline(config)
+ }
+ };
+ result.push_str(&first_sep);
+ result.push_str(&missing_comment);
+
+ let second_sep = if missing_comment.is_empty() || next_str.is_empty() {
+ Cow::from("")
+ } else if missing_comment.starts_with("//") {
+ indent.to_string_with_newline(config)
+ } else {
+ one_line_width += missing_comment.len() + first_sep.len() + 1;
+ allow_one_line &= !missing_comment.starts_with("//") && !missing_comment.contains('\n');
+ if prefer_same_line && allow_one_line && one_line_width <= shape.width {
+ Cow::from(" ")
+ } else {
+ indent.to_string_with_newline(config)
+ }
+ };
+ result.push_str(&second_sep);
+ result.push_str(next_str);
+
+ Some(result)
+}
+
+pub(crate) fn rewrite_doc_comment(orig: &str, shape: Shape, config: &Config) -> Option<String> {
+ identify_comment(orig, false, shape, config, true)
+}
+
+pub(crate) fn rewrite_comment(
+ orig: &str,
+ block_style: bool,
+ shape: Shape,
+ config: &Config,
+) -> Option<String> {
+ identify_comment(orig, block_style, shape, config, false)
+}
+
+fn identify_comment(
+ orig: &str,
+ block_style: bool,
+ shape: Shape,
+ config: &Config,
+ is_doc_comment: bool,
+) -> Option<String> {
+ let style = comment_style(orig, false);
+
+ // Computes the byte length of line taking into account a newline if the line is part of a
+ // paragraph.
+ fn compute_len(orig: &str, line: &str) -> usize {
+ if orig.len() > line.len() {
+ if orig.as_bytes()[line.len()] == b'\r' {
+ line.len() + 2
+ } else {
+ line.len() + 1
+ }
+ } else {
+ line.len()
+ }
+ }
+
+ // Get the first group of line comments having the same commenting style.
+ //
+ // Returns a tuple with:
+ // - a boolean indicating if there is a blank line
+ // - a number indicating the size of the first group of comments
+ fn consume_same_line_comments(
+ style: CommentStyle<'_>,
+ orig: &str,
+ line_start: &str,
+ ) -> (bool, usize) {
+ let mut first_group_ending = 0;
+ let mut hbl = false;
+
+ for line in orig.lines() {
+ let trimmed_line = line.trim_start();
+ if trimmed_line.is_empty() {
+ hbl = true;
+ break;
+ } else if trimmed_line.starts_with(line_start)
+ || comment_style(trimmed_line, false) == style
+ {
+ first_group_ending += compute_len(&orig[first_group_ending..], line);
+ } else {
+ break;
+ }
+ }
+ (hbl, first_group_ending)
+ }
+
+ let (has_bare_lines, first_group_ending) = match style {
+ CommentStyle::DoubleSlash | CommentStyle::TripleSlash | CommentStyle::Doc => {
+ let line_start = style.line_start().trim_start();
+ consume_same_line_comments(style, orig, line_start)
+ }
+ CommentStyle::Custom(opener) => {
+ let trimmed_opener = opener.trim_end();
+ consume_same_line_comments(style, orig, trimmed_opener)
+ }
+ // for a block comment, search for the closing symbol
+ CommentStyle::DoubleBullet | CommentStyle::SingleBullet | CommentStyle::Exclamation => {
+ let closer = style.closer().trim_start();
+ let mut count = orig.matches(closer).count();
+ let mut closing_symbol_offset = 0;
+ let mut hbl = false;
+ let mut first = true;
+ for line in orig.lines() {
+ closing_symbol_offset += compute_len(&orig[closing_symbol_offset..], line);
+ let mut trimmed_line = line.trim_start();
+ if !trimmed_line.starts_with('*')
+ && !trimmed_line.starts_with("//")
+ && !trimmed_line.starts_with("/*")
+ {
+ hbl = true;
+ }
+
+ // Remove opener from consideration when searching for closer
+ if first {
+ let opener = style.opener().trim_end();
+ trimmed_line = &trimmed_line[opener.len()..];
+ first = false;
+ }
+ if trimmed_line.ends_with(closer) {
+ count -= 1;
+ if count == 0 {
+ break;
+ }
+ }
+ }
+ (hbl, closing_symbol_offset)
+ }
+ };
+
+ let (first_group, rest) = orig.split_at(first_group_ending);
+ let rewritten_first_group =
+ if !config.normalize_comments() && has_bare_lines && style.is_block_comment() {
+ trim_left_preserve_layout(first_group, shape.indent, config)?
+ } else if !config.normalize_comments()
+ && !config.wrap_comments()
+ && !config.format_code_in_doc_comments()
+ {
+ light_rewrite_comment(first_group, shape.indent, config, is_doc_comment)
+ } else {
+ rewrite_comment_inner(
+ first_group,
+ block_style,
+ style,
+ shape,
+ config,
+ is_doc_comment || style.is_doc_comment(),
+ )?
+ };
+ if rest.is_empty() {
+ Some(rewritten_first_group)
+ } else {
+ identify_comment(
+ rest.trim_start(),
+ block_style,
+ shape,
+ config,
+ is_doc_comment,
+ )
+ .map(|rest_str| {
+ format!(
+ "{}\n{}{}{}",
+ rewritten_first_group,
+ // insert back the blank line
+ if has_bare_lines && style.is_line_comment() {
+ "\n"
+ } else {
+ ""
+ },
+ shape.indent.to_string(config),
+ rest_str
+ )
+ })
+ }
+}
+
- Ignore,
- Text,
- ShouldPanic,
- NoRun,
- CompileFail,
++/// Enum indicating if the code block contains rust based on attributes
+enum CodeBlockAttribute {
+ Rust,
- fn new(attribute: &str) -> CodeBlockAttribute {
- match attribute {
- "rust" | "" => CodeBlockAttribute::Rust,
- "ignore" => CodeBlockAttribute::Ignore,
- "text" => CodeBlockAttribute::Text,
- "should_panic" => CodeBlockAttribute::ShouldPanic,
- "no_run" => CodeBlockAttribute::NoRun,
- "compile_fail" => CodeBlockAttribute::CompileFail,
- _ => CodeBlockAttribute::Text,
++ NotRust,
+}
+
+impl CodeBlockAttribute {
- CodeBlockAttribute::Ignore | CodeBlockAttribute::Text => {
- trim_custom_comment_prefix(&self.code_block_buffer)
- }
- _ if self.code_block_buffer.is_empty() => String::new(),
- _ => {
++ /// Parse comma separated attributes list. Return rust only if all
++ /// attributes are valid rust attributes
++ /// See https://doc.rust-lang.org/rustdoc/print.html#attributes
++ fn new(attributes: &str) -> CodeBlockAttribute {
++ for attribute in attributes.split(",") {
++ match attribute.trim() {
++ "" | "rust" | "should_panic" | "no_run" | "edition2015" | "edition2018"
++ | "edition2021" => (),
++ "ignore" | "compile_fail" | "text" => return CodeBlockAttribute::NotRust,
++ _ => return CodeBlockAttribute::NotRust,
++ }
+ }
++ CodeBlockAttribute::Rust
+ }
+}
+
+/// Block that is formatted as an item.
+///
+/// An item starts with either a star `*` or a dash `-`. Different level of indentation are
+/// handled by shrinking the shape accordingly.
+struct ItemizedBlock {
+ /// the lines that are identified as part of an itemized block
+ lines: Vec<String>,
+ /// the number of whitespaces up to the item sigil
+ indent: usize,
+ /// the string that marks the start of an item
+ opener: String,
+ /// sequence of whitespaces to prefix new lines that are part of the item
+ line_start: String,
+}
+
+impl ItemizedBlock {
+ /// Returns `true` if the line is formatted as an item
+ fn is_itemized_line(line: &str) -> bool {
+ let trimmed = line.trim_start();
+ trimmed.starts_with("* ") || trimmed.starts_with("- ")
+ }
+
+ /// Creates a new ItemizedBlock described with the given line.
+ /// The `is_itemized_line` needs to be called first.
+ fn new(line: &str) -> ItemizedBlock {
+ let space_to_sigil = line.chars().take_while(|c| c.is_whitespace()).count();
+ let indent = space_to_sigil + 2;
+ ItemizedBlock {
+ lines: vec![line[indent..].to_string()],
+ indent,
+ opener: line[..indent].to_string(),
+ line_start: " ".repeat(indent),
+ }
+ }
+
+ /// Returns a `StringFormat` used for formatting the content of an item.
+ fn create_string_format<'a>(&'a self, fmt: &'a StringFormat<'_>) -> StringFormat<'a> {
+ StringFormat {
+ opener: "",
+ closer: "",
+ line_start: "",
+ line_end: "",
+ shape: Shape::legacy(fmt.shape.width.saturating_sub(self.indent), Indent::empty()),
+ trim_end: true,
+ config: fmt.config,
+ }
+ }
+
+ /// Returns `true` if the line is part of the current itemized block.
+ /// If it is, then it is added to the internal lines list.
+ fn add_line(&mut self, line: &str) -> bool {
+ if !ItemizedBlock::is_itemized_line(line)
+ && self.indent <= line.chars().take_while(|c| c.is_whitespace()).count()
+ {
+ self.lines.push(line.to_string());
+ return true;
+ }
+ false
+ }
+
+ /// Returns the block as a string, with each line trimmed at the start.
+ fn trimmed_block_as_string(&self) -> String {
+ self.lines
+ .iter()
+ .map(|line| format!("{} ", line.trim_start()))
+ .collect::<String>()
+ }
+
+ /// Returns the block as a string under its original form.
+ fn original_block_as_string(&self) -> String {
+ self.lines.join("\n")
+ }
+}
+
+struct CommentRewrite<'a> {
+ result: String,
+ code_block_buffer: String,
+ is_prev_line_multi_line: bool,
+ code_block_attr: Option<CodeBlockAttribute>,
+ item_block: Option<ItemizedBlock>,
+ comment_line_separator: String,
+ indent_str: String,
+ max_width: usize,
+ fmt_indent: Indent,
+ fmt: StringFormat<'a>,
+
+ opener: String,
+ closer: String,
+ line_start: String,
+}
+
+impl<'a> CommentRewrite<'a> {
+ fn new(
+ orig: &'a str,
+ block_style: bool,
+ shape: Shape,
+ config: &'a Config,
+ ) -> CommentRewrite<'a> {
+ let (opener, closer, line_start) = if block_style {
+ CommentStyle::SingleBullet.to_str_tuplet()
+ } else {
+ comment_style(orig, config.normalize_comments()).to_str_tuplet()
+ };
+
+ let max_width = shape
+ .width
+ .checked_sub(closer.len() + opener.len())
+ .unwrap_or(1);
+ let indent_str = shape.indent.to_string_with_newline(config).to_string();
+
+ let mut cr = CommentRewrite {
+ result: String::with_capacity(orig.len() * 2),
+ code_block_buffer: String::with_capacity(128),
+ is_prev_line_multi_line: false,
+ code_block_attr: None,
+ item_block: None,
+ comment_line_separator: format!("{}{}", indent_str, line_start),
+ max_width,
+ indent_str,
+ fmt_indent: shape.indent,
+
+ fmt: StringFormat {
+ opener: "",
+ closer: "",
+ line_start,
+ line_end: "",
+ shape: Shape::legacy(max_width, shape.indent),
+ trim_end: true,
+ config,
+ },
+
+ opener: opener.to_owned(),
+ closer: closer.to_owned(),
+ line_start: line_start.to_owned(),
+ };
+ cr.result.push_str(opener);
+ cr
+ }
+
+ fn join_block(s: &str, sep: &str) -> String {
+ let mut result = String::with_capacity(s.len() + 128);
+ let mut iter = s.lines().peekable();
+ while let Some(line) = iter.next() {
+ result.push_str(line);
+ result.push_str(match iter.peek() {
+ Some(next_line) if next_line.is_empty() => sep.trim_end(),
+ Some(..) => &sep,
+ None => "",
+ });
+ }
+ result
+ }
+
+ fn finish(mut self) -> String {
+ if !self.code_block_buffer.is_empty() {
+ // There is a code block that is not properly enclosed by backticks.
+ // We will leave them untouched.
+ self.result.push_str(&self.comment_line_separator);
+ self.result.push_str(&Self::join_block(
+ &trim_custom_comment_prefix(&self.code_block_buffer),
+ &self.comment_line_separator,
+ ));
+ }
+
+ if let Some(ref ib) = self.item_block {
+ // the last few lines are part of an itemized block
+ self.fmt.shape = Shape::legacy(self.max_width, self.fmt_indent);
+ let item_fmt = ib.create_string_format(&self.fmt);
+ self.result.push_str(&self.comment_line_separator);
+ self.result.push_str(&ib.opener);
+ match rewrite_string(
+ &ib.trimmed_block_as_string(),
+ &item_fmt,
+ self.max_width.saturating_sub(ib.indent),
+ ) {
+ Some(s) => self.result.push_str(&Self::join_block(
+ &s,
+ &format!("{}{}", self.comment_line_separator, ib.line_start),
+ )),
+ None => self.result.push_str(&Self::join_block(
+ &ib.original_block_as_string(),
+ &self.comment_line_separator,
+ )),
+ };
+ }
+
+ self.result.push_str(&self.closer);
+ if self.result.ends_with(&self.opener) && self.opener.ends_with(' ') {
+ // Trailing space.
+ self.result.pop();
+ }
+
+ self.result
+ }
+
+ fn handle_line(
+ &mut self,
+ orig: &'a str,
+ i: usize,
+ line: &'a str,
+ has_leading_whitespace: bool,
+ ) -> bool {
+ let is_last = i == count_newlines(orig);
+
+ if let Some(ref mut ib) = self.item_block {
+ if ib.add_line(&line) {
+ return false;
+ }
+ self.is_prev_line_multi_line = false;
+ self.fmt.shape = Shape::legacy(self.max_width, self.fmt_indent);
+ let item_fmt = ib.create_string_format(&self.fmt);
+ self.result.push_str(&self.comment_line_separator);
+ self.result.push_str(&ib.opener);
+ match rewrite_string(
+ &ib.trimmed_block_as_string(),
+ &item_fmt,
+ self.max_width.saturating_sub(ib.indent),
+ ) {
+ Some(s) => self.result.push_str(&Self::join_block(
+ &s,
+ &format!("{}{}", self.comment_line_separator, ib.line_start),
+ )),
+ None => self.result.push_str(&Self::join_block(
+ &ib.original_block_as_string(),
+ &self.comment_line_separator,
+ )),
+ };
+ } else if self.code_block_attr.is_some() {
+ if line.starts_with("```") {
+ let code_block = match self.code_block_attr.as_ref().unwrap() {
- if config.format_code_in_doc_comments() {
- if let Some(s) =
- crate::format_code_block(&self.code_block_buffer, &config, false)
- {
- trim_custom_comment_prefix(&s.snippet)
- } else {
- trim_custom_comment_prefix(&self.code_block_buffer)
- }
++ CodeBlockAttribute::Rust
++ if self.fmt.config.format_code_in_doc_comments()
++ && !self.code_block_buffer.is_empty() =>
++ {
+ let mut config = self.fmt.config.clone();
+ config.set().wrap_comments(false);
++ if let Some(s) =
++ crate::format_code_block(&self.code_block_buffer, &config, false)
++ {
++ trim_custom_comment_prefix(&s.snippet)
+ } else {
+ trim_custom_comment_prefix(&self.code_block_buffer)
+ }
+ }
++ _ => trim_custom_comment_prefix(&self.code_block_buffer),
+ };
+ if !code_block.is_empty() {
+ self.result.push_str(&self.comment_line_separator);
+ self.result
+ .push_str(&Self::join_block(&code_block, &self.comment_line_separator));
+ }
+ self.code_block_buffer.clear();
+ self.result.push_str(&self.comment_line_separator);
+ self.result.push_str(line);
+ self.code_block_attr = None;
+ } else {
+ self.code_block_buffer
+ .push_str(&hide_sharp_behind_comment(line));
+ self.code_block_buffer.push('\n');
+ }
+ return false;
+ }
+
+ self.code_block_attr = None;
+ self.item_block = None;
+ if let Some(stripped) = line.strip_prefix("```") {
+ self.code_block_attr = Some(CodeBlockAttribute::new(stripped))
+ } else if self.fmt.config.wrap_comments() && ItemizedBlock::is_itemized_line(&line) {
+ let ib = ItemizedBlock::new(&line);
+ self.item_block = Some(ib);
+ return false;
+ }
+
+ if self.result == self.opener {
+ let force_leading_whitespace = &self.opener == "/* " && count_newlines(orig) == 0;
+ if !has_leading_whitespace && !force_leading_whitespace && self.result.ends_with(' ') {
+ self.result.pop();
+ }
+ if line.is_empty() {
+ return false;
+ }
+ } else if self.is_prev_line_multi_line && !line.is_empty() {
+ self.result.push(' ')
+ } else if is_last && line.is_empty() {
+ // trailing blank lines are unwanted
+ if !self.closer.is_empty() {
+ self.result.push_str(&self.indent_str);
+ }
+ return true;
+ } else {
+ self.result.push_str(&self.comment_line_separator);
+ if !has_leading_whitespace && self.result.ends_with(' ') {
+ self.result.pop();
+ }
+ }
+
+ if self.fmt.config.wrap_comments()
+ && unicode_str_width(line) > self.fmt.shape.width
+ && !has_url(line)
+ {
+ match rewrite_string(line, &self.fmt, self.max_width) {
+ Some(ref s) => {
+ self.is_prev_line_multi_line = s.contains('\n');
+ self.result.push_str(s);
+ }
+ None if self.is_prev_line_multi_line => {
+ // We failed to put the current `line` next to the previous `line`.
+ // Remove the trailing space, then start rewrite on the next line.
+ self.result.pop();
+ self.result.push_str(&self.comment_line_separator);
+ self.fmt.shape = Shape::legacy(self.max_width, self.fmt_indent);
+ match rewrite_string(line, &self.fmt, self.max_width) {
+ Some(ref s) => {
+ self.is_prev_line_multi_line = s.contains('\n');
+ self.result.push_str(s);
+ }
+ None => {
+ self.is_prev_line_multi_line = false;
+ self.result.push_str(line);
+ }
+ }
+ }
+ None => {
+ self.is_prev_line_multi_line = false;
+ self.result.push_str(line);
+ }
+ }
+
+ self.fmt.shape = if self.is_prev_line_multi_line {
+ // 1 = " "
+ let offset = 1 + last_line_width(&self.result) - self.line_start.len();
+ Shape {
+ width: self.max_width.saturating_sub(offset),
+ indent: self.fmt_indent,
+ offset: self.fmt.shape.offset + offset,
+ }
+ } else {
+ Shape::legacy(self.max_width, self.fmt_indent)
+ };
+ } else {
+ if line.is_empty() && self.result.ends_with(' ') && !is_last {
+ // Remove space if this is an empty comment or a doc comment.
+ self.result.pop();
+ }
+ self.result.push_str(line);
+ self.fmt.shape = Shape::legacy(self.max_width, self.fmt_indent);
+ self.is_prev_line_multi_line = false;
+ }
+
+ false
+ }
+}
+
+fn rewrite_comment_inner(
+ orig: &str,
+ block_style: bool,
+ style: CommentStyle<'_>,
+ shape: Shape,
+ config: &Config,
+ is_doc_comment: bool,
+) -> Option<String> {
+ let mut rewriter = CommentRewrite::new(orig, block_style, shape, config);
+
+ let line_breaks = count_newlines(orig.trim_end());
+ let lines = orig
+ .lines()
+ .enumerate()
+ .map(|(i, mut line)| {
+ line = trim_end_unless_two_whitespaces(line.trim_start(), is_doc_comment);
+ // Drop old closer.
+ if i == line_breaks && line.ends_with("*/") && !line.starts_with("//") {
+ line = line[..(line.len() - 2)].trim_end();
+ }
+
+ line
+ })
+ .map(|s| left_trim_comment_line(s, &style))
+ .map(|(line, has_leading_whitespace)| {
+ if orig.starts_with("/*") && line_breaks == 0 {
+ (
+ line.trim_start(),
+ has_leading_whitespace || config.normalize_comments(),
+ )
+ } else {
+ (line, has_leading_whitespace || config.normalize_comments())
+ }
+ });
+
+ for (i, (line, has_leading_whitespace)) in lines.enumerate() {
+ if rewriter.handle_line(orig, i, line, has_leading_whitespace) {
+ break;
+ }
+ }
+
+ Some(rewriter.finish())
+}
+
+const RUSTFMT_CUSTOM_COMMENT_PREFIX: &str = "//#### ";
+
+fn hide_sharp_behind_comment(s: &str) -> Cow<'_, str> {
+ let s_trimmed = s.trim();
+ if s_trimmed.starts_with("# ") || s_trimmed == "#" {
+ Cow::from(format!("{}{}", RUSTFMT_CUSTOM_COMMENT_PREFIX, s))
+ } else {
+ Cow::from(s)
+ }
+}
+
+fn trim_custom_comment_prefix(s: &str) -> String {
+ s.lines()
+ .map(|line| {
+ let left_trimmed = line.trim_start();
+ if left_trimmed.starts_with(RUSTFMT_CUSTOM_COMMENT_PREFIX) {
+ left_trimmed.trim_start_matches(RUSTFMT_CUSTOM_COMMENT_PREFIX)
+ } else {
+ line
+ }
+ })
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+/// Returns `true` if the given string MAY include URLs or alike.
+fn has_url(s: &str) -> bool {
+ // This function may return false positive, but should get its job done in most cases.
+ s.contains("https://") || s.contains("http://") || s.contains("ftp://") || s.contains("file://")
+}
+
+/// Given the span, rewrite the missing comment inside it if available.
+/// Note that the given span must only include comments (or leading/trailing whitespaces).
+pub(crate) fn rewrite_missing_comment(
+ span: Span,
+ shape: Shape,
+ context: &RewriteContext<'_>,
+) -> Option<String> {
+ let missing_snippet = context.snippet(span);
+ let trimmed_snippet = missing_snippet.trim();
+ // check the span starts with a comment
+ let pos = trimmed_snippet.find('/');
+ if !trimmed_snippet.is_empty() && pos.is_some() {
+ rewrite_comment(trimmed_snippet, false, shape, context.config)
+ } else {
+ Some(String::new())
+ }
+}
+
+/// Recover the missing comments in the specified span, if available.
+/// The layout of the comments will be preserved as long as it does not break the code
+/// and its total width does not exceed the max width.
+pub(crate) fn recover_missing_comment_in_span(
+ span: Span,
+ shape: Shape,
+ context: &RewriteContext<'_>,
+ used_width: usize,
+) -> Option<String> {
+ let missing_comment = rewrite_missing_comment(span, shape, context)?;
+ if missing_comment.is_empty() {
+ Some(String::new())
+ } else {
+ let missing_snippet = context.snippet(span);
+ let pos = missing_snippet.find('/')?;
+ // 1 = ` `
+ let total_width = missing_comment.len() + used_width + 1;
+ let force_new_line_before_comment =
+ missing_snippet[..pos].contains('\n') || total_width > context.config.max_width();
+ let sep = if force_new_line_before_comment {
+ shape.indent.to_string_with_newline(context.config)
+ } else {
+ Cow::from(" ")
+ };
+ Some(format!("{}{}", sep, missing_comment))
+ }
+}
+
+/// Trim trailing whitespaces unless they consist of two or more whitespaces.
+fn trim_end_unless_two_whitespaces(s: &str, is_doc_comment: bool) -> &str {
+ if is_doc_comment && s.ends_with(" ") {
+ s
+ } else {
+ s.trim_end()
+ }
+}
+
+/// Trims whitespace and aligns to indent, but otherwise does not change comments.
+fn light_rewrite_comment(
+ orig: &str,
+ offset: Indent,
+ config: &Config,
+ is_doc_comment: bool,
+) -> String {
+ let lines: Vec<&str> = orig
+ .lines()
+ .map(|l| {
+ // This is basically just l.trim(), but in the case that a line starts
+ // with `*` we want to leave one space before it, so it aligns with the
+ // `*` in `/*`.
+ let first_non_whitespace = l.find(|c| !char::is_whitespace(c));
+ let left_trimmed = if let Some(fnw) = first_non_whitespace {
+ if l.as_bytes()[fnw] == b'*' && fnw > 0 {
+ &l[fnw - 1..]
+ } else {
+ &l[fnw..]
+ }
+ } else {
+ ""
+ };
+ // Preserve markdown's double-space line break syntax in doc comment.
+ trim_end_unless_two_whitespaces(left_trimmed, is_doc_comment)
+ })
+ .collect();
+ lines.join(&format!("\n{}", offset.to_string(config)))
+}
+
+/// Trims comment characters and possibly a single space from the left of a string.
+/// Does not trim all whitespace. If a single space is trimmed from the left of the string,
+/// this function returns true.
+fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle<'_>) -> (&'a str, bool) {
+ if line.starts_with("//! ")
+ || line.starts_with("/// ")
+ || line.starts_with("/*! ")
+ || line.starts_with("/** ")
+ {
+ (&line[4..], true)
+ } else if let CommentStyle::Custom(opener) = *style {
+ if let Some(ref stripped) = line.strip_prefix(opener) {
+ (stripped, true)
+ } else {
+ (&line[opener.trim_end().len()..], false)
+ }
+ } else if line.starts_with("/* ")
+ || line.starts_with("// ")
+ || line.starts_with("//!")
+ || line.starts_with("///")
+ || line.starts_with("** ")
+ || line.starts_with("/*!")
+ || (line.starts_with("/**") && !line.starts_with("/**/"))
+ {
+ (&line[3..], line.chars().nth(2).unwrap() == ' ')
+ } else if line.starts_with("/*")
+ || line.starts_with("* ")
+ || line.starts_with("//")
+ || line.starts_with("**")
+ {
+ (&line[2..], line.chars().nth(1).unwrap() == ' ')
+ } else if let Some(stripped) = line.strip_prefix('*') {
+ (stripped, false)
+ } else {
+ (line, line.starts_with(' '))
+ }
+}
+
+pub(crate) trait FindUncommented {
+ fn find_uncommented(&self, pat: &str) -> Option<usize>;
+ fn find_last_uncommented(&self, pat: &str) -> Option<usize>;
+}
+
+impl FindUncommented for str {
+ fn find_uncommented(&self, pat: &str) -> Option<usize> {
+ let mut needle_iter = pat.chars();
+ for (kind, (i, b)) in CharClasses::new(self.char_indices()) {
+ match needle_iter.next() {
+ None => {
+ return Some(i - pat.len());
+ }
+ Some(c) => match kind {
+ FullCodeCharKind::Normal | FullCodeCharKind::InString if b == c => {}
+ _ => {
+ needle_iter = pat.chars();
+ }
+ },
+ }
+ }
+
+ // Handle case where the pattern is a suffix of the search string
+ match needle_iter.next() {
+ Some(_) => None,
+ None => Some(self.len() - pat.len()),
+ }
+ }
+
+ fn find_last_uncommented(&self, pat: &str) -> Option<usize> {
+ if let Some(left) = self.find_uncommented(pat) {
+ let mut result = left;
+ // add 1 to use find_last_uncommented for &str after pat
+ while let Some(next) = self[(result + 1)..].find_last_uncommented(pat) {
+ result += next + 1;
+ }
+ Some(result)
+ } else {
+ None
+ }
+ }
+}
+
+// Returns the first byte position after the first comment. The given string
+// is expected to be prefixed by a comment, including delimiters.
+// Good: `/* /* inner */ outer */ code();`
+// Bad: `code(); // hello\n world!`
+pub(crate) fn find_comment_end(s: &str) -> Option<usize> {
+ let mut iter = CharClasses::new(s.char_indices());
+ for (kind, (i, _c)) in &mut iter {
+ if kind == FullCodeCharKind::Normal || kind == FullCodeCharKind::InString {
+ return Some(i);
+ }
+ }
+
+ // Handle case where the comment ends at the end of `s`.
+ if iter.status == CharClassesStatus::Normal {
+ Some(s.len())
+ } else {
+ None
+ }
+}
+
+/// Returns `true` if text contains any comment.
+pub(crate) fn contains_comment(text: &str) -> bool {
+ CharClasses::new(text.chars()).any(|(kind, _)| kind.is_comment())
+}
+
+pub(crate) struct CharClasses<T>
+where
+ T: Iterator,
+ T::Item: RichChar,
+{
+ base: MultiPeek<T>,
+ status: CharClassesStatus,
+}
+
+pub(crate) trait RichChar {
+ fn get_char(&self) -> char;
+}
+
+impl RichChar for char {
+ fn get_char(&self) -> char {
+ *self
+ }
+}
+
+impl RichChar for (usize, char) {
+ fn get_char(&self) -> char {
+ self.1
+ }
+}
+
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
+enum CharClassesStatus {
+ Normal,
+ /// Character is within a string
+ LitString,
+ LitStringEscape,
+ /// Character is within a raw string
+ LitRawString(u32),
+ RawStringPrefix(u32),
+ RawStringSuffix(u32),
+ LitChar,
+ LitCharEscape,
+ /// Character inside a block comment, with the integer indicating the nesting deepness of the
+ /// comment
+ BlockComment(u32),
+ /// Character inside a block-commented string, with the integer indicating the nesting deepness
+ /// of the comment
+ StringInBlockComment(u32),
+ /// Status when the '/' has been consumed, but not yet the '*', deepness is
+ /// the new deepness (after the comment opening).
+ BlockCommentOpening(u32),
+ /// Status when the '*' has been consumed, but not yet the '/', deepness is
+ /// the new deepness (after the comment closing).
+ BlockCommentClosing(u32),
+ /// Character is within a line comment
+ LineComment,
+}
+
+/// Distinguish between functional part of code and comments
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
+pub(crate) enum CodeCharKind {
+ Normal,
+ Comment,
+}
+
+/// Distinguish between functional part of code and comments,
+/// describing opening and closing of comments for ease when chunking
+/// code from tagged characters
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
+pub(crate) enum FullCodeCharKind {
+ Normal,
+ /// The first character of a comment, there is only one for a comment (always '/')
+ StartComment,
+ /// Any character inside a comment including the second character of comment
+ /// marks ("//", "/*")
+ InComment,
+ /// Last character of a comment, '\n' for a line comment, '/' for a block comment.
+ EndComment,
+ /// Start of a mutlitine string inside a comment
+ StartStringCommented,
+ /// End of a mutlitine string inside a comment
+ EndStringCommented,
+ /// Inside a commented string
+ InStringCommented,
+ /// Start of a mutlitine string
+ StartString,
+ /// End of a mutlitine string
+ EndString,
+ /// Inside a string.
+ InString,
+}
+
+impl FullCodeCharKind {
+ pub(crate) fn is_comment(self) -> bool {
+ match self {
+ FullCodeCharKind::StartComment
+ | FullCodeCharKind::InComment
+ | FullCodeCharKind::EndComment
+ | FullCodeCharKind::StartStringCommented
+ | FullCodeCharKind::InStringCommented
+ | FullCodeCharKind::EndStringCommented => true,
+ _ => false,
+ }
+ }
+
+ /// Returns true if the character is inside a comment
+ pub(crate) fn inside_comment(self) -> bool {
+ match self {
+ FullCodeCharKind::InComment
+ | FullCodeCharKind::StartStringCommented
+ | FullCodeCharKind::InStringCommented
+ | FullCodeCharKind::EndStringCommented => true,
+ _ => false,
+ }
+ }
+
+ pub(crate) fn is_string(self) -> bool {
+ self == FullCodeCharKind::InString || self == FullCodeCharKind::StartString
+ }
+
+ /// Returns true if the character is within a commented string
+ pub(crate) fn is_commented_string(self) -> bool {
+ self == FullCodeCharKind::InStringCommented
+ || self == FullCodeCharKind::StartStringCommented
+ }
+
+ fn to_codecharkind(self) -> CodeCharKind {
+ if self.is_comment() {
+ CodeCharKind::Comment
+ } else {
+ CodeCharKind::Normal
+ }
+ }
+}
+
+impl<T> CharClasses<T>
+where
+ T: Iterator,
+ T::Item: RichChar,
+{
+ pub(crate) fn new(base: T) -> CharClasses<T> {
+ CharClasses {
+ base: multipeek(base),
+ status: CharClassesStatus::Normal,
+ }
+ }
+}
+
+fn is_raw_string_suffix<T>(iter: &mut MultiPeek<T>, count: u32) -> bool
+where
+ T: Iterator,
+ T::Item: RichChar,
+{
+ for _ in 0..count {
+ match iter.peek() {
+ Some(c) if c.get_char() == '#' => continue,
+ _ => return false,
+ }
+ }
+ true
+}
+
+impl<T> Iterator for CharClasses<T>
+where
+ T: Iterator,
+ T::Item: RichChar,
+{
+ type Item = (FullCodeCharKind, T::Item);
+
+ fn next(&mut self) -> Option<(FullCodeCharKind, T::Item)> {
+ let item = self.base.next()?;
+ let chr = item.get_char();
+ let mut char_kind = FullCodeCharKind::Normal;
+ self.status = match self.status {
+ CharClassesStatus::LitRawString(sharps) => {
+ char_kind = FullCodeCharKind::InString;
+ match chr {
+ '"' => {
+ if sharps == 0 {
+ char_kind = FullCodeCharKind::Normal;
+ CharClassesStatus::Normal
+ } else if is_raw_string_suffix(&mut self.base, sharps) {
+ CharClassesStatus::RawStringSuffix(sharps)
+ } else {
+ CharClassesStatus::LitRawString(sharps)
+ }
+ }
+ _ => CharClassesStatus::LitRawString(sharps),
+ }
+ }
+ CharClassesStatus::RawStringPrefix(sharps) => {
+ char_kind = FullCodeCharKind::InString;
+ match chr {
+ '#' => CharClassesStatus::RawStringPrefix(sharps + 1),
+ '"' => CharClassesStatus::LitRawString(sharps),
+ _ => CharClassesStatus::Normal, // Unreachable.
+ }
+ }
+ CharClassesStatus::RawStringSuffix(sharps) => {
+ match chr {
+ '#' => {
+ if sharps == 1 {
+ CharClassesStatus::Normal
+ } else {
+ char_kind = FullCodeCharKind::InString;
+ CharClassesStatus::RawStringSuffix(sharps - 1)
+ }
+ }
+ _ => CharClassesStatus::Normal, // Unreachable
+ }
+ }
+ CharClassesStatus::LitString => {
+ char_kind = FullCodeCharKind::InString;
+ match chr {
+ '"' => CharClassesStatus::Normal,
+ '\\' => CharClassesStatus::LitStringEscape,
+ _ => CharClassesStatus::LitString,
+ }
+ }
+ CharClassesStatus::LitStringEscape => {
+ char_kind = FullCodeCharKind::InString;
+ CharClassesStatus::LitString
+ }
+ CharClassesStatus::LitChar => match chr {
+ '\\' => CharClassesStatus::LitCharEscape,
+ '\'' => CharClassesStatus::Normal,
+ _ => CharClassesStatus::LitChar,
+ },
+ CharClassesStatus::LitCharEscape => CharClassesStatus::LitChar,
+ CharClassesStatus::Normal => match chr {
+ 'r' => match self.base.peek().map(RichChar::get_char) {
+ Some('#') | Some('"') => {
+ char_kind = FullCodeCharKind::InString;
+ CharClassesStatus::RawStringPrefix(0)
+ }
+ _ => CharClassesStatus::Normal,
+ },
+ '"' => {
+ char_kind = FullCodeCharKind::InString;
+ CharClassesStatus::LitString
+ }
+ '\'' => {
+ // HACK: Work around mut borrow.
+ match self.base.peek() {
+ Some(next) if next.get_char() == '\\' => {
+ self.status = CharClassesStatus::LitChar;
+ return Some((char_kind, item));
+ }
+ _ => (),
+ }
+
+ match self.base.peek() {
+ Some(next) if next.get_char() == '\'' => CharClassesStatus::LitChar,
+ _ => CharClassesStatus::Normal,
+ }
+ }
+ '/' => match self.base.peek() {
+ Some(next) if next.get_char() == '*' => {
+ self.status = CharClassesStatus::BlockCommentOpening(1);
+ return Some((FullCodeCharKind::StartComment, item));
+ }
+ Some(next) if next.get_char() == '/' => {
+ self.status = CharClassesStatus::LineComment;
+ return Some((FullCodeCharKind::StartComment, item));
+ }
+ _ => CharClassesStatus::Normal,
+ },
+ _ => CharClassesStatus::Normal,
+ },
+ CharClassesStatus::StringInBlockComment(deepness) => {
+ char_kind = FullCodeCharKind::InStringCommented;
+ if chr == '"' {
+ CharClassesStatus::BlockComment(deepness)
+ } else if chr == '*' && self.base.peek().map(RichChar::get_char) == Some('/') {
+ char_kind = FullCodeCharKind::InComment;
+ CharClassesStatus::BlockCommentClosing(deepness - 1)
+ } else {
+ CharClassesStatus::StringInBlockComment(deepness)
+ }
+ }
+ CharClassesStatus::BlockComment(deepness) => {
+ assert_ne!(deepness, 0);
+ char_kind = FullCodeCharKind::InComment;
+ match self.base.peek() {
+ Some(next) if next.get_char() == '/' && chr == '*' => {
+ CharClassesStatus::BlockCommentClosing(deepness - 1)
+ }
+ Some(next) if next.get_char() == '*' && chr == '/' => {
+ CharClassesStatus::BlockCommentOpening(deepness + 1)
+ }
+ _ if chr == '"' => CharClassesStatus::StringInBlockComment(deepness),
+ _ => self.status,
+ }
+ }
+ CharClassesStatus::BlockCommentOpening(deepness) => {
+ assert_eq!(chr, '*');
+ self.status = CharClassesStatus::BlockComment(deepness);
+ return Some((FullCodeCharKind::InComment, item));
+ }
+ CharClassesStatus::BlockCommentClosing(deepness) => {
+ assert_eq!(chr, '/');
+ if deepness == 0 {
+ self.status = CharClassesStatus::Normal;
+ return Some((FullCodeCharKind::EndComment, item));
+ } else {
+ self.status = CharClassesStatus::BlockComment(deepness);
+ return Some((FullCodeCharKind::InComment, item));
+ }
+ }
+ CharClassesStatus::LineComment => match chr {
+ '\n' => {
+ self.status = CharClassesStatus::Normal;
+ return Some((FullCodeCharKind::EndComment, item));
+ }
+ _ => {
+ self.status = CharClassesStatus::LineComment;
+ return Some((FullCodeCharKind::InComment, item));
+ }
+ },
+ };
+ Some((char_kind, item))
+ }
+}
+
+/// An iterator over the lines of a string, paired with the char kind at the
+/// end of the line.
+pub(crate) struct LineClasses<'a> {
+ base: iter::Peekable<CharClasses<std::str::Chars<'a>>>,
+ kind: FullCodeCharKind,
+}
+
+impl<'a> LineClasses<'a> {
+ pub(crate) fn new(s: &'a str) -> Self {
+ LineClasses {
+ base: CharClasses::new(s.chars()).peekable(),
+ kind: FullCodeCharKind::Normal,
+ }
+ }
+}
+
+impl<'a> Iterator for LineClasses<'a> {
+ type Item = (FullCodeCharKind, String);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.base.peek()?;
+
+ let mut line = String::new();
+
+ let start_kind = match self.base.peek() {
+ Some((kind, _)) => *kind,
+ None => unreachable!(),
+ };
+
+ while let Some((kind, c)) = self.base.next() {
+ // needed to set the kind of the ending character on the last line
+ self.kind = kind;
+ if c == '\n' {
+ self.kind = match (start_kind, kind) {
+ (FullCodeCharKind::Normal, FullCodeCharKind::InString) => {
+ FullCodeCharKind::StartString
+ }
+ (FullCodeCharKind::InString, FullCodeCharKind::Normal) => {
+ FullCodeCharKind::EndString
+ }
+ (FullCodeCharKind::InComment, FullCodeCharKind::InStringCommented) => {
+ FullCodeCharKind::StartStringCommented
+ }
+ (FullCodeCharKind::InStringCommented, FullCodeCharKind::InComment) => {
+ FullCodeCharKind::EndStringCommented
+ }
+ _ => kind,
+ };
+ break;
+ }
+ line.push(c);
+ }
+
+ // Workaround for CRLF newline.
+ if line.ends_with('\r') {
+ line.pop();
+ }
+
+ Some((self.kind, line))
+ }
+}
+
+/// Iterator over functional and commented parts of a string. Any part of a string is either
+/// functional code, either *one* block comment, either *one* line comment. Whitespace between
+/// comments is functional code. Line comments contain their ending newlines.
+struct UngroupedCommentCodeSlices<'a> {
+ slice: &'a str,
+ iter: iter::Peekable<CharClasses<std::str::CharIndices<'a>>>,
+}
+
+impl<'a> UngroupedCommentCodeSlices<'a> {
+ fn new(code: &'a str) -> UngroupedCommentCodeSlices<'a> {
+ UngroupedCommentCodeSlices {
+ slice: code,
+ iter: CharClasses::new(code.char_indices()).peekable(),
+ }
+ }
+}
+
+impl<'a> Iterator for UngroupedCommentCodeSlices<'a> {
+ type Item = (CodeCharKind, usize, &'a str);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let (kind, (start_idx, _)) = self.iter.next()?;
+ match kind {
+ FullCodeCharKind::Normal | FullCodeCharKind::InString => {
+ // Consume all the Normal code
+ while let Some(&(char_kind, _)) = self.iter.peek() {
+ if char_kind.is_comment() {
+ break;
+ }
+ let _ = self.iter.next();
+ }
+ }
+ FullCodeCharKind::StartComment => {
+ // Consume the whole comment
+ loop {
+ match self.iter.next() {
+ Some((kind, ..)) if kind.inside_comment() => continue,
+ _ => break,
+ }
+ }
+ }
+ _ => panic!(),
+ }
+ let slice = match self.iter.peek() {
+ Some(&(_, (end_idx, _))) => &self.slice[start_idx..end_idx],
+ None => &self.slice[start_idx..],
+ };
+ Some((
+ if kind.is_comment() {
+ CodeCharKind::Comment
+ } else {
+ CodeCharKind::Normal
+ },
+ start_idx,
+ slice,
+ ))
+ }
+}
+
+/// Iterator over an alternating sequence of functional and commented parts of
+/// a string. The first item is always a, possibly zero length, subslice of
+/// functional text. Line style comments contain their ending newlines.
+pub(crate) struct CommentCodeSlices<'a> {
+ slice: &'a str,
+ last_slice_kind: CodeCharKind,
+ last_slice_end: usize,
+}
+
+impl<'a> CommentCodeSlices<'a> {
+ pub(crate) fn new(slice: &'a str) -> CommentCodeSlices<'a> {
+ CommentCodeSlices {
+ slice,
+ last_slice_kind: CodeCharKind::Comment,
+ last_slice_end: 0,
+ }
+ }
+}
+
+impl<'a> Iterator for CommentCodeSlices<'a> {
+ type Item = (CodeCharKind, usize, &'a str);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ if self.last_slice_end == self.slice.len() {
+ return None;
+ }
+
+ let mut sub_slice_end = self.last_slice_end;
+ let mut first_whitespace = None;
+ let subslice = &self.slice[self.last_slice_end..];
+ let mut iter = CharClasses::new(subslice.char_indices());
+
+ for (kind, (i, c)) in &mut iter {
+ let is_comment_connector = self.last_slice_kind == CodeCharKind::Normal
+ && &subslice[..2] == "//"
+ && [' ', '\t'].contains(&c);
+
+ if is_comment_connector && first_whitespace.is_none() {
+ first_whitespace = Some(i);
+ }
+
+ if kind.to_codecharkind() == self.last_slice_kind && !is_comment_connector {
+ let last_index = match first_whitespace {
+ Some(j) => j,
+ None => i,
+ };
+ sub_slice_end = self.last_slice_end + last_index;
+ break;
+ }
+
+ if !is_comment_connector {
+ first_whitespace = None;
+ }
+ }
+
+ if let (None, true) = (iter.next(), sub_slice_end == self.last_slice_end) {
+ // This was the last subslice.
+ sub_slice_end = match first_whitespace {
+ Some(i) => self.last_slice_end + i,
+ None => self.slice.len(),
+ };
+ }
+
+ let kind = match self.last_slice_kind {
+ CodeCharKind::Comment => CodeCharKind::Normal,
+ CodeCharKind::Normal => CodeCharKind::Comment,
+ };
+ let res = (
+ kind,
+ self.last_slice_end,
+ &self.slice[self.last_slice_end..sub_slice_end],
+ );
+ self.last_slice_end = sub_slice_end;
+ self.last_slice_kind = kind;
+
+ Some(res)
+ }
+}
+
+/// Checks is `new` didn't miss any comment from `span`, if it removed any, return previous text
+/// (if it fits in the width/offset, else return `None`), else return `new`
+pub(crate) fn recover_comment_removed(
+ new: String,
+ span: Span,
+ context: &RewriteContext<'_>,
+) -> Option<String> {
+ let snippet = context.snippet(span);
+ if snippet != new && changed_comment_content(snippet, &new) {
+ // We missed some comments. Warn and keep the original text.
+ if context.config.error_on_unformatted() {
+ context.report.append(
+ context.parse_sess.span_to_filename(span),
+ vec![FormattingError::from_span(
+ span,
+ &context.parse_sess,
+ ErrorKind::LostComment,
+ )],
+ );
+ }
+ Some(snippet.to_owned())
+ } else {
+ Some(new)
+ }
+}
+
+pub(crate) fn filter_normal_code(code: &str) -> String {
+ let mut buffer = String::with_capacity(code.len());
+ LineClasses::new(code).for_each(|(kind, line)| match kind {
+ FullCodeCharKind::Normal
+ | FullCodeCharKind::StartString
+ | FullCodeCharKind::InString
+ | FullCodeCharKind::EndString => {
+ buffer.push_str(&line);
+ buffer.push('\n');
+ }
+ _ => (),
+ });
+ if !code.ends_with('\n') && buffer.ends_with('\n') {
+ buffer.pop();
+ }
+ buffer
+}
+
+/// Returns `true` if the two strings of code have the same payload of comments.
+/// The payload of comments is everything in the string except:
+/// - actual code (not comments),
+/// - comment start/end marks,
+/// - whitespace,
+/// - '*' at the beginning of lines in block comments.
+fn changed_comment_content(orig: &str, new: &str) -> bool {
+ // Cannot write this as a fn since we cannot return types containing closures.
+ let code_comment_content = |code| {
+ let slices = UngroupedCommentCodeSlices::new(code);
+ slices
+ .filter(|&(ref kind, _, _)| *kind == CodeCharKind::Comment)
+ .flat_map(|(_, _, s)| CommentReducer::new(s))
+ };
+ let res = code_comment_content(orig).ne(code_comment_content(new));
+ debug!(
+ "comment::changed_comment_content: {}\norig: '{}'\nnew: '{}'\nraw_old: {}\nraw_new: {}",
+ res,
+ orig,
+ new,
+ code_comment_content(orig).collect::<String>(),
+ code_comment_content(new).collect::<String>()
+ );
+ res
+}
+
+/// Iterator over the 'payload' characters of a comment.
+/// It skips whitespace, comment start/end marks, and '*' at the beginning of lines.
+/// The comment must be one comment, ie not more than one start mark (no multiple line comments,
+/// for example).
+struct CommentReducer<'a> {
+ is_block: bool,
+ at_start_line: bool,
+ iter: std::str::Chars<'a>,
+}
+
+impl<'a> CommentReducer<'a> {
+ fn new(comment: &'a str) -> CommentReducer<'a> {
+ let is_block = comment.starts_with("/*");
+ let comment = remove_comment_header(comment);
+ CommentReducer {
+ is_block,
+ // There are no supplementary '*' on the first line.
+ at_start_line: false,
+ iter: comment.chars(),
+ }
+ }
+}
+
+impl<'a> Iterator for CommentReducer<'a> {
+ type Item = char;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ loop {
+ let mut c = self.iter.next()?;
+ if self.is_block && self.at_start_line {
+ while c.is_whitespace() {
+ c = self.iter.next()?;
+ }
+ // Ignore leading '*'.
+ if c == '*' {
+ c = self.iter.next()?;
+ }
+ } else if c == '\n' {
+ self.at_start_line = true;
+ }
+ if !c.is_whitespace() {
+ return Some(c);
+ }
+ }
+ }
+}
+
+fn remove_comment_header(comment: &str) -> &str {
+ if comment.starts_with("///") || comment.starts_with("//!") {
+ &comment[3..]
+ } else if let Some(ref stripped) = comment.strip_prefix("//") {
+ stripped
+ } else if (comment.starts_with("/**") && !comment.starts_with("/**/"))
+ || comment.starts_with("/*!")
+ {
+ &comment[3..comment.len() - 2]
+ } else {
+ assert!(
+ comment.starts_with("/*"),
+ "string '{}' is not a comment",
+ comment
+ );
+ &comment[2..comment.len() - 2]
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::shape::{Indent, Shape};
+
+ #[test]
+ fn char_classes() {
+ let mut iter = CharClasses::new("//\n\n".chars());
+
+ assert_eq!((FullCodeCharKind::StartComment, '/'), iter.next().unwrap());
+ assert_eq!((FullCodeCharKind::InComment, '/'), iter.next().unwrap());
+ assert_eq!((FullCodeCharKind::EndComment, '\n'), iter.next().unwrap());
+ assert_eq!((FullCodeCharKind::Normal, '\n'), iter.next().unwrap());
+ assert_eq!(None, iter.next());
+ }
+
+ #[test]
+ fn comment_code_slices() {
+ let input = "code(); /* test */ 1 + 1";
+ let mut iter = CommentCodeSlices::new(input);
+
+ assert_eq!((CodeCharKind::Normal, 0, "code(); "), iter.next().unwrap());
+ assert_eq!(
+ (CodeCharKind::Comment, 8, "/* test */"),
+ iter.next().unwrap()
+ );
+ assert_eq!((CodeCharKind::Normal, 18, " 1 + 1"), iter.next().unwrap());
+ assert_eq!(None, iter.next());
+ }
+
+ #[test]
+ fn comment_code_slices_two() {
+ let input = "// comment\n test();";
+ let mut iter = CommentCodeSlices::new(input);
+
+ assert_eq!((CodeCharKind::Normal, 0, ""), iter.next().unwrap());
+ assert_eq!(
+ (CodeCharKind::Comment, 0, "// comment\n"),
+ iter.next().unwrap()
+ );
+ assert_eq!(
+ (CodeCharKind::Normal, 11, " test();"),
+ iter.next().unwrap()
+ );
+ assert_eq!(None, iter.next());
+ }
+
+ #[test]
+ fn comment_code_slices_three() {
+ let input = "1 // comment\n // comment2\n\n";
+ let mut iter = CommentCodeSlices::new(input);
+
+ assert_eq!((CodeCharKind::Normal, 0, "1 "), iter.next().unwrap());
+ assert_eq!(
+ (CodeCharKind::Comment, 2, "// comment\n // comment2\n"),
+ iter.next().unwrap()
+ );
+ assert_eq!((CodeCharKind::Normal, 29, "\n"), iter.next().unwrap());
+ assert_eq!(None, iter.next());
+ }
+
+ #[test]
+ #[rustfmt::skip]
+ fn format_doc_comments() {
+ let mut wrap_normalize_config: crate::config::Config = Default::default();
+ wrap_normalize_config.set().wrap_comments(true);
+ wrap_normalize_config.set().normalize_comments(true);
+
+ let mut wrap_config: crate::config::Config = Default::default();
+ wrap_config.set().wrap_comments(true);
+
+ let comment = rewrite_comment(" //test",
+ true,
+ Shape::legacy(100, Indent::new(0, 100)),
+ &wrap_normalize_config).unwrap();
+ assert_eq!("/* test */", comment);
+
+ let comment = rewrite_comment("// comment on a",
+ false,
+ Shape::legacy(10, Indent::empty()),
+ &wrap_normalize_config).unwrap();
+ assert_eq!("// comment\n// on a", comment);
+
+ let comment = rewrite_comment("// A multi line comment\n // between args.",
+ false,
+ Shape::legacy(60, Indent::new(0, 12)),
+ &wrap_normalize_config).unwrap();
+ assert_eq!("// A multi line comment\n // between args.", comment);
+
+ let input = "// comment";
+ let expected =
+ "/* comment */";
+ let comment = rewrite_comment(input,
+ true,
+ Shape::legacy(9, Indent::new(0, 69)),
+ &wrap_normalize_config).unwrap();
+ assert_eq!(expected, comment);
+
+ let comment = rewrite_comment("/* trimmed */",
+ true,
+ Shape::legacy(100, Indent::new(0, 100)),
+ &wrap_normalize_config).unwrap();
+ assert_eq!("/* trimmed */", comment);
+
+ // Check that different comment style are properly recognised.
+ let comment = rewrite_comment(r#"/// test1
+ /// test2
+ /*
+ * test3
+ */"#,
+ false,
+ Shape::legacy(100, Indent::new(0, 0)),
+ &wrap_normalize_config).unwrap();
+ assert_eq!("/// test1\n/// test2\n// test3", comment);
+
+ // Check that the blank line marks the end of a commented paragraph.
+ let comment = rewrite_comment(r#"// test1
+
+ // test2"#,
+ false,
+ Shape::legacy(100, Indent::new(0, 0)),
+ &wrap_normalize_config).unwrap();
+ assert_eq!("// test1\n\n// test2", comment);
+
+ // Check that the blank line marks the end of a custom-commented paragraph.
+ let comment = rewrite_comment(r#"//@ test1
+
+ //@ test2"#,
+ false,
+ Shape::legacy(100, Indent::new(0, 0)),
+ &wrap_normalize_config).unwrap();
+ assert_eq!("//@ test1\n\n//@ test2", comment);
+
+ // Check that bare lines are just indented but otherwise left unchanged.
+ let comment = rewrite_comment(r#"// test1
+ /*
+ a bare line!
+
+ another bare line!
+ */"#,
+ false,
+ Shape::legacy(100, Indent::new(0, 0)),
+ &wrap_config).unwrap();
+ assert_eq!("// test1\n/*\n a bare line!\n\n another bare line!\n*/", comment);
+ }
+
+ // This is probably intended to be a non-test fn, but it is not used.
+ // We should keep this around unless it helps us test stuff to remove it.
+ fn uncommented(text: &str) -> String {
+ CharClasses::new(text.chars())
+ .filter_map(|(s, c)| match s {
+ FullCodeCharKind::Normal | FullCodeCharKind::InString => Some(c),
+ _ => None,
+ })
+ .collect()
+ }
+
+ #[test]
+ fn test_uncommented() {
+ assert_eq!(&uncommented("abc/*...*/"), "abc");
+ assert_eq!(
+ &uncommented("// .... /* \n../* /* *** / */ */a/* // */c\n"),
+ "..ac\n"
+ );
+ assert_eq!(&uncommented("abc \" /* */\" qsdf"), "abc \" /* */\" qsdf");
+ }
+
+ #[test]
+ fn test_contains_comment() {
+ assert_eq!(contains_comment("abc"), false);
+ assert_eq!(contains_comment("abc // qsdf"), true);
+ assert_eq!(contains_comment("abc /* kqsdf"), true);
+ assert_eq!(contains_comment("abc \" /* */\" qsdf"), false);
+ }
+
+ #[test]
+ fn test_find_uncommented() {
+ fn check(haystack: &str, needle: &str, expected: Option<usize>) {
+ assert_eq!(expected, haystack.find_uncommented(needle));
+ }
+
+ check("/*/ */test", "test", Some(6));
+ check("//test\ntest", "test", Some(7));
+ check("/* comment only */", "whatever", None);
+ check(
+ "/* comment */ some text /* more commentary */ result",
+ "result",
+ Some(46),
+ );
+ check("sup // sup", "p", Some(2));
+ check("sup", "x", None);
+ check(r#"π? /**/ π is nice!"#, r#"π is nice"#, Some(9));
+ check("/*sup yo? \n sup*/ sup", "p", Some(20));
+ check("hel/*lohello*/lo", "hello", None);
+ check("acb", "ab", None);
+ check(",/*A*/ ", ",", Some(0));
+ check("abc", "abc", Some(0));
+ check("/* abc */", "abc", None);
+ check("/**/abc/* */", "abc", Some(4));
+ check("\"/* abc */\"", "abc", Some(4));
+ check("\"/* abc", "abc", Some(4));
+ }
+
+ #[test]
+ fn test_filter_normal_code() {
+ let s = r#"
+fn main() {
+ println!("hello, world");
+}
+"#;
+ assert_eq!(s, filter_normal_code(s));
+ let s_with_comment = r#"
+fn main() {
+ // hello, world
+ println!("hello, world");
+}
+"#;
+ assert_eq!(s, filter_normal_code(s_with_comment));
+ }
+}
--- /dev/null
- match_block_trailing_comma: bool, false, false,
+use std::cell::Cell;
+use std::default::Default;
+use std::fs::File;
+use std::io::{Error, ErrorKind, Read};
+use std::path::{Path, PathBuf};
+use std::{env, fs};
+
+use regex::Regex;
+use thiserror::Error;
+
+use crate::config::config_type::ConfigType;
+#[allow(unreachable_pub)]
+pub use crate::config::file_lines::{FileLines, FileName, Range};
+#[allow(unreachable_pub)]
+pub use crate::config::lists::*;
+#[allow(unreachable_pub)]
+pub use crate::config::options::*;
+
+#[macro_use]
+pub(crate) mod config_type;
+#[macro_use]
+pub(crate) mod options;
+
+pub(crate) mod file_lines;
+pub(crate) mod license;
+pub(crate) mod lists;
+
+// This macro defines configuration options used in rustfmt. Each option
+// is defined as follows:
+//
+// `name: value type, default value, is stable, description;`
+create_config! {
+ // Fundamental stuff
+ max_width: usize, 100, true, "Maximum width of each line";
+ hard_tabs: bool, false, true, "Use tab characters for indentation, spaces for alignment";
+ tab_spaces: usize, 4, true, "Number of spaces per tab";
+ newline_style: NewlineStyle, NewlineStyle::Auto, true, "Unix or Windows line endings";
+ indent_style: IndentStyle, IndentStyle::Block, false, "How do we indent expressions or items";
+
+ // Width Heuristics
+ use_small_heuristics: Heuristics, Heuristics::Default, true, "Whether to use different \
+ formatting for items and expressions if they satisfy a heuristic notion of 'small'";
+ width_heuristics: WidthHeuristics, WidthHeuristics::scaled(100), false,
+ "'small' heuristic values";
+ fn_call_width: usize, 60, true, "Maximum width of the args of a function call before \
+ falling back to vertical formatting.";
+ attr_fn_like_width: usize, 70, true, "Maximum width of the args of a function-like \
+ attributes before falling back to vertical formatting.";
+ struct_lit_width: usize, 18, true, "Maximum width in the body of a struct lit before \
+ falling back to vertical formatting.";
+ struct_variant_width: usize, 35, true, "Maximum width in the body of a struct variant before \
+ falling back to vertical formatting.";
+ array_width: usize, 60, true, "Maximum width of an array literal before falling \
+ back to vertical formatting.";
+ chain_width: usize, 60, true, "Maximum length of a chain to fit on a single line.";
+ single_line_if_else_max_width: usize, 50, true, "Maximum line length for single line if-else \
+ expressions. A value of zero means always break if-else expressions.";
+
+ // Comments. macros, and strings
+ wrap_comments: bool, false, false, "Break comments to fit on the line";
+ format_code_in_doc_comments: bool, false, false, "Format the code snippet in doc comments.";
+ comment_width: usize, 80, false,
+ "Maximum length of comments. No effect unless wrap_comments = true";
+ normalize_comments: bool, false, false, "Convert /* */ comments to // comments where possible";
+ normalize_doc_attributes: bool, false, false, "Normalize doc attributes as doc comments";
+ license_template_path: String, String::default(), false,
+ "Beginning of file must match license template";
+ format_strings: bool, false, false, "Format string literals where necessary";
+ format_macro_matchers: bool, false, false,
+ "Format the metavariable matching patterns in macros";
+ format_macro_bodies: bool, true, false, "Format the bodies of macros";
++ hex_literal_case: HexLiteralCase, HexLiteralCase::Preserve, false,
++ "Format hexadecimal integer literals";
+
+ // Single line expressions and items
+ empty_item_single_line: bool, true, false,
+ "Put empty-body functions and impls on a single line";
+ struct_lit_single_line: bool, true, false,
+ "Put small struct literals on a single line";
+ fn_single_line: bool, false, false, "Put single-expression functions on a single line";
+ where_single_line: bool, false, false, "Force where-clauses to be on a single line";
+
+ // Imports
+ imports_indent: IndentStyle, IndentStyle::Block, false, "Indent of imports";
+ imports_layout: ListTactic, ListTactic::Mixed, false, "Item layout inside a import block";
+ imports_granularity: ImportGranularity, ImportGranularity::Preserve, false,
+ "Merge or split imports to the provided granularity";
+ group_imports: GroupImportsTactic, GroupImportsTactic::Preserve, false,
+ "Controls the strategy for how imports are grouped together";
+ merge_imports: bool, false, false, "(deprecated: use imports_granularity instead)";
+
+ // Ordering
+ reorder_imports: bool, true, true, "Reorder import and extern crate statements alphabetically";
+ reorder_modules: bool, true, true, "Reorder module statements alphabetically in group";
+ reorder_impl_items: bool, false, false, "Reorder impl items";
+
+ // Spaces around punctuation
+ type_punctuation_density: TypeDensity, TypeDensity::Wide, false,
+ "Determines if '+' or '=' are wrapped in spaces in the punctuation of types";
+ space_before_colon: bool, false, false, "Leave a space before the colon";
+ space_after_colon: bool, true, false, "Leave a space after the colon";
+ spaces_around_ranges: bool, false, false, "Put spaces around the .. and ..= range operators";
+ binop_separator: SeparatorPlace, SeparatorPlace::Front, false,
+ "Where to put a binary operator when a binary expression goes multiline";
+
+ // Misc.
+ remove_nested_parens: bool, true, true, "Remove nested parens";
+ combine_control_expr: bool, true, false, "Combine control expressions with function calls";
+ overflow_delimited_expr: bool, false, false,
+ "Allow trailing bracket/brace delimited expressions to overflow";
+ struct_field_align_threshold: usize, 0, false,
+ "Align struct fields if their diffs fits within threshold";
+ enum_discrim_align_threshold: usize, 0, false,
+ "Align enum variants discrims, if their diffs fit within threshold";
+ match_arm_blocks: bool, true, false, "Wrap the body of arms in blocks when it does not fit on \
+ the same line with the pattern of arms";
+ match_arm_leading_pipes: MatchArmLeadingPipe, MatchArmLeadingPipe::Never, true,
+ "Determines whether leading pipes are emitted on match arms";
+ force_multiline_blocks: bool, false, false,
+ "Force multiline closure bodies and match arms to be wrapped in a block";
+ fn_args_layout: Density, Density::Tall, true,
+ "Control the layout of arguments in a function";
+ brace_style: BraceStyle, BraceStyle::SameLineWhere, false, "Brace style for items";
+ control_brace_style: ControlBraceStyle, ControlBraceStyle::AlwaysSameLine, false,
+ "Brace style for control flow constructs";
+ trailing_semicolon: bool, true, false,
+ "Add trailing semicolon after break, continue and return";
+ trailing_comma: SeparatorTactic, SeparatorTactic::Vertical, false,
+ "How to handle trailing commas for lists";
- disable_all_formatting: bool, false, false, "Don't reformat anything";
++ match_block_trailing_comma: bool, false, true,
+ "Put a trailing comma after a block based match arm (non-block arms are not affected)";
+ blank_lines_upper_bound: usize, 1, false,
+ "Maximum number of blank lines which can be put between items";
+ blank_lines_lower_bound: usize, 0, false,
+ "Minimum number of blank lines which must be put between items";
+ edition: Edition, Edition::Edition2015, true, "The edition of the parser (RFC 2052)";
+ version: Version, Version::One, false, "Version of formatting rules";
+ inline_attribute_width: usize, 0, false,
+ "Write an item and its attribute on the same line \
+ if their combined width is below a threshold";
++ format_generated_files: bool, false, false, "Format generated files";
+
+ // Options that can change the source code beyond whitespace/blocks (somewhat linty things)
+ merge_derives: bool, true, true, "Merge multiple `#[derive(...)]` into a single one";
+ use_try_shorthand: bool, false, true, "Replace uses of the try! macro by the ? shorthand";
+ use_field_init_shorthand: bool, false, true, "Use field initialization shorthand if possible";
+ force_explicit_abi: bool, true, true, "Always print the abi for extern items";
+ condense_wildcard_suffixes: bool, false, false, "Replace strings of _ wildcards by a single .. \
+ in tuple patterns";
+
+ // Control options (changes the operation of rustfmt, rather than the formatting)
+ color: Color, Color::Auto, false,
+ "What Color option to use when none is supplied: Always, Never, Auto";
+ required_version: String, env!("CARGO_PKG_VERSION").to_owned(), false,
+ "Require a specific version of rustfmt";
+ unstable_features: bool, false, false,
+ "Enables unstable features. Only available on nightly channel";
++ disable_all_formatting: bool, false, true, "Don't reformat anything";
+ skip_children: bool, false, false, "Don't reformat out of line modules";
+ hide_parse_errors: bool, false, false, "Hide errors from the parser";
+ error_on_line_overflow: bool, false, false, "Error if unable to get all lines within max_width";
+ error_on_unformatted: bool, false, false,
+ "Error if unable to get comments or string literals within max_width, \
+ or they are left with trailing whitespaces";
+ report_todo: ReportTactic, ReportTactic::Never, false,
+ "Report all, none or unnumbered occurrences of TODO in source file comments";
+ report_fixme: ReportTactic, ReportTactic::Never, false,
+ "Report all, none or unnumbered occurrences of FIXME in source file comments";
+ ignore: IgnoreList, IgnoreList::default(), false,
+ "Skip formatting the specified files and directories";
+
+ // Not user-facing
+ verbose: Verbosity, Verbosity::Normal, false, "How much to information to emit to the user";
+ file_lines: FileLines, FileLines::all(), false,
+ "Lines to format; this is not supported in rustfmt.toml, and can only be specified \
+ via the --file-lines option";
+ emit_mode: EmitMode, EmitMode::Files, false,
+ "What emit Mode to use when none is supplied";
+ make_backup: bool, false, false, "Backup changed files";
+ print_misformatted_file_names: bool, false, true,
+ "Prints the names of mismatched files that were formatted. Prints the names of \
+ files that would be formated when used with `--check` mode. ";
+}
+
+#[derive(Error, Debug)]
+#[error("Could not output config: {0}")]
+pub struct ToTomlError(toml::ser::Error);
+
+impl PartialConfig {
+ pub fn to_toml(&self) -> Result<String, ToTomlError> {
+ // Non-user-facing options can't be specified in TOML
+ let mut cloned = self.clone();
+ cloned.file_lines = None;
+ cloned.verbose = None;
+ cloned.width_heuristics = None;
+ cloned.print_misformatted_file_names = None;
+ cloned.merge_imports = None;
+
+ ::toml::to_string(&cloned).map_err(ToTomlError)
+ }
+}
+
+impl Config {
+ pub(crate) fn version_meets_requirement(&self) -> bool {
+ if self.was_set().required_version() {
+ let version = env!("CARGO_PKG_VERSION");
+ let required_version = self.required_version();
+ if version != required_version {
+ println!(
+ "Error: rustfmt version ({}) doesn't match the required version ({})",
+ version, required_version,
+ );
+ return false;
+ }
+ }
+
+ true
+ }
+
+ /// Constructs a `Config` from the toml file specified at `file_path`.
+ ///
+ /// This method only looks at the provided path, for a method that
+ /// searches parents for a `rustfmt.toml` see `from_resolved_toml_path`.
+ ///
+ /// Returns a `Config` if the config could be read and parsed from
+ /// the file, otherwise errors.
+ pub(super) fn from_toml_path(file_path: &Path) -> Result<Config, Error> {
+ let mut file = File::open(&file_path)?;
+ let mut toml = String::new();
+ file.read_to_string(&mut toml)?;
+ Config::from_toml(&toml, file_path.parent().unwrap())
+ .map_err(|err| Error::new(ErrorKind::InvalidData, err))
+ }
+
+ /// Resolves the config for input in `dir`.
+ ///
+ /// Searches for `rustfmt.toml` beginning with `dir`, and
+ /// recursively checking parents of `dir` if no config file is found.
+ /// If no config file exists in `dir` or in any parent, a
+ /// default `Config` will be returned (and the returned path will be empty).
+ ///
+ /// Returns the `Config` to use, and the path of the project file if there was
+ /// one.
+ pub(super) fn from_resolved_toml_path(dir: &Path) -> Result<(Config, Option<PathBuf>), Error> {
+ /// Try to find a project file in the given directory and its parents.
+ /// Returns the path of a the nearest project file if one exists,
+ /// or `None` if no project file was found.
+ fn resolve_project_file(dir: &Path) -> Result<Option<PathBuf>, Error> {
+ let mut current = if dir.is_relative() {
+ env::current_dir()?.join(dir)
+ } else {
+ dir.to_path_buf()
+ };
+
+ current = fs::canonicalize(current)?;
+
+ loop {
+ match get_toml_path(¤t) {
+ Ok(Some(path)) => return Ok(Some(path)),
+ Err(e) => return Err(e),
+ _ => (),
+ }
+
+ // If the current directory has no parent, we're done searching.
+ if !current.pop() {
+ break;
+ }
+ }
+
+ // If nothing was found, check in the home directory.
+ if let Some(home_dir) = dirs::home_dir() {
+ if let Some(path) = get_toml_path(&home_dir)? {
+ return Ok(Some(path));
+ }
+ }
+
+ // If none was found ther either, check in the user's configuration directory.
+ if let Some(mut config_dir) = dirs::config_dir() {
+ config_dir.push("rustfmt");
+ if let Some(path) = get_toml_path(&config_dir)? {
+ return Ok(Some(path));
+ }
+ }
+
+ Ok(None)
+ }
+
+ match resolve_project_file(dir)? {
+ None => Ok((Config::default(), None)),
+ Some(path) => Config::from_toml_path(&path).map(|config| (config, Some(path))),
+ }
+ }
+
+ pub(crate) fn from_toml(toml: &str, dir: &Path) -> Result<Config, String> {
+ let parsed: ::toml::Value = toml
+ .parse()
+ .map_err(|e| format!("Could not parse TOML: {}", e))?;
+ let mut err = String::new();
+ let table = parsed
+ .as_table()
+ .ok_or_else(|| String::from("Parsed config was not table"))?;
+ for key in table.keys() {
+ if !Config::is_valid_name(key) {
+ let msg = &format!("Warning: Unknown configuration option `{}`\n", key);
+ err.push_str(msg)
+ }
+ }
+ match parsed.try_into() {
+ Ok(parsed_config) => {
+ if !err.is_empty() {
+ eprint!("{}", err);
+ }
+ Ok(Config::default().fill_from_parsed_config(parsed_config, dir))
+ }
+ Err(e) => {
+ err.push_str("Error: Decoding config file failed:\n");
+ err.push_str(format!("{}\n", e).as_str());
+ err.push_str("Please check your config file.");
+ Err(err)
+ }
+ }
+ }
+}
+
+/// Loads a config by checking the client-supplied options and if appropriate, the
+/// file system (including searching the file system for overrides).
+pub fn load_config<O: CliOptions>(
+ file_path: Option<&Path>,
+ options: Option<O>,
+) -> Result<(Config, Option<PathBuf>), Error> {
+ let over_ride = match options {
+ Some(ref opts) => config_path(opts)?,
+ None => None,
+ };
+
+ let result = if let Some(over_ride) = over_ride {
+ Config::from_toml_path(over_ride.as_ref()).map(|p| (p, Some(over_ride.to_owned())))
+ } else if let Some(file_path) = file_path {
+ Config::from_resolved_toml_path(file_path)
+ } else {
+ Ok((Config::default(), None))
+ };
+
+ result.map(|(mut c, p)| {
+ if let Some(options) = options {
+ options.apply_to(&mut c);
+ }
+ (c, p)
+ })
+}
+
+// Check for the presence of known config file names (`rustfmt.toml, `.rustfmt.toml`) in `dir`
+//
+// Return the path if a config file exists, empty if no file exists, and Error for IO errors
+fn get_toml_path(dir: &Path) -> Result<Option<PathBuf>, Error> {
+ const CONFIG_FILE_NAMES: [&str; 2] = [".rustfmt.toml", "rustfmt.toml"];
+ for config_file_name in &CONFIG_FILE_NAMES {
+ let config_file = dir.join(config_file_name);
+ match fs::metadata(&config_file) {
+ // Only return if it's a file to handle the unlikely situation of a directory named
+ // `rustfmt.toml`.
+ Ok(ref md) if md.is_file() => return Ok(Some(config_file)),
+ // Return the error if it's something other than `NotFound`; otherwise we didn't
+ // find the project file yet, and continue searching.
+ Err(e) => {
+ if e.kind() != ErrorKind::NotFound {
+ return Err(e);
+ }
+ }
+ _ => {}
+ }
+ }
+ Ok(None)
+}
+
+fn config_path(options: &dyn CliOptions) -> Result<Option<PathBuf>, Error> {
+ let config_path_not_found = |path: &str| -> Result<Option<PathBuf>, Error> {
+ Err(Error::new(
+ ErrorKind::NotFound,
+ format!(
+ "Error: unable to find a config file for the given path: `{}`",
+ path
+ ),
+ ))
+ };
+
+ // Read the config_path and convert to parent dir if a file is provided.
+ // If a config file cannot be found from the given path, return error.
+ match options.config_path() {
+ Some(path) if !path.exists() => config_path_not_found(path.to_str().unwrap()),
+ Some(path) if path.is_dir() => {
+ let config_file_path = get_toml_path(path)?;
+ if config_file_path.is_some() {
+ Ok(config_file_path)
+ } else {
+ config_path_not_found(path.to_str().unwrap())
+ }
+ }
+ path => Ok(path.map(ToOwned::to_owned)),
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use std::str;
+
+ #[allow(dead_code)]
+ mod mock {
+ use super::super::*;
+
+ create_config! {
+ // Options that are used by the generated functions
+ max_width: usize, 100, true, "Maximum width of each line";
+ license_template_path: String, String::default(), false,
+ "Beginning of file must match license template";
+ required_version: String, env!("CARGO_PKG_VERSION").to_owned(), false,
+ "Require a specific version of rustfmt.";
+ ignore: IgnoreList, IgnoreList::default(), false,
+ "Skip formatting the specified files and directories.";
+ verbose: Verbosity, Verbosity::Normal, false,
+ "How much to information to emit to the user";
+ file_lines: FileLines, FileLines::all(), false,
+ "Lines to format; this is not supported in rustfmt.toml, and can only be specified \
+ via the --file-lines option";
+
+ // merge_imports deprecation
+ imports_granularity: ImportGranularity, ImportGranularity::Preserve, false,
+ "Merge imports";
+ merge_imports: bool, false, false, "(deprecated: use imports_granularity instead)";
+
+ // Width Heuristics
+ use_small_heuristics: Heuristics, Heuristics::Default, true,
+ "Whether to use different formatting for items and \
+ expressions if they satisfy a heuristic notion of 'small'.";
+ width_heuristics: WidthHeuristics, WidthHeuristics::scaled(100), false,
+ "'small' heuristic values";
+
+ fn_call_width: usize, 60, true, "Maximum width of the args of a function call before \
+ falling back to vertical formatting.";
+ attr_fn_like_width: usize, 70, true, "Maximum width of the args of a function-like \
+ attributes before falling back to vertical formatting.";
+ struct_lit_width: usize, 18, true, "Maximum width in the body of a struct lit before \
+ falling back to vertical formatting.";
+ struct_variant_width: usize, 35, true, "Maximum width in the body of a struct \
+ variant before falling back to vertical formatting.";
+ array_width: usize, 60, true, "Maximum width of an array literal before falling \
+ back to vertical formatting.";
+ chain_width: usize, 60, true, "Maximum length of a chain to fit on a single line.";
+ single_line_if_else_max_width: usize, 50, true, "Maximum line length for single \
+ line if-else expressions. A value of zero means always break if-else expressions.";
+
+ // Options that are used by the tests
+ stable_option: bool, false, true, "A stable option";
+ unstable_option: bool, false, false, "An unstable option";
+ }
+ }
+
+ #[test]
+ fn test_config_set() {
+ let mut config = Config::default();
+ config.set().verbose(Verbosity::Quiet);
+ assert_eq!(config.verbose(), Verbosity::Quiet);
+ config.set().verbose(Verbosity::Normal);
+ assert_eq!(config.verbose(), Verbosity::Normal);
+ }
+
+ #[test]
+ fn test_config_used_to_toml() {
+ let config = Config::default();
+
+ let merge_derives = config.merge_derives();
+ let skip_children = config.skip_children();
+
+ let used_options = config.used_options();
+ let toml = used_options.to_toml().unwrap();
+ assert_eq!(
+ toml,
+ format!(
+ "merge_derives = {}\nskip_children = {}\n",
+ merge_derives, skip_children,
+ )
+ );
+ }
+
+ #[test]
+ fn test_was_set() {
+ let config = Config::from_toml("hard_tabs = true", Path::new("")).unwrap();
+
+ assert_eq!(config.was_set().hard_tabs(), true);
+ assert_eq!(config.was_set().verbose(), false);
+ }
+
+ #[test]
+ fn test_print_docs_exclude_unstable() {
+ use self::mock::Config;
+
+ let mut output = Vec::new();
+ Config::print_docs(&mut output, false);
+
+ let s = str::from_utf8(&output).unwrap();
+
+ assert_eq!(s.contains("stable_option"), true);
+ assert_eq!(s.contains("unstable_option"), false);
+ assert_eq!(s.contains("(unstable)"), false);
+ }
+
+ #[test]
+ fn test_print_docs_include_unstable() {
+ use self::mock::Config;
+
+ let mut output = Vec::new();
+ Config::print_docs(&mut output, true);
+
+ let s = str::from_utf8(&output).unwrap();
+ assert_eq!(s.contains("stable_option"), true);
+ assert_eq!(s.contains("unstable_option"), true);
+ assert_eq!(s.contains("(unstable)"), true);
+ }
+
+ #[test]
+ fn test_empty_string_license_template_path() {
+ let toml = r#"license_template_path = """#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert!(config.license_template.is_none());
+ }
+
+ #[test]
+ fn test_valid_license_template_path() {
+ if !crate::is_nightly_channel!() {
+ return;
+ }
+ let toml = r#"license_template_path = "tests/license-template/lt.txt""#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert!(config.license_template.is_some());
+ }
+
+ #[test]
+ fn test_override_existing_license_with_no_license() {
+ if !crate::is_nightly_channel!() {
+ return;
+ }
+ let toml = r#"license_template_path = "tests/license-template/lt.txt""#;
+ let mut config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert!(config.license_template.is_some());
+ config.override_value("license_template_path", "");
+ assert!(config.license_template.is_none());
+ }
+
+ #[test]
+ fn test_dump_default_config() {
+ let default_config = format!(
+ r#"max_width = 100
+hard_tabs = false
+tab_spaces = 4
+newline_style = "Auto"
+indent_style = "Block"
+use_small_heuristics = "Default"
+fn_call_width = 60
+attr_fn_like_width = 70
+struct_lit_width = 18
+struct_variant_width = 35
+array_width = 60
+chain_width = 60
+single_line_if_else_max_width = 50
+wrap_comments = false
+format_code_in_doc_comments = false
+comment_width = 80
+normalize_comments = false
+normalize_doc_attributes = false
+license_template_path = ""
+format_strings = false
+format_macro_matchers = false
+format_macro_bodies = true
++hex_literal_case = "Preserve"
+empty_item_single_line = true
+struct_lit_single_line = true
+fn_single_line = false
+where_single_line = false
+imports_indent = "Block"
+imports_layout = "Mixed"
+imports_granularity = "Preserve"
+group_imports = "Preserve"
+reorder_imports = true
+reorder_modules = true
+reorder_impl_items = false
+type_punctuation_density = "Wide"
+space_before_colon = false
+space_after_colon = true
+spaces_around_ranges = false
+binop_separator = "Front"
+remove_nested_parens = true
+combine_control_expr = true
+overflow_delimited_expr = false
+struct_field_align_threshold = 0
+enum_discrim_align_threshold = 0
+match_arm_blocks = true
+match_arm_leading_pipes = "Never"
+force_multiline_blocks = false
+fn_args_layout = "Tall"
+brace_style = "SameLineWhere"
+control_brace_style = "AlwaysSameLine"
+trailing_semicolon = true
+trailing_comma = "Vertical"
+match_block_trailing_comma = false
+blank_lines_upper_bound = 1
+blank_lines_lower_bound = 0
+edition = "2015"
+version = "One"
+inline_attribute_width = 0
++format_generated_files = false
+merge_derives = true
+use_try_shorthand = false
+use_field_init_shorthand = false
+force_explicit_abi = true
+condense_wildcard_suffixes = false
+color = "Auto"
+required_version = "{}"
+unstable_features = false
+disable_all_formatting = false
+skip_children = false
+hide_parse_errors = false
+error_on_line_overflow = false
+error_on_unformatted = false
+report_todo = "Never"
+report_fixme = "Never"
+ignore = []
+emit_mode = "Files"
+make_backup = false
+"#,
+ env!("CARGO_PKG_VERSION")
+ );
+ let toml = Config::default().all_options().to_toml().unwrap();
+ assert_eq!(&toml, &default_config);
+ }
+
+ // FIXME(#2183): these tests cannot be run in parallel because they use env vars.
+ // #[test]
+ // fn test_as_not_nightly_channel() {
+ // let mut config = Config::default();
+ // assert_eq!(config.was_set().unstable_features(), false);
+ // config.set().unstable_features(true);
+ // assert_eq!(config.was_set().unstable_features(), false);
+ // }
+
+ // #[test]
+ // fn test_as_nightly_channel() {
+ // let v = ::std::env::var("CFG_RELEASE_CHANNEL").unwrap_or(String::from(""));
+ // ::std::env::set_var("CFG_RELEASE_CHANNEL", "nightly");
+ // let mut config = Config::default();
+ // config.set().unstable_features(true);
+ // assert_eq!(config.was_set().unstable_features(), false);
+ // config.set().unstable_features(true);
+ // assert_eq!(config.unstable_features(), true);
+ // ::std::env::set_var("CFG_RELEASE_CHANNEL", v);
+ // }
+
+ // #[test]
+ // fn test_unstable_from_toml() {
+ // let mut config = Config::from_toml("unstable_features = true").unwrap();
+ // assert_eq!(config.was_set().unstable_features(), false);
+ // let v = ::std::env::var("CFG_RELEASE_CHANNEL").unwrap_or(String::from(""));
+ // ::std::env::set_var("CFG_RELEASE_CHANNEL", "nightly");
+ // config = Config::from_toml("unstable_features = true").unwrap();
+ // assert_eq!(config.was_set().unstable_features(), true);
+ // assert_eq!(config.unstable_features(), true);
+ // ::std::env::set_var("CFG_RELEASE_CHANNEL", v);
+ // }
+
+ #[cfg(test)]
+ mod deprecated_option_merge_imports {
+ use super::*;
+
+ #[test]
+ fn test_old_option_set() {
+ if !crate::is_nightly_channel!() {
+ return;
+ }
+ let toml = r#"
+ unstable_features = true
+ merge_imports = true
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.imports_granularity(), ImportGranularity::Crate);
+ }
+
+ #[test]
+ fn test_both_set() {
+ if !crate::is_nightly_channel!() {
+ return;
+ }
+ let toml = r#"
+ unstable_features = true
+ merge_imports = true
+ imports_granularity = "Preserve"
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.imports_granularity(), ImportGranularity::Preserve);
+ }
+
+ #[test]
+ fn test_new_overridden() {
+ if !crate::is_nightly_channel!() {
+ return;
+ }
+ let toml = r#"
+ unstable_features = true
+ merge_imports = true
+ "#;
+ let mut config = Config::from_toml(toml, Path::new("")).unwrap();
+ config.override_value("imports_granularity", "Preserve");
+ assert_eq!(config.imports_granularity(), ImportGranularity::Preserve);
+ }
+
+ #[test]
+ fn test_old_overridden() {
+ if !crate::is_nightly_channel!() {
+ return;
+ }
+ let toml = r#"
+ unstable_features = true
+ imports_granularity = "Module"
+ "#;
+ let mut config = Config::from_toml(toml, Path::new("")).unwrap();
+ config.override_value("merge_imports", "true");
+ // no effect: the new option always takes precedence
+ assert_eq!(config.imports_granularity(), ImportGranularity::Module);
+ }
+ }
+
+ #[cfg(test)]
+ mod use_small_heuristics {
+ use super::*;
+
+ #[test]
+ fn test_default_sets_correct_widths() {
+ let toml = r#"
+ use_small_heuristics = "Default"
+ max_width = 200
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.array_width(), 120);
+ assert_eq!(config.attr_fn_like_width(), 140);
+ assert_eq!(config.chain_width(), 120);
+ assert_eq!(config.fn_call_width(), 120);
+ assert_eq!(config.single_line_if_else_max_width(), 100);
+ assert_eq!(config.struct_lit_width(), 36);
+ assert_eq!(config.struct_variant_width(), 70);
+ }
+
+ #[test]
+ fn test_max_sets_correct_widths() {
+ let toml = r#"
+ use_small_heuristics = "Max"
+ max_width = 120
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.array_width(), 120);
+ assert_eq!(config.attr_fn_like_width(), 120);
+ assert_eq!(config.chain_width(), 120);
+ assert_eq!(config.fn_call_width(), 120);
+ assert_eq!(config.single_line_if_else_max_width(), 120);
+ assert_eq!(config.struct_lit_width(), 120);
+ assert_eq!(config.struct_variant_width(), 120);
+ }
+
+ #[test]
+ fn test_off_sets_correct_widths() {
+ let toml = r#"
+ use_small_heuristics = "Off"
+ max_width = 100
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.array_width(), usize::max_value());
+ assert_eq!(config.attr_fn_like_width(), usize::max_value());
+ assert_eq!(config.chain_width(), usize::max_value());
+ assert_eq!(config.fn_call_width(), usize::max_value());
+ assert_eq!(config.single_line_if_else_max_width(), 0);
+ assert_eq!(config.struct_lit_width(), 0);
+ assert_eq!(config.struct_variant_width(), 0);
+ }
+
+ #[test]
+ fn test_override_works_with_default() {
+ let toml = r#"
+ use_small_heuristics = "Default"
+ array_width = 20
+ attr_fn_like_width = 40
+ chain_width = 20
+ fn_call_width = 90
+ single_line_if_else_max_width = 40
+ struct_lit_width = 30
+ struct_variant_width = 34
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.array_width(), 20);
+ assert_eq!(config.attr_fn_like_width(), 40);
+ assert_eq!(config.chain_width(), 20);
+ assert_eq!(config.fn_call_width(), 90);
+ assert_eq!(config.single_line_if_else_max_width(), 40);
+ assert_eq!(config.struct_lit_width(), 30);
+ assert_eq!(config.struct_variant_width(), 34);
+ }
+
+ #[test]
+ fn test_override_with_max() {
+ let toml = r#"
+ use_small_heuristics = "Max"
+ array_width = 20
+ attr_fn_like_width = 40
+ chain_width = 20
+ fn_call_width = 90
+ single_line_if_else_max_width = 40
+ struct_lit_width = 30
+ struct_variant_width = 34
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.array_width(), 20);
+ assert_eq!(config.attr_fn_like_width(), 40);
+ assert_eq!(config.chain_width(), 20);
+ assert_eq!(config.fn_call_width(), 90);
+ assert_eq!(config.single_line_if_else_max_width(), 40);
+ assert_eq!(config.struct_lit_width(), 30);
+ assert_eq!(config.struct_variant_width(), 34);
+ }
+
+ #[test]
+ fn test_override_with_off() {
+ let toml = r#"
+ use_small_heuristics = "Off"
+ array_width = 20
+ attr_fn_like_width = 40
+ chain_width = 20
+ fn_call_width = 90
+ single_line_if_else_max_width = 40
+ struct_lit_width = 30
+ struct_variant_width = 34
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.array_width(), 20);
+ assert_eq!(config.attr_fn_like_width(), 40);
+ assert_eq!(config.chain_width(), 20);
+ assert_eq!(config.fn_call_width(), 90);
+ assert_eq!(config.single_line_if_else_max_width(), 40);
+ assert_eq!(config.struct_lit_width(), 30);
+ assert_eq!(config.struct_variant_width(), 34);
+ }
+
+ #[test]
+ fn test_fn_call_width_config_exceeds_max_width() {
+ let toml = r#"
+ max_width = 90
+ fn_call_width = 95
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.fn_call_width(), 90);
+ }
+
+ #[test]
+ fn test_attr_fn_like_width_config_exceeds_max_width() {
+ let toml = r#"
+ max_width = 80
+ attr_fn_like_width = 90
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.attr_fn_like_width(), 80);
+ }
+
+ #[test]
+ fn test_struct_lit_config_exceeds_max_width() {
+ let toml = r#"
+ max_width = 78
+ struct_lit_width = 90
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.struct_lit_width(), 78);
+ }
+
+ #[test]
+ fn test_struct_variant_width_config_exceeds_max_width() {
+ let toml = r#"
+ max_width = 80
+ struct_variant_width = 90
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.struct_variant_width(), 80);
+ }
+
+ #[test]
+ fn test_array_width_config_exceeds_max_width() {
+ let toml = r#"
+ max_width = 60
+ array_width = 80
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.array_width(), 60);
+ }
+
+ #[test]
+ fn test_chain_width_config_exceeds_max_width() {
+ let toml = r#"
+ max_width = 80
+ chain_width = 90
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.chain_width(), 80);
+ }
+
+ #[test]
+ fn test_single_line_if_else_max_width_config_exceeds_max_width() {
+ let toml = r#"
+ max_width = 70
+ single_line_if_else_max_width = 90
+ "#;
+ let config = Config::from_toml(toml, Path::new("")).unwrap();
+ assert_eq!(config.single_line_if_else_max_width(), 70);
+ }
+
+ #[test]
+ fn test_override_fn_call_width_exceeds_max_width() {
+ let mut config = Config::default();
+ config.override_value("fn_call_width", "101");
+ assert_eq!(config.fn_call_width(), 100);
+ }
+
+ #[test]
+ fn test_override_attr_fn_like_width_exceeds_max_width() {
+ let mut config = Config::default();
+ config.override_value("attr_fn_like_width", "101");
+ assert_eq!(config.attr_fn_like_width(), 100);
+ }
+
+ #[test]
+ fn test_override_struct_lit_exceeds_max_width() {
+ let mut config = Config::default();
+ config.override_value("struct_lit_width", "101");
+ assert_eq!(config.struct_lit_width(), 100);
+ }
+
+ #[test]
+ fn test_override_struct_variant_width_exceeds_max_width() {
+ let mut config = Config::default();
+ config.override_value("struct_variant_width", "101");
+ assert_eq!(config.struct_variant_width(), 100);
+ }
+
+ #[test]
+ fn test_override_array_width_exceeds_max_width() {
+ let mut config = Config::default();
+ config.override_value("array_width", "101");
+ assert_eq!(config.array_width(), 100);
+ }
+
+ #[test]
+ fn test_override_chain_width_exceeds_max_width() {
+ let mut config = Config::default();
+ config.override_value("chain_width", "101");
+ assert_eq!(config.chain_width(), 100);
+ }
+
+ #[test]
+ fn test_override_single_line_if_else_max_width_exceeds_max_width() {
+ let mut config = Config::default();
+ config.override_value("single_line_if_else_max_width", "101");
+ assert_eq!(config.single_line_if_else_max_width(), 100);
+ }
+ }
+}
--- /dev/null
+use std::collections::{hash_set, HashSet};
+use std::fmt;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+
+use itertools::Itertools;
+use rustfmt_config_proc_macro::config_type;
+use serde::de::{SeqAccess, Visitor};
+use serde::ser::SerializeSeq;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::config::lists::*;
+use crate::config::Config;
+
+#[config_type]
+pub enum NewlineStyle {
+ /// Auto-detect based on the raw source input.
+ Auto,
+ /// Force CRLF (`\r\n`).
+ Windows,
+ /// Force CR (`\n).
+ Unix,
+ /// `\r\n` in Windows, `\n`` on other platforms.
+ Native,
+}
+
+#[config_type]
+/// Where to put the opening brace of items (`fn`, `impl`, etc.).
+pub enum BraceStyle {
+ /// Put the opening brace on the next line.
+ AlwaysNextLine,
+ /// Put the opening brace on the same line, if possible.
+ PreferSameLine,
+ /// Prefer the same line except where there is a where-clause, in which
+ /// case force the brace to be put on the next line.
+ SameLineWhere,
+}
+
+#[config_type]
+/// Where to put the opening brace of conditional expressions (`if`, `match`, etc.).
+pub enum ControlBraceStyle {
+ /// K&R style, Rust community default
+ AlwaysSameLine,
+ /// Stroustrup style
+ ClosingNextLine,
+ /// Allman style
+ AlwaysNextLine,
+}
+
+#[config_type]
+/// How to indent.
+pub enum IndentStyle {
+ /// First line on the same line as the opening brace, all lines aligned with
+ /// the first line.
+ Visual,
+ /// First line is on a new line and all lines align with **block** indent.
+ Block,
+}
+
+#[config_type]
+/// How to place a list-like items.
+/// FIXME: Issue-3581: this should be renamed to ItemsLayout when publishing 2.0
+pub enum Density {
+ /// Fit as much on one line as possible.
+ Compressed,
+ /// Items are placed horizontally if sufficient space, vertically otherwise.
+ Tall,
+ /// Place every item on a separate line.
+ Vertical,
+}
+
+#[config_type]
+/// Spacing around type combinators.
+pub enum TypeDensity {
+ /// No spaces around "=" and "+"
+ Compressed,
+ /// Spaces around " = " and " + "
+ Wide,
+}
+
+#[config_type]
+/// Heuristic settings that can be used to simply
+/// the configuration of the granular width configurations
+/// like `struct_lit_width`, `array_width`, etc.
+pub enum Heuristics {
+ /// Turn off any heuristics
+ Off,
+ /// Turn on max heuristics
+ Max,
+ /// Use scaled values based on the value of `max_width`
+ Default,
+}
+
+impl Density {
+ pub fn to_list_tactic(self, len: usize) -> ListTactic {
+ match self {
+ Density::Compressed => ListTactic::Mixed,
+ Density::Tall => ListTactic::HorizontalVertical,
+ Density::Vertical if len == 1 => ListTactic::Horizontal,
+ Density::Vertical => ListTactic::Vertical,
+ }
+ }
+}
+
+#[config_type]
+/// Configuration for import groups, i.e. sets of imports separated by newlines.
+pub enum GroupImportsTactic {
+ /// Keep groups as they are.
+ Preserve,
+ /// Discard existing groups, and create new groups for
+ /// 1. `std` / `core` / `alloc` imports
+ /// 2. other imports
+ /// 3. `self` / `crate` / `super` imports
+ StdExternalCrate,
+}
+
+#[config_type]
+/// How to merge imports.
+pub enum ImportGranularity {
+ /// Do not merge imports.
+ Preserve,
+ /// Use one `use` statement per crate.
+ Crate,
+ /// Use one `use` statement per module.
+ Module,
+ /// Use one `use` statement per imported item.
+ Item,
++ /// Use one `use` statement including all items.
++ One,
++}
++
++/// Controls how rustfmt should handle case in hexadecimal literals.
++#[config_type]
++pub enum HexLiteralCase {
++ /// Leave the literal as-is
++ Preserve,
++ /// Ensure all literals use uppercase lettering
++ Upper,
++ /// Ensure all literals use lowercase lettering
++ Lower,
+}
+
+#[config_type]
+pub enum ReportTactic {
+ Always,
+ Unnumbered,
+ Never,
+}
+
+/// What Rustfmt should emit. Mostly corresponds to the `--emit` command line
+/// option.
+#[config_type]
+pub enum EmitMode {
+ /// Emits to files.
+ Files,
+ /// Writes the output to stdout.
+ Stdout,
+ /// Displays how much of the input file was processed
+ Coverage,
+ /// Unfancy stdout
+ Checkstyle,
+ /// Writes the resulting diffs in a JSON format. Returns an empty array
+ /// `[]` if there were no diffs.
+ Json,
+ /// Output the changed lines (for internal value only)
+ ModifiedLines,
+ /// Checks if a diff can be generated. If so, rustfmt outputs a diff and
+ /// quits with exit code 1.
+ /// This option is designed to be run in CI where a non-zero exit signifies
+ /// non-standard code formatting. Used for `--check`.
+ Diff,
+}
+
+/// Client-preference for coloured output.
+#[config_type]
+pub enum Color {
+ /// Always use color, whether it is a piped or terminal output
+ Always,
+ /// Never use color
+ Never,
+ /// Automatically use color, if supported by terminal
+ Auto,
+}
+
+#[config_type]
+/// rustfmt format style version.
+pub enum Version {
+ /// 1.x.y. When specified, rustfmt will format in the same style as 1.0.0.
+ One,
+ /// 2.x.y. When specified, rustfmt will format in the the latest style.
+ Two,
+}
+
+impl Color {
+ /// Whether we should use a coloured terminal.
+ pub fn use_colored_tty(self) -> bool {
+ match self {
+ Color::Always | Color::Auto => true,
+ Color::Never => false,
+ }
+ }
+}
+
+/// How chatty should Rustfmt be?
+#[config_type]
+pub enum Verbosity {
+ /// Emit more.
+ Verbose,
+ /// Default.
+ Normal,
+ /// Emit as little as possible.
+ Quiet,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
+pub struct WidthHeuristics {
+ // Maximum width of the args of a function call before falling back
+ // to vertical formatting.
+ pub fn_call_width: usize,
+ // Maximum width of the args of a function-like attributes before falling
+ // back to vertical formatting.
+ pub attr_fn_like_width: usize,
+ // Maximum width in the body of a struct lit before falling back to
+ // vertical formatting.
+ pub struct_lit_width: usize,
+ // Maximum width in the body of a struct variant before falling back
+ // to vertical formatting.
+ pub struct_variant_width: usize,
+ // Maximum width of an array literal before falling back to vertical
+ // formatting.
+ pub array_width: usize,
+ // Maximum length of a chain to fit on a single line.
+ pub chain_width: usize,
+ // Maximum line length for single line if-else expressions. A value
+ // of zero means always break if-else expressions.
+ pub single_line_if_else_max_width: usize,
+}
+
+impl fmt::Display for WidthHeuristics {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{:?}", self)
+ }
+}
+
+impl WidthHeuristics {
+ // Using this WidthHeuristics means we ignore heuristics.
+ pub fn null() -> WidthHeuristics {
+ WidthHeuristics {
+ fn_call_width: usize::max_value(),
+ attr_fn_like_width: usize::max_value(),
+ struct_lit_width: 0,
+ struct_variant_width: 0,
+ array_width: usize::max_value(),
+ chain_width: usize::max_value(),
+ single_line_if_else_max_width: 0,
+ }
+ }
+
+ pub fn set(max_width: usize) -> WidthHeuristics {
+ WidthHeuristics {
+ fn_call_width: max_width,
+ attr_fn_like_width: max_width,
+ struct_lit_width: max_width,
+ struct_variant_width: max_width,
+ array_width: max_width,
+ chain_width: max_width,
+ single_line_if_else_max_width: max_width,
+ }
+ }
+
+ // scale the default WidthHeuristics according to max_width
+ pub fn scaled(max_width: usize) -> WidthHeuristics {
+ const DEFAULT_MAX_WIDTH: usize = 100;
+ let max_width_ratio = if max_width > DEFAULT_MAX_WIDTH {
+ let ratio = max_width as f32 / DEFAULT_MAX_WIDTH as f32;
+ // round to the closest 0.1
+ (ratio * 10.0).round() / 10.0
+ } else {
+ 1.0
+ };
+ WidthHeuristics {
+ fn_call_width: (60.0 * max_width_ratio).round() as usize,
+ attr_fn_like_width: (70.0 * max_width_ratio).round() as usize,
+ struct_lit_width: (18.0 * max_width_ratio).round() as usize,
+ struct_variant_width: (35.0 * max_width_ratio).round() as usize,
+ array_width: (60.0 * max_width_ratio).round() as usize,
+ chain_width: (60.0 * max_width_ratio).round() as usize,
+ single_line_if_else_max_width: (50.0 * max_width_ratio).round() as usize,
+ }
+ }
+}
+
+impl ::std::str::FromStr for WidthHeuristics {
+ type Err = &'static str;
+
+ fn from_str(_: &str) -> Result<Self, Self::Err> {
+ Err("WidthHeuristics is not parsable")
+ }
+}
+
+impl Default for EmitMode {
+ fn default() -> EmitMode {
+ EmitMode::Files
+ }
+}
+
+/// A set of directories, files and modules that rustfmt should ignore.
+#[derive(Default, Clone, Debug, PartialEq)]
+pub struct IgnoreList {
+ /// A set of path specified in rustfmt.toml.
+ path_set: HashSet<PathBuf>,
+ /// A path to rustfmt.toml.
+ rustfmt_toml_path: PathBuf,
+}
+
+impl fmt::Display for IgnoreList {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "[{}]",
+ self.path_set
+ .iter()
+ .format_with(", ", |path, f| f(&format_args!(
+ "{}",
+ path.to_string_lossy()
+ )))
+ )
+ }
+}
+
+impl Serialize for IgnoreList {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let mut seq = serializer.serialize_seq(Some(self.path_set.len()))?;
+ for e in &self.path_set {
+ seq.serialize_element(e)?;
+ }
+ seq.end()
+ }
+}
+
+impl<'de> Deserialize<'de> for IgnoreList {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct HashSetVisitor;
+ impl<'v> Visitor<'v> for HashSetVisitor {
+ type Value = HashSet<PathBuf>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a sequence of path")
+ }
+
+ fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'v>,
+ {
+ let mut path_set = HashSet::new();
+ while let Some(elem) = seq.next_element()? {
+ path_set.insert(elem);
+ }
+ Ok(path_set)
+ }
+ }
+ Ok(IgnoreList {
+ path_set: deserializer.deserialize_seq(HashSetVisitor)?,
+ rustfmt_toml_path: PathBuf::new(),
+ })
+ }
+}
+
+impl<'a> IntoIterator for &'a IgnoreList {
+ type Item = &'a PathBuf;
+ type IntoIter = hash_set::Iter<'a, PathBuf>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.path_set.iter()
+ }
+}
+
+impl IgnoreList {
+ pub fn add_prefix(&mut self, dir: &Path) {
+ self.rustfmt_toml_path = dir.to_path_buf();
+ }
+
+ pub fn rustfmt_toml_path(&self) -> &Path {
+ &self.rustfmt_toml_path
+ }
+}
+
+impl FromStr for IgnoreList {
+ type Err = &'static str;
+
+ fn from_str(_: &str) -> Result<Self, Self::Err> {
+ Err("IgnoreList is not parsable")
+ }
+}
+
+/// Maps client-supplied options to Rustfmt's internals, mostly overriding
+/// values in a config with values from the command line.
+pub trait CliOptions {
+ fn apply_to(self, config: &mut Config);
+ fn config_path(&self) -> Option<&Path>;
+}
+
+/// The edition of the syntax and semntics of code (RFC 2052).
+#[config_type]
+pub enum Edition {
+ #[value = "2015"]
+ #[doc_hint = "2015"]
+ /// Edition 2015.
+ Edition2015,
+ #[value = "2018"]
+ #[doc_hint = "2018"]
+ /// Edition 2018.
+ Edition2018,
+ #[value = "2021"]
+ #[doc_hint = "2021"]
+ /// Edition 2021.
+ Edition2021,
+}
+
+impl Default for Edition {
+ fn default() -> Edition {
+ Edition::Edition2015
+ }
+}
+
+impl From<Edition> for rustc_span::edition::Edition {
+ fn from(edition: Edition) -> Self {
+ match edition {
+ Edition::Edition2015 => Self::Edition2015,
+ Edition::Edition2018 => Self::Edition2018,
+ Edition::Edition2021 => Self::Edition2021,
+ }
+ }
+}
+
+impl PartialOrd for Edition {
+ fn partial_cmp(&self, other: &Edition) -> Option<std::cmp::Ordering> {
+ rustc_span::edition::Edition::partial_cmp(&(*self).into(), &(*other).into())
+ }
+}
+
+/// Controls how rustfmt should handle leading pipes on match arms.
+#[config_type]
+pub enum MatchArmLeadingPipe {
+ /// Place leading pipes on all match arms
+ Always,
+ /// Never emit leading pipes on match arms
+ Never,
+ /// Preserve any existing leading pipes
+ Preserve,
+}
--- /dev/null
- use crate::config::{Config, ControlBraceStyle, IndentStyle, Version};
+use std::borrow::Cow;
+use std::cmp::min;
+
+use itertools::Itertools;
+use rustc_ast::token::{DelimToken, LitKind};
+use rustc_ast::{ast, ptr};
+use rustc_span::{BytePos, Span};
+
+use crate::chains::rewrite_chain;
+use crate::closures;
+use crate::comment::{
+ combine_strs_with_missing_comments, contains_comment, recover_comment_removed, rewrite_comment,
+ rewrite_missing_comment, CharClasses, FindUncommented,
+};
+use crate::config::lists::*;
- .span_after(self.span, self.connector.trim());
++use crate::config::{Config, ControlBraceStyle, HexLiteralCase, IndentStyle, Version};
+use crate::lists::{
+ definitive_tactic, itemize_list, shape_for_tactic, struct_lit_formatting, struct_lit_shape,
+ struct_lit_tactic, write_list, ListFormatting, Separator,
+};
+use crate::macros::{rewrite_macro, MacroPosition};
+use crate::matches::rewrite_match;
+use crate::overflow::{self, IntoOverflowableItem, OverflowableItem};
+use crate::pairs::{rewrite_all_pairs, rewrite_pair, PairParts};
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::{Indent, Shape};
+use crate::source_map::{LineRangeUtils, SpanUtils};
+use crate::spanned::Spanned;
+use crate::string::{rewrite_string, StringFormat};
+use crate::types::{rewrite_path, PathContext};
+use crate::utils::{
+ colon_spaces, contains_skip, count_newlines, first_line_ends_with, inner_attributes,
+ last_line_extendable, last_line_width, mk_sp, outer_attributes, semicolon_for_expr,
+ unicode_str_width, wrap_str,
+};
+use crate::vertical::rewrite_with_alignment;
+use crate::visitor::FmtVisitor;
+
+impl Rewrite for ast::Expr {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ format_expr(self, ExprType::SubExpression, context, shape)
+ }
+}
+
+#[derive(Copy, Clone, PartialEq)]
+pub(crate) enum ExprType {
+ Statement,
+ SubExpression,
+}
+
+pub(crate) fn format_expr(
+ expr: &ast::Expr,
+ expr_type: ExprType,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String> {
+ skip_out_of_file_lines_range!(context, expr.span);
+
+ if contains_skip(&*expr.attrs) {
+ return Some(context.snippet(expr.span()).to_owned());
+ }
+ let shape = if expr_type == ExprType::Statement && semicolon_for_expr(context, expr) {
+ shape.sub_width(1)?
+ } else {
+ shape
+ };
+
+ let expr_rw = match expr.kind {
+ ast::ExprKind::Array(ref expr_vec) => rewrite_array(
+ "",
+ expr_vec.iter(),
+ expr.span,
+ context,
+ shape,
+ choose_separator_tactic(context, expr.span),
+ None,
+ ),
+ ast::ExprKind::Lit(ref l) => {
+ if let Some(expr_rw) = rewrite_literal(context, l, shape) {
+ Some(expr_rw)
+ } else {
+ if let LitKind::StrRaw(_) = l.token.kind {
+ Some(context.snippet(l.span).trim().into())
+ } else {
+ None
+ }
+ }
+ }
+ ast::ExprKind::Call(ref callee, ref args) => {
+ let inner_span = mk_sp(callee.span.hi(), expr.span.hi());
+ let callee_str = callee.rewrite(context, shape)?;
+ rewrite_call(context, &callee_str, args, inner_span, shape)
+ }
+ ast::ExprKind::Paren(ref subexpr) => rewrite_paren(context, subexpr, shape, expr.span),
+ ast::ExprKind::Binary(op, ref lhs, ref rhs) => {
+ // FIXME: format comments between operands and operator
+ rewrite_all_pairs(expr, shape, context).or_else(|| {
+ rewrite_pair(
+ &**lhs,
+ &**rhs,
+ PairParts::infix(&format!(" {} ", context.snippet(op.span))),
+ context,
+ shape,
+ context.config.binop_separator(),
+ )
+ })
+ }
+ ast::ExprKind::Unary(op, ref subexpr) => rewrite_unary_op(context, op, subexpr, shape),
+ ast::ExprKind::Struct(ref struct_expr) => {
+ let ast::StructExpr {
+ fields, path, rest, ..
+ } = &**struct_expr;
+ rewrite_struct_lit(context, path, fields, rest, &expr.attrs, expr.span, shape)
+ }
+ ast::ExprKind::Tup(ref items) => {
+ rewrite_tuple(context, items.iter(), expr.span, shape, items.len() == 1)
+ }
+ ast::ExprKind::Let(..) => None,
+ ast::ExprKind::If(..)
+ | ast::ExprKind::ForLoop(..)
+ | ast::ExprKind::Loop(..)
+ | ast::ExprKind::While(..) => to_control_flow(expr, expr_type)
+ .and_then(|control_flow| control_flow.rewrite(context, shape)),
+ ast::ExprKind::ConstBlock(ref anon_const) => {
+ Some(format!("const {}", anon_const.rewrite(context, shape)?))
+ }
+ ast::ExprKind::Block(ref block, opt_label) => {
+ match expr_type {
+ ExprType::Statement => {
+ if is_unsafe_block(block) {
+ rewrite_block(block, Some(&expr.attrs), opt_label, context, shape)
+ } else if let rw @ Some(_) =
+ rewrite_empty_block(context, block, Some(&expr.attrs), opt_label, "", shape)
+ {
+ // Rewrite block without trying to put it in a single line.
+ rw
+ } else {
+ let prefix = block_prefix(context, block, shape)?;
+
+ rewrite_block_with_visitor(
+ context,
+ &prefix,
+ block,
+ Some(&expr.attrs),
+ opt_label,
+ shape,
+ true,
+ )
+ }
+ }
+ ExprType::SubExpression => {
+ rewrite_block(block, Some(&expr.attrs), opt_label, context, shape)
+ }
+ }
+ }
+ ast::ExprKind::Match(ref cond, ref arms) => {
+ rewrite_match(context, cond, arms, shape, expr.span, &expr.attrs)
+ }
+ ast::ExprKind::Path(ref qself, ref path) => {
+ rewrite_path(context, PathContext::Expr, qself.as_ref(), path, shape)
+ }
+ ast::ExprKind::Assign(ref lhs, ref rhs, _) => {
+ rewrite_assignment(context, lhs, rhs, None, shape)
+ }
+ ast::ExprKind::AssignOp(ref op, ref lhs, ref rhs) => {
+ rewrite_assignment(context, lhs, rhs, Some(op), shape)
+ }
+ ast::ExprKind::Continue(ref opt_label) => {
+ let id_str = match *opt_label {
+ Some(label) => format!(" {}", label.ident),
+ None => String::new(),
+ };
+ Some(format!("continue{}", id_str))
+ }
+ ast::ExprKind::Break(ref opt_label, ref opt_expr) => {
+ let id_str = match *opt_label {
+ Some(label) => format!(" {}", label.ident),
+ None => String::new(),
+ };
+
+ if let Some(ref expr) = *opt_expr {
+ rewrite_unary_prefix(context, &format!("break{} ", id_str), &**expr, shape)
+ } else {
+ Some(format!("break{}", id_str))
+ }
+ }
+ ast::ExprKind::Yield(ref opt_expr) => {
+ if let Some(ref expr) = *opt_expr {
+ rewrite_unary_prefix(context, "yield ", &**expr, shape)
+ } else {
+ Some("yield".to_string())
+ }
+ }
+ ast::ExprKind::Closure(capture, ref is_async, movability, ref fn_decl, ref body, _) => {
+ closures::rewrite_closure(
+ capture, is_async, movability, fn_decl, body, expr.span, context, shape,
+ )
+ }
+ ast::ExprKind::Try(..) | ast::ExprKind::Field(..) | ast::ExprKind::MethodCall(..) => {
+ rewrite_chain(expr, context, shape)
+ }
+ ast::ExprKind::MacCall(ref mac) => {
+ rewrite_macro(mac, None, context, shape, MacroPosition::Expression).or_else(|| {
+ wrap_str(
+ context.snippet(expr.span).to_owned(),
+ context.config.max_width(),
+ shape,
+ )
+ })
+ }
+ ast::ExprKind::Ret(None) => Some("return".to_owned()),
+ ast::ExprKind::Ret(Some(ref expr)) => {
+ rewrite_unary_prefix(context, "return ", &**expr, shape)
+ }
+ ast::ExprKind::Box(ref expr) => rewrite_unary_prefix(context, "box ", &**expr, shape),
+ ast::ExprKind::AddrOf(borrow_kind, mutability, ref expr) => {
+ rewrite_expr_addrof(context, borrow_kind, mutability, expr, shape)
+ }
+ ast::ExprKind::Cast(ref expr, ref ty) => rewrite_pair(
+ &**expr,
+ &**ty,
+ PairParts::infix(" as "),
+ context,
+ shape,
+ SeparatorPlace::Front,
+ ),
+ ast::ExprKind::Type(ref expr, ref ty) => rewrite_pair(
+ &**expr,
+ &**ty,
+ PairParts::infix(": "),
+ context,
+ shape,
+ SeparatorPlace::Back,
+ ),
+ ast::ExprKind::Index(ref expr, ref index) => {
+ rewrite_index(&**expr, &**index, context, shape)
+ }
+ ast::ExprKind::Repeat(ref expr, ref repeats) => rewrite_pair(
+ &**expr,
+ &*repeats.value,
+ PairParts::new("[", "; ", "]"),
+ context,
+ shape,
+ SeparatorPlace::Back,
+ ),
+ ast::ExprKind::Range(ref lhs, ref rhs, limits) => {
+ let delim = match limits {
+ ast::RangeLimits::HalfOpen => "..",
+ ast::RangeLimits::Closed => "..=",
+ };
+
+ fn needs_space_before_range(context: &RewriteContext<'_>, lhs: &ast::Expr) -> bool {
+ match lhs.kind {
+ ast::ExprKind::Lit(ref lit) => match lit.kind {
+ ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
+ context.snippet(lit.span).ends_with('.')
+ }
+ _ => false,
+ },
+ ast::ExprKind::Unary(_, ref expr) => needs_space_before_range(context, &expr),
+ _ => false,
+ }
+ }
+
+ fn needs_space_after_range(rhs: &ast::Expr) -> bool {
+ // Don't format `.. ..` into `....`, which is invalid.
+ //
+ // This check is unnecessary for `lhs`, because a range
+ // starting from another range needs parentheses as `(x ..) ..`
+ // (`x .. ..` is a range from `x` to `..`).
+ matches!(rhs.kind, ast::ExprKind::Range(None, _, _))
+ }
+
+ let default_sp_delim = |lhs: Option<&ast::Expr>, rhs: Option<&ast::Expr>| {
+ let space_if = |b: bool| if b { " " } else { "" };
+
+ format!(
+ "{}{}{}",
+ lhs.map_or("", |lhs| space_if(needs_space_before_range(context, lhs))),
+ delim,
+ rhs.map_or("", |rhs| space_if(needs_space_after_range(rhs))),
+ )
+ };
+
+ match (lhs.as_ref().map(|x| &**x), rhs.as_ref().map(|x| &**x)) {
+ (Some(lhs), Some(rhs)) => {
+ let sp_delim = if context.config.spaces_around_ranges() {
+ format!(" {} ", delim)
+ } else {
+ default_sp_delim(Some(lhs), Some(rhs))
+ };
+ rewrite_pair(
+ &*lhs,
+ &*rhs,
+ PairParts::infix(&sp_delim),
+ context,
+ shape,
+ context.config.binop_separator(),
+ )
+ }
+ (None, Some(rhs)) => {
+ let sp_delim = if context.config.spaces_around_ranges() {
+ format!("{} ", delim)
+ } else {
+ default_sp_delim(None, Some(rhs))
+ };
+ rewrite_unary_prefix(context, &sp_delim, &*rhs, shape)
+ }
+ (Some(lhs), None) => {
+ let sp_delim = if context.config.spaces_around_ranges() {
+ format!(" {}", delim)
+ } else {
+ default_sp_delim(Some(lhs), None)
+ };
+ rewrite_unary_suffix(context, &sp_delim, &*lhs, shape)
+ }
+ (None, None) => Some(delim.to_owned()),
+ }
+ }
+ // We do not format these expressions yet, but they should still
+ // satisfy our width restrictions.
+ // Style Guide RFC for InlineAsm variant pending
+ // https://github.com/rust-dev-tools/fmt-rfcs/issues/152
+ ast::ExprKind::LlvmInlineAsm(..) | ast::ExprKind::InlineAsm(..) => {
+ Some(context.snippet(expr.span).to_owned())
+ }
+ ast::ExprKind::TryBlock(ref block) => {
+ if let rw @ Some(_) =
+ rewrite_single_line_block(context, "try ", block, Some(&expr.attrs), None, shape)
+ {
+ rw
+ } else {
+ // 9 = `try `
+ let budget = shape.width.saturating_sub(9);
+ Some(format!(
+ "{}{}",
+ "try ",
+ rewrite_block(
+ block,
+ Some(&expr.attrs),
+ None,
+ context,
+ Shape::legacy(budget, shape.indent)
+ )?
+ ))
+ }
+ }
+ ast::ExprKind::Async(capture_by, _node_id, ref block) => {
+ let mover = if capture_by == ast::CaptureBy::Value {
+ "move "
+ } else {
+ ""
+ };
+ if let rw @ Some(_) = rewrite_single_line_block(
+ context,
+ format!("{}{}", "async ", mover).as_str(),
+ block,
+ Some(&expr.attrs),
+ None,
+ shape,
+ ) {
+ rw
+ } else {
+ // 6 = `async `
+ let budget = shape.width.saturating_sub(6);
+ Some(format!(
+ "{}{}{}",
+ "async ",
+ mover,
+ rewrite_block(
+ block,
+ Some(&expr.attrs),
+ None,
+ context,
+ Shape::legacy(budget, shape.indent)
+ )?
+ ))
+ }
+ }
+ ast::ExprKind::Await(_) => rewrite_chain(expr, context, shape),
+ ast::ExprKind::Underscore => Some("_".to_owned()),
+ ast::ExprKind::Err => None,
+ };
+
+ expr_rw
+ .and_then(|expr_str| recover_comment_removed(expr_str, expr.span, context))
+ .and_then(|expr_str| {
+ let attrs = outer_attributes(&expr.attrs);
+ let attrs_str = attrs.rewrite(context, shape)?;
+ let span = mk_sp(
+ attrs.last().map_or(expr.span.lo(), |attr| attr.span.hi()),
+ expr.span.lo(),
+ );
+ combine_strs_with_missing_comments(context, &attrs_str, &expr_str, span, shape, false)
+ })
+}
+
+pub(crate) fn rewrite_array<'a, T: 'a + IntoOverflowableItem<'a>>(
+ name: &'a str,
+ exprs: impl Iterator<Item = &'a T>,
+ span: Span,
+ context: &'a RewriteContext<'_>,
+ shape: Shape,
+ force_separator_tactic: Option<SeparatorTactic>,
+ delim_token: Option<DelimToken>,
+) -> Option<String> {
+ overflow::rewrite_with_square_brackets(
+ context,
+ name,
+ exprs,
+ shape,
+ span,
+ force_separator_tactic,
+ delim_token,
+ )
+}
+
+fn rewrite_empty_block(
+ context: &RewriteContext<'_>,
+ block: &ast::Block,
+ attrs: Option<&[ast::Attribute]>,
+ label: Option<ast::Label>,
+ prefix: &str,
+ shape: Shape,
+) -> Option<String> {
+ if block_has_statements(&block) {
+ return None;
+ }
+
+ let label_str = rewrite_label(label);
+ if attrs.map_or(false, |a| !inner_attributes(a).is_empty()) {
+ return None;
+ }
+
+ if !block_contains_comment(context, block) && shape.width >= 2 {
+ return Some(format!("{}{}{{}}", prefix, label_str));
+ }
+
+ // If a block contains only a single-line comment, then leave it on one line.
+ let user_str = context.snippet(block.span);
+ let user_str = user_str.trim();
+ if user_str.starts_with('{') && user_str.ends_with('}') {
+ let comment_str = user_str[1..user_str.len() - 1].trim();
+ if block.stmts.is_empty()
+ && !comment_str.contains('\n')
+ && !comment_str.starts_with("//")
+ && comment_str.len() + 4 <= shape.width
+ {
+ return Some(format!("{}{}{{ {} }}", prefix, label_str, comment_str));
+ }
+ }
+
+ None
+}
+
+fn block_prefix(context: &RewriteContext<'_>, block: &ast::Block, shape: Shape) -> Option<String> {
+ Some(match block.rules {
+ ast::BlockCheckMode::Unsafe(..) => {
+ let snippet = context.snippet(block.span);
+ let open_pos = snippet.find_uncommented("{")?;
+ // Extract comment between unsafe and block start.
+ let trimmed = &snippet[6..open_pos].trim();
+
+ if !trimmed.is_empty() {
+ // 9 = "unsafe {".len(), 7 = "unsafe ".len()
+ let budget = shape.width.checked_sub(9)?;
+ format!(
+ "unsafe {} ",
+ rewrite_comment(
+ trimmed,
+ true,
+ Shape::legacy(budget, shape.indent + 7),
+ context.config,
+ )?
+ )
+ } else {
+ "unsafe ".to_owned()
+ }
+ }
+ ast::BlockCheckMode::Default => String::new(),
+ })
+}
+
+fn rewrite_single_line_block(
+ context: &RewriteContext<'_>,
+ prefix: &str,
+ block: &ast::Block,
+ attrs: Option<&[ast::Attribute]>,
+ label: Option<ast::Label>,
+ shape: Shape,
+) -> Option<String> {
+ if is_simple_block(context, block, attrs) {
+ let expr_shape = shape.offset_left(last_line_width(prefix))?;
+ let expr_str = block.stmts[0].rewrite(context, expr_shape)?;
+ let label_str = rewrite_label(label);
+ let result = format!("{}{}{{ {} }}", prefix, label_str, expr_str);
+ if result.len() <= shape.width && !result.contains('\n') {
+ return Some(result);
+ }
+ }
+ None
+}
+
+pub(crate) fn rewrite_block_with_visitor(
+ context: &RewriteContext<'_>,
+ prefix: &str,
+ block: &ast::Block,
+ attrs: Option<&[ast::Attribute]>,
+ label: Option<ast::Label>,
+ shape: Shape,
+ has_braces: bool,
+) -> Option<String> {
+ if let rw @ Some(_) = rewrite_empty_block(context, block, attrs, label, prefix, shape) {
+ return rw;
+ }
+
+ let mut visitor = FmtVisitor::from_context(context);
+ visitor.block_indent = shape.indent;
+ visitor.is_if_else_block = context.is_if_else_block();
+ match (block.rules, label) {
+ (ast::BlockCheckMode::Unsafe(..), _) | (ast::BlockCheckMode::Default, Some(_)) => {
+ let snippet = context.snippet(block.span);
+ let open_pos = snippet.find_uncommented("{")?;
+ visitor.last_pos = block.span.lo() + BytePos(open_pos as u32)
+ }
+ (ast::BlockCheckMode::Default, None) => visitor.last_pos = block.span.lo(),
+ }
+
+ let inner_attrs = attrs.map(inner_attributes);
+ let label_str = rewrite_label(label);
+ visitor.visit_block(block, inner_attrs.as_deref(), has_braces);
+ let visitor_context = visitor.get_context();
+ context
+ .skipped_range
+ .borrow_mut()
+ .append(&mut visitor_context.skipped_range.borrow_mut());
+ Some(format!("{}{}{}", prefix, label_str, visitor.buffer))
+}
+
+impl Rewrite for ast::Block {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ rewrite_block(self, None, None, context, shape)
+ }
+}
+
+fn rewrite_block(
+ block: &ast::Block,
+ attrs: Option<&[ast::Attribute]>,
+ label: Option<ast::Label>,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String> {
+ let prefix = block_prefix(context, block, shape)?;
+
+ // shape.width is used only for the single line case: either the empty block `{}`,
+ // or an unsafe expression `unsafe { e }`.
+ if let rw @ Some(_) = rewrite_empty_block(context, block, attrs, label, &prefix, shape) {
+ return rw;
+ }
+
+ let result = rewrite_block_with_visitor(context, &prefix, block, attrs, label, shape, true);
+ if let Some(ref result_str) = result {
+ if result_str.lines().count() <= 3 {
+ if let rw @ Some(_) =
+ rewrite_single_line_block(context, &prefix, block, attrs, label, shape)
+ {
+ return rw;
+ }
+ }
+ }
+
+ result
+}
+
+// Rewrite condition if the given expression has one.
+pub(crate) fn rewrite_cond(
+ context: &RewriteContext<'_>,
+ expr: &ast::Expr,
+ shape: Shape,
+) -> Option<String> {
+ match expr.kind {
+ ast::ExprKind::Match(ref cond, _) => {
+ // `match `cond` {`
+ let cond_shape = match context.config.indent_style() {
+ IndentStyle::Visual => shape.shrink_left(6).and_then(|s| s.sub_width(2))?,
+ IndentStyle::Block => shape.offset_left(8)?,
+ };
+ cond.rewrite(context, cond_shape)
+ }
+ _ => to_control_flow(expr, ExprType::SubExpression).and_then(|control_flow| {
+ let alt_block_sep =
+ String::from("\n") + &shape.indent.block_only().to_string(context.config);
+ control_flow
+ .rewrite_cond(context, shape, &alt_block_sep)
+ .map(|rw| rw.0)
+ }),
+ }
+}
+
+// Abstraction over control flow expressions
+#[derive(Debug)]
+struct ControlFlow<'a> {
+ cond: Option<&'a ast::Expr>,
+ block: &'a ast::Block,
+ else_block: Option<&'a ast::Expr>,
+ label: Option<ast::Label>,
+ pat: Option<&'a ast::Pat>,
+ keyword: &'a str,
+ matcher: &'a str,
+ connector: &'a str,
+ allow_single_line: bool,
+ // HACK: `true` if this is an `if` expression in an `else if`.
+ nested_if: bool,
+ span: Span,
+}
+
+fn extract_pats_and_cond(expr: &ast::Expr) -> (Option<&ast::Pat>, &ast::Expr) {
+ match expr.kind {
+ ast::ExprKind::Let(ref pat, ref cond, _) => (Some(pat), cond),
+ _ => (None, expr),
+ }
+}
+
+// FIXME: Refactor this.
+fn to_control_flow(expr: &ast::Expr, expr_type: ExprType) -> Option<ControlFlow<'_>> {
+ match expr.kind {
+ ast::ExprKind::If(ref cond, ref if_block, ref else_block) => {
+ let (pat, cond) = extract_pats_and_cond(cond);
+ Some(ControlFlow::new_if(
+ cond,
+ pat,
+ if_block,
+ else_block.as_ref().map(|e| &**e),
+ expr_type == ExprType::SubExpression,
+ false,
+ expr.span,
+ ))
+ }
+ ast::ExprKind::ForLoop(ref pat, ref cond, ref block, label) => {
+ Some(ControlFlow::new_for(pat, cond, block, label, expr.span))
+ }
+ ast::ExprKind::Loop(ref block, label) => {
+ Some(ControlFlow::new_loop(block, label, expr.span))
+ }
+ ast::ExprKind::While(ref cond, ref block, label) => {
+ let (pat, cond) = extract_pats_and_cond(cond);
+ Some(ControlFlow::new_while(pat, cond, block, label, expr.span))
+ }
+ _ => None,
+ }
+}
+
+fn choose_matcher(pat: Option<&ast::Pat>) -> &'static str {
+ pat.map_or("", |_| "let")
+}
+
+impl<'a> ControlFlow<'a> {
+ fn new_if(
+ cond: &'a ast::Expr,
+ pat: Option<&'a ast::Pat>,
+ block: &'a ast::Block,
+ else_block: Option<&'a ast::Expr>,
+ allow_single_line: bool,
+ nested_if: bool,
+ span: Span,
+ ) -> ControlFlow<'a> {
+ let matcher = choose_matcher(pat);
+ ControlFlow {
+ cond: Some(cond),
+ block,
+ else_block,
+ label: None,
+ pat,
+ keyword: "if",
+ matcher,
+ connector: " =",
+ allow_single_line,
+ nested_if,
+ span,
+ }
+ }
+
+ fn new_loop(block: &'a ast::Block, label: Option<ast::Label>, span: Span) -> ControlFlow<'a> {
+ ControlFlow {
+ cond: None,
+ block,
+ else_block: None,
+ label,
+ pat: None,
+ keyword: "loop",
+ matcher: "",
+ connector: "",
+ allow_single_line: false,
+ nested_if: false,
+ span,
+ }
+ }
+
+ fn new_while(
+ pat: Option<&'a ast::Pat>,
+ cond: &'a ast::Expr,
+ block: &'a ast::Block,
+ label: Option<ast::Label>,
+ span: Span,
+ ) -> ControlFlow<'a> {
+ let matcher = choose_matcher(pat);
+ ControlFlow {
+ cond: Some(cond),
+ block,
+ else_block: None,
+ label,
+ pat,
+ keyword: "while",
+ matcher,
+ connector: " =",
+ allow_single_line: false,
+ nested_if: false,
+ span,
+ }
+ }
+
+ fn new_for(
+ pat: &'a ast::Pat,
+ cond: &'a ast::Expr,
+ block: &'a ast::Block,
+ label: Option<ast::Label>,
+ span: Span,
+ ) -> ControlFlow<'a> {
+ ControlFlow {
+ cond: Some(cond),
+ block,
+ else_block: None,
+ label,
+ pat: Some(pat),
+ keyword: "for",
+ matcher: "",
+ connector: " in",
+ allow_single_line: false,
+ nested_if: false,
+ span,
+ }
+ }
+
+ fn rewrite_single_line(
+ &self,
+ pat_expr_str: &str,
+ context: &RewriteContext<'_>,
+ width: usize,
+ ) -> Option<String> {
+ assert!(self.allow_single_line);
+ let else_block = self.else_block?;
+ let fixed_cost = self.keyword.len() + " { } else { }".len();
+
+ if let ast::ExprKind::Block(ref else_node, _) = else_block.kind {
+ if !is_simple_block(context, self.block, None)
+ || !is_simple_block(context, else_node, None)
+ || pat_expr_str.contains('\n')
+ {
+ return None;
+ }
+
+ let new_width = width.checked_sub(pat_expr_str.len() + fixed_cost)?;
+ let expr = &self.block.stmts[0];
+ let if_str = expr.rewrite(context, Shape::legacy(new_width, Indent::empty()))?;
+
+ let new_width = new_width.checked_sub(if_str.len())?;
+ let else_expr = &else_node.stmts[0];
+ let else_str = else_expr.rewrite(context, Shape::legacy(new_width, Indent::empty()))?;
+
+ if if_str.contains('\n') || else_str.contains('\n') {
+ return None;
+ }
+
+ let result = format!(
+ "{} {} {{ {} }} else {{ {} }}",
+ self.keyword, pat_expr_str, if_str, else_str
+ );
+
+ if result.len() <= width {
+ return Some(result);
+ }
+ }
+
+ None
+ }
+}
+
+/// Returns `true` if the last line of pat_str has leading whitespace and it is wider than the
+/// shape's indent.
+fn last_line_offsetted(start_column: usize, pat_str: &str) -> bool {
+ let mut leading_whitespaces = 0;
+ for c in pat_str.chars().rev() {
+ match c {
+ '\n' => break,
+ _ if c.is_whitespace() => leading_whitespaces += 1,
+ _ => leading_whitespaces = 0,
+ }
+ }
+ leading_whitespaces > start_column
+}
+
+impl<'a> ControlFlow<'a> {
+ fn rewrite_pat_expr(
+ &self,
+ context: &RewriteContext<'_>,
+ expr: &ast::Expr,
+ shape: Shape,
+ offset: usize,
+ ) -> Option<String> {
+ debug!("rewrite_pat_expr {:?} {:?} {:?}", shape, self.pat, expr);
+
+ let cond_shape = shape.offset_left(offset)?;
+ if let Some(pat) = self.pat {
+ let matcher = if self.matcher.is_empty() {
+ self.matcher.to_owned()
+ } else {
+ format!("{} ", self.matcher)
+ };
+ let pat_shape = cond_shape
+ .offset_left(matcher.len())?
+ .sub_width(self.connector.len())?;
+ let pat_string = pat.rewrite(context, pat_shape)?;
+ let comments_lo = context
+ .snippet_provider
- let has_base = match struct_rest {
++ .span_after(self.span.with_lo(pat.span.hi()), self.connector.trim());
+ let comments_span = mk_sp(comments_lo, expr.span.lo());
+ return rewrite_assign_rhs_with_comments(
+ context,
+ &format!("{}{}{}", matcher, pat_string, self.connector),
+ expr,
+ cond_shape,
+ RhsTactics::Default,
+ comments_span,
+ true,
+ );
+ }
+
+ let expr_rw = expr.rewrite(context, cond_shape);
+ // The expression may (partially) fit on the current line.
+ // We do not allow splitting between `if` and condition.
+ if self.keyword == "if" || expr_rw.is_some() {
+ return expr_rw;
+ }
+
+ // The expression won't fit on the current line, jump to next.
+ let nested_shape = shape
+ .block_indent(context.config.tab_spaces())
+ .with_max_width(context.config);
+ let nested_indent_str = nested_shape.indent.to_string_with_newline(context.config);
+ expr.rewrite(context, nested_shape)
+ .map(|expr_rw| format!("{}{}", nested_indent_str, expr_rw))
+ }
+
+ fn rewrite_cond(
+ &self,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+ alt_block_sep: &str,
+ ) -> Option<(String, usize)> {
+ // Do not take the rhs overhead from the upper expressions into account
+ // when rewriting pattern.
+ let new_width = context.budget(shape.used_width());
+ let fresh_shape = Shape {
+ width: new_width,
+ ..shape
+ };
+ let constr_shape = if self.nested_if {
+ // We are part of an if-elseif-else chain. Our constraints are tightened.
+ // 7 = "} else " .len()
+ fresh_shape.offset_left(7)?
+ } else {
+ fresh_shape
+ };
+
+ let label_string = rewrite_label(self.label);
+ // 1 = space after keyword.
+ let offset = self.keyword.len() + label_string.len() + 1;
+
+ let pat_expr_string = match self.cond {
+ Some(cond) => self.rewrite_pat_expr(context, cond, constr_shape, offset)?,
+ None => String::new(),
+ };
+
+ let brace_overhead =
+ if context.config.control_brace_style() != ControlBraceStyle::AlwaysNextLine {
+ // 2 = ` {`
+ 2
+ } else {
+ 0
+ };
+ let one_line_budget = context
+ .config
+ .max_width()
+ .saturating_sub(constr_shape.used_width() + offset + brace_overhead);
+ let force_newline_brace = (pat_expr_string.contains('\n')
+ || pat_expr_string.len() > one_line_budget)
+ && (!last_line_extendable(&pat_expr_string)
+ || last_line_offsetted(shape.used_width(), &pat_expr_string));
+
+ // Try to format if-else on single line.
+ if self.allow_single_line && context.config.single_line_if_else_max_width() > 0 {
+ let trial = self.rewrite_single_line(&pat_expr_string, context, shape.width);
+
+ if let Some(cond_str) = trial {
+ if cond_str.len() <= context.config.single_line_if_else_max_width() {
+ return Some((cond_str, 0));
+ }
+ }
+ }
+
+ let cond_span = if let Some(cond) = self.cond {
+ cond.span
+ } else {
+ mk_sp(self.block.span.lo(), self.block.span.lo())
+ };
+
+ // `for event in event`
+ // Do not include label in the span.
+ let lo = self
+ .label
+ .map_or(self.span.lo(), |label| label.ident.span.hi());
+ let between_kwd_cond = mk_sp(
+ context
+ .snippet_provider
+ .span_after(mk_sp(lo, self.span.hi()), self.keyword.trim()),
+ if self.pat.is_none() {
+ cond_span.lo()
+ } else if self.matcher.is_empty() {
+ self.pat.unwrap().span.lo()
+ } else {
+ context
+ .snippet_provider
+ .span_before(self.span, self.matcher.trim())
+ },
+ );
+
+ let between_kwd_cond_comment = extract_comment(between_kwd_cond, context, shape);
+
+ let after_cond_comment =
+ extract_comment(mk_sp(cond_span.hi(), self.block.span.lo()), context, shape);
+
+ let block_sep = if self.cond.is_none() && between_kwd_cond_comment.is_some() {
+ ""
+ } else if context.config.control_brace_style() == ControlBraceStyle::AlwaysNextLine
+ || force_newline_brace
+ {
+ alt_block_sep
+ } else {
+ " "
+ };
+
+ let used_width = if pat_expr_string.contains('\n') {
+ last_line_width(&pat_expr_string)
+ } else {
+ // 2 = spaces after keyword and condition.
+ label_string.len() + self.keyword.len() + pat_expr_string.len() + 2
+ };
+
+ Some((
+ format!(
+ "{}{}{}{}{}",
+ label_string,
+ self.keyword,
+ between_kwd_cond_comment.as_ref().map_or(
+ if pat_expr_string.is_empty() || pat_expr_string.starts_with('\n') {
+ ""
+ } else {
+ " "
+ },
+ |s| &**s,
+ ),
+ pat_expr_string,
+ after_cond_comment.as_ref().map_or(block_sep, |s| &**s)
+ ),
+ used_width,
+ ))
+ }
+}
+
+impl<'a> Rewrite for ControlFlow<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ debug!("ControlFlow::rewrite {:?} {:?}", self, shape);
+
+ let alt_block_sep = &shape.indent.to_string_with_newline(context.config);
+ let (cond_str, used_width) = self.rewrite_cond(context, shape, alt_block_sep)?;
+ // If `used_width` is 0, it indicates that whole control flow is written in a single line.
+ if used_width == 0 {
+ return Some(cond_str);
+ }
+
+ let block_width = shape.width.saturating_sub(used_width);
+ // This is used only for the empty block case: `{}`. So, we use 1 if we know
+ // we should avoid the single line case.
+ let block_width = if self.else_block.is_some() || self.nested_if {
+ min(1, block_width)
+ } else {
+ block_width
+ };
+ let block_shape = Shape {
+ width: block_width,
+ ..shape
+ };
+ let block_str = {
+ let old_val = context.is_if_else_block.replace(self.else_block.is_some());
+ let result =
+ rewrite_block_with_visitor(context, "", self.block, None, None, block_shape, true);
+ context.is_if_else_block.replace(old_val);
+ result?
+ };
+
+ let mut result = format!("{}{}", cond_str, block_str);
+
+ if let Some(else_block) = self.else_block {
+ let shape = Shape::indented(shape.indent, context.config);
+ let mut last_in_chain = false;
+ let rewrite = match else_block.kind {
+ // If the else expression is another if-else expression, prevent it
+ // from being formatted on a single line.
+ // Note how we're passing the original shape, as the
+ // cost of "else" should not cascade.
+ ast::ExprKind::If(ref cond, ref if_block, ref next_else_block) => {
+ let (pats, cond) = extract_pats_and_cond(cond);
+ ControlFlow::new_if(
+ cond,
+ pats,
+ if_block,
+ next_else_block.as_ref().map(|e| &**e),
+ false,
+ true,
+ mk_sp(else_block.span.lo(), self.span.hi()),
+ )
+ .rewrite(context, shape)
+ }
+ _ => {
+ last_in_chain = true;
+ // When rewriting a block, the width is only used for single line
+ // blocks, passing 1 lets us avoid that.
+ let else_shape = Shape {
+ width: min(1, shape.width),
+ ..shape
+ };
+ format_expr(else_block, ExprType::Statement, context, else_shape)
+ }
+ };
+
+ let between_kwd_else_block = mk_sp(
+ self.block.span.hi(),
+ context
+ .snippet_provider
+ .span_before(mk_sp(self.block.span.hi(), else_block.span.lo()), "else"),
+ );
+ let between_kwd_else_block_comment =
+ extract_comment(between_kwd_else_block, context, shape);
+
+ let after_else = mk_sp(
+ context
+ .snippet_provider
+ .span_after(mk_sp(self.block.span.hi(), else_block.span.lo()), "else"),
+ else_block.span.lo(),
+ );
+ let after_else_comment = extract_comment(after_else, context, shape);
+
+ let between_sep = match context.config.control_brace_style() {
+ ControlBraceStyle::AlwaysNextLine | ControlBraceStyle::ClosingNextLine => {
+ &*alt_block_sep
+ }
+ ControlBraceStyle::AlwaysSameLine => " ",
+ };
+ let after_sep = match context.config.control_brace_style() {
+ ControlBraceStyle::AlwaysNextLine if last_in_chain => &*alt_block_sep,
+ _ => " ",
+ };
+
+ result.push_str(&format!(
+ "{}else{}",
+ between_kwd_else_block_comment
+ .as_ref()
+ .map_or(between_sep, |s| &**s),
+ after_else_comment.as_ref().map_or(after_sep, |s| &**s),
+ ));
+ result.push_str(&rewrite?);
+ }
+
+ Some(result)
+ }
+}
+
+fn rewrite_label(opt_label: Option<ast::Label>) -> Cow<'static, str> {
+ match opt_label {
+ Some(label) => Cow::from(format!("{}: ", label.ident)),
+ None => Cow::from(""),
+ }
+}
+
+fn extract_comment(span: Span, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match rewrite_missing_comment(span, shape, context) {
+ Some(ref comment) if !comment.is_empty() => Some(format!(
+ "{indent}{}{indent}",
+ comment,
+ indent = shape.indent.to_string_with_newline(context.config)
+ )),
+ _ => None,
+ }
+}
+
+pub(crate) fn block_contains_comment(context: &RewriteContext<'_>, block: &ast::Block) -> bool {
+ contains_comment(context.snippet(block.span))
+}
+
+// Checks that a block contains no statements, an expression and no comments or
+// attributes.
+// FIXME: incorrectly returns false when comment is contained completely within
+// the expression.
+pub(crate) fn is_simple_block(
+ context: &RewriteContext<'_>,
+ block: &ast::Block,
+ attrs: Option<&[ast::Attribute]>,
+) -> bool {
+ block.stmts.len() == 1
+ && stmt_is_expr(&block.stmts[0])
+ && !block_contains_comment(context, block)
+ && attrs.map_or(true, |a| a.is_empty())
+}
+
+/// Checks whether a block contains at most one statement or expression, and no
+/// comments or attributes.
+pub(crate) fn is_simple_block_stmt(
+ context: &RewriteContext<'_>,
+ block: &ast::Block,
+ attrs: Option<&[ast::Attribute]>,
+) -> bool {
+ block.stmts.len() <= 1
+ && !block_contains_comment(context, block)
+ && attrs.map_or(true, |a| a.is_empty())
+}
+
+fn block_has_statements(block: &ast::Block) -> bool {
+ block
+ .stmts
+ .iter()
+ .any(|stmt| !matches!(stmt.kind, ast::StmtKind::Empty))
+}
+
+/// Checks whether a block contains no statements, expressions, comments, or
+/// inner attributes.
+pub(crate) fn is_empty_block(
+ context: &RewriteContext<'_>,
+ block: &ast::Block,
+ attrs: Option<&[ast::Attribute]>,
+) -> bool {
+ !block_has_statements(&block)
+ && !block_contains_comment(context, block)
+ && attrs.map_or(true, |a| inner_attributes(a).is_empty())
+}
+
+pub(crate) fn stmt_is_expr(stmt: &ast::Stmt) -> bool {
+ matches!(stmt.kind, ast::StmtKind::Expr(..))
+}
+
+pub(crate) fn is_unsafe_block(block: &ast::Block) -> bool {
+ matches!(block.rules, ast::BlockCheckMode::Unsafe(..))
+}
+
+pub(crate) fn rewrite_literal(
+ context: &RewriteContext<'_>,
+ l: &ast::Lit,
+ shape: Shape,
+) -> Option<String> {
+ match l.kind {
+ ast::LitKind::Str(_, ast::StrStyle::Cooked) => rewrite_string_lit(context, l.span, shape),
++ ast::LitKind::Int(..) => rewrite_int_lit(context, l, shape),
+ _ => wrap_str(
+ context.snippet(l.span).to_owned(),
+ context.config.max_width(),
+ shape,
+ ),
+ }
+}
+
+fn rewrite_string_lit(context: &RewriteContext<'_>, span: Span, shape: Shape) -> Option<String> {
+ let string_lit = context.snippet(span);
+
+ if !context.config.format_strings() {
+ if string_lit
+ .lines()
+ .dropping_back(1)
+ .all(|line| line.ends_with('\\'))
+ && context.config.version() == Version::Two
+ {
+ return Some(string_lit.to_owned());
+ } else {
+ return wrap_str(string_lit.to_owned(), context.config.max_width(), shape);
+ }
+ }
+
+ // Remove the quote characters.
+ let str_lit = &string_lit[1..string_lit.len() - 1];
+
+ rewrite_string(
+ str_lit,
+ &StringFormat::new(shape.visual_indent(0), context.config),
+ shape.width.saturating_sub(2),
+ )
+}
+
++fn rewrite_int_lit(context: &RewriteContext<'_>, lit: &ast::Lit, shape: Shape) -> Option<String> {
++ let span = lit.span;
++ let symbol = lit.token.symbol.as_str();
++
++ if symbol.starts_with("0x") {
++ let hex_lit = match context.config.hex_literal_case() {
++ HexLiteralCase::Preserve => None,
++ HexLiteralCase::Upper => Some(symbol[2..].to_ascii_uppercase()),
++ HexLiteralCase::Lower => Some(symbol[2..].to_ascii_lowercase()),
++ };
++ if let Some(hex_lit) = hex_lit {
++ return wrap_str(
++ format!(
++ "0x{}{}",
++ hex_lit,
++ lit.token.suffix.map_or(String::new(), |s| s.to_string())
++ ),
++ context.config.max_width(),
++ shape,
++ );
++ }
++ }
++
++ wrap_str(
++ context.snippet(span).to_owned(),
++ context.config.max_width(),
++ shape,
++ )
++}
++
+fn choose_separator_tactic(context: &RewriteContext<'_>, span: Span) -> Option<SeparatorTactic> {
+ if context.inside_macro() {
+ if span_ends_with_comma(context, span) {
+ Some(SeparatorTactic::Always)
+ } else {
+ Some(SeparatorTactic::Never)
+ }
+ } else {
+ None
+ }
+}
+
+pub(crate) fn rewrite_call(
+ context: &RewriteContext<'_>,
+ callee: &str,
+ args: &[ptr::P<ast::Expr>],
+ span: Span,
+ shape: Shape,
+) -> Option<String> {
+ overflow::rewrite_with_parens(
+ context,
+ callee,
+ args.iter(),
+ shape,
+ span,
+ context.config.fn_call_width(),
+ choose_separator_tactic(context, span),
+ )
+}
+
+pub(crate) fn is_simple_expr(expr: &ast::Expr) -> bool {
+ match expr.kind {
+ ast::ExprKind::Lit(..) => true,
+ ast::ExprKind::Path(ref qself, ref path) => qself.is_none() && path.segments.len() <= 1,
+ ast::ExprKind::AddrOf(_, _, ref expr)
+ | ast::ExprKind::Box(ref expr)
+ | ast::ExprKind::Cast(ref expr, _)
+ | ast::ExprKind::Field(ref expr, _)
+ | ast::ExprKind::Try(ref expr)
+ | ast::ExprKind::Unary(_, ref expr) => is_simple_expr(expr),
+ ast::ExprKind::Index(ref lhs, ref rhs) => is_simple_expr(lhs) && is_simple_expr(rhs),
+ ast::ExprKind::Repeat(ref lhs, ref rhs) => {
+ is_simple_expr(lhs) && is_simple_expr(&*rhs.value)
+ }
+ _ => false,
+ }
+}
+
+pub(crate) fn is_every_expr_simple(lists: &[OverflowableItem<'_>]) -> bool {
+ lists.iter().all(OverflowableItem::is_simple)
+}
+
+pub(crate) fn can_be_overflowed_expr(
+ context: &RewriteContext<'_>,
+ expr: &ast::Expr,
+ args_len: usize,
+) -> bool {
+ match expr.kind {
+ _ if !expr.attrs.is_empty() => false,
+ ast::ExprKind::Match(..) => {
+ (context.use_block_indent() && args_len == 1)
+ || (context.config.indent_style() == IndentStyle::Visual && args_len > 1)
+ || context.config.overflow_delimited_expr()
+ }
+ ast::ExprKind::If(..)
+ | ast::ExprKind::ForLoop(..)
+ | ast::ExprKind::Loop(..)
+ | ast::ExprKind::While(..) => {
+ context.config.combine_control_expr() && context.use_block_indent() && args_len == 1
+ }
+
+ // Handle always block-like expressions
+ ast::ExprKind::Async(..) | ast::ExprKind::Block(..) | ast::ExprKind::Closure(..) => true,
+
+ // Handle `[]` and `{}`-like expressions
+ ast::ExprKind::Array(..) | ast::ExprKind::Struct(..) => {
+ context.config.overflow_delimited_expr()
+ || (context.use_block_indent() && args_len == 1)
+ }
+ ast::ExprKind::MacCall(ref mac) => {
+ match (
+ rustc_ast::ast::MacDelimiter::from_token(mac.args.delim()),
+ context.config.overflow_delimited_expr(),
+ ) {
+ (Some(ast::MacDelimiter::Bracket), true)
+ | (Some(ast::MacDelimiter::Brace), true) => true,
+ _ => context.use_block_indent() && args_len == 1,
+ }
+ }
+
+ // Handle parenthetical expressions
+ ast::ExprKind::Call(..) | ast::ExprKind::MethodCall(..) | ast::ExprKind::Tup(..) => {
+ context.use_block_indent() && args_len == 1
+ }
+
+ // Handle unary-like expressions
+ ast::ExprKind::AddrOf(_, _, ref expr)
+ | ast::ExprKind::Box(ref expr)
+ | ast::ExprKind::Try(ref expr)
+ | ast::ExprKind::Unary(_, ref expr)
+ | ast::ExprKind::Cast(ref expr, _) => can_be_overflowed_expr(context, expr, args_len),
+ _ => false,
+ }
+}
+
+pub(crate) fn is_nested_call(expr: &ast::Expr) -> bool {
+ match expr.kind {
+ ast::ExprKind::Call(..) | ast::ExprKind::MacCall(..) => true,
+ ast::ExprKind::AddrOf(_, _, ref expr)
+ | ast::ExprKind::Box(ref expr)
+ | ast::ExprKind::Try(ref expr)
+ | ast::ExprKind::Unary(_, ref expr)
+ | ast::ExprKind::Cast(ref expr, _) => is_nested_call(expr),
+ _ => false,
+ }
+}
+
+/// Returns `true` if a function call or a method call represented by the given span ends with a
+/// trailing comma. This function is used when rewriting macro, as adding or removing a trailing
+/// comma from macro can potentially break the code.
+pub(crate) fn span_ends_with_comma(context: &RewriteContext<'_>, span: Span) -> bool {
+ let mut result: bool = Default::default();
+ let mut prev_char: char = Default::default();
+ let closing_delimiters = &[')', '}', ']'];
+
+ for (kind, c) in CharClasses::new(context.snippet(span).chars()) {
+ match c {
+ _ if kind.is_comment() || c.is_whitespace() => continue,
+ c if closing_delimiters.contains(&c) => {
+ result &= !closing_delimiters.contains(&prev_char);
+ }
+ ',' => result = true,
+ _ => result = false,
+ }
+ prev_char = c;
+ }
+
+ result
+}
+
+fn rewrite_paren(
+ context: &RewriteContext<'_>,
+ mut subexpr: &ast::Expr,
+ shape: Shape,
+ mut span: Span,
+) -> Option<String> {
+ debug!("rewrite_paren, shape: {:?}", shape);
+
+ // Extract comments within parens.
+ let mut pre_span;
+ let mut post_span;
+ let mut pre_comment;
+ let mut post_comment;
+ let remove_nested_parens = context.config.remove_nested_parens();
+ loop {
+ // 1 = "(" or ")"
+ pre_span = mk_sp(span.lo() + BytePos(1), subexpr.span.lo());
+ post_span = mk_sp(subexpr.span.hi(), span.hi() - BytePos(1));
+ pre_comment = rewrite_missing_comment(pre_span, shape, context)?;
+ post_comment = rewrite_missing_comment(post_span, shape, context)?;
+
+ // Remove nested parens if there are no comments.
+ if let ast::ExprKind::Paren(ref subsubexpr) = subexpr.kind {
+ if remove_nested_parens && pre_comment.is_empty() && post_comment.is_empty() {
+ span = subexpr.span;
+ subexpr = subsubexpr;
+ continue;
+ }
+ }
+
+ break;
+ }
+
+ // 1 = `(` and `)`
+ let sub_shape = shape.offset_left(1)?.sub_width(1)?;
+ let subexpr_str = subexpr.rewrite(context, sub_shape)?;
+ let fits_single_line = !pre_comment.contains("//") && !post_comment.contains("//");
+ if fits_single_line {
+ Some(format!("({}{}{})", pre_comment, subexpr_str, post_comment))
+ } else {
+ rewrite_paren_in_multi_line(context, subexpr, shape, pre_span, post_span)
+ }
+}
+
+fn rewrite_paren_in_multi_line(
+ context: &RewriteContext<'_>,
+ subexpr: &ast::Expr,
+ shape: Shape,
+ pre_span: Span,
+ post_span: Span,
+) -> Option<String> {
+ let nested_indent = shape.indent.block_indent(context.config);
+ let nested_shape = Shape::indented(nested_indent, context.config);
+ let pre_comment = rewrite_missing_comment(pre_span, nested_shape, context)?;
+ let post_comment = rewrite_missing_comment(post_span, nested_shape, context)?;
+ let subexpr_str = subexpr.rewrite(context, nested_shape)?;
+
+ let mut result = String::with_capacity(subexpr_str.len() * 2);
+ result.push('(');
+ if !pre_comment.is_empty() {
+ result.push_str(&nested_indent.to_string_with_newline(context.config));
+ result.push_str(&pre_comment);
+ }
+ result.push_str(&nested_indent.to_string_with_newline(context.config));
+ result.push_str(&subexpr_str);
+ if !post_comment.is_empty() {
+ result.push_str(&nested_indent.to_string_with_newline(context.config));
+ result.push_str(&post_comment);
+ }
+ result.push_str(&shape.indent.to_string_with_newline(context.config));
+ result.push(')');
+
+ Some(result)
+}
+
+fn rewrite_index(
+ expr: &ast::Expr,
+ index: &ast::Expr,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String> {
+ let expr_str = expr.rewrite(context, shape)?;
+
+ let offset = last_line_width(&expr_str) + 1;
+ let rhs_overhead = shape.rhs_overhead(context.config);
+ let index_shape = if expr_str.contains('\n') {
+ Shape::legacy(context.config.max_width(), shape.indent)
+ .offset_left(offset)
+ .and_then(|shape| shape.sub_width(1 + rhs_overhead))
+ } else {
+ match context.config.indent_style() {
+ IndentStyle::Block => shape
+ .offset_left(offset)
+ .and_then(|shape| shape.sub_width(1)),
+ IndentStyle::Visual => shape.visual_indent(offset).sub_width(offset + 1),
+ }
+ };
+ let orig_index_rw = index_shape.and_then(|s| index.rewrite(context, s));
+
+ // Return if index fits in a single line.
+ match orig_index_rw {
+ Some(ref index_str) if !index_str.contains('\n') => {
+ return Some(format!("{}[{}]", expr_str, index_str));
+ }
+ _ => (),
+ }
+
+ // Try putting index on the next line and see if it fits in a single line.
+ let indent = shape.indent.block_indent(context.config);
+ let index_shape = Shape::indented(indent, context.config).offset_left(1)?;
+ let index_shape = index_shape.sub_width(1 + rhs_overhead)?;
+ let new_index_rw = index.rewrite(context, index_shape);
+ match (orig_index_rw, new_index_rw) {
+ (_, Some(ref new_index_str)) if !new_index_str.contains('\n') => Some(format!(
+ "{}{}[{}]",
+ expr_str,
+ indent.to_string_with_newline(context.config),
+ new_index_str,
+ )),
+ (None, Some(ref new_index_str)) => Some(format!(
+ "{}{}[{}]",
+ expr_str,
+ indent.to_string_with_newline(context.config),
+ new_index_str,
+ )),
+ (Some(ref index_str), _) => Some(format!("{}[{}]", expr_str, index_str)),
+ _ => None,
+ }
+}
+
+fn struct_lit_can_be_aligned(fields: &[ast::ExprField], has_base: bool) -> bool {
+ !has_base && fields.iter().all(|field| !field.is_shorthand)
+}
+
+fn rewrite_struct_lit<'a>(
+ context: &RewriteContext<'_>,
+ path: &ast::Path,
+ fields: &'a [ast::ExprField],
+ struct_rest: &ast::StructRest,
+ attrs: &[ast::Attribute],
+ span: Span,
+ shape: Shape,
+) -> Option<String> {
+ debug!("rewrite_struct_lit: shape {:?}", shape);
+
+ enum StructLitField<'a> {
+ Regular(&'a ast::ExprField),
+ Base(&'a ast::Expr),
+ Rest(&'a Span),
+ }
+
+ // 2 = " {".len()
+ let path_shape = shape.sub_width(2)?;
+ let path_str = rewrite_path(context, PathContext::Expr, None, path, path_shape)?;
+
- ast::StructRest::Base(_) => true,
++ let has_base_or_rest = match struct_rest {
+ ast::StructRest::None if fields.is_empty() => return Some(format!("{} {{}}", path_str)),
+ ast::StructRest::Rest(_) if fields.is_empty() => {
+ return Some(format!("{} {{ .. }}", path_str));
+ }
- let fields_str = if struct_lit_can_be_aligned(fields, has_base)
++ ast::StructRest::Rest(_) | ast::StructRest::Base(_) => true,
+ _ => false,
+ };
+
+ // Foo { a: Foo } - indent is +3, width is -5.
+ let (h_shape, v_shape) = struct_lit_shape(shape, context, path_str.len() + 3, 2)?;
+
+ let one_line_width = h_shape.map_or(0, |shape| shape.width);
+ let body_lo = context.snippet_provider.span_after(span, "{");
- force_no_trailing_comma
- || has_base
- || !context.use_block_indent()
- || matches!(struct_rest, ast::StructRest::Rest(_)),
++ let fields_str = if struct_lit_can_be_aligned(fields, has_base_or_rest)
+ && context.config.struct_field_align_threshold() > 0
+ {
+ rewrite_with_alignment(
+ fields,
+ context,
+ v_shape,
+ mk_sp(body_lo, span.hi()),
+ one_line_width,
+ )?
+ } else {
+ let field_iter = fields.iter().map(StructLitField::Regular).chain(
+ match struct_rest {
+ ast::StructRest::Base(expr) => Some(StructLitField::Base(&**expr)),
+ ast::StructRest::Rest(span) => Some(StructLitField::Rest(span)),
+ ast::StructRest::None => None,
+ }
+ .into_iter(),
+ );
+
+ let span_lo = |item: &StructLitField<'_>| match *item {
+ StructLitField::Regular(field) => field.span().lo(),
+ StructLitField::Base(expr) => {
+ let last_field_hi = fields.last().map_or(span.lo(), |field| field.span.hi());
+ let snippet = context.snippet(mk_sp(last_field_hi, expr.span.lo()));
+ let pos = snippet.find_uncommented("..").unwrap();
+ last_field_hi + BytePos(pos as u32)
+ }
+ StructLitField::Rest(span) => span.lo(),
+ };
+ let span_hi = |item: &StructLitField<'_>| match *item {
+ StructLitField::Regular(field) => field.span().hi(),
+ StructLitField::Base(expr) => expr.span.hi(),
+ StructLitField::Rest(span) => span.hi(),
+ };
+ let rewrite = |item: &StructLitField<'_>| match *item {
+ StructLitField::Regular(field) => {
+ // The 1 taken from the v_budget is for the comma.
+ rewrite_field(context, field, v_shape.sub_width(1)?, 0)
+ }
+ StructLitField::Base(expr) => {
+ // 2 = ..
+ expr.rewrite(context, v_shape.offset_left(2)?)
+ .map(|s| format!("..{}", s))
+ }
+ StructLitField::Rest(_) => Some("..".to_owned()),
+ };
+
+ let items = itemize_list(
+ context.snippet_provider,
+ field_iter,
+ "}",
+ ",",
+ span_lo,
+ span_hi,
+ rewrite,
+ body_lo,
+ span.hi(),
+ false,
+ );
+ let item_vec = items.collect::<Vec<_>>();
+
+ let tactic = struct_lit_tactic(h_shape, context, &item_vec);
+ let nested_shape = shape_for_tactic(tactic, h_shape, v_shape);
+
+ let ends_with_comma = span_ends_with_comma(context, span);
+ let force_no_trailing_comma = context.inside_macro() && !ends_with_comma;
+
+ let fmt = struct_lit_formatting(
+ nested_shape,
+ tactic,
+ context,
++ force_no_trailing_comma || has_base_or_rest || !context.use_block_indent(),
+ );
+
+ write_list(&item_vec, &fmt)?
+ };
+
+ let fields_str =
+ wrap_struct_field(context, &attrs, &fields_str, shape, v_shape, one_line_width)?;
+ Some(format!("{} {{{}}}", path_str, fields_str))
+
+ // FIXME if context.config.indent_style() == Visual, but we run out
+ // of space, we should fall back to BlockIndent.
+}
+
+pub(crate) fn wrap_struct_field(
+ context: &RewriteContext<'_>,
+ attrs: &[ast::Attribute],
+ fields_str: &str,
+ shape: Shape,
+ nested_shape: Shape,
+ one_line_width: usize,
+) -> Option<String> {
+ let should_vertical = context.config.indent_style() == IndentStyle::Block
+ && (fields_str.contains('\n')
+ || !context.config.struct_lit_single_line()
+ || fields_str.len() > one_line_width);
+
+ let inner_attrs = &inner_attributes(attrs);
+ if inner_attrs.is_empty() {
+ if should_vertical {
+ Some(format!(
+ "{}{}{}",
+ nested_shape.indent.to_string_with_newline(context.config),
+ fields_str,
+ shape.indent.to_string_with_newline(context.config)
+ ))
+ } else {
+ // One liner or visual indent.
+ Some(format!(" {} ", fields_str))
+ }
+ } else {
+ Some(format!(
+ "{}{}{}{}{}",
+ nested_shape.indent.to_string_with_newline(context.config),
+ inner_attrs.rewrite(context, shape)?,
+ nested_shape.indent.to_string_with_newline(context.config),
+ fields_str,
+ shape.indent.to_string_with_newline(context.config)
+ ))
+ }
+}
+
+pub(crate) fn struct_lit_field_separator(config: &Config) -> &str {
+ colon_spaces(config)
+}
+
+pub(crate) fn rewrite_field(
+ context: &RewriteContext<'_>,
+ field: &ast::ExprField,
+ shape: Shape,
+ prefix_max_width: usize,
+) -> Option<String> {
+ if contains_skip(&field.attrs) {
+ return Some(context.snippet(field.span()).to_owned());
+ }
+ let mut attrs_str = field.attrs.rewrite(context, shape)?;
+ if !attrs_str.is_empty() {
+ attrs_str.push_str(&shape.indent.to_string_with_newline(context.config));
+ };
+ let name = context.snippet(field.ident.span);
+ if field.is_shorthand {
+ Some(attrs_str + name)
+ } else {
+ let mut separator = String::from(struct_lit_field_separator(context.config));
+ for _ in 0..prefix_max_width.saturating_sub(name.len()) {
+ separator.push(' ');
+ }
+ let overhead = name.len() + separator.len();
+ let expr_shape = shape.offset_left(overhead)?;
+ let expr = field.expr.rewrite(context, expr_shape);
+
+ match expr {
+ Some(ref e) if e.as_str() == name && context.config.use_field_init_shorthand() => {
+ Some(attrs_str + name)
+ }
+ Some(e) => Some(format!("{}{}{}{}", attrs_str, name, separator, e)),
+ None => {
+ let expr_offset = shape.indent.block_indent(context.config);
+ let expr = field
+ .expr
+ .rewrite(context, Shape::indented(expr_offset, context.config));
+ expr.map(|s| {
+ format!(
+ "{}{}:\n{}{}",
+ attrs_str,
+ name,
+ expr_offset.to_string(context.config),
+ s
+ )
+ })
+ }
+ }
+ }
+}
+
+fn rewrite_tuple_in_visual_indent_style<'a, T: 'a + IntoOverflowableItem<'a>>(
+ context: &RewriteContext<'_>,
+ mut items: impl Iterator<Item = &'a T>,
+ span: Span,
+ shape: Shape,
+ is_singleton_tuple: bool,
+) -> Option<String> {
+ // In case of length 1, need a trailing comma
+ debug!("rewrite_tuple_in_visual_indent_style {:?}", shape);
+ if is_singleton_tuple {
+ // 3 = "(" + ",)"
+ let nested_shape = shape.sub_width(3)?.visual_indent(1);
+ return items
+ .next()
+ .unwrap()
+ .rewrite(context, nested_shape)
+ .map(|s| format!("({},)", s));
+ }
+
+ let list_lo = context.snippet_provider.span_after(span, "(");
+ let nested_shape = shape.sub_width(2)?.visual_indent(1);
+ let items = itemize_list(
+ context.snippet_provider,
+ items,
+ ")",
+ ",",
+ |item| item.span().lo(),
+ |item| item.span().hi(),
+ |item| item.rewrite(context, nested_shape),
+ list_lo,
+ span.hi() - BytePos(1),
+ false,
+ );
+ let item_vec: Vec<_> = items.collect();
+ let tactic = definitive_tactic(
+ &item_vec,
+ ListTactic::HorizontalVertical,
+ Separator::Comma,
+ nested_shape.width,
+ );
+ let fmt = ListFormatting::new(nested_shape, context.config)
+ .tactic(tactic)
+ .ends_with_newline(false);
+ let list_str = write_list(&item_vec, &fmt)?;
+
+ Some(format!("({})", list_str))
+}
+
+pub(crate) fn rewrite_tuple<'a, T: 'a + IntoOverflowableItem<'a>>(
+ context: &'a RewriteContext<'_>,
+ items: impl Iterator<Item = &'a T>,
+ span: Span,
+ shape: Shape,
+ is_singleton_tuple: bool,
+) -> Option<String> {
+ debug!("rewrite_tuple {:?}", shape);
+ if context.use_block_indent() {
+ // We use the same rule as function calls for rewriting tuples.
+ let force_tactic = if context.inside_macro() {
+ if span_ends_with_comma(context, span) {
+ Some(SeparatorTactic::Always)
+ } else {
+ Some(SeparatorTactic::Never)
+ }
+ } else if is_singleton_tuple {
+ Some(SeparatorTactic::Always)
+ } else {
+ None
+ };
+ overflow::rewrite_with_parens(
+ context,
+ "",
+ items,
+ shape,
+ span,
+ context.config.fn_call_width(),
+ force_tactic,
+ )
+ } else {
+ rewrite_tuple_in_visual_indent_style(context, items, span, shape, is_singleton_tuple)
+ }
+}
+
+pub(crate) fn rewrite_unary_prefix<R: Rewrite>(
+ context: &RewriteContext<'_>,
+ prefix: &str,
+ rewrite: &R,
+ shape: Shape,
+) -> Option<String> {
+ rewrite
+ .rewrite(context, shape.offset_left(prefix.len())?)
+ .map(|r| format!("{}{}", prefix, r))
+}
+
+// FIXME: this is probably not correct for multi-line Rewrites. we should
+// subtract suffix.len() from the last line budget, not the first!
+pub(crate) fn rewrite_unary_suffix<R: Rewrite>(
+ context: &RewriteContext<'_>,
+ suffix: &str,
+ rewrite: &R,
+ shape: Shape,
+) -> Option<String> {
+ rewrite
+ .rewrite(context, shape.sub_width(suffix.len())?)
+ .map(|mut r| {
+ r.push_str(suffix);
+ r
+ })
+}
+
+fn rewrite_unary_op(
+ context: &RewriteContext<'_>,
+ op: ast::UnOp,
+ expr: &ast::Expr,
+ shape: Shape,
+) -> Option<String> {
+ // For some reason, an UnOp is not spanned like BinOp!
+ rewrite_unary_prefix(context, ast::UnOp::to_string(op), expr, shape)
+}
+
+fn rewrite_assignment(
+ context: &RewriteContext<'_>,
+ lhs: &ast::Expr,
+ rhs: &ast::Expr,
+ op: Option<&ast::BinOp>,
+ shape: Shape,
+) -> Option<String> {
+ let operator_str = match op {
+ Some(op) => context.snippet(op.span),
+ None => "=",
+ };
+
+ // 1 = space between lhs and operator.
+ let lhs_shape = shape.sub_width(operator_str.len() + 1)?;
+ let lhs_str = format!("{} {}", lhs.rewrite(context, lhs_shape)?, operator_str);
+
+ rewrite_assign_rhs(context, lhs_str, rhs, shape)
+}
+
+/// Controls where to put the rhs.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(crate) enum RhsTactics {
+ /// Use heuristics.
+ Default,
+ /// Put the rhs on the next line if it uses multiple line, without extra indentation.
+ ForceNextLineWithoutIndent,
+ /// Allow overflowing max width if neither `Default` nor `ForceNextLineWithoutIndent`
+ /// did not work.
+ AllowOverflow,
+}
+
+// The left hand side must contain everything up to, and including, the
+// assignment operator.
+pub(crate) fn rewrite_assign_rhs<S: Into<String>, R: Rewrite>(
+ context: &RewriteContext<'_>,
+ lhs: S,
+ ex: &R,
+ shape: Shape,
+) -> Option<String> {
+ rewrite_assign_rhs_with(context, lhs, ex, shape, RhsTactics::Default)
+}
+
+pub(crate) fn rewrite_assign_rhs_expr<R: Rewrite>(
+ context: &RewriteContext<'_>,
+ lhs: &str,
+ ex: &R,
+ shape: Shape,
+ rhs_tactics: RhsTactics,
+) -> Option<String> {
+ let last_line_width = last_line_width(&lhs).saturating_sub(if lhs.contains('\n') {
+ shape.indent.width()
+ } else {
+ 0
+ });
+ // 1 = space between operator and rhs.
+ let orig_shape = shape.offset_left(last_line_width + 1).unwrap_or(Shape {
+ width: 0,
+ offset: shape.offset + last_line_width + 1,
+ ..shape
+ });
+ let has_rhs_comment = if let Some(offset) = lhs.find_last_uncommented("=") {
+ lhs.trim_end().len() > offset + 1
+ } else {
+ false
+ };
+
+ choose_rhs(
+ context,
+ ex,
+ orig_shape,
+ ex.rewrite(context, orig_shape),
+ rhs_tactics,
+ has_rhs_comment,
+ )
+}
+
+pub(crate) fn rewrite_assign_rhs_with<S: Into<String>, R: Rewrite>(
+ context: &RewriteContext<'_>,
+ lhs: S,
+ ex: &R,
+ shape: Shape,
+ rhs_tactics: RhsTactics,
+) -> Option<String> {
+ let lhs = lhs.into();
+ let rhs = rewrite_assign_rhs_expr(context, &lhs, ex, shape, rhs_tactics)?;
+ Some(lhs + &rhs)
+}
+
+pub(crate) fn rewrite_assign_rhs_with_comments<S: Into<String>, R: Rewrite>(
+ context: &RewriteContext<'_>,
+ lhs: S,
+ ex: &R,
+ shape: Shape,
+ rhs_tactics: RhsTactics,
+ between_span: Span,
+ allow_extend: bool,
+) -> Option<String> {
+ let lhs = lhs.into();
+ let contains_comment = contains_comment(context.snippet(between_span));
+ let shape = if contains_comment {
+ shape.block_left(context.config.tab_spaces())?
+ } else {
+ shape
+ };
+ let rhs = rewrite_assign_rhs_expr(context, &lhs, ex, shape, rhs_tactics)?;
+
+ if contains_comment {
+ let rhs = rhs.trim_start();
+ combine_strs_with_missing_comments(context, &lhs, &rhs, between_span, shape, allow_extend)
+ } else {
+ Some(lhs + &rhs)
+ }
+}
+
+fn choose_rhs<R: Rewrite>(
+ context: &RewriteContext<'_>,
+ expr: &R,
+ shape: Shape,
+ orig_rhs: Option<String>,
+ rhs_tactics: RhsTactics,
+ has_rhs_comment: bool,
+) -> Option<String> {
+ match orig_rhs {
+ Some(ref new_str)
+ if !new_str.contains('\n') && unicode_str_width(new_str) <= shape.width =>
+ {
+ Some(format!(" {}", new_str))
+ }
+ _ => {
+ // Expression did not fit on the same line as the identifier.
+ // Try splitting the line and see if that works better.
+ let new_shape = shape_from_rhs_tactic(context, shape, rhs_tactics)?;
+ let new_rhs = expr.rewrite(context, new_shape);
+ let new_indent_str = &shape
+ .indent
+ .block_indent(context.config)
+ .to_string_with_newline(context.config);
+ let before_space_str = if has_rhs_comment { "" } else { " " };
+
+ match (orig_rhs, new_rhs) {
+ (Some(ref orig_rhs), Some(ref new_rhs))
+ if wrap_str(new_rhs.clone(), context.config.max_width(), new_shape)
+ .is_none() =>
+ {
+ Some(format!("{}{}", before_space_str, orig_rhs))
+ }
+ (Some(ref orig_rhs), Some(ref new_rhs))
+ if prefer_next_line(orig_rhs, new_rhs, rhs_tactics) =>
+ {
+ Some(format!("{}{}", new_indent_str, new_rhs))
+ }
+ (None, Some(ref new_rhs)) => Some(format!("{}{}", new_indent_str, new_rhs)),
+ (None, None) if rhs_tactics == RhsTactics::AllowOverflow => {
+ let shape = shape.infinite_width();
+ expr.rewrite(context, shape)
+ .map(|s| format!("{}{}", before_space_str, s))
+ }
+ (None, None) => None,
+ (Some(orig_rhs), _) => Some(format!("{}{}", before_space_str, orig_rhs)),
+ }
+ }
+ }
+}
+
+fn shape_from_rhs_tactic(
+ context: &RewriteContext<'_>,
+ shape: Shape,
+ rhs_tactic: RhsTactics,
+) -> Option<Shape> {
+ match rhs_tactic {
+ RhsTactics::ForceNextLineWithoutIndent => shape
+ .with_max_width(context.config)
+ .sub_width(shape.indent.width()),
+ RhsTactics::Default | RhsTactics::AllowOverflow => {
+ Shape::indented(shape.indent.block_indent(context.config), context.config)
+ .sub_width(shape.rhs_overhead(context.config))
+ }
+ }
+}
+
+/// Returns true if formatting next_line_rhs is better on a new line when compared to the
+/// original's line formatting.
+///
+/// It is considered better if:
+/// 1. the tactic is ForceNextLineWithoutIndent
+/// 2. next_line_rhs doesn't have newlines
+/// 3. the original line has more newlines than next_line_rhs
+/// 4. the original formatting of the first line ends with `(`, `{`, or `[` and next_line_rhs
+/// doesn't
+pub(crate) fn prefer_next_line(
+ orig_rhs: &str,
+ next_line_rhs: &str,
+ rhs_tactics: RhsTactics,
+) -> bool {
+ rhs_tactics == RhsTactics::ForceNextLineWithoutIndent
+ || !next_line_rhs.contains('\n')
+ || count_newlines(orig_rhs) > count_newlines(next_line_rhs) + 1
+ || first_line_ends_with(orig_rhs, '(') && !first_line_ends_with(next_line_rhs, '(')
+ || first_line_ends_with(orig_rhs, '{') && !first_line_ends_with(next_line_rhs, '{')
+ || first_line_ends_with(orig_rhs, '[') && !first_line_ends_with(next_line_rhs, '[')
+}
+
+fn rewrite_expr_addrof(
+ context: &RewriteContext<'_>,
+ borrow_kind: ast::BorrowKind,
+ mutability: ast::Mutability,
+ expr: &ast::Expr,
+ shape: Shape,
+) -> Option<String> {
+ let operator_str = match (mutability, borrow_kind) {
+ (ast::Mutability::Not, ast::BorrowKind::Ref) => "&",
+ (ast::Mutability::Not, ast::BorrowKind::Raw) => "&raw const ",
+ (ast::Mutability::Mut, ast::BorrowKind::Ref) => "&mut ",
+ (ast::Mutability::Mut, ast::BorrowKind::Raw) => "&raw mut ",
+ };
+ rewrite_unary_prefix(context, operator_str, expr, shape)
+}
+
+pub(crate) fn is_method_call(expr: &ast::Expr) -> bool {
+ match expr.kind {
+ ast::ExprKind::MethodCall(..) => true,
+ ast::ExprKind::AddrOf(_, _, ref expr)
+ | ast::ExprKind::Box(ref expr)
+ | ast::ExprKind::Cast(ref expr, _)
+ | ast::ExprKind::Try(ref expr)
+ | ast::ExprKind::Unary(_, ref expr) => is_method_call(expr),
+ _ => false,
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::last_line_offsetted;
+
+ #[test]
+ fn test_last_line_offsetted() {
+ let lines = "one\n two";
+ assert_eq!(last_line_offsetted(2, lines), true);
+ assert_eq!(last_line_offsetted(4, lines), false);
+ assert_eq!(last_line_offsetted(6, lines), false);
+
+ let lines = "one two";
+ assert_eq!(last_line_offsetted(2, lines), false);
+ assert_eq!(last_line_offsetted(0, lines), false);
+
+ let lines = "\ntwo";
+ assert_eq!(last_line_offsetted(2, lines), false);
+ assert_eq!(last_line_offsetted(0, lines), false);
+
+ let lines = "one\n two three";
+ assert_eq!(last_line_offsetted(2, lines), true);
+ let lines = "one\n two three";
+ assert_eq!(last_line_offsetted(2, lines), false);
+ }
+}
--- /dev/null
- let should_ignore = !input_is_stdin && context.ignore_file(&path);
+// High level formatting functions.
+
+use std::collections::HashMap;
+use std::io::{self, Write};
+use std::time::{Duration, Instant};
+
+use rustc_ast::ast;
+use rustc_span::Span;
+
+use self::newline_style::apply_newline_style;
+use crate::comment::{CharClasses, FullCodeCharKind};
+use crate::config::{Config, FileName, Verbosity};
++use crate::formatting::generated::is_generated_file;
+use crate::issues::BadIssueSeeker;
+use crate::modules::Module;
+use crate::syntux::parser::{DirectoryOwnership, Parser, ParserError};
+use crate::syntux::session::ParseSess;
+use crate::utils::count_newlines;
+use crate::visitor::FmtVisitor;
+use crate::{modules, source_file, ErrorKind, FormatReport, Input, Session};
+
++mod generated;
+mod newline_style;
+
+// A map of the files of a crate, with their new content
+pub(crate) type SourceFile = Vec<FileRecord>;
+pub(crate) type FileRecord = (FileName, String);
+
+impl<'b, T: Write + 'b> Session<'b, T> {
+ pub(crate) fn format_input_inner(
+ &mut self,
+ input: Input,
+ is_macro_def: bool,
+ ) -> Result<FormatReport, ErrorKind> {
+ if !self.config.version_meets_requirement() {
+ return Err(ErrorKind::VersionMismatch);
+ }
+
+ rustc_span::create_session_if_not_set_then(self.config.edition().into(), |_| {
+ if self.config.disable_all_formatting() {
+ // When the input is from stdin, echo back the input.
+ if let Input::Text(ref buf) = input {
+ if let Err(e) = io::stdout().write_all(buf.as_bytes()) {
+ return Err(From::from(e));
+ }
+ }
+ return Ok(FormatReport::new());
+ }
+
+ let config = &self.config.clone();
+ let format_result = format_project(input, config, self, is_macro_def);
+
+ format_result.map(|report| {
+ self.errors.add(&report.internal.borrow().1);
+ report
+ })
+ })
+ }
+}
+
+// Format an entire crate (or subset of the module tree).
+fn format_project<T: FormatHandler>(
+ input: Input,
+ config: &Config,
+ handler: &mut T,
+ is_macro_def: bool,
+) -> Result<FormatReport, ErrorKind> {
+ let mut timer = Timer::start();
+
+ let main_file = input.file_name();
+ let input_is_stdin = main_file == FileName::Stdin;
+
+ let parse_session = ParseSess::new(config)?;
+ if config.skip_children() && parse_session.ignore_file(&main_file) {
+ return Ok(FormatReport::new());
+ }
+
+ // Parse the crate.
+ let mut report = FormatReport::new();
+ let directory_ownership = input.to_directory_ownership();
+ let krate = match Parser::parse_crate(input, &parse_session) {
+ Ok(krate) => krate,
+ // Surface parse error via Session (errors are merged there from report)
+ Err(e) => {
+ let forbid_verbose = input_is_stdin || e != ParserError::ParsePanicError;
+ should_emit_verbose(forbid_verbose, config, || {
+ eprintln!("The Rust parser panicked");
+ });
+ report.add_parsing_error();
+ return Ok(report);
+ }
+ };
+
+ let mut context = FormatContext::new(&krate, report, parse_session, config, handler);
+ let files = modules::ModResolver::new(
+ &context.parse_session,
+ directory_ownership.unwrap_or(DirectoryOwnership::UnownedViaBlock),
+ !input_is_stdin && !config.skip_children(),
+ )
+ .visit_crate(&krate)?;
+
+ timer = timer.done_parsing();
+
+ // Suppress error output if we have to do any further parsing.
+ context.parse_session.set_silent_emitter();
+
+ for (path, module) in files {
++ let source_file = context.parse_session.span_to_file_contents(module.span);
++ let src = source_file.src.as_ref().expect("SourceFile without src");
++
++ let should_ignore = (!input_is_stdin && context.ignore_file(&path))
++ || (!config.format_generated_files() && is_generated_file(src));
++
+ if (config.skip_children() && path != main_file) || should_ignore {
+ continue;
+ }
+ should_emit_verbose(input_is_stdin, config, || println!("Formatting {}", path));
+ context.format_file(path, &module, is_macro_def)?;
+ }
+ timer = timer.done_formatting();
+
+ should_emit_verbose(input_is_stdin, config, || {
+ println!(
+ "Spent {0:.3} secs in the parsing phase, and {1:.3} secs in the formatting phase",
+ timer.get_parse_time(),
+ timer.get_format_time(),
+ )
+ });
+
+ Ok(context.report)
+}
+
+// Used for formatting files.
+#[derive(new)]
+struct FormatContext<'a, T: FormatHandler> {
+ krate: &'a ast::Crate,
+ report: FormatReport,
+ parse_session: ParseSess,
+ config: &'a Config,
+ handler: &'a mut T,
+}
+
+impl<'a, T: FormatHandler + 'a> FormatContext<'a, T> {
+ fn ignore_file(&self, path: &FileName) -> bool {
+ self.parse_session.ignore_file(path)
+ }
+
+ // Formats a single file/module.
+ fn format_file(
+ &mut self,
+ path: FileName,
+ module: &Module<'_>,
+ is_macro_def: bool,
+ ) -> Result<(), ErrorKind> {
+ let snippet_provider = self.parse_session.snippet_provider(module.span);
+ let mut visitor = FmtVisitor::from_parse_sess(
+ &self.parse_session,
+ &self.config,
+ &snippet_provider,
+ self.report.clone(),
+ );
+ visitor.skip_context.update_with_attrs(&self.krate.attrs);
+ visitor.is_macro_def = is_macro_def;
+ visitor.last_pos = snippet_provider.start_pos();
+ visitor.skip_empty_lines(snippet_provider.end_pos());
+ visitor.format_separate_mod(module, snippet_provider.end_pos());
+
+ debug_assert_eq!(
+ visitor.line_number,
+ count_newlines(&visitor.buffer),
+ "failed in format_file visitor.buffer:\n {:?}",
+ &visitor.buffer
+ );
+
+ // For some reason, the source_map does not include terminating
+ // newlines so we must add one on for each file. This is sad.
+ source_file::append_newline(&mut visitor.buffer);
+
+ format_lines(
+ &mut visitor.buffer,
+ &path,
+ &visitor.skipped_range.borrow(),
+ &self.config,
+ &self.report,
+ );
+
+ apply_newline_style(
+ self.config.newline_style(),
+ &mut visitor.buffer,
+ snippet_provider.entire_snippet(),
+ );
+
+ if visitor.macro_rewrite_failure {
+ self.report.add_macro_format_failure();
+ }
+ self.report
+ .add_non_formatted_ranges(visitor.skipped_range.borrow().clone());
+
+ self.handler.handle_formatted_file(
+ &self.parse_session,
+ path,
+ visitor.buffer.to_owned(),
+ &mut self.report,
+ )
+ }
+}
+
+// Handle the results of formatting.
+trait FormatHandler {
+ fn handle_formatted_file(
+ &mut self,
+ parse_session: &ParseSess,
+ path: FileName,
+ result: String,
+ report: &mut FormatReport,
+ ) -> Result<(), ErrorKind>;
+}
+
+impl<'b, T: Write + 'b> FormatHandler for Session<'b, T> {
+ // Called for each formatted file.
+ fn handle_formatted_file(
+ &mut self,
+ parse_session: &ParseSess,
+ path: FileName,
+ result: String,
+ report: &mut FormatReport,
+ ) -> Result<(), ErrorKind> {
+ if let Some(ref mut out) = self.out {
+ match source_file::write_file(
+ Some(parse_session),
+ &path,
+ &result,
+ out,
+ &mut *self.emitter,
+ self.config.newline_style(),
+ ) {
+ Ok(ref result) if result.has_diff => report.add_diff(),
+ Err(e) => {
+ // Create a new error with path_str to help users see which files failed
+ let err_msg = format!("{}: {}", path, e);
+ return Err(io::Error::new(e.kind(), err_msg).into());
+ }
+ _ => {}
+ }
+ }
+
+ self.source_file.push((path, result));
+ Ok(())
+ }
+}
+
+pub(crate) struct FormattingError {
+ pub(crate) line: usize,
+ pub(crate) kind: ErrorKind,
+ is_comment: bool,
+ is_string: bool,
+ pub(crate) line_buffer: String,
+}
+
+impl FormattingError {
+ pub(crate) fn from_span(
+ span: Span,
+ parse_sess: &ParseSess,
+ kind: ErrorKind,
+ ) -> FormattingError {
+ FormattingError {
+ line: parse_sess.line_of_byte_pos(span.lo()),
+ is_comment: kind.is_comment(),
+ kind,
+ is_string: false,
+ line_buffer: parse_sess.span_to_first_line_string(span),
+ }
+ }
+
+ pub(crate) fn is_internal(&self) -> bool {
+ match self.kind {
+ ErrorKind::LineOverflow(..)
+ | ErrorKind::TrailingWhitespace
+ | ErrorKind::IoError(_)
+ | ErrorKind::ParseError
+ | ErrorKind::LostComment => true,
+ _ => false,
+ }
+ }
+
+ pub(crate) fn msg_suffix(&self) -> &str {
+ if self.is_comment || self.is_string {
+ "set `error_on_unformatted = false` to suppress \
+ the warning against comments or string literals\n"
+ } else {
+ ""
+ }
+ }
+
+ // (space, target)
+ pub(crate) fn format_len(&self) -> (usize, usize) {
+ match self.kind {
+ ErrorKind::LineOverflow(found, max) => (max, found - max),
+ ErrorKind::TrailingWhitespace
+ | ErrorKind::DeprecatedAttr
+ | ErrorKind::BadIssue(_)
+ | ErrorKind::BadAttr
+ | ErrorKind::LostComment
+ | ErrorKind::LicenseCheck => {
+ let trailing_ws_start = self
+ .line_buffer
+ .rfind(|c: char| !c.is_whitespace())
+ .map(|pos| pos + 1)
+ .unwrap_or(0);
+ (
+ trailing_ws_start,
+ self.line_buffer.len() - trailing_ws_start,
+ )
+ }
+ _ => unreachable!(),
+ }
+ }
+}
+
+pub(crate) type FormatErrorMap = HashMap<FileName, Vec<FormattingError>>;
+
+#[derive(Default, Debug, PartialEq)]
+pub(crate) struct ReportedErrors {
+ // Encountered e.g., an IO error.
+ pub(crate) has_operational_errors: bool,
+
+ // Failed to reformat code because of parsing errors.
+ pub(crate) has_parsing_errors: bool,
+
+ // Code is valid, but it is impossible to format it properly.
+ pub(crate) has_formatting_errors: bool,
+
+ // Code contains macro call that was unable to format.
+ pub(crate) has_macro_format_failure: bool,
+
+ // Failed a check, such as the license check or other opt-in checking.
+ pub(crate) has_check_errors: bool,
+
+ /// Formatted code differs from existing code (--check only).
+ pub(crate) has_diff: bool,
+
+ /// Formatted code missed something, like lost comments or extra trailing space
+ pub(crate) has_unformatted_code_errors: bool,
+}
+
+impl ReportedErrors {
+ /// Combine two summaries together.
+ pub(crate) fn add(&mut self, other: &ReportedErrors) {
+ self.has_operational_errors |= other.has_operational_errors;
+ self.has_parsing_errors |= other.has_parsing_errors;
+ self.has_formatting_errors |= other.has_formatting_errors;
+ self.has_macro_format_failure |= other.has_macro_format_failure;
+ self.has_check_errors |= other.has_check_errors;
+ self.has_diff |= other.has_diff;
+ self.has_unformatted_code_errors |= other.has_unformatted_code_errors;
+ }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum Timer {
+ Disabled,
+ Initialized(Instant),
+ DoneParsing(Instant, Instant),
+ DoneFormatting(Instant, Instant, Instant),
+}
+
+impl Timer {
+ fn start() -> Timer {
+ if cfg!(target_arch = "wasm32") {
+ Timer::Disabled
+ } else {
+ Timer::Initialized(Instant::now())
+ }
+ }
+ fn done_parsing(self) -> Self {
+ match self {
+ Timer::Disabled => Timer::Disabled,
+ Timer::Initialized(init_time) => Timer::DoneParsing(init_time, Instant::now()),
+ _ => panic!("Timer can only transition to DoneParsing from Initialized state"),
+ }
+ }
+
+ fn done_formatting(self) -> Self {
+ match self {
+ Timer::Disabled => Timer::Disabled,
+ Timer::DoneParsing(init_time, parse_time) => {
+ Timer::DoneFormatting(init_time, parse_time, Instant::now())
+ }
+ _ => panic!("Timer can only transition to DoneFormatting from DoneParsing state"),
+ }
+ }
+
+ /// Returns the time it took to parse the source files in seconds.
+ fn get_parse_time(&self) -> f32 {
+ match *self {
+ Timer::Disabled => panic!("this platform cannot time execution"),
+ Timer::DoneParsing(init, parse_time) | Timer::DoneFormatting(init, parse_time, _) => {
+ // This should never underflow since `Instant::now()` guarantees monotonicity.
+ Self::duration_to_f32(parse_time.duration_since(init))
+ }
+ Timer::Initialized(..) => unreachable!(),
+ }
+ }
+
+ /// Returns the time it took to go from the parsed AST to the formatted output. Parsing time is
+ /// not included.
+ fn get_format_time(&self) -> f32 {
+ match *self {
+ Timer::Disabled => panic!("this platform cannot time execution"),
+ Timer::DoneFormatting(_init, parse_time, format_time) => {
+ Self::duration_to_f32(format_time.duration_since(parse_time))
+ }
+ Timer::DoneParsing(..) | Timer::Initialized(..) => unreachable!(),
+ }
+ }
+
+ fn duration_to_f32(d: Duration) -> f32 {
+ d.as_secs() as f32 + d.subsec_nanos() as f32 / 1_000_000_000f32
+ }
+}
+
+// Formatting done on a char by char or line by line basis.
+// FIXME(#20): other stuff for parity with make tidy.
+fn format_lines(
+ text: &mut String,
+ name: &FileName,
+ skipped_range: &[(usize, usize)],
+ config: &Config,
+ report: &FormatReport,
+) {
+ let mut formatter = FormatLines::new(name, skipped_range, config);
+ formatter.check_license(text);
+ formatter.iterate(text);
+
+ if formatter.newline_count > 1 {
+ debug!("track truncate: {} {}", text.len(), formatter.newline_count);
+ let line = text.len() - formatter.newline_count + 1;
+ text.truncate(line);
+ }
+
+ report.append(name.clone(), formatter.errors);
+}
+
+struct FormatLines<'a> {
+ name: &'a FileName,
+ skipped_range: &'a [(usize, usize)],
+ last_was_space: bool,
+ line_len: usize,
+ cur_line: usize,
+ newline_count: usize,
+ errors: Vec<FormattingError>,
+ issue_seeker: BadIssueSeeker,
+ line_buffer: String,
+ current_line_contains_string_literal: bool,
+ format_line: bool,
+ allow_issue_seek: bool,
+ config: &'a Config,
+}
+
+impl<'a> FormatLines<'a> {
+ fn new(
+ name: &'a FileName,
+ skipped_range: &'a [(usize, usize)],
+ config: &'a Config,
+ ) -> FormatLines<'a> {
+ let issue_seeker = BadIssueSeeker::new(config.report_todo(), config.report_fixme());
+ FormatLines {
+ name,
+ skipped_range,
+ last_was_space: false,
+ line_len: 0,
+ cur_line: 1,
+ newline_count: 0,
+ errors: vec![],
+ allow_issue_seek: !issue_seeker.is_disabled(),
+ issue_seeker,
+ line_buffer: String::with_capacity(config.max_width() * 2),
+ current_line_contains_string_literal: false,
+ format_line: config.file_lines().contains_line(name, 1),
+ config,
+ }
+ }
+
+ fn check_license(&mut self, text: &mut String) {
+ if let Some(ref license_template) = self.config.license_template {
+ if !license_template.is_match(text) {
+ self.errors.push(FormattingError {
+ line: self.cur_line,
+ kind: ErrorKind::LicenseCheck,
+ is_comment: false,
+ is_string: false,
+ line_buffer: String::new(),
+ });
+ }
+ }
+ }
+
+ // Iterate over the chars in the file map.
+ fn iterate(&mut self, text: &mut String) {
+ for (kind, c) in CharClasses::new(text.chars()) {
+ if c == '\r' {
+ continue;
+ }
+
+ if self.allow_issue_seek && self.format_line {
+ // Add warnings for bad todos/ fixmes
+ if let Some(issue) = self.issue_seeker.inspect(c) {
+ self.push_err(ErrorKind::BadIssue(issue), false, false);
+ }
+ }
+
+ if c == '\n' {
+ self.new_line(kind);
+ } else {
+ self.char(c, kind);
+ }
+ }
+ }
+
+ fn new_line(&mut self, kind: FullCodeCharKind) {
+ if self.format_line {
+ // Check for (and record) trailing whitespace.
+ if self.last_was_space {
+ if self.should_report_error(kind, &ErrorKind::TrailingWhitespace)
+ && !self.is_skipped_line()
+ {
+ self.push_err(
+ ErrorKind::TrailingWhitespace,
+ kind.is_comment(),
+ kind.is_string(),
+ );
+ }
+ self.line_len -= 1;
+ }
+
+ // Check for any line width errors we couldn't correct.
+ let error_kind = ErrorKind::LineOverflow(self.line_len, self.config.max_width());
+ if self.line_len > self.config.max_width()
+ && !self.is_skipped_line()
+ && self.should_report_error(kind, &error_kind)
+ {
+ let is_string = self.current_line_contains_string_literal;
+ self.push_err(error_kind, kind.is_comment(), is_string);
+ }
+ }
+
+ self.line_len = 0;
+ self.cur_line += 1;
+ self.format_line = self
+ .config
+ .file_lines()
+ .contains_line(self.name, self.cur_line);
+ self.newline_count += 1;
+ self.last_was_space = false;
+ self.line_buffer.clear();
+ self.current_line_contains_string_literal = false;
+ }
+
+ fn char(&mut self, c: char, kind: FullCodeCharKind) {
+ self.newline_count = 0;
+ self.line_len += if c == '\t' {
+ self.config.tab_spaces()
+ } else {
+ 1
+ };
+ self.last_was_space = c.is_whitespace();
+ self.line_buffer.push(c);
+ if kind.is_string() {
+ self.current_line_contains_string_literal = true;
+ }
+ }
+
+ fn push_err(&mut self, kind: ErrorKind, is_comment: bool, is_string: bool) {
+ self.errors.push(FormattingError {
+ line: self.cur_line,
+ kind,
+ is_comment,
+ is_string,
+ line_buffer: self.line_buffer.clone(),
+ });
+ }
+
+ fn should_report_error(&self, char_kind: FullCodeCharKind, error_kind: &ErrorKind) -> bool {
+ let allow_error_report = if char_kind.is_comment()
+ || self.current_line_contains_string_literal
+ || error_kind.is_comment()
+ {
+ self.config.error_on_unformatted()
+ } else {
+ true
+ };
+
+ match error_kind {
+ ErrorKind::LineOverflow(..) => {
+ self.config.error_on_line_overflow() && allow_error_report
+ }
+ ErrorKind::TrailingWhitespace | ErrorKind::LostComment => allow_error_report,
+ _ => true,
+ }
+ }
+
+ /// Returns `true` if the line with the given line number was skipped by `#[rustfmt::skip]`.
+ fn is_skipped_line(&self) -> bool {
+ self.skipped_range
+ .iter()
+ .any(|&(lo, hi)| lo <= self.cur_line && self.cur_line <= hi)
+ }
+}
+
+fn should_emit_verbose<F>(forbid_verbose_output: bool, config: &Config, f: F)
+where
+ F: Fn(),
+{
+ if config.verbose() == Verbosity::Verbose && !forbid_verbose_output {
+ f();
+ }
+}
--- /dev/null
--- /dev/null
++/// Returns `true` if the given span is a part of generated files.
++pub(super) fn is_generated_file(original_snippet: &str) -> bool {
++ original_snippet
++ .lines()
++ .take(5) // looking for marker only in the beginning of the file
++ .any(|line| line.contains("@generated"))
++}
--- /dev/null
- if *a == *b {
+use std::borrow::Cow;
+use std::cmp::Ordering;
+use std::fmt;
+
+use rustc_ast::ast::{self, UseTreeKind};
+use rustc_span::{
+ symbol::{self, sym},
+ BytePos, Span, DUMMY_SP,
+};
+
+use crate::comment::combine_strs_with_missing_comments;
+use crate::config::lists::*;
+use crate::config::{Edition, IndentStyle};
+use crate::lists::{
+ definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
+};
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::Shape;
+use crate::source_map::SpanUtils;
+use crate::spanned::Spanned;
+use crate::utils::{is_same_visibility, mk_sp, rewrite_ident};
+use crate::visitor::FmtVisitor;
+
+/// Returns a name imported by a `use` declaration.
+/// E.g., returns `Ordering` for `std::cmp::Ordering` and `self` for `std::cmp::self`.
+pub(crate) fn path_to_imported_ident(path: &ast::Path) -> symbol::Ident {
+ path.segments.last().unwrap().ident
+}
+
+impl<'a> FmtVisitor<'a> {
+ pub(crate) fn format_import(&mut self, item: &ast::Item, tree: &ast::UseTree) {
+ let span = item.span();
+ let shape = self.shape();
+ let rw = UseTree::from_ast(
+ &self.get_context(),
+ tree,
+ None,
+ Some(item.vis.clone()),
+ Some(item.span.lo()),
+ Some(item.attrs.clone()),
+ )
+ .rewrite_top_level(&self.get_context(), shape);
+ match rw {
+ Some(ref s) if s.is_empty() => {
+ // Format up to last newline
+ let prev_span = mk_sp(self.last_pos, source!(self, span).lo());
+ let trimmed_snippet = self.snippet(prev_span).trim_end();
+ let span_end = self.last_pos + BytePos(trimmed_snippet.len() as u32);
+ self.format_missing(span_end);
+ // We have an excessive newline from the removed import.
+ if self.buffer.ends_with('\n') {
+ self.buffer.pop();
+ self.line_number -= 1;
+ }
+ self.last_pos = source!(self, span).hi();
+ }
+ Some(ref s) => {
+ self.format_missing_with_indent(source!(self, span).lo());
+ self.push_str(s);
+ self.last_pos = source!(self, span).hi();
+ }
+ None => {
+ self.format_missing_with_indent(source!(self, span).lo());
+ self.format_missing(source!(self, span).hi());
+ }
+ }
+ }
+}
+
+// Ordering of imports
+
+// We order imports by translating to our own representation and then sorting.
+// The Rust AST data structures are really bad for this. Rustfmt applies a bunch
+// of normalisations to imports and since we want to sort based on the result
+// of these (and to maintain idempotence) we must apply the same normalisations
+// to the data structures for sorting.
+//
+// We sort `self` and `super` before other imports, then identifier imports,
+// then glob imports, then lists of imports. We do not take aliases into account
+// when ordering unless the imports are identical except for the alias (rare in
+// practice).
+
+// FIXME(#2531): we should unify the comparison code here with the formatting
+// code elsewhere since we are essentially string-ifying twice. Furthermore, by
+// parsing to our own format on comparison, we repeat a lot of work when
+// sorting.
+
+// FIXME we do a lot of allocation to make our own representation.
+#[derive(Clone, Eq, PartialEq)]
+pub(crate) enum UseSegment {
+ Ident(String, Option<String>),
+ Slf(Option<String>),
+ Super(Option<String>),
+ Crate(Option<String>),
+ Glob,
+ List(Vec<UseTree>),
+}
+
+#[derive(Clone)]
+pub(crate) struct UseTree {
+ pub(crate) path: Vec<UseSegment>,
+ pub(crate) span: Span,
+ // Comment information within nested use tree.
+ pub(crate) list_item: Option<ListItem>,
+ // Additional fields for top level use items.
+ // Should we have another struct for top-level use items rather than reusing this?
+ visibility: Option<ast::Visibility>,
+ attrs: Option<Vec<ast::Attribute>>,
+}
+
+impl PartialEq for UseTree {
+ fn eq(&self, other: &UseTree) -> bool {
+ self.path == other.path
+ }
+}
+impl Eq for UseTree {}
+
+impl Spanned for UseTree {
+ fn span(&self) -> Span {
+ let lo = if let Some(ref attrs) = self.attrs {
+ attrs.iter().next().map_or(self.span.lo(), |a| a.span.lo())
+ } else {
+ self.span.lo()
+ };
+ mk_sp(lo, self.span.hi())
+ }
+}
+
+impl UseSegment {
+ // Clone a version of self with any top-level alias removed.
+ fn remove_alias(&self) -> UseSegment {
+ match *self {
+ UseSegment::Ident(ref s, _) => UseSegment::Ident(s.clone(), None),
+ UseSegment::Slf(_) => UseSegment::Slf(None),
+ UseSegment::Super(_) => UseSegment::Super(None),
+ UseSegment::Crate(_) => UseSegment::Crate(None),
+ _ => self.clone(),
+ }
+ }
+
++ // Check if self == other with their aliases removed.
++ fn equal_except_alias(&self, other: &Self) -> bool {
++ match (self, other) {
++ (UseSegment::Ident(ref s1, _), UseSegment::Ident(ref s2, _)) => s1 == s2,
++ (UseSegment::Slf(_), UseSegment::Slf(_))
++ | (UseSegment::Super(_), UseSegment::Super(_))
++ | (UseSegment::Crate(_), UseSegment::Crate(_))
++ | (UseSegment::Glob, UseSegment::Glob) => true,
++ (UseSegment::List(ref list1), UseSegment::List(ref list2)) => list1 == list2,
++ _ => false,
++ }
++ }
++
++ fn get_alias(&self) -> Option<&str> {
++ match self {
++ UseSegment::Ident(_, a)
++ | UseSegment::Slf(a)
++ | UseSegment::Super(a)
++ | UseSegment::Crate(a) => a.as_deref(),
++ _ => None,
++ }
++ }
++
+ fn from_path_segment(
+ context: &RewriteContext<'_>,
+ path_seg: &ast::PathSegment,
+ modsep: bool,
+ ) -> Option<UseSegment> {
+ let name = rewrite_ident(context, path_seg.ident);
+ if name.is_empty() || name == "{{root}}" {
+ return None;
+ }
+ Some(match name {
+ "self" => UseSegment::Slf(None),
+ "super" => UseSegment::Super(None),
+ "crate" => UseSegment::Crate(None),
+ _ => {
+ let mod_sep = if modsep { "::" } else { "" };
+ UseSegment::Ident(format!("{}{}", mod_sep, name), None)
+ }
+ })
+ }
+}
+
+pub(crate) fn merge_use_trees(use_trees: Vec<UseTree>, merge_by: SharedPrefix) -> Vec<UseTree> {
+ let mut result = Vec::with_capacity(use_trees.len());
+ for use_tree in use_trees {
+ if use_tree.has_comment() || use_tree.attrs.is_some() {
+ result.push(use_tree);
+ continue;
+ }
+
+ for flattened in use_tree.flatten() {
+ if let Some(tree) = result
+ .iter_mut()
+ .find(|tree| tree.share_prefix(&flattened, merge_by))
+ {
+ tree.merge(&flattened, merge_by);
+ } else {
+ result.push(flattened);
+ }
+ }
+ }
+ result
+}
+
+pub(crate) fn flatten_use_trees(use_trees: Vec<UseTree>) -> Vec<UseTree> {
+ use_trees
+ .into_iter()
+ .flat_map(UseTree::flatten)
+ .map(|mut tree| {
+ // If a path ends in `::self`, rewrite it to `::{self}`.
+ if let Some(UseSegment::Slf(..)) = tree.path.last() {
+ let self_segment = tree.path.pop().unwrap();
+ tree.path.push(UseSegment::List(vec![UseTree::from_path(
+ vec![self_segment],
+ DUMMY_SP,
+ )]));
+ }
+ tree
+ })
+ .collect()
+}
+
+impl fmt::Debug for UseTree {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt::Display::fmt(self, f)
+ }
+}
+
+impl fmt::Debug for UseSegment {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt::Display::fmt(self, f)
+ }
+}
+
+impl fmt::Display for UseSegment {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match *self {
+ UseSegment::Glob => write!(f, "*"),
+ UseSegment::Ident(ref s, _) => write!(f, "{}", s),
+ UseSegment::Slf(..) => write!(f, "self"),
+ UseSegment::Super(..) => write!(f, "super"),
+ UseSegment::Crate(..) => write!(f, "crate"),
+ UseSegment::List(ref list) => {
+ write!(f, "{{")?;
+ for (i, item) in list.iter().enumerate() {
+ if i != 0 {
+ write!(f, ", ")?;
+ }
+ write!(f, "{}", item)?;
+ }
+ write!(f, "}}")
+ }
+ }
+ }
+}
+impl fmt::Display for UseTree {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ for (i, segment) in self.path.iter().enumerate() {
+ if i != 0 {
+ write!(f, "::")?;
+ }
+ write!(f, "{}", segment)?;
+ }
+ Ok(())
+ }
+}
+
+impl UseTree {
+ // Rewrite use tree with `use ` and a trailing `;`.
+ pub(crate) fn rewrite_top_level(
+ &self,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+ ) -> Option<String> {
+ let vis = self.visibility.as_ref().map_or(Cow::from(""), |vis| {
+ crate::utils::format_visibility(context, &vis)
+ });
+ let use_str = self
+ .rewrite(context, shape.offset_left(vis.len())?)
+ .map(|s| {
+ if s.is_empty() {
+ s
+ } else {
+ format!("{}use {};", vis, s)
+ }
+ })?;
+ match self.attrs {
+ Some(ref attrs) if !attrs.is_empty() => {
+ let attr_str = attrs.rewrite(context, shape)?;
+ let lo = attrs.last().as_ref()?.span.hi();
+ let hi = self.span.lo();
+ let span = mk_sp(lo, hi);
+
+ let allow_extend = if attrs.len() == 1 {
+ let line_len = attr_str.len() + 1 + use_str.len();
+ !attrs.first().unwrap().is_doc_comment()
+ && context.config.inline_attribute_width() >= line_len
+ } else {
+ false
+ };
+
+ combine_strs_with_missing_comments(
+ context,
+ &attr_str,
+ &use_str,
+ span,
+ shape,
+ allow_extend,
+ )
+ }
+ _ => Some(use_str),
+ }
+ }
+
+ // FIXME: Use correct span?
+ // The given span is essentially incorrect, since we are reconstructing
+ // use-statements. This should not be a problem, though, since we have
+ // already tried to extract comment and observed that there are no comment
+ // around the given use item, and the span will not be used afterward.
+ fn from_path(path: Vec<UseSegment>, span: Span) -> UseTree {
+ UseTree {
+ path,
+ span,
+ list_item: None,
+ visibility: None,
+ attrs: None,
+ }
+ }
+
+ pub(crate) fn from_ast_with_normalization(
+ context: &RewriteContext<'_>,
+ item: &ast::Item,
+ ) -> Option<UseTree> {
+ match item.kind {
+ ast::ItemKind::Use(ref use_tree) => Some(
+ UseTree::from_ast(
+ context,
+ use_tree,
+ None,
+ Some(item.vis.clone()),
+ Some(item.span.lo()),
+ if item.attrs.is_empty() {
+ None
+ } else {
+ Some(item.attrs.clone())
+ },
+ )
+ .normalize(),
+ ),
+ _ => None,
+ }
+ }
+
+ fn from_ast(
+ context: &RewriteContext<'_>,
+ a: &ast::UseTree,
+ list_item: Option<ListItem>,
+ visibility: Option<ast::Visibility>,
+ opt_lo: Option<BytePos>,
+ attrs: Option<Vec<ast::Attribute>>,
+ ) -> UseTree {
+ let span = if let Some(lo) = opt_lo {
+ mk_sp(lo, a.span.hi())
+ } else {
+ a.span
+ };
+ let mut result = UseTree {
+ path: vec![],
+ span,
+ list_item,
+ visibility,
+ attrs,
+ };
+
+ let leading_modsep =
+ context.config.edition() >= Edition::Edition2018 && a.prefix.is_global();
+
+ let mut modsep = leading_modsep;
+
+ for p in &a.prefix.segments {
+ if let Some(use_segment) = UseSegment::from_path_segment(context, p, modsep) {
+ result.path.push(use_segment);
+ modsep = false;
+ }
+ }
+
+ match a.kind {
+ UseTreeKind::Glob => {
+ // in case of a global path and the glob starts at the root, e.g., "::*"
+ if a.prefix.segments.len() == 1 && leading_modsep {
+ result.path.push(UseSegment::Ident("".to_owned(), None));
+ }
+ result.path.push(UseSegment::Glob);
+ }
+ UseTreeKind::Nested(ref list) => {
+ // Extract comments between nested use items.
+ // This needs to be done before sorting use items.
+ let items = itemize_list(
+ context.snippet_provider,
+ list.iter().map(|(tree, _)| tree),
+ "}",
+ ",",
+ |tree| tree.span.lo(),
+ |tree| tree.span.hi(),
+ |_| Some("".to_owned()), // We only need comments for now.
+ context.snippet_provider.span_after(a.span, "{"),
+ a.span.hi(),
+ false,
+ );
+
+ // in case of a global path and the nested list starts at the root,
+ // e.g., "::{foo, bar}"
+ if a.prefix.segments.len() == 1 && leading_modsep {
+ result.path.push(UseSegment::Ident("".to_owned(), None));
+ }
+ result.path.push(UseSegment::List(
+ list.iter()
+ .zip(items)
+ .map(|(t, list_item)| {
+ Self::from_ast(context, &t.0, Some(list_item), None, None, None)
+ })
+ .collect(),
+ ));
+ }
+ UseTreeKind::Simple(ref rename, ..) => {
+ // If the path has leading double colons and is composed of only 2 segments, then we
+ // bypass the call to path_to_imported_ident which would get only the ident and
+ // lose the path root, e.g., `that` in `::that`.
+ // The span of `a.prefix` contains the leading colons.
+ let name = if a.prefix.segments.len() == 2 && leading_modsep {
+ context.snippet(a.prefix.span).to_owned()
+ } else {
+ rewrite_ident(context, path_to_imported_ident(&a.prefix)).to_owned()
+ };
+ let alias = rename.and_then(|ident| {
+ if ident.name == sym::underscore_imports {
+ // for impl-only-use
+ Some("_".to_owned())
+ } else if ident == path_to_imported_ident(&a.prefix) {
+ None
+ } else {
+ Some(rewrite_ident(context, ident).to_owned())
+ }
+ });
+ let segment = match name.as_ref() {
+ "self" => UseSegment::Slf(alias),
+ "super" => UseSegment::Super(alias),
+ "crate" => UseSegment::Crate(alias),
+ _ => UseSegment::Ident(name, alias),
+ };
+
+ // `name` is already in result.
+ result.path.pop();
+ result.path.push(segment);
+ }
+ }
+ result
+ }
+
+ // Do the adjustments that rustfmt does elsewhere to use paths.
+ pub(crate) fn normalize(mut self) -> UseTree {
+ let mut last = self.path.pop().expect("Empty use tree?");
+ // Hack around borrow checker.
+ let mut normalize_sole_list = false;
+ let mut aliased_self = false;
+
+ // Remove foo::{} or self without attributes.
+ match last {
+ _ if self.attrs.is_some() => (),
+ UseSegment::List(ref list) if list.is_empty() => {
+ self.path = vec![];
+ return self;
+ }
+ UseSegment::Slf(None) if self.path.is_empty() && self.visibility.is_some() => {
+ self.path = vec![];
+ return self;
+ }
+ _ => (),
+ }
+
+ // Normalise foo::self -> foo.
+ if let UseSegment::Slf(None) = last {
+ if !self.path.is_empty() {
+ return self;
+ }
+ }
+
+ // Normalise foo::self as bar -> foo as bar.
+ if let UseSegment::Slf(_) = last {
+ if let Some(UseSegment::Ident(_, None)) = self.path.last() {
+ aliased_self = true;
+ }
+ }
+
+ let mut done = false;
+ if aliased_self {
+ match self.path.last_mut() {
+ Some(UseSegment::Ident(_, ref mut old_rename)) => {
+ assert!(old_rename.is_none());
+ if let UseSegment::Slf(Some(rename)) = last.clone() {
+ *old_rename = Some(rename);
+ done = true;
+ }
+ }
+ _ => unreachable!(),
+ }
+ }
+
+ if done {
+ return self;
+ }
+
+ // Normalise foo::{bar} -> foo::bar
+ if let UseSegment::List(ref list) = last {
+ if list.len() == 1 && list[0].to_string() != "self" {
+ normalize_sole_list = true;
+ }
+ }
+
+ if normalize_sole_list {
+ match last {
+ UseSegment::List(list) => {
+ for seg in &list[0].path {
+ self.path.push(seg.clone());
+ }
+ return self.normalize();
+ }
+ _ => unreachable!(),
+ }
+ }
+
+ // Recursively normalize elements of a list use (including sorting the list).
+ if let UseSegment::List(list) = last {
+ let mut list = list.into_iter().map(UseTree::normalize).collect::<Vec<_>>();
+ list.sort();
+ last = UseSegment::List(list);
+ }
+
+ self.path.push(last);
+ self
+ }
+
+ fn has_comment(&self) -> bool {
+ self.list_item.as_ref().map_or(false, ListItem::has_comment)
+ }
+
+ fn same_visibility(&self, other: &UseTree) -> bool {
+ match (&self.visibility, &other.visibility) {
+ (
+ Some(ast::Visibility {
+ kind: ast::VisibilityKind::Inherited,
+ ..
+ }),
+ None,
+ )
+ | (
+ None,
+ Some(ast::Visibility {
+ kind: ast::VisibilityKind::Inherited,
+ ..
+ }),
+ )
+ | (None, None) => true,
+ (Some(ref a), Some(ref b)) => is_same_visibility(a, b),
+ _ => false,
+ }
+ }
+
+ fn share_prefix(&self, other: &UseTree, shared_prefix: SharedPrefix) -> bool {
+ if self.path.is_empty()
+ || other.path.is_empty()
+ || self.attrs.is_some()
+ || !self.same_visibility(other)
+ {
+ false
+ } else {
+ match shared_prefix {
+ SharedPrefix::Crate => self.path[0] == other.path[0],
+ SharedPrefix::Module => {
+ self.path[..self.path.len() - 1] == other.path[..other.path.len() - 1]
+ }
++ SharedPrefix::One => true,
+ }
+ }
+ }
+
+ fn flatten(self) -> Vec<UseTree> {
+ if self.path.is_empty() {
+ return vec![self];
+ }
+ match self.path.clone().last().unwrap() {
+ UseSegment::List(list) => {
+ if list.len() == 1 && list[0].path.len() == 1 {
+ if let UseSegment::Slf(..) = list[0].path[0] {
+ return vec![self];
+ };
+ }
+ let prefix = &self.path[..self.path.len() - 1];
+ let mut result = vec![];
+ for nested_use_tree in list {
+ for flattend in &mut nested_use_tree.clone().flatten() {
+ let mut new_path = prefix.to_vec();
+ new_path.append(&mut flattend.path);
+ result.push(UseTree {
+ path: new_path,
+ span: self.span,
+ list_item: None,
+ visibility: self.visibility.clone(),
+ attrs: None,
+ });
+ }
+ }
+
+ result
+ }
+ _ => vec![self],
+ }
+ }
+
+ fn merge(&mut self, other: &UseTree, merge_by: SharedPrefix) {
+ let mut prefix = 0;
+ for (a, b) in self.path.iter().zip(other.path.iter()) {
- let rest = if a.len() == len { &b[1..] } else { &a[1..] };
- return Some(vec![
- b[0].clone(),
- UseSegment::List(vec![
- UseTree::from_path(vec![UseSegment::Slf(None)], DUMMY_SP),
- UseTree::from_path(rest.to_vec(), DUMMY_SP),
- ]),
- ]);
++ if a.equal_except_alias(b) {
+ prefix += 1;
+ } else {
+ break;
+ }
+ }
+ if let Some(new_path) = merge_rest(&self.path, &other.path, prefix, merge_by) {
+ self.path = new_path;
+ self.span = self.span.to(other.span);
+ }
+ }
+}
+
+fn merge_rest(
+ a: &[UseSegment],
+ b: &[UseSegment],
+ mut len: usize,
+ merge_by: SharedPrefix,
+) -> Option<Vec<UseSegment>> {
+ if a.len() == len && b.len() == len {
+ return None;
+ }
+ if a.len() != len && b.len() != len {
+ if let UseSegment::List(ref list) = a[len] {
+ let mut list = list.clone();
+ merge_use_trees_inner(
+ &mut list,
+ UseTree::from_path(b[len..].to_vec(), DUMMY_SP),
+ merge_by,
+ );
+ let mut new_path = b[..len].to_vec();
+ new_path.push(UseSegment::List(list));
+ return Some(new_path);
+ }
+ } else if len == 1 {
- let similar_trees = trees
- .iter_mut()
- .filter(|tree| tree.share_prefix(&use_tree, merge_by));
++ let (common, rest) = if a.len() == len {
++ (&a[0], &b[1..])
++ } else {
++ (&b[0], &a[1..])
++ };
++ let mut list = vec![UseTree::from_path(
++ vec![UseSegment::Slf(common.get_alias().map(ToString::to_string))],
++ DUMMY_SP,
++ )];
++ match rest {
++ [UseSegment::List(rest_list)] => list.extend(rest_list.clone()),
++ _ => list.push(UseTree::from_path(rest.to_vec(), DUMMY_SP)),
++ }
++ return Some(vec![b[0].clone(), UseSegment::List(list)]);
+ } else {
+ len -= 1;
+ }
+ let mut list = vec![
+ UseTree::from_path(a[len..].to_vec(), DUMMY_SP),
+ UseTree::from_path(b[len..].to_vec(), DUMMY_SP),
+ ];
+ list.sort();
+ let mut new_path = b[..len].to_vec();
+ new_path.push(UseSegment::List(list));
+ Some(new_path)
+}
+
+fn merge_use_trees_inner(trees: &mut Vec<UseTree>, use_tree: UseTree, merge_by: SharedPrefix) {
- if let Some(tree) = similar_trees.min_by_key(|tree| tree.path.len()) {
- if tree.path.len() == 1 {
++ struct SimilarTree<'a> {
++ similarity: usize,
++ path_len: usize,
++ tree: &'a mut UseTree,
++ }
++
++ let similar_trees = trees.iter_mut().filter_map(|tree| {
++ if tree.share_prefix(&use_tree, merge_by) {
++ // In the case of `SharedPrefix::One`, `similarity` is used for deciding with which
++ // tree `use_tree` should be merge.
++ // In other cases `similarity` won't be used, so set it to `0` as a dummy value.
++ let similarity = if merge_by == SharedPrefix::One {
++ tree.path
++ .iter()
++ .zip(&use_tree.path)
++ .take_while(|(a, b)| a.equal_except_alias(b))
++ .count()
++ } else {
++ 0
++ };
++
++ let path_len = tree.path.len();
++ Some(SimilarTree {
++ similarity,
++ tree,
++ path_len,
++ })
++ } else {
++ None
++ }
++ });
++
+ if use_tree.path.len() == 1 && merge_by == SharedPrefix::Crate {
- } else if let Some(tree) = similar_trees.max_by_key(|tree| tree.path.len()) {
- if tree.path.len() > 1 {
- tree.merge(&use_tree, merge_by);
++ if let Some(tree) = similar_trees.min_by_key(|tree| tree.path_len) {
++ if tree.path_len == 1 {
++ return;
++ }
++ }
++ } else if merge_by == SharedPrefix::One {
++ if let Some(sim_tree) = similar_trees.max_by_key(|tree| tree.similarity) {
++ if sim_tree.similarity > 0 {
++ sim_tree.tree.merge(&use_tree, merge_by);
+ return;
+ }
+ }
- assert!(self.input.next().unwrap() == c);
++ } else if let Some(sim_tree) = similar_trees.max_by_key(|tree| tree.path_len) {
++ if sim_tree.path_len > 1 {
++ sim_tree.tree.merge(&use_tree, merge_by);
+ return;
+ }
+ }
+ trees.push(use_tree);
+ trees.sort();
+}
+
+impl PartialOrd for UseSegment {
+ fn partial_cmp(&self, other: &UseSegment) -> Option<Ordering> {
+ Some(self.cmp(other))
+ }
+}
+impl PartialOrd for UseTree {
+ fn partial_cmp(&self, other: &UseTree) -> Option<Ordering> {
+ Some(self.cmp(other))
+ }
+}
+impl Ord for UseSegment {
+ fn cmp(&self, other: &UseSegment) -> Ordering {
+ use self::UseSegment::*;
+
+ fn is_upper_snake_case(s: &str) -> bool {
+ s.chars()
+ .all(|c| c.is_uppercase() || c == '_' || c.is_numeric())
+ }
+
+ match (self, other) {
+ (&Slf(ref a), &Slf(ref b))
+ | (&Super(ref a), &Super(ref b))
+ | (&Crate(ref a), &Crate(ref b)) => a.cmp(b),
+ (&Glob, &Glob) => Ordering::Equal,
+ (&Ident(ref ia, ref aa), &Ident(ref ib, ref ab)) => {
+ // snake_case < CamelCase < UPPER_SNAKE_CASE
+ if ia.starts_with(char::is_uppercase) && ib.starts_with(char::is_lowercase) {
+ return Ordering::Greater;
+ }
+ if ia.starts_with(char::is_lowercase) && ib.starts_with(char::is_uppercase) {
+ return Ordering::Less;
+ }
+ if is_upper_snake_case(ia) && !is_upper_snake_case(ib) {
+ return Ordering::Greater;
+ }
+ if !is_upper_snake_case(ia) && is_upper_snake_case(ib) {
+ return Ordering::Less;
+ }
+ let ident_ord = ia.cmp(ib);
+ if ident_ord != Ordering::Equal {
+ return ident_ord;
+ }
+ if aa.is_none() && ab.is_some() {
+ return Ordering::Less;
+ }
+ if aa.is_some() && ab.is_none() {
+ return Ordering::Greater;
+ }
+ aa.cmp(ab)
+ }
+ (&List(ref a), &List(ref b)) => {
+ for (a, b) in a.iter().zip(b.iter()) {
+ let ord = a.cmp(b);
+ if ord != Ordering::Equal {
+ return ord;
+ }
+ }
+
+ a.len().cmp(&b.len())
+ }
+ (&Slf(_), _) => Ordering::Less,
+ (_, &Slf(_)) => Ordering::Greater,
+ (&Super(_), _) => Ordering::Less,
+ (_, &Super(_)) => Ordering::Greater,
+ (&Crate(_), _) => Ordering::Less,
+ (_, &Crate(_)) => Ordering::Greater,
+ (&Ident(..), _) => Ordering::Less,
+ (_, &Ident(..)) => Ordering::Greater,
+ (&Glob, _) => Ordering::Less,
+ (_, &Glob) => Ordering::Greater,
+ }
+ }
+}
+impl Ord for UseTree {
+ fn cmp(&self, other: &UseTree) -> Ordering {
+ for (a, b) in self.path.iter().zip(other.path.iter()) {
+ let ord = a.cmp(b);
+ // The comparison without aliases is a hack to avoid situations like
+ // comparing `a::b` to `a as c` - where the latter should be ordered
+ // first since it is shorter.
+ if ord != Ordering::Equal && a.remove_alias().cmp(&b.remove_alias()) != Ordering::Equal
+ {
+ return ord;
+ }
+ }
+
+ self.path.len().cmp(&other.path.len())
+ }
+}
+
+fn rewrite_nested_use_tree(
+ context: &RewriteContext<'_>,
+ use_tree_list: &[UseTree],
+ shape: Shape,
+) -> Option<String> {
+ let mut list_items = Vec::with_capacity(use_tree_list.len());
+ let nested_shape = match context.config.imports_indent() {
+ IndentStyle::Block => shape
+ .block_indent(context.config.tab_spaces())
+ .with_max_width(context.config)
+ .sub_width(1)?,
+ IndentStyle::Visual => shape.visual_indent(0),
+ };
+ for use_tree in use_tree_list {
+ if let Some(mut list_item) = use_tree.list_item.clone() {
+ list_item.item = use_tree.rewrite(context, nested_shape);
+ list_items.push(list_item);
+ } else {
+ list_items.push(ListItem::from_str(use_tree.rewrite(context, nested_shape)?));
+ }
+ }
+ let has_nested_list = use_tree_list.iter().any(|use_segment| {
+ use_segment.path.last().map_or(false, |last_segment| {
+ matches!(last_segment, UseSegment::List(..))
+ })
+ });
+
+ let remaining_width = if has_nested_list {
+ 0
+ } else {
+ shape.width.saturating_sub(2)
+ };
+
+ let tactic = definitive_tactic(
+ &list_items,
+ context.config.imports_layout(),
+ Separator::Comma,
+ remaining_width,
+ );
+
+ let ends_with_newline = context.config.imports_indent() == IndentStyle::Block
+ && tactic != DefinitiveListTactic::Horizontal;
+ let trailing_separator = if ends_with_newline {
+ context.config.trailing_comma()
+ } else {
+ SeparatorTactic::Never
+ };
+ let fmt = ListFormatting::new(nested_shape, context.config)
+ .tactic(tactic)
+ .trailing_separator(trailing_separator)
+ .ends_with_newline(ends_with_newline)
+ .preserve_newline(true)
+ .nested(has_nested_list);
+
+ let list_str = write_list(&list_items, &fmt)?;
+
+ let result = if (list_str.contains('\n') || list_str.len() > remaining_width)
+ && context.config.imports_indent() == IndentStyle::Block
+ {
+ format!(
+ "{{\n{}{}\n{}}}",
+ nested_shape.indent.to_string(context.config),
+ list_str,
+ shape.indent.to_string(context.config)
+ )
+ } else {
+ format!("{{{}}}", list_str)
+ };
+
+ Some(result)
+}
+
+impl Rewrite for UseSegment {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ Some(match self {
+ UseSegment::Ident(ref ident, Some(ref rename)) => format!("{} as {}", ident, rename),
+ UseSegment::Ident(ref ident, None) => ident.clone(),
+ UseSegment::Slf(Some(ref rename)) => format!("self as {}", rename),
+ UseSegment::Slf(None) => "self".to_owned(),
+ UseSegment::Super(Some(ref rename)) => format!("super as {}", rename),
+ UseSegment::Super(None) => "super".to_owned(),
+ UseSegment::Crate(Some(ref rename)) => format!("crate as {}", rename),
+ UseSegment::Crate(None) => "crate".to_owned(),
+ UseSegment::Glob => "*".to_owned(),
+ UseSegment::List(ref use_tree_list) => rewrite_nested_use_tree(
+ context,
+ use_tree_list,
+ // 1 = "{" and "}"
+ shape.offset_left(1)?.sub_width(1)?,
+ )?,
+ })
+ }
+}
+
+impl Rewrite for UseTree {
+ // This does NOT format attributes and visibility or add a trailing `;`.
+ fn rewrite(&self, context: &RewriteContext<'_>, mut shape: Shape) -> Option<String> {
+ let mut result = String::with_capacity(256);
+ let mut iter = self.path.iter().peekable();
+ while let Some(ref segment) = iter.next() {
+ let segment_str = segment.rewrite(context, shape)?;
+ result.push_str(&segment_str);
+ if iter.peek().is_some() {
+ result.push_str("::");
+ // 2 = "::"
+ shape = shape.offset_left(2 + segment_str.len())?;
+ }
+ }
+ Some(result)
+ }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum SharedPrefix {
+ Crate,
+ Module,
++ One,
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use rustc_span::DUMMY_SP;
+
+ // Parse the path part of an import. This parser is not robust and is only
+ // suitable for use in a test harness.
+ fn parse_use_tree(s: &str) -> UseTree {
+ use std::iter::Peekable;
+ use std::mem::swap;
+ use std::str::Chars;
+
+ struct Parser<'a> {
+ input: Peekable<Chars<'a>>,
+ }
+
+ impl<'a> Parser<'a> {
+ fn bump(&mut self) {
+ self.input.next().unwrap();
+ }
+
+ fn eat(&mut self, c: char) {
++ assert_eq!(self.input.next().unwrap(), c);
+ }
+
+ fn push_segment(
+ result: &mut Vec<UseSegment>,
+ buf: &mut String,
+ alias_buf: &mut Option<String>,
+ ) {
+ if !buf.is_empty() {
+ let mut alias = None;
+ swap(alias_buf, &mut alias);
+
+ match buf.as_ref() {
+ "self" => {
+ result.push(UseSegment::Slf(alias));
+ *buf = String::new();
+ *alias_buf = None;
+ }
+ "super" => {
+ result.push(UseSegment::Super(alias));
+ *buf = String::new();
+ *alias_buf = None;
+ }
+ "crate" => {
+ result.push(UseSegment::Crate(alias));
+ *buf = String::new();
+ *alias_buf = None;
+ }
+ _ => {
+ let mut name = String::new();
+ swap(buf, &mut name);
+ result.push(UseSegment::Ident(name, alias));
+ }
+ }
+ }
+ }
+
+ fn parse_in_list(&mut self) -> UseTree {
+ let mut result = vec![];
+ let mut buf = String::new();
+ let mut alias_buf = None;
+ while let Some(&c) = self.input.peek() {
+ match c {
+ '{' => {
+ assert!(buf.is_empty());
+ self.bump();
+ result.push(UseSegment::List(self.parse_list()));
+ self.eat('}');
+ }
+ '*' => {
+ assert!(buf.is_empty());
+ self.bump();
+ result.push(UseSegment::Glob);
+ }
+ ':' => {
+ self.bump();
+ self.eat(':');
+ Self::push_segment(&mut result, &mut buf, &mut alias_buf);
+ }
+ '}' | ',' => {
+ Self::push_segment(&mut result, &mut buf, &mut alias_buf);
+ return UseTree {
+ path: result,
+ span: DUMMY_SP,
+ list_item: None,
+ visibility: None,
+ attrs: None,
+ };
+ }
+ ' ' => {
+ self.bump();
+ self.eat('a');
+ self.eat('s');
+ self.eat(' ');
+ alias_buf = Some(String::new());
+ }
+ c => {
+ self.bump();
+ if let Some(ref mut buf) = alias_buf {
+ buf.push(c);
+ } else {
+ buf.push(c);
+ }
+ }
+ }
+ }
+ Self::push_segment(&mut result, &mut buf, &mut alias_buf);
+ UseTree {
+ path: result,
+ span: DUMMY_SP,
+ list_item: None,
+ visibility: None,
+ attrs: None,
+ }
+ }
+
+ fn parse_list(&mut self) -> Vec<UseTree> {
+ let mut result = vec![];
+ loop {
+ match self.input.peek().unwrap() {
+ ',' | ' ' => self.bump(),
+ '}' => {
+ return result;
+ }
+ _ => result.push(self.parse_in_list()),
+ }
+ }
+ }
+ }
+
+ let mut parser = Parser {
+ input: s.chars().peekable(),
+ };
+ parser.parse_in_list()
+ }
+
+ macro_rules! parse_use_trees {
+ ($($s:expr),* $(,)*) => {
+ vec![
+ $(parse_use_tree($s),)*
+ ]
+ }
+ }
+
+ macro_rules! test_merge {
+ ($by:ident, [$($input:expr),* $(,)*], [$($output:expr),* $(,)*]) => {
+ assert_eq!(
+ merge_use_trees(parse_use_trees!($($input,)*), SharedPrefix::$by),
+ parse_use_trees!($($output,)*),
+ );
+ }
+ }
+
+ #[test]
+ fn test_use_tree_merge_crate() {
+ test_merge!(
+ Crate,
+ ["a::b::{c, d}", "a::b::{e, f}"],
+ ["a::b::{c, d, e, f}"]
+ );
+ test_merge!(Crate, ["a::b::c", "a::b"], ["a::{b, b::c}"]);
+ test_merge!(Crate, ["a::b", "a::b"], ["a::b"]);
+ test_merge!(Crate, ["a", "a::b", "a::b::c"], ["a::{self, b, b::c}"]);
+ test_merge!(
+ Crate,
+ ["a", "a::b", "a::b::c", "a::b::c::d"],
+ ["a::{self, b, b::{c, c::d}}"]
+ );
+ test_merge!(
+ Crate,
+ ["a", "a::b", "a::b::c", "a::b"],
+ ["a::{self, b, b::c}"]
+ );
+ test_merge!(
+ Crate,
+ ["a::{b::{self, c}, d::e}", "a::d::f"],
+ ["a::{b::{self, c}, d::{e, f}}"]
+ );
+ test_merge!(
+ Crate,
+ ["a::d::f", "a::{b::{self, c}, d::e}"],
+ ["a::{b::{self, c}, d::{e, f}}"]
+ );
+ test_merge!(
+ Crate,
+ ["a::{c, d, b}", "a::{d, e, b, a, f}", "a::{f, g, c}"],
+ ["a::{a, b, c, d, e, f, g}"]
+ );
+ test_merge!(
+ Crate,
+ ["a::{self}", "b::{self as foo}"],
+ ["a::{self}", "b::{self as foo}"]
+ );
+ }
+
+ #[test]
+ fn test_use_tree_merge_module() {
+ test_merge!(
+ Module,
+ ["foo::b", "foo::{a, c, d::e}"],
+ ["foo::{a, b, c}", "foo::d::e"]
+ );
+
+ test_merge!(
+ Module,
+ ["foo::{a::b, a::c, d::e, d::f}"],
+ ["foo::a::{b, c}", "foo::d::{e, f}"]
+ );
+ }
+
++ #[test]
++ fn test_use_tree_merge_one() {
++ test_merge!(One, ["a", "b"], ["{a, b}"]);
++
++ test_merge!(One, ["a::{aa, ab}", "b", "a"], ["{a::{self, aa, ab}, b}"]);
++
++ test_merge!(One, ["a as x", "b as y"], ["{a as x, b as y}"]);
++
++ test_merge!(
++ One,
++ ["a::{aa as xa, ab}", "b", "a"],
++ ["{a::{self, aa as xa, ab}, b}"]
++ );
++
++ test_merge!(
++ One,
++ ["a", "a::{aa, ab::{aba, abb}}"],
++ ["a::{self, aa, ab::{aba, abb}}"]
++ );
++
++ test_merge!(One, ["a", "b::{ba, *}"], ["{a, b::{ba, *}}"]);
++
++ test_merge!(One, ["a", "b", "a::aa"], ["{a::{self, aa}, b}"]);
++
++ test_merge!(
++ One,
++ ["a::aa::aaa", "a::ac::aca", "a::aa::*"],
++ ["a::{aa::{aaa, *}, ac::aca}"]
++ );
++
++ test_merge!(
++ One,
++ ["a", "b::{ba, bb}", "a::{aa::*, ab::aba}"],
++ ["{a::{self, aa::*, ab::aba}, b::{ba, bb}}"]
++ );
++
++ test_merge!(
++ One,
++ ["b", "a::ac::{aca, acb}", "a::{aa::*, ab}"],
++ ["{a::{aa::*, ab, ac::{aca, acb}}, b}"]
++ );
++ }
++
+ #[test]
+ fn test_flatten_use_trees() {
+ assert_eq!(
+ flatten_use_trees(parse_use_trees!["foo::{a::{b, c}, d::e}"]),
+ parse_use_trees!["foo::a::b", "foo::a::c", "foo::d::e"]
+ );
+
+ assert_eq!(
+ flatten_use_trees(parse_use_trees!["foo::{self, a, b::{c, d}, e::*}"]),
+ parse_use_trees![
+ "foo::{self}",
+ "foo::a",
+ "foo::b::c",
+ "foo::b::d",
+ "foo::e::*"
+ ]
+ );
+ }
+
+ #[test]
+ fn test_use_tree_flatten() {
+ assert_eq!(
+ parse_use_tree("a::b::{c, d, e, f}").flatten(),
+ parse_use_trees!("a::b::c", "a::b::d", "a::b::e", "a::b::f",)
+ );
+
+ assert_eq!(
+ parse_use_tree("a::b::{c::{d, e, f}, g, h::{i, j, k}}").flatten(),
+ parse_use_trees![
+ "a::b::c::d",
+ "a::b::c::e",
+ "a::b::c::f",
+ "a::b::g",
+ "a::b::h::i",
+ "a::b::h::j",
+ "a::b::h::k",
+ ]
+ );
+ }
+
+ #[test]
+ fn test_use_tree_normalize() {
+ assert_eq!(parse_use_tree("a::self").normalize(), parse_use_tree("a"));
+ assert_eq!(
+ parse_use_tree("a::self as foo").normalize(),
+ parse_use_tree("a as foo")
+ );
+ assert_eq!(
+ parse_use_tree("a::{self}").normalize(),
+ parse_use_tree("a::{self}")
+ );
+ assert_eq!(parse_use_tree("a::{b}").normalize(), parse_use_tree("a::b"));
+ assert_eq!(
+ parse_use_tree("a::{b, c::self}").normalize(),
+ parse_use_tree("a::{b, c}")
+ );
+ assert_eq!(
+ parse_use_tree("a::{b as bar, c::self}").normalize(),
+ parse_use_tree("a::{b as bar, c}")
+ );
+ }
+
+ #[test]
+ fn test_use_tree_ord() {
+ assert!(parse_use_tree("a").normalize() < parse_use_tree("aa").normalize());
+ assert!(parse_use_tree("a").normalize() < parse_use_tree("a::a").normalize());
+ assert!(parse_use_tree("a").normalize() < parse_use_tree("*").normalize());
+ assert!(parse_use_tree("a").normalize() < parse_use_tree("{a, b}").normalize());
+ assert!(parse_use_tree("*").normalize() < parse_use_tree("{a, b}").normalize());
+
+ assert!(
+ parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, dddddddd}").normalize()
+ < parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, ddddddddd}").normalize()
+ );
+ assert!(
+ parse_use_tree("serde::de::{Deserialize}").normalize()
+ < parse_use_tree("serde_json").normalize()
+ );
+ assert!(parse_use_tree("a::b::c").normalize() < parse_use_tree("a::b::*").normalize());
+ assert!(
+ parse_use_tree("foo::{Bar, Baz}").normalize()
+ < parse_use_tree("{Bar, Baz}").normalize()
+ );
+
+ assert!(
+ parse_use_tree("foo::{qux as bar}").normalize()
+ < parse_use_tree("foo::{self as bar}").normalize()
+ );
+ assert!(
+ parse_use_tree("foo::{qux as bar}").normalize()
+ < parse_use_tree("foo::{baz, qux as bar}").normalize()
+ );
+ assert!(
+ parse_use_tree("foo::{self as bar, baz}").normalize()
+ < parse_use_tree("foo::{baz, qux as bar}").normalize()
+ );
+
+ assert!(parse_use_tree("foo").normalize() < parse_use_tree("Foo").normalize());
+ assert!(parse_use_tree("foo").normalize() < parse_use_tree("foo::Bar").normalize());
+
+ assert!(
+ parse_use_tree("std::cmp::{d, c, b, a}").normalize()
+ < parse_use_tree("std::cmp::{b, e, g, f}").normalize()
+ );
+ }
+}
--- /dev/null
- visibility: ast::Visibility,
+// Formatting top-level items - functions, structs, enums, traits, impls.
+
+use std::borrow::Cow;
+use std::cmp::{max, min, Ordering};
+
+use regex::Regex;
+use rustc_ast::visit;
+use rustc_ast::{ast, ptr};
+use rustc_span::{symbol, BytePos, Span, DUMMY_SP};
+
+use crate::attr::filter_inline_attrs;
+use crate::comment::{
+ combine_strs_with_missing_comments, contains_comment, is_last_comment_block,
+ recover_comment_removed, recover_missing_comment_in_span, rewrite_missing_comment,
+ FindUncommented,
+};
+use crate::config::lists::*;
+use crate::config::{BraceStyle, Config, IndentStyle, Version};
+use crate::expr::{
+ is_empty_block, is_simple_block_stmt, rewrite_assign_rhs, rewrite_assign_rhs_with,
+ rewrite_assign_rhs_with_comments, RhsTactics,
+};
+use crate::lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
+use crate::macros::{rewrite_macro, MacroPosition};
+use crate::overflow;
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::{Indent, Shape};
+use crate::source_map::{LineRangeUtils, SpanUtils};
+use crate::spanned::Spanned;
+use crate::stmt::Stmt;
+use crate::utils::*;
+use crate::vertical::rewrite_with_alignment;
+use crate::visitor::FmtVisitor;
+
+const DEFAULT_VISIBILITY: ast::Visibility = ast::Visibility {
+ kind: ast::VisibilityKind::Inherited,
+ span: DUMMY_SP,
+ tokens: None,
+};
+
+fn type_annotation_separator(config: &Config) -> &str {
+ colon_spaces(config)
+}
+
+// Statements of the form
+// let pat: ty = init;
+impl Rewrite for ast::Local {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ debug!(
+ "Local::rewrite {:?} {} {:?}",
+ self, shape.width, shape.indent
+ );
+
+ skip_out_of_file_lines_range!(context, self.span);
+
+ if contains_skip(&self.attrs) || matches!(self.kind, ast::LocalKind::InitElse(..)) {
+ return None;
+ }
+
+ let attrs_str = self.attrs.rewrite(context, shape)?;
+ let mut result = if attrs_str.is_empty() {
+ "let ".to_owned()
+ } else {
+ combine_strs_with_missing_comments(
+ context,
+ &attrs_str,
+ "let ",
+ mk_sp(
+ self.attrs.last().map(|a| a.span.hi()).unwrap(),
+ self.span.lo(),
+ ),
+ shape,
+ false,
+ )?
+ };
+
+ // 4 = "let ".len()
+ let pat_shape = shape.offset_left(4)?;
+ // 1 = ;
+ let pat_shape = pat_shape.sub_width(1)?;
+ let pat_str = self.pat.rewrite(context, pat_shape)?;
+ result.push_str(&pat_str);
+
+ // String that is placed within the assignment pattern and expression.
+ let infix = {
+ let mut infix = String::with_capacity(32);
+
+ if let Some(ref ty) = self.ty {
+ let separator = type_annotation_separator(context.config);
+ let ty_shape = if pat_str.contains('\n') {
+ shape.with_max_width(context.config)
+ } else {
+ shape
+ }
+ .offset_left(last_line_width(&result) + separator.len())?
+ // 2 = ` =`
+ .sub_width(2)?;
+
+ let rewrite = ty.rewrite(context, ty_shape)?;
+
+ infix.push_str(separator);
+ infix.push_str(&rewrite);
+ }
+
+ if self.kind.init().is_some() {
+ infix.push_str(" =");
+ }
+
+ infix
+ };
+
+ result.push_str(&infix);
+
+ if let Some((init, _els)) = self.kind.init_else_opt() {
+ // 1 = trailing semicolon;
+ let nested_shape = shape.sub_width(1)?;
+
+ result = rewrite_assign_rhs(context, result, init, nested_shape)?;
+ // todo else
+ }
+
+ result.push(';');
+ Some(result)
+ }
+}
+
+// FIXME convert to using rewrite style rather than visitor
+// FIXME format modules in this style
+#[allow(dead_code)]
+#[derive(Debug)]
+struct Item<'a> {
+ unsafety: ast::Unsafe,
+ abi: Cow<'static, str>,
+ vis: Option<&'a ast::Visibility>,
+ body: Vec<BodyElement<'a>>,
+ span: Span,
+}
+
+impl<'a> Item<'a> {
+ fn from_foreign_mod(fm: &'a ast::ForeignMod, span: Span, config: &Config) -> Item<'a> {
+ Item {
+ unsafety: fm.unsafety,
+ abi: format_extern(
+ ast::Extern::from_abi(fm.abi),
+ config.force_explicit_abi(),
+ true,
+ ),
+ vis: None,
+ body: fm
+ .items
+ .iter()
+ .map(|i| BodyElement::ForeignItem(i))
+ .collect(),
+ span,
+ }
+ }
+}
+
+#[derive(Debug)]
+enum BodyElement<'a> {
+ // Stmt(&'a ast::Stmt),
+ // Field(&'a ast::ExprField),
+ // Variant(&'a ast::Variant),
+ // Item(&'a ast::Item),
+ ForeignItem(&'a ast::ForeignItem),
+}
+
+/// Represents a fn's signature.
+pub(crate) struct FnSig<'a> {
+ decl: &'a ast::FnDecl,
+ generics: &'a ast::Generics,
+ ext: ast::Extern,
+ is_async: Cow<'a, ast::Async>,
+ constness: ast::Const,
+ defaultness: ast::Defaultness,
+ unsafety: ast::Unsafe,
- visibility: ast::Visibility,
++ visibility: &'a ast::Visibility,
+}
+
+impl<'a> FnSig<'a> {
+ pub(crate) fn from_method_sig(
+ method_sig: &'a ast::FnSig,
+ generics: &'a ast::Generics,
- let mut fn_sig = FnSig::from_method_sig(fn_sig, generics, vis.clone());
++ visibility: &'a ast::Visibility,
+ ) -> FnSig<'a> {
+ FnSig {
+ unsafety: method_sig.header.unsafety,
+ is_async: Cow::Borrowed(&method_sig.header.asyncness),
+ constness: method_sig.header.constness,
+ defaultness: ast::Defaultness::Final,
+ ext: method_sig.header.ext,
+ decl: &*method_sig.decl,
+ generics,
+ visibility,
+ }
+ }
+
+ pub(crate) fn from_fn_kind(
+ fn_kind: &'a visit::FnKind<'_>,
+ generics: &'a ast::Generics,
+ decl: &'a ast::FnDecl,
+ defaultness: ast::Defaultness,
+ ) -> FnSig<'a> {
+ match *fn_kind {
+ visit::FnKind::Fn(fn_ctxt, _, fn_sig, vis, _) => match fn_ctxt {
+ visit::FnCtxt::Assoc(..) => {
- visibility: vis.clone(),
++ let mut fn_sig = FnSig::from_method_sig(fn_sig, generics, vis);
+ fn_sig.defaultness = defaultness;
+ fn_sig
+ }
+ _ => FnSig {
+ decl,
+ generics,
+ ext: fn_sig.header.ext,
+ constness: fn_sig.header.constness,
+ is_async: Cow::Borrowed(&fn_sig.header.asyncness),
+ defaultness,
+ unsafety: fn_sig.header.unsafety,
- &FnSig::from_method_sig(sig, generics, DEFAULT_VISIBILITY),
++ visibility: vis,
+ },
+ },
+ _ => unreachable!(),
+ }
+ }
+
+ fn to_str(&self, context: &RewriteContext<'_>) -> String {
+ let mut result = String::with_capacity(128);
+ // Vis defaultness constness unsafety abi.
+ result.push_str(&*format_visibility(context, &self.visibility));
+ result.push_str(format_defaultness(self.defaultness));
+ result.push_str(format_constness(self.constness));
+ result.push_str(format_async(&self.is_async));
+ result.push_str(format_unsafety(self.unsafety));
+ result.push_str(&format_extern(
+ self.ext,
+ context.config.force_explicit_abi(),
+ false,
+ ));
+ result
+ }
+}
+
+impl<'a> FmtVisitor<'a> {
+ fn format_item(&mut self, item: &Item<'_>) {
+ self.buffer.push_str(format_unsafety(item.unsafety));
+ self.buffer.push_str(&item.abi);
+
+ let snippet = self.snippet(item.span);
+ let brace_pos = snippet.find_uncommented("{").unwrap();
+
+ self.push_str("{");
+ if !item.body.is_empty() || contains_comment(&snippet[brace_pos..]) {
+ // FIXME: this skips comments between the extern keyword and the opening
+ // brace.
+ self.last_pos = item.span.lo() + BytePos(brace_pos as u32 + 1);
+ self.block_indent = self.block_indent.block_indent(self.config);
+
+ if !item.body.is_empty() {
+ for item in &item.body {
+ self.format_body_element(item);
+ }
+ }
+
+ self.format_missing_no_indent(item.span.hi() - BytePos(1));
+ self.block_indent = self.block_indent.block_unindent(self.config);
+ let indent_str = self.block_indent.to_string(self.config);
+ self.push_str(&indent_str);
+ }
+
+ self.push_str("}");
+ self.last_pos = item.span.hi();
+ }
+
+ fn format_body_element(&mut self, element: &BodyElement<'_>) {
+ match *element {
+ BodyElement::ForeignItem(item) => self.format_foreign_item(item),
+ }
+ }
+
+ pub(crate) fn format_foreign_mod(&mut self, fm: &ast::ForeignMod, span: Span) {
+ let item = Item::from_foreign_mod(fm, span, self.config);
+ self.format_item(&item);
+ }
+
+ fn format_foreign_item(&mut self, item: &ast::ForeignItem) {
+ let rewrite = item.rewrite(&self.get_context(), self.shape());
+ let hi = item.span.hi();
+ let span = if item.attrs.is_empty() {
+ item.span
+ } else {
+ mk_sp(item.attrs[0].span.lo(), hi)
+ };
+ self.push_rewrite(span, rewrite);
+ self.last_pos = hi;
+ }
+
+ pub(crate) fn rewrite_fn_before_block(
+ &mut self,
+ indent: Indent,
+ ident: symbol::Ident,
+ fn_sig: &FnSig<'_>,
+ span: Span,
+ ) -> Option<(String, FnBraceStyle)> {
+ let context = self.get_context();
+
+ let mut fn_brace_style = newline_for_brace(self.config, &fn_sig.generics.where_clause);
+ let (result, _, force_newline_brace) =
+ rewrite_fn_base(&context, indent, ident, fn_sig, span, fn_brace_style)?;
+
+ // 2 = ` {`
+ if self.config.brace_style() == BraceStyle::AlwaysNextLine
+ || force_newline_brace
+ || last_line_width(&result) + 2 > self.shape().width
+ {
+ fn_brace_style = FnBraceStyle::NextLine
+ }
+
+ Some((result, fn_brace_style))
+ }
+
+ pub(crate) fn rewrite_required_fn(
+ &mut self,
+ indent: Indent,
+ ident: symbol::Ident,
+ sig: &ast::FnSig,
++ vis: &ast::Visibility,
+ generics: &ast::Generics,
+ span: Span,
+ ) -> Option<String> {
+ // Drop semicolon or it will be interpreted as comment.
+ let span = mk_sp(span.lo(), span.hi() - BytePos(1));
+ let context = self.get_context();
+
+ let (mut result, ends_with_comment, _) = rewrite_fn_base(
+ &context,
+ indent,
+ ident,
- span,
++ &FnSig::from_method_sig(sig, generics, vis),
+ span,
+ FnBraceStyle::None,
+ )?;
+
+ // If `result` ends with a comment, then remember to add a newline
+ if ends_with_comment {
+ result.push_str(&indent.to_string_with_newline(context.config));
+ }
+
+ // Re-attach semicolon
+ result.push(';');
+
+ Some(result)
+ }
+
+ pub(crate) fn single_line_fn(
+ &self,
+ fn_str: &str,
+ block: &ast::Block,
+ inner_attrs: Option<&[ast::Attribute]>,
+ ) -> Option<String> {
+ if fn_str.contains('\n') || inner_attrs.map_or(false, |a| !a.is_empty()) {
+ return None;
+ }
+
+ let context = self.get_context();
+
+ if self.config.empty_item_single_line()
+ && is_empty_block(&context, block, None)
+ && self.block_indent.width() + fn_str.len() + 3 <= self.config.max_width()
+ && !last_line_contains_single_line_comment(fn_str)
+ {
+ return Some(format!("{} {{}}", fn_str));
+ }
+
+ if !self.config.fn_single_line() || !is_simple_block_stmt(&context, block, None) {
+ return None;
+ }
+
+ let res = Stmt::from_ast_node(block.stmts.first()?, true)
+ .rewrite(&self.get_context(), self.shape())?;
+
+ let width = self.block_indent.width() + fn_str.len() + res.len() + 5;
+ if !res.contains('\n') && width <= self.config.max_width() {
+ Some(format!("{} {{ {} }}", fn_str, res))
+ } else {
+ None
+ }
+ }
+
+ pub(crate) fn visit_static(&mut self, static_parts: &StaticParts<'_>) {
+ let rewrite = rewrite_static(&self.get_context(), static_parts, self.block_indent);
+ self.push_rewrite(static_parts.span, rewrite);
+ }
+
+ pub(crate) fn visit_struct(&mut self, struct_parts: &StructParts<'_>) {
+ let is_tuple = match struct_parts.def {
+ ast::VariantData::Tuple(..) => true,
+ _ => false,
+ };
+ let rewrite = format_struct(&self.get_context(), struct_parts, self.block_indent, None)
+ .map(|s| if is_tuple { s + ";" } else { s });
+ self.push_rewrite(struct_parts.span, rewrite);
+ }
+
+ pub(crate) fn visit_enum(
+ &mut self,
+ ident: symbol::Ident,
+ vis: &ast::Visibility,
+ enum_def: &ast::EnumDef,
+ generics: &ast::Generics,
+ span: Span,
+ ) {
+ let enum_header =
+ format_header(&self.get_context(), "enum ", ident, vis, self.block_indent);
+ self.push_str(&enum_header);
+
+ let enum_snippet = self.snippet(span);
+ let brace_pos = enum_snippet.find_uncommented("{").unwrap();
+ let body_start = span.lo() + BytePos(brace_pos as u32 + 1);
+ let generics_str = format_generics(
+ &self.get_context(),
+ generics,
+ self.config.brace_style(),
+ if enum_def.variants.is_empty() {
+ BracePos::ForceSameLine
+ } else {
+ BracePos::Auto
+ },
+ self.block_indent,
+ // make a span that starts right after `enum Foo`
+ mk_sp(ident.span.hi(), body_start),
+ last_line_width(&enum_header),
+ )
+ .unwrap();
+ self.push_str(&generics_str);
+
+ self.last_pos = body_start;
+
+ match self.format_variant_list(enum_def, body_start, span.hi()) {
+ Some(ref s) if enum_def.variants.is_empty() => self.push_str(s),
+ rw => {
+ self.push_rewrite(mk_sp(body_start, span.hi()), rw);
+ self.block_indent = self.block_indent.block_unindent(self.config);
+ }
+ }
+ }
+
+ // Format the body of an enum definition
+ fn format_variant_list(
+ &mut self,
+ enum_def: &ast::EnumDef,
+ body_lo: BytePos,
+ body_hi: BytePos,
+ ) -> Option<String> {
+ if enum_def.variants.is_empty() {
+ let mut buffer = String::with_capacity(128);
+ // 1 = "}"
+ let span = mk_sp(body_lo, body_hi - BytePos(1));
+ format_empty_struct_or_tuple(
+ &self.get_context(),
+ span,
+ self.block_indent,
+ &mut buffer,
+ "",
+ "}",
+ );
+ return Some(buffer);
+ }
+ let mut result = String::with_capacity(1024);
+ let original_offset = self.block_indent;
+ self.block_indent = self.block_indent.block_indent(self.config);
+
+ // If enum variants have discriminants, try to vertically align those,
+ // provided the discrims are not shifted too much to the right
+ let align_threshold: usize = self.config.enum_discrim_align_threshold();
+ let discr_ident_lens: Vec<usize> = enum_def
+ .variants
+ .iter()
+ .filter(|var| var.disr_expr.is_some())
+ .map(|var| rewrite_ident(&self.get_context(), var.ident).len())
+ .collect();
+ // cut the list at the point of longest discrim shorter than the threshold
+ // All of the discrims under the threshold will get padded, and all above - left as is.
+ let pad_discrim_ident_to = *discr_ident_lens
+ .iter()
+ .filter(|&l| *l <= align_threshold)
+ .max()
+ .unwrap_or(&0);
+
+ let itemize_list_with = |one_line_width: usize| {
+ itemize_list(
+ self.snippet_provider,
+ enum_def.variants.iter(),
+ "}",
+ ",",
+ |f| {
+ if !f.attrs.is_empty() {
+ f.attrs[0].span.lo()
+ } else {
+ f.span.lo()
+ }
+ },
+ |f| f.span.hi(),
+ |f| self.format_variant(f, one_line_width, pad_discrim_ident_to),
+ body_lo,
+ body_hi,
+ false,
+ )
+ .collect()
+ };
+ let mut items: Vec<_> = itemize_list_with(self.config.struct_variant_width());
+
+ // If one of the variants use multiple lines, use multi-lined formatting for all variants.
+ let has_multiline_variant = items.iter().any(|item| item.inner_as_ref().contains('\n'));
+ let has_single_line_variant = items.iter().any(|item| !item.inner_as_ref().contains('\n'));
+ if has_multiline_variant && has_single_line_variant {
+ items = itemize_list_with(0);
+ }
+
+ let shape = self.shape().sub_width(2)?;
+ let fmt = ListFormatting::new(shape, self.config)
+ .trailing_separator(self.config.trailing_comma())
+ .preserve_newline(true);
+
+ let list = write_list(&items, &fmt)?;
+ result.push_str(&list);
+ result.push_str(&original_offset.to_string_with_newline(self.config));
+ result.push('}');
+ Some(result)
+ }
+
+ // Variant of an enum.
+ fn format_variant(
+ &self,
+ field: &ast::Variant,
+ one_line_width: usize,
+ pad_discrim_ident_to: usize,
+ ) -> Option<String> {
+ if contains_skip(&field.attrs) {
+ let lo = field.attrs[0].span.lo();
+ let span = mk_sp(lo, field.span.hi());
+ return Some(self.snippet(span).to_owned());
+ }
+
+ let context = self.get_context();
+ // 1 = ','
+ let shape = self.shape().sub_width(1)?;
+ let attrs_str = field.attrs.rewrite(&context, shape)?;
+ let lo = field
+ .attrs
+ .last()
+ .map_or(field.span.lo(), |attr| attr.span.hi());
+ let span = mk_sp(lo, field.span.lo());
+
+ let variant_body = match field.data {
+ ast::VariantData::Tuple(..) | ast::VariantData::Struct(..) => format_struct(
+ &context,
+ &StructParts::from_variant(field),
+ self.block_indent,
+ Some(one_line_width),
+ )?,
+ ast::VariantData::Unit(..) => rewrite_ident(&context, field.ident).to_owned(),
+ };
+
+ let variant_body = if let Some(ref expr) = field.disr_expr {
+ let lhs = format!("{:1$} =", variant_body, pad_discrim_ident_to);
+ rewrite_assign_rhs_with(
+ &context,
+ lhs,
+ &*expr.value,
+ shape,
+ RhsTactics::AllowOverflow,
+ )?
+ } else {
+ variant_body
+ };
+
+ combine_strs_with_missing_comments(&context, &attrs_str, &variant_body, span, shape, false)
+ }
+
+ fn visit_impl_items(&mut self, items: &[ptr::P<ast::AssocItem>]) {
+ if self.get_context().config.reorder_impl_items() {
+ // Create visitor for each items, then reorder them.
+ let mut buffer = vec![];
+ for item in items {
+ self.visit_impl_item(item);
+ buffer.push((self.buffer.clone(), item.clone()));
+ self.buffer.clear();
+ }
+
+ fn is_type(ty: &Option<rustc_ast::ptr::P<ast::Ty>>) -> bool {
+ if let Some(lty) = ty {
+ if let ast::TyKind::ImplTrait(..) = lty.kind {
+ return false;
+ }
+ }
+ true
+ }
+
+ fn is_opaque(ty: &Option<rustc_ast::ptr::P<ast::Ty>>) -> bool {
+ !is_type(ty)
+ }
+
+ fn both_type(
+ a: &Option<rustc_ast::ptr::P<ast::Ty>>,
+ b: &Option<rustc_ast::ptr::P<ast::Ty>>,
+ ) -> bool {
+ is_type(a) && is_type(b)
+ }
+
+ fn both_opaque(
+ a: &Option<rustc_ast::ptr::P<ast::Ty>>,
+ b: &Option<rustc_ast::ptr::P<ast::Ty>>,
+ ) -> bool {
+ is_opaque(a) && is_opaque(b)
+ }
+
+ // In rustc-ap-v638 the `OpaqueTy` AssocItemKind variant was removed but
+ // we still need to differentiate to maintain sorting order.
+
+ // type -> opaque -> const -> macro -> method
+ use crate::ast::AssocItemKind::*;
+ fn need_empty_line(a: &ast::AssocItemKind, b: &ast::AssocItemKind) -> bool {
+ match (a, b) {
+ (TyAlias(lty), TyAlias(rty))
+ if both_type(<y.3, &rty.3) || both_opaque(<y.3, &rty.3) =>
+ {
+ false
+ }
+ (Const(..), Const(..)) => false,
+ _ => true,
+ }
+ }
+
+ buffer.sort_by(|(_, a), (_, b)| match (&a.kind, &b.kind) {
+ (TyAlias(lty), TyAlias(rty))
+ if both_type(<y.3, &rty.3) || both_opaque(<y.3, &rty.3) =>
+ {
+ a.ident.as_str().cmp(&b.ident.as_str())
+ }
+ (Const(..), Const(..)) | (MacCall(..), MacCall(..)) => {
+ a.ident.as_str().cmp(&b.ident.as_str())
+ }
+ (Fn(..), Fn(..)) => a.span.lo().cmp(&b.span.lo()),
+ (TyAlias(ty), _) if is_type(&ty.3) => Ordering::Less,
+ (_, TyAlias(ty)) if is_type(&ty.3) => Ordering::Greater,
+ (TyAlias(..), _) => Ordering::Less,
+ (_, TyAlias(..)) => Ordering::Greater,
+ (Const(..), _) => Ordering::Less,
+ (_, Const(..)) => Ordering::Greater,
+ (MacCall(..), _) => Ordering::Less,
+ (_, MacCall(..)) => Ordering::Greater,
+ });
+ let mut prev_kind = None;
+ for (buf, item) in buffer {
+ // Make sure that there are at least a single empty line between
+ // different impl items.
+ if prev_kind
+ .as_ref()
+ .map_or(false, |prev_kind| need_empty_line(prev_kind, &item.kind))
+ {
+ self.push_str("\n");
+ }
+ let indent_str = self.block_indent.to_string_with_newline(self.config);
+ self.push_str(&indent_str);
+ self.push_str(buf.trim());
+ prev_kind = Some(item.kind.clone());
+ }
+ } else {
+ for item in items {
+ self.visit_impl_item(item);
+ }
+ }
+ }
+}
+
+pub(crate) fn format_impl(
+ context: &RewriteContext<'_>,
+ item: &ast::Item,
+ offset: Indent,
+) -> Option<String> {
+ if let ast::ItemKind::Impl(impl_kind) = &item.kind {
+ let ast::ImplKind {
+ ref generics,
+ ref self_ty,
+ ref items,
+ ..
+ } = **impl_kind;
+ let mut result = String::with_capacity(128);
+ let ref_and_type = format_impl_ref_and_type(context, item, offset)?;
+ let sep = offset.to_string_with_newline(context.config);
+ result.push_str(&ref_and_type);
+
+ let where_budget = if result.contains('\n') {
+ context.config.max_width()
+ } else {
+ context.budget(last_line_width(&result))
+ };
+
+ let mut option = WhereClauseOption::snuggled(&ref_and_type);
+ let snippet = context.snippet(item.span);
+ let open_pos = snippet.find_uncommented("{")? + 1;
+ if !contains_comment(&snippet[open_pos..])
+ && items.is_empty()
+ && generics.where_clause.predicates.len() == 1
+ && !result.contains('\n')
+ {
+ option.suppress_comma();
+ option.snuggle();
+ option.allow_single_line();
+ }
+
+ let missing_span = mk_sp(self_ty.span.hi(), item.span.hi());
+ let where_span_end = context.snippet_provider.opt_span_before(missing_span, "{");
+ let where_clause_str = rewrite_where_clause(
+ context,
+ &generics.where_clause,
+ context.config.brace_style(),
+ Shape::legacy(where_budget, offset.block_only()),
+ false,
+ "{",
+ where_span_end,
+ self_ty.span.hi(),
+ option,
+ )?;
+
+ // If there is no where-clause, we may have missing comments between the trait name and
+ // the opening brace.
+ if generics.where_clause.predicates.is_empty() {
+ if let Some(hi) = where_span_end {
+ match recover_missing_comment_in_span(
+ mk_sp(self_ty.span.hi(), hi),
+ Shape::indented(offset, context.config),
+ context,
+ last_line_width(&result),
+ ) {
+ Some(ref missing_comment) if !missing_comment.is_empty() => {
+ result.push_str(missing_comment);
+ }
+ _ => (),
+ }
+ }
+ }
+
+ if is_impl_single_line(context, items.as_slice(), &result, &where_clause_str, item)? {
+ result.push_str(&where_clause_str);
+ if where_clause_str.contains('\n') || last_line_contains_single_line_comment(&result) {
+ // if the where_clause contains extra comments AND
+ // there is only one where-clause predicate
+ // recover the suppressed comma in single line where_clause formatting
+ if generics.where_clause.predicates.len() == 1 {
+ result.push(',');
+ }
+ result.push_str(&format!("{}{{{}}}", sep, sep));
+ } else {
+ result.push_str(" {}");
+ }
+ return Some(result);
+ }
+
+ result.push_str(&where_clause_str);
+
+ let need_newline = last_line_contains_single_line_comment(&result) || result.contains('\n');
+ match context.config.brace_style() {
+ _ if need_newline => result.push_str(&sep),
+ BraceStyle::AlwaysNextLine => result.push_str(&sep),
+ BraceStyle::PreferSameLine => result.push(' '),
+ BraceStyle::SameLineWhere => {
+ if !where_clause_str.is_empty() {
+ result.push_str(&sep);
+ } else {
+ result.push(' ');
+ }
+ }
+ }
+
+ result.push('{');
+ // this is an impl body snippet(impl SampleImpl { /* here */ })
+ let lo = max(self_ty.span.hi(), generics.where_clause.span.hi());
+ let snippet = context.snippet(mk_sp(lo, item.span.hi()));
+ let open_pos = snippet.find_uncommented("{")? + 1;
+
+ if !items.is_empty() || contains_comment(&snippet[open_pos..]) {
+ let mut visitor = FmtVisitor::from_context(context);
+ let item_indent = offset.block_only().block_indent(context.config);
+ visitor.block_indent = item_indent;
+ visitor.last_pos = lo + BytePos(open_pos as u32);
+
+ visitor.visit_attrs(&item.attrs, ast::AttrStyle::Inner);
+ visitor.visit_impl_items(items);
+
+ visitor.format_missing(item.span.hi() - BytePos(1));
+
+ let inner_indent_str = visitor.block_indent.to_string_with_newline(context.config);
+ let outer_indent_str = offset.block_only().to_string_with_newline(context.config);
+
+ result.push_str(&inner_indent_str);
+ result.push_str(visitor.buffer.trim());
+ result.push_str(&outer_indent_str);
+ } else if need_newline || !context.config.empty_item_single_line() {
+ result.push_str(&sep);
+ }
+
+ result.push('}');
+
+ Some(result)
+ } else {
+ unreachable!();
+ }
+}
+
+fn is_impl_single_line(
+ context: &RewriteContext<'_>,
+ items: &[ptr::P<ast::AssocItem>],
+ result: &str,
+ where_clause_str: &str,
+ item: &ast::Item,
+) -> Option<bool> {
+ let snippet = context.snippet(item.span);
+ let open_pos = snippet.find_uncommented("{")? + 1;
+
+ Some(
+ context.config.empty_item_single_line()
+ && items.is_empty()
+ && !result.contains('\n')
+ && result.len() + where_clause_str.len() <= context.config.max_width()
+ && !contains_comment(&snippet[open_pos..]),
+ )
+}
+
+fn format_impl_ref_and_type(
+ context: &RewriteContext<'_>,
+ item: &ast::Item,
+ offset: Indent,
+) -> Option<String> {
+ if let ast::ItemKind::Impl(impl_kind) = &item.kind {
+ let ast::ImplKind {
+ unsafety,
+ polarity,
+ defaultness,
+ constness,
+ ref generics,
+ of_trait: ref trait_ref,
+ ref self_ty,
+ ..
+ } = **impl_kind;
+ let mut result = String::with_capacity(128);
+
+ result.push_str(&format_visibility(context, &item.vis));
+ result.push_str(format_defaultness(defaultness));
+ result.push_str(format_unsafety(unsafety));
+
+ let shape = if context.config.version() == Version::Two {
+ Shape::indented(offset + last_line_width(&result), context.config)
+ } else {
+ generics_shape_from_config(
+ context.config,
+ Shape::indented(offset + last_line_width(&result), context.config),
+ 0,
+ )?
+ };
+ let generics_str = rewrite_generics(context, "impl", generics, shape)?;
+ result.push_str(&generics_str);
+ result.push_str(format_constness_right(constness));
+
+ let polarity_str = match polarity {
+ ast::ImplPolarity::Negative(_) => "!",
+ ast::ImplPolarity::Positive => "",
+ };
+
+ let polarity_overhead;
+ let trait_ref_overhead;
+ if let Some(ref trait_ref) = *trait_ref {
+ let result_len = last_line_width(&result);
+ result.push_str(&rewrite_trait_ref(
+ context,
+ trait_ref,
+ offset,
+ polarity_str,
+ result_len,
+ )?);
+ polarity_overhead = 0; // already written
+ trait_ref_overhead = " for".len();
+ } else {
+ polarity_overhead = polarity_str.len();
+ trait_ref_overhead = 0;
+ }
+
+ // Try to put the self type in a single line.
+ let curly_brace_overhead = if generics.where_clause.predicates.is_empty() {
+ // If there is no where-clause adapt budget for type formatting to take space and curly
+ // brace into account.
+ match context.config.brace_style() {
+ BraceStyle::AlwaysNextLine => 0,
+ _ => 2,
+ }
+ } else {
+ 0
+ };
+ let used_space = last_line_width(&result)
+ + polarity_overhead
+ + trait_ref_overhead
+ + curly_brace_overhead;
+ // 1 = space before the type.
+ let budget = context.budget(used_space + 1);
+ if let Some(self_ty_str) = self_ty.rewrite(context, Shape::legacy(budget, offset)) {
+ if !self_ty_str.contains('\n') {
+ if trait_ref.is_some() {
+ result.push_str(" for ");
+ } else {
+ result.push(' ');
+ result.push_str(polarity_str);
+ }
+ result.push_str(&self_ty_str);
+ return Some(result);
+ }
+ }
+
+ // Couldn't fit the self type on a single line, put it on a new line.
+ result.push('\n');
+ // Add indentation of one additional tab.
+ let new_line_offset = offset.block_indent(context.config);
+ result.push_str(&new_line_offset.to_string(context.config));
+ if trait_ref.is_some() {
+ result.push_str("for ");
+ } else {
+ result.push_str(polarity_str);
+ }
+ let budget = context.budget(last_line_width(&result) + polarity_overhead);
+ let type_offset = match context.config.indent_style() {
+ IndentStyle::Visual => new_line_offset + trait_ref_overhead,
+ IndentStyle::Block => new_line_offset,
+ };
+ result.push_str(&*self_ty.rewrite(context, Shape::legacy(budget, type_offset))?);
+ Some(result)
+ } else {
+ unreachable!();
+ }
+}
+
+fn rewrite_trait_ref(
+ context: &RewriteContext<'_>,
+ trait_ref: &ast::TraitRef,
+ offset: Indent,
+ polarity_str: &str,
+ result_len: usize,
+) -> Option<String> {
+ // 1 = space between generics and trait_ref
+ let used_space = 1 + polarity_str.len() + result_len;
+ let shape = Shape::indented(offset + used_space, context.config);
+ if let Some(trait_ref_str) = trait_ref.rewrite(context, shape) {
+ if !trait_ref_str.contains('\n') {
+ return Some(format!(" {}{}", polarity_str, trait_ref_str));
+ }
+ }
+ // We could not make enough space for trait_ref, so put it on new line.
+ let offset = offset.block_indent(context.config);
+ let shape = Shape::indented(offset, context.config);
+ let trait_ref_str = trait_ref.rewrite(context, shape)?;
+ Some(format!(
+ "{}{}{}",
+ offset.to_string_with_newline(context.config),
+ polarity_str,
+ trait_ref_str
+ ))
+}
+
+pub(crate) struct StructParts<'a> {
+ prefix: &'a str,
+ ident: symbol::Ident,
+ vis: &'a ast::Visibility,
+ def: &'a ast::VariantData,
+ generics: Option<&'a ast::Generics>,
+ span: Span,
+}
+
+impl<'a> StructParts<'a> {
+ fn format_header(&self, context: &RewriteContext<'_>, offset: Indent) -> String {
+ format_header(context, self.prefix, self.ident, self.vis, offset)
+ }
+
+ fn from_variant(variant: &'a ast::Variant) -> Self {
+ StructParts {
+ prefix: "",
+ ident: variant.ident,
+ vis: &DEFAULT_VISIBILITY,
+ def: &variant.data,
+ generics: None,
+ span: variant.span,
+ }
+ }
+
+ pub(crate) fn from_item(item: &'a ast::Item) -> Self {
+ let (prefix, def, generics) = match item.kind {
+ ast::ItemKind::Struct(ref def, ref generics) => ("struct ", def, generics),
+ ast::ItemKind::Union(ref def, ref generics) => ("union ", def, generics),
+ _ => unreachable!(),
+ };
+ StructParts {
+ prefix,
+ ident: item.ident,
+ vis: &item.vis,
+ def,
+ generics: Some(generics),
+ span: item.span,
+ }
+ }
+}
+
+fn format_struct(
+ context: &RewriteContext<'_>,
+ struct_parts: &StructParts<'_>,
+ offset: Indent,
+ one_line_width: Option<usize>,
+) -> Option<String> {
+ match *struct_parts.def {
+ ast::VariantData::Unit(..) => format_unit_struct(context, struct_parts, offset),
+ ast::VariantData::Tuple(ref fields, _) => {
+ format_tuple_struct(context, struct_parts, fields, offset)
+ }
+ ast::VariantData::Struct(ref fields, _) => {
+ format_struct_struct(context, struct_parts, fields, offset, one_line_width)
+ }
+ }
+}
+
+pub(crate) fn format_trait(
+ context: &RewriteContext<'_>,
+ item: &ast::Item,
+ offset: Indent,
+) -> Option<String> {
+ if let ast::ItemKind::Trait(trait_kind) = &item.kind {
+ let ast::TraitKind(is_auto, unsafety, ref generics, ref generic_bounds, ref trait_items) =
+ **trait_kind;
+ let mut result = String::with_capacity(128);
+ let header = format!(
+ "{}{}{}trait ",
+ format_visibility(context, &item.vis),
+ format_unsafety(unsafety),
+ format_auto(is_auto),
+ );
+ result.push_str(&header);
+
+ let body_lo = context.snippet_provider.span_after(item.span, "{");
+
+ let shape = Shape::indented(offset, context.config).offset_left(result.len())?;
+ let generics_str =
+ rewrite_generics(context, rewrite_ident(context, item.ident), generics, shape)?;
+ result.push_str(&generics_str);
+
+ // FIXME(#2055): rustfmt fails to format when there are comments between trait bounds.
+ if !generic_bounds.is_empty() {
+ let ident_hi = context
+ .snippet_provider
+ .span_after(item.span, &item.ident.as_str());
+ let bound_hi = generic_bounds.last().unwrap().span().hi();
+ let snippet = context.snippet(mk_sp(ident_hi, bound_hi));
+ if contains_comment(snippet) {
+ return None;
+ }
+
+ result = rewrite_assign_rhs_with(
+ context,
+ result + ":",
+ generic_bounds,
+ shape,
+ RhsTactics::ForceNextLineWithoutIndent,
+ )?;
+ }
+
+ // Rewrite where-clause.
+ if !generics.where_clause.predicates.is_empty() {
+ let where_on_new_line = context.config.indent_style() != IndentStyle::Block;
+
+ let where_budget = context.budget(last_line_width(&result));
+ let pos_before_where = if generic_bounds.is_empty() {
+ generics.where_clause.span.lo()
+ } else {
+ generic_bounds[generic_bounds.len() - 1].span().hi()
+ };
+ let option = WhereClauseOption::snuggled(&generics_str);
+ let where_clause_str = rewrite_where_clause(
+ context,
+ &generics.where_clause,
+ context.config.brace_style(),
+ Shape::legacy(where_budget, offset.block_only()),
+ where_on_new_line,
+ "{",
+ None,
+ pos_before_where,
+ option,
+ )?;
+ // If the where-clause cannot fit on the same line,
+ // put the where-clause on a new line
+ if !where_clause_str.contains('\n')
+ && last_line_width(&result) + where_clause_str.len() + offset.width()
+ > context.config.comment_width()
+ {
+ let width = offset.block_indent + context.config.tab_spaces() - 1;
+ let where_indent = Indent::new(0, width);
+ result.push_str(&where_indent.to_string_with_newline(context.config));
+ }
+ result.push_str(&where_clause_str);
+ } else {
+ let item_snippet = context.snippet(item.span);
+ if let Some(lo) = item_snippet.find('/') {
+ // 1 = `{`
+ let comment_hi = body_lo - BytePos(1);
+ let comment_lo = item.span.lo() + BytePos(lo as u32);
+ if comment_lo < comment_hi {
+ match recover_missing_comment_in_span(
+ mk_sp(comment_lo, comment_hi),
+ Shape::indented(offset, context.config),
+ context,
+ last_line_width(&result),
+ ) {
+ Some(ref missing_comment) if !missing_comment.is_empty() => {
+ result.push_str(missing_comment);
+ }
+ _ => (),
+ }
+ }
+ }
+ }
+
+ match context.config.brace_style() {
+ _ if last_line_contains_single_line_comment(&result)
+ || last_line_width(&result) + 2 > context.budget(offset.width()) =>
+ {
+ result.push_str(&offset.to_string_with_newline(context.config));
+ }
+ BraceStyle::AlwaysNextLine => {
+ result.push_str(&offset.to_string_with_newline(context.config));
+ }
+ BraceStyle::PreferSameLine => result.push(' '),
+ BraceStyle::SameLineWhere => {
+ if result.contains('\n')
+ || (!generics.where_clause.predicates.is_empty() && !trait_items.is_empty())
+ {
+ result.push_str(&offset.to_string_with_newline(context.config));
+ } else {
+ result.push(' ');
+ }
+ }
+ }
+ result.push('{');
+
+ let block_span = mk_sp(generics.where_clause.span.hi(), item.span.hi());
+ let snippet = context.snippet(block_span);
+ let open_pos = snippet.find_uncommented("{")? + 1;
+ let outer_indent_str = offset.block_only().to_string_with_newline(context.config);
+
+ if !trait_items.is_empty() || contains_comment(&snippet[open_pos..]) {
+ let mut visitor = FmtVisitor::from_context(context);
+ visitor.block_indent = offset.block_only().block_indent(context.config);
+ visitor.last_pos = block_span.lo() + BytePos(open_pos as u32);
+
+ for item in trait_items {
+ visitor.visit_trait_item(item);
+ }
+
+ visitor.format_missing(item.span.hi() - BytePos(1));
+
+ let inner_indent_str = visitor.block_indent.to_string_with_newline(context.config);
+
+ result.push_str(&inner_indent_str);
+ result.push_str(visitor.buffer.trim());
+ result.push_str(&outer_indent_str);
+ } else if result.contains('\n') {
+ result.push_str(&outer_indent_str);
+ }
+
+ result.push('}');
+ Some(result)
+ } else {
+ unreachable!();
+ }
+}
+
+struct OpaqueTypeBounds<'a> {
+ generic_bounds: &'a ast::GenericBounds,
+}
+
+impl<'a> Rewrite for OpaqueTypeBounds<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ self.generic_bounds
+ .rewrite(context, shape)
+ .map(|s| format!("impl {}", s))
+ }
+}
+
+pub(crate) struct TraitAliasBounds<'a> {
+ generic_bounds: &'a ast::GenericBounds,
+ generics: &'a ast::Generics,
+}
+
+impl<'a> Rewrite for TraitAliasBounds<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ let generic_bounds_str = self.generic_bounds.rewrite(context, shape)?;
+
+ let mut option = WhereClauseOption::new(true, WhereClauseSpace::None);
+ option.allow_single_line();
+
+ let where_str = rewrite_where_clause(
+ context,
+ &self.generics.where_clause,
+ context.config.brace_style(),
+ shape,
+ false,
+ ";",
+ None,
+ self.generics.where_clause.span.lo(),
+ option,
+ )?;
+
+ let fits_single_line = !generic_bounds_str.contains('\n')
+ && !where_str.contains('\n')
+ && generic_bounds_str.len() + where_str.len() < shape.width;
+ let space = if generic_bounds_str.is_empty() || where_str.is_empty() {
+ Cow::from("")
+ } else if fits_single_line {
+ Cow::from(" ")
+ } else {
+ shape.indent.to_string_with_newline(&context.config)
+ };
+
+ Some(format!("{}{}{}", generic_bounds_str, space, where_str))
+ }
+}
+
+pub(crate) fn format_trait_alias(
+ context: &RewriteContext<'_>,
+ ident: symbol::Ident,
+ vis: &ast::Visibility,
+ generics: &ast::Generics,
+ generic_bounds: &ast::GenericBounds,
+ shape: Shape,
+) -> Option<String> {
+ let alias = rewrite_ident(context, ident);
+ // 6 = "trait ", 2 = " ="
+ let g_shape = shape.offset_left(6)?.sub_width(2)?;
+ let generics_str = rewrite_generics(context, &alias, generics, g_shape)?;
+ let vis_str = format_visibility(context, vis);
+ let lhs = format!("{}trait {} =", vis_str, generics_str);
+ // 1 = ";"
+ let trait_alias_bounds = TraitAliasBounds {
+ generic_bounds,
+ generics,
+ };
+ rewrite_assign_rhs(context, lhs, &trait_alias_bounds, shape.sub_width(1)?).map(|s| s + ";")
+}
+
+fn format_unit_struct(
+ context: &RewriteContext<'_>,
+ p: &StructParts<'_>,
+ offset: Indent,
+) -> Option<String> {
+ let header_str = format_header(context, p.prefix, p.ident, p.vis, offset);
+ let generics_str = if let Some(generics) = p.generics {
+ let hi = context.snippet_provider.span_before(p.span, ";");
+ format_generics(
+ context,
+ generics,
+ context.config.brace_style(),
+ BracePos::None,
+ offset,
+ // make a span that starts right after `struct Foo`
+ mk_sp(p.ident.span.hi(), hi),
+ last_line_width(&header_str),
+ )?
+ } else {
+ String::new()
+ };
+ Some(format!("{}{};", header_str, generics_str))
+}
+
+pub(crate) fn format_struct_struct(
+ context: &RewriteContext<'_>,
+ struct_parts: &StructParts<'_>,
+ fields: &[ast::FieldDef],
+ offset: Indent,
+ one_line_width: Option<usize>,
+) -> Option<String> {
+ let mut result = String::with_capacity(1024);
+ let span = struct_parts.span;
+
+ let header_str = struct_parts.format_header(context, offset);
+ result.push_str(&header_str);
+
+ let header_hi = struct_parts.ident.span.hi();
+ let body_lo = context.snippet_provider.span_after(span, "{");
+
+ let generics_str = match struct_parts.generics {
+ Some(g) => format_generics(
+ context,
+ g,
+ context.config.brace_style(),
+ if fields.is_empty() {
+ BracePos::ForceSameLine
+ } else {
+ BracePos::Auto
+ },
+ offset,
+ // make a span that starts right after `struct Foo`
+ mk_sp(header_hi, body_lo),
+ last_line_width(&result),
+ )?,
+ None => {
+ // 3 = ` {}`, 2 = ` {`.
+ let overhead = if fields.is_empty() { 3 } else { 2 };
+ if (context.config.brace_style() == BraceStyle::AlwaysNextLine && !fields.is_empty())
+ || context.config.max_width() < overhead + result.len()
+ {
+ format!("\n{}{{", offset.block_only().to_string(context.config))
+ } else {
+ " {".to_owned()
+ }
+ }
+ };
+ // 1 = `}`
+ let overhead = if fields.is_empty() { 1 } else { 0 };
+ let total_width = result.len() + generics_str.len() + overhead;
+ if !generics_str.is_empty()
+ && !generics_str.contains('\n')
+ && total_width > context.config.max_width()
+ {
+ result.push('\n');
+ result.push_str(&offset.to_string(context.config));
+ result.push_str(generics_str.trim_start());
+ } else {
+ result.push_str(&generics_str);
+ }
+
+ if fields.is_empty() {
+ let inner_span = mk_sp(body_lo, span.hi() - BytePos(1));
+ format_empty_struct_or_tuple(context, inner_span, offset, &mut result, "", "}");
+ return Some(result);
+ }
+
+ // 3 = ` ` and ` }`
+ let one_line_budget = context.budget(result.len() + 3 + offset.width());
+ let one_line_budget =
+ one_line_width.map_or(0, |one_line_width| min(one_line_width, one_line_budget));
+
+ let items_str = rewrite_with_alignment(
+ fields,
+ context,
+ Shape::indented(offset.block_indent(context.config), context.config).sub_width(1)?,
+ mk_sp(body_lo, span.hi()),
+ one_line_budget,
+ )?;
+
+ if !items_str.contains('\n')
+ && !result.contains('\n')
+ && items_str.len() <= one_line_budget
+ && !last_line_contains_single_line_comment(&items_str)
+ {
+ Some(format!("{} {} }}", result, items_str))
+ } else {
+ Some(format!(
+ "{}\n{}{}\n{}}}",
+ result,
+ offset
+ .block_indent(context.config)
+ .to_string(context.config),
+ items_str,
+ offset.to_string(context.config)
+ ))
+ }
+}
+
+fn get_bytepos_after_visibility(vis: &ast::Visibility, default_span: Span) -> BytePos {
+ match vis.kind {
+ ast::VisibilityKind::Crate(..) | ast::VisibilityKind::Restricted { .. } => vis.span.hi(),
+ _ => default_span.lo(),
+ }
+}
+
+// Format tuple or struct without any fields. We need to make sure that the comments
+// inside the delimiters are preserved.
+fn format_empty_struct_or_tuple(
+ context: &RewriteContext<'_>,
+ span: Span,
+ offset: Indent,
+ result: &mut String,
+ opener: &str,
+ closer: &str,
+) {
+ // 3 = " {}" or "();"
+ let used_width = last_line_used_width(&result, offset.width()) + 3;
+ if used_width > context.config.max_width() {
+ result.push_str(&offset.to_string_with_newline(context.config))
+ }
+ result.push_str(opener);
+ match rewrite_missing_comment(span, Shape::indented(offset, context.config), context) {
+ Some(ref s) if s.is_empty() => (),
+ Some(ref s) => {
+ if !is_single_line(s) || first_line_contains_single_line_comment(s) {
+ let nested_indent_str = offset
+ .block_indent(context.config)
+ .to_string_with_newline(context.config);
+ result.push_str(&nested_indent_str);
+ }
+ result.push_str(s);
+ if last_line_contains_single_line_comment(s) {
+ result.push_str(&offset.to_string_with_newline(context.config));
+ }
+ }
+ None => result.push_str(context.snippet(span)),
+ }
+ result.push_str(closer);
+}
+
+fn format_tuple_struct(
+ context: &RewriteContext<'_>,
+ struct_parts: &StructParts<'_>,
+ fields: &[ast::FieldDef],
+ offset: Indent,
+) -> Option<String> {
+ let mut result = String::with_capacity(1024);
+ let span = struct_parts.span;
+
+ let header_str = struct_parts.format_header(context, offset);
+ result.push_str(&header_str);
+
+ let body_lo = if fields.is_empty() {
+ let lo = get_bytepos_after_visibility(struct_parts.vis, span);
+ context
+ .snippet_provider
+ .span_after(mk_sp(lo, span.hi()), "(")
+ } else {
+ fields[0].span.lo()
+ };
+ let body_hi = if fields.is_empty() {
+ context
+ .snippet_provider
+ .span_after(mk_sp(body_lo, span.hi()), ")")
+ } else {
+ // This is a dirty hack to work around a missing `)` from the span of the last field.
+ let last_arg_span = fields[fields.len() - 1].span;
+ context
+ .snippet_provider
+ .opt_span_after(mk_sp(last_arg_span.hi(), span.hi()), ")")
+ .unwrap_or_else(|| last_arg_span.hi())
+ };
+
+ let where_clause_str = match struct_parts.generics {
+ Some(generics) => {
+ let budget = context.budget(last_line_width(&header_str));
+ let shape = Shape::legacy(budget, offset);
+ let generics_str = rewrite_generics(context, "", generics, shape)?;
+ result.push_str(&generics_str);
+
+ let where_budget = context.budget(last_line_width(&result));
+ let option = WhereClauseOption::new(true, WhereClauseSpace::Newline);
+ rewrite_where_clause(
+ context,
+ &generics.where_clause,
+ context.config.brace_style(),
+ Shape::legacy(where_budget, offset.block_only()),
+ false,
+ ";",
+ None,
+ body_hi,
+ option,
+ )?
+ }
+ None => "".to_owned(),
+ };
+
+ if fields.is_empty() {
+ let body_hi = context
+ .snippet_provider
+ .span_before(mk_sp(body_lo, span.hi()), ")");
+ let inner_span = mk_sp(body_lo, body_hi);
+ format_empty_struct_or_tuple(context, inner_span, offset, &mut result, "(", ")");
+ } else {
+ let shape = Shape::indented(offset, context.config).sub_width(1)?;
++ let lo = if let Some(generics) = struct_parts.generics {
++ generics.span.hi()
++ } else {
++ struct_parts.ident.span.hi()
++ };
+ result = overflow::rewrite_with_parens(
+ context,
+ &result,
+ fields.iter(),
+ shape,
- fn rewrite_type<R: Rewrite>(
++ mk_sp(lo, span.hi()),
+ context.config.fn_call_width(),
+ None,
+ )?;
+ }
+
+ if !where_clause_str.is_empty()
+ && !where_clause_str.contains('\n')
+ && (result.contains('\n')
+ || offset.block_indent + result.len() + where_clause_str.len() + 1
+ > context.config.max_width())
+ {
+ // We need to put the where-clause on a new line, but we didn't
+ // know that earlier, so the where-clause will not be indented properly.
+ result.push('\n');
+ result.push_str(
+ &(offset.block_only() + (context.config.tab_spaces() - 1)).to_string(context.config),
+ );
+ }
+ result.push_str(&where_clause_str);
+
+ Some(result)
+}
+
- vis: &DEFAULT_VISIBILITY,
++pub(crate) fn rewrite_type<R: Rewrite>(
+ context: &RewriteContext<'_>,
+ indent: Indent,
+ ident: symbol::Ident,
+ vis: &ast::Visibility,
+ generics: &ast::Generics,
+ generic_bounds_opt: Option<&ast::GenericBounds>,
+ rhs: Option<&R>,
+ span: Span,
+) -> Option<String> {
+ let mut result = String::with_capacity(128);
+ result.push_str(&format!("{}type ", format_visibility(context, vis)));
+ let ident_str = rewrite_ident(context, ident);
+
+ if generics.params.is_empty() {
+ result.push_str(ident_str)
+ } else {
+ // 2 = `= `
+ let g_shape = Shape::indented(indent, context.config)
+ .offset_left(result.len())?
+ .sub_width(2)?;
+ let generics_str = rewrite_generics(context, ident_str, generics, g_shape)?;
+ result.push_str(&generics_str);
+ }
+
+ if let Some(bounds) = generic_bounds_opt {
+ if !bounds.is_empty() {
+ // 2 = `: `
+ let shape = Shape::indented(indent, context.config).offset_left(result.len() + 2)?;
+ let type_bounds = bounds.rewrite(context, shape).map(|s| format!(": {}", s))?;
+ result.push_str(&type_bounds);
+ }
+ }
+
+ let where_budget = context.budget(last_line_width(&result));
+ let mut option = WhereClauseOption::snuggled(&result);
+ if rhs.is_none() {
+ option.suppress_comma();
+ }
+ let where_clause_str = rewrite_where_clause(
+ context,
+ &generics.where_clause,
+ context.config.brace_style(),
+ Shape::legacy(where_budget, indent),
+ false,
+ "=",
+ None,
+ generics.span.hi(),
+ option,
+ )?;
+ result.push_str(&where_clause_str);
+
+ if let Some(ty) = rhs {
+ // If there's a where clause, add a newline before the assignment. Otherwise just add a
+ // space.
+ let has_where = !generics.where_clause.predicates.is_empty();
+ if has_where {
+ result.push_str(&indent.to_string_with_newline(context.config));
+ } else {
+ result.push(' ');
+ }
+
+ let comment_span = context
+ .snippet_provider
+ .opt_span_before(span, "=")
+ .map(|op_lo| mk_sp(generics.where_clause.span.hi(), op_lo));
+
+ let lhs = match comment_span {
+ Some(comment_span)
+ if contains_comment(context.snippet_provider.span_to_snippet(comment_span)?) =>
+ {
+ let comment_shape = if has_where {
+ Shape::indented(indent, context.config)
+ } else {
+ Shape::indented(indent, context.config)
+ .block_left(context.config.tab_spaces())?
+ };
+
+ combine_strs_with_missing_comments(
+ context,
+ result.trim_end(),
+ "=",
+ comment_span,
+ comment_shape,
+ true,
+ )?
+ }
+ _ => format!("{}=", result),
+ };
+
+ // 1 = `;`
+ let shape = Shape::indented(indent, context.config).sub_width(1)?;
+ rewrite_assign_rhs(context, lhs, &*ty, shape).map(|s| s + ";")
+ } else {
+ Some(format!("{};", result))
+ }
+}
+
+pub(crate) fn rewrite_opaque_type(
+ context: &RewriteContext<'_>,
+ indent: Indent,
+ ident: symbol::Ident,
+ generic_bounds: &ast::GenericBounds,
+ generics: &ast::Generics,
+ vis: &ast::Visibility,
+ span: Span,
+) -> Option<String> {
+ let opaque_type_bounds = OpaqueTypeBounds { generic_bounds };
+ rewrite_type(
+ context,
+ indent,
+ ident,
+ vis,
+ generics,
+ Some(generic_bounds),
+ Some(&opaque_type_bounds),
+ span,
+ )
+}
+
+fn type_annotation_spacing(config: &Config) -> (&str, &str) {
+ (
+ if config.space_before_colon() { " " } else { "" },
+ if config.space_after_colon() { " " } else { "" },
+ )
+}
+
+pub(crate) fn rewrite_struct_field_prefix(
+ context: &RewriteContext<'_>,
+ field: &ast::FieldDef,
+) -> Option<String> {
+ let vis = format_visibility(context, &field.vis);
+ let type_annotation_spacing = type_annotation_spacing(context.config);
+ Some(match field.ident {
+ Some(name) => format!(
+ "{}{}{}:",
+ vis,
+ rewrite_ident(context, name),
+ type_annotation_spacing.0
+ ),
+ None => vis.to_string(),
+ })
+}
+
+impl Rewrite for ast::FieldDef {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ rewrite_struct_field(context, self, shape, 0)
+ }
+}
+
+pub(crate) fn rewrite_struct_field(
+ context: &RewriteContext<'_>,
+ field: &ast::FieldDef,
+ shape: Shape,
+ lhs_max_width: usize,
+) -> Option<String> {
+ if contains_skip(&field.attrs) {
+ return Some(context.snippet(field.span()).to_owned());
+ }
+
+ let type_annotation_spacing = type_annotation_spacing(context.config);
+ let prefix = rewrite_struct_field_prefix(context, field)?;
+
+ let attrs_str = field.attrs.rewrite(context, shape)?;
+ let attrs_extendable = field.ident.is_none() && is_attributes_extendable(&attrs_str);
+ let missing_span = if field.attrs.is_empty() {
+ mk_sp(field.span.lo(), field.span.lo())
+ } else {
+ mk_sp(field.attrs.last().unwrap().span.hi(), field.span.lo())
+ };
+ let mut spacing = String::from(if field.ident.is_some() {
+ type_annotation_spacing.1
+ } else {
+ ""
+ });
+ // Try to put everything on a single line.
+ let attr_prefix = combine_strs_with_missing_comments(
+ context,
+ &attrs_str,
+ &prefix,
+ missing_span,
+ shape,
+ attrs_extendable,
+ )?;
+ let overhead = trimmed_last_line_width(&attr_prefix);
+ let lhs_offset = lhs_max_width.saturating_sub(overhead);
+ for _ in 0..lhs_offset {
+ spacing.push(' ');
+ }
+ // In this extreme case we will be missing a space between an attribute and a field.
+ if prefix.is_empty() && !attrs_str.is_empty() && attrs_extendable && spacing.is_empty() {
+ spacing.push(' ');
+ }
+ let orig_ty = shape
+ .offset_left(overhead + spacing.len())
+ .and_then(|ty_shape| field.ty.rewrite(context, ty_shape));
+ if let Some(ref ty) = orig_ty {
+ if !ty.contains('\n') {
+ return Some(attr_prefix + &spacing + ty);
+ }
+ }
+
+ let is_prefix_empty = prefix.is_empty();
+ // We must use multiline. We are going to put attributes and a field on different lines.
+ let field_str = rewrite_assign_rhs(context, prefix, &*field.ty, shape)?;
+ // Remove a leading white-space from `rewrite_assign_rhs()` when rewriting a tuple struct.
+ let field_str = if is_prefix_empty {
+ field_str.trim_start()
+ } else {
+ &field_str
+ };
+ combine_strs_with_missing_comments(context, &attrs_str, field_str, missing_span, shape, false)
+}
+
+pub(crate) struct StaticParts<'a> {
+ prefix: &'a str,
+ vis: &'a ast::Visibility,
+ ident: symbol::Ident,
+ ty: &'a ast::Ty,
+ mutability: ast::Mutability,
+ expr_opt: Option<&'a ptr::P<ast::Expr>>,
+ defaultness: Option<ast::Defaultness>,
+ span: Span,
+}
+
+impl<'a> StaticParts<'a> {
+ pub(crate) fn from_item(item: &'a ast::Item) -> Self {
+ let (defaultness, prefix, ty, mutability, expr) = match item.kind {
+ ast::ItemKind::Static(ref ty, mutability, ref expr) => {
+ (None, "static", ty, mutability, expr)
+ }
+ ast::ItemKind::Const(defaultness, ref ty, ref expr) => {
+ (Some(defaultness), "const", ty, ast::Mutability::Not, expr)
+ }
+ _ => unreachable!(),
+ };
+ StaticParts {
+ prefix,
+ vis: &item.vis,
+ ident: item.ident,
+ ty,
+ mutability,
+ expr_opt: expr.as_ref(),
+ defaultness,
+ span: item.span,
+ }
+ }
+
+ pub(crate) fn from_trait_item(ti: &'a ast::AssocItem) -> Self {
+ let (defaultness, ty, expr_opt) = match ti.kind {
+ ast::AssocItemKind::Const(defaultness, ref ty, ref expr_opt) => {
+ (defaultness, ty, expr_opt)
+ }
+ _ => unreachable!(),
+ };
+ StaticParts {
+ prefix: "const",
-
- pub(crate) fn rewrite_type_alias(
- ident: symbol::Ident,
- ty_opt: Option<&ptr::P<ast::Ty>>,
- generics: &ast::Generics,
- generic_bounds_opt: Option<&ast::GenericBounds>,
- context: &RewriteContext<'_>,
- indent: Indent,
- vis: &ast::Visibility,
- span: Span,
- ) -> Option<String> {
- rewrite_type(
- context,
- indent,
- ident,
- vis,
- generics,
- generic_bounds_opt,
- ty_opt,
- span,
- )
- }
-
++ vis: &ti.vis,
+ ident: ti.ident,
+ ty,
+ mutability: ast::Mutability::Not,
+ expr_opt: expr_opt.as_ref(),
+ defaultness: Some(defaultness),
+ span: ti.span,
+ }
+ }
+
+ pub(crate) fn from_impl_item(ii: &'a ast::AssocItem) -> Self {
+ let (defaultness, ty, expr) = match ii.kind {
+ ast::AssocItemKind::Const(defaultness, ref ty, ref expr) => (defaultness, ty, expr),
+ _ => unreachable!(),
+ };
+ StaticParts {
+ prefix: "const",
+ vis: &ii.vis,
+ ident: ii.ident,
+ ty,
+ mutability: ast::Mutability::Not,
+ expr_opt: expr.as_ref(),
+ defaultness: Some(defaultness),
+ span: ii.span,
+ }
+ }
+}
+
+fn rewrite_static(
+ context: &RewriteContext<'_>,
+ static_parts: &StaticParts<'_>,
+ offset: Indent,
+) -> Option<String> {
+ let colon = colon_spaces(context.config);
+ let mut prefix = format!(
+ "{}{}{} {}{}{}",
+ format_visibility(context, static_parts.vis),
+ static_parts.defaultness.map_or("", format_defaultness),
+ static_parts.prefix,
+ format_mutability(static_parts.mutability),
+ rewrite_ident(context, static_parts.ident),
+ colon,
+ );
+ // 2 = " =".len()
+ let ty_shape =
+ Shape::indented(offset.block_only(), context.config).offset_left(prefix.len() + 2)?;
+ let ty_str = match static_parts.ty.rewrite(context, ty_shape) {
+ Some(ty_str) => ty_str,
+ None => {
+ if prefix.ends_with(' ') {
+ prefix.pop();
+ }
+ let nested_indent = offset.block_indent(context.config);
+ let nested_shape = Shape::indented(nested_indent, context.config);
+ let ty_str = static_parts.ty.rewrite(context, nested_shape)?;
+ format!(
+ "{}{}",
+ nested_indent.to_string_with_newline(context.config),
+ ty_str
+ )
+ }
+ };
+
+ if let Some(expr) = static_parts.expr_opt {
+ let comments_lo = context.snippet_provider.span_after(static_parts.span, "=");
+ let expr_lo = expr.span.lo();
+ let comments_span = mk_sp(comments_lo, expr_lo);
+
+ let lhs = format!("{}{} =", prefix, ty_str);
+
+ // 1 = ;
+ let remaining_width = context.budget(offset.block_indent + 1);
+ rewrite_assign_rhs_with_comments(
+ context,
+ &lhs,
+ &**expr,
+ Shape::legacy(remaining_width, offset.block_only()),
+ RhsTactics::Default,
+ comments_span,
+ true,
+ )
+ .and_then(|res| recover_comment_removed(res, static_parts.span, context))
+ .map(|s| if s.ends_with(';') { s } else { s + ";" })
+ } else {
+ Some(format!("{}{};", prefix, ty_str))
+ }
+}
- pub(crate) fn rewrite_opaque_impl_type(
- context: &RewriteContext<'_>,
- ident: symbol::Ident,
- generics: &ast::Generics,
- generic_bounds: &ast::GenericBounds,
- indent: Indent,
- ) -> Option<String> {
- let ident_str = rewrite_ident(context, ident);
- // 5 = "type "
- let generics_shape = Shape::indented(indent, context.config).offset_left(5)?;
- let generics_str = rewrite_generics(context, ident_str, generics, generics_shape)?;
- let prefix = format!("type {} =", generics_str);
- let rhs = OpaqueType {
- bounds: generic_bounds,
- };
-
- rewrite_assign_rhs(
- context,
- &prefix,
- &rhs,
- Shape::indented(indent, context.config).sub_width(1)?,
- )
- .map(|s| s + ";")
- }
-
- pub(crate) fn rewrite_associated_impl_type(
+struct OpaqueType<'a> {
+ bounds: &'a ast::GenericBounds,
+}
+
+impl<'a> Rewrite for OpaqueType<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ let shape = shape.offset_left(5)?; // `impl `
+ self.bounds
+ .rewrite(context, shape)
+ .map(|s| format!("impl {}", s))
+ }
+}
+
- let result = rewrite_type_alias(ident, ty_opt, generics, None, context, indent, vis, span)?;
++pub(crate) fn rewrite_impl_type(
+ ident: symbol::Ident,
+ vis: &ast::Visibility,
+ defaultness: ast::Defaultness,
+ ty_opt: Option<&ptr::P<ast::Ty>>,
+ generics: &ast::Generics,
+ context: &RewriteContext<'_>,
+ indent: Indent,
+ span: Span,
+) -> Option<String> {
- let (span, has_multiple_attr_lines) = if !self.attrs.is_empty() {
++ // Opaque type
++ let result = if let Some(rustc_ast::ast::Ty {
++ kind: ast::TyKind::ImplTrait(_, ref bounds),
++ ..
++ }) = ty_opt.map(|t| &**t)
++ {
++ rewrite_type(
++ context,
++ indent,
++ ident,
++ &DEFAULT_VISIBILITY,
++ generics,
++ None,
++ Some(&OpaqueType { bounds }),
++ span,
++ )
++ } else {
++ rewrite_type(context, indent, ident, vis, generics, None, ty_opt, span)
++ }?;
+
+ match defaultness {
+ ast::Defaultness::Default(..) => Some(format!("default {}", result)),
+ _ => Some(result),
+ }
+}
+
+impl Rewrite for ast::FnRetTy {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match *self {
+ ast::FnRetTy::Default(_) => Some(String::new()),
+ ast::FnRetTy::Ty(ref ty) => {
+ if context.config.version() == Version::One
+ || context.config.indent_style() == IndentStyle::Visual
+ {
+ let inner_width = shape.width.checked_sub(3)?;
+ return ty
+ .rewrite(context, Shape::legacy(inner_width, shape.indent + 3))
+ .map(|r| format!("-> {}", r));
+ }
+
+ ty.rewrite(context, shape.offset_left(3)?)
+ .map(|s| format!("-> {}", s))
+ }
+ }
+ }
+}
+
+fn is_empty_infer(ty: &ast::Ty, pat_span: Span) -> bool {
+ match ty.kind {
+ ast::TyKind::Infer => ty.span.hi() == pat_span.hi(),
+ _ => false,
+ }
+}
+
+/// Recover any missing comments between the param and the type.
+///
+/// # Returns
+///
+/// A 2-len tuple with the comment before the colon in first position, and the comment after the
+/// colon in second position.
+fn get_missing_param_comments(
+ context: &RewriteContext<'_>,
+ pat_span: Span,
+ ty_span: Span,
+ shape: Shape,
+) -> (String, String) {
+ let missing_comment_span = mk_sp(pat_span.hi(), ty_span.lo());
+
+ let span_before_colon = {
+ let missing_comment_span_hi = context
+ .snippet_provider
+ .span_before(missing_comment_span, ":");
+ mk_sp(pat_span.hi(), missing_comment_span_hi)
+ };
+ let span_after_colon = {
+ let missing_comment_span_lo = context
+ .snippet_provider
+ .span_after(missing_comment_span, ":");
+ mk_sp(missing_comment_span_lo, ty_span.lo())
+ };
+
+ let comment_before_colon = rewrite_missing_comment(span_before_colon, shape, context)
+ .filter(|comment| !comment.is_empty())
+ .map_or(String::new(), |comment| format!(" {}", comment));
+ let comment_after_colon = rewrite_missing_comment(span_after_colon, shape, context)
+ .filter(|comment| !comment.is_empty())
+ .map_or(String::new(), |comment| format!("{} ", comment));
+ (comment_before_colon, comment_after_colon)
+}
+
+impl Rewrite for ast::Param {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ let param_attrs_result = self
+ .attrs
+ .rewrite(context, Shape::legacy(shape.width, shape.indent))?;
- (mk_sp(self.span.lo(), self.span.lo()), false)
++ // N.B. Doc comments aren't typically valid syntax, but could appear
++ // in the presence of certain macros - https://github.com/rust-lang/rustfmt/issues/4936
++ let (span, has_multiple_attr_lines, has_doc_comments) = if !self.attrs.is_empty() {
+ let num_attrs = self.attrs.len();
+ (
+ mk_sp(self.attrs[num_attrs - 1].span.hi(), self.pat.span.lo()),
+ param_attrs_result.contains('\n'),
++ self.attrs.iter().any(|a| a.is_doc_comment()),
+ )
+ } else {
- &self
- .pat
- .rewrite(context, Shape::legacy(shape.width, shape.indent))?,
++ (mk_sp(self.span.lo(), self.span.lo()), false, false)
+ };
+
+ if let Some(ref explicit_self) = self.to_self() {
+ rewrite_explicit_self(
+ context,
+ explicit_self,
+ ¶m_attrs_result,
+ span,
+ shape,
+ has_multiple_attr_lines,
+ )
+ } else if is_named_param(self) {
++ let param_name = &self
++ .pat
++ .rewrite(context, Shape::legacy(shape.width, shape.indent))?;
+ let mut result = combine_strs_with_missing_comments(
+ context,
+ ¶m_attrs_result,
- !has_multiple_attr_lines,
++ param_name,
+ span,
+ shape,
- let ty_str = self
++ !has_multiple_attr_lines && !has_doc_comments,
+ )?;
+
+ if !is_empty_infer(&*self.ty, self.pat.span) {
+ let (before_comment, after_comment) =
+ get_missing_param_comments(context, self.pat.span, self.ty.span, shape);
+ result.push_str(&before_comment);
+ result.push_str(colon_spaces(context.config));
+ result.push_str(&after_comment);
+ let overhead = last_line_width(&result);
+ let max_width = shape.width.checked_sub(overhead)?;
- .rewrite(context, Shape::legacy(max_width, shape.indent))?;
- result.push_str(&ty_str);
++ if let Some(ty_str) = self
+ .ty
- &FnSig::from_method_sig(&fn_sig, generics, self.vis.clone()),
++ .rewrite(context, Shape::legacy(max_width, shape.indent))
++ {
++ result.push_str(&ty_str);
++ } else {
++ result = combine_strs_with_missing_comments(
++ context,
++ &(param_attrs_result + &shape.to_string_with_newline(context.config)),
++ param_name,
++ span,
++ shape,
++ !has_multiple_attr_lines,
++ )?;
++ result.push_str(&before_comment);
++ result.push_str(colon_spaces(context.config));
++ result.push_str(&after_comment);
++ let overhead = last_line_width(&result);
++ let max_width = shape.width.checked_sub(overhead)?;
++ let ty_str = self
++ .ty
++ .rewrite(context, Shape::legacy(max_width, shape.indent))?;
++ result.push_str(&ty_str);
++ }
+ }
+
+ Some(result)
+ } else {
+ self.ty.rewrite(context, shape)
+ }
+ }
+}
+
+fn rewrite_explicit_self(
+ context: &RewriteContext<'_>,
+ explicit_self: &ast::ExplicitSelf,
+ param_attrs: &str,
+ span: Span,
+ shape: Shape,
+ has_multiple_attr_lines: bool,
+) -> Option<String> {
+ match explicit_self.node {
+ ast::SelfKind::Region(lt, m) => {
+ let mut_str = format_mutability(m);
+ match lt {
+ Some(ref l) => {
+ let lifetime_str = l.rewrite(
+ context,
+ Shape::legacy(context.config.max_width(), Indent::empty()),
+ )?;
+ Some(combine_strs_with_missing_comments(
+ context,
+ ¶m_attrs,
+ &format!("&{} {}self", lifetime_str, mut_str),
+ span,
+ shape,
+ !has_multiple_attr_lines,
+ )?)
+ }
+ None => Some(combine_strs_with_missing_comments(
+ context,
+ ¶m_attrs,
+ &format!("&{}self", mut_str),
+ span,
+ shape,
+ !has_multiple_attr_lines,
+ )?),
+ }
+ }
+ ast::SelfKind::Explicit(ref ty, mutability) => {
+ let type_str = ty.rewrite(
+ context,
+ Shape::legacy(context.config.max_width(), Indent::empty()),
+ )?;
+
+ Some(combine_strs_with_missing_comments(
+ context,
+ ¶m_attrs,
+ &format!("{}self: {}", format_mutability(mutability), type_str),
+ span,
+ shape,
+ !has_multiple_attr_lines,
+ )?)
+ }
+ ast::SelfKind::Value(mutability) => Some(combine_strs_with_missing_comments(
+ context,
+ ¶m_attrs,
+ &format!("{}self", format_mutability(mutability)),
+ span,
+ shape,
+ !has_multiple_attr_lines,
+ )?),
+ }
+}
+
+pub(crate) fn span_lo_for_param(param: &ast::Param) -> BytePos {
+ if param.attrs.is_empty() {
+ if is_named_param(param) {
+ param.pat.span.lo()
+ } else {
+ param.ty.span.lo()
+ }
+ } else {
+ param.attrs[0].span.lo()
+ }
+}
+
+pub(crate) fn span_hi_for_param(context: &RewriteContext<'_>, param: &ast::Param) -> BytePos {
+ match param.ty.kind {
+ ast::TyKind::Infer if context.snippet(param.ty.span) == "_" => param.ty.span.hi(),
+ ast::TyKind::Infer if is_named_param(param) => param.pat.span.hi(),
+ _ => param.ty.span.hi(),
+ }
+}
+
+pub(crate) fn is_named_param(param: &ast::Param) -> bool {
+ if let ast::PatKind::Ident(_, ident, _) = param.pat.kind {
+ ident.name != symbol::kw::Empty
+ } else {
+ true
+ }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum FnBraceStyle {
+ SameLine,
+ NextLine,
+ None,
+}
+
+// Return type is (result, force_new_line_for_brace)
+fn rewrite_fn_base(
+ context: &RewriteContext<'_>,
+ indent: Indent,
+ ident: symbol::Ident,
+ fn_sig: &FnSig<'_>,
+ span: Span,
+ fn_brace_style: FnBraceStyle,
+) -> Option<(String, bool, bool)> {
+ let mut force_new_line_for_brace = false;
+
+ let where_clause = &fn_sig.generics.where_clause;
+
+ let mut result = String::with_capacity(1024);
+ result.push_str(&fn_sig.to_str(context));
+
+ // fn foo
+ result.push_str("fn ");
+
+ // Generics.
+ let overhead = if let FnBraceStyle::SameLine = fn_brace_style {
+ // 4 = `() {`
+ 4
+ } else {
+ // 2 = `()`
+ 2
+ };
+ let used_width = last_line_used_width(&result, indent.width());
+ let one_line_budget = context.budget(used_width + overhead);
+ let shape = Shape {
+ width: one_line_budget,
+ indent,
+ offset: used_width,
+ };
+ let fd = fn_sig.decl;
+ let generics_str = rewrite_generics(
+ context,
+ rewrite_ident(context, ident),
+ fn_sig.generics,
+ shape,
+ )?;
+ result.push_str(&generics_str);
+
+ let snuggle_angle_bracket = generics_str
+ .lines()
+ .last()
+ .map_or(false, |l| l.trim_start().len() == 1);
+
+ // Note that the width and indent don't really matter, we'll re-layout the
+ // return type later anyway.
+ let ret_str = fd
+ .output
+ .rewrite(context, Shape::indented(indent, context.config))?;
+
+ let multi_line_ret_str = ret_str.contains('\n');
+ let ret_str_len = if multi_line_ret_str { 0 } else { ret_str.len() };
+
+ // Params.
+ let (one_line_budget, multi_line_budget, mut param_indent) = compute_budgets_for_params(
+ context,
+ &result,
+ indent,
+ ret_str_len,
+ fn_brace_style,
+ multi_line_ret_str,
+ )?;
+
+ debug!(
+ "rewrite_fn_base: one_line_budget: {}, multi_line_budget: {}, param_indent: {:?}",
+ one_line_budget, multi_line_budget, param_indent
+ );
+
+ result.push('(');
+ // Check if vertical layout was forced.
+ if one_line_budget == 0
+ && !snuggle_angle_bracket
+ && context.config.indent_style() == IndentStyle::Visual
+ {
+ result.push_str(¶m_indent.to_string_with_newline(context.config));
+ }
+
+ // Skip `pub(crate)`.
+ let lo_after_visibility = get_bytepos_after_visibility(&fn_sig.visibility, span);
+ // A conservative estimation, the goal is to be over all parens in generics
+ let params_start = fn_sig
+ .generics
+ .params
+ .last()
+ .map_or(lo_after_visibility, |param| param.span().hi());
+ let params_end = if fd.inputs.is_empty() {
+ context
+ .snippet_provider
+ .span_after(mk_sp(params_start, span.hi()), ")")
+ } else {
+ let last_span = mk_sp(fd.inputs[fd.inputs.len() - 1].span().hi(), span.hi());
+ context.snippet_provider.span_after(last_span, ")")
+ };
+ let params_span = mk_sp(
+ context
+ .snippet_provider
+ .span_after(mk_sp(params_start, span.hi()), "("),
+ params_end,
+ );
+ let param_str = rewrite_params(
+ context,
+ &fd.inputs,
+ one_line_budget,
+ multi_line_budget,
+ indent,
+ param_indent,
+ params_span,
+ fd.c_variadic(),
+ )?;
+
+ let put_params_in_block = match context.config.indent_style() {
+ IndentStyle::Block => param_str.contains('\n') || param_str.len() > one_line_budget,
+ _ => false,
+ } && !fd.inputs.is_empty();
+
+ let mut params_last_line_contains_comment = false;
+ let mut no_params_and_over_max_width = false;
+
+ if put_params_in_block {
+ param_indent = indent.block_indent(context.config);
+ result.push_str(¶m_indent.to_string_with_newline(context.config));
+ result.push_str(¶m_str);
+ result.push_str(&indent.to_string_with_newline(context.config));
+ result.push(')');
+ } else {
+ result.push_str(¶m_str);
+ let used_width = last_line_used_width(&result, indent.width()) + first_line_width(&ret_str);
+ // Put the closing brace on the next line if it overflows the max width.
+ // 1 = `)`
+ let closing_paren_overflow_max_width =
+ fd.inputs.is_empty() && used_width + 1 > context.config.max_width();
+ // If the last line of params contains comment, we cannot put the closing paren
+ // on the same line.
+ params_last_line_contains_comment = param_str
+ .lines()
+ .last()
+ .map_or(false, |last_line| last_line.contains("//"));
+
+ if context.config.version() == Version::Two {
+ if closing_paren_overflow_max_width {
+ result.push(')');
+ result.push_str(&indent.to_string_with_newline(context.config));
+ no_params_and_over_max_width = true;
+ } else if params_last_line_contains_comment {
+ result.push_str(&indent.to_string_with_newline(context.config));
+ result.push(')');
+ no_params_and_over_max_width = true;
+ } else {
+ result.push(')');
+ }
+ } else {
+ if closing_paren_overflow_max_width || params_last_line_contains_comment {
+ result.push_str(&indent.to_string_with_newline(context.config));
+ }
+ result.push(')');
+ }
+ }
+
+ // Return type.
+ if let ast::FnRetTy::Ty(..) = fd.output {
+ let ret_should_indent = match context.config.indent_style() {
+ // If our params are block layout then we surely must have space.
+ IndentStyle::Block if put_params_in_block || fd.inputs.is_empty() => false,
+ _ if params_last_line_contains_comment => false,
+ _ if result.contains('\n') || multi_line_ret_str => true,
+ _ => {
+ // If the return type would push over the max width, then put the return type on
+ // a new line. With the +1 for the signature length an additional space between
+ // the closing parenthesis of the param and the arrow '->' is considered.
+ let mut sig_length = result.len() + indent.width() + ret_str_len + 1;
+
+ // If there is no where-clause, take into account the space after the return type
+ // and the brace.
+ if where_clause.predicates.is_empty() {
+ sig_length += 2;
+ }
+
+ sig_length > context.config.max_width()
+ }
+ };
+ let ret_shape = if ret_should_indent {
+ if context.config.version() == Version::One
+ || context.config.indent_style() == IndentStyle::Visual
+ {
+ let indent = if param_str.is_empty() {
+ // Aligning with non-existent params looks silly.
+ force_new_line_for_brace = true;
+ indent + 4
+ } else {
+ // FIXME: we might want to check that using the param indent
+ // doesn't blow our budget, and if it does, then fallback to
+ // the where-clause indent.
+ param_indent
+ };
+
+ result.push_str(&indent.to_string_with_newline(context.config));
+ Shape::indented(indent, context.config)
+ } else {
+ let mut ret_shape = Shape::indented(indent, context.config);
+ if param_str.is_empty() {
+ // Aligning with non-existent params looks silly.
+ force_new_line_for_brace = true;
+ ret_shape = if context.use_block_indent() {
+ ret_shape.offset_left(4).unwrap_or(ret_shape)
+ } else {
+ ret_shape.indent = ret_shape.indent + 4;
+ ret_shape
+ };
+ }
+
+ result.push_str(&ret_shape.indent.to_string_with_newline(context.config));
+ ret_shape
+ }
+ } else {
+ if context.config.version() == Version::Two {
+ if !param_str.is_empty() || !no_params_and_over_max_width {
+ result.push(' ');
+ }
+ } else {
+ result.push(' ');
+ }
+
+ let ret_shape = Shape::indented(indent, context.config);
+ ret_shape
+ .offset_left(last_line_width(&result))
+ .unwrap_or(ret_shape)
+ };
+
+ if multi_line_ret_str || ret_should_indent {
+ // Now that we know the proper indent and width, we need to
+ // re-layout the return type.
+ let ret_str = fd.output.rewrite(context, ret_shape)?;
+ result.push_str(&ret_str);
+ } else {
+ result.push_str(&ret_str);
+ }
+
+ // Comment between return type and the end of the decl.
+ let snippet_lo = fd.output.span().hi();
+ if where_clause.predicates.is_empty() {
+ let snippet_hi = span.hi();
+ let snippet = context.snippet(mk_sp(snippet_lo, snippet_hi));
+ // Try to preserve the layout of the original snippet.
+ let original_starts_with_newline = snippet
+ .find(|c| c != ' ')
+ .map_or(false, |i| starts_with_newline(&snippet[i..]));
+ let original_ends_with_newline = snippet
+ .rfind(|c| c != ' ')
+ .map_or(false, |i| snippet[i..].ends_with('\n'));
+ let snippet = snippet.trim();
+ if !snippet.is_empty() {
+ result.push(if original_starts_with_newline {
+ '\n'
+ } else {
+ ' '
+ });
+ result.push_str(snippet);
+ if original_ends_with_newline {
+ force_new_line_for_brace = true;
+ }
+ }
+ }
+ }
+
+ let pos_before_where = match fd.output {
+ ast::FnRetTy::Default(..) => params_span.hi(),
+ ast::FnRetTy::Ty(ref ty) => ty.span.hi(),
+ };
+
+ let is_params_multi_lined = param_str.contains('\n');
+
+ let space = if put_params_in_block && ret_str.is_empty() {
+ WhereClauseSpace::Space
+ } else {
+ WhereClauseSpace::Newline
+ };
+ let mut option = WhereClauseOption::new(fn_brace_style == FnBraceStyle::None, space);
+ if is_params_multi_lined {
+ option.veto_single_line();
+ }
+ let where_clause_str = rewrite_where_clause(
+ context,
+ where_clause,
+ context.config.brace_style(),
+ Shape::indented(indent, context.config),
+ true,
+ "{",
+ Some(span.hi()),
+ pos_before_where,
+ option,
+ )?;
+ // If there are neither where-clause nor return type, we may be missing comments between
+ // params and `{`.
+ if where_clause_str.is_empty() {
+ if let ast::FnRetTy::Default(ret_span) = fd.output {
+ match recover_missing_comment_in_span(
+ mk_sp(params_span.hi(), ret_span.hi()),
+ shape,
+ context,
+ last_line_width(&result),
+ ) {
+ Some(ref missing_comment) if !missing_comment.is_empty() => {
+ result.push_str(missing_comment);
+ force_new_line_for_brace = true;
+ }
+ _ => (),
+ }
+ }
+ }
+
+ result.push_str(&where_clause_str);
+
+ let ends_with_comment = last_line_contains_single_line_comment(&result);
+ force_new_line_for_brace |= ends_with_comment;
+ force_new_line_for_brace |=
+ is_params_multi_lined && context.config.where_single_line() && !where_clause_str.is_empty();
+ Some((result, ends_with_comment, force_new_line_for_brace))
+}
+
+/// Kind of spaces to put before `where`.
+#[derive(Copy, Clone)]
+enum WhereClauseSpace {
+ /// A single space.
+ Space,
+ /// A new line.
+ Newline,
+ /// Nothing.
+ None,
+}
+
+#[derive(Copy, Clone)]
+struct WhereClauseOption {
+ suppress_comma: bool, // Force no trailing comma
+ snuggle: WhereClauseSpace,
+ allow_single_line: bool, // Try single line where-clause instead of vertical layout
+ veto_single_line: bool, // Disallow a single-line where-clause.
+}
+
+impl WhereClauseOption {
+ fn new(suppress_comma: bool, snuggle: WhereClauseSpace) -> WhereClauseOption {
+ WhereClauseOption {
+ suppress_comma,
+ snuggle,
+ allow_single_line: false,
+ veto_single_line: false,
+ }
+ }
+
+ fn snuggled(current: &str) -> WhereClauseOption {
+ WhereClauseOption {
+ suppress_comma: false,
+ snuggle: if last_line_width(current) == 1 {
+ WhereClauseSpace::Space
+ } else {
+ WhereClauseSpace::Newline
+ },
+ allow_single_line: false,
+ veto_single_line: false,
+ }
+ }
+
+ fn suppress_comma(&mut self) {
+ self.suppress_comma = true
+ }
+
+ fn allow_single_line(&mut self) {
+ self.allow_single_line = true
+ }
+
+ fn snuggle(&mut self) {
+ self.snuggle = WhereClauseSpace::Space
+ }
+
+ fn veto_single_line(&mut self) {
+ self.veto_single_line = true;
+ }
+}
+
+fn rewrite_params(
+ context: &RewriteContext<'_>,
+ params: &[ast::Param],
+ one_line_budget: usize,
+ multi_line_budget: usize,
+ indent: Indent,
+ param_indent: Indent,
+ span: Span,
+ variadic: bool,
+) -> Option<String> {
+ if params.is_empty() {
+ let comment = context
+ .snippet(mk_sp(
+ span.lo(),
+ // to remove ')'
+ span.hi() - BytePos(1),
+ ))
+ .trim();
+ return Some(comment.to_owned());
+ }
+ let param_items: Vec<_> = itemize_list(
+ context.snippet_provider,
+ params.iter(),
+ ")",
+ ",",
+ |param| span_lo_for_param(param),
+ |param| param.ty.span.hi(),
+ |param| {
+ param
+ .rewrite(context, Shape::legacy(multi_line_budget, param_indent))
+ .or_else(|| Some(context.snippet(param.span()).to_owned()))
+ },
+ span.lo(),
+ span.hi(),
+ false,
+ )
+ .collect();
+
+ let tactic = definitive_tactic(
+ ¶m_items,
+ context
+ .config
+ .fn_args_layout()
+ .to_list_tactic(param_items.len()),
+ Separator::Comma,
+ one_line_budget,
+ );
+ let budget = match tactic {
+ DefinitiveListTactic::Horizontal => one_line_budget,
+ _ => multi_line_budget,
+ };
+ let indent = match context.config.indent_style() {
+ IndentStyle::Block => indent.block_indent(context.config),
+ IndentStyle::Visual => param_indent,
+ };
+ let trailing_separator = if variadic {
+ SeparatorTactic::Never
+ } else {
+ match context.config.indent_style() {
+ IndentStyle::Block => context.config.trailing_comma(),
+ IndentStyle::Visual => SeparatorTactic::Never,
+ }
+ };
+ let fmt = ListFormatting::new(Shape::legacy(budget, indent), context.config)
+ .tactic(tactic)
+ .trailing_separator(trailing_separator)
+ .ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
+ .preserve_newline(true);
+ write_list(¶m_items, &fmt)
+}
+
+fn compute_budgets_for_params(
+ context: &RewriteContext<'_>,
+ result: &str,
+ indent: Indent,
+ ret_str_len: usize,
+ fn_brace_style: FnBraceStyle,
+ force_vertical_layout: bool,
+) -> Option<(usize, usize, Indent)> {
+ debug!(
+ "compute_budgets_for_params {} {:?}, {}, {:?}",
+ result.len(),
+ indent,
+ ret_str_len,
+ fn_brace_style,
+ );
+ // Try keeping everything on the same line.
+ if !result.contains('\n') && !force_vertical_layout {
+ // 2 = `()`, 3 = `() `, space is before ret_string.
+ let overhead = if ret_str_len == 0 { 2 } else { 3 };
+ let mut used_space = indent.width() + result.len() + ret_str_len + overhead;
+ match fn_brace_style {
+ FnBraceStyle::None => used_space += 1, // 1 = `;`
+ FnBraceStyle::SameLine => used_space += 2, // 2 = `{}`
+ FnBraceStyle::NextLine => (),
+ }
+ let one_line_budget = context.budget(used_space);
+
+ if one_line_budget > 0 {
+ // 4 = "() {".len()
+ let (indent, multi_line_budget) = match context.config.indent_style() {
+ IndentStyle::Block => {
+ let indent = indent.block_indent(context.config);
+ (indent, context.budget(indent.width() + 1))
+ }
+ IndentStyle::Visual => {
+ let indent = indent + result.len() + 1;
+ let multi_line_overhead = match fn_brace_style {
+ FnBraceStyle::SameLine => 4,
+ _ => 2,
+ } + indent.width();
+ (indent, context.budget(multi_line_overhead))
+ }
+ };
+
+ return Some((one_line_budget, multi_line_budget, indent));
+ }
+ }
+
+ // Didn't work. we must force vertical layout and put params on a newline.
+ let new_indent = indent.block_indent(context.config);
+ let used_space = match context.config.indent_style() {
+ // 1 = `,`
+ IndentStyle::Block => new_indent.width() + 1,
+ // Account for `)` and possibly ` {`.
+ IndentStyle::Visual => new_indent.width() + if ret_str_len == 0 { 1 } else { 3 },
+ };
+ Some((0, context.budget(used_space), new_indent))
+}
+
+fn newline_for_brace(config: &Config, where_clause: &ast::WhereClause) -> FnBraceStyle {
+ let predicate_count = where_clause.predicates.len();
+
+ if config.where_single_line() && predicate_count == 1 {
+ return FnBraceStyle::SameLine;
+ }
+ let brace_style = config.brace_style();
+
+ let use_next_line = brace_style == BraceStyle::AlwaysNextLine
+ || (brace_style == BraceStyle::SameLineWhere && predicate_count > 0);
+ if use_next_line {
+ FnBraceStyle::NextLine
+ } else {
+ FnBraceStyle::SameLine
+ }
+}
+
+fn rewrite_generics(
+ context: &RewriteContext<'_>,
+ ident: &str,
+ generics: &ast::Generics,
+ shape: Shape,
+) -> Option<String> {
+ // FIXME: convert bounds to where-clauses where they get too big or if
+ // there is a where-clause at all.
+
+ if generics.params.is_empty() {
+ return Some(ident.to_owned());
+ }
+
+ let params = generics.params.iter();
+ overflow::rewrite_with_angle_brackets(context, ident, params, shape, generics.span)
+}
+
+fn generics_shape_from_config(config: &Config, shape: Shape, offset: usize) -> Option<Shape> {
+ match config.indent_style() {
+ IndentStyle::Visual => shape.visual_indent(1 + offset).sub_width(offset + 2),
+ IndentStyle::Block => {
+ // 1 = ","
+ shape
+ .block()
+ .block_indent(config.tab_spaces())
+ .with_max_width(config)
+ .sub_width(1)
+ }
+ }
+}
+
+fn rewrite_where_clause_rfc_style(
+ context: &RewriteContext<'_>,
+ where_clause: &ast::WhereClause,
+ shape: Shape,
+ terminator: &str,
+ span_end: Option<BytePos>,
+ span_end_before_where: BytePos,
+ where_clause_option: WhereClauseOption,
+) -> Option<String> {
+ let (where_keyword, allow_single_line) = rewrite_where_keyword(
+ context,
+ where_clause,
+ shape,
+ span_end_before_where,
+ where_clause_option,
+ )?;
+
+ // 1 = `,`
+ let clause_shape = shape
+ .block()
+ .with_max_width(context.config)
+ .block_left(context.config.tab_spaces())?
+ .sub_width(1)?;
+ let force_single_line = context.config.where_single_line()
+ && where_clause.predicates.len() == 1
+ && !where_clause_option.veto_single_line;
+
+ let preds_str = rewrite_bounds_on_where_clause(
+ context,
+ where_clause,
+ clause_shape,
+ terminator,
+ span_end,
+ where_clause_option,
+ force_single_line,
+ )?;
+
+ // 6 = `where `
+ let clause_sep =
+ if allow_single_line && !preds_str.contains('\n') && 6 + preds_str.len() <= shape.width
+ || force_single_line
+ {
+ Cow::from(" ")
+ } else {
+ clause_shape.indent.to_string_with_newline(context.config)
+ };
+
+ Some(format!("{}{}{}", where_keyword, clause_sep, preds_str))
+}
+
+/// Rewrite `where` and comment around it.
+fn rewrite_where_keyword(
+ context: &RewriteContext<'_>,
+ where_clause: &ast::WhereClause,
+ shape: Shape,
+ span_end_before_where: BytePos,
+ where_clause_option: WhereClauseOption,
+) -> Option<(String, bool)> {
+ let block_shape = shape.block().with_max_width(context.config);
+ // 1 = `,`
+ let clause_shape = block_shape
+ .block_left(context.config.tab_spaces())?
+ .sub_width(1)?;
+
+ let comment_separator = |comment: &str, shape: Shape| {
+ if comment.is_empty() {
+ Cow::from("")
+ } else {
+ shape.indent.to_string_with_newline(context.config)
+ }
+ };
+
+ let (span_before, span_after) =
+ missing_span_before_after_where(span_end_before_where, where_clause);
+ let (comment_before, comment_after) =
+ rewrite_comments_before_after_where(context, span_before, span_after, shape)?;
+
+ let starting_newline = match where_clause_option.snuggle {
+ WhereClauseSpace::Space if comment_before.is_empty() => Cow::from(" "),
+ WhereClauseSpace::None => Cow::from(""),
+ _ => block_shape.indent.to_string_with_newline(context.config),
+ };
+
+ let newline_before_where = comment_separator(&comment_before, shape);
+ let newline_after_where = comment_separator(&comment_after, clause_shape);
+ let result = format!(
+ "{}{}{}where{}{}",
+ starting_newline, comment_before, newline_before_where, newline_after_where, comment_after
+ );
+ let allow_single_line = where_clause_option.allow_single_line
+ && comment_before.is_empty()
+ && comment_after.is_empty();
+
+ Some((result, allow_single_line))
+}
+
+/// Rewrite bounds on a where clause.
+fn rewrite_bounds_on_where_clause(
+ context: &RewriteContext<'_>,
+ where_clause: &ast::WhereClause,
+ shape: Shape,
+ terminator: &str,
+ span_end: Option<BytePos>,
+ where_clause_option: WhereClauseOption,
+ force_single_line: bool,
+) -> Option<String> {
+ let span_start = where_clause.predicates[0].span().lo();
+ // If we don't have the start of the next span, then use the end of the
+ // predicates, but that means we miss comments.
+ let len = where_clause.predicates.len();
+ let end_of_preds = where_clause.predicates[len - 1].span().hi();
+ let span_end = span_end.unwrap_or(end_of_preds);
+ let items = itemize_list(
+ context.snippet_provider,
+ where_clause.predicates.iter(),
+ terminator,
+ ",",
+ |pred| pred.span().lo(),
+ |pred| pred.span().hi(),
+ |pred| pred.rewrite(context, shape),
+ span_start,
+ span_end,
+ false,
+ );
+ let comma_tactic = if where_clause_option.suppress_comma || force_single_line {
+ SeparatorTactic::Never
+ } else {
+ context.config.trailing_comma()
+ };
+
+ // shape should be vertical only and only if we have `force_single_line` option enabled
+ // and the number of items of the where-clause is equal to 1
+ let shape_tactic = if force_single_line {
+ DefinitiveListTactic::Horizontal
+ } else {
+ DefinitiveListTactic::Vertical
+ };
+
+ let fmt = ListFormatting::new(shape, context.config)
+ .tactic(shape_tactic)
+ .trailing_separator(comma_tactic)
+ .preserve_newline(true);
+ write_list(&items.collect::<Vec<_>>(), &fmt)
+}
+
+fn rewrite_where_clause(
+ context: &RewriteContext<'_>,
+ where_clause: &ast::WhereClause,
+ brace_style: BraceStyle,
+ shape: Shape,
+ on_new_line: bool,
+ terminator: &str,
+ span_end: Option<BytePos>,
+ span_end_before_where: BytePos,
+ where_clause_option: WhereClauseOption,
+) -> Option<String> {
+ if where_clause.predicates.is_empty() {
+ return Some(String::new());
+ }
+
+ if context.config.indent_style() == IndentStyle::Block {
+ return rewrite_where_clause_rfc_style(
+ context,
+ where_clause,
+ shape,
+ terminator,
+ span_end,
+ span_end_before_where,
+ where_clause_option,
+ );
+ }
+
+ let extra_indent = Indent::new(context.config.tab_spaces(), 0);
+
+ let offset = match context.config.indent_style() {
+ IndentStyle::Block => shape.indent + extra_indent.block_indent(context.config),
+ // 6 = "where ".len()
+ IndentStyle::Visual => shape.indent + extra_indent + 6,
+ };
+ // FIXME: if indent_style != Visual, then the budgets below might
+ // be out by a char or two.
+
+ let budget = context.config.max_width() - offset.width();
+ let span_start = where_clause.predicates[0].span().lo();
+ // If we don't have the start of the next span, then use the end of the
+ // predicates, but that means we miss comments.
+ let len = where_clause.predicates.len();
+ let end_of_preds = where_clause.predicates[len - 1].span().hi();
+ let span_end = span_end.unwrap_or(end_of_preds);
+ let items = itemize_list(
+ context.snippet_provider,
+ where_clause.predicates.iter(),
+ terminator,
+ ",",
+ |pred| pred.span().lo(),
+ |pred| pred.span().hi(),
+ |pred| pred.rewrite(context, Shape::legacy(budget, offset)),
+ span_start,
+ span_end,
+ false,
+ );
+ let item_vec = items.collect::<Vec<_>>();
+ // FIXME: we don't need to collect here
+ let tactic = definitive_tactic(&item_vec, ListTactic::Vertical, Separator::Comma, budget);
+
+ let mut comma_tactic = context.config.trailing_comma();
+ // Kind of a hack because we don't usually have trailing commas in where-clauses.
+ if comma_tactic == SeparatorTactic::Vertical || where_clause_option.suppress_comma {
+ comma_tactic = SeparatorTactic::Never;
+ }
+
+ let fmt = ListFormatting::new(Shape::legacy(budget, offset), context.config)
+ .tactic(tactic)
+ .trailing_separator(comma_tactic)
+ .ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
+ .preserve_newline(true);
+ let preds_str = write_list(&item_vec, &fmt)?;
+
+ let end_length = if terminator == "{" {
+ // If the brace is on the next line we don't need to count it otherwise it needs two
+ // characters " {"
+ match brace_style {
+ BraceStyle::AlwaysNextLine | BraceStyle::SameLineWhere => 0,
+ BraceStyle::PreferSameLine => 2,
+ }
+ } else if terminator == "=" {
+ 2
+ } else {
+ terminator.len()
+ };
+ if on_new_line
+ || preds_str.contains('\n')
+ || shape.indent.width() + " where ".len() + preds_str.len() + end_length > shape.width
+ {
+ Some(format!(
+ "\n{}where {}",
+ (shape.indent + extra_indent).to_string(context.config),
+ preds_str
+ ))
+ } else {
+ Some(format!(" where {}", preds_str))
+ }
+}
+
+fn missing_span_before_after_where(
+ before_item_span_end: BytePos,
+ where_clause: &ast::WhereClause,
+) -> (Span, Span) {
+ let missing_span_before = mk_sp(before_item_span_end, where_clause.span.lo());
+ // 5 = `where`
+ let pos_after_where = where_clause.span.lo() + BytePos(5);
+ let missing_span_after = mk_sp(pos_after_where, where_clause.predicates[0].span().lo());
+ (missing_span_before, missing_span_after)
+}
+
+fn rewrite_comments_before_after_where(
+ context: &RewriteContext<'_>,
+ span_before_where: Span,
+ span_after_where: Span,
+ shape: Shape,
+) -> Option<(String, String)> {
+ let before_comment = rewrite_missing_comment(span_before_where, shape, context)?;
+ let after_comment = rewrite_missing_comment(
+ span_after_where,
+ shape.block_indent(context.config.tab_spaces()),
+ context,
+ )?;
+ Some((before_comment, after_comment))
+}
+
+fn format_header(
+ context: &RewriteContext<'_>,
+ item_name: &str,
+ ident: symbol::Ident,
+ vis: &ast::Visibility,
+ offset: Indent,
+) -> String {
+ let mut result = String::with_capacity(128);
+ let shape = Shape::indented(offset, context.config);
+
+ result.push_str(&format_visibility(context, vis).trim());
+
+ // Check for a missing comment between the visibility and the item name.
+ let after_vis = vis.span.hi();
+ if let Some(before_item_name) = context
+ .snippet_provider
+ .opt_span_before(mk_sp(vis.span.lo(), ident.span.hi()), item_name.trim())
+ {
+ let missing_span = mk_sp(after_vis, before_item_name);
+ if let Some(result_with_comment) = combine_strs_with_missing_comments(
+ context,
+ &result,
+ item_name,
+ missing_span,
+ shape,
+ /* allow_extend */ true,
+ ) {
+ result = result_with_comment;
+ }
+ }
+
+ result.push_str(&rewrite_ident(context, ident));
+
+ result
+}
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+enum BracePos {
+ None,
+ Auto,
+ ForceSameLine,
+}
+
+fn format_generics(
+ context: &RewriteContext<'_>,
+ generics: &ast::Generics,
+ brace_style: BraceStyle,
+ brace_pos: BracePos,
+ offset: Indent,
+ span: Span,
+ used_width: usize,
+) -> Option<String> {
+ let shape = Shape::legacy(context.budget(used_width + offset.width()), offset);
+ let mut result = rewrite_generics(context, "", generics, shape)?;
+
+ // If the generics are not parameterized then generics.span.hi() == 0,
+ // so we use span.lo(), which is the position after `struct Foo`.
+ let span_end_before_where = if !generics.params.is_empty() {
+ generics.span.hi()
+ } else {
+ span.lo()
+ };
+ let (same_line_brace, missed_comments) = if !generics.where_clause.predicates.is_empty() {
+ let budget = context.budget(last_line_used_width(&result, offset.width()));
+ let mut option = WhereClauseOption::snuggled(&result);
+ if brace_pos == BracePos::None {
+ option.suppress_comma = true;
+ }
+ let where_clause_str = rewrite_where_clause(
+ context,
+ &generics.where_clause,
+ brace_style,
+ Shape::legacy(budget, offset.block_only()),
+ true,
+ "{",
+ Some(span.hi()),
+ span_end_before_where,
+ option,
+ )?;
+ result.push_str(&where_clause_str);
+ (
+ brace_pos == BracePos::ForceSameLine || brace_style == BraceStyle::PreferSameLine,
+ // missed comments are taken care of in #rewrite_where_clause
+ None,
+ )
+ } else {
+ (
+ brace_pos == BracePos::ForceSameLine
+ || (result.contains('\n') && brace_style == BraceStyle::PreferSameLine
+ || brace_style != BraceStyle::AlwaysNextLine)
+ || trimmed_last_line_width(&result) == 1,
+ rewrite_missing_comment(
+ mk_sp(
+ span_end_before_where,
+ if brace_pos == BracePos::None {
+ span.hi()
+ } else {
+ context.snippet_provider.span_before(span, "{")
+ },
+ ),
+ shape,
+ context,
+ ),
+ )
+ };
+ // add missing comments
+ let missed_line_comments = missed_comments
+ .filter(|missed_comments| !missed_comments.is_empty())
+ .map_or(false, |missed_comments| {
+ let is_block = is_last_comment_block(&missed_comments);
+ let sep = if is_block { " " } else { "\n" };
+ result.push_str(sep);
+ result.push_str(&missed_comments);
+ !is_block
+ });
+ if brace_pos == BracePos::None {
+ return Some(result);
+ }
+ let total_used_width = last_line_used_width(&result, used_width);
+ let remaining_budget = context.budget(total_used_width);
+ // If the same line brace if forced, it indicates that we are rewriting an item with empty body,
+ // and hence we take the closer into account as well for one line budget.
+ // We assume that the closer has the same length as the opener.
+ let overhead = if brace_pos == BracePos::ForceSameLine {
+ // 3 = ` {}`
+ 3
+ } else {
+ // 2 = ` {`
+ 2
+ };
+ let forbid_same_line_brace = missed_line_comments || overhead > remaining_budget;
+ if !forbid_same_line_brace && same_line_brace {
+ result.push(' ');
+ } else {
+ result.push('\n');
+ result.push_str(&offset.block_only().to_string(context.config));
+ }
+ result.push('{');
+
+ Some(result)
+}
+
+impl Rewrite for ast::ForeignItem {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ let attrs_str = self.attrs.rewrite(context, shape)?;
+ // Drop semicolon or it will be interpreted as comment.
+ // FIXME: this may be a faulty span from libsyntax.
+ let span = mk_sp(self.span.lo(), self.span.hi() - BytePos(1));
+
+ let item_str = match self.kind {
+ ast::ForeignItemKind::Fn(ref fn_kind) => {
+ let ast::FnKind(defaultness, ref fn_sig, ref generics, ref block) = **fn_kind;
+ if let Some(ref body) = block {
+ let mut visitor = FmtVisitor::from_context(context);
+ visitor.block_indent = shape.indent;
+ visitor.last_pos = self.span.lo();
+ let inner_attrs = inner_attributes(&self.attrs);
+ let fn_ctxt = visit::FnCtxt::Foreign;
+ visitor.visit_fn(
+ visit::FnKind::Fn(fn_ctxt, self.ident, &fn_sig, &self.vis, Some(body)),
+ generics,
+ &fn_sig.decl,
+ self.span,
+ defaultness,
+ Some(&inner_attrs),
+ );
+ Some(visitor.buffer.to_owned())
+ } else {
+ rewrite_fn_base(
+ context,
+ shape.indent,
+ self.ident,
- rewrite_type_alias(
- self.ident,
- type_default.as_ref(),
- generics,
- Some(generic_bounds),
++ &FnSig::from_method_sig(&fn_sig, generics, &self.vis),
+ span,
+ FnBraceStyle::None,
+ )
+ .map(|(s, _, _)| format!("{};", s))
+ }
+ }
+ ast::ForeignItemKind::Static(ref ty, mutability, _) => {
+ // FIXME(#21): we're dropping potential comments in between the
+ // function kw here.
+ let vis = format_visibility(context, &self.vis);
+ let mut_str = format_mutability(mutability);
+ let prefix = format!(
+ "{}static {}{}:",
+ vis,
+ mut_str,
+ rewrite_ident(context, self.ident)
+ );
+ // 1 = ;
+ rewrite_assign_rhs(context, prefix, &**ty, shape.sub_width(1)?).map(|s| s + ";")
+ }
+ ast::ForeignItemKind::TyAlias(ref ty_alias_kind) => {
+ let ast::TyAliasKind(_, ref generics, ref generic_bounds, ref type_default) =
+ **ty_alias_kind;
++ rewrite_type(
+ &context,
+ shape.indent,
++ self.ident,
+ &self.vis,
++ generics,
++ Some(generic_bounds),
++ type_default.as_ref(),
+ self.span,
+ )
+ }
+ ast::ForeignItemKind::MacCall(ref mac) => {
+ rewrite_macro(mac, None, context, shape, MacroPosition::Item)
+ }
+ }?;
+
+ let missing_span = if self.attrs.is_empty() {
+ mk_sp(self.span.lo(), self.span.lo())
+ } else {
+ mk_sp(self.attrs[self.attrs.len() - 1].span.hi(), self.span.lo())
+ };
+ combine_strs_with_missing_comments(
+ context,
+ &attrs_str,
+ &item_str,
+ missing_span,
+ shape,
+ false,
+ )
+ }
+}
+
+/// Rewrite the attributes of an item.
+fn rewrite_attrs(
+ context: &RewriteContext<'_>,
+ item: &ast::Item,
+ item_str: &str,
+ shape: Shape,
+) -> Option<String> {
+ let attrs = filter_inline_attrs(&item.attrs, item.span());
+ let attrs_str = attrs.rewrite(context, shape)?;
+
+ let missed_span = if attrs.is_empty() {
+ mk_sp(item.span.lo(), item.span.lo())
+ } else {
+ mk_sp(attrs[attrs.len() - 1].span.hi(), item.span.lo())
+ };
+
+ let allow_extend = if attrs.len() == 1 {
+ let line_len = attrs_str.len() + 1 + item_str.len();
+ !attrs.first().unwrap().is_doc_comment()
+ && context.config.inline_attribute_width() >= line_len
+ } else {
+ false
+ };
+
+ combine_strs_with_missing_comments(
+ context,
+ &attrs_str,
+ &item_str,
+ missed_span,
+ shape,
+ allow_extend,
+ )
+}
+
+/// Rewrite an inline mod.
+/// The given shape is used to format the mod's attributes.
+pub(crate) fn rewrite_mod(
+ context: &RewriteContext<'_>,
+ item: &ast::Item,
+ attrs_shape: Shape,
+) -> Option<String> {
+ let mut result = String::with_capacity(32);
+ result.push_str(&*format_visibility(context, &item.vis));
+ result.push_str("mod ");
+ result.push_str(rewrite_ident(context, item.ident));
+ result.push(';');
+ rewrite_attrs(context, item, &result, attrs_shape)
+}
+
+/// Rewrite `extern crate foo;`.
+/// The given shape is used to format the extern crate's attributes.
+pub(crate) fn rewrite_extern_crate(
+ context: &RewriteContext<'_>,
+ item: &ast::Item,
+ attrs_shape: Shape,
+) -> Option<String> {
+ assert!(is_extern_crate(item));
+ let new_str = context.snippet(item.span);
+ let item_str = if contains_comment(new_str) {
+ new_str.to_owned()
+ } else {
+ let no_whitespace = &new_str.split_whitespace().collect::<Vec<&str>>().join(" ");
+ String::from(&*Regex::new(r"\s;").unwrap().replace(no_whitespace, ";"))
+ };
+ rewrite_attrs(context, item, &item_str, attrs_shape)
+}
+
+/// Returns `true` for `mod foo;`, false for `mod foo { .. }`.
+pub(crate) fn is_mod_decl(item: &ast::Item) -> bool {
+ !matches!(
+ item.kind,
+ ast::ItemKind::Mod(_, ast::ModKind::Loaded(_, ast::Inline::Yes, _))
+ )
+}
+
+pub(crate) fn is_use_item(item: &ast::Item) -> bool {
+ matches!(item.kind, ast::ItemKind::Use(_))
+}
+
+pub(crate) fn is_extern_crate(item: &ast::Item) -> bool {
+ matches!(item.kind, ast::ItemKind::ExternCrate(..))
+}
--- /dev/null
- if tactic == DefinitiveListTactic::Vertical || tactic == DefinitiveListTactic::Mixed
- {
- // We cannot keep pre-comments on the same line if the comment if normalized.
+//! Format list-like expressions and items.
+
+use std::cmp;
+use std::iter::Peekable;
+
+use rustc_span::BytePos;
+
+use crate::comment::{find_comment_end, rewrite_comment, FindUncommented};
+use crate::config::lists::*;
+use crate::config::{Config, IndentStyle};
+use crate::rewrite::RewriteContext;
+use crate::shape::{Indent, Shape};
+use crate::utils::{
+ count_newlines, first_line_width, last_line_width, mk_sp, starts_with_newline,
+ unicode_str_width,
+};
+use crate::visitor::SnippetProvider;
+
+pub(crate) struct ListFormatting<'a> {
+ tactic: DefinitiveListTactic,
+ separator: &'a str,
+ trailing_separator: SeparatorTactic,
+ separator_place: SeparatorPlace,
+ shape: Shape,
+ // Non-expressions, e.g., items, will have a new line at the end of the list.
+ // Important for comment styles.
+ ends_with_newline: bool,
+ // Remove newlines between list elements for expressions.
+ preserve_newline: bool,
+ // Nested import lists get some special handling for the "Mixed" list type
+ nested: bool,
+ // Whether comments should be visually aligned.
+ align_comments: bool,
+ config: &'a Config,
+}
+
+impl<'a> ListFormatting<'a> {
+ pub(crate) fn new(shape: Shape, config: &'a Config) -> Self {
+ ListFormatting {
+ tactic: DefinitiveListTactic::Vertical,
+ separator: ",",
+ trailing_separator: SeparatorTactic::Never,
+ separator_place: SeparatorPlace::Back,
+ shape,
+ ends_with_newline: true,
+ preserve_newline: false,
+ nested: false,
+ align_comments: true,
+ config,
+ }
+ }
+
+ pub(crate) fn tactic(mut self, tactic: DefinitiveListTactic) -> Self {
+ self.tactic = tactic;
+ self
+ }
+
+ pub(crate) fn separator(mut self, separator: &'a str) -> Self {
+ self.separator = separator;
+ self
+ }
+
+ pub(crate) fn trailing_separator(mut self, trailing_separator: SeparatorTactic) -> Self {
+ self.trailing_separator = trailing_separator;
+ self
+ }
+
+ pub(crate) fn separator_place(mut self, separator_place: SeparatorPlace) -> Self {
+ self.separator_place = separator_place;
+ self
+ }
+
+ pub(crate) fn ends_with_newline(mut self, ends_with_newline: bool) -> Self {
+ self.ends_with_newline = ends_with_newline;
+ self
+ }
+
+ pub(crate) fn preserve_newline(mut self, preserve_newline: bool) -> Self {
+ self.preserve_newline = preserve_newline;
+ self
+ }
+
+ pub(crate) fn nested(mut self, nested: bool) -> Self {
+ self.nested = nested;
+ self
+ }
+
+ pub(crate) fn align_comments(mut self, align_comments: bool) -> Self {
+ self.align_comments = align_comments;
+ self
+ }
+
+ pub(crate) fn needs_trailing_separator(&self) -> bool {
+ match self.trailing_separator {
+ // We always put separator in front.
+ SeparatorTactic::Always => true,
+ SeparatorTactic::Vertical => self.tactic == DefinitiveListTactic::Vertical,
+ SeparatorTactic::Never => {
+ self.tactic == DefinitiveListTactic::Vertical && self.separator_place.is_front()
+ }
+ }
+ }
+}
+
+impl AsRef<ListItem> for ListItem {
+ fn as_ref(&self) -> &ListItem {
+ self
+ }
+}
+
+#[derive(PartialEq, Eq, Debug, Copy, Clone)]
+pub(crate) enum ListItemCommentStyle {
+ // Try to keep the comment on the same line with the item.
+ SameLine,
+ // Put the comment on the previous or the next line of the item.
+ DifferentLine,
+ // No comment available.
+ None,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct ListItem {
+ // None for comments mean that they are not present.
+ pub(crate) pre_comment: Option<String>,
+ pub(crate) pre_comment_style: ListItemCommentStyle,
+ // Item should include attributes and doc comments. None indicates a failed
+ // rewrite.
+ pub(crate) item: Option<String>,
+ pub(crate) post_comment: Option<String>,
+ // Whether there is extra whitespace before this item.
+ pub(crate) new_lines: bool,
+}
+
+impl ListItem {
+ pub(crate) fn empty() -> ListItem {
+ ListItem {
+ pre_comment: None,
+ pre_comment_style: ListItemCommentStyle::None,
+ item: None,
+ post_comment: None,
+ new_lines: false,
+ }
+ }
+
+ pub(crate) fn inner_as_ref(&self) -> &str {
+ self.item.as_ref().map_or("", |s| s)
+ }
+
+ pub(crate) fn is_different_group(&self) -> bool {
+ self.inner_as_ref().contains('\n')
+ || self.pre_comment.is_some()
+ || self
+ .post_comment
+ .as_ref()
+ .map_or(false, |s| s.contains('\n'))
+ }
+
+ pub(crate) fn is_multiline(&self) -> bool {
+ self.inner_as_ref().contains('\n')
+ || self
+ .pre_comment
+ .as_ref()
+ .map_or(false, |s| s.contains('\n'))
+ || self
+ .post_comment
+ .as_ref()
+ .map_or(false, |s| s.contains('\n'))
+ }
+
+ pub(crate) fn has_single_line_comment(&self) -> bool {
+ self.pre_comment
+ .as_ref()
+ .map_or(false, |comment| comment.trim_start().starts_with("//"))
+ || self
+ .post_comment
+ .as_ref()
+ .map_or(false, |comment| comment.trim_start().starts_with("//"))
+ }
+
+ pub(crate) fn has_comment(&self) -> bool {
+ self.pre_comment.is_some() || self.post_comment.is_some()
+ }
+
+ pub(crate) fn from_str<S: Into<String>>(s: S) -> ListItem {
+ ListItem {
+ pre_comment: None,
+ pre_comment_style: ListItemCommentStyle::None,
+ item: Some(s.into()),
+ post_comment: None,
+ new_lines: false,
+ }
+ }
+
+ // Returns `true` if the item causes something to be written.
+ fn is_substantial(&self) -> bool {
+ fn empty(s: &Option<String>) -> bool {
+ !matches!(*s, Some(ref s) if !s.is_empty())
+ }
+
+ !(empty(&self.pre_comment) && empty(&self.item) && empty(&self.post_comment))
+ }
+}
+
+/// The type of separator for lists.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub(crate) enum Separator {
+ Comma,
+ VerticalBar,
+}
+
+impl Separator {
+ pub(crate) fn len(self) -> usize {
+ match self {
+ // 2 = `, `
+ Separator::Comma => 2,
+ // 3 = ` | `
+ Separator::VerticalBar => 3,
+ }
+ }
+}
+
+pub(crate) fn definitive_tactic<I, T>(
+ items: I,
+ tactic: ListTactic,
+ sep: Separator,
+ width: usize,
+) -> DefinitiveListTactic
+where
+ I: IntoIterator<Item = T> + Clone,
+ T: AsRef<ListItem>,
+{
+ let pre_line_comments = items
+ .clone()
+ .into_iter()
+ .any(|item| item.as_ref().has_single_line_comment());
+
+ let limit = match tactic {
+ _ if pre_line_comments => return DefinitiveListTactic::Vertical,
+ ListTactic::Horizontal => return DefinitiveListTactic::Horizontal,
+ ListTactic::Vertical => return DefinitiveListTactic::Vertical,
+ ListTactic::LimitedHorizontalVertical(limit) => ::std::cmp::min(width, limit),
+ ListTactic::Mixed | ListTactic::HorizontalVertical => width,
+ };
+
+ let (sep_count, total_width) = calculate_width(items.clone());
+ let total_sep_len = sep.len() * sep_count.saturating_sub(1);
+ let real_total = total_width + total_sep_len;
+
+ if real_total <= limit && !items.into_iter().any(|item| item.as_ref().is_multiline()) {
+ DefinitiveListTactic::Horizontal
+ } else {
+ match tactic {
+ ListTactic::Mixed => DefinitiveListTactic::Mixed,
+ _ => DefinitiveListTactic::Vertical,
+ }
+ }
+}
+
+// Format a list of commented items into a string.
+pub(crate) fn write_list<I, T>(items: I, formatting: &ListFormatting<'_>) -> Option<String>
+where
+ I: IntoIterator<Item = T> + Clone,
+ T: AsRef<ListItem>,
+{
+ let tactic = formatting.tactic;
+ let sep_len = formatting.separator.len();
+
+ // Now that we know how we will layout, we can decide for sure if there
+ // will be a trailing separator.
+ let mut trailing_separator = formatting.needs_trailing_separator();
+ let mut result = String::with_capacity(128);
+ let cloned_items = items.clone();
+ let mut iter = items.into_iter().enumerate().peekable();
+ let mut item_max_width: Option<usize> = None;
+ let sep_place =
+ SeparatorPlace::from_tactic(formatting.separator_place, tactic, formatting.separator);
+ let mut prev_item_had_post_comment = false;
+ let mut prev_item_is_nested_import = false;
+
+ let mut line_len = 0;
+ let indent_str = &formatting.shape.indent.to_string(formatting.config);
+ while let Some((i, item)) = iter.next() {
+ let item = item.as_ref();
+ let inner_item = item.item.as_ref()?;
+ let first = i == 0;
+ let last = iter.peek().is_none();
+ let mut separate = match sep_place {
+ SeparatorPlace::Front => !first,
+ SeparatorPlace::Back => !last || trailing_separator,
+ };
+ let item_sep_len = if separate { sep_len } else { 0 };
+
+ // Item string may be multi-line. Its length (used for block comment alignment)
+ // should be only the length of the last line.
+ let item_last_line = if item.is_multiline() {
+ inner_item.lines().last().unwrap_or("")
+ } else {
+ inner_item.as_ref()
+ };
+ let mut item_last_line_width = item_last_line.len() + item_sep_len;
+ if item_last_line.starts_with(&**indent_str) {
+ item_last_line_width -= indent_str.len();
+ }
+
+ if !item.is_substantial() {
+ continue;
+ }
+
+ match tactic {
+ DefinitiveListTactic::Horizontal if !first => {
+ result.push(' ');
+ }
+ DefinitiveListTactic::SpecialMacro(num_args_before) => {
+ if i == 0 {
+ // Nothing
+ } else if i < num_args_before {
+ result.push(' ');
+ } else if i <= num_args_before + 1 {
+ result.push('\n');
+ result.push_str(indent_str);
+ } else {
+ result.push(' ');
+ }
+ }
+ DefinitiveListTactic::Vertical
+ if !first && !inner_item.is_empty() && !result.is_empty() =>
+ {
+ result.push('\n');
+ result.push_str(indent_str);
+ }
+ DefinitiveListTactic::Mixed => {
+ let total_width = total_item_width(item) + item_sep_len;
+
+ // 1 is space between separator and item.
+ if (line_len > 0 && line_len + 1 + total_width > formatting.shape.width)
+ || prev_item_had_post_comment
+ || (formatting.nested
+ && (prev_item_is_nested_import || (!first && inner_item.contains("::"))))
+ {
+ result.push('\n');
+ result.push_str(indent_str);
+ line_len = 0;
+ if formatting.ends_with_newline {
+ trailing_separator = true;
+ }
+ } else if line_len > 0 {
+ result.push(' ');
+ line_len += 1;
+ }
+
+ if last && formatting.ends_with_newline {
+ separate = formatting.trailing_separator != SeparatorTactic::Never;
+ }
+
+ line_len += total_width;
+ }
+ _ => {}
+ }
+
+ // Pre-comments
+ if let Some(ref comment) = item.pre_comment {
+ // Block style in non-vertical mode.
+ let block_mode = tactic == DefinitiveListTactic::Horizontal;
+ // Width restriction is only relevant in vertical mode.
+ let comment =
+ rewrite_comment(comment, block_mode, formatting.shape, formatting.config)?;
+ result.push_str(&comment);
+
+ if !inner_item.is_empty() {
- result.push(' ');
++ use DefinitiveListTactic::*;
++ if matches!(tactic, Vertical | Mixed | SpecialMacro(_)) {
++ // We cannot keep pre-comments on the same line if the comment is normalized.
+ let keep_comment = if formatting.config.normalize_comments()
+ || item.pre_comment_style == ListItemCommentStyle::DifferentLine
+ {
+ false
+ } else {
+ // We will try to keep the comment on the same line with the item here.
+ // 1 = ` `
+ let total_width = total_item_width(item) + item_sep_len + 1;
+ total_width <= formatting.shape.width
+ };
+ if keep_comment {
+ result.push(' ');
+ } else {
+ result.push('\n');
+ result.push_str(indent_str);
+ // This is the width of the item (without comments).
+ line_len = item.item.as_ref().map_or(0, |s| unicode_str_width(&s));
+ }
+ } else {
++ result.push(' ')
+ }
+ }
+ item_max_width = None;
+ }
+
+ if separate && sep_place.is_front() && !first {
+ result.push_str(formatting.separator.trim());
+ result.push(' ');
+ }
+ result.push_str(inner_item);
+
+ // Post-comments
+ if tactic == DefinitiveListTactic::Horizontal && item.post_comment.is_some() {
+ let comment = item.post_comment.as_ref().unwrap();
+ let formatted_comment = rewrite_comment(
+ comment,
+ true,
+ Shape::legacy(formatting.shape.width, Indent::empty()),
+ formatting.config,
+ )?;
+
+ result.push(' ');
+ result.push_str(&formatted_comment);
+ }
+
+ if separate && sep_place.is_back() {
+ result.push_str(formatting.separator);
+ }
+
+ if tactic != DefinitiveListTactic::Horizontal && item.post_comment.is_some() {
+ let comment = item.post_comment.as_ref().unwrap();
+ let overhead = last_line_width(&result) + first_line_width(comment.trim());
+
+ let rewrite_post_comment = |item_max_width: &mut Option<usize>| {
+ if item_max_width.is_none() && !last && !inner_item.contains('\n') {
+ *item_max_width = Some(max_width_of_item_with_post_comment(
+ &cloned_items,
+ i,
+ overhead,
+ formatting.config.max_width(),
+ ));
+ }
+ let overhead = if starts_with_newline(comment) {
+ 0
+ } else if let Some(max_width) = *item_max_width {
+ max_width + 2
+ } else {
+ // 1 = space between item and comment.
+ item_last_line_width + 1
+ };
+ let width = formatting.shape.width.checked_sub(overhead).unwrap_or(1);
+ let offset = formatting.shape.indent + overhead;
+ let comment_shape = Shape::legacy(width, offset);
+
+ // Use block-style only for the last item or multiline comments.
+ let block_style = !formatting.ends_with_newline && last
+ || comment.trim().contains('\n')
+ || comment.trim().len() > width;
+
+ rewrite_comment(
+ comment.trim_start(),
+ block_style,
+ comment_shape,
+ formatting.config,
+ )
+ };
+
+ let mut formatted_comment = rewrite_post_comment(&mut item_max_width)?;
+
+ if !starts_with_newline(comment) {
+ if formatting.align_comments {
+ let mut comment_alignment =
+ post_comment_alignment(item_max_width, inner_item.len());
+ if first_line_width(&formatted_comment)
+ + last_line_width(&result)
+ + comment_alignment
+ + 1
+ > formatting.config.max_width()
+ {
+ item_max_width = None;
+ formatted_comment = rewrite_post_comment(&mut item_max_width)?;
+ comment_alignment =
+ post_comment_alignment(item_max_width, inner_item.len());
+ }
+ for _ in 0..=comment_alignment {
+ result.push(' ');
+ }
+ }
+ // An additional space for the missing trailing separator (or
+ // if we skipped alignment above).
+ if !formatting.align_comments
+ || (last
+ && item_max_width.is_some()
+ && !separate
+ && !formatting.separator.is_empty())
+ {
+ result.push(' ');
+ }
+ } else {
+ result.push('\n');
+ result.push_str(indent_str);
+ }
+ if formatted_comment.contains('\n') {
+ item_max_width = None;
+ }
+ result.push_str(&formatted_comment);
+ } else {
+ item_max_width = None;
+ }
+
+ if formatting.preserve_newline
+ && !last
+ && tactic == DefinitiveListTactic::Vertical
+ && item.new_lines
+ {
+ item_max_width = None;
+ result.push('\n');
+ }
+
+ prev_item_had_post_comment = item.post_comment.is_some();
+ prev_item_is_nested_import = inner_item.contains("::");
+ }
+
+ Some(result)
+}
+
+fn max_width_of_item_with_post_comment<I, T>(
+ items: &I,
+ i: usize,
+ overhead: usize,
+ max_budget: usize,
+) -> usize
+where
+ I: IntoIterator<Item = T> + Clone,
+ T: AsRef<ListItem>,
+{
+ let mut max_width = 0;
+ let mut first = true;
+ for item in items.clone().into_iter().skip(i) {
+ let item = item.as_ref();
+ let inner_item_width = item.inner_as_ref().len();
+ if !first
+ && (item.is_different_group()
+ || item.post_comment.is_none()
+ || inner_item_width + overhead > max_budget)
+ {
+ return max_width;
+ }
+ if max_width < inner_item_width {
+ max_width = inner_item_width;
+ }
+ if item.new_lines {
+ return max_width;
+ }
+ first = false;
+ }
+ max_width
+}
+
+fn post_comment_alignment(item_max_width: Option<usize>, inner_item_len: usize) -> usize {
+ item_max_width.unwrap_or(0).saturating_sub(inner_item_len)
+}
+
+pub(crate) struct ListItems<'a, I, F1, F2, F3>
+where
+ I: Iterator,
+{
+ snippet_provider: &'a SnippetProvider,
+ inner: Peekable<I>,
+ get_lo: F1,
+ get_hi: F2,
+ get_item_string: F3,
+ prev_span_end: BytePos,
+ next_span_start: BytePos,
+ terminator: &'a str,
+ separator: &'a str,
+ leave_last: bool,
+}
+
+pub(crate) fn extract_pre_comment(pre_snippet: &str) -> (Option<String>, ListItemCommentStyle) {
+ let trimmed_pre_snippet = pre_snippet.trim();
+ // Both start and end are checked to support keeping a block comment inline with
+ // the item, even if there are preceeding line comments, while still supporting
+ // a snippet that starts with a block comment but also contains one or more
+ // trailing single line comments.
+ // https://github.com/rust-lang/rustfmt/issues/3025
+ // https://github.com/rust-lang/rustfmt/pull/3048
+ // https://github.com/rust-lang/rustfmt/issues/3839
+ let starts_with_block_comment = trimmed_pre_snippet.starts_with("/*");
+ let ends_with_block_comment = trimmed_pre_snippet.ends_with("*/");
+ let starts_with_single_line_comment = trimmed_pre_snippet.starts_with("//");
+ if ends_with_block_comment {
+ let comment_end = pre_snippet.rfind(|c| c == '/').unwrap();
+ if pre_snippet[comment_end..].contains('\n') {
+ (
+ Some(trimmed_pre_snippet.to_owned()),
+ ListItemCommentStyle::DifferentLine,
+ )
+ } else {
+ (
+ Some(trimmed_pre_snippet.to_owned()),
+ ListItemCommentStyle::SameLine,
+ )
+ }
+ } else if starts_with_single_line_comment || starts_with_block_comment {
+ (
+ Some(trimmed_pre_snippet.to_owned()),
+ ListItemCommentStyle::DifferentLine,
+ )
+ } else {
+ (None, ListItemCommentStyle::None)
+ }
+}
+
+pub(crate) fn extract_post_comment(
+ post_snippet: &str,
+ comment_end: usize,
+ separator: &str,
+) -> Option<String> {
+ let white_space: &[_] = &[' ', '\t'];
+
+ // Cleanup post-comment: strip separators and whitespace.
+ let post_snippet = post_snippet[..comment_end].trim();
+ let post_snippet_trimmed = if post_snippet.starts_with(|c| c == ',' || c == ':') {
+ post_snippet[1..].trim_matches(white_space)
+ } else if let Some(stripped) = post_snippet.strip_prefix(separator) {
+ stripped.trim_matches(white_space)
+ }
+ // not comment or over two lines
+ else if post_snippet.ends_with(',')
+ && (!post_snippet.trim().starts_with("//") || post_snippet.trim().contains('\n'))
+ {
+ post_snippet[..(post_snippet.len() - 1)].trim_matches(white_space)
+ } else {
+ post_snippet
+ };
+ // FIXME(#3441): post_snippet includes 'const' now
+ // it should not include here
+ let removed_newline_snippet = post_snippet_trimmed.trim();
+ if !post_snippet_trimmed.is_empty()
+ && (removed_newline_snippet.starts_with("//") || removed_newline_snippet.starts_with("/*"))
+ {
+ Some(post_snippet_trimmed.to_owned())
+ } else {
+ None
+ }
+}
+
+pub(crate) fn get_comment_end(
+ post_snippet: &str,
+ separator: &str,
+ terminator: &str,
+ is_last: bool,
+) -> usize {
+ if is_last {
+ return post_snippet
+ .find_uncommented(terminator)
+ .unwrap_or_else(|| post_snippet.len());
+ }
+
+ let mut block_open_index = post_snippet.find("/*");
+ // check if it really is a block comment (and not `//*` or a nested comment)
+ if let Some(i) = block_open_index {
+ match post_snippet.find('/') {
+ Some(j) if j < i => block_open_index = None,
+ _ if post_snippet[..i].ends_with('/') => block_open_index = None,
+ _ => (),
+ }
+ }
+ let newline_index = post_snippet.find('\n');
+ if let Some(separator_index) = post_snippet.find_uncommented(separator) {
+ match (block_open_index, newline_index) {
+ // Separator before comment, with the next item on same line.
+ // Comment belongs to next item.
+ (Some(i), None) if i > separator_index => separator_index + 1,
+ // Block-style post-comment before the separator.
+ (Some(i), None) => cmp::max(
+ find_comment_end(&post_snippet[i..]).unwrap() + i,
+ separator_index + 1,
+ ),
+ // Block-style post-comment. Either before or after the separator.
+ (Some(i), Some(j)) if i < j => cmp::max(
+ find_comment_end(&post_snippet[i..]).unwrap() + i,
+ separator_index + 1,
+ ),
+ // Potential *single* line comment.
+ (_, Some(j)) if j > separator_index => j + 1,
+ _ => post_snippet.len(),
+ }
+ } else if let Some(newline_index) = newline_index {
+ // Match arms may not have trailing comma. In any case, for match arms,
+ // we will assume that the post comment belongs to the next arm if they
+ // do not end with trailing comma.
+ newline_index + 1
+ } else {
+ 0
+ }
+}
+
+// Account for extra whitespace between items. This is fiddly
+// because of the way we divide pre- and post- comments.
+pub(crate) fn has_extra_newline(post_snippet: &str, comment_end: usize) -> bool {
+ if post_snippet.is_empty() || comment_end == 0 {
+ return false;
+ }
+
+ let len_last = post_snippet[..comment_end]
+ .chars()
+ .last()
+ .unwrap()
+ .len_utf8();
+ // Everything from the separator to the next item.
+ let test_snippet = &post_snippet[comment_end - len_last..];
+ let first_newline = test_snippet
+ .find('\n')
+ .unwrap_or_else(|| test_snippet.len());
+ // From the end of the first line of comments.
+ let test_snippet = &test_snippet[first_newline..];
+ let first = test_snippet
+ .find(|c: char| !c.is_whitespace())
+ .unwrap_or_else(|| test_snippet.len());
+ // From the end of the first line of comments to the next non-whitespace char.
+ let test_snippet = &test_snippet[..first];
+
+ // There were multiple line breaks which got trimmed to nothing.
+ count_newlines(test_snippet) > 1
+}
+
+impl<'a, T, I, F1, F2, F3> Iterator for ListItems<'a, I, F1, F2, F3>
+where
+ I: Iterator<Item = T>,
+ F1: Fn(&T) -> BytePos,
+ F2: Fn(&T) -> BytePos,
+ F3: Fn(&T) -> Option<String>,
+{
+ type Item = ListItem;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.inner.next().map(|item| {
+ // Pre-comment
+ let pre_snippet = self
+ .snippet_provider
+ .span_to_snippet(mk_sp(self.prev_span_end, (self.get_lo)(&item)))
+ .unwrap_or("");
+ let (pre_comment, pre_comment_style) = extract_pre_comment(pre_snippet);
+
+ // Post-comment
+ let next_start = match self.inner.peek() {
+ Some(next_item) => (self.get_lo)(next_item),
+ None => self.next_span_start,
+ };
+ let post_snippet = self
+ .snippet_provider
+ .span_to_snippet(mk_sp((self.get_hi)(&item), next_start))
+ .unwrap_or("");
+ let comment_end = get_comment_end(
+ post_snippet,
+ self.separator,
+ self.terminator,
+ self.inner.peek().is_none(),
+ );
+ let new_lines = has_extra_newline(post_snippet, comment_end);
+ let post_comment = extract_post_comment(post_snippet, comment_end, self.separator);
+
+ self.prev_span_end = (self.get_hi)(&item) + BytePos(comment_end as u32);
+
+ ListItem {
+ pre_comment,
+ pre_comment_style,
+ item: if self.inner.peek().is_none() && self.leave_last {
+ None
+ } else {
+ (self.get_item_string)(&item)
+ },
+ post_comment,
+ new_lines,
+ }
+ })
+ }
+}
+
+#[allow(clippy::too_many_arguments)]
+// Creates an iterator over a list's items with associated comments.
+pub(crate) fn itemize_list<'a, T, I, F1, F2, F3>(
+ snippet_provider: &'a SnippetProvider,
+ inner: I,
+ terminator: &'a str,
+ separator: &'a str,
+ get_lo: F1,
+ get_hi: F2,
+ get_item_string: F3,
+ prev_span_end: BytePos,
+ next_span_start: BytePos,
+ leave_last: bool,
+) -> ListItems<'a, I, F1, F2, F3>
+where
+ I: Iterator<Item = T>,
+ F1: Fn(&T) -> BytePos,
+ F2: Fn(&T) -> BytePos,
+ F3: Fn(&T) -> Option<String>,
+{
+ ListItems {
+ snippet_provider,
+ inner: inner.peekable(),
+ get_lo,
+ get_hi,
+ get_item_string,
+ prev_span_end,
+ next_span_start,
+ terminator,
+ separator,
+ leave_last,
+ }
+}
+
+/// Returns the count and total width of the list items.
+fn calculate_width<I, T>(items: I) -> (usize, usize)
+where
+ I: IntoIterator<Item = T>,
+ T: AsRef<ListItem>,
+{
+ items
+ .into_iter()
+ .map(|item| total_item_width(item.as_ref()))
+ .fold((0, 0), |acc, l| (acc.0 + 1, acc.1 + l))
+}
+
+pub(crate) fn total_item_width(item: &ListItem) -> usize {
+ comment_len(item.pre_comment.as_ref().map(|x| &(*x)[..]))
+ + comment_len(item.post_comment.as_ref().map(|x| &(*x)[..]))
+ + item.item.as_ref().map_or(0, |s| unicode_str_width(&s))
+}
+
+fn comment_len(comment: Option<&str>) -> usize {
+ match comment {
+ Some(s) => {
+ let text_len = s.trim().len();
+ if text_len > 0 {
+ // We'll put " /*" before and " */" after inline comments.
+ text_len + 6
+ } else {
+ text_len
+ }
+ }
+ None => 0,
+ }
+}
+
+// Compute horizontal and vertical shapes for a struct-lit-like thing.
+pub(crate) fn struct_lit_shape(
+ shape: Shape,
+ context: &RewriteContext<'_>,
+ prefix_width: usize,
+ suffix_width: usize,
+) -> Option<(Option<Shape>, Shape)> {
+ let v_shape = match context.config.indent_style() {
+ IndentStyle::Visual => shape
+ .visual_indent(0)
+ .shrink_left(prefix_width)?
+ .sub_width(suffix_width)?,
+ IndentStyle::Block => {
+ let shape = shape.block_indent(context.config.tab_spaces());
+ Shape {
+ width: context.budget(shape.indent.width()),
+ ..shape
+ }
+ }
+ };
+ let shape_width = shape.width.checked_sub(prefix_width + suffix_width);
+ if let Some(w) = shape_width {
+ let shape_width = cmp::min(w, context.config.struct_lit_width());
+ Some((Some(Shape::legacy(shape_width, shape.indent)), v_shape))
+ } else {
+ Some((None, v_shape))
+ }
+}
+
+// Compute the tactic for the internals of a struct-lit-like thing.
+pub(crate) fn struct_lit_tactic(
+ h_shape: Option<Shape>,
+ context: &RewriteContext<'_>,
+ items: &[ListItem],
+) -> DefinitiveListTactic {
+ if let Some(h_shape) = h_shape {
+ let prelim_tactic = match (context.config.indent_style(), items.len()) {
+ (IndentStyle::Visual, 1) => ListTactic::HorizontalVertical,
+ _ if context.config.struct_lit_single_line() => ListTactic::HorizontalVertical,
+ _ => ListTactic::Vertical,
+ };
+ definitive_tactic(items, prelim_tactic, Separator::Comma, h_shape.width)
+ } else {
+ DefinitiveListTactic::Vertical
+ }
+}
+
+// Given a tactic and possible shapes for horizontal and vertical layout,
+// come up with the actual shape to use.
+pub(crate) fn shape_for_tactic(
+ tactic: DefinitiveListTactic,
+ h_shape: Option<Shape>,
+ v_shape: Shape,
+) -> Shape {
+ match tactic {
+ DefinitiveListTactic::Horizontal => h_shape.unwrap(),
+ _ => v_shape,
+ }
+}
+
+// Create a ListFormatting object for formatting the internals of a
+// struct-lit-like thing, that is a series of fields.
+pub(crate) fn struct_lit_formatting<'a>(
+ shape: Shape,
+ tactic: DefinitiveListTactic,
+ context: &'a RewriteContext<'_>,
+ force_no_trailing_comma: bool,
+) -> ListFormatting<'a> {
+ let ends_with_newline = context.config.indent_style() != IndentStyle::Visual
+ && tactic == DefinitiveListTactic::Vertical;
+ ListFormatting {
+ tactic,
+ separator: ",",
+ trailing_separator: if force_no_trailing_comma {
+ SeparatorTactic::Never
+ } else {
+ context.config.trailing_comma()
+ },
+ separator_place: SeparatorPlace::Back,
+ shape,
+ ends_with_newline,
+ preserve_newline: true,
+ nested: false,
+ align_comments: true,
+ config: context.config,
+ }
+}
--- /dev/null
+//! Format match expression.
+
+use std::iter::repeat;
+
+use rustc_ast::{ast, ptr};
+use rustc_span::{BytePos, Span};
+
+use crate::comment::{combine_strs_with_missing_comments, rewrite_comment};
+use crate::config::lists::*;
+use crate::config::{Config, ControlBraceStyle, IndentStyle, MatchArmLeadingPipe, Version};
+use crate::expr::{
+ format_expr, is_empty_block, is_simple_block, is_unsafe_block, prefer_next_line, rewrite_cond,
+ ExprType, RhsTactics,
+};
+use crate::lists::{itemize_list, write_list, ListFormatting};
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::Shape;
+use crate::source_map::SpanUtils;
+use crate::spanned::Spanned;
+use crate::utils::{
+ contains_skip, extra_offset, first_line_width, inner_attributes, last_line_extendable, mk_sp,
+ semicolon_for_expr, trimmed_last_line_width, unicode_str_width,
+};
+
+/// A simple wrapper type against `ast::Arm`. Used inside `write_list()`.
+struct ArmWrapper<'a> {
+ arm: &'a ast::Arm,
+ /// `true` if the arm is the last one in match expression. Used to decide on whether we should
+ /// add trailing comma to the match arm when `config.trailing_comma() == Never`.
+ is_last: bool,
+ /// Holds a byte position of `|` at the beginning of the arm pattern, if available.
+ beginning_vert: Option<BytePos>,
+}
+
+impl<'a> ArmWrapper<'a> {
+ fn new(arm: &'a ast::Arm, is_last: bool, beginning_vert: Option<BytePos>) -> ArmWrapper<'a> {
+ ArmWrapper {
+ arm,
+ is_last,
+ beginning_vert,
+ }
+ }
+}
+
+impl<'a> Spanned for ArmWrapper<'a> {
+ fn span(&self) -> Span {
+ if let Some(lo) = self.beginning_vert {
+ let lo = std::cmp::min(lo, self.arm.span().lo());
+ mk_sp(lo, self.arm.span().hi())
+ } else {
+ self.arm.span()
+ }
+ }
+}
+
+impl<'a> Rewrite for ArmWrapper<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ rewrite_match_arm(
+ context,
+ self.arm,
+ shape,
+ self.is_last,
+ self.beginning_vert.is_some(),
+ )
+ }
+}
+
+pub(crate) fn rewrite_match(
+ context: &RewriteContext<'_>,
+ cond: &ast::Expr,
+ arms: &[ast::Arm],
+ shape: Shape,
+ span: Span,
+ attrs: &[ast::Attribute],
+) -> Option<String> {
+ // Do not take the rhs overhead from the upper expressions into account
+ // when rewriting match condition.
+ let cond_shape = Shape {
+ width: context.budget(shape.used_width()),
+ ..shape
+ };
+ // 6 = `match `
+ let cond_shape = match context.config.indent_style() {
+ IndentStyle::Visual => cond_shape.shrink_left(6)?,
+ IndentStyle::Block => cond_shape.offset_left(6)?,
+ };
+ let cond_str = cond.rewrite(context, cond_shape)?;
+ let alt_block_sep = &shape.indent.to_string_with_newline(context.config);
+ let block_sep = match context.config.control_brace_style() {
+ ControlBraceStyle::AlwaysNextLine => alt_block_sep,
+ _ if last_line_extendable(&cond_str) => " ",
+ // 2 = ` {`
+ _ if cond_str.contains('\n') || cond_str.len() + 2 > cond_shape.width => alt_block_sep,
+ _ => " ",
+ };
+
+ let nested_indent_str = shape
+ .indent
+ .block_indent(context.config)
+ .to_string(context.config);
+ // Inner attributes.
+ let inner_attrs = &inner_attributes(attrs);
+ let inner_attrs_str = if inner_attrs.is_empty() {
+ String::new()
+ } else {
+ inner_attrs
+ .rewrite(context, shape)
+ .map(|s| format!("{}{}\n", nested_indent_str, s))?
+ };
+
+ let open_brace_pos = if inner_attrs.is_empty() {
+ let hi = if arms.is_empty() {
+ span.hi()
+ } else {
+ arms[0].span().lo()
+ };
+ context
+ .snippet_provider
+ .span_after(mk_sp(cond.span.hi(), hi), "{")
+ } else {
+ inner_attrs[inner_attrs.len() - 1].span.hi()
+ };
+
+ if arms.is_empty() {
+ let snippet = context.snippet(mk_sp(open_brace_pos, span.hi() - BytePos(1)));
+ if snippet.trim().is_empty() {
+ Some(format!("match {} {{}}", cond_str))
+ } else {
+ // Empty match with comments or inner attributes? We are not going to bother, sorry ;)
+ Some(context.snippet(span).to_owned())
+ }
+ } else {
+ let span_after_cond = mk_sp(cond.span.hi(), span.hi());
+ Some(format!(
+ "match {}{}{{\n{}{}{}\n{}}}",
+ cond_str,
+ block_sep,
+ inner_attrs_str,
+ nested_indent_str,
+ rewrite_match_arms(context, arms, shape, span_after_cond, open_brace_pos)?,
+ shape.indent.to_string(context.config),
+ ))
+ }
+}
+
+fn arm_comma(config: &Config, body: &ast::Expr, is_last: bool) -> &'static str {
+ if is_last && config.trailing_comma() == SeparatorTactic::Never {
+ ""
+ } else if config.match_block_trailing_comma() {
+ ","
+ } else if let ast::ExprKind::Block(ref block, _) = body.kind {
+ if let ast::BlockCheckMode::Default = block.rules {
+ ""
+ } else {
+ ","
+ }
+ } else {
+ ","
+ }
+}
+
+/// Collect a byte position of the beginning `|` for each arm, if available.
+fn collect_beginning_verts(
+ context: &RewriteContext<'_>,
+ arms: &[ast::Arm],
+) -> Vec<Option<BytePos>> {
+ arms.iter()
+ .map(|a| {
+ context
+ .snippet(a.pat.span)
+ .starts_with("|")
+ .then(|| a.pat.span().lo())
+ })
+ .collect()
+}
+
+fn rewrite_match_arms(
+ context: &RewriteContext<'_>,
+ arms: &[ast::Arm],
+ shape: Shape,
+ span: Span,
+ open_brace_pos: BytePos,
+) -> Option<String> {
+ let arm_shape = shape
+ .block_indent(context.config.tab_spaces())
+ .with_max_width(context.config);
+
+ let arm_len = arms.len();
+ let is_last_iter = repeat(false)
+ .take(arm_len.saturating_sub(1))
+ .chain(repeat(true));
+ let beginning_verts = collect_beginning_verts(context, arms);
+ let items = itemize_list(
+ context.snippet_provider,
+ arms.iter()
+ .zip(is_last_iter)
+ .zip(beginning_verts.into_iter())
+ .map(|((arm, is_last), beginning_vert)| ArmWrapper::new(arm, is_last, beginning_vert)),
+ "}",
+ "|",
+ |arm| arm.span().lo(),
+ |arm| arm.span().hi(),
+ |arm| arm.rewrite(context, arm_shape),
+ open_brace_pos,
+ span.hi(),
+ false,
+ );
+ let arms_vec: Vec<_> = items.collect();
+ // We will add/remove commas inside `arm.rewrite()`, and hence no separator here.
+ let fmt = ListFormatting::new(arm_shape, context.config)
+ .separator("")
+ .preserve_newline(true);
+
+ write_list(&arms_vec, &fmt)
+}
+
+fn rewrite_match_arm(
+ context: &RewriteContext<'_>,
+ arm: &ast::Arm,
+ shape: Shape,
+ is_last: bool,
+ has_leading_pipe: bool,
+) -> Option<String> {
+ let (missing_span, attrs_str) = if !arm.attrs.is_empty() {
+ if contains_skip(&arm.attrs) {
+ let (_, body) = flatten_arm_body(context, &arm.body, None);
+ // `arm.span()` does not include trailing comma, add it manually.
+ return Some(format!(
+ "{}{}",
+ context.snippet(arm.span()),
+ arm_comma(context.config, body, is_last),
+ ));
+ }
+ let missing_span = mk_sp(arm.attrs[arm.attrs.len() - 1].span.hi(), arm.pat.span.lo());
+ (missing_span, arm.attrs.rewrite(context, shape)?)
+ } else {
+ (mk_sp(arm.span().lo(), arm.span().lo()), String::new())
+ };
+
+ // Leading pipe offset
+ // 2 = `| `
+ let (pipe_offset, pipe_str) = match context.config.match_arm_leading_pipes() {
+ MatchArmLeadingPipe::Never => (0, ""),
+ MatchArmLeadingPipe::Preserve if !has_leading_pipe => (0, ""),
+ MatchArmLeadingPipe::Preserve | MatchArmLeadingPipe::Always => (2, "| "),
+ };
+
+ // Patterns
+ // 5 = ` => {`
+ let pat_shape = shape.sub_width(5)?.offset_left(pipe_offset)?;
+ let pats_str = arm.pat.rewrite(context, pat_shape)?;
+
+ // Guard
+ let block_like_pat = trimmed_last_line_width(&pats_str) <= context.config.tab_spaces();
+ let new_line_guard = pats_str.contains('\n') && !block_like_pat;
+ let guard_str = rewrite_guard(
+ context,
+ &arm.guard,
+ shape,
+ trimmed_last_line_width(&pats_str),
+ new_line_guard,
+ )?;
+
+ let lhs_str = combine_strs_with_missing_comments(
+ context,
+ &attrs_str,
+ &format!("{}{}{}", pipe_str, pats_str, guard_str),
+ missing_span,
+ shape,
+ false,
+ )?;
+
+ let arrow_span = mk_sp(arm.pat.span.hi(), arm.body.span().lo());
+ rewrite_match_body(
+ context,
+ &arm.body,
+ &lhs_str,
+ shape,
+ guard_str.contains('\n'),
+ arrow_span,
+ is_last,
+ )
+}
+
+fn stmt_is_expr_mac(stmt: &ast::Stmt) -> bool {
+ if let ast::StmtKind::Expr(expr) = &stmt.kind {
+ if let ast::ExprKind::MacCall(_) = &expr.kind {
+ return true;
+ }
+ }
+ false
+}
+
+fn block_can_be_flattened<'a>(
+ context: &RewriteContext<'_>,
+ expr: &'a ast::Expr,
+) -> Option<&'a ast::Block> {
+ match expr.kind {
+ ast::ExprKind::Block(ref block, _)
+ if !is_unsafe_block(block)
+ && !context.inside_macro()
+ && is_simple_block(context, block, Some(&expr.attrs))
+ && !stmt_is_expr_mac(&block.stmts[0]) =>
+ {
+ Some(&*block)
+ }
+ _ => None,
+ }
+}
+
+// (extend, body)
+// @extend: true if the arm body can be put next to `=>`
+// @body: flattened body, if the body is block with a single expression
+fn flatten_arm_body<'a>(
+ context: &'a RewriteContext<'_>,
+ body: &'a ast::Expr,
+ opt_shape: Option<Shape>,
+) -> (bool, &'a ast::Expr) {
+ let can_extend =
+ |expr| !context.config.force_multiline_blocks() && can_flatten_block_around_this(expr);
+
+ if let Some(ref block) = block_can_be_flattened(context, body) {
+ if let ast::StmtKind::Expr(ref expr) = block.stmts[0].kind {
+ if let ast::ExprKind::Block(..) = expr.kind {
+ flatten_arm_body(context, expr, None)
+ } else {
+ let cond_becomes_muti_line = opt_shape
+ .and_then(|shape| rewrite_cond(context, expr, shape))
+ .map_or(false, |cond| cond.contains('\n'));
+ if cond_becomes_muti_line {
+ (false, &*body)
+ } else {
+ (can_extend(expr), &*expr)
+ }
+ }
+ } else {
+ (false, &*body)
+ }
+ } else {
+ (can_extend(body), &*body)
+ }
+}
+
+fn rewrite_match_body(
+ context: &RewriteContext<'_>,
+ body: &ptr::P<ast::Expr>,
+ pats_str: &str,
+ shape: Shape,
+ has_guard: bool,
+ arrow_span: Span,
+ is_last: bool,
+) -> Option<String> {
+ let (extend, body) = flatten_arm_body(
+ context,
+ body,
+ shape.offset_left(extra_offset(pats_str, shape) + 4),
+ );
+ let (is_block, is_empty_block) = if let ast::ExprKind::Block(ref block, _) = body.kind {
+ (true, is_empty_block(context, block, Some(&body.attrs)))
+ } else {
+ (false, false)
+ };
+
+ let comma = arm_comma(context.config, body, is_last);
+ let alt_block_sep = &shape.indent.to_string_with_newline(context.config);
+
+ let combine_orig_body = |body_str: &str| {
+ let block_sep = match context.config.control_brace_style() {
+ ControlBraceStyle::AlwaysNextLine if is_block => alt_block_sep,
+ _ => " ",
+ };
+
+ Some(format!("{} =>{}{}{}", pats_str, block_sep, body_str, comma))
+ };
+
+ let next_line_indent = if !is_block || is_empty_block {
+ shape.indent.block_indent(context.config)
+ } else {
+ shape.indent
+ };
+
+ let forbid_same_line =
+ (has_guard && pats_str.contains('\n') && !is_empty_block) || !body.attrs.is_empty();
+
+ // Look for comments between `=>` and the start of the body.
+ let arrow_comment = {
+ let arrow_snippet = context.snippet(arrow_span).trim();
+ // search for the arrow starting from the end of the snippet since there may be a match
+ // expression within the guard
+ let arrow_index = arrow_snippet.rfind("=>").unwrap();
+ // 2 = `=>`
+ let comment_str = arrow_snippet[arrow_index + 2..].trim();
+ if comment_str.is_empty() {
+ String::new()
+ } else {
+ rewrite_comment(comment_str, false, shape, &context.config)?
+ }
+ };
+
+ let combine_next_line_body = |body_str: &str| {
+ let nested_indent_str = next_line_indent.to_string_with_newline(context.config);
+
+ if is_block {
+ let mut result = pats_str.to_owned();
+ result.push_str(" =>");
+ if !arrow_comment.is_empty() {
+ result.push_str(&nested_indent_str);
+ result.push_str(&arrow_comment);
+ }
+ result.push_str(&nested_indent_str);
+ result.push_str(&body_str);
++ result.push_str(&comma);
+ return Some(result);
+ }
+
+ let indent_str = shape.indent.to_string_with_newline(context.config);
+ let (body_prefix, body_suffix) =
+ if context.config.match_arm_blocks() && !context.inside_macro() {
+ let comma = if context.config.match_block_trailing_comma() {
+ ","
+ } else {
+ ""
+ };
+ let semicolon = if context.config.version() == Version::One {
+ ""
+ } else {
+ if semicolon_for_expr(context, body) {
+ ";"
+ } else {
+ ""
+ }
+ };
+ ("{", format!("{}{}}}{}", semicolon, indent_str, comma))
+ } else {
+ ("", String::from(","))
+ };
+
+ let block_sep = match context.config.control_brace_style() {
+ ControlBraceStyle::AlwaysNextLine => format!("{}{}", alt_block_sep, body_prefix),
+ _ if body_prefix.is_empty() => "".to_owned(),
+ _ if forbid_same_line || !arrow_comment.is_empty() => {
+ format!("{}{}", alt_block_sep, body_prefix)
+ }
+ _ => format!(" {}", body_prefix),
+ } + &nested_indent_str;
+
+ let mut result = pats_str.to_owned();
+ result.push_str(" =>");
+ if !arrow_comment.is_empty() {
+ result.push_str(&indent_str);
+ result.push_str(&arrow_comment);
+ }
+ result.push_str(&block_sep);
+ result.push_str(&body_str);
+ result.push_str(&body_suffix);
+ Some(result)
+ };
+
+ // Let's try and get the arm body on the same line as the condition.
+ // 4 = ` => `.len()
+ let orig_body_shape = shape
+ .offset_left(extra_offset(pats_str, shape) + 4)
+ .and_then(|shape| shape.sub_width(comma.len()));
+ let orig_body = if forbid_same_line || !arrow_comment.is_empty() {
+ None
+ } else if let Some(body_shape) = orig_body_shape {
+ let rewrite = nop_block_collapse(
+ format_expr(body, ExprType::Statement, context, body_shape),
+ body_shape.width,
+ );
+
+ match rewrite {
+ Some(ref body_str)
+ if is_block
+ || (!body_str.contains('\n')
+ && unicode_str_width(body_str) <= body_shape.width) =>
+ {
+ return combine_orig_body(body_str);
+ }
+ _ => rewrite,
+ }
+ } else {
+ None
+ };
+ let orig_budget = orig_body_shape.map_or(0, |shape| shape.width);
+
+ // Try putting body on the next line and see if it looks better.
+ let next_line_body_shape = Shape::indented(next_line_indent, context.config);
+ let next_line_body = nop_block_collapse(
+ format_expr(body, ExprType::Statement, context, next_line_body_shape),
+ next_line_body_shape.width,
+ );
+ match (orig_body, next_line_body) {
+ (Some(ref orig_str), Some(ref next_line_str))
+ if prefer_next_line(orig_str, next_line_str, RhsTactics::Default) =>
+ {
+ combine_next_line_body(next_line_str)
+ }
+ (Some(ref orig_str), _) if extend && first_line_width(orig_str) <= orig_budget => {
+ combine_orig_body(orig_str)
+ }
+ (Some(ref orig_str), Some(ref next_line_str)) if orig_str.contains('\n') => {
+ combine_next_line_body(next_line_str)
+ }
+ (None, Some(ref next_line_str)) => combine_next_line_body(next_line_str),
+ (None, None) => None,
+ (Some(ref orig_str), _) => combine_orig_body(orig_str),
+ }
+}
+
+// The `if ...` guard on a match arm.
+fn rewrite_guard(
+ context: &RewriteContext<'_>,
+ guard: &Option<ptr::P<ast::Expr>>,
+ shape: Shape,
+ // The amount of space used up on this line for the pattern in
+ // the arm (excludes offset).
+ pattern_width: usize,
+ multiline_pattern: bool,
+) -> Option<String> {
+ if let Some(ref guard) = *guard {
+ // First try to fit the guard string on the same line as the pattern.
+ // 4 = ` if `, 5 = ` => {`
+ let cond_shape = shape
+ .offset_left(pattern_width + 4)
+ .and_then(|s| s.sub_width(5));
+ if !multiline_pattern {
+ if let Some(cond_shape) = cond_shape {
+ if let Some(cond_str) = guard.rewrite(context, cond_shape) {
+ if !cond_str.contains('\n') || pattern_width <= context.config.tab_spaces() {
+ return Some(format!(" if {}", cond_str));
+ }
+ }
+ }
+ }
+
+ // Not enough space to put the guard after the pattern, try a newline.
+ // 3 = `if `, 5 = ` => {`
+ let cond_shape = Shape::indented(shape.indent.block_indent(context.config), context.config)
+ .offset_left(3)
+ .and_then(|s| s.sub_width(5));
+ if let Some(cond_shape) = cond_shape {
+ if let Some(cond_str) = guard.rewrite(context, cond_shape) {
+ return Some(format!(
+ "{}if {}",
+ cond_shape.indent.to_string_with_newline(context.config),
+ cond_str
+ ));
+ }
+ }
+
+ None
+ } else {
+ Some(String::new())
+ }
+}
+
+fn nop_block_collapse(block_str: Option<String>, budget: usize) -> Option<String> {
+ debug!("nop_block_collapse {:?} {}", block_str, budget);
+ block_str.map(|block_str| {
+ if block_str.starts_with('{')
+ && budget >= 2
+ && (block_str[1..].find(|c: char| !c.is_whitespace()).unwrap() == block_str.len() - 2)
+ {
+ String::from("{}")
+ } else {
+ block_str
+ }
+ })
+}
+
+fn can_flatten_block_around_this(body: &ast::Expr) -> bool {
+ match body.kind {
+ // We do not allow `if` to stay on the same line, since we could easily mistake
+ // `pat => if cond { ... }` and `pat if cond => { ... }`.
+ ast::ExprKind::If(..) => false,
+ // We do not allow collapsing a block around expression with condition
+ // to avoid it being cluttered with match arm.
+ ast::ExprKind::ForLoop(..) | ast::ExprKind::While(..) => false,
+ ast::ExprKind::Loop(..)
+ | ast::ExprKind::Match(..)
+ | ast::ExprKind::Block(..)
+ | ast::ExprKind::Closure(..)
+ | ast::ExprKind::Array(..)
+ | ast::ExprKind::Call(..)
+ | ast::ExprKind::MethodCall(..)
+ | ast::ExprKind::MacCall(..)
+ | ast::ExprKind::Struct(..)
+ | ast::ExprKind::Tup(..) => true,
+ ast::ExprKind::AddrOf(_, _, ref expr)
+ | ast::ExprKind::Box(ref expr)
+ | ast::ExprKind::Try(ref expr)
+ | ast::ExprKind::Unary(_, ref expr)
+ | ast::ExprKind::Index(ref expr, _)
+ | ast::ExprKind::Cast(ref expr, _) => can_flatten_block_around_this(expr),
+ _ => false,
+ }
+}
--- /dev/null
- let indent = this.block_indent.to_string(config);
- this.push_str(&indent);
- })
- }
-
- pub(crate) fn format_missing_no_indent(&mut self, end: BytePos) {
- self.format_missing_inner(end, |this, last_snippet, _| {
- this.push_str(last_snippet.trim_end());
+use rustc_span::{BytePos, Pos, Span};
+
+use crate::comment::{is_last_comment_block, rewrite_comment, CodeCharKind, CommentCodeSlices};
+use crate::config::file_lines::FileLines;
+use crate::config::FileName;
+use crate::config::Version;
+use crate::coverage::transform_missing_snippet;
+use crate::shape::{Indent, Shape};
+use crate::source_map::LineRangeUtils;
+use crate::utils::{count_lf_crlf, count_newlines, last_line_width, mk_sp};
+use crate::visitor::FmtVisitor;
+
+struct SnippetStatus {
+ /// An offset to the current line from the beginning of the original snippet.
+ line_start: usize,
+ /// A length of trailing whitespaces on the current line.
+ last_wspace: Option<usize>,
+ /// The current line number.
+ cur_line: usize,
+}
+
+impl SnippetStatus {
+ fn new(cur_line: usize) -> Self {
+ SnippetStatus {
+ line_start: 0,
+ last_wspace: None,
+ cur_line,
+ }
+ }
+}
+
+impl<'a> FmtVisitor<'a> {
+ fn output_at_start(&self) -> bool {
+ self.buffer.is_empty()
+ }
+
+ pub(crate) fn format_missing(&mut self, end: BytePos) {
+ // HACK(topecongiro): we use `format_missing()` to extract a missing comment between
+ // a macro (or similar) and a trailing semicolon. Here we just try to avoid calling
+ // `format_missing_inner` in the common case where there is no such comment.
+ // This is a hack, ideally we should fix a possible bug in `format_missing_inner`
+ // or refactor `visit_mac` and `rewrite_macro`, but this should suffice to fix the
+ // issue (#2727).
+ let missing_snippet = self.snippet(mk_sp(self.last_pos, end));
+ if missing_snippet.trim() == ";" {
+ self.push_str(";");
+ self.last_pos = end;
+ return;
+ }
+ self.format_missing_inner(end, |this, last_snippet, _| this.push_str(last_snippet))
+ }
+
+ pub(crate) fn format_missing_with_indent(&mut self, end: BytePos) {
++ self.format_missing_indent(end, true)
++ }
++
++ pub(crate) fn format_missing_no_indent(&mut self, end: BytePos) {
++ self.format_missing_indent(end, false)
++ }
++
++ fn format_missing_indent(&mut self, end: BytePos, should_indent: bool) {
+ let config = self.config;
+ self.format_missing_inner(end, |this, last_snippet, snippet| {
+ this.push_str(last_snippet.trim_end());
+ if last_snippet == snippet && !this.output_at_start() {
+ // No new lines in the snippet.
+ this.push_str("\n");
+ }
++ if should_indent {
++ let indent = this.block_indent.to_string(config);
++ this.push_str(&indent);
++ }
+ })
+ }
+
+ fn format_missing_inner<F: Fn(&mut FmtVisitor<'_>, &str, &str)>(
+ &mut self,
+ end: BytePos,
+ process_last_snippet: F,
+ ) {
+ let start = self.last_pos;
+
+ if start == end {
+ // Do nothing if this is the beginning of the file.
+ if !self.output_at_start() {
+ process_last_snippet(self, "", "");
+ }
+ return;
+ }
+
+ assert!(
+ start < end,
+ "Request to format inverted span: {}",
+ self.parse_sess.span_to_debug_info(mk_sp(start, end)),
+ );
+
+ self.last_pos = end;
+ let span = mk_sp(start, end);
+ let snippet = self.snippet(span);
+
+ // Do nothing for spaces in the beginning of the file
+ if start == BytePos(0) && end.0 as usize == snippet.len() && snippet.trim().is_empty() {
+ return;
+ }
+
+ if snippet.trim().is_empty() && !out_of_file_lines_range!(self, span) {
+ // Keep vertical spaces within range.
+ self.push_vertical_spaces(count_newlines(snippet));
+ process_last_snippet(self, "", snippet);
+ } else {
+ self.write_snippet(span, &process_last_snippet);
+ }
+ }
+
+ fn push_vertical_spaces(&mut self, mut newline_count: usize) {
+ let offset = self.buffer.chars().rev().take_while(|c| *c == '\n').count();
+ let newline_upper_bound = self.config.blank_lines_upper_bound() + 1;
+ let newline_lower_bound = self.config.blank_lines_lower_bound() + 1;
+
+ if newline_count + offset > newline_upper_bound {
+ if offset >= newline_upper_bound {
+ newline_count = 0;
+ } else {
+ newline_count = newline_upper_bound - offset;
+ }
+ } else if newline_count + offset < newline_lower_bound {
+ if offset >= newline_lower_bound {
+ newline_count = 0;
+ } else {
+ newline_count = newline_lower_bound - offset;
+ }
+ }
+
+ let blank_lines = "\n".repeat(newline_count);
+ self.push_str(&blank_lines);
+ }
+
+ fn write_snippet<F>(&mut self, span: Span, process_last_snippet: F)
+ where
+ F: Fn(&mut FmtVisitor<'_>, &str, &str),
+ {
+ // Get a snippet from the file start to the span's hi without allocating.
+ // We need it to determine what precedes the current comment. If the comment
+ // follows code on the same line, we won't touch it.
+ let big_span_lo = self.snippet_provider.start_pos();
+ let big_snippet = self.snippet_provider.entire_snippet();
+ let big_diff = (span.lo() - big_span_lo).to_usize();
+
+ let snippet = self.snippet(span);
+
+ debug!("write_snippet `{}`", snippet);
+
+ self.write_snippet_inner(big_snippet, snippet, big_diff, span, process_last_snippet);
+ }
+
+ fn write_snippet_inner<F>(
+ &mut self,
+ big_snippet: &str,
+ old_snippet: &str,
+ big_diff: usize,
+ span: Span,
+ process_last_snippet: F,
+ ) where
+ F: Fn(&mut FmtVisitor<'_>, &str, &str),
+ {
+ // Trim whitespace from the right hand side of each line.
+ // Annoyingly, the library functions for splitting by lines etc. are not
+ // quite right, so we must do it ourselves.
+ let line = self.parse_sess.line_of_byte_pos(span.lo());
+ let file_name = &self.parse_sess.span_to_filename(span);
+ let mut status = SnippetStatus::new(line);
+
+ let snippet = &*transform_missing_snippet(self.config, old_snippet);
+
+ let slice_within_file_lines_range =
+ |file_lines: FileLines, cur_line, s| -> (usize, usize, bool) {
+ let (lf_count, crlf_count) = count_lf_crlf(s);
+ let newline_count = lf_count + crlf_count;
+ let within_file_lines_range = file_lines.contains_range(
+ file_name,
+ cur_line,
+ // if a newline character is at the end of the slice, then the number of
+ // newlines needs to be decreased by 1 so that the range checked against
+ // the file_lines is the visual range one would expect.
+ cur_line + newline_count - if s.ends_with('\n') { 1 } else { 0 },
+ );
+ (lf_count, crlf_count, within_file_lines_range)
+ };
+ for (kind, offset, subslice) in CommentCodeSlices::new(snippet) {
+ debug!("{:?}: {:?}", kind, subslice);
+
+ let (lf_count, crlf_count, within_file_lines_range) =
+ slice_within_file_lines_range(self.config.file_lines(), status.cur_line, subslice);
+ let newline_count = lf_count + crlf_count;
+ if CodeCharKind::Comment == kind && within_file_lines_range {
+ // 1: comment.
+ self.process_comment(
+ &mut status,
+ snippet,
+ &big_snippet[..(offset + big_diff)],
+ offset,
+ subslice,
+ );
+ } else if subslice.trim().is_empty() && newline_count > 0 && within_file_lines_range {
+ // 2: blank lines.
+ self.push_vertical_spaces(newline_count);
+ status.cur_line += newline_count;
+ status.line_start = offset + lf_count + crlf_count * 2;
+ } else {
+ // 3: code which we failed to format or which is not within file-lines range.
+ self.process_missing_code(&mut status, snippet, subslice, offset, file_name);
+ }
+ }
+
+ let last_snippet = &snippet[status.line_start..];
+ let (_, _, within_file_lines_range) =
+ slice_within_file_lines_range(self.config.file_lines(), status.cur_line, last_snippet);
+ if within_file_lines_range {
+ process_last_snippet(self, last_snippet, snippet);
+ } else {
+ // just append what's left
+ self.push_str(last_snippet);
+ }
+ }
+
+ fn process_comment(
+ &mut self,
+ status: &mut SnippetStatus,
+ snippet: &str,
+ big_snippet: &str,
+ offset: usize,
+ subslice: &str,
+ ) {
+ let last_char = big_snippet
+ .chars()
+ .rev()
+ .find(|rev_c| ![' ', '\t'].contains(rev_c));
+
+ let fix_indent = last_char.map_or(true, |rev_c| ['{', '\n'].contains(&rev_c));
+ let mut on_same_line = false;
+
+ let comment_indent = if fix_indent {
+ if let Some('{') = last_char {
+ self.push_str("\n");
+ }
+ let indent_str = self.block_indent.to_string(self.config);
+ self.push_str(&indent_str);
+ self.block_indent
+ } else if self.config.version() == Version::Two && !snippet.starts_with('\n') {
+ // The comment appears on the same line as the previous formatted code.
+ // Assuming that comment is logically associated with that code, we want to keep it on
+ // the same level and avoid mixing it with possible other comment.
+ on_same_line = true;
+ self.push_str(" ");
+ self.block_indent
+ } else {
+ self.push_str(" ");
+ Indent::from_width(self.config, last_line_width(&self.buffer))
+ };
+
+ let comment_width = ::std::cmp::min(
+ self.config.comment_width(),
+ self.config.max_width() - self.block_indent.width(),
+ );
+ let comment_shape = Shape::legacy(comment_width, comment_indent);
+
+ if on_same_line {
+ match subslice.find('\n') {
+ None => {
+ self.push_str(subslice);
+ }
+ Some(offset) if offset + 1 == subslice.len() => {
+ self.push_str(&subslice[..offset]);
+ }
+ Some(offset) => {
+ // keep first line as is: if it were too long and wrapped, it may get mixed
+ // with the other lines.
+ let first_line = &subslice[..offset];
+ self.push_str(first_line);
+ self.push_str(&comment_indent.to_string_with_newline(self.config));
+
+ let other_lines = &subslice[offset + 1..];
+ let comment_str =
+ rewrite_comment(other_lines, false, comment_shape, self.config)
+ .unwrap_or_else(|| String::from(other_lines));
+ self.push_str(&comment_str);
+ }
+ }
+ } else {
+ let comment_str = rewrite_comment(subslice, false, comment_shape, self.config)
+ .unwrap_or_else(|| String::from(subslice));
+ self.push_str(&comment_str);
+ }
+
+ status.last_wspace = None;
+ status.line_start = offset + subslice.len();
+
+ // Add a newline:
+ // - if there isn't one already
+ // - otherwise, only if the last line is a line comment
+ if status.line_start <= snippet.len() {
+ match snippet[status.line_start..]
+ .chars()
+ // skip trailing whitespaces
+ .find(|c| !(*c == ' ' || *c == '\t'))
+ {
+ Some('\n') | Some('\r') => {
+ if !is_last_comment_block(subslice) {
+ self.push_str("\n");
+ }
+ }
+ _ => self.push_str("\n"),
+ }
+ }
+
+ status.cur_line += count_newlines(subslice);
+ }
+
+ fn process_missing_code(
+ &mut self,
+ status: &mut SnippetStatus,
+ snippet: &str,
+ subslice: &str,
+ offset: usize,
+ file_name: &FileName,
+ ) {
+ for (mut i, c) in subslice.char_indices() {
+ i += offset;
+
+ if c == '\n' {
+ let skip_this_line = !self
+ .config
+ .file_lines()
+ .contains_line(file_name, status.cur_line);
+ if skip_this_line {
+ status.last_wspace = None;
+ }
+
+ if let Some(lw) = status.last_wspace {
+ self.push_str(&snippet[status.line_start..lw]);
+ self.push_str("\n");
+ status.last_wspace = None;
+ } else {
+ self.push_str(&snippet[status.line_start..=i]);
+ }
+
+ status.cur_line += 1;
+ status.line_start = i + 1;
+ } else if c.is_whitespace() && status.last_wspace.is_none() {
+ status.last_wspace = Some(i);
+ } else {
+ status.last_wspace = None;
+ }
+ }
+
+ let remaining = snippet[status.line_start..subslice.len() + offset].trim();
+ if !remaining.is_empty() {
+ self.push_str(&self.block_indent.to_string(self.config));
+ self.push_str(remaining);
+ status.line_start = subslice.len() + offset;
+ }
+ }
+}
--- /dev/null
- impl_into_overflowable_item_for_ast_node!(Expr, GenericParam, NestedMetaItem, FieldDef, Ty);
+//! Rewrite a list some items with overflow.
+
+use std::cmp::min;
+
+use itertools::Itertools;
+use rustc_ast::token::DelimToken;
+use rustc_ast::{ast, ptr};
+use rustc_span::Span;
+
+use crate::closures;
+use crate::config::lists::*;
+use crate::config::Version;
+use crate::expr::{
+ can_be_overflowed_expr, is_every_expr_simple, is_method_call, is_nested_call, is_simple_expr,
+ rewrite_cond,
+};
+use crate::lists::{
+ definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
+};
+use crate::macros::MacroArg;
+use crate::patterns::{can_be_overflowed_pat, TuplePatField};
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::Shape;
+use crate::source_map::SpanUtils;
+use crate::spanned::Spanned;
+use crate::types::{can_be_overflowed_type, SegmentParam};
+use crate::utils::{count_newlines, extra_offset, first_line_width, last_line_width, mk_sp};
+
+const SHORT_ITEM_THRESHOLD: usize = 10;
+
+/// A list of `format!`-like macros, that take a long format string and a list of arguments to
+/// format.
+///
+/// Organized as a list of `(&str, usize)` tuples, giving the name of the macro and the number of
+/// arguments before the format string (none for `format!("format", ...)`, one for `assert!(result,
+/// "format", ...)`, two for `assert_eq!(left, right, "format", ...)`).
+const SPECIAL_MACRO_WHITELIST: &[(&str, usize)] = &[
+ // format! like macros
+ // From the Rust Standard Library.
+ ("eprint!", 0),
+ ("eprintln!", 0),
+ ("format!", 0),
+ ("format_args!", 0),
+ ("print!", 0),
+ ("println!", 0),
+ ("panic!", 0),
+ ("unreachable!", 0),
+ // From the `log` crate.
+ ("debug!", 0),
+ ("error!", 0),
+ ("info!", 0),
+ ("warn!", 0),
+ // write! like macros
+ ("assert!", 1),
+ ("debug_assert!", 1),
+ ("write!", 1),
+ ("writeln!", 1),
+ // assert_eq! like macros
+ ("assert_eq!", 2),
+ ("assert_ne!", 2),
+ ("debug_assert_eq!", 2),
+ ("debug_assert_ne!", 2),
+];
+
+const SPECIAL_ATTR_WHITELIST: &[(&str, usize)] = &[
+ // From the `failure` crate.
+ ("fail", 0),
+];
+
+#[derive(Debug)]
+pub(crate) enum OverflowableItem<'a> {
+ Expr(&'a ast::Expr),
+ GenericParam(&'a ast::GenericParam),
+ MacroArg(&'a MacroArg),
+ NestedMetaItem(&'a ast::NestedMetaItem),
+ SegmentParam(&'a SegmentParam<'a>),
+ FieldDef(&'a ast::FieldDef),
+ TuplePatField(&'a TuplePatField<'a>),
+ Ty(&'a ast::Ty),
++ Pat(&'a ast::Pat),
+}
+
+impl<'a> Rewrite for OverflowableItem<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ self.map(|item| item.rewrite(context, shape))
+ }
+}
+
+impl<'a> Spanned for OverflowableItem<'a> {
+ fn span(&self) -> Span {
+ self.map(|item| item.span())
+ }
+}
+
+impl<'a> OverflowableItem<'a> {
+ fn has_attrs(&self) -> bool {
+ match self {
+ OverflowableItem::Expr(ast::Expr { attrs, .. })
+ | OverflowableItem::GenericParam(ast::GenericParam { attrs, .. }) => !attrs.is_empty(),
+ OverflowableItem::FieldDef(ast::FieldDef { attrs, .. }) => !attrs.is_empty(),
+ OverflowableItem::MacroArg(MacroArg::Expr(expr)) => !expr.attrs.is_empty(),
+ OverflowableItem::MacroArg(MacroArg::Item(item)) => !item.attrs.is_empty(),
+ _ => false,
+ }
+ }
+
+ pub(crate) fn map<F, T>(&self, f: F) -> T
+ where
+ F: Fn(&dyn IntoOverflowableItem<'a>) -> T,
+ {
+ match self {
+ OverflowableItem::Expr(expr) => f(*expr),
+ OverflowableItem::GenericParam(gp) => f(*gp),
+ OverflowableItem::MacroArg(macro_arg) => f(*macro_arg),
+ OverflowableItem::NestedMetaItem(nmi) => f(*nmi),
+ OverflowableItem::SegmentParam(sp) => f(*sp),
+ OverflowableItem::FieldDef(sf) => f(*sf),
+ OverflowableItem::TuplePatField(pat) => f(*pat),
+ OverflowableItem::Ty(ty) => f(*ty),
++ OverflowableItem::Pat(pat) => f(*pat),
+ }
+ }
+
+ pub(crate) fn is_simple(&self) -> bool {
+ match self {
+ OverflowableItem::Expr(expr) => is_simple_expr(expr),
+ OverflowableItem::MacroArg(MacroArg::Keyword(..)) => true,
+ OverflowableItem::MacroArg(MacroArg::Expr(expr)) => is_simple_expr(expr),
+ OverflowableItem::NestedMetaItem(nested_meta_item) => match nested_meta_item {
+ ast::NestedMetaItem::Literal(..) => true,
+ ast::NestedMetaItem::MetaItem(ref meta_item) => {
+ matches!(meta_item.kind, ast::MetaItemKind::Word)
+ }
+ },
+ _ => false,
+ }
+ }
+
+ pub(crate) fn is_expr(&self) -> bool {
+ matches!(
+ self,
+ OverflowableItem::Expr(..) | OverflowableItem::MacroArg(MacroArg::Expr(..))
+ )
+ }
+
+ pub(crate) fn is_nested_call(&self) -> bool {
+ match self {
+ OverflowableItem::Expr(expr) => is_nested_call(expr),
+ OverflowableItem::MacroArg(MacroArg::Expr(expr)) => is_nested_call(expr),
+ _ => false,
+ }
+ }
+
+ pub(crate) fn to_expr(&self) -> Option<&'a ast::Expr> {
+ match self {
+ OverflowableItem::Expr(expr) => Some(expr),
+ OverflowableItem::MacroArg(MacroArg::Expr(ref expr)) => Some(expr),
+ _ => None,
+ }
+ }
+
+ pub(crate) fn can_be_overflowed(&self, context: &RewriteContext<'_>, len: usize) -> bool {
+ match self {
+ OverflowableItem::Expr(expr) => can_be_overflowed_expr(context, expr, len),
+ OverflowableItem::MacroArg(macro_arg) => match macro_arg {
+ MacroArg::Expr(ref expr) => can_be_overflowed_expr(context, expr, len),
+ MacroArg::Ty(ref ty) => can_be_overflowed_type(context, ty, len),
+ MacroArg::Pat(..) => false,
+ MacroArg::Item(..) => len == 1,
+ MacroArg::Keyword(..) => false,
+ },
+ OverflowableItem::NestedMetaItem(nested_meta_item) if len == 1 => {
+ match nested_meta_item {
+ ast::NestedMetaItem::Literal(..) => false,
+ ast::NestedMetaItem::MetaItem(..) => true,
+ }
+ }
+ OverflowableItem::SegmentParam(SegmentParam::Type(ty)) => {
+ can_be_overflowed_type(context, ty, len)
+ }
+ OverflowableItem::TuplePatField(pat) => can_be_overflowed_pat(context, pat, len),
+ OverflowableItem::Ty(ty) => can_be_overflowed_type(context, ty, len),
+ _ => false,
+ }
+ }
+
+ fn whitelist(&self) -> &'static [(&'static str, usize)] {
+ match self {
+ OverflowableItem::MacroArg(..) => SPECIAL_MACRO_WHITELIST,
+ OverflowableItem::NestedMetaItem(..) => SPECIAL_ATTR_WHITELIST,
+ _ => &[],
+ }
+ }
+}
+
+pub(crate) trait IntoOverflowableItem<'a>: Rewrite + Spanned {
+ fn into_overflowable_item(&'a self) -> OverflowableItem<'a>;
+}
+
+impl<'a, T: 'a + IntoOverflowableItem<'a>> IntoOverflowableItem<'a> for ptr::P<T> {
+ fn into_overflowable_item(&'a self) -> OverflowableItem<'a> {
+ (**self).into_overflowable_item()
+ }
+}
+
+macro_rules! impl_into_overflowable_item_for_ast_node {
+ ($($ast_node:ident),*) => {
+ $(
+ impl<'a> IntoOverflowableItem<'a> for ast::$ast_node {
+ fn into_overflowable_item(&'a self) -> OverflowableItem<'a> {
+ OverflowableItem::$ast_node(self)
+ }
+ }
+ )*
+ }
+}
+
+macro_rules! impl_into_overflowable_item_for_rustfmt_types {
+ ([$($ty:ident),*], [$($ty_with_lifetime:ident),*]) => {
+ $(
+ impl<'a> IntoOverflowableItem<'a> for $ty {
+ fn into_overflowable_item(&'a self) -> OverflowableItem<'a> {
+ OverflowableItem::$ty(self)
+ }
+ }
+ )*
+ $(
+ impl<'a> IntoOverflowableItem<'a> for $ty_with_lifetime<'a> {
+ fn into_overflowable_item(&'a self) -> OverflowableItem<'a> {
+ OverflowableItem::$ty_with_lifetime(self)
+ }
+ }
+ )*
+ }
+}
+
++impl_into_overflowable_item_for_ast_node!(Expr, GenericParam, NestedMetaItem, FieldDef, Ty, Pat);
+impl_into_overflowable_item_for_rustfmt_types!([MacroArg], [SegmentParam, TuplePatField]);
+
+pub(crate) fn into_overflowable_list<'a, T>(
+ iter: impl Iterator<Item = &'a T>,
+) -> impl Iterator<Item = OverflowableItem<'a>>
+where
+ T: 'a + IntoOverflowableItem<'a>,
+{
+ iter.map(|x| IntoOverflowableItem::into_overflowable_item(x))
+}
+
+pub(crate) fn rewrite_with_parens<'a, T: 'a + IntoOverflowableItem<'a>>(
+ context: &'a RewriteContext<'_>,
+ ident: &'a str,
+ items: impl Iterator<Item = &'a T>,
+ shape: Shape,
+ span: Span,
+ item_max_width: usize,
+ force_separator_tactic: Option<SeparatorTactic>,
+) -> Option<String> {
+ Context::new(
+ context,
+ items,
+ ident,
+ shape,
+ span,
+ "(",
+ ")",
+ item_max_width,
+ force_separator_tactic,
+ None,
+ )
+ .rewrite(shape)
+}
+
+pub(crate) fn rewrite_with_angle_brackets<'a, T: 'a + IntoOverflowableItem<'a>>(
+ context: &'a RewriteContext<'_>,
+ ident: &'a str,
+ items: impl Iterator<Item = &'a T>,
+ shape: Shape,
+ span: Span,
+) -> Option<String> {
+ Context::new(
+ context,
+ items,
+ ident,
+ shape,
+ span,
+ "<",
+ ">",
+ context.config.max_width(),
+ None,
+ None,
+ )
+ .rewrite(shape)
+}
+
+pub(crate) fn rewrite_with_square_brackets<'a, T: 'a + IntoOverflowableItem<'a>>(
+ context: &'a RewriteContext<'_>,
+ name: &'a str,
+ items: impl Iterator<Item = &'a T>,
+ shape: Shape,
+ span: Span,
+ force_separator_tactic: Option<SeparatorTactic>,
+ delim_token: Option<DelimToken>,
+) -> Option<String> {
+ let (lhs, rhs) = match delim_token {
+ Some(DelimToken::Paren) => ("(", ")"),
+ Some(DelimToken::Brace) => ("{", "}"),
+ _ => ("[", "]"),
+ };
+ Context::new(
+ context,
+ items,
+ name,
+ shape,
+ span,
+ lhs,
+ rhs,
+ context.config.array_width(),
+ force_separator_tactic,
+ Some(("[", "]")),
+ )
+ .rewrite(shape)
+}
+
+struct Context<'a> {
+ context: &'a RewriteContext<'a>,
+ items: Vec<OverflowableItem<'a>>,
+ ident: &'a str,
+ prefix: &'static str,
+ suffix: &'static str,
+ one_line_shape: Shape,
+ nested_shape: Shape,
+ span: Span,
+ item_max_width: usize,
+ one_line_width: usize,
+ force_separator_tactic: Option<SeparatorTactic>,
+ custom_delims: Option<(&'a str, &'a str)>,
+}
+
+impl<'a> Context<'a> {
+ fn new<T: 'a + IntoOverflowableItem<'a>>(
+ context: &'a RewriteContext<'_>,
+ items: impl Iterator<Item = &'a T>,
+ ident: &'a str,
+ shape: Shape,
+ span: Span,
+ prefix: &'static str,
+ suffix: &'static str,
+ item_max_width: usize,
+ force_separator_tactic: Option<SeparatorTactic>,
+ custom_delims: Option<(&'a str, &'a str)>,
+ ) -> Context<'a> {
+ let used_width = extra_offset(ident, shape);
+ // 1 = `()`
+ let one_line_width = shape.width.saturating_sub(used_width + 2);
+
+ // 1 = "(" or ")"
+ let one_line_shape = shape
+ .offset_left(last_line_width(ident) + 1)
+ .and_then(|shape| shape.sub_width(1))
+ .unwrap_or(Shape { width: 0, ..shape });
+ let nested_shape = shape_from_indent_style(context, shape, used_width + 2, used_width + 1);
+ Context {
+ context,
+ items: into_overflowable_list(items).collect(),
+ ident,
+ one_line_shape,
+ nested_shape,
+ span,
+ prefix,
+ suffix,
+ item_max_width,
+ one_line_width,
+ force_separator_tactic,
+ custom_delims,
+ }
+ }
+
+ fn last_item(&self) -> Option<&OverflowableItem<'_>> {
+ self.items.last()
+ }
+
+ fn items_span(&self) -> Span {
+ let span_lo = self
+ .context
+ .snippet_provider
+ .span_after(self.span, self.prefix);
+ mk_sp(span_lo, self.span.hi())
+ }
+
+ fn rewrite_last_item_with_overflow(
+ &self,
+ last_list_item: &mut ListItem,
+ shape: Shape,
+ ) -> Option<String> {
+ let last_item = self.last_item()?;
+ let rewrite = match last_item {
+ OverflowableItem::Expr(ref expr) => {
+ match expr.kind {
+ // When overflowing the closure which consists of a single control flow
+ // expression, force to use block if its condition uses multi line.
+ ast::ExprKind::Closure(..) => {
+ // If the argument consists of multiple closures, we do not overflow
+ // the last closure.
+ if closures::args_have_many_closure(&self.items) {
+ None
+ } else {
+ closures::rewrite_last_closure(self.context, expr, shape)
+ }
+ }
+
+ // When overflowing the expressions which consists of a control flow
+ // expression, avoid condition to use multi line.
+ ast::ExprKind::If(..)
+ | ast::ExprKind::ForLoop(..)
+ | ast::ExprKind::Loop(..)
+ | ast::ExprKind::While(..)
+ | ast::ExprKind::Match(..) => {
+ let multi_line = rewrite_cond(self.context, expr, shape)
+ .map_or(false, |cond| cond.contains('\n'));
+
+ if multi_line {
+ None
+ } else {
+ expr.rewrite(self.context, shape)
+ }
+ }
+
+ _ => expr.rewrite(self.context, shape),
+ }
+ }
+ item => item.rewrite(self.context, shape),
+ };
+
+ if let Some(rewrite) = rewrite {
+ // splitn(2, *).next().unwrap() is always safe.
+ let rewrite_first_line = Some(rewrite.splitn(2, '\n').next().unwrap().to_owned());
+ last_list_item.item = rewrite_first_line;
+ Some(rewrite)
+ } else {
+ None
+ }
+ }
+
+ fn default_tactic(&self, list_items: &[ListItem]) -> DefinitiveListTactic {
+ definitive_tactic(
+ list_items,
+ ListTactic::LimitedHorizontalVertical(self.item_max_width),
+ Separator::Comma,
+ self.one_line_width,
+ )
+ }
+
+ fn try_overflow_last_item(&self, list_items: &mut Vec<ListItem>) -> DefinitiveListTactic {
+ // 1 = "("
+ let combine_arg_with_callee = self.items.len() == 1
+ && self.items[0].is_expr()
+ && !self.items[0].has_attrs()
+ && self.ident.len() < self.context.config.tab_spaces();
+ let overflow_last = combine_arg_with_callee || can_be_overflowed(self.context, &self.items);
+
+ // Replace the last item with its first line to see if it fits with
+ // first arguments.
+ let placeholder = if overflow_last {
+ let old_value = self.context.force_one_line_chain.get();
+ match self.last_item() {
+ Some(OverflowableItem::Expr(expr))
+ if !combine_arg_with_callee && is_method_call(expr) =>
+ {
+ self.context.force_one_line_chain.replace(true);
+ }
+ Some(OverflowableItem::MacroArg(MacroArg::Expr(expr)))
+ if !combine_arg_with_callee
+ && is_method_call(expr)
+ && self.context.config.version() == Version::Two =>
+ {
+ self.context.force_one_line_chain.replace(true);
+ }
+ _ => (),
+ }
+ let result = last_item_shape(
+ &self.items,
+ list_items,
+ self.one_line_shape,
+ self.item_max_width,
+ )
+ .and_then(|arg_shape| {
+ self.rewrite_last_item_with_overflow(
+ &mut list_items[self.items.len() - 1],
+ arg_shape,
+ )
+ });
+ self.context.force_one_line_chain.replace(old_value);
+ result
+ } else {
+ None
+ };
+
+ let mut tactic = definitive_tactic(
+ &*list_items,
+ ListTactic::LimitedHorizontalVertical(self.item_max_width),
+ Separator::Comma,
+ self.one_line_width,
+ );
+
+ // Replace the stub with the full overflowing last argument if the rewrite
+ // succeeded and its first line fits with the other arguments.
+ match (overflow_last, tactic, placeholder) {
+ (true, DefinitiveListTactic::Horizontal, Some(ref overflowed))
+ if self.items.len() == 1 =>
+ {
+ // When we are rewriting a nested function call, we restrict the
+ // budget for the inner function to avoid them being deeply nested.
+ // However, when the inner function has a prefix or a suffix
+ // (e.g., `foo() as u32`), this budget reduction may produce poorly
+ // formatted code, where a prefix or a suffix being left on its own
+ // line. Here we explicitlly check those cases.
+ if count_newlines(overflowed) == 1 {
+ let rw = self
+ .items
+ .last()
+ .and_then(|last_item| last_item.rewrite(self.context, self.nested_shape));
+ let no_newline = rw.as_ref().map_or(false, |s| !s.contains('\n'));
+ if no_newline {
+ list_items[self.items.len() - 1].item = rw;
+ } else {
+ list_items[self.items.len() - 1].item = Some(overflowed.to_owned());
+ }
+ } else {
+ list_items[self.items.len() - 1].item = Some(overflowed.to_owned());
+ }
+ }
+ (true, DefinitiveListTactic::Horizontal, placeholder @ Some(..)) => {
+ list_items[self.items.len() - 1].item = placeholder;
+ }
+ _ if !self.items.is_empty() => {
+ list_items[self.items.len() - 1].item = self
+ .items
+ .last()
+ .and_then(|last_item| last_item.rewrite(self.context, self.nested_shape));
+
+ // Use horizontal layout for a function with a single argument as long as
+ // everything fits in a single line.
+ // `self.one_line_width == 0` means vertical layout is forced.
+ if self.items.len() == 1
+ && self.one_line_width != 0
+ && !list_items[0].has_comment()
+ && !list_items[0].inner_as_ref().contains('\n')
+ && crate::lists::total_item_width(&list_items[0]) <= self.one_line_width
+ {
+ tactic = DefinitiveListTactic::Horizontal;
+ } else {
+ tactic = self.default_tactic(list_items);
+
+ if tactic == DefinitiveListTactic::Vertical {
+ if let Some((all_simple, num_args_before)) =
+ maybe_get_args_offset(self.ident, &self.items)
+ {
+ let one_line = all_simple
+ && definitive_tactic(
+ &list_items[..num_args_before],
+ ListTactic::HorizontalVertical,
+ Separator::Comma,
+ self.nested_shape.width,
+ ) == DefinitiveListTactic::Horizontal
+ && definitive_tactic(
+ &list_items[num_args_before + 1..],
+ ListTactic::HorizontalVertical,
+ Separator::Comma,
+ self.nested_shape.width,
+ ) == DefinitiveListTactic::Horizontal;
+
+ if one_line {
+ tactic = DefinitiveListTactic::SpecialMacro(num_args_before);
+ };
+ } else if is_every_expr_simple(&self.items) && no_long_items(list_items) {
+ tactic = DefinitiveListTactic::Mixed;
+ }
+ }
+ }
+ }
+ _ => (),
+ }
+
+ tactic
+ }
+
+ fn rewrite_items(&self) -> Option<(bool, String)> {
+ let span = self.items_span();
+ let items = itemize_list(
+ self.context.snippet_provider,
+ self.items.iter(),
+ self.suffix,
+ ",",
+ |item| item.span().lo(),
+ |item| item.span().hi(),
+ |item| item.rewrite(self.context, self.nested_shape),
+ span.lo(),
+ span.hi(),
+ true,
+ );
+ let mut list_items: Vec<_> = items.collect();
+
+ // Try letting the last argument overflow to the next line with block
+ // indentation. If its first line fits on one line with the other arguments,
+ // we format the function arguments horizontally.
+ let tactic = self.try_overflow_last_item(&mut list_items);
+ let trailing_separator = if let Some(tactic) = self.force_separator_tactic {
+ tactic
+ } else if !self.context.use_block_indent() {
+ SeparatorTactic::Never
+ } else {
+ self.context.config.trailing_comma()
+ };
+ let ends_with_newline = match tactic {
+ DefinitiveListTactic::Vertical | DefinitiveListTactic::Mixed => {
+ self.context.use_block_indent()
+ }
+ _ => false,
+ };
+
+ let fmt = ListFormatting::new(self.nested_shape, self.context.config)
+ .tactic(tactic)
+ .trailing_separator(trailing_separator)
+ .ends_with_newline(ends_with_newline);
+
+ write_list(&list_items, &fmt)
+ .map(|items_str| (tactic == DefinitiveListTactic::Horizontal, items_str))
+ }
+
+ fn wrap_items(&self, items_str: &str, shape: Shape, is_extendable: bool) -> String {
+ let shape = Shape {
+ width: shape.width.saturating_sub(last_line_width(self.ident)),
+ ..shape
+ };
+
+ let (prefix, suffix) = match self.custom_delims {
+ Some((lhs, rhs)) => (lhs, rhs),
+ _ => (self.prefix, self.suffix),
+ };
+
+ let extend_width = if items_str.is_empty() {
+ 2
+ } else {
+ first_line_width(items_str) + 1
+ };
+ let nested_indent_str = self
+ .nested_shape
+ .indent
+ .to_string_with_newline(self.context.config);
+ let indent_str = shape
+ .block()
+ .indent
+ .to_string_with_newline(self.context.config);
+ let mut result = String::with_capacity(
+ self.ident.len() + items_str.len() + 2 + indent_str.len() + nested_indent_str.len(),
+ );
+ result.push_str(self.ident);
+ result.push_str(prefix);
+ let force_single_line = if self.context.config.version() == Version::Two {
+ !self.context.use_block_indent() || (is_extendable && extend_width <= shape.width)
+ } else {
+ // 2 = `()`
+ let fits_one_line = items_str.len() + 2 <= shape.width;
+ !self.context.use_block_indent()
+ || (self.context.inside_macro() && !items_str.contains('\n') && fits_one_line)
+ || (is_extendable && extend_width <= shape.width)
+ };
+ if force_single_line {
+ result.push_str(items_str);
+ } else {
+ if !items_str.is_empty() {
+ result.push_str(&nested_indent_str);
+ result.push_str(items_str);
+ }
+ result.push_str(&indent_str);
+ }
+ result.push_str(suffix);
+ result
+ }
+
+ fn rewrite(&self, shape: Shape) -> Option<String> {
+ let (extendable, items_str) = self.rewrite_items()?;
+
+ // If we are using visual indent style and failed to format, retry with block indent.
+ if !self.context.use_block_indent()
+ && need_block_indent(&items_str, self.nested_shape)
+ && !extendable
+ {
+ self.context.use_block.replace(true);
+ let result = self.rewrite(shape);
+ self.context.use_block.replace(false);
+ return result;
+ }
+
+ Some(self.wrap_items(&items_str, shape, extendable))
+ }
+}
+
+fn need_block_indent(s: &str, shape: Shape) -> bool {
+ s.lines().skip(1).any(|s| {
+ s.find(|c| !char::is_whitespace(c))
+ .map_or(false, |w| w + 1 < shape.indent.width())
+ })
+}
+
+fn can_be_overflowed(context: &RewriteContext<'_>, items: &[OverflowableItem<'_>]) -> bool {
+ items
+ .last()
+ .map_or(false, |x| x.can_be_overflowed(context, items.len()))
+}
+
+/// Returns a shape for the last argument which is going to be overflowed.
+fn last_item_shape(
+ lists: &[OverflowableItem<'_>],
+ items: &[ListItem],
+ shape: Shape,
+ args_max_width: usize,
+) -> Option<Shape> {
+ if items.len() == 1 && !lists.get(0)?.is_nested_call() {
+ return Some(shape);
+ }
+ let offset = items
+ .iter()
+ .dropping_back(1)
+ .map(|i| {
+ // 2 = ", "
+ 2 + i.inner_as_ref().len()
+ })
+ .sum();
+ Shape {
+ width: min(args_max_width, shape.width),
+ ..shape
+ }
+ .offset_left(offset)
+}
+
+fn shape_from_indent_style(
+ context: &RewriteContext<'_>,
+ shape: Shape,
+ overhead: usize,
+ offset: usize,
+) -> Shape {
+ let (shape, overhead) = if context.use_block_indent() {
+ let shape = shape
+ .block()
+ .block_indent(context.config.tab_spaces())
+ .with_max_width(context.config);
+ (shape, 1) // 1 = ","
+ } else {
+ (shape.visual_indent(offset), overhead)
+ };
+ Shape {
+ width: shape.width.saturating_sub(overhead),
+ ..shape
+ }
+}
+
+fn no_long_items(list: &[ListItem]) -> bool {
+ list.iter()
+ .all(|item| item.inner_as_ref().len() <= SHORT_ITEM_THRESHOLD)
+}
+
+/// In case special-case style is required, returns an offset from which we start horizontal layout.
+pub(crate) fn maybe_get_args_offset(
+ callee_str: &str,
+ args: &[OverflowableItem<'_>],
+) -> Option<(bool, usize)> {
+ if let Some(&(_, num_args_before)) = args
+ .get(0)?
+ .whitelist()
+ .iter()
+ .find(|&&(s, _)| s == callee_str)
+ {
+ let all_simple = args.len() > num_args_before
+ && is_every_expr_simple(&args[0..num_args_before])
+ && is_every_expr_simple(&args[num_args_before + 1..]);
+
+ Some((all_simple, num_args_before))
+ } else {
+ None
+ }
+}
--- /dev/null
- PatKind::TupleStruct(_, ref path, ref pat_vec) => {
- let path_str = rewrite_path(context, PathContext::Expr, None, path, shape)?;
+use rustc_ast::ast::{self, BindingMode, Pat, PatField, PatKind, RangeEnd, RangeSyntax};
+use rustc_ast::ptr;
+use rustc_span::{BytePos, Span};
+
+use crate::comment::{combine_strs_with_missing_comments, FindUncommented};
+use crate::config::lists::*;
++use crate::config::Version;
+use crate::expr::{can_be_overflowed_expr, rewrite_unary_prefix, wrap_struct_field};
+use crate::lists::{
+ definitive_tactic, itemize_list, shape_for_tactic, struct_lit_formatting, struct_lit_shape,
+ struct_lit_tactic, write_list, ListFormatting, ListItem, Separator,
+};
+use crate::macros::{rewrite_macro, MacroPosition};
+use crate::overflow;
+use crate::pairs::{rewrite_pair, PairParts};
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::Shape;
+use crate::source_map::SpanUtils;
+use crate::spanned::Spanned;
+use crate::types::{rewrite_path, PathContext};
+use crate::utils::{format_mutability, mk_sp, mk_sp_lo_plus_one, rewrite_ident};
+
+/// Returns `true` if the given pattern is "short".
+/// A short pattern is defined by the following grammar:
+///
+/// `[small, ntp]`:
+/// - single token
+/// - `&[single-line, ntp]`
+///
+/// `[small]`:
+/// - `[small, ntp]`
+/// - unary tuple constructor `([small, ntp])`
+/// - `&[small]`
+pub(crate) fn is_short_pattern(pat: &ast::Pat, pat_str: &str) -> bool {
+ // We also require that the pattern is reasonably 'small' with its literal width.
+ pat_str.len() <= 20 && !pat_str.contains('\n') && is_short_pattern_inner(pat)
+}
+
+fn is_short_pattern_inner(pat: &ast::Pat) -> bool {
+ match pat.kind {
+ ast::PatKind::Rest | ast::PatKind::Wild | ast::PatKind::Lit(_) => true,
+ ast::PatKind::Ident(_, _, ref pat) => pat.is_none(),
+ ast::PatKind::Struct(..)
+ | ast::PatKind::MacCall(..)
+ | ast::PatKind::Slice(..)
+ | ast::PatKind::Path(..)
+ | ast::PatKind::Range(..) => false,
+ ast::PatKind::Tuple(ref subpats) => subpats.len() <= 1,
+ ast::PatKind::TupleStruct(_, ref path, ref subpats) => {
+ path.segments.len() <= 1 && subpats.len() <= 1
+ }
+ ast::PatKind::Box(ref p) | ast::PatKind::Ref(ref p, _) | ast::PatKind::Paren(ref p) => {
+ is_short_pattern_inner(&*p)
+ }
+ PatKind::Or(ref pats) => pats.iter().all(|p| is_short_pattern_inner(p)),
+ }
+}
+
+struct RangeOperand<'a>(&'a Option<ptr::P<ast::Expr>>);
+
+impl<'a> Rewrite for RangeOperand<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match &self.0 {
+ None => Some("".to_owned()),
+ Some(ref exp) => exp.rewrite(context, shape),
+ }
+ }
+}
+
+impl Rewrite for Pat {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match self.kind {
+ PatKind::Or(ref pats) => {
+ let pat_strs = pats
+ .iter()
+ .map(|p| p.rewrite(context, shape))
+ .collect::<Option<Vec<_>>>()?;
+
+ let use_mixed_layout = pats
+ .iter()
+ .zip(pat_strs.iter())
+ .all(|(pat, pat_str)| is_short_pattern(pat, pat_str));
+ let items: Vec<_> = pat_strs.into_iter().map(ListItem::from_str).collect();
+ let tactic = if use_mixed_layout {
+ DefinitiveListTactic::Mixed
+ } else {
+ definitive_tactic(
+ &items,
+ ListTactic::HorizontalVertical,
+ Separator::VerticalBar,
+ shape.width,
+ )
+ };
+ let fmt = ListFormatting::new(shape, context.config)
+ .tactic(tactic)
+ .separator(" |")
+ .separator_place(context.config.binop_separator())
+ .ends_with_newline(false);
+ write_list(&items, &fmt)
+ }
+ PatKind::Box(ref pat) => rewrite_unary_prefix(context, "box ", &**pat, shape),
+ PatKind::Ident(binding_mode, ident, ref sub_pat) => {
+ let (prefix, mutability) = match binding_mode {
+ BindingMode::ByRef(mutability) => ("ref", mutability),
+ BindingMode::ByValue(mutability) => ("", mutability),
+ };
+ let mut_infix = format_mutability(mutability).trim();
+ let id_str = rewrite_ident(context, ident);
+ let sub_pat = match *sub_pat {
+ Some(ref p) => {
+ // 2 - `@ `.
+ let width = shape
+ .width
+ .checked_sub(prefix.len() + mut_infix.len() + id_str.len() + 2)?;
+ let lo = context.snippet_provider.span_after(self.span, "@");
+ combine_strs_with_missing_comments(
+ context,
+ "@",
+ &p.rewrite(context, Shape::legacy(width, shape.indent))?,
+ mk_sp(lo, p.span.lo()),
+ shape,
+ true,
+ )?
+ }
+ None => "".to_owned(),
+ };
+
+ // combine prefix and mut
+ let (first_lo, first) = if !prefix.is_empty() && !mut_infix.is_empty() {
+ let hi = context.snippet_provider.span_before(self.span, "mut");
+ let lo = context.snippet_provider.span_after(self.span, "ref");
+ (
+ context.snippet_provider.span_after(self.span, "mut"),
+ combine_strs_with_missing_comments(
+ context,
+ prefix,
+ mut_infix,
+ mk_sp(lo, hi),
+ shape,
+ true,
+ )?,
+ )
+ } else if !prefix.is_empty() {
+ (
+ context.snippet_provider.span_after(self.span, "ref"),
+ prefix.to_owned(),
+ )
+ } else if !mut_infix.is_empty() {
+ (
+ context.snippet_provider.span_after(self.span, "mut"),
+ mut_infix.to_owned(),
+ )
+ } else {
+ (self.span.lo(), "".to_owned())
+ };
+
+ let next = if !sub_pat.is_empty() {
+ let hi = context.snippet_provider.span_before(self.span, "@");
+ combine_strs_with_missing_comments(
+ context,
+ id_str,
+ &sub_pat,
+ mk_sp(ident.span.hi(), hi),
+ shape,
+ true,
+ )?
+ } else {
+ id_str.to_owned()
+ };
+
+ combine_strs_with_missing_comments(
+ context,
+ &first,
+ &next,
+ mk_sp(first_lo, ident.span.lo()),
+ shape,
+ true,
+ )
+ }
+ PatKind::Wild => {
+ if 1 <= shape.width {
+ Some("_".to_owned())
+ } else {
+ None
+ }
+ }
+ PatKind::Rest => {
+ if 1 <= shape.width {
+ Some("..".to_owned())
+ } else {
+ None
+ }
+ }
+ PatKind::Range(ref lhs, ref rhs, ref end_kind) => {
+ let infix = match end_kind.node {
+ RangeEnd::Included(RangeSyntax::DotDotDot) => "...",
+ RangeEnd::Included(RangeSyntax::DotDotEq) => "..=",
+ RangeEnd::Excluded => "..",
+ };
+ let infix = if context.config.spaces_around_ranges() {
+ let lhs_spacing = match lhs {
+ None => "",
+ Some(_) => " ",
+ };
+ let rhs_spacing = match rhs {
+ None => "",
+ Some(_) => " ",
+ };
+ format!("{}{}{}", lhs_spacing, infix, rhs_spacing)
+ } else {
+ infix.to_owned()
+ };
+ rewrite_pair(
+ &RangeOperand(lhs),
+ &RangeOperand(rhs),
+ PairParts::infix(&infix),
+ context,
+ shape,
+ SeparatorPlace::Front,
+ )
+ }
+ PatKind::Ref(ref pat, mutability) => {
+ let prefix = format!("&{}", format_mutability(mutability));
+ rewrite_unary_prefix(context, &prefix, &**pat, shape)
+ }
+ PatKind::Tuple(ref items) => rewrite_tuple_pat(items, None, self.span, context, shape),
+ PatKind::Path(ref q_self, ref path) => {
+ rewrite_path(context, PathContext::Expr, q_self.as_ref(), path, shape)
+ }
- PatKind::Slice(ref slice_pat) => {
++ PatKind::TupleStruct(ref q_self, ref path, ref pat_vec) => {
++ let path_str =
++ rewrite_path(context, PathContext::Expr, q_self.as_ref(), path, shape)?;
+ rewrite_tuple_pat(pat_vec, Some(path_str), self.span, context, shape)
+ }
+ PatKind::Lit(ref expr) => expr.rewrite(context, shape),
- PatKind::Struct(_, ref path, ref fields, ellipsis) => {
- rewrite_struct_pat(path, fields, ellipsis, self.span, context, shape)
++ PatKind::Slice(ref slice_pat) if context.config.version() == Version::One => {
+ let rw: Vec<String> = slice_pat
+ .iter()
+ .map(|p| {
+ if let Some(rw) = p.rewrite(context, shape) {
+ rw
+ } else {
+ context.snippet(p.span).to_string()
+ }
+ })
+ .collect();
+ Some(format!("[{}]", rw.join(", ")))
+ }
- let path_str = rewrite_path(context, PathContext::Expr, None, path, path_shape)?;
++ PatKind::Slice(ref slice_pat) => overflow::rewrite_with_square_brackets(
++ context,
++ "",
++ slice_pat.iter(),
++ shape,
++ self.span,
++ None,
++ None,
++ ),
++ PatKind::Struct(ref qself, ref path, ref fields, ellipsis) => {
++ rewrite_struct_pat(qself, path, fields, ellipsis, self.span, context, shape)
+ }
+ PatKind::MacCall(ref mac) => {
+ rewrite_macro(mac, None, context, shape, MacroPosition::Pat)
+ }
+ PatKind::Paren(ref pat) => pat
+ .rewrite(context, shape.offset_left(1)?.sub_width(1)?)
+ .map(|inner_pat| format!("({})", inner_pat)),
+ }
+ }
+}
+
+fn rewrite_struct_pat(
++ qself: &Option<ast::QSelf>,
+ path: &ast::Path,
+ fields: &[ast::PatField],
+ ellipsis: bool,
+ span: Span,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String> {
+ // 2 = ` {`
+ let path_shape = shape.sub_width(2)?;
++ let path_str = rewrite_path(context, PathContext::Expr, qself.as_ref(), path, path_shape)?;
+
+ if fields.is_empty() && !ellipsis {
+ return Some(format!("{} {{}}", path_str));
+ }
+
+ let (ellipsis_str, terminator) = if ellipsis { (", ..", "..") } else { ("", "}") };
+
+ // 3 = ` { `, 2 = ` }`.
+ let (h_shape, v_shape) =
+ struct_lit_shape(shape, context, path_str.len() + 3, ellipsis_str.len() + 2)?;
+
+ let items = itemize_list(
+ context.snippet_provider,
+ fields.iter(),
+ terminator,
+ ",",
+ |f| {
+ if f.attrs.is_empty() {
+ f.span.lo()
+ } else {
+ f.attrs.first().unwrap().span.lo()
+ }
+ },
+ |f| f.span.hi(),
+ |f| f.rewrite(context, v_shape),
+ context.snippet_provider.span_after(span, "{"),
+ span.hi(),
+ false,
+ );
+ let item_vec = items.collect::<Vec<_>>();
+
+ let tactic = struct_lit_tactic(h_shape, context, &item_vec);
+ let nested_shape = shape_for_tactic(tactic, h_shape, v_shape);
+ let fmt = struct_lit_formatting(nested_shape, tactic, context, false);
+
+ let mut fields_str = write_list(&item_vec, &fmt)?;
+ let one_line_width = h_shape.map_or(0, |shape| shape.width);
+
+ if ellipsis {
+ if fields_str.contains('\n') || fields_str.len() > one_line_width {
+ // Add a missing trailing comma.
+ if context.config.trailing_comma() == SeparatorTactic::Never {
+ fields_str.push(',');
+ }
+ fields_str.push('\n');
+ fields_str.push_str(&nested_shape.indent.to_string(context.config));
+ } else {
+ if !fields_str.is_empty() {
+ // there are preceding struct fields being matched on
+ if tactic == DefinitiveListTactic::Vertical {
+ // if the tactic is Vertical, write_list already added a trailing ,
+ fields_str.push(' ');
+ } else {
+ fields_str.push_str(", ");
+ }
+ }
+ }
+ fields_str.push_str("..");
+ }
+
+ // ast::Pat doesn't have attrs so use &[]
+ let fields_str = wrap_struct_field(context, &[], &fields_str, shape, v_shape, one_line_width)?;
+ Some(format!("{} {{{}}}", path_str, fields_str))
+}
+
+impl Rewrite for PatField {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ let hi_pos = if let Some(last) = self.attrs.last() {
+ last.span.hi()
+ } else {
+ self.pat.span.lo()
+ };
+
+ let attrs_str = if self.attrs.is_empty() {
+ String::from("")
+ } else {
+ self.attrs.rewrite(context, shape)?
+ };
+
+ let pat_str = self.pat.rewrite(context, shape)?;
+ if self.is_shorthand {
+ combine_strs_with_missing_comments(
+ context,
+ &attrs_str,
+ &pat_str,
+ mk_sp(hi_pos, self.pat.span.lo()),
+ shape,
+ false,
+ )
+ } else {
+ let nested_shape = shape.block_indent(context.config.tab_spaces());
+ let id_str = rewrite_ident(context, self.ident);
+ let one_line_width = id_str.len() + 2 + pat_str.len();
+ let pat_and_id_str = if one_line_width <= shape.width {
+ format!("{}: {}", id_str, pat_str)
+ } else {
+ format!(
+ "{}:\n{}{}",
+ id_str,
+ nested_shape.indent.to_string(context.config),
+ self.pat.rewrite(context, nested_shape)?
+ )
+ };
+ combine_strs_with_missing_comments(
+ context,
+ &attrs_str,
+ &pat_and_id_str,
+ mk_sp(hi_pos, self.pat.span.lo()),
+ nested_shape,
+ false,
+ )
+ }
+ }
+}
+
+#[derive(Debug)]
+pub(crate) enum TuplePatField<'a> {
+ Pat(&'a ptr::P<ast::Pat>),
+ Dotdot(Span),
+}
+
+impl<'a> Rewrite for TuplePatField<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match *self {
+ TuplePatField::Pat(p) => p.rewrite(context, shape),
+ TuplePatField::Dotdot(_) => Some("..".to_string()),
+ }
+ }
+}
+
+impl<'a> Spanned for TuplePatField<'a> {
+ fn span(&self) -> Span {
+ match *self {
+ TuplePatField::Pat(p) => p.span(),
+ TuplePatField::Dotdot(span) => span,
+ }
+ }
+}
+
+impl<'a> TuplePatField<'a> {
+ fn is_dotdot(&self) -> bool {
+ match self {
+ TuplePatField::Pat(pat) => matches!(pat.kind, ast::PatKind::Rest),
+ TuplePatField::Dotdot(_) => true,
+ }
+ }
+}
+
+pub(crate) fn can_be_overflowed_pat(
+ context: &RewriteContext<'_>,
+ pat: &TuplePatField<'_>,
+ len: usize,
+) -> bool {
+ match *pat {
+ TuplePatField::Pat(pat) => match pat.kind {
+ ast::PatKind::Path(..)
+ | ast::PatKind::Tuple(..)
+ | ast::PatKind::Struct(..)
+ | ast::PatKind::TupleStruct(..) => context.use_block_indent() && len == 1,
+ ast::PatKind::Ref(ref p, _) | ast::PatKind::Box(ref p) => {
+ can_be_overflowed_pat(context, &TuplePatField::Pat(p), len)
+ }
+ ast::PatKind::Lit(ref expr) => can_be_overflowed_expr(context, expr, len),
+ _ => false,
+ },
+ TuplePatField::Dotdot(..) => false,
+ }
+}
+
+fn rewrite_tuple_pat(
+ pats: &[ptr::P<ast::Pat>],
+ path_str: Option<String>,
+ span: Span,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String> {
+ let mut pat_vec: Vec<_> = pats.iter().map(|x| TuplePatField::Pat(x)).collect();
+
+ if pat_vec.is_empty() {
+ return Some(format!("{}()", path_str.unwrap_or_default()));
+ }
+ let wildcard_suffix_len = count_wildcard_suffix_len(context, &pat_vec, span, shape);
+ let (pat_vec, span) = if context.config.condense_wildcard_suffixes() && wildcard_suffix_len >= 2
+ {
+ let new_item_count = 1 + pat_vec.len() - wildcard_suffix_len;
+ let sp = pat_vec[new_item_count - 1].span();
+ let snippet = context.snippet(sp);
+ let lo = sp.lo() + BytePos(snippet.find_uncommented("_").unwrap() as u32);
+ pat_vec[new_item_count - 1] = TuplePatField::Dotdot(mk_sp_lo_plus_one(lo));
+ (
+ &pat_vec[..new_item_count],
+ mk_sp(span.lo(), lo + BytePos(1)),
+ )
+ } else {
+ (&pat_vec[..], span)
+ };
+
+ let is_last_pat_dotdot = pat_vec.last().map_or(false, |p| p.is_dotdot());
+ let add_comma = path_str.is_none() && pat_vec.len() == 1 && !is_last_pat_dotdot;
+ let path_str = path_str.unwrap_or_default();
+
+ overflow::rewrite_with_parens(
+ &context,
+ &path_str,
+ pat_vec.iter(),
+ shape,
+ span,
+ context.config.max_width(),
+ if add_comma {
+ Some(SeparatorTactic::Always)
+ } else {
+ None
+ },
+ )
+}
+
+fn count_wildcard_suffix_len(
+ context: &RewriteContext<'_>,
+ patterns: &[TuplePatField<'_>],
+ span: Span,
+ shape: Shape,
+) -> usize {
+ let mut suffix_len = 0;
+
+ let items: Vec<_> = itemize_list(
+ context.snippet_provider,
+ patterns.iter(),
+ ")",
+ ",",
+ |item| item.span().lo(),
+ |item| item.span().hi(),
+ |item| item.rewrite(context, shape),
+ context.snippet_provider.span_after(span, "("),
+ span.hi() - BytePos(1),
+ false,
+ )
+ .collect();
+
+ for item in items
+ .iter()
+ .rev()
+ .take_while(|i| matches!(i.item, Some(ref internal_string) if internal_string == "_"))
+ {
+ suffix_len += 1;
+
+ if item.has_comment() {
+ break;
+ }
+ }
+
+ suffix_len
+}
--- /dev/null
+//! Reorder items.
+//!
+//! `mod`, `extern crate` and `use` declarations are reordered in alphabetical
+//! order. Trait items are reordered in pre-determined order (associated types
+//! and constants comes before methods).
+
+// FIXME(#2455): Reorder trait items.
+
+use std::cmp::{Ord, Ordering};
+
+use rustc_ast::ast;
+use rustc_span::{symbol::sym, Span};
+
+use crate::config::{Config, GroupImportsTactic, ImportGranularity};
+use crate::imports::{flatten_use_trees, merge_use_trees, SharedPrefix, UseSegment, UseTree};
+use crate::items::{is_mod_decl, rewrite_extern_crate, rewrite_mod};
+use crate::lists::{itemize_list, write_list, ListFormatting, ListItem};
+use crate::rewrite::RewriteContext;
+use crate::shape::Shape;
+use crate::source_map::LineRangeUtils;
+use crate::spanned::Spanned;
+use crate::utils::{contains_skip, mk_sp};
+use crate::visitor::FmtVisitor;
+
+/// Choose the ordering between the given two items.
+fn compare_items(a: &ast::Item, b: &ast::Item) -> Ordering {
+ match (&a.kind, &b.kind) {
+ (&ast::ItemKind::Mod(..), &ast::ItemKind::Mod(..)) => {
+ a.ident.as_str().cmp(&b.ident.as_str())
+ }
+ (&ast::ItemKind::ExternCrate(ref a_name), &ast::ItemKind::ExternCrate(ref b_name)) => {
+ // `extern crate foo as bar;`
+ // ^^^ Comparing this.
+ let a_orig_name = a_name.map_or_else(|| a.ident.as_str(), rustc_span::Symbol::as_str);
+ let b_orig_name = b_name.map_or_else(|| b.ident.as_str(), rustc_span::Symbol::as_str);
+ let result = a_orig_name.cmp(&b_orig_name);
+ if result != Ordering::Equal {
+ return result;
+ }
+
+ // `extern crate foo as bar;`
+ // ^^^ Comparing this.
+ match (a_name, b_name) {
+ (Some(..), None) => Ordering::Greater,
+ (None, Some(..)) => Ordering::Less,
+ (None, None) => Ordering::Equal,
+ (Some(..), Some(..)) => a.ident.as_str().cmp(&b.ident.as_str()),
+ }
+ }
+ _ => unreachable!(),
+ }
+}
+
+fn wrap_reorderable_items(
+ context: &RewriteContext<'_>,
+ list_items: &[ListItem],
+ shape: Shape,
+) -> Option<String> {
+ let fmt = ListFormatting::new(shape, context.config)
+ .separator("")
+ .align_comments(false);
+ write_list(list_items, &fmt)
+}
+
+fn rewrite_reorderable_item(
+ context: &RewriteContext<'_>,
+ item: &ast::Item,
+ shape: Shape,
+) -> Option<String> {
+ match item.kind {
+ ast::ItemKind::ExternCrate(..) => rewrite_extern_crate(context, item, shape),
+ ast::ItemKind::Mod(..) => rewrite_mod(context, item, shape),
+ _ => None,
+ }
+}
+
+/// Rewrite a list of items with reordering and/or regrouping. Every item
+/// in `items` must have the same `ast::ItemKind`. Whether reordering, regrouping,
+/// or both are done is determined from the `context`.
+fn rewrite_reorderable_or_regroupable_items(
+ context: &RewriteContext<'_>,
+ reorderable_items: &[&ast::Item],
+ shape: Shape,
+ span: Span,
+) -> Option<String> {
+ match reorderable_items[0].kind {
+ // FIXME: Remove duplicated code.
+ ast::ItemKind::Use(..) => {
+ let mut normalized_items: Vec<_> = reorderable_items
+ .iter()
+ .filter_map(|item| UseTree::from_ast_with_normalization(context, item))
+ .collect();
+ let cloned = normalized_items.clone();
+ // Add comments before merging.
+ let list_items = itemize_list(
+ context.snippet_provider,
+ cloned.iter(),
+ "",
+ ";",
+ |item| item.span().lo(),
+ |item| item.span().hi(),
+ |_item| Some("".to_owned()),
+ span.lo(),
+ span.hi(),
+ false,
+ );
+ for (item, list_item) in normalized_items.iter_mut().zip(list_items) {
+ item.list_item = Some(list_item.clone());
+ }
+ normalized_items = match context.config.imports_granularity() {
+ ImportGranularity::Crate => merge_use_trees(normalized_items, SharedPrefix::Crate),
+ ImportGranularity::Module => {
+ merge_use_trees(normalized_items, SharedPrefix::Module)
+ }
+ ImportGranularity::Item => flatten_use_trees(normalized_items),
++ ImportGranularity::One => merge_use_trees(normalized_items, SharedPrefix::One),
+ ImportGranularity::Preserve => normalized_items,
+ };
+
+ let mut regrouped_items = match context.config.group_imports() {
+ GroupImportsTactic::Preserve => vec![normalized_items],
+ GroupImportsTactic::StdExternalCrate => group_imports(normalized_items),
+ };
+
+ if context.config.reorder_imports() {
+ regrouped_items.iter_mut().for_each(|items| items.sort())
+ }
+
+ // 4 = "use ", 1 = ";"
+ let nested_shape = shape.offset_left(4)?.sub_width(1)?;
+ let item_vec: Vec<_> = regrouped_items
+ .into_iter()
+ .filter(|use_group| !use_group.is_empty())
+ .map(|use_group| {
+ let item_vec: Vec<_> = use_group
+ .into_iter()
+ .map(|use_tree| ListItem {
+ item: use_tree.rewrite_top_level(context, nested_shape),
+ ..use_tree.list_item.unwrap_or_else(ListItem::empty)
+ })
+ .collect();
+ wrap_reorderable_items(context, &item_vec, nested_shape)
+ })
+ .collect::<Option<Vec<_>>>()?;
+
+ let join_string = format!("\n\n{}", shape.indent.to_string(context.config));
+ Some(item_vec.join(&join_string))
+ }
+ _ => {
+ let list_items = itemize_list(
+ context.snippet_provider,
+ reorderable_items.iter(),
+ "",
+ ";",
+ |item| item.span().lo(),
+ |item| item.span().hi(),
+ |item| rewrite_reorderable_item(context, item, shape),
+ span.lo(),
+ span.hi(),
+ false,
+ );
+
+ let mut item_pair_vec: Vec<_> = list_items.zip(reorderable_items.iter()).collect();
+ item_pair_vec.sort_by(|a, b| compare_items(a.1, b.1));
+ let item_vec: Vec<_> = item_pair_vec.into_iter().map(|pair| pair.0).collect();
+
+ wrap_reorderable_items(context, &item_vec, shape)
+ }
+ }
+}
+
+fn contains_macro_use_attr(item: &ast::Item) -> bool {
+ crate::attr::contains_name(&item.attrs, sym::macro_use)
+}
+
+/// Divides imports into three groups, corresponding to standard, external
+/// and local imports. Sorts each subgroup.
+fn group_imports(uts: Vec<UseTree>) -> Vec<Vec<UseTree>> {
+ let mut std_imports = Vec::new();
+ let mut external_imports = Vec::new();
+ let mut local_imports = Vec::new();
+
+ for ut in uts.into_iter() {
+ if ut.path.is_empty() {
+ external_imports.push(ut);
+ continue;
+ }
+ match &ut.path[0] {
+ UseSegment::Ident(id, _) => match id.as_ref() {
+ "std" | "alloc" | "core" => std_imports.push(ut),
+ _ => external_imports.push(ut),
+ },
+ UseSegment::Slf(_) | UseSegment::Super(_) | UseSegment::Crate(_) => {
+ local_imports.push(ut)
+ }
+ // These are probably illegal here
+ UseSegment::Glob | UseSegment::List(_) => external_imports.push(ut),
+ }
+ }
+
+ vec![std_imports, external_imports, local_imports]
+}
+
+/// A simplified version of `ast::ItemKind`.
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+enum ReorderableItemKind {
+ ExternCrate,
+ Mod,
+ Use,
+ /// An item that cannot be reordered. Either has an unreorderable item kind
+ /// or an `macro_use` attribute.
+ Other,
+}
+
+impl ReorderableItemKind {
+ fn from(item: &ast::Item) -> Self {
+ match item.kind {
+ _ if contains_macro_use_attr(item) | contains_skip(&item.attrs) => {
+ ReorderableItemKind::Other
+ }
+ ast::ItemKind::ExternCrate(..) => ReorderableItemKind::ExternCrate,
+ ast::ItemKind::Mod(..) if is_mod_decl(item) => ReorderableItemKind::Mod,
+ ast::ItemKind::Use(..) => ReorderableItemKind::Use,
+ _ => ReorderableItemKind::Other,
+ }
+ }
+
+ fn is_same_item_kind(self, item: &ast::Item) -> bool {
+ ReorderableItemKind::from(item) == self
+ }
+
+ fn is_reorderable(self, config: &Config) -> bool {
+ match self {
+ ReorderableItemKind::ExternCrate => config.reorder_imports(),
+ ReorderableItemKind::Mod => config.reorder_modules(),
+ ReorderableItemKind::Use => config.reorder_imports(),
+ ReorderableItemKind::Other => false,
+ }
+ }
+
+ fn is_regroupable(self, config: &Config) -> bool {
+ match self {
+ ReorderableItemKind::ExternCrate
+ | ReorderableItemKind::Mod
+ | ReorderableItemKind::Other => false,
+ ReorderableItemKind::Use => config.group_imports() != GroupImportsTactic::Preserve,
+ }
+ }
+
+ fn in_group(self, config: &Config) -> bool {
+ match self {
+ ReorderableItemKind::ExternCrate | ReorderableItemKind::Mod => true,
+ ReorderableItemKind::Use => config.group_imports() == GroupImportsTactic::Preserve,
+ ReorderableItemKind::Other => false,
+ }
+ }
+}
+
+impl<'b, 'a: 'b> FmtVisitor<'a> {
+ /// Format items with the same item kind and reorder them, regroup them, or
+ /// both. If `in_group` is `true`, then the items separated by an empty line
+ /// will not be reordered together.
+ fn walk_reorderable_or_regroupable_items(
+ &mut self,
+ items: &[&ast::Item],
+ item_kind: ReorderableItemKind,
+ in_group: bool,
+ ) -> usize {
+ let mut last = self.parse_sess.lookup_line_range(items[0].span());
+ let item_length = items
+ .iter()
+ .take_while(|ppi| {
+ item_kind.is_same_item_kind(&***ppi)
+ && (!in_group || {
+ let current = self.parse_sess.lookup_line_range(ppi.span());
+ let in_same_group = current.lo < last.hi + 2;
+ last = current;
+ in_same_group
+ })
+ })
+ .count();
+ let items = &items[..item_length];
+
+ let at_least_one_in_file_lines = items
+ .iter()
+ .any(|item| !out_of_file_lines_range!(self, item.span));
+
+ if at_least_one_in_file_lines && !items.is_empty() {
+ let lo = items.first().unwrap().span().lo();
+ let hi = items.last().unwrap().span().hi();
+ let span = mk_sp(lo, hi);
+ let rw = rewrite_reorderable_or_regroupable_items(
+ &self.get_context(),
+ items,
+ self.shape(),
+ span,
+ );
+ self.push_rewrite(span, rw);
+ } else {
+ for item in items {
+ self.push_rewrite(item.span, None);
+ }
+ }
+
+ item_length
+ }
+
+ /// Visits and format the given items. Items are reordered If they are
+ /// consecutive and reorderable.
+ pub(crate) fn visit_items_with_reordering(&mut self, mut items: &[&ast::Item]) {
+ while !items.is_empty() {
+ // If the next item is a `use`, `extern crate` or `mod`, then extract it and any
+ // subsequent items that have the same item kind to be reordered within
+ // `walk_reorderable_items`. Otherwise, just format the next item for output.
+ let item_kind = ReorderableItemKind::from(items[0]);
+ if item_kind.is_reorderable(self.config) || item_kind.is_regroupable(self.config) {
+ let visited_items_num = self.walk_reorderable_or_regroupable_items(
+ items,
+ item_kind,
+ item_kind.in_group(self.config),
+ );
+ let (_, rest) = items.split_at(visited_items_num);
+ items = rest;
+ } else {
+ // Reaching here means items were not reordered. There must be at least
+ // one item left in `items`, so calling `unwrap()` here is safe.
+ let (item, rest) = items.split_first().unwrap();
+ self.visit_item(item);
+ items = rest;
+ }
+ }
+ }
+}
--- /dev/null
- mk_sp(self.pat.span.lo(), self.ty.span.hi())
+use std::cmp::max;
+
+use rustc_ast::{ast, ptr};
+use rustc_span::{source_map, Span};
+
+use crate::macros::MacroArg;
+use crate::utils::{mk_sp, outer_attributes};
+
+/// Spanned returns a span including attributes, if available.
+pub(crate) trait Spanned {
+ fn span(&self) -> Span;
+}
+
+impl<T: Spanned> Spanned for ptr::P<T> {
+ fn span(&self) -> Span {
+ (**self).span()
+ }
+}
+
+impl<T> Spanned for source_map::Spanned<T> {
+ fn span(&self) -> Span {
+ self.span
+ }
+}
+
+macro_rules! span_with_attrs_lo_hi {
+ ($this:ident, $lo:expr, $hi:expr) => {{
+ let attrs = outer_attributes(&$this.attrs);
+ if attrs.is_empty() {
+ mk_sp($lo, $hi)
+ } else {
+ mk_sp(attrs[0].span.lo(), $hi)
+ }
+ }};
+}
+
+macro_rules! span_with_attrs {
+ ($this:ident) => {
+ span_with_attrs_lo_hi!($this, $this.span.lo(), $this.span.hi())
+ };
+}
+
+macro_rules! implement_spanned {
+ ($this:ty) => {
+ impl Spanned for $this {
+ fn span(&self) -> Span {
+ span_with_attrs!(self)
+ }
+ }
+ };
+}
+
+// Implement `Spanned` for structs with `attrs` field.
+implement_spanned!(ast::AssocItem);
+implement_spanned!(ast::Expr);
+implement_spanned!(ast::ExprField);
+implement_spanned!(ast::ForeignItem);
+implement_spanned!(ast::Item);
+implement_spanned!(ast::Local);
+
+impl Spanned for ast::Stmt {
+ fn span(&self) -> Span {
+ match self.kind {
+ ast::StmtKind::Local(ref local) => mk_sp(local.span().lo(), self.span.hi()),
+ ast::StmtKind::Item(ref item) => mk_sp(item.span().lo(), self.span.hi()),
+ ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => {
+ mk_sp(expr.span().lo(), self.span.hi())
+ }
+ ast::StmtKind::MacCall(ref mac_stmt) => {
+ if mac_stmt.attrs.is_empty() {
+ self.span
+ } else {
+ mk_sp(mac_stmt.attrs[0].span.lo(), self.span.hi())
+ }
+ }
+ ast::StmtKind::Empty => self.span,
+ }
+ }
+}
+
+impl Spanned for ast::Pat {
+ fn span(&self) -> Span {
+ self.span
+ }
+}
+
+impl Spanned for ast::Ty {
+ fn span(&self) -> Span {
+ self.span
+ }
+}
+
+impl Spanned for ast::Arm {
+ fn span(&self) -> Span {
+ let lo = if self.attrs.is_empty() {
+ self.pat.span.lo()
+ } else {
+ self.attrs[0].span.lo()
+ };
+ span_with_attrs_lo_hi!(self, lo, self.body.span.hi())
+ }
+}
+
+impl Spanned for ast::Param {
+ fn span(&self) -> Span {
+ if crate::items::is_named_param(self) {
++ mk_sp(crate::items::span_lo_for_param(self), self.ty.span.hi())
+ } else {
+ self.ty.span
+ }
+ }
+}
+
+impl Spanned for ast::GenericParam {
+ fn span(&self) -> Span {
+ let lo = if let ast::GenericParamKind::Const {
+ ty: _,
+ kw_span,
+ default: _,
+ } = self.kind
+ {
+ kw_span.lo()
+ } else if self.attrs.is_empty() {
+ self.ident.span.lo()
+ } else {
+ self.attrs[0].span.lo()
+ };
+ let hi = if self.bounds.is_empty() {
+ self.ident.span.hi()
+ } else {
+ self.bounds.last().unwrap().span().hi()
+ };
+ let ty_hi = if let ast::GenericParamKind::Type {
+ default: Some(ref ty),
+ }
+ | ast::GenericParamKind::Const { ref ty, .. } = self.kind
+ {
+ ty.span().hi()
+ } else {
+ hi
+ };
+ mk_sp(lo, max(hi, ty_hi))
+ }
+}
+
+impl Spanned for ast::FieldDef {
+ fn span(&self) -> Span {
+ span_with_attrs_lo_hi!(self, self.span.lo(), self.ty.span.hi())
+ }
+}
+
+impl Spanned for ast::WherePredicate {
+ fn span(&self) -> Span {
+ match *self {
+ ast::WherePredicate::BoundPredicate(ref p) => p.span,
+ ast::WherePredicate::RegionPredicate(ref p) => p.span,
+ ast::WherePredicate::EqPredicate(ref p) => p.span,
+ }
+ }
+}
+
+impl Spanned for ast::FnRetTy {
+ fn span(&self) -> Span {
+ match *self {
+ ast::FnRetTy::Default(span) => span,
+ ast::FnRetTy::Ty(ref ty) => ty.span,
+ }
+ }
+}
+
+impl Spanned for ast::GenericArg {
+ fn span(&self) -> Span {
+ match *self {
+ ast::GenericArg::Lifetime(ref lt) => lt.ident.span,
+ ast::GenericArg::Type(ref ty) => ty.span(),
+ ast::GenericArg::Const(ref _const) => _const.value.span(),
+ }
+ }
+}
+
+impl Spanned for ast::GenericBound {
+ fn span(&self) -> Span {
+ match *self {
+ ast::GenericBound::Trait(ref ptr, _) => ptr.span,
+ ast::GenericBound::Outlives(ref l) => l.ident.span,
+ }
+ }
+}
+
+impl Spanned for MacroArg {
+ fn span(&self) -> Span {
+ match *self {
+ MacroArg::Expr(ref expr) => expr.span(),
+ MacroArg::Ty(ref ty) => ty.span(),
+ MacroArg::Pat(ref pat) => pat.span(),
+ MacroArg::Item(ref item) => item.span(),
+ MacroArg::Keyword(_, span) => span,
+ }
+ }
+}
+
+impl Spanned for ast::NestedMetaItem {
+ fn span(&self) -> Span {
+ self.span()
+ }
+}
--- /dev/null
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use rustc_data_structures::sync::{Lrc, Send};
+use rustc_errors::emitter::{Emitter, EmitterWriter};
+use rustc_errors::{ColorConfig, Diagnostic, Handler, Level as DiagnosticLevel};
+use rustc_session::parse::ParseSess as RawParseSess;
+use rustc_span::{
+ source_map::{FilePathMapping, SourceMap},
+ symbol, BytePos, Span,
+};
+
+use crate::config::file_lines::LineRange;
+use crate::ignore_path::IgnorePathSet;
+use crate::source_map::LineRangeUtils;
+use crate::utils::starts_with_newline;
+use crate::visitor::SnippetProvider;
+use crate::{Config, ErrorKind, FileName};
+
+/// ParseSess holds structs necessary for constructing a parser.
+pub(crate) struct ParseSess {
+ parse_sess: RawParseSess,
+ ignore_path_set: Lrc<IgnorePathSet>,
+ can_reset_errors: Lrc<AtomicBool>,
+}
+
+/// Emitter which discards every error.
+struct SilentEmitter;
+
+impl Emitter for SilentEmitter {
+ fn source_map(&self) -> Option<&Lrc<SourceMap>> {
+ None
+ }
+ fn emit_diagnostic(&mut self, _db: &Diagnostic) {}
+}
+
+fn silent_emitter() -> Box<dyn Emitter + Send> {
+ Box::new(SilentEmitter {})
+}
+
+/// Emit errors against every files expect ones specified in the `ignore_path_set`.
+struct SilentOnIgnoredFilesEmitter {
+ ignore_path_set: Lrc<IgnorePathSet>,
+ source_map: Lrc<SourceMap>,
+ emitter: Box<dyn Emitter + Send>,
+ has_non_ignorable_parser_errors: bool,
+ can_reset: Lrc<AtomicBool>,
+}
+
+impl SilentOnIgnoredFilesEmitter {
+ fn handle_non_ignoreable_error(&mut self, db: &Diagnostic) {
+ self.has_non_ignorable_parser_errors = true;
+ self.can_reset.store(false, Ordering::Release);
+ self.emitter.emit_diagnostic(db);
+ }
+}
+
+impl Emitter for SilentOnIgnoredFilesEmitter {
+ fn source_map(&self) -> Option<&Lrc<SourceMap>> {
+ None
+ }
+ fn emit_diagnostic(&mut self, db: &Diagnostic) {
+ if db.level == DiagnosticLevel::Fatal {
+ return self.handle_non_ignoreable_error(db);
+ }
+ if let Some(primary_span) = &db.span.primary_span() {
+ let file_name = self.source_map.span_to_filename(*primary_span);
+ if let rustc_span::FileName::Real(rustc_span::RealFileName::LocalPath(ref path)) =
+ file_name
+ {
+ if self
+ .ignore_path_set
+ .is_match(&FileName::Real(path.to_path_buf()))
+ {
+ if !self.has_non_ignorable_parser_errors {
+ self.can_reset.store(true, Ordering::Release);
+ }
+ return;
+ }
+ };
+ }
+ self.handle_non_ignoreable_error(db);
+ }
+}
+
+fn default_handler(
+ source_map: Lrc<SourceMap>,
+ ignore_path_set: Lrc<IgnorePathSet>,
+ can_reset: Lrc<AtomicBool>,
+ hide_parse_errors: bool,
+) -> Handler {
+ let supports_color = term::stderr().map_or(false, |term| term.supports_color());
+ let color_cfg = if supports_color {
+ ColorConfig::Auto
+ } else {
+ ColorConfig::Never
+ };
+
+ let emitter = if hide_parse_errors {
+ silent_emitter()
+ } else {
+ Box::new(EmitterWriter::stderr(
+ color_cfg,
+ Some(source_map.clone()),
+ false,
+ false,
+ None,
+ false,
+ ))
+ };
+ Handler::with_emitter(
+ true,
+ None,
+ Box::new(SilentOnIgnoredFilesEmitter {
+ has_non_ignorable_parser_errors: false,
+ source_map,
+ emitter,
+ ignore_path_set,
+ can_reset,
+ }),
+ )
+}
+
+impl ParseSess {
+ pub(crate) fn new(config: &Config) -> Result<ParseSess, ErrorKind> {
+ let ignore_path_set = match IgnorePathSet::from_ignore_list(&config.ignore()) {
+ Ok(ignore_path_set) => Lrc::new(ignore_path_set),
+ Err(e) => return Err(ErrorKind::InvalidGlobPattern(e)),
+ };
+ let source_map = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+ let can_reset_errors = Lrc::new(AtomicBool::new(false));
+
+ let handler = default_handler(
+ Lrc::clone(&source_map),
+ Lrc::clone(&ignore_path_set),
+ Lrc::clone(&can_reset_errors),
+ config.hide_parse_errors(),
+ );
+ let parse_sess = RawParseSess::with_span_handler(handler, source_map);
+
+ Ok(ParseSess {
+ parse_sess,
+ ignore_path_set,
+ can_reset_errors,
+ })
+ }
+
+ pub(crate) fn default_submod_path(
+ &self,
+ id: symbol::Ident,
+ relative: Option<symbol::Ident>,
+ dir_path: &Path,
+ ) -> Result<rustc_expand::module::ModulePathSuccess, rustc_expand::module::ModError<'_>> {
+ rustc_expand::module::default_submod_path(&self.parse_sess, id, relative, dir_path)
+ }
+
+ pub(crate) fn is_file_parsed(&self, path: &Path) -> bool {
+ self.parse_sess
+ .source_map()
+ .get_source_file(&rustc_span::FileName::Real(
+ rustc_span::RealFileName::LocalPath(path.to_path_buf()),
+ ))
+ .is_some()
+ }
+
+ pub(crate) fn ignore_file(&self, path: &FileName) -> bool {
+ self.ignore_path_set.as_ref().is_match(&path)
+ }
+
+ pub(crate) fn set_silent_emitter(&mut self) {
+ self.parse_sess.span_diagnostic = Handler::with_emitter(true, None, silent_emitter());
+ }
+
+ pub(crate) fn span_to_filename(&self, span: Span) -> FileName {
+ self.parse_sess.source_map().span_to_filename(span).into()
+ }
+
++ pub(crate) fn span_to_file_contents(&self, span: Span) -> Lrc<rustc_span::SourceFile> {
++ self.parse_sess
++ .source_map()
++ .lookup_source_file(span.data().lo)
++ }
++
+ pub(crate) fn span_to_first_line_string(&self, span: Span) -> String {
+ let file_lines = self.parse_sess.source_map().span_to_lines(span).ok();
+
+ match file_lines {
+ Some(fl) => fl
+ .file
+ .get_line(fl.lines[0].line_index)
+ .map_or_else(String::new, |s| s.to_string()),
+ None => String::new(),
+ }
+ }
+
+ pub(crate) fn line_of_byte_pos(&self, pos: BytePos) -> usize {
+ self.parse_sess.source_map().lookup_char_pos(pos).line
+ }
+
+ pub(crate) fn span_to_debug_info(&self, span: Span) -> String {
+ self.parse_sess.source_map().span_to_diagnostic_string(span)
+ }
+
+ pub(crate) fn inner(&self) -> &RawParseSess {
+ &self.parse_sess
+ }
+
+ pub(crate) fn snippet_provider(&self, span: Span) -> SnippetProvider {
+ let source_file = self.parse_sess.source_map().lookup_char_pos(span.lo()).file;
+ SnippetProvider::new(
+ source_file.start_pos,
+ source_file.end_pos,
+ Lrc::clone(source_file.src.as_ref().unwrap()),
+ )
+ }
+
+ pub(crate) fn get_original_snippet(&self, file_name: &FileName) -> Option<Lrc<String>> {
+ self.parse_sess
+ .source_map()
+ .get_source_file(&file_name.into())
+ .and_then(|source_file| source_file.src.clone())
+ }
+}
+
+// Methods that should be restricted within the syntux module.
+impl ParseSess {
+ pub(super) fn emit_diagnostics(&self, diagnostics: Vec<Diagnostic>) {
+ for diagnostic in diagnostics {
+ self.parse_sess.span_diagnostic.emit_diagnostic(&diagnostic);
+ }
+ }
+
+ pub(crate) fn emit_or_cancel_diagnostic(&self, diagnostic: &mut Diagnostic) {
+ self.parse_sess.span_diagnostic.emit_diagnostic(diagnostic);
+ // The Handler will check whether the diagnostic should be emitted
+ // based on the user's rustfmt configuration and the originating file
+ // that caused the parser error. If the Handler determined it should skip
+ // emission then we need to ensure the diagnostic is cancelled.
+ if !diagnostic.cancelled() {
+ diagnostic.cancel();
+ }
+ }
+
+ pub(super) fn can_reset_errors(&self) -> bool {
+ self.can_reset_errors.load(Ordering::Acquire)
+ }
+
+ pub(super) fn has_errors(&self) -> bool {
+ self.parse_sess.span_diagnostic.has_errors()
+ }
+
+ pub(super) fn reset_errors(&self) {
+ self.parse_sess.span_diagnostic.reset_err_count();
+ }
+}
+
+impl LineRangeUtils for ParseSess {
+ fn lookup_line_range(&self, span: Span) -> LineRange {
+ let snippet = self
+ .parse_sess
+ .source_map()
+ .span_to_snippet(span)
+ .unwrap_or_default();
+ let lo = self.parse_sess.source_map().lookup_line(span.lo()).unwrap();
+ let hi = self.parse_sess.source_map().lookup_line(span.hi()).unwrap();
+
+ debug_assert_eq!(
+ lo.sf.name, hi.sf.name,
+ "span crossed file boundary: lo: {:?}, hi: {:?}",
+ lo, hi
+ );
+
+ // in case the span starts with a newline, the line range is off by 1 without the
+ // adjustment below
+ let offset = 1 + if starts_with_newline(&snippet) { 1 } else { 0 };
+ // Line numbers start at 1
+ LineRange {
+ file: lo.sf.clone(),
+ lo: lo.line + offset,
+ hi: hi.line + offset,
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ mod emitter {
+ use super::*;
+ use crate::config::IgnoreList;
+ use crate::is_nightly_channel;
+ use crate::utils::mk_sp;
+ use rustc_span::{FileName as SourceMapFileName, MultiSpan, RealFileName, DUMMY_SP};
+ use std::path::PathBuf;
+ use std::sync::atomic::AtomicU32;
+
+ struct TestEmitter {
+ num_emitted_errors: Lrc<AtomicU32>,
+ }
+
+ impl Emitter for TestEmitter {
+ fn source_map(&self) -> Option<&Lrc<SourceMap>> {
+ None
+ }
+ fn emit_diagnostic(&mut self, _db: &Diagnostic) {
+ self.num_emitted_errors.fetch_add(1, Ordering::Release);
+ }
+ }
+
+ fn build_diagnostic(level: DiagnosticLevel, span: Option<MultiSpan>) -> Diagnostic {
+ Diagnostic {
+ level,
+ code: None,
+ message: vec![],
+ children: vec![],
+ suggestions: vec![],
+ span: span.unwrap_or_else(MultiSpan::new),
+ sort_span: DUMMY_SP,
+ is_lint: false,
+ }
+ }
+
+ fn build_emitter(
+ num_emitted_errors: Lrc<AtomicU32>,
+ can_reset: Lrc<AtomicBool>,
+ source_map: Option<Lrc<SourceMap>>,
+ ignore_list: Option<IgnoreList>,
+ ) -> SilentOnIgnoredFilesEmitter {
+ let emitter_writer = TestEmitter { num_emitted_errors };
+ let source_map =
+ source_map.unwrap_or_else(|| Lrc::new(SourceMap::new(FilePathMapping::empty())));
+ let ignore_path_set = Lrc::new(
+ IgnorePathSet::from_ignore_list(&ignore_list.unwrap_or_default()).unwrap(),
+ );
+ SilentOnIgnoredFilesEmitter {
+ has_non_ignorable_parser_errors: false,
+ source_map,
+ emitter: Box::new(emitter_writer),
+ ignore_path_set,
+ can_reset,
+ }
+ }
+
+ fn get_ignore_list(config: &str) -> IgnoreList {
+ Config::from_toml(config, Path::new("")).unwrap().ignore()
+ }
+
+ #[test]
+ fn handles_fatal_parse_error_in_ignored_file() {
+ let num_emitted_errors = Lrc::new(AtomicU32::new(0));
+ let can_reset_errors = Lrc::new(AtomicBool::new(false));
+ let ignore_list = get_ignore_list(r#"ignore = ["foo.rs"]"#);
+ let source_map = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+ let source =
+ String::from(r#"extern "system" fn jni_symbol!( funcName ) ( ... ) -> {} "#);
+ source_map.new_source_file(
+ SourceMapFileName::Real(RealFileName::LocalPath(PathBuf::from("foo.rs"))),
+ source,
+ );
+ let mut emitter = build_emitter(
+ Lrc::clone(&num_emitted_errors),
+ Lrc::clone(&can_reset_errors),
+ Some(Lrc::clone(&source_map)),
+ Some(ignore_list),
+ );
+ let span = MultiSpan::from_span(mk_sp(BytePos(0), BytePos(1)));
+ let fatal_diagnostic = build_diagnostic(DiagnosticLevel::Fatal, Some(span));
+ emitter.emit_diagnostic(&fatal_diagnostic);
+ assert_eq!(num_emitted_errors.load(Ordering::Acquire), 1);
+ assert_eq!(can_reset_errors.load(Ordering::Acquire), false);
+ }
+
+ #[test]
+ fn handles_recoverable_parse_error_in_ignored_file() {
+ if !is_nightly_channel!() {
+ return;
+ }
+ let num_emitted_errors = Lrc::new(AtomicU32::new(0));
+ let can_reset_errors = Lrc::new(AtomicBool::new(false));
+ let ignore_list = get_ignore_list(r#"ignore = ["foo.rs"]"#);
+ let source_map = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+ let source = String::from(r#"pub fn bar() { 1x; }"#);
+ source_map.new_source_file(
+ SourceMapFileName::Real(RealFileName::LocalPath(PathBuf::from("foo.rs"))),
+ source,
+ );
+ let mut emitter = build_emitter(
+ Lrc::clone(&num_emitted_errors),
+ Lrc::clone(&can_reset_errors),
+ Some(Lrc::clone(&source_map)),
+ Some(ignore_list),
+ );
+ let span = MultiSpan::from_span(mk_sp(BytePos(0), BytePos(1)));
+ let non_fatal_diagnostic = build_diagnostic(DiagnosticLevel::Warning, Some(span));
+ emitter.emit_diagnostic(&non_fatal_diagnostic);
+ assert_eq!(num_emitted_errors.load(Ordering::Acquire), 0);
+ assert_eq!(can_reset_errors.load(Ordering::Acquire), true);
+ }
+
+ #[test]
+ fn handles_recoverable_parse_error_in_non_ignored_file() {
+ if !is_nightly_channel!() {
+ return;
+ }
+ let num_emitted_errors = Lrc::new(AtomicU32::new(0));
+ let can_reset_errors = Lrc::new(AtomicBool::new(false));
+ let source_map = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+ let source = String::from(r#"pub fn bar() { 1x; }"#);
+ source_map.new_source_file(
+ SourceMapFileName::Real(RealFileName::LocalPath(PathBuf::from("foo.rs"))),
+ source,
+ );
+ let mut emitter = build_emitter(
+ Lrc::clone(&num_emitted_errors),
+ Lrc::clone(&can_reset_errors),
+ Some(Lrc::clone(&source_map)),
+ None,
+ );
+ let span = MultiSpan::from_span(mk_sp(BytePos(0), BytePos(1)));
+ let non_fatal_diagnostic = build_diagnostic(DiagnosticLevel::Warning, Some(span));
+ emitter.emit_diagnostic(&non_fatal_diagnostic);
+ assert_eq!(num_emitted_errors.load(Ordering::Acquire), 1);
+ assert_eq!(can_reset_errors.load(Ordering::Acquire), false);
+ }
+
+ #[test]
+ fn handles_mix_of_recoverable_parse_error() {
+ if !is_nightly_channel!() {
+ return;
+ }
+ let num_emitted_errors = Lrc::new(AtomicU32::new(0));
+ let can_reset_errors = Lrc::new(AtomicBool::new(false));
+ let source_map = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+ let ignore_list = get_ignore_list(r#"ignore = ["foo.rs"]"#);
+ let bar_source = String::from(r#"pub fn bar() { 1x; }"#);
+ let foo_source = String::from(r#"pub fn foo() { 1x; }"#);
+ let fatal_source =
+ String::from(r#"extern "system" fn jni_symbol!( funcName ) ( ... ) -> {} "#);
+ source_map.new_source_file(
+ SourceMapFileName::Real(RealFileName::LocalPath(PathBuf::from("bar.rs"))),
+ bar_source,
+ );
+ source_map.new_source_file(
+ SourceMapFileName::Real(RealFileName::LocalPath(PathBuf::from("foo.rs"))),
+ foo_source,
+ );
+ source_map.new_source_file(
+ SourceMapFileName::Real(RealFileName::LocalPath(PathBuf::from("fatal.rs"))),
+ fatal_source,
+ );
+ let mut emitter = build_emitter(
+ Lrc::clone(&num_emitted_errors),
+ Lrc::clone(&can_reset_errors),
+ Some(Lrc::clone(&source_map)),
+ Some(ignore_list),
+ );
+ let bar_span = MultiSpan::from_span(mk_sp(BytePos(0), BytePos(1)));
+ let foo_span = MultiSpan::from_span(mk_sp(BytePos(21), BytePos(22)));
+ let bar_diagnostic = build_diagnostic(DiagnosticLevel::Warning, Some(bar_span));
+ let foo_diagnostic = build_diagnostic(DiagnosticLevel::Warning, Some(foo_span));
+ let fatal_diagnostic = build_diagnostic(DiagnosticLevel::Fatal, None);
+ emitter.emit_diagnostic(&bar_diagnostic);
+ emitter.emit_diagnostic(&foo_diagnostic);
+ emitter.emit_diagnostic(&fatal_diagnostic);
+ assert_eq!(num_emitted_errors.load(Ordering::Acquire), 2);
+ assert_eq!(can_reset_errors.load(Ordering::Acquire), false);
+ }
+ }
+}
--- /dev/null
- match option_env!("CFG_RELEASE_CHANNEL") {
- None | Some("nightly") => {}
- // These tests require nightly.
- _ => return,
- }
+use std::collections::HashMap;
+use std::env;
+use std::fs;
+use std::io::{self, BufRead, BufReader, Read, Write};
+use std::iter::Peekable;
+use std::mem;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::str::Chars;
+use std::thread;
+
+use crate::config::{Color, Config, EmitMode, FileName, NewlineStyle, ReportTactic};
+use crate::formatting::{ReportedErrors, SourceFile};
+use crate::rustfmt_diff::{make_diff, print_diff, DiffLine, Mismatch, ModifiedChunk, OutputWriter};
+use crate::source_file;
+use crate::{is_nightly_channel, FormatReport, FormatReportFormatterBuilder, Input, Session};
+
+mod configuration_snippet;
+mod mod_resolver;
+mod parser;
+
+const DIFF_CONTEXT_SIZE: usize = 3;
+
+// A list of files on which we want to skip testing.
+const SKIP_FILE_WHITE_LIST: &[&str] = &[
+ // We want to make sure that the `skip_children` is correctly working,
+ // so we do not want to test this file directly.
+ "configs/skip_children/foo/mod.rs",
+ "issue-3434/no_entry.rs",
+ "issue-3665/sub_mod.rs",
+ // Testing for issue-3779
+ "issue-3779/ice.rs",
+ // These files and directory are a part of modules defined inside `cfg_if!`.
+ "cfg_if/mod.rs",
+ "cfg_if/detect",
+ "issue-3253/foo.rs",
+ "issue-3253/bar.rs",
+ "issue-3253/paths",
+ // These files and directory are a part of modules defined inside `cfg_attr(..)`.
+ "cfg_mod/dir",
+ "cfg_mod/bar.rs",
+ "cfg_mod/foo.rs",
+ "cfg_mod/wasm32.rs",
+ "skip/foo.rs",
+];
+
+fn init_log() {
+ let _ = env_logger::builder().is_test(true).try_init();
+}
+
+struct TestSetting {
+ /// The size of the stack of the thread that run tests.
+ stack_size: usize,
+}
+
+impl Default for TestSetting {
+ fn default() -> Self {
+ TestSetting {
+ stack_size: 8_388_608, // 8MB
+ }
+ }
+}
+
+fn run_test_with<F>(test_setting: &TestSetting, f: F)
+where
+ F: FnOnce(),
+ F: Send + 'static,
+{
+ thread::Builder::new()
+ .stack_size(test_setting.stack_size)
+ .spawn(f)
+ .expect("Failed to create a test thread")
+ .join()
+ .expect("Failed to join a test thread")
+}
+
+fn is_subpath<P>(path: &Path, subpath: &P) -> bool
+where
+ P: AsRef<Path>,
+{
+ (0..path.components().count())
+ .map(|i| {
+ path.components()
+ .skip(i)
+ .take(subpath.as_ref().components().count())
+ })
+ .any(|c| c.zip(subpath.as_ref().components()).all(|(a, b)| a == b))
+}
+
+fn is_file_skip(path: &Path) -> bool {
+ SKIP_FILE_WHITE_LIST
+ .iter()
+ .any(|file_path| is_subpath(path, file_path))
+}
+
+// Returns a `Vec` containing `PathBuf`s of files with an `rs` extension in the
+// given path. The `recursive` argument controls if files from subdirectories
+// are also returned.
+fn get_test_files(path: &Path, recursive: bool) -> Vec<PathBuf> {
+ let mut files = vec![];
+ if path.is_dir() {
+ for entry in fs::read_dir(path).expect(&format!(
+ "couldn't read directory {}",
+ path.to_str().unwrap()
+ )) {
+ let entry = entry.expect("couldn't get `DirEntry`");
+ let path = entry.path();
+ if path.is_dir() && recursive {
+ files.append(&mut get_test_files(&path, recursive));
+ } else if path.extension().map_or(false, |f| f == "rs") && !is_file_skip(&path) {
+ files.push(path);
+ }
+ }
+ }
+ files
+}
+
+fn verify_config_used(path: &Path, config_name: &str) {
+ for entry in fs::read_dir(path).expect(&format!(
+ "couldn't read {} directory",
+ path.to_str().unwrap()
+ )) {
+ let entry = entry.expect("couldn't get directory entry");
+ let path = entry.path();
+ if path.extension().map_or(false, |f| f == "rs") {
+ // check if "// rustfmt-<config_name>:" appears in the file.
+ let filebuf = BufReader::new(
+ fs::File::open(&path)
+ .unwrap_or_else(|_| panic!("couldn't read file {}", path.display())),
+ );
+ assert!(
+ filebuf
+ .lines()
+ .map(Result::unwrap)
+ .take_while(|l| l.starts_with("//"))
+ .any(|l| l.starts_with(&format!("// rustfmt-{}", config_name))),
+ "config option file {} does not contain expected config name",
+ path.display()
+ );
+ }
+ }
+}
+
+#[test]
+fn verify_config_test_names() {
+ init_log();
+ for path in &[
+ Path::new("tests/source/configs"),
+ Path::new("tests/target/configs"),
+ ] {
+ for entry in fs::read_dir(path).expect("couldn't read configs directory") {
+ let entry = entry.expect("couldn't get directory entry");
+ let path = entry.path();
+ if path.is_dir() {
+ let config_name = path.file_name().unwrap().to_str().unwrap();
+
+ // Make sure that config name is used in the files in the directory.
+ verify_config_used(&path, config_name);
+ }
+ }
+ }
+}
+
+// This writes to the terminal using the same approach (via `term::stdout` or
+// `println!`) that is used by `rustfmt::rustfmt_diff::print_diff`. Writing
+// using only one or the other will cause the output order to differ when
+// `print_diff` selects the approach not used.
+fn write_message(msg: &str) {
+ let mut writer = OutputWriter::new(Color::Auto);
+ writer.writeln(msg, None);
+}
+
+// Integration tests. The files in `tests/source` are formatted and compared
+// to their equivalent in `tests/target`. The target file and config can be
+// overridden by annotations in the source file. The input and output must match
+// exactly.
+#[test]
+fn system_tests() {
+ init_log();
+ run_test_with(&TestSetting::default(), || {
+ // Get all files in the tests/source directory.
+ let files = get_test_files(Path::new("tests/source"), true);
+ let (_reports, count, fails) = check_files(files, &None);
+
+ // Display results.
+ println!("Ran {} system tests.", count);
+ assert_eq!(fails, 0, "{} system tests failed", fails);
+ assert!(
+ count >= 300,
+ "Expected a minimum of {} system tests to be executed",
+ 300
+ )
+ });
+}
+
+// Do the same for tests/coverage-source directory.
+// The only difference is the coverage mode.
+#[test]
+fn coverage_tests() {
+ init_log();
+ let files = get_test_files(Path::new("tests/coverage/source"), true);
+ let (_reports, count, fails) = check_files(files, &None);
+
+ println!("Ran {} tests in coverage mode.", count);
+ assert_eq!(fails, 0, "{} tests failed", fails);
+}
+
+#[test]
+fn checkstyle_test() {
+ init_log();
+ let filename = "tests/writemode/source/fn-single-line.rs";
+ let expected_filename = "tests/writemode/target/checkstyle.xml";
+ assert_output(Path::new(filename), Path::new(expected_filename));
+}
+
+#[test]
+fn json_test() {
+ init_log();
+ let filename = "tests/writemode/source/json.rs";
+ let expected_filename = "tests/writemode/target/output.json";
+ assert_output(Path::new(filename), Path::new(expected_filename));
+}
+
+#[test]
+fn modified_test() {
+ init_log();
+ use std::io::BufRead;
+
+ // Test "modified" output
+ let filename = "tests/writemode/source/modified.rs";
+ let mut data = Vec::new();
+ let mut config = Config::default();
+ config
+ .set()
+ .emit_mode(crate::config::EmitMode::ModifiedLines);
+
+ {
+ let mut session = Session::new(config, Some(&mut data));
+ session.format(Input::File(filename.into())).unwrap();
+ }
+
+ let mut lines = data.lines();
+ let mut chunks = Vec::new();
+ while let Some(Ok(header)) = lines.next() {
+ // Parse the header line
+ let values: Vec<_> = header
+ .split(' ')
+ .map(|s| s.parse::<u32>().unwrap())
+ .collect();
+ assert_eq!(values.len(), 3);
+ let line_number_orig = values[0];
+ let lines_removed = values[1];
+ let num_added = values[2];
+ let mut added_lines = Vec::new();
+ for _ in 0..num_added {
+ added_lines.push(lines.next().unwrap().unwrap());
+ }
+ chunks.push(ModifiedChunk {
+ line_number_orig,
+ lines_removed,
+ lines: added_lines,
+ });
+ }
+
+ assert_eq!(
+ chunks,
+ vec![
+ ModifiedChunk {
+ line_number_orig: 4,
+ lines_removed: 4,
+ lines: vec!["fn blah() {}".into()],
+ },
+ ModifiedChunk {
+ line_number_orig: 9,
+ lines_removed: 6,
+ lines: vec!["#[cfg(a, b)]".into(), "fn main() {}".into()],
+ },
+ ],
+ );
+}
+
+// Helper function for comparing the results of rustfmt
+// to a known output file generated by one of the write modes.
+fn assert_output(source: &Path, expected_filename: &Path) {
+ let config = read_config(source);
+ let (_, source_file, _) = format_file(source, config.clone());
+
+ // Populate output by writing to a vec.
+ let mut out = vec![];
+ let _ = source_file::write_all_files(&source_file, &mut out, &config);
+ let output = String::from_utf8(out).unwrap();
+
+ let mut expected_file = fs::File::open(&expected_filename).expect("couldn't open target");
+ let mut expected_text = String::new();
+ expected_file
+ .read_to_string(&mut expected_text)
+ .expect("Failed reading target");
+
+ let compare = make_diff(&expected_text, &output, DIFF_CONTEXT_SIZE);
+ if !compare.is_empty() {
+ let mut failures = HashMap::new();
+ failures.insert(source.to_owned(), compare);
+ print_mismatches_default_message(failures);
+ panic!("Text does not match expected output");
+ }
+}
+
+// Idempotence tests. Files in tests/target are checked to be unaltered by
+// rustfmt.
+#[test]
+fn idempotence_tests() {
+ init_log();
+ run_test_with(&TestSetting::default(), || {
+ // these tests require nightly
+ if !is_nightly_channel!() {
+ return;
+ }
+ // Get all files in the tests/target directory.
+ let files = get_test_files(Path::new("tests/target"), true);
+ let (_reports, count, fails) = check_files(files, &None);
+
+ // Display results.
+ println!("Ran {} idempotent tests.", count);
+ assert_eq!(fails, 0, "{} idempotent tests failed", fails);
+ assert!(
+ count >= 400,
+ "Expected a minimum of {} idempotent tests to be executed",
+ 400
+ )
+ });
+}
+
+// Run rustfmt on itself. This operation must be idempotent. We also check that
+// no warnings are emitted.
+#[test]
+fn self_tests() {
+ init_log();
+ // Issue-3443: these tests require nightly
+ if !is_nightly_channel!() {
+ return;
+ }
+ let mut files = get_test_files(Path::new("tests"), false);
+ let bin_directories = vec!["cargo-fmt", "git-rustfmt", "bin", "format-diff"];
+ for dir in bin_directories {
+ let mut path = PathBuf::from("src");
+ path.push(dir);
+ path.push("main.rs");
+ files.push(path);
+ }
+ files.push(PathBuf::from("src/lib.rs"));
+
+ let (reports, count, fails) = check_files(files, &Some(PathBuf::from("rustfmt.toml")));
+ let mut warnings = 0;
+
+ // Display results.
+ println!("Ran {} self tests.", count);
+ assert_eq!(fails, 0, "{} self tests failed", fails);
+
+ for format_report in reports {
+ println!(
+ "{}",
+ FormatReportFormatterBuilder::new(&format_report).build()
+ );
+ warnings += format_report.warning_count();
+ }
+
+ assert_eq!(
+ warnings, 0,
+ "Rustfmt's code generated {} warnings",
+ warnings
+ );
+}
+
+#[test]
+fn format_files_find_new_files_via_cfg_if() {
+ init_log();
+ run_test_with(&TestSetting::default(), || {
+ // To repro issue-4656, it is necessary that these files are parsed
+ // as a part of the same session (hence this separate test runner).
+ let files = vec![
+ Path::new("tests/source/issue-4656/lib2.rs"),
+ Path::new("tests/source/issue-4656/lib.rs"),
+ ];
+
+ let config = Config::default();
+ let mut session = Session::<io::Stdout>::new(config, None);
+
+ let mut write_result = HashMap::new();
+ for file in files {
+ assert!(file.exists());
+ let result = session.format(Input::File(file.into())).unwrap();
+ assert!(!session.has_formatting_errors());
+ assert!(!result.has_warnings());
+ let mut source_file = SourceFile::new();
+ mem::swap(&mut session.source_file, &mut source_file);
+
+ for (filename, text) in source_file {
+ if let FileName::Real(ref filename) = filename {
+ write_result.insert(filename.to_owned(), text);
+ }
+ }
+ }
+ assert_eq!(
+ 3,
+ write_result.len(),
+ "Should have uncovered an extra file (format_me_please.rs) via lib.rs"
+ );
+ assert!(handle_result(write_result, None).is_ok());
+ });
+}
+
+#[test]
+fn stdin_formatting_smoke_test() {
+ init_log();
+ let input = Input::Text("fn main () {}".to_owned());
+ let mut config = Config::default();
+ config.set().emit_mode(EmitMode::Stdout);
+ let mut buf: Vec<u8> = vec![];
+ {
+ let mut session = Session::new(config, Some(&mut buf));
+ session.format(input).unwrap();
+ assert!(session.has_no_errors());
+ }
+
+ #[cfg(not(windows))]
+ assert_eq!(buf, "stdin:\n\nfn main() {}\n".as_bytes());
+ #[cfg(windows)]
+ assert_eq!(buf, "stdin:\n\nfn main() {}\r\n".as_bytes());
+}
+
+#[test]
+fn stdin_parser_panic_caught() {
+ init_log();
+ // See issue #3239.
+ for text in ["{", "}"].iter().cloned().map(String::from) {
+ let mut buf = vec![];
+ let mut session = Session::new(Default::default(), Some(&mut buf));
+ let _ = session.format(Input::Text(text));
+
+ assert!(session.has_parsing_errors());
+ }
+}
+
+/// Ensures that `EmitMode::ModifiedLines` works with input from `stdin`. Useful
+/// when embedding Rustfmt (e.g. inside RLS).
+#[test]
+fn stdin_works_with_modified_lines() {
+ init_log();
+ let input = "\nfn\n some( )\n{\n}\nfn main () {}\n";
+ let output = "1 6 2\nfn some() {}\nfn main() {}\n";
+
+ let input = Input::Text(input.to_owned());
+ let mut config = Config::default();
+ config.set().newline_style(NewlineStyle::Unix);
+ config.set().emit_mode(EmitMode::ModifiedLines);
+ let mut buf: Vec<u8> = vec![];
+ {
+ let mut session = Session::new(config, Some(&mut buf));
+ session.format(input).unwrap();
+ let errors = ReportedErrors {
+ has_diff: true,
+ ..Default::default()
+ };
+ assert_eq!(session.errors, errors);
+ }
+ assert_eq!(buf, output.as_bytes());
+}
+
+#[test]
+fn stdin_disable_all_formatting_test() {
+ init_log();
- .take_while(|line| line_regex.is_match(line))
+ let input = String::from("fn main() { println!(\"This should not be formatted.\"); }");
+ let mut child = Command::new(rustfmt().to_str().unwrap())
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .arg("--config-path=./tests/config/disable_all_formatting.toml")
+ .spawn()
+ .expect("failed to execute child");
+
+ {
+ let stdin = child.stdin.as_mut().expect("failed to get stdin");
+ stdin
+ .write_all(input.as_bytes())
+ .expect("failed to write stdin");
+ }
+
+ let output = child.wait_with_output().expect("failed to wait on child");
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert_eq!(input, String::from_utf8(output.stdout).unwrap());
+}
+
+#[test]
+fn format_lines_errors_are_reported() {
+ init_log();
+ let long_identifier = String::from_utf8(vec![b'a'; 239]).unwrap();
+ let input = Input::Text(format!("fn {}() {{}}", long_identifier));
+ let mut config = Config::default();
+ config.set().error_on_line_overflow(true);
+ let mut session = Session::<io::Stdout>::new(config, None);
+ session.format(input).unwrap();
+ assert!(session.has_formatting_errors());
+}
+
+#[test]
+fn format_lines_errors_are_reported_with_tabs() {
+ init_log();
+ let long_identifier = String::from_utf8(vec![b'a'; 97]).unwrap();
+ let input = Input::Text(format!("fn a() {{\n\t{}\n}}", long_identifier));
+ let mut config = Config::default();
+ config.set().error_on_line_overflow(true);
+ config.set().hard_tabs(true);
+ let mut session = Session::<io::Stdout>::new(config, None);
+ session.format(input).unwrap();
+ assert!(session.has_formatting_errors());
+}
+
+// For each file, run rustfmt and collect the output.
+// Returns the number of files checked and the number of failures.
+fn check_files(files: Vec<PathBuf>, opt_config: &Option<PathBuf>) -> (Vec<FormatReport>, u32, u32) {
+ let mut count = 0;
+ let mut fails = 0;
+ let mut reports = vec![];
+
+ for file_name in files {
+ let sig_comments = read_significant_comments(&file_name);
+ if sig_comments.contains_key("unstable") && !is_nightly_channel!() {
+ debug!(
+ "Skipping '{}' because it requires unstable \
+ features which are only available on nightly...",
+ file_name.display()
+ );
+ continue;
+ }
+
+ debug!("Testing '{}'...", file_name.display());
+
+ match idempotent_check(&file_name, &opt_config) {
+ Ok(ref report) if report.has_warnings() => {
+ print!("{}", FormatReportFormatterBuilder::new(&report).build());
+ fails += 1;
+ }
+ Ok(report) => reports.push(report),
+ Err(err) => {
+ if let IdempotentCheckError::Mismatch(msg) = err {
+ print_mismatches_default_message(msg);
+ }
+ fails += 1;
+ }
+ }
+
+ count += 1;
+ }
+
+ (reports, count, fails)
+}
+
+fn print_mismatches_default_message(result: HashMap<PathBuf, Vec<Mismatch>>) {
+ for (file_name, diff) in result {
+ let mismatch_msg_formatter =
+ |line_num| format!("\nMismatch at {}:{}:", file_name.display(), line_num);
+ print_diff(diff, &mismatch_msg_formatter, &Default::default());
+ }
+
+ if let Some(mut t) = term::stdout() {
+ t.reset().unwrap_or(());
+ }
+}
+
+fn print_mismatches<T: Fn(u32) -> String>(
+ result: HashMap<PathBuf, Vec<Mismatch>>,
+ mismatch_msg_formatter: T,
+) {
+ for (_file_name, diff) in result {
+ print_diff(diff, &mismatch_msg_formatter, &Default::default());
+ }
+
+ if let Some(mut t) = term::stdout() {
+ t.reset().unwrap_or(());
+ }
+}
+
+fn read_config(filename: &Path) -> Config {
+ let sig_comments = read_significant_comments(filename);
+ // Look for a config file. If there is a 'config' property in the significant comments, use
+ // that. Otherwise, if there are no significant comments at all, look for a config file with
+ // the same name as the test file.
+ let mut config = if !sig_comments.is_empty() {
+ get_config(sig_comments.get("config").map(Path::new))
+ } else {
+ get_config(filename.with_extension("toml").file_name().map(Path::new))
+ };
+
+ for (key, val) in &sig_comments {
+ if key != "target" && key != "config" && key != "unstable" {
+ config.override_value(key, val);
+ if config.is_default(key) {
+ warn!("Default value {} used explicitly for {}", val, key);
+ }
+ }
+ }
+
+ // Don't generate warnings for to-do items.
+ config.set().report_todo(ReportTactic::Never);
+
+ config
+}
+
+fn format_file<P: Into<PathBuf>>(filepath: P, config: Config) -> (bool, SourceFile, FormatReport) {
+ let filepath = filepath.into();
+ let input = Input::File(filepath);
+ let mut session = Session::<io::Stdout>::new(config, None);
+ let result = session.format(input).unwrap();
+ let parsing_errors = session.has_parsing_errors();
+ let mut source_file = SourceFile::new();
+ mem::swap(&mut session.source_file, &mut source_file);
+ (parsing_errors, source_file, result)
+}
+
+enum IdempotentCheckError {
+ Mismatch(HashMap<PathBuf, Vec<Mismatch>>),
+ Parse,
+}
+
+fn idempotent_check(
+ filename: &PathBuf,
+ opt_config: &Option<PathBuf>,
+) -> Result<FormatReport, IdempotentCheckError> {
+ let sig_comments = read_significant_comments(filename);
+ let config = if let Some(ref config_file_path) = opt_config {
+ Config::from_toml_path(config_file_path).expect("`rustfmt.toml` not found")
+ } else {
+ read_config(filename)
+ };
+ let (parsing_errors, source_file, format_report) = format_file(filename, config);
+ if parsing_errors {
+ return Err(IdempotentCheckError::Parse);
+ }
+
+ let mut write_result = HashMap::new();
+ for (filename, text) in source_file {
+ if let FileName::Real(ref filename) = filename {
+ write_result.insert(filename.to_owned(), text);
+ }
+ }
+
+ let target = sig_comments.get("target").map(|x| &(*x)[..]);
+
+ handle_result(write_result, target).map(|_| format_report)
+}
+
+// Reads test config file using the supplied (optional) file name. If there's no file name or the
+// file doesn't exist, just return the default config. Otherwise, the file must be read
+// successfully.
+fn get_config(config_file: Option<&Path>) -> Config {
+ let config_file_name = match config_file {
+ None => return Default::default(),
+ Some(file_name) => {
+ let mut full_path = PathBuf::from("tests/config/");
+ full_path.push(file_name);
+ if !full_path.exists() {
+ return Default::default();
+ };
+ full_path
+ }
+ };
+
+ let mut def_config_file = fs::File::open(config_file_name).expect("couldn't open config");
+ let mut def_config = String::new();
+ def_config_file
+ .read_to_string(&mut def_config)
+ .expect("Couldn't read config");
+
+ Config::from_toml(&def_config, Path::new("tests/config/")).expect("invalid TOML")
+}
+
+// Reads significant comments of the form: `// rustfmt-key: value` into a hash map.
+fn read_significant_comments(file_name: &Path) -> HashMap<String, String> {
+ let file = fs::File::open(file_name)
+ .unwrap_or_else(|_| panic!("couldn't read file {}", file_name.display()));
+ let reader = BufReader::new(file);
+ let pattern = r"^\s*//\s*rustfmt-([^:]+):\s*(\S+)";
+ let regex = regex::Regex::new(pattern).expect("failed creating pattern 1");
+
+ // Matches lines containing significant comments or whitespace.
+ let line_regex = regex::Regex::new(r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)")
+ .expect("failed creating pattern 2");
+
+ reader
+ .lines()
+ .map(|line| line.expect("failed getting line"))
++ .filter(|line| line_regex.is_match(line))
+ .filter_map(|line| {
+ regex.captures_iter(&line).next().map(|capture| {
+ (
+ capture
+ .get(1)
+ .expect("couldn't unwrap capture")
+ .as_str()
+ .to_owned(),
+ capture
+ .get(2)
+ .expect("couldn't unwrap capture")
+ .as_str()
+ .to_owned(),
+ )
+ })
+ })
+ .collect()
+}
+
+// Compares output to input.
+// TODO: needs a better name, more explanation.
+fn handle_result(
+ result: HashMap<PathBuf, String>,
+ target: Option<&str>,
+) -> Result<(), IdempotentCheckError> {
+ let mut failures = HashMap::new();
+
+ for (file_name, fmt_text) in result {
+ // If file is in tests/source, compare to file with same name in tests/target.
+ let target = get_target(&file_name, target);
+ let open_error = format!("couldn't open target {:?}", target);
+ let mut f = fs::File::open(&target).expect(&open_error);
+
+ let mut text = String::new();
+ let read_error = format!("failed reading target {:?}", target);
+ f.read_to_string(&mut text).expect(&read_error);
+
+ // Ignore LF and CRLF difference for Windows.
+ if !string_eq_ignore_newline_repr(&fmt_text, &text) {
+ let diff = make_diff(&text, &fmt_text, DIFF_CONTEXT_SIZE);
+ assert!(
+ !diff.is_empty(),
+ "Empty diff? Maybe due to a missing a newline at the end of a file?"
+ );
+ failures.insert(file_name, diff);
+ }
+ }
+
+ if failures.is_empty() {
+ Ok(())
+ } else {
+ Err(IdempotentCheckError::Mismatch(failures))
+ }
+}
+
+// Maps source file paths to their target paths.
+fn get_target(file_name: &Path, target: Option<&str>) -> PathBuf {
+ if let Some(n) = file_name
+ .components()
+ .position(|c| c.as_os_str() == "source")
+ {
+ let mut target_file_name = PathBuf::new();
+ for (i, c) in file_name.components().enumerate() {
+ if i == n {
+ target_file_name.push("target");
+ } else {
+ target_file_name.push(c.as_os_str());
+ }
+ }
+ if let Some(replace_name) = target {
+ target_file_name.with_file_name(replace_name)
+ } else {
+ target_file_name
+ }
+ } else {
+ // This is either and idempotence check or a self check.
+ file_name.to_owned()
+ }
+}
+
+#[test]
+fn rustfmt_diff_make_diff_tests() {
+ init_log();
+ let diff = make_diff("a\nb\nc\nd", "a\ne\nc\nd", 3);
+ assert_eq!(
+ diff,
+ vec![Mismatch {
+ line_number: 1,
+ line_number_orig: 1,
+ lines: vec![
+ DiffLine::Context("a".into()),
+ DiffLine::Resulting("b".into()),
+ DiffLine::Expected("e".into()),
+ DiffLine::Context("c".into()),
+ DiffLine::Context("d".into()),
+ ],
+ }]
+ );
+}
+
+#[test]
+fn rustfmt_diff_no_diff_test() {
+ init_log();
+ let diff = make_diff("a\nb\nc\nd", "a\nb\nc\nd", 3);
+ assert_eq!(diff, vec![]);
+}
+
+// Compare strings without distinguishing between CRLF and LF
+fn string_eq_ignore_newline_repr(left: &str, right: &str) -> bool {
+ let left = CharsIgnoreNewlineRepr(left.chars().peekable());
+ let right = CharsIgnoreNewlineRepr(right.chars().peekable());
+ left.eq(right)
+}
+
+struct CharsIgnoreNewlineRepr<'a>(Peekable<Chars<'a>>);
+
+impl<'a> Iterator for CharsIgnoreNewlineRepr<'a> {
+ type Item = char;
+
+ fn next(&mut self) -> Option<char> {
+ self.0.next().map(|c| {
+ if c == '\r' {
+ if *self.0.peek().unwrap_or(&'\0') == '\n' {
+ self.0.next();
+ '\n'
+ } else {
+ '\r'
+ }
+ } else {
+ c
+ }
+ })
+ }
+}
+
+#[test]
+fn string_eq_ignore_newline_repr_test() {
+ init_log();
+ assert!(string_eq_ignore_newline_repr("", ""));
+ assert!(!string_eq_ignore_newline_repr("", "abc"));
+ assert!(!string_eq_ignore_newline_repr("abc", ""));
+ assert!(string_eq_ignore_newline_repr("a\nb\nc\rd", "a\nb\r\nc\rd"));
+ assert!(string_eq_ignore_newline_repr("a\r\n\r\n\r\nb", "a\n\n\nb"));
+ assert!(!string_eq_ignore_newline_repr("a\r\nbcd", "a\nbcdefghijk"));
+}
+
+struct TempFile {
+ path: PathBuf,
+}
+
+fn make_temp_file(file_name: &'static str) -> TempFile {
+ use std::env::var;
+ use std::fs::File;
+
+ // Used in the Rust build system.
+ let target_dir = var("RUSTFMT_TEST_DIR").unwrap_or_else(|_| ".".to_owned());
+ let path = Path::new(&target_dir).join(file_name);
+
+ let mut file = File::create(&path).expect("couldn't create temp file");
+ let content = "fn main() {}\n";
+ file.write_all(content.as_bytes())
+ .expect("couldn't write temp file");
+ TempFile { path }
+}
+
+impl Drop for TempFile {
+ fn drop(&mut self) {
+ use std::fs::remove_file;
+ remove_file(&self.path).expect("couldn't delete temp file");
+ }
+}
+
+fn rustfmt() -> PathBuf {
+ let mut me = env::current_exe().expect("failed to get current executable");
+ // Chop of the test name.
+ me.pop();
+ // Chop off `deps`.
+ me.pop();
+
+ // If we run `cargo test --release`, we might only have a release build.
+ if cfg!(release) {
+ // `../release/`
+ me.pop();
+ me.push("release");
+ }
+ me.push("rustfmt");
+ assert!(
+ me.is_file() || me.with_extension("exe").is_file(),
+ "{}",
+ if cfg!(release) {
+ "no rustfmt bin, try running `cargo build --release` before testing"
+ } else {
+ "no rustfmt bin, try running `cargo build` before testing"
+ }
+ );
+ me
+}
+
+#[test]
+fn verify_check_works() {
+ init_log();
+ let temp_file = make_temp_file("temp_check.rs");
+
+ Command::new(rustfmt().to_str().unwrap())
+ .arg("--check")
+ .arg(temp_file.path.to_str().unwrap())
+ .status()
+ .expect("run with check option failed");
+}
--- /dev/null
- SegmentParam::Binding(assoc_ty_constraint) => {
- let mut result = match assoc_ty_constraint.kind {
- ast::AssocTyConstraintKind::Bound { .. } => {
- format!("{}: ", rewrite_ident(context, assoc_ty_constraint.ident))
- }
- ast::AssocTyConstraintKind::Equality { .. } => {
- match context.config.type_punctuation_density() {
- TypeDensity::Wide => {
- format!("{} = ", rewrite_ident(context, assoc_ty_constraint.ident))
- }
- TypeDensity::Compressed => {
- format!("{}=", rewrite_ident(context, assoc_ty_constraint.ident))
- }
- }
- }
- };
+use std::iter::ExactSizeIterator;
+use std::ops::Deref;
+
+use rustc_ast::ast::{self, FnRetTy, Mutability};
+use rustc_span::{symbol::kw, BytePos, Pos, Span};
+
+use crate::comment::{combine_strs_with_missing_comments, contains_comment};
+use crate::config::lists::*;
+use crate::config::{IndentStyle, TypeDensity, Version};
+use crate::expr::{
+ format_expr, rewrite_assign_rhs, rewrite_call, rewrite_tuple, rewrite_unary_prefix, ExprType,
+};
+use crate::lists::{
+ definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
+};
+use crate::macros::{rewrite_macro, MacroPosition};
+use crate::overflow;
+use crate::pairs::{rewrite_pair, PairParts};
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::Shape;
+use crate::source_map::SpanUtils;
+use crate::spanned::Spanned;
+use crate::utils::{
+ colon_spaces, extra_offset, first_line_width, format_extern, format_mutability,
+ last_line_extendable, last_line_width, mk_sp, rewrite_ident,
+};
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) enum PathContext {
+ Expr,
+ Type,
+ Import,
+}
+
+// Does not wrap on simple segments.
+pub(crate) fn rewrite_path(
+ context: &RewriteContext<'_>,
+ path_context: PathContext,
+ qself: Option<&ast::QSelf>,
+ path: &ast::Path,
+ shape: Shape,
+) -> Option<String> {
+ let skip_count = qself.map_or(0, |x| x.position);
+
+ let mut result = if path.is_global() && qself.is_none() && path_context != PathContext::Import {
+ "::".to_owned()
+ } else {
+ String::new()
+ };
+
+ let mut span_lo = path.span.lo();
+
+ if let Some(qself) = qself {
+ result.push('<');
+
+ let fmt_ty = qself.ty.rewrite(context, shape)?;
+ result.push_str(&fmt_ty);
+
+ if skip_count > 0 {
+ result.push_str(" as ");
+ if path.is_global() && path_context != PathContext::Import {
+ result.push_str("::");
+ }
+
+ // 3 = ">::".len()
+ let shape = shape.sub_width(3)?;
+
+ result = rewrite_path_segments(
+ PathContext::Type,
+ result,
+ path.segments.iter().take(skip_count),
+ span_lo,
+ path.span.hi(),
+ context,
+ shape,
+ )?;
+ }
+
+ result.push_str(">::");
+ span_lo = qself.ty.span.hi() + BytePos(1);
+ }
+
+ rewrite_path_segments(
+ path_context,
+ result,
+ path.segments.iter().skip(skip_count),
+ span_lo,
+ path.span.hi(),
+ context,
+ shape,
+ )
+}
+
+fn rewrite_path_segments<'a, I>(
+ path_context: PathContext,
+ mut buffer: String,
+ iter: I,
+ mut span_lo: BytePos,
+ span_hi: BytePos,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String>
+where
+ I: Iterator<Item = &'a ast::PathSegment>,
+{
+ let mut first = true;
+ let shape = shape.visual_indent(0);
+
+ for segment in iter {
+ // Indicates a global path, shouldn't be rendered.
+ if segment.ident.name == kw::PathRoot {
+ continue;
+ }
+ if first {
+ first = false;
+ } else {
+ buffer.push_str("::");
+ }
+
+ let extra_offset = extra_offset(&buffer, shape);
+ let new_shape = shape.shrink_left(extra_offset)?;
+ let segment_string = rewrite_segment(
+ path_context,
+ segment,
+ &mut span_lo,
+ span_hi,
+ context,
+ new_shape,
+ )?;
+
+ buffer.push_str(&segment_string);
+ }
+
+ Some(buffer)
+}
+
+#[derive(Debug)]
+pub(crate) enum SegmentParam<'a> {
+ Const(&'a ast::AnonConst),
+ LifeTime(&'a ast::Lifetime),
+ Type(&'a ast::Ty),
+ Binding(&'a ast::AssocTyConstraint),
+}
+
+impl<'a> SegmentParam<'a> {
+ fn from_generic_arg(arg: &ast::GenericArg) -> SegmentParam<'_> {
+ match arg {
+ ast::GenericArg::Lifetime(ref lt) => SegmentParam::LifeTime(lt),
+ ast::GenericArg::Type(ref ty) => SegmentParam::Type(ty),
+ ast::GenericArg::Const(const_) => SegmentParam::Const(const_),
+ }
+ }
+}
+
+impl<'a> Spanned for SegmentParam<'a> {
+ fn span(&self) -> Span {
+ match *self {
+ SegmentParam::Const(const_) => const_.value.span,
+ SegmentParam::LifeTime(lt) => lt.ident.span,
+ SegmentParam::Type(ty) => ty.span,
+ SegmentParam::Binding(binding) => binding.span,
+ }
+ }
+}
+
+impl<'a> Rewrite for SegmentParam<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match *self {
+ SegmentParam::Const(const_) => const_.rewrite(context, shape),
+ SegmentParam::LifeTime(lt) => lt.rewrite(context, shape),
+ SegmentParam::Type(ty) => ty.rewrite(context, shape),
- let budget = shape.width.checked_sub(result.len())?;
- let rewrite = assoc_ty_constraint
- .kind
- .rewrite(context, Shape::legacy(budget, shape.indent + result.len()))?;
- result.push_str(&rewrite);
- Some(result)
- }
++ SegmentParam::Binding(atc) => atc.rewrite(context, shape),
++ }
++ }
++}
+
- let param_list = data
- .args
- .iter()
- .map(|x| match x {
- ast::AngleBracketedArg::Arg(generic_arg) => {
- SegmentParam::from_generic_arg(generic_arg)
- }
- ast::AngleBracketedArg::Constraint(constraint) => {
- SegmentParam::Binding(constraint)
- }
- })
- .collect::<Vec<_>>();
-
++impl Rewrite for ast::AssocTyConstraint {
++ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
++ use ast::AssocTyConstraintKind::{Bound, Equality};
++
++ let mut result = String::with_capacity(128);
++ result.push_str(rewrite_ident(context, self.ident));
++
++ if let Some(ref gen_args) = self.gen_args {
++ let budget = shape.width.checked_sub(result.len())?;
++ let shape = Shape::legacy(budget, shape.indent + result.len());
++ let gen_str = rewrite_generic_args(gen_args, context, shape, gen_args.span())?;
++ result.push_str(&gen_str);
+ }
++
++ let infix = match (&self.kind, context.config.type_punctuation_density()) {
++ (Bound { .. }, _) => ": ",
++ (Equality { .. }, TypeDensity::Wide) => " = ",
++ (Equality { .. }, TypeDensity::Compressed) => "=",
++ };
++ result.push_str(infix);
++
++ let budget = shape.width.checked_sub(result.len())?;
++ let shape = Shape::legacy(budget, shape.indent + result.len());
++ let rewrite = self.kind.rewrite(context, shape)?;
++ result.push_str(&rewrite);
++
++ Some(result)
+ }
+}
+
+impl Rewrite for ast::AssocTyConstraintKind {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match self {
+ ast::AssocTyConstraintKind::Equality { ty } => ty.rewrite(context, shape),
+ ast::AssocTyConstraintKind::Bound { bounds } => bounds.rewrite(context, shape),
+ }
+ }
+}
+
+// Formats a path segment. There are some hacks involved to correctly determine
+// the segment's associated span since it's not part of the AST.
+//
+// The span_lo is assumed to be greater than the end of any previous segment's
+// parameters and lesser or equal than the start of current segment.
+//
+// span_hi is assumed equal to the end of the entire path.
+//
+// When the segment contains a positive number of parameters, we update span_lo
+// so that invariants described above will hold for the next segment.
+fn rewrite_segment(
+ path_context: PathContext,
+ segment: &ast::PathSegment,
+ span_lo: &mut BytePos,
+ span_hi: BytePos,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String> {
+ let mut result = String::with_capacity(128);
+ result.push_str(rewrite_ident(context, segment.ident));
+
+ let ident_len = result.len();
+ let shape = if context.use_block_indent() {
+ shape.offset_left(ident_len)?
+ } else {
+ shape.shrink_left(ident_len)?
+ };
+
+ if let Some(ref args) = segment.args {
++ let generics_str = rewrite_generic_args(args, context, shape, mk_sp(*span_lo, span_hi))?;
+ match **args {
+ ast::GenericArgs::AngleBracketed(ref data) if !data.args.is_empty() => {
- let generics_str = overflow::rewrite_with_angle_brackets(
- context,
- "",
- param_list.iter(),
- shape,
- mk_sp(*span_lo, span_hi),
- )?;
-
+ // HACK: squeeze out the span between the identifier and the parameters.
+ // The hack is requried so that we don't remove the separator inside macro calls.
+ // This does not work in the presence of comment, hoping that people are
+ // sane about where to put their comment.
+ let separator_snippet = context
+ .snippet(mk_sp(segment.ident.span.hi(), data.span.lo()))
+ .trim();
+ let force_separator = context.inside_macro() && separator_snippet.starts_with("::");
+ let separator = if path_context == PathContext::Expr || force_separator {
+ "::"
+ } else {
+ ""
+ };
+ result.push_str(separator);
+
-
- result.push_str(&generics_str)
- }
- ast::GenericArgs::Parenthesized(ref data) => {
- result.push_str(&format_function_type(
- data.inputs.iter().map(|x| &**x),
- &data.output,
- false,
- data.span,
- context,
- shape,
- )?);
+ // Update position of last bracket.
+ *span_lo = context
+ .snippet_provider
+ .span_after(mk_sp(*span_lo, span_hi), "<");
- default: _,
+ }
+ _ => (),
+ }
++ result.push_str(&generics_str)
+ }
+
+ Some(result)
+}
+
+fn format_function_type<'a, I>(
+ inputs: I,
+ output: &FnRetTy,
+ variadic: bool,
+ span: Span,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String>
+where
+ I: ExactSizeIterator,
+ <I as Iterator>::Item: Deref,
+ <I::Item as Deref>::Target: Rewrite + Spanned + 'a,
+{
+ debug!("format_function_type {:#?}", shape);
+
+ let ty_shape = match context.config.indent_style() {
+ // 4 = " -> "
+ IndentStyle::Block => shape.offset_left(4)?,
+ IndentStyle::Visual => shape.block_left(4)?,
+ };
+ let output = match *output {
+ FnRetTy::Ty(ref ty) => {
+ let type_str = ty.rewrite(context, ty_shape)?;
+ format!(" -> {}", type_str)
+ }
+ FnRetTy::Default(..) => String::new(),
+ };
+
+ let list_shape = if context.use_block_indent() {
+ Shape::indented(
+ shape.block().indent.block_indent(context.config),
+ context.config,
+ )
+ } else {
+ // 2 for ()
+ let budget = shape.width.checked_sub(2)?;
+ // 1 for (
+ let offset = shape.indent + 1;
+ Shape::legacy(budget, offset)
+ };
+
+ let is_inputs_empty = inputs.len() == 0;
+ let list_lo = context.snippet_provider.span_after(span, "(");
+ let (list_str, tactic) = if is_inputs_empty {
+ let tactic = get_tactics(&[], &output, shape);
+ let list_hi = context.snippet_provider.span_before(span, ")");
+ let comment = context
+ .snippet_provider
+ .span_to_snippet(mk_sp(list_lo, list_hi))?
+ .trim();
+ let comment = if comment.starts_with("//") {
+ format!(
+ "{}{}{}",
+ &list_shape.indent.to_string_with_newline(context.config),
+ comment,
+ &shape.block().indent.to_string_with_newline(context.config)
+ )
+ } else {
+ comment.to_string()
+ };
+ (comment, tactic)
+ } else {
+ let items = itemize_list(
+ context.snippet_provider,
+ inputs,
+ ")",
+ ",",
+ |arg| arg.span().lo(),
+ |arg| arg.span().hi(),
+ |arg| arg.rewrite(context, list_shape),
+ list_lo,
+ span.hi(),
+ false,
+ );
+
+ let item_vec: Vec<_> = items.collect();
+ let tactic = get_tactics(&item_vec, &output, shape);
+ let trailing_separator = if !context.use_block_indent() || variadic {
+ SeparatorTactic::Never
+ } else {
+ context.config.trailing_comma()
+ };
+
+ let fmt = ListFormatting::new(list_shape, context.config)
+ .tactic(tactic)
+ .trailing_separator(trailing_separator)
+ .ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
+ .preserve_newline(true);
+ (write_list(&item_vec, &fmt)?, tactic)
+ };
+
+ let args = if tactic == DefinitiveListTactic::Horizontal
+ || !context.use_block_indent()
+ || is_inputs_empty
+ {
+ format!("({})", list_str)
+ } else {
+ format!(
+ "({}{}{})",
+ list_shape.indent.to_string_with_newline(context.config),
+ list_str,
+ shape.block().indent.to_string_with_newline(context.config),
+ )
+ };
+ if output.is_empty() || last_line_width(&args) + first_line_width(&output) <= shape.width {
+ Some(format!("{}{}", args, output))
+ } else {
+ Some(format!(
+ "{}\n{}{}",
+ args,
+ list_shape.indent.to_string(context.config),
+ output.trim_start()
+ ))
+ }
+}
+
+fn type_bound_colon(context: &RewriteContext<'_>) -> &'static str {
+ colon_spaces(context.config)
+}
+
+// If the return type is multi-lined, then force to use multiple lines for
+// arguments as well.
+fn get_tactics(item_vec: &[ListItem], output: &str, shape: Shape) -> DefinitiveListTactic {
+ if output.contains('\n') {
+ DefinitiveListTactic::Vertical
+ } else {
+ definitive_tactic(
+ item_vec,
+ ListTactic::HorizontalVertical,
+ Separator::Comma,
+ // 2 is for the case of ',\n'
+ shape.width.saturating_sub(2 + output.len()),
+ )
+ }
+}
+
+impl Rewrite for ast::WherePredicate {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ // FIXME: dead spans?
+ let result = match *self {
+ ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
+ ref bound_generic_params,
+ ref bounded_ty,
+ ref bounds,
+ ..
+ }) => {
+ let type_str = bounded_ty.rewrite(context, shape)?;
+ let colon = type_bound_colon(context).trim_end();
+ let lhs = if let Some(lifetime_str) =
+ rewrite_lifetime_param(context, shape, bound_generic_params)
+ {
+ format!("for<{}> {}{}", lifetime_str, type_str, colon)
+ } else {
+ format!("{}{}", type_str, colon)
+ };
+
+ rewrite_assign_rhs(context, lhs, bounds, shape)?
+ }
+ ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate {
+ ref lifetime,
+ ref bounds,
+ ..
+ }) => rewrite_bounded_lifetime(lifetime, bounds, context, shape)?,
+ ast::WherePredicate::EqPredicate(ast::WhereEqPredicate {
+ ref lhs_ty,
+ ref rhs_ty,
+ ..
+ }) => {
+ let lhs_ty_str = lhs_ty.rewrite(context, shape).map(|lhs| lhs + " =")?;
+ rewrite_assign_rhs(context, lhs_ty_str, &**rhs_ty, shape)?
+ }
+ };
+
+ Some(result)
+ }
+}
+
+impl Rewrite for ast::GenericArg {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match *self {
+ ast::GenericArg::Lifetime(ref lt) => lt.rewrite(context, shape),
+ ast::GenericArg::Type(ref ty) => ty.rewrite(context, shape),
+ ast::GenericArg::Const(ref const_) => const_.rewrite(context, shape),
+ }
+ }
+}
+
++fn rewrite_generic_args(
++ gen_args: &ast::GenericArgs,
++ context: &RewriteContext<'_>,
++ shape: Shape,
++ span: Span,
++) -> Option<String> {
++ match gen_args {
++ ast::GenericArgs::AngleBracketed(ref data) if !data.args.is_empty() => {
++ let args = data
++ .args
++ .iter()
++ .map(|x| match x {
++ ast::AngleBracketedArg::Arg(generic_arg) => {
++ SegmentParam::from_generic_arg(generic_arg)
++ }
++ ast::AngleBracketedArg::Constraint(constraint) => {
++ SegmentParam::Binding(constraint)
++ }
++ })
++ .collect::<Vec<_>>();
++
++ overflow::rewrite_with_angle_brackets(context, "", args.iter(), shape, span)
++ }
++ ast::GenericArgs::Parenthesized(ref data) => format_function_type(
++ data.inputs.iter().map(|x| &**x),
++ &data.output,
++ false,
++ data.span,
++ context,
++ shape,
++ ),
++ _ => Some("".to_owned()),
++ }
++}
++
+fn rewrite_bounded_lifetime(
+ lt: &ast::Lifetime,
+ bounds: &[ast::GenericBound],
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String> {
+ let result = lt.rewrite(context, shape)?;
+
+ if bounds.is_empty() {
+ Some(result)
+ } else {
+ let colon = type_bound_colon(context);
+ let overhead = last_line_width(&result) + colon.len();
+ let result = format!(
+ "{}{}{}",
+ result,
+ colon,
+ join_bounds(context, shape.sub_width(overhead)?, bounds, true)?
+ );
+ Some(result)
+ }
+}
+
+impl Rewrite for ast::AnonConst {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ format_expr(&self.value, ExprType::SubExpression, context, shape)
+ }
+}
+
+impl Rewrite for ast::Lifetime {
+ fn rewrite(&self, context: &RewriteContext<'_>, _: Shape) -> Option<String> {
+ Some(rewrite_ident(context, self.ident).to_owned())
+ }
+}
+
+impl Rewrite for ast::GenericBound {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match *self {
+ ast::GenericBound::Trait(ref poly_trait_ref, trait_bound_modifier) => {
+ let snippet = context.snippet(self.span());
+ let has_paren = snippet.starts_with('(') && snippet.ends_with(')');
+ let rewrite = match trait_bound_modifier {
+ ast::TraitBoundModifier::None => poly_trait_ref.rewrite(context, shape),
+ ast::TraitBoundModifier::Maybe => poly_trait_ref
+ .rewrite(context, shape.offset_left(1)?)
+ .map(|s| format!("?{}", s)),
+ ast::TraitBoundModifier::MaybeConst => poly_trait_ref
+ .rewrite(context, shape.offset_left(7)?)
+ .map(|s| format!("~const {}", s)),
+ ast::TraitBoundModifier::MaybeConstMaybe => poly_trait_ref
+ .rewrite(context, shape.offset_left(8)?)
+ .map(|s| format!("~const ?{}", s)),
+ };
+ rewrite.map(|s| if has_paren { format!("({})", s) } else { s })
+ }
+ ast::GenericBound::Outlives(ref lifetime) => lifetime.rewrite(context, shape),
+ }
+ }
+}
+
+impl Rewrite for ast::GenericBounds {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ if self.is_empty() {
+ return Some(String::new());
+ }
+
+ join_bounds(context, shape, self, true)
+ }
+}
+
+impl Rewrite for ast::GenericParam {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ let mut result = String::with_capacity(128);
+ // FIXME: If there are more than one attributes, this will force multiline.
+ match self.attrs.rewrite(context, shape) {
+ Some(ref rw) if !rw.is_empty() => result.push_str(&format!("{} ", rw)),
+ _ => (),
+ }
+
+ if let ast::GenericParamKind::Const {
+ ref ty,
+ kw_span: _,
++ default,
+ } = &self.kind
+ {
+ result.push_str("const ");
+ result.push_str(rewrite_ident(context, self.ident));
+ result.push_str(": ");
+ result.push_str(&ty.rewrite(context, shape)?);
++ if let Some(default) = default {
++ let eq_str = match context.config.type_punctuation_density() {
++ TypeDensity::Compressed => "=",
++ TypeDensity::Wide => " = ",
++ };
++ result.push_str(eq_str);
++ let budget = shape.width.checked_sub(result.len())?;
++ let rewrite = default.rewrite(context, Shape::legacy(budget, shape.indent))?;
++ result.push_str(&rewrite);
++ }
+ } else {
+ result.push_str(rewrite_ident(context, self.ident));
+ }
+
+ if !self.bounds.is_empty() {
+ result.push_str(type_bound_colon(context));
+ result.push_str(&self.bounds.rewrite(context, shape)?)
+ }
+ if let ast::GenericParamKind::Type {
+ default: Some(ref def),
+ } = self.kind
+ {
+ let eq_str = match context.config.type_punctuation_density() {
+ TypeDensity::Compressed => "=",
+ TypeDensity::Wide => " = ",
+ };
+ result.push_str(eq_str);
+ let budget = shape.width.checked_sub(result.len())?;
+ let rewrite =
+ def.rewrite(context, Shape::legacy(budget, shape.indent + result.len()))?;
+ result.push_str(&rewrite);
+ }
+
+ Some(result)
+ }
+}
+
+impl Rewrite for ast::PolyTraitRef {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ if let Some(lifetime_str) =
+ rewrite_lifetime_param(context, shape, &self.bound_generic_params)
+ {
+ // 6 is "for<> ".len()
+ let extra_offset = lifetime_str.len() + 6;
+ let path_str = self
+ .trait_ref
+ .rewrite(context, shape.offset_left(extra_offset)?)?;
+
+ Some(format!("for<{}> {}", lifetime_str, path_str))
+ } else {
+ self.trait_ref.rewrite(context, shape)
+ }
+ }
+}
+
+impl Rewrite for ast::TraitRef {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ rewrite_path(context, PathContext::Type, None, &self.path, shape)
+ }
+}
+
+impl Rewrite for ast::Ty {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ match self.kind {
+ ast::TyKind::TraitObject(ref bounds, tobj_syntax) => {
+ // we have to consider 'dyn' keyword is used or not!!!
+ let is_dyn = tobj_syntax == ast::TraitObjectSyntax::Dyn;
+ // 4 is length of 'dyn '
+ let shape = if is_dyn { shape.offset_left(4)? } else { shape };
+ let mut res = bounds.rewrite(context, shape)?;
+ // We may have falsely removed a trailing `+` inside macro call.
+ if context.inside_macro() && bounds.len() == 1 {
+ if context.snippet(self.span).ends_with('+') && !res.ends_with('+') {
+ res.push('+');
+ }
+ }
+ if is_dyn {
+ Some(format!("dyn {}", res))
+ } else {
+ Some(res)
+ }
+ }
+ ast::TyKind::Ptr(ref mt) => {
+ let prefix = match mt.mutbl {
+ Mutability::Mut => "*mut ",
+ Mutability::Not => "*const ",
+ };
+
+ rewrite_unary_prefix(context, prefix, &*mt.ty, shape)
+ }
+ ast::TyKind::Rptr(ref lifetime, ref mt) => {
+ let mut_str = format_mutability(mt.mutbl);
+ let mut_len = mut_str.len();
+ let mut result = String::with_capacity(128);
+ result.push('&');
+ let ref_hi = context.snippet_provider.span_after(self.span(), "&");
+ let mut cmnt_lo = ref_hi;
+
+ if let Some(ref lifetime) = *lifetime {
+ let lt_budget = shape.width.checked_sub(2 + mut_len)?;
+ let lt_str = lifetime.rewrite(
+ context,
+ Shape::legacy(lt_budget, shape.indent + 2 + mut_len),
+ )?;
+ let before_lt_span = mk_sp(cmnt_lo, lifetime.ident.span.lo());
+ if contains_comment(context.snippet(before_lt_span)) {
+ result = combine_strs_with_missing_comments(
+ context,
+ &result,
+ <_str,
+ before_lt_span,
+ shape,
+ true,
+ )?;
+ } else {
+ result.push_str(<_str);
+ }
+ result.push(' ');
+ cmnt_lo = lifetime.ident.span.hi();
+ }
+
+ if ast::Mutability::Mut == mt.mutbl {
+ let mut_hi = context.snippet_provider.span_after(self.span(), "mut");
+ let before_mut_span = mk_sp(cmnt_lo, mut_hi - BytePos::from_usize(3));
+ if contains_comment(context.snippet(before_mut_span)) {
+ result = combine_strs_with_missing_comments(
+ context,
+ result.trim_end(),
+ mut_str,
+ before_mut_span,
+ shape,
+ true,
+ )?;
+ } else {
+ result.push_str(mut_str);
+ }
+ cmnt_lo = mut_hi;
+ }
+
+ let before_ty_span = mk_sp(cmnt_lo, mt.ty.span.lo());
+ if contains_comment(context.snippet(before_ty_span)) {
+ result = combine_strs_with_missing_comments(
+ context,
+ result.trim_end(),
+ &mt.ty.rewrite(&context, shape)?,
+ before_ty_span,
+ shape,
+ true,
+ )?;
+ } else {
+ let used_width = last_line_width(&result);
+ let budget = shape.width.checked_sub(used_width)?;
+ let ty_str = mt
+ .ty
+ .rewrite(&context, Shape::legacy(budget, shape.indent + used_width))?;
+ result.push_str(&ty_str);
+ }
+
+ Some(result)
+ }
+ // FIXME: we drop any comments here, even though it's a silly place to put
+ // comments.
+ ast::TyKind::Paren(ref ty) => {
+ if context.config.version() == Version::One
+ || context.config.indent_style() == IndentStyle::Visual
+ {
+ let budget = shape.width.checked_sub(2)?;
+ return ty
+ .rewrite(context, Shape::legacy(budget, shape.indent + 1))
+ .map(|ty_str| format!("({})", ty_str));
+ }
+
+ // 2 = ()
+ if let Some(sh) = shape.sub_width(2) {
+ if let Some(ref s) = ty.rewrite(context, sh) {
+ if !s.contains('\n') {
+ return Some(format!("({})", s));
+ }
+ }
+ }
+
+ let indent_str = shape.indent.to_string_with_newline(context.config);
+ let shape = shape
+ .block_indent(context.config.tab_spaces())
+ .with_max_width(context.config);
+ let rw = ty.rewrite(context, shape)?;
+ Some(format!(
+ "({}{}{})",
+ shape.to_string_with_newline(context.config),
+ rw,
+ indent_str
+ ))
+ }
+ ast::TyKind::Slice(ref ty) => {
+ let budget = shape.width.checked_sub(4)?;
+ ty.rewrite(context, Shape::legacy(budget, shape.indent + 1))
+ .map(|ty_str| format!("[{}]", ty_str))
+ }
+ ast::TyKind::Tup(ref items) => {
+ rewrite_tuple(context, items.iter(), self.span, shape, items.len() == 1)
+ }
+ ast::TyKind::Path(ref q_self, ref path) => {
+ rewrite_path(context, PathContext::Type, q_self.as_ref(), path, shape)
+ }
+ ast::TyKind::Array(ref ty, ref repeats) => rewrite_pair(
+ &**ty,
+ &*repeats.value,
+ PairParts::new("[", "; ", "]"),
+ context,
+ shape,
+ SeparatorPlace::Back,
+ ),
+ ast::TyKind::Infer => {
+ if shape.width >= 1 {
+ Some("_".to_owned())
+ } else {
+ None
+ }
+ }
+ ast::TyKind::BareFn(ref bare_fn) => rewrite_bare_fn(bare_fn, self.span, context, shape),
+ ast::TyKind::Never => Some(String::from("!")),
+ ast::TyKind::MacCall(ref mac) => {
+ rewrite_macro(mac, None, context, shape, MacroPosition::Expression)
+ }
+ ast::TyKind::ImplicitSelf => Some(String::from("")),
+ ast::TyKind::ImplTrait(_, ref it) => {
+ // Empty trait is not a parser error.
+ if it.is_empty() {
+ return Some("impl".to_owned());
+ }
+ let rw = if context.config.version() == Version::One {
+ it.rewrite(context, shape)
+ } else {
+ join_bounds(context, shape, it, false)
+ };
+ rw.map(|it_str| {
+ let space = if it_str.is_empty() { "" } else { " " };
+ format!("impl{}{}", space, it_str)
+ })
+ }
+ ast::TyKind::CVarArgs => Some("...".to_owned()),
+ ast::TyKind::Err => Some(context.snippet(self.span).to_owned()),
+ ast::TyKind::Typeof(ref anon_const) => rewrite_call(
+ context,
+ "typeof",
+ &[anon_const.value.clone()],
+ self.span,
+ shape,
+ ),
+ }
+ }
+}
+
+fn rewrite_bare_fn(
+ bare_fn: &ast::BareFnTy,
+ span: Span,
+ context: &RewriteContext<'_>,
+ shape: Shape,
+) -> Option<String> {
+ debug!("rewrite_bare_fn {:#?}", shape);
+
+ let mut result = String::with_capacity(128);
+
+ if let Some(ref lifetime_str) = rewrite_lifetime_param(context, shape, &bare_fn.generic_params)
+ {
+ result.push_str("for<");
+ // 6 = "for<> ".len(), 4 = "for<".
+ // This doesn't work out so nicely for multiline situation with lots of
+ // rightward drift. If that is a problem, we could use the list stuff.
+ result.push_str(lifetime_str);
+ result.push_str("> ");
+ }
+
+ result.push_str(crate::utils::format_unsafety(bare_fn.unsafety));
+
+ result.push_str(&format_extern(
+ bare_fn.ext,
+ context.config.force_explicit_abi(),
+ false,
+ ));
+
+ result.push_str("fn");
+
+ let func_ty_shape = if context.use_block_indent() {
+ shape.offset_left(result.len())?
+ } else {
+ shape.visual_indent(result.len()).sub_width(result.len())?
+ };
+
+ let rewrite = format_function_type(
+ bare_fn.decl.inputs.iter(),
+ &bare_fn.decl.output,
+ bare_fn.decl.c_variadic(),
+ span,
+ context,
+ func_ty_shape,
+ )?;
+
+ result.push_str(&rewrite);
+
+ Some(result)
+}
+
+fn is_generic_bounds_in_order(generic_bounds: &[ast::GenericBound]) -> bool {
+ let is_trait = |b: &ast::GenericBound| match b {
+ ast::GenericBound::Outlives(..) => false,
+ ast::GenericBound::Trait(..) => true,
+ };
+ let is_lifetime = |b: &ast::GenericBound| !is_trait(b);
+ let last_trait_index = generic_bounds.iter().rposition(is_trait);
+ let first_lifetime_index = generic_bounds.iter().position(is_lifetime);
+ match (last_trait_index, first_lifetime_index) {
+ (Some(last_trait_index), Some(first_lifetime_index)) => {
+ last_trait_index < first_lifetime_index
+ }
+ _ => true,
+ }
+}
+
+fn join_bounds(
+ context: &RewriteContext<'_>,
+ shape: Shape,
+ items: &[ast::GenericBound],
+ need_indent: bool,
+) -> Option<String> {
+ join_bounds_inner(context, shape, items, need_indent, false)
+}
+
+fn join_bounds_inner(
+ context: &RewriteContext<'_>,
+ shape: Shape,
+ items: &[ast::GenericBound],
+ need_indent: bool,
+ force_newline: bool,
+) -> Option<String> {
+ debug_assert!(!items.is_empty());
+
+ let generic_bounds_in_order = is_generic_bounds_in_order(items);
+ let is_bound_extendable = |s: &str, b: &ast::GenericBound| match b {
+ ast::GenericBound::Outlives(..) => true,
+ ast::GenericBound::Trait(..) => last_line_extendable(s),
+ };
+
+ let result = items.iter().enumerate().try_fold(
+ (String::new(), None, false),
+ |(strs, prev_trailing_span, prev_extendable), (i, item)| {
+ let trailing_span = if i < items.len() - 1 {
+ let hi = context
+ .snippet_provider
+ .span_before(mk_sp(items[i + 1].span().lo(), item.span().hi()), "+");
+
+ Some(mk_sp(item.span().hi(), hi))
+ } else {
+ None
+ };
+ let (leading_span, has_leading_comment) = if i > 0 {
+ let lo = context
+ .snippet_provider
+ .span_after(mk_sp(items[i - 1].span().hi(), item.span().lo()), "+");
+
+ let span = mk_sp(lo, item.span().lo());
+
+ let has_comments = contains_comment(context.snippet(span));
+
+ (Some(mk_sp(lo, item.span().lo())), has_comments)
+ } else {
+ (None, false)
+ };
+ let prev_has_trailing_comment = match prev_trailing_span {
+ Some(ts) => contains_comment(context.snippet(ts)),
+ _ => false,
+ };
+
+ let shape = if need_indent && force_newline {
+ shape
+ .block_indent(context.config.tab_spaces())
+ .with_max_width(context.config)
+ } else {
+ shape
+ };
+ let whitespace = if force_newline && (!prev_extendable || !generic_bounds_in_order) {
+ shape
+ .indent
+ .to_string_with_newline(context.config)
+ .to_string()
+ } else {
+ String::from(" ")
+ };
+
+ let joiner = match context.config.type_punctuation_density() {
+ TypeDensity::Compressed => String::from("+"),
+ TypeDensity::Wide => whitespace + "+ ",
+ };
+ let joiner = if has_leading_comment {
+ joiner.trim_end()
+ } else {
+ &joiner
+ };
+ let joiner = if prev_has_trailing_comment {
+ joiner.trim_start()
+ } else {
+ joiner
+ };
+
+ let (extendable, trailing_str) = if i == 0 {
+ let bound_str = item.rewrite(context, shape)?;
+ (is_bound_extendable(&bound_str, item), bound_str)
+ } else {
+ let bound_str = &item.rewrite(context, shape)?;
+ match leading_span {
+ Some(ls) if has_leading_comment => (
+ is_bound_extendable(bound_str, item),
+ combine_strs_with_missing_comments(
+ context, joiner, bound_str, ls, shape, true,
+ )?,
+ ),
+ _ => (
+ is_bound_extendable(bound_str, item),
+ String::from(joiner) + bound_str,
+ ),
+ }
+ };
+ match prev_trailing_span {
+ Some(ts) if prev_has_trailing_comment => combine_strs_with_missing_comments(
+ context,
+ &strs,
+ &trailing_str,
+ ts,
+ shape,
+ true,
+ )
+ .map(|v| (v, trailing_span, extendable)),
+ _ => Some((strs + &trailing_str, trailing_span, extendable)),
+ }
+ },
+ )?;
+
+ if !force_newline
+ && items.len() > 1
+ && (result.0.contains('\n') || result.0.len() > shape.width)
+ {
+ join_bounds_inner(context, shape, items, need_indent, true)
+ } else {
+ Some(result.0)
+ }
+}
+
+pub(crate) fn can_be_overflowed_type(
+ context: &RewriteContext<'_>,
+ ty: &ast::Ty,
+ len: usize,
+) -> bool {
+ match ty.kind {
+ ast::TyKind::Tup(..) => context.use_block_indent() && len == 1,
+ ast::TyKind::Rptr(_, ref mutty) | ast::TyKind::Ptr(ref mutty) => {
+ can_be_overflowed_type(context, &*mutty.ty, len)
+ }
+ _ => false,
+ }
+}
+
+/// Returns `None` if there is no `LifetimeDef` in the given generic parameters.
+fn rewrite_lifetime_param(
+ context: &RewriteContext<'_>,
+ shape: Shape,
+ generic_params: &[ast::GenericParam],
+) -> Option<String> {
+ let result = generic_params
+ .iter()
+ .filter(|p| matches!(p.kind, ast::GenericParamKind::Lifetime))
+ .map(|lt| lt.rewrite(context, shape))
+ .collect::<Option<Vec<_>>>()?
+ .join(", ");
+ if result.is_empty() {
+ None
+ } else {
+ Some(result)
+ }
+}
--- /dev/null
- use rustc_span::{symbol, BytePos, Pos, Span, DUMMY_SP};
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+use rustc_ast::{ast, token::DelimToken, visit, AstLike};
+use rustc_data_structures::sync::Lrc;
- format_impl, format_trait, format_trait_alias, is_mod_decl, is_use_item,
- rewrite_associated_impl_type, rewrite_extern_crate, rewrite_opaque_impl_type,
- rewrite_opaque_type, rewrite_type_alias, FnBraceStyle, FnSig, StaticParts, StructParts,
++use rustc_span::{symbol, BytePos, Pos, Span};
+
+use crate::attr::*;
+use crate::comment::{contains_comment, rewrite_comment, CodeCharKind, CommentCodeSlices};
+use crate::config::Version;
+use crate::config::{BraceStyle, Config};
+use crate::coverage::transform_missing_snippet;
+use crate::items::{
- let rewrite = rewrite_type_alias(
- item.ident,
- Some(&*ty),
- generics,
- Some(generic_bounds),
++ format_impl, format_trait, format_trait_alias, is_mod_decl, is_use_item, rewrite_extern_crate,
++ rewrite_impl_type, rewrite_opaque_type, rewrite_type, FnBraceStyle, FnSig, StaticParts,
++ StructParts,
+};
+use crate::macros::{macro_style, rewrite_macro, rewrite_macro_def, MacroPosition};
+use crate::modules::Module;
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::{Indent, Shape};
+use crate::skip::{is_skip_attr, SkipContext};
+use crate::source_map::{LineRangeUtils, SpanUtils};
+use crate::spanned::Spanned;
+use crate::stmt::Stmt;
+use crate::syntux::session::ParseSess;
+use crate::utils::{
+ self, contains_skip, count_newlines, depr_skip_annotation, format_unsafety, inner_attributes,
+ last_line_width, mk_sp, ptr_vec_to_ref_vec, rewrite_ident, starts_with_newline, stmt_expr,
+};
+use crate::{ErrorKind, FormatReport, FormattingError};
+
+/// Creates a string slice corresponding to the specified span.
+pub(crate) struct SnippetProvider {
+ /// A pointer to the content of the file we are formatting.
+ big_snippet: Lrc<String>,
+ /// A position of the start of `big_snippet`, used as an offset.
+ start_pos: usize,
+ /// An end position of the file that this snippet lives.
+ end_pos: usize,
+}
+
+impl SnippetProvider {
+ pub(crate) fn span_to_snippet(&self, span: Span) -> Option<&str> {
+ let start_index = span.lo().to_usize().checked_sub(self.start_pos)?;
+ let end_index = span.hi().to_usize().checked_sub(self.start_pos)?;
+ Some(&self.big_snippet[start_index..end_index])
+ }
+
+ pub(crate) fn new(start_pos: BytePos, end_pos: BytePos, big_snippet: Lrc<String>) -> Self {
+ let start_pos = start_pos.to_usize();
+ let end_pos = end_pos.to_usize();
+ SnippetProvider {
+ big_snippet,
+ start_pos,
+ end_pos,
+ }
+ }
+
+ pub(crate) fn entire_snippet(&self) -> &str {
+ self.big_snippet.as_str()
+ }
+
+ pub(crate) fn start_pos(&self) -> BytePos {
+ BytePos::from_usize(self.start_pos)
+ }
+
+ pub(crate) fn end_pos(&self) -> BytePos {
+ BytePos::from_usize(self.end_pos)
+ }
+}
+
+pub(crate) struct FmtVisitor<'a> {
+ parent_context: Option<&'a RewriteContext<'a>>,
+ pub(crate) parse_sess: &'a ParseSess,
+ pub(crate) buffer: String,
+ pub(crate) last_pos: BytePos,
+ // FIXME: use an RAII util or closure for indenting
+ pub(crate) block_indent: Indent,
+ pub(crate) config: &'a Config,
+ pub(crate) is_if_else_block: bool,
+ pub(crate) snippet_provider: &'a SnippetProvider,
+ pub(crate) line_number: usize,
+ /// List of 1-based line ranges which were annotated with skip
+ /// Both bounds are inclusifs.
+ pub(crate) skipped_range: Rc<RefCell<Vec<(usize, usize)>>>,
+ pub(crate) macro_rewrite_failure: bool,
+ pub(crate) report: FormatReport,
+ pub(crate) skip_context: SkipContext,
+ pub(crate) is_macro_def: bool,
+}
+
+impl<'a> Drop for FmtVisitor<'a> {
+ fn drop(&mut self) {
+ if let Some(ctx) = self.parent_context {
+ if self.macro_rewrite_failure {
+ ctx.macro_rewrite_failure.replace(true);
+ }
+ }
+ }
+}
+
+impl<'b, 'a: 'b> FmtVisitor<'a> {
+ fn set_parent_context(&mut self, context: &'a RewriteContext<'_>) {
+ self.parent_context = Some(context);
+ }
+
+ pub(crate) fn shape(&self) -> Shape {
+ Shape::indented(self.block_indent, self.config)
+ }
+
+ fn next_span(&self, hi: BytePos) -> Span {
+ mk_sp(self.last_pos, hi)
+ }
+
+ fn visit_stmt(&mut self, stmt: &Stmt<'_>, include_empty_semi: bool) {
+ debug!(
+ "visit_stmt: {}",
+ self.parse_sess.span_to_debug_info(stmt.span())
+ );
+
+ if stmt.is_empty() {
+ // If the statement is empty, just skip over it. Before that, make sure any comment
+ // snippet preceding the semicolon is picked up.
+ let snippet = self.snippet(mk_sp(self.last_pos, stmt.span().lo()));
+ let original_starts_with_newline = snippet
+ .find(|c| c != ' ')
+ .map_or(false, |i| starts_with_newline(&snippet[i..]));
+ let snippet = snippet.trim();
+ if !snippet.is_empty() {
+ // FIXME(calebcartwright 2021-01-03) - This exists strictly to maintain legacy
+ // formatting where rustfmt would preserve redundant semicolons on Items in a
+ // statement position.
+ // See comment within `walk_stmts` for more info
+ if include_empty_semi {
+ self.format_missing(stmt.span().hi());
+ } else {
+ if original_starts_with_newline {
+ self.push_str("\n");
+ }
+
+ self.push_str(&self.block_indent.to_string(self.config));
+ self.push_str(snippet);
+ }
+ } else if include_empty_semi {
+ self.push_str(";");
+ }
+ self.last_pos = stmt.span().hi();
+ return;
+ }
+
+ match stmt.as_ast_node().kind {
+ ast::StmtKind::Item(ref item) => {
+ self.visit_item(item);
+ self.last_pos = stmt.span().hi();
+ }
+ ast::StmtKind::Local(..) | ast::StmtKind::Expr(..) | ast::StmtKind::Semi(..) => {
+ let attrs = get_attrs_from_stmt(stmt.as_ast_node());
+ if contains_skip(attrs) {
+ self.push_skipped_with_span(
+ attrs,
+ stmt.span(),
+ get_span_without_attrs(stmt.as_ast_node()),
+ );
+ } else {
+ let shape = self.shape();
+ let rewrite = self.with_context(|ctx| stmt.rewrite(&ctx, shape));
+ self.push_rewrite(stmt.span(), rewrite)
+ }
+ }
+ ast::StmtKind::MacCall(ref mac_stmt) => {
+ if self.visit_attrs(&mac_stmt.attrs, ast::AttrStyle::Outer) {
+ self.push_skipped_with_span(
+ &mac_stmt.attrs,
+ stmt.span(),
+ get_span_without_attrs(stmt.as_ast_node()),
+ );
+ } else {
+ self.visit_mac(&mac_stmt.mac, None, MacroPosition::Statement);
+ }
+ self.format_missing(stmt.span().hi());
+ }
+ ast::StmtKind::Empty => (),
+ }
+ }
+
+ /// Remove spaces between the opening brace and the first statement or the inner attribute
+ /// of the block.
+ fn trim_spaces_after_opening_brace(
+ &mut self,
+ b: &ast::Block,
+ inner_attrs: Option<&[ast::Attribute]>,
+ ) {
+ if let Some(first_stmt) = b.stmts.first() {
+ let hi = inner_attrs
+ .and_then(|attrs| inner_attributes(attrs).first().map(|attr| attr.span.lo()))
+ .unwrap_or_else(|| first_stmt.span().lo());
+ let missing_span = self.next_span(hi);
+ let snippet = self.snippet(missing_span);
+ let len = CommentCodeSlices::new(snippet)
+ .next()
+ .and_then(|(kind, _, s)| {
+ if kind == CodeCharKind::Normal {
+ s.rfind('\n')
+ } else {
+ None
+ }
+ });
+ if let Some(len) = len {
+ self.last_pos = self.last_pos + BytePos::from_usize(len);
+ }
+ }
+ }
+
+ pub(crate) fn visit_block(
+ &mut self,
+ b: &ast::Block,
+ inner_attrs: Option<&[ast::Attribute]>,
+ has_braces: bool,
+ ) {
+ debug!(
+ "visit_block: {}",
+ self.parse_sess.span_to_debug_info(b.span),
+ );
+
+ // Check if this block has braces.
+ let brace_compensation = BytePos(if has_braces { 1 } else { 0 });
+
+ self.last_pos = self.last_pos + brace_compensation;
+ self.block_indent = self.block_indent.block_indent(self.config);
+ self.push_str("{");
+ self.trim_spaces_after_opening_brace(b, inner_attrs);
+
+ // Format inner attributes if available.
+ if let Some(attrs) = inner_attrs {
+ self.visit_attrs(attrs, ast::AttrStyle::Inner);
+ }
+
+ self.walk_block_stmts(b);
+
+ if !b.stmts.is_empty() {
+ if let Some(expr) = stmt_expr(&b.stmts[b.stmts.len() - 1]) {
+ if utils::semicolon_for_expr(&self.get_context(), expr) {
+ self.push_str(";");
+ }
+ }
+ }
+
+ let rest_span = self.next_span(b.span.hi());
+ if out_of_file_lines_range!(self, rest_span) {
+ self.push_str(self.snippet(rest_span));
+ self.block_indent = self.block_indent.block_unindent(self.config);
+ } else {
+ // Ignore the closing brace.
+ let missing_span = self.next_span(b.span.hi() - brace_compensation);
+ self.close_block(missing_span, self.unindent_comment_on_closing_brace(b));
+ }
+ self.last_pos = source!(self, b.span).hi();
+ }
+
+ fn close_block(&mut self, span: Span, unindent_comment: bool) {
+ let config = self.config;
+
+ let mut last_hi = span.lo();
+ let mut unindented = false;
+ let mut prev_ends_with_newline = false;
+ let mut extra_newline = false;
+
+ let skip_normal = |s: &str| {
+ let trimmed = s.trim();
+ trimmed.is_empty() || trimmed.chars().all(|c| c == ';')
+ };
+
+ let comment_snippet = self.snippet(span);
+
+ let align_to_right = if unindent_comment && contains_comment(&comment_snippet) {
+ let first_lines = comment_snippet.splitn(2, '/').next().unwrap_or("");
+ last_line_width(first_lines) > last_line_width(&comment_snippet)
+ } else {
+ false
+ };
+
+ for (kind, offset, sub_slice) in CommentCodeSlices::new(comment_snippet) {
+ let sub_slice = transform_missing_snippet(config, sub_slice);
+
+ debug!("close_block: {:?} {:?} {:?}", kind, offset, sub_slice);
+
+ match kind {
+ CodeCharKind::Comment => {
+ if !unindented && unindent_comment && !align_to_right {
+ unindented = true;
+ self.block_indent = self.block_indent.block_unindent(config);
+ }
+ let span_in_between = mk_sp(last_hi, span.lo() + BytePos::from_usize(offset));
+ let snippet_in_between = self.snippet(span_in_between);
+ let mut comment_on_same_line = !snippet_in_between.contains('\n');
+
+ let mut comment_shape =
+ Shape::indented(self.block_indent, config).comment(config);
+ if self.config.version() == Version::Two && comment_on_same_line {
+ self.push_str(" ");
+ // put the first line of the comment on the same line as the
+ // block's last line
+ match sub_slice.find('\n') {
+ None => {
+ self.push_str(&sub_slice);
+ }
+ Some(offset) if offset + 1 == sub_slice.len() => {
+ self.push_str(&sub_slice[..offset]);
+ }
+ Some(offset) => {
+ let first_line = &sub_slice[..offset];
+ self.push_str(first_line);
+ self.push_str(&self.block_indent.to_string_with_newline(config));
+
+ // put the other lines below it, shaping it as needed
+ let other_lines = &sub_slice[offset + 1..];
+ let comment_str =
+ rewrite_comment(other_lines, false, comment_shape, config);
+ match comment_str {
+ Some(ref s) => self.push_str(s),
+ None => self.push_str(other_lines),
+ }
+ }
+ }
+ } else {
+ if comment_on_same_line {
+ // 1 = a space before `//`
+ let offset_len = 1 + last_line_width(&self.buffer)
+ .saturating_sub(self.block_indent.width());
+ match comment_shape
+ .visual_indent(offset_len)
+ .sub_width(offset_len)
+ {
+ Some(shp) => comment_shape = shp,
+ None => comment_on_same_line = false,
+ }
+ };
+
+ if comment_on_same_line {
+ self.push_str(" ");
+ } else {
+ if count_newlines(snippet_in_between) >= 2 || extra_newline {
+ self.push_str("\n");
+ }
+ self.push_str(&self.block_indent.to_string_with_newline(config));
+ }
+
+ let comment_str = rewrite_comment(&sub_slice, false, comment_shape, config);
+ match comment_str {
+ Some(ref s) => self.push_str(s),
+ None => self.push_str(&sub_slice),
+ }
+ }
+ }
+ CodeCharKind::Normal if skip_normal(&sub_slice) => {
+ extra_newline = prev_ends_with_newline && sub_slice.contains('\n');
+ continue;
+ }
+ CodeCharKind::Normal => {
+ self.push_str(&self.block_indent.to_string_with_newline(config));
+ self.push_str(sub_slice.trim());
+ }
+ }
+ prev_ends_with_newline = sub_slice.ends_with('\n');
+ extra_newline = false;
+ last_hi = span.lo() + BytePos::from_usize(offset + sub_slice.len());
+ }
+ if unindented {
+ self.block_indent = self.block_indent.block_indent(self.config);
+ }
+ self.block_indent = self.block_indent.block_unindent(self.config);
+ self.push_str(&self.block_indent.to_string_with_newline(config));
+ self.push_str("}");
+ }
+
+ fn unindent_comment_on_closing_brace(&self, b: &ast::Block) -> bool {
+ self.is_if_else_block && !b.stmts.is_empty()
+ }
+
+ // Note that this only gets called for function definitions. Required methods
+ // on traits do not get handled here.
+ pub(crate) fn visit_fn(
+ &mut self,
+ fk: visit::FnKind<'_>,
+ generics: &ast::Generics,
+ fd: &ast::FnDecl,
+ s: Span,
+ defaultness: ast::Defaultness,
+ inner_attrs: Option<&[ast::Attribute]>,
+ ) {
+ let indent = self.block_indent;
+ let block;
+ let rewrite = match fk {
+ visit::FnKind::Fn(_, ident, _, _, Some(ref b)) => {
+ block = b;
+ self.rewrite_fn_before_block(
+ indent,
+ ident,
+ &FnSig::from_fn_kind(&fk, generics, fd, defaultness),
+ mk_sp(s.lo(), b.span.lo()),
+ )
+ }
+ _ => unreachable!(),
+ };
+
+ if let Some((fn_str, fn_brace_style)) = rewrite {
+ self.format_missing_with_indent(source!(self, s).lo());
+
+ if let Some(rw) = self.single_line_fn(&fn_str, block, inner_attrs) {
+ self.push_str(&rw);
+ self.last_pos = s.hi();
+ return;
+ }
+
+ self.push_str(&fn_str);
+ match fn_brace_style {
+ FnBraceStyle::SameLine => self.push_str(" "),
+ FnBraceStyle::NextLine => {
+ self.push_str(&self.block_indent.to_string_with_newline(self.config))
+ }
+ _ => unreachable!(),
+ }
+ self.last_pos = source!(self, block.span).lo();
+ } else {
+ self.format_missing(source!(self, block.span).lo());
+ }
+
+ self.visit_block(block, inner_attrs, true)
+ }
+
+ pub(crate) fn visit_item(&mut self, item: &ast::Item) {
+ skip_out_of_file_lines_range_visitor!(self, item.span);
+
+ // This is where we bail out if there is a skip attribute. This is only
+ // complex in the module case. It is complex because the module could be
+ // in a separate file and there might be attributes in both files, but
+ // the AST lumps them all together.
+ let filtered_attrs;
+ let mut attrs = &item.attrs;
+ let skip_context_saved = self.skip_context.clone();
+ self.skip_context.update_with_attrs(&attrs);
+
+ let should_visit_node_again = match item.kind {
+ // For use/extern crate items, skip rewriting attributes but check for a skip attribute.
+ ast::ItemKind::Use(..) | ast::ItemKind::ExternCrate(_) => {
+ if contains_skip(attrs) {
+ self.push_skipped_with_span(attrs.as_slice(), item.span(), item.span());
+ false
+ } else {
+ true
+ }
+ }
+ // Module is inline, in this case we treat it like any other item.
+ _ if !is_mod_decl(item) => {
+ if self.visit_attrs(&item.attrs, ast::AttrStyle::Outer) {
+ self.push_skipped_with_span(item.attrs.as_slice(), item.span(), item.span());
+ false
+ } else {
+ true
+ }
+ }
+ // Module is not inline, but should be skipped.
+ ast::ItemKind::Mod(..) if contains_skip(&item.attrs) => false,
+ // Module is not inline and should not be skipped. We want
+ // to process only the attributes in the current file.
+ ast::ItemKind::Mod(..) => {
+ filtered_attrs = filter_inline_attrs(&item.attrs, item.span());
+ // Assert because if we should skip it should be caught by
+ // the above case.
+ assert!(!self.visit_attrs(&filtered_attrs, ast::AttrStyle::Outer));
+ attrs = &filtered_attrs;
+ true
+ }
+ _ => {
+ if self.visit_attrs(&item.attrs, ast::AttrStyle::Outer) {
+ self.push_skipped_with_span(item.attrs.as_slice(), item.span(), item.span());
+ false
+ } else {
+ true
+ }
+ }
+ };
+
+ // TODO(calebcartwright): consider enabling box_patterns feature gate
+ if should_visit_node_again {
+ match item.kind {
+ ast::ItemKind::Use(ref tree) => self.format_import(item, tree),
+ ast::ItemKind::Impl { .. } => {
+ let block_indent = self.block_indent;
+ let rw = self.with_context(|ctx| format_impl(&ctx, item, block_indent));
+ self.push_rewrite(item.span, rw);
+ }
+ ast::ItemKind::Trait(..) => {
+ let block_indent = self.block_indent;
+ let rw = self.with_context(|ctx| format_trait(&ctx, item, block_indent));
+ self.push_rewrite(item.span, rw);
+ }
+ ast::ItemKind::TraitAlias(ref generics, ref generic_bounds) => {
+ let shape = Shape::indented(self.block_indent, self.config);
+ let rw = format_trait_alias(
+ &self.get_context(),
+ item.ident,
+ &item.vis,
+ generics,
+ generic_bounds,
+ shape,
+ );
+ self.push_rewrite(item.span, rw);
+ }
+ ast::ItemKind::ExternCrate(_) => {
+ let rw = rewrite_extern_crate(&self.get_context(), item, self.shape());
+ let span = if attrs.is_empty() {
+ item.span
+ } else {
+ mk_sp(attrs[0].span.lo(), item.span.hi())
+ };
+ self.push_rewrite(span, rw);
+ }
+ ast::ItemKind::Struct(..) | ast::ItemKind::Union(..) => {
+ self.visit_struct(&StructParts::from_item(item));
+ }
+ ast::ItemKind::Enum(ref def, ref generics) => {
+ self.format_missing_with_indent(source!(self, item.span).lo());
+ self.visit_enum(item.ident, &item.vis, def, generics, item.span);
+ self.last_pos = source!(self, item.span).hi();
+ }
+ ast::ItemKind::Mod(unsafety, ref mod_kind) => {
+ self.format_missing_with_indent(source!(self, item.span).lo());
+ self.format_mod(mod_kind, unsafety, &item.vis, item.span, item.ident, attrs);
+ }
+ ast::ItemKind::MacCall(ref mac) => {
+ self.visit_mac(mac, Some(item.ident), MacroPosition::Item);
+ }
+ ast::ItemKind::ForeignMod(ref foreign_mod) => {
+ self.format_missing_with_indent(source!(self, item.span).lo());
+ self.format_foreign_mod(foreign_mod, item.span);
+ }
+ ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => {
+ self.visit_static(&StaticParts::from_item(item));
+ }
+ ast::ItemKind::Fn(ref fn_kind) => {
+ let ast::FnKind(defaultness, ref fn_signature, ref generics, ref block) =
+ **fn_kind;
+ if let Some(ref body) = block {
+ let inner_attrs = inner_attributes(&item.attrs);
+ let fn_ctxt = match fn_signature.header.ext {
+ ast::Extern::None => visit::FnCtxt::Free,
+ _ => visit::FnCtxt::Foreign,
+ };
+ self.visit_fn(
+ visit::FnKind::Fn(
+ fn_ctxt,
+ item.ident,
+ &fn_signature,
+ &item.vis,
+ Some(body),
+ ),
+ generics,
+ &fn_signature.decl,
+ item.span,
+ defaultness,
+ Some(&inner_attrs),
+ )
+ } else {
+ let indent = self.block_indent;
+ let rewrite = self.rewrite_required_fn(
+ indent,
+ item.ident,
+ &fn_signature,
++ &item.vis,
+ generics,
+ item.span,
+ );
+ self.push_rewrite(item.span, rewrite);
+ }
+ }
+ ast::ItemKind::TyAlias(ref alias_kind) => {
+ let ast::TyAliasKind(_, ref generics, ref generic_bounds, ref ty) =
+ **alias_kind;
+ match ty {
+ Some(ty) => {
- let vis = ast::Visibility {
- kind: ast::VisibilityKind::Inherited,
- span: DUMMY_SP,
- tokens: None,
- };
++ let rewrite = rewrite_type(
+ &self.get_context(),
+ self.block_indent,
++ item.ident,
+ &item.vis,
++ generics,
++ Some(generic_bounds),
++ Some(&*ty),
+ item.span,
+ );
+ self.push_rewrite(item.span, rewrite);
+ }
+ None => {
+ let rewrite = rewrite_opaque_type(
+ &self.get_context(),
+ self.block_indent,
+ item.ident,
+ generic_bounds,
+ generics,
+ &item.vis,
+ item.span,
+ );
+ self.push_rewrite(item.span, rewrite);
+ }
+ }
+ }
+ ast::ItemKind::GlobalAsm(..) => {
+ let snippet = Some(self.snippet(item.span).to_owned());
+ self.push_rewrite(item.span, snippet);
+ }
+ ast::ItemKind::MacroDef(ref def) => {
+ let rewrite = rewrite_macro_def(
+ &self.get_context(),
+ self.shape(),
+ self.block_indent,
+ def,
+ item.ident,
+ &item.vis,
+ item.span,
+ );
+ self.push_rewrite(item.span, rewrite);
+ }
+ };
+ }
+ self.skip_context = skip_context_saved;
+ }
+
+ pub(crate) fn visit_trait_item(&mut self, ti: &ast::AssocItem) {
+ skip_out_of_file_lines_range_visitor!(self, ti.span);
+
+ if self.visit_attrs(&ti.attrs, ast::AttrStyle::Outer) {
+ self.push_skipped_with_span(ti.attrs.as_slice(), ti.span(), ti.span());
+ return;
+ }
+
+ // TODO(calebcartwright): consider enabling box_patterns feature gate
+ match ti.kind {
+ ast::AssocItemKind::Const(..) => self.visit_static(&StaticParts::from_trait_item(ti)),
+ ast::AssocItemKind::Fn(ref fn_kind) => {
+ let ast::FnKind(defaultness, ref sig, ref generics, ref block) = **fn_kind;
+ if let Some(ref body) = block {
+ let inner_attrs = inner_attributes(&ti.attrs);
- visit::FnKind::Fn(fn_ctxt, ti.ident, sig, &vis, Some(body)),
+ let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Trait);
+ self.visit_fn(
- self.rewrite_required_fn(indent, ti.ident, sig, generics, ti.span);
++ visit::FnKind::Fn(fn_ctxt, ti.ident, sig, &ti.vis, Some(body)),
+ generics,
+ &sig.decl,
+ ti.span,
+ defaultness,
+ Some(&inner_attrs),
+ );
+ } else {
+ let indent = self.block_indent;
+ let rewrite =
- let rewrite = rewrite_type_alias(
- ti.ident,
- type_default.as_ref(),
- generics,
- Some(generic_bounds),
++ self.rewrite_required_fn(indent, ti.ident, sig, &ti.vis, generics, ti.span);
+ self.push_rewrite(ti.span, rewrite);
+ }
+ }
+ ast::AssocItemKind::TyAlias(ref ty_alias_kind) => {
+ let ast::TyAliasKind(_, ref generics, ref generic_bounds, ref type_default) =
+ **ty_alias_kind;
- self.rewrite_required_fn(indent, ii.ident, sig, generics, ii.span);
++ let rewrite = rewrite_type(
+ &self.get_context(),
+ self.block_indent,
++ ti.ident,
+ &ti.vis,
++ generics,
++ Some(generic_bounds),
++ type_default.as_ref(),
+ ti.span,
+ );
+ self.push_rewrite(ti.span, rewrite);
+ }
+ ast::AssocItemKind::MacCall(ref mac) => {
+ self.visit_mac(mac, Some(ti.ident), MacroPosition::Item);
+ }
+ }
+ }
+
+ pub(crate) fn visit_impl_item(&mut self, ii: &ast::AssocItem) {
+ skip_out_of_file_lines_range_visitor!(self, ii.span);
+
+ if self.visit_attrs(&ii.attrs, ast::AttrStyle::Outer) {
+ self.push_skipped_with_span(ii.attrs.as_slice(), ii.span, ii.span);
+ return;
+ }
+
+ match ii.kind {
+ ast::AssocItemKind::Fn(ref fn_kind) => {
+ let ast::FnKind(defaultness, ref sig, ref generics, ref block) = **fn_kind;
+ if let Some(ref body) = block {
+ let inner_attrs = inner_attributes(&ii.attrs);
+ let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Impl);
+ self.visit_fn(
+ visit::FnKind::Fn(fn_ctxt, ii.ident, sig, &ii.vis, Some(body)),
+ generics,
+ &sig.decl,
+ ii.span,
+ defaultness,
+ Some(&inner_attrs),
+ );
+ } else {
+ let indent = self.block_indent;
+ let rewrite =
- let rewrite_associated = || {
- rewrite_associated_impl_type(
++ self.rewrite_required_fn(indent, ii.ident, sig, &ii.vis, generics, ii.span);
+ self.push_rewrite(ii.span, rewrite);
+ }
+ }
+ ast::AssocItemKind::Const(..) => self.visit_static(&StaticParts::from_impl_item(ii)),
+ ast::AssocItemKind::TyAlias(ref ty_alias_kind) => {
+ let ast::TyAliasKind(defaultness, ref generics, _, ref ty) = **ty_alias_kind;
- )
- };
- let rewrite = match ty {
- None => rewrite_associated(),
- Some(ty) => match ty.kind {
- ast::TyKind::ImplTrait(_, ref bounds) => rewrite_opaque_impl_type(
- &self.get_context(),
- ii.ident,
- generics,
- bounds,
- self.block_indent,
- ),
- _ => rewrite_associated(),
- },
- };
- self.push_rewrite(ii.span, rewrite);
++ self.push_rewrite(
++ ii.span,
++ rewrite_impl_type(
+ ii.ident,
+ &ii.vis,
+ defaultness,
+ ty.as_ref(),
+ &generics,
+ &self.get_context(),
+ self.block_indent,
+ ii.span,
++ ),
++ );
+ }
+ ast::AssocItemKind::MacCall(ref mac) => {
+ self.visit_mac(mac, Some(ii.ident), MacroPosition::Item);
+ }
+ }
+ }
+
+ fn visit_mac(&mut self, mac: &ast::MacCall, ident: Option<symbol::Ident>, pos: MacroPosition) {
+ skip_out_of_file_lines_range_visitor!(self, mac.span());
+
+ // 1 = ;
+ let shape = self.shape().saturating_sub_width(1);
+ let rewrite = self.with_context(|ctx| rewrite_macro(mac, ident, ctx, shape, pos));
+ // As of v638 of the rustc-ap-* crates, the associated span no longer includes
+ // the trailing semicolon. This determines the correct span to ensure scenarios
+ // with whitespace between the delimiters and trailing semi (i.e. `foo!(abc) ;`)
+ // are formatted correctly.
+ let (span, rewrite) = match macro_style(mac, &self.get_context()) {
+ DelimToken::Bracket | DelimToken::Paren if MacroPosition::Item == pos => {
+ let search_span = mk_sp(mac.span().hi(), self.snippet_provider.end_pos());
+ let hi = self.snippet_provider.span_before(search_span, ";");
+ let target_span = mk_sp(mac.span().lo(), hi + BytePos(1));
+ let rewrite = rewrite.map(|rw| {
+ if !rw.ends_with(';') {
+ format!("{};", rw)
+ } else {
+ rw
+ }
+ });
+ (target_span, rewrite)
+ }
+ _ => (mac.span(), rewrite),
+ };
+
+ self.push_rewrite(span, rewrite);
+ }
+
+ pub(crate) fn push_str(&mut self, s: &str) {
+ self.line_number += count_newlines(s);
+ self.buffer.push_str(s);
+ }
+
+ #[allow(clippy::needless_pass_by_value)]
+ fn push_rewrite_inner(&mut self, span: Span, rewrite: Option<String>) {
+ if let Some(ref s) = rewrite {
+ self.push_str(s);
+ } else {
+ let snippet = self.snippet(span);
+ self.push_str(snippet.trim());
+ }
+ self.last_pos = source!(self, span).hi();
+ }
+
+ pub(crate) fn push_rewrite(&mut self, span: Span, rewrite: Option<String>) {
+ self.format_missing_with_indent(source!(self, span).lo());
+ self.push_rewrite_inner(span, rewrite);
+ }
+
+ pub(crate) fn push_skipped_with_span(
+ &mut self,
+ attrs: &[ast::Attribute],
+ item_span: Span,
+ main_span: Span,
+ ) {
+ self.format_missing_with_indent(source!(self, item_span).lo());
+ // do not take into account the lines with attributes as part of the skipped range
+ let attrs_end = attrs
+ .iter()
+ .map(|attr| self.parse_sess.line_of_byte_pos(attr.span.hi()))
+ .max()
+ .unwrap_or(1);
+ let first_line = self.parse_sess.line_of_byte_pos(main_span.lo());
+ // Statement can start after some newlines and/or spaces
+ // or it can be on the same line as the last attribute.
+ // So here we need to take a minimum between the two.
+ let lo = std::cmp::min(attrs_end + 1, first_line);
+ self.push_rewrite_inner(item_span, None);
+ let hi = self.line_number + 1;
+ self.skipped_range.borrow_mut().push((lo, hi));
+ }
+
+ pub(crate) fn from_context(ctx: &'a RewriteContext<'_>) -> FmtVisitor<'a> {
+ let mut visitor = FmtVisitor::from_parse_sess(
+ ctx.parse_sess,
+ ctx.config,
+ ctx.snippet_provider,
+ ctx.report.clone(),
+ );
+ visitor.skip_context.update(ctx.skip_context.clone());
+ visitor.set_parent_context(ctx);
+ visitor
+ }
+
+ pub(crate) fn from_parse_sess(
+ parse_session: &'a ParseSess,
+ config: &'a Config,
+ snippet_provider: &'a SnippetProvider,
+ report: FormatReport,
+ ) -> FmtVisitor<'a> {
+ FmtVisitor {
+ parent_context: None,
+ parse_sess: parse_session,
+ buffer: String::with_capacity(snippet_provider.big_snippet.len() * 2),
+ last_pos: BytePos(0),
+ block_indent: Indent::empty(),
+ config,
+ is_if_else_block: false,
+ snippet_provider,
+ line_number: 0,
+ skipped_range: Rc::new(RefCell::new(vec![])),
+ is_macro_def: false,
+ macro_rewrite_failure: false,
+ report,
+ skip_context: Default::default(),
+ }
+ }
+
+ pub(crate) fn opt_snippet(&'b self, span: Span) -> Option<&'a str> {
+ self.snippet_provider.span_to_snippet(span)
+ }
+
+ pub(crate) fn snippet(&'b self, span: Span) -> &'a str {
+ self.opt_snippet(span).unwrap()
+ }
+
+ // Returns true if we should skip the following item.
+ pub(crate) fn visit_attrs(&mut self, attrs: &[ast::Attribute], style: ast::AttrStyle) -> bool {
+ for attr in attrs {
+ if attr.has_name(depr_skip_annotation()) {
+ let file_name = self.parse_sess.span_to_filename(attr.span);
+ self.report.append(
+ file_name,
+ vec![FormattingError::from_span(
+ attr.span,
+ self.parse_sess,
+ ErrorKind::DeprecatedAttr,
+ )],
+ );
+ } else {
+ match &attr.kind {
+ ast::AttrKind::Normal(ref attribute_item, _)
+ if self.is_unknown_rustfmt_attr(&attribute_item.path.segments) =>
+ {
+ let file_name = self.parse_sess.span_to_filename(attr.span);
+ self.report.append(
+ file_name,
+ vec![FormattingError::from_span(
+ attr.span,
+ self.parse_sess,
+ ErrorKind::BadAttr,
+ )],
+ );
+ }
+ _ => (),
+ }
+ }
+ }
+ if contains_skip(attrs) {
+ return true;
+ }
+
+ let attrs: Vec<_> = attrs.iter().filter(|a| a.style == style).cloned().collect();
+ if attrs.is_empty() {
+ return false;
+ }
+
+ let rewrite = attrs.rewrite(&self.get_context(), self.shape());
+ let span = mk_sp(attrs[0].span.lo(), attrs[attrs.len() - 1].span.hi());
+ self.push_rewrite(span, rewrite);
+
+ false
+ }
+
+ fn is_unknown_rustfmt_attr(&self, segments: &[ast::PathSegment]) -> bool {
+ if segments[0].ident.to_string() != "rustfmt" {
+ return false;
+ }
+ !is_skip_attr(segments)
+ }
+
+ fn walk_mod_items(&mut self, items: &[rustc_ast::ptr::P<ast::Item>]) {
+ self.visit_items_with_reordering(&ptr_vec_to_ref_vec(&items));
+ }
+
+ fn walk_stmts(&mut self, stmts: &[Stmt<'_>], include_current_empty_semi: bool) {
+ if stmts.is_empty() {
+ return;
+ }
+
+ // Extract leading `use ...;`.
+ let items: Vec<_> = stmts
+ .iter()
+ .take_while(|stmt| stmt.to_item().map_or(false, is_use_item))
+ .filter_map(|stmt| stmt.to_item())
+ .collect();
+
+ if items.is_empty() {
+ self.visit_stmt(&stmts[0], include_current_empty_semi);
+
+ // FIXME(calebcartwright 2021-01-03) - This exists strictly to maintain legacy
+ // formatting where rustfmt would preserve redundant semicolons on Items in a
+ // statement position.
+ //
+ // Starting in rustc-ap-* v692 (~2020-12-01) the rustc parser now parses this as
+ // two separate statements (Item and Empty kinds), whereas before it was parsed as
+ // a single statement with the statement's span including the redundant semicolon.
+ //
+ // rustfmt typically tosses unnecessary/redundant semicolons, and eventually we
+ // should toss these as well, but doing so at this time would
+ // break the Stability Guarantee
+ // N.B. This could be updated to utilize the version gates.
+ let include_next_empty = if stmts.len() > 1 {
+ matches!(
+ (&stmts[0].as_ast_node().kind, &stmts[1].as_ast_node().kind),
+ (ast::StmtKind::Item(_), ast::StmtKind::Empty)
+ )
+ } else {
+ false
+ };
+
+ self.walk_stmts(&stmts[1..], include_next_empty);
+ } else {
+ self.visit_items_with_reordering(&items);
+ self.walk_stmts(&stmts[items.len()..], false);
+ }
+ }
+
+ fn walk_block_stmts(&mut self, b: &ast::Block) {
+ self.walk_stmts(&Stmt::from_ast_nodes(b.stmts.iter()), false)
+ }
+
+ fn format_mod(
+ &mut self,
+ mod_kind: &ast::ModKind,
+ unsafety: ast::Unsafe,
+ vis: &ast::Visibility,
+ s: Span,
+ ident: symbol::Ident,
+ attrs: &[ast::Attribute],
+ ) {
+ let vis_str = utils::format_visibility(&self.get_context(), vis);
+ self.push_str(&*vis_str);
+ self.push_str(format_unsafety(unsafety));
+ self.push_str("mod ");
+ // Calling `to_owned()` to work around borrow checker.
+ let ident_str = rewrite_ident(&self.get_context(), ident).to_owned();
+ self.push_str(&ident_str);
+
+ if let ast::ModKind::Loaded(ref items, ast::Inline::Yes, inner_span) = mod_kind {
+ match self.config.brace_style() {
+ BraceStyle::AlwaysNextLine => {
+ let indent_str = self.block_indent.to_string_with_newline(self.config);
+ self.push_str(&indent_str);
+ self.push_str("{");
+ }
+ _ => self.push_str(" {"),
+ }
+ // Hackery to account for the closing }.
+ let mod_lo = self.snippet_provider.span_after(source!(self, s), "{");
+ let body_snippet =
+ self.snippet(mk_sp(mod_lo, source!(self, inner_span).hi() - BytePos(1)));
+ let body_snippet = body_snippet.trim();
+ if body_snippet.is_empty() {
+ self.push_str("}");
+ } else {
+ self.last_pos = mod_lo;
+ self.block_indent = self.block_indent.block_indent(self.config);
+ self.visit_attrs(attrs, ast::AttrStyle::Inner);
+ self.walk_mod_items(items);
+ let missing_span = self.next_span(inner_span.hi() - BytePos(1));
+ self.close_block(missing_span, false);
+ }
+ self.last_pos = source!(self, inner_span).hi();
+ } else {
+ self.push_str(";");
+ self.last_pos = source!(self, s).hi();
+ }
+ }
+
+ pub(crate) fn format_separate_mod(&mut self, m: &Module<'_>, end_pos: BytePos) {
+ self.block_indent = Indent::empty();
+ if self.visit_attrs(m.attrs(), ast::AttrStyle::Inner) {
+ self.push_skipped_with_span(m.attrs(), m.span, m.span);
+ } else {
+ self.walk_mod_items(&m.items);
+ self.format_missing_with_indent(end_pos);
+ }
+ }
+
+ pub(crate) fn skip_empty_lines(&mut self, end_pos: BytePos) {
+ while let Some(pos) = self
+ .snippet_provider
+ .opt_span_after(self.next_span(end_pos), "\n")
+ {
+ if let Some(snippet) = self.opt_snippet(self.next_span(pos)) {
+ if snippet.trim().is_empty() {
+ self.last_pos = pos;
+ } else {
+ return;
+ }
+ }
+ }
+ }
+
+ pub(crate) fn with_context<F>(&mut self, f: F) -> Option<String>
+ where
+ F: Fn(&RewriteContext<'_>) -> Option<String>,
+ {
+ let context = self.get_context();
+ let result = f(&context);
+
+ self.macro_rewrite_failure |= context.macro_rewrite_failure.get();
+ result
+ }
+
+ pub(crate) fn get_context(&self) -> RewriteContext<'_> {
+ RewriteContext {
+ parse_sess: self.parse_sess,
+ config: self.config,
+ inside_macro: Rc::new(Cell::new(false)),
+ use_block: Cell::new(false),
+ is_if_else_block: Cell::new(false),
+ force_one_line_chain: Cell::new(false),
+ snippet_provider: self.snippet_provider,
+ macro_rewrite_failure: Cell::new(false),
+ is_macro_def: self.is_macro_def,
+ report: self.report.clone(),
+ skip_context: self.skip_context.clone(),
+ skipped_range: self.skipped_range.clone(),
+ }
+ }
+}
--- /dev/null
--- /dev/null
++[package]
++name = "cargo-fmt-test"
++version = "0.1.0"
++authors = ["calebcartwright"]
++edition = "2018"
++
++[dependencies]
++indexmap = "1.0.2"
++
++[workspace]
++members = [
++ "dependency-dir-name",
++]
--- /dev/null
--- /dev/null
++[package]
++name = "dependency-crate-name"
++version = "0.1.0"
++authors = ["calebcartwright"]
++edition = "2018"
++
++[dependencies]
++subdep-crate-name = { path = "subdep-dir-name" }
++indexmap = "1.0.2"
++rusty-hook = "0.8.4"
--- /dev/null
--- /dev/null
++#[cfg(test)]
++mod tests {
++#[test]
++fn it_works() {
++ assert_eq!(2 + 2, 4);
++}
++}
--- /dev/null
--- /dev/null
++[package]
++name = "subdep-crate-name"
++version = "0.1.0"
++authors = ["calebcartwright"]
++edition = "2018"
++
++[dependencies]
--- /dev/null
--- /dev/null
++#[cfg(test)]
++mod tests {
++#[test]
++fn sub_test_that_works() {
++ assert_eq!(3 + 3, 6);
++}
++ }
--- /dev/null
--- /dev/null
++fn main() {
++println!("Hello, world!");
++}
--- /dev/null
--- /dev/null
++[package]
++name = "e"
++version = "0.1.0"
++edition = "2018"
++[dependencies]
++c = { path = "../ws/c" }
--- /dev/null
--- /dev/null
++struct E{ }
--- /dev/null
--- /dev/null
++[workspace]
++members = [
++ "a",
++ "b"
++]
--- /dev/null
--- /dev/null
++[package]
++name = "a"
++version = "0.1.0"
++edition = "2018"
++[dependencies]
++d = { path = "./d" }
--- /dev/null
--- /dev/null
++[package]
++name = "d"
++version = "0.1.0"
++edition = "2018"
++[dependencies]
++e = { path = "../../../e" }
++f = { path = "f" }
--- /dev/null
--- /dev/null
++[package]
++name = "f"
++version = "0.1.0"
++edition = "2018"
--- /dev/null
--- /dev/null
++struct F{ }
--- /dev/null
--- /dev/null
++struct D{ }
--- /dev/null
--- /dev/null
++struct D{ }
--- /dev/null
--- /dev/null
++[package]
++name = "b"
++version = "0.1.0"
++edition = "2018"
++[dependencies]
++c = { path = "../c" }
--- /dev/null
--- /dev/null
++struct B{ }
--- /dev/null
--- /dev/null
++[package]
++name = "c"
++version = "0.1.0"
++edition = "2018"
--- /dev/null
--- /dev/null
++struct C{ }
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ^ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ & abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ | abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ << abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ >> abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ < abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ {
++ //
++ }
++
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ <= abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ {
++ //
++ }
++
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ > abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ {
++ //
++ }
++
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ >= abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ {
++ //
++ }
++
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ == abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ {
++ //
++ }
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ && abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ || abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ {
++ //
++ }
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ * abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ - abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ / abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ * abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ * abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ / abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ / abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ + abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ match val {
++ ThisIsA::ReallyLongPatternNameToHelpOverflowTheNextValueOntoTheNextLine | ThisIsA::SecondValueSeparatedByAPipe | ThisIsA::ThirdValueSeparatedByAPipe => {
++ //
++ }
++ }
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ..abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ..=abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++}
--- /dev/null
--- /dev/null
++// @generated
++// rustfmt-format_generated_files: false
++
++fn main()
++{
++ println!("hello, world")
++ ;
++}
--- /dev/null
--- /dev/null
++// @generated
++// rustfmt-format_generated_files: true
++
++fn main()
++{
++ println!("hello, world")
++ ;
++}
--- /dev/null
--- /dev/null
++// rustfmt-hex_literal_case: Lower
++fn main() {
++ let h1 = 0xCAFE_5EA7;
++ let h2 = 0xCAFE_F00Du32;
++}
--- /dev/null
--- /dev/null
++// rustfmt-hex_literal_case: Upper
++fn main() {
++ let h1 = 0xCaFE_5ea7;
++ let h2 = 0xCAFE_F00Du32;
++}
--- /dev/null
+// rustfmt-normalize_comments: true
+impl Foo for Bar { fn foo() { "hi" } }
+
+pub impl Foo for Bar {
+ // Associated Constants
+ const Baz: i32 = 16;
+ // Associated Types
+ type FooBar = usize;
+ // Comment 1
+ fn foo() { "hi" }
+ // Comment 2
+ fn foo() { "hi" }
+ // Comment 3
+}
+
++#[inherent]
++impl Visible for Bar {
++ pub const C: i32;
++ pub type T;
++ pub fn f();
++ pub fn g() {}
++}
++
+pub unsafe impl<'a, 'b, X, Y: Foo<Bar>> !Foo<'a, X> for Bar<'b, Y> where X: Foo<'a, Z> {
+ fn foo() { "hi" }
+}
+
+impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y> where X: Fooooooooooooooooooooooooooooo<'a, Z>
+{
+ fn foo() { "hi" }
+}
+
+impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y> where X: Foooooooooooooooooooooooooooo<'a, Z>
+{
+ fn foo() { "hi" }
+}
+
+impl<T> Foo for Bar<T> where T: Baz
+{
+}
+
+impl<T> Foo for Bar<T> where T: Baz { /* Comment */ }
+
+impl Foo {
+ fn foo() {}
+}
+
+impl Boo {
+
+ // BOO
+ fn boo() {}
+ // FOO
+
+
+
+}
+
+mod a {
+ impl Foo {
+ // Hello!
+ fn foo() {}
+ }
+}
+
+
+mod b {
+ mod a {
+ impl Foo {
+ fn foo() {}
+ }
+ }
+}
+
+impl Foo { add_fun!(); }
+
+impl Blah {
+ fn boop() {}
+ add_fun!();
+}
+
+impl X { fn do_parse( mut self : X ) {} }
+
+impl Y5000 {
+ fn bar(self: X< 'a , 'b >, y: Y) {}
+
+ fn bad(&self, ( x, y): CoorT) {}
+
+ fn turbo_bad(self: X< 'a , 'b > , ( x, y): CoorT) {
+
+ }
+}
+
+pub impl<T> Foo for Bar<T> where T: Foo
+{
+ fn foo() { "hi" }
+}
+
+pub impl<T, Z> Foo for Bar<T, Z> where T: Foo, Z: Baz {}
+
+mod m {
+ impl<T> PartialEq for S<T> where T: PartialEq {
+ fn eq(&self, other: &Self) {
+ true
+ }
+ }
+
+ impl<T> PartialEq for S<T> where T: PartialEq { }
+ }
+
+impl<BorrowType, K, V, NodeType, HandleType> Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType> {
+}
+
+impl<BorrowType, K, V, NodeType, HandleType> PartialEq for Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType> {
+}
+
+mod x {
+ impl<A, B, C, D> Foo
+ where A: 'static,
+ B: 'static,
+ C: 'static,
+ D: 'static { }
+}
+
+impl<ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNodeFoo> Issue1249<ConcreteThreadSafeLayoutNode> {
+ // Creates a new flow constructor.
+ fn foo() {}
+}
+
+// #1600
+impl<#[may_dangle] K, #[may_dangle] V> Drop for RawTable<K, V> {
+ fn drop() {}
+}
+
+// #1168
+pub trait Number: Copy + Eq + Not<Output = Self> + Shl<u8, Output = Self> +
+ Shr<u8, Output = Self> +
+ BitAnd<Self, Output=Self> + BitOr<Self, Output=Self> + BitAndAssign + BitOrAssign
+
+
+
+{
+ // test
+ fn zero() -> Self;
+}
+
+// #1642
+pub trait SomeTrait : Clone + Eq + PartialEq + Ord + PartialOrd + Default + Hash + Debug + Display + Write + Read + FromStr {
+ // comment
+}
+
+// #1995
+impl Foo {
+ fn f(
+ S {
+ aaaaaaaaaa: aaaaaaaaaa,
+ bbbbbbbbbb: bbbbbbbbbb,
+ cccccccccc: cccccccccc,
+ }: S
+ ) -> u32{
+ 1
+ }
+}
+
+// #2491
+impl<'a, 'b, 'c> SomeThing<Something> for (&'a mut SomethingLong, &'b mut SomethingLong, &'c mut SomethingLong) {
+ fn foo() {}
+}
+
+// #2746
+impl<'seq1, 'seq2, 'body, 'scope, Channel> Adc12< Dual, MasterRunningDma<'seq1, 'body, 'scope, Channel>, SlaveRunningDma<'seq2, 'body, 'scope>, > where Channel: DmaChannel, {}
+
+// #4084
+impl const std::default::Default for Struct {
+ #[inline]
+ fn default() -> Self {
+ Self { f: 12.5 }
+ }
+}
--- /dev/null
--- /dev/null
++// rustfmt-imports_granularity: One
++
++use b;
++use a::ac::{aca, acb};
++use a::{aa::*, ab};
++
++use a as x;
++use b::ba;
++use a::{aa, ab};
++
++use a::aa::aaa;
++use a::ab::aba as x;
++use a::aa::*;
++
++use a::aa;
++use a::ad::ada;
++#[cfg(test)]
++use a::{ab, ac::aca};
++use b;
++#[cfg(test)]
++use b::{
++ ba, bb,
++ bc::bca::{bcaa, bcab},
++};
++
++pub use a::aa;
++pub use a::ae;
++use a::{ab, ac, ad};
++use b::ba;
++pub use b::{bb, bc::bca};
++
++use a::aa::aaa;
++use a::ac::{aca, acb};
++use a::{aa::*, ab};
++use b::{
++ ba,
++ bb::{self, bba},
++};
++
++use crate::a;
++use crate::b::ba;
++use c::ca;
++
++use super::a;
++use c::ca;
++use super::b::ba;
++
++use crate::a;
++use super::b;
++use c::{self, ca};
++
++use a::{
++ // some comment
++ aa::{aaa, aab},
++ ab,
++ // another comment
++ ac::aca,
++};
++use b as x;
++use a::ad::ada;
--- /dev/null
--- /dev/null
++// rustfmt-format_code_in_doc_comments: true
++
++/// Should format
++/// ```rust
++/// assert!( false );
++/// ```
++///
++/// Should format
++/// ```rust,should_panic
++/// assert!( false );
++/// ```
++///
++/// Should format
++/// ```rust,should_panic,edition2018
++/// assert!( false );
++/// ```
++///
++/// Should format
++/// ```rust , should_panic , edition2018
++/// assert!( false );
++/// ```
++///
++/// Should not format
++/// ```ignore
++/// assert!( false );
++/// ```
++///
++/// Should not format (not all are rust)
++/// ```rust,ignore
++/// assert!( false );
++/// ```
++///
++/// Should not format (rust compile_fail)
++/// ```compile_fail
++/// assert!( false );
++/// ```
++///
++/// Should not format (rust compile_fail)
++/// ```rust,compile_fail
++/// assert!( false );
++/// ```
++///
++/// Various unspecified ones that should format
++/// ```
++/// assert!( false );
++/// ```
++///
++/// ```,
++/// assert!( false );
++/// ```
++///
++/// ```,,,,,
++/// assert!( false );
++/// ```
++///
++/// ```,,, rust ,,
++/// assert!( false );
++/// ```
++///
++/// Should not format
++/// ```,,, rust , ignore,
++/// assert!( false );
++/// ```
++///
++/// Few empty ones
++/// ```
++/// ```
++///
++/// ```rust
++/// ```
++///
++/// ```ignore
++/// ```
++fn foo() {}
--- /dev/null
--- /dev/null
++// rustfmt-version: Two
++fn main() {
++ let [aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, cccccccccccccccccccccccccc, ddddddddddddddddddddddddd] = panic!();
++}
--- /dev/null
--- /dev/null
++info!(//debug
++ "{}: sending function_code={:04x} data={:04x} crc=0x{:04X} data={:02X?}",
++ self.name, function_code, data, crc, output_cmd
++);
--- /dev/null
--- /dev/null
++#![feature(const_generics_defaults)]
++struct Foo<const N: usize = 1, const N2: usize = 2>;
++struct Bar<const N: usize, const N2: usize = { N +
++1 }>;
++struct Lots<const N1BlahFooUwU: usize = { 10 + 28 + 1872 / 10 * 3 },const N2SecondParamOhmyyy: usize = { N1BlahFooUwU / 2 + 10 * 2 },>;
++struct NamesRHard<const N: usize = { 1 + 1 + 1 + 1 + 1 + 1 }>;
++struct FooBar<
++ const LessThan100ButClose: usize = {1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1}
++>;
++struct FooBarrrrrrrr<const N: usize = {13478234326456456444323871+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+1+1+1 + 1},>;
--- /dev/null
--- /dev/null
++
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ a: i32,
++ b: i32,
++ c: i32,
++}
++
++fn test(x: X) {
++ let d = {
++ let e = {
++ let f = {
++ let g = {
++ let h = {
++ let i = {
++ let j = {
++ matches!(
++ x,
++ X { a: 1_000, b: 1_000, .. }
++ )
++ };
++ j
++ };
++ i
++ };
++ h
++ };
++ g
++ };
++ f
++ };
++ e
++ };
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ really_really_long_field_a: i32,
++ really_really_really_long_field_b: i32,
++ really_really_really_really_long_field_c: i32,
++ really_really_really_really_really_long_field_d: i32,
++ really_really_really_really_really_really_long_field_e: i32,
++ f: i32,
++}
++
++fn test(x: X) {
++ let d = {
++ let e = {
++ let f = {
++ let g = {
++ let h = {
++ let i = {
++ let j = {
++ matches!(
++ x,
++ X {
++ really_really_long_field_a: 10,
++ really_really_really_long_field_b: 10,
++ really_really_really_really_long_field_c: 10,
++ really_really_really_really_really_long_field_d: 10,
++ really_really_really_really_really_really_long_field_e: 10, ..
++ }
++ )
++ };
++ j
++ };
++ i
++ };
++ h
++ };
++ g
++ };
++ f
++ };
++ e
++ };
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ a: i32,
++ b: i32,
++ c: i32,
++ d: i32,
++ e: i32,
++ f: i32,
++ g: i32,
++ h: i32,
++ i: i32,
++ j: i32,
++ k: i32,
++}
++
++fn test(x: X) {
++ let d = {
++ let e = {
++ let f = {
++ let g = {
++ let h = {
++ let i = {
++ let j = {
++ matches!(
++ x,
++ X {
++ a: 1_000, b: 1_000, c: 1_000, d: 1_000, e: 1_000, f: 1_000, g: 1_000, h: 1_000, i: 1_000, j: 1_000, ..
++ }
++ )
++ };
++ j
++ };
++ i
++ };
++ h
++ };
++ g
++ };
++ f
++ };
++ e
++ };
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++// rustfmt-enum_discrim_align_threshold: 30
++// rustfmt-imports_layout: HorizontalVertical
++
++#[derive(Default)]
++struct InnerStructA { bbbbbbbbb: i32, cccccccc: i32 }
++
++enum SomeEnumNamedD {
++ E(InnerStructA),
++ F {
++ ggggggggggggggggggggggggg: bool,
++ h: bool,
++ }
++}
++
++impl SomeEnumNamedD {
++ fn f_variant() -> Self {
++ Self::F { ggggggggggggggggggggggggg: true, h: true }
++ }
++}
++
++fn main() {
++ let kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = SomeEnumNamedD::f_variant();
++ let something_we_care_about = matches!(
++ kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk,
++ SomeEnumNamedD::F {
++ ggggggggggggggggggggggggg: true,
++ ..
++ }
++ );
++
++ if something_we_care_about {
++ println!("Yup it happened");
++ }
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X { a: i32, b: i32 }
++
++fn test(x: X) {
++ let y = matches!(x, X {
++ a: 1,
++ ..
++ });
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ really_really_long_field_a: i32,
++ really_really_really_long_field_b: i32,
++ really_really_really_really_long_field_c: i32,
++ really_really_really_really_really_long_field_d: i32,
++ really_really_really_really_really_really_long_field_e: i32,
++ f: i32,
++}
++
++fn test(x: X) {
++ let y = matches!(x, X {
++ really_really_long_field_a: 10,
++ really_really_really_long_field_b: 10,
++ really_really_really_really_long_field_c: 10,
++ really_really_really_really_really_long_field_d: 10,
++ really_really_really_really_really_really_long_field_e: 10,
++ ..
++ });
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ a: i32,
++ b: i32,
++ c: i32,
++ d: i32,
++ e: i32,
++ f: i32,
++ g: i32,
++ h: i32,
++ i: i32,
++ j: i32,
++ k: i32,
++}
++
++fn test(x: X) {
++ let y = matches!(x, X {
++ a: 1_000, b: 1_000, c: 1_000, d: 1_000, e: 1_000, f: 1_000, g: 1_000, h: 1_000, i: 1_000, j: 1_000, ..
++ });
++}
--- /dev/null
--- /dev/null
++#[derive(/*Debug, */Clone)]
++struct Foo;
--- /dev/null
--- /dev/null
++#[derive(
++/* ---------- Some really important comment that just had to go inside the derive --------- */
++Debug, Clone, Eq, PartialEq,
++)]
++struct Foo {
++ a: i32,
++ b: T,
++}
++
++#[derive(
++/*
++ Some really important comment that just had to go inside the derive.
++ Also had to be put over multiple lines
++*/
++Debug, Clone, Eq, PartialEq,
++)]
++struct Bar {
++ a: i32,
++ b: T,
++}
--- /dev/null
--- /dev/null
++#[derive(
++/* ---------- Some really important comment that just had to go inside the derive --------- */
++Debug, Clone,/* Another comment */Eq, PartialEq,
++)]
++struct Foo {
++ a: i32,
++ b: T,
++}
--- /dev/null
--- /dev/null
++pub(crate) struct ASlash(
++ // hello
++ i32
++);
++
++pub(crate) struct AStar(
++ /* hello */
++ i32
++);
++
++pub(crate) struct BStar(/* hello */ i32);
++
--- /dev/null
--- /dev/null
++fn a1(#[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] a: u8) {}
++fn b1(#[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] bb: u8) {}
++fn a2(#[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] a: u8) {}
++fn b2(#[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] bb: u8) {}
--- /dev/null
--- /dev/null
++#![feature(generic_associated_types)]
++#![allow(incomplete_features)]
++
++trait Trait<T> {
++ type Type<'a> where T: 'a;
++ fn foo(x: &T) -> Self::Type<'_>;
++}
++impl<T> Trait<T> for () {
++ type Type<'a> where T: 'a = &'a T;
++ fn foo(x: &T) -> Self::Type<'_> {
++ x
++ }
++}
--- /dev/null
--- /dev/null
++trait Bar {
++ type X<'a> where Self: 'a;
++}
--- /dev/null
--- /dev/null
++// rustfmt-hard_tabs: true
++
++#[macro_export]
++macro_rules! main {
++ () => {
++ #[spirv(fragment)]
++ pub fn main_fs(
++ mut out_color: ::spirv_std::storage_class::Output<Vec4>,
++ #[spirv(descriptor_set = 1)]iChannelResolution: ::spirv_std::storage_class::UniformConstant<
++ [::spirv_std::glam::Vec3A; 4],
++ >,
++ ) {
++ }
++ };
++}
--- /dev/null
--- /dev/null
++#![feature(generic_associated_types)]
++#![feature(min_type_alias_impl_trait)]
++
++impl SomeTrait for SomeType {
++ type SomeGAT<'a> where Self: 'a = impl SomeOtherTrait;
++}
--- /dev/null
--- /dev/null
++#![feature(generic_associated_types)]
++
++impl SomeStruct {
++ fn process<T>(v: T) -> <Self as GAT>::R<T>
++ where Self: GAT<R<T> = T>
++ {
++ SomeStruct::do_something(v)
++ }
++}
--- /dev/null
--- /dev/null
++trait Foo {
++ type Arg<'a>;
++}
++
++struct Bar<T>(T) where for<'a> T: Foo<Arg<'a> = ()>;
--- /dev/null
--- /dev/null
++mod test {
++ extern "C" {fn test();}
++}
++
++extern "C" {fn test();}
--- /dev/null
+// rustfmt-match_block_trailing_comma: true
+// Match expressions, no unwrapping of block arms or wrapping of multiline
+// expressions.
+
+fn foo() {
+ match x {
+ a => {
+ "line1";
+ "line2"
+ }
++ ThisIsA::Guard if true => {
++ "line1";
++ "line2"
++ }
++ ThisIsA::ReallyLongPattern(ThatWillForce::TheGuard, ToWrapOnto::TheFollowingLine) if true => {
++ "line1";
++ "line2"
++ }
+ b => (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb),
+ }
+}
--- /dev/null
+// Test traits
+
+trait Foo {
+ fn bar(x: i32 ) -> Baz< U> { Baz::new()
+ }
+
+ fn baz(a: AAAAAAAAAAAAAAAAAAAAAA,
+b: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB)
+-> RetType;
+
+ fn foo(a: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, // Another comment
+b: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB)
+ -> RetType ; // Some comment
+
+ fn baz(&mut self ) -> i32 ;
+
+fn increment(& mut self, x: i32 );
+
+ fn read(&mut self, x: BufReader<R> /* Used to be MemReader */)
+ where R: Read;
+}
+
+pub trait WriteMessage {
+ fn write_message (&mut self, &FrontendMessage) -> io::Result<()>;
+}
+
+trait Runnable {
+ fn handler(self: & Runnable );
+}
+
+trait TraitWithExpr {
+ fn fn_with_expr(x: [i32; 1]);
+}
+
+trait Test {
+ fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F) -> Result<T, Self::Error> where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
+}
+
+trait T<> {}
+
+trait Foo { type Bar: Baz; type Inner: Foo = Box< Foo >; }
+
+trait ConstCheck<T>:Foo where T: Baz {
+ const J: i32;
+}
+
+trait Tttttttttttttttttttttttttttttttttttttttttttttttttttttttttt<T>
+ where T: Foo {}
+
+trait Ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt<T> where T: Foo {}
+
+trait FooBar<T> : Tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt where J: Bar { fn test(); }
+
+trait WhereList<T, J> where T: Foo, J: Bar {}
+
+trait X /* comment */ {}
+trait Y // comment
+{
+}
+
+// #2055
+pub trait Foo:
+// A and C
+A + C
+// and B
+ + B
+{}
+
+// #2158
+trait Foo {
+ type ItRev = <MergingUntypedTimeSeries<SliceSeries<SliceWindow>> as UntypedTimeSeries>::IterRev;
+ type IteRev = <MergingUntypedTimeSeries<SliceSeries<SliceWindow>> as UntypedTimeSeries>::IterRev;
+}
+
+// #2331
+trait MyTrait<AAAAAAAAAAAAAAAAAAAA, BBBBBBBBBBBBBBBBBBBB, CCCCCCCCCCCCCCCCCCCC, DDDDDDDDDDDDDDDDDDDD> {
+ fn foo() {}
+}
+
+// Trait aliases
+trait FooBar =
+ Foo
+ + Bar;
+trait FooBar <A, B, C>=
+ Foo
+ + Bar;
+pub trait FooBar =
+ Foo
+ + Bar;
+pub trait FooBar <A, B, C>=
+ Foo
+ + Bar;
+trait AAAAAAAAAAAAAAAAAA = BBBBBBBBBBBBBBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCC + DDDDDDDDDDDDDDDDDD;
+pub trait AAAAAAAAAAAAAAAAAA = BBBBBBBBBBBBBBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCC + DDDDDDDDDDDDDDDDDD;
+trait AAAAAAAAAAAAAAAAAAA = BBBBBBBBBBBBBBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCC + DDDDDDDDDDDDDDDDDD;
+trait AAAAAAAAAAAAAAAAAA = BBBBBBBBBBBBBBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCC + DDDDDDDDDDDDDDDDDDD;
+trait AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<A, B, C, D, E> = FooBar;
+trait AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<A, B, C, D, E> = FooBar;
+#[rustfmt::skip]
+trait FooBar = Foo
+ + Bar;
+
+// #2637
+auto trait Example {}
+pub auto trait PubExample {}
+pub unsafe auto trait PubUnsafeExample {}
+
+// #3006
+trait Foo<'a> {
+ type Bar< 'a >;
+}
+
+impl<'a> Foo<'a> for i32 {
+ type Bar< 'a > = i32;
+}
+
+// #3092
+pub mod test {
+ pub trait ATraitWithALooongName {}
+ pub trait ATrait
+ :ATraitWithALooongName + ATraitWithALooongName + ATraitWithALooongName + ATraitWithALooongName
+{
+}
+}
+
+// Trait aliases with where clauses.
+trait A = where for<'b> &'b Self: Send;
+
+trait B = where for<'b> &'b Self: Send + Clone + Copy + SomeTrait + AAAAAAAA + BBBBBBB + CCCCCCCCCC;
+trait B = where for<'b> &'b Self: Send + Clone + Copy + SomeTrait + AAAAAAAA + BBBBBBB + CCCCCCCCCCC;
+trait B = where
+ for<'b> &'b Self:
+Send + Clone + Copy + SomeTrait + AAAAAAAA + BBBBBBB + CCCCCCCCCCCCCCCCCCCCCCC;
+trait B = where
+ for<'b> &'b Self:
+Send + Clone + Copy + SomeTrait + AAAAAAAA + BBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC;
+
+trait B = where
+ for<'b> &'b Self:
+Send
+ + Clone
+ + Copy
+ + SomeTrait
+ + AAAAAAAA
+ + BBBBBBB
+ + CCCCCCCCC
+ + DDDDDDD
+ + DDDDDDDD
+ + DDDDDDDDD
+ + EEEEEEE;
+
+trait A<'a, 'b, 'c> = Debug<T> + Foo where for<'b> &'b Self: Send;
+
+trait B<'a, 'b, 'c> = Debug<T> +Foo
+where for<'b> &'b Self:
+Send
+ + Clone
+ + Copy
+ + SomeTrait
+ + AAAAAAAA
+ + BBBBBBB
+ + CCCCCCCCC
+ + DDDDDDD;
+
+trait B<'a, 'b, 'c,T> = Debug<'a, T> where for<'b> &'b Self:
+Send
+ + Clone
+ + Copy
+ + SomeTrait
+ + AAAAAAAA
+ + BBBBBBB
+ + CCCCCCCCC
+ + DDDDDDD
+ + DDDDDDDD
+ + DDDDDDDDD
+ + EEEEEEE;
++
++trait Visible {
++ pub const C: i32;
++ pub type T;
++ pub fn f();
++ pub fn g() {}
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ^
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ &
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ |
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ <<
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ >>
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ <
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
++ {
++ //
++ }
++
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ <=
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
++ {
++ //
++ }
++
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ >
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
++ {
++ //
++ }
++
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ >=
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
++ {
++ //
++ }
++
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ==
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
++ {
++ //
++ }
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ if abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ &&
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ||
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
++ {
++ //
++ }
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ *
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ -
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ /
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ *
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ *
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ /
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ /
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ match val {
++ ThisIsA::ReallyLongPatternNameToHelpOverflowTheNextValueOntoTheNextLine |
++ ThisIsA::SecondValueSeparatedByAPipe |
++ ThisIsA::ThirdValueSeparatedByAPipe => {
++ //
++ }
++ }
++}
--- /dev/null
--- /dev/null
++// rustfmt-binop_separator: Back
++
++fn main() {
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ..
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++
++ let value = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ..=
++ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;
++}
--- /dev/null
--- /dev/null
++// @generated
++// rustfmt-format_generated_files: false
++
++fn main()
++{
++ println!("hello, world")
++ ;
++}
--- /dev/null
--- /dev/null
++// @generated
++// rustfmt-format_generated_files: true
++
++fn main() {
++ println!("hello, world");
++}
--- /dev/null
--- /dev/null
++// rustfmt-hex_literal_case: Lower
++fn main() {
++ let h1 = 0xcafe_5ea7;
++ let h2 = 0xcafe_f00du32;
++}
--- /dev/null
--- /dev/null
++// rustfmt-hex_literal_case: Preserve
++fn main() {
++ let h1 = 0xcAfE_5Ea7;
++ let h2 = 0xCaFe_F00du32;
++}
--- /dev/null
--- /dev/null
++// rustfmt-hex_literal_case: Upper
++fn main() {
++ let h1 = 0xCAFE_5EA7;
++ let h2 = 0xCAFE_F00Du32;
++}
--- /dev/null
+// rustfmt-normalize_comments: true
+impl Foo for Bar {
+ fn foo() {
+ "hi"
+ }
+}
+
+pub impl Foo for Bar {
+ // Associated Constants
+ const Baz: i32 = 16;
+ // Associated Types
+ type FooBar = usize;
+ // Comment 1
+ fn foo() {
+ "hi"
+ }
+ // Comment 2
+ fn foo() {
+ "hi"
+ }
+ // Comment 3
+}
+
++#[inherent]
++impl Visible for Bar {
++ pub const C: i32;
++ pub type T;
++ pub fn f();
++ pub fn g() {}
++}
++
+pub unsafe impl<'a, 'b, X, Y: Foo<Bar>> !Foo<'a, X> for Bar<'b, Y>
+where
+ X: Foo<'a, Z>,
+{
+ fn foo() {
+ "hi"
+ }
+}
+
+impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y>
+where
+ X: Fooooooooooooooooooooooooooooo<'a, Z>,
+{
+ fn foo() {
+ "hi"
+ }
+}
+
+impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y>
+where
+ X: Foooooooooooooooooooooooooooo<'a, Z>,
+{
+ fn foo() {
+ "hi"
+ }
+}
+
+impl<T> Foo for Bar<T> where T: Baz {}
+
+impl<T> Foo for Bar<T>
+where
+ T: Baz,
+{
+ // Comment
+}
+
+impl Foo {
+ fn foo() {}
+}
+
+impl Boo {
+ // BOO
+ fn boo() {}
+ // FOO
+}
+
+mod a {
+ impl Foo {
+ // Hello!
+ fn foo() {}
+ }
+}
+
+mod b {
+ mod a {
+ impl Foo {
+ fn foo() {}
+ }
+ }
+}
+
+impl Foo {
+ add_fun!();
+}
+
+impl Blah {
+ fn boop() {}
+ add_fun!();
+}
+
+impl X {
+ fn do_parse(mut self: X) {}
+}
+
+impl Y5000 {
+ fn bar(self: X<'a, 'b>, y: Y) {}
+
+ fn bad(&self, (x, y): CoorT) {}
+
+ fn turbo_bad(self: X<'a, 'b>, (x, y): CoorT) {}
+}
+
+pub impl<T> Foo for Bar<T>
+where
+ T: Foo,
+{
+ fn foo() {
+ "hi"
+ }
+}
+
+pub impl<T, Z> Foo for Bar<T, Z>
+where
+ T: Foo,
+ Z: Baz,
+{
+}
+
+mod m {
+ impl<T> PartialEq for S<T>
+ where
+ T: PartialEq,
+ {
+ fn eq(&self, other: &Self) {
+ true
+ }
+ }
+
+ impl<T> PartialEq for S<T> where T: PartialEq {}
+}
+
+impl<BorrowType, K, V, NodeType, HandleType>
+ Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType>
+{
+}
+
+impl<BorrowType, K, V, NodeType, HandleType> PartialEq
+ for Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType>
+{
+}
+
+mod x {
+ impl<A, B, C, D> Foo
+ where
+ A: 'static,
+ B: 'static,
+ C: 'static,
+ D: 'static,
+ {
+ }
+}
+
+impl<ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNodeFoo>
+ Issue1249<ConcreteThreadSafeLayoutNode>
+{
+ // Creates a new flow constructor.
+ fn foo() {}
+}
+
+// #1600
+impl<#[may_dangle] K, #[may_dangle] V> Drop for RawTable<K, V> {
+ fn drop() {}
+}
+
+// #1168
+pub trait Number:
+ Copy
+ + Eq
+ + Not<Output = Self>
+ + Shl<u8, Output = Self>
+ + Shr<u8, Output = Self>
+ + BitAnd<Self, Output = Self>
+ + BitOr<Self, Output = Self>
+ + BitAndAssign
+ + BitOrAssign
+{
+ // test
+ fn zero() -> Self;
+}
+
+// #1642
+pub trait SomeTrait:
+ Clone
+ + Eq
+ + PartialEq
+ + Ord
+ + PartialOrd
+ + Default
+ + Hash
+ + Debug
+ + Display
+ + Write
+ + Read
+ + FromStr
+{
+ // comment
+}
+
+// #1995
+impl Foo {
+ fn f(
+ S {
+ aaaaaaaaaa: aaaaaaaaaa,
+ bbbbbbbbbb: bbbbbbbbbb,
+ cccccccccc: cccccccccc,
+ }: S,
+ ) -> u32 {
+ 1
+ }
+}
+
+// #2491
+impl<'a, 'b, 'c> SomeThing<Something>
+ for (
+ &'a mut SomethingLong,
+ &'b mut SomethingLong,
+ &'c mut SomethingLong,
+ )
+{
+ fn foo() {}
+}
+
+// #2746
+impl<'seq1, 'seq2, 'body, 'scope, Channel>
+ Adc12<
+ Dual,
+ MasterRunningDma<'seq1, 'body, 'scope, Channel>,
+ SlaveRunningDma<'seq2, 'body, 'scope>,
+ >
+where
+ Channel: DmaChannel,
+{
+}
+
+// #4084
+impl const std::default::Default for Struct {
+ #[inline]
+ fn default() -> Self {
+ Self { f: 12.5 }
+ }
+}
--- /dev/null
--- /dev/null
++// rustfmt-imports_granularity: One
++
++use {
++ a::{
++ aa::*,
++ ab,
++ ac::{aca, acb},
++ },
++ b,
++};
++
++use {
++ a::{self as x, aa, ab},
++ b::ba,
++};
++
++use a::{
++ aa::{aaa, *},
++ ab::aba as x,
++};
++
++#[cfg(test)]
++use a::{ab, ac::aca};
++#[cfg(test)]
++use b::{
++ ba, bb,
++ bc::bca::{bcaa, bcab},
++};
++use {
++ a::{aa, ad::ada},
++ b,
++};
++
++pub use {
++ a::{aa, ae},
++ b::{bb, bc::bca},
++};
++use {
++ a::{ab, ac, ad},
++ b::ba,
++};
++
++use {
++ a::{
++ aa::{aaa, *},
++ ab,
++ ac::{aca, acb},
++ },
++ b::{
++ ba,
++ bb::{self, bba},
++ },
++};
++
++use {
++ crate::{a, b::ba},
++ c::ca,
++};
++
++use {
++ super::{a, b::ba},
++ c::ca,
++};
++
++use {
++ super::b,
++ crate::a,
++ c::{self, ca},
++};
++
++use {
++ a::{
++ aa::{aaa, aab},
++ ab,
++ ac::aca,
++ ad::ada,
++ },
++ b as x,
++};
--- /dev/null
--- /dev/null
++// rustfmt-format_code_in_doc_comments: true
++
++/// Should format
++/// ```rust
++/// assert!(false);
++/// ```
++///
++/// Should format
++/// ```rust,should_panic
++/// assert!(false);
++/// ```
++///
++/// Should format
++/// ```rust,should_panic,edition2018
++/// assert!(false);
++/// ```
++///
++/// Should format
++/// ```rust , should_panic , edition2018
++/// assert!(false);
++/// ```
++///
++/// Should not format
++/// ```ignore
++/// assert!( false );
++/// ```
++///
++/// Should not format (not all are rust)
++/// ```rust,ignore
++/// assert!( false );
++/// ```
++///
++/// Should not format (rust compile_fail)
++/// ```compile_fail
++/// assert!( false );
++/// ```
++///
++/// Should not format (rust compile_fail)
++/// ```rust,compile_fail
++/// assert!( false );
++/// ```
++///
++/// Various unspecified ones that should format
++/// ```
++/// assert!(false);
++/// ```
++///
++/// ```,
++/// assert!(false);
++/// ```
++///
++/// ```,,,,,
++/// assert!(false);
++/// ```
++///
++/// ```,,, rust ,,
++/// assert!(false);
++/// ```
++///
++/// Should not format
++/// ```,,, rust , ignore,
++/// assert!( false );
++/// ```
++///
++/// Few empty ones
++/// ```
++/// ```
++///
++/// ```rust
++/// ```
++///
++/// ```ignore
++/// ```
++fn foo() {}
--- /dev/null
--- /dev/null
++// rustfmt-version: Two
++fn main() {
++ let [
++ aaaaaaaaaaaaaaaaaaaaaaaaaa,
++ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
++ cccccccccccccccccccccccccc,
++ ddddddddddddddddddddddddd,
++ ] = panic!();
++}
--- /dev/null
--- /dev/null
++info!(
++ //debug
++ "{}: sending function_code={:04x} data={:04x} crc=0x{:04X} data={:02X?}",
++ self.name, function_code, data, crc, output_cmd
++);
--- /dev/null
--- /dev/null
++#![feature(const_generics_defaults)]
++struct Foo<const N: usize = 1, const N2: usize = 2>;
++struct Bar<const N: usize, const N2: usize = { N + 1 }>;
++struct Lots<
++ const N1BlahFooUwU: usize = { 10 + 28 + 1872 / 10 * 3 },
++ const N2SecondParamOhmyyy: usize = { N1BlahFooUwU / 2 + 10 * 2 },
++>;
++struct NamesRHard<const N: usize = { 1 + 1 + 1 + 1 + 1 + 1 }>;
++struct FooBar<
++ const LessThan100ButClose: usize = {
++ 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1
++ },
++>;
++struct FooBarrrrrrrr<
++ const N: usize = {
++ 13478234326456456444323871
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ + 1
++ },
++>;
--- /dev/null
--- /dev/null
++#![feature(more_qualified_paths)]
++
++fn main() {
++ // destructure through a qualified path
++ let <Foo as A>::Assoc { br } = StructStruct { br: 2 };
++}
++
++struct StructStruct {
++ br: i8,
++}
++
++struct Foo;
++
++trait A {
++ type Assoc;
++}
++
++impl A for Foo {
++ type Assoc = StructStruct;
++}
--- /dev/null
--- /dev/null
++#![feature(more_qualified_paths)]
++
++mod foo_bar {
++ pub enum Example {
++ Example1 {},
++ Example2 {},
++ }
++}
++
++fn main() {
++ foo!(crate::foo_bar::Example, Example1);
++
++ let i1 = foo_bar::Example::Example1 {};
++
++ assert_eq!(i1.foo_example(), 1);
++
++ let i2 = foo_bar::Example::Example2 {};
++
++ assert_eq!(i2.foo_example(), 2);
++}
++
++#[macro_export]
++macro_rules! foo {
++ ($struct:path, $variant:ident) => {
++ impl $struct {
++ pub fn foo_example(&self) -> i32 {
++ match self {
++ <$struct>::$variant { .. } => 1,
++ _ => 2,
++ }
++ }
++ }
++ };
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ a: i32,
++ b: i32,
++ c: i32,
++}
++
++fn test(x: X) {
++ let d = {
++ let e = {
++ let f = {
++ let g = {
++ let h = {
++ let i = {
++ let j = {
++ matches!(
++ x,
++ X {
++ a: 1_000,
++ b: 1_000,
++ ..
++ }
++ )
++ };
++ j
++ };
++ i
++ };
++ h
++ };
++ g
++ };
++ f
++ };
++ e
++ };
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ really_really_long_field_a: i32,
++ really_really_really_long_field_b: i32,
++ really_really_really_really_long_field_c: i32,
++ really_really_really_really_really_long_field_d: i32,
++ really_really_really_really_really_really_long_field_e: i32,
++ f: i32,
++}
++
++fn test(x: X) {
++ let d = {
++ let e = {
++ let f = {
++ let g = {
++ let h = {
++ let i = {
++ let j = {
++ matches!(
++ x,
++ X {
++ really_really_long_field_a: 10,
++ really_really_really_long_field_b: 10,
++ really_really_really_really_long_field_c: 10,
++ really_really_really_really_really_long_field_d: 10,
++ really_really_really_really_really_really_long_field_e: 10,
++ ..
++ }
++ )
++ };
++ j
++ };
++ i
++ };
++ h
++ };
++ g
++ };
++ f
++ };
++ e
++ };
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ a: i32,
++ b: i32,
++ c: i32,
++ d: i32,
++ e: i32,
++ f: i32,
++ g: i32,
++ h: i32,
++ i: i32,
++ j: i32,
++ k: i32,
++}
++
++fn test(x: X) {
++ let d = {
++ let e = {
++ let f = {
++ let g = {
++ let h = {
++ let i = {
++ let j = {
++ matches!(
++ x,
++ X {
++ a: 1_000,
++ b: 1_000,
++ c: 1_000,
++ d: 1_000,
++ e: 1_000,
++ f: 1_000,
++ g: 1_000,
++ h: 1_000,
++ i: 1_000,
++ j: 1_000,
++ ..
++ }
++ )
++ };
++ j
++ };
++ i
++ };
++ h
++ };
++ g
++ };
++ f
++ };
++ e
++ };
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++// rustfmt-enum_discrim_align_threshold: 30
++// rustfmt-imports_layout: HorizontalVertical
++
++#[derive(Default)]
++struct InnerStructA {
++ bbbbbbbbb: i32,
++ cccccccc: i32,
++}
++
++enum SomeEnumNamedD {
++ E(InnerStructA),
++ F {
++ ggggggggggggggggggggggggg: bool,
++ h: bool,
++ },
++}
++
++impl SomeEnumNamedD {
++ fn f_variant() -> Self {
++ Self::F {
++ ggggggggggggggggggggggggg: true,
++ h: true,
++ }
++ }
++}
++
++fn main() {
++ let kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = SomeEnumNamedD::f_variant();
++ let something_we_care_about = matches!(
++ kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk,
++ SomeEnumNamedD::F {
++ ggggggggggggggggggggggggg: true,
++ ..
++ }
++ );
++
++ if something_we_care_about {
++ println!("Yup it happened");
++ }
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ a: i32,
++ b: i32,
++}
++
++fn test(x: X) {
++ let y = matches!(x, X { a: 1, .. });
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ really_really_long_field_a: i32,
++ really_really_really_long_field_b: i32,
++ really_really_really_really_long_field_c: i32,
++ really_really_really_really_really_long_field_d: i32,
++ really_really_really_really_really_really_long_field_e: i32,
++ f: i32,
++}
++
++fn test(x: X) {
++ let y = matches!(
++ x,
++ X {
++ really_really_long_field_a: 10,
++ really_really_really_long_field_b: 10,
++ really_really_really_really_long_field_c: 10,
++ really_really_really_really_really_long_field_d: 10,
++ really_really_really_really_really_really_long_field_e: 10,
++ ..
++ }
++ );
++}
--- /dev/null
--- /dev/null
++// rustfmt-struct_field_align_threshold: 30
++
++struct X {
++ a: i32,
++ b: i32,
++ c: i32,
++ d: i32,
++ e: i32,
++ f: i32,
++ g: i32,
++ h: i32,
++ i: i32,
++ j: i32,
++ k: i32,
++}
++
++fn test(x: X) {
++ let y = matches!(
++ x,
++ X {
++ a: 1_000,
++ b: 1_000,
++ c: 1_000,
++ d: 1_000,
++ e: 1_000,
++ f: 1_000,
++ g: 1_000,
++ h: 1_000,
++ i: 1_000,
++ j: 1_000,
++ ..
++ }
++ );
++}
--- /dev/null
--- /dev/null
++#[derive(/*Debug, */ Clone)]
++struct Foo;
--- /dev/null
--- /dev/null
++#[derive(
++ /* ---------- Some really important comment that just had to go inside the derive --------- */
++ Debug,
++ Clone,
++ Eq,
++ PartialEq,
++)]
++struct Foo {
++ a: i32,
++ b: T,
++}
++
++#[derive(
++ /*
++ Some really important comment that just had to go inside the derive.
++ Also had to be put over multiple lines
++ */
++ Debug,
++ Clone,
++ Eq,
++ PartialEq,
++)]
++struct Bar {
++ a: i32,
++ b: T,
++}
--- /dev/null
--- /dev/null
++#[derive(
++ /* ---------- Some really important comment that just had to go inside the derive --------- */
++ Debug,
++ Clone,
++ /* Another comment */ Eq,
++ PartialEq,
++)]
++struct Foo {
++ a: i32,
++ b: T,
++}
--- /dev/null
--- /dev/null
++#[derive(Clone, Debug, Eq, PartialEq)]
++struct Foo;
++
++#[derive(Clone)]
++struct Bar;
--- /dev/null
--- /dev/null
++#![feature(more_qualified_paths)]
++macro_rules! show {
++ ($ty:ty, $ex:expr) => {
++ match $ex {
++ <$ty>::A(_val) => println!("got a"), // formatting should not remove <$ty>::
++ <$ty>::B => println!("got b"),
++ }
++ };
++}
--- /dev/null
--- /dev/null
++fn main() {
++ // the "in" inside the pattern produced invalid syntax
++ for variable_in_here /* ... */ in 0..1 {}
++}
--- /dev/null
--- /dev/null
++fn main() {
++ for in_in_in_in_in_in_in_in /* ... */ in 0..1 {}
++}
--- /dev/null
--- /dev/null
++fn main() {
++ for variable_in_x /* ... */ in 0..1 {
++ for variable_in_y /* ... */ in 0..1 {}
++ }
++}
--- /dev/null
--- /dev/null
++fn main() {
++ for variable_in_x /* ... */ in 0..1 {
++ for variable_in_y /* ... */ in 0..1 {
++ if false {
++
++ } else if false {
++
++ } else {
++
++ }
++ }
++ }
++}
--- /dev/null
--- /dev/null
++fn main() {
++ let in_ = false;
++
++ for variable_in_x /* ... */ in 0..1 {
++ for variable_in_y /* ... */ in 0..1 {
++ if in_ {
++
++ } else if in_ {
++
++ } else {
++
++ }
++ }
++ }
++}
--- /dev/null
--- /dev/null
++fn main() {
++ for variable_in_a /* ... */ in 0..1 {
++ for variable_in_b /* ... */ in 0..1 {
++ for variable_in_c /* ... */ in 0..1 {
++ for variable_in_d /* ... */ in 0..1 {
++ for variable_in_e /* ... */ in 0..1 {
++ for variable_in_f /* ... */ in 0..1 {
++ for variable_in_g /* ... */ in 0..1 {
++ for variable_in_h /* ... */ in 0..1 {
++ for variable_in_i /* ... */ in 0..1 {
++ for variable_in_j /* ... */ in 0..1 {
++ for variable_in_k /* ... */ in 0..1 {
++ for variable_in_l /* ... */ in 0..1 {
++ for variable_in_m /* ... */ in 0..1 {
++ for variable_in_n /* ... */ in 0..1 {
++ for variable_in_o /* ... */ in 0..1 {
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++}
--- /dev/null
--- /dev/null
++pub(crate) struct ASlash(
++ // hello
++ i32,
++);
++
++pub(crate) struct AStar(/* hello */ i32);
++
++pub(crate) struct BStar(/* hello */ i32);
--- /dev/null
--- /dev/null
++fn foo() {
++ with_woff2_glyf_table("tests/fonts/woff2/SFNT-TTF-Composite.woff2", |glyf| {
++ let actual = glyf
++ .records
++ .iter()
++ .map(|glyph| match glyph {
++ GlyfRecord::Parsed(
++ found @ Glyph {
++ data: GlyphData::Composite { .. },
++ ..
++ },
++ ) => Some(found),
++ _ => None,
++ })
++ .find(|candidate| candidate.is_some())
++ .unwrap()
++ .unwrap();
++
++ assert_eq!(*actual, expected)
++ });
++}
--- /dev/null
--- /dev/null
++fn a1(
++ #[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]
++ a: u8,
++) {
++}
++fn b1(
++ #[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]
++ bb: u8,
++) {
++}
++fn a2(
++ #[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] a: u8,
++) {
++}
++fn b2(
++ #[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] bb: u8,
++) {
++}
--- /dev/null
--- /dev/null
++fn bindings() {
++ let err = match (place_desc, explanation) {
++ (
++ Some(ref name),
++ BorrowExplanation::MustBeValidFor {
++ category:
++ category @ (ConstraintCategory::Return
++ | ConstraintCategory::CallArgument
++ | ConstraintCategory::OpaqueType),
++ from_closure: false,
++ ref region_name,
++ span,
++ ..
++ },
++ ) if borrow_spans.for_generator() | borrow_spans.for_closure() => self
++ .report_escaping_closure_capture(
++ borrow_spans,
++ borrow_span,
++ region_name,
++ category,
++ span,
++ &format!("`{}`", name),
++ ),
++ (
++ ref name,
++ BorrowExplanation::MustBeValidFor {
++ category: ConstraintCategory::Assignment,
++ from_closure: false,
++ region_name:
++ RegionName {
++ source: RegionNameSource::AnonRegionFromUpvar(upvar_span, ref upvar_name),
++ ..
++ },
++ span,
++ ..
++ },
++ ) => self.report_escaping_data(borrow_span, name, upvar_span, upvar_name, span),
++ (Some(name), explanation) => self.report_local_value_does_not_live_long_enough(
++ location,
++ &name,
++ &borrow,
++ drop_span,
++ borrow_spans,
++ explanation,
++ ),
++ (None, explanation) => self.report_temporary_value_does_not_live_long_enough(
++ location,
++ &borrow,
++ drop_span,
++ borrow_spans,
++ proper_span,
++ explanation,
++ ),
++ };
++}
--- /dev/null
--- /dev/null
++#![feature(generic_associated_types)]
++#![allow(incomplete_features)]
++
++trait Trait<T> {
++ type Type<'a>
++ where
++ T: 'a;
++ fn foo(x: &T) -> Self::Type<'_>;
++}
++impl<T> Trait<T> for () {
++ type Type<'a>
++ where
++ T: 'a,
++ = &'a T;
++ fn foo(x: &T) -> Self::Type<'_> {
++ x
++ }
++}
--- /dev/null
--- /dev/null
++trait Bar {
++ type X<'a>
++ where
++ Self: 'a;
++}
--- /dev/null
--- /dev/null
++// rustfmt-hard_tabs: true
++
++#[macro_export]
++macro_rules! main {
++ () => {
++ #[spirv(fragment)]
++ pub fn main_fs(
++ mut out_color: ::spirv_std::storage_class::Output<Vec4>,
++ #[spirv(descriptor_set = 1)]
++ iChannelResolution: ::spirv_std::storage_class::UniformConstant<
++ [::spirv_std::glam::Vec3A; 4],
++ >,
++ ) {
++ }
++ };
++}
--- /dev/null
--- /dev/null
++#![feature(generic_associated_types)]
++#![feature(min_type_alias_impl_trait)]
++
++impl SomeTrait for SomeType {
++ type SomeGAT<'a>
++ where
++ Self: 'a,
++ = impl SomeOtherTrait;
++}
--- /dev/null
--- /dev/null
++#[discard_params_doc]
++trait Trait {
++ fn foo(
++ &self,
++ /// some docs
++ bar: String,
++ /// another docs
++ baz: i32,
++ );
++}
--- /dev/null
--- /dev/null
++#![feature(generic_associated_types)]
++
++impl SomeStruct {
++ fn process<T>(v: T) -> <Self as GAT>::R<T>
++ where
++ Self: GAT<R<T> = T>,
++ {
++ SomeStruct::do_something(v)
++ }
++}
--- /dev/null
--- /dev/null
++trait Foo {
++ type Arg<'a>;
++}
++
++struct Bar<T>(T)
++where
++ for<'a> T: Foo<Arg<'a> = ()>;
--- /dev/null
--- /dev/null
++mod test {
++ extern "C" {
++ fn test();
++ }
++}
++
++extern "C" {
++ fn test();
++}
--- /dev/null
+// rustfmt-match_block_trailing_comma: true
+// Match expressions, no unwrapping of block arms or wrapping of multiline
+// expressions.
+
+fn foo() {
+ match x {
+ a => {
+ "line1";
+ "line2"
+ },
++ ThisIsA::Guard if true => {
++ "line1";
++ "line2"
++ },
++ ThisIsA::ReallyLongPattern(ThatWillForce::TheGuard, ToWrapOnto::TheFollowingLine)
++ if true =>
++ {
++ "line1";
++ "line2"
++ },
+ b => (
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
+ ),
+ }
+}
--- /dev/null
+// Test traits
+
+trait Foo {
+ fn bar(x: i32) -> Baz<U> {
+ Baz::new()
+ }
+
+ fn baz(a: AAAAAAAAAAAAAAAAAAAAAA, b: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB) -> RetType;
+
+ fn foo(
+ a: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, // Another comment
+ b: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,
+ ) -> RetType; // Some comment
+
+ fn baz(&mut self) -> i32;
+
+ fn increment(&mut self, x: i32);
+
+ fn read(&mut self, x: BufReader<R> /* Used to be MemReader */)
+ where
+ R: Read;
+}
+
+pub trait WriteMessage {
+ fn write_message(&mut self, &FrontendMessage) -> io::Result<()>;
+}
+
+trait Runnable {
+ fn handler(self: &Runnable);
+}
+
+trait TraitWithExpr {
+ fn fn_with_expr(x: [i32; 1]);
+}
+
+trait Test {
+ fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F) -> Result<T, Self::Error>
+ where
+ F: FnOnce(&mut Self) -> Result<T, Self::Error>;
+}
+
+trait T {}
+
+trait Foo {
+ type Bar: Baz;
+ type Inner: Foo = Box<Foo>;
+}
+
+trait ConstCheck<T>: Foo
+where
+ T: Baz,
+{
+ const J: i32;
+}
+
+trait Tttttttttttttttttttttttttttttttttttttttttttttttttttttttttt<T>
+where
+ T: Foo,
+{
+}
+
+trait Ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt<T>
+where
+ T: Foo,
+{
+}
+
+trait FooBar<T>: Tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt
+where
+ J: Bar,
+{
+ fn test();
+}
+
+trait WhereList<T, J>
+where
+ T: Foo,
+ J: Bar,
+{
+}
+
+trait X /* comment */ {}
+trait Y // comment
+{
+}
+
+// #2055
+pub trait Foo:
+// A and C
+A + C
+// and B
+ + B
+{}
+
+// #2158
+trait Foo {
+ type ItRev = <MergingUntypedTimeSeries<SliceSeries<SliceWindow>> as UntypedTimeSeries>::IterRev;
+ type IteRev =
+ <MergingUntypedTimeSeries<SliceSeries<SliceWindow>> as UntypedTimeSeries>::IterRev;
+}
+
+// #2331
+trait MyTrait<
+ AAAAAAAAAAAAAAAAAAAA,
+ BBBBBBBBBBBBBBBBBBBB,
+ CCCCCCCCCCCCCCCCCCCC,
+ DDDDDDDDDDDDDDDDDDDD,
+>
+{
+ fn foo() {}
+}
+
+// Trait aliases
+trait FooBar = Foo + Bar;
+trait FooBar<A, B, C> = Foo + Bar;
+pub trait FooBar = Foo + Bar;
+pub trait FooBar<A, B, C> = Foo + Bar;
+trait AAAAAAAAAAAAAAAAAA = BBBBBBBBBBBBBBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCC + DDDDDDDDDDDDDDDDDD;
+pub trait AAAAAAAAAAAAAAAAAA =
+ BBBBBBBBBBBBBBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCC + DDDDDDDDDDDDDDDDDD;
+trait AAAAAAAAAAAAAAAAAAA =
+ BBBBBBBBBBBBBBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCC + DDDDDDDDDDDDDDDDDD;
+trait AAAAAAAAAAAAAAAAAA =
+ BBBBBBBBBBBBBBBBBBB + CCCCCCCCCCCCCCCCCCCCCCCCCCCCC + DDDDDDDDDDDDDDDDDDD;
+trait AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<A, B, C, D, E> =
+ FooBar;
+trait AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<
+ A,
+ B,
+ C,
+ D,
+ E,
+> = FooBar;
+#[rustfmt::skip]
+trait FooBar = Foo
+ + Bar;
+
+// #2637
+auto trait Example {}
+pub auto trait PubExample {}
+pub unsafe auto trait PubUnsafeExample {}
+
+// #3006
+trait Foo<'a> {
+ type Bar<'a>;
+}
+
+impl<'a> Foo<'a> for i32 {
+ type Bar<'a> = i32;
+}
+
+// #3092
+pub mod test {
+ pub trait ATraitWithALooongName {}
+ pub trait ATrait:
+ ATraitWithALooongName
+ + ATraitWithALooongName
+ + ATraitWithALooongName
+ + ATraitWithALooongName
+ {
+ }
+}
+
+// Trait aliases with where clauses.
+trait A = where for<'b> &'b Self: Send;
+
+trait B = where for<'b> &'b Self: Send + Clone + Copy + SomeTrait + AAAAAAAA + BBBBBBB + CCCCCCCCCC;
+trait B =
+ where for<'b> &'b Self: Send + Clone + Copy + SomeTrait + AAAAAAAA + BBBBBBB + CCCCCCCCCCC;
+trait B = where
+ for<'b> &'b Self:
+ Send + Clone + Copy + SomeTrait + AAAAAAAA + BBBBBBB + CCCCCCCCCCCCCCCCCCCCCCC;
+trait B = where
+ for<'b> &'b Self: Send
+ + Clone
+ + Copy
+ + SomeTrait
+ + AAAAAAAA
+ + BBBBBBB
+ + CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC;
+
+trait B = where
+ for<'b> &'b Self: Send
+ + Clone
+ + Copy
+ + SomeTrait
+ + AAAAAAAA
+ + BBBBBBB
+ + CCCCCCCCC
+ + DDDDDDD
+ + DDDDDDDD
+ + DDDDDDDDD
+ + EEEEEEE;
+
+trait A<'a, 'b, 'c> = Debug<T> + Foo where for<'b> &'b Self: Send;
+
+trait B<'a, 'b, 'c> = Debug<T> + Foo
+where
+ for<'b> &'b Self: Send + Clone + Copy + SomeTrait + AAAAAAAA + BBBBBBB + CCCCCCCCC + DDDDDDD;
+
+trait B<'a, 'b, 'c, T> = Debug<'a, T>
+where
+ for<'b> &'b Self: Send
+ + Clone
+ + Copy
+ + SomeTrait
+ + AAAAAAAA
+ + BBBBBBB
+ + CCCCCCCCC
+ + DDDDDDD
+ + DDDDDDDD
+ + DDDDDDDDD
+ + EEEEEEE;
++
++trait Visible {
++ pub const C: i32;
++ pub type T;
++ pub fn f();
++ pub fn g() {}
++}
--- /dev/null
--- /dev/null
++[assign]
projects / rust.git / commitdiff