---

yaml
---
r: 213089
b: refs/heads/auto
c: 7182683
h: refs/heads/master
i:
  213087: 81c106c
v: v3

Author: nrc

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 92d66764121a719d6755a7c33829598d32c9f4ba
+refs/heads/auto: 718268398e312b02775e946af31d77fe35fb5550
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc_trans/save/dump_csv.rs

@@ -873,30 +873,31 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
 
         self.write_sub_paths_truncated(path, false);
 
-        let struct_lit_data = self.save_ctxt.get_expr_data(ex);
-        down_cast_data!(struct_lit_data, TypeRefData, self, ex.span);
-        self.fmt.ref_str(recorder::TypeRef,
-                         ex.span,
-                         Some(struct_lit_data.span),
-                         struct_lit_data.ref_id,
-                         struct_lit_data.scope);
-        let struct_def = struct_lit_data.ref_id;
-
-        for field in fields {
-            if generated_code(field.ident.span) {
-                continue;
-            }
+        if let Some(struct_lit_data) = self.save_ctxt.get_expr_data(ex) {
+            down_cast_data!(struct_lit_data, TypeRefData, self, ex.span);
+            self.fmt.ref_str(recorder::TypeRef,
+                             ex.span,
+                             Some(struct_lit_data.span),
+                             struct_lit_data.ref_id,
+                             struct_lit_data.scope);
+            let struct_def = struct_lit_data.ref_id;
+
+            for field in fields {
+                if generated_code(field.ident.span) {
+                    continue;
+                }
 
-            let field_data = self.save_ctxt.get_field_ref_data(field,
-                                                               struct_def,
-                                                               self.cur_scope);
-            self.fmt.ref_str(recorder::VarRef,
-                             field.ident.span,
-                             Some(field_data.span),
-                             field_data.ref_id,
-                             field_data.scope);
+                let field_data = self.save_ctxt.get_field_ref_data(field,
+                                                                   struct_def,
+                                                                   self.cur_scope);
+                self.fmt.ref_str(recorder::VarRef,
+                                 field.ident.span,
+                                 Some(field_data.span),
+                                 field_data.ref_id,
+                                 field_data.scope);
 
-            self.visit_expr(&field.expr)
+                self.visit_expr(&field.expr)
+            }
         }
 
         visit::walk_expr_opt(self, base)
@@ -1256,13 +1257,14 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
 
                 self.visit_expr(&sub_ex);
 
-                let field_data = self.save_ctxt.get_expr_data(ex);
-                down_cast_data!(field_data, VariableRefData, self, ex.span);
-                self.fmt.ref_str(recorder::VarRef,
-                                 ex.span,
-                                 Some(field_data.span),
-                                 field_data.ref_id,
-                                 field_data.scope);
+                if let Some(field_data) = self.save_ctxt.get_expr_data(ex) {
+                    down_cast_data!(field_data, VariableRefData, self, ex.span);
+                    self.fmt.ref_str(recorder::VarRef,
+                                     ex.span,
+                                     Some(field_data.span),
+                                     field_data.ref_id,
+                                     field_data.scope);
+                }
             },
             ast::ExprTupField(ref sub_ex, idx) => {
                 if generated_code(sub_ex.span) {

branches/auto/src/librustc_trans/save/mod.rs

@@ -329,7 +329,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
         })
     }
 
-    pub fn get_expr_data(&self, expr: &ast::Expr) -> Data {
+    pub fn get_expr_data(&self, expr: &ast::Expr) -> Option<Data> {
         match expr.node {
             ast::ExprField(ref sub_ex, ident) => {
                 let ty = &ty::expr_ty_adjusted(&self.analysis.ty_cx, &sub_ex).sty;
@@ -339,12 +339,12 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
                         for f in &fields {
                             if f.name == ident.node.name {
                                 let sub_span = self.span_utils.span_for_last_ident(expr.span);
-                                return Data::VariableRefData(VariableRefData {
+                                return Some(Data::VariableRefData(VariableRefData {
                                     name: get_ident(ident.node).to_string(),
                                     span: sub_span.unwrap(),
                                     scope: self.analysis.ty_cx.map.get_parent(expr.id),
                                     ref_id: f.id,
-                                });
+                                }));
                             }
                         }
 
@@ -353,24 +353,28 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
                                                     &get_ident(ident.node),
                                                     ty))
                     }
-                    _ => self.sess.span_bug(expr.span,
-                                            &format!("Expected struct type, found {:?}", ty)),
+                    _ => {
+                        debug!("Expected struct type, found {:?}", ty);
+                        None
+                    }
                 }
             }
             ast::ExprStruct(ref path, _, _) => {
                 let ty = &ty::expr_ty_adjusted(&self.analysis.ty_cx, expr).sty;
                 match *ty {
-                    ty::ty_struct(def_id, _) => {
+                    ty::TyStruct(def_id, _) => {
                         let sub_span = self.span_utils.span_for_last_ident(path.span);
-                        Data::TypeRefData(TypeRefData {
+                        Some(Data::TypeRefData(TypeRefData {
                             span: sub_span.unwrap(),
                             scope: self.analysis.ty_cx.map.get_parent(expr.id),
                             ref_id: def_id,
-                        })
+                        }))
                     }
                     _ => {
-                        self.sess.span_bug(expr.span,
-                                           &format!("expected ty_struct, found {:?}", ty));
+                        // FIXME ty could legitimately be a TyEnum, but then we will fail
+                        // later if we try to look up the fields.
+                        debug!("expected TyStruct, found {:?}", ty);
+                        None
                     }
                 }
             }