- - run: rm dist/rust-analyzer-no-server.vsix

-

-version = "0.4.7"

-checksum = "5396562cd2eaa828445d6d34258ae21ee1eb9d40fe626ca7f51c8dccb4af9d66"

-version = "1.0.1"

-checksum = "ce9bedf5da2c234fdf2391ede2b90fabf585355f33100689bc364a3ea558561a"

-version = "0.15.17"

-checksum = "d4f1e4a001f863f41ea8d0e6a0c34b356d5b733db50dadab3efef640bafb779b"

-rowan = "=0.15.17"

- CrateGraphBuilder, CratesIdMap, LibraryRoots, LocalRoots, RootQueryDb, SourceRoot, SourceRootId,

- pub fn apply(self, db: &mut dyn RootQueryDb) -> Option<CratesIdMap> {

-use crate::{CrateWorkspaceData, EditionedFileId, FxIndexSet, RootQueryDb};

- pub fn transitive_rev_deps(self, db: &dyn RootQueryDb) -> Box<[Crate]> {

- db.all_crates().iter().for_each(|&krate| {

- pub fn set_in_db(self, db: &mut dyn RootQueryDb) -> CratesIdMap {

- let old_all_crates = db.all_crates();

-

- db.set_all_crates_with_durability(

- Arc::new(Vec::from_iter(all_crates).into_boxed_slice()),

- Durability::MEDIUM,

- );

- db: &mut dyn RootQueryDb,

-use syntax::{Parse, SyntaxError, ast};

-/// Database which stores all significant input facts: source code and project

-/// model. Everything else in rust-analyzer is derived from these queries.

-#[query_group::query_group]

-pub trait RootQueryDb: SourceDatabase + salsa::Database {

- /// Parses the file into the syntax tree.

- #[salsa::invoke(parse)]

- #[salsa::lru(128)]

- fn parse(&self, file_id: EditionedFileId) -> Parse<ast::SourceFile>;

-

- /// Returns the set of errors obtained from parsing the file including validation errors.

- #[salsa::transparent]

- fn parse_errors(&self, file_id: EditionedFileId) -> Option<&[SyntaxError]>;

-

- #[salsa::transparent]

- fn toolchain_channel(&self, krate: Crate) -> Option<ReleaseChannel>;

-

- /// Crates whose root file is in `id`.

- #[salsa::invoke_interned(source_root_crates)]

- fn source_root_crates(&self, id: SourceRootId) -> Arc<[Crate]>;

-

- #[salsa::transparent]

- fn relevant_crates(&self, file_id: FileId) -> Arc<[Crate]>;

-

- /// Returns the crates in topological order.

- ///

- /// **Warning**: do not use this query in `hir-*` crates! It kills incrementality across crate metadata modifications.

- #[salsa::input]

- fn all_crates(&self) -> Arc<Box<[Crate]>>;

-}

-

-fn toolchain_channel(db: &dyn RootQueryDb, krate: Crate) -> Option<ReleaseChannel> {

-fn parse(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Parse<ast::SourceFile> {

- let _p = tracing::info_span!("parse", ?file_id).entered();

- let (file_id, edition) = file_id.unpack(db.as_dyn_database());

- let text = db.file_text(file_id).text(db);

- ast::SourceFile::parse(text, edition)

-fn parse_errors(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Option<&[SyntaxError]> {

- #[salsa_macros::tracked(returns(ref))]

- fn parse_errors(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Option<Box<[SyntaxError]>> {

- let errors = db.parse(file_id).errors();

- match &*errors {

- [] => None,

- [..] => Some(errors.into()),

- }

- }

- parse_errors(db, file_id).as_ref().map(|it| &**it)

-fn source_root_crates(db: &dyn RootQueryDb, id: SourceRootId) -> Arc<[Crate]> {

- let crates = db.all_crates();

- crates

- .iter()

- .copied()

- .filter(|&krate| {

- let root_file = krate.data(db).root_file_id;

- db.file_source_root(root_file).source_root_id(db) == id

- })

- .collect()

-fn relevant_crates(db: &dyn RootQueryDb, file_id: FileId) -> Arc<[Crate]> {

- db.source_root_crates(source_root.source_root_id(db))

-//! An exception to this model that is also defined in this module is documentation (doc

-//! comments and `#[doc = "..."]` attributes). But it also has a more compact form than

-//! the attribute: a concatenated string of the full docs as well as a source map

-//! to map it back to AST (which is needed for things like resolving links in doc comments

-//! and highlight injection). The lowering and upmapping of doc comments is a bit complicated,

-//! but it is encapsulated in the [`Docs`] struct.

-

-use std::{

- convert::Infallible,

- iter::Peekable,

- ops::{ControlFlow, Range},

-};

- HirFileId, InFile, Lookup,

- attrs::{Meta, expand_cfg_attr, expand_cfg_attr_with_doc_comments},

- AstNode, AstToken, NodeOrToken, SmolStr, SourceFile, SyntaxNode, SyntaxToken, T,

- ast::{self, AttrDocCommentIter, HasAttrs, IsString, TokenTreeChildren},

-use tt::{TextRange, TextSize};

- let definition_source = db.parse(definition).tree();

- let definition_source = db.parse(definition).tree();

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

-struct DocsSourceMapLine {

- /// The offset in [`Docs::docs`].

- string_offset: TextSize,

- /// The offset in the AST of the text.

- ast_offset: TextSize,

-}

-

-#[derive(Debug, Clone, PartialEq, Eq, Hash)]

-pub struct Docs {

- /// The concatenated string of all `#[doc = "..."]` attributes and documentation comments.

- docs: String,

- /// A sorted map from an offset in `docs` to an offset in the source code.

- docs_source_map: Vec<DocsSourceMapLine>,

- /// If the item is an outlined module (`mod foo;`), `docs_source_map` store the concatenated

- /// list of the outline and inline docs (outline first). Then, this field contains the [`HirFileId`]

- /// of the outline declaration, and the index in `docs` from which the inline docs

- /// begin.

- outline_mod: Option<(HirFileId, usize)>,

- inline_file: HirFileId,

- /// The size the prepended prefix, which does not map to real doc comments.

- prefix_len: TextSize,

- /// The offset in `docs` from which the docs are inner attributes/comments.

- inline_inner_docs_start: Option<TextSize>,

- /// Like `inline_inner_docs_start`, but for `outline_mod`. This can happen only when merging `Docs`

- /// (as outline modules don't have inner attributes).

- outline_inner_docs_start: Option<TextSize>,

-}

-

-#[derive(Debug, Clone, Copy, PartialEq, Eq)]

-pub enum IsInnerDoc {

- No,

- Yes,

-}

-

-impl IsInnerDoc {

- #[inline]

- pub fn yes(self) -> bool {

- self == IsInnerDoc::Yes

- }

-}

-

-impl Docs {

- #[inline]

- pub fn docs(&self) -> &str {

- &self.docs

- }

-

- #[inline]

- pub fn into_docs(self) -> String {

- self.docs

- }

-

- pub fn find_ast_range(

- &self,

- mut string_range: TextRange,

- ) -> Option<(InFile<TextRange>, IsInnerDoc)> {

- if string_range.start() < self.prefix_len {

- return None;

- }

- string_range -= self.prefix_len;

-

- let mut file = self.inline_file;

- let mut inner_docs_start = self.inline_inner_docs_start;

- // Check whether the range is from the outline, the inline, or both.

- let source_map = if let Some((outline_mod_file, outline_mod_end)) = self.outline_mod {

- if let Some(first_inline) = self.docs_source_map.get(outline_mod_end) {

- if string_range.end() <= first_inline.string_offset {

- // The range is completely in the outline.

- file = outline_mod_file;

- inner_docs_start = self.outline_inner_docs_start;

- &self.docs_source_map[..outline_mod_end]

- } else if string_range.start() >= first_inline.string_offset {

- // The range is completely in the inline.

- &self.docs_source_map[outline_mod_end..]

- } else {

- // The range is combined from the outline and the inline - cannot map it back.

- return None;

- }

- } else {

- // There is no inline.

- file = outline_mod_file;

- inner_docs_start = self.outline_inner_docs_start;

- &self.docs_source_map

- }

- } else {

- // There is no outline.

- &self.docs_source_map

- };

-

- let after_range =

- source_map.partition_point(|line| line.string_offset <= string_range.start()) - 1;

- let after_range = &source_map[after_range..];

- let line = after_range.first()?;

- if after_range.get(1).is_some_and(|next_line| next_line.string_offset < string_range.end())

- {

- // The range is combined from two lines - cannot map it back.

- return None;

- }

- let ast_range = string_range - line.string_offset + line.ast_offset;

- let is_inner = if inner_docs_start

- .is_some_and(|inner_docs_start| string_range.start() >= inner_docs_start)

- {

- IsInnerDoc::Yes

- } else {

- IsInnerDoc::No

- };

- Some((InFile::new(file, ast_range), is_inner))

- }

-

- #[inline]

- pub fn shift_by(&mut self, offset: TextSize) {

- self.prefix_len += offset;

- }

-

- pub fn prepend_str(&mut self, s: &str) {

- self.prefix_len += TextSize::of(s);

- self.docs.insert_str(0, s);

- }

-

- pub fn append_str(&mut self, s: &str) {

- self.docs.push_str(s);

- }

-

- pub fn append(&mut self, other: &Docs) {

- let other_offset = TextSize::of(&self.docs);

-

- assert!(

- self.outline_mod.is_none() && other.outline_mod.is_none(),

- "cannot merge `Docs` that have `outline_mod` set"

- );

- self.outline_mod = Some((self.inline_file, self.docs_source_map.len()));

- self.inline_file = other.inline_file;

- self.outline_inner_docs_start = self.inline_inner_docs_start;

- self.inline_inner_docs_start = other.inline_inner_docs_start.map(|it| it + other_offset);

-

- self.docs.push_str(&other.docs);

- self.docs_source_map.extend(other.docs_source_map.iter().map(

- |&DocsSourceMapLine { string_offset, ast_offset }| DocsSourceMapLine {

- ast_offset,

- string_offset: string_offset + other_offset,

- },

- ));

- }

-

- fn extend_with_doc_comment(&mut self, comment: ast::Comment, indent: &mut usize) {

- let Some((doc, offset)) = comment.doc_comment() else { return };

- self.extend_with_doc_str(doc, comment.syntax().text_range().start() + offset, indent);

- }

-

- fn extend_with_doc_attr(&mut self, value: SyntaxToken, indent: &mut usize) {

- let Some(value) = ast::String::cast(value) else { return };

- let Some(value_offset) = value.text_range_between_quotes() else { return };

- let value_offset = value_offset.start();

- let Ok(value) = value.value() else { return };

- // FIXME: Handle source maps for escaped text.

- self.extend_with_doc_str(&value, value_offset, indent);

- }

-

- fn extend_with_doc_str(&mut self, doc: &str, mut offset_in_ast: TextSize, indent: &mut usize) {

- for line in doc.split('\n') {

- self.docs_source_map.push(DocsSourceMapLine {

- string_offset: TextSize::of(&self.docs),

- ast_offset: offset_in_ast,

- });

- offset_in_ast += TextSize::of(line) + TextSize::of("\n");

-

- let line = line.trim_end();

- if let Some(line_indent) = line.chars().position(|ch| !ch.is_whitespace()) {

- // Empty lines are handled because `position()` returns `None` for them.

- *indent = std::cmp::min(*indent, line_indent);

- }

- self.docs.push_str(line);

- self.docs.push('\n');

- }

- }

-

- fn remove_indent(&mut self, indent: usize, start_source_map_index: usize) {

- /// In case of panics, we want to avoid corrupted UTF-8 in `self.docs`, so we clear it.

- struct Guard<'a>(&'a mut Docs);

- impl Drop for Guard<'_> {

- fn drop(&mut self) {

- let Docs {

- docs,

- docs_source_map,

- outline_mod,

- inline_file: _,

- prefix_len: _,

- inline_inner_docs_start: _,

- outline_inner_docs_start: _,

- } = self.0;

- // Don't use `String::clear()` here because it's not guaranteed to not do UTF-8-dependent things,

- // and we may have temporarily broken the string's encoding.

- unsafe { docs.as_mut_vec() }.clear();

- // This is just to avoid panics down the road.

- docs_source_map.clear();

- *outline_mod = None;

- }

- }

-

- if self.docs.is_empty() {

- return;

- }

-

- let guard = Guard(self);

- let source_map = &mut guard.0.docs_source_map[start_source_map_index..];

- let Some(&DocsSourceMapLine { string_offset: mut copy_into, .. }) = source_map.first()

- else {

- return;

- };

- // We basically want to remove multiple ranges from a string. Doing this efficiently (without O(N^2)

- // or allocations) requires unsafe. Basically, for each line, we copy the line minus the indent into

- // consecutive to the previous line (which may have moved). Then at the end we truncate.

- let mut accumulated_offset = TextSize::new(0);

- for idx in 0..source_map.len() {

- let string_end_offset = source_map

- .get(idx + 1)

- .map_or_else(|| TextSize::of(&guard.0.docs), |next_attr| next_attr.string_offset);

- let line_source = &mut source_map[idx];

- let line_docs =

- &guard.0.docs[TextRange::new(line_source.string_offset, string_end_offset)];

- let line_docs_len = TextSize::of(line_docs);

- let indent_size = line_docs.char_indices().nth(indent).map_or_else(

- || TextSize::of(line_docs) - TextSize::of("\n"),

- |(offset, _)| TextSize::new(offset as u32),

- );

- unsafe { guard.0.docs.as_bytes_mut() }.copy_within(

- Range::<usize>::from(TextRange::new(

- line_source.string_offset + indent_size,

- string_end_offset,

- )),

- copy_into.into(),

- );

- copy_into += line_docs_len - indent_size;

-

- if let Some(inner_attrs_start) = &mut guard.0.inline_inner_docs_start

- && *inner_attrs_start == line_source.string_offset

- {

- *inner_attrs_start -= accumulated_offset;

- }

- // The removals in the string accumulate, but in the AST not, because it already points

- // to the beginning of each attribute.

- // Also, we need to shift the AST offset of every line, but the string offset of the first

- // line should not get shifted (in general, the shift for the string offset is by the

- // number of lines until the current one, excluding the current one).

- line_source.string_offset -= accumulated_offset;

- line_source.ast_offset += indent_size;

-

- accumulated_offset += indent_size;

- }

- // Don't use `String::truncate()` here because it's not guaranteed to not do UTF-8-dependent things,

- // and we may have temporarily broken the string's encoding.

- unsafe { guard.0.docs.as_mut_vec() }.truncate(copy_into.into());

-

- std::mem::forget(guard);

- }

-

- fn remove_last_newline(&mut self) {

- self.docs.truncate(self.docs.len().saturating_sub(1));

- }

-

- fn shrink_to_fit(&mut self) {

- let Docs {

- docs,

- docs_source_map,

- outline_mod: _,

- inline_file: _,

- prefix_len: _,

- inline_inner_docs_start: _,

- outline_inner_docs_start: _,

- } = self;

- docs.shrink_to_fit();

- docs_source_map.shrink_to_fit();

- }

-}

-

-fn extract_docs<'a>(

- get_cfg_options: &dyn Fn() -> &'a CfgOptions,

- source: InFile<ast::AnyHasAttrs>,

- outer_mod_decl: Option<InFile<ast::Module>>,

- inner_attrs_node: Option<SyntaxNode>,

-) -> Option<Box<Docs>> {

- let mut result = Docs {

- docs: String::new(),

- docs_source_map: Vec::new(),

- outline_mod: None,

- inline_file: source.file_id,

- prefix_len: TextSize::new(0),

- inline_inner_docs_start: None,

- outline_inner_docs_start: None,

- };

-

- let mut cfg_options = None;

- let mut extend_with_attrs =

- |result: &mut Docs, node: &SyntaxNode, expect_inner_attrs, indent: &mut usize| {

- expand_cfg_attr_with_doc_comments::<_, Infallible>(

- AttrDocCommentIter::from_syntax_node(node).filter(|attr| match attr {

- Either::Left(attr) => attr.kind().is_inner() == expect_inner_attrs,

- Either::Right(comment) => comment.kind().doc.is_some_and(|kind| {

- (kind == ast::CommentPlacement::Inner) == expect_inner_attrs

- }),

- }),

- || cfg_options.get_or_insert_with(get_cfg_options),

- |attr| {

- match attr {

- Either::Right(doc_comment) => {

- result.extend_with_doc_comment(doc_comment, indent)

- }

- Either::Left((attr, _, _, _)) => match attr {

- // FIXME: Handle macros: `#[doc = concat!("foo", "bar")]`.

- Meta::NamedKeyValue {

- name: Some(name), value: Some(value), ..

- } if name.text() == "doc" => {

- result.extend_with_doc_attr(value, indent);

- }

- _ => {}

- },

- }

- ControlFlow::Continue(())

- },

- );

- };

-

- if let Some(outer_mod_decl) = outer_mod_decl {

- let mut indent = usize::MAX;

- extend_with_attrs(&mut result, outer_mod_decl.value.syntax(), false, &mut indent);

- result.remove_indent(indent, 0);

- result.outline_mod = Some((outer_mod_decl.file_id, result.docs_source_map.len()));

- }

-

- let inline_source_map_start = result.docs_source_map.len();

- let mut indent = usize::MAX;

- extend_with_attrs(&mut result, source.value.syntax(), false, &mut indent);

- if let Some(inner_attrs_node) = &inner_attrs_node {

- result.inline_inner_docs_start = Some(TextSize::of(&result.docs));

- extend_with_attrs(&mut result, inner_attrs_node, true, &mut indent);

- }

- result.remove_indent(indent, inline_source_map_start);

-

- result.remove_last_newline();

-

- result.shrink_to_fit();

-

- if result.docs.is_empty() { None } else { Some(Box::new(result)) }

-}

-

- let syntax = db.parse(root_file_id).tree();

- extract_docs(&|| krate.cfg_options(db), source, outer_mod_decl, inner_attrs_node)

- extract_docs(&|| cfg_options, field, None, None)

- use expect_test::expect;

- use hir_expand::InFile;

- use tt::{TextRange, TextSize};

- use crate::attrs::{AttrFlags, Docs, IsInnerDoc};

- fn docs() {

- let (_db, file_id) = TestDB::with_single_file("");

- let mut docs = Docs {

- docs: String::new(),

- docs_source_map: Vec::new(),

- outline_mod: None,

- inline_file: file_id.into(),

- prefix_len: TextSize::new(0),

- inline_inner_docs_start: None,

- outline_inner_docs_start: None,

- };

- let mut indent = usize::MAX;

-

- let outer = " foo\n\tbar baz";

- let mut ast_offset = TextSize::new(123);

- for line in outer.split('\n') {

- docs.extend_with_doc_str(line, ast_offset, &mut indent);

- ast_offset += TextSize::of(line) + TextSize::of("\n");

- }

-

- docs.inline_inner_docs_start = Some(TextSize::of(&docs.docs));

- ast_offset += TextSize::new(123);

- let inner = " bar \n baz";

- for line in inner.split('\n') {

- docs.extend_with_doc_str(line, ast_offset, &mut indent);

- ast_offset += TextSize::of(line) + TextSize::of("\n");

- }

-

- assert_eq!(indent, 1);

- expect![[r#"

- [

- DocsSourceMapLine {

- string_offset: 0,

- ast_offset: 123,

- },

- DocsSourceMapLine {

- string_offset: 5,

- ast_offset: 128,

- },

- DocsSourceMapLine {

- string_offset: 15,

- ast_offset: 261,

- },

- DocsSourceMapLine {

- string_offset: 20,

- ast_offset: 267,

- },

- ]

- "#]]

- .assert_debug_eq(&docs.docs_source_map);

-

- docs.remove_indent(indent, 0);

-

- assert_eq!(docs.inline_inner_docs_start, Some(TextSize::new(13)));

-

- assert_eq!(docs.docs, "foo\nbar baz\nbar\nbaz\n");

- expect![[r#"

- [

- DocsSourceMapLine {

- string_offset: 0,

- ast_offset: 124,

- },

- DocsSourceMapLine {

- string_offset: 4,

- ast_offset: 129,

- },

- DocsSourceMapLine {

- string_offset: 13,

- ast_offset: 262,

- },

- DocsSourceMapLine {

- string_offset: 17,

- ast_offset: 268,

- },

- ]

- "#]]

- .assert_debug_eq(&docs.docs_source_map);

-

- docs.append(&docs.clone());

- docs.prepend_str("prefix---");

- assert_eq!(docs.docs, "prefix---foo\nbar baz\nbar\nbaz\nfoo\nbar baz\nbar\nbaz\n");

- expect![[r#"

- [

- DocsSourceMapLine {

- string_offset: 0,

- ast_offset: 124,

- },

- DocsSourceMapLine {

- string_offset: 4,

- ast_offset: 129,

- },

- DocsSourceMapLine {

- string_offset: 13,

- ast_offset: 262,

- },

- DocsSourceMapLine {

- string_offset: 17,

- ast_offset: 268,

- },

- DocsSourceMapLine {

- string_offset: 21,

- ast_offset: 124,

- },

- DocsSourceMapLine {

- string_offset: 25,

- ast_offset: 129,

- },

- DocsSourceMapLine {

- string_offset: 34,

- ast_offset: 262,

- },

- DocsSourceMapLine {

- string_offset: 38,

- ast_offset: 268,

- },

- ]

- "#]]

- .assert_debug_eq(&docs.docs_source_map);

-

- let range = |start, end| TextRange::new(TextSize::new(start), TextSize::new(end));

- let in_file = |range| InFile::new(file_id.into(), range);

- assert_eq!(docs.find_ast_range(range(0, 2)), None);

- assert_eq!(docs.find_ast_range(range(8, 10)), None);

- assert_eq!(

- docs.find_ast_range(range(9, 10)),

- Some((in_file(range(124, 125)), IsInnerDoc::No))

- );

- assert_eq!(docs.find_ast_range(range(20, 23)), None);

- assert_eq!(

- docs.find_ast_range(range(23, 25)),

- Some((in_file(range(263, 265)), IsInnerDoc::Yes))

- );

- }

-

- #[test]

-use base_db::{Crate, RootQueryDb, SourceDatabase};

-pub trait InternDatabase: RootQueryDb {

- /// Like [`Self::signature_const_expr_roots`], but also returns the origin

- let elements = e.map(|expr| self.collect_expr(expr)).collect();

- use base_db::RootQueryDb;

- let file_syntax = db.parse(editioned_file_id).syntax_node();

- let file = db.parse(editioned_file_id).ok().unwrap();

- [salsa id]: Id(3803),

- Id(2400),

- 4801,

- use base_db::RootQueryDb;

- let all_crates = db.all_crates();

- let all_crates = db.all_crates();

-struct#0:MacroRules[BE8F, 0]@58..64#18432# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#18432#

- map#0:MacroRules[BE8F, 0]@86..89#18432#:#0:MacroRules[BE8F, 0]@89..90#18432# #0:MacroRules[BE8F, 0]@89..90#18432#::#0:MacroRules[BE8F, 0]@91..93#18432#std#0:MacroRules[BE8F, 0]@93..96#18432#::#0:MacroRules[BE8F, 0]@96..98#18432#collections#0:MacroRules[BE8F, 0]@98..109#18432#::#0:MacroRules[BE8F, 0]@109..111#18432#HashSet#0:MacroRules[BE8F, 0]@111..118#18432#<#0:MacroRules[BE8F, 0]@118..119#18432#(#0:MacroRules[BE8F, 0]@119..120#18432#)#0:MacroRules[BE8F, 0]@120..121#18432#>#0:MacroRules[BE8F, 0]@121..122#18432#,#0:MacroRules[BE8F, 0]@122..123#18432#

-}#0:MacroRules[BE8F, 0]@132..133#18432#

-struct#1:MacroRules[DB0C, 0]@59..65#18432# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#18432#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#18432#;#1:MacroRules[DB0C, 0]@75..76#18432#

-impl#\18432# Bar#\18432# {#\18432#

- fn#\18432# foo#\ROOT2024#(#\18432#)#\18432# {#\18432#}#\18432#

- fn#\18432# bar#\ROOT2024#(#\18432#)#\18432# {#\18432#}#\18432#

-}#\18432#

-use base_db::RootQueryDb;

- let ast = db.parse(editioned_file_id).syntax_node();

- let sf = db.parse(editioned_file_id).tree();

-use span::{Edition, FileAstId, SyntaxContext};

- if matches!(item_tree.top_level_attrs(), AttrsOrCfg::CfgDisabled(_)) {

-use base_db::RootQueryDb;

- DependencyBuilder, Env, RootQueryDb, SourceDatabase,

- for &krate in db.all_crates().iter() {

- let all_crates_before = db.all_crates();

- let all_crates_after = db.all_crates();

- Arc::ptr_eq(&all_crates_before, &all_crates_after),

- for &krate in db.all_crates().iter() {

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- let krate = *db.all_crates().last().expect("no crate graph present");

- let krate = *db.all_crates().last().expect("no crate graph present");

- Crate, CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, Nonce, RootQueryDb,

- SourceDatabase, SourceRoot, SourceRootId, SourceRootInput,

- this.set_all_crates(Arc::new(Box::new([])));

- let all_crates = self.all_crates();

- for &krate in self.relevant_crates(file_id).iter() {

- let root_syntax_node = self.parse(file_id).syntax_node();

- &db.parse(editioned_file_id).syntax_node(),

-use base_db::{Crate, RootQueryDb};

-pub trait ExpandDatabase: RootQueryDb {

- HirFileId::FileId(file_id) => db.parse(file_id).syntax_node(),

- (db.parse(file_id).to_syntax(), SpanMap::RealSpanMap(db.real_span_map(file_id)))

- db.parse(self).syntax_node()

- let value = db

- .parse(editioned_file_id)

- let anc = db.parse(editioned_file_id).syntax_node().covering_element(range);

- let tree = db.parse(editioned_file_id).tree();

- Clauses::new_from_slice(adt_predicates.explicit_predicates().skip_binder())

- .store(),

- adt_predicates.explicit_predicates().iter_identity_copied().filter_map(|pred| {

- .iter_identity_copied()

- .iter_identity_copied()

- preds.iter().format_with("\n", |pred, formatter| formatter(&format_args!(

-use base_db::RootQueryDb;

- DisplayTarget::from_crate(db, *db.all_crates().last().expect("no crate graph present"));

- .iter_identity_copied()

- .iter_identity_copied()

- elaborate::elaborate(interner, predicates.iter_identity_copied()).any(|pred| {

- .iter_identity_copied()

- let predicates = GenericPredicates::query_own(db, func.into());

- for pred in predicates.iter_identity_copied() {

- .iter_identity_copied()

- TypeNs::AdtId(AdtId::EnumId(_))

- | TypeNs::BuiltinType(_)

- | TypeNs::TraitId(_)

- | TypeNs::ModuleId(_) => {

- generic_predicates.iter_instantiated_copied(self.interner(), parameters.as_slice()),

- predicates.iter_instantiated_copied(interner, subst.as_slice()),

- // The order is the following: first, if `parent_is_trait == true`, comes the implicit trait

- // predicate for the parent. Then come the bounds of the associated types of the parents,

- // then the explicit, self-only predicates for the parent, then the explicit, self-only trait

- // predicate for the child, then the bounds of the associated types of the child,

- // then the implicit trait predicate for the child, if `is_trait` is `true`.

- is_trait: bool,

- parent_is_trait: bool,

- is_trait: false,

- parent_is_trait: false,

- ) -> EarlyBinder<'db, &'db [Clause<'db>]> {

- pub fn query_own<'db>(

- ) -> EarlyBinder<'db, &'db [Clause<'db>]> {

- Self::query(db, def).own_predicates()

- ) -> EarlyBinder<'db, &'db [Clause<'db>]> {

- pub fn query_explicit_implied<'db>(

- db: &'db dyn HirDatabase,

- def: GenericDefId,

- ) -> EarlyBinder<'db, &'db [Clause<'db>]> {

- Self::query(db, def).explicit_implied_predicates()

- pub fn all_predicates(&self) -> EarlyBinder<'_, &[Clause<'_>]> {

- self.predicates.get().map_bound(|it| it.as_slice())

- pub fn own_predicates(&self) -> EarlyBinder<'_, &[Clause<'_>]> {

- self.predicates.get().map_bound(|it| &it.as_slice()[self.own_predicates_start as usize..])

- /// Returns the predicates, minus the implicit `Self: Trait` predicate and bounds of the

- /// associated types for a trait.

- pub fn explicit_predicates(&self) -> EarlyBinder<'_, &[Clause<'_>]> {

- &it.as_slice()[self.parent_explicit_self_predicates_start as usize

- pub fn explicit_implied_predicates(&self) -> EarlyBinder<'_, &[Clause<'_>]> {

- self.predicates.get().map_bound(|it| {

- &it.as_slice()[usize::from(self.parent_is_trait)..it.len() - usize::from(self.is_trait)]

- let clauses = rustc_type_ir::elaborate::elaborate(

- interner,

- predicates.all_predicates().iter_identity_copied(),

- );

- // The order is:

- //

- // 1. parent implicit trait pred

- // 2. parent assoc bounds

- // 3. parent self only preds

- // 4. own self only preds

- // 5. own assoc ty bounds

- // 6. own implicit trait pred

- //

- // The purpose of this is to index the slice of the followings, without making extra `Vec`s or

- // iterators:

- // - explicit self only predicates, of own or own + self

- // - explicit predicates, of own or own + self

- .chain(own_implicit_trait_predicate.iter())

- let parent_is_trait = parent_implicit_trait_predicate.is_some();

- let is_trait = own_implicit_trait_predicate.is_some();

- parent_is_trait as u32 + parent_assoc_ty_bounds.len() as u32;

- is_trait,

- parent_is_trait,

- bounds.iter_instantiated_copied(interner, args.as_slice()),

- .iter_instantiated_copied(self.interner(), filler_args.as_slice()),

- .iter_instantiated_copied(self.interner(), all_args),

- impl_bounds.iter_instantiated_copied(self.interner(), impl_args.as_slice()),

- "libc::write args are not provided".into(),

- return Err(MirEvalError::InternalError(

- "libc::write args are not provided".into(),

- ));

- #[tracing::instrument(level = "debug", skip(self), ret)]

- predicates_of(self.db, def_id).all_predicates().map_bound(|it| it.iter().copied())

- #[tracing::instrument(level = "debug", skip(self), ret)]

- predicates_of(self.db, def_id).own_predicates().map_bound(|it| it.iter().copied())

- #[tracing::instrument(skip(self), ret)]

- let is_self = |ty: Ty<'db>| match ty.kind() {

- rustc_type_ir::TyKind::Param(param) => param.index == 0,

- _ => false,

- };

-

- GenericPredicates::query_explicit(self.db, def_id.0.into()).map_bound(move |predicates| {

- predicates

- .iter()

- .copied()

- .filter(move |p| match p.kind().skip_binder() {

- // rustc has the following assertion:

- // https://github.com/rust-lang/rust/blob/52618eb338609df44978b0ca4451ab7941fd1c7a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs#L525-L608

- ClauseKind::Trait(it) => is_self(it.self_ty()),

- ClauseKind::TypeOutlives(it) => is_self(it.0),

- ClauseKind::Projection(it) => is_self(it.self_ty()),

- ClauseKind::HostEffect(it) => is_self(it.self_ty()),

- _ => false,

- })

- .map(|p| (p, Span::dummy()))

- })

- #[tracing::instrument(skip(self), ret)]

- fn is_self_or_assoc(ty: Ty<'_>) -> bool {

- match ty.kind() {

- rustc_type_ir::TyKind::Param(param) => param.index == 0,

- rustc_type_ir::TyKind::Alias(rustc_type_ir::AliasTyKind::Projection, alias) => {

- is_self_or_assoc(alias.self_ty())

- }

- _ => false,

- predicates_of(self.db, def_id).explicit_implied_predicates().map_bound(|predicates| {

- predicates

- .iter()

- .copied()

- .filter(|p| match p.kind().skip_binder() {

- ClauseKind::Trait(it) => is_self_or_assoc(it.self_ty()),

- ClauseKind::TypeOutlives(it) => is_self_or_assoc(it.0),

- ClauseKind::Projection(it) => is_self_or_assoc(it.self_ty()),

- ClauseKind::HostEffect(it) => is_self_or_assoc(it.self_ty()),

- // FIXME: Not sure is this correct to allow other clauses but we might replace

- // `generic_predicates_ns` query here with something closer to rustc's

- // `implied_bounds_with_filter`, which is more granular lowering than this

- // "lower at once and then filter" implementation.

- _ => true,

- })

- .map(|p| (p, Span::dummy()))

- })

- .iter_identity_copied()

- .iter_instantiated_copied(interner, parent_args.as_slice()),

- CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, Nonce, RootQueryDb,

- SourceDatabase, SourceRoot, SourceRootId, SourceRootInput,

- this.set_all_crates(Arc::new(Box::new([])));

- for &krate in self.relevant_crates(file_id).iter() {

- for &krate in self.all_crates().iter() {

- "source_root_crates_shim",

- "parse_shim",

- "parse_shim",

- "source_root_crates_shim",

- "parse_shim",

- "parse_shim",

- "source_root_crates_shim",

- "parse_shim",

- "parse_shim",

- "source_root_crates_shim",

- "parse_shim",

- "parse_shim",

- "source_root_crates_shim",

- "parse_shim",

- "parse_shim",

- "source_root_crates_shim",

- "parse_shim",

- "parse_shim",

- "source_root_crates_shim",

- "parse_shim",

- "parse_shim",

- // ^ {unknown}

- // ^ {unknown}

- // ^ {unknown}

- // ^ {unknown}

- // ^ {unknown}

- // ^ {unknown}

- // ^ {unknown}

- // ^ {unknown}

- pub missed_fields: Vec<Name>,

- .map(|idx| variant_data.fields()[idx].name.clone())

- write_params_bounds(f, predicates)?;

- .iter_identity_copied()

-use base_db::{CrateDisplayName, CrateOrigin, LangCrateOrigin};

- let all_crates = db.all_crates();

- db.all_crates().iter().map(|&id| Crate { id }).collect()

- db.all_crates()

- None => Crate::core(db).unwrap_or_else(|| db.all_crates()[0].into()),

- let core = Crate::core(db).map(|core| core.id).unwrap_or_else(|| db.all_crates()[0]);

- .iter_identity_copied()

- for &krate in &**db.all_crates() {

- for &krate in &**db.all_crates() {

- db.all_crates()

-use base_db::FxIndexSet;

- let toolchain = self.db.toolchain_channel(krate.into());

- let tree = self.db.parse(file_id).tree();

- None => self.db.all_crates().last().copied().map(Into::into),

- let tree = self.db.parse(file_id).tree();

- it.to_ptr(db).to_node(&db.parse(file_id).syntax_node())

- it.to_ptr(db).to_node(&db.parse(file_id).syntax_node())

- for &crate_id in db.relevant_crates(file.file_id(db)).iter() {

- for &crate_id in self.db.relevant_crates(file).iter() {

- ast::{self, AstNode, make},

- let mut func_editor = SyntaxEditor::new(first_new_item.syntax().clone_subtree());

- let assoc_item_list = make::assoc_item_list(Some(new_assoc_items)).clone_for_update();

- vec![make::tokens::whitespace(" ").into(), assoc_item_list.syntax().clone().into()],

- let trait_path = make::ext::ident_path(

- &trait_ref.trait_().name(ctx.db()).display(ctx.db(), edition).to_string(),

- );

- gen_trait_fn_body(func, &trait_path, &adt.value, Some(trait_ref))

-use std::iter::{self, Peekable};

- let (mut missing_pats, is_non_exhaustive, has_hidden_variants): (

- Peekable<Box<dyn Iterator<Item = (ast::Pat, bool)>>>,

- let missing_pats: Box<dyn Iterator<Item = _>> = if matches!(enum_def, ExtendedEnum::Enum { enum_: e, .. } if Some(e) == option_enum)

- Box::new(missing_pats.rev())

- Box::new(missing_pats)

- (missing_pats.peekable(), is_non_exhaustive, has_hidden_variants)

- .filter(|(variant_pat, _)| is_variant_missing(&top_lvl_pats, variant_pat));

- (

- (Box::new(missing_pats) as Box<dyn Iterator<Item = _>>).peekable(),

- is_non_exhaustive,

- has_hidden_variants,

- )

- .filter(|(variant_pat, _)| is_variant_missing(&top_lvl_pats, variant_pat));

- (

- (Box::new(missing_pats) as Box<dyn Iterator<Item = _>>).peekable(),

- is_non_exhaustive,

- has_hidden_variants,

- )

- && ((has_hidden_variants && has_catch_all_arm) || missing_pats.peek().is_none())

- "Fill match arms",

- check_assist_unresolved, check_assist_with_config,

- // Computing a single missing arm is enough to determine applicability of the assist.

- cov_mark::check_count!(add_missing_match_arms_lazy_computation, 1);

- let demorganed = bin_expr.clone_subtree();

- let mut editor = SyntaxEditor::new(demorganed.syntax().clone());

- let closure_body = closure_body.clone_subtree();

- let mut editor = SyntaxEditor::new(closure_body.syntax().clone());

- let closure_body = closure_body.clone_subtree();

- let mut editor = SyntaxEditor::new(closure_body.syntax().clone());

- let label = label.syntax().clone_for_update();

- for_loop.attrs().map(|it| it.clone_for_update()),

- let else_expr = if else_block.statements().next().is_none() {

- else_block.tail_expr()?

- else_block.into()

- let match_ = make.expr_match(init, make.match_arm_list([binding_arm, else_arm]));

- let match_ = match_.reset_indent();

- p.clone_for_update().into()

- let syntax = pat.syntax().clone_subtree();

- let mut editor = SyntaxEditor::new(syntax.clone());

- make.record_pat_field(

- make.name_ref(&name_ref.text()),

- binding.clone_for_update(),

- )

- .syntax(),

- editor.replace(extracted_syntax, binding.syntax().clone_for_update());

- let field = ast::make::tuple_field(f.visibility(), f.ty()?);

- let mut editor = SyntaxEditor::new(field.syntax().clone());

- f.attrs().map(|attr| attr.syntax().clone_subtree().clone_for_update().into()).collect(),

- let w = w.syntax().clone_subtree();

- let mut editor = SyntaxEditor::new(w.clone());

- let new_body = body.indent(1.into()).clone_subtree();

- let break_expr = make::expr_break(Some(continue_label.clone()), None).clone_for_update();

- let mut new_edit = SyntaxEditor::new(new_body.syntax().clone());

- continue_label.syntax().clone_for_update().syntax_element(),

-use hir::{Semantics, TypeInfo};

- SyntaxKind::{CLOSURE_EXPR, FN, FOR_EXPR, LOOP_EXPR, WHILE_EXPR, WHITESPACE},

- Some(ast::ElseBranch::Block(block_expr)) if is_never_block(&ctx.sema, &block_expr) => {

- Some(block_expr)

- }

- if parent_block.tail_expr() != Some(if_expr.clone().into())

- && !(else_block.is_some() && ast::ExprStmt::can_cast(if_expr.syntax().parent()?.kind()))

- {

- return None;

- }

-

- let parent_container = parent_block.syntax().parent()?;

- let early_expression = else_block

- .or_else(|| {

- early_expression(parent_container, &ctx.sema, &make)

- .map(ast::make::tail_only_block_expr)

- })?

- .reset_indent();

- let make = SyntaxFactory::without_mappings();

- let early_expression: ast::Expr = {

- let parent_block =

- let_stmt.syntax().parent()?.ancestors().find_map(ast::BlockExpr::cast)?;

- let parent_container = parent_block.syntax().parent()?;

-

- early_expression(parent_container, &ctx.sema, &make)?

- };

- ast::make::tail_only_block_expr(early_expression),

-fn early_expression(

- parent_container: SyntaxNode,

- sema: &Semantics<'_, RootDatabase>,

- make: &SyntaxFactory,

-) -> Option<ast::Expr> {

- let return_none_expr = || {

- let none_expr = make.expr_path(make.ident_path("None"));

- make.expr_return(Some(none_expr))

- };

- if let Some(fn_) = ast::Fn::cast(parent_container.clone())

- && let Some(fn_def) = sema.to_def(&fn_)

- && let Some(TryEnum::Option) = TryEnum::from_ty(sema, &fn_def.ret_type(sema.db))

- {

- return Some(return_none_expr().into());

- if let Some(body) = ast::ClosureExpr::cast(parent_container.clone()).and_then(|it| it.body())

- && let Some(ret_ty) = sema.type_of_expr(&body).map(TypeInfo::original)

- && let Some(TryEnum::Option) = TryEnum::from_ty(sema, &ret_ty)

- {

- return Some(return_none_expr().into());

- Some(match parent_container.kind() {

- WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make.expr_continue(None).into(),

- FN | CLOSURE_EXPR => make.expr_return(None).into(),

- _ => return None,

- })

- fn convert_if_let_has_else_block_in_statement() {

- fn ignore_else_branch() {

- let field = ast::make::record_field(f.visibility(), name, f.ty()?);

- let mut field_editor = SyntaxEditor::new(field.syntax().clone());

- f.attrs().map(|attr| attr.syntax().clone_subtree().clone_for_update().into()).collect(),

- insert_element.push(w.syntax().clone_for_update().syntax_element());

- let (container_info, contains_tail_expr) = body.analyze_container(&ctx.sema, edition)?;

- let args = make::arg_list(fun.params.iter().map(|param| param.to_arg(ctx, fun.mods.edition)));

- let mut call_expr = if fun.self_param.is_some() {

- make::expr_method_call(self_arg, name, args).into()

- make::expr_call(func, args).into()

- let self_param = self.self_param.clone();

- make::param_list(self_param, params)

- let expr = rewrite_body_segment(ctx, &fun.params, &handler, expr.syntax());

- rewrite_body_segment(ctx, &fun.params, &handler, n),

- let syntax = fix_param_usages(ctx, params, syntax);

- let usages = usages

- .iter()

- .filter(|reference| syntax.text_range().contains_range(reference.range))

- .filter_map(|reference| path_element_of_reference(syntax, reference))

- .map(|expr| tm.make_mut(&expr));

- imports::insert_use::{ImportScope, InsertUseConfig, insert_use},

- self, AstNode, HasAttrs, HasGenericParams, HasName, HasVisibility, edit::AstNodeEdit, make,

- match_ast, ted,

-use crate::{AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder};

- builder.edit_file(file_id.file_id(ctx.db()));

- builder,

- apply_references(ctx.config.insert_use, path, node, import, edition)

- builder.edit_file(ctx.vfs_file_id());

- let variant = builder.make_mut(variant.clone());

- builder,

- apply_references(ctx.config.insert_use, path, node, import, edition)

- let generic_params = enum_ast

- .generic_param_list()

- .and_then(|known_generics| extract_generic_params(&known_generics, &field_list));

- let generics = generic_params.as_ref().map(|generics| generics.clone_for_update());

- field_list.clone_for_update()

- let def =

- create_struct_def(variant_name.clone(), &variant, &field_list, generics, &enum_ast);

- ted::insert_all(

- ted::Position::before(enum_ast.syntax()),

- vec![

- def.syntax().clone().into(),

- make::tokens::whitespace(&format!("\n\n{indent}")).into(),

- ],

- update_variant(&variant, generic_params.map(|g| g.clone_for_update()));

- tagged_one.then(|| make::generic_param_list(generics))