Compiler construction 在编写语法扩展时，是否可以查找有关注释类型以外的类型的信息？

我想写一个语法扩展，它在生成新函数时结合了相关类型的信息。作为一个无意义的例子，假设我有以下代码：

struct Monster {
    health: u8,
}

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

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

我希望将

攻击

属性扩展为了解

怪物

方法的函数。一个简单的例子是

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

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

我目前有一个修饰类型的语法扩展，因为我想添加方法。为此，我实现了一个

多项目装饰器

。查看

expand

函数的参数后，我无法找到任何查找类型或特征的方法，只能找到生成全新类型或特征的方法：

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

---

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

但是，您可以为您的

impl Monster

编写另一个decorator来自己获取类型

例如：

#![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)));
}

---

这与我在本文中所做的类似，我仍在寻找更好的方式来共享这个全局可变状态（

singleton

）。

谢谢！不幸的是，我希望能够将其用于无法修改以添加注释的类型，例如其他板条箱或标准库中的类型。@Shepmaster:我不会等待。你就是不能按你的要求去做。通常，当我编写宏来生成必须与其他类型交互的代码时，我要么使用宏的许多变体来处理不同的类型，要么直接将必要的信息传递给宏。

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