According to this setup, where nested or-patterns are unstable, then match 0 { 0 | 1 => 0 } is also unstable but it isn't.

We don't have a proper stability setup, but I can undo this change.

Maybe just leave a comment instead. You might want to double check if/while let also.

Also, we annoyingly don't allow fn foo(Ok(x) | Err(x): _); but require parens around the pattern instead.

The syntax itself is stable so you can remove this.

The self param is only allowed in the first parameter syntactically (Also, consider lifting this out to its own rule.)

... is allowed in any position now syntactically with semantic restrictions in validation to enforce the order (I fixed your FIXME.)

It's more like this:

FnParamKind =
   | SelfParam: FnSelfParam
   | Regular:{ { pat:Pat ":" }? ty:FnParamType }
   ;

FnParamType =
   | CVariadic: "..."
   | Regular: Type
   ;

Alternatively you can just explain this as a binary operator rather than a list.

Fair, it's just weird to think of it as a binary operator because it's fully commutative and associative.

This isn't right; the actual grammar is defined by:

    fn parse_ty_bare_fn(&mut self, generic_params: Vec<GenericParam>) -> PResult<'a, TyKind> {
        let unsafety = self.parse_unsafety();
        let ext = self.parse_extern()?;
        self.expect_keyword(kw::Fn)?;
        let decl = self.parse_fn_decl(|_| false, AllowPlus::No)?;
        Ok(TyKind::BareFn(P(BareFnTy { ext, unsafety, generic_params, decl })))
    }

Aside from that false, which adjusts the precedence (bias towards named vs. not), its just the regular FnDecl grammar, and since we don't deal with precedence here, you can use FnDecl instead.

Well, I'd rather move the full grammar here than have a separate FnDecl, but that makes sense.
So fn(self) parses, I didn't know that.

Yeah I've made some changes recently in the large scale parser refactorings to simplify things.

You might want to review the new tests and PR descriptions in:

• parse: unify item parsing & filter illegal item kinds rust#69366
• parse: allow type Foo: Ord syntactically rust#69361
• parse: fuse associated and extern items up to defaultness rust#69194
• parse: unify function front matter parsing rust#69023
• parse: towards unified fn grammar rust#68788
• parser: syntactically allow self in all fn contexts rust#68764
• parse: merge fn syntax + cleanup item parsing rust#68728
• Merge TraitItem & ImplItem into AssocItem` rust#67131