Spurious 'non-exhaustive patterns' error

[ebfe]

It looks like #14731 introduced a regression.

The following used to work:

fn main() {
    let mut x = &[1, 2, 3, 4];

    loop {
        x = match x {
            [1, n, 3, ..rest] => {
                println!("1, {}, 3", n); 
                rest
            }
            [n, ..rest] => {
                println!("{}", n);
                rest
            }
            [] =>
                break
        }
    }
}

but now generates the following error:

t.rs:5:13: 16:10 error: non-exhaustive patterns: `[_, _]` not covered
t.rs:5         x = match x {
t.rs:6             [1, n, 3, ..rest] => {
t.rs:7                 println!("1, {}, 3", n); 
t.rs:8                 rest
t.rs:9             }
t.rs:10             [n, ..rest] => {
        ...
error: aborting due to previous error

[ghost]

@ebfe Yeah, sorry about that! There's already a fix for this in #15078.

[ghost]

I am also now seeing spurious 'non-exhaustive patterns' errors when attempting to match struct variants of an imported enum type.

For example, here is a simplification of some code in dtrebbien/valgrind_suppressions_util:

// mkdir -p lib
// rustc --out-dir lib mylib.rs

#![crate_id = "mylib#0.1"]
#![crate_type = "lib"]
#![feature(struct_variant)]

use std::string::{String};

pub enum SuppressionType {
    MemcheckAddr(uint),
    MemcheckLeak,
    OtherType {
        pub tool_name: String,
        pub suppression_type: String,
    },
}

// rustc -o main -L lib main.rs

#![feature(struct_variant)]

extern crate mylib;

use mylib::{SuppressionType, MemcheckAddr, MemcheckLeak, OtherType};
use std::io::stdio::{println};
use std::string::{String};

fn do_stuff(t: &SuppressionType) {
    let s = match t {
            &MemcheckAddr(n) => format!("Memcheck:Addr{:u}", n),
            &MemcheckLeak => format!("Memcheck:Leak"),
            &OtherType {
                tool_name: ref tool_name,
                suppression_type: ref suppression_type,
            } => {
                format!("{}:{}", tool_name.as_slice(), suppression_type.as_slice())
            },
        };
    println(s.as_slice());
}

fn main() {
    let t = MemcheckAddr(14);
    do_stuff(&t);
}

The error is:

main.rs:12:13: 21:10 error: non-exhaustive patterns: `&OtherType(_, _)` not covered
main.rs:12     let s = match t {
main.rs:13             &MemcheckAddr(n) => format!("Memcheck:Addr{:u}", n),
main.rs:14             &MemcheckLeak => format!("Memcheck:Leak"),
main.rs:15             &OtherType {
main.rs:16                 tool_name: ref tool_name,
main.rs:17                 suppression_type: ref suppression_type,
           ...
error: aborting due to previous error

[ghost]

@dtrebbien Oh dear. Looks like it only fails when the enum is defined in a different crate as this works:

#![feature(struct_variant)]

use std::string::{String};
use std::io::stdio::{println};

pub enum SuppressionType {
    MemcheckAddr(uint),
    MemcheckLeak,
    OtherType {
        pub tool_name: String,
        pub suppression_type: String,
    },
}

fn do_stuff(t: &SuppressionType) {
    let s = match t {
            &MemcheckAddr(n) => format!("Memcheck:Addr{:u}", n),
            &MemcheckLeak => format!("Memcheck:Leak"),
            &OtherType {
                tool_name: ref tool_name,
                suppression_type: ref suppression_type,
            } => {
                format!("{}:{}", tool_name.as_slice(), suppression_type.as_slice())
            },
        };
    println(s.as_slice());
}

fn main() {
    let t = MemcheckAddr(14);
    do_stuff(&t);
}

I'll take a look!

[nikomatsakis]

Please add an appropriate test for this case...

Niko

[ghost]

@nikomatsakis I added a test for the cross-crate case in #15086. There are already quite a few existing tests for local variants.

[nikomatsakis]

On Sun, Jun 22, 2014 at 07:43:54AM -0700, Jakub Wieczorek wrote:

@nikomatsakis I added a test for the cross-crate case in #15086. There are already quite a few existing tests for local variants.

great