3

I would like to write a syntax extension that combines information from a related type when generating a new function. As a nonsense example, pretend I have this code:

struct Monster {
    health: u8,
}

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

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

I'd like the attack attribute to be expanded to a function that knows about the methods of Monster. A simple example would be

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

Specifically, I'd like to be able to get the function signatures of the inherent methods of a type. I'd also be OK with being able to the function signatures of a trait. The important distinction is that my extension does not know ahead of time which type or trait to look up - it would be provided by the user as an argument to the annotation.

I currently have a syntax extension that decorates a type, as I want to add methods. To that end, I have implemented a MultiItemDecorator. After looking at the parameters to the expand function, I've been unable to figure out any way of looking up a type or a trait, only ways of generating brand-new types or traits:

trait MultiItemDecorator {
    fn expand(&self,
              ctx: &mut ExtCtxt,
              sp: Span,
              meta_item: &MetaItem,
              item: &Annotatable,
              push: &mut FnMut(Annotatable));
}
Daniel Fath
  • 16,453
  • 7
  • 47
  • 82
Shepmaster
  • 388,571
  • 95
  • 1,107
  • 1,366

1 Answers1

4

Type information is not available for a syntax extensions. They are available to lint plugins.

However, you can write another decorator for your impl Monster to get the type by yourself.

For instance:

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

And then, you can use it:

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

This is similar to what I did in this question and I am still looking for a better way to share this global mutable state (singleton).

Community
  • 1
  • 1
antoyo
  • 11,097
  • 7
  • 51
  • 82
  • Thanks! Unfortunately, I'd like to be able to use this for types that I can't modify to add an annotation to, such as types in other crates or the standard library. – Shepmaster Sep 18 '15 at 02:48
  • 1
    @Shepmaster: I wouldn't wait. You just can't do what you're asking. Generally, when I'm writing macros to generate code that has to interact with other types, I either have many variations of the macro to deal with different types, or just pass the necessary information in to the macro by hand. – DK. Sep 18 '15 at 05:08