]> git.lizzy.rs Git - rust.git/commitdiff
Improve non-exhaustive pattern witnesses for structs with multiple fields
authorJakub Wieczorek <jakub@jakub.cc>
Mon, 7 Jul 2014 18:54:50 +0000 (20:54 +0200)
committerJakub Wieczorek <jakub@jakub.cc>
Mon, 7 Jul 2014 20:00:34 +0000 (22:00 +0200)
src/librustc/middle/check_match.rs
src/libsyntax/print/pprust.rs
src/test/compile-fail/non-exhaustive-pattern-witness.rs
src/test/run-make/graphviz-flowgraph/f06.dot-expected.dot

index db5268220fa99f4d907056e6abae51e23177ae61..0395a7c9df46ac37db06ef61956e5a44342d2b12 100644 (file)
@@ -283,13 +283,15 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
             };
             if is_structure {
                 let fields = ty::lookup_struct_fields(cx.tcx, vid);
-                let field_pats = fields.move_iter()
+                let field_pats: Vec<FieldPat> = fields.move_iter()
                     .zip(pats.iter())
+                    .filter(|&(_, pat)| pat.node != PatWild)
                     .map(|(field, pat)| FieldPat {
                         ident: Ident::new(field.name),
                         pat: pat.clone()
                     }).collect();
-                PatStruct(def_to_path(cx.tcx, vid), field_pats, false)
+                let has_more_fields = field_pats.len() < pats.len();
+                PatStruct(def_to_path(cx.tcx, vid), field_pats, has_more_fields)
             } else {
                 PatEnum(def_to_path(cx.tcx, vid), Some(pats))
             }
index 4660bb337ab23e1d46c4d8ad2fb608a214d5804c..bf2101108293960cb25ea4c74b997f21ca33a4d9 100644 (file)
@@ -1745,13 +1745,14 @@ pub fn print_pat(&mut self, pat: &ast::Pat) -> IoResult<()> {
             }
             ast::PatStruct(ref path, ref fields, etc) => {
                 try!(self.print_path(path, true));
-                try!(word(&mut self.s, "{"));
+                try!(self.nbsp());
+                try!(self.word_space("{"));
                 try!(self.commasep_cmnt(
                     Consistent, fields.as_slice(),
                     |s, f| {
                         try!(s.cbox(indent_unit));
                         try!(s.print_ident(f.ident));
-                        try!(s.word_space(":"));
+                        try!(s.word_nbsp(":"));
                         try!(s.print_pat(&*f.pat));
                         s.end()
                     },
@@ -1760,6 +1761,7 @@ pub fn print_pat(&mut self, pat: &ast::Pat) -> IoResult<()> {
                     if fields.len() != 0u { try!(self.word_space(",")); }
                     try!(word(&mut self.s, ".."));
                 }
+                try!(space(&mut self.s));
                 try!(word(&mut self.s, "}"));
             }
             ast::PatTup(ref elts) => {
index 7fba306d868607103ed3dd124cca1fd481908d1d..6dc5ad8b606c37e7055f17596f5db1b43def01f0 100644 (file)
@@ -23,7 +23,7 @@ enum Color {
 
 fn struct_with_a_nested_enum_and_vector() {
     match (Foo { first: true, second: None }) {
-    //~^ ERROR non-exhaustive patterns: `Foo{first: false, second: Some([_, _, _, _])}` not covered
+//~^ ERROR non-exhaustive patterns: `Foo { first: false, second: Some([_, _, _, _]) }` not covered
         Foo { first: true, second: None } => (),
         Foo { first: true, second: Some(_) } => (),
         Foo { first: false, second: None } => (),
@@ -40,7 +40,7 @@ fn enum_with_multiple_missing_variants() {
 
 fn enum_struct_variant() {
     match Red {
-    //~^ ERROR non-exhaustive patterns: `CustomRGBA{a: true, r: _, g: _, b: _}` not covered
+    //~^ ERROR non-exhaustive patterns: `CustomRGBA { a: true, .. }` not covered
         Red => (),
         Green => (),
         CustomRGBA { a: false, r: _, g: _, b: 0 } => (),
index 61b40d68dd1b56431ce2fbd2a9170cbf9dd35d7a..b431476f84a6636a9e3c7613d8546384df033ae8 100644 (file)
@@ -4,8 +4,8 @@ digraph block {
     N2[label="expr 6"];
     N3[label="expr S6{val: 6,}"];
     N4[label="local _x"];
-    N5[label="pat S6{val: _x}"];
-    N6[label="block { let S6{val: _x} = S6{val: 6,}; }"];
+    N5[label="pat S6 { val: _x }"];
+    N6[label="block { let S6 { val: _x } = S6{val: 6,}; }"];
     N0 -> N2;
     N2 -> N3;
     N3 -> N4;