rust-analyzer/crates/hir_expand/src/builtin_macro.rs

851 lines
26 KiB
Rust
Raw Normal View History

2019-11-10 03:03:24 +00:00
//! Builtin macro
2019-11-11 06:15:09 +00:00
use crate::{
2021-05-19 18:19:08 +00:00
db::AstDatabase, name, quote, AstId, CrateId, MacroCallId, MacroCallLoc, MacroDefId,
MacroDefKind, TextSize,
2019-11-11 06:15:09 +00:00
};
use base_db::{AnchoredPath, Edition, FileId};
2021-03-10 18:43:03 +00:00
use cfg::CfgExpr;
2020-03-02 06:05:15 +00:00
use either::Either;
use mbe::{parse_exprs_with_sep, parse_to_token_tree, ExpandResult};
2020-11-06 21:30:58 +00:00
use syntax::ast::{self, AstToken};
2019-11-10 03:03:24 +00:00
2019-11-22 17:47:35 +00:00
macro_rules! register_builtin {
2020-03-02 06:05:15 +00:00
( LAZY: $(($name:ident, $kind: ident) => $expand:ident),* , EAGER: $(($e_name:ident, $e_kind: ident) => $e_expand:ident),* ) => {
2019-11-23 14:48:34 +00:00
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BuiltinFnLikeExpander {
$($kind),*
}
2020-03-02 06:05:15 +00:00
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum EagerExpander {
$($e_kind),*
}
2019-11-23 14:48:34 +00:00
impl BuiltinFnLikeExpander {
pub fn expand(
&self,
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
id: MacroCallId,
2019-11-23 14:48:34 +00:00
tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
2019-11-23 14:48:34 +00:00
let expander = match *self {
$( BuiltinFnLikeExpander::$kind => $expand, )*
};
expander(db, id, tt)
}
2020-03-02 06:05:15 +00:00
}
2020-03-02 06:05:15 +00:00
impl EagerExpander {
pub fn expand(
&self,
2020-03-06 14:58:45 +00:00
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
arg_id: MacroCallId,
2020-03-02 06:05:15 +00:00
tt: &tt::Subtree,
) -> ExpandResult<Option<ExpandedEager>> {
2020-03-02 06:05:15 +00:00
let expander = match *self {
$( EagerExpander::$e_kind => $e_expand, )*
};
expander(db, arg_id, tt)
}
2019-11-23 14:48:34 +00:00
}
2020-03-02 06:05:15 +00:00
fn find_by_name(ident: &name::Name) -> Option<Either<BuiltinFnLikeExpander, EagerExpander>> {
match ident {
$( id if id == &name::name![$name] => Some(Either::Left(BuiltinFnLikeExpander::$kind)), )*
$( id if id == &name::name![$e_name] => Some(Either::Right(EagerExpander::$e_kind)), )*
_ => return None,
}
2019-11-23 14:48:34 +00:00
}
2019-11-22 17:47:35 +00:00
};
}
#[derive(Debug)]
pub struct ExpandedEager {
pub(crate) subtree: tt::Subtree,
/// The included file ID of the include macro.
pub(crate) included_file: Option<FileId>,
}
impl ExpandedEager {
fn new(subtree: tt::Subtree) -> Self {
ExpandedEager { subtree, included_file: None }
}
}
2020-03-02 06:05:15 +00:00
pub fn find_builtin_macro(
ident: &name::Name,
krate: CrateId,
2020-12-15 17:43:19 +00:00
ast_id: AstId<ast::Macro>,
2020-03-02 06:05:15 +00:00
) -> Option<MacroDefId> {
let kind = find_by_name(ident)?;
match kind {
Either::Left(kind) => Some(MacroDefId {
krate,
kind: MacroDefKind::BuiltIn(kind, ast_id),
2020-05-01 03:23:03 +00:00
local_inner: false,
2020-03-02 06:05:15 +00:00
}),
Either::Right(kind) => Some(MacroDefId {
krate,
kind: MacroDefKind::BuiltInEager(kind, ast_id),
2020-05-01 03:23:03 +00:00
local_inner: false,
2020-03-02 06:05:15 +00:00
}),
}
}
2019-11-22 17:47:35 +00:00
register_builtin! {
2020-03-02 06:05:15 +00:00
LAZY:
2019-12-13 20:43:53 +00:00
(column, Column) => column_expand,
(file, File) => file_expand,
(line, Line) => line_expand,
2020-12-14 15:38:53 +00:00
(module_path, ModulePath) => module_path_expand,
2020-03-11 15:08:12 +00:00
(assert, Assert) => assert_expand,
2019-12-13 20:43:53 +00:00
(stringify, Stringify) => stringify_expand,
(format_args, FormatArgs) => format_args_expand,
// format_args_nl only differs in that it adds a newline in the end,
// so we use the same stub expansion for now
2020-03-02 06:05:15 +00:00
(format_args_nl, FormatArgsNl) => format_args_expand,
(llvm_asm, LlvmAsm) => asm_expand,
(asm, Asm) => asm_expand,
2021-04-18 16:43:45 +00:00
(global_asm, GlobalAsm) => global_asm_expand,
2021-03-10 18:43:03 +00:00
(cfg, Cfg) => cfg_expand,
(core_panic, CorePanic) => panic_expand,
(std_panic, StdPanic) => panic_expand,
2020-03-02 06:05:15 +00:00
EAGER:
(compile_error, CompileError) => compile_error_expand,
2020-03-06 14:58:45 +00:00
(concat, Concat) => concat_expand,
2021-05-13 22:42:10 +00:00
(concat_idents, ConcatIdents) => concat_idents_expand,
2020-03-10 14:01:08 +00:00
(include, Include) => include_expand,
2020-06-27 18:02:47 +00:00
(include_bytes, IncludeBytes) => include_bytes_expand,
2020-06-27 12:31:19 +00:00
(include_str, IncludeStr) => include_str_expand,
2020-03-10 14:01:08 +00:00
(env, Env) => env_expand,
(option_env, OptionEnv) => option_env_expand
2019-11-22 17:47:35 +00:00
}
2020-12-14 15:38:53 +00:00
fn module_path_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
2020-12-14 15:38:53 +00:00
_tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
// Just return a dummy result.
ExpandResult::ok(quote! { "module::path" })
}
2019-11-11 06:15:09 +00:00
fn line_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
2019-11-11 06:15:09 +00:00
_tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
// dummy implementation for type-checking purposes
let line_num = 0;
2019-11-11 06:15:09 +00:00
let expanded = quote! {
#line_num
};
ExpandResult::ok(expanded)
2019-11-11 06:15:09 +00:00
}
fn stringify_expand(
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
id: MacroCallId,
_tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
let loc = db.lookup_intern_macro(id);
let macro_content = {
let arg = match loc.kind.arg(db) {
Some(arg) => arg,
None => return ExpandResult::only_err(mbe::ExpandError::UnexpectedToken),
};
2019-12-20 14:43:01 +00:00
let macro_args = arg;
let text = macro_args.text();
2020-04-24 21:40:41 +00:00
let without_parens = TextSize::of('(')..text.len() - TextSize::of(')');
text.slice(without_parens).to_string()
};
let expanded = quote! {
#macro_content
};
ExpandResult::ok(expanded)
}
2019-11-22 15:05:04 +00:00
2019-11-22 13:48:33 +00:00
fn column_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
2019-11-22 13:48:33 +00:00
_tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
// dummy implementation for type-checking purposes
let col_num = 0;
2019-11-22 13:48:33 +00:00
let expanded = quote! {
#col_num
};
ExpandResult::ok(expanded)
2019-11-22 13:48:33 +00:00
}
2020-03-11 15:08:12 +00:00
fn assert_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
2020-03-11 15:08:12 +00:00
tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
2020-03-11 15:08:12 +00:00
// A hacky implementation for goto def and hover
// We expand `assert!(cond, arg1, arg2)` to
2020-03-11 15:08:12 +00:00
// ```
// {(cond, &(arg1), &(arg2));}
2020-03-11 15:08:12 +00:00
// ```,
// which is wrong but useful.
2021-02-28 12:46:24 +00:00
let args = parse_exprs_with_sep(tt, ',');
2020-03-11 15:08:12 +00:00
let arg_tts = args.into_iter().flat_map(|arg| {
2021-02-28 12:46:24 +00:00
quote! { &(#arg), }
2021-06-18 11:40:51 +00:00
}.token_trees);
2020-03-11 15:08:12 +00:00
let expanded = quote! {
{ { (##arg_tts); } }
};
ExpandResult::ok(expanded)
2020-03-11 15:08:12 +00:00
}
2019-11-22 15:05:04 +00:00
fn file_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
2019-11-22 15:05:04 +00:00
_tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
2019-11-22 15:05:04 +00:00
// FIXME: RA purposefully lacks knowledge of absolute file names
// so just return "".
let file_name = "";
let expanded = quote! {
#file_name
};
ExpandResult::ok(expanded)
2019-11-22 15:05:04 +00:00
}
2019-11-22 17:47:35 +00:00
fn format_args_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
2019-12-06 18:30:01 +00:00
tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
2019-12-08 08:26:17 +00:00
// We expand `format_args!("", a1, a2)` to
// ```
// std::fmt::Arguments::new_v1(&[], &[
// std::fmt::ArgumentV1::new(&arg1,std::fmt::Display::fmt),
// std::fmt::ArgumentV1::new(&arg2,std::fmt::Display::fmt),
// ])
// ```,
2019-12-06 18:30:01 +00:00
// which is still not really correct, but close enough for now
let mut args = parse_exprs_with_sep(tt, ',');
2019-12-06 18:30:01 +00:00
if args.is_empty() {
return ExpandResult::only_err(mbe::ExpandError::NoMatchingRule);
2019-12-06 18:30:01 +00:00
}
for arg in &mut args {
// Remove `key =`.
if matches!(arg.token_trees.get(1), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=' && p.spacing != tt::Spacing::Joint)
{
arg.token_trees.drain(..2);
}
}
2019-12-06 18:30:01 +00:00
let _format_string = args.remove(0);
2019-12-08 08:26:17 +00:00
let arg_tts = args.into_iter().flat_map(|arg| {
quote! { std::fmt::ArgumentV1::new(&(#arg), std::fmt::Display::fmt), }
2021-06-18 11:40:51 +00:00
}.token_trees);
let expanded = quote! {
// It's unsafe since https://github.com/rust-lang/rust/pull/83302
// Wrap an unsafe block to avoid false-positive `missing-unsafe` lint.
// FIXME: Currently we don't have `unused_unsafe` lint so an extra unsafe block won't cause issues on early
// stable rust-src.
unsafe {
std::fmt::Arguments::new_v1(&[], &[##arg_tts])
}
};
ExpandResult::ok(expanded)
}
fn asm_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
_tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
// both asm and llvm_asm don't return anything, so we can expand them to nothing,
// for now
let expanded = quote! {
()
};
ExpandResult::ok(expanded)
}
2021-04-18 16:43:45 +00:00
fn global_asm_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
2021-04-18 16:43:45 +00:00
_tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
// Expand to nothing (at item-level)
ExpandResult::ok(quote! {})
}
2021-03-10 18:43:03 +00:00
fn cfg_expand(
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
id: MacroCallId,
2021-03-10 18:43:03 +00:00
tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
let loc = db.lookup_intern_macro(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) };
ExpandResult::ok(expanded)
}
fn panic_expand(
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
id: MacroCallId,
tt: &tt::Subtree,
) -> ExpandResult<tt::Subtree> {
let loc: MacroCallLoc = db.lookup_intern_macro(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 {
quote!(#krate::panic::panic_2021!)
} else {
quote!(#krate::panic::panic_2015!)
};
// Pass the original arguments
call.token_trees.push(tt::TokenTree::Subtree(tt.clone()));
ExpandResult::ok(call)
}
2020-03-02 06:05:15 +00:00
fn unquote_str(lit: &tt::Literal) -> Option<String> {
let lit = ast::make::tokens::literal(&lit.to_string());
let token = ast::String::cast(lit)?;
token.value().map(|it| it.into_owned())
2020-03-02 06:05:15 +00:00
}
fn compile_error_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_id: MacroCallId,
tt: &tt::Subtree,
) -> ExpandResult<Option<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())
} else {
mbe::ExpandError::BindingError("`compile_error!` argument must be a string".into())
}
}
_ => mbe::ExpandError::BindingError("`compile_error!` argument must be a string".into()),
};
ExpandResult { value: Some(ExpandedEager::new(quote! {})), err: Some(err) }
}
2020-03-06 14:58:45 +00:00
fn concat_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_arg_id: MacroCallId,
2020-03-06 14:58:45 +00:00
tt: &tt::Subtree,
) -> ExpandResult<Option<ExpandedEager>> {
2020-12-08 19:06:41 +00:00
let mut err = None;
2020-03-02 06:05:15 +00:00
let mut text = String::new();
for (i, t) in tt.token_trees.iter().enumerate() {
match t {
tt::TokenTree::Leaf(tt::Leaf::Literal(it)) if i % 2 == 0 => {
2020-12-08 19:06:41 +00:00
// 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.
2021-06-13 03:54:16 +00:00
let component = unquote_str(it).unwrap_or_else(|| it.text.to_string());
text.push_str(&component);
}
// handle boolean literals
tt::TokenTree::Leaf(tt::Leaf::Ident(id))
if i % 2 == 0 && (id.text == "true" || id.text == "false") =>
{
text.push_str(id.text.as_str());
2020-03-02 06:05:15 +00:00
}
tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
2020-12-08 19:06:41 +00:00
_ => {
err.get_or_insert(mbe::ExpandError::UnexpectedToken);
}
2020-03-02 06:05:15 +00:00
}
}
ExpandResult { value: Some(ExpandedEager::new(quote!(#text))), err }
2020-03-02 06:05:15 +00:00
}
2021-05-13 22:42:10 +00:00
fn concat_idents_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_arg_id: MacroCallId,
2021-05-13 22:42:10 +00:00
tt: &tt::Subtree,
) -> ExpandResult<Option<ExpandedEager>> {
let mut err = None;
let mut ident = String::new();
for (i, t) in tt.token_trees.iter().enumerate() {
match t {
tt::TokenTree::Leaf(tt::Leaf::Ident(id)) => {
ident.push_str(id.text.as_str());
}
tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
_ => {
err.get_or_insert(mbe::ExpandError::UnexpectedToken);
}
}
}
let ident = tt::Ident { text: ident.into(), id: tt::TokenId::unspecified() };
ExpandResult { value: Some(ExpandedEager::new(quote!(#ident))), err }
2021-05-13 22:42:10 +00:00
}
2020-06-27 12:31:19 +00:00
fn relative_file(
db: &dyn AstDatabase,
call_id: MacroCallId,
path_str: &str,
2020-06-27 12:31:19 +00:00
allow_recursion: bool,
) -> Result<FileId, mbe::ExpandError> {
2020-03-06 14:58:45 +00:00
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)))?;
2020-06-05 14:45:20 +00:00
// Prevent include itself
2020-06-27 12:31:19 +00:00
if res == call_site && !allow_recursion {
Err(mbe::ExpandError::Other(format!("recursive inclusion of `{}`", path_str)))
2020-06-05 14:45:20 +00:00
} else {
Ok(res)
2020-03-07 08:25:43 +00:00
}
2020-03-06 14:58:45 +00:00
}
2020-03-10 14:01:08 +00:00
fn parse_string(tt: &tt::Subtree) -> Result<String, mbe::ExpandError> {
tt.token_trees
2020-03-06 14:58:45 +00:00
.get(0)
.and_then(|tt| match tt {
2021-06-13 03:54:16 +00:00
tt::TokenTree::Leaf(tt::Leaf::Literal(it)) => unquote_str(it),
2020-03-06 14:58:45 +00:00
_ => None,
})
2021-06-07 11:59:01 +00:00
.ok_or(mbe::ExpandError::ConversionError)
2020-03-10 14:01:08 +00:00
}
2020-03-06 14:58:45 +00:00
2020-03-10 14:01:08 +00:00
fn include_expand(
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
arg_id: MacroCallId,
2020-03-10 14:01:08 +00:00
tt: &tt::Subtree,
) -> ExpandResult<Option<ExpandedEager>> {
let res = (|| {
let path = parse_string(tt)?;
2021-06-13 03:55:55 +00:00
let file_id = relative_file(db, arg_id, &path, false)?;
2021-06-07 11:59:01 +00:00
let subtree =
parse_to_token_tree(&db.file_text(file_id)).ok_or(mbe::ExpandError::ConversionError)?.0;
Ok((subtree, file_id))
})();
match res {
Ok((subtree, file_id)) => {
ExpandResult::ok(Some(ExpandedEager { subtree, included_file: Some(file_id) }))
}
Err(e) => ExpandResult::only_err(e),
}
2020-03-06 14:58:45 +00:00
}
2020-06-27 18:02:47 +00:00
fn include_bytes_expand(
_db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
_arg_id: MacroCallId,
2020-06-27 18:02:47 +00:00
tt: &tt::Subtree,
) -> ExpandResult<Option<ExpandedEager>> {
if let Err(e) = parse_string(tt) {
return ExpandResult::only_err(e);
}
2020-06-27 18:02:47 +00:00
// FIXME: actually read the file here if the user asked for macro expansion
let res = tt::Subtree {
delimiter: None,
token_trees: vec![tt::TokenTree::Leaf(tt::Leaf::Literal(tt::Literal {
text: r#"b"""#.into(),
id: tt::TokenId::unspecified(),
}))],
};
ExpandResult::ok(Some(ExpandedEager::new(res)))
2020-06-27 18:02:47 +00:00
}
2020-06-27 12:31:19 +00:00
fn include_str_expand(
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
arg_id: MacroCallId,
2020-06-27 12:31:19 +00:00
tt: &tt::Subtree,
) -> ExpandResult<Option<ExpandedEager>> {
let path = match parse_string(tt) {
Ok(it) => it,
Err(e) => return ExpandResult::only_err(e),
};
2020-06-27 12:31:19 +00:00
// FIXME: we're not able to read excluded files (which is most of them because
// it's unusual to `include_str!` a Rust file), but we can return an empty string.
// Ideally, we'd be able to offer a precise expansion if the user asks for macro
// expansion.
2021-06-13 03:55:55 +00:00
let file_id = match relative_file(db, arg_id, &path, true) {
Ok(file_id) => file_id,
Err(_) => {
return ExpandResult::ok(Some(ExpandedEager::new(quote!(""))));
2020-06-27 12:31:19 +00:00
}
};
let text = db.file_text(file_id);
let text = &*text;
ExpandResult::ok(Some(ExpandedEager::new(quote!(#text))))
2020-06-27 12:31:19 +00:00
}
2021-05-19 18:19:08 +00:00
fn get_env_inner(db: &dyn AstDatabase, arg_id: MacroCallId, key: &str) -> Option<String> {
let krate = db.lookup_intern_macro(arg_id).krate;
2020-03-10 14:01:08 +00:00
db.crate_graph()[krate].env.get(key)
}
fn env_expand(
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
arg_id: MacroCallId,
2020-03-10 14:01:08 +00:00
tt: &tt::Subtree,
) -> ExpandResult<Option<ExpandedEager>> {
let key = match parse_string(tt) {
Ok(it) => it,
Err(e) => return ExpandResult::only_err(e),
};
2020-03-10 14:01:08 +00:00
let mut err = None;
let s = get_env_inner(db, arg_id, &key).unwrap_or_else(|| {
// 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(
r#"`OUT_DIR` not set, enable "run build scripts" to fix"#.into(),
));
}
// If the variable is unset, still return a dummy string to help type inference along.
// We cannot use an empty string here, because for
// `include!(concat!(env!("OUT_DIR"), "/foo.rs"))` will become
// `include!("foo.rs"), which might go to infinite loop
"__RA_UNIMPLEMENTED__".to_string()
});
2020-03-10 14:01:08 +00:00
let expanded = quote! { #s };
ExpandResult { value: Some(ExpandedEager::new(expanded)), err }
2020-03-10 14:01:08 +00:00
}
fn option_env_expand(
db: &dyn AstDatabase,
2021-05-19 18:19:08 +00:00
arg_id: MacroCallId,
2020-03-10 14:01:08 +00:00
tt: &tt::Subtree,
) -> ExpandResult<Option<ExpandedEager>> {
let key = match parse_string(tt) {
Ok(it) => it,
Err(e) => return ExpandResult::only_err(e),
};
2020-03-10 14:01:08 +00:00
let expanded = match get_env_inner(db, arg_id, &key) {
None => quote! { std::option::Option::None::<&str> },
Some(s) => quote! { std::option::Some(#s) },
};
ExpandResult::ok(Some(ExpandedEager::new(expanded)))
2020-03-10 14:01:08 +00:00
}
2019-11-22 17:47:35 +00:00
#[cfg(test)]
mod tests {
use std::sync::Arc;
2020-08-13 14:25:38 +00:00
use base_db::{fixture::WithFixture, SourceDatabase};
use expect_test::{expect, Expect};
2021-09-27 10:54:24 +00:00
use syntax::ast::HasName;
2019-11-22 17:47:35 +00:00
use crate::{
name::AsName, test_db::TestDB, AstNode, EagerCallInfo, ExpandTo, MacroCallId,
MacroCallKind, MacroCallLoc,
};
use super::*;
2020-03-02 06:05:15 +00:00
fn expand_builtin_macro(ra_fixture: &str) -> String {
2021-06-13 03:54:16 +00:00
let (db, file_id) = TestDB::with_single_file(ra_fixture);
2019-11-22 17:47:35 +00:00
let parsed = db.parse(file_id);
2020-12-15 17:43:19 +00:00
let mut macro_rules: Vec<_> =
2020-12-15 14:37:37 +00:00
parsed.syntax_node().descendants().filter_map(ast::MacroRules::cast).collect();
2020-12-15 17:43:19 +00:00
let mut macro_calls: Vec<_> =
parsed.syntax_node().descendants().filter_map(ast::MacroCall::cast).collect();
2019-11-22 17:47:35 +00:00
let ast_id_map = db.ast_id_map(file_id.into());
2020-12-15 14:37:37 +00:00
assert_eq!(macro_rules.len(), 1, "test must contain exactly 1 `macro_rules!`");
assert_eq!(macro_calls.len(), 1, "test must contain exactly 1 macro call");
2020-12-15 17:43:19 +00:00
let macro_rules = ast::Macro::from(macro_rules.pop().unwrap());
let macro_call = macro_calls.pop().unwrap();
let expander = find_by_name(&macro_rules.name().unwrap().as_name()).unwrap();
let ast_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules));
2020-06-11 10:08:24 +00:00
let krate = CrateId(0);
2020-03-10 14:01:08 +00:00
let file_id = match expander {
Either::Left(expander) => {
// the first one should be a macro_rules
let def = MacroDefId {
krate: CrateId(0),
kind: MacroDefKind::BuiltIn(expander, ast_id),
2020-05-01 03:23:03 +00:00
local_inner: false,
2020-03-10 14:01:08 +00:00
};
2019-11-22 17:47:35 +00:00
2020-03-10 14:01:08 +00:00
let loc = MacroCallLoc {
def,
2020-06-11 10:08:24 +00:00
krate,
2021-05-19 18:19:08 +00:00
eager: None,
2021-04-08 18:43:07 +00:00
kind: MacroCallKind::FnLike {
ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call)),
expand_to: ExpandTo::Expr,
2021-04-08 18:43:07 +00:00
},
2020-03-10 14:01:08 +00:00
};
2021-06-13 03:55:55 +00:00
let id: MacroCallId = db.intern_macro(loc);
2020-03-10 14:01:08 +00:00
id.as_file()
}
Either::Right(expander) => {
// the first one should be a macro_rules
let def = MacroDefId {
krate,
kind: MacroDefKind::BuiltInEager(expander, ast_id),
2020-05-01 03:23:03 +00:00
local_inner: false,
2020-03-10 14:01:08 +00:00
};
2019-11-22 17:47:35 +00:00
2020-12-15 17:43:19 +00:00
let args = macro_call.token_tree().unwrap();
let parsed_args = mbe::syntax_node_to_token_tree(args.syntax()).0;
2020-12-22 13:42:28 +00:00
let call_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call));
2020-03-10 14:01:08 +00:00
2021-05-19 18:19:08 +00:00
let arg_id = db.intern_macro(MacroCallLoc {
def,
krate,
eager: Some(EagerCallInfo {
2021-05-19 18:23:26 +00:00
arg_or_expansion: Arc::new(parsed_args.clone()),
included_file: None,
2021-05-19 18:19:08 +00:00
}),
kind: MacroCallKind::FnLike { ast_id: call_id, expand_to: ExpandTo::Expr },
2020-03-10 14:01:08 +00:00
});
let expanded = expander.expand(&db, arg_id, &parsed_args).value.unwrap();
let expand_to = crate::ExpandTo::from_call_site(&macro_call);
2021-05-19 18:19:08 +00:00
let loc = MacroCallLoc {
2020-03-10 14:01:08 +00:00
def,
2020-06-11 10:08:24 +00:00
krate,
2021-05-19 18:19:08 +00:00
eager: Some(EagerCallInfo {
2021-05-19 18:23:26 +00:00
arg_or_expansion: Arc::new(expanded.subtree),
2021-05-19 18:19:08 +00:00
included_file: expanded.included_file,
}),
kind: MacroCallKind::FnLike { ast_id: call_id, expand_to },
2020-03-10 14:01:08 +00:00
};
2021-06-13 03:55:55 +00:00
let id: MacroCallId = db.intern_macro(loc);
2020-03-10 14:01:08 +00:00
id.as_file()
}
};
2019-11-22 17:47:35 +00:00
2020-03-10 14:01:08 +00:00
db.parse_or_expand(file_id).unwrap().to_string()
2019-11-22 17:47:35 +00:00
}
fn check_expansion(ra_fixture: &str, expect: Expect) {
let expansion = expand_builtin_macro(ra_fixture);
expect.assert_eq(&expansion);
}
2019-11-22 17:47:35 +00:00
#[test]
fn test_column_expand() {
check_expansion(
2019-11-22 17:47:35 +00:00
r#"
#[rustc_builtin_macro]
macro_rules! column {() => {}}
column!()
"#,
expect![["0"]],
2019-11-22 17:47:35 +00:00
);
}
#[test]
fn test_line_expand() {
check_expansion(
2019-11-22 17:47:35 +00:00
r#"
#[rustc_builtin_macro]
macro_rules! line {() => {}}
line!()
"#,
expect![["0"]],
2019-11-22 17:47:35 +00:00
);
}
#[test]
fn test_stringify_expand() {
check_expansion(
2019-11-22 17:47:35 +00:00
r#"
#[rustc_builtin_macro]
macro_rules! stringify {() => {}}
stringify!(a b c)
"#,
expect![["\"a b c\""]],
2019-11-22 17:47:35 +00:00
);
}
#[test]
fn test_env_expand() {
check_expansion(
r#"
#[rustc_builtin_macro]
macro_rules! env {() => {}}
env!("TEST_ENV_VAR")
"#,
expect![["\"__RA_UNIMPLEMENTED__\""]],
);
}
#[test]
fn test_option_env_expand() {
check_expansion(
r#"
#[rustc_builtin_macro]
macro_rules! option_env {() => {}}
option_env!("TEST_ENV_VAR")
"#,
expect![["std::option::Option::None:: < &str>"]],
);
}
2019-11-22 17:47:35 +00:00
#[test]
fn test_file_expand() {
check_expansion(
2019-11-22 17:47:35 +00:00
r#"
#[rustc_builtin_macro]
macro_rules! file {() => {}}
file!()
"#,
expect![[r#""""#]],
2019-11-22 17:47:35 +00:00
);
}
2019-11-25 00:01:51 +00:00
2020-03-11 15:08:12 +00:00
#[test]
fn test_assert_expand() {
check_expansion(
2020-03-11 15:08:12 +00:00
r#"
#[rustc_builtin_macro]
macro_rules! assert {
($cond:expr) => ({ /* compiler built-in */ });
($cond:expr, $($args:tt)*) => ({ /* compiler built-in */ })
2020-03-11 15:08:12 +00:00
}
assert!(true, "{} {:?}", arg1(a, b, c), arg2);
"#,
expect![["{{(&(true), &(\"{} {:?}\"), &(arg1(a,b,c)), &(arg2),);}}"]],
2020-03-11 15:08:12 +00:00
);
}
2019-11-25 00:01:51 +00:00
#[test]
fn test_compile_error_expand() {
check_expansion(
2019-11-25 00:01:51 +00:00
r#"
#[rustc_builtin_macro]
macro_rules! compile_error {
($msg:expr) => ({ /* compiler built-in */ });
($msg:expr,) => ({ /* compiler built-in */ })
}
compile_error!("error!");
"#,
// This expands to nothing (since it's in item position), but emits an error.
expect![[""]],
2019-11-25 00:01:51 +00:00
);
}
2019-12-06 18:30:01 +00:00
#[test]
fn test_format_args_expand() {
check_expansion(
2019-12-06 18:30:01 +00:00
r#"
#[rustc_builtin_macro]
macro_rules! format_args {
($fmt:expr) => ({ /* compiler built-in */ });
($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
}
format_args!("{} {:?}", arg1(a, b, c), arg2);
"#,
expect![[
r#"unsafe{std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(arg1(a,b,c)),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(arg2),std::fmt::Display::fmt),])}"#
]],
2019-12-12 13:34:03 +00:00
);
2019-12-06 18:30:01 +00:00
}
2020-06-27 18:02:47 +00:00
#[test]
fn test_format_args_expand_with_comma_exprs() {
check_expansion(
r#"
#[rustc_builtin_macro]
macro_rules! format_args {
($fmt:expr) => ({ /* compiler built-in */ });
($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
}
format_args!("{} {:?}", a::<A,B>(), b);
"#,
expect![[
r#"unsafe{std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(a::<A,B>()),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(b),std::fmt::Display::fmt),])}"#
]],
);
}
#[test]
fn test_format_args_expand_with_broken_member_access() {
check_expansion(
r#"
#[rustc_builtin_macro]
macro_rules! format_args {
($fmt:expr) => ({ /* compiler built-in */ });
($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
}
format_args!("{} {:?}", a.);
"#,
expect![[
r#"unsafe{std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(a.),std::fmt::Display::fmt),])}"#
]],
);
}
2020-06-27 18:02:47 +00:00
#[test]
fn test_include_bytes_expand() {
check_expansion(
2020-06-27 18:02:47 +00:00
r#"
#[rustc_builtin_macro]
macro_rules! include_bytes {
($file:expr) => {{ /* compiler built-in */ }};
($file:expr,) => {{ /* compiler built-in */ }};
}
include_bytes("foo");
"#,
expect![[r#"b"""#]],
2020-06-27 18:02:47 +00:00
);
}
2020-12-08 19:06:41 +00:00
#[test]
fn test_concat_expand() {
check_expansion(
2020-12-08 19:06:41 +00:00
r##"
#[rustc_builtin_macro]
macro_rules! concat {}
concat!("foo", "r", 0, r#"bar"#, "\n", false);
2020-12-08 19:06:41 +00:00
"##,
expect![[r#""foor0bar\nfalse""#]],
2020-12-08 19:06:41 +00:00
);
}
2021-05-13 22:42:10 +00:00
#[test]
fn test_concat_idents_expand() {
check_expansion(
r##"
#[rustc_builtin_macro]
macro_rules! concat_idents {}
concat_idents!(foo, bar);
"##,
expect![[r#"foobar"#]],
);
}
2019-11-22 17:47:35 +00:00
}