Current standard draft, in [dcl.type.auto.deduct], Part 3, reads:

If the placeholder-type-specifier is of the form type-constraint(opt) auto, the deduced type T′ replacing T is determined using the rules for template argument deduction. If the initialization is copy-list-initialization, a declaration of std::initializer_list shall precede ([basic.lookup.general]) the placeholder-type-specifier. Obtain P from T by replacing the occurrences of type-constraint(opt) auto either with a new invented type template parameter U or, if the initialization is copy-list-initialization, with std::initializer_list<U>. Deduce a value for U using the rules of template argument deduction from a function call ([temp.deduct.call]), where P is a function template parameter type and the corresponding argument is E. If the deduction fails, the declaration is ill-formed. Otherwise, T′ is obtained by substituting the deduced U into P.

The only example I can see with "multiple occurrences" of (optionally type-constrained) auto within type T, is with a function where auto is in both decl-specifier and trailing-return-type:

auto foo() -> auto;

or similarly, for a variable or function parameter that have function pointer/reference type, e.g.;

auto (*fp)() -> auto = ...initializer...;

I see two chances here:

1) preliminary Part 2 clarifies that the type T to be considered is, for example, the declared return type of a function, or the declared type of a variable. In former case, it means that a single auto is considered, because [dcl.spec.auto.general] indicates the trailing-return-type replaces the type of the decl-specifier, and this is true even for latter case despite [dcl.spec.auto.general]-p5 does not define an explicit (overall) declared type for the variable.

In this perspective 1), T would anyway contain a single 'auto' and the wording "occurrences" should be fixed, for example from "the occurrences of type-constraint(opt) auto" to "the placeholder-type-specifier" (provided that the begin of p3 states the placeholder is just a single type-constraint(opt) auto").

2) if, for any other reason, T really contains both 'auto', then the wording of replacing U in P with the deduced type is formally wrong, as for example for the function above foo(), if the type parameter U is deduced as int, then the replacement leads to:

int foo() -> int;

which is syntactically not allowed.

Additionally, even with a single auto, in decl-specifier only:

auto (*fp)() -> int = ...initializer...;

Therefore, even with perspective 2), the wording about replacing should change.

Are there other intended examples with 'multiple occurrences' ? I tried to ask on stackoverflow but no one provided any.

As an additional note, [dcl.spec.auto.general]-p4 states that a deduction is done in ase any non-discarded return statement is present, and even [dcl.type.auto.deduct]-p2 focuses on the non-discarded return statements.

Shouldn't we extend [dcl.spec.auto.general]-p4 for deducing void type when no non-discarded return statement is present ?