authors = ["rust-analyzer team"]

[profile.dev]

[profile.dev.package]

# These speed up local tests.

attr,

) {

Ok(ResolvedAttr::Macro(call_id)) => {

let loc = self.db.lookup_intern_macro_call(call_id);

if let MacroDefKind::ProcMacro(_, exp, _) = loc.def.kind {

// If there's no expander for the proc macro (e.g. the

let name = Name::new_text_dont_use(it.name.clone());

(

name,

CustomProcMacroExpander::disabled()

} else {

CustomProcMacroExpander::new(hir_expand::proc_macro::ProcMacroId::new(

let call_id = call_id();

if let MacroDefKind::ProcMacro(_, exp, _) = def.kind {

// If there's no expander for the proc macro (e.g.

// because proc macros are disabled, or building the

// proc macro crate failed), report this and skip

#[derive(Debug, PartialEq, Eq)]

pub enum DefDiagnosticKind {

}

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

Self { in_module: container, kind: DefDiagnosticKind::UnconfiguredCode { ast, cfg, opts } }

}

pub fn unresolved_proc_macro(

container: LocalModuleId,

ast: MacroCallKind,

//! Things to wrap other things in file ids.

use either::Either;

use span::{

AstIdNode, ErasedFileAstId, FileAstId, FileId, FileRange, HirFileId, HirFileIdRepr,

pub fn as_ref(&self) -> InFileWrapper<FileKind, &T> {

self.with_value(&self.value)

}

}

impl<FileKind: Copy, T: Clone> InFileWrapper<FileKind, &T> {

}

// region:specific impls

/// Falls back to the macro call range if the node cannot be mapped up fully.

///

/// For attributes and derives, this will point back to the attribute only.

/// For the entire item use [`InFile::original_file_range_full`].

pub fn original_file_range_rooted(self, db: &dyn db::ExpandDatabase) -> FileRange {

}

/// Falls back to the macro call range if the node cannot be mapped up fully.

self,

db: &dyn db::ExpandDatabase,

) -> FileRange {

}

pub fn original_syntax_node_rooted(

// as we don't have node inputs otherwise and therefore can't find an `N` node in the input

let file_id = match self.file_id.repr() {

HirFileIdRepr::FileId(file_id) => {

}

HirFileIdRepr::MacroFile(m) if m.is_attr_macro(db) => m,

_ => return None,

};

let value = db

.parse(file_id)

.syntax_node()

}

}

impl InMacroFile<SyntaxToken> {

pub fn upmap_once(

self,

pub(crate) fn new_for_body(

db: &dyn HirDatabase,

def: DefWithBodyId,

offset: Option<TextSize>,

) -> SourceAnalyzer {

}

pub(crate) fn new_for_body_no_infer(

db: &dyn HirDatabase,

def: DefWithBodyId,

node @ InFile { file_id, .. }: InFile<&SyntaxNode>,

offset: Option<TextSize>,

) -> SourceAnalyzer {

let (body, source_map) = db.body_with_source_map(def);

let scopes = db.expr_scopes(def);

let scope = match offset {

};

let resolver = resolver_for_scope(db.upcast(), def, scope);

}

pub(crate) fn new_for_resolver(

return resolved;

}

let ctx = LowerCtx::new(db.upcast(), self.file_id);

let hir_path = Path::from_src(&ctx, path.clone())?;

}

fn scope_for(

scopes: &ExprScopes,

source_map: &BodySourceMap,

node: InFile<&SyntaxNode>,

) -> Option<ScopeId> {

.find_map(|it| scopes.scope_for(it))

}

Some(it.file_id.macro_file()?.call_node(db.upcast()))

})

.find(|it| it.file_id == from_file)

})

.filter(|(expr_range, _scope)| expr_range.start() <= offset && offset <= expr_range.end())

// find containing scope

Expr::FamousType { ty: Type::new(db, module.id, TyBuilder::unit()), value: "()" },

]

.into_iter()

lookup.insert(exprs.ty(db), std::iter::once(exprs.clone()));

})

.filter(|expr| expr.ty(db).could_unify_with_deeply(db, &ctx.goal))

}

let usages = definition.usages(&ctx.sema).all();

add_enum_def(edit, ctx, &usages, target_node, &target_module);

},

)

}

usages: UsageSearchResult,

target_definition: Definition,

target_module: &hir::Module,

) {

for (file_id, references) in usages {

edit.edit_file(file_id);

def.usages(&ctx.sema).all(),

target_definition,

target_module,

)

}

} else if let Some(initializer) = find_assignment_usage(&name) {

def.usages(&ctx.sema).all(),

target_definition,

target_module,

)

}

}

ImportScope::Module(it) => ImportScope::Module(edit.make_mut(it)),

ImportScope::Block(it) => ImportScope::Block(edit.make_mut(it)),

};

}

},

)

let mut seen_rust_tags = false;

let mut seen_other_tags = false;

for token in tokens {

match token {

let function = id;

(

format!("`fn {redundant_assoc_item_name}`"),

format!("\n {};", function.display(db)),

)

}

let constant = id;

(

format!("`const {redundant_assoc_item_name}`"),

format!("\n {};", constant.display(db)),

)

}

let type_alias = id;

(

format!("`type {redundant_assoc_item_name}`"),

format!("\n type {};", type_alias.name(ctx.sema.db).to_smol_str()),

)

}

}

impl Runnable {

pub fn label(&self, target: Option<&str>) -> String {

match &self.kind {

RunnableKind::Test { test_id, .. } => format!("test {test_id}"),

RunnableKind::Bench { test_id } => format!("bench {test_id}"),

RunnableKind::DocTest { test_id, .. } => format!("doctest {test_id}"),

RunnableKind::Bin => {

}

}

}

}

}

fn has_runnable_doc_test(attrs: &hir::Attrs) -> bool {

docs_from_attrs(attrs).map_or(false, |doc| {

let mut in_code_block = false;

<span class="brace">}</span>

<span class="brace">}</span>

<span class="macro default_library library">include</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="macro default_library library macro">concat</span><span class="macro_bang macro">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"foo/"</span><span class="string_literal macro">,</span> <span class="string_literal macro">"foo.rs"</span><span class="parenthesis macro">)</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>

<span class="macro default_library library">format_args</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal macro">!"</span><span class="comma macro">,</span> <span class="parenthesis macro">(</span><span class="numeric_literal macro">92</span><span class="comma macro">,</span><span class="parenthesis macro">)</span><span class="operator macro">.</span><span class="field library macro">0</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

<span class="macro">dont_color_me_braces</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

<span class="macro">noop</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="macro macro">noop</span><span class="macro_bang macro">!</span><span class="parenthesis macro">(</span><span class="numeric_literal macro">1</span><span class="parenthesis macro">)</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

}

}

include!(concat!("foo/", "foo.rs"));

fn main() {

format_args!("Hello, {}!", (92,).0);

dont_color_me_braces!();

noop!(noop!(1));

if let Some(src) = source {

let original_file = src.file_id.original_file(db);

let path = vfs.file_path(original_file);

format!("processing: {} ({} {:?})", full_name(), path, syntax_range)

} else {

format!("processing: {}", full_name())

if let Some(src) = source {

let original_file = src.file_id.original_file(db);

let path = vfs.file_path(original_file);

format!("processing: {} ({} {:?})", full_name(), path, syntax_range)

} else {

format!("processing: {}", full_name())

for idx in url_offsets {

let link = &schema[idx..];

// matching on whitespace to ignore normal links

if link.chars().nth(link_end) == Some('[') {

if let Some(link_text_end) = link.find(']') {

let link_text = link[link_end..(link_text_end + 1)].to_string();

}

fn recv(&self) -> Result<Option<Message>, Timeout> {

let msg = recv_timeout(&self.client.receiver)?;

self.messages.borrow_mut().push(msg.clone());

});

Ok(msg)

}

let meta = cmd!(sh, "cargo metadata --format-version 1").read().unwrap();

let mut licenses = meta

.filter(|it| it.contains(r#""license""#))

.map(|it| it.trim())

.map(|it| it[r#""license":"#.len()..].trim_matches('"'))

}

let range = TextRange::at(offset, len.try_into().unwrap());

let line_no_caret = &line[len..];

let next = line_no_caret.find(marker).map_or(line.len(), |it| it + len);

let cond = |end_marker| {

if diagnostic.chars().any(|c| c.is_ascii_uppercase()) {

return Err("Diagnostic names can't contain uppercase symbols".into());

}

return Err("Diagnostic can't contain non-ASCII symbols".into());

}

// Fetch given rustc commit.

cmd!(sh, "git fetch http://localhost:{JOSH_PORT}/rust-lang/rust.git@{commit}{JOSH_FILTER}.git")

.run()

// Try to un-do the previous `git commit`, to leave the repo in the state we found it it.

cmd!(sh, "git reset --hard HEAD^")

.run()

.expect("FAILED to clean up again after failed `git fetch`, sorry for that");

})

.context("FAILED to fetch new commits, something went wrong (committing the rust-version file has been undone)")?;