@@ -16,6 +16,7 @@ use syntax::ast;
1616use syntax:: attr;
1717use syntax:: codemap:: dummy_sp;
1818use syntax:: codemap;
19+ use syntax:: fold:: ast_fold;
1920use syntax:: fold;
2021use syntax:: opt_vec;
2122
@@ -38,91 +39,103 @@ fn no_prelude(attrs: &[ast::Attribute]) -> bool {
3839 attr:: contains_name ( attrs, "no_implicit_prelude" )
3940}
4041
41- fn inject_libstd_ref ( sess : Session , crate : & ast:: Crate ) -> @ast:: Crate {
42- fn spanned < T > ( x : T ) -> codemap:: Spanned < T > {
43- codemap:: Spanned { node : x, span : dummy_sp ( ) }
42+ fn spanned < T > ( x : T ) -> codemap:: Spanned < T > {
43+ codemap:: Spanned {
44+ node : x,
45+ span : dummy_sp ( ) ,
4446 }
47+ }
4548
46- let precursor = @fold:: AstFoldFns {
47- fold_crate : |crate , fld| {
48- let n1 = ast:: DUMMY_NODE_ID ;
49- let vi1 = ast:: view_item {
50- node : ast:: view_item_extern_mod (
51- sess. ident_of ( "std" ) , None , ~[ ] , n1) ,
52- attrs : ~[
53- attr:: mk_attr (
54- attr:: mk_name_value_item_str ( @"vers", STD_VERSION . to_managed ( ) ) )
55- ] ,
56- vis : ast:: private,
57- span : dummy_sp ( )
58- } ;
59-
60- let vis = vec:: append ( ~[ vi1] , crate . module. view_items ) ;
61- let mut new_module = ast:: _mod {
62- view_items : vis,
63- ..crate . module. clone ( )
64- } ;
65-
66- if !no_prelude ( crate . attrs) {
67- // only add `use std::prelude::*;` if there wasn't a
68- // `#[no_implicit_prelude];` at the crate level.
69- new_module = fld. fold_mod ( & new_module) ;
70- }
71-
72- // FIXME #2543: Bad copy.
73- ast:: Crate {
74- module : new_module,
75- ..( * crate ) . clone ( )
76- }
77- } ,
78- fold_item : |item, fld| {
79- if !no_prelude ( item. attrs ) {
80- // only recur if there wasn't `#[no_implicit_prelude];`
81- // on this item, i.e. this means that the prelude is not
82- // implicitly imported though the whole subtree
83- fold:: noop_fold_item ( item, fld)
84- } else {
85- Some ( item)
86- }
87- } ,
88- fold_mod : |module, fld| {
89- let n2 = ast:: DUMMY_NODE_ID ;
90-
91- let prelude_path = ast:: Path {
92- span : dummy_sp ( ) ,
93- global : false ,
94- segments : ~[
95- ast:: PathSegment {
96- identifier : sess. ident_of ( "std" ) ,
97- lifetime : None ,
98- types : opt_vec:: Empty ,
99- } ,
100- ast:: PathSegment {
101- identifier : sess. ident_of ( "prelude" ) ,
102- lifetime : None ,
103- types : opt_vec:: Empty ,
104- } ,
105- ] ,
106- } ;
107-
108- let vp = @spanned ( ast:: view_path_glob ( prelude_path, n2) ) ;
109- let vi2 = ast:: view_item { node : ast:: view_item_use ( ~[ vp] ) ,
110- attrs : ~[ ] ,
111- vis : ast:: private,
112- span : dummy_sp ( ) } ;
113-
114- let vis = vec:: append ( ~[ vi2] , module. view_items ) ;
115-
116- // FIXME #2543: Bad copy.
117- let new_module = ast:: _mod {
118- view_items : vis,
119- ..( * module) . clone ( )
120- } ;
121- fold:: noop_fold_mod ( & new_module, fld)
122- } ,
123- ..* fold:: default_ast_fold ( )
124- } ;
49+ struct StandardLibraryInjector {
50+ sess : Session ,
51+ }
12552
126- let fold = fold:: make_fold ( precursor) ;
53+ impl fold:: ast_fold for StandardLibraryInjector {
54+ fn fold_crate ( & self , crate : & ast:: Crate ) -> ast:: Crate {
55+ let version = STD_VERSION . to_managed ( ) ;
56+ let vi1 = ast:: view_item {
57+ node : ast:: view_item_extern_mod ( self . sess . ident_of ( "std" ) ,
58+ None ,
59+ ~[ ] ,
60+ ast:: DUMMY_NODE_ID ) ,
61+ attrs : ~[
62+ attr:: mk_attr ( attr:: mk_name_value_item_str ( @"vers", version) )
63+ ] ,
64+ vis : ast:: private,
65+ span : dummy_sp ( )
66+ } ;
67+
68+ let vis = vec:: append ( ~[ vi1] , crate . module. view_items ) ;
69+ let mut new_module = ast:: _mod {
70+ view_items : vis,
71+ ..crate . module. clone ( )
72+ } ;
73+
74+ if !no_prelude ( crate . attrs) {
75+ // only add `use std::prelude::*;` if there wasn't a
76+ // `#[no_implicit_prelude];` at the crate level.
77+ new_module = self . fold_mod ( & new_module) ;
78+ }
79+
80+ // FIXME #2543: Bad copy.
81+ ast:: Crate {
82+ module : new_module,
83+ ..( * crate ) . clone ( )
84+ }
85+ }
86+
87+ fn fold_item ( & self , item : @ast:: item ) -> Option < @ast:: item > {
88+ if !no_prelude ( item. attrs ) {
89+ // only recur if there wasn't `#[no_implicit_prelude];`
90+ // on this item, i.e. this means that the prelude is not
91+ // implicitly imported though the whole subtree
92+ fold:: noop_fold_item ( item, self )
93+ } else {
94+ Some ( item)
95+ }
96+ }
97+
98+ fn fold_mod ( & self , module : & ast:: _mod ) -> ast:: _mod {
99+ let prelude_path = ast:: Path {
100+ span : dummy_sp ( ) ,
101+ global : false ,
102+ segments : ~[
103+ ast:: PathSegment {
104+ identifier : self . sess . ident_of ( "std" ) ,
105+ lifetime : None ,
106+ types : opt_vec:: Empty ,
107+ } ,
108+ ast:: PathSegment {
109+ identifier : self . sess . ident_of ( "prelude" ) ,
110+ lifetime : None ,
111+ types : opt_vec:: Empty ,
112+ } ,
113+ ] ,
114+ } ;
115+
116+ let vp = @spanned ( ast:: view_path_glob ( prelude_path,
117+ ast:: DUMMY_NODE_ID ) ) ;
118+ let vi2 = ast:: view_item {
119+ node : ast:: view_item_use ( ~[ vp] ) ,
120+ attrs : ~[ ] ,
121+ vis : ast:: private,
122+ span : dummy_sp ( ) ,
123+ } ;
124+
125+ let vis = vec:: append ( ~[ vi2] , module. view_items ) ;
126+
127+ // FIXME #2543: Bad copy.
128+ let new_module = ast:: _mod {
129+ view_items : vis,
130+ ..( * module) . clone ( )
131+ } ;
132+ fold:: noop_fold_mod ( & new_module, self )
133+ }
134+ }
135+
136+ fn inject_libstd_ref ( sess : Session , crate : & ast:: Crate ) -> @ast:: Crate {
137+ let fold = StandardLibraryInjector {
138+ sess : sess,
139+ } ;
127140 @fold. fold_crate ( crate )
128141}
0 commit comments