Как написать плагин компилятора Rust, который генерирует модуль?
Я пишу плагин компилятора Rust, который расширяет
choose! {
test_a
test_b
}
в
#[cfg(feature = "a")]
mod test_a;
#[cfg(feature = "b")]
mod test_b;
Это почти сделано, но модуль не содержит ничего в окончательно расширенном коде. Я думаю, причина в том, что span не покрывает файл модуля.
use syntax::ast;
use syntax::ptr::P;
use syntax::codemap;
use syntax::parse::token;
use syntax::tokenstream::TokenTree;
use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
use syntax::ext::build::AstBuilder;
use syntax_pos::Span;
use rustc_plugin::Registry;
use syntax::util::small_vector::SmallVector;
// Ideally, it will expand
//
// ```rust
// choose! {
// test_a
// test_b
// }
// ```
// to
// ```rust
// #[cfg(feature = "a")]
// mod test_a;
// #[cfg(feature = "b")]
// mod test_b;
// ```
//
// but the modules contain nothing in the expanded code at present
fn choose(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<MacResult + 'static> {
let mut test_mods: SmallVector<P<ast::Item>> = SmallVector::many(vec![]);
for arg in args {
let mut attrs = vec![];
let text = match arg {
&TokenTree::Token(_, token::Ident(s)) => s.to_string(),
_ => {
return DummyResult::any(sp);
}
};
let cfg_str = token::InternedString::new("cfg");
let feat_str = token::InternedString::new("feature");
attrs.push(cx.attribute(sp,
cx.meta_list(sp,
cfg_str,
vec![cx.meta_name_value(sp,
feat_str,
ast::LitKind::Str(token::intern_and_get_ident(text.trim_left_matches("test_")), ast::StrStyle::Cooked))])));
test_mods.push(P(ast::Item {
ident: cx.ident_of(text.as_str()),
attrs: attrs,
id: ast::DUMMY_NODE_ID,
node: ast::ItemKind::Mod(
// === How to include the specified module file here? ===
ast::Mod {
inner: codemap::DUMMY_SP,
items: vec![],
}
),
vis: ast::Visibility::Inherited,
span: sp,
}))
}
MacEager::items(test_mods)
}
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("choose", choose);
}
( Гист)
1 ответ
Решение
2016-08-25 обновление: использование libsyntax::parse::new_parser_from_source_str чтобы избежать установки пути модуля вручную.new_parser_from_source_str будет размещать только модули на CWD, что является неожиданным.
Как указывает @Francis, реальный путь к файлу модуля может быть foo/mod.rs,и я обнаружил функцию с именем поэтому я должен разобраться с этим делом вручную. Обновленный код:new_parser_from_source_str, который может создать новый парсер из исходной строки, в libsyntax::parse, поэтому я решил попросить компилятор обработать этот случай для меня
fn choose(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<MacResult + 'static> {
let mut test_mods = SmallVector::zero();
let cfg_str = intern("cfg");
let ftre_str = intern("feature");
for arg in args {
let mut attrs = vec![];
let mod_name = match arg {
&TokenTree::Token(_, token::Ident(s)) => s.to_string(),
_ => {
return DummyResult::any(sp);
}
};
attrs.push(cx.attribute(sp,
cx.meta_list(sp,
// simply increase the reference counter
cfg_str.clone(),
vec![cx.meta_name_value(sp,
ftre_str.clone(),
ast::LitKind::Str(intern(mod_name.trim_left_matches("test_")), ast::StrStyle::Cooked))])));
let mut mod_path = PathBuf::from(&cx.codemap().span_to_filename(sp));
let dir = mod_path.parent().expect("no parent directory").to_owned();
let default_path = dir.join(format!("{}.rs", mod_name.as_str()));
let secondary_path = dir.join(format!("{}/mod.rs", mod_name.as_str()));
match (default_path.exists(), secondary_path.exists()) {
(false, false) => {
cx.span_err(sp, &format!("file not found for module `{}`", mod_name.as_str()));
return DummyResult::any(sp);
}
(true, true) => {
cx.span_err(sp, &format!("file for module `{}` found at both {} and {}", mod_name.as_str(), default_path.display(), secondary_path.display()));
return DummyResult::any(sp);
}
(true, false) => mod_path = default_path,
(false, true) => mod_path = secondary_path,
}
test_mods.push(P(ast::Item {
ident: cx.ident_of(mod_name.as_str()),
attrs: attrs,
id: ast::DUMMY_NODE_ID,
node: ast::ItemKind::Mod(
ast::Mod {
inner: sp,
items: expand_include(cx, sp, &mod_path),
}
),
vis: ast::Visibility::Inherited,
span: sp,
}))
}
MacEager::items(test_mods)
}
Наконец я нашел решение! \ О /
Процесс Rust обрабатывает файл модуля как include!, В результате я посмотрел на реализацию макроса include!, который можно найти здесь, и переписать его в соответствии с моими потребностями:
use ::std::path::Path;
use ::std::path::PathBuf;
use syntax::parse::{self, token};
use syntax::errors::FatalError;
macro_rules! panictry {
($e:expr) => ({
match $e {
Ok(e) => e,
Err(mut e) => {
e.emit();
panic!(FatalError);
}
}
})
}
pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt, sp: Span, file: &Path) -> Vec<P<ast::Item>> {
let mut p = parse::new_sub_parser_from_file(cx.parse_sess(), cx.cfg(), file, true, None, sp);
let mut ret = vec![];
while p.token != token::Eof {
match panictry!(p.parse_item()) {
Some(item) => ret.push(item),
None => {
panic!(p.diagnostic().span_fatal(p.span,
&format!("expected item, found `{}`", p.this_token_to_string())))
}
}
}
ret
}
Чтобы получить элементы из файла модуля, мы должны узнать реальный путь к модулю:
let mut mod_path = PathBuf::from(&cx.codemap().span_to_filename(sp));
mod_path.set_file_name(mod_name.as_str());
mod_path.set_extension("rs");
Тогда мы можем построить наш узел модуля следующим образом:
P(ast::Item {
ident: cx.ident_of(mod_name.as_str()),
attrs: attrs,
id: ast::DUMMY_NODE_ID,
node: ast::ItemKind::Mod(ast::Mod {
inner: sp,
items: expand_include(cx, sp, &mod_path),
}),
vis: ast::Visibility::Inherited,
span: sp,
})
Таким образом, плагин должен быть переписан следующим образом:
#![feature(plugin_registrar, rustc_private)]
extern crate syntax;
extern crate rustc_plugin;
use syntax::ast;
use syntax::ptr::P;
use syntax::codemap::Span;
use syntax::parse::{self, token};
use syntax::tokenstream::TokenTree;
use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
use syntax::errors::FatalError;
use syntax::ext::build::AstBuilder;
use rustc_plugin::Registry;
use syntax::util::small_vector::SmallVector;
use ::std::path::Path;
use ::std::path::PathBuf;
macro_rules! panictry {
($e:expr) => ({
match $e {
Ok(e) => e,
Err(mut e) => {
e.emit();
panic!(FatalError);
}
}
})
}
pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt, sp: Span, file: &Path) -> Vec<P<ast::Item>> {
let mut p = parse::new_sub_parser_from_file(cx.parse_sess(), cx.cfg(), file, true, None, sp);
let mut ret = vec![];
while p.token != token::Eof {
match panictry!(p.parse_item()) {
Some(item) => ret.push(item),
None => {
panic!(p.diagnostic().span_fatal(p.span,
&format!("expected item, found `{}`", p.this_token_to_string())))
}
}
}
ret
}
fn intern(s: &str) -> token::InternedString {
token::intern_and_get_ident(s)
}
fn choose(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<MacResult + 'static> {
let mut test_mods = SmallVector::zero();
let cfg_str = intern("cfg");
let feat_str = intern("feature");
for arg in args {
let mut attrs = vec![];
let mod_name = match arg {
&TokenTree::Token(_, token::Ident(s)) => s.to_string(),
_ => {
return DummyResult::any(sp);
}
};
attrs.push(cx.attribute(sp,
cx.meta_list(sp,
// simply increase the reference counter
cfg_str.clone(),
vec![cx.meta_name_value(sp,
feat_str.clone(),
ast::LitKind::Str(intern(mod_name.trim_left_matches("test_")), ast::StrStyle::Cooked))])));
let mut mod_path = PathBuf::from(&cx.codemap().span_to_filename(sp));
mod_path.set_file_name(mod_name.as_str());
mod_path.set_extension("rs");
test_mods.push(P(ast::Item {
ident: cx.ident_of(mod_name.as_str()),
attrs: attrs,
id: ast::DUMMY_NODE_ID,
node: ast::ItemKind::Mod(
ast::Mod {
inner: sp,
items: expand_include(cx, sp, &mod_path),
}
),
vis: ast::Visibility::Inherited,
span: sp,
}))
}
MacEager::items(test_mods)
}
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("choose", choose);
}