Могу ли я при поиске расширения синтаксиса искать информацию о типах, отличных от аннотированного типа?

Question

Я хотел бы написать расширение синтаксиса, которое объединяет информацию из связанного типа при создании новой функции. В качестве глупого примера представьте, что у меня есть этот код:

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));
}

Answer 1

Информация о типе недоступна для расширения синтаксиса. Они доступны для плагинов 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).