Parameter names in foreign functions, function pointer types and trait methods are not resolved / validated

[petrochenkov]

Arguments in foreign functions, function types and traits are pattern bindings like all other function arguments and supposedly they should be resolved in the same way, however they are not resolved at all.
It doesn't make much difference because these bindings can't be used in function bodies, however it makes some difference, for example foreign functions can reuse constant names for their arguments, while other functions can't (whether it's good or bad is a separate question).

Accidentally, some function arguments being unresolved also affect lints like non_snake_case, such lints don't report warnings for them. This may be reasonable for foreign functions though, because such functions may follow foreign naming conventions. If this lint is "fixed" it may affects crates like winapi (cc @retep998). This is not so reasonable for trait methods however.

Examples:

#![allow(dead_code, unused_variables)]

const SOD: u8 = 0;
const SOB: u8 = 0;
const MOD: u8 = 0;
const MDC: u8 = 0;
const DRI: u8 = 0;

// warning: variable `SOD` should have a snake case name
// error: let variables cannot be named the same as const variables
fn f(SOD: u8) {}

trait Tr {
    // warning: variable `SOB` should have a snake case name
    // error: let variables cannot be named the same as const variables
    fn g(SOB: u8) {}

    // No warnings, no errors
    fn h(MOD: u8);
}

// No warnings, no errors
type A = fn(MDC: u8);

extern "C" {
    // No warnings, no errors
    fn k(DRI: u8);
}

fn main() {
}

[retep998]

I'd appreciate if the lints did fire for foreign functions (winapi sets those lints to allow anyway so it doesn't affect it). However being unable to use identifiers for function parameters when there is a constant with the same name is rather dumb in my opinion, and I'm opposed to extending that to cover foreign functions.

[petrochenkov]

This also means arguments with same names are allowed:

#![allow(dead_code, unused_variables)]

// error: identifier `a` is bound more than once in this parameter list
fn f(a: u8, a: f64) {}

trait Tr {
    // error: identifier `a` is bound more than once in this parameter list
    fn g(a: u8, a: f64) {}

    // No errors
    fn h(a: u8, a: f64);
}

// No errors
type A = fn(a: u8, a: f64);

extern "C" {
    // No errors
    fn k(a: u8, a: f64);
}

fn main() {
}

[retep998]

I'm also okay with that being fixed.

[theemathas]

This also means that #[expect] does not work in trait methods, function pointer types, and extern blocks.

That is, the following code compiles without warnings.

pub trait Trait {
    fn foo(#[expect(while_true)] x: i32);
}

pub fn bar() {
    let _: fn(#[expect(while_true)] y: i32);
}

unsafe extern "C" {
    pub fn baz(#[expect(while_true)] z: i32);
}