//! Builtin macro
-use crate::{
- db::AstDatabase, name, quote, AstId, CrateId, MacroCallId, MacroCallLoc, MacroDefId,
- MacroDefKind,
-};
use base_db::{AnchoredPath, Edition, FileId};
use cfg::CfgExpr;
use either::Either;
-use mbe::{parse_exprs_with_sep, parse_to_token_tree, ExpandResult};
+use mbe::{parse_exprs_with_sep, parse_to_token_tree};
use syntax::ast::{self, AstToken};
+use crate::{
+ db::AstDatabase, name, quote, AstId, CrateId, ExpandError, ExpandResult, MacroCallId,
+ MacroCallLoc, MacroDefId, MacroDefKind,
+};
+
macro_rules! register_builtin {
( LAZY: $(($name:ident, $kind: ident) => $expand:ident),* , EAGER: $(($e_name:ident, $e_kind: ident) => $e_expand:ident),* ) => {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
db: &dyn AstDatabase,
arg_id: MacroCallId,
tt: &tt::Subtree,
- ) -> ExpandResult<Option<ExpandedEager>> {
+ ) -> ExpandResult<ExpandedEager> {
let expander = match *self {
$( EagerExpander::$e_kind => $e_expand, )*
};
};
}
-#[derive(Debug)]
+#[derive(Debug, Default)]
pub struct ExpandedEager {
pub(crate) subtree: tt::Subtree,
/// The included file ID of the include macro.
(cfg, Cfg) => cfg_expand,
(core_panic, CorePanic) => panic_expand,
(std_panic, StdPanic) => panic_expand,
+ (log_syntax, LogSyntax) => log_syntax_expand,
+ (trace_macros, TraceMacros) => trace_macros_expand,
EAGER:
(compile_error, CompileError) => compile_error_expand,
ExpandResult::ok(expanded)
}
+fn log_syntax_expand(
+ _db: &dyn AstDatabase,
+ _id: MacroCallId,
+ _tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+ ExpandResult::ok(quote! {})
+}
+
+fn trace_macros_expand(
+ _db: &dyn AstDatabase,
+ _id: MacroCallId,
+ _tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+ ExpandResult::ok(quote! {})
+}
+
fn stringify_expand(
_db: &dyn AstDatabase,
_id: MacroCallId,
let mut args = parse_exprs_with_sep(tt, ',');
if args.is_empty() {
- return ExpandResult::only_err(mbe::ExpandError::NoMatchingRule);
+ return ExpandResult::only_err(mbe::ExpandError::NoMatchingRule.into());
}
for arg in &mut args {
// Remove `key =`.
id: MacroCallId,
tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
- let loc = db.lookup_intern_macro(id);
+ let loc = db.lookup_intern_macro_call(id);
let expr = CfgExpr::parse(tt);
let enabled = db.crate_graph()[loc.krate].cfg_options.check(&expr) != Some(false);
let expanded = if enabled { quote!(true) } else { quote!(false) };
id: MacroCallId,
tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
- let loc: MacroCallLoc = db.lookup_intern_macro(id);
+ let loc: MacroCallLoc = db.lookup_intern_macro_call(id);
// Expand to a macro call `$crate::panic::panic_{edition}`
let krate = tt::Ident { text: "$crate".into(), id: tt::TokenId::unspecified() };
let mut call = if db.crate_graph()[loc.krate].edition == Edition::Edition2021 {
_db: &dyn AstDatabase,
_id: MacroCallId,
tt: &tt::Subtree,
-) -> ExpandResult<Option<ExpandedEager>> {
+) -> ExpandResult<ExpandedEager> {
let err = match &*tt.token_trees {
[tt::TokenTree::Leaf(tt::Leaf::Literal(it))] => {
let text = it.text.as_str();
if text.starts_with('"') && text.ends_with('"') {
// FIXME: does not handle raw strings
- mbe::ExpandError::Other(text[1..text.len() - 1].to_string())
+ ExpandError::Other(text[1..text.len() - 1].into())
} else {
- mbe::ExpandError::BindingError("`compile_error!` argument must be a string".into())
+ ExpandError::Other("`compile_error!` argument must be a string".into())
}
}
- _ => mbe::ExpandError::BindingError("`compile_error!` argument must be a string".into()),
+ _ => ExpandError::Other("`compile_error!` argument must be a string".into()),
};
- ExpandResult { value: Some(ExpandedEager::new(quote! {})), err: Some(err) }
+ ExpandResult { value: ExpandedEager::new(quote! {}), err: Some(err) }
}
fn concat_expand(
_db: &dyn AstDatabase,
_arg_id: MacroCallId,
tt: &tt::Subtree,
-) -> ExpandResult<Option<ExpandedEager>> {
+) -> ExpandResult<ExpandedEager> {
let mut err = None;
let mut text = String::new();
- for (i, t) in tt.token_trees.iter().enumerate() {
+ 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
+ // implement rustc's model. cc https://github.com/rust-analyzer/rust-analyzer/pull/10623
+ if let tt::TokenTree::Subtree(tt::Subtree { delimiter: Some(delim), token_trees }) = t {
+ if let [tt] = &**token_trees {
+ if delim.kind == tt::DelimiterKind::Parenthesis {
+ t = tt;
+ }
+ }
+ }
+
match t {
tt::TokenTree::Leaf(tt::Leaf::Literal(it)) if i % 2 == 0 => {
// concat works with string and char literals, so remove any quotes.
}
tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
_ => {
- err.get_or_insert(mbe::ExpandError::UnexpectedToken);
+ err.get_or_insert(mbe::ExpandError::UnexpectedToken.into());
}
}
}
- ExpandResult { value: Some(ExpandedEager::new(quote!(#text))), err }
+ ExpandResult { value: ExpandedEager::new(quote!(#text)), err }
}
fn concat_idents_expand(
_db: &dyn AstDatabase,
_arg_id: MacroCallId,
tt: &tt::Subtree,
-) -> ExpandResult<Option<ExpandedEager>> {
+) -> ExpandResult<ExpandedEager> {
let mut err = None;
let mut ident = String::new();
for (i, t) in tt.token_trees.iter().enumerate() {
}
tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
_ => {
- err.get_or_insert(mbe::ExpandError::UnexpectedToken);
+ err.get_or_insert(mbe::ExpandError::UnexpectedToken.into());
}
}
}
let ident = tt::Ident { text: ident.into(), id: tt::TokenId::unspecified() };
- ExpandResult { value: Some(ExpandedEager::new(quote!(#ident))), err }
+ ExpandResult { value: ExpandedEager::new(quote!(#ident)), err }
}
fn relative_file(
call_id: MacroCallId,
path_str: &str,
allow_recursion: bool,
-) -> Result<FileId, mbe::ExpandError> {
+) -> Result<FileId, ExpandError> {
let call_site = call_id.as_file().original_file(db);
let path = AnchoredPath { anchor: call_site, path: path_str };
let res = db
.resolve_path(path)
- .ok_or_else(|| mbe::ExpandError::Other(format!("failed to load file `{}`", path_str)))?;
+ .ok_or_else(|| ExpandError::Other(format!("failed to load file `{path_str}`").into()))?;
// Prevent include itself
if res == call_site && !allow_recursion {
- Err(mbe::ExpandError::Other(format!("recursive inclusion of `{}`", path_str)))
+ Err(ExpandError::Other(format!("recursive inclusion of `{path_str}`").into()))
} else {
Ok(res)
}
}
-fn parse_string(tt: &tt::Subtree) -> Result<String, mbe::ExpandError> {
+fn parse_string(tt: &tt::Subtree) -> Result<String, ExpandError> {
tt.token_trees
.get(0)
.and_then(|tt| match tt {
tt::TokenTree::Leaf(tt::Leaf::Literal(it)) => unquote_str(it),
_ => None,
})
- .ok_or(mbe::ExpandError::ConversionError)
+ .ok_or(mbe::ExpandError::ConversionError.into())
}
fn include_expand(
db: &dyn AstDatabase,
arg_id: MacroCallId,
tt: &tt::Subtree,
-) -> ExpandResult<Option<ExpandedEager>> {
+) -> ExpandResult<ExpandedEager> {
let res = (|| {
let path = parse_string(tt)?;
let file_id = relative_file(db, arg_id, &path, false)?;
match res {
Ok((subtree, file_id)) => {
- ExpandResult::ok(Some(ExpandedEager { subtree, included_file: Some(file_id) }))
+ ExpandResult::ok(ExpandedEager { subtree, included_file: Some(file_id) })
}
Err(e) => ExpandResult::only_err(e),
}
_db: &dyn AstDatabase,
_arg_id: MacroCallId,
tt: &tt::Subtree,
-) -> ExpandResult<Option<ExpandedEager>> {
+) -> ExpandResult<ExpandedEager> {
if let Err(e) = parse_string(tt) {
return ExpandResult::only_err(e);
}
id: tt::TokenId::unspecified(),
}))],
};
- ExpandResult::ok(Some(ExpandedEager::new(res)))
+ ExpandResult::ok(ExpandedEager::new(res))
}
fn include_str_expand(
db: &dyn AstDatabase,
arg_id: MacroCallId,
tt: &tt::Subtree,
-) -> ExpandResult<Option<ExpandedEager>> {
+) -> ExpandResult<ExpandedEager> {
let path = match parse_string(tt) {
Ok(it) => it,
Err(e) => return ExpandResult::only_err(e),
let file_id = match relative_file(db, arg_id, &path, true) {
Ok(file_id) => file_id,
Err(_) => {
- return ExpandResult::ok(Some(ExpandedEager::new(quote!(""))));
+ return ExpandResult::ok(ExpandedEager::new(quote!("")));
}
};
let text = db.file_text(file_id);
let text = &*text;
- ExpandResult::ok(Some(ExpandedEager::new(quote!(#text))))
+ ExpandResult::ok(ExpandedEager::new(quote!(#text)))
}
fn get_env_inner(db: &dyn AstDatabase, arg_id: MacroCallId, key: &str) -> Option<String> {
- let krate = db.lookup_intern_macro(arg_id).krate;
+ let krate = db.lookup_intern_macro_call(arg_id).krate;
db.crate_graph()[krate].env.get(key)
}
db: &dyn AstDatabase,
arg_id: MacroCallId,
tt: &tt::Subtree,
-) -> ExpandResult<Option<ExpandedEager>> {
+) -> ExpandResult<ExpandedEager> {
let key = match parse_string(tt) {
Ok(it) => it,
Err(e) => return ExpandResult::only_err(e),
// The only variable rust-analyzer ever sets is `OUT_DIR`, so only diagnose that to avoid
// unnecessary diagnostics for eg. `CARGO_PKG_NAME`.
if key == "OUT_DIR" {
- err = Some(mbe::ExpandError::Other(
+ err = Some(ExpandError::Other(
r#"`OUT_DIR` not set, enable "run build scripts" to fix"#.into(),
));
}
});
let expanded = quote! { #s };
- ExpandResult { value: Some(ExpandedEager::new(expanded)), err }
+ ExpandResult { value: ExpandedEager::new(expanded), err }
}
fn option_env_expand(
db: &dyn AstDatabase,
arg_id: MacroCallId,
tt: &tt::Subtree,
-) -> ExpandResult<Option<ExpandedEager>> {
+) -> ExpandResult<ExpandedEager> {
let key = match parse_string(tt) {
Ok(it) => it,
Err(e) => return ExpandResult::only_err(e),
Some(s) => quote! { std::option::Some(#s) },
};
- ExpandResult::ok(Some(ExpandedEager::new(expanded)))
+ ExpandResult::ok(ExpandedEager::new(expanded))
}