Patterns in extern fns either ICE or aren't type-checked

[huonw]

The following compiles fine, but uncommenting any of the currently-commented extern functions makes the compiler ICE.

struct Foo { x: int }
extern {
    // fn foo(1: ());
    // fn bar((): int);
    // fn baz(Foo { x }: int);
    fn qux((x,y): ());
}
fn main() {}

For foo the ICE message is

error: internal compiler error: node_id_to_type: no type for node `expr 1 (id=12)`

and the others are similar.

[alexcrichton]

I'm inclined to say that the correct behavior is to deny all patterns other than ident (give a parser error perhaps).

[alexcrichton]

Nominating.

[nikomatsakis]

@alexcrichton I agree

[pnkfelix]

Accepted for 1.0, P-backcompat-lang.

[brson]

Good newbie bug.

[mankyKitty]

Being a good newbie, I'll have a crack at this one. :)

[mankyKitty]

Might have aimed a little too high by trying this issue.. but from what i understand, the type checking is working as people would like, but the message is incorrect and should be a actual syntax error and not an ICE... so the below is some thing like how it should work?

struct Foo { x: int }

extern {
    // This one should fail because you've supplied a literal as a fn arg with
    // no type
    fn foo(1: ());
    // This one should fail because you've specified '()' as a variable name for
    // the fn args
    fn bar((): int);
    // This one should pass because you've declared a deconstructed variable name
    // for the input parm 'x' and you've declared a type. This still should trigger
    // the warning for not using a 'libc::c_int'.
    fn baz(Foo {x}: int);
    // This should pass because you've specified input parameters and rust will 
    // infer the type?
    fn qux((x,y): ());
}

Sorry if I've completely misunderstood, still pretty nubbins with Rust. :\

[pnkfelix]

@mankyKitty my reading of acrichto's comment is that all of your examples should fail; ideally only an identfier should pass.

[huonw]

They should all fail, the only thing that should pass is fn foo(some_ident: int);, nothing involving destructuring or pattern matching.

One way to implement this would be to make it an actual syntax error. You can find a starting place for this change by grepping for ForeignItemFn in src/libsyntax/parse/parser.rs. (I personally would recommend implementing this by threading a require_ident_patterns_only argument through parse_fn_decl, parse_fn_args to parse_arg_general where you chose between the existing parse_pat call and calling parse_pat_ident directly based on that boolean.)

// This should pass because you've specified input parameters and rust will 
// infer the type?
fn qux((x,y): ());

No inference; this is always incorrect because you're trying to match a 2-tuple pattern (i.e. type (T, U)) in a slot of type () (i.e. nil, void, 0-tuple).

[mankyKitty]

@pnkfelix @huonw

Ahhh okay, that makes more sense. Thanks for that. I'll see what I can make happen.