1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use syntax::fold::Folder;
12 use syntax::{ast, fold, attr};
16 in_cfg: |attrs: &[ast::Attribute]|: 'a -> bool,
19 // Support conditional compilation by transforming the AST, stripping out
20 // any items that do not belong in the current configuration
21 pub fn strip_unconfigured_items(krate: ast::Crate) -> ast::Crate {
22 let config = krate.config.clone();
23 strip_items(krate, |attrs| in_cfg(config.as_slice(), attrs))
26 impl<'a> fold::Folder for Context<'a> {
27 fn fold_mod(&mut self, module: &ast::Mod) -> ast::Mod {
28 fold_mod(self, module)
30 fn fold_block(&mut self, block: ast::P<ast::Block>) -> ast::P<ast::Block> {
31 fold_block(self, block)
33 fn fold_foreign_mod(&mut self, foreign_mod: &ast::ForeignMod) -> ast::ForeignMod {
34 fold_foreign_mod(self, foreign_mod)
36 fn fold_item_underscore(&mut self, item: &ast::Item_) -> ast::Item_ {
37 fold_item_underscore(self, item)
41 pub fn strip_items(krate: ast::Crate,
42 in_cfg: |attrs: &[ast::Attribute]| -> bool)
44 let mut ctxt = Context {
47 ctxt.fold_crate(krate)
50 fn filter_view_item<'r>(cx: &mut Context, view_item: &'r ast::ViewItem)
51 -> Option<&'r ast::ViewItem> {
52 if view_item_in_cfg(cx, view_item) {
59 fn fold_mod(cx: &mut Context, m: &ast::Mod) -> ast::Mod {
60 let filtered_items: Vec<&@ast::Item> = m.items.iter()
61 .filter(|&a| item_in_cfg(cx, *a))
63 let flattened_items = filtered_items.move_iter()
64 .flat_map(|&x| cx.fold_item(x).move_iter())
66 let filtered_view_items = m.view_items.iter().filter_map(|a| {
67 filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
70 view_items: filtered_view_items,
71 items: flattened_items
75 fn filter_foreign_item(cx: &mut Context, item: @ast::ForeignItem)
76 -> Option<@ast::ForeignItem> {
77 if foreign_item_in_cfg(cx, item) {
84 fn fold_foreign_mod(cx: &mut Context, nm: &ast::ForeignMod) -> ast::ForeignMod {
85 let filtered_items = nm.items
87 .filter_map(|a| filter_foreign_item(cx, *a))
89 let filtered_view_items = nm.view_items.iter().filter_map(|a| {
90 filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
94 view_items: filtered_view_items,
99 fn fold_item_underscore(cx: &mut Context, item: &ast::Item_) -> ast::Item_ {
100 let item = match *item {
101 ast::ItemImpl(ref a, ref b, c, ref methods) => {
102 let methods = methods.iter().filter(|m| method_in_cfg(cx, **m))
103 .map(|x| *x).collect();
104 ast::ItemImpl((*a).clone(), (*b).clone(), c, methods)
106 ast::ItemTrait(ref a, b, ref c, ref methods) => {
107 let methods = methods.iter()
108 .filter(|m| trait_method_in_cfg(cx, *m) )
109 .map(|x| (*x).clone())
111 ast::ItemTrait((*a).clone(), b, (*c).clone(), methods)
113 ast::ItemStruct(def, ref generics) => {
114 ast::ItemStruct(fold_struct(cx, def), generics.clone())
116 ast::ItemEnum(ref def, ref generics) => {
117 let mut variants = def.variants.iter().map(|c| c.clone()).
119 if !(cx.in_cfg)(v.node.attrs.as_slice()) {
122 Some(match v.node.kind {
123 ast::TupleVariantKind(..) => v,
124 ast::StructVariantKind(def) => {
125 let def = fold_struct(cx, def);
127 node: ast::Variant_ {
128 kind: ast::StructVariantKind(def),
137 ast::ItemEnum(ast::EnumDef {
138 variants: variants.collect(),
141 ref item => item.clone(),
144 fold::noop_fold_item_underscore(&item, cx)
147 fn fold_struct(cx: &mut Context, def: &ast::StructDef) -> @ast::StructDef {
148 let mut fields = def.fields.iter().map(|c| c.clone()).filter(|m| {
149 (cx.in_cfg)(m.node.attrs.as_slice())
152 fields: fields.collect(),
153 ctor_id: def.ctor_id,
154 super_struct: def.super_struct.clone(),
155 is_virtual: def.is_virtual,
159 fn retain_stmt(cx: &mut Context, stmt: @ast::Stmt) -> bool {
161 ast::StmtDecl(decl, _) => {
163 ast::DeclItem(item) => {
164 item_in_cfg(cx, item)
173 fn fold_block(cx: &mut Context, b: ast::P<ast::Block>) -> ast::P<ast::Block> {
174 let resulting_stmts: Vec<&@ast::Stmt> =
175 b.stmts.iter().filter(|&a| retain_stmt(cx, *a)).collect();
176 let resulting_stmts = resulting_stmts.move_iter()
177 .flat_map(|&stmt| cx.fold_stmt(stmt).move_iter())
179 let filtered_view_items = b.view_items.iter().filter_map(|a| {
180 filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
183 view_items: filtered_view_items,
184 stmts: resulting_stmts,
185 expr: b.expr.map(|x| cx.fold_expr(x)),
192 fn item_in_cfg(cx: &mut Context, item: &ast::Item) -> bool {
193 return (cx.in_cfg)(item.attrs.as_slice());
196 fn foreign_item_in_cfg(cx: &mut Context, item: &ast::ForeignItem) -> bool {
197 return (cx.in_cfg)(item.attrs.as_slice());
200 fn view_item_in_cfg(cx: &mut Context, item: &ast::ViewItem) -> bool {
201 return (cx.in_cfg)(item.attrs.as_slice());
204 fn method_in_cfg(cx: &mut Context, meth: &ast::Method) -> bool {
205 return (cx.in_cfg)(meth.attrs.as_slice());
208 fn trait_method_in_cfg(cx: &mut Context, meth: &ast::TraitMethod) -> bool {
210 ast::Required(ref meth) => (cx.in_cfg)(meth.attrs.as_slice()),
211 ast::Provided(meth) => (cx.in_cfg)(meth.attrs.as_slice())
215 // Determine if an item should be translated in the current crate
216 // configuration based on the item's attributes
217 fn in_cfg(cfg: &[@ast::MetaItem], attrs: &[ast::Attribute]) -> bool {
218 attr::test_cfg(cfg, attrs.iter().map(|x| *x))