save-analysis: return an Option from get_path_data

Author: Nick Cameron

src/librustc_trans/save/dump_csv.rs

@@ -671,6 +671,15 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
         }
 
         let path_data = self.save_ctxt.get_path_data(id, path);
+        let path_data = match path_data {
+            Some(pd) => pd,
+            None => {
+                self.tcx.sess.span_bug(path.span,
+                                       &format!("Unexpected def kind while looking \
+                                                 up path in `{}`",
+                                                self.span.snippet(path.span)))
+            }
+        };
         match path_data {
             Data::VariableRefData(ref vrd) => {
                 self.fmt.ref_str(ref_kind.unwrap_or(recorder::VarRef),

src/librustc_trans/save/mod.rs

@@ -508,7 +508,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
                 }))
             }
             ast::ExprPath(_, ref path) => {
-                Some(self.get_path_data(expr.id, path))
+                self.get_path_data(expr.id, path)
             }
             _ => {
                 // FIXME
@@ -520,7 +520,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
     pub fn get_path_data(&self,
                          id: NodeId,
                          path: &ast::Path)
-                         -> Data {
+                         -> Option<Data> {
         let def_map = self.tcx.def_map.borrow();
         if !def_map.contains_key(&id) {
             self.tcx.sess.span_bug(path.span,
@@ -535,22 +535,22 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
             def::DefConst(..) |
             def::DefAssociatedConst(..) |
             def::DefVariant(..) => {
-                Data::VariableRefData(VariableRefData {
+                Some(Data::VariableRefData(VariableRefData {
                     name: self.span_utils.snippet(sub_span.unwrap()),
                     span: sub_span.unwrap(),
                     scope: self.enclosing_scope(id),
                     ref_id: def.def_id(),
-                })
+                }))
             }
             def::DefStruct(def_id) |
             def::DefTy(def_id, _) |
             def::DefTrait(def_id) |
             def::DefTyParam(_, _, def_id, _) => {
-                Data::TypeRefData(TypeRefData {
+                Some(Data::TypeRefData(TypeRefData {
                     span: sub_span.unwrap(),
                     ref_id: def_id,
                     scope: self.enclosing_scope(id),
-                })
+                }))
             }
             def::DefMethod(decl_id, provenence) => {
                 let sub_span = self.span_utils.sub_span_for_meth_name(path.span);
@@ -581,32 +581,28 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
                 } else {
                     None
                 };
-                Data::MethodCallData(MethodCallData {
+                Some(Data::MethodCallData(MethodCallData {
                     span: sub_span.unwrap(),
                     scope: self.enclosing_scope(id),
                     ref_id: def_id,
                     decl_id: Some(decl_id),
-                })
+                }))
             },
             def::DefFn(def_id, _) => {
-                Data::FunctionCallData(FunctionCallData {
+                Some(Data::FunctionCallData(FunctionCallData {
                     ref_id: def_id,
                     span: sub_span.unwrap(),
                     scope: self.enclosing_scope(id),
-                })
+                }))
             }
             def::DefMod(def_id) => {
-                Data::ModRefData(ModRefData {
+                Some(Data::ModRefData(ModRefData {
                     ref_id: def_id,
                     span: sub_span.unwrap(),
                     scope: self.enclosing_scope(id),
-                })
+                }))
             }
-            _ => self.tcx.sess.span_bug(path.span,
-                                        &format!("Unexpected def kind while looking \
-                                                  up path in `{}`: `{:?}`",
-                                                 self.span_utils.snippet(path.span),
-                                                 def)),
+            _ => None,
         }
     }