nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-06-05 11:48:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #138305 - lnicola:sync-from-ra, r=lnicola

Browse Source 
Subtree update of `rust-analyzer`

r? `@ghost`
This commit is contained in:
Matthias Krüger 2025-03-10 15:57:19 +01:00 committed by GitHub
commit 2abeceeb97
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
184 changed files with 4699 additions and 1903 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/tools/rust-analyzer/.editorconfig
View File

@ -15,3 +15,6 @@ indent_size = 2
[*.{yml,yaml}] [*.{yml,yaml}]
indent_size = 2 indent_size = 2
[COMMIT_EDITMSG]
max_line_length = unset

73
src/tools/rust-analyzer/.github/workflows/ci.yaml vendored
View File

@ -35,19 +35,48 @@ jobs:
typescript: typescript:
- 'editors/code/**' - 'editors/code/**'
proc_macros: proc_macros:
- 'crates/tt/**'
- 'crates/proc-macro-api/**' - 'crates/proc-macro-api/**'
- 'crates/proc-macro-srv/**' - 'crates/proc-macro-srv/**'
- 'crates/proc-macro-srv-cli/**' - 'crates/proc-macro-srv-cli/**'
rust: proc-macro-srv:
needs: changes needs: changes
if: github.repository == 'rust-lang/rust-analyzer' && needs.changes.outputs.proc_macros == 'true'
name: proc-macro-srv
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
ref: ${{ github.event.pull_request.head.sha }}
- name: Install Rust toolchain
run: |
rustup update --no-self-update nightly
rustup default nightly
rustup component add --toolchain nightly rust-src rustfmt
# https://github.com/actions-rust-lang/setup-rust-toolchain/blob/main/rust.json
- name: Install Rust Problem Matcher
if: matrix.os == 'ubuntu-latest'
run: echo "::add-matcher::.github/rust.json"
- name: Cache Dependencies
uses: Swatinem/rust-cache@9bdad043e88c75890e36ad3bbc8d27f0090dd609
- name: Bump opt-level
if: matrix.os == 'ubuntu-latest'
run: sed -i '/\[profile.dev]/a opt-level=1' Cargo.toml
- name: Test
run: cargo test --features sysroot-abi -p rust-analyzer -p proc-macro-srv -p proc-macro-srv-cli -p proc-macro-api -- --quiet
rust:
if: github.repository == 'rust-lang/rust-analyzer' if: github.repository == 'rust-lang/rust-analyzer'
name: Rust name: Rust
runs-on: ${{ matrix.os }} runs-on: ${{ matrix.os }}
env: env:
CC: deny_c CC: deny_c
RUST_CHANNEL: "${{ needs.changes.outputs.proc_macros == 'true' && 'nightly' || 'stable' }}"
USE_SYSROOT_ABI: "${{ needs.changes.outputs.proc_macros == 'true' && '--features sysroot-abi' || '' }}"
strategy: strategy:
fail-fast: false fail-fast: false
@ -62,13 +91,12 @@ jobs:
- name: Install Rust toolchain - name: Install Rust toolchain
run: | run: |
rustup update --no-self-update ${{ env.RUST_CHANNEL }} rustup update --no-self-update stable
rustup default ${{ env.RUST_CHANNEL }} rustup default stable
rustup component add --toolchain ${{ env.RUST_CHANNEL }} rust-src rustup component add --toolchain stable rust-src
# We always use a nightly rustfmt, regardless of channel, because we need # We always use a nightly rustfmt, regardless of channel, because we need
# --file-lines. # --file-lines.
rustup toolchain add nightly --profile minimal rustup toolchain install nightly --profile minimal --component rustfmt
rustup component add --toolchain nightly rustfmt
# https://github.com/actions-rust-lang/setup-rust-toolchain/blob/main/rust.json # https://github.com/actions-rust-lang/setup-rust-toolchain/blob/main/rust.json
- name: Install Rust Problem Matcher - name: Install Rust Problem Matcher
if: matrix.os == 'ubuntu-latest' if: matrix.os == 'ubuntu-latest'
@ -76,8 +104,6 @@ jobs:
- name: Cache Dependencies - name: Cache Dependencies
uses: Swatinem/rust-cache@9bdad043e88c75890e36ad3bbc8d27f0090dd609 uses: Swatinem/rust-cache@9bdad043e88c75890e36ad3bbc8d27f0090dd609
with:
key: ${{ env.RUST_CHANNEL }}
- name: Bump opt-level - name: Bump opt-level
if: matrix.os == 'ubuntu-latest' if: matrix.os == 'ubuntu-latest'
@ -87,16 +113,16 @@ jobs:
run: cargo codegen --check run: cargo codegen --check
- name: Compile (tests) - name: Compile (tests)
run: cargo test --no-run --locked ${{ env.USE_SYSROOT_ABI }} run: cargo test --no-run --locked
# It's faster to `test` before `build` ¯\_(ツ)_/¯ # It's faster to `test` before `build` ¯\_(ツ)_/¯
- name: Compile (rust-analyzer) - name: Compile (rust-analyzer)
if: matrix.os == 'ubuntu-latest' if: matrix.os == 'ubuntu-latest'
run: cargo build --quiet ${{ env.USE_SYSROOT_ABI }} run: cargo build --quiet
- name: Test - name: Test
if: matrix.os == 'ubuntu-latest' || matrix.os == 'windows-latest' || github.event_name == 'push' if: matrix.os == 'ubuntu-latest' || matrix.os == 'windows-latest' || github.event_name == 'push'
run: cargo test ${{ env.USE_SYSROOT_ABI }} -- --nocapture --quiet run: cargo test -- --quiet
- name: Switch to stable toolchain - name: Switch to stable toolchain
run: | run: |
@ -157,7 +183,7 @@ jobs:
typescript: typescript:
needs: changes needs: changes
if: github.repository == 'rust-lang/rust-analyzer' if: github.repository == 'rust-lang/rust-analyzer' && needs.changes.outputs.typescript == 'true'
name: TypeScript name: TypeScript
strategy: strategy:
fail-fast: false fail-fast: false
@ -169,21 +195,18 @@ jobs:
steps: steps:
- name: Checkout repository - name: Checkout repository
uses: actions/checkout@v4 uses: actions/checkout@v4
if: needs.changes.outputs.typescript == 'true'
- name: Install Nodejs - name: Install Nodejs
uses: actions/setup-node@v4 uses: actions/setup-node@v4
with: with:
node-version: 22 node-version: 22
if: needs.changes.outputs.typescript == 'true'
- name: Install xvfb - name: Install xvfb
if: matrix.os == 'ubuntu-latest' && needs.changes.outputs.typescript == 'true' if: matrix.os == 'ubuntu-latest'
run: sudo apt-get install -y xvfb run: sudo apt-get install -y xvfb
- run: npm ci - run: npm ci
working-directory: ./editors/code working-directory: ./editors/code
if: needs.changes.outputs.typescript == 'true'
# - run: npm audit || { sleep 10 && npm audit; } || { sleep 30 && npm audit; } # - run: npm audit || { sleep 10 && npm audit; } || { sleep 30 && npm audit; }
# if: runner.os == 'Linux' # if: runner.os == 'Linux'
@ -192,27 +215,24 @@ jobs:
# If this steps fails, your code's type integrity might be wrong at some places at TypeScript level. # If this steps fails, your code's type integrity might be wrong at some places at TypeScript level.
- run: npm run typecheck - run: npm run typecheck
working-directory: ./editors/code working-directory: ./editors/code
if: needs.changes.outputs.typescript == 'true'
# You may fix the code automatically by running `npm run lint:fix` if this steps fails. # You may fix the code automatically by running `npm run lint:fix` if this steps fails.
- run: npm run lint - run: npm run lint
working-directory: ./editors/code working-directory: ./editors/code
if: needs.changes.outputs.typescript == 'true'
# To fix this steps, please run `npm run format`. # To fix this steps, please run `npm run format`.
- run: npm run format:check - run: npm run format:check
working-directory: ./editors/code working-directory: ./editors/code
if: needs.changes.outputs.typescript == 'true'
- name: Run VS Code tests (Linux) - name: Run VS Code tests (Linux)
if: matrix.os == 'ubuntu-latest' && needs.changes.outputs.typescript == 'true' if: matrix.os == 'ubuntu-latest'
env: env:
VSCODE_CLI: 1 VSCODE_CLI: 1
run: xvfb-run npm test run: xvfb-run npm test
working-directory: ./editors/code working-directory: ./editors/code
- name: Run VS Code tests (Windows) - name: Run VS Code tests (Windows)
if: matrix.os == 'windows-latest' && needs.changes.outputs.typescript == 'true' if: matrix.os == 'windows-latest'
env: env:
VSCODE_CLI: 1 VSCODE_CLI: 1
run: npm test run: npm test
@ -220,7 +240,6 @@ jobs:
- run: npm run package --scripts-prepend-node-path - run: npm run package --scripts-prepend-node-path
working-directory: ./editors/code working-directory: ./editors/code
if: needs.changes.outputs.typescript == 'true'
typo-check: typo-check:
name: Typo Check name: Typo Check
@ -242,7 +261,7 @@ jobs:
run: typos run: typos
conclusion: conclusion:
needs: [rust, rust-cross, typescript, typo-check] needs: [rust, rust-cross, typescript, typo-check, proc-macro-srv]
# We need to ensure this job does *not* get skipped if its dependencies fail, # We need to ensure this job does *not* get skipped if its dependencies fail,
# because a skipped job is considered a success by GitHub. So we have to # because a skipped job is considered a success by GitHub. So we have to
# overwrite `if:`. We use `!cancelled()` to ensure the job does still not get run # overwrite `if:`. We use `!cancelled()` to ensure the job does still not get run
@ -257,5 +276,5 @@ jobs:
run: | run: |
# Print the dependent jobs to see them in the CI log # Print the dependent jobs to see them in the CI log
jq -C <<< '${{ toJson(needs) }}' jq -C <<< '${{ toJson(needs) }}'
# Check if all jobs that we depend on (in the needs array) were successful. # Check if all jobs that we depend on (in the needs array) were successful (or have been skipped).
jq --exit-status 'all(.result == "success")' <<< '${{ toJson(needs) }}' jq --exit-status 'all(.result == "success" or .result == "skipped")' <<< '${{ toJson(needs) }}'

45
src/tools/rust-analyzer/Cargo.lock
View File

@ -191,9 +191,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
[[package]] [[package]]
name = "chalk-derive" name = "chalk-derive"
version = "0.99.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "572583d9b97f9d277e5c7607f8239a30e2e04d3ed3b47c87d1cb2152ae724073" checksum = "ab2d131019373f0d0d1f2af0abd4f719739f6583c1b33965112455f643a910af"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",
@ -203,9 +203,9 @@ dependencies = [
[[package]] [[package]]
name = "chalk-ir" name = "chalk-ir"
version = "0.99.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e60e0ef9c81dce1336a9ed3c76f08775f5b623151d96d85ba45f7b10de76d1c7" checksum = "4f114996bda14c0213f014a4ef31a7867dcf5f539a3900477fc6b20138e7a17b"
dependencies = [ dependencies = [
"bitflags 2.7.0", "bitflags 2.7.0",
"chalk-derive", "chalk-derive",
@ -213,9 +213,9 @@ dependencies = [
[[package]] [[package]]
name = "chalk-recursive" name = "chalk-recursive"
version = "0.99.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a06350d614e22b03a69b8105e3541614450a7ea48bc58ecc6c6bd92731a3995" checksum = "551e956e031c09057c7b21f17d48d91de99c9b6b6e34bceaf5e7202d71021268"
dependencies = [ dependencies = [
"chalk-derive", "chalk-derive",
"chalk-ir", "chalk-ir",
@ -226,9 +226,9 @@ dependencies = [
[[package]] [[package]]
name = "chalk-solve" name = "chalk-solve"
version = "0.99.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e428761e9b55bee516bfe2457caed8b6d1b86353f92ae825bbe438a36ce91e8" checksum = "cd7ca50181156ce649efe8e5dd00580f573651554e4dcd11afa4e2ac93f53324"
dependencies = [ dependencies = [
"chalk-derive", "chalk-derive",
"chalk-ir", "chalk-ir",
@ -626,7 +626,6 @@ dependencies = [
"oorandom", "oorandom",
"project-model", "project-model",
"ra-ap-rustc_abi", "ra-ap-rustc_abi",
"ra-ap-rustc_hashes",
"ra-ap-rustc_index", "ra-ap-rustc_index",
"ra-ap-rustc_pattern_analysis", "ra-ap-rustc_pattern_analysis",
"rustc-hash 2.0.0", "rustc-hash 2.0.0",
@ -1504,9 +1503,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_abi" name = "ra-ap-rustc_abi"
version = "0.98.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4b42cccfff8091a4c3397736518774dbad619e82f8def6f70d8e46dbbe396007" checksum = "f1651b0f7e8c3eb7c27a88f39d277e69c32bfe58e3be174d286c1a24d6a7a4d8"
dependencies = [ dependencies = [
"bitflags 2.7.0", "bitflags 2.7.0",
"ra-ap-rustc_hashes", "ra-ap-rustc_hashes",
@ -1516,18 +1515,18 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_hashes" name = "ra-ap-rustc_hashes"
version = "0.98.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "46d8bd34ed6552c8cac1764106ef5adbeef3e5c7700e0ceb4c83a47a631894fe" checksum = "2bcd85e93dc0ea850bcfe7957a115957df799ccbc9eea488bdee5ec6780d212b"
dependencies = [ dependencies = [
"rustc-stable-hash", "rustc-stable-hash",
] ]
[[package]] [[package]]
name = "ra-ap-rustc_index" name = "ra-ap-rustc_index"
version = "0.98.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "93799e4dccbbd47f8b66bc0aa42effc1b7077aaee09d8a40b86b8d659b80c7b7" checksum = "62b295fc0640cd9fe0ecab872ee4a17a96f90a3998ec9f0c4765e9b8415c12cc"
dependencies = [ dependencies = [
"ra-ap-rustc_index_macros", "ra-ap-rustc_index_macros",
"smallvec", "smallvec",
@ -1535,9 +1534,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_index_macros" name = "ra-ap-rustc_index_macros"
version = "0.98.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "30baa5d00f94ba437a9dcaf7ae074ebe4f367bb05a4c2835e0aa2e7af3463aac" checksum = "c675f4257023aa933882906f13802cae287e88cc39ab13cbb96809083db0c801"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",
@ -1546,9 +1545,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_lexer" name = "ra-ap-rustc_lexer"
version = "0.98.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3004d1d1b50afe3e1f9cdd428a282da7ffbf5f26dd8bf04af0d651d44e4873d8" checksum = "c8358702c2a510ea84ba5801ddc047d9ad9520902cfb0e6173277610cdce2c9c"
dependencies = [ dependencies = [
"memchr", "memchr",
"unicode-properties", "unicode-properties",
@ -1557,9 +1556,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_parse_format" name = "ra-ap-rustc_parse_format"
version = "0.98.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb57e5124a64aaaf92c06130fbc1b8e1d547b5a2a96081f1f848e31c211df5d2" checksum = "b98f402011d46732c35c47bfd111dec0495747fef2ec900ddee7fe15d78449a7"
dependencies = [ dependencies = [
"ra-ap-rustc_index", "ra-ap-rustc_index",
"ra-ap-rustc_lexer", "ra-ap-rustc_lexer",
@ -1567,9 +1566,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_pattern_analysis" name = "ra-ap-rustc_pattern_analysis"
version = "0.98.0" version = "0.100.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e427c3d30e4bdff28abd6b0ef3e6f4dfab44acd9468a4954eeff8717d8df8819" checksum = "bef3ff73fa4653252ffe1d1e9177a446f49ef46d97140e4816b7ff2dad59ed53"
dependencies = [ dependencies = [
"ra-ap-rustc_index", "ra-ap-rustc_index",
"rustc-hash 2.0.0", "rustc-hash 2.0.0",

20
src/tools/rust-analyzer/Cargo.toml
View File

@ -85,12 +85,12 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
vfs = { path = "./crates/vfs", version = "0.0.0" } vfs = { path = "./crates/vfs", version = "0.0.0" }
edition = { path = "./crates/edition", version = "0.0.0" } edition = { path = "./crates/edition", version = "0.0.0" }
ra-ap-rustc_hashes = { version = "0.98", default-features = false } ra-ap-rustc_hashes = { version = "0.100", default-features = false }
ra-ap-rustc_lexer = { version = "0.98", default-features = false } ra-ap-rustc_lexer = { version = "0.100", default-features = false }
ra-ap-rustc_parse_format = { version = "0.98", default-features = false } ra-ap-rustc_parse_format = { version = "0.100", default-features = false }
ra-ap-rustc_index = { version = "0.98", default-features = false } ra-ap-rustc_index = { version = "0.100", default-features = false }
ra-ap-rustc_abi = { version = "0.98", default-features = false } ra-ap-rustc_abi = { version = "0.100", default-features = false }
ra-ap-rustc_pattern_analysis = { version = "0.98", default-features = false } ra-ap-rustc_pattern_analysis = { version = "0.100", default-features = false }
# local crates that aren't published to crates.io. These should not have versions. # local crates that aren't published to crates.io. These should not have versions.
@ -105,10 +105,10 @@ arrayvec = "0.7.4"
bitflags = "2.4.1" bitflags = "2.4.1"
cargo_metadata = "0.18.1" cargo_metadata = "0.18.1"
camino = "1.1.6" camino = "1.1.6"
chalk-solve = { version = "0.99.0", default-features = false } chalk-solve = { version = "0.100.0", default-features = false }
chalk-ir = "0.99.0" chalk-ir = "0.100.0"
chalk-recursive = { version = "0.99.0", default-features = false } chalk-recursive = { version = "0.100.0", default-features = false }
chalk-derive = "0.99.0" chalk-derive = "0.100.0"
crossbeam-channel = "0.5.8" crossbeam-channel = "0.5.8"
dissimilar = "1.0.7" dissimilar = "1.0.7"
dot = "0.1.4" dot = "0.1.4"

19
src/tools/rust-analyzer/crates/cfg/src/cfg_expr.rs
View File

@ -18,6 +18,25 @@ pub enum CfgAtom {
KeyValue { key: Symbol, value: Symbol }, KeyValue { key: Symbol, value: Symbol },
} }
impl PartialOrd for CfgAtom {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for CfgAtom {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
match (self, other) {
(CfgAtom::Flag(a), CfgAtom::Flag(b)) => a.as_str().cmp(b.as_str()),
(CfgAtom::Flag(_), CfgAtom::KeyValue { .. }) => std::cmp::Ordering::Less,
(CfgAtom::KeyValue { .. }, CfgAtom::Flag(_)) => std::cmp::Ordering::Greater,
(CfgAtom::KeyValue { key, value }, CfgAtom::KeyValue { key: key2, value: value2 }) => {
key.as_str().cmp(key2.as_str()).then(value.as_str().cmp(value2.as_str()))
}
}
}
}
impl fmt::Display for CfgAtom { impl fmt::Display for CfgAtom {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {

19
src/tools/rust-analyzer/crates/cfg/src/dnf.rs
View File

@ -66,9 +66,9 @@ impl DnfExpr {
} }
} }
res.enabled.sort_unstable_by(compare); res.enabled.sort_unstable();
res.enabled.dedup(); res.enabled.dedup();
res.disabled.sort_unstable_by(compare); res.disabled.sort_unstable();
res.disabled.dedup(); res.disabled.dedup();
Some(res) Some(res)
} }
@ -114,25 +114,14 @@ impl DnfExpr {
}; };
// Undo the FxHashMap randomization for consistent output. // Undo the FxHashMap randomization for consistent output.
diff.enable.sort_unstable_by(compare); diff.enable.sort_unstable();
diff.disable.sort_unstable_by(compare); diff.disable.sort_unstable();
Some(diff) Some(diff)
}) })
} }
} }
fn compare(a: &CfgAtom, b: &CfgAtom) -> std::cmp::Ordering {
match (a, b) {
(CfgAtom::Flag(a), CfgAtom::Flag(b)) => a.as_str().cmp(b.as_str()),
(CfgAtom::Flag(_), CfgAtom::KeyValue { .. }) => std::cmp::Ordering::Less,
(CfgAtom::KeyValue { .. }, CfgAtom::Flag(_)) => std::cmp::Ordering::Greater,
(CfgAtom::KeyValue { key, value }, CfgAtom::KeyValue { key: key2, value: value2 }) => {
key.as_str().cmp(key2.as_str()).then(value.as_str().cmp(value2.as_str()))
}
}
}
impl fmt::Display for DnfExpr { impl fmt::Display for DnfExpr {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.conjunctions.len() != 1 { if self.conjunctions.len() != 1 {

20
src/tools/rust-analyzer/crates/cfg/src/lib.rs
View File

@ -148,16 +148,20 @@ pub struct CfgDiff {
} }
impl CfgDiff { impl CfgDiff {
/// Create a new CfgDiff. Will return None if the same item appears more than once in the set /// Create a new CfgDiff.
/// of both. pub fn new(mut enable: Vec<CfgAtom>, mut disable: Vec<CfgAtom>) -> CfgDiff {
pub fn new(enable: Vec<CfgAtom>, disable: Vec<CfgAtom>) -> Option<CfgDiff> { enable.sort();
let mut occupied = FxHashSet::default(); enable.dedup();
if enable.iter().chain(disable.iter()).any(|item| !occupied.insert(item)) { disable.sort();
// was present disable.dedup();
return None; for i in (0..enable.len()).rev() {
if let Some(j) = disable.iter().position(|atom| *atom == enable[i]) {
enable.remove(i);
disable.remove(j);
}
} }
Some(CfgDiff { enable, disable }) CfgDiff { enable, disable }
} }
/// Returns the total number of atoms changed by this diff. /// Returns the total number of atoms changed by this diff.

2
src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs
View File

@ -260,7 +260,7 @@ pub enum TypeBound {
} }
#[cfg(target_pointer_width = "64")] #[cfg(target_pointer_width = "64")]
const _: [(); 24] = [(); ::std::mem::size_of::<TypeBound>()]; const _: [(); 24] = [(); size_of::<TypeBound>()];
#[derive(Clone, PartialEq, Eq, Hash, Debug)] #[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub enum UseArgRef { pub enum UseArgRef {

8
src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe/tt_conversion.rs
View File

@ -93,15 +93,15 @@ fn broken_parenthesis_sequence() {
macro_rules! m1 { ($x:ident) => { ($x } } macro_rules! m1 { ($x:ident) => { ($x } }
macro_rules! m2 { ($x:ident) => {} } macro_rules! m2 { ($x:ident) => {} }
m1!(); fn f1() { m1!(x); }
m2!(x fn f2() { m2!(x }
"#, "#,
expect![[r#" expect![[r#"
macro_rules! m1 { ($x:ident) => { ($x } } macro_rules! m1 { ($x:ident) => { ($x } }
macro_rules! m2 { ($x:ident) => {} } macro_rules! m2 { ($x:ident) => {} }
/* error: macro definition has parse errors */ fn f1() { (x); }
/* error: expected ident */ fn f2() { /* error: expected ident */ }
"#]], "#]],
) )
} }

16
src/tools/rust-analyzer/crates/hir-def/src/path.rs
View File

@ -57,7 +57,7 @@ pub enum Path {
/// or type anchor, it is `Path::Normal` with the generics filled with `None` even if there are none (practically /// or type anchor, it is `Path::Normal` with the generics filled with `None` even if there are none (practically
/// this is not a problem since many more paths have generics than a type anchor). /// this is not a problem since many more paths have generics than a type anchor).
BarePath(Interned<ModPath>), BarePath(Interned<ModPath>),
/// `Path::Normal` may have empty generics and type anchor (but generic args will be filled with `None`). /// `Path::Normal` will always have either generics or type anchor.
Normal(NormalPath), Normal(NormalPath),
/// A link to a lang item. It is used in desugaring of things like `it?`. We can show these /// A link to a lang item. It is used in desugaring of things like `it?`. We can show these
/// links via a normal path since they might be private and not accessible in the usage place. /// links via a normal path since they might be private and not accessible in the usage place.
@ -208,11 +208,15 @@ impl Path {
mod_path.segments()[..mod_path.segments().len() - 1].iter().cloned(), mod_path.segments()[..mod_path.segments().len() - 1].iter().cloned(),
)); ));
let qualifier_generic_args = &generic_args[..generic_args.len() - 1]; let qualifier_generic_args = &generic_args[..generic_args.len() - 1];
Some(Path::Normal(NormalPath::new( if type_anchor.is_none() && qualifier_generic_args.iter().all(|it| it.is_none()) {
type_anchor, Some(Path::BarePath(qualifier_mod_path))
qualifier_mod_path, } else {
qualifier_generic_args.iter().cloned(), Some(Path::Normal(NormalPath::new(
))) type_anchor,
qualifier_mod_path,
qualifier_generic_args.iter().cloned(),
)))
}
} }
Path::LangItem(..) => None, Path::LangItem(..) => None,
} }

166
src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
View File

@ -3,10 +3,11 @@ use std::{fmt, iter, mem};
use base_db::CrateId; use base_db::CrateId;
use hir_expand::{name::Name, MacroDefId}; use hir_expand::{name::Name, MacroDefId};
use intern::sym; use intern::{sym, Symbol};
use itertools::Itertools as _; use itertools::Itertools as _;
use rustc_hash::FxHashSet; use rustc_hash::FxHashSet;
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
use span::SyntaxContextId;
use triomphe::Arc; use triomphe::Arc;
use crate::{ use crate::{
@ -343,15 +344,7 @@ impl Resolver {
} }
if n_segments <= 1 { if n_segments <= 1 {
let mut hygiene_info = if !hygiene_id.is_root() { let mut hygiene_info = hygiene_info(db, hygiene_id);
let ctx = hygiene_id.lookup(db);
ctx.outer_expn.map(|expansion| {
let expansion = db.lookup_intern_macro_call(expansion);
(ctx.parent, expansion.def)
})
} else {
None
};
for scope in self.scopes() { for scope in self.scopes() {
match scope { match scope {
Scope::ExprScope(scope) => { Scope::ExprScope(scope) => {
@ -371,19 +364,7 @@ impl Resolver {
} }
} }
Scope::MacroDefScope(macro_id) => { Scope::MacroDefScope(macro_id) => {
if let Some((parent_ctx, label_macro_id)) = hygiene_info { handle_macro_def_scope(db, &mut hygiene_id, &mut hygiene_info, macro_id)
if label_macro_id == **macro_id {
// A macro is allowed to refer to variables from before its declaration.
// Therefore, if we got to the rib of its declaration, give up its hygiene
// and use its parent expansion.
let parent_ctx = db.lookup_intern_syntax_context(parent_ctx);
hygiene_id = HygieneId::new(parent_ctx.opaque_and_semitransparent);
hygiene_info = parent_ctx.outer_expn.map(|expansion| {
let expansion = db.lookup_intern_macro_call(expansion);
(parent_ctx.parent, expansion.def)
});
}
}
} }
Scope::GenericParams { params, def } => { Scope::GenericParams { params, def } => {
if let Some(id) = params.find_const_by_name(first_name, *def) { if let Some(id) = params.find_const_by_name(first_name, *def) {
@ -730,6 +711,107 @@ impl Resolver {
}) })
} }
/// Checks if we rename `renamed` (currently named `current_name`) to `new_name`, will the meaning of this reference
/// (that contains `current_name` path) change from `renamed` to some another variable (returned as `Some`).
pub fn rename_will_conflict_with_another_variable(
&self,
db: &dyn DefDatabase,
current_name: &Name,
current_name_as_path: &ModPath,
mut hygiene_id: HygieneId,
new_name: &Symbol,
to_be_renamed: BindingId,
) -> Option<BindingId> {
let mut hygiene_info = hygiene_info(db, hygiene_id);
let mut will_be_resolved_to = None;
for scope in self.scopes() {
match scope {
Scope::ExprScope(scope) => {
for entry in scope.expr_scopes.entries(scope.scope_id) {
if entry.hygiene() == hygiene_id {
if entry.binding() == to_be_renamed {
// This currently resolves to our renamed variable, now `will_be_resolved_to`
// contains `Some` if the meaning will change or `None` if not.
return will_be_resolved_to;
} else if entry.name().symbol() == new_name {
will_be_resolved_to = Some(entry.binding());
}
}
}
}
Scope::MacroDefScope(macro_id) => {
handle_macro_def_scope(db, &mut hygiene_id, &mut hygiene_info, macro_id)
}
Scope::GenericParams { params, def } => {
if params.find_const_by_name(current_name, *def).is_some() {
// It does not resolve to our renamed variable.
return None;
}
}
Scope::AdtScope(_) | Scope::ImplDefScope(_) => continue,
Scope::BlockScope(m) => {
if m.resolve_path_in_value_ns(db, current_name_as_path).is_some() {
// It does not resolve to our renamed variable.
return None;
}
}
}
}
// It does not resolve to our renamed variable.
None
}
/// Checks if we rename `renamed` to `name`, will the meaning of this reference (that contains `name` path) change
/// from some other variable (returned as `Some`) to `renamed`.
pub fn rename_will_conflict_with_renamed(
&self,
db: &dyn DefDatabase,
name: &Name,
name_as_path: &ModPath,
mut hygiene_id: HygieneId,
to_be_renamed: BindingId,
) -> Option<BindingId> {
let mut hygiene_info = hygiene_info(db, hygiene_id);
let mut will_resolve_to_renamed = false;
for scope in self.scopes() {
match scope {
Scope::ExprScope(scope) => {
for entry in scope.expr_scopes.entries(scope.scope_id) {
if entry.binding() == to_be_renamed {
will_resolve_to_renamed = true;
} else if entry.hygiene() == hygiene_id && entry.name() == name {
if will_resolve_to_renamed {
// This will resolve to the renamed variable before it resolves to the original variable.
return Some(entry.binding());
} else {
// This will resolve to the original variable.
return None;
}
}
}
}
Scope::MacroDefScope(macro_id) => {
handle_macro_def_scope(db, &mut hygiene_id, &mut hygiene_info, macro_id)
}
Scope::GenericParams { params, def } => {
if params.find_const_by_name(name, *def).is_some() {
// Here and below, it might actually resolve to our renamed variable - in which case it'll
// hide the generic parameter or some other thing (not a variable). We don't check for that
// because due to naming conventions, it is rare that variable will shadow a non-variable.
return None;
}
}
Scope::AdtScope(_) | Scope::ImplDefScope(_) => continue,
Scope::BlockScope(m) => {
if m.resolve_path_in_value_ns(db, name_as_path).is_some() {
return None;
}
}
}
}
None
}
/// `expr_id` is required to be an expression id that comes after the top level expression scope in the given resolver /// `expr_id` is required to be an expression id that comes after the top level expression scope in the given resolver
#[must_use] #[must_use]
pub fn update_to_inner_scope( pub fn update_to_inner_scope(
@ -795,6 +877,44 @@ impl Resolver {
} }
} }
#[inline]
fn handle_macro_def_scope(
db: &dyn DefDatabase,
hygiene_id: &mut HygieneId,
hygiene_info: &mut Option<(SyntaxContextId, MacroDefId)>,
macro_id: &MacroDefId,
) {
if let Some((parent_ctx, label_macro_id)) = hygiene_info {
if label_macro_id == macro_id {
// A macro is allowed to refer to variables from before its declaration.
// Therefore, if we got to the rib of its declaration, give up its hygiene
// and use its parent expansion.
let parent_ctx = db.lookup_intern_syntax_context(*parent_ctx);
*hygiene_id = HygieneId::new(parent_ctx.opaque_and_semitransparent);
*hygiene_info = parent_ctx.outer_expn.map(|expansion| {
let expansion = db.lookup_intern_macro_call(expansion);
(parent_ctx.parent, expansion.def)
});
}
}
}
#[inline]
fn hygiene_info(
db: &dyn DefDatabase,
hygiene_id: HygieneId,
) -> Option<(SyntaxContextId, MacroDefId)> {
if !hygiene_id.is_root() {
let ctx = hygiene_id.lookup(db);
ctx.outer_expn.map(|expansion| {
let expansion = db.lookup_intern_macro_call(expansion);
(ctx.parent, expansion.def)
})
} else {
None
}
}
pub struct UpdateGuard(usize); pub struct UpdateGuard(usize);
impl Resolver { impl Resolver {

68
src/tools/rust-analyzer/crates/hir-expand/src/fixup.rs
View File

@ -148,7 +148,6 @@ pub(crate) fn fixup_syntax(
} }
if it.then_branch().is_none() { if it.then_branch().is_none() {
append.insert(node.clone().into(), vec![ append.insert(node.clone().into(), vec![
// FIXME: THis should be a subtree no?
Leaf::Punct(Punct { Leaf::Punct(Punct {
char: '{', char: '{',
spacing: Spacing::Alone, spacing: Spacing::Alone,
@ -179,7 +178,6 @@ pub(crate) fn fixup_syntax(
} }
if it.loop_body().is_none() { if it.loop_body().is_none() {
append.insert(node.clone().into(), vec![ append.insert(node.clone().into(), vec![
// FIXME: THis should be a subtree no?
Leaf::Punct(Punct { Leaf::Punct(Punct {
char: '{', char: '{',
spacing: Spacing::Alone, spacing: Spacing::Alone,
@ -196,7 +194,6 @@ pub(crate) fn fixup_syntax(
ast::LoopExpr(it) => { ast::LoopExpr(it) => {
if it.loop_body().is_none() { if it.loop_body().is_none() {
append.insert(node.clone().into(), vec![ append.insert(node.clone().into(), vec![
// FIXME: THis should be a subtree no?
Leaf::Punct(Punct { Leaf::Punct(Punct {
char: '{', char: '{',
spacing: Spacing::Alone, spacing: Spacing::Alone,
@ -228,7 +225,6 @@ pub(crate) fn fixup_syntax(
if it.match_arm_list().is_none() { if it.match_arm_list().is_none() {
// No match arms // No match arms
append.insert(node.clone().into(), vec![ append.insert(node.clone().into(), vec![
// FIXME: THis should be a subtree no?
Leaf::Punct(Punct { Leaf::Punct(Punct {
char: '{', char: '{',
spacing: Spacing::Alone, spacing: Spacing::Alone,
@ -269,7 +265,6 @@ pub(crate) fn fixup_syntax(
if it.loop_body().is_none() { if it.loop_body().is_none() {
append.insert(node.clone().into(), vec![ append.insert(node.clone().into(), vec![
// FIXME: THis should be a subtree no?
Leaf::Punct(Punct { Leaf::Punct(Punct {
char: '{', char: '{',
spacing: Spacing::Alone, spacing: Spacing::Alone,
@ -309,28 +304,6 @@ pub(crate) fn fixup_syntax(
} }
} }
}, },
ast::ArgList(it) => {
if it.r_paren_token().is_none() {
append.insert(node.into(), vec![
Leaf::Punct(Punct {
span: fake_span(node_range),
char: ')',
spacing: Spacing::Alone
})
]);
}
},
ast::ArgList(it) => {
if it.r_paren_token().is_none() {
append.insert(node.into(), vec![
Leaf::Punct(Punct {
span: fake_span(node_range),
char: ')',
spacing: Spacing::Alone
})
]);
}
},
ast::ClosureExpr(it) => { ast::ClosureExpr(it) => {
if it.body().is_none() { if it.body().is_none() {
append.insert(node.into(), vec![ append.insert(node.into(), vec![
@ -476,12 +449,12 @@ fn reverse_fixups_(tt: &mut TopSubtree, undo_info: &[TopSubtree]) {
} }
} }
tt::TokenTree::Subtree(tt) => { tt::TokenTree::Subtree(tt) => {
// fixup should only create matching delimiters, but proc macros
// could just copy the span to one of the delimiters. We don't want
// to leak the dummy ID, so we remove both.
if tt.delimiter.close.anchor.ast_id == FIXUP_DUMMY_AST_ID if tt.delimiter.close.anchor.ast_id == FIXUP_DUMMY_AST_ID
|| tt.delimiter.open.anchor.ast_id == FIXUP_DUMMY_AST_ID || tt.delimiter.open.anchor.ast_id == FIXUP_DUMMY_AST_ID
{ {
// Even though fixup never creates subtrees with fixup spans, the old proc-macro server
// might copy them if the proc-macro asks for it, so we need to filter those out
// here as well.
return TransformTtAction::remove(); return TransformTtAction::remove();
} }
TransformTtAction::Keep TransformTtAction::Keep
@ -571,6 +544,17 @@ mod tests {
parse.syntax_node() parse.syntax_node()
); );
// the fixed-up tree should not contain braces as punct
// FIXME: should probably instead check that it's a valid punctuation character
for x in tt.token_trees().flat_tokens() {
match x {
::tt::TokenTree::Leaf(::tt::Leaf::Punct(punct)) => {
assert!(!matches!(punct.char, '{' | '}' | '(' | ')' | '[' | ']'))
}
_ => (),
}
}
reverse_fixups(&mut tt, &fixups.undo_info); reverse_fixups(&mut tt, &fixups.undo_info);
// the fixed-up + reversed version should be equivalent to the original input // the fixed-up + reversed version should be equivalent to the original input
@ -596,7 +580,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {for _ in __ra_fixup { }} fn foo () {for _ in __ra_fixup {}}
"#]], "#]],
) )
} }
@ -624,7 +608,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {for bar in qux { }} fn foo () {for bar in qux {}}
"#]], "#]],
) )
} }
@ -655,7 +639,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {match __ra_fixup { }} fn foo () {match __ra_fixup {}}
"#]], "#]],
) )
} }
@ -687,7 +671,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {match __ra_fixup { }} fn foo () {match __ra_fixup {}}
"#]], "#]],
) )
} }
@ -802,7 +786,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {if a { }} fn foo () {if a {}}
"#]], "#]],
) )
} }
@ -816,7 +800,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {if __ra_fixup { }} fn foo () {if __ra_fixup {}}
"#]], "#]],
) )
} }
@ -830,7 +814,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {if __ra_fixup {} { }} fn foo () {if __ra_fixup {} {}}
"#]], "#]],
) )
} }
@ -844,7 +828,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {while __ra_fixup { }} fn foo () {while __ra_fixup {}}
"#]], "#]],
) )
} }
@ -858,7 +842,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {while foo { }} fn foo () {while foo {}}
"#]], "#]],
) )
} }
@ -885,7 +869,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () {loop { }} fn foo () {loop {}}
"#]], "#]],
) )
} }
@ -941,7 +925,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () { foo ( a ) } fn foo () {foo (a)}
"#]], "#]],
); );
check( check(
@ -951,7 +935,7 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
fn foo () { bar . foo ( a ) } fn foo () {bar . foo (a)}
"#]], "#]],
); );
} }

2
src/tools/rust-analyzer/crates/hir-expand/src/lib.rs
View File

@ -5,6 +5,8 @@
//! expansion. //! expansion.
#![cfg_attr(feature = "in-rust-tree", feature(rustc_private))] #![cfg_attr(feature = "in-rust-tree", feature(rustc_private))]
pub use intern;
pub mod attrs; pub mod attrs;
pub mod builtin; pub mod builtin;
pub mod change; pub mod change;

4
src/tools/rust-analyzer/crates/hir-expand/src/mod_path.rs
View File

@ -388,7 +388,7 @@ macro_rules! __path {
($start:ident $(:: $seg:ident)*) => ({ ($start:ident $(:: $seg:ident)*) => ({
$crate::__known_path!($start $(:: $seg)*); $crate::__known_path!($start $(:: $seg)*);
$crate::mod_path::ModPath::from_segments($crate::mod_path::PathKind::Abs, vec![ $crate::mod_path::ModPath::from_segments($crate::mod_path::PathKind::Abs, vec![
$crate::name::Name::new_symbol_root(intern::sym::$start.clone()), $($crate::name::Name::new_symbol_root(intern::sym::$seg.clone()),)* $crate::name::Name::new_symbol_root($crate::intern::sym::$start.clone()), $($crate::name::Name::new_symbol_root($crate::intern::sym::$seg.clone()),)*
]) ])
}); });
} }
@ -399,7 +399,7 @@ pub use crate::__path as path;
macro_rules! __tool_path { macro_rules! __tool_path {
($start:ident $(:: $seg:ident)*) => ({ ($start:ident $(:: $seg:ident)*) => ({
$crate::mod_path::ModPath::from_segments($crate::mod_path::PathKind::Plain, vec![ $crate::mod_path::ModPath::from_segments($crate::mod_path::PathKind::Plain, vec![
$crate::name::Name::new_symbol_root(intern::sym::rust_analyzer.clone()), $crate::name::Name::new_symbol_root(intern::sym::$start.clone()), $($crate::name::Name::new_symbol_root(intern::sym::$seg.clone()),)* $crate::name::Name::new_symbol_root($crate::intern::sym::rust_analyzer.clone()), $crate::name::Name::new_symbol_root($crate::intern::sym::$start.clone()), $($crate::name::Name::new_symbol_root($crate::intern::sym::$seg.clone()),)*
]) ])
}); });
} }

1
src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
View File

@ -35,7 +35,6 @@ indexmap.workspace = true
rustc_apfloat = "0.2.0" rustc_apfloat = "0.2.0"
ra-ap-rustc_abi.workspace = true ra-ap-rustc_abi.workspace = true
ra-ap-rustc_hashes.workspace = true
ra-ap-rustc_index.workspace = true ra-ap-rustc_index.workspace = true
ra-ap-rustc_pattern_analysis.workspace = true ra-ap-rustc_pattern_analysis.workspace = true

8
src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
View File

@ -708,6 +708,9 @@ fn well_known_trait_from_lang_item(item: LangItem) -> Option<WellKnownTrait> {
LangItem::Fn => WellKnownTrait::Fn, LangItem::Fn => WellKnownTrait::Fn,
LangItem::FnMut => WellKnownTrait::FnMut, LangItem::FnMut => WellKnownTrait::FnMut,
LangItem::FnOnce => WellKnownTrait::FnOnce, LangItem::FnOnce => WellKnownTrait::FnOnce,
LangItem::AsyncFn => WellKnownTrait::AsyncFn,
LangItem::AsyncFnMut => WellKnownTrait::AsyncFnMut,
LangItem::AsyncFnOnce => WellKnownTrait::AsyncFnOnce,
LangItem::Coroutine => WellKnownTrait::Coroutine, LangItem::Coroutine => WellKnownTrait::Coroutine,
LangItem::Sized => WellKnownTrait::Sized, LangItem::Sized => WellKnownTrait::Sized,
LangItem::Unpin => WellKnownTrait::Unpin, LangItem::Unpin => WellKnownTrait::Unpin,
@ -715,6 +718,7 @@ fn well_known_trait_from_lang_item(item: LangItem) -> Option<WellKnownTrait> {
LangItem::Tuple => WellKnownTrait::Tuple, LangItem::Tuple => WellKnownTrait::Tuple,
LangItem::PointeeTrait => WellKnownTrait::Pointee, LangItem::PointeeTrait => WellKnownTrait::Pointee,
LangItem::FnPtrTrait => WellKnownTrait::FnPtr, LangItem::FnPtrTrait => WellKnownTrait::FnPtr,
LangItem::Future => WellKnownTrait::Future,
_ => return None, _ => return None,
}) })
} }
@ -730,6 +734,9 @@ fn lang_item_from_well_known_trait(trait_: WellKnownTrait) -> LangItem {
WellKnownTrait::Fn => LangItem::Fn, WellKnownTrait::Fn => LangItem::Fn,
WellKnownTrait::FnMut => LangItem::FnMut, WellKnownTrait::FnMut => LangItem::FnMut,
WellKnownTrait::FnOnce => LangItem::FnOnce, WellKnownTrait::FnOnce => LangItem::FnOnce,
WellKnownTrait::AsyncFn => LangItem::AsyncFn,
WellKnownTrait::AsyncFnMut => LangItem::AsyncFnMut,
WellKnownTrait::AsyncFnOnce => LangItem::AsyncFnOnce,
WellKnownTrait::Coroutine => LangItem::Coroutine, WellKnownTrait::Coroutine => LangItem::Coroutine,
WellKnownTrait::Sized => LangItem::Sized, WellKnownTrait::Sized => LangItem::Sized,
WellKnownTrait::Tuple => LangItem::Tuple, WellKnownTrait::Tuple => LangItem::Tuple,
@ -737,6 +744,7 @@ fn lang_item_from_well_known_trait(trait_: WellKnownTrait) -> LangItem {
WellKnownTrait::Unsize => LangItem::Unsize, WellKnownTrait::Unsize => LangItem::Unsize,
WellKnownTrait::Pointee => LangItem::PointeeTrait, WellKnownTrait::Pointee => LangItem::PointeeTrait,
WellKnownTrait::FnPtr => LangItem::FnPtrTrait, WellKnownTrait::FnPtr => LangItem::FnPtrTrait,
WellKnownTrait::Future => LangItem::Future,
} }
} }

17
src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
View File

@ -15,9 +15,10 @@ use stdx::never;
use triomphe::Arc; use triomphe::Arc;
use crate::{ use crate::{
db::HirDatabase, generics::Generics, infer::InferenceContext, lower::ParamLoweringMode, db::HirDatabase, display::DisplayTarget, generics::Generics, infer::InferenceContext,
mir::monomorphize_mir_body_bad, to_placeholder_idx, Const, ConstData, ConstScalar, ConstValue, lower::ParamLoweringMode, mir::monomorphize_mir_body_bad, to_placeholder_idx, Const, ConstData,
GenericArg, Interner, MemoryMap, Substitution, TraitEnvironment, Ty, TyBuilder, ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution, TraitEnvironment, Ty,
TyBuilder,
}; };
use super::mir::{interpret_mir, lower_to_mir, pad16, MirEvalError, MirLowerError}; use super::mir::{interpret_mir, lower_to_mir, pad16, MirEvalError, MirLowerError};
@ -62,11 +63,15 @@ impl ConstEvalError {
f: &mut String, f: &mut String,
db: &dyn HirDatabase, db: &dyn HirDatabase,
span_formatter: impl Fn(span::FileId, span::TextRange) -> String, span_formatter: impl Fn(span::FileId, span::TextRange) -> String,
edition: span::Edition, display_target: DisplayTarget,
) -> std::result::Result<(), std::fmt::Error> { ) -> std::result::Result<(), std::fmt::Error> {
match self { match self {
ConstEvalError::MirLowerError(e) => e.pretty_print(f, db, span_formatter, edition), ConstEvalError::MirLowerError(e) => {
ConstEvalError::MirEvalError(e) => e.pretty_print(f, db, span_formatter, edition), e.pretty_print(f, db, span_formatter, display_target)
}
ConstEvalError::MirEvalError(e) => {
e.pretty_print(f, db, span_formatter, display_target)
}
} }
} }
} }

21
src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
View File

@ -10,8 +10,8 @@ use test_fixture::WithFixture;
use test_utils::skip_slow_tests; use test_utils::skip_slow_tests;
use crate::{ use crate::{
consteval::try_const_usize, db::HirDatabase, mir::pad16, test_db::TestDB, Const, ConstScalar, consteval::try_const_usize, db::HirDatabase, display::DisplayTarget, mir::pad16,
Interner, MemoryMap, test_db::TestDB, Const, ConstScalar, Interner, MemoryMap,
}; };
use super::{ use super::{
@ -101,11 +101,17 @@ fn check_answer(
fn pretty_print_err(e: ConstEvalError, db: TestDB) -> String { fn pretty_print_err(e: ConstEvalError, db: TestDB) -> String {
let mut err = String::new(); let mut err = String::new();
let span_formatter = |file, range| format!("{file:?} {range:?}"); let span_formatter = |file, range| format!("{file:?} {range:?}");
let edition = let display_target = DisplayTarget::from_crate(
db.crate_graph()[*db.crate_graph().crates_in_topological_order().last().unwrap()].edition; &db,
*db.crate_graph().crates_in_topological_order().last().unwrap(),
);
match e { match e {
ConstEvalError::MirLowerError(e) => e.pretty_print(&mut err, &db, span_formatter, edition), ConstEvalError::MirLowerError(e) => {
ConstEvalError::MirEvalError(e) => e.pretty_print(&mut err, &db, span_formatter, edition), e.pretty_print(&mut err, &db, span_formatter, display_target)
}
ConstEvalError::MirEvalError(e) => {
e.pretty_print(&mut err, &db, span_formatter, display_target)
}
} }
.unwrap(); .unwrap();
err err
@ -2713,12 +2719,11 @@ fn const_trait_assoc() {
r#" r#"
//- minicore: size_of, fn //- minicore: size_of, fn
//- /a/lib.rs crate:a //- /a/lib.rs crate:a
use core::mem::size_of;
pub struct S<T>(T); pub struct S<T>(T);
impl<T> S<T> { impl<T> S<T> {
pub const X: usize = { pub const X: usize = {
let k: T; let k: T;
let f = || core::mem::size_of::<T>(); let f = || size_of::<T>();
f() f()
}; };
} }

5
src/tools/rust-analyzer/crates/hir-ty/src/diagnostics.rs
View File

@ -9,5 +9,8 @@ pub use crate::diagnostics::{
expr::{ expr::{
record_literal_missing_fields, record_pattern_missing_fields, BodyValidationDiagnostic, record_literal_missing_fields, record_pattern_missing_fields, BodyValidationDiagnostic,
}, },
unsafe_check::{missing_unsafe, unsafe_expressions, InsideUnsafeBlock, UnsafetyReason}, unsafe_check::{
missing_unsafe, unsafe_operations, unsafe_operations_for_body, InsideUnsafeBlock,
UnsafetyReason,
},
}; };

15
src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
View File

@ -16,7 +16,6 @@ use intern::sym;
use itertools::Itertools; use itertools::Itertools;
use rustc_hash::FxHashSet; use rustc_hash::FxHashSet;
use rustc_pattern_analysis::constructor::Constructor; use rustc_pattern_analysis::constructor::Constructor;
use span::Edition;
use syntax::{ use syntax::{
ast::{self, UnaryOp}, ast::{self, UnaryOp},
AstNode, AstNode,
@ -31,7 +30,7 @@ use crate::{
self, self,
pat_analysis::{self, DeconstructedPat, MatchCheckCtx, WitnessPat}, pat_analysis::{self, DeconstructedPat, MatchCheckCtx, WitnessPat},
}, },
display::HirDisplay, display::{DisplayTarget, HirDisplay},
Adjust, InferenceResult, Interner, Ty, TyExt, TyKind, Adjust, InferenceResult, Interner, Ty, TyExt, TyKind,
}; };
@ -633,24 +632,24 @@ fn missing_match_arms<'p>(
arms_is_empty: bool, arms_is_empty: bool,
krate: CrateId, krate: CrateId,
) -> String { ) -> String {
struct DisplayWitness<'a, 'p>(&'a WitnessPat<'p>, &'a MatchCheckCtx<'p>, Edition); struct DisplayWitness<'a, 'p>(&'a WitnessPat<'p>, &'a MatchCheckCtx<'p>, DisplayTarget);
impl fmt::Display for DisplayWitness<'_, '_> { impl fmt::Display for DisplayWitness<'_, '_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let DisplayWitness(witness, cx, edition) = *self; let DisplayWitness(witness, cx, display_target) = *self;
let pat = cx.hoist_witness_pat(witness); let pat = cx.hoist_witness_pat(witness);
write!(f, "{}", pat.display(cx.db, edition)) write!(f, "{}", pat.display(cx.db, display_target))
} }
} }
let edition = cx.db.crate_graph()[krate].edition;
let non_empty_enum = match scrut_ty.as_adt() { let non_empty_enum = match scrut_ty.as_adt() {
Some((AdtId::EnumId(e), _)) => !cx.db.enum_data(e).variants.is_empty(), Some((AdtId::EnumId(e), _)) => !cx.db.enum_data(e).variants.is_empty(),
_ => false, _ => false,
}; };
let display_target = DisplayTarget::from_crate(cx.db, krate);
if arms_is_empty && !non_empty_enum { if arms_is_empty && !non_empty_enum {
format!("type `{}` is non-empty", scrut_ty.display(cx.db, edition)) format!("type `{}` is non-empty", scrut_ty.display(cx.db, display_target))
} else { } else {
let pat_display = |witness| DisplayWitness(witness, cx, edition); let pat_display = |witness| DisplayWitness(witness, cx, display_target);
const LIMIT: usize = 3; const LIMIT: usize = 3;
match &*witnesses { match &*witnesses {
[witness] => format!("`{}` not covered", pat_display(witness)), [witness] => format!("`{}` not covered", pat_display(witness)),

42
src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
View File

@ -95,7 +95,26 @@ enum UnsafeDiagnostic {
DeprecatedSafe2024 { node: ExprId, inside_unsafe_block: InsideUnsafeBlock }, DeprecatedSafe2024 { node: ExprId, inside_unsafe_block: InsideUnsafeBlock },
} }
pub fn unsafe_expressions( pub fn unsafe_operations_for_body(
db: &dyn HirDatabase,
infer: &InferenceResult,
def: DefWithBodyId,
body: &Body,
callback: &mut dyn FnMut(ExprOrPatId),
) {
let mut visitor_callback = |diag| {
if let UnsafeDiagnostic::UnsafeOperation { node, .. } = diag {
callback(node);
}
};
let mut visitor = UnsafeVisitor::new(db, infer, body, def, &mut visitor_callback);
visitor.walk_expr(body.body_expr);
for &param in &body.params {
visitor.walk_pat(param);
}
}
pub fn unsafe_operations(
db: &dyn HirDatabase, db: &dyn HirDatabase,
infer: &InferenceResult, infer: &InferenceResult,
def: DefWithBodyId, def: DefWithBodyId,
@ -281,13 +300,6 @@ impl<'a> UnsafeVisitor<'a> {
self.on_unsafe_op(current.into(), UnsafetyReason::RawPtrDeref); self.on_unsafe_op(current.into(), UnsafetyReason::RawPtrDeref);
} }
} }
Expr::Unsafe { .. } => {
let old_inside_unsafe_block =
mem::replace(&mut self.inside_unsafe_block, InsideUnsafeBlock::Yes);
self.body.walk_child_exprs_without_pats(current, |child| self.walk_expr(child));
self.inside_unsafe_block = old_inside_unsafe_block;
return;
}
&Expr::Assignment { target, value: _ } => { &Expr::Assignment { target, value: _ } => {
let old_inside_assignment = mem::replace(&mut self.inside_assignment, true); let old_inside_assignment = mem::replace(&mut self.inside_assignment, true);
self.walk_pats_top(std::iter::once(target), current); self.walk_pats_top(std::iter::once(target), current);
@ -306,6 +318,20 @@ impl<'a> UnsafeVisitor<'a> {
} }
} }
} }
Expr::Unsafe { statements, .. } => {
let old_inside_unsafe_block =
mem::replace(&mut self.inside_unsafe_block, InsideUnsafeBlock::Yes);
self.walk_pats_top(
statements.iter().filter_map(|statement| match statement {
&Statement::Let { pat, .. } => Some(pat),
_ => None,
}),
current,
);
self.body.walk_child_exprs_without_pats(current, |child| self.walk_expr(child));
self.inside_unsafe_block = old_inside_unsafe_block;
return;
}
Expr::Block { statements, .. } | Expr::Async { statements, .. } => { Expr::Block { statements, .. } | Expr::Async { statements, .. } => {
self.walk_pats_top( self.walk_pats_top(
statements.iter().filter_map(|statement| match statement { statements.iter().filter_map(|statement| match statement {

145
src/tools/rust-analyzer/crates/hir-ty/src/display.rs
View File

@ -4,7 +4,7 @@
use std::{ use std::{
fmt::{self, Debug}, fmt::{self, Debug},
mem::{self, size_of}, mem,
}; };
use base_db::CrateId; use base_db::CrateId;
@ -45,6 +45,7 @@ use crate::{
db::{HirDatabase, InternedClosure}, db::{HirDatabase, InternedClosure},
from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx,
generics::generics, generics::generics,
infer::normalize,
layout::Layout, layout::Layout,
lt_from_placeholder_idx, lt_from_placeholder_idx,
mapping::from_chalk, mapping::from_chalk,
@ -87,6 +88,7 @@ pub struct HirFormatter<'a> {
show_container_bounds: bool, show_container_bounds: bool,
omit_verbose_types: bool, omit_verbose_types: bool,
closure_style: ClosureStyle, closure_style: ClosureStyle,
display_kind: DisplayKind,
display_target: DisplayTarget, display_target: DisplayTarget,
bounds_formatting_ctx: BoundsFormattingCtx, bounds_formatting_ctx: BoundsFormattingCtx,
} }
@ -164,6 +166,7 @@ pub trait HirDisplay {
limited_size: Option<usize>, limited_size: Option<usize>,
omit_verbose_types: bool, omit_verbose_types: bool,
display_target: DisplayTarget, display_target: DisplayTarget,
display_kind: DisplayKind,
closure_style: ClosureStyle, closure_style: ClosureStyle,
show_container_bounds: bool, show_container_bounds: bool,
) -> HirDisplayWrapper<'a, Self> ) -> HirDisplayWrapper<'a, Self>
@ -171,7 +174,7 @@ pub trait HirDisplay {
Self: Sized, Self: Sized,
{ {
assert!( assert!(
!matches!(display_target, DisplayTarget::SourceCode { .. }), !matches!(display_kind, DisplayKind::SourceCode { .. }),
"HirDisplayWrapper cannot fail with DisplaySourceCodeError, use HirDisplay::hir_fmt directly instead" "HirDisplayWrapper cannot fail with DisplaySourceCodeError, use HirDisplay::hir_fmt directly instead"
); );
HirDisplayWrapper { HirDisplayWrapper {
@ -181,6 +184,7 @@ pub trait HirDisplay {
limited_size, limited_size,
omit_verbose_types, omit_verbose_types,
display_target, display_target,
display_kind,
closure_style, closure_style,
show_container_bounds, show_container_bounds,
} }
@ -191,7 +195,7 @@ pub trait HirDisplay {
fn display<'a>( fn display<'a>(
&'a self, &'a self,
db: &'a dyn HirDatabase, db: &'a dyn HirDatabase,
edition: Edition, display_target: DisplayTarget,
) -> HirDisplayWrapper<'a, Self> ) -> HirDisplayWrapper<'a, Self>
where where
Self: Sized, Self: Sized,
@ -203,7 +207,8 @@ pub trait HirDisplay {
limited_size: None, limited_size: None,
omit_verbose_types: false, omit_verbose_types: false,
closure_style: ClosureStyle::ImplFn, closure_style: ClosureStyle::ImplFn,
display_target: DisplayTarget::Diagnostics { edition }, display_target,
display_kind: DisplayKind::Diagnostics,
show_container_bounds: false, show_container_bounds: false,
} }
} }
@ -214,7 +219,7 @@ pub trait HirDisplay {
&'a self, &'a self,
db: &'a dyn HirDatabase, db: &'a dyn HirDatabase,
max_size: Option<usize>, max_size: Option<usize>,
edition: Edition, display_target: DisplayTarget,
) -> HirDisplayWrapper<'a, Self> ) -> HirDisplayWrapper<'a, Self>
where where
Self: Sized, Self: Sized,
@ -226,7 +231,8 @@ pub trait HirDisplay {
limited_size: None, limited_size: None,
omit_verbose_types: true, omit_verbose_types: true,
closure_style: ClosureStyle::ImplFn, closure_style: ClosureStyle::ImplFn,
display_target: DisplayTarget::Diagnostics { edition }, display_target,
display_kind: DisplayKind::Diagnostics,
show_container_bounds: false, show_container_bounds: false,
} }
} }
@ -237,7 +243,7 @@ pub trait HirDisplay {
&'a self, &'a self,
db: &'a dyn HirDatabase, db: &'a dyn HirDatabase,
limited_size: Option<usize>, limited_size: Option<usize>,
edition: Edition, display_target: DisplayTarget,
) -> HirDisplayWrapper<'a, Self> ) -> HirDisplayWrapper<'a, Self>
where where
Self: Sized, Self: Sized,
@ -249,7 +255,8 @@ pub trait HirDisplay {
limited_size, limited_size,
omit_verbose_types: true, omit_verbose_types: true,
closure_style: ClosureStyle::ImplFn, closure_style: ClosureStyle::ImplFn,
display_target: DisplayTarget::Diagnostics { edition }, display_target,
display_kind: DisplayKind::Diagnostics,
show_container_bounds: false, show_container_bounds: false,
} }
} }
@ -272,7 +279,8 @@ pub trait HirDisplay {
entity_limit: None, entity_limit: None,
omit_verbose_types: false, omit_verbose_types: false,
closure_style: ClosureStyle::ImplFn, closure_style: ClosureStyle::ImplFn,
display_target: DisplayTarget::SourceCode { module_id, allow_opaque }, display_target: DisplayTarget::from_crate(db, module_id.krate()),
display_kind: DisplayKind::SourceCode { target_module_id: module_id, allow_opaque },
show_container_bounds: false, show_container_bounds: false,
bounds_formatting_ctx: Default::default(), bounds_formatting_ctx: Default::default(),
}) { }) {
@ -284,29 +292,10 @@ pub trait HirDisplay {
} }
/// Returns a String representation of `self` for test purposes /// Returns a String representation of `self` for test purposes
fn display_test<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self> fn display_test<'a>(
where
Self: Sized,
{
HirDisplayWrapper {
db,
t: self,
max_size: None,
limited_size: None,
omit_verbose_types: false,
closure_style: ClosureStyle::ImplFn,
display_target: DisplayTarget::Test,
show_container_bounds: false,
}
}
/// Returns a String representation of `self` that shows the constraint from
/// the container for functions
fn display_with_container_bounds<'a>(
&'a self, &'a self,
db: &'a dyn HirDatabase, db: &'a dyn HirDatabase,
show_container_bounds: bool, display_target: DisplayTarget,
edition: Edition,
) -> HirDisplayWrapper<'a, Self> ) -> HirDisplayWrapper<'a, Self>
where where
Self: Sized, Self: Sized,
@ -318,21 +307,44 @@ pub trait HirDisplay {
limited_size: None, limited_size: None,
omit_verbose_types: false, omit_verbose_types: false,
closure_style: ClosureStyle::ImplFn, closure_style: ClosureStyle::ImplFn,
display_target: DisplayTarget::Diagnostics { edition }, display_target,
display_kind: DisplayKind::Test,
show_container_bounds: false,
}
}
/// Returns a String representation of `self` that shows the constraint from
/// the container for functions
fn display_with_container_bounds<'a>(
&'a self,
db: &'a dyn HirDatabase,
show_container_bounds: bool,
display_target: DisplayTarget,
) -> HirDisplayWrapper<'a, Self>
where
Self: Sized,
{
HirDisplayWrapper {
db,
t: self,
max_size: None,
limited_size: None,
omit_verbose_types: false,
closure_style: ClosureStyle::ImplFn,
display_target,
display_kind: DisplayKind::Diagnostics,
show_container_bounds, show_container_bounds,
} }
} }
} }
impl HirFormatter<'_> { impl HirFormatter<'_> {
pub fn krate(&self) -> CrateId {
self.display_target.krate
}
pub fn edition(&self) -> Edition { pub fn edition(&self) -> Edition {
match self.display_target { self.display_target.edition
DisplayTarget::Diagnostics { edition } => edition,
DisplayTarget::SourceCode { module_id, .. } => {
self.db.crate_graph()[module_id.krate()].edition
}
DisplayTarget::Test => Edition::CURRENT,
}
} }
pub fn write_joined<T: HirDisplay>( pub fn write_joined<T: HirDisplay>(
@ -394,20 +406,33 @@ impl HirFormatter<'_> {
} }
} }
#[derive(Debug, Clone, Copy)]
pub struct DisplayTarget {
krate: CrateId,
pub edition: Edition,
}
impl DisplayTarget {
pub fn from_crate(db: &dyn HirDatabase, krate: CrateId) -> Self {
let edition = db.crate_graph()[krate].edition;
Self { krate, edition }
}
}
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
pub enum DisplayTarget { pub enum DisplayKind {
/// Display types for inlays, doc popups, autocompletion, etc... /// Display types for inlays, doc popups, autocompletion, etc...
/// Showing `{unknown}` or not qualifying paths is fine here. /// Showing `{unknown}` or not qualifying paths is fine here.
/// There's no reason for this to fail. /// There's no reason for this to fail.
Diagnostics { edition: Edition }, Diagnostics,
/// Display types for inserting them in source files. /// Display types for inserting them in source files.
/// The generated code should compile, so paths need to be qualified. /// The generated code should compile, so paths need to be qualified.
SourceCode { module_id: ModuleId, allow_opaque: bool }, SourceCode { target_module_id: ModuleId, allow_opaque: bool },
/// Only for test purpose to keep real types /// Only for test purpose to keep real types
Test, Test,
} }
impl DisplayTarget { impl DisplayKind {
fn is_source_code(self) -> bool { fn is_source_code(self) -> bool {
matches!(self, Self::SourceCode { .. }) matches!(self, Self::SourceCode { .. })
} }
@ -450,6 +475,7 @@ pub struct HirDisplayWrapper<'a, T> {
limited_size: Option<usize>, limited_size: Option<usize>,
omit_verbose_types: bool, omit_verbose_types: bool,
closure_style: ClosureStyle, closure_style: ClosureStyle,
display_kind: DisplayKind,
display_target: DisplayTarget, display_target: DisplayTarget,
show_container_bounds: bool, show_container_bounds: bool,
} }
@ -479,6 +505,7 @@ impl<T: HirDisplay> HirDisplayWrapper<'_, T> {
max_size: self.max_size, max_size: self.max_size,
entity_limit: self.limited_size, entity_limit: self.limited_size,
omit_verbose_types: self.omit_verbose_types, omit_verbose_types: self.omit_verbose_types,
display_kind: self.display_kind,
display_target: self.display_target, display_target: self.display_target,
closure_style: self.closure_style, closure_style: self.closure_style,
show_container_bounds: self.show_container_bounds, show_container_bounds: self.show_container_bounds,
@ -533,7 +560,7 @@ impl HirDisplay for ProjectionTy {
// if we are projection on a type parameter, check if the projection target has bounds // if we are projection on a type parameter, check if the projection target has bounds
// itself, if so, we render them directly as `impl Bound` instead of the less useful // itself, if so, we render them directly as `impl Bound` instead of the less useful
// `<Param as Trait>::Assoc` // `<Param as Trait>::Assoc`
if !f.display_target.is_source_code() { if !f.display_kind.is_source_code() {
if let TyKind::Placeholder(idx) = self_ty.kind(Interner) { if let TyKind::Placeholder(idx) = self_ty.kind(Interner) {
if !f.bounds_formatting_ctx.contains(self) { if !f.bounds_formatting_ctx.contains(self) {
let db = f.db; let db = f.db;
@ -653,10 +680,8 @@ fn render_const_scalar(
memory_map: &MemoryMap, memory_map: &MemoryMap,
ty: &Ty, ty: &Ty,
) -> Result<(), HirDisplayError> { ) -> Result<(), HirDisplayError> {
// FIXME: We need to get krate from the final callers of the hir display let trait_env = TraitEnvironment::empty(f.krate());
// infrastructure and have it here as a field on `f`. let ty = normalize(f.db, trait_env.clone(), ty.clone());
let trait_env =
TraitEnvironment::empty(*f.db.crate_graph().crates_in_topological_order().last().unwrap());
match ty.kind(Interner) { match ty.kind(Interner) {
TyKind::Scalar(s) => match s { TyKind::Scalar(s) => match s {
Scalar::Bool => write!(f, "{}", b[0] != 0), Scalar::Bool => write!(f, "{}", b[0] != 0),
@ -1109,7 +1134,7 @@ impl HirDisplay for Ty {
let def = from_chalk(db, *def); let def = from_chalk(db, *def);
let sig = db.callable_item_signature(def).substitute(Interner, parameters); let sig = db.callable_item_signature(def).substitute(Interner, parameters);
if f.display_target.is_source_code() { if f.display_kind.is_source_code() {
// `FnDef` is anonymous and there's no surface syntax for it. Show it as a // `FnDef` is anonymous and there's no surface syntax for it. Show it as a
// function pointer type. // function pointer type.
return sig.hir_fmt(f); return sig.hir_fmt(f);
@ -1198,8 +1223,8 @@ impl HirDisplay for Ty {
} }
TyKind::Adt(AdtId(def_id), parameters) => { TyKind::Adt(AdtId(def_id), parameters) => {
f.start_location_link((*def_id).into()); f.start_location_link((*def_id).into());
match f.display_target { match f.display_kind {
DisplayTarget::Diagnostics { .. } | DisplayTarget::Test => { DisplayKind::Diagnostics { .. } | DisplayKind::Test { .. } => {
let name = match *def_id { let name = match *def_id {
hir_def::AdtId::StructId(it) => db.struct_data(it).name.clone(), hir_def::AdtId::StructId(it) => db.struct_data(it).name.clone(),
hir_def::AdtId::UnionId(it) => db.union_data(it).name.clone(), hir_def::AdtId::UnionId(it) => db.union_data(it).name.clone(),
@ -1207,7 +1232,7 @@ impl HirDisplay for Ty {
}; };
write!(f, "{}", name.display(f.db.upcast(), f.edition()))?; write!(f, "{}", name.display(f.db.upcast(), f.edition()))?;
} }
DisplayTarget::SourceCode { module_id, allow_opaque: _ } => { DisplayKind::SourceCode { target_module_id: module_id, allow_opaque: _ } => {
if let Some(path) = find_path::find_path( if let Some(path) = find_path::find_path(
db.upcast(), db.upcast(),
ItemInNs::Types((*def_id).into()), ItemInNs::Types((*def_id).into()),
@ -1246,7 +1271,7 @@ impl HirDisplay for Ty {
let type_alias_data = db.type_alias_data(type_alias); let type_alias_data = db.type_alias_data(type_alias);
// Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types) // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types)
if f.display_target.is_test() { if f.display_kind.is_test() {
f.start_location_link(trait_.into()); f.start_location_link(trait_.into());
write!(f, "{}", trait_data.name.display(f.db.upcast(), f.edition()))?; write!(f, "{}", trait_data.name.display(f.db.upcast(), f.edition()))?;
f.end_location_link(); f.end_location_link();
@ -1275,7 +1300,7 @@ impl HirDisplay for Ty {
f.end_location_link(); f.end_location_link();
} }
TyKind::OpaqueType(opaque_ty_id, parameters) => { TyKind::OpaqueType(opaque_ty_id, parameters) => {
if !f.display_target.allows_opaque() { if !f.display_kind.allows_opaque() {
return Err(HirDisplayError::DisplaySourceCodeError( return Err(HirDisplayError::DisplaySourceCodeError(
DisplaySourceCodeError::OpaqueType, DisplaySourceCodeError::OpaqueType,
)); ));
@ -1344,8 +1369,8 @@ impl HirDisplay for Ty {
} }
} }
TyKind::Closure(id, substs) => { TyKind::Closure(id, substs) => {
if f.display_target.is_source_code() { if f.display_kind.is_source_code() {
if !f.display_target.allows_opaque() { if !f.display_kind.allows_opaque() {
return Err(HirDisplayError::DisplaySourceCodeError( return Err(HirDisplayError::DisplaySourceCodeError(
DisplaySourceCodeError::OpaqueType, DisplaySourceCodeError::OpaqueType,
)); ));
@ -1465,7 +1490,7 @@ impl HirDisplay for Ty {
} }
TyKind::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?, TyKind::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?,
TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
if !f.display_target.allows_opaque() { if !f.display_kind.allows_opaque() {
return Err(HirDisplayError::DisplaySourceCodeError( return Err(HirDisplayError::DisplaySourceCodeError(
DisplaySourceCodeError::OpaqueType, DisplaySourceCodeError::OpaqueType,
)); ));
@ -1508,7 +1533,7 @@ impl HirDisplay for Ty {
}; };
} }
TyKind::Error => { TyKind::Error => {
if f.display_target.is_source_code() { if f.display_kind.is_source_code() {
f.write_char('_')?; f.write_char('_')?;
} else { } else {
write!(f, "{{unknown}}")?; write!(f, "{{unknown}}")?;
@ -1516,7 +1541,7 @@ impl HirDisplay for Ty {
} }
TyKind::InferenceVar(..) => write!(f, "_")?, TyKind::InferenceVar(..) => write!(f, "_")?,
TyKind::Coroutine(_, subst) => { TyKind::Coroutine(_, subst) => {
if f.display_target.is_source_code() { if f.display_kind.is_source_code() {
return Err(HirDisplayError::DisplaySourceCodeError( return Err(HirDisplayError::DisplaySourceCodeError(
DisplaySourceCodeError::Coroutine, DisplaySourceCodeError::Coroutine,
)); ));
@ -1573,7 +1598,7 @@ fn generic_args_sans_defaults<'ga>(
generic_def: Option<hir_def::GenericDefId>, generic_def: Option<hir_def::GenericDefId>,
parameters: &'ga [GenericArg], parameters: &'ga [GenericArg],
) -> &'ga [GenericArg] { ) -> &'ga [GenericArg] {
if f.display_target.is_source_code() || f.omit_verbose_types() { if f.display_kind.is_source_code() || f.omit_verbose_types() {
match generic_def match generic_def
.map(|generic_def_id| f.db.generic_defaults(generic_def_id)) .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
.filter(|it| !it.is_empty()) .filter(|it| !it.is_empty())
@ -1958,7 +1983,7 @@ impl HirDisplay for LifetimeData {
write!(f, "{}", param_data.name.display(f.db.upcast(), f.edition()))?; write!(f, "{}", param_data.name.display(f.db.upcast(), f.edition()))?;
Ok(()) Ok(())
} }
_ if f.display_target.is_source_code() => write!(f, "'_"), _ if f.display_kind.is_source_code() => write!(f, "'_"),
LifetimeData::BoundVar(idx) => idx.hir_fmt(f), LifetimeData::BoundVar(idx) => idx.hir_fmt(f),
LifetimeData::InferenceVar(_) => write!(f, "_"), LifetimeData::InferenceVar(_) => write!(f, "_"),
LifetimeData::Static => write!(f, "'static"), LifetimeData::Static => write!(f, "'static"),

81
src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
View File

@ -6,9 +6,8 @@ use base_db::ra_salsa::Cycle;
use chalk_ir::{AdtId, FloatTy, IntTy, TyKind, UintTy}; use chalk_ir::{AdtId, FloatTy, IntTy, TyKind, UintTy};
use hir_def::{ use hir_def::{
layout::{ layout::{
Float, Integer, LayoutCalculator, LayoutCalculatorError, Float, Integer, LayoutCalculator, LayoutCalculatorError, LayoutData, Primitive,
LayoutData, Primitive, ReprOptions, Scalar, StructKind, TargetDataLayout, ReprOptions, Scalar, StructKind, TargetDataLayout, WrappingRange,
WrappingRange,
}, },
LocalFieldId, StructId, LocalFieldId, StructId,
}; };
@ -192,43 +191,52 @@ pub fn layout_of_ty_query(
valid_range: WrappingRange { start: 0, end: 0x10FFFF }, valid_range: WrappingRange { start: 0, end: 0x10FFFF },
}, },
), ),
chalk_ir::Scalar::Int(i) => Layout::scalar(dl, scalar_unit( chalk_ir::Scalar::Int(i) => Layout::scalar(
dl, dl,
Primitive::Int( scalar_unit(
match i { dl,
IntTy::Isize => dl.ptr_sized_integer(), Primitive::Int(
IntTy::I8 => Integer::I8, match i {
IntTy::I16 => Integer::I16, IntTy::Isize => dl.ptr_sized_integer(),
IntTy::I32 => Integer::I32, IntTy::I8 => Integer::I8,
IntTy::I64 => Integer::I64, IntTy::I16 => Integer::I16,
IntTy::I128 => Integer::I128, IntTy::I32 => Integer::I32,
}, IntTy::I64 => Integer::I64,
true, IntTy::I128 => Integer::I128,
},
true,
),
), ),
)), ),
chalk_ir::Scalar::Uint(i) => Layout::scalar(dl, scalar_unit( chalk_ir::Scalar::Uint(i) => Layout::scalar(
dl, dl,
Primitive::Int( scalar_unit(
match i { dl,
UintTy::Usize => dl.ptr_sized_integer(), Primitive::Int(
UintTy::U8 => Integer::I8, match i {
UintTy::U16 => Integer::I16, UintTy::Usize => dl.ptr_sized_integer(),
UintTy::U32 => Integer::I32, UintTy::U8 => Integer::I8,
UintTy::U64 => Integer::I64, UintTy::U16 => Integer::I16,
UintTy::U128 => Integer::I128, UintTy::U32 => Integer::I32,
}, UintTy::U64 => Integer::I64,
false, UintTy::U128 => Integer::I128,
},
false,
),
), ),
)), ),
chalk_ir::Scalar::Float(f) => Layout::scalar(dl, scalar_unit( chalk_ir::Scalar::Float(f) => Layout::scalar(
dl, dl,
Primitive::Float(match f { scalar_unit(
FloatTy::F16 => Float::F16, dl,
FloatTy::F32 => Float::F32, Primitive::Float(match f {
FloatTy::F64 => Float::F64, FloatTy::F16 => Float::F16,
FloatTy::F128 => Float::F128, FloatTy::F32 => Float::F32,
}), FloatTy::F64 => Float::F64,
)), FloatTy::F128 => Float::F128,
}),
),
),
}, },
TyKind::Tuple(len, tys) => { TyKind::Tuple(len, tys) => {
let kind = if *len == 0 { StructKind::AlwaysSized } else { StructKind::MaybeUnsized }; let kind = if *len == 0 { StructKind::AlwaysSized } else { StructKind::MaybeUnsized };
@ -341,6 +349,9 @@ pub fn layout_of_ty_query(
TyKind::Error => return Err(LayoutError::HasErrorType), TyKind::Error => return Err(LayoutError::HasErrorType),
TyKind::AssociatedType(id, subst) => { TyKind::AssociatedType(id, subst) => {
// Try again with `TyKind::Alias` to normalize the associated type. // Try again with `TyKind::Alias` to normalize the associated type.
// Usually we should not try to normalize `TyKind::AssociatedType`, but layout calculation is used
// in monomorphized MIR where this is okay. If outside monomorphization, this will lead to cycle,
// which we will recover from with an error.
let ty = TyKind::Alias(chalk_ir::AliasTy::Projection(ProjectionTy { let ty = TyKind::Alias(chalk_ir::AliasTy::Projection(ProjectionTy {
associated_ty_id: *id, associated_ty_id: *id,
substitution: subst.clone(), substitution: subst.clone(),

2
src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
View File

@ -342,7 +342,7 @@ fn simd_types() {
check_size_and_align( check_size_and_align(
r#" r#"
#[repr(simd)] #[repr(simd)]
struct SimdType(i64, i64); struct SimdType([i64; 2]);
struct Goal(SimdType); struct Goal(SimdType);
"#, "#,
"", "",

13
src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
View File

@ -21,9 +21,6 @@ extern crate rustc_pattern_analysis;
#[cfg(not(feature = "in-rust-tree"))] #[cfg(not(feature = "in-rust-tree"))]
extern crate ra_ap_rustc_pattern_analysis as rustc_pattern_analysis; extern crate ra_ap_rustc_pattern_analysis as rustc_pattern_analysis;
#[cfg(not(feature = "in-rust-tree"))]
extern crate ra_ap_rustc_hashes as rustc_hashes;
mod builder; mod builder;
mod chalk_db; mod chalk_db;
mod chalk_ext; mod chalk_ext;
@ -73,13 +70,15 @@ use intern::{sym, Symbol};
use la_arena::{Arena, Idx}; use la_arena::{Arena, Idx};
use mir::{MirEvalError, VTableMap}; use mir::{MirEvalError, VTableMap};
use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet}; use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
use span::Edition;
use syntax::ast::{make, ConstArg}; use syntax::ast::{make, ConstArg};
use traits::FnTrait; use traits::FnTrait;
use triomphe::Arc; use triomphe::Arc;
use crate::{ use crate::{
consteval::unknown_const, db::HirDatabase, display::HirDisplay, generics::Generics, consteval::unknown_const,
db::HirDatabase,
display::{DisplayTarget, HirDisplay},
generics::Generics,
infer::unify::InferenceTable, infer::unify::InferenceTable,
}; };
@ -1041,7 +1040,7 @@ where
pub fn known_const_to_ast( pub fn known_const_to_ast(
konst: &Const, konst: &Const,
db: &dyn HirDatabase, db: &dyn HirDatabase,
edition: Edition, display_target: DisplayTarget,
) -> Option<ConstArg> { ) -> Option<ConstArg> {
if let ConstValue::Concrete(c) = &konst.interned().value { if let ConstValue::Concrete(c) = &konst.interned().value {
match c.interned { match c.interned {
@ -1052,7 +1051,7 @@ pub fn known_const_to_ast(
_ => (), _ => (),
} }
} }
Some(make::expr_const_value(konst.display(db, edition).to_string().as_str())) Some(make::expr_const_value(konst.display(db, display_target).to_string().as_str()))
} }
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]

4
src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
View File

@ -5,7 +5,7 @@ use std::{collections::hash_map::Entry, fmt::Display, iter};
use crate::{ use crate::{
consteval::usize_const, consteval::usize_const,
db::HirDatabase, db::HirDatabase,
display::HirDisplay, display::{DisplayTarget, HirDisplay},
infer::{normalize, PointerCast}, infer::{normalize, PointerCast},
lang_items::is_box, lang_items::is_box,
mapping::ToChalk, mapping::ToChalk,
@ -168,7 +168,7 @@ impl<V, T> ProjectionElem<V, T> {
_ => { _ => {
never!( never!(
"Overloaded deref on type {} is not a projection", "Overloaded deref on type {} is not a projection",
base.display(db, db.crate_graph()[krate].edition) base.display(db, DisplayTarget::from_crate(db, krate))
); );
TyKind::Error.intern(Interner) TyKind::Error.intern(Interner)
} }

6
src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
View File

@ -13,6 +13,7 @@ use triomphe::Arc;
use crate::{ use crate::{
db::{HirDatabase, InternedClosure}, db::{HirDatabase, InternedClosure},
display::DisplayTarget,
mir::Operand, mir::Operand,
utils::ClosureSubst, utils::ClosureSubst,
ClosureId, Interner, Substitution, Ty, TyExt, TypeFlags, ClosureId, Interner, Substitution, Ty, TyExt, TypeFlags,
@ -422,7 +423,10 @@ fn ever_initialized_map(
let Some(terminator) = &block.terminator else { let Some(terminator) = &block.terminator else {
never!( never!(
"Terminator should be none only in construction.\nThe body:\n{}", "Terminator should be none only in construction.\nThe body:\n{}",
body.pretty_print(db) body.pretty_print(
db,
DisplayTarget::from_crate(db, body.owner.krate(db.upcast()))
)
); );
return; return;
}; };

31
src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
View File

@ -24,7 +24,7 @@ use rustc_apfloat::{
Float, Float,
}; };
use rustc_hash::{FxHashMap, FxHashSet}; use rustc_hash::{FxHashMap, FxHashSet};
use span::{Edition, FileId}; use span::FileId;
use stdx::never; use stdx::never;
use syntax::{SyntaxNodePtr, TextRange}; use syntax::{SyntaxNodePtr, TextRange};
use triomphe::Arc; use triomphe::Arc;
@ -32,7 +32,7 @@ use triomphe::Arc;
use crate::{ use crate::{
consteval::{intern_const_scalar, try_const_usize, ConstEvalError}, consteval::{intern_const_scalar, try_const_usize, ConstEvalError},
db::{HirDatabase, InternedClosure}, db::{HirDatabase, InternedClosure},
display::{ClosureStyle, HirDisplay}, display::{ClosureStyle, DisplayTarget, HirDisplay},
infer::PointerCast, infer::PointerCast,
layout::{Layout, LayoutError, RustcEnumVariantIdx}, layout::{Layout, LayoutError, RustcEnumVariantIdx},
mapping::from_chalk, mapping::from_chalk,
@ -302,7 +302,7 @@ impl Address {
} }
} }
fn to_bytes(&self) -> [u8; mem::size_of::<usize>()] { fn to_bytes(&self) -> [u8; size_of::<usize>()] {
usize::to_le_bytes(self.to_usize()) usize::to_le_bytes(self.to_usize())
} }
@ -359,7 +359,7 @@ impl MirEvalError {
f: &mut String, f: &mut String,
db: &dyn HirDatabase, db: &dyn HirDatabase,
span_formatter: impl Fn(FileId, TextRange) -> String, span_formatter: impl Fn(FileId, TextRange) -> String,
edition: Edition, display_target: DisplayTarget,
) -> std::result::Result<(), std::fmt::Error> { ) -> std::result::Result<(), std::fmt::Error> {
writeln!(f, "Mir eval error:")?; writeln!(f, "Mir eval error:")?;
let mut err = self; let mut err = self;
@ -372,7 +372,7 @@ impl MirEvalError {
writeln!( writeln!(
f, f,
"In function {} ({:?})", "In function {} ({:?})",
function_name.name.display(db.upcast(), edition), function_name.name.display(db.upcast(), display_target.edition),
func func
)?; )?;
} }
@ -417,7 +417,7 @@ impl MirEvalError {
write!( write!(
f, f,
"Layout for type `{}` is not available due {err:?}", "Layout for type `{}` is not available due {err:?}",
ty.display(db, edition).with_closure_style(ClosureStyle::ClosureWithId) ty.display(db, display_target).with_closure_style(ClosureStyle::ClosureWithId)
)?; )?;
} }
MirEvalError::MirLowerError(func, err) => { MirEvalError::MirLowerError(func, err) => {
@ -428,12 +428,15 @@ impl MirEvalError {
let substs = generics.placeholder_subst(db); let substs = generics.placeholder_subst(db);
db.impl_self_ty(impl_id) db.impl_self_ty(impl_id)
.substitute(Interner, &substs) .substitute(Interner, &substs)
.display(db, edition) .display(db, display_target)
.to_string() .to_string()
}), }),
ItemContainerId::TraitId(it) => { ItemContainerId::TraitId(it) => Some(
Some(db.trait_data(it).name.display(db.upcast(), edition).to_string()) db.trait_data(it)
} .name
.display(db.upcast(), display_target.edition)
.to_string(),
),
_ => None, _ => None,
}; };
writeln!( writeln!(
@ -441,17 +444,17 @@ impl MirEvalError {
"MIR lowering for function `{}{}{}` ({:?}) failed due:", "MIR lowering for function `{}{}{}` ({:?}) failed due:",
self_.as_deref().unwrap_or_default(), self_.as_deref().unwrap_or_default(),
if self_.is_some() { "::" } else { "" }, if self_.is_some() { "::" } else { "" },
function_name.name.display(db.upcast(), edition), function_name.name.display(db.upcast(), display_target.edition),
func func
)?; )?;
err.pretty_print(f, db, span_formatter, edition)?; err.pretty_print(f, db, span_formatter, display_target)?;
} }
MirEvalError::ConstEvalError(name, err) => { MirEvalError::ConstEvalError(name, err) => {
MirLowerError::ConstEvalError((**name).into(), err.clone()).pretty_print( MirLowerError::ConstEvalError((**name).into(), err.clone()).pretty_print(
f, f,
db, db,
span_formatter, span_formatter,
edition, display_target,
)?; )?;
} }
MirEvalError::UndefinedBehavior(_) MirEvalError::UndefinedBehavior(_)
@ -589,7 +592,7 @@ pub fn interpret_mir(
let ty = body.locals[return_slot()].ty.clone(); let ty = body.locals[return_slot()].ty.clone();
let mut evaluator = Evaluator::new(db, body.owner, assert_placeholder_ty_is_unused, trait_env)?; let mut evaluator = Evaluator::new(db, body.owner, assert_placeholder_ty_is_unused, trait_env)?;
let it: Result<Const> = (|| { let it: Result<Const> = (|| {
if evaluator.ptr_size() != std::mem::size_of::<usize>() { if evaluator.ptr_size() != size_of::<usize>() {
not_supported!("targets with different pointer size from host"); not_supported!("targets with different pointer size from host");
} }
let interval = evaluator.interpret_mir(body.clone(), None.into_iter())?; let interval = evaluator.interpret_mir(body.clone(), None.into_iter())?;

4
src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
View File

@ -14,6 +14,7 @@ use intern::{sym, Symbol};
use stdx::never; use stdx::never;
use crate::{ use crate::{
display::DisplayTarget,
error_lifetime, error_lifetime,
mir::eval::{ mir::eval::{
pad16, Address, AdtId, Arc, BuiltinType, Evaluator, FunctionId, HasModule, HirDisplay, pad16, Address, AdtId, Arc, BuiltinType, Evaluator, FunctionId, HasModule, HirDisplay,
@ -835,8 +836,7 @@ impl Evaluator<'_> {
// render full paths. // render full paths.
Err(_) => { Err(_) => {
let krate = locals.body.owner.krate(self.db.upcast()); let krate = locals.body.owner.krate(self.db.upcast());
let edition = self.db.crate_graph()[krate].edition; ty.display(self.db, DisplayTarget::from_crate(self.db, krate)).to_string()
ty.display(self.db, edition).to_string()
} }
}; };
let len = ty_name.len(); let len = ty_name.len();

5
src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
View File

@ -3,6 +3,7 @@ use span::{Edition, EditionedFileId};
use syntax::{TextRange, TextSize}; use syntax::{TextRange, TextSize};
use test_fixture::WithFixture; use test_fixture::WithFixture;
use crate::display::DisplayTarget;
use crate::{db::HirDatabase, mir::MirLowerError, test_db::TestDB, Interner, Substitution}; use crate::{db::HirDatabase, mir::MirLowerError, test_db::TestDB, Interner, Substitution};
use super::{interpret_mir, MirEvalError}; use super::{interpret_mir, MirEvalError};
@ -67,7 +68,9 @@ fn check_pass_and_stdio(
let span_formatter = |file, range: TextRange| { let span_formatter = |file, range: TextRange| {
format!("{:?} {:?}..{:?}", file, line_index(range.start()), line_index(range.end())) format!("{:?} {:?}..{:?}", file, line_index(range.start()), line_index(range.end()))
}; };
e.pretty_print(&mut err, &db, span_formatter, Edition::CURRENT).unwrap(); let krate = db.module_for_file(file_id).krate();
e.pretty_print(&mut err, &db, span_formatter, DisplayTarget::from_crate(&db, krate))
.unwrap();
panic!("Error in interpreting: {err}"); panic!("Error in interpreting: {err}");
} }
Ok((stdout, stderr)) => { Ok((stdout, stderr)) => {

57
src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
View File

@ -2,7 +2,7 @@
use std::{fmt::Write, iter, mem}; use std::{fmt::Write, iter, mem};
use base_db::ra_salsa::Cycle; use base_db::{ra_salsa::Cycle, CrateId};
use chalk_ir::{BoundVar, ConstData, DebruijnIndex, TyKind}; use chalk_ir::{BoundVar, ConstData, DebruijnIndex, TyKind};
use hir_def::{ use hir_def::{
data::adt::{StructKind, VariantData}, data::adt::{StructKind, VariantData},
@ -29,7 +29,7 @@ use triomphe::Arc;
use crate::{ use crate::{
consteval::ConstEvalError, consteval::ConstEvalError,
db::{HirDatabase, InternedClosure}, db::{HirDatabase, InternedClosure},
display::{hir_display_with_types_map, HirDisplay}, display::{hir_display_with_types_map, DisplayTarget, HirDisplay},
error_lifetime, error_lifetime,
generics::generics, generics::generics,
infer::{cast::CastTy, unify::InferenceTable, CaptureKind, CapturedItem, TypeMismatch}, infer::{cast::CastTy, unify::InferenceTable, CaptureKind, CapturedItem, TypeMismatch},
@ -160,17 +160,17 @@ impl MirLowerError {
f: &mut String, f: &mut String,
db: &dyn HirDatabase, db: &dyn HirDatabase,
span_formatter: impl Fn(FileId, TextRange) -> String, span_formatter: impl Fn(FileId, TextRange) -> String,
edition: Edition, display_target: DisplayTarget,
) -> std::result::Result<(), std::fmt::Error> { ) -> std::result::Result<(), std::fmt::Error> {
match self { match self {
MirLowerError::ConstEvalError(name, e) => { MirLowerError::ConstEvalError(name, e) => {
writeln!(f, "In evaluating constant {name}")?; writeln!(f, "In evaluating constant {name}")?;
match &**e { match &**e {
ConstEvalError::MirLowerError(e) => { ConstEvalError::MirLowerError(e) => {
e.pretty_print(f, db, span_formatter, edition)? e.pretty_print(f, db, span_formatter, display_target)?
} }
ConstEvalError::MirEvalError(e) => { ConstEvalError::MirEvalError(e) => {
e.pretty_print(f, db, span_formatter, edition)? e.pretty_print(f, db, span_formatter, display_target)?
} }
} }
} }
@ -179,15 +179,15 @@ impl MirLowerError {
writeln!( writeln!(
f, f,
"Missing function definition for {}", "Missing function definition for {}",
body.pretty_print_expr(db.upcast(), *owner, *it, edition) body.pretty_print_expr(db.upcast(), *owner, *it, display_target.edition)
)?; )?;
} }
MirLowerError::HasErrors => writeln!(f, "Type inference result contains errors")?, MirLowerError::HasErrors => writeln!(f, "Type inference result contains errors")?,
MirLowerError::TypeMismatch(e) => writeln!( MirLowerError::TypeMismatch(e) => writeln!(
f, f,
"Type mismatch: Expected {}, found {}", "Type mismatch: Expected {}, found {}",
e.expected.display(db, edition), e.expected.display(db, display_target),
e.actual.display(db, edition), e.actual.display(db, display_target),
)?, )?,
MirLowerError::GenericArgNotProvided(id, subst) => { MirLowerError::GenericArgNotProvided(id, subst) => {
let parent = id.parent; let parent = id.parent;
@ -195,11 +195,14 @@ impl MirLowerError {
writeln!( writeln!(
f, f,
"Generic arg not provided for {}", "Generic arg not provided for {}",
param.name().unwrap_or(&Name::missing()).display(db.upcast(), edition) param
.name()
.unwrap_or(&Name::missing())
.display(db.upcast(), display_target.edition)
)?; )?;
writeln!(f, "Provided args: [")?; writeln!(f, "Provided args: [")?;
for g in subst.iter(Interner) { for g in subst.iter(Interner) {
write!(f, " {},", g.display(db, edition))?; write!(f, " {},", g.display(db, display_target))?;
} }
writeln!(f, "]")?; writeln!(f, "]")?;
} }
@ -251,11 +254,11 @@ impl MirLowerError {
fn unresolved_path( fn unresolved_path(
db: &dyn HirDatabase, db: &dyn HirDatabase,
p: &Path, p: &Path,
edition: Edition, display_target: DisplayTarget,
types_map: &TypesMap, types_map: &TypesMap,
) -> Self { ) -> Self {
Self::UnresolvedName( Self::UnresolvedName(
hir_display_with_types_map(p, types_map).display(db, edition).to_string(), hir_display_with_types_map(p, types_map).display(db, display_target).to_string(),
) )
} }
} }
@ -462,7 +465,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
MirLowerError::unresolved_path( MirLowerError::unresolved_path(
self.db, self.db,
p, p,
self.edition(), DisplayTarget::from_crate(self.db, self.krate()),
&self.body.types, &self.body.types,
) )
})?; })?;
@ -838,7 +841,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
self.infer.variant_resolution_for_expr(expr_id).ok_or_else(|| match path { self.infer.variant_resolution_for_expr(expr_id).ok_or_else(|| match path {
Some(p) => MirLowerError::UnresolvedName( Some(p) => MirLowerError::UnresolvedName(
hir_display_with_types_map(&**p, &self.body.types) hir_display_with_types_map(&**p, &self.body.types)
.display(self.db, self.edition()) .display(self.db, self.display_target())
.to_string(), .to_string(),
), ),
None => MirLowerError::RecordLiteralWithoutPath, None => MirLowerError::RecordLiteralWithoutPath,
@ -1362,9 +1365,16 @@ impl<'ctx> MirLowerCtx<'ctx> {
match &self.body.exprs[*loc] { match &self.body.exprs[*loc] {
Expr::Literal(l) => self.lower_literal_to_operand(ty, l), Expr::Literal(l) => self.lower_literal_to_operand(ty, l),
Expr::Path(c) => { Expr::Path(c) => {
let edition = self.edition(); let owner = self.owner;
let unresolved_name = let db = self.db;
|| MirLowerError::unresolved_path(self.db, c, edition, &self.body.types); let unresolved_name = || {
MirLowerError::unresolved_path(
self.db,
c,
DisplayTarget::from_crate(db, owner.krate(db.upcast())),
&self.body.types,
)
};
let pr = self let pr = self
.resolver .resolver
.resolve_path_in_value_ns(self.db.upcast(), c, HygieneId::ROOT) .resolve_path_in_value_ns(self.db.upcast(), c, HygieneId::ROOT)
@ -1394,7 +1404,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
.layout_of_ty(ty.clone(), self.db.trait_environment_for_body(self.owner)) .layout_of_ty(ty.clone(), self.db.trait_environment_for_body(self.owner))
.map(|it| it.size.bytes_usize()) .map(|it| it.size.bytes_usize())
}; };
const USIZE_SIZE: usize = mem::size_of::<usize>(); const USIZE_SIZE: usize = size_of::<usize>();
let bytes: Box<[_]> = match l { let bytes: Box<[_]> = match l {
hir_def::hir::Literal::String(b) => { hir_def::hir::Literal::String(b) => {
let b = b.as_str(); let b = b.as_str();
@ -1910,8 +1920,15 @@ impl<'ctx> MirLowerCtx<'ctx> {
} }
fn edition(&self) -> Edition { fn edition(&self) -> Edition {
let krate = self.owner.krate(self.db.upcast()); self.db.crate_graph()[self.krate()].edition
self.db.crate_graph()[krate].edition }
fn krate(&self) -> CrateId {
self.owner.krate(self.db.upcast())
}
fn display_target(&self) -> DisplayTarget {
DisplayTarget::from_crate(self.db, self.krate())
} }
fn drop_until_scope( fn drop_until_scope(

7
src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
View File

@ -350,7 +350,12 @@ impl MirLowerCtx<'_> {
)?, )?,
None => { None => {
let unresolved_name = || { let unresolved_name = || {
MirLowerError::unresolved_path(self.db, p, self.edition(), &self.body.types) MirLowerError::unresolved_path(
self.db,
p,
self.display_target(),
&self.body.types,
)
}; };
let hygiene = self.body.pat_path_hygiene(pattern); let hygiene = self.body.pat_path_hygiene(pattern);
let pr = self let pr = self

63
src/tools/rust-analyzer/crates/hir-ty/src/mir/pretty.rs
View File

@ -9,11 +9,10 @@ use either::Either;
use hir_def::{expr_store::Body, hir::BindingId}; use hir_def::{expr_store::Body, hir::BindingId};
use hir_expand::{name::Name, Lookup}; use hir_expand::{name::Name, Lookup};
use la_arena::ArenaMap; use la_arena::ArenaMap;
use span::Edition;
use crate::{ use crate::{
db::HirDatabase, db::HirDatabase,
display::{ClosureStyle, HirDisplay}, display::{ClosureStyle, DisplayTarget, HirDisplay},
mir::{PlaceElem, ProjectionElem, StatementKind, TerminatorKind}, mir::{PlaceElem, ProjectionElem, StatementKind, TerminatorKind},
ClosureId, ClosureId,
}; };
@ -39,17 +38,21 @@ macro_rules! wln {
} }
impl MirBody { impl MirBody {
pub fn pretty_print(&self, db: &dyn HirDatabase) -> String { pub fn pretty_print(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> String {
let hir_body = db.body(self.owner); let hir_body = db.body(self.owner);
let mut ctx = MirPrettyCtx::new(self, &hir_body, db); let mut ctx = MirPrettyCtx::new(self, &hir_body, db, display_target);
ctx.for_body(|this| match ctx.body.owner { ctx.for_body(|this| match ctx.body.owner {
hir_def::DefWithBodyId::FunctionId(id) => { hir_def::DefWithBodyId::FunctionId(id) => {
let data = db.function_data(id); let data = db.function_data(id);
w!(this, "fn {}() ", data.name.display(db.upcast(), Edition::LATEST)); w!(this, "fn {}() ", data.name.display(db.upcast(), this.display_target.edition));
} }
hir_def::DefWithBodyId::StaticId(id) => { hir_def::DefWithBodyId::StaticId(id) => {
let data = db.static_data(id); let data = db.static_data(id);
w!(this, "static {}: _ = ", data.name.display(db.upcast(), Edition::LATEST)); w!(
this,
"static {}: _ = ",
data.name.display(db.upcast(), this.display_target.edition)
);
} }
hir_def::DefWithBodyId::ConstId(id) => { hir_def::DefWithBodyId::ConstId(id) => {
let data = db.const_data(id); let data = db.const_data(id);
@ -59,7 +62,7 @@ impl MirBody {
data.name data.name
.as_ref() .as_ref()
.unwrap_or(&Name::missing()) .unwrap_or(&Name::missing())
.display(db.upcast(), Edition::LATEST) .display(db.upcast(), this.display_target.edition)
); );
} }
hir_def::DefWithBodyId::VariantId(id) => { hir_def::DefWithBodyId::VariantId(id) => {
@ -70,10 +73,10 @@ impl MirBody {
"enum {}::{} = ", "enum {}::{} = ",
enum_loc.id.item_tree(db.upcast())[enum_loc.id.value] enum_loc.id.item_tree(db.upcast())[enum_loc.id.value]
.name .name
.display(db.upcast(), Edition::LATEST), .display(db.upcast(), this.display_target.edition),
loc.id.item_tree(db.upcast())[loc.id.value] loc.id.item_tree(db.upcast())[loc.id.value]
.name .name
.display(db.upcast(), Edition::LATEST), .display(db.upcast(), this.display_target.edition),
) )
} }
hir_def::DefWithBodyId::InTypeConstId(id) => { hir_def::DefWithBodyId::InTypeConstId(id) => {
@ -85,14 +88,14 @@ impl MirBody {
// String with lines is rendered poorly in `dbg` macros, which I use very much, so this // String with lines is rendered poorly in `dbg` macros, which I use very much, so this
// function exists to solve that. // function exists to solve that.
pub fn dbg(&self, db: &dyn HirDatabase) -> impl Debug { pub fn dbg(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> impl Debug {
struct StringDbg(String); struct StringDbg(String);
impl Debug for StringDbg { impl Debug for StringDbg {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0) f.write_str(&self.0)
} }
} }
StringDbg(self.pretty_print(db)) StringDbg(self.pretty_print(db, display_target))
} }
} }
@ -103,6 +106,7 @@ struct MirPrettyCtx<'a> {
result: String, result: String,
indent: String, indent: String,
local_to_binding: ArenaMap<LocalId, BindingId>, local_to_binding: ArenaMap<LocalId, BindingId>,
display_target: DisplayTarget,
} }
impl Write for MirPrettyCtx<'_> { impl Write for MirPrettyCtx<'_> {
@ -182,7 +186,12 @@ impl<'a> MirPrettyCtx<'a> {
wln!(self, "}}"); wln!(self, "}}");
} }
fn new(body: &'a MirBody, hir_body: &'a Body, db: &'a dyn HirDatabase) -> Self { fn new(
body: &'a MirBody,
hir_body: &'a Body,
db: &'a dyn HirDatabase,
display_target: DisplayTarget,
) -> Self {
let local_to_binding = body.local_to_binding_map(); let local_to_binding = body.local_to_binding_map();
MirPrettyCtx { MirPrettyCtx {
body, body,
@ -191,6 +200,7 @@ impl<'a> MirPrettyCtx<'a> {
indent: String::new(), indent: String::new(),
local_to_binding, local_to_binding,
hir_body, hir_body,
display_target,
} }
} }
@ -208,7 +218,7 @@ impl<'a> MirPrettyCtx<'a> {
wln!( wln!(
self, self,
"let {}: {};", "let {}: {};",
self.local_name(id).display_test(self.db), self.local_name(id).display_test(self.db, self.display_target),
self.hir_display(&local.ty) self.hir_display(&local.ty)
); );
} }
@ -242,14 +252,14 @@ impl<'a> MirPrettyCtx<'a> {
wln!( wln!(
this, this,
"StorageDead({})", "StorageDead({})",
this.local_name(*p).display_test(self.db) this.local_name(*p).display_test(this.db, this.display_target)
); );
} }
StatementKind::StorageLive(p) => { StatementKind::StorageLive(p) => {
wln!( wln!(
this, this,
"StorageLive({})", "StorageLive({})",
this.local_name(*p).display_test(self.db) this.local_name(*p).display_test(this.db, this.display_target)
); );
} }
StatementKind::Deinit(p) => { StatementKind::Deinit(p) => {
@ -313,7 +323,7 @@ impl<'a> MirPrettyCtx<'a> {
fn f(this: &mut MirPrettyCtx<'_>, local: LocalId, projections: &[PlaceElem]) { fn f(this: &mut MirPrettyCtx<'_>, local: LocalId, projections: &[PlaceElem]) {
let Some((last, head)) = projections.split_last() else { let Some((last, head)) = projections.split_last() else {
// no projection // no projection
w!(this, "{}", this.local_name(local).display_test(this.db)); w!(this, "{}", this.local_name(local).display_test(this.db, this.display_target));
return; return;
}; };
match last { match last {
@ -333,13 +343,17 @@ impl<'a> MirPrettyCtx<'a> {
w!( w!(
this, this,
" as {}).{}", " as {}).{}",
variant_name.display(this.db.upcast(), Edition::LATEST), variant_name.display(this.db.upcast(), this.display_target.edition),
name.display(this.db.upcast(), Edition::LATEST) name.display(this.db.upcast(), this.display_target.edition)
); );
} }
hir_def::VariantId::StructId(_) | hir_def::VariantId::UnionId(_) => { hir_def::VariantId::StructId(_) | hir_def::VariantId::UnionId(_) => {
f(this, local, head); f(this, local, head);
w!(this, ".{}", name.display(this.db.upcast(), Edition::LATEST)); w!(
this,
".{}",
name.display(this.db.upcast(), this.display_target.edition)
);
} }
} }
} }
@ -353,7 +367,11 @@ impl<'a> MirPrettyCtx<'a> {
} }
ProjectionElem::Index(l) => { ProjectionElem::Index(l) => {
f(this, local, head); f(this, local, head);
w!(this, "[{}]", this.local_name(*l).display_test(this.db)); w!(
this,
"[{}]",
this.local_name(*l).display_test(this.db, this.display_target)
);
} }
it => { it => {
f(this, local, head); f(this, local, head);
@ -403,7 +421,7 @@ impl<'a> MirPrettyCtx<'a> {
Rvalue::Repeat(op, len) => { Rvalue::Repeat(op, len) => {
w!(self, "["); w!(self, "[");
self.operand(op); self.operand(op);
w!(self, "; {}]", len.display_test(self.db)); w!(self, "; {}]", len.display_test(self.db, self.display_target));
} }
Rvalue::Aggregate(AggregateKind::Adt(_, _), it) => { Rvalue::Aggregate(AggregateKind::Adt(_, _), it) => {
w!(self, "Adt("); w!(self, "Adt(");
@ -478,6 +496,7 @@ impl<'a> MirPrettyCtx<'a> {
} }
fn hir_display<T: HirDisplay>(&self, ty: &'a T) -> impl Display + 'a { fn hir_display<T: HirDisplay>(&self, ty: &'a T) -> impl Display + 'a {
ty.display_test(self.db).with_closure_style(ClosureStyle::ClosureWithSubst) ty.display_test(self.db, self.display_target)
.with_closure_style(ClosureStyle::ClosureWithSubst)
} }
} }

47
src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
View File

@ -15,7 +15,7 @@ mod type_alias_impl_traits;
use std::env; use std::env;
use std::sync::LazyLock; use std::sync::LazyLock;
use base_db::SourceDatabaseFileInputExt as _; use base_db::{CrateId, SourceDatabaseFileInputExt as _};
use expect_test::Expect; use expect_test::Expect;
use hir_def::{ use hir_def::{
db::DefDatabase, db::DefDatabase,
@ -41,7 +41,7 @@ use triomphe::Arc;
use crate::{ use crate::{
db::HirDatabase, db::HirDatabase,
display::HirDisplay, display::{DisplayTarget, HirDisplay},
infer::{Adjustment, TypeMismatch}, infer::{Adjustment, TypeMismatch},
test_db::TestDB, test_db::TestDB,
InferenceResult, Ty, InferenceResult, Ty,
@ -124,7 +124,7 @@ fn check_impl(
} }
assert!(had_annotations || allow_none, "no `//^` annotations found"); assert!(had_annotations || allow_none, "no `//^` annotations found");
let mut defs: Vec<DefWithBodyId> = Vec::new(); let mut defs: Vec<(DefWithBodyId, CrateId)> = Vec::new();
for file_id in files { for file_id in files {
let module = db.module_for_file_opt(file_id); let module = db.module_for_file_opt(file_id);
let module = match module { let module = match module {
@ -133,16 +133,17 @@ fn check_impl(
}; };
let def_map = module.def_map(&db); let def_map = module.def_map(&db);
visit_module(&db, &def_map, module.local_id, &mut |it| { visit_module(&db, &def_map, module.local_id, &mut |it| {
defs.push(match it { let def = match it {
ModuleDefId::FunctionId(it) => it.into(), ModuleDefId::FunctionId(it) => it.into(),
ModuleDefId::EnumVariantId(it) => it.into(), ModuleDefId::EnumVariantId(it) => it.into(),
ModuleDefId::ConstId(it) => it.into(), ModuleDefId::ConstId(it) => it.into(),
ModuleDefId::StaticId(it) => it.into(), ModuleDefId::StaticId(it) => it.into(),
_ => return, _ => return,
}) };
defs.push((def, module.krate()))
}); });
} }
defs.sort_by_key(|def| match def { defs.sort_by_key(|(def, _)| match def {
DefWithBodyId::FunctionId(it) => { DefWithBodyId::FunctionId(it) => {
let loc = it.lookup(&db); let loc = it.lookup(&db);
loc.source(&db).value.syntax().text_range().start() loc.source(&db).value.syntax().text_range().start()
@ -162,7 +163,8 @@ fn check_impl(
DefWithBodyId::InTypeConstId(it) => it.source(&db).syntax().text_range().start(), DefWithBodyId::InTypeConstId(it) => it.source(&db).syntax().text_range().start(),
}); });
let mut unexpected_type_mismatches = String::new(); let mut unexpected_type_mismatches = String::new();
for def in defs { for (def, krate) in defs {
let display_target = DisplayTarget::from_crate(&db, krate);
let (body, body_source_map) = db.body_with_source_map(def); let (body, body_source_map) = db.body_with_source_map(def);
let inference_result = db.infer(def); let inference_result = db.infer(def);
@ -179,7 +181,7 @@ fn check_impl(
let actual = if display_source { let actual = if display_source {
ty.display_source_code(&db, def.module(&db), true).unwrap() ty.display_source_code(&db, def.module(&db), true).unwrap()
} else { } else {
ty.display_test(&db).to_string() ty.display_test(&db, display_target).to_string()
}; };
assert_eq!(actual, expected, "type annotation differs at {:#?}", range.range); assert_eq!(actual, expected, "type annotation differs at {:#?}", range.range);
} }
@ -195,7 +197,7 @@ fn check_impl(
let actual = if display_source { let actual = if display_source {
ty.display_source_code(&db, def.module(&db), true).unwrap() ty.display_source_code(&db, def.module(&db), true).unwrap()
} else { } else {
ty.display_test(&db).to_string() ty.display_test(&db, display_target).to_string()
}; };
assert_eq!(actual, expected, "type annotation differs at {:#?}", range.range); assert_eq!(actual, expected, "type annotation differs at {:#?}", range.range);
} }
@ -224,8 +226,8 @@ fn check_impl(
let range = node.as_ref().original_file_range_rooted(&db); let range = node.as_ref().original_file_range_rooted(&db);
let actual = format!( let actual = format!(
"expected {}, got {}", "expected {}, got {}",
mismatch.expected.display_test(&db), mismatch.expected.display_test(&db, display_target),
mismatch.actual.display_test(&db) mismatch.actual.display_test(&db, display_target)
); );
match mismatches.remove(&range) { match mismatches.remove(&range) {
Some(annotation) => assert_eq!(actual, annotation), Some(annotation) => assert_eq!(actual, annotation),
@ -299,7 +301,9 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
let mut infer_def = |inference_result: Arc<InferenceResult>, let mut infer_def = |inference_result: Arc<InferenceResult>,
body: Arc<Body>, body: Arc<Body>,
body_source_map: Arc<BodySourceMap>| { body_source_map: Arc<BodySourceMap>,
krate: CrateId| {
let display_target = DisplayTarget::from_crate(&db, krate);
let mut types: Vec<(InFile<SyntaxNode>, &Ty)> = Vec::new(); let mut types: Vec<(InFile<SyntaxNode>, &Ty)> = Vec::new();
let mut mismatches: Vec<(InFile<SyntaxNode>, &TypeMismatch)> = Vec::new(); let mut mismatches: Vec<(InFile<SyntaxNode>, &TypeMismatch)> = Vec::new();
@ -361,7 +365,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
macro_prefix, macro_prefix,
range, range,
ellipsize(text, 15), ellipsize(text, 15),
ty.display_test(&db) ty.display_test(&db, display_target)
); );
} }
if include_mismatches { if include_mismatches {
@ -377,8 +381,8 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
"{}{:?}: expected {}, got {}\n", "{}{:?}: expected {}, got {}\n",
macro_prefix, macro_prefix,
range, range,
mismatch.expected.display_test(&db), mismatch.expected.display_test(&db, display_target),
mismatch.actual.display_test(&db), mismatch.actual.display_test(&db, display_target),
); );
} }
} }
@ -387,17 +391,18 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
let module = db.module_for_file(file_id); let module = db.module_for_file(file_id);
let def_map = module.def_map(&db); let def_map = module.def_map(&db);
let mut defs: Vec<DefWithBodyId> = Vec::new(); let mut defs: Vec<(DefWithBodyId, CrateId)> = Vec::new();
visit_module(&db, &def_map, module.local_id, &mut |it| { visit_module(&db, &def_map, module.local_id, &mut |it| {
defs.push(match it { let def = match it {
ModuleDefId::FunctionId(it) => it.into(), ModuleDefId::FunctionId(it) => it.into(),
ModuleDefId::EnumVariantId(it) => it.into(), ModuleDefId::EnumVariantId(it) => it.into(),
ModuleDefId::ConstId(it) => it.into(), ModuleDefId::ConstId(it) => it.into(),
ModuleDefId::StaticId(it) => it.into(), ModuleDefId::StaticId(it) => it.into(),
_ => return, _ => return,
}) };
defs.push((def, module.krate()))
}); });
defs.sort_by_key(|def| match def { defs.sort_by_key(|(def, _)| match def {
DefWithBodyId::FunctionId(it) => { DefWithBodyId::FunctionId(it) => {
let loc = it.lookup(&db); let loc = it.lookup(&db);
loc.source(&db).value.syntax().text_range().start() loc.source(&db).value.syntax().text_range().start()
@ -416,10 +421,10 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
} }
DefWithBodyId::InTypeConstId(it) => it.source(&db).syntax().text_range().start(), DefWithBodyId::InTypeConstId(it) => it.source(&db).syntax().text_range().start(),
}); });
for def in defs { for (def, krate) in defs {
let (body, source_map) = db.body_with_source_map(def); let (body, source_map) = db.body_with_source_map(def);
let infer = db.infer(def); let infer = db.infer(def);
infer_def(infer, body, source_map); infer_def(infer, body, source_map, krate);
} }
buf.truncate(buf.trim_end().len()); buf.truncate(buf.trim_end().len());

8
src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
View File

@ -8,7 +8,7 @@ use syntax::{AstNode, AstPtr};
use test_fixture::WithFixture; use test_fixture::WithFixture;
use crate::db::{HirDatabase, InternedClosureId}; use crate::db::{HirDatabase, InternedClosureId};
use crate::display::HirDisplay; use crate::display::{DisplayTarget, HirDisplay};
use crate::mir::MirSpan; use crate::mir::MirSpan;
use crate::test_db::TestDB; use crate::test_db::TestDB;
@ -66,7 +66,11 @@ fn check_closure_captures(#[rust_analyzer::rust_fixture] ra_fixture: &str, expec
.join(", "), .join(", "),
}; };
let place = capture.display_place(closure.0, db); let place = capture.display_place(closure.0, db);
let capture_ty = capture.ty.skip_binders().display_test(db).to_string(); let capture_ty = capture
.ty
.skip_binders()
.display_test(db, DisplayTarget::from_crate(db, module.krate()))
.to_string();
let spans = capture let spans = capture
.spans() .spans()
.iter() .iter()

39
src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
View File

@ -3861,3 +3861,42 @@ fn main() {
"#]], "#]],
); );
} }
#[test]
fn regression_19196() {
check_infer(
r#"
//- minicore: async_fn
fn async_closure<F: AsyncFnOnce(i32)>(f: F) {}
fn closure<F: FnOnce(i32)>(f: F) {}
fn main() {
async_closure(async |arg| {
arg;
});
closure(|arg| {
arg;
});
}
"#,
expect![[r#"
38..39 'f': F
44..46 '{}': ()
74..75 'f': F
80..82 '{}': ()
94..191 '{ ... }); }': ()
100..113 'async_closure': fn async_closure<impl AsyncFnOnce(i32) -> impl Future<Output = ()>>(impl AsyncFnOnce(i32) -> impl Future<Output = ()>)
100..147 'async_... })': ()
114..146 'async ... }': impl AsyncFnOnce(i32) -> impl Future<Output = ()>
121..124 'arg': i32
126..146 '{ ... }': ()
136..139 'arg': i32
153..160 'closure': fn closure<impl FnOnce(i32)>(impl FnOnce(i32))
153..188 'closur... })': ()
161..187 '|arg| ... }': impl FnOnce(i32)
162..165 'arg': i32
167..187 '{ ... }': ()
177..180 'arg': i32
"#]],
);
}

12
src/tools/rust-analyzer/crates/hir/src/has_source.rs
View File

@ -15,7 +15,7 @@ use tt::TextRange;
use crate::{ use crate::{
db::HirDatabase, Adt, Callee, Const, Enum, ExternCrateDecl, Field, FieldSource, Function, Impl, db::HirDatabase, Adt, Callee, Const, Enum, ExternCrateDecl, Field, FieldSource, Function, Impl,
InlineAsmOperand, Label, LifetimeParam, LocalSource, Macro, Module, Param, SelfParam, Static, InlineAsmOperand, Label, LifetimeParam, LocalSource, Macro, Module, Param, SelfParam, Static,
Struct, Trait, TraitAlias, TypeAlias, TypeOrConstParam, Union, Variant, Struct, Trait, TraitAlias, TypeAlias, TypeOrConstParam, Union, Variant, VariantDef,
}; };
pub trait HasSource { pub trait HasSource {
@ -110,6 +110,16 @@ impl HasSource for Adt {
} }
} }
} }
impl HasSource for VariantDef {
type Ast = ast::VariantDef;
fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
match self {
VariantDef::Struct(s) => Some(s.source(db)?.map(ast::VariantDef::Struct)),
VariantDef::Union(u) => Some(u.source(db)?.map(ast::VariantDef::Union)),
VariantDef::Variant(v) => Some(v.source(db)?.map(ast::VariantDef::Variant)),
}
}
}
impl HasSource for Struct { impl HasSource for Struct {
type Ast = ast::Struct; type Ast = ast::Struct;
fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> { fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {

74
src/tools/rust-analyzer/crates/hir/src/lib.rs
View File

@ -39,7 +39,7 @@ use std::{
}; };
use arrayvec::ArrayVec; use arrayvec::ArrayVec;
use base_db::{CrateDisplayName, CrateId, CrateOrigin}; use base_db::{CrateDisplayName, CrateId, CrateOrigin, LangCrateOrigin};
use either::Either; use either::Either;
use hir_def::{ use hir_def::{
data::{adt::VariantData, TraitFlags}, data::{adt::VariantData, TraitFlags},
@ -139,6 +139,7 @@ pub use {
}, },
hygiene::{marks_rev, SyntaxContextExt}, hygiene::{marks_rev, SyntaxContextExt},
inert_attr_macro::AttributeTemplate, inert_attr_macro::AttributeTemplate,
mod_path::tool_path,
name::Name, name::Name,
prettify_macro_expansion, prettify_macro_expansion,
proc_macro::{ProcMacros, ProcMacrosBuilder}, proc_macro::{ProcMacros, ProcMacrosBuilder},
@ -147,7 +148,7 @@ pub use {
hir_ty::{ hir_ty::{
consteval::ConstEvalError, consteval::ConstEvalError,
diagnostics::UnsafetyReason, diagnostics::UnsafetyReason,
display::{ClosureStyle, HirDisplay, HirDisplayError, HirWrite}, display::{ClosureStyle, DisplayTarget, HirDisplay, HirDisplayError, HirWrite},
dyn_compatibility::{DynCompatibilityViolation, MethodViolationCode}, dyn_compatibility::{DynCompatibilityViolation, MethodViolationCode},
layout::LayoutError, layout::LayoutError,
method_resolution::TyFingerprint, method_resolution::TyFingerprint,
@ -282,6 +283,21 @@ impl Crate {
let data = &db.crate_graph()[self.id]; let data = &db.crate_graph()[self.id];
data.potential_cfg_options.clone().unwrap_or_else(|| data.cfg_options.clone()) data.potential_cfg_options.clone().unwrap_or_else(|| data.cfg_options.clone())
} }
pub fn to_display_target(self, db: &dyn HirDatabase) -> DisplayTarget {
DisplayTarget::from_crate(db, self.id)
}
fn core(db: &dyn HirDatabase) -> Option<Crate> {
let crate_graph = db.crate_graph();
let result = crate_graph
.iter()
.find(|&krate| {
matches!(crate_graph[krate].origin, CrateOrigin::Lang(LangCrateOrigin::Core))
})
.map(Crate::from);
result
}
} }
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@ -296,6 +312,7 @@ pub enum ModuleDef {
Function(Function), Function(Function),
Adt(Adt), Adt(Adt),
// Can't be directly declared, but can be imported. // Can't be directly declared, but can be imported.
// FIXME: Rename to `EnumVariant`
Variant(Variant), Variant(Variant),
Const(Const), Const(Const),
Static(Static), Static(Static),
@ -469,6 +486,17 @@ impl ModuleDef {
} }
} }
impl HasCrate for ModuleDef {
fn krate(&self, db: &dyn HirDatabase) -> Crate {
match self.module(db) {
Some(module) => module.krate(),
None => Crate::core(db).unwrap_or_else(|| {
(*db.crate_graph().crates_in_topological_order().last().unwrap()).into()
}),
}
}
}
impl HasVisibility for ModuleDef { impl HasVisibility for ModuleDef {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility { fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
match *self { match *self {
@ -1564,6 +1592,7 @@ impl From<&Variant> for DefWithBodyId {
} }
} }
// FIXME: Rename to `EnumVariant`
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Variant { pub struct Variant {
pub(crate) id: EnumVariantId, pub(crate) id: EnumVariantId,
@ -1863,7 +1892,7 @@ impl DefWithBody {
pub fn debug_mir(self, db: &dyn HirDatabase) -> String { pub fn debug_mir(self, db: &dyn HirDatabase) -> String {
let body = db.mir_body(self.id()); let body = db.mir_body(self.id());
match body { match body {
Ok(body) => body.pretty_print(db), Ok(body) => body.pretty_print(db, self.module(db).krate().to_display_target(db)),
Err(e) => format!("error:\n{e:?}"), Err(e) => format!("error:\n{e:?}"),
} }
} }
@ -2449,8 +2478,6 @@ impl Function {
db: &dyn HirDatabase, db: &dyn HirDatabase,
span_formatter: impl Fn(FileId, TextRange) -> String, span_formatter: impl Fn(FileId, TextRange) -> String,
) -> Result<String, ConstEvalError> { ) -> Result<String, ConstEvalError> {
let krate = HasModule::krate(&self.id, db.upcast());
let edition = db.crate_graph()[krate].edition;
let body = db.monomorphized_mir_body( let body = db.monomorphized_mir_body(
self.id.into(), self.id.into(),
Substitution::empty(Interner), Substitution::empty(Interner),
@ -2461,7 +2488,12 @@ impl Function {
Ok(_) => "pass".to_owned(), Ok(_) => "pass".to_owned(),
Err(e) => { Err(e) => {
let mut r = String::new(); let mut r = String::new();
_ = e.pretty_print(&mut r, db, &span_formatter, edition); _ = e.pretty_print(
&mut r,
db,
&span_formatter,
self.krate(db).to_display_target(db),
);
r r
} }
}; };
@ -2725,8 +2757,8 @@ pub struct EvaluatedConst {
} }
impl EvaluatedConst { impl EvaluatedConst {
pub fn render(&self, db: &dyn HirDatabase, edition: Edition) -> String { pub fn render(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> String {
format!("{}", self.const_.display(db, edition)) format!("{}", self.const_.display(db, display_target))
} }
pub fn render_debug(&self, db: &dyn HirDatabase) -> Result<String, MirEvalError> { pub fn render_debug(&self, db: &dyn HirDatabase) -> Result<String, MirEvalError> {
@ -4195,9 +4227,13 @@ impl ConstParam {
Type::new(db, self.id.parent(), db.const_param_ty(self.id)) Type::new(db, self.id.parent(), db.const_param_ty(self.id))
} }
pub fn default(self, db: &dyn HirDatabase, edition: Edition) -> Option<ast::ConstArg> { pub fn default(
self,
db: &dyn HirDatabase,
display_target: DisplayTarget,
) -> Option<ast::ConstArg> {
let arg = generic_arg_from_param(db, self.id.into())?; let arg = generic_arg_from_param(db, self.id.into())?;
known_const_to_ast(arg.constant(Interner)?, db, edition) known_const_to_ast(arg.constant(Interner)?, db, display_target)
} }
} }
@ -4505,18 +4541,18 @@ impl Closure {
TyKind::Closure(self.id, self.subst).intern(Interner) TyKind::Closure(self.id, self.subst).intern(Interner)
} }
pub fn display_with_id(&self, db: &dyn HirDatabase, edition: Edition) -> String { pub fn display_with_id(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> String {
self.clone() self.clone()
.as_ty() .as_ty()
.display(db, edition) .display(db, display_target)
.with_closure_style(ClosureStyle::ClosureWithId) .with_closure_style(ClosureStyle::ClosureWithId)
.to_string() .to_string()
} }
pub fn display_with_impl(&self, db: &dyn HirDatabase, edition: Edition) -> String { pub fn display_with_impl(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> String {
self.clone() self.clone()
.as_ty() .as_ty()
.display(db, edition) .display(db, display_target)
.with_closure_style(ClosureStyle::ImplFn) .with_closure_style(ClosureStyle::ImplFn)
.to_string() .to_string()
} }
@ -5321,7 +5357,7 @@ impl Type {
pub fn type_and_const_arguments<'a>( pub fn type_and_const_arguments<'a>(
&'a self, &'a self,
db: &'a dyn HirDatabase, db: &'a dyn HirDatabase,
edition: Edition, display_target: DisplayTarget,
) -> impl Iterator<Item = SmolStr> + 'a { ) -> impl Iterator<Item = SmolStr> + 'a {
self.ty self.ty
.strip_references() .strip_references()
@ -5331,10 +5367,10 @@ impl Type {
.filter_map(move |arg| { .filter_map(move |arg| {
// arg can be either a `Ty` or `constant` // arg can be either a `Ty` or `constant`
if let Some(ty) = arg.ty(Interner) { if let Some(ty) = arg.ty(Interner) {
Some(format_smolstr!("{}", ty.display(db, edition))) Some(format_smolstr!("{}", ty.display(db, display_target)))
} else { } else {
arg.constant(Interner) arg.constant(Interner)
.map(|const_| format_smolstr!("{}", const_.display(db, edition))) .map(|const_| format_smolstr!("{}", const_.display(db, display_target)))
} }
}) })
} }
@ -5343,7 +5379,7 @@ impl Type {
pub fn generic_parameters<'a>( pub fn generic_parameters<'a>(
&'a self, &'a self,
db: &'a dyn HirDatabase, db: &'a dyn HirDatabase,
edition: Edition, display_target: DisplayTarget,
) -> impl Iterator<Item = SmolStr> + 'a { ) -> impl Iterator<Item = SmolStr> + 'a {
// iterate the lifetime // iterate the lifetime
self.as_adt() self.as_adt()
@ -5353,7 +5389,7 @@ impl Type {
}) })
.into_iter() .into_iter()
// add the type and const parameters // add the type and const parameters
.chain(self.type_and_const_arguments(db, edition)) .chain(self.type_and_const_arguments(db, display_target))
} }
pub fn iterate_method_candidates_with_traits<T>( pub fn iterate_method_candidates_with_traits<T>(

214
src/tools/rust-analyzer/crates/hir/src/semantics.rs
View File

@ -12,7 +12,8 @@ use std::{
use either::Either; use either::Either;
use hir_def::{ use hir_def::{
hir::{Expr, ExprOrPatId}, expr_store::{Body, ExprOrPatSource},
hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat},
lower::LowerCtx, lower::LowerCtx,
nameres::{MacroSubNs, ModuleOrigin}, nameres::{MacroSubNs, ModuleOrigin},
path::ModPath, path::ModPath,
@ -30,6 +31,7 @@ use hir_expand::{
name::AsName, name::AsName,
ExpandResult, FileRange, InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt, ExpandResult, FileRange, InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt,
}; };
use hir_ty::diagnostics::unsafe_operations_for_body;
use intern::{sym, Symbol}; use intern::{sym, Symbol};
use itertools::Itertools; use itertools::Itertools;
use rustc_hash::{FxHashMap, FxHashSet}; use rustc_hash::{FxHashMap, FxHashSet};
@ -48,8 +50,8 @@ use crate::{
db::HirDatabase, db::HirDatabase,
semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx}, semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
source_analyzer::{name_hygiene, resolve_hir_path, SourceAnalyzer}, source_analyzer::{name_hygiene, resolve_hir_path, SourceAnalyzer},
Access, Adjust, Adjustment, Adt, AutoBorrow, BindingMode, BuiltinAttr, Callable, Const, Adjust, Adjustment, Adt, AutoBorrow, BindingMode, BuiltinAttr, Callable, Const, ConstParam,
ConstParam, Crate, DeriveHelper, Enum, Field, Function, GenericSubstitution, HasSource, Crate, DefWithBody, DeriveHelper, Enum, Field, Function, GenericSubstitution, HasSource,
HirFileId, Impl, InFile, InlineAsmOperand, ItemInNs, Label, LifetimeParam, Local, Macro, HirFileId, Impl, InFile, InlineAsmOperand, ItemInNs, Label, LifetimeParam, Local, Macro,
Module, ModuleDef, Name, OverloadedDeref, Path, ScopeDef, Static, Struct, ToolModule, Trait, Module, ModuleDef, Name, OverloadedDeref, Path, ScopeDef, Static, Struct, ToolModule, Trait,
TraitAlias, TupleField, Type, TypeAlias, TypeParam, Union, Variant, VariantDef, TraitAlias, TupleField, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
@ -311,6 +313,14 @@ impl<'db> SemanticsImpl<'db> {
tree tree
} }
/// If not crate is found for the file, returns the last crate in topological order.
pub fn first_crate_or_default(&self, file: FileId) -> Crate {
match self.file_to_module_defs(file).next() {
Some(module) => module.krate(),
None => (*self.db.crate_graph().crates_in_topological_order().last().unwrap()).into(),
}
}
pub fn attach_first_edition(&self, file: FileId) -> Option<EditionedFileId> { pub fn attach_first_edition(&self, file: FileId) -> Option<EditionedFileId> {
Some(EditionedFileId::new( Some(EditionedFileId::new(
file, file,
@ -627,6 +637,31 @@ impl<'db> SemanticsImpl<'db> {
) )
} }
/// Checks if renaming `renamed` to `new_name` may introduce conflicts with other locals,
/// and returns the conflicting locals.
pub fn rename_conflicts(&self, to_be_renamed: &Local, new_name: &str) -> Vec<Local> {
let body = self.db.body(to_be_renamed.parent);
let resolver = to_be_renamed.parent.resolver(self.db.upcast());
let starting_expr =
body.binding_owners.get(&to_be_renamed.binding_id).copied().unwrap_or(body.body_expr);
let mut visitor = RenameConflictsVisitor {
body: &body,
conflicts: FxHashSet::default(),
db: self.db,
new_name: Symbol::intern(new_name),
old_name: to_be_renamed.name(self.db).symbol().clone(),
owner: to_be_renamed.parent,
to_be_renamed: to_be_renamed.binding_id,
resolver,
};
visitor.rename_conflicts(starting_expr);
visitor
.conflicts
.into_iter()
.map(|binding_id| Local { parent: to_be_renamed.parent, binding_id })
.collect()
}
/// Retrieves all the formatting parts of the format_args! (or `asm!`) template string. /// Retrieves all the formatting parts of the format_args! (or `asm!`) template string.
pub fn as_format_args_parts( pub fn as_format_args_parts(
&self, &self,
@ -1555,6 +1590,19 @@ impl<'db> SemanticsImpl<'db> {
.matched_arm .matched_arm
} }
pub fn get_unsafe_ops(&self, def: DefWithBody) -> FxHashSet<ExprOrPatSource> {
let def = DefWithBodyId::from(def);
let (body, source_map) = self.db.body_with_source_map(def);
let infer = self.db.infer(def);
let mut res = FxHashSet::default();
unsafe_operations_for_body(self.db, &infer, def, &body, &mut |node| {
if let Ok(node) = source_map.expr_or_pat_syntax(node) {
res.insert(node);
}
});
res
}
pub fn is_unsafe_macro_call(&self, macro_call: &ast::MacroCall) -> bool { pub fn is_unsafe_macro_call(&self, macro_call: &ast::MacroCall) -> bool {
let Some(mac) = self.resolve_macro_call(macro_call) else { return false }; let Some(mac) = self.resolve_macro_call(macro_call) else { return false };
if mac.is_asm_or_global_asm(self.db) { if mac.is_asm_or_global_asm(self.db) {
@ -1682,6 +1730,15 @@ impl<'db> SemanticsImpl<'db> {
Some(res) Some(res)
} }
pub fn body_for(&self, node: InFile<&SyntaxNode>) -> Option<DefWithBody> {
let container = self.with_ctx(|ctx| ctx.find_container(node))?;
match container {
ChildContainer::DefWithBodyId(def) => Some(def.into()),
_ => None,
}
}
/// Returns none if the file of the node is not part of a crate. /// Returns none if the file of the node is not part of a crate.
fn analyze(&self, node: &SyntaxNode) -> Option<SourceAnalyzer> { fn analyze(&self, node: &SyntaxNode) -> Option<SourceAnalyzer> {
let node = self.find_file(node); let node = self.find_file(node);
@ -1783,91 +1840,6 @@ impl<'db> SemanticsImpl<'db> {
InFile::new(file_id, node) InFile::new(file_id, node)
} }
pub fn is_unsafe_method_call(&self, method_call_expr: &ast::MethodCallExpr) -> bool {
method_call_expr
.receiver()
.and_then(|expr| {
let field_expr = match expr {
ast::Expr::FieldExpr(field_expr) => field_expr,
_ => return None,
};
let ty = self.type_of_expr(&field_expr.expr()?)?.original;
if !ty.is_packed(self.db) {
return None;
}
let func = self.resolve_method_call(method_call_expr)?;
let res = match func.self_param(self.db)?.access(self.db) {
Access::Shared | Access::Exclusive => true,
Access::Owned => false,
};
Some(res)
})
.unwrap_or(false)
}
pub fn is_unsafe_ref_expr(&self, ref_expr: &ast::RefExpr) -> bool {
ref_expr
.expr()
.and_then(|expr| {
let field_expr = match expr {
ast::Expr::FieldExpr(field_expr) => field_expr,
_ => return None,
};
let expr = field_expr.expr()?;
self.type_of_expr(&expr)
})
// Binding a reference to a packed type is possibly unsafe.
.map(|ty| ty.original.is_packed(self.db))
.unwrap_or(false)
// FIXME This needs layout computation to be correct. It will highlight
// more than it should with the current implementation.
}
pub fn is_unsafe_ident_pat(&self, ident_pat: &ast::IdentPat) -> bool {
if ident_pat.ref_token().is_none() {
return false;
}
ident_pat
.syntax()
.parent()
.and_then(|parent| {
// `IdentPat` can live under `RecordPat` directly under `RecordPatField` or
// `RecordPatFieldList`. `RecordPatField` also lives under `RecordPatFieldList`,
// so this tries to lookup the `IdentPat` anywhere along that structure to the
// `RecordPat` so we can get the containing type.
let record_pat = ast::RecordPatField::cast(parent.clone())
.and_then(|record_pat| record_pat.syntax().parent())
.or_else(|| Some(parent.clone()))
.and_then(|parent| {
ast::RecordPatFieldList::cast(parent)?
.syntax()
.parent()
.and_then(ast::RecordPat::cast)
});
// If this doesn't match a `RecordPat`, fallback to a `LetStmt` to see if
// this is initialized from a `FieldExpr`.
if let Some(record_pat) = record_pat {
self.type_of_pat(&ast::Pat::RecordPat(record_pat))
} else if let Some(let_stmt) = ast::LetStmt::cast(parent) {
let field_expr = match let_stmt.initializer()? {
ast::Expr::FieldExpr(field_expr) => field_expr,
_ => return None,
};
self.type_of_expr(&field_expr.expr()?)
} else {
None
}
})
// Binding a reference to a packed type is possibly unsafe.
.map(|ty| ty.original.is_packed(self.db))
.unwrap_or(false)
}
/// Returns `true` if the `node` is inside an `unsafe` context. /// Returns `true` if the `node` is inside an `unsafe` context.
pub fn is_inside_unsafe(&self, expr: &ast::Expr) -> bool { pub fn is_inside_unsafe(&self, expr: &ast::Expr) -> bool {
let Some(enclosing_item) = let Some(enclosing_item) =
@ -2155,3 +2127,69 @@ impl ops::Deref for VisibleTraits {
&self.0 &self.0
} }
} }
struct RenameConflictsVisitor<'a> {
db: &'a dyn HirDatabase,
owner: DefWithBodyId,
resolver: Resolver,
body: &'a Body,
to_be_renamed: BindingId,
new_name: Symbol,
old_name: Symbol,
conflicts: FxHashSet<BindingId>,
}
impl RenameConflictsVisitor<'_> {
fn resolve_path(&mut self, node: ExprOrPatId, path: &Path) {
if let Path::BarePath(path) = path {
if let Some(name) = path.as_ident() {
if *name.symbol() == self.new_name {
if let Some(conflicting) = self.resolver.rename_will_conflict_with_renamed(
self.db.upcast(),
name,
path,
self.body.expr_or_pat_path_hygiene(node),
self.to_be_renamed,
) {
self.conflicts.insert(conflicting);
}
} else if *name.symbol() == self.old_name {
if let Some(conflicting) =
self.resolver.rename_will_conflict_with_another_variable(
self.db.upcast(),
name,
path,
self.body.expr_or_pat_path_hygiene(node),
&self.new_name,
self.to_be_renamed,
)
{
self.conflicts.insert(conflicting);
}
}
}
}
}
fn rename_conflicts(&mut self, expr: ExprId) {
match &self.body[expr] {
Expr::Path(path) => {
let guard = self.resolver.update_to_inner_scope(self.db.upcast(), self.owner, expr);
self.resolve_path(expr.into(), path);
self.resolver.reset_to_guard(guard);
}
&Expr::Assignment { target, .. } => {
let guard = self.resolver.update_to_inner_scope(self.db.upcast(), self.owner, expr);
self.body.walk_pats(target, &mut |pat| {
if let Pat::Path(path) = &self.body[pat] {
self.resolve_path(pat.into(), path);
}
});
self.resolver.reset_to_guard(guard);
}
_ => {}
}
self.body.walk_child_exprs(expr, |expr| self.rename_conflicts(expr));
}
}

4
src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
View File

@ -35,7 +35,7 @@ use hir_expand::{
}; };
use hir_ty::{ use hir_ty::{
diagnostics::{ diagnostics::{
record_literal_missing_fields, record_pattern_missing_fields, unsafe_expressions, record_literal_missing_fields, record_pattern_missing_fields, unsafe_operations,
InsideUnsafeBlock, InsideUnsafeBlock,
}, },
from_assoc_type_id, from_assoc_type_id,
@ -1160,7 +1160,7 @@ impl SourceAnalyzer {
if let Some(expanded_expr) = sm.macro_expansion_expr(macro_expr) { if let Some(expanded_expr) = sm.macro_expansion_expr(macro_expr) {
let mut is_unsafe = false; let mut is_unsafe = false;
let mut walk_expr = |expr_id| { let mut walk_expr = |expr_id| {
unsafe_expressions(db, infer, *def, body, expr_id, &mut |inside_unsafe_block| { unsafe_operations(db, infer, *def, body, expr_id, &mut |inside_unsafe_block| {
is_unsafe |= inside_unsafe_block == InsideUnsafeBlock::No is_unsafe |= inside_unsafe_block == InsideUnsafeBlock::No
}) })
}; };

14
src/tools/rust-analyzer/crates/hir/src/symbols.rs
View File

@ -13,11 +13,10 @@ use hir_def::{
use hir_expand::{name::Name, HirFileId}; use hir_expand::{name::Name, HirFileId};
use hir_ty::{ use hir_ty::{
db::HirDatabase, db::HirDatabase,
display::{hir_display_with_types_map, HirDisplay}, display::{hir_display_with_types_map, DisplayTarget, HirDisplay},
}; };
use intern::Symbol; use intern::Symbol;
use rustc_hash::FxHashMap; use rustc_hash::FxHashMap;
use span::Edition;
use syntax::{ast::HasName, AstNode, AstPtr, SmolStr, SyntaxNode, SyntaxNodePtr, ToSmolStr}; use syntax::{ast::HasName, AstNode, AstPtr, SmolStr, SyntaxNode, SyntaxNodePtr, ToSmolStr};
use crate::{Module, ModuleDef, Semantics}; use crate::{Module, ModuleDef, Semantics};
@ -66,7 +65,7 @@ pub struct SymbolCollector<'a> {
symbols: FxIndexSet<FileSymbol>, symbols: FxIndexSet<FileSymbol>,
work: Vec<SymbolCollectorWork>, work: Vec<SymbolCollectorWork>,
current_container_name: Option<SmolStr>, current_container_name: Option<SmolStr>,
edition: Edition, display_target: DisplayTarget,
} }
/// Given a [`ModuleId`] and a [`HirDatabase`], use the DefMap for the module's crate to collect /// Given a [`ModuleId`] and a [`HirDatabase`], use the DefMap for the module's crate to collect
@ -78,7 +77,10 @@ impl<'a> SymbolCollector<'a> {
symbols: Default::default(), symbols: Default::default(),
work: Default::default(), work: Default::default(),
current_container_name: None, current_container_name: None,
edition: Edition::Edition2015, display_target: DisplayTarget::from_crate(
db,
*db.crate_graph().crates_in_topological_order().last().unwrap(),
),
} }
} }
@ -91,7 +93,7 @@ impl<'a> SymbolCollector<'a> {
pub fn collect(&mut self, module: Module) { pub fn collect(&mut self, module: Module) {
let _p = tracing::info_span!("SymbolCollector::collect", ?module).entered(); let _p = tracing::info_span!("SymbolCollector::collect", ?module).entered();
tracing::info!(?module, "SymbolCollector::collect",); tracing::info!(?module, "SymbolCollector::collect",);
self.edition = module.krate().edition(self.db); self.display_target = module.krate().to_display_target(self.db);
// The initial work is the root module we're collecting, additional work will // The initial work is the root module we're collecting, additional work will
// be populated as we traverse the module's definitions. // be populated as we traverse the module's definitions.
@ -307,7 +309,7 @@ impl<'a> SymbolCollector<'a> {
let impl_data = self.db.impl_data(impl_id); let impl_data = self.db.impl_data(impl_id);
let impl_name = Some( let impl_name = Some(
hir_display_with_types_map(impl_data.self_ty, &impl_data.types_map) hir_display_with_types_map(impl_data.self_ty, &impl_data.types_map)
.display(self.db, self.edition) .display(self.db, self.display_target)
.to_smolstr(), .to_smolstr(),
); );
self.with_container_name(impl_name, |s| { self.with_container_name(impl_name, |s| {

50
src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs
View File

@ -4,7 +4,7 @@ use hir_def::ImportPathConfig;
use hir_expand::mod_path::ModPath; use hir_expand::mod_path::ModPath;
use hir_ty::{ use hir_ty::{
db::HirDatabase, db::HirDatabase,
display::{DisplaySourceCodeError, HirDisplay}, display::{DisplaySourceCodeError, DisplayTarget, HirDisplay},
}; };
use itertools::Itertools; use itertools::Itertools;
use span::Edition; use span::Edition;
@ -99,14 +99,16 @@ impl Expr {
sema_scope: &SemanticsScope<'_>, sema_scope: &SemanticsScope<'_>,
many_formatter: &mut dyn FnMut(&Type) -> String, many_formatter: &mut dyn FnMut(&Type) -> String,
cfg: ImportPathConfig, cfg: ImportPathConfig,
edition: Edition, display_target: DisplayTarget,
) -> Result<String, DisplaySourceCodeError> { ) -> Result<String, DisplaySourceCodeError> {
let db = sema_scope.db; let db = sema_scope.db;
let edition = display_target.edition;
let mod_item_path_str = |s, def| mod_item_path_str(s, def, cfg, edition); let mod_item_path_str = |s, def| mod_item_path_str(s, def, cfg, edition);
match self { match self {
Expr::Const(it) => match it.as_assoc_item(db).map(|it| it.container(db)) { Expr::Const(it) => match it.as_assoc_item(db).map(|it| it.container(db)) {
Some(container) => { Some(container) => {
let container_name = container_name(container, sema_scope, cfg, edition)?; let container_name =
container_name(container, sema_scope, cfg, edition, display_target)?;
let const_name = it let const_name = it
.name(db) .name(db)
.map(|c| c.display(db.upcast(), edition).to_string()) .map(|c| c.display(db.upcast(), edition).to_string())
@ -122,14 +124,15 @@ impl Expr {
Expr::Function { func, params, .. } => { Expr::Function { func, params, .. } => {
let args = params let args = params
.iter() .iter()
.map(|f| f.gen_source_code(sema_scope, many_formatter, cfg, edition)) .map(|f| f.gen_source_code(sema_scope, many_formatter, cfg, display_target))
.collect::<Result<Vec<String>, DisplaySourceCodeError>>()? .collect::<Result<Vec<String>, DisplaySourceCodeError>>()?
.into_iter() .into_iter()
.join(", "); .join(", ");
match func.as_assoc_item(db).map(|it| it.container(db)) { match func.as_assoc_item(db).map(|it| it.container(db)) {
Some(container) => { Some(container) => {
let container_name = container_name(container, sema_scope, cfg, edition)?; let container_name =
container_name(container, sema_scope, cfg, edition, display_target)?;
let fn_name = func.name(db).display(db.upcast(), edition).to_string(); let fn_name = func.name(db).display(db.upcast(), edition).to_string();
Ok(format!("{container_name}::{fn_name}({args})")) Ok(format!("{container_name}::{fn_name}({args})"))
} }
@ -147,10 +150,10 @@ impl Expr {
let func_name = func.name(db).display(db.upcast(), edition).to_string(); let func_name = func.name(db).display(db.upcast(), edition).to_string();
let self_param = func.self_param(db).unwrap(); let self_param = func.self_param(db).unwrap();
let target_str = let target_str =
target.gen_source_code(sema_scope, many_formatter, cfg, edition)?; target.gen_source_code(sema_scope, many_formatter, cfg, display_target)?;
let args = params let args = params
.iter() .iter()
.map(|f| f.gen_source_code(sema_scope, many_formatter, cfg, edition)) .map(|f| f.gen_source_code(sema_scope, many_formatter, cfg, display_target))
.collect::<Result<Vec<String>, DisplaySourceCodeError>>()? .collect::<Result<Vec<String>, DisplaySourceCodeError>>()?
.into_iter() .into_iter()
.join(", "); .join(", ");
@ -180,7 +183,9 @@ impl Expr {
StructKind::Tuple => { StructKind::Tuple => {
let args = params let args = params
.iter() .iter()
.map(|f| f.gen_source_code(sema_scope, many_formatter, cfg, edition)) .map(|f| {
f.gen_source_code(sema_scope, many_formatter, cfg, display_target)
})
.collect::<Result<Vec<String>, DisplaySourceCodeError>>()? .collect::<Result<Vec<String>, DisplaySourceCodeError>>()?
.into_iter() .into_iter()
.join(", "); .join(", ");
@ -195,7 +200,12 @@ impl Expr {
let tmp = format!( let tmp = format!(
"{}: {}", "{}: {}",
f.name(db).display(db.upcast(), edition), f.name(db).display(db.upcast(), edition),
a.gen_source_code(sema_scope, many_formatter, cfg, edition)? a.gen_source_code(
sema_scope,
many_formatter,
cfg,
display_target
)?
); );
Ok(tmp) Ok(tmp)
}) })
@ -215,7 +225,9 @@ impl Expr {
StructKind::Tuple => { StructKind::Tuple => {
let args = params let args = params
.iter() .iter()
.map(|a| a.gen_source_code(sema_scope, many_formatter, cfg, edition)) .map(|a| {
a.gen_source_code(sema_scope, many_formatter, cfg, display_target)
})
.collect::<Result<Vec<String>, DisplaySourceCodeError>>()? .collect::<Result<Vec<String>, DisplaySourceCodeError>>()?
.into_iter() .into_iter()
.join(", "); .join(", ");
@ -230,7 +242,12 @@ impl Expr {
let tmp = format!( let tmp = format!(
"{}: {}", "{}: {}",
f.name(db).display(db.upcast(), edition), f.name(db).display(db.upcast(), edition),
a.gen_source_code(sema_scope, many_formatter, cfg, edition)? a.gen_source_code(
sema_scope,
many_formatter,
cfg,
display_target
)?
); );
Ok(tmp) Ok(tmp)
}) })
@ -248,7 +265,7 @@ impl Expr {
Expr::Tuple { params, .. } => { Expr::Tuple { params, .. } => {
let args = params let args = params
.iter() .iter()
.map(|a| a.gen_source_code(sema_scope, many_formatter, cfg, edition)) .map(|a| a.gen_source_code(sema_scope, many_formatter, cfg, display_target))
.collect::<Result<Vec<String>, DisplaySourceCodeError>>()? .collect::<Result<Vec<String>, DisplaySourceCodeError>>()?
.into_iter() .into_iter()
.join(", "); .join(", ");
@ -260,7 +277,8 @@ impl Expr {
return Ok(many_formatter(&expr.ty(db))); return Ok(many_formatter(&expr.ty(db)));
} }
let strukt = expr.gen_source_code(sema_scope, many_formatter, cfg, edition)?; let strukt =
expr.gen_source_code(sema_scope, many_formatter, cfg, display_target)?;
let field = field.name(db).display(db.upcast(), edition).to_string(); let field = field.name(db).display(db.upcast(), edition).to_string();
Ok(format!("{strukt}.{field}")) Ok(format!("{strukt}.{field}"))
} }
@ -269,7 +287,8 @@ impl Expr {
return Ok(many_formatter(&expr.ty(db))); return Ok(many_formatter(&expr.ty(db)));
} }
let inner = expr.gen_source_code(sema_scope, many_formatter, cfg, edition)?; let inner =
expr.gen_source_code(sema_scope, many_formatter, cfg, display_target)?;
Ok(format!("&{inner}")) Ok(format!("&{inner}"))
} }
Expr::Many(ty) => Ok(many_formatter(ty)), Expr::Many(ty) => Ok(many_formatter(ty)),
@ -358,6 +377,7 @@ fn container_name(
sema_scope: &SemanticsScope<'_>, sema_scope: &SemanticsScope<'_>,
cfg: ImportPathConfig, cfg: ImportPathConfig,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Result<String, DisplaySourceCodeError> { ) -> Result<String, DisplaySourceCodeError> {
let container_name = match container { let container_name = match container {
crate::AssocItemContainer::Trait(trait_) => { crate::AssocItemContainer::Trait(trait_) => {
@ -368,7 +388,7 @@ fn container_name(
// Should it be guaranteed that `mod_item_path` always exists? // Should it be guaranteed that `mod_item_path` always exists?
match self_ty.as_adt().and_then(|adt| mod_item_path(sema_scope, &adt.into(), cfg)) { match self_ty.as_adt().and_then(|adt| mod_item_path(sema_scope, &adt.into(), cfg)) {
Some(path) => path.display(sema_scope.db.upcast(), edition).to_string(), Some(path) => path.display(sema_scope.db.upcast(), edition).to_string(),
None => self_ty.display(sema_scope.db, edition).to_string(), None => self_ty.display(sema_scope.db, display_target).to_string(),
} }
} }
}; };

23
src/tools/rust-analyzer/crates/ide-assists/src/handlers/explicit_enum_discriminant.rs → src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_explicit_enum_discriminant.rs
View File

@ -8,7 +8,7 @@ use syntax::{ast, AstNode};
use crate::{AssistContext, Assists}; use crate::{AssistContext, Assists};
// Assist: explicit_enum_discriminant // Assist: add_explicit_enum_discriminant
// //
// Adds explicit discriminant to all enum variants. // Adds explicit discriminant to all enum variants.
// //
@ -29,7 +29,10 @@ use crate::{AssistContext, Assists};
// Quux = 43, // Quux = 43,
// } // }
// ``` // ```
pub(crate) fn explicit_enum_discriminant(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> { pub(crate) fn add_explicit_enum_discriminant(
acc: &mut Assists,
ctx: &AssistContext<'_>,
) -> Option<()> {
let enum_node = ctx.find_node_at_offset::<ast::Enum>()?; let enum_node = ctx.find_node_at_offset::<ast::Enum>()?;
let enum_def = ctx.sema.to_def(&enum_node)?; let enum_def = ctx.sema.to_def(&enum_node)?;
@ -50,7 +53,7 @@ pub(crate) fn explicit_enum_discriminant(acc: &mut Assists, ctx: &AssistContext<
} }
acc.add( acc.add(
AssistId("explicit_enum_discriminant", AssistKind::RefactorRewrite), AssistId("add_explicit_enum_discriminant", AssistKind::RefactorRewrite),
"Add explicit enum discriminants", "Add explicit enum discriminants",
enum_node.syntax().text_range(), enum_node.syntax().text_range(),
|builder| { |builder| {
@ -88,12 +91,12 @@ fn add_variant_discriminant(
mod tests { mod tests {
use crate::tests::{check_assist, check_assist_not_applicable}; use crate::tests::{check_assist, check_assist_not_applicable};
use super::explicit_enum_discriminant; use super::add_explicit_enum_discriminant;
#[test] #[test]
fn non_primitive_repr_non_data_bearing_add_discriminant() { fn non_primitive_repr_non_data_bearing_add_discriminant() {
check_assist( check_assist(
explicit_enum_discriminant, add_explicit_enum_discriminant,
r#" r#"
enum TheEnum$0 { enum TheEnum$0 {
Foo, Foo,
@ -120,7 +123,7 @@ enum TheEnum {
#[test] #[test]
fn primitive_repr_data_bearing_add_discriminant() { fn primitive_repr_data_bearing_add_discriminant() {
check_assist( check_assist(
explicit_enum_discriminant, add_explicit_enum_discriminant,
r#" r#"
#[repr(u8)] #[repr(u8)]
$0enum TheEnum { $0enum TheEnum {
@ -145,7 +148,7 @@ enum TheEnum {
#[test] #[test]
fn non_primitive_repr_data_bearing_not_applicable() { fn non_primitive_repr_data_bearing_not_applicable() {
check_assist_not_applicable( check_assist_not_applicable(
explicit_enum_discriminant, add_explicit_enum_discriminant,
r#" r#"
enum TheEnum$0 { enum TheEnum$0 {
Foo, Foo,
@ -159,7 +162,7 @@ enum TheEnum$0 {
#[test] #[test]
fn primitive_repr_non_data_bearing_add_discriminant() { fn primitive_repr_non_data_bearing_add_discriminant() {
check_assist( check_assist(
explicit_enum_discriminant, add_explicit_enum_discriminant,
r#" r#"
#[repr(i64)] #[repr(i64)]
enum TheEnum { enum TheEnum {
@ -184,7 +187,7 @@ enum TheEnum {
#[test] #[test]
fn discriminants_already_explicit_not_applicable() { fn discriminants_already_explicit_not_applicable() {
check_assist_not_applicable( check_assist_not_applicable(
explicit_enum_discriminant, add_explicit_enum_discriminant,
r#" r#"
enum TheEnum$0 { enum TheEnum$0 {
Foo = 0, Foo = 0,
@ -197,7 +200,7 @@ enum TheEnum$0 {
#[test] #[test]
fn empty_enum_not_applicable() { fn empty_enum_not_applicable() {
check_assist_not_applicable( check_assist_not_applicable(
explicit_enum_discriminant, add_explicit_enum_discriminant,
r#" r#"
enum TheEnum$0 {} enum TheEnum$0 {}
"#, "#,

14
src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs
View File

@ -128,7 +128,9 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
let parent = neg_expr.syntax().parent(); let parent = neg_expr.syntax().parent();
editor = builder.make_editor(neg_expr.syntax()); editor = builder.make_editor(neg_expr.syntax());
if parent.is_some_and(|parent| demorganed.needs_parens_in(&parent)) { if parent.is_some_and(|parent| {
demorganed.needs_parens_in_place_of(&parent, neg_expr.syntax())
}) {
cov_mark::hit!(demorgan_keep_parens_for_op_precedence2); cov_mark::hit!(demorgan_keep_parens_for_op_precedence2);
editor.replace(neg_expr.syntax(), make.expr_paren(demorganed).syntax()); editor.replace(neg_expr.syntax(), make.expr_paren(demorganed).syntax());
} else { } else {
@ -392,15 +394,19 @@ fn f() { !(S <= S || S < S) }
#[test] #[test]
fn demorgan_keep_pars_for_op_precedence3() { fn demorgan_keep_pars_for_op_precedence3() {
check_assist(apply_demorgan, "fn f() { (a || !(b &&$0 c); }", "fn f() { (a || !b || !c; }"); check_assist(
apply_demorgan,
"fn f() { (a || !(b &&$0 c); }",
"fn f() { (a || (!b || !c); }",
);
} }
#[test] #[test]
fn demorgan_removes_pars_in_eq_precedence() { fn demorgan_keeps_pars_in_eq_precedence() {
check_assist( check_assist(
apply_demorgan, apply_demorgan,
"fn() { let x = a && !(!b |$0| !c); }", "fn() { let x = a && !(!b |$0| !c); }",
"fn() { let x = a && b && c; }", "fn() { let x = a && (b && c); }",
) )
} }

96
src/tools/rust-analyzer/crates/ide-assists/src/handlers/bool_to_enum.rs → src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
View File

@ -26,7 +26,7 @@ use crate::{
utils, utils,
}; };
// Assist: bool_to_enum // Assist: convert_bool_to_enum
// //
// This converts boolean local variables, fields, constants, and statics into a new // This converts boolean local variables, fields, constants, and statics into a new
// enum with two variants `Bool::True` and `Bool::False`, as well as replacing // enum with two variants `Bool::True` and `Bool::False`, as well as replacing
@ -55,14 +55,14 @@ use crate::{
// } // }
// } // }
// ``` // ```
pub(crate) fn bool_to_enum(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> { pub(crate) fn convert_bool_to_enum(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
let BoolNodeData { target_node, name, ty_annotation, initializer, definition } = let BoolNodeData { target_node, name, ty_annotation, initializer, definition } =
find_bool_node(ctx)?; find_bool_node(ctx)?;
let target_module = ctx.sema.scope(&target_node)?.module().nearest_non_block_module(ctx.db()); let target_module = ctx.sema.scope(&target_node)?.module().nearest_non_block_module(ctx.db());
let target = name.syntax().text_range(); let target = name.syntax().text_range();
acc.add( acc.add(
AssistId("bool_to_enum", AssistKind::RefactorRewrite), AssistId("convert_bool_to_enum", AssistKind::RefactorRewrite),
"Convert boolean to enum", "Convert boolean to enum",
target, target,
|edit| { |edit| {
@ -549,7 +549,7 @@ mod tests {
#[test] #[test]
fn parameter_with_first_param_usage() { fn parameter_with_first_param_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn function($0foo: bool, bar: bool) { fn function($0foo: bool, bar: bool) {
if foo { if foo {
@ -573,7 +573,7 @@ fn function(foo: Bool, bar: bool) {
#[test] #[test]
fn no_duplicate_enums() { fn no_duplicate_enums() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
#[derive(PartialEq, Eq)] #[derive(PartialEq, Eq)]
enum Bool { True, False } enum Bool { True, False }
@ -600,7 +600,7 @@ fn function(foo: bool, bar: Bool) {
#[test] #[test]
fn parameter_with_last_param_usage() { fn parameter_with_last_param_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn function(foo: bool, $0bar: bool) { fn function(foo: bool, $0bar: bool) {
if bar { if bar {
@ -624,7 +624,7 @@ fn function(foo: bool, bar: Bool) {
#[test] #[test]
fn parameter_with_middle_param_usage() { fn parameter_with_middle_param_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn function(foo: bool, $0bar: bool, baz: bool) { fn function(foo: bool, $0bar: bool, baz: bool) {
if bar { if bar {
@ -648,7 +648,7 @@ fn function(foo: bool, bar: Bool, baz: bool) {
#[test] #[test]
fn parameter_with_closure_usage() { fn parameter_with_closure_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let foo = |$0bar: bool| bar; let foo = |$0bar: bool| bar;
@ -668,7 +668,7 @@ fn main() {
#[test] #[test]
fn local_variable_with_usage() { fn local_variable_with_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo = true; let $0foo = true;
@ -697,7 +697,7 @@ fn main() {
fn local_variable_with_usage_negated() { fn local_variable_with_usage_negated() {
cov_mark::check!(replaces_negation); cov_mark::check!(replaces_negation);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo = true; let $0foo = true;
@ -726,7 +726,7 @@ fn main() {
fn local_variable_with_type_annotation() { fn local_variable_with_type_annotation() {
cov_mark::check!(replaces_ty_annotation); cov_mark::check!(replaces_ty_annotation);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo: bool = false; let $0foo: bool = false;
@ -746,7 +746,7 @@ fn main() {
#[test] #[test]
fn local_variable_with_non_literal_initializer() { fn local_variable_with_non_literal_initializer() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo = 1 == 2; let $0foo = 1 == 2;
@ -766,7 +766,7 @@ fn main() {
#[test] #[test]
fn local_variable_binexpr_usage() { fn local_variable_binexpr_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo = false; let $0foo = false;
@ -796,7 +796,7 @@ fn main() {
#[test] #[test]
fn local_variable_unop_usage() { fn local_variable_unop_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo = true; let $0foo = true;
@ -825,7 +825,7 @@ fn main() {
fn local_variable_assigned_later() { fn local_variable_assigned_later() {
cov_mark::check!(replaces_assignment); cov_mark::check!(replaces_assignment);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo: bool; let $0foo: bool;
@ -847,7 +847,7 @@ fn main() {
#[test] #[test]
fn local_variable_does_not_apply_recursively() { fn local_variable_does_not_apply_recursively() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo = true; let $0foo = true;
@ -878,7 +878,7 @@ fn main() {
fn local_variable_nested_in_negation() { fn local_variable_nested_in_negation() {
cov_mark::check!(dont_overwrite_expression_inside_negation); cov_mark::check!(dont_overwrite_expression_inside_negation);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
if !"foo".chars().any(|c| { if !"foo".chars().any(|c| {
@ -909,7 +909,7 @@ fn main() {
fn local_variable_non_bool() { fn local_variable_non_bool() {
cov_mark::check!(not_applicable_non_bool_local); cov_mark::check!(not_applicable_non_bool_local);
check_assist_not_applicable( check_assist_not_applicable(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let $0foo = 1; let $0foo = 1;
@ -921,7 +921,7 @@ fn main() {
#[test] #[test]
fn local_variable_cursor_not_on_ident() { fn local_variable_cursor_not_on_ident() {
check_assist_not_applicable( check_assist_not_applicable(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let foo = $0true; let foo = $0true;
@ -933,7 +933,7 @@ fn main() {
#[test] #[test]
fn local_variable_non_ident_pat() { fn local_variable_non_ident_pat() {
check_assist_not_applicable( check_assist_not_applicable(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
let ($0foo, bar) = (true, false); let ($0foo, bar) = (true, false);
@ -945,7 +945,7 @@ fn main() {
#[test] #[test]
fn local_var_init_struct_usage() { fn local_var_init_struct_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Foo { struct Foo {
foo: bool, foo: bool,
@ -975,7 +975,7 @@ fn main() {
#[test] #[test]
fn local_var_init_struct_usage_in_macro() { fn local_var_init_struct_usage_in_macro() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Struct { struct Struct {
boolean: bool, boolean: bool,
@ -1018,7 +1018,7 @@ fn new() -> Struct {
fn field_struct_basic() { fn field_struct_basic() {
cov_mark::check!(replaces_record_expr); cov_mark::check!(replaces_record_expr);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Foo { struct Foo {
$0bar: bool, $0bar: bool,
@ -1057,7 +1057,7 @@ fn main() {
fn field_enum_basic() { fn field_enum_basic() {
cov_mark::check!(replaces_record_pat); cov_mark::check!(replaces_record_pat);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
enum Foo { enum Foo {
Foo, Foo,
@ -1100,7 +1100,7 @@ fn main() {
fn field_enum_cross_file() { fn field_enum_cross_file() {
// FIXME: The import is missing // FIXME: The import is missing
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
//- /foo.rs //- /foo.rs
pub enum Foo { pub enum Foo {
@ -1151,7 +1151,7 @@ fn main() {
fn field_enum_shorthand() { fn field_enum_shorthand() {
cov_mark::check!(replaces_record_pat_shorthand); cov_mark::check!(replaces_record_pat_shorthand);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
enum Foo { enum Foo {
Foo, Foo,
@ -1200,7 +1200,7 @@ fn main() {
fn field_enum_replaces_literal_patterns() { fn field_enum_replaces_literal_patterns() {
cov_mark::check!(replaces_literal_pat); cov_mark::check!(replaces_literal_pat);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
enum Foo { enum Foo {
Foo, Foo,
@ -1238,7 +1238,7 @@ fn main() {
#[test] #[test]
fn field_enum_keeps_wildcard_patterns() { fn field_enum_keeps_wildcard_patterns() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
enum Foo { enum Foo {
Foo, Foo,
@ -1276,7 +1276,7 @@ fn main() {
#[test] #[test]
fn field_union_basic() { fn field_union_basic() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
union Foo { union Foo {
$0foo: bool, $0foo: bool,
@ -1314,7 +1314,7 @@ fn main() {
#[test] #[test]
fn field_negated() { fn field_negated() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Foo { struct Foo {
$0bar: bool, $0bar: bool,
@ -1350,7 +1350,7 @@ fn main() {
#[test] #[test]
fn field_in_mod_properly_indented() { fn field_in_mod_properly_indented() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
mod foo { mod foo {
struct Bar { struct Bar {
@ -1386,7 +1386,7 @@ mod foo {
#[test] #[test]
fn field_multiple_initializations() { fn field_multiple_initializations() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Foo { struct Foo {
$0bar: bool, $0bar: bool,
@ -1427,7 +1427,7 @@ fn main() {
fn field_assigned_to_another() { fn field_assigned_to_another() {
cov_mark::check!(dont_assign_incorrect_ref); cov_mark::check!(dont_assign_incorrect_ref);
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Foo { struct Foo {
$0foo: bool, $0foo: bool,
@ -1469,7 +1469,7 @@ fn main() {
#[test] #[test]
fn field_initialized_with_other() { fn field_initialized_with_other() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Foo { struct Foo {
$0foo: bool, $0foo: bool,
@ -1507,7 +1507,7 @@ fn main() {
#[test] #[test]
fn field_method_chain_usage() { fn field_method_chain_usage() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Foo { struct Foo {
$0bool: bool, $0bool: bool,
@ -1539,7 +1539,7 @@ fn main() {
#[test] #[test]
fn field_in_macro() { fn field_in_macro() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Struct { struct Struct {
$0boolean: bool, $0boolean: bool,
@ -1580,7 +1580,7 @@ fn new() -> Struct {
fn field_non_bool() { fn field_non_bool() {
cov_mark::check!(not_applicable_non_bool_field); cov_mark::check!(not_applicable_non_bool_field);
check_assist_not_applicable( check_assist_not_applicable(
bool_to_enum, convert_bool_to_enum,
r#" r#"
struct Foo { struct Foo {
$0bar: usize, $0bar: usize,
@ -1596,7 +1596,7 @@ fn main() {
#[test] #[test]
fn const_basic() { fn const_basic() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
const $0FOO: bool = false; const $0FOO: bool = false;
@ -1624,7 +1624,7 @@ fn main() {
#[test] #[test]
fn const_in_module() { fn const_in_module() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
if foo::FOO { if foo::FOO {
@ -1658,7 +1658,7 @@ mod foo {
#[test] #[test]
fn const_in_module_with_import() { fn const_in_module_with_import() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
fn main() { fn main() {
use foo::FOO; use foo::FOO;
@ -1696,7 +1696,7 @@ mod foo {
#[test] #[test]
fn const_cross_file() { fn const_cross_file() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
//- /main.rs //- /main.rs
mod foo; mod foo;
@ -1734,7 +1734,7 @@ pub const FOO: Bool = Bool::True;
#[test] #[test]
fn const_cross_file_and_module() { fn const_cross_file_and_module() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
//- /main.rs //- /main.rs
mod foo; mod foo;
@ -1780,7 +1780,7 @@ pub mod bar {
#[test] #[test]
fn const_in_impl_cross_file() { fn const_in_impl_cross_file() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
//- /main.rs //- /main.rs
mod foo; mod foo;
@ -1824,7 +1824,7 @@ fn foo() -> bool {
#[test] #[test]
fn const_in_trait() { fn const_in_trait() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
trait Foo { trait Foo {
const $0BOOL: bool; const $0BOOL: bool;
@ -1865,7 +1865,7 @@ fn main() {
fn const_non_bool() { fn const_non_bool() {
cov_mark::check!(not_applicable_non_bool_const); cov_mark::check!(not_applicable_non_bool_const);
check_assist_not_applicable( check_assist_not_applicable(
bool_to_enum, convert_bool_to_enum,
r#" r#"
const $0FOO: &str = "foo"; const $0FOO: &str = "foo";
@ -1879,7 +1879,7 @@ fn main() {
#[test] #[test]
fn static_basic() { fn static_basic() {
check_assist( check_assist(
bool_to_enum, convert_bool_to_enum,
r#" r#"
static mut $0BOOL: bool = true; static mut $0BOOL: bool = true;
@ -1910,7 +1910,7 @@ fn main() {
fn static_non_bool() { fn static_non_bool() {
cov_mark::check!(not_applicable_non_bool_static); cov_mark::check!(not_applicable_non_bool_static);
check_assist_not_applicable( check_assist_not_applicable(
bool_to_enum, convert_bool_to_enum,
r#" r#"
static mut $0FOO: usize = 0; static mut $0FOO: usize = 0;
@ -1925,6 +1925,6 @@ fn main() {
#[test] #[test]
fn not_applicable_to_other_names() { fn not_applicable_to_other_names() {
check_assist_not_applicable(bool_to_enum, "fn $0main() {}") check_assist_not_applicable(convert_bool_to_enum, "fn $0main() {}")
} }
} }

205
src/tools/rust-analyzer/crates/ide-assists/src/handlers/fill_record_pattern_fields.rs → src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
View File

@ -1,11 +1,29 @@
use hir::{PathResolution, StructKind};
use ide_db::syntax_helpers::suggest_name::NameGenerator;
use syntax::{ use syntax::{
ast::{self, make}, ast::{self, make},
AstNode, ToSmolStr, match_ast, AstNode, ToSmolStr,
}; };
use crate::{AssistContext, AssistId, Assists}; use crate::{AssistContext, AssistId, Assists};
// Assist: fill_record_pattern_fields pub(crate) fn expand_rest_pattern(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
let rest_pat = ctx.find_node_at_offset::<ast::RestPat>()?;
let parent = rest_pat.syntax().parent()?;
match_ast! {
match parent {
ast::RecordPatFieldList(it) => expand_record_rest_pattern(acc, ctx, it.syntax().parent().and_then(ast::RecordPat::cast)?, rest_pat),
ast::TupleStructPat(it) => expand_tuple_struct_rest_pattern(acc, ctx, it, rest_pat),
// FIXME
// ast::TuplePat(it) => (),
// FIXME
// ast::SlicePat(it) => (),
_ => return None,
}
}
}
// Assist: expand_record_rest_pattern
// //
// Fills fields by replacing rest pattern in record patterns. // Fills fields by replacing rest pattern in record patterns.
// //
@ -24,16 +42,12 @@ use crate::{AssistContext, AssistId, Assists};
// let Bar { y, z } = bar; // let Bar { y, z } = bar;
// } // }
// ``` // ```
pub(crate) fn fill_record_pattern_fields(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> { fn expand_record_rest_pattern(
let record_pat = ctx.find_node_at_offset::<ast::RecordPat>()?; acc: &mut Assists,
ctx: &AssistContext<'_>,
let ellipsis = record_pat.record_pat_field_list().and_then(|r| r.rest_pat())?; record_pat: ast::RecordPat,
if !ellipsis.syntax().text_range().contains_inclusive(ctx.offset()) { rest_pat: ast::RestPat,
return None; ) -> Option<()> {
}
let target_range = ellipsis.syntax().text_range();
let missing_fields = ctx.sema.record_pattern_missing_fields(&record_pat); let missing_fields = ctx.sema.record_pattern_missing_fields(&record_pat);
if missing_fields.is_empty() { if missing_fields.is_empty() {
@ -42,6 +56,11 @@ pub(crate) fn fill_record_pattern_fields(acc: &mut Assists, ctx: &AssistContext<
} }
let old_field_list = record_pat.record_pat_field_list()?; let old_field_list = record_pat.record_pat_field_list()?;
let old_range = ctx.sema.original_range_opt(old_field_list.syntax())?;
if old_range.file_id != ctx.file_id() {
return None;
}
let new_field_list = let new_field_list =
make::record_pat_field_list(old_field_list.fields(), None).clone_for_update(); make::record_pat_field_list(old_field_list.fields(), None).clone_for_update();
for (f, _) in missing_fields.iter() { for (f, _) in missing_fields.iter() {
@ -52,16 +71,93 @@ pub(crate) fn fill_record_pattern_fields(acc: &mut Assists, ctx: &AssistContext<
new_field_list.add_field(field.clone_for_update()); new_field_list.add_field(field.clone_for_update());
} }
let old_range = ctx.sema.original_range_opt(old_field_list.syntax())?; let target_range = rest_pat.syntax().text_range();
acc.add(
AssistId("expand_record_rest_pattern", crate::AssistKind::RefactorRewrite),
"Fill struct fields",
target_range,
move |builder| builder.replace_ast(old_field_list, new_field_list),
)
}
// Assist: expand_tuple_struct_rest_pattern
//
// Fills fields by replacing rest pattern in tuple struct patterns.
//
// ```
// struct Bar(Y, Z);
//
// fn foo(bar: Bar) {
// let Bar(..$0) = bar;
// }
// ```
// ->
// ```
// struct Bar(Y, Z);
//
// fn foo(bar: Bar) {
// let Bar(_0, _1) = bar;
// }
// ```
fn expand_tuple_struct_rest_pattern(
acc: &mut Assists,
ctx: &AssistContext<'_>,
pat: ast::TupleStructPat,
rest_pat: ast::RestPat,
) -> Option<()> {
let path = pat.path()?;
let fields = match ctx.sema.type_of_pat(&pat.clone().into())?.original.as_adt()? {
hir::Adt::Struct(s) if s.kind(ctx.sema.db) == StructKind::Tuple => s.fields(ctx.sema.db),
hir::Adt::Enum(_) => match ctx.sema.resolve_path(&path)? {
PathResolution::Def(hir::ModuleDef::Variant(v))
if v.kind(ctx.sema.db) == StructKind::Tuple =>
{
v.fields(ctx.sema.db)
}
_ => return None,
},
_ => return None,
};
let rest_pat = rest_pat.into();
let mut pats = pat.fields();
let prefix_count = pats.by_ref().position(|p| p == rest_pat)?;
let suffix_count = pats.count();
if fields.len().saturating_sub(prefix_count).saturating_sub(suffix_count) == 0 {
cov_mark::hit!(no_missing_fields_tuple_struct);
return None;
}
let old_range = ctx.sema.original_range_opt(pat.syntax())?;
if old_range.file_id != ctx.file_id() { if old_range.file_id != ctx.file_id() {
return None; return None;
} }
let mut name_gen = NameGenerator::new_from_scope_locals(ctx.sema.scope(pat.syntax()));
let new_pat = make::tuple_struct_pat(
path,
pat.fields()
.take(prefix_count)
.chain(fields[prefix_count..fields.len() - suffix_count].iter().map(|f| {
make::ident_pat(
false,
false,
match name_gen.for_type(&f.ty(ctx.sema.db), ctx.sema.db, ctx.edition()) {
Some(name) => make::name(&name),
None => make::name(&format!("_{}", f.index())),
},
)
.into()
}))
.chain(pat.fields().skip(prefix_count + 1)),
);
let target_range = rest_pat.syntax().text_range();
acc.add( acc.add(
AssistId("fill_record_pattern_fields", crate::AssistKind::RefactorRewrite), AssistId("expand_tuple_struct_rest_pattern", crate::AssistKind::RefactorRewrite),
"Fill structure fields", "Fill tuple struct fields",
target_range, target_range,
move |builder| builder.replace_ast(old_field_list, new_field_list), move |builder| builder.replace_ast(pat, new_pat),
) )
} }
@ -73,7 +169,7 @@ mod tests {
#[test] #[test]
fn fill_fields_enum_with_only_ellipsis() { fn fill_fields_enum_with_only_ellipsis() {
check_assist( check_assist(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
enum Foo { enum Foo {
A(X), A(X),
@ -106,7 +202,7 @@ fn bar(foo: Foo) {
#[test] #[test]
fn fill_fields_enum_with_fields() { fn fill_fields_enum_with_fields() {
check_assist( check_assist(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
enum Foo { enum Foo {
A(X), A(X),
@ -139,7 +235,7 @@ fn bar(foo: Foo) {
#[test] #[test]
fn fill_fields_struct_with_only_ellipsis() { fn fill_fields_struct_with_only_ellipsis() {
check_assist( check_assist(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
struct Bar { struct Bar {
y: Y, y: Y,
@ -159,6 +255,27 @@ struct Bar {
fn foo(bar: Bar) { fn foo(bar: Bar) {
let Bar { y, z } = bar; let Bar { y, z } = bar;
} }
"#,
);
check_assist(
expand_rest_pattern,
r#"
struct Y;
struct Z;
struct Bar(Y, Z)
fn foo(bar: Bar) {
let Bar(..$0) = bar;
}
"#,
r#"
struct Y;
struct Z;
struct Bar(Y, Z)
fn foo(bar: Bar) {
let Bar(y, z) = bar;
}
"#, "#,
) )
} }
@ -166,7 +283,7 @@ fn foo(bar: Bar) {
#[test] #[test]
fn fill_fields_struct_with_fields() { fn fill_fields_struct_with_fields() {
check_assist( check_assist(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
struct Bar { struct Bar {
y: Y, y: Y,
@ -186,6 +303,29 @@ struct Bar {
fn foo(bar: Bar) { fn foo(bar: Bar) {
let Bar { y, z } = bar; let Bar { y, z } = bar;
} }
"#,
);
check_assist(
expand_rest_pattern,
r#"
struct X;
struct Y;
struct Z;
struct Bar(X, Y, Z)
fn foo(bar: Bar) {
let Bar(x, ..$0, z) = bar;
}
"#,
r#"
struct X;
struct Y;
struct Z;
struct Bar(X, Y, Z)
fn foo(bar: Bar) {
let Bar(x, y, z) = bar;
}
"#, "#,
) )
} }
@ -193,7 +333,7 @@ fn foo(bar: Bar) {
#[test] #[test]
fn fill_fields_struct_generated_by_macro() { fn fill_fields_struct_generated_by_macro() {
check_assist( check_assist(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
macro_rules! position { macro_rules! position {
($t: ty) => { ($t: ty) => {
@ -226,7 +366,7 @@ fn macro_call(pos: Pos) {
#[test] #[test]
fn fill_fields_enum_generated_by_macro() { fn fill_fields_enum_generated_by_macro() {
check_assist( check_assist(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
macro_rules! enum_gen { macro_rules! enum_gen {
($t: ty) => { ($t: ty) => {
@ -271,7 +411,7 @@ fn macro_call(foo: Foo) {
#[test] #[test]
fn not_applicable_when_not_in_ellipsis() { fn not_applicable_when_not_in_ellipsis() {
check_assist_not_applicable( check_assist_not_applicable(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
enum Foo { enum Foo {
A(X), A(X),
@ -287,7 +427,7 @@ fn bar(foo: Foo) {
"#, "#,
); );
check_assist_not_applicable( check_assist_not_applicable(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
enum Foo { enum Foo {
A(X), A(X),
@ -303,7 +443,7 @@ fn bar(foo: Foo) {
"#, "#,
); );
check_assist_not_applicable( check_assist_not_applicable(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
enum Foo { enum Foo {
A(X), A(X),
@ -324,8 +464,9 @@ fn bar(foo: Foo) {
fn not_applicable_when_no_missing_fields() { fn not_applicable_when_no_missing_fields() {
// This is still possible even though it's meaningless // This is still possible even though it's meaningless
cov_mark::check!(no_missing_fields); cov_mark::check!(no_missing_fields);
cov_mark::check!(no_missing_fields_tuple_struct);
check_assist_not_applicable( check_assist_not_applicable(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
enum Foo { enum Foo {
A(X), A(X),
@ -341,7 +482,7 @@ fn bar(foo: Foo) {
"#, "#,
); );
check_assist_not_applicable( check_assist_not_applicable(
fill_record_pattern_fields, expand_rest_pattern,
r#" r#"
struct Bar { struct Bar {
y: Y, y: Y,
@ -351,6 +492,16 @@ struct Bar {
fn foo(bar: Bar) { fn foo(bar: Bar) {
let Bar { y, z, ..$0 } = bar; let Bar { y, z, ..$0 } = bar;
} }
"#,
);
check_assist_not_applicable(
expand_rest_pattern,
r#"
struct Bar(Y, Z)
fn foo(bar: Bar) {
let Bar(y, ..$0, z) = bar;
}
"#, "#,
); );
} }

5
src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
View File

@ -750,7 +750,10 @@ impl FunctionBody {
ast::Stmt::Item(_) => (), ast::Stmt::Item(_) => (),
ast::Stmt::LetStmt(stmt) => { ast::Stmt::LetStmt(stmt) => {
if let Some(pat) = stmt.pat() { if let Some(pat) = stmt.pat() {
walk_pat(&pat, cb); walk_pat(&pat, &mut |pat| {
cb(pat);
std::ops::ControlFlow::<(), ()>::Continue(())
});
} }
if let Some(expr) = stmt.initializer() { if let Some(expr) = stmt.initializer() {
walk_patterns_in_expr(&expr, cb); walk_patterns_in_expr(&expr, cb);

11
src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
View File

@ -724,9 +724,9 @@ fn fn_generic_params(
filter_unnecessary_bounds(&mut generic_params, &mut where_preds, necessary_params); filter_unnecessary_bounds(&mut generic_params, &mut where_preds, necessary_params);
filter_bounds_in_scope(&mut generic_params, &mut where_preds, ctx, target); filter_bounds_in_scope(&mut generic_params, &mut where_preds, ctx, target);
let generic_params: Vec<_> = let generic_params: Vec<ast::GenericParam> =
generic_params.into_iter().map(|it| it.node.clone_for_update()).collect(); generic_params.into_iter().map(|it| it.node.clone_for_update()).collect();
let where_preds: Vec<_> = let where_preds: Vec<ast::WherePred> =
where_preds.into_iter().map(|it| it.node.clone_for_update()).collect(); where_preds.into_iter().map(|it| it.node.clone_for_update()).collect();
// 4. Rewrite paths // 4. Rewrite paths
@ -1116,9 +1116,12 @@ fn fn_arg_type(
if ty.is_reference() || ty.is_mutable_reference() { if ty.is_reference() || ty.is_mutable_reference() {
let famous_defs = &FamousDefs(&ctx.sema, ctx.sema.scope(fn_arg.syntax())?.krate()); let famous_defs = &FamousDefs(&ctx.sema, ctx.sema.scope(fn_arg.syntax())?.krate());
let target_edition = target_module.krate().edition(ctx.db());
convert_reference_type(ty.strip_references(), ctx.db(), famous_defs) convert_reference_type(ty.strip_references(), ctx.db(), famous_defs)
.map(|conversion| conversion.convert_type(ctx.db(), target_edition).to_string()) .map(|conversion| {
conversion
.convert_type(ctx.db(), target_module.krate().to_display_target(ctx.db()))
.to_string()
})
.or_else(|| ty.display_source_code(ctx.db(), target_module.into(), true).ok()) .or_else(|| ty.display_source_code(ctx.db(), target_module.into(), true).ok())
} else { } else {
ty.display_source_code(ctx.db(), target_module.into(), true).ok() ty.display_source_code(ctx.db(), target_module.into(), true).ok()

2
src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
View File

@ -233,7 +233,7 @@ fn generate_getter_from_info(
.map(|conversion| { .map(|conversion| {
cov_mark::hit!(convert_reference_type); cov_mark::hit!(convert_reference_type);
( (
conversion.convert_type(ctx.db(), krate.edition(ctx.db())), conversion.convert_type(ctx.db(), krate.to_display_target(ctx.db())),
conversion.getter(record_field_info.field_name.to_string()), conversion.getter(record_field_info.field_name.to_string()),
) )
}) })

2
src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_const_as_literal.rs
View File

@ -42,7 +42,7 @@ pub(crate) fn inline_const_as_literal(acc: &mut Assists, ctx: &AssistContext<'_>
let value = konst let value = konst
.eval(ctx.sema.db) .eval(ctx.sema.db)
.ok()? .ok()?
.render(ctx.sema.db, konst.krate(ctx.sema.db).edition(ctx.sema.db)); .render(ctx.sema.db, konst.krate(ctx.sema.db).to_display_target(ctx.sema.db));
let id = AssistId("inline_const_as_literal", AssistKind::RefactorInline); let id = AssistId("inline_const_as_literal", AssistKind::RefactorInline);

124
src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_local_variable.rs
View File

@ -5,7 +5,7 @@ use ide_db::{
EditionedFileId, RootDatabase, EditionedFileId, RootDatabase,
}; };
use syntax::{ use syntax::{
ast::{self, AstNode, AstToken, HasName}, ast::{self, syntax_factory::SyntaxFactory, AstNode, AstToken, HasName},
SyntaxElement, TextRange, SyntaxElement, TextRange,
}; };
@ -43,22 +43,6 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext<'_>)
}?; }?;
let initializer_expr = let_stmt.initializer()?; let initializer_expr = let_stmt.initializer()?;
let delete_range = delete_let.then(|| {
if let Some(whitespace) = let_stmt
.syntax()
.next_sibling_or_token()
.and_then(SyntaxElement::into_token)
.and_then(ast::Whitespace::cast)
{
TextRange::new(
let_stmt.syntax().text_range().start(),
whitespace.syntax().text_range().end(),
)
} else {
let_stmt.syntax().text_range()
}
});
let wrap_in_parens = references let wrap_in_parens = references
.into_iter() .into_iter()
.filter_map(|FileReference { range, name, .. }| match name { .filter_map(|FileReference { range, name, .. }| match name {
@ -73,40 +57,60 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext<'_>)
} }
let usage_node = let usage_node =
name_ref.syntax().ancestors().find(|it| ast::PathExpr::can_cast(it.kind())); name_ref.syntax().ancestors().find(|it| ast::PathExpr::can_cast(it.kind()));
let usage_parent_option = usage_node.and_then(|it| it.parent()); let usage_parent_option = usage_node.as_ref().and_then(|it| it.parent());
let usage_parent = match usage_parent_option { let usage_parent = match usage_parent_option {
Some(u) => u, Some(u) => u,
None => return Some((range, name_ref, false)), None => return Some((name_ref, false)),
}; };
Some((range, name_ref, initializer_expr.needs_parens_in(&usage_parent))) let should_wrap = initializer_expr
.needs_parens_in_place_of(&usage_parent, usage_node.as_ref().unwrap());
Some((name_ref, should_wrap))
}) })
.collect::<Option<Vec<_>>>()?; .collect::<Option<Vec<_>>>()?;
let init_str = initializer_expr.syntax().text().to_string();
let init_in_paren = format!("({init_str})");
let target = match target { let target = match target {
ast::NameOrNameRef::Name(it) => it.syntax().text_range(), ast::NameOrNameRef::Name(it) => it.syntax().clone(),
ast::NameOrNameRef::NameRef(it) => it.syntax().text_range(), ast::NameOrNameRef::NameRef(it) => it.syntax().clone(),
}; };
acc.add( acc.add(
AssistId("inline_local_variable", AssistKind::RefactorInline), AssistId("inline_local_variable", AssistKind::RefactorInline),
"Inline variable", "Inline variable",
target, target.text_range(),
move |builder| { move |builder| {
if let Some(range) = delete_range { let mut editor = builder.make_editor(&target);
builder.delete(range); if delete_let {
} editor.delete(let_stmt.syntax());
for (range, name, should_wrap) in wrap_in_parens { if let Some(whitespace) = let_stmt
let replacement = if should_wrap { &init_in_paren } else { &init_str }; .syntax()
if ast::RecordExprField::for_field_name(&name).is_some() { .next_sibling_or_token()
cov_mark::hit!(inline_field_shorthand); .and_then(SyntaxElement::into_token)
builder.insert(range.end(), format!(": {replacement}")); .and_then(ast::Whitespace::cast)
} else { {
builder.replace(range, replacement.clone()) editor.delete(whitespace.syntax());
} }
} }
let make = SyntaxFactory::new();
for (name, should_wrap) in wrap_in_parens {
let replacement = if should_wrap {
make.expr_paren(initializer_expr.clone()).into()
} else {
initializer_expr.clone()
};
if let Some(record_field) = ast::RecordExprField::for_field_name(&name) {
cov_mark::hit!(inline_field_shorthand);
let replacement = make.record_expr_field(name, Some(replacement));
editor.replace(record_field.syntax(), replacement.syntax());
} else {
editor.replace(name.syntax(), replacement.syntax());
}
}
editor.add_mappings(make.finish_with_mappings());
builder.add_file_edits(ctx.file_id(), editor);
}, },
) )
} }
@ -939,6 +943,54 @@ fn main() {
fn main() { fn main() {
let _ = (|| 2)(); let _ = (|| 2)();
} }
"#,
);
}
#[test]
fn test_wrap_in_parens() {
check_assist(
inline_local_variable,
r#"
fn main() {
let $0a = 123 < 456;
let b = !a;
}
"#,
r#"
fn main() {
let b = !(123 < 456);
}
"#,
);
check_assist(
inline_local_variable,
r#"
trait Foo {
fn foo(&self);
}
impl Foo for bool {
fn foo(&self) {}
}
fn main() {
let $0a = 123 < 456;
let b = a.foo();
}
"#,
r#"
trait Foo {
fn foo(&self);
}
impl Foo for bool {
fn foo(&self) {}
}
fn main() {
let b = (123 < 456).foo();
}
"#, "#,
); );
} }

36
src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs → src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_type_parameter.rs
View File

@ -4,7 +4,7 @@ use syntax::ast::{self, syntax_factory::SyntaxFactory, AstNode, HasGenericParams
use crate::{AssistContext, AssistId, AssistKind, Assists}; use crate::{AssistContext, AssistId, AssistKind, Assists};
// Assist: introduce_named_generic // Assist: introduce_named_type_parameter
// //
// Replaces `impl Trait` function argument with the named generic. // Replaces `impl Trait` function argument with the named generic.
// //
@ -15,18 +15,20 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
// ``` // ```
// fn foo<$0B: Bar>(bar: B) {} // fn foo<$0B: Bar>(bar: B) {}
// ``` // ```
pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> { pub(crate) fn introduce_named_type_parameter(
acc: &mut Assists,
ctx: &AssistContext<'_>,
) -> Option<()> {
let impl_trait_type = ctx.find_node_at_offset::<ast::ImplTraitType>()?; let impl_trait_type = ctx.find_node_at_offset::<ast::ImplTraitType>()?;
let param = impl_trait_type.syntax().ancestors().find_map(ast::Param::cast)?; let param = impl_trait_type.syntax().ancestors().find_map(ast::Param::cast)?;
let fn_ = param.syntax().ancestors().find_map(ast::Fn::cast)?; let fn_ = param.syntax().ancestors().nth(2).and_then(ast::Fn::cast)?;
let type_bound_list = impl_trait_type.type_bound_list()?; let type_bound_list = impl_trait_type.type_bound_list()?;
let make = SyntaxFactory::new(); let make = SyntaxFactory::new();
let target = fn_.syntax().text_range(); let target = fn_.syntax().text_range();
acc.add( acc.add(
AssistId("introduce_named_generic", AssistKind::RefactorRewrite), AssistId("introduce_named_type_parameter", AssistKind::RefactorRewrite),
"Replace impl trait with generic", "Replace impl trait with type parameter",
target, target,
|builder| { |builder| {
let mut editor = builder.make_editor(fn_.syntax()); let mut editor = builder.make_editor(fn_.syntax());
@ -71,7 +73,7 @@ mod tests {
#[test] #[test]
fn introduce_named_generic_params() { fn introduce_named_generic_params() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn foo<G>(bar: $0impl Bar) {}"#, r#"fn foo<G>(bar: $0impl Bar) {}"#,
r#"fn foo<G, $0B: Bar>(bar: B) {}"#, r#"fn foo<G, $0B: Bar>(bar: B) {}"#,
); );
@ -80,7 +82,7 @@ mod tests {
#[test] #[test]
fn replace_impl_trait_without_generic_params() { fn replace_impl_trait_without_generic_params() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn foo(bar: $0impl Bar) {}"#, r#"fn foo(bar: $0impl Bar) {}"#,
r#"fn foo<$0B: Bar>(bar: B) {}"#, r#"fn foo<$0B: Bar>(bar: B) {}"#,
); );
@ -89,7 +91,7 @@ mod tests {
#[test] #[test]
fn replace_two_impl_trait_with_generic_params() { fn replace_two_impl_trait_with_generic_params() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn foo<G>(foo: impl Foo, bar: $0impl Bar) {}"#, r#"fn foo<G>(foo: impl Foo, bar: $0impl Bar) {}"#,
r#"fn foo<G, $0B: Bar>(foo: impl Foo, bar: B) {}"#, r#"fn foo<G, $0B: Bar>(foo: impl Foo, bar: B) {}"#,
); );
@ -98,7 +100,7 @@ mod tests {
#[test] #[test]
fn replace_impl_trait_with_empty_generic_params() { fn replace_impl_trait_with_empty_generic_params() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn foo<>(bar: $0impl Bar) {}"#, r#"fn foo<>(bar: $0impl Bar) {}"#,
r#"fn foo<$0B: Bar>(bar: B) {}"#, r#"fn foo<$0B: Bar>(bar: B) {}"#,
); );
@ -107,7 +109,7 @@ mod tests {
#[test] #[test]
fn replace_impl_trait_with_empty_multiline_generic_params() { fn replace_impl_trait_with_empty_multiline_generic_params() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#" r#"
fn foo< fn foo<
>(bar: $0impl Bar) {} >(bar: $0impl Bar) {}
@ -122,7 +124,7 @@ fn foo<$0B: Bar
#[test] #[test]
fn replace_impl_trait_with_exist_generic_letter() { fn replace_impl_trait_with_exist_generic_letter() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn foo<B>(bar: $0impl Bar) {}"#, r#"fn foo<B>(bar: $0impl Bar) {}"#,
r#"fn foo<B, $0B1: Bar>(bar: B1) {}"#, r#"fn foo<B, $0B1: Bar>(bar: B1) {}"#,
); );
@ -131,7 +133,7 @@ fn foo<$0B: Bar
#[test] #[test]
fn replace_impl_trait_with_more_exist_generic_letter() { fn replace_impl_trait_with_more_exist_generic_letter() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn foo<B, B0, B1, B3>(bar: $0impl Bar) {}"#, r#"fn foo<B, B0, B1, B3>(bar: $0impl Bar) {}"#,
r#"fn foo<B, B0, B1, B3, $0B4: Bar>(bar: B4) {}"#, r#"fn foo<B, B0, B1, B3, $0B4: Bar>(bar: B4) {}"#,
); );
@ -140,7 +142,7 @@ fn foo<$0B: Bar
#[test] #[test]
fn replace_impl_trait_with_multiline_generic_params() { fn replace_impl_trait_with_multiline_generic_params() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#" r#"
fn foo< fn foo<
G: Foo, G: Foo,
@ -161,7 +163,7 @@ fn foo<
#[test] #[test]
fn replace_impl_trait_multiple() { fn replace_impl_trait_multiple() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn foo(bar: $0impl Foo + Bar) {}"#, r#"fn foo(bar: $0impl Foo + Bar) {}"#,
r#"fn foo<$0F: Foo + Bar>(bar: F) {}"#, r#"fn foo<$0F: Foo + Bar>(bar: F) {}"#,
); );
@ -170,7 +172,7 @@ fn foo<
#[test] #[test]
fn replace_impl_with_mut() { fn replace_impl_with_mut() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn f(iter: &mut $0impl Iterator<Item = i32>) {}"#, r#"fn f(iter: &mut $0impl Iterator<Item = i32>) {}"#,
r#"fn f<$0I: Iterator<Item = i32>>(iter: &mut I) {}"#, r#"fn f<$0I: Iterator<Item = i32>>(iter: &mut I) {}"#,
); );
@ -179,7 +181,7 @@ fn foo<
#[test] #[test]
fn replace_impl_inside() { fn replace_impl_inside() {
check_assist( check_assist(
introduce_named_generic, introduce_named_type_parameter,
r#"fn f(x: &mut Vec<$0impl Iterator<Item = i32>>) {}"#, r#"fn f(x: &mut Vec<$0impl Iterator<Item = i32>>) {}"#,
r#"fn f<$0I: Iterator<Item = i32>>(x: &mut Vec<I>) {}"#, r#"fn f<$0I: Iterator<Item = i32>>(x: &mut Vec<I>) {}"#,
); );

9
src/tools/rust-analyzer/crates/ide-assists/src/handlers/term_search.rs
View File

@ -52,8 +52,13 @@ pub(crate) fn term_search(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<
let paths = paths let paths = paths
.into_iter() .into_iter()
.filter_map(|path| { .filter_map(|path| {
path.gen_source_code(&scope, &mut formatter, ctx.config.import_path_config(), edition) path.gen_source_code(
.ok() &scope,
&mut formatter,
ctx.config.import_path_config(),
scope.krate().to_display_target(ctx.db()),
)
.ok()
}) })
.unique(); .unique();

60
src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
View File

@ -105,6 +105,7 @@ mod handlers {
pub(crate) type Handler = fn(&mut Assists, &AssistContext<'_>) -> Option<()>; pub(crate) type Handler = fn(&mut Assists, &AssistContext<'_>) -> Option<()>;
mod add_braces; mod add_braces;
mod add_explicit_enum_discriminant;
mod add_explicit_type; mod add_explicit_type;
mod add_label_to_loop; mod add_label_to_loop;
mod add_lifetime_to_type; mod add_lifetime_to_type;
@ -115,9 +116,9 @@ mod handlers {
mod apply_demorgan; mod apply_demorgan;
mod auto_import; mod auto_import;
mod bind_unused_param; mod bind_unused_param;
mod bool_to_enum;
mod change_visibility; mod change_visibility;
mod convert_bool_then; mod convert_bool_then;
mod convert_bool_to_enum;
mod convert_closure_to_fn; mod convert_closure_to_fn;
mod convert_comment_block; mod convert_comment_block;
mod convert_comment_from_or_to_doc; mod convert_comment_from_or_to_doc;
@ -138,14 +139,13 @@ mod handlers {
mod destructure_tuple_binding; mod destructure_tuple_binding;
mod desugar_doc_comment; mod desugar_doc_comment;
mod expand_glob_import; mod expand_glob_import;
mod explicit_enum_discriminant; mod expand_rest_pattern;
mod extract_expressions_from_format_string; mod extract_expressions_from_format_string;
mod extract_function; mod extract_function;
mod extract_module; mod extract_module;
mod extract_struct_from_enum_variant; mod extract_struct_from_enum_variant;
mod extract_type_alias; mod extract_type_alias;
mod extract_variable; mod extract_variable;
mod fill_record_pattern_fields;
mod fix_visibility; mod fix_visibility;
mod flip_binexpr; mod flip_binexpr;
mod flip_comma; mod flip_comma;
@ -177,8 +177,8 @@ mod handlers {
mod inline_macro; mod inline_macro;
mod inline_type_alias; mod inline_type_alias;
mod into_to_qualified_from; mod into_to_qualified_from;
mod introduce_named_generic;
mod introduce_named_lifetime; mod introduce_named_lifetime;
mod introduce_named_type_parameter;
mod invert_if; mod invert_if;
mod merge_imports; mod merge_imports;
mod merge_match_arms; mod merge_match_arms;
@ -234,49 +234,47 @@ mod handlers {
&[ &[
// These are alphabetic for the foolish consistency // These are alphabetic for the foolish consistency
add_braces::add_braces, add_braces::add_braces,
add_explicit_enum_discriminant::add_explicit_enum_discriminant,
add_explicit_type::add_explicit_type, add_explicit_type::add_explicit_type,
add_label_to_loop::add_label_to_loop, add_label_to_loop::add_label_to_loop,
add_missing_match_arms::add_missing_match_arms,
add_lifetime_to_type::add_lifetime_to_type, add_lifetime_to_type::add_lifetime_to_type,
add_missing_match_arms::add_missing_match_arms,
add_return_type::add_return_type, add_return_type::add_return_type,
add_turbo_fish::add_turbo_fish, add_turbo_fish::add_turbo_fish,
apply_demorgan::apply_demorgan,
apply_demorgan::apply_demorgan_iterator, apply_demorgan::apply_demorgan_iterator,
apply_demorgan::apply_demorgan,
auto_import::auto_import, auto_import::auto_import,
bind_unused_param::bind_unused_param, bind_unused_param::bind_unused_param,
bool_to_enum::bool_to_enum,
change_visibility::change_visibility, change_visibility::change_visibility,
convert_bool_then::convert_bool_then_to_if, convert_bool_then::convert_bool_then_to_if,
convert_bool_then::convert_if_to_bool_then, convert_bool_then::convert_if_to_bool_then,
toggle_async_sugar::desugar_async_into_impl_future, convert_bool_to_enum::convert_bool_to_enum,
toggle_async_sugar::sugar_impl_future_into_async, convert_closure_to_fn::convert_closure_to_fn,
convert_comment_block::convert_comment_block, convert_comment_block::convert_comment_block,
convert_comment_from_or_to_doc::convert_comment_from_or_to_doc, convert_comment_from_or_to_doc::convert_comment_from_or_to_doc,
convert_closure_to_fn::convert_closure_to_fn,
convert_from_to_tryfrom::convert_from_to_tryfrom, convert_from_to_tryfrom::convert_from_to_tryfrom,
convert_integer_literal::convert_integer_literal, convert_integer_literal::convert_integer_literal,
convert_into_to_from::convert_into_to_from, convert_into_to_from::convert_into_to_from,
convert_iter_for_each_to_for::convert_iter_for_each_to_for,
convert_iter_for_each_to_for::convert_for_loop_with_for_each, convert_iter_for_each_to_for::convert_for_loop_with_for_each,
convert_iter_for_each_to_for::convert_iter_for_each_to_for,
convert_let_else_to_match::convert_let_else_to_match, convert_let_else_to_match::convert_let_else_to_match,
convert_match_to_let_else::convert_match_to_let_else, convert_match_to_let_else::convert_match_to_let_else,
convert_tuple_return_type_to_struct::convert_tuple_return_type_to_struct,
convert_named_struct_to_tuple_struct::convert_named_struct_to_tuple_struct, convert_named_struct_to_tuple_struct::convert_named_struct_to_tuple_struct,
convert_nested_function_to_closure::convert_nested_function_to_closure, convert_nested_function_to_closure::convert_nested_function_to_closure,
convert_to_guarded_return::convert_to_guarded_return, convert_to_guarded_return::convert_to_guarded_return,
convert_tuple_return_type_to_struct::convert_tuple_return_type_to_struct,
convert_tuple_struct_to_named_struct::convert_tuple_struct_to_named_struct, convert_tuple_struct_to_named_struct::convert_tuple_struct_to_named_struct,
convert_two_arm_bool_match_to_matches_macro::convert_two_arm_bool_match_to_matches_macro, convert_two_arm_bool_match_to_matches_macro::convert_two_arm_bool_match_to_matches_macro,
convert_while_to_loop::convert_while_to_loop, convert_while_to_loop::convert_while_to_loop,
desugar_doc_comment::desugar_doc_comment,
destructure_tuple_binding::destructure_tuple_binding,
destructure_struct_binding::destructure_struct_binding, destructure_struct_binding::destructure_struct_binding,
destructure_tuple_binding::destructure_tuple_binding,
desugar_doc_comment::desugar_doc_comment,
expand_glob_import::expand_glob_import, expand_glob_import::expand_glob_import,
expand_glob_import::expand_glob_reexport, expand_glob_import::expand_glob_reexport,
explicit_enum_discriminant::explicit_enum_discriminant, expand_rest_pattern::expand_rest_pattern,
extract_expressions_from_format_string::extract_expressions_from_format_string, extract_expressions_from_format_string::extract_expressions_from_format_string,
extract_struct_from_enum_variant::extract_struct_from_enum_variant, extract_struct_from_enum_variant::extract_struct_from_enum_variant,
extract_type_alias::extract_type_alias, extract_type_alias::extract_type_alias,
fill_record_pattern_fields::fill_record_pattern_fields,
fix_visibility::fix_visibility, fix_visibility::fix_visibility,
flip_binexpr::flip_binexpr, flip_binexpr::flip_binexpr,
flip_comma::flip_comma, flip_comma::flip_comma,
@ -287,8 +285,8 @@ mod handlers {
generate_default_from_new::generate_default_from_new, generate_default_from_new::generate_default_from_new,
generate_delegate_trait::generate_delegate_trait, generate_delegate_trait::generate_delegate_trait,
generate_derive::generate_derive, generate_derive::generate_derive,
generate_documentation_template::generate_documentation_template,
generate_documentation_template::generate_doc_example, generate_documentation_template::generate_doc_example,
generate_documentation_template::generate_documentation_template,
generate_enum_is_method::generate_enum_is_method, generate_enum_is_method::generate_enum_is_method,
generate_enum_projection_method::generate_enum_as_method, generate_enum_projection_method::generate_enum_as_method,
generate_enum_projection_method::generate_enum_try_into_method, generate_enum_projection_method::generate_enum_try_into_method,
@ -298,8 +296,8 @@ mod handlers {
generate_function::generate_function, generate_function::generate_function,
generate_impl::generate_impl, generate_impl::generate_impl,
generate_impl::generate_trait_impl, generate_impl::generate_trait_impl,
generate_mut_trait_impl::generate_mut_trait_impl,
generate_is_empty_from_len::generate_is_empty_from_len, generate_is_empty_from_len::generate_is_empty_from_len,
generate_mut_trait_impl::generate_mut_trait_impl,
generate_new::generate_new, generate_new::generate_new,
generate_trait_from_impl::generate_trait_from_impl, generate_trait_from_impl::generate_trait_from_impl,
inline_call::inline_call, inline_call::inline_call,
@ -307,39 +305,41 @@ mod handlers {
inline_const_as_literal::inline_const_as_literal, inline_const_as_literal::inline_const_as_literal,
inline_local_variable::inline_local_variable, inline_local_variable::inline_local_variable,
inline_macro::inline_macro, inline_macro::inline_macro,
inline_type_alias::inline_type_alias,
inline_type_alias::inline_type_alias_uses, inline_type_alias::inline_type_alias_uses,
inline_type_alias::inline_type_alias,
into_to_qualified_from::into_to_qualified_from, into_to_qualified_from::into_to_qualified_from,
introduce_named_generic::introduce_named_generic,
introduce_named_lifetime::introduce_named_lifetime, introduce_named_lifetime::introduce_named_lifetime,
introduce_named_type_parameter::introduce_named_type_parameter,
invert_if::invert_if, invert_if::invert_if,
merge_imports::merge_imports, merge_imports::merge_imports,
merge_match_arms::merge_match_arms, merge_match_arms::merge_match_arms,
merge_nested_if::merge_nested_if, merge_nested_if::merge_nested_if,
move_bounds::move_bounds_to_where_clause, move_bounds::move_bounds_to_where_clause,
move_const_to_impl::move_const_to_impl, move_const_to_impl::move_const_to_impl,
move_from_mod_rs::move_from_mod_rs,
move_guard::move_arm_cond_to_match_guard, move_guard::move_arm_cond_to_match_guard,
move_guard::move_guard_to_arm_body, move_guard::move_guard_to_arm_body,
move_module_to_file::move_module_to_file, move_module_to_file::move_module_to_file,
move_to_mod_rs::move_to_mod_rs, move_to_mod_rs::move_to_mod_rs,
move_from_mod_rs::move_from_mod_rs,
normalize_import::normalize_import, normalize_import::normalize_import,
number_representation::reformat_number_literal, number_representation::reformat_number_literal,
pull_assignment_up::pull_assignment_up,
promote_local_to_const::promote_local_to_const, promote_local_to_const::promote_local_to_const,
qualify_path::qualify_path, pull_assignment_up::pull_assignment_up,
qualify_method_call::qualify_method_call, qualify_method_call::qualify_method_call,
qualify_path::qualify_path,
raw_string::add_hash, raw_string::add_hash,
raw_string::make_usual_string, raw_string::make_usual_string,
raw_string::remove_hash, raw_string::remove_hash,
remove_dbg::remove_dbg, remove_dbg::remove_dbg,
remove_mut::remove_mut, remove_mut::remove_mut,
remove_parentheses::remove_parentheses,
remove_unused_imports::remove_unused_imports, remove_unused_imports::remove_unused_imports,
remove_unused_param::remove_unused_param, remove_unused_param::remove_unused_param,
remove_parentheses::remove_parentheses,
reorder_fields::reorder_fields, reorder_fields::reorder_fields,
reorder_impl_items::reorder_impl_items, reorder_impl_items::reorder_impl_items,
replace_try_expr_with_match::replace_try_expr_with_match, replace_arith_op::replace_arith_with_checked,
replace_arith_op::replace_arith_with_saturating,
replace_arith_op::replace_arith_with_wrapping,
replace_derive_with_manual_impl::replace_derive_with_manual_impl, replace_derive_with_manual_impl::replace_derive_with_manual_impl,
replace_if_let_with_match::replace_if_let_with_match, replace_if_let_with_match::replace_if_let_with_match,
replace_if_let_with_match::replace_match_with_if_let, replace_if_let_with_match::replace_match_with_if_let,
@ -348,23 +348,23 @@ mod handlers {
replace_method_eager_lazy::replace_with_eager_method, replace_method_eager_lazy::replace_with_eager_method,
replace_method_eager_lazy::replace_with_lazy_method, replace_method_eager_lazy::replace_with_lazy_method,
replace_named_generic_with_impl::replace_named_generic_with_impl, replace_named_generic_with_impl::replace_named_generic_with_impl,
replace_turbofish_with_explicit_type::replace_turbofish_with_explicit_type,
replace_qualified_name_with_use::replace_qualified_name_with_use, replace_qualified_name_with_use::replace_qualified_name_with_use,
replace_arith_op::replace_arith_with_wrapping, replace_try_expr_with_match::replace_try_expr_with_match,
replace_arith_op::replace_arith_with_checked, replace_turbofish_with_explicit_type::replace_turbofish_with_explicit_type,
replace_arith_op::replace_arith_with_saturating,
sort_items::sort_items, sort_items::sort_items,
split_import::split_import, split_import::split_import,
term_search::term_search, term_search::term_search,
toggle_async_sugar::desugar_async_into_impl_future,
toggle_async_sugar::sugar_impl_future_into_async,
toggle_ignore::toggle_ignore, toggle_ignore::toggle_ignore,
toggle_macro_delimiter::toggle_macro_delimiter, toggle_macro_delimiter::toggle_macro_delimiter,
unmerge_match_arm::unmerge_match_arm, unmerge_match_arm::unmerge_match_arm,
unmerge_use::unmerge_use, unmerge_use::unmerge_use,
unnecessary_async::unnecessary_async, unnecessary_async::unnecessary_async,
unqualify_method_call::unqualify_method_call,
unwrap_block::unwrap_block, unwrap_block::unwrap_block,
unwrap_return_type::unwrap_return_type, unwrap_return_type::unwrap_return_type,
unwrap_tuple::unwrap_tuple, unwrap_tuple::unwrap_tuple,
unqualify_method_call::unqualify_method_call,
wrap_return_type::wrap_return_type, wrap_return_type::wrap_return_type,
wrap_unwrap_cfg_attr::wrap_unwrap_cfg_attr, wrap_unwrap_cfg_attr::wrap_unwrap_cfg_attr,

30
src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
View File

@ -710,18 +710,22 @@ pub fn test_some_range(a: int) -> bool {
Indel { Indel {
insert: "let", insert: "let",
delete: 45..47, delete: 45..47,
annotation: None,
}, },
Indel { Indel {
insert: "var_name", insert: "var_name",
delete: 48..60, delete: 48..60,
annotation: None,
}, },
Indel { Indel {
insert: "=", insert: "=",
delete: 61..81, delete: 61..81,
annotation: None,
}, },
Indel { Indel {
insert: "5;\n if let 2..6 = var_name {\n true\n } else {\n false\n }", insert: "5;\n if let 2..6 = var_name {\n true\n } else {\n false\n }",
delete: 82..108, delete: 82..108,
annotation: None,
}, },
], ],
}, },
@ -739,6 +743,8 @@ pub fn test_some_range(a: int) -> bool {
}, },
file_system_edits: [], file_system_edits: [],
is_snippet: true, is_snippet: true,
annotations: {},
next_annotation_id: 0,
}, },
), ),
command: Some( command: Some(
@ -839,18 +845,22 @@ pub fn test_some_range(a: int) -> bool {
Indel { Indel {
insert: "let", insert: "let",
delete: 45..47, delete: 45..47,
annotation: None,
}, },
Indel { Indel {
insert: "var_name", insert: "var_name",
delete: 48..60, delete: 48..60,
annotation: None,
}, },
Indel { Indel {
insert: "=", insert: "=",
delete: 61..81, delete: 61..81,
annotation: None,
}, },
Indel { Indel {
insert: "5;\n if let 2..6 = var_name {\n true\n } else {\n false\n }", insert: "5;\n if let 2..6 = var_name {\n true\n } else {\n false\n }",
delete: 82..108, delete: 82..108,
annotation: None,
}, },
], ],
}, },
@ -868,6 +878,8 @@ pub fn test_some_range(a: int) -> bool {
}, },
file_system_edits: [], file_system_edits: [],
is_snippet: true, is_snippet: true,
annotations: {},
next_annotation_id: 0,
}, },
), ),
command: Some( command: Some(
@ -902,22 +914,27 @@ pub fn test_some_range(a: int) -> bool {
Indel { Indel {
insert: "const", insert: "const",
delete: 45..47, delete: 45..47,
annotation: None,
}, },
Indel { Indel {
insert: "VAR_NAME:", insert: "VAR_NAME:",
delete: 48..60, delete: 48..60,
annotation: None,
}, },
Indel { Indel {
insert: "i32", insert: "i32",
delete: 61..81, delete: 61..81,
annotation: None,
}, },
Indel { Indel {
insert: "=", insert: "=",
delete: 82..86, delete: 82..86,
annotation: None,
}, },
Indel { Indel {
insert: "5;\n if let 2..6 = VAR_NAME {\n true\n } else {\n false\n }", insert: "5;\n if let 2..6 = VAR_NAME {\n true\n } else {\n false\n }",
delete: 87..108, delete: 87..108,
annotation: None,
}, },
], ],
}, },
@ -935,6 +952,8 @@ pub fn test_some_range(a: int) -> bool {
}, },
file_system_edits: [], file_system_edits: [],
is_snippet: true, is_snippet: true,
annotations: {},
next_annotation_id: 0,
}, },
), ),
command: Some( command: Some(
@ -969,22 +988,27 @@ pub fn test_some_range(a: int) -> bool {
Indel { Indel {
insert: "static", insert: "static",
delete: 45..47, delete: 45..47,
annotation: None,
}, },
Indel { Indel {
insert: "VAR_NAME:", insert: "VAR_NAME:",
delete: 48..60, delete: 48..60,
annotation: None,
}, },
Indel { Indel {
insert: "i32", insert: "i32",
delete: 61..81, delete: 61..81,
annotation: None,
}, },
Indel { Indel {
insert: "=", insert: "=",
delete: 82..86, delete: 82..86,
annotation: None,
}, },
Indel { Indel {
insert: "5;\n if let 2..6 = VAR_NAME {\n true\n } else {\n false\n }", insert: "5;\n if let 2..6 = VAR_NAME {\n true\n } else {\n false\n }",
delete: 87..108, delete: 87..108,
annotation: None,
}, },
], ],
}, },
@ -1002,6 +1026,8 @@ pub fn test_some_range(a: int) -> bool {
}, },
file_system_edits: [], file_system_edits: [],
is_snippet: true, is_snippet: true,
annotations: {},
next_annotation_id: 0,
}, },
), ),
command: Some( command: Some(
@ -1036,10 +1062,12 @@ pub fn test_some_range(a: int) -> bool {
Indel { Indel {
insert: "fun_name()", insert: "fun_name()",
delete: 59..60, delete: 59..60,
annotation: None,
}, },
Indel { Indel {
insert: "\n\nfn fun_name() -> i32 {\n 5\n}", insert: "\n\nfn fun_name() -> i32 {\n 5\n}",
delete: 110..110, delete: 110..110,
annotation: None,
}, },
], ],
}, },
@ -1057,6 +1085,8 @@ pub fn test_some_range(a: int) -> bool {
}, },
file_system_edits: [], file_system_edits: [],
is_snippet: true, is_snippet: true,
annotations: {},
next_annotation_id: 0,
}, },
), ),
command: None, command: None,

169
src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
View File

@ -27,6 +27,29 @@ fn foo(n: i32) -> i32 {
) )
} }
#[test]
fn doctest_add_explicit_enum_discriminant() {
check_doc_test(
"add_explicit_enum_discriminant",
r#####"
enum TheEnum$0 {
Foo,
Bar,
Baz = 42,
Quux,
}
"#####,
r#####"
enum TheEnum {
Foo = 0,
Bar = 1,
Baz = 42,
Quux = 43,
}
"#####,
)
}
#[test] #[test]
fn doctest_add_explicit_type() { fn doctest_add_explicit_type() {
check_doc_test( check_doc_test(
@ -304,34 +327,6 @@ fn some_function(x: i32) {
) )
} }
#[test]
fn doctest_bool_to_enum() {
check_doc_test(
"bool_to_enum",
r#####"
fn main() {
let $0bool = true;
if bool {
println!("foo");
}
}
"#####,
r#####"
#[derive(PartialEq, Eq)]
enum Bool { True, False }
fn main() {
let bool = Bool::True;
if bool == Bool::True {
println!("foo");
}
}
"#####,
)
}
#[test] #[test]
fn doctest_change_visibility() { fn doctest_change_visibility() {
check_doc_test( check_doc_test(
@ -382,6 +377,34 @@ fn main() {
) )
} }
#[test]
fn doctest_convert_bool_to_enum() {
check_doc_test(
"convert_bool_to_enum",
r#####"
fn main() {
let $0bool = true;
if bool {
println!("foo");
}
}
"#####,
r#####"
#[derive(PartialEq, Eq)]
enum Bool { True, False }
fn main() {
let bool = Bool::True;
if bool == Bool::True {
println!("foo");
}
}
"#####,
)
}
#[test] #[test]
fn doctest_convert_closure_to_fn() { fn doctest_convert_closure_to_fn() {
check_doc_test( check_doc_test(
@ -933,23 +956,42 @@ pub use foo::{Bar, Baz};
} }
#[test] #[test]
fn doctest_explicit_enum_discriminant() { fn doctest_expand_record_rest_pattern() {
check_doc_test( check_doc_test(
"explicit_enum_discriminant", "expand_record_rest_pattern",
r#####" r#####"
enum TheEnum$0 { struct Bar { y: Y, z: Z }
Foo,
Bar, fn foo(bar: Bar) {
Baz = 42, let Bar { ..$0 } = bar;
Quux,
} }
"#####, "#####,
r#####" r#####"
enum TheEnum { struct Bar { y: Y, z: Z }
Foo = 0,
Bar = 1, fn foo(bar: Bar) {
Baz = 42, let Bar { y, z } = bar;
Quux = 43, }
"#####,
)
}
#[test]
fn doctest_expand_tuple_struct_rest_pattern() {
check_doc_test(
"expand_tuple_struct_rest_pattern",
r#####"
struct Bar(Y, Z);
fn foo(bar: Bar) {
let Bar(..$0) = bar;
}
"#####,
r#####"
struct Bar(Y, Z);
fn foo(bar: Bar) {
let Bar(_0, _1) = bar;
} }
"#####, "#####,
) )
@ -1117,27 +1159,6 @@ fn main() {
) )
} }
#[test]
fn doctest_fill_record_pattern_fields() {
check_doc_test(
"fill_record_pattern_fields",
r#####"
struct Bar { y: Y, z: Z }
fn foo(bar: Bar) {
let Bar { ..$0 } = bar;
}
"#####,
r#####"
struct Bar { y: Y, z: Z }
fn foo(bar: Bar) {
let Bar { y, z } = bar;
}
"#####,
)
}
#[test] #[test]
fn doctest_fix_visibility() { fn doctest_fix_visibility() {
check_doc_test( check_doc_test(
@ -2193,19 +2214,6 @@ fn main() -> () {
) )
} }
#[test]
fn doctest_introduce_named_generic() {
check_doc_test(
"introduce_named_generic",
r#####"
fn foo(bar: $0impl Bar) {}
"#####,
r#####"
fn foo<$0B: Bar>(bar: B) {}
"#####,
)
}
#[test] #[test]
fn doctest_introduce_named_lifetime() { fn doctest_introduce_named_lifetime() {
check_doc_test( check_doc_test(
@ -2231,6 +2239,19 @@ impl<'a> Cursor<'a> {
) )
} }
#[test]
fn doctest_introduce_named_type_parameter() {
check_doc_test(
"introduce_named_type_parameter",
r#####"
fn foo(bar: $0impl Bar) {}
"#####,
r#####"
fn foo<$0B: Bar>(bar: B) {}
"#####,
)
}
#[test] #[test]
fn doctest_invert_if() { fn doctest_invert_if() {
check_doc_test( check_doc_test(

44
src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
View File

@ -3,7 +3,8 @@
pub(crate) use gen_trait_fn_body::gen_trait_fn_body; pub(crate) use gen_trait_fn_body::gen_trait_fn_body;
use hir::{ use hir::{
db::{ExpandDatabase, HirDatabase}, db::{ExpandDatabase, HirDatabase},
HasAttrs as HirHasAttrs, HirDisplay, InFile, ModuleDef, PathResolution, Semantics, DisplayTarget, HasAttrs as HirHasAttrs, HirDisplay, InFile, ModuleDef, PathResolution,
Semantics,
}; };
use ide_db::{ use ide_db::{
famous_defs::FamousDefs, famous_defs::FamousDefs,
@ -21,7 +22,7 @@ use syntax::{
syntax_factory::SyntaxFactory, syntax_factory::SyntaxFactory,
HasArgList, HasAttrs, HasGenericParams, HasName, HasTypeBounds, Whitespace, HasArgList, HasAttrs, HasGenericParams, HasName, HasTypeBounds, Whitespace,
}, },
ted, AstNode, AstToken, Direction, Edition, NodeOrToken, SourceFile, ted, AstNode, AstToken, Direction, NodeOrToken, SourceFile,
SyntaxKind::*, SyntaxKind::*,
SyntaxNode, SyntaxToken, TextRange, TextSize, WalkEvent, T, SyntaxNode, SyntaxToken, TextRange, TextSize, WalkEvent, T,
}; };
@ -793,31 +794,50 @@ enum ReferenceConversionType {
} }
impl ReferenceConversion { impl ReferenceConversion {
pub(crate) fn convert_type(&self, db: &dyn HirDatabase, edition: Edition) -> ast::Type { pub(crate) fn convert_type(
&self,
db: &dyn HirDatabase,
display_target: DisplayTarget,
) -> ast::Type {
let ty = match self.conversion { let ty = match self.conversion {
ReferenceConversionType::Copy => self.ty.display(db, edition).to_string(), ReferenceConversionType::Copy => self.ty.display(db, display_target).to_string(),
ReferenceConversionType::AsRefStr => "&str".to_owned(), ReferenceConversionType::AsRefStr => "&str".to_owned(),
ReferenceConversionType::AsRefSlice => { ReferenceConversionType::AsRefSlice => {
let type_argument_name = let type_argument_name = self
self.ty.type_arguments().next().unwrap().display(db, edition).to_string(); .ty
.type_arguments()
.next()
.unwrap()
.display(db, display_target)
.to_string();
format!("&[{type_argument_name}]") format!("&[{type_argument_name}]")
} }
ReferenceConversionType::Dereferenced => { ReferenceConversionType::Dereferenced => {
let type_argument_name = let type_argument_name = self
self.ty.type_arguments().next().unwrap().display(db, edition).to_string(); .ty
.type_arguments()
.next()
.unwrap()
.display(db, display_target)
.to_string();
format!("&{type_argument_name}") format!("&{type_argument_name}")
} }
ReferenceConversionType::Option => { ReferenceConversionType::Option => {
let type_argument_name = let type_argument_name = self
self.ty.type_arguments().next().unwrap().display(db, edition).to_string(); .ty
.type_arguments()
.next()
.unwrap()
.display(db, display_target)
.to_string();
format!("Option<&{type_argument_name}>") format!("Option<&{type_argument_name}>")
} }
ReferenceConversionType::Result => { ReferenceConversionType::Result => {
let mut type_arguments = self.ty.type_arguments(); let mut type_arguments = self.ty.type_arguments();
let first_type_argument_name = let first_type_argument_name =
type_arguments.next().unwrap().display(db, edition).to_string(); type_arguments.next().unwrap().display(db, display_target).to_string();
let second_type_argument_name = let second_type_argument_name =
type_arguments.next().unwrap().display(db, edition).to_string(); type_arguments.next().unwrap().display(db, display_target).to_string();
format!("Result<&{first_type_argument_name}, &{second_type_argument_name}>") format!("Result<&{first_type_argument_name}, &{second_type_argument_name}>")
} }
}; };

3
src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
View File

@ -365,7 +365,8 @@ pub(crate) fn complete_expr_path(
add_keyword("false", "false"); add_keyword("false", "false");
if in_condition || in_block_expr { if in_condition || in_block_expr {
add_keyword("let", "let"); add_keyword("letm", "let mut $0");
add_keyword("let", "let $0");
} }
if after_if_expr { if after_if_expr {

30
src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
View File

@ -330,4 +330,34 @@ fn main() {
", ",
) )
} }
#[test]
fn completes_let_with_space() {
check_edit(
"let",
r#"
fn main() {
$0
}
"#,
r#"
fn main() {
let $0
}
"#,
);
check_edit(
"letm",
r#"
fn main() {
$0
}
"#,
r#"
fn main() {
let mut $0
}
"#,
);
}
} }

7
src/tools/rust-analyzer/crates/ide-completion/src/context.rs
View File

@ -7,8 +7,8 @@ mod tests;
use std::{iter, ops::ControlFlow}; use std::{iter, ops::ControlFlow};
use hir::{ use hir::{
HasAttrs, Local, ModPath, ModuleDef, ModuleSource, Name, PathResolution, ScopeDef, Semantics, DisplayTarget, HasAttrs, Local, ModPath, ModuleDef, ModuleSource, Name, PathResolution,
SemanticsScope, Symbol, Type, TypeInfo, ScopeDef, Semantics, SemanticsScope, Symbol, Type, TypeInfo,
}; };
use ide_db::{ use ide_db::{
base_db::SourceDatabase, famous_defs::FamousDefs, helpers::is_editable_crate, FilePosition, base_db::SourceDatabase, famous_defs::FamousDefs, helpers::is_editable_crate, FilePosition,
@ -440,6 +440,7 @@ pub(crate) struct CompletionContext<'a> {
pub(crate) token: SyntaxToken, pub(crate) token: SyntaxToken,
/// The crate of the current file. /// The crate of the current file.
pub(crate) krate: hir::Crate, pub(crate) krate: hir::Crate,
pub(crate) display_target: DisplayTarget,
/// The module of the `scope`. /// The module of the `scope`.
pub(crate) module: hir::Module, pub(crate) module: hir::Module,
/// The function where we're completing, if inside a function. /// The function where we're completing, if inside a function.
@ -867,6 +868,7 @@ impl<'a> CompletionContext<'a> {
CompleteSemicolon::DoNotComplete CompleteSemicolon::DoNotComplete
}; };
let display_target = krate.to_display_target(db);
let ctx = CompletionContext { let ctx = CompletionContext {
sema, sema,
scope, scope,
@ -888,6 +890,7 @@ impl<'a> CompletionContext<'a> {
exclude_flyimport, exclude_flyimport,
exclude_traits, exclude_traits,
complete_semicolon, complete_semicolon,
display_target,
}; };
Some((ctx, analysis)) Some((ctx, analysis))
} }

2
src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
View File

@ -13,7 +13,7 @@ fn check_expected_type_and_name(#[rust_analyzer::rust_fixture] ra_fixture: &str,
let ty = completion_context let ty = completion_context
.expected_type .expected_type
.map(|t| t.display_test(&db).to_string()) .map(|t| t.display_test(&db, completion_context.krate.to_display_target(&db)).to_string())
.unwrap_or("?".to_owned()); .unwrap_or("?".to_owned());
let name = let name =

8
src/tools/rust-analyzer/crates/ide-completion/src/item.rs
View File

@ -252,14 +252,16 @@ impl CompletionRelevance {
/// Provides a relevance score. Higher values are more relevant. /// Provides a relevance score. Higher values are more relevant.
/// ///
/// The absolute value of the relevance score is not meaningful, for /// The absolute value of the relevance score is not meaningful, for
/// example a value of 0 doesn't mean "not relevant", rather /// example a value of BASE_SCORE doesn't mean "not relevant", rather
/// it means "least relevant". The score value should only be used /// it means "least relevant". The score value should only be used
/// for relative ordering. /// for relative ordering.
/// ///
/// See is_relevant if you need to make some judgement about score /// See is_relevant if you need to make some judgement about score
/// in an absolute sense. /// in an absolute sense.
const BASE_SCORE: u32 = u32::MAX / 2;
pub fn score(self) -> u32 { pub fn score(self) -> u32 {
let mut score = !0 / 2; let mut score = Self::BASE_SCORE;
let CompletionRelevance { let CompletionRelevance {
exact_name_match, exact_name_match,
type_match, type_match,
@ -350,7 +352,7 @@ impl CompletionRelevance {
/// some threshold such that we think it is especially likely /// some threshold such that we think it is especially likely
/// to be relevant. /// to be relevant.
pub fn is_relevant(&self) -> bool { pub fn is_relevant(&self) -> bool {
self.score() > 0 self.score() > Self::BASE_SCORE
} }
} }

119
src/tools/rust-analyzer/crates/ide-completion/src/render.rs
View File

@ -144,7 +144,7 @@ pub(crate) fn render_field(
is_skipping_completion: receiver.is_some(), is_skipping_completion: receiver.is_some(),
..CompletionRelevance::default() ..CompletionRelevance::default()
}); });
item.detail(ty.display(db, ctx.completion.edition).to_string()) item.detail(ty.display(db, ctx.completion.display_target).to_string())
.set_documentation(field.docs(db)) .set_documentation(field.docs(db))
.set_deprecated(is_deprecated) .set_deprecated(is_deprecated)
.lookup_by(name); .lookup_by(name);
@ -212,7 +212,7 @@ pub(crate) fn render_tuple_field(
field_with_receiver(receiver.as_deref(), &field.to_string()), field_with_receiver(receiver.as_deref(), &field.to_string()),
ctx.completion.edition, ctx.completion.edition,
); );
item.detail(ty.display(ctx.db(), ctx.completion.edition).to_string()) item.detail(ty.display(ctx.db(), ctx.completion.display_target).to_string())
.lookup_by(field.to_string()); .lookup_by(field.to_string());
item.set_relevance(CompletionRelevance { item.set_relevance(CompletionRelevance {
is_skipping_completion: receiver.is_some(), is_skipping_completion: receiver.is_some(),
@ -303,7 +303,8 @@ pub(crate) fn render_expr(
let cfg = ctx.config.import_path_config(ctx.is_nightly); let cfg = ctx.config.import_path_config(ctx.is_nightly);
let label = expr.gen_source_code(&ctx.scope, &mut label_formatter, cfg, ctx.edition).ok()?; let label =
expr.gen_source_code(&ctx.scope, &mut label_formatter, cfg, ctx.display_target).ok()?;
let source_range = match ctx.original_token.parent() { let source_range = match ctx.original_token.parent() {
Some(node) => match node.ancestors().find_map(ast::Path::cast) { Some(node) => match node.ancestors().find_map(ast::Path::cast) {
@ -318,7 +319,7 @@ pub(crate) fn render_expr(
let snippet = format!( let snippet = format!(
"{}$0", "{}$0",
expr.gen_source_code(&ctx.scope, &mut snippet_formatter, cfg, ctx.edition).ok()? expr.gen_source_code(&ctx.scope, &mut snippet_formatter, cfg, ctx.display_target).ok()?
); );
let edit = TextEdit::replace(source_range, snippet); let edit = TextEdit::replace(source_range, snippet);
item.snippet_edit(ctx.config.snippet_cap?, edit); item.snippet_edit(ctx.config.snippet_cap?, edit);
@ -398,6 +399,8 @@ fn render_resolution_path(
let _p = tracing::info_span!("render_resolution_path").entered(); let _p = tracing::info_span!("render_resolution_path").entered();
use hir::ModuleDef::*; use hir::ModuleDef::*;
let krate = ctx.completion.display_target;
match resolution { match resolution {
ScopeDef::ModuleDef(Macro(mac)) => { ScopeDef::ModuleDef(Macro(mac)) => {
let ctx = ctx.import_to_add(import_to_add); let ctx = ctx.import_to_add(import_to_add);
@ -459,7 +462,7 @@ fn render_resolution_path(
let mut set_item_relevance = |ty: Type| { let mut set_item_relevance = |ty: Type| {
if !ty.is_unknown() { if !ty.is_unknown() {
item.detail(ty.display(db, completion.edition).to_string()); item.detail(ty.display(db, krate).to_string());
} }
item.set_relevance(CompletionRelevance { item.set_relevance(CompletionRelevance {
@ -1151,6 +1154,24 @@ fn main() { Foo::Fo$0 }
), ),
lookup: "Foo{}", lookup: "Foo{}",
detail: "Foo { x: i32, y: i32 }", detail: "Foo { x: i32, y: i32 }",
relevance: CompletionRelevance {
exact_name_match: false,
type_match: None,
is_local: false,
trait_: None,
is_name_already_imported: false,
requires_import: false,
is_private_editable: false,
postfix_match: None,
function: Some(
CompletionRelevanceFn {
has_params: true,
has_self_param: false,
return_type: DirectConstructor,
},
),
is_skipping_completion: false,
},
trigger_call_info: true, trigger_call_info: true,
}, },
] ]
@ -1183,6 +1204,24 @@ fn main() { Foo::Fo$0 }
), ),
lookup: "Foo()", lookup: "Foo()",
detail: "Foo(i32, i32)", detail: "Foo(i32, i32)",
relevance: CompletionRelevance {
exact_name_match: false,
type_match: None,
is_local: false,
trait_: None,
is_name_already_imported: false,
requires_import: false,
is_private_editable: false,
postfix_match: None,
function: Some(
CompletionRelevanceFn {
has_params: true,
has_self_param: false,
return_type: DirectConstructor,
},
),
is_skipping_completion: false,
},
trigger_call_info: true, trigger_call_info: true,
}, },
] ]
@ -1261,6 +1300,24 @@ fn main() { Foo::Fo$0 }
Variant, Variant,
), ),
detail: "Foo", detail: "Foo",
relevance: CompletionRelevance {
exact_name_match: false,
type_match: None,
is_local: false,
trait_: None,
is_name_already_imported: false,
requires_import: false,
is_private_editable: false,
postfix_match: None,
function: Some(
CompletionRelevanceFn {
has_params: false,
has_self_param: false,
return_type: DirectConstructor,
},
),
is_skipping_completion: false,
},
trigger_call_info: true, trigger_call_info: true,
}, },
] ]
@ -1335,7 +1392,13 @@ fn main() { let _: m::Spam = S$0 }
requires_import: false, requires_import: false,
is_private_editable: false, is_private_editable: false,
postfix_match: None, postfix_match: None,
function: None, function: Some(
CompletionRelevanceFn {
has_params: true,
has_self_param: false,
return_type: DirectConstructor,
},
),
is_skipping_completion: false, is_skipping_completion: false,
}, },
trigger_call_info: true, trigger_call_info: true,
@ -1365,7 +1428,13 @@ fn main() { let _: m::Spam = S$0 }
requires_import: false, requires_import: false,
is_private_editable: false, is_private_editable: false,
postfix_match: None, postfix_match: None,
function: None, function: Some(
CompletionRelevanceFn {
has_params: false,
has_self_param: false,
return_type: DirectConstructor,
},
),
is_skipping_completion: false, is_skipping_completion: false,
}, },
trigger_call_info: true, trigger_call_info: true,
@ -1590,6 +1659,24 @@ use self::E::*;
documentation: Documentation( documentation: Documentation(
"variant docs", "variant docs",
), ),
relevance: CompletionRelevance {
exact_name_match: false,
type_match: None,
is_local: false,
trait_: None,
is_name_already_imported: false,
requires_import: false,
is_private_editable: false,
postfix_match: None,
function: Some(
CompletionRelevanceFn {
has_params: false,
has_self_param: false,
return_type: DirectConstructor,
},
),
is_skipping_completion: false,
},
trigger_call_info: true, trigger_call_info: true,
}, },
CompletionItem { CompletionItem {
@ -2081,8 +2168,8 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
lc ssss S [type+local]
st S S [type] st S S [type]
lc ssss S [type+local]
st S S [type] st S S [type]
ex ssss [type] ex ssss [type]
ex S [type] ex S [type]
@ -2153,14 +2240,14 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
st S S []
st &S [type]
ex core::ops::Deref::deref(&t) [type_could_unify] ex core::ops::Deref::deref(&t) [type_could_unify]
lc m i32 [local] lc m i32 [local]
lc t T [local] lc t T [local]
lc &t [type+local] lc &t [type+local]
st S S [] st S S []
st &S [type] st &S [type]
st S S []
st &S [type]
st T T [] st T T []
st &T [type] st &T [type]
fn foo(…) fn(&S) [] fn foo(…) fn(&S) []
@ -2202,14 +2289,14 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
st S S []
st &mut S [type]
ex core::ops::DerefMut::deref_mut(&mut t) [type_could_unify] ex core::ops::DerefMut::deref_mut(&mut t) [type_could_unify]
lc m i32 [local] lc m i32 [local]
lc t T [local] lc t T [local]
lc &mut t [type+local] lc &mut t [type+local]
st S S [] st S S []
st &mut S [type] st &mut S [type]
st S S []
st &mut S [type]
st T T [] st T T []
st &mut T [type] st &mut T [type]
fn foo(…) fn(&mut S) [] fn foo(…) fn(&mut S) []
@ -2306,9 +2393,9 @@ fn main() {
} }
"#, "#,
expect![[r#" expect![[r#"
ex core::ops::Deref::deref(&bar()) [type_could_unify]
st S S [] st S S []
st &S [type] st &S [type]
ex core::ops::Deref::deref(&bar()) [type_could_unify]
st S S [] st S S []
st &S [type] st &S [type]
st T T [] st T T []
@ -2686,10 +2773,12 @@ fn foo(f: Foo) { let _: &u32 = f.b$0 }
Indel { Indel {
insert: "(", insert: "(",
delete: 107..107, delete: 107..107,
annotation: None,
}, },
Indel { Indel {
insert: "qux)()", insert: "qux)()",
delete: 109..110, delete: 109..110,
annotation: None,
}, },
], ],
}, },
@ -2827,11 +2916,11 @@ fn foo() {
} }
"#, "#,
expect![[r#" expect![[r#"
ev Foo::B Foo::B [type_could_unify]
ev Foo::A(…) Foo::A(T) [type_could_unify]
lc foo Foo<u32> [type+local] lc foo Foo<u32> [type+local]
ex foo [type] ex foo [type]
ex Foo::B [type] ex Foo::B [type]
ev Foo::A(…) Foo::A(T) [type_could_unify]
ev Foo::B Foo::B [type_could_unify]
en Foo Foo<{unknown}> [type_could_unify] en Foo Foo<{unknown}> [type_could_unify]
fn foo() fn() [] fn foo() fn() []
fn bar() fn() -> Foo<u8> [] fn bar() fn() -> Foo<u8> []

2
src/tools/rust-analyzer/crates/ide-completion/src/render/const_.rs
View File

@ -16,7 +16,7 @@ fn render(ctx: RenderContext<'_>, const_: hir::Const) -> Option<CompletionItem>
let name = const_.name(db)?; let name = const_.name(db)?;
let (name, escaped_name) = let (name, escaped_name) =
(name.as_str().to_smolstr(), name.display(db, ctx.completion.edition).to_smolstr()); (name.as_str().to_smolstr(), name.display(db, ctx.completion.edition).to_smolstr());
let detail = const_.display(db, ctx.completion.edition).to_string(); let detail = const_.display(db, ctx.completion.display_target).to_string();
let mut item = let mut item =
CompletionItem::new(SymbolKind::Const, ctx.source_range(), name, ctx.completion.edition); CompletionItem::new(SymbolKind::Const, ctx.source_range(), name, ctx.completion.edition);

32
src/tools/rust-analyzer/crates/ide-completion/src/render/function.rs
View File

@ -4,7 +4,7 @@ use hir::{db::HirDatabase, AsAssocItem, HirDisplay};
use ide_db::{SnippetCap, SymbolKind}; use ide_db::{SnippetCap, SymbolKind};
use itertools::Itertools; use itertools::Itertools;
use stdx::{format_to, to_lower_snake_case}; use stdx::{format_to, to_lower_snake_case};
use syntax::{format_smolstr, AstNode, Edition, SmolStr, ToSmolStr}; use syntax::{format_smolstr, AstNode, SmolStr, ToSmolStr};
use crate::{ use crate::{
context::{ context::{
@ -142,9 +142,9 @@ fn render(
} }
let detail = if ctx.completion.config.full_function_signatures { let detail = if ctx.completion.config.full_function_signatures {
detail_full(db, func, ctx.completion.edition) detail_full(ctx.completion, func)
} else { } else {
detail(ctx.completion, func, ctx.completion.edition) detail(ctx.completion, func)
}; };
item.set_documentation(ctx.docs(func)) item.set_documentation(ctx.docs(func))
.set_deprecated(ctx.is_deprecated(func) || ctx.is_deprecated_assoc_item(func)) .set_deprecated(ctx.is_deprecated(func) || ctx.is_deprecated_assoc_item(func))
@ -251,7 +251,7 @@ pub(super) fn add_call_parens<'b>(
format!( format!(
"{}(${{1:{}}}{}{})$0", "{}(${{1:{}}}{}{})$0",
escaped_name, escaped_name,
self_param.display(ctx.db, ctx.edition), self_param.display(ctx.db, ctx.display_target),
if params.is_empty() { "" } else { ", " }, if params.is_empty() { "" } else { ", " },
function_params_snippet function_params_snippet
) )
@ -307,7 +307,7 @@ fn ref_of_param(ctx: &CompletionContext<'_>, arg: &str, ty: &hir::Type) -> &'sta
"" ""
} }
fn detail(ctx: &CompletionContext<'_>, func: hir::Function, edition: Edition) -> String { fn detail(ctx: &CompletionContext<'_>, func: hir::Function) -> String {
let mut ret_ty = func.ret_type(ctx.db); let mut ret_ty = func.ret_type(ctx.db);
let mut detail = String::new(); let mut detail = String::new();
@ -324,15 +324,15 @@ fn detail(ctx: &CompletionContext<'_>, func: hir::Function, edition: Edition) ->
format_to!(detail, "unsafe "); format_to!(detail, "unsafe ");
} }
format_to!(detail, "fn({})", params_display(ctx.db, func, edition)); format_to!(detail, "fn({})", params_display(ctx, func));
if !ret_ty.is_unit() { if !ret_ty.is_unit() {
format_to!(detail, " -> {}", ret_ty.display(ctx.db, edition)); format_to!(detail, " -> {}", ret_ty.display(ctx.db, ctx.display_target));
} }
detail detail
} }
fn detail_full(db: &dyn HirDatabase, func: hir::Function, edition: Edition) -> String { fn detail_full(ctx: &CompletionContext<'_>, func: hir::Function) -> String {
let signature = format!("{}", func.display(db, edition)); let signature = format!("{}", func.display(ctx.db, ctx.display_target));
let mut detail = String::with_capacity(signature.len()); let mut detail = String::with_capacity(signature.len());
for segment in signature.split_whitespace() { for segment in signature.split_whitespace() {
@ -346,24 +346,24 @@ fn detail_full(db: &dyn HirDatabase, func: hir::Function, edition: Edition) -> S
detail detail
} }
fn params_display(db: &dyn HirDatabase, func: hir::Function, edition: Edition) -> String { fn params_display(ctx: &CompletionContext<'_>, func: hir::Function) -> String {
if let Some(self_param) = func.self_param(db) { if let Some(self_param) = func.self_param(ctx.db) {
let assoc_fn_params = func.assoc_fn_params(db); let assoc_fn_params = func.assoc_fn_params(ctx.db);
let params = assoc_fn_params let params = assoc_fn_params
.iter() .iter()
.skip(1) // skip the self param because we are manually handling that .skip(1) // skip the self param because we are manually handling that
.map(|p| p.ty().display(db, edition)); .map(|p| p.ty().display(ctx.db, ctx.display_target));
format!( format!(
"{}{}", "{}{}",
self_param.display(db, edition), self_param.display(ctx.db, ctx.display_target),
params.format_with("", |display, f| { params.format_with("", |display, f| {
f(&", ")?; f(&", ")?;
f(&display) f(&display)
}) })
) )
} else { } else {
let assoc_fn_params = func.assoc_fn_params(db); let assoc_fn_params = func.assoc_fn_params(ctx.db);
assoc_fn_params.iter().map(|p| p.ty().display(db, edition)).join(", ") assoc_fn_params.iter().map(|p| p.ty().display(ctx.db, ctx.display_target)).join(", ")
} }
} }

14
src/tools/rust-analyzer/crates/ide-completion/src/render/literal.rs
View File

@ -8,7 +8,7 @@ use ide_db::{
use crate::{ use crate::{
context::{CompletionContext, PathCompletionCtx, PathKind}, context::{CompletionContext, PathCompletionCtx, PathKind},
item::{Builder, CompletionItem}, item::{Builder, CompletionItem, CompletionRelevanceFn},
render::{ render::{
compute_type_match, compute_type_match,
variant::{ variant::{
@ -17,7 +17,7 @@ use crate::{
}, },
RenderContext, RenderContext,
}, },
CompletionItemKind, CompletionRelevance, CompletionItemKind, CompletionRelevance, CompletionRelevanceReturnType,
}; };
pub(crate) fn render_variant_lit( pub(crate) fn render_variant_lit(
@ -82,10 +82,10 @@ fn render(
let mut rendered = match kind { let mut rendered = match kind {
StructKind::Tuple if should_add_parens => { StructKind::Tuple if should_add_parens => {
render_tuple_lit(db, snippet_cap, &fields, &escaped_qualified_name, completion.edition) render_tuple_lit(completion, snippet_cap, &fields, &escaped_qualified_name)
} }
StructKind::Record if should_add_parens => { StructKind::Record if should_add_parens => {
render_record_lit(db, snippet_cap, &fields, &escaped_qualified_name, completion.edition) render_record_lit(completion, snippet_cap, &fields, &escaped_qualified_name)
} }
_ => RenderedLiteral { _ => RenderedLiteral {
literal: escaped_qualified_name.clone(), literal: escaped_qualified_name.clone(),
@ -131,6 +131,12 @@ fn render(
let ty = thing.ty(db); let ty = thing.ty(db);
item.set_relevance(CompletionRelevance { item.set_relevance(CompletionRelevance {
type_match: compute_type_match(ctx.completion, &ty), type_match: compute_type_match(ctx.completion, &ty),
// function is a misnomer here, this is more about constructor information
function: Some(CompletionRelevanceFn {
has_params: !fields.is_empty(),
has_self_param: false,
return_type: CompletionRelevanceReturnType::DirectConstructor,
}),
..ctx.completion_relevance() ..ctx.completion_relevance()
}); });

2
src/tools/rust-analyzer/crates/ide-completion/src/render/macro_.rs
View File

@ -62,7 +62,7 @@ fn render(
completion.edition, completion.edition,
); );
item.set_deprecated(ctx.is_deprecated(macro_)) item.set_deprecated(ctx.is_deprecated(macro_))
.detail(macro_.display(completion.db, completion.edition).to_string()) .detail(macro_.display(completion.db, completion.display_target).to_string())
.set_documentation(docs) .set_documentation(docs)
.set_relevance(ctx.completion_relevance()); .set_relevance(ctx.completion_relevance());

2
src/tools/rust-analyzer/crates/ide-completion/src/render/type_alias.rs
View File

@ -38,7 +38,7 @@ fn render(
} else { } else {
(name.as_str().to_smolstr(), name.display_no_db(ctx.completion.edition).to_smolstr()) (name.as_str().to_smolstr(), name.display_no_db(ctx.completion.edition).to_smolstr())
}; };
let detail = type_alias.display(db, ctx.completion.edition).to_string(); let detail = type_alias.display(db, ctx.completion.display_target).to_string();
let mut item = CompletionItem::new( let mut item = CompletionItem::new(
SymbolKind::TypeAlias, SymbolKind::TypeAlias,

2
src/tools/rust-analyzer/crates/ide-completion/src/render/union_literal.rs
View File

@ -88,7 +88,7 @@ pub(crate) fn render_union_literal(
f(&format_args!( f(&format_args!(
"{}: {}", "{}: {}",
field.name(ctx.db()).display(ctx.db(), ctx.completion.edition), field.name(ctx.db()).display(ctx.db(), ctx.completion.edition),
field.ty(ctx.db()).display(ctx.db(), ctx.completion.edition) field.ty(ctx.db()).display(ctx.db(), ctx.completion.display_target)
)) ))
}), }),
if fields_omitted { ", .." } else { "" } if fields_omitted { ", .." } else { "" }

22
src/tools/rust-analyzer/crates/ide-completion/src/render/variant.rs
View File

@ -1,10 +1,10 @@
//! Code common to structs, unions, and enum variants. //! Code common to structs, unions, and enum variants.
use crate::context::CompletionContext; use crate::context::CompletionContext;
use hir::{db::HirDatabase, sym, HasAttrs, HasCrate, HasVisibility, HirDisplay, StructKind}; use hir::{sym, HasAttrs, HasCrate, HasVisibility, HirDisplay, StructKind};
use ide_db::SnippetCap; use ide_db::SnippetCap;
use itertools::Itertools; use itertools::Itertools;
use syntax::{Edition, SmolStr}; use syntax::SmolStr;
/// A rendered struct, union, or enum variant, split into fields for actual /// A rendered struct, union, or enum variant, split into fields for actual
/// auto-completion (`literal`, using `field: ()`) and display in the /// auto-completion (`literal`, using `field: ()`) and display in the
@ -17,11 +17,10 @@ pub(crate) struct RenderedLiteral {
/// Render a record type (or sub-type) to a `RenderedCompound`. Use `None` for /// Render a record type (or sub-type) to a `RenderedCompound`. Use `None` for
/// the `name` argument for an anonymous type. /// the `name` argument for an anonymous type.
pub(crate) fn render_record_lit( pub(crate) fn render_record_lit(
db: &dyn HirDatabase, ctx: &CompletionContext<'_>,
snippet_cap: Option<SnippetCap>, snippet_cap: Option<SnippetCap>,
fields: &[hir::Field], fields: &[hir::Field],
path: &str, path: &str,
edition: Edition,
) -> RenderedLiteral { ) -> RenderedLiteral {
if snippet_cap.is_none() { if snippet_cap.is_none() {
return RenderedLiteral { literal: path.to_owned(), detail: path.to_owned() }; return RenderedLiteral { literal: path.to_owned(), detail: path.to_owned() };
@ -30,19 +29,19 @@ pub(crate) fn render_record_lit(
if snippet_cap.is_some() { if snippet_cap.is_some() {
f(&format_args!( f(&format_args!(
"{}: ${{{}:()}}", "{}: ${{{}:()}}",
field.name(db).display(db.upcast(), edition), field.name(ctx.db).display(ctx.db, ctx.edition),
idx + 1 idx + 1
)) ))
} else { } else {
f(&format_args!("{}: ()", field.name(db).display(db.upcast(), edition))) f(&format_args!("{}: ()", field.name(ctx.db).display(ctx.db, ctx.edition)))
} }
}); });
let types = fields.iter().format_with(", ", |field, f| { let types = fields.iter().format_with(", ", |field, f| {
f(&format_args!( f(&format_args!(
"{}: {}", "{}: {}",
field.name(db).display(db.upcast(), edition), field.name(ctx.db).display(ctx.db, ctx.edition),
field.ty(db).display(db, edition) field.ty(ctx.db).display(ctx.db, ctx.display_target)
)) ))
}); });
@ -55,11 +54,10 @@ pub(crate) fn render_record_lit(
/// Render a tuple type (or sub-type) to a `RenderedCompound`. Use `None` for /// Render a tuple type (or sub-type) to a `RenderedCompound`. Use `None` for
/// the `name` argument for an anonymous type. /// the `name` argument for an anonymous type.
pub(crate) fn render_tuple_lit( pub(crate) fn render_tuple_lit(
db: &dyn HirDatabase, ctx: &CompletionContext<'_>,
snippet_cap: Option<SnippetCap>, snippet_cap: Option<SnippetCap>,
fields: &[hir::Field], fields: &[hir::Field],
path: &str, path: &str,
edition: Edition,
) -> RenderedLiteral { ) -> RenderedLiteral {
if snippet_cap.is_none() { if snippet_cap.is_none() {
return RenderedLiteral { literal: path.to_owned(), detail: path.to_owned() }; return RenderedLiteral { literal: path.to_owned(), detail: path.to_owned() };
@ -72,7 +70,9 @@ pub(crate) fn render_tuple_lit(
} }
}); });
let types = fields.iter().format_with(", ", |field, f| f(&field.ty(db).display(db, edition))); let types = fields
.iter()
.format_with(", ", |field, f| f(&field.ty(ctx.db).display(ctx.db, ctx.display_target)));
RenderedLiteral { RenderedLiteral {
literal: format!("{path}({completions})"), literal: format!("{path}({completions})"),

15
src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
View File

@ -170,6 +170,7 @@ impl Unit {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -247,6 +248,7 @@ fn complete_in_block() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -297,6 +299,7 @@ fn complete_after_if_expr() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -370,6 +373,7 @@ fn completes_in_loop_ctx() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -942,6 +946,7 @@ fn foo() { if foo {} $0 }
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -983,6 +988,7 @@ fn foo() { if foo {} el$0 }
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1072,6 +1078,7 @@ fn foo() { if foo {} $0 let x = 92; }
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1113,6 +1120,7 @@ fn foo() { if foo {} el$0 let x = 92; }
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1154,6 +1162,7 @@ fn foo() { if foo {} el$0 { let x = 92; } }
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1205,6 +1214,7 @@ pub struct UnstableThisShouldNotBeListed;
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1258,6 +1268,7 @@ pub struct UnstableButWeAreOnNightlyAnyway;
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1495,6 +1506,7 @@ fn main() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1920,6 +1932,7 @@ fn bar() {
md rust_2015 (use core::prelude::rust_2015) md rust_2015 (use core::prelude::rust_2015)
md rust_2018 (use core::prelude::rust_2018) md rust_2018 (use core::prelude::rust_2018)
md rust_2021 (use core::prelude::rust_2021) md rust_2021 (use core::prelude::rust_2021)
md rust_2024 (use core::prelude::rust_2024)
tt Clone tt Clone
tt Copy tt Copy
tt IntoIterator tt IntoIterator
@ -1944,6 +1957,7 @@ fn bar() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -2015,6 +2029,7 @@ fn foo() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod

1
src/tools/rust-analyzer/crates/ide-completion/src/tests/item.rs
View File

@ -285,6 +285,7 @@ fn bar() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod

4
src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
View File

@ -1009,6 +1009,7 @@ fn here_we_go() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1059,6 +1060,7 @@ fn here_we_go() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1182,6 +1184,7 @@ fn bar() { qu$0 }
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod
@ -1437,6 +1440,7 @@ fn foo() {
kw if let kw if let
kw impl kw impl
kw let kw let
kw letm
kw loop kw loop
kw match kw match
kw mod kw mod

93
src/tools/rust-analyzer/crates/ide-db/src/defs.rs
View File

@ -12,11 +12,11 @@ use arrayvec::ArrayVec;
use either::Either; use either::Either;
use hir::{ use hir::{
Adt, AsAssocItem, AsExternAssocItem, AssocItem, AttributeTemplate, BuiltinAttr, BuiltinType, Adt, AsAssocItem, AsExternAssocItem, AssocItem, AttributeTemplate, BuiltinAttr, BuiltinType,
Const, Crate, DefWithBody, DeriveHelper, DocLinkDef, ExternAssocItem, ExternCrateDecl, Field, Const, Crate, DefWithBody, DeriveHelper, DisplayTarget, DocLinkDef, ExternAssocItem,
Function, GenericDef, GenericParam, GenericSubstitution, HasContainer, HasVisibility, ExternCrateDecl, Field, Function, GenericDef, GenericParam, GenericSubstitution, HasContainer,
HirDisplay, Impl, InlineAsmOperand, ItemContainer, Label, Local, Macro, Module, ModuleDef, HasVisibility, HirDisplay, Impl, InlineAsmOperand, ItemContainer, Label, Local, Macro, Module,
Name, PathResolution, Semantics, Static, StaticLifetime, Struct, ToolModule, Trait, TraitAlias, ModuleDef, Name, PathResolution, Semantics, Static, StaticLifetime, Struct, ToolModule, Trait,
TupleField, TypeAlias, Variant, VariantDef, Visibility, TraitAlias, TupleField, TypeAlias, Variant, VariantDef, Visibility,
}; };
use span::Edition; use span::Edition;
use stdx::{format_to, impl_from}; use stdx::{format_to, impl_from};
@ -207,7 +207,7 @@ impl Definition {
&self, &self,
db: &RootDatabase, db: &RootDatabase,
famous_defs: Option<&FamousDefs<'_, '_>>, famous_defs: Option<&FamousDefs<'_, '_>>,
edition: Edition, display_target: DisplayTarget,
) -> Option<Documentation> { ) -> Option<Documentation> {
let docs = match self { let docs = match self {
Definition::Macro(it) => it.docs(db), Definition::Macro(it) => it.docs(db),
@ -228,7 +228,7 @@ impl Definition {
let docs = adt.docs(db)?; let docs = adt.docs(db)?;
let docs = format!( let docs = format!(
"*This is the documentation for* `{}`\n\n{}", "*This is the documentation for* `{}`\n\n{}",
adt.display(db, edition), adt.display(db, display_target),
docs.as_str() docs.as_str()
); );
Some(Documentation::new(docs)) Some(Documentation::new(docs))
@ -237,8 +237,9 @@ impl Definition {
Definition::BuiltinType(it) => { Definition::BuiltinType(it) => {
famous_defs.and_then(|fd| { famous_defs.and_then(|fd| {
// std exposes prim_{} modules with docstrings on the root to document the builtins // std exposes prim_{} modules with docstrings on the root to document the builtins
let primitive_mod = format!("prim_{}", it.name().display(fd.0.db, edition)); let primitive_mod =
let doc_owner = find_std_module(fd, &primitive_mod, edition)?; format!("prim_{}", it.name().display(fd.0.db, display_target.edition));
let doc_owner = find_std_module(fd, &primitive_mod, display_target.edition)?;
doc_owner.docs(fd.0.db) doc_owner.docs(fd.0.db)
}) })
} }
@ -256,16 +257,21 @@ impl Definition {
let AttributeTemplate { word, list, name_value_str } = it.template(db)?; let AttributeTemplate { word, list, name_value_str } = it.template(db)?;
let mut docs = "Valid forms are:".to_owned(); let mut docs = "Valid forms are:".to_owned();
if word { if word {
format_to!(docs, "\n - #\\[{}]", name.display(db, edition)); format_to!(docs, "\n - #\\[{}]", name.display(db, display_target.edition));
} }
if let Some(list) = list { if let Some(list) = list {
format_to!(docs, "\n - #\\[{}({})]", name.display(db, edition), list); format_to!(
docs,
"\n - #\\[{}({})]",
name.display(db, display_target.edition),
list
);
} }
if let Some(name_value_str) = name_value_str { if let Some(name_value_str) = name_value_str {
format_to!( format_to!(
docs, docs,
"\n - #\\[{} = {}]", "\n - #\\[{} = {}]",
name.display(db, edition), name.display(db, display_target.edition),
name_value_str name_value_str
); );
} }
@ -288,49 +294,60 @@ impl Definition {
}) })
} }
pub fn label(&self, db: &RootDatabase, edition: Edition) -> String { pub fn label(&self, db: &RootDatabase, display_target: DisplayTarget) -> String {
match *self { match *self {
Definition::Macro(it) => it.display(db, edition).to_string(), Definition::Macro(it) => it.display(db, display_target).to_string(),
Definition::Field(it) => it.display(db, edition).to_string(), Definition::Field(it) => it.display(db, display_target).to_string(),
Definition::TupleField(it) => it.display(db, edition).to_string(), Definition::TupleField(it) => it.display(db, display_target).to_string(),
Definition::Module(it) => it.display(db, edition).to_string(), Definition::Module(it) => it.display(db, display_target).to_string(),
Definition::Crate(it) => it.display(db, edition).to_string(), Definition::Crate(it) => it.display(db, display_target).to_string(),
Definition::Function(it) => it.display(db, edition).to_string(), Definition::Function(it) => it.display(db, display_target).to_string(),
Definition::Adt(it) => it.display(db, edition).to_string(), Definition::Adt(it) => it.display(db, display_target).to_string(),
Definition::Variant(it) => it.display(db, edition).to_string(), Definition::Variant(it) => it.display(db, display_target).to_string(),
Definition::Const(it) => it.display(db, edition).to_string(), Definition::Const(it) => it.display(db, display_target).to_string(),
Definition::Static(it) => it.display(db, edition).to_string(), Definition::Static(it) => it.display(db, display_target).to_string(),
Definition::Trait(it) => it.display(db, edition).to_string(), Definition::Trait(it) => it.display(db, display_target).to_string(),
Definition::TraitAlias(it) => it.display(db, edition).to_string(), Definition::TraitAlias(it) => it.display(db, display_target).to_string(),
Definition::TypeAlias(it) => it.display(db, edition).to_string(), Definition::TypeAlias(it) => it.display(db, display_target).to_string(),
Definition::BuiltinType(it) => it.name().display(db, edition).to_string(), Definition::BuiltinType(it) => {
Definition::BuiltinLifetime(it) => it.name().display(db, edition).to_string(), it.name().display(db, display_target.edition).to_string()
}
Definition::BuiltinLifetime(it) => {
it.name().display(db, display_target.edition).to_string()
}
Definition::Local(it) => { Definition::Local(it) => {
let ty = it.ty(db); let ty = it.ty(db);
let ty_display = ty.display_truncated(db, None, edition); let ty_display = ty.display_truncated(db, None, display_target);
let is_mut = if it.is_mut(db) { "mut " } else { "" }; let is_mut = if it.is_mut(db) { "mut " } else { "" };
if it.is_self(db) { if it.is_self(db) {
format!("{is_mut}self: {ty_display}") format!("{is_mut}self: {ty_display}")
} else { } else {
let name = it.name(db); let name = it.name(db);
let let_kw = if it.is_param(db) { "" } else { "let " }; let let_kw = if it.is_param(db) { "" } else { "let " };
format!("{let_kw}{is_mut}{}: {ty_display}", name.display(db, edition)) format!(
"{let_kw}{is_mut}{}: {ty_display}",
name.display(db, display_target.edition)
)
} }
} }
Definition::SelfType(impl_def) => { Definition::SelfType(impl_def) => {
let self_ty = &impl_def.self_ty(db); let self_ty = &impl_def.self_ty(db);
match self_ty.as_adt() { match self_ty.as_adt() {
Some(it) => it.display(db, edition).to_string(), Some(it) => it.display(db, display_target).to_string(),
None => self_ty.display(db, edition).to_string(), None => self_ty.display(db, display_target).to_string(),
} }
} }
Definition::GenericParam(it) => it.display(db, edition).to_string(), Definition::GenericParam(it) => it.display(db, display_target).to_string(),
Definition::Label(it) => it.name(db).display(db, edition).to_string(), Definition::Label(it) => it.name(db).display(db, display_target.edition).to_string(),
Definition::ExternCrateDecl(it) => it.display(db, edition).to_string(), Definition::ExternCrateDecl(it) => it.display(db, display_target).to_string(),
Definition::BuiltinAttr(it) => format!("#[{}]", it.name(db).display(db, edition)), Definition::BuiltinAttr(it) => {
Definition::ToolModule(it) => it.name(db).display(db, edition).to_string(), format!("#[{}]", it.name(db).display(db, display_target.edition))
}
Definition::ToolModule(it) => {
it.name(db).display(db, display_target.edition).to_string()
}
Definition::DeriveHelper(it) => { Definition::DeriveHelper(it) => {
format!("derive_helper {}", it.name(db).display(db, edition)) format!("derive_helper {}", it.name(db).display(db, display_target.edition))
} }
// FIXME // FIXME
Definition::InlineAsmRegOrRegClass(_) => "inline_asm_reg_or_reg_class".to_owned(), Definition::InlineAsmRegOrRegClass(_) => "inline_asm_reg_or_reg_class".to_owned(),

4
src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
View File

@ -15052,7 +15052,7 @@ cannot be represented as the underlying type without loss."##,
}, },
Lint { Lint {
label: "clippy::manual_bits", label: "clippy::manual_bits",
description: r##"Checks for usage of `std::mem::size_of::<T>() * 8` when description: r##"Checks for usage of `size_of::<T>() * 8` when
`T::BITS` is available."##, `T::BITS` is available."##,
default_severity: Severity::Allow, default_severity: Severity::Allow,
warn_since: None, warn_since: None,
@ -17394,7 +17394,7 @@ count of elements of type `T`"##,
}, },
Lint { Lint {
label: "clippy::size_of_ref", label: "clippy::size_of_ref",
description: r##"Checks for calls to `std::mem::size_of_val()` where the argument is description: r##"Checks for calls to `size_of_val()` where the argument is
a reference to a reference."##, a reference to a reference."##,
default_severity: Severity::Allow, default_severity: Severity::Allow,
warn_since: None, warn_since: None,

4
src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
View File

@ -192,7 +192,9 @@ impl<'a> PathTransform<'a> {
} }
} }
(Either::Left(k), None) => { (Either::Left(k), None) => {
if let Some(default) = k.default(db, target_edition) { if let Some(default) =
k.default(db, target_module.krate().to_display_target(db))
{
if let Some(default) = default.expr() { if let Some(default) = default.expr() {
const_substs.insert(k, default.syntax().clone_for_update()); const_substs.insert(k, default.syntax().clone_for_update());
defaulted_params.push(Either::Right(k)); defaulted_params.push(Either::Right(k));

36
src/tools/rust-analyzer/crates/ide-db/src/rename.rs
View File

@ -22,7 +22,10 @@
//! Our current behavior is ¯\_(ツ)_/¯. //! Our current behavior is ¯\_(ツ)_/¯.
use std::fmt; use std::fmt;
use crate::text_edit::{TextEdit, TextEditBuilder}; use crate::{
source_change::ChangeAnnotation,
text_edit::{TextEdit, TextEditBuilder},
};
use base_db::AnchoredPathBuf; use base_db::AnchoredPathBuf;
use either::Either; use either::Either;
use hir::{FieldSource, FileRange, HirFileIdExt, InFile, ModuleSource, Semantics}; use hir::{FieldSource, FileRange, HirFileIdExt, InFile, ModuleSource, Semantics};
@ -365,10 +368,12 @@ fn rename_reference(
})); }));
let mut insert_def_edit = |def| { let mut insert_def_edit = |def| {
let (file_id, edit) = source_edit_from_def(sema, def, new_name)?; let (file_id, edit) = source_edit_from_def(sema, def, new_name, &mut source_change)?;
source_change.insert_source_edit(file_id, edit); source_change.insert_source_edit(file_id, edit);
Ok(()) Ok(())
}; };
// This needs to come after the references edits, because we change the annotation of existing edits
// if a conflict is detected.
insert_def_edit(def)?; insert_def_edit(def)?;
Ok(source_change) Ok(source_change)
} }
@ -537,6 +542,7 @@ fn source_edit_from_def(
sema: &Semantics<'_, RootDatabase>, sema: &Semantics<'_, RootDatabase>,
def: Definition, def: Definition,
new_name: &str, new_name: &str,
source_change: &mut SourceChange,
) -> Result<(FileId, TextEdit)> { ) -> Result<(FileId, TextEdit)> {
let new_name_edition_aware = |new_name: &str, file_id: EditionedFileId| { let new_name_edition_aware = |new_name: &str, file_id: EditionedFileId| {
if is_raw_identifier(new_name, file_id.edition()) { if is_raw_identifier(new_name, file_id.edition()) {
@ -548,6 +554,23 @@ fn source_edit_from_def(
let mut edit = TextEdit::builder(); let mut edit = TextEdit::builder();
if let Definition::Local(local) = def { if let Definition::Local(local) = def {
let mut file_id = None; let mut file_id = None;
let conflict_annotation = if !sema.rename_conflicts(&local, new_name).is_empty() {
Some(
source_change.insert_annotation(ChangeAnnotation {
label: "This rename will change the program's meaning".to_owned(),
needs_confirmation: true,
description: Some(
"Some variable(s) will shadow the renamed variable \
or be shadowed by it if the rename is performed"
.to_owned(),
),
}),
)
} else {
None
};
for source in local.sources(sema.db) { for source in local.sources(sema.db) {
let source = match source.source.clone().original_ast_node_rooted(sema.db) { let source = match source.source.clone().original_ast_node_rooted(sema.db) {
Some(source) => source, Some(source) => source,
@ -611,8 +634,15 @@ fn source_edit_from_def(
} }
} }
} }
let mut edit = edit.finish();
for (edit, _) in source_change.source_file_edits.values_mut() {
edit.set_annotation(conflict_annotation);
}
edit.set_annotation(conflict_annotation);
let Some(file_id) = file_id else { bail!("No file available to rename") }; let Some(file_id) = file_id else { bail!("No file available to rename") };
return Ok((EditionedFileId::file_id(file_id), edit.finish())); return Ok((EditionedFileId::file_id(file_id), edit));
} }
let FileRange { file_id, range } = def let FileRange { file_id, range } = def
.range_for_rename(sema) .range_for_rename(sema)

45
src/tools/rust-analyzer/crates/ide-db/src/source_change.rs
View File

@ -3,7 +3,7 @@
//! //!
//! It can be viewed as a dual for `Change`. //! It can be viewed as a dual for `Change`.
use std::{collections::hash_map::Entry, iter, mem}; use std::{collections::hash_map::Entry, fmt, iter, mem};
use crate::text_edit::{TextEdit, TextEditBuilder}; use crate::text_edit::{TextEdit, TextEditBuilder};
use crate::{assists::Command, syntax_helpers::tree_diff::diff, SnippetCap}; use crate::{assists::Command, syntax_helpers::tree_diff::diff, SnippetCap};
@ -18,23 +18,33 @@ use syntax::{
AstNode, SyntaxElement, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextSize, AstNode, SyntaxElement, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextSize,
}; };
/// An annotation ID associated with an indel, to describe changes.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ChangeAnnotationId(u32);
impl fmt::Display for ChangeAnnotationId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.0, f)
}
}
#[derive(Debug, Clone)]
pub struct ChangeAnnotation {
pub label: String,
pub needs_confirmation: bool,
pub description: Option<String>,
}
#[derive(Default, Debug, Clone)] #[derive(Default, Debug, Clone)]
pub struct SourceChange { pub struct SourceChange {
pub source_file_edits: IntMap<FileId, (TextEdit, Option<SnippetEdit>)>, pub source_file_edits: IntMap<FileId, (TextEdit, Option<SnippetEdit>)>,
pub file_system_edits: Vec<FileSystemEdit>, pub file_system_edits: Vec<FileSystemEdit>,
pub is_snippet: bool, pub is_snippet: bool,
pub annotations: FxHashMap<ChangeAnnotationId, ChangeAnnotation>,
next_annotation_id: u32,
} }
impl SourceChange { impl SourceChange {
/// Creates a new SourceChange with the given label
/// from the edits.
pub fn from_edits(
source_file_edits: IntMap<FileId, (TextEdit, Option<SnippetEdit>)>,
file_system_edits: Vec<FileSystemEdit>,
) -> Self {
SourceChange { source_file_edits, file_system_edits, is_snippet: false }
}
pub fn from_text_edit(file_id: impl Into<FileId>, edit: TextEdit) -> Self { pub fn from_text_edit(file_id: impl Into<FileId>, edit: TextEdit) -> Self {
SourceChange { SourceChange {
source_file_edits: iter::once((file_id.into(), (edit, None))).collect(), source_file_edits: iter::once((file_id.into(), (edit, None))).collect(),
@ -42,6 +52,13 @@ impl SourceChange {
} }
} }
pub fn insert_annotation(&mut self, annotation: ChangeAnnotation) -> ChangeAnnotationId {
let id = ChangeAnnotationId(self.next_annotation_id);
self.next_annotation_id += 1;
self.annotations.insert(id, annotation);
id
}
/// Inserts a [`TextEdit`] for the given [`FileId`]. This properly handles merging existing /// Inserts a [`TextEdit`] for the given [`FileId`]. This properly handles merging existing
/// edits for a file if some already exist. /// edits for a file if some already exist.
pub fn insert_source_edit(&mut self, file_id: impl Into<FileId>, edit: TextEdit) { pub fn insert_source_edit(&mut self, file_id: impl Into<FileId>, edit: TextEdit) {
@ -120,7 +137,12 @@ impl From<IntMap<FileId, TextEdit>> for SourceChange {
fn from(source_file_edits: IntMap<FileId, TextEdit>) -> SourceChange { fn from(source_file_edits: IntMap<FileId, TextEdit>) -> SourceChange {
let source_file_edits = let source_file_edits =
source_file_edits.into_iter().map(|(file_id, edit)| (file_id, (edit, None))).collect(); source_file_edits.into_iter().map(|(file_id, edit)| (file_id, (edit, None))).collect();
SourceChange { source_file_edits, file_system_edits: Vec::new(), is_snippet: false } SourceChange {
source_file_edits,
file_system_edits: Vec::new(),
is_snippet: false,
..SourceChange::default()
}
} }
} }
@ -482,6 +504,7 @@ impl From<FileSystemEdit> for SourceChange {
source_file_edits: Default::default(), source_file_edits: Default::default(),
file_system_edits: vec![edit], file_system_edits: vec![edit],
is_snippet: false, is_snippet: false,
..SourceChange::default()
} }
} }
} }

3
src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
View File

@ -24,7 +24,6 @@ use std::{
cmp::Ordering, cmp::Ordering,
fmt, fmt,
hash::{Hash, Hasher}, hash::{Hash, Hasher},
mem,
ops::ControlFlow, ops::ControlFlow,
}; };
@ -299,7 +298,7 @@ impl SymbolIndex {
} }
pub fn memory_size(&self) -> usize { pub fn memory_size(&self) -> usize {
self.map.as_fst().size() + self.symbols.len() * mem::size_of::<FileSymbol>() self.map.as_fst().size() + self.symbols.len() * size_of::<FileSymbol>()
} }
fn range_to_map_value(start: usize, end: usize) -> u64 { fn range_to_map_value(start: usize, end: usize) -> u64 {

22
src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/node_ext.rs
View File

@ -1,4 +1,6 @@
//! Various helper functions to work with SyntaxNodes. //! Various helper functions to work with SyntaxNodes.
use std::ops::ControlFlow;
use itertools::Itertools; use itertools::Itertools;
use parser::T; use parser::T;
use span::Edition; use span::Edition;
@ -119,7 +121,10 @@ pub fn walk_patterns_in_expr(start: &ast::Expr, cb: &mut dyn FnMut(ast::Pat)) {
match ast::Stmt::cast(node.clone()) { match ast::Stmt::cast(node.clone()) {
Some(ast::Stmt::LetStmt(l)) => { Some(ast::Stmt::LetStmt(l)) => {
if let Some(pat) = l.pat() { if let Some(pat) = l.pat() {
walk_pat(&pat, cb); walk_pat(&pat, &mut |pat| {
cb(pat);
ControlFlow::<(), ()>::Continue(())
});
} }
if let Some(expr) = l.initializer() { if let Some(expr) = l.initializer() {
walk_patterns_in_expr(&expr, cb); walk_patterns_in_expr(&expr, cb);
@ -154,7 +159,10 @@ pub fn walk_patterns_in_expr(start: &ast::Expr, cb: &mut dyn FnMut(ast::Pat)) {
} }
} else if let Some(pat) = ast::Pat::cast(node) { } else if let Some(pat) = ast::Pat::cast(node) {
preorder.skip_subtree(); preorder.skip_subtree();
walk_pat(&pat, cb); walk_pat(&pat, &mut |pat| {
cb(pat);
ControlFlow::<(), ()>::Continue(())
});
} }
} }
} }
@ -162,7 +170,10 @@ pub fn walk_patterns_in_expr(start: &ast::Expr, cb: &mut dyn FnMut(ast::Pat)) {
} }
/// Preorder walk all the pattern's sub patterns. /// Preorder walk all the pattern's sub patterns.
pub fn walk_pat(pat: &ast::Pat, cb: &mut dyn FnMut(ast::Pat)) { pub fn walk_pat<T>(
pat: &ast::Pat,
cb: &mut dyn FnMut(ast::Pat) -> ControlFlow<T>,
) -> ControlFlow<T> {
let mut preorder = pat.syntax().preorder(); let mut preorder = pat.syntax().preorder();
while let Some(event) = preorder.next() { while let Some(event) = preorder.next() {
let node = match event { let node = match event {
@ -173,10 +184,10 @@ pub fn walk_pat(pat: &ast::Pat, cb: &mut dyn FnMut(ast::Pat)) {
match ast::Pat::cast(node) { match ast::Pat::cast(node) {
Some(pat @ ast::Pat::ConstBlockPat(_)) => { Some(pat @ ast::Pat::ConstBlockPat(_)) => {
preorder.skip_subtree(); preorder.skip_subtree();
cb(pat); cb(pat)?;
} }
Some(pat) => { Some(pat) => {
cb(pat); cb(pat)?;
} }
// skip const args // skip const args
None if ast::GenericArg::can_cast(kind) => { None if ast::GenericArg::can_cast(kind) => {
@ -185,6 +196,7 @@ pub fn walk_pat(pat: &ast::Pat, cb: &mut dyn FnMut(ast::Pat)) {
None => (), None => (),
} }
} }
ControlFlow::Continue(())
} }
/// Preorder walk all the type's sub types. /// Preorder walk all the type's sub types.

15
src/tools/rust-analyzer/crates/ide-db/src/text_edit.rs
View File

@ -8,6 +8,8 @@ use itertools::Itertools;
pub use span::{TextRange, TextSize}; pub use span::{TextRange, TextSize};
use std::cmp::max; use std::cmp::max;
use crate::source_change::ChangeAnnotationId;
/// `InsertDelete` -- a single "atomic" change to text /// `InsertDelete` -- a single "atomic" change to text
/// ///
/// Must not overlap with other `InDel`s /// Must not overlap with other `InDel`s
@ -16,6 +18,7 @@ pub struct Indel {
pub insert: String, pub insert: String,
/// Refers to offsets in the original text /// Refers to offsets in the original text
pub delete: TextRange, pub delete: TextRange,
pub annotation: Option<ChangeAnnotationId>,
} }
#[derive(Default, Debug, Clone)] #[derive(Default, Debug, Clone)]
@ -37,7 +40,7 @@ impl Indel {
Indel::replace(range, String::new()) Indel::replace(range, String::new())
} }
pub fn replace(range: TextRange, replace_with: String) -> Indel { pub fn replace(range: TextRange, replace_with: String) -> Indel {
Indel { delete: range, insert: replace_with } Indel { delete: range, insert: replace_with, annotation: None }
} }
pub fn apply(&self, text: &mut String) { pub fn apply(&self, text: &mut String) {
@ -138,6 +141,14 @@ impl TextEdit {
} }
Some(res) Some(res)
} }
pub fn set_annotation(&mut self, annotation: Option<ChangeAnnotationId>) {
if annotation.is_some() {
for indel in &mut self.indels {
indel.annotation = annotation;
}
}
}
} }
impl IntoIterator for TextEdit { impl IntoIterator for TextEdit {
@ -180,7 +191,7 @@ impl TextEditBuilder {
pub fn invalidates_offset(&self, offset: TextSize) -> bool { pub fn invalidates_offset(&self, offset: TextSize) -> bool {
self.indels.iter().any(|indel| indel.delete.contains_inclusive(offset)) self.indels.iter().any(|indel| indel.delete.contains_inclusive(offset))
} }
fn indel(&mut self, indel: Indel) { pub fn indel(&mut self, indel: Indel) {
self.indels.push(indel); self.indels.push(indel);
if self.indels.len() <= 16 { if self.indels.len() <= 16 {
assert_disjoint_or_equal(&mut self.indels); assert_disjoint_or_equal(&mut self.indels);

2
src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/expected_function.rs
View File

@ -12,7 +12,7 @@ pub(crate) fn expected_function(
Diagnostic::new_with_syntax_node_ptr( Diagnostic::new_with_syntax_node_ptr(
ctx, ctx,
DiagnosticCode::RustcHardError("E0618"), DiagnosticCode::RustcHardError("E0618"),
format!("expected function, found {}", d.found.display(ctx.sema.db, ctx.edition)), format!("expected function, found {}", d.found.display(ctx.sema.db, ctx.display_target)),
d.call.map(|it| it.into()), d.call.map(|it| it.into()),
) )
.experimental() .experimental()

2
src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/invalid_cast.rs
View File

@ -8,7 +8,7 @@ macro_rules! format_ty {
$fmt, $fmt,
$( $(
$arg $arg
.display($ctx.sema.db, $ctx.edition) .display($ctx.sema.db, $ctx.display_target)
.with_closure_style(ClosureStyle::ClosureWithId) .with_closure_style(ClosureStyle::ClosureWithId)
),* ),*
) )

2
src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/moved_out_of_ref.rs
View File

@ -8,7 +8,7 @@ pub(crate) fn moved_out_of_ref(ctx: &DiagnosticsContext<'_>, d: &hir::MovedOutOf
Diagnostic::new_with_syntax_node_ptr( Diagnostic::new_with_syntax_node_ptr(
ctx, ctx,
DiagnosticCode::RustcHardError("E0507"), DiagnosticCode::RustcHardError("E0507"),
format!("cannot move `{}` out of reference", d.ty.display(ctx.sema.db, ctx.edition)), format!("cannot move `{}` out of reference", d.ty.display(ctx.sema.db, ctx.display_target)),
d.span, d.span,
) )
.experimental() // spans are broken, and I'm not sure how precise we can detect copy types .experimental() // spans are broken, and I'm not sure how precise we can detect copy types

4
src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs
View File

@ -30,7 +30,7 @@ pub(crate) fn trait_impl_redundant_assoc_item(
( (
format!("`fn {redundant_assoc_item_name}`"), format!("`fn {redundant_assoc_item_name}`"),
function.source(db).map(|it| it.syntax().text_range()).unwrap_or(default_range), function.source(db).map(|it| it.syntax().text_range()).unwrap_or(default_range),
format!("\n {};", function.display(db, ctx.edition)), format!("\n {};", function.display(db, ctx.display_target)),
) )
} }
hir::AssocItem::Const(id) => { hir::AssocItem::Const(id) => {
@ -38,7 +38,7 @@ pub(crate) fn trait_impl_redundant_assoc_item(
( (
format!("`const {redundant_assoc_item_name}`"), format!("`const {redundant_assoc_item_name}`"),
constant.source(db).map(|it| it.syntax().text_range()).unwrap_or(default_range), constant.source(db).map(|it| it.syntax().text_range()).unwrap_or(default_range),
format!("\n {};", constant.display(db, ctx.edition)), format!("\n {};", constant.display(db, ctx.display_target)),
) )
} }
hir::AssocItem::TypeAlias(id) => { hir::AssocItem::TypeAlias(id) => {

8
src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/type_mismatch.rs
View File

@ -45,10 +45,10 @@ pub(crate) fn type_mismatch(ctx: &DiagnosticsContext<'_>, d: &hir::TypeMismatch)
format!( format!(
"expected {}, found {}", "expected {}, found {}",
d.expected d.expected
.display(ctx.sema.db, ctx.edition) .display(ctx.sema.db, ctx.display_target)
.with_closure_style(ClosureStyle::ClosureWithId), .with_closure_style(ClosureStyle::ClosureWithId),
d.actual d.actual
.display(ctx.sema.db, ctx.edition) .display(ctx.sema.db, ctx.display_target)
.with_closure_style(ClosureStyle::ClosureWithId), .with_closure_style(ClosureStyle::ClosureWithId),
), ),
display_range, display_range,
@ -306,8 +306,8 @@ fn str_ref_to_owned(
expr_ptr: &InFile<AstPtr<ast::Expr>>, expr_ptr: &InFile<AstPtr<ast::Expr>>,
acc: &mut Vec<Assist>, acc: &mut Vec<Assist>,
) -> Option<()> { ) -> Option<()> {
let expected = d.expected.display(ctx.sema.db, ctx.edition); let expected = d.expected.display(ctx.sema.db, ctx.display_target);
let actual = d.actual.display(ctx.sema.db, ctx.edition); let actual = d.actual.display(ctx.sema.db, ctx.display_target);
// FIXME do this properly // FIXME do this properly
if expected.to_string() != "String" || actual.to_string() != "&str" { if expected.to_string() != "String" || actual.to_string() != "&str" {

4
src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
View File

@ -27,7 +27,7 @@ pub(crate) fn typed_hole(ctx: &DiagnosticsContext<'_>, d: &hir::TypedHole) -> Di
format!( format!(
"invalid `_` expression, expected type `{}`", "invalid `_` expression, expected type `{}`",
d.expected d.expected
.display(ctx.sema.db, ctx.edition) .display(ctx.sema.db, ctx.display_target)
.with_closure_style(ClosureStyle::ClosureWithId), .with_closure_style(ClosureStyle::ClosureWithId),
), ),
fixes(ctx, d), fixes(ctx, d),
@ -72,7 +72,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::TypedHole) -> Option<Vec<Assist>
prefer_absolute: ctx.config.prefer_absolute, prefer_absolute: ctx.config.prefer_absolute,
allow_unstable: ctx.is_nightly, allow_unstable: ctx.is_nightly,
}, },
ctx.edition, ctx.display_target,
) )
.ok() .ok()
}) })

2
src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_field.rs
View File

@ -38,7 +38,7 @@ pub(crate) fn unresolved_field(
format!( format!(
"no field `{}` on type `{}`{method_suffix}", "no field `{}` on type `{}`{method_suffix}",
d.name.display(ctx.sema.db, ctx.edition), d.name.display(ctx.sema.db, ctx.edition),
d.receiver.display(ctx.sema.db, ctx.edition) d.receiver.display(ctx.sema.db, ctx.display_target)
), ),
adjusted_display_range(ctx, d.expr, &|expr| { adjusted_display_range(ctx, d.expr, &|expr| {
Some( Some(

4
src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_method.rs
View File

@ -31,7 +31,7 @@ pub(crate) fn unresolved_method(
format!( format!(
"no method `{}` on type `{}`{suffix}", "no method `{}` on type `{}`{suffix}",
d.name.display(ctx.sema.db, ctx.edition), d.name.display(ctx.sema.db, ctx.edition),
d.receiver.display(ctx.sema.db, ctx.edition) d.receiver.display(ctx.sema.db, ctx.display_target)
), ),
adjusted_display_range(ctx, d.expr, &|expr| { adjusted_display_range(ctx, d.expr, &|expr| {
Some( Some(
@ -152,7 +152,7 @@ fn assoc_func_fix(ctx: &DiagnosticsContext<'_>, d: &hir::UnresolvedMethodCall) -
receiver_type.as_adt()?.name(db).display_no_db(ctx.edition).to_smolstr(); receiver_type.as_adt()?.name(db).display_no_db(ctx.edition).to_smolstr();
let generic_parameters: Vec<SmolStr> = let generic_parameters: Vec<SmolStr> =
receiver_type.generic_parameters(db, ctx.edition).collect(); receiver_type.generic_parameters(db, ctx.display_target).collect();
// if receiver should be pass as first arg in the assoc func, // if receiver should be pass as first arg in the assoc func,
// we could omit generic parameters cause compiler can deduce it automatically // we could omit generic parameters cause compiler can deduce it automatically
if !need_to_take_receiver_as_first_arg && !generic_parameters.is_empty() { if !need_to_take_receiver_as_first_arg && !generic_parameters.is_empty() {

19
src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs
View File

@ -81,7 +81,10 @@ mod tests;
use std::{collections::hash_map, iter, sync::LazyLock}; use std::{collections::hash_map, iter, sync::LazyLock};
use either::Either; use either::Either;
use hir::{db::ExpandDatabase, diagnostics::AnyDiagnostic, Crate, HirFileId, InFile, Semantics}; use hir::{
db::ExpandDatabase, diagnostics::AnyDiagnostic, Crate, DisplayTarget, HirFileId, InFile,
Semantics,
};
use ide_db::{ use ide_db::{
assists::{Assist, AssistId, AssistKind, AssistResolveStrategy}, assists::{Assist, AssistId, AssistKind, AssistResolveStrategy},
base_db::{ReleaseChannel, SourceDatabase}, base_db::{ReleaseChannel, SourceDatabase},
@ -277,6 +280,7 @@ struct DiagnosticsContext<'a> {
sema: Semantics<'a, RootDatabase>, sema: Semantics<'a, RootDatabase>,
resolve: &'a AssistResolveStrategy, resolve: &'a AssistResolveStrategy,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
is_nightly: bool, is_nightly: bool,
} }
@ -374,7 +378,18 @@ pub fn semantic_diagnostics(
module.and_then(|m| db.toolchain_channel(m.krate().into())), module.and_then(|m| db.toolchain_channel(m.krate().into())),
Some(ReleaseChannel::Nightly) | None Some(ReleaseChannel::Nightly) | None
); );
let ctx = DiagnosticsContext { config, sema, resolve, edition: file_id.edition(), is_nightly }; let krate = module.map(|module| module.krate()).unwrap_or_else(|| {
(*db.crate_graph().crates_in_topological_order().last().unwrap()).into()
});
let display_target = krate.to_display_target(db);
let ctx = DiagnosticsContext {
config,
sema,
resolve,
edition: file_id.edition(),
is_nightly,
display_target,
};
let mut diags = Vec::new(); let mut diags = Vec::new();
match module { match module {

20
src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs
View File

@ -7,8 +7,7 @@ use crate::{
SsrMatches, SsrMatches,
}; };
use hir::{FileRange, ImportPathConfig, Semantics}; use hir::{FileRange, ImportPathConfig, Semantics};
use ide_db::FxHashMap; use ide_db::{base_db::SourceDatabase, FxHashMap};
use parser::Edition;
use std::{cell::Cell, iter::Peekable}; use std::{cell::Cell, iter::Peekable};
use syntax::{ use syntax::{
ast::{self, AstNode, AstToken, HasGenericArgs}, ast::{self, AstNode, AstToken, HasGenericArgs},
@ -627,22 +626,23 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
match_error!("Failed to get receiver type for `{}`", expr.syntax().text()) match_error!("Failed to get receiver type for `{}`", expr.syntax().text())
})? })?
.original; .original;
let edition = self let krate = self.sema.scope(expr.syntax()).map(|it| it.krate()).unwrap_or_else(|| {
.sema hir::Crate::from(
.scope(expr.syntax()) *self.sema.db.crate_graph().crates_in_topological_order().last().unwrap(),
.map(|it| it.krate().edition(self.sema.db)) )
.unwrap_or(Edition::CURRENT); });
// Temporary needed to make the borrow checker happy.
let res = code_type let res = code_type
.autoderef(self.sema.db) .autoderef(self.sema.db)
.enumerate() .enumerate()
.find(|(_, deref_code_type)| pattern_type == deref_code_type) .find(|(_, deref_code_type)| pattern_type == deref_code_type)
.map(|(count, _)| count) .map(|(count, _)| count)
.ok_or_else(|| { .ok_or_else(|| {
let display_target = krate.to_display_target(self.sema.db);
// Temporary needed to make the borrow checker happy.
match_error!( match_error!(
"Pattern type `{}` didn't match code type `{}`", "Pattern type `{}` didn't match code type `{}`",
pattern_type.display(self.sema.db, edition), pattern_type.display(self.sema.db, display_target),
code_type.display(self.sema.db, edition) code_type.display(self.sema.db, display_target)
) )
}); });
res res

54
src/tools/rust-analyzer/crates/ide/src/hover.rs
View File

@ -7,7 +7,8 @@ use std::{iter, ops::Not};
use either::Either; use either::Either;
use hir::{ use hir::{
db::DefDatabase, GenericDef, GenericSubstitution, HasCrate, HasSource, LangItem, Semantics, db::DefDatabase, DisplayTarget, GenericDef, GenericSubstitution, HasCrate, HasSource, LangItem,
Semantics,
}; };
use ide_db::{ use ide_db::{
defs::{Definition, IdentClass, NameRefClass, OperatorClass}, defs::{Definition, IdentClass, NameRefClass, OperatorClass},
@ -129,10 +130,18 @@ pub(crate) fn hover(
let file = sema.parse_guess_edition(file_id).syntax().clone(); let file = sema.parse_guess_edition(file_id).syntax().clone();
let edition = let edition =
sema.attach_first_edition(file_id).map(|it| it.edition()).unwrap_or(Edition::CURRENT); sema.attach_first_edition(file_id).map(|it| it.edition()).unwrap_or(Edition::CURRENT);
let display_target = sema.first_crate_or_default(file_id).to_display_target(db);
let mut res = if range.is_empty() { let mut res = if range.is_empty() {
hover_offset(sema, FilePosition { file_id, offset: range.start() }, file, config, edition) hover_offset(
sema,
FilePosition { file_id, offset: range.start() },
file,
config,
edition,
display_target,
)
} else { } else {
hover_ranged(sema, frange, file, config, edition) hover_ranged(sema, frange, file, config, edition, display_target)
}?; }?;
if let HoverDocFormat::PlainText = config.format { if let HoverDocFormat::PlainText = config.format {
@ -148,6 +157,7 @@ fn hover_offset(
file: SyntaxNode, file: SyntaxNode,
config: &HoverConfig, config: &HoverConfig,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<RangeInfo<HoverResult>> { ) -> Option<RangeInfo<HoverResult>> {
let original_token = pick_best_token(file.token_at_offset(offset), |kind| match kind { let original_token = pick_best_token(file.token_at_offset(offset), |kind| match kind {
IDENT IDENT
@ -169,8 +179,18 @@ fn hover_offset(
if let Some(doc_comment) = token_as_doc_comment(&original_token) { if let Some(doc_comment) = token_as_doc_comment(&original_token) {
cov_mark::hit!(no_highlight_on_comment_hover); cov_mark::hit!(no_highlight_on_comment_hover);
return doc_comment.get_definition_with_descend_at(sema, offset, |def, node, range| { return doc_comment.get_definition_with_descend_at(sema, offset, |def, node, range| {
let res = let res = hover_for_definition(
hover_for_definition(sema, file_id, def, None, &node, None, false, config, edition); sema,
file_id,
def,
None,
&node,
None,
false,
config,
edition,
display_target,
);
Some(RangeInfo::new(range, res)) Some(RangeInfo::new(range, res))
}); });
} }
@ -188,6 +208,7 @@ fn hover_offset(
false, false,
config, config,
edition, edition,
display_target,
); );
return Some(RangeInfo::new(range, res)); return Some(RangeInfo::new(range, res));
} }
@ -277,6 +298,7 @@ fn hover_offset(
hovered_definition, hovered_definition,
config, config,
edition, edition,
display_target,
) )
}) })
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
@ -286,12 +308,12 @@ fn hover_offset(
res.extend(definitions); res.extend(definitions);
continue; continue;
} }
let keywords = || render::keyword(sema, config, &token, edition); let keywords = || render::keyword(sema, config, &token, edition, display_target);
let underscore = || { let underscore = || {
if !is_same_kind { if !is_same_kind {
return None; return None;
} }
render::underscore(sema, config, &token, edition) render::underscore(sema, config, &token, edition, display_target)
}; };
let rest_pat = || { let rest_pat = || {
if !is_same_kind || token.kind() != DOT2 { if !is_same_kind || token.kind() != DOT2 {
@ -305,7 +327,7 @@ fn hover_offset(
let record_pat = let record_pat =
record_pat_field_list.syntax().parent().and_then(ast::RecordPat::cast)?; record_pat_field_list.syntax().parent().and_then(ast::RecordPat::cast)?;
Some(render::struct_rest_pat(sema, config, &record_pat, edition)) Some(render::struct_rest_pat(sema, config, &record_pat, edition, display_target))
}; };
let call = || { let call = || {
if !is_same_kind || token.kind() != T!['('] && token.kind() != T![')'] { if !is_same_kind || token.kind() != T!['('] && token.kind() != T![')'] {
@ -319,17 +341,17 @@ fn hover_offset(
_ => return None, _ => return None,
} }
}; };
render::type_info_of(sema, config, &Either::Left(call_expr), edition) render::type_info_of(sema, config, &Either::Left(call_expr), edition, display_target)
}; };
let closure = || { let closure = || {
if !is_same_kind || token.kind() != T![|] { if !is_same_kind || token.kind() != T![|] {
return None; return None;
} }
let c = token.parent().and_then(|x| x.parent()).and_then(ast::ClosureExpr::cast)?; let c = token.parent().and_then(|x| x.parent()).and_then(ast::ClosureExpr::cast)?;
render::closure_expr(sema, config, c, edition) render::closure_expr(sema, config, c, edition, display_target)
}; };
let literal = || { let literal = || {
render::literal(sema, original_token.clone(), edition) render::literal(sema, original_token.clone(), display_target)
.map(|markup| HoverResult { markup, actions: vec![] }) .map(|markup| HoverResult { markup, actions: vec![] })
}; };
if let Some(result) = keywords() if let Some(result) = keywords()
@ -362,6 +384,7 @@ fn hover_ranged(
file: SyntaxNode, file: SyntaxNode,
config: &HoverConfig, config: &HoverConfig,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<RangeInfo<HoverResult>> { ) -> Option<RangeInfo<HoverResult>> {
// FIXME: make this work in attributes // FIXME: make this work in attributes
let expr_or_pat = file let expr_or_pat = file
@ -371,16 +394,17 @@ fn hover_ranged(
.find_map(Either::<ast::Expr, ast::Pat>::cast)?; .find_map(Either::<ast::Expr, ast::Pat>::cast)?;
let res = match &expr_or_pat { let res = match &expr_or_pat {
Either::Left(ast::Expr::TryExpr(try_expr)) => { Either::Left(ast::Expr::TryExpr(try_expr)) => {
render::try_expr(sema, config, try_expr, edition) render::try_expr(sema, config, try_expr, edition, display_target)
} }
Either::Left(ast::Expr::PrefixExpr(prefix_expr)) Either::Left(ast::Expr::PrefixExpr(prefix_expr))
if prefix_expr.op_kind() == Some(ast::UnaryOp::Deref) => if prefix_expr.op_kind() == Some(ast::UnaryOp::Deref) =>
{ {
render::deref_expr(sema, config, prefix_expr, edition) render::deref_expr(sema, config, prefix_expr, edition, display_target)
} }
_ => None, _ => None,
}; };
let res = res.or_else(|| render::type_info_of(sema, config, &expr_or_pat, edition)); let res =
res.or_else(|| render::type_info_of(sema, config, &expr_or_pat, edition, display_target));
res.map(|it| { res.map(|it| {
let range = match expr_or_pat { let range = match expr_or_pat {
Either::Left(it) => it.syntax().text_range(), Either::Left(it) => it.syntax().text_range(),
@ -401,6 +425,7 @@ pub(crate) fn hover_for_definition(
hovered_definition: bool, hovered_definition: bool,
config: &HoverConfig, config: &HoverConfig,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> HoverResult { ) -> HoverResult {
let famous_defs = match &def { let famous_defs = match &def {
Definition::BuiltinType(_) => sema.scope(scope_node).map(|it| FamousDefs(sema, it.krate())), Definition::BuiltinType(_) => sema.scope(scope_node).map(|it| FamousDefs(sema, it.krate())),
@ -435,6 +460,7 @@ pub(crate) fn hover_for_definition(
subst_types.as_ref(), subst_types.as_ref(),
config, config,
edition, edition,
display_target,
); );
HoverResult { HoverResult {
markup: render::process_markup(sema.db, def, &markup, config), markup: render::process_markup(sema.db, def, &markup, config),

124
src/tools/rust-analyzer/crates/ide/src/hover/render.rs
View File

@ -3,7 +3,7 @@ use std::{env, mem, ops::Not};
use either::Either; use either::Either;
use hir::{ use hir::{
db::ExpandDatabase, Adt, AsAssocItem, AsExternAssocItem, CaptureKind, DropGlue, db::ExpandDatabase, Adt, AsAssocItem, AsExternAssocItem, CaptureKind, DisplayTarget, DropGlue,
DynCompatibilityViolation, HasCrate, HasSource, HirDisplay, Layout, LayoutError, DynCompatibilityViolation, HasCrate, HasSource, HirDisplay, Layout, LayoutError,
MethodViolationCode, Name, Semantics, Symbol, Trait, Type, TypeInfo, VariantDef, MethodViolationCode, Name, Semantics, Symbol, Trait, Type, TypeInfo, VariantDef,
}; };
@ -38,12 +38,13 @@ pub(super) fn type_info_of(
_config: &HoverConfig, _config: &HoverConfig,
expr_or_pat: &Either<ast::Expr, ast::Pat>, expr_or_pat: &Either<ast::Expr, ast::Pat>,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<HoverResult> { ) -> Option<HoverResult> {
let ty_info = match expr_or_pat { let ty_info = match expr_or_pat {
Either::Left(expr) => sema.type_of_expr(expr)?, Either::Left(expr) => sema.type_of_expr(expr)?,
Either::Right(pat) => sema.type_of_pat(pat)?, Either::Right(pat) => sema.type_of_pat(pat)?,
}; };
type_info(sema, _config, ty_info, edition) type_info(sema, _config, ty_info, edition, display_target)
} }
pub(super) fn closure_expr( pub(super) fn closure_expr(
@ -51,9 +52,10 @@ pub(super) fn closure_expr(
config: &HoverConfig, config: &HoverConfig,
c: ast::ClosureExpr, c: ast::ClosureExpr,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<HoverResult> { ) -> Option<HoverResult> {
let TypeInfo { original, .. } = sema.type_of_expr(&c.into())?; let TypeInfo { original, .. } = sema.type_of_expr(&c.into())?;
closure_ty(sema, config, &TypeInfo { original, adjusted: None }, edition) closure_ty(sema, config, &TypeInfo { original, adjusted: None }, edition, display_target)
} }
pub(super) fn try_expr( pub(super) fn try_expr(
@ -61,6 +63,7 @@ pub(super) fn try_expr(
_config: &HoverConfig, _config: &HoverConfig,
try_expr: &ast::TryExpr, try_expr: &ast::TryExpr,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<HoverResult> { ) -> Option<HoverResult> {
let inner_ty = sema.type_of_expr(&try_expr.expr()?)?.original; let inner_ty = sema.type_of_expr(&try_expr.expr()?)?.original;
let mut ancestors = try_expr.syntax().ancestors(); let mut ancestors = try_expr.syntax().ancestors();
@ -127,8 +130,8 @@ pub(super) fn try_expr(
res.actions.push(actions); res.actions.push(actions);
} }
let inner_ty = inner_ty.display(sema.db, edition).to_string(); let inner_ty = inner_ty.display(sema.db, display_target).to_string();
let body_ty = body_ty.display(sema.db, edition).to_string(); let body_ty = body_ty.display(sema.db, display_target).to_string();
let ty_len_max = inner_ty.len().max(body_ty.len()); let ty_len_max = inner_ty.len().max(body_ty.len());
let l = "Propagated as: ".len() - " Type: ".len(); let l = "Propagated as: ".len() - " Type: ".len();
@ -153,6 +156,7 @@ pub(super) fn deref_expr(
_config: &HoverConfig, _config: &HoverConfig,
deref_expr: &ast::PrefixExpr, deref_expr: &ast::PrefixExpr,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<HoverResult> { ) -> Option<HoverResult> {
let inner_ty = sema.type_of_expr(&deref_expr.expr()?)?.original; let inner_ty = sema.type_of_expr(&deref_expr.expr()?)?.original;
let TypeInfo { original, adjusted } = let TypeInfo { original, adjusted } =
@ -170,9 +174,9 @@ pub(super) fn deref_expr(
res.markup = if let Some(adjusted_ty) = adjusted { res.markup = if let Some(adjusted_ty) = adjusted {
walk_and_push_ty(sema.db, &adjusted_ty, &mut push_new_def); walk_and_push_ty(sema.db, &adjusted_ty, &mut push_new_def);
let original = original.display(sema.db, edition).to_string(); let original = original.display(sema.db, display_target).to_string();
let adjusted = adjusted_ty.display(sema.db, edition).to_string(); let adjusted = adjusted_ty.display(sema.db, display_target).to_string();
let inner = inner_ty.display(sema.db, edition).to_string(); let inner = inner_ty.display(sema.db, display_target).to_string();
let type_len = "To type: ".len(); let type_len = "To type: ".len();
let coerced_len = "Coerced to: ".len(); let coerced_len = "Coerced to: ".len();
let deref_len = "Dereferenced from: ".len(); let deref_len = "Dereferenced from: ".len();
@ -190,8 +194,8 @@ pub(super) fn deref_expr(
) )
.into() .into()
} else { } else {
let original = original.display(sema.db, edition).to_string(); let original = original.display(sema.db, display_target).to_string();
let inner = inner_ty.display(sema.db, edition).to_string(); let inner = inner_ty.display(sema.db, display_target).to_string();
let type_len = "To type: ".len(); let type_len = "To type: ".len();
let deref_len = "Dereferenced from: ".len(); let deref_len = "Dereferenced from: ".len();
let max_len = (original.len() + type_len).max(inner.len() + deref_len); let max_len = (original.len() + type_len).max(inner.len() + deref_len);
@ -216,6 +220,7 @@ pub(super) fn underscore(
config: &HoverConfig, config: &HoverConfig,
token: &SyntaxToken, token: &SyntaxToken,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<HoverResult> { ) -> Option<HoverResult> {
if token.kind() != T![_] { if token.kind() != T![_] {
return None; return None;
@ -224,8 +229,8 @@ pub(super) fn underscore(
let _it = match_ast! { let _it = match_ast! {
match parent { match parent {
ast::InferType(it) => it, ast::InferType(it) => it,
ast::UnderscoreExpr(it) => return type_info_of(sema, config, &Either::Left(ast::Expr::UnderscoreExpr(it)),edition), ast::UnderscoreExpr(it) => return type_info_of(sema, config, &Either::Left(ast::Expr::UnderscoreExpr(it)),edition, display_target),
ast::WildcardPat(it) => return type_info_of(sema, config, &Either::Right(ast::Pat::WildcardPat(it)),edition), ast::WildcardPat(it) => return type_info_of(sema, config, &Either::Right(ast::Pat::WildcardPat(it)),edition, display_target),
_ => return None, _ => return None,
} }
}; };
@ -259,6 +264,7 @@ pub(super) fn keyword(
config: &HoverConfig, config: &HoverConfig,
token: &SyntaxToken, token: &SyntaxToken,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<HoverResult> { ) -> Option<HoverResult> {
if !token.kind().is_keyword(edition) || !config.documentation || !config.keywords { if !token.kind().is_keyword(edition) || !config.documentation || !config.keywords {
return None; return None;
@ -267,7 +273,7 @@ pub(super) fn keyword(
let famous_defs = FamousDefs(sema, sema.scope(&parent)?.krate()); let famous_defs = FamousDefs(sema, sema.scope(&parent)?.krate());
let KeywordHint { description, keyword_mod, actions } = let KeywordHint { description, keyword_mod, actions } =
keyword_hints(sema, token, parent, edition); keyword_hints(sema, token, parent, edition, display_target);
let doc_owner = find_std_module(&famous_defs, &keyword_mod, edition)?; let doc_owner = find_std_module(&famous_defs, &keyword_mod, edition)?;
let docs = doc_owner.docs(sema.db)?; let docs = doc_owner.docs(sema.db)?;
@ -288,6 +294,7 @@ pub(super) fn struct_rest_pat(
_config: &HoverConfig, _config: &HoverConfig,
pattern: &ast::RecordPat, pattern: &ast::RecordPat,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> HoverResult { ) -> HoverResult {
let missing_fields = sema.record_pattern_missing_fields(pattern); let missing_fields = sema.record_pattern_missing_fields(pattern);
@ -309,7 +316,7 @@ pub(super) fn struct_rest_pat(
res.markup = { res.markup = {
let mut s = String::from(".., "); let mut s = String::from(".., ");
for (f, _) in &missing_fields { for (f, _) in &missing_fields {
s += f.display(sema.db, edition).to_string().as_ref(); s += f.display(sema.db, display_target).to_string().as_ref();
s += ", "; s += ", ";
} }
// get rid of trailing comma // get rid of trailing comma
@ -479,41 +486,44 @@ pub(super) fn definition(
subst_types: Option<&Vec<(Symbol, Type)>>, subst_types: Option<&Vec<(Symbol, Type)>>,
config: &HoverConfig, config: &HoverConfig,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Markup { ) -> Markup {
let mod_path = definition_path(db, &def, edition); let mod_path = definition_path(db, &def, edition);
let label = match def { let label = match def {
Definition::Trait(trait_) => { Definition::Trait(trait_) => trait_
trait_.display_limited(db, config.max_trait_assoc_items_count, edition).to_string() .display_limited(db, config.max_trait_assoc_items_count, display_target)
} .to_string(),
Definition::Adt(adt @ (Adt::Struct(_) | Adt::Union(_))) => { Definition::Adt(adt @ (Adt::Struct(_) | Adt::Union(_))) => {
adt.display_limited(db, config.max_fields_count, edition).to_string() adt.display_limited(db, config.max_fields_count, display_target).to_string()
} }
Definition::Variant(variant) => { Definition::Variant(variant) => {
variant.display_limited(db, config.max_fields_count, edition).to_string() variant.display_limited(db, config.max_fields_count, display_target).to_string()
} }
Definition::Adt(adt @ Adt::Enum(_)) => { Definition::Adt(adt @ Adt::Enum(_)) => {
adt.display_limited(db, config.max_enum_variants_count, edition).to_string() adt.display_limited(db, config.max_enum_variants_count, display_target).to_string()
} }
Definition::SelfType(impl_def) => { Definition::SelfType(impl_def) => {
let self_ty = &impl_def.self_ty(db); let self_ty = &impl_def.self_ty(db);
match self_ty.as_adt() { match self_ty.as_adt() {
Some(adt) => adt.display_limited(db, config.max_fields_count, edition).to_string(), Some(adt) => {
None => self_ty.display(db, edition).to_string(), adt.display_limited(db, config.max_fields_count, display_target).to_string()
}
None => self_ty.display(db, display_target).to_string(),
} }
} }
Definition::Macro(it) => { Definition::Macro(it) => {
let mut label = it.display(db, edition).to_string(); let mut label = it.display(db, display_target).to_string();
if let Some(macro_arm) = macro_arm { if let Some(macro_arm) = macro_arm {
format_to!(label, " // matched arm #{}", macro_arm); format_to!(label, " // matched arm #{}", macro_arm);
} }
label label
} }
Definition::Function(fn_) => { Definition::Function(fn_) => {
fn_.display_with_container_bounds(db, true, edition).to_string() fn_.display_with_container_bounds(db, true, display_target).to_string()
} }
_ => def.label(db, edition), _ => def.label(db, display_target),
}; };
let docs = def.docs(db, famous_defs, edition); let docs = def.docs(db, famous_defs, display_target);
let value = || match def { let value = || match def {
Definition::Variant(it) => { Definition::Variant(it) => {
if !it.parent_enum(db).is_data_carrying(db) { if !it.parent_enum(db).is_data_carrying(db) {
@ -525,7 +535,10 @@ pub(super) fn definition(
let res = it.value(db).map(|it| format!("{it:?}")); let res = it.value(db).map(|it| format!("{it:?}"));
if env::var_os("RA_DEV").is_some() { if env::var_os("RA_DEV").is_some() {
let res = res.as_deref().unwrap_or(""); let res = res.as_deref().unwrap_or("");
Some(format!("{res} ({})", render_const_eval_error(db, err, edition))) Some(format!(
"{res} ({})",
render_const_eval_error(db, err, display_target)
))
} else { } else {
res res
} }
@ -541,9 +554,12 @@ pub(super) fn definition(
Ok(it) => match it.render_debug(db) { Ok(it) => match it.render_debug(db) {
Ok(it) => it, Ok(it) => it,
Err(err) => { Err(err) => {
let it = it.render(db, edition); let it = it.render(db, display_target);
if env::var_os("RA_DEV").is_some() { if env::var_os("RA_DEV").is_some() {
format!("{it}\n{}", render_const_eval_error(db, err.into(), edition)) format!(
"{it}\n{}",
render_const_eval_error(db, err.into(), display_target)
)
} else { } else {
it it
} }
@ -557,7 +573,7 @@ pub(super) fn definition(
body = prettify_macro_expansion(db, body, &span_map, it.krate(db).into()); body = prettify_macro_expansion(db, body, &span_map, it.krate(db).into());
} }
if env::var_os("RA_DEV").is_some() { if env::var_os("RA_DEV").is_some() {
format!("{body}\n{}", render_const_eval_error(db, err, edition)) format!("{body}\n{}", render_const_eval_error(db, err, display_target))
} else { } else {
body.to_string() body.to_string()
} }
@ -570,9 +586,12 @@ pub(super) fn definition(
Ok(it) => match it.render_debug(db) { Ok(it) => match it.render_debug(db) {
Ok(it) => it, Ok(it) => it,
Err(err) => { Err(err) => {
let it = it.render(db, edition); let it = it.render(db, display_target);
if env::var_os("RA_DEV").is_some() { if env::var_os("RA_DEV").is_some() {
format!("{it}\n{}", render_const_eval_error(db, err.into(), edition)) format!(
"{it}\n{}",
render_const_eval_error(db, err.into(), display_target)
)
} else { } else {
it it
} }
@ -586,7 +605,7 @@ pub(super) fn definition(
body = prettify_macro_expansion(db, body, &span_map, it.krate(db).into()); body = prettify_macro_expansion(db, body, &span_map, it.krate(db).into());
} }
if env::var_os("RA_DEV").is_some() { if env::var_os("RA_DEV").is_some() {
format!("{body}\n{}", render_const_eval_error(db, err, edition)) format!("{body}\n{}", render_const_eval_error(db, err, display_target))
} else { } else {
body.to_string() body.to_string()
} }
@ -728,7 +747,9 @@ pub(super) fn definition(
let mut extra = String::new(); let mut extra = String::new();
if hovered_definition { if hovered_definition {
if let Some(notable_traits) = render_notable_trait(db, notable_traits, edition) { if let Some(notable_traits) =
render_notable_trait(db, notable_traits, edition, display_target)
{
extra.push_str("\n___\n"); extra.push_str("\n___\n");
extra.push_str(&notable_traits); extra.push_str(&notable_traits);
} }
@ -772,7 +793,7 @@ pub(super) fn definition(
.format_with(", ", |(name, ty), fmt| { .format_with(", ", |(name, ty), fmt| {
fmt(&format_args!( fmt(&format_args!(
"`{name}` = `{}`", "`{name}` = `{}`",
ty.display_truncated(db, limit, edition) ty.display_truncated(db, limit, display_target)
)) ))
}) })
.to_string() .to_string()
@ -799,7 +820,7 @@ struct DropInfo {
pub(super) fn literal( pub(super) fn literal(
sema: &Semantics<'_, RootDatabase>, sema: &Semantics<'_, RootDatabase>,
token: SyntaxToken, token: SyntaxToken,
edition: Edition, display_target: DisplayTarget,
) -> Option<Markup> { ) -> Option<Markup> {
let lit = token.parent().and_then(ast::Literal::cast)?; let lit = token.parent().and_then(ast::Literal::cast)?;
let ty = if let Some(p) = lit.syntax().parent().and_then(ast::Pat::cast) { let ty = if let Some(p) = lit.syntax().parent().and_then(ast::Pat::cast) {
@ -847,7 +868,7 @@ pub(super) fn literal(
_ => return None _ => return None
} }
}; };
let ty = ty.display(sema.db, edition); let ty = ty.display(sema.db, display_target);
let mut s = format!("```rust\n{ty}\n```\n___\n\n"); let mut s = format!("```rust\n{ty}\n```\n___\n\n");
match value { match value {
@ -879,6 +900,7 @@ fn render_notable_trait(
db: &RootDatabase, db: &RootDatabase,
notable_traits: &[(Trait, Vec<(Option<Type>, Name)>)], notable_traits: &[(Trait, Vec<(Option<Type>, Name)>)],
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<String> { ) -> Option<String> {
let mut desc = String::new(); let mut desc = String::new();
let mut needs_impl_header = true; let mut needs_impl_header = true;
@ -898,7 +920,7 @@ fn render_notable_trait(
f(&name.display(db, edition))?; f(&name.display(db, edition))?;
f(&" = ")?; f(&" = ")?;
match ty { match ty {
Some(ty) => f(&ty.display(db, edition)), Some(ty) => f(&ty.display(db, display_target)),
None => f(&"?"), None => f(&"?"),
} }
}) })
@ -914,8 +936,9 @@ fn type_info(
config: &HoverConfig, config: &HoverConfig,
ty: TypeInfo, ty: TypeInfo,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<HoverResult> { ) -> Option<HoverResult> {
if let Some(res) = closure_ty(sema, config, &ty, edition) { if let Some(res) = closure_ty(sema, config, &ty, edition, display_target) {
return Some(res); return Some(res);
}; };
let db = sema.db; let db = sema.db;
@ -951,7 +974,7 @@ fn type_info(
f(&name.display(db, edition))?; f(&name.display(db, edition))?;
f(&" = ")?; f(&" = ")?;
match ty { match ty {
Some(ty) => f(&ty.display(db, edition)), Some(ty) => f(&ty.display(db, display_target)),
None => f(&"?"), None => f(&"?"),
} }
}) })
@ -965,8 +988,8 @@ fn type_info(
desc desc
}; };
let original = original.display(db, edition).to_string(); let original = original.display(db, display_target).to_string();
let adjusted = adjusted_ty.display(db, edition).to_string(); let adjusted = adjusted_ty.display(db, display_target).to_string();
let static_text_diff_len = "Coerced to: ".len() - "Type: ".len(); let static_text_diff_len = "Coerced to: ".len() - "Type: ".len();
format!( format!(
"```text\nType: {:>apad$}\nCoerced to: {:>opad$}\n{notable}```\n", "```text\nType: {:>apad$}\nCoerced to: {:>opad$}\n{notable}```\n",
@ -977,8 +1000,10 @@ fn type_info(
) )
.into() .into()
} else { } else {
let mut desc = format!("```rust\n{}\n```", original.display(db, edition)); let mut desc = format!("```rust\n{}\n```", original.display(db, display_target));
if let Some(extra) = render_notable_trait(db, &notable_traits(db, &original), edition) { if let Some(extra) =
render_notable_trait(db, &notable_traits(db, &original), edition, display_target)
{
desc.push_str("\n___\n"); desc.push_str("\n___\n");
desc.push_str(&extra); desc.push_str(&extra);
}; };
@ -995,6 +1020,7 @@ fn closure_ty(
config: &HoverConfig, config: &HoverConfig,
TypeInfo { original, adjusted }: &TypeInfo, TypeInfo { original, adjusted }: &TypeInfo,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> Option<HoverResult> { ) -> Option<HoverResult> {
let c = original.as_closure()?; let c = original.as_closure()?;
let mut captures_rendered = c.captured_items(sema.db) let mut captures_rendered = c.captured_items(sema.db)
@ -1027,12 +1053,14 @@ fn closure_ty(
walk_and_push_ty(sema.db, adjusted_ty, &mut push_new_def); walk_and_push_ty(sema.db, adjusted_ty, &mut push_new_def);
format!( format!(
"\nCoerced to: {}", "\nCoerced to: {}",
adjusted_ty.display(sema.db, edition).with_closure_style(hir::ClosureStyle::ImplFn) adjusted_ty
.display(sema.db, display_target)
.with_closure_style(hir::ClosureStyle::ImplFn)
) )
} else { } else {
String::new() String::new()
}; };
let mut markup = format!("```rust\n{}\n```", c.display_with_impl(sema.db, edition)); let mut markup = format!("```rust\n{}\n```", c.display_with_impl(sema.db, display_target));
if let Some(trait_) = c.fn_trait(sema.db).get_id(sema.db, original.krate(sema.db).into()) { if let Some(trait_) = c.fn_trait(sema.db).get_id(sema.db, original.krate(sema.db).into()) {
push_new_def(hir::Trait::from(trait_).into()) push_new_def(hir::Trait::from(trait_).into())
@ -1213,6 +1241,7 @@ fn keyword_hints(
token: &SyntaxToken, token: &SyntaxToken,
parent: syntax::SyntaxNode, parent: syntax::SyntaxNode,
edition: Edition, edition: Edition,
display_target: DisplayTarget,
) -> KeywordHint { ) -> KeywordHint {
match token.kind() { match token.kind() {
T![await] | T![loop] | T![match] | T![unsafe] | T![as] | T![try] | T![if] | T![else] => { T![await] | T![loop] | T![match] | T![unsafe] | T![as] | T![try] | T![if] | T![else] => {
@ -1230,7 +1259,8 @@ fn keyword_hints(
walk_and_push_ty(sema.db, &ty.original, &mut push_new_def); walk_and_push_ty(sema.db, &ty.original, &mut push_new_def);
let ty = ty.adjusted(); let ty = ty.adjusted();
let description = format!("{}: {}", token.text(), ty.display(sema.db, edition)); let description =
format!("{}: {}", token.text(), ty.display(sema.db, display_target));
KeywordHint { KeywordHint {
description, description,

39
src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
View File

@ -10947,3 +10947,42 @@ pub struct ManuallyDrop$0<T: ?Sized> {
"#]], "#]],
); );
} }
#[test]
fn projection_const() {
// This uses two crates, which have *no* relation between them, to test another thing:
// `render_const_scalar()` used to just use the last crate for the trait env, which will
// fail in this scenario.
check(
r#"
//- /foo.rs crate:foo
pub trait PublicFlags {
type Internal;
}
pub struct NoteDialects(<NoteDialects as PublicFlags>::Internal);
impl NoteDialects {
pub const CLAP$0: Self = Self(InternalBitFlags);
}
pub struct InternalBitFlags;
impl PublicFlags for NoteDialects {
type Internal = InternalBitFlags;
}
//- /bar.rs crate:bar
"#,
expect![[r#"
*CLAP*
```rust
foo::NoteDialects
```
```rust
pub const CLAP: Self = NoteDialects(InternalBitFlags)
```
"#]],
);
}

28
src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
View File

@ -5,14 +5,14 @@ use std::{
use either::Either; use either::Either;
use hir::{ use hir::{
sym, ClosureStyle, HasVisibility, HirDisplay, HirDisplayError, HirWrite, ModuleDef, sym, ClosureStyle, DisplayTarget, HasVisibility, HirDisplay, HirDisplayError, HirWrite,
ModuleDefId, Semantics, ModuleDef, ModuleDefId, Semantics,
}; };
use ide_db::{famous_defs::FamousDefs, FileRange, RootDatabase}; use ide_db::{famous_defs::FamousDefs, FileRange, RootDatabase};
use ide_db::{text_edit::TextEdit, FxHashSet}; use ide_db::{text_edit::TextEdit, FxHashSet};
use itertools::Itertools; use itertools::Itertools;
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
use span::{Edition, EditionedFileId}; use span::EditionedFileId;
use stdx::never; use stdx::never;
use syntax::{ use syntax::{
ast::{self, AstNode, HasGenericParams}, ast::{self, AstNode, HasGenericParams},
@ -207,7 +207,8 @@ fn hints(
file_id: EditionedFileId, file_id: EditionedFileId,
node: SyntaxNode, node: SyntaxNode,
) { ) {
closing_brace::hints(hints, sema, config, file_id, node.clone()); let display_target = sema.first_crate_or_default(file_id.file_id()).to_display_target(sema.db);
closing_brace::hints(hints, sema, config, file_id, display_target, node.clone());
if let Some(any_has_generic_args) = ast::AnyHasGenericArgs::cast(node.clone()) { if let Some(any_has_generic_args) = ast::AnyHasGenericArgs::cast(node.clone()) {
generic_param::hints(hints, famous_defs, config, any_has_generic_args); generic_param::hints(hints, famous_defs, config, any_has_generic_args);
} }
@ -215,8 +216,8 @@ fn hints(
match_ast! { match_ast! {
match node { match node {
ast::Expr(expr) => { ast::Expr(expr) => {
chaining::hints(hints, famous_defs, config, file_id, &expr); chaining::hints(hints, famous_defs, config, display_target, &expr);
adjustment::hints(hints, famous_defs, config, file_id, &expr); adjustment::hints(hints, famous_defs, config, display_target, &expr);
match expr { match expr {
ast::Expr::CallExpr(it) => param_name::hints(hints, famous_defs, config, file_id, ast::Expr::from(it)), ast::Expr::CallExpr(it) => param_name::hints(hints, famous_defs, config, file_id, ast::Expr::from(it)),
ast::Expr::MethodCallExpr(it) => { ast::Expr::MethodCallExpr(it) => {
@ -224,7 +225,7 @@ fn hints(
} }
ast::Expr::ClosureExpr(it) => { ast::Expr::ClosureExpr(it) => {
closure_captures::hints(hints, famous_defs, config, file_id, it.clone()); closure_captures::hints(hints, famous_defs, config, file_id, it.clone());
closure_ret::hints(hints, famous_defs, config, file_id, it) closure_ret::hints(hints, famous_defs, config, display_target, it)
}, },
ast::Expr::RangeExpr(it) => range_exclusive::hints(hints, famous_defs, config, file_id, it), ast::Expr::RangeExpr(it) => range_exclusive::hints(hints, famous_defs, config, file_id, it),
_ => Some(()), _ => Some(()),
@ -234,7 +235,7 @@ fn hints(
binding_mode::hints(hints, famous_defs, config, file_id, &it); binding_mode::hints(hints, famous_defs, config, file_id, &it);
match it { match it {
ast::Pat::IdentPat(it) => { ast::Pat::IdentPat(it) => {
bind_pat::hints(hints, famous_defs, config, file_id, &it); bind_pat::hints(hints, famous_defs, config, display_target, &it);
} }
ast::Pat::RangePat(it) => { ast::Pat::RangePat(it) => {
range_exclusive::hints(hints, famous_defs, config, file_id, it); range_exclusive::hints(hints, famous_defs, config, file_id, it);
@ -704,7 +705,7 @@ fn label_of_ty(
famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>, famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>,
config: &InlayHintsConfig, config: &InlayHintsConfig,
ty: &hir::Type, ty: &hir::Type,
edition: Edition, display_target: DisplayTarget,
) -> Option<InlayHintLabel> { ) -> Option<InlayHintLabel> {
fn rec( fn rec(
sema: &Semantics<'_, RootDatabase>, sema: &Semantics<'_, RootDatabase>,
@ -713,7 +714,7 @@ fn label_of_ty(
ty: &hir::Type, ty: &hir::Type,
label_builder: &mut InlayHintLabelBuilder<'_>, label_builder: &mut InlayHintLabelBuilder<'_>,
config: &InlayHintsConfig, config: &InlayHintsConfig,
edition: Edition, display_target: DisplayTarget,
) -> Result<(), HirDisplayError> { ) -> Result<(), HirDisplayError> {
let iter_item_type = hint_iterator(sema, famous_defs, ty); let iter_item_type = hint_iterator(sema, famous_defs, ty);
match iter_item_type { match iter_item_type {
@ -744,12 +745,12 @@ fn label_of_ty(
label_builder.write_str(LABEL_ITEM)?; label_builder.write_str(LABEL_ITEM)?;
label_builder.end_location_link(); label_builder.end_location_link();
label_builder.write_str(LABEL_MIDDLE2)?; label_builder.write_str(LABEL_MIDDLE2)?;
rec(sema, famous_defs, max_length, &ty, label_builder, config, edition)?; rec(sema, famous_defs, max_length, &ty, label_builder, config, display_target)?;
label_builder.write_str(LABEL_END)?; label_builder.write_str(LABEL_END)?;
Ok(()) Ok(())
} }
None => ty None => ty
.display_truncated(sema.db, max_length, edition) .display_truncated(sema.db, max_length, display_target)
.with_closure_style(config.closure_style) .with_closure_style(config.closure_style)
.write_to(label_builder), .write_to(label_builder),
} }
@ -762,7 +763,8 @@ fn label_of_ty(
result: InlayHintLabel::default(), result: InlayHintLabel::default(),
resolve: config.fields_to_resolve.resolve_label_location, resolve: config.fields_to_resolve.resolve_label_location,
}; };
let _ = rec(sema, famous_defs, config.max_length, ty, &mut label_builder, config, edition); let _ =
rec(sema, famous_defs, config.max_length, ty, &mut label_builder, config, display_target);
let r = label_builder.finish(); let r = label_builder.finish();
Some(r) Some(r)
} }

10
src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
View File

@ -7,12 +7,12 @@ use std::ops::Not;
use either::Either; use either::Either;
use hir::{ use hir::{
Adjust, Adjustment, AutoBorrow, HirDisplay, Mutability, OverloadedDeref, PointerCast, Safety, Adjust, Adjustment, AutoBorrow, DisplayTarget, HirDisplay, Mutability, OverloadedDeref,
PointerCast, Safety,
}; };
use ide_db::famous_defs::FamousDefs; use ide_db::famous_defs::FamousDefs;
use ide_db::text_edit::TextEditBuilder; use ide_db::text_edit::TextEditBuilder;
use span::EditionedFileId;
use syntax::ast::{self, prec::ExprPrecedence, AstNode}; use syntax::ast::{self, prec::ExprPrecedence, AstNode};
use crate::{ use crate::{
@ -24,7 +24,7 @@ pub(super) fn hints(
acc: &mut Vec<InlayHint>, acc: &mut Vec<InlayHint>,
FamousDefs(sema, _): &FamousDefs<'_, '_>, FamousDefs(sema, _): &FamousDefs<'_, '_>,
config: &InlayHintsConfig, config: &InlayHintsConfig,
file_id: EditionedFileId, display_target: DisplayTarget,
expr: &ast::Expr, expr: &ast::Expr,
) -> Option<()> { ) -> Option<()> {
if config.adjustment_hints_hide_outside_unsafe && !sema.is_inside_unsafe(expr) { if config.adjustment_hints_hide_outside_unsafe && !sema.is_inside_unsafe(expr) {
@ -163,8 +163,8 @@ pub(super) fn hints(
tooltip: Some(config.lazy_tooltip(|| { tooltip: Some(config.lazy_tooltip(|| {
InlayTooltip::Markdown(format!( InlayTooltip::Markdown(format!(
"`{}` → `{}` ({coercion} coercion)", "`{}` → `{}` ({coercion} coercion)",
source.display(sema.db, file_id.edition()), source.display(sema.db, display_target),
target.display(sema.db, file_id.edition()), target.display(sema.db, display_target),
)) ))
})), })),
}; };

7
src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
View File

@ -3,11 +3,10 @@
//! fn f(a: i32, b: i32) -> i32 { a + b } //! fn f(a: i32, b: i32) -> i32 { a + b }
//! let _x /* i32 */= f(4, 4); //! let _x /* i32 */= f(4, 4);
//! ``` //! ```
use hir::Semantics; use hir::{DisplayTarget, Semantics};
use ide_db::{famous_defs::FamousDefs, RootDatabase}; use ide_db::{famous_defs::FamousDefs, RootDatabase};
use itertools::Itertools; use itertools::Itertools;
use span::EditionedFileId;
use syntax::{ use syntax::{
ast::{self, AstNode, HasGenericArgs, HasName}, ast::{self, AstNode, HasGenericArgs, HasName},
match_ast, match_ast,
@ -22,7 +21,7 @@ pub(super) fn hints(
acc: &mut Vec<InlayHint>, acc: &mut Vec<InlayHint>,
famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>, famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>,
config: &InlayHintsConfig, config: &InlayHintsConfig,
file_id: EditionedFileId, display_target: DisplayTarget,
pat: &ast::IdentPat, pat: &ast::IdentPat,
) -> Option<()> { ) -> Option<()> {
if !config.type_hints { if !config.type_hints {
@ -70,7 +69,7 @@ pub(super) fn hints(
return None; return None;
} }
let mut label = label_of_ty(famous_defs, config, &ty, file_id.edition())?; let mut label = label_of_ty(famous_defs, config, &ty, display_target)?;
if config.hide_named_constructor_hints if config.hide_named_constructor_hints
&& is_named_constructor(sema, pat, &label.to_string()).is_some() && is_named_constructor(sema, pat, &label.to_string()).is_some()

6
src/tools/rust-analyzer/crates/ide/src/inlay_hints/chaining.rs
View File

@ -1,6 +1,6 @@
//! Implementation of "chaining" inlay hints. //! Implementation of "chaining" inlay hints.
use hir::DisplayTarget;
use ide_db::famous_defs::FamousDefs; use ide_db::famous_defs::FamousDefs;
use span::EditionedFileId;
use syntax::{ use syntax::{
ast::{self, AstNode}, ast::{self, AstNode},
Direction, NodeOrToken, SyntaxKind, T, Direction, NodeOrToken, SyntaxKind, T,
@ -14,7 +14,7 @@ pub(super) fn hints(
acc: &mut Vec<InlayHint>, acc: &mut Vec<InlayHint>,
famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>, famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>,
config: &InlayHintsConfig, config: &InlayHintsConfig,
file_id: EditionedFileId, display_target: DisplayTarget,
expr: &ast::Expr, expr: &ast::Expr,
) -> Option<()> { ) -> Option<()> {
if !config.chaining_hints { if !config.chaining_hints {
@ -58,7 +58,7 @@ pub(super) fn hints(
} }
} }
} }
let label = label_of_ty(famous_defs, config, &ty, file_id.edition())?; let label = label_of_ty(famous_defs, config, &ty, display_target)?;
acc.push(InlayHint { acc.push(InlayHint {
range: expr.syntax().text_range(), range: expr.syntax().text_range(),
kind: InlayKind::Chaining, kind: InlayKind::Chaining,

7
src/tools/rust-analyzer/crates/ide/src/inlay_hints/closing_brace.rs
View File

@ -3,7 +3,7 @@
//! fn g() { //! fn g() {
//! } /* fn g */ //! } /* fn g */
//! ``` //! ```
use hir::{HirDisplay, Semantics}; use hir::{DisplayTarget, HirDisplay, Semantics};
use ide_db::{FileRange, RootDatabase}; use ide_db::{FileRange, RootDatabase};
use span::EditionedFileId; use span::EditionedFileId;
use syntax::{ use syntax::{
@ -21,6 +21,7 @@ pub(super) fn hints(
sema: &Semantics<'_, RootDatabase>, sema: &Semantics<'_, RootDatabase>,
config: &InlayHintsConfig, config: &InlayHintsConfig,
file_id: EditionedFileId, file_id: EditionedFileId,
display_target: DisplayTarget,
original_node: SyntaxNode, original_node: SyntaxNode,
) -> Option<()> { ) -> Option<()> {
let min_lines = config.closing_brace_hints_min_lines?; let min_lines = config.closing_brace_hints_min_lines?;
@ -43,9 +44,9 @@ pub(super) fn hints(
Some(tr) => format!( Some(tr) => format!(
"impl {} for {}", "impl {} for {}",
tr.name(sema.db).display(sema.db, file_id.edition()), tr.name(sema.db).display(sema.db, file_id.edition()),
ty.display_truncated(sema.db, config.max_length, file_id.edition(), ty.display_truncated(sema.db, config.max_length, display_target,
)), )),
None => format!("impl {}", ty.display_truncated(sema.db, config.max_length, file_id.edition())), None => format!("impl {}", ty.display_truncated(sema.db, config.max_length, display_target)),
}; };
(hint_text, None) (hint_text, None)
}, },

6
src/tools/rust-analyzer/crates/ide/src/inlay_hints/closure_ret.rs
View File

@ -1,8 +1,8 @@
//! Implementation of "closure return type" inlay hints. //! Implementation of "closure return type" inlay hints.
//! //!
//! Tests live in [`bind_pat`][super::bind_pat] module. //! Tests live in [`bind_pat`][super::bind_pat] module.
use hir::DisplayTarget;
use ide_db::famous_defs::FamousDefs; use ide_db::famous_defs::FamousDefs;
use span::EditionedFileId;
use syntax::ast::{self, AstNode}; use syntax::ast::{self, AstNode};
use crate::{ use crate::{
@ -14,7 +14,7 @@ pub(super) fn hints(
acc: &mut Vec<InlayHint>, acc: &mut Vec<InlayHint>,
famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>, famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>,
config: &InlayHintsConfig, config: &InlayHintsConfig,
file_id: EditionedFileId, display_target: DisplayTarget,
closure: ast::ClosureExpr, closure: ast::ClosureExpr,
) -> Option<()> { ) -> Option<()> {
if config.closure_return_type_hints == ClosureReturnTypeHints::Never { if config.closure_return_type_hints == ClosureReturnTypeHints::Never {
@ -43,7 +43,7 @@ pub(super) fn hints(
return None; return None;
} }
let mut label = label_of_ty(famous_defs, config, &ty, file_id.edition())?; let mut label = label_of_ty(famous_defs, config, &ty, display_target)?;
if arrow.is_none() { if arrow.is_none() {
label.prepend_str(" -> "); label.prepend_str(" -> ");

Some files were not shown because too many files have changed in this diff Show More