2019-10-29 08:03:29 -05:00
|
|
|
//! Defines database & queries for macro expansion.
|
|
|
|
|
2019-10-29 06:55:39 -05:00
|
|
|
use std::sync::Arc;
|
|
|
|
|
2020-03-16 06:22:10 -05:00
|
|
|
use mbe::{ExpandResult, MacroRules};
|
2019-10-29 06:55:39 -05:00
|
|
|
use ra_db::{salsa, SourceDatabase};
|
2019-11-09 04:14:10 -06:00
|
|
|
use ra_parser::FragmentKind;
|
2019-10-29 07:11:42 -05:00
|
|
|
use ra_prof::profile;
|
2020-03-21 09:43:48 -05:00
|
|
|
use ra_syntax::{algo::diff, AstNode, Parse, SyntaxKind::*, SyntaxNode};
|
2019-10-29 06:55:39 -05:00
|
|
|
|
|
|
|
use crate::{
|
2020-03-02 00:05:15 -06:00
|
|
|
ast_id_map::AstIdMap, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerCallLoc, EagerMacroId,
|
|
|
|
HirFileId, HirFileIdRepr, LazyMacroId, MacroCallId, MacroCallLoc, MacroDefId, MacroDefKind,
|
|
|
|
MacroFile,
|
2019-10-29 06:55:39 -05:00
|
|
|
};
|
|
|
|
|
2019-11-09 21:03:24 -06:00
|
|
|
#[derive(Debug, Clone, Eq, PartialEq)]
|
|
|
|
pub enum TokenExpander {
|
|
|
|
MacroRules(mbe::MacroRules),
|
2019-11-23 07:54:39 -06:00
|
|
|
Builtin(BuiltinFnLikeExpander),
|
2019-12-05 08:10:33 -06:00
|
|
|
BuiltinDerive(BuiltinDeriveExpander),
|
2019-11-09 21:03:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl TokenExpander {
|
|
|
|
pub fn expand(
|
|
|
|
&self,
|
|
|
|
db: &dyn AstDatabase,
|
2020-03-02 00:05:15 -06:00
|
|
|
id: LazyMacroId,
|
2019-11-09 21:03:24 -06:00
|
|
|
tt: &tt::Subtree,
|
2020-03-13 07:03:31 -05:00
|
|
|
) -> mbe::ExpandResult<tt::Subtree> {
|
2019-11-09 21:03:24 -06:00
|
|
|
match self {
|
|
|
|
TokenExpander::MacroRules(it) => it.expand(tt),
|
2020-03-13 07:03:31 -05:00
|
|
|
// FIXME switch these to ExpandResult as well
|
2020-03-16 06:22:10 -05:00
|
|
|
TokenExpander::Builtin(it) => it.expand(db, id, tt).into(),
|
|
|
|
TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt).into(),
|
2019-11-09 21:03:24 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-17 10:11:43 -06:00
|
|
|
pub fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
|
2019-11-09 21:03:24 -06:00
|
|
|
match self {
|
2019-11-17 10:11:43 -06:00
|
|
|
TokenExpander::MacroRules(it) => it.map_id_down(id),
|
|
|
|
TokenExpander::Builtin(..) => id,
|
2019-12-05 08:10:33 -06:00
|
|
|
TokenExpander::BuiltinDerive(..) => id,
|
2019-11-17 10:11:43 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, mbe::Origin) {
|
|
|
|
match self {
|
|
|
|
TokenExpander::MacroRules(it) => it.map_id_up(id),
|
2019-12-06 14:21:39 -06:00
|
|
|
TokenExpander::Builtin(..) => (id, mbe::Origin::Call),
|
|
|
|
TokenExpander::BuiltinDerive(..) => (id, mbe::Origin::Call),
|
2019-11-09 21:03:24 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-29 07:20:08 -05:00
|
|
|
// FIXME: rename to ExpandDatabase
|
2019-10-29 06:55:39 -05:00
|
|
|
#[salsa::query_group(AstDatabaseStorage)]
|
|
|
|
pub trait AstDatabase: SourceDatabase {
|
|
|
|
fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
|
|
|
|
|
|
|
|
#[salsa::transparent]
|
|
|
|
fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
|
|
|
|
|
|
|
|
#[salsa::interned]
|
2020-02-17 05:32:13 -06:00
|
|
|
fn intern_macro(&self, macro_call: MacroCallLoc) -> LazyMacroId;
|
2019-11-08 22:00:46 -06:00
|
|
|
fn macro_arg(&self, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>>;
|
2019-11-09 21:03:24 -06:00
|
|
|
fn macro_def(&self, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>>;
|
2019-11-18 07:08:41 -06:00
|
|
|
fn parse_macro(&self, macro_file: MacroFile)
|
|
|
|
-> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>;
|
2020-03-13 07:03:31 -05:00
|
|
|
fn macro_expand(&self, macro_call: MacroCallId) -> (Option<Arc<tt::Subtree>>, Option<String>);
|
2020-03-02 00:05:15 -06:00
|
|
|
|
|
|
|
#[salsa::interned]
|
|
|
|
fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
|
2019-10-29 06:55:39 -05:00
|
|
|
}
|
|
|
|
|
2020-03-08 05:02:14 -05:00
|
|
|
/// This expands the given macro call, but with different arguments. This is
|
|
|
|
/// used for completion, where we want to see what 'would happen' if we insert a
|
|
|
|
/// token. The `token_to_map` mapped down into the expansion, with the mapped
|
|
|
|
/// token returned.
|
|
|
|
pub fn expand_hypothetical(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn AstDatabase,
|
2020-03-08 05:02:14 -05:00
|
|
|
actual_macro_call: MacroCallId,
|
|
|
|
hypothetical_args: &ra_syntax::ast::TokenTree,
|
|
|
|
token_to_map: ra_syntax::SyntaxToken,
|
|
|
|
) -> Option<(SyntaxNode, ra_syntax::SyntaxToken)> {
|
|
|
|
let macro_file = MacroFile { macro_call_id: actual_macro_call };
|
|
|
|
let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax()).unwrap();
|
|
|
|
let range =
|
|
|
|
token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
|
|
|
|
let token_id = tmap_1.token_by_range(range)?;
|
|
|
|
let macro_def = expander(db, actual_macro_call)?;
|
|
|
|
let (node, tmap_2) =
|
|
|
|
parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1))))?;
|
|
|
|
let token_id = macro_def.0.map_id_down(token_id);
|
|
|
|
let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
|
|
|
|
let token = ra_syntax::algo::find_covering_element(&node.syntax_node(), range).into_token()?;
|
|
|
|
Some((node.syntax_node(), token))
|
|
|
|
}
|
|
|
|
|
2019-10-29 08:12:54 -05:00
|
|
|
pub(crate) fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
|
2019-10-29 06:55:39 -05:00
|
|
|
let map =
|
|
|
|
db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
|
|
|
|
Arc::new(map)
|
|
|
|
}
|
|
|
|
|
2019-11-03 08:46:12 -06:00
|
|
|
pub(crate) fn macro_def(
|
|
|
|
db: &dyn AstDatabase,
|
|
|
|
id: MacroDefId,
|
2019-11-09 21:03:24 -06:00
|
|
|
) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
|
2019-11-11 04:45:55 -06:00
|
|
|
match id.kind {
|
|
|
|
MacroDefKind::Declarative => {
|
2019-12-05 08:10:33 -06:00
|
|
|
let macro_call = id.ast_id?.to_node(db);
|
2019-11-09 21:03:24 -06:00
|
|
|
let arg = macro_call.token_tree()?;
|
|
|
|
let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
|
|
|
|
log::warn!("fail on macro_def to token tree: {:#?}", arg);
|
|
|
|
None
|
|
|
|
})?;
|
2020-03-03 11:03:44 -06:00
|
|
|
let rules = match MacroRules::parse(&tt) {
|
|
|
|
Ok(it) => it,
|
|
|
|
Err(err) => {
|
|
|
|
log::warn!("fail on macro_def parse: error: {:#?} {:#?}", err, tt);
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
};
|
2019-11-09 21:03:24 -06:00
|
|
|
Some(Arc::new((TokenExpander::MacroRules(rules), tmap)))
|
|
|
|
}
|
2019-11-11 04:45:55 -06:00
|
|
|
MacroDefKind::BuiltIn(expander) => {
|
2019-12-20 14:14:30 -06:00
|
|
|
Some(Arc::new((TokenExpander::Builtin(expander), mbe::TokenMap::default())))
|
|
|
|
}
|
|
|
|
MacroDefKind::BuiltInDerive(expander) => {
|
|
|
|
Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
|
2019-11-09 21:03:24 -06:00
|
|
|
}
|
2020-03-02 00:05:15 -06:00
|
|
|
MacroDefKind::BuiltInEager(_expander) => None,
|
2019-11-09 21:03:24 -06:00
|
|
|
}
|
2019-10-29 07:11:42 -05:00
|
|
|
}
|
|
|
|
|
2019-11-03 08:46:12 -06:00
|
|
|
pub(crate) fn macro_arg(
|
|
|
|
db: &dyn AstDatabase,
|
|
|
|
id: MacroCallId,
|
2019-11-08 22:00:46 -06:00
|
|
|
) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
|
2020-02-17 05:32:13 -06:00
|
|
|
let id = match id {
|
|
|
|
MacroCallId::LazyMacro(id) => id,
|
2020-03-02 00:05:15 -06:00
|
|
|
MacroCallId::EagerMacro(_id) => {
|
|
|
|
// FIXME: support macro_arg for eager macro
|
|
|
|
return None;
|
|
|
|
}
|
2020-02-17 05:32:13 -06:00
|
|
|
};
|
2019-10-29 07:11:42 -05:00
|
|
|
let loc = db.lookup_intern_macro(id);
|
2019-12-05 08:10:33 -06:00
|
|
|
let arg = loc.kind.arg(db)?;
|
|
|
|
let (tt, tmap) = mbe::syntax_node_to_token_tree(&arg)?;
|
2019-11-08 22:00:46 -06:00
|
|
|
Some(Arc::new((tt, tmap)))
|
2019-10-29 07:11:42 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn macro_expand(
|
2019-10-29 08:12:54 -05:00
|
|
|
db: &dyn AstDatabase,
|
2019-10-29 07:11:42 -05:00
|
|
|
id: MacroCallId,
|
2020-03-13 07:03:31 -05:00
|
|
|
) -> (Option<Arc<tt::Subtree>>, Option<String>) {
|
2020-03-07 08:27:03 -06:00
|
|
|
macro_expand_with_arg(db, id, None)
|
|
|
|
}
|
|
|
|
|
2020-03-08 05:02:14 -05:00
|
|
|
fn expander(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
|
2020-03-07 08:27:03 -06:00
|
|
|
let lazy_id = match id {
|
|
|
|
MacroCallId::LazyMacro(id) => id,
|
|
|
|
MacroCallId::EagerMacro(_id) => {
|
2020-03-07 12:58:18 -06:00
|
|
|
return None;
|
2020-03-07 08:27:03 -06:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
let loc = db.lookup_intern_macro(lazy_id);
|
|
|
|
let macro_rules = db.macro_def(loc.def)?;
|
|
|
|
Some(macro_rules)
|
|
|
|
}
|
|
|
|
|
2020-03-08 05:02:14 -05:00
|
|
|
fn macro_expand_with_arg(
|
2020-03-07 08:27:03 -06:00
|
|
|
db: &dyn AstDatabase,
|
|
|
|
id: MacroCallId,
|
|
|
|
arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
|
2020-03-13 07:03:31 -05:00
|
|
|
) -> (Option<Arc<tt::Subtree>>, Option<String>) {
|
2020-02-17 05:32:13 -06:00
|
|
|
let lazy_id = match id {
|
|
|
|
MacroCallId::LazyMacro(id) => id,
|
2020-03-02 00:05:15 -06:00
|
|
|
MacroCallId::EagerMacro(id) => {
|
2020-03-07 12:58:18 -06:00
|
|
|
if arg.is_some() {
|
2020-03-13 07:03:31 -05:00
|
|
|
return (
|
|
|
|
None,
|
2020-03-14 14:24:18 -05:00
|
|
|
Some("hypothetical macro expansion not implemented for eager macro".to_owned()),
|
2020-03-08 05:02:14 -05:00
|
|
|
);
|
2020-03-07 12:58:18 -06:00
|
|
|
} else {
|
2020-03-13 07:03:31 -05:00
|
|
|
return (Some(db.lookup_intern_eager_expansion(id).subtree), None);
|
2020-03-07 12:58:18 -06:00
|
|
|
}
|
2020-03-02 00:05:15 -06:00
|
|
|
}
|
2020-02-17 05:32:13 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
let loc = db.lookup_intern_macro(lazy_id);
|
2020-03-13 07:03:31 -05:00
|
|
|
let macro_arg = match arg.or_else(|| db.macro_arg(id)) {
|
|
|
|
Some(it) => it,
|
|
|
|
None => return (None, Some("Fail to args in to tt::TokenTree".into())),
|
|
|
|
};
|
2019-10-29 07:11:42 -05:00
|
|
|
|
2020-03-13 07:03:31 -05:00
|
|
|
let macro_rules = match db.macro_def(loc.def) {
|
|
|
|
Some(it) => it,
|
|
|
|
None => return (None, Some("Fail to find macro definition".into())),
|
|
|
|
};
|
2020-03-16 06:22:10 -05:00
|
|
|
let ExpandResult(tt, err) = macro_rules.0.expand(db, lazy_id, ¯o_arg.0);
|
2019-10-29 07:11:42 -05:00
|
|
|
// Set a hard limit for the expanded tt
|
|
|
|
let count = tt.count();
|
|
|
|
if count > 65536 {
|
2020-03-13 07:03:31 -05:00
|
|
|
return (None, Some(format!("Total tokens count exceed limit : count = {}", count)));
|
2019-10-29 07:11:42 -05:00
|
|
|
}
|
2020-03-13 07:03:31 -05:00
|
|
|
(Some(Arc::new(tt)), err.map(|e| format!("{:?}", e)))
|
2019-10-29 07:11:42 -05:00
|
|
|
}
|
|
|
|
|
2019-10-29 08:12:54 -05:00
|
|
|
pub(crate) fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
|
2019-10-29 07:11:42 -05:00
|
|
|
match file_id.0 {
|
|
|
|
HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
|
|
|
|
HirFileIdRepr::MacroFile(macro_file) => {
|
2019-11-08 14:00:27 -06:00
|
|
|
db.parse_macro(macro_file).map(|(it, _)| it.syntax_node())
|
2019-10-29 07:11:42 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn parse_macro(
|
2019-10-29 08:12:54 -05:00
|
|
|
db: &dyn AstDatabase,
|
2019-10-29 07:11:42 -05:00
|
|
|
macro_file: MacroFile,
|
2020-03-07 08:27:03 -06:00
|
|
|
) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
|
|
|
|
parse_macro_with_arg(db, macro_file, None)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn parse_macro_with_arg(
|
|
|
|
db: &dyn AstDatabase,
|
|
|
|
macro_file: MacroFile,
|
|
|
|
arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
|
2019-11-18 07:08:41 -06:00
|
|
|
) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
|
2019-10-29 07:11:42 -05:00
|
|
|
let _p = profile("parse_macro_query");
|
2019-11-03 08:46:12 -06:00
|
|
|
|
2019-10-29 07:11:42 -05:00
|
|
|
let macro_call_id = macro_file.macro_call_id;
|
2020-03-13 07:03:31 -05:00
|
|
|
let (tt, err) = if let Some(arg) = arg {
|
2020-03-07 08:27:03 -06:00
|
|
|
macro_expand_with_arg(db, macro_call_id, Some(arg))
|
|
|
|
} else {
|
|
|
|
db.macro_expand(macro_call_id)
|
|
|
|
};
|
2020-03-21 09:43:48 -05:00
|
|
|
if let Some(err) = &err {
|
2020-03-13 07:03:31 -05:00
|
|
|
// Note:
|
|
|
|
// The final goal we would like to make all parse_macro success,
|
|
|
|
// such that the following log will not call anyway.
|
|
|
|
match macro_call_id {
|
|
|
|
MacroCallId::LazyMacro(id) => {
|
|
|
|
let loc: MacroCallLoc = db.lookup_intern_macro(id);
|
|
|
|
let node = loc.kind.node(db);
|
2020-03-04 13:02:51 -06:00
|
|
|
|
2020-03-13 07:03:31 -05:00
|
|
|
// collect parent information for warning log
|
|
|
|
let parents = std::iter::successors(loc.kind.file_id().call_node(db), |it| {
|
|
|
|
it.file_id.call_node(db)
|
|
|
|
})
|
2020-03-14 14:24:18 -05:00
|
|
|
.map(|n| format!("{:#}", n.value))
|
|
|
|
.collect::<Vec<_>>()
|
|
|
|
.join("\n");
|
2020-03-04 13:02:51 -06:00
|
|
|
|
2020-03-13 07:03:31 -05:00
|
|
|
log::warn!(
|
|
|
|
"fail on macro_parse: (reason: {} macro_call: {:#}) parents: {}",
|
|
|
|
err,
|
|
|
|
node.value,
|
|
|
|
parents
|
|
|
|
);
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
log::warn!("fail on macro_parse: (reason: {})", err);
|
2020-03-03 11:24:33 -06:00
|
|
|
}
|
2020-03-13 07:03:31 -05:00
|
|
|
}
|
|
|
|
};
|
|
|
|
let tt = tt?;
|
2019-11-04 07:43:36 -06:00
|
|
|
|
2019-12-08 02:16:52 -06:00
|
|
|
let fragment_kind = to_fragment_kind(db, macro_call_id);
|
|
|
|
|
2019-11-09 04:14:10 -06:00
|
|
|
let (parse, rev_token_map) = mbe::token_tree_to_syntax_node(&tt, fragment_kind).ok()?;
|
2020-03-21 09:43:48 -05:00
|
|
|
|
|
|
|
if err.is_none() {
|
|
|
|
Some((parse, Arc::new(rev_token_map)))
|
|
|
|
} else {
|
|
|
|
// FIXME:
|
2020-03-21 10:08:53 -05:00
|
|
|
// In future, we should propagate the actual error with recovery information
|
2020-03-21 09:43:48 -05:00
|
|
|
// instead of ignore the error here.
|
|
|
|
|
|
|
|
// Safe check for recurisve identity macro
|
|
|
|
let node = parse.syntax_node();
|
|
|
|
let file: HirFileId = macro_file.into();
|
|
|
|
let call_node = file.call_node(db)?;
|
|
|
|
|
|
|
|
if !diff(&node, &call_node.value).is_empty() {
|
|
|
|
Some((parse, Arc::new(rev_token_map)))
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
2019-10-29 07:11:42 -05:00
|
|
|
}
|
2019-12-08 02:16:52 -06:00
|
|
|
|
|
|
|
/// Given a `MacroCallId`, return what `FragmentKind` it belongs to.
|
|
|
|
/// FIXME: Not completed
|
2020-02-17 05:32:13 -06:00
|
|
|
fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
|
|
|
|
let lazy_id = match id {
|
|
|
|
MacroCallId::LazyMacro(id) => id,
|
2020-03-02 00:05:15 -06:00
|
|
|
MacroCallId::EagerMacro(id) => {
|
|
|
|
return db.lookup_intern_eager_expansion(id).fragment;
|
|
|
|
}
|
2020-02-17 05:32:13 -06:00
|
|
|
};
|
|
|
|
let syn = db.lookup_intern_macro(lazy_id).kind.node(db).value;
|
2019-12-08 02:16:52 -06:00
|
|
|
|
|
|
|
let parent = match syn.parent() {
|
|
|
|
Some(it) => it,
|
|
|
|
None => {
|
|
|
|
// FIXME:
|
|
|
|
// If it is root, which means the parent HirFile
|
|
|
|
// MacroKindFile must be non-items
|
|
|
|
// return expr now.
|
|
|
|
return FragmentKind::Expr;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
match parent.kind() {
|
|
|
|
MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
|
2020-01-10 13:11:23 -06:00
|
|
|
ITEM_LIST => FragmentKind::Items,
|
2019-12-08 02:16:52 -06:00
|
|
|
LET_STMT => {
|
|
|
|
// FIXME: Handle Pattern
|
|
|
|
FragmentKind::Expr
|
|
|
|
}
|
2019-12-08 05:50:49 -06:00
|
|
|
// FIXME: Expand to statements in appropriate positions; HIR lowering needs to handle that
|
|
|
|
EXPR_STMT | BLOCK => FragmentKind::Expr,
|
2019-12-08 02:16:52 -06:00
|
|
|
ARG_LIST => FragmentKind::Expr,
|
|
|
|
TRY_EXPR => FragmentKind::Expr,
|
|
|
|
TUPLE_EXPR => FragmentKind::Expr,
|
2020-01-10 10:29:00 -06:00
|
|
|
PAREN_EXPR => FragmentKind::Expr,
|
2020-01-10 13:11:23 -06:00
|
|
|
|
|
|
|
FOR_EXPR => FragmentKind::Expr,
|
|
|
|
PATH_EXPR => FragmentKind::Expr,
|
|
|
|
LAMBDA_EXPR => FragmentKind::Expr,
|
|
|
|
CONDITION => FragmentKind::Expr,
|
|
|
|
BREAK_EXPR => FragmentKind::Expr,
|
|
|
|
RETURN_EXPR => FragmentKind::Expr,
|
|
|
|
BLOCK_EXPR => FragmentKind::Expr,
|
|
|
|
MATCH_EXPR => FragmentKind::Expr,
|
|
|
|
MATCH_ARM => FragmentKind::Expr,
|
|
|
|
MATCH_GUARD => FragmentKind::Expr,
|
|
|
|
RECORD_FIELD => FragmentKind::Expr,
|
|
|
|
CALL_EXPR => FragmentKind::Expr,
|
|
|
|
INDEX_EXPR => FragmentKind::Expr,
|
|
|
|
METHOD_CALL_EXPR => FragmentKind::Expr,
|
|
|
|
AWAIT_EXPR => FragmentKind::Expr,
|
|
|
|
CAST_EXPR => FragmentKind::Expr,
|
|
|
|
REF_EXPR => FragmentKind::Expr,
|
|
|
|
PREFIX_EXPR => FragmentKind::Expr,
|
|
|
|
RANGE_EXPR => FragmentKind::Expr,
|
|
|
|
BIN_EXPR => FragmentKind::Expr,
|
2019-12-08 02:16:52 -06:00
|
|
|
_ => {
|
|
|
|
// Unknown , Just guess it is `Items`
|
|
|
|
FragmentKind::Items
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|