+use mbe::syntax_node_to_token_tree;

+use span::{AstIdMap, Span, SyntaxContextData, SyntaxContextId};

+use syntax::{ast, AstNode, Parse, SyntaxElement, SyntaxError, SyntaxNode, SyntaxToken, T};

+ attrs::{collect_attrs, AttrId},

+ cfg_process,

+ fixup::{self, SyntaxFixupUndoInfo},

+ fn macro_arg(&self, id: MacroCallId) -> (Arc<tt::Subtree>, SyntaxFixupUndoInfo, Span);

+ /// Retrieves the span to be used for a proc-macro expansions spans.

+ /// This is a firewall query as it requires parsing the file, which we don't want proc-macros to

+ /// directly depend on as that would cause to frequent invalidations, mainly because of the

+ /// parse queries being LRU cached. If they weren't the invalidations would only happen if the

+ /// user wrote in the file that defines the proc-macro.

+ fn proc_macro_span(&self, fun: AstId<ast::Fn>) -> Span;

+ // FIXME: This BOGUS here is dangerous once the proc-macro server can call back into the database!

+ let (_, _, span) = db.macro_arg(actual_macro_call);

+

+ mbe::syntax_node_to_token_tree(speculative_args, span_map, span),

+ SyntaxFixupUndoInfo::NONE,

+ ),

+ MacroCallKind::Attr { .. } if loc.def.is_attribute_derive() => (

+ mbe::syntax_node_to_token_tree(speculative_args, span_map, span),

+ MacroCallKind::Derive { derive_attr_index: index, .. }

+ | MacroCallKind::Attr { invoc_attr_index: index, .. } => {

+ let censor = if let MacroCallKind::Derive { .. } = loc.kind {

+ censor_derive_input(index, &ast::Adt::cast(speculative_args.clone())?)

+ } else {

+ attr_source(index, &ast::Item::cast(speculative_args.clone())?)

+ .into_iter()

+ .map(|it| it.syntax().clone().into())

+ .collect()

+ };

+

+ let censor_cfg =

+ cfg_process::process_cfg_attrs(speculative_args, &loc, db).unwrap_or_default();

+ let mut fixups = fixup::fixup_syntax(span_map, speculative_args, span);

+ it => !censor.contains(it) && !censor_cfg.contains(it),

+ fixups.remove.extend(censor_cfg);

+

+ span,

+ let mut tree = syntax_node_to_token_tree(token_tree.syntax(), span_map, span);

+ tree.delimiter = tt::Delimiter::invisible_spanned(span);

+ MacroDefKind::ProcMacro(expander, _, ast) => {

+ let span = db.proc_macro_span(ast);

+ tt.delimiter = tt::Delimiter::invisible_spanned(span);

+ span_with_def_site_ctxt(db, span, actual_macro_call),

+ span_with_call_site_ctxt(db, span, actual_macro_call),

+ span_with_mixed_site_ctxt(db, span, actual_macro_call),

+ pseudo_derive_attr_expansion(&tt, attr_arg.as_ref()?, span)

+ }

+ MacroDefKind::Declarative(it) => {

+ db.decl_macro_expander(loc.krate, it).expand_unhygienic(db, tt, loc.def.krate, span)

+ }

+ MacroDefKind::BuiltIn(it, _) => {

+ it.expand(db, actual_macro_call, &tt, span).map_err(Into::into)

+ it.expand(db, actual_macro_call, &tt, span).map_err(Into::into)

+ it.expand(db, actual_macro_call, &tt, span).map_err(Into::into)

+ MacroDefKind::BuiltInAttr(it, _) => it.expand(db, actual_macro_call, &tt, span),

+// FIXME: for derive attributes, this will return separate copies of the same structures! Though

+// they may differ in spans due to differing call sites...

+) -> (Arc<tt::Subtree>, SyntaxFixupUndoInfo, Span) {

+

+ if let MacroCallLoc {

+ def: MacroDefId { kind: MacroDefKind::BuiltInEager(..), .. },

+ kind: MacroCallKind::FnLike { eager: Some(eager), .. },

+ ..

+ } = &loc

+ return (eager.arg.clone(), SyntaxFixupUndoInfo::NONE, eager.span);

+ }

+ let (parse, map) = parse_with_map(db, loc.kind.file_id());

+ let root = parse.syntax_node();

+

+ let (censor, item_node, span) = match loc.kind {

+ MacroCallKind::FnLike { ast_id, .. } => {

+ let node = &ast_id.to_ptr(db).to_node(&root);

+ let path_range = node

+ .path()

+ .map_or_else(|| node.syntax().text_range(), |path| path.syntax().text_range());

+ let span = map.span_for_range(path_range);

+

+ let dummy_tt = |kind| {

+ Arc::new(tt::Subtree {

+ delimiter: tt::Delimiter { open: span, close: span, kind },

+ token_trees: Box::default(),

+ }),

+ SyntaxFixupUndoInfo::default(),

+ span,

+ };

+ let Some(tt) = node.token_tree() else {

+ return dummy_tt(tt::DelimiterKind::Invisible);

+ };

+ let first = tt.left_delimiter_token().map(|it| it.kind()).unwrap_or(T!['(']);

+ let last = tt.right_delimiter_token().map(|it| it.kind()).unwrap_or(T![.]);

+

+ let mismatched_delimiters = !matches!(

+ (first, last),

+ (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}'])

+ );

+ if mismatched_delimiters {

+ // Don't expand malformed (unbalanced) macro invocations. This is

+ // less than ideal, but trying to expand unbalanced macro calls

+ // sometimes produces pathological, deeply nested code which breaks

+ // all kinds of things.

+ //

+ // So instead, we'll return an empty subtree here

+ cov_mark::hit!(issue9358_bad_macro_stack_overflow);

+

+ let kind = match first {

+ _ if loc.def.is_proc_macro() => tt::DelimiterKind::Invisible,

+ T!['('] => tt::DelimiterKind::Parenthesis,

+ T!['['] => tt::DelimiterKind::Bracket,

+ T!['{'] => tt::DelimiterKind::Brace,

+ _ => tt::DelimiterKind::Invisible,

+ };

+ return dummy_tt(kind);

+ }

+ let mut tt = mbe::syntax_node_to_token_tree(tt.syntax(), map.as_ref(), span);

+ if loc.def.is_proc_macro() {

+ // proc macros expect their inputs without parentheses, MBEs expect it with them included

+ tt.delimiter.kind = tt::DelimiterKind::Invisible;

+ return (Arc::new(tt), SyntaxFixupUndoInfo::NONE, span);

+ }

+ MacroCallKind::Derive { ast_id, derive_attr_index, .. } => {

+ let node = ast_id.to_ptr(db).to_node(&root);

+ let censor_derive_input = censor_derive_input(derive_attr_index, &node);

+ let item_node = node.into();

+ let attr_source = attr_source(derive_attr_index, &item_node);

+ // FIXME: This is wrong, this should point to the path of the derive attribute`

+ let span =

+ map.span_for_range(attr_source.as_ref().and_then(|it| it.path()).map_or_else(

+ || item_node.syntax().text_range(),

+ |it| it.syntax().text_range(),

+ ));

+ (censor_derive_input, item_node, span)

+ }

+ MacroCallKind::Attr { ast_id, invoc_attr_index, .. } => {

+ let node = ast_id.to_ptr(db).to_node(&root);

+ let attr_source = attr_source(invoc_attr_index, &node);

+ let span = map.span_for_range(

+ attr_source

+ .as_ref()

+ .and_then(|it| it.path())

+ .map_or_else(|| node.syntax().text_range(), |it| it.syntax().text_range()),

+ );

+ (attr_source.into_iter().map(|it| it.syntax().clone().into()).collect(), node, span)

+ };

+

+ let (mut tt, undo_info) = {

+ let syntax = item_node.syntax();

+ let censor_cfg = cfg_process::process_cfg_attrs(syntax, &loc, db).unwrap_or_default();

+ let mut fixups = fixup::fixup_syntax(map.as_ref(), syntax, span);

+ fixups.append.retain(|it, _| match it {

+ syntax::NodeOrToken::Token(_) => true,

+ it => !censor.contains(it) && !censor_cfg.contains(it),

+ });

+ fixups.remove.extend(censor);

+ fixups.remove.extend(censor_cfg);

+

+ (

+ mbe::syntax_node_to_token_tree_modified(

+ syntax,

+ map,

+ fixups.append,

+ fixups.remove,

+ span,

+ ),

+ fixups.undo_info,

+ )

+ };

+

+ if loc.def.is_proc_macro() {

+ // proc macros expect their inputs without parentheses, MBEs expect it with them included

+ tt.delimiter.kind = tt::DelimiterKind::Invisible;

+

+ (Arc::new(tt), undo_info, span)

+/// Derives expect all `#[derive(..)]` invocations up to (and including) the currently invoked one to be stripped

+fn censor_derive_input(derive_attr_index: AttrId, node: &ast::Adt) -> FxHashSet<SyntaxElement> {

+ cov_mark::hit!(derive_censoring);

+ collect_attrs(node)

+ .take(derive_attr_index.ast_index() + 1)

+ .filter_map(|(_, attr)| Either::left(attr))

+ // FIXME, this resolution should not be done syntactically

+ // derive is a proper macro now, no longer builtin

+ // But we do not have resolution at this stage, this means

+ // we need to know about all macro calls for the given ast item here

+ // so we require some kind of mapping...

+ .filter(|attr| attr.simple_name().as_deref() == Some("derive"))

+ .map(|it| it.syntax().clone().into())

+ .collect()

+}

+

+/// Attributes expect the invoking attribute to be stripped

+fn attr_source(invoc_attr_index: AttrId, node: &ast::Item) -> Option<ast::Attr> {

+ // FIXME: handle `cfg_attr`

+ cov_mark::hit!(attribute_macro_attr_censoring);

+ collect_attrs(node).nth(invoc_attr_index.ast_index()).and_then(|(_, attr)| Either::left(attr))

+ let (ExpandResult { value: tt, err }, span) = match loc.def.kind {

+ let (macro_arg, undo_info, span) = db.macro_arg(macro_call_id);

+ let res =

+ match loc.def.kind {

+ MacroDefKind::Declarative(id) => db

+ .decl_macro_expander(loc.def.krate, id)

+ .expand(db, arg.clone(), macro_call_id, span),

+ MacroDefKind::BuiltIn(it, _) => {

+ it.expand(db, macro_call_id, arg, span).map_err(Into::into)

+ }

+ MacroDefKind::BuiltInDerive(it, _) => {

+ it.expand(db, macro_call_id, arg, span).map_err(Into::into)

+ }

+ MacroDefKind::BuiltInEager(it, _) => {

+ // This might look a bit odd, but we do not expand the inputs to eager macros here.

+ // Eager macros inputs are expanded, well, eagerly when we collect the macro calls.

+ // That kind of expansion uses the ast id map of an eager macros input though which goes through

+ // the HirFileId machinery. As eager macro inputs are assigned a macro file id that query

+ // will end up going through here again, whereas we want to just want to inspect the raw input.

+ // As such we just return the input subtree here.

+ let eager = match &loc.kind {

+ MacroCallKind::FnLike { eager: None, .. } => {

+ return ExpandResult::ok(CowArc::Arc(macro_arg.clone()));

+ }

+ MacroCallKind::FnLike { eager: Some(eager), .. } => Some(&**eager),

+ _ => None,

+ };

+

+ let mut res = it.expand(db, macro_call_id, arg, span).map_err(Into::into);

+

+ if let Some(EagerCallInfo { error, .. }) = eager {

+ // FIXME: We should report both errors!

+ res.err = error.clone().or(res.err);

+ }

+ res

+ }

+ MacroDefKind::BuiltInAttr(it, _) => {

+ let mut res = it.expand(db, macro_call_id, arg, span);

+ fixup::reverse_fixups(&mut res.value, &undo_info);

+ res

+ }

+ _ => unreachable!(),

+ };

+ (ExpandResult { value: res.value, err: res.err }, span)

+ delimiter: tt::Delimiter::invisible_spanned(span),

+fn proc_macro_span(db: &dyn ExpandDatabase, ast: AstId<ast::Fn>) -> Span {

+ let root = db.parse_or_expand(ast.file_id);

+ let ast_id_map = &db.ast_id_map(ast.file_id);

+ let span_map = &db.span_map(ast.file_id);

+

+ let node = ast_id_map.get(ast.value).to_node(&root);

+ let range = ast::HasName::name(&node)

+ .map_or_else(|| node.syntax().text_range(), |name| name.syntax().text_range());

+ span_map.span_for_range(range)

+}

+

+ let (macro_arg, undo_info, span) = db.macro_arg(id);

+ let (expander, ast) = match loc.def.kind {

+ MacroDefKind::ProcMacro(expander, _, ast) => (expander, ast),

+ let ExpandResult { value: mut tt, err } = {

+ let span = db.proc_macro_span(ast);

+ expander.expand(

+ db,

+ loc.def.krate,

+ loc.krate,

+ &macro_arg,

+ attr_arg,

+ span_with_def_site_ctxt(db, span, id),

+ span_with_call_site_ctxt(db, span, id),

+ span_with_mixed_site_ctxt(db, span, id),

+ )

+ };

+ delimiter: tt::Delimiter::invisible_spanned(span),