@@ -1485,26 +1485,21 @@ impl<'a> Resolver<'a> {
1485
1485
1486
1486
ViewItemExternCrate ( name, _, node_id) => {
1487
1487
// n.b. we don't need to look at the path option here, because cstore already did
1488
- match self . session . cstore . find_extern_mod_stmt_cnum ( node_id) {
1489
- Some ( crate_id) => {
1490
- let def_id = DefId { krate : crate_id, node : 0 } ;
1491
- self . external_exports . insert ( def_id) ;
1492
- let parent_link = ModuleParentLink
1493
- ( parent. module ( ) . downgrade ( ) , name) ;
1494
- let external_module = Rc :: new ( Module :: new ( parent_link,
1495
- Some ( def_id) ,
1496
- NormalModuleKind ,
1497
- false ,
1498
- true ) ) ;
1499
-
1500
- parent. module ( ) . external_module_children
1501
- . borrow_mut ( ) . insert ( name. name ,
1502
- external_module. clone ( ) ) ;
1503
-
1504
- self . build_reduced_graph_for_external_crate (
1505
- external_module) ;
1506
- }
1507
- None => { } // Ignore.
1488
+ for & crate_id in self . session . cstore . find_extern_mod_stmt_cnum ( node_id) . iter ( ) {
1489
+ let def_id = DefId { krate : crate_id, node : 0 } ;
1490
+ self . external_exports . insert ( def_id) ;
1491
+ let parent_link = ModuleParentLink ( parent. module ( ) . downgrade ( ) , name) ;
1492
+ let external_module = Rc :: new ( Module :: new ( parent_link,
1493
+ Some ( def_id) ,
1494
+ NormalModuleKind ,
1495
+ false ,
1496
+ true ) ) ;
1497
+ debug ! ( "(build reduced graph for item) found extern `{}`" ,
1498
+ self . module_to_str( & * external_module) ) ;
1499
+ parent. module ( ) . external_module_children . borrow_mut ( )
1500
+ . insert ( name. name ,
1501
+ external_module. clone ( ) ) ;
1502
+ self . build_reduced_graph_for_external_crate ( external_module) ;
1508
1503
}
1509
1504
}
1510
1505
}
@@ -1997,7 +1992,9 @@ impl<'a> Resolver<'a> {
1997
1992
fn resolve_imports_for_module_subtree ( & mut self , module_ : Rc < Module > ) {
1998
1993
debug ! ( "(resolving imports for module subtree) resolving {}" ,
1999
1994
self . module_to_str( & * module_) ) ;
1995
+ let orig_module = replace ( & mut self . current_module , module_. clone ( ) ) ;
2000
1996
self . resolve_imports_for_module ( module_. clone ( ) ) ;
1997
+ self . current_module = orig_module;
2001
1998
2002
1999
self . populate_module_if_necessary ( & module_) ;
2003
2000
for ( _, child_node) in module_. children . borrow ( ) . iter ( ) {
@@ -2611,6 +2608,22 @@ impl<'a> Resolver<'a> {
2611
2608
name_search_type : NameSearchType ,
2612
2609
lp : LastPrivate )
2613
2610
-> ResolveResult < ( Rc < Module > , LastPrivate ) > {
2611
+ fn search_parent_externals ( needle : Name , module : & Rc < Module > )
2612
+ -> Option < Rc < Module > > {
2613
+ module. external_module_children . borrow ( )
2614
+ . find_copy ( & needle)
2615
+ . map ( |_| module. clone ( ) )
2616
+ . or_else ( || {
2617
+ match module. parent_link . clone ( ) {
2618
+ ModuleParentLink ( parent, _) => {
2619
+ search_parent_externals ( needle,
2620
+ & parent. upgrade ( ) . unwrap ( ) )
2621
+ }
2622
+ _ => None
2623
+ }
2624
+ } )
2625
+ }
2626
+
2614
2627
let mut search_module = module_;
2615
2628
let mut index = index;
2616
2629
let module_path_len = module_path. len ( ) ;
@@ -2635,11 +2648,28 @@ impl<'a> Resolver<'a> {
2635
2648
hi : span. lo + Pos :: from_uint ( segment_name. get ( ) . len ( ) ) ,
2636
2649
expn_info : span. expn_info ,
2637
2650
} ;
2638
- self . resolve_error ( span,
2639
- format ! ( "unresolved import. maybe \
2640
- a missing `extern crate \
2641
- {}`?",
2642
- segment_name) . as_slice ( ) ) ;
2651
+
2652
+ match search_parent_externals ( name. name , & self . current_module ) {
2653
+ Some ( module) => {
2654
+ let path_str = self . idents_to_str ( module_path) ;
2655
+ let target_mod_str = self . module_to_str ( & * module) ;
2656
+ let current_mod_str = self . module_to_str ( & * self . current_module ) ;
2657
+
2658
+ let prefix = if target_mod_str == current_mod_str {
2659
+ "self::" . to_string ( )
2660
+ } else {
2661
+ format ! ( "{}::" , target_mod_str)
2662
+ } ;
2663
+
2664
+ self . resolve_error ( span, format ! ( "unresolved import. Did you mean \
2665
+ `{}{}`?",
2666
+ prefix, path_str) . as_slice ( ) ) ;
2667
+ } ,
2668
+ None => self . resolve_error ( span, format ! ( "unresolved import. Maybe a \
2669
+ missing `extern crate {}`?",
2670
+ segment_name) . as_slice ( ) ) ,
2671
+ }
2672
+
2643
2673
return Failed ;
2644
2674
}
2645
2675
self . resolve_error ( span,
@@ -5480,7 +5510,7 @@ impl<'a> Resolver<'a> {
5480
5510
//
5481
5511
5482
5512
/// A somewhat inefficient routine to obtain the name of a module.
5483
- fn module_to_str ( & mut self , module : & Module ) -> String {
5513
+ fn module_to_str ( & self , module : & Module ) -> String {
5484
5514
let mut idents = Vec :: new ( ) ;
5485
5515
5486
5516
fn collect_mod ( idents : & mut Vec < ast:: Ident > , module : & Module ) {
0 commit comments