Create a group from an Args struct

[epage]

Maintainer's notes

• Expose #[derive(Args)] as an ArgGroup #4210
• feat(derive): Implicitly populate groups from some structs #4303
• feat(derive): Report the group id #4305
• Optional, nested flatten gets ignored (nested ArgGroups are unsupported) #4697
• Implement more derive attributes for ArgGroup #4574

---

Please complete the following tasks

• I have searched the discussions
• I have searched the existing issues

Clap Version

3.0.0-rc.4

Describe your use case

I have a group of fields that I want to make a group for conflicting with other fields

Describe the solution you'd like

Inspired by #2621, what if we implicitly created a group from a struct?

#[derive(Args)]
struct Group {
    arg1: String,
    arg2: String
}

would have an implicitly created ArgGroup::new("Group").multiple(true).

You could then do

#[derive(Args)]
#[group(...group builder methods...)]
struct Group {
    arg1: String,
    arg2: String
}

Alternatives, if applicable

Manually define the args and deal with typos in arg and group names and issues like #2475

Additional Context

The big issue is defining this to not conflict with other app or group attributes. Somewhere I brought up the idea of more explicitly naming our attributes as clap::app,. clap::args, etc (#1553). Maybe that can help?

Per-builder attributes are n
ow in

[epage]

#4210 reserved some functionality in 4.0.0 that we could use for this.

[ModProg]

I was actually stumbling on this trying to design a shard set of options for dynamic completions.

Would we support the use case of conflicting groups? I see two ways of doing it with increasing type safety (both not fully supported yet AFAICT):

Semi-Typesafe

Type system ensures completeness of groups

#[derive(Parser)]
struct CompleteArgs {
    #[clap(flatten)]
    register: Option<Register>,
    #[clap(flatten)]
    complete: Option<Complete>,
}
#[derive(Args)]
#[group(conflicts_with = Complete)]
struct Register {
    #[arg(long)]
    shell: String,
}
#[derive(Args)]
struct Complete {
    #[arg(long)]
    current: String,
}

Fully-Typesafe

Type system ensures group conflict
somewhat related to #2621

#[derive(Parser)]
struct CompleteArgs {
    #[clap(arg_group)]
    register_or_complete: RegisterComplete,
}
#[derive(ArgGroups)]
enum RegisterComplete {
    Register(Register),
    Complete(Complete),
}
#[derive(Args)]
struct Register {
    #[arg(long)]
    shell: String,
}
#[derive(Args)]
struct Complete {
    #[arg(long)]
    current: String,
}

[epage]

My expectation is we'll eventually support the fully type-safe solution as part of #2621

[epage]

I'm going to consider this done with a known bug (#4697)