let krate = loc.container.krate;

let item_tree = loc.id.item_tree(db);

let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());

let mut flags = StructFlags::NO_FLAGS;

if attrs.by_key("rustc_has_incoherent_inherent_impls").exists() {

let krate = loc.container.krate;

let item_tree = loc.id.item_tree(db);

let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());

let mut flags = StructFlags::NO_FLAGS;

if attrs.by_key("rustc_has_incoherent_inherent_impls").exists() {

flags |= StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPL;

kind: kind(loc.expander, loc.id.file_id(), makro.ast_id.upcast()),

local_inner: false,

allow_internal_unsafe: loc.allow_internal_unsafe,

edition: loc.edition,

}

}

MacroId::MacroRulesId(it) => {

let loc: MacroRulesLoc = it.lookup(db);

allow_internal_unsafe: loc

.flags

.contains(MacroRulesLocFlags::ALLOW_INTERNAL_UNSAFE),

edition: loc.edition,

}

}

),

local_inner: false,

allow_internal_unsafe: false,

span: db

.span_map(loc.id.file_id())

.span_for_range(db.ast_id_map(loc.id.file_id()).get(makro.ast_id).text_range()),

pub path: Interned<ModPath>,

pub ast_id: FileAstId<ast::MacroCall>,

pub expand_to: ExpandTo,

pub call_site: Span,

}

/// The name of the declared macro.

pub name: Name,

pub ast_id: FileAstId<ast::MacroRules>,

}

/// "Macros 2.0" macro definition.

pub name: Name,

pub visibility: RawVisibilityId,

pub ast_id: FileAstId<ast::MacroDef>,

}

impl Use {

fn lower_macro_call(&mut self, m: &ast::MacroCall) -> Option<FileItemTreeId<MacroCall>> {

let span_map = self.span_map();

span_map.span_for_range(range).ctx

})?);

let ast_id = self.source_ast_id_map.ast_id(m);

let expand_to = hir_expand::ExpandTo::from_call_site(m);

Some(id(self.data().macro_calls.alloc(res)))

}

fn lower_macro_rules(&mut self, m: &ast::MacroRules) -> Option<FileItemTreeId<MacroRules>> {

let ast_id = self.source_ast_id_map.ast_id(m);

Some(id(self.data().macro_rules.alloc(res)))

}

fn lower_macro_def(&mut self, m: &ast::MacroDef) -> Option<FileItemTreeId<Macro2>> {

let ast_id = self.source_ast_id_map.ast_id(m);

let visibility = self.lower_visibility(m);

Some(id(self.data().macro_defs.alloc(res)))

}

wln!(self, "{}!(...);", path.display(self.db.upcast()));

}

ModItem::MacroRules(it) => {

wln!(self, "macro_rules! {} {{ ... }}", name.display(self.db.upcast()));

}

ModItem::Macro2(it) => {

self.print_visibility(*visibility);

wln!(self, "macro {} {{ ... }}", name.display(self.db.upcast()));

}

m!();

"#,

expect![[r#"

macro_rules! m { ... }

pub macro m2 { ... }

m!(...);

"#]],

);

let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value));

let span_map = db.span_map(self.file_id);

let path = self.value.path().and_then(|path| {

span_map.as_ref().span_for_range(range).ctx

});

return Ok(ExpandResult::only_err(ExpandError::other("malformed macro invocation")));

};

macro_call_as_call_id_with_eager(

db,

&AstIdWithPath::new(ast_id.file_id, ast_id.value, path),

}

fn main(foo: ()) {

}

}

span_map: SpanMapRef<'_>,

id: AttrId,

) -> Option<Attr> {

span_map.span_for_range(range).ctx

})?);

let input = if let Some(ast::Expr::Literal(lit)) = ast.expr() {

let value = match lit.kind() {

ast::LiteralKind::String(string) => string.value()?.into(),

};

macro_rules! register_builtin {

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

$($kind),*

}

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

$($e_kind),*

}

pub fn is_include(&self) -> bool {

matches!(self, EagerExpander::Include)

}

}

pub fn find_builtin_macro(

}

register_builtin! {

(column, Column) => line_expand,

(file, File) => file_expand,

(line, Line) => line_expand,

(format_args_nl, FormatArgsNl) => format_args_nl_expand,

(quote, Quote) => quote_expand,

(compile_error, CompileError) => compile_error_expand,

(concat, Concat) => concat_expand,

(concat_idents, ConcatIdents) => concat_idents_expand,

}

}

let lit = ast::make::tokens::literal(&lit.to_string());

let token = ast::String::cast(lit)?;

}

let lit = ast::make::tokens::literal(&lit.to_string());

let token = ast::Char::cast(lit)?;

}

let lit = ast::make::tokens::literal(&lit.to_string());

let token = ast::ByteString::cast(lit)?;

}

fn compile_error_expand(

) -> ExpandResult<tt::Subtree> {

let err = match &*tt.token_trees {

[tt::TokenTree::Leaf(tt::Leaf::Literal(it))] => match unquote_str(it) {

None => ExpandError::other("`compile_error!` argument must be a string"),

},

_ => ExpandError::other("`compile_error!` argument must be a string"),

_db: &dyn ExpandDatabase,

_arg_id: MacroCallId,

tt: &tt::Subtree,

) -> ExpandResult<tt::Subtree> {

let mut err = None;

let mut text = String::new();

for (i, mut t) in tt.token_trees.iter().enumerate() {

// FIXME: hack on top of a hack: `$e:expr` captures get surrounded in parentheses

// to ensure the right parsing order, so skip the parentheses here. Ideally we'd

// concat works with string and char literals, so remove any quotes.

// It also works with integer, float and boolean literals, so just use the rest

// as-is.

text.push(c);

} else {

text.push_str(&component);

}

}

// handle boolean literals

if i % 2 == 0 && (id.text == "true" || id.text == "false") =>

{

text.push_str(id.text.as_str());

}

tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),

_ => {

}

}

}

ExpandResult { value: quote!(span =>#text), err }

}

_db: &dyn ExpandDatabase,

_arg_id: MacroCallId,

tt: &tt::Subtree,

) -> ExpandResult<tt::Subtree> {

let mut bytes = Vec::new();

let mut err = None;

for (i, t) in tt.token_trees.iter().enumerate() {

match t {

tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => {

let token = ast::make::tokens::literal(&lit.to_string());

match token.kind() {

syntax::SyntaxKind::BYTE => bytes.push(token.text().to_owned()),

syntax::SyntaxKind::BYTE_STRING => {

components.into_iter().for_each(|it| bytes.push(it.to_string()));

}

_ => {

}

tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),

tt::TokenTree::Subtree(tree) if tree.delimiter.kind == tt::DelimiterKind::Bracket => {

err.get_or_insert(e);

break;

}

}

}

let value = tt::Subtree {

token_trees: {

Itertools::intersperse_with(

bytes.into_iter().map(|it| {

}),

|| {

tt::TokenTree::Leaf(tt::Leaf::Punct(tt::Punct {

char: ',',

spacing: tt::Spacing::Alone,

}))

},

)

fn concat_bytes_expand_subtree(

tree: &tt::Subtree,

bytes: &mut Vec<String>,

) -> Result<(), ExpandError> {

for (ti, tt) in tree.token_trees.iter().enumerate() {

match tt {

match lit.kind() {

syntax::SyntaxKind::BYTE | syntax::SyntaxKind::INT_NUMBER => {

bytes.push(lit.text().to_owned())

}

_ => {

}

}

tt.token_trees

.first()

.and_then(|tt| match tt {

arg_id: MacroCallId,

arg: &tt::Subtree,

) -> Result<FileId, ExpandError> {

}

fn include_bytes_expand(

tt: &tt::Subtree,

span: Span,

) -> ExpandResult<tt::Subtree> {

Ok(it) => it,

Err(e) => {

return ExpandResult::new(tt::Subtree::empty(DelimSpan { open: span, close: span }), e)

tt: &tt::Subtree,

span: Span,

) -> ExpandResult<tt::Subtree> {

Ok(it) => it,

Err(e) => {

return ExpandResult::new(tt::Subtree::empty(DelimSpan { open: span, close: span }), e)

db: &dyn ExpandDatabase,

arg_id: MacroCallId,

tt: &tt::Subtree,

) -> ExpandResult<tt::Subtree> {

Ok(it) => it,

Err(e) => {

}

};

let expanded = match get_env_inner(db, arg_id, &key) {

};

ExpandResult::ok(expanded)

}

pub trait MacroFileIdExt {

fn expansion_level(self, db: &dyn ExpandDatabase) -> u32;

/// If this is a macro call, returns the syntax node of the call.

fn call_node(self, db: &dyn ExpandDatabase) -> InFile<SyntaxNode>;

db.lookup_intern_macro_call(self.macro_call_id).def.is_include()

}

fn is_eager(&self, db: &dyn ExpandDatabase) -> bool {

matches!(loc.def.kind, MacroDefKind::BuiltInEager(..))

}

fn is_attr_macro(&self, db: &dyn ExpandDatabase) -> bool {

matches!(loc.kind, MacroCallKind::Attr { .. })

}

fn is_derive_attr_pseudo_expansion(&self, db: &dyn ExpandDatabase) -> bool {

loc.def.is_attribute_derive()

}

}

pub fn is_include(&self) -> bool {

matches!(self.kind, MacroDefKind::BuiltInEager(expander, ..) if expander.is_include())

}

}

impl MacroCallLoc {

/// ExpansionInfo mainly describes how to map text range between src and expanded macro

// FIXME: can be expensive to create, we should check the use sites and maybe replace them with

// simpler function calls if the map is only used once

pub struct ExpansionInfo {

pub expanded: InMacroFile<SyntaxNode>,

/// The argument TokenTree or item for attributes

/// Maps the passed in file range down into a macro expansion if it is the input to a macro call.

///

/// Note this does a linear search through the entire backing vector of the spanmap.

pub fn map_range_down(

&self,

span: Span,

InFile::new(

self.arg.file_id,

arg_map

.filter(|range| range.intersect(arg_range).is_some())

.collect(),

)

let quoted = quote!(DUMMY =>#a);

assert_eq!(quoted.to_string(), "hello");

expect![[r#"

}

#[test]

//! Span maps for real files and macro expansions.

use span::{FileId, HirFileId, HirFileIdRepr, MacroFileId, Span, SyntaxContextId};

use syntax::{AstNode, TextRange};

use triomphe::Arc;

}

}

pub fn is_attr(&self, db: &dyn HirDatabase) -> bool {

matches!(self.kind(db), MacroKind::Attr)

}

.filter(|&(_, include_file_id)| include_file_id == file_id)

{

let macro_file = invoc.as_macro_file();

// Create the source analyzer for the macro call scope

let Some(sa) = self.analyze_no_infer(&self.parse_or_expand(expansion_info.call_file()))

else {

continue;

};

// get mapped token in the include! macro file

let span = span::SpanData {

ctx: SyntaxContextId::ROOT,

};

let Some(InMacroFile { file_id, value: mut mapped_tokens }) =

else {

continue;

};

let def_map = sa.resolver.def_map();

let mut stack: Vec<(_, SmallVec<[_; 2]>)> = vec![(file_id, smallvec![token])];

let mut process_expansion_for_token = |stack: &mut Vec<_>, macro_file| {

self.cache(value, file_id.into());

let mapped_tokens: SmallVec<[_; 2]> = mapped_tokens.collect();

let res = mapped_tokens.is_empty().not().then_some(());

// requeue the tokens we got from mapping our current token down

stack.push((HirFileId::from(file_id), mapped_tokens));

// remove any other token in this macro input, all their mappings are the

// same as this one

tokens.retain(|t| !text_range.contains_range(t.text_range()));

} else if let Some(meta) = ast::Meta::cast(parent) {

// attribute we failed expansion for earlier, this might be a derive invocation

// or derive helper attribute

//! Completes environment variables defined by Cargo (https://doc.rust-lang.org/cargo/reference/environment-variables.html)

use crate::{

completions::Completions, context::CompletionContext, CompletionItem, CompletionItemKind,

pub(crate) fn complete_cargo_env_vars(

acc: &mut Completions,

ctx: &CompletionContext<'_>,

expanded: &ast::String,

) -> Option<()> {

CARGO_DEFINED_VARS.iter().for_each(|&(var, detail)| {

let mut item = CompletionItem::new(CompletionItemKind::Keyword, range, var);

Some(())

}

#[cfg(test)]

mod tests {

use crate::tests::{check_edit, completion_list};

&format!(

r#"

#[rustc_builtin_macro]

($var:literal) => {{ 0 }}

}}

&format!(

r#"

#[rustc_builtin_macro]

($var:literal) => {{ 0 }}

}}

CompletionAnalysis::String { original, expanded: Some(expanded) } => {

completions::extern_abi::complete_extern_abi(acc, ctx, expanded);

completions::format_string::format_string(acc, ctx, original, expanded);

}

CompletionAnalysis::UnexpandedAttrTT {

colon_prefix,

use crate::{

doc_links::token_as_doc_comment, navigation_target::ToNav, FilePosition, NavigationTarget,

RangeInfo, TryToNav,

};

use ide_db::{

base_db::{AnchoredPath, FileId, FileLoader},

defs::{Definition, IdentClass},

.filter_map(|token| {

let parent = token.parent()?;

return Some(vec![x]);

}

if let Some(x) = try_lookup_macro_def_in_macro_use(sema, token) {

return Some(vec![x]);

}

fn try_lookup_include_path(

sema: &Semantics<'_, RootDatabase>,

file_id: FileId,

) -> Option<NavigationTarget> {

return None;

}

let file_id = sema.db.resolve_path(AnchoredPath { anchor: file_id, path: &path })?;

let size = sema.db.file_text(file_id).len().try_into().ok()?;

}

#[test]

fn goto_doc_include_str() {

check(

r#"

<span class="brace">}</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>

#[test]

fn test_derive_empty() {

}

#[test]

IDENT compile_error 1

PUNCH ! [alone] 1

SUBTREE () 1 1

PUNCH ; [alone] 1"##]],

expect![[r##"

);

}

SUBTREE $$ 1 1

IDENT ident 1

PUNCH , [alone] 1

PUNCH , [alone] 1

PUNCH , [alone] 1

SUBTREE [] 1 1"#]],

expect![[r#"

);

}

PUNCH , [alone] 1

SUBTREE [] 1 1"#]],

expect![[r#"

);

}

SUBTREE $$ 1 1

IDENT r#async 1"#]],

expect![[r#"

);

}

SUBTREE $$ 1 1

IDENT r#joined 1"#]],

expect![[r#"

);

}

IDENT resolved_at_def_site 1

IDENT start_span 1"#]],

expect![[r#"

);

}

r#""#,

expect![[r#"

SUBTREE $$ 1 1

expect![[r#"

);

}

IDENT standard 1

IDENT r#raw 1"#]],

expect![[r#"

);

}

r###"1u16, 2_u32, -4i64, 3.14f32, "hello bridge", "suffixed"suffix, r##"raw"##, 'a', b'b', c"null""###,

expect![[r###"

SUBTREE $$ 1 1

PUNCH , [alone] 1

PUNCH , [alone] 1

PUNCH - [alone] 1

PUNCH , [alone] 1

PUNCH , [alone] 1

PUNCH , [alone] 1

PUNCH , [alone] 1

PUNCH , [alone] 1

PUNCH , [alone] 1

PUNCH , [alone] 1

expect![[r###"

);

}

IDENT compile_error 1

PUNCH ! [alone] 1

SUBTREE () 1 1

PUNCH ; [alone] 1"##]],

expect![[r##"

);

}

let res = expander

.expand(macro_name, fixture.into_subtree(call_site), attr, def_site, call_site, mixed_site)

.unwrap();

}

pub(crate) fn list() -> Vec<String> {

use crate::MacroCallId;

/// Interned [`SyntaxContextData`].

pub struct SyntaxContextId(InternId);

impl salsa::InternKey for SyntaxContextId {

fn from_intern_id(v: salsa::InternId) -> Self {

SyntaxContextId(v)

pub type Span = SpanData<SyntaxContextId>;

pub struct SpanData<Ctx> {

/// The text range of this span, relative to the anchor.

/// We need the anchor for incrementality, as storing absolute ranges will require

pub ctx: Ctx,

}

impl<Ctx: Copy> SpanData<Ctx> {

pub fn eq_ignoring_ctx(self, other: Self) -> bool {

self.anchor == other.anchor && self.range == other.range

//! A map that maps a span to every position in a file. Usually maps a span to some range of positions.

//! Allows bidirectional lookup.

use stdx::{always, itertools::Itertools};

use syntax::{TextRange, TextSize};

/// Returns all [`TextRange`]s that correspond to the given span.

///

/// Note this does a linear search through the entire backing vector.

where

S: Copy,

{

})

}

/// Returns the span at the given position.

pub fn span_at(&self, offset: TextSize) -> SpanData<S> {

let entry = self.spans.partition_point(|&(it, _)| it <= offset);

end: TextSize,

}

impl RealSpanMap {

/// Creates a real file span map that returns absolute ranges (relative ranges to the root ast id).

pub fn absolute(file_id: FileId) -> Self {

mod tests {

use super::*;

#[test]

fn test_varieties() {

fn assert_send<T: Send>() {}

let align = " ".repeat(level);

let Delimiter { kind, open, close } = &subtree.delimiter;

};

for (idx, child) in subtree.token_trees.iter().enumerate() {

print_debug_token(f, child, level + 1)?;

if idx != subtree.token_trees.len() - 1 {

match tkn {

TokenTree::Leaf(leaf) => match leaf {

},

TokenTree::Subtree(subtree) => {

print_debug_subtree(f, subtree, level)?;