]>
Commit | Line | Data |
---|---|---|
064997fb FG |
1 | //! Defines database & queries for macro expansion. |
2 | ||
3 | use std::sync::Arc; | |
4 | ||
5 | use base_db::{salsa, SourceDatabase}; | |
6 | use either::Either; | |
7 | use limit::Limit; | |
8 | use mbe::syntax_node_to_token_tree; | |
9 | use rustc_hash::FxHashSet; | |
10 | use syntax::{ | |
11 | ast::{self, HasAttrs, HasDocComments}, | |
12 | AstNode, GreenNode, Parse, SyntaxNode, SyntaxToken, T, | |
13 | }; | |
14 | ||
15 | use crate::{ | |
16 | ast_id_map::AstIdMap, builtin_attr_macro::pseudo_derive_attr_expansion, fixup, | |
17 | hygiene::HygieneFrame, BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander, | |
18 | ExpandError, ExpandResult, ExpandTo, HirFileId, HirFileIdRepr, MacroCallId, MacroCallKind, | |
19 | MacroCallLoc, MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander, | |
20 | }; | |
21 | ||
22 | /// Total limit on the number of tokens produced by any macro invocation. | |
23 | /// | |
24 | /// If an invocation produces more tokens than this limit, it will not be stored in the database and | |
25 | /// an error will be emitted. | |
26 | /// | |
27 | /// Actual max for `analysis-stats .` at some point: 30672. | |
28 | static TOKEN_LIMIT: Limit = Limit::new(524_288); | |
29 | ||
30 | #[derive(Debug, Clone, Eq, PartialEq)] | |
31 | pub enum TokenExpander { | |
32 | /// Old-style `macro_rules` or the new macros 2.0 | |
33 | DeclarativeMacro { mac: mbe::DeclarativeMacro, def_site_token_map: mbe::TokenMap }, | |
34 | /// Stuff like `line!` and `file!`. | |
35 | Builtin(BuiltinFnLikeExpander), | |
36 | /// `global_allocator` and such. | |
37 | BuiltinAttr(BuiltinAttrExpander), | |
38 | /// `derive(Copy)` and such. | |
39 | BuiltinDerive(BuiltinDeriveExpander), | |
40 | /// The thing we love the most here in rust-analyzer -- procedural macros. | |
41 | ProcMacro(ProcMacroExpander), | |
42 | } | |
43 | ||
44 | impl TokenExpander { | |
45 | fn expand( | |
46 | &self, | |
47 | db: &dyn AstDatabase, | |
48 | id: MacroCallId, | |
49 | tt: &tt::Subtree, | |
50 | ) -> ExpandResult<tt::Subtree> { | |
51 | match self { | |
52 | TokenExpander::DeclarativeMacro { mac, .. } => mac.expand(tt).map_err(Into::into), | |
53 | TokenExpander::Builtin(it) => it.expand(db, id, tt).map_err(Into::into), | |
54 | TokenExpander::BuiltinAttr(it) => it.expand(db, id, tt), | |
55 | TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt), | |
56 | TokenExpander::ProcMacro(_) => { | |
57 | // We store the result in salsa db to prevent non-deterministic behavior in | |
58 | // some proc-macro implementation | |
59 | // See #4315 for details | |
60 | db.expand_proc_macro(id) | |
61 | } | |
62 | } | |
63 | } | |
64 | ||
65 | pub(crate) fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId { | |
66 | match self { | |
67 | TokenExpander::DeclarativeMacro { mac, .. } => mac.map_id_down(id), | |
68 | TokenExpander::Builtin(..) | |
69 | | TokenExpander::BuiltinAttr(..) | |
70 | | TokenExpander::BuiltinDerive(..) | |
71 | | TokenExpander::ProcMacro(..) => id, | |
72 | } | |
73 | } | |
74 | ||
75 | pub(crate) fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, mbe::Origin) { | |
76 | match self { | |
77 | TokenExpander::DeclarativeMacro { mac, .. } => mac.map_id_up(id), | |
78 | TokenExpander::Builtin(..) | |
79 | | TokenExpander::BuiltinAttr(..) | |
80 | | TokenExpander::BuiltinDerive(..) | |
81 | | TokenExpander::ProcMacro(..) => (id, mbe::Origin::Call), | |
82 | } | |
83 | } | |
84 | } | |
85 | ||
86 | // FIXME: rename to ExpandDatabase | |
87 | #[salsa::query_group(AstDatabaseStorage)] | |
88 | pub trait AstDatabase: SourceDatabase { | |
89 | fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>; | |
90 | ||
91 | /// Main public API -- parses a hir file, not caring whether it's a real | |
92 | /// file or a macro expansion. | |
93 | #[salsa::transparent] | |
94 | fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>; | |
95 | /// Implementation for the macro case. | |
96 | fn parse_macro_expansion( | |
97 | &self, | |
98 | macro_file: MacroFile, | |
99 | ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>>; | |
100 | ||
101 | /// Macro ids. That's probably the tricksiest bit in rust-analyzer, and the | |
102 | /// reason why we use salsa at all. | |
103 | /// | |
104 | /// We encode macro definitions into ids of macro calls, this what allows us | |
105 | /// to be incremental. | |
106 | #[salsa::interned] | |
107 | fn intern_macro_call(&self, macro_call: MacroCallLoc) -> MacroCallId; | |
108 | ||
109 | /// Lowers syntactic macro call to a token tree representation. | |
110 | #[salsa::transparent] | |
111 | fn macro_arg( | |
112 | &self, | |
113 | id: MacroCallId, | |
114 | ) -> Option<Arc<(tt::Subtree, mbe::TokenMap, fixup::SyntaxFixupUndoInfo)>>; | |
115 | /// Extracts syntax node, corresponding to a macro call. That's a firewall | |
116 | /// query, only typing in the macro call itself changes the returned | |
117 | /// subtree. | |
118 | fn macro_arg_text(&self, id: MacroCallId) -> Option<GreenNode>; | |
119 | /// Gets the expander for this macro. This compiles declarative macros, and | |
120 | /// just fetches procedural ones. | |
121 | fn macro_def(&self, id: MacroDefId) -> Result<Arc<TokenExpander>, mbe::ParseError>; | |
122 | ||
123 | /// Expand macro call to a token tree. This query is LRUed (we keep 128 or so results in memory) | |
124 | fn macro_expand(&self, macro_call: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>>; | |
125 | /// Special case of the previous query for procedural macros. We can't LRU | |
126 | /// proc macros, since they are not deterministic in general, and | |
127 | /// non-determinism breaks salsa in a very, very, very bad way. @edwin0cheng | |
128 | /// heroically debugged this once! | |
129 | fn expand_proc_macro(&self, call: MacroCallId) -> ExpandResult<tt::Subtree>; | |
130 | /// Firewall query that returns the error from the `macro_expand` query. | |
131 | fn macro_expand_error(&self, macro_call: MacroCallId) -> Option<ExpandError>; | |
132 | ||
133 | fn hygiene_frame(&self, file_id: HirFileId) -> Arc<HygieneFrame>; | |
134 | } | |
135 | ||
136 | /// This expands the given macro call, but with different arguments. This is | |
137 | /// used for completion, where we want to see what 'would happen' if we insert a | |
138 | /// token. The `token_to_map` mapped down into the expansion, with the mapped | |
139 | /// token returned. | |
140 | pub fn expand_speculative( | |
141 | db: &dyn AstDatabase, | |
142 | actual_macro_call: MacroCallId, | |
143 | speculative_args: &SyntaxNode, | |
144 | token_to_map: SyntaxToken, | |
145 | ) -> Option<(SyntaxNode, SyntaxToken)> { | |
146 | let loc = db.lookup_intern_macro_call(actual_macro_call); | |
147 | let macro_def = db.macro_def(loc.def).ok()?; | |
148 | let token_range = token_to_map.text_range(); | |
149 | ||
150 | // Build the subtree and token mapping for the speculative args | |
151 | let censor = censor_for_macro_input(&loc, speculative_args); | |
152 | let mut fixups = fixup::fixup_syntax(speculative_args); | |
153 | fixups.replace.extend(censor.into_iter().map(|node| (node.into(), Vec::new()))); | |
154 | let (mut tt, spec_args_tmap, _) = mbe::syntax_node_to_token_tree_with_modifications( | |
155 | speculative_args, | |
156 | fixups.token_map, | |
157 | fixups.next_id, | |
158 | fixups.replace, | |
159 | fixups.append, | |
160 | ); | |
161 | ||
162 | let (attr_arg, token_id) = match loc.kind { | |
163 | MacroCallKind::Attr { invoc_attr_index, is_derive, .. } => { | |
164 | let attr = if is_derive { | |
165 | // for pseudo-derive expansion we actually pass the attribute itself only | |
166 | ast::Attr::cast(speculative_args.clone()) | |
167 | } else { | |
168 | // Attributes may have an input token tree, build the subtree and map for this as well | |
169 | // then try finding a token id for our token if it is inside this input subtree. | |
170 | let item = ast::Item::cast(speculative_args.clone())?; | |
171 | item.doc_comments_and_attrs().nth(invoc_attr_index as usize).and_then(Either::left) | |
172 | }?; | |
173 | match attr.token_tree() { | |
174 | Some(token_tree) => { | |
175 | let (mut tree, map) = syntax_node_to_token_tree(attr.token_tree()?.syntax()); | |
176 | tree.delimiter = None; | |
177 | ||
178 | let shift = mbe::Shift::new(&tt); | |
179 | shift.shift_all(&mut tree); | |
180 | ||
181 | let token_id = if token_tree.syntax().text_range().contains_range(token_range) { | |
182 | let attr_input_start = | |
183 | token_tree.left_delimiter_token()?.text_range().start(); | |
184 | let range = token_range.checked_sub(attr_input_start)?; | |
185 | let token_id = shift.shift(map.token_by_range(range)?); | |
186 | Some(token_id) | |
187 | } else { | |
188 | None | |
189 | }; | |
190 | (Some(tree), token_id) | |
191 | } | |
192 | _ => (None, None), | |
193 | } | |
194 | } | |
195 | _ => (None, None), | |
196 | }; | |
197 | let token_id = match token_id { | |
198 | Some(token_id) => token_id, | |
199 | // token wasn't inside an attribute input so it has to be in the general macro input | |
200 | None => { | |
201 | let range = token_range.checked_sub(speculative_args.text_range().start())?; | |
202 | let token_id = spec_args_tmap.token_by_range(range)?; | |
203 | macro_def.map_id_down(token_id) | |
204 | } | |
205 | }; | |
206 | ||
207 | // Do the actual expansion, we need to directly expand the proc macro due to the attribute args | |
208 | // Otherwise the expand query will fetch the non speculative attribute args and pass those instead. | |
209 | let mut speculative_expansion = match loc.def.kind { | |
210 | MacroDefKind::ProcMacro(expander, ..) => { | |
211 | tt.delimiter = None; | |
212 | expander.expand(db, loc.krate, &tt, attr_arg.as_ref()) | |
213 | } | |
214 | MacroDefKind::BuiltInAttr(BuiltinAttrExpander::Derive, _) => { | |
215 | pseudo_derive_attr_expansion(&tt, attr_arg.as_ref()?) | |
216 | } | |
217 | _ => macro_def.expand(db, actual_macro_call, &tt), | |
218 | }; | |
219 | ||
220 | let expand_to = macro_expand_to(db, actual_macro_call); | |
221 | fixup::reverse_fixups(&mut speculative_expansion.value, &spec_args_tmap, &fixups.undo_info); | |
222 | let (node, rev_tmap) = token_tree_to_syntax_node(&speculative_expansion.value, expand_to); | |
223 | ||
224 | let range = rev_tmap.first_range_by_token(token_id, token_to_map.kind())?; | |
225 | let token = node.syntax_node().covering_element(range).into_token()?; | |
226 | Some((node.syntax_node(), token)) | |
227 | } | |
228 | ||
229 | fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> { | |
230 | let map = db.parse_or_expand(file_id).map(|it| AstIdMap::from_source(&it)).unwrap_or_default(); | |
231 | Arc::new(map) | |
232 | } | |
233 | ||
234 | fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> { | |
235 | match file_id.0 { | |
236 | HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), | |
237 | HirFileIdRepr::MacroFile(macro_file) => { | |
238 | // FIXME: Note how we convert from `Parse` to `SyntaxNode` here, | |
239 | // forgetting about parse errors. | |
240 | db.parse_macro_expansion(macro_file).value.map(|(it, _)| it.syntax_node()) | |
241 | } | |
242 | } | |
243 | } | |
244 | ||
245 | fn parse_macro_expansion( | |
246 | db: &dyn AstDatabase, | |
247 | macro_file: MacroFile, | |
248 | ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> { | |
249 | let _p = profile::span("parse_macro_expansion"); | |
250 | let result = db.macro_expand(macro_file.macro_call_id); | |
251 | ||
252 | if let Some(err) = &result.err { | |
253 | // Note: | |
254 | // The final goal we would like to make all parse_macro success, | |
255 | // such that the following log will not call anyway. | |
256 | let loc: MacroCallLoc = db.lookup_intern_macro_call(macro_file.macro_call_id); | |
257 | let node = loc.kind.to_node(db); | |
258 | ||
259 | // collect parent information for warning log | |
260 | let parents = | |
261 | std::iter::successors(loc.kind.file_id().call_node(db), |it| it.file_id.call_node(db)) | |
262 | .map(|n| format!("{:#}", n.value)) | |
263 | .collect::<Vec<_>>() | |
264 | .join("\n"); | |
265 | ||
266 | tracing::debug!( | |
267 | "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}", | |
268 | err, | |
269 | node.value, | |
270 | parents | |
271 | ); | |
272 | } | |
273 | let tt = match result.value { | |
274 | Some(tt) => tt, | |
275 | None => return ExpandResult { value: None, err: result.err }, | |
276 | }; | |
277 | ||
278 | let expand_to = macro_expand_to(db, macro_file.macro_call_id); | |
279 | ||
280 | tracing::debug!("expanded = {}", tt.as_debug_string()); | |
281 | tracing::debug!("kind = {:?}", expand_to); | |
282 | ||
283 | let (parse, rev_token_map) = token_tree_to_syntax_node(&tt, expand_to); | |
284 | ||
285 | ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: result.err } | |
286 | } | |
287 | ||
288 | fn macro_arg( | |
289 | db: &dyn AstDatabase, | |
290 | id: MacroCallId, | |
291 | ) -> Option<Arc<(tt::Subtree, mbe::TokenMap, fixup::SyntaxFixupUndoInfo)>> { | |
292 | let arg = db.macro_arg_text(id)?; | |
293 | let loc = db.lookup_intern_macro_call(id); | |
294 | ||
295 | let node = SyntaxNode::new_root(arg); | |
296 | let censor = censor_for_macro_input(&loc, &node); | |
297 | let mut fixups = fixup::fixup_syntax(&node); | |
298 | fixups.replace.extend(censor.into_iter().map(|node| (node.into(), Vec::new()))); | |
299 | let (mut tt, tmap, _) = mbe::syntax_node_to_token_tree_with_modifications( | |
300 | &node, | |
301 | fixups.token_map, | |
302 | fixups.next_id, | |
303 | fixups.replace, | |
304 | fixups.append, | |
305 | ); | |
306 | ||
307 | if loc.def.is_proc_macro() { | |
308 | // proc macros expect their inputs without parentheses, MBEs expect it with them included | |
309 | tt.delimiter = None; | |
310 | } | |
311 | ||
312 | Some(Arc::new((tt, tmap, fixups.undo_info))) | |
313 | } | |
314 | ||
315 | fn censor_for_macro_input(loc: &MacroCallLoc, node: &SyntaxNode) -> FxHashSet<SyntaxNode> { | |
316 | (|| { | |
317 | let censor = match loc.kind { | |
318 | MacroCallKind::FnLike { .. } => return None, | |
319 | MacroCallKind::Derive { derive_attr_index, .. } => { | |
320 | cov_mark::hit!(derive_censoring); | |
321 | ast::Item::cast(node.clone())? | |
322 | .attrs() | |
323 | .take(derive_attr_index as usize + 1) | |
324 | // FIXME | |
325 | .filter(|attr| attr.simple_name().as_deref() == Some("derive")) | |
326 | .map(|it| it.syntax().clone()) | |
327 | .collect() | |
328 | } | |
329 | MacroCallKind::Attr { is_derive: true, .. } => return None, | |
330 | MacroCallKind::Attr { invoc_attr_index, .. } => { | |
331 | cov_mark::hit!(attribute_macro_attr_censoring); | |
332 | ast::Item::cast(node.clone())? | |
333 | .doc_comments_and_attrs() | |
334 | .nth(invoc_attr_index as usize) | |
335 | .and_then(Either::left) | |
336 | .map(|attr| attr.syntax().clone()) | |
337 | .into_iter() | |
338 | .collect() | |
339 | } | |
340 | }; | |
341 | Some(censor) | |
342 | })() | |
343 | .unwrap_or_default() | |
344 | } | |
345 | ||
346 | fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> { | |
347 | let loc = db.lookup_intern_macro_call(id); | |
348 | let arg = loc.kind.arg(db)?; | |
349 | if matches!(loc.kind, MacroCallKind::FnLike { .. }) { | |
350 | let first = arg.first_child_or_token().map_or(T![.], |it| it.kind()); | |
351 | let last = arg.last_child_or_token().map_or(T![.], |it| it.kind()); | |
352 | let well_formed_tt = | |
353 | matches!((first, last), (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}'])); | |
354 | if !well_formed_tt { | |
355 | // Don't expand malformed (unbalanced) macro invocations. This is | |
356 | // less than ideal, but trying to expand unbalanced macro calls | |
357 | // sometimes produces pathological, deeply nested code which breaks | |
358 | // all kinds of things. | |
359 | // | |
360 | // Some day, we'll have explicit recursion counters for all | |
361 | // recursive things, at which point this code might be removed. | |
362 | cov_mark::hit!(issue9358_bad_macro_stack_overflow); | |
363 | return None; | |
364 | } | |
365 | } | |
366 | Some(arg.green().into()) | |
367 | } | |
368 | ||
369 | fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Result<Arc<TokenExpander>, mbe::ParseError> { | |
370 | match id.kind { | |
371 | MacroDefKind::Declarative(ast_id) => { | |
372 | let (mac, def_site_token_map) = match ast_id.to_node(db) { | |
373 | ast::Macro::MacroRules(macro_rules) => { | |
374 | let arg = macro_rules | |
375 | .token_tree() | |
376 | .ok_or_else(|| mbe::ParseError::Expected("expected a token tree".into()))?; | |
377 | let (tt, def_site_token_map) = mbe::syntax_node_to_token_tree(arg.syntax()); | |
378 | let mac = mbe::DeclarativeMacro::parse_macro_rules(&tt)?; | |
379 | (mac, def_site_token_map) | |
380 | } | |
381 | ast::Macro::MacroDef(macro_def) => { | |
382 | let arg = macro_def | |
383 | .body() | |
384 | .ok_or_else(|| mbe::ParseError::Expected("expected a token tree".into()))?; | |
385 | let (tt, def_site_token_map) = mbe::syntax_node_to_token_tree(arg.syntax()); | |
386 | let mac = mbe::DeclarativeMacro::parse_macro2(&tt)?; | |
387 | (mac, def_site_token_map) | |
388 | } | |
389 | }; | |
390 | Ok(Arc::new(TokenExpander::DeclarativeMacro { mac, def_site_token_map })) | |
391 | } | |
392 | MacroDefKind::BuiltIn(expander, _) => Ok(Arc::new(TokenExpander::Builtin(expander))), | |
393 | MacroDefKind::BuiltInAttr(expander, _) => { | |
394 | Ok(Arc::new(TokenExpander::BuiltinAttr(expander))) | |
395 | } | |
396 | MacroDefKind::BuiltInDerive(expander, _) => { | |
397 | Ok(Arc::new(TokenExpander::BuiltinDerive(expander))) | |
398 | } | |
399 | MacroDefKind::BuiltInEager(..) => { | |
400 | // FIXME: Return a random error here just to make the types align. | |
401 | // This obviously should do something real instead. | |
402 | Err(mbe::ParseError::UnexpectedToken("unexpected eager macro".into())) | |
403 | } | |
404 | MacroDefKind::ProcMacro(expander, ..) => Ok(Arc::new(TokenExpander::ProcMacro(expander))), | |
405 | } | |
406 | } | |
407 | ||
408 | fn macro_expand(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>> { | |
409 | let _p = profile::span("macro_expand"); | |
410 | let loc: MacroCallLoc = db.lookup_intern_macro_call(id); | |
411 | if let Some(eager) = &loc.eager { | |
412 | return ExpandResult { | |
413 | value: Some(eager.arg_or_expansion.clone()), | |
414 | // FIXME: There could be errors here! | |
415 | err: None, | |
416 | }; | |
417 | } | |
418 | ||
419 | let macro_arg = match db.macro_arg(id) { | |
420 | Some(it) => it, | |
421 | None => { | |
422 | return ExpandResult::only_err(ExpandError::Other( | |
423 | "Failed to lower macro args to token tree".into(), | |
424 | )) | |
425 | } | |
426 | }; | |
427 | ||
428 | let expander = match db.macro_def(loc.def) { | |
429 | Ok(it) => it, | |
430 | // FIXME: This is weird -- we effectively report macro *definition* | |
431 | // errors lazily, when we try to expand the macro. Instead, they should | |
432 | // be reported at the definition site (when we construct a def map). | |
433 | Err(err) => { | |
434 | return ExpandResult::only_err(ExpandError::Other( | |
435 | format!("invalid macro definition: {}", err).into(), | |
436 | )) | |
437 | } | |
438 | }; | |
439 | let ExpandResult { value: mut tt, err } = expander.expand(db, id, ¯o_arg.0); | |
440 | // Set a hard limit for the expanded tt | |
441 | let count = tt.count(); | |
442 | if TOKEN_LIMIT.check(count).is_err() { | |
443 | return ExpandResult::only_err(ExpandError::Other( | |
444 | format!( | |
445 | "macro invocation exceeds token limit: produced {} tokens, limit is {}", | |
446 | count, | |
447 | TOKEN_LIMIT.inner(), | |
448 | ) | |
449 | .into(), | |
450 | )); | |
451 | } | |
452 | ||
453 | fixup::reverse_fixups(&mut tt, ¯o_arg.1, ¯o_arg.2); | |
454 | ||
455 | ExpandResult { value: Some(Arc::new(tt)), err } | |
456 | } | |
457 | ||
458 | fn macro_expand_error(db: &dyn AstDatabase, macro_call: MacroCallId) -> Option<ExpandError> { | |
459 | db.macro_expand(macro_call).err | |
460 | } | |
461 | ||
462 | fn expand_proc_macro(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<tt::Subtree> { | |
463 | let loc: MacroCallLoc = db.lookup_intern_macro_call(id); | |
464 | let macro_arg = match db.macro_arg(id) { | |
465 | Some(it) => it, | |
466 | None => { | |
467 | return ExpandResult::only_err(ExpandError::Other("No arguments for proc-macro".into())) | |
468 | } | |
469 | }; | |
470 | ||
471 | let expander = match loc.def.kind { | |
472 | MacroDefKind::ProcMacro(expander, ..) => expander, | |
473 | _ => unreachable!(), | |
474 | }; | |
475 | ||
476 | let attr_arg = match &loc.kind { | |
477 | MacroCallKind::Attr { attr_args, .. } => { | |
478 | let mut attr_args = attr_args.0.clone(); | |
479 | mbe::Shift::new(¯o_arg.0).shift_all(&mut attr_args); | |
480 | Some(attr_args) | |
481 | } | |
482 | _ => None, | |
483 | }; | |
484 | ||
485 | expander.expand(db, loc.krate, ¯o_arg.0, attr_arg.as_ref()) | |
486 | } | |
487 | ||
488 | fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame> { | |
489 | Arc::new(HygieneFrame::new(db, file_id)) | |
490 | } | |
491 | ||
492 | fn macro_expand_to(db: &dyn AstDatabase, id: MacroCallId) -> ExpandTo { | |
493 | let loc: MacroCallLoc = db.lookup_intern_macro_call(id); | |
494 | loc.kind.expand_to() | |
495 | } | |
496 | ||
497 | fn token_tree_to_syntax_node( | |
498 | tt: &tt::Subtree, | |
499 | expand_to: ExpandTo, | |
500 | ) -> (Parse<SyntaxNode>, mbe::TokenMap) { | |
501 | let entry_point = match expand_to { | |
502 | ExpandTo::Statements => mbe::TopEntryPoint::MacroStmts, | |
503 | ExpandTo::Items => mbe::TopEntryPoint::MacroItems, | |
504 | ExpandTo::Pattern => mbe::TopEntryPoint::Pattern, | |
505 | ExpandTo::Type => mbe::TopEntryPoint::Type, | |
506 | ExpandTo::Expr => mbe::TopEntryPoint::Expr, | |
507 | }; | |
508 | mbe::token_tree_to_syntax_node(tt, entry_point) | |
509 | } |