3

我想编写一个语法扩展，在生成新函数时结合来自相关类型的信息。作为一个废话的例子，假设我有这个代码：

struct Monster {
    health: u8,
}

impl Monster {
    fn health(&self) { self.health }
}

#[attack(Monster)]
struct Player {
    has_weapon: true,
}

我希望将该attack属性扩展为一个了解Monster. 一个简单的例子是

impl Player {
    fn attack_monster(m: &Monster) {
        println!("{}", m.health());
    }
}

具体来说，我希望能够获得一个类型的固有方法的函数签名。我也可以使用特征的函数签名。重要的区别是我的扩展不提前知道要查找哪种类型或特征——它将由用户作为注释的参数提供。

我目前有一个修饰类型的语法扩展，因为我想添加方法。为此，我实施了一个MultiItemDecorator. 在查看了expand函数的参数后，我无法找到任何查找类型或特征的方法，只能找到生成全新类型或特征的方法：

trait MultiItemDecorator {
    fn expand(&self,
              ctx: &mut ExtCtxt,
              sp: Span,
              meta_item: &MetaItem,
              item: &Annotatable,
              push: &mut FnMut(Annotatable));
}
4

1 回答 1

4

类型信息不可用于语法扩展。它们可用于 lint 插件。

但是，您可以为自己编写另一个装饰器impl Monster来获取类型。

例如：

#![feature(plugin_registrar, rustc_private)]

extern crate rustc;
extern crate syntax;

use rustc::plugin::Registry;
use syntax::ast::MetaItem;
use syntax::ast::Item_::ItemImpl;
use syntax::ast::MetaItem_::{MetaList, MetaWord};
use syntax::codemap::Span;
use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax::ext::base::Annotatable::Item;
use syntax::ext::base::SyntaxExtension::MultiDecorator;
use syntax::parse::token::intern;

use std::collections::hash_map::HashMap;
use std::collections::hash_set::HashSet;
use std::mem;

type Structs = HashMap<String, HashSet<String>>;

fn singleton() -> &'static mut Structs {
    static mut hash_set: *mut Structs = 0 as *mut Structs;

    let set: Structs = HashMap::new();
    unsafe {
        if hash_set == 0 as *mut Structs {
            hash_set = mem::transmute(Box::new(set));
        }
        &mut *hash_set
    }
}

fn expand_attack(cx: &mut ExtCtxt, sp: Span, meta_item: &MetaItem, _: &Annotatable, _: &mut FnMut(Annotatable)) {
    let structs = singleton();
    if let MetaList(_, ref items) = meta_item.node {
        if let MetaWord(ref word) = items[0].node {
            let struct_name = word.to_string();
            if let Some(ref methods) = structs.get(&struct_name) {
                if let Some(method_name) = methods.iter().next() {
                    cx.span_warn(sp, &format!("{}.{}()", struct_name, method_name));
                    // TODO: generate the impl.
                }
            }
        }
    }
}

fn expand_register(_: &mut ExtCtxt, _: Span, _: &MetaItem, item: &Annotatable, _: &mut FnMut(Annotatable)) {
    let mut structs = singleton();

    if let &Annotatable::Item(ref item) = item {
        let name = item.ident.to_string();
        if let ItemImpl(_, _, _, _, _, ref items) = item.node {
            let mut methods = HashSet::new();
            for item in items {
                methods.insert(item.ident.to_string());
            }
            structs.insert(name, methods);
        }
    }
}

#[plugin_registrar]
pub fn plugin_register(reg: &mut Registry) {
    reg.register_syntax_extension(intern("attack"), MultiDecorator(Box::new(expand_attack)));
    reg.register_syntax_extension(intern("register"), MultiDecorator(Box::new(expand_register)));
}

然后，您可以使用它：

#[register]
impl Monster {
    fn health(&self) -> u8 { self.health }
}

这类似于我在这个问题中所做的，我仍在寻找一种更好的方法来共享这个全局可变状态（singleton）。

于 2015-09-18T02:42:58.357 回答