let loc = db.lookup_intern_block(block);

let block = loc.ast_id.to_node(db.upcast());

let hygiene = Hygiene::new(db.upcast(), loc.ast_id.file_id);

Arc::new(ctx.lower_block(&block))

}

token: SyntaxToken,

file_id: FileId,

) -> Option<Vec<HighlightedRange>> {

let usages = defs

.iter()

.filter_map(|&d| {

let block_prefix =

CommentKind { shape: CommentShape::Block, ..comment.kind() }.prefix();

edit.replace(target, output)

},

builder.replace(src_type.syntax().text_range(), dest_type.to_string());

builder.replace(ast_trait.syntax().text_range(), format!("From<{}>", src_type));

builder.replace(into_fn_return.syntax().text_range(), "-> Self");

builder.replace(into_fn_name.syntax().text_range(), "from");

for s in selfs {

// with sub_pattern: keep original tuple and add subpattern: `tup @ (_0, _1)`

if in_sub_pattern {

match ctx.config.snippet_cap {

Some(cap) => {

let snip = add_cursor(&text);

let mut body_items: Vec<ast::Item> = node

.children()

.filter_map(|child| {

if selection_range.contains_range(item.syntax().text_range()) {

return Some(item);

}

if let Some(name_ref) = ast::NameRef::cast(desc) {

return Some((

name_ref.syntax().text_range(),

));

}

}

get_replacements_for_visibilty_change(self.body_items.clone(), false);

let impl_items = impls.into_iter().fold(Vec::new(), |mut impl_items, x| {

x.syntax().descendants().fold(Vec::new(), |mut this_impl_items, x| {

this_impl_items.push(item);

}

return this_impl_items;

});

return impl_items;

});

let (_, mut impl_item_replacements, _, _) =

replacements.append(&mut impl_item_replacements);

.find(|x| x.to_string() == desc.to_string())

.is_some();

if is_record_field_present {

}

});

});

(&x.1).into_iter().for_each(|x| {

let node_opt: Option<ast::Use> = find_node_at_range(file.syntax(), x.range);

if let Some(node) = node_opt {

}

});

}

}

if let Some(use_tree_str) = use_tree_str_opt {

use_tree_str.reverse();

if use_tree_str[0].to_string().contains("super") {

let super_path = make::ext::ident_path("super");

body_items.push(item.clone());

//Use stmts are ignored

match item {

ast::Item::Impl(it) => impls.push(it),

ast::Item::Struct(it) => {

}

ast::Item::Union(it) => {

}

_ => (),

}

use_tree_str: &mut Vec<ast::Path>,

) -> Option<&mut Vec<ast::Path>> {

path.syntax().ancestors().filter(|x| x.to_string() != path.to_string()).find_map(|x| {

if let Some(upper_tree_path) = use_tree.path() {

if upper_tree_path.to_string() != path.to_string() {

use_tree_str.push(upper_tree_path.clone());

"Generate a documentation template",

text_range,

|builder| {

// Introduction / short function description before the sections

// Then come the sections

if let Some(mut lines) = examples_builder(&ast_func, ctx) {

doc_lines.push("".into());

// instance `TuplePat`) could be managed later.

Some(ast::Pat::IdentPat(ident_pat)) => match ident_pat.name() {

Some(name) => match is_a_ref_mut_param(&param) {

false => name.to_string(),

},

None => "_".to_string(),

}

QualifyCandidate::UnqualifiedName(generics) => {

let generics = generics.as_ref().map_or_else(String::new, ToString::to_string);

}

QualifyCandidate::TraitAssocItem(qualifier, segment) => {

replacer(format!("<{} as {}>::{}", qualifier, import, segment));

buf.push_str("\n\n");

adt.attrs()

.filter(|attr| attr.as_simple_call().map(|(name, _arg)| name == "cfg").unwrap_or(false))

buf.push_str("impl");

if let Some(generic_params) = &generic_params {

let lifetimes = generic_params.lifetime_params().map(|lt| format!("{}", lt.syntax()));

//!

//! This module uses a bit of static metadata to provide completions

//! for built-in attributes.

use ide_db::{

helpers::{

if line.starts_with("// ")

&& line.contains(':')

&& !line.contains("::")

&& line.chars().all(|it| !it.is_uppercase())

{

panic!("looks like invalid metadata line: {:?}", line);

The next thing to check would be panic messages in rust-analyzer's log.

Log messages are printed to stderr, in VS Code you can see then in the `Output > Rust Analyzer Language Server` tab of the panel.

To fully capture LSP messages between the editor and the server, set `"rust-analyzer.trace.server": "verbose"` config and check

`Output > Rust Analyzer Language Server Trace`.

See https://github.com/rust-analyzer/rust-project.json-example for a small example.

Note that calls to `cargo check` are disabled when using `rust-project.json` by default, so compilation errors and warnings will no longer be sent to your LSP client. To enable these compilation errors you will need to specify explicitly what command rust-analyzer should run to perform the checks using the `checkOnSave.overrideCommand` configuration. As an example, the following configuration explicitly sets `cargo check` as the `checkOnSave` command.