rust/src/librustc/plugin/load.rs

// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! Used by `rustc` when loading a plugin, or a crate with exported macros.

use session::Session;
use metadata::creader::CrateReader;
use plugin::registry::Registry;

use std::mem;
use std::env;
use std::dynamic_lib::DynamicLibrary;
use std::collections::{HashSet, HashMap};
use std::borrow::ToOwned;
use syntax::ast;
use syntax::attr;
use syntax::codemap::{Span, COMMAND_LINE_SP};
use syntax::parse::token;
use syntax::ptr::P;
use syntax::visit;
use syntax::visit::Visitor;
use syntax::attr::AttrMetaMethods;

/// Pointer to a registrar function.
pub type PluginRegistrarFun =
    fn(&mut Registry);

pub struct PluginRegistrar {
    pub fun: PluginRegistrarFun,
    pub args: Vec<P<ast::MetaItem>>,
}

/// Information about loaded plugins.
pub struct Plugins {
    /// Imported macros.
    pub macros: Vec<ast::MacroDef>,
    /// Registrars, as function pointers.
    pub registrars: Vec<PluginRegistrar>,
}

pub struct PluginLoader<'a> {
    sess: &'a Session,
    span_whitelist: HashSet<Span>,
    reader: CrateReader<'a>,
    pub plugins: Plugins,
}

impl<'a> PluginLoader<'a> {
    fn new(sess: &'a Session) -> PluginLoader<'a> {
        PluginLoader {
            sess: sess,
            reader: CrateReader::new(sess),
            span_whitelist: HashSet::new(),
            plugins: Plugins {
                macros: vec!(),
                registrars: vec!(),
            },
        }
    }
}

/// Read plugin metadata and dynamically load registrar functions.
pub fn load_plugins(sess: &Session, krate: &ast::Crate,
                    addl_plugins: Option<Vec<String>>) -> Plugins {
    let mut loader = PluginLoader::new(sess);

    // We need to error on `#[macro_use] extern crate` when it isn't at the
    // crate root, because `$crate` won't work properly. Identify these by
    // spans, because the crate map isn't set up yet.
    for item in &krate.module.items {
        if let ast::ItemExternCrate(_) = item.node {
            loader.span_whitelist.insert(item.span);
        }
    }

    visit::walk_crate(&mut loader, krate);

    for attr in &krate.attrs {
        if !attr.check_name("plugin") {
            continue;
        }

        let plugins = match attr.meta_item_list() {
            Some(xs) => xs,
            None => {
                sess.span_err(attr.span, "malformed plugin attribute");
                continue;
            }
        };

        for plugin in plugins {
            if plugin.value_str().is_some() {
                sess.span_err(attr.span, "malformed plugin attribute");
                continue;
            }

            let args = plugin.meta_item_list().map(ToOwned::to_owned).unwrap_or_default();
            loader.load_plugin(plugin.span, &*plugin.name(), args);
        }
    }

    if let Some(plugins) = addl_plugins {
        for plugin in plugins {
            loader.load_plugin(COMMAND_LINE_SP, &plugin, vec![]);
        }
    }

    return loader.plugins;
}

pub type MacroSelection = HashMap<token::InternedString, Span>;

// note that macros aren't expanded yet, and therefore macros can't add plugins.
impl<'a, 'v> Visitor<'v> for PluginLoader<'a> {
    fn visit_item(&mut self, item: &ast::Item) {
        // We're only interested in `extern crate`.
        match item.node {
            ast::ItemExternCrate(_) => {}
            _ => {
                visit::walk_item(self, item);
                return;
            }
        }

        // Parse the attributes relating to macro loading.
        let mut import = Some(HashMap::new());  // None => load all
        let mut reexport = HashMap::new();
        for attr in &item.attrs {
            let mut used = true;
            match &attr.name()[] {
                "phase" => {
                    self.sess.span_err(attr.span, "#[phase] is deprecated");
                }
                "plugin" => {
                    self.sess.span_err(attr.span, "#[plugin] on `extern crate` is deprecated");
                    self.sess.span_help(attr.span, &format!("use a crate attribute instead, \
                                                            i.e. #![plugin({})]",
                                                            item.ident.as_str())[]);
                }
                "macro_use" => {
                    let names = attr.meta_item_list();
                    if names.is_none() {
                        // no names => load all
                        import = None;
                    }
                    if let (Some(sel), Some(names)) = (import.as_mut(), names) {
                        for attr in names {
                            if let ast::MetaWord(ref name) = attr.node {
                                sel.insert(name.clone(), attr.span);
                            } else {
                                self.sess.span_err(attr.span, "bad macro import");
                            }
                        }
                    }
                }
                "macro_reexport" => {
                    let names = match attr.meta_item_list() {
                        Some(names) => names,
                        None => {
                            self.sess.span_err(attr.span, "bad macro reexport");
                            continue;
                        }
                    };

                    for attr in names {
                        if let ast::MetaWord(ref name) = attr.node {
                            reexport.insert(name.clone(), attr.span);
                        } else {
                            self.sess.span_err(attr.span, "bad macro reexport");
                        }
                    }
                }
                _ => used = false,
            }
            if used {
                attr::mark_used(attr);
            }
        }

        self.load_macros(item, import, reexport)
    }

    fn visit_mac(&mut self, _: &ast::Mac) {
        // bummer... can't see plugins inside macros.
        // do nothing.
    }
}

impl<'a> PluginLoader<'a> {
    pub fn load_macros<'b>(&mut self,
                           vi: &ast::Item,
                           import: Option<MacroSelection>,
                           reexport: MacroSelection) {
        if let Some(sel) = import.as_ref() {
            if sel.is_empty() && reexport.is_empty() {
                return;
            }
        }

        if !self.span_whitelist.contains(&vi.span) {
            self.sess.span_err(vi.span, "an `extern crate` loading macros must be at \
                                         the crate root");
            return;
        }

        let macros = self.reader.read_exported_macros(vi);
        let mut seen = HashSet::new();

        for mut def in macros {
            let name = token::get_ident(def.ident);
            seen.insert(name.clone());

            def.use_locally = match import.as_ref() {
                None => true,
                Some(sel) => sel.contains_key(&name),
            };
            def.export = reexport.contains_key(&name);
            self.plugins.macros.push(def);
        }

        if let Some(sel) = import.as_ref() {
            for (name, span) in sel.iter() {
                if !seen.contains(name) {
                    self.sess.span_err(*span, "imported macro not found");
                }
            }
        }

        for (name, span) in reexport.iter() {
            if !seen.contains(name) {
                self.sess.span_err(*span, "reexported macro not found");
            }
        }
    }

    pub fn load_plugin(&mut self, span: Span, name: &str, args: Vec<P<ast::MetaItem>>) {
        let registrar = self.reader.find_plugin_registrar(span, name);

        if let Some((lib, symbol)) = registrar {
            let fun = self.dylink_registrar(span, lib, symbol);
            self.plugins.registrars.push(PluginRegistrar {
                fun: fun,
                args: args,
            });
        }
    }

    // Dynamically link a registrar function into the compiler process.
    fn dylink_registrar(&mut self,
                        span: Span,
                        path: Path,
                        symbol: String) -> PluginRegistrarFun {
        // Make sure the path contains a / or the linker will search for it.
        let path = env::current_dir().unwrap().join(&path);

        let lib = match DynamicLibrary::open(Some(&path)) {
            Ok(lib) => lib,
            // this is fatal: there are almost certainly macros we need
            // inside this crate, so continue would spew "macro undefined"
            // errors
            Err(err) => {
                self.sess.span_fatal(span, &err[])
            }
        };

        unsafe {
            let registrar =
                match lib.symbol(&symbol[]) {
                    Ok(registrar) => {
                        mem::transmute::<*mut u8,PluginRegistrarFun>(registrar)
                    }
                    // again fatal if we can't register macros
                    Err(err) => {
                        self.sess.span_fatal(span, &err[])
                    }
                };

            // Intentionally leak the dynamic library. We can't ever unload it
            // since the library can make things that will live arbitrarily long
            // (e.g. an @-box cycle or a task).
            mem::forget(lib);

            registrar
        }
    }
}