Blog

fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv {
    // ...
    let mut syntax_expanders = SyntaxEnv::new();

    // ...
    syntax_expanders.insert(intern("derive"),
                            Decorator(box ext::deriving::expand_meta_derive));
    // ...
}

// File: libsyntax/ext/deriving/mod.rs
pub fn expand_meta_derive(cx: &mut ExtCtxt,
                          _span: Span,
                          mitem: &MetaItem,
                          item: &Item,
                          mut push: Box<FnMut(P<Item>)>) {
    // ...
}

// File: libsyntax/ext/deriving/mod.rs in function expand_meta_derive()
match tname.get() {
    "Clone" => expand!(clone::expand_deriving_clone),

    "Hash" => expand!(hash::expand_deriving_hash),

    "RustcEncodable" => {
        expand!(encodable::expand_deriving_rustc_encodable)
    }
    "RustcDecodable" => {
        expand!(decodable::expand_deriving_rustc_decodable)
    }
    "Encodable" => {
        cx.span_warn(titem.span,
                     "derive(Encodable) is deprecated \
                      in favor of derive(RustcEncodable)");

        expand!(encodable::expand_deriving_encodable)
    }
    "Decodable" => {
        cx.span_warn(titem.span,
                     "derive(Decodable) is deprecated \
                      in favor of derive(RustcDecodable)");

        expand!(decodable::expand_deriving_decodable)
    }

    "PartialEq" => expand!(eq::expand_deriving_eq),
    "Eq" => expand!(totaleq::expand_deriving_totaleq),
    "PartialOrd" => expand!(ord::expand_deriving_ord),
    "Ord" => expand!(totalord::expand_deriving_totalord),

    "Rand" => expand!(rand::expand_deriving_rand),

    "Show" => {
        cx.span_warn(titem.span,
                     "derive(Show) is deprecated \
                      in favor of derive(Debug)");

        expand!(show::expand_deriving_show)
    },

    "Debug" => expand!(show::expand_deriving_show),

    "Default" => expand!(default::expand_deriving_default),

    "FromPrimitive" => expand!(primitive::expand_deriving_from_primitive),

    "Send" => expand!(bounds::expand_deriving_bound),
    "Sync" => expand!(bounds::expand_deriving_bound),
    "Copy" => expand!(bounds::expand_deriving_bound),

    ref tname => {
        cx.span_err(titem.span,
                    &format!("unknown `derive` \
                             trait: `{}`",
                            *tname)[]);
    }
}

// File: libsyntax/ext/deriving/show.rs
pub fn expand_deriving_show<F>(cx: &mut ExtCtxt,
                               span: Span,
                               mitem: &MetaItem,
                               item: &Item,
                               push: F) where
    F: FnOnce(P<Item>),
{
    // &mut ::std::fmt::Formatter
    let fmtr = Ptr(box Literal(Path::new(vec!("std", "fmt", "Formatter"))),
                   Borrowed(None, ast::MutMutable));

    let trait_def = TraitDef {
        span: span,
        attributes: Vec::new(),
        path: Path::new(vec!["std", "fmt", "Debug"]),
        additional_bounds: Vec::new(),
        generics: LifetimeBounds::empty(),
        methods: vec![
            MethodDef {
                name: "fmt",
                generics: LifetimeBounds::empty(),
                explicit_self: borrowed_explicit_self(),
                args: vec!(fmtr),
                ret_ty: Literal(Path::new(vec!("std", "fmt", "Result"))),
                attributes: Vec::new(),
                combine_substructure: combine_substructure(box |a, b, c| {
                    show_substructure(a, b, c)
                })
            }
        ],
        associated_types: Vec::new(),
    };
    trait_def.expand(cx, mitem, item, push)
}

cx.item(
    self.span,
    ident,
    a,
    ast::ItemImpl(ast::Unsafety::Normal,
                  ast::ImplPolarity::Positive,
                  trait_generics,
                  opt_trait_ref,
                  self_type,
                  methods.into_iter()
                         .map(|method| {
                             ast::MethodImplItem(method)
                         }).chain(
                             associated_types.map(|type_| {
                                 ast::TypeImplItem(type_)
                             })
                         ).collect()))

// File: libsyntax/ext/build.rs
impl<'a> AstBuilder for ExtCtxt<'a> {
    // ...
    fn item(&self, span: Span, name: Ident,
            attrs: Vec<ast::Attribute>, node: ast::Item_) -> P<ast::Item> {
        // FIXME: Would be nice if our generated code didn't violate
        // Rust coding conventions
        P(ast::Item {
            ident: name,
            attrs: attrs,
            id: ast::DUMMY_NODE_ID,
            node: node,
            vis: ast::Inherited,
            span: span
        })
    }
    // ...
}

/* File: some-header.h */
#ifdef __cplusplus
extern "C" {
#endif

/* Contents of header file */

#ifdef __cplusplus
}
#endif

/* File: common.h */
#ifdef __cplusplus
# define BEGIN_C_DECLS extern "C" {
# define END_C_DECLS }
#else
# define BEGIN_C_DECLS 
# define END_C_DECLS
#endif

/* File: some-header.h */
#include <common.h>
BEGIN_C_DECLS

/* Contents of header file */

END_C_DECLS

// File: foo.rs
pub fn foo_function(v: &Vec<u8>) -> Vec<u8> {
    ...
}

// File: bar.rs
pub fn bar_function(v: &Vec<u8>) -> Vec<u8> {
    ...
}

// File: main1.rs
mod foo;
mod bar;

fn main() {
    // Use both 'foo::foo_function()' and 'bar::bar_function' here...
}

// File: bar.rs
mod foo;

fn bar_function(v: &Vec<u8>) -> Vec<u8> {
    // Do something
    let _ = foo::foo_function(...)
}

> rustc main.rs
bar.rs:1:5: 1:8 error: cannot declare a new module at this location
bar.rs:1 mod foo;
             ^~~
bar.rs:1:5: 1:8 note: maybe move this module `bar` to its own directory via `bar/mod.rs`
       1 mod foo;
bar.rs:1 mod foo;
             ^~~
bar.rs:1:5: 1:8 note: ... or maybe `use` the module `foo` instead of possibly redeclaring it
bar.rs:1 mod foo;
             ^~~