[dcl.type.auto.deduct]

A type T containing a placeholder type, and a corresponding initializer-clause E, are determined as follows:

(2.1)
For a non-discarded return statement that occurs in a function declared with a return type that contains a placeholder type, T is the declared return type.
- (2.1.1)
  If the return statement has no operand, then E is void().
- (2.1.2)
  If the operand is a braced-init-list ([dcl.init.list]), the program is ill-formed.
- (2.1.3)
  If the operand is an expression X that is not an assignment-expression, E is (X).
  
  [Note 1:
  A comma expression ([expr.comma]) is not an assignment-expression.
  — end note]
- (2.1.4)
  Otherwise, E is the operand of the return statement.
If E has type void, T shall be either type-constraint ${o p t decltype (auto) or cv type-constraint {o p t auto .}_{o p t auto .}}_{o p t decltype (auto) or cv type-constraint {o p t auto .}_{o p t auto .}}$
(2.2)
For a variable declared with a type that contains a placeholder type, T is the declared type of the variable.
- (2.2.1)
  If the initializer of the variable is a brace-or-equal-initializer of the form = initializer-clause, E is the initializer-clause.
- (2.2.2)
  If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression.
- (2.2.3)
  If the initializer is a parenthesized expression-list, the expression-list shall be a single assignment-expression and E is the assignment-expression.
(2.3)
For an explicit type conversion ([expr.type.conv]), T is the specified type, which shall be auto.
- (2.3.1)
  If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression.
- (2.3.2)
  If the initializer is a parenthesized expression-list, the expression-list shall be a single assignment-expression and E is the assignment-expression.
(2.4)
For a constant template parameter declared with a type that contains a placeholder type, T is the declared type of the constant template parameter and E is the corresponding template argument.

T shall not be an array type.

If the placeholder-type-specifier is of the form type-constraint

{o p t auto, the deduced type {T' replacing T is determined using the rules for template argument deduction .}^{' replacing T is determined using the rules for template argument deduction .}}_{o p t auto, the deduced type {T' replacing T is determined using the rules for template argument deduction .}^{' 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 occurrence of type-constraint

{o p t auto either with a new invented type template parameter U or, if the initialization is copy-list-initialization, with std ​::​ initializer_list < U > .}_{o p t auto either with a new invented type template parameter U or, if the initialization is copy-list-initialization, with std ​::​ initializer_list < U > .}

If E is a value synthesized for a constant template parameter of type decltype(auto) ([temp.func.order]), the declaration is ill-formed.

Otherwise, 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 .}^{' is obtained by substituting the deduced U into P .}

[Example 1: auto x1 = { 1, 2 }; / decltype(x1) is std::initializer_list<int> auto x2 = { 1, 2.0 }; / error: cannot deduce element type auto x3{ 1, 2 }; / error: not a single element auto x4 = { 3 }; / decltype(x4) is std::initializer_list<int> auto x5{ 3 }; / decltype(x5) is int — end example]

[Example 2: const auto &i = expr;

The type of i is the deduced type of the parameter u in the call f(expr) of the following invented function template: template <class U> void f(const U& u);

— end example]

If the placeholder-type-specifier is of the form type-constraint

{o p t decltype (auto), T shall be the placeholder alone .}_{o p t decltype (auto), T shall be the placeholder alone .}

The type deduced for T is determined as described in [dcl.type.decltype], as though E had been the operand of the decltype.

[Example 3: int i; int& f(); auto x2a(i); / decltype(x2a) is int decltype(auto) x2d(i); / decltype(x2d) is int auto x3a = i; / decltype(x3a) is int decltype(auto) x3d = i; / decltype(x3d) is int auto x4a = (i); / decltype(x4a) is int decltype(auto) x4d = (i); / decltype(x4d) is int& auto x5a = f(); / decltype(x5a) is int decltype(auto) x5d = f(); / decltype(x5d) is int&& auto x6a = { 1, 2 }; / decltype(x6a) is std::initializer_list<int> decltype(auto) x6d = { 1, 2 }; / error: { 1, 2 } is not an expression auto *x7a = &i; / decltype(x7a) is int* decltype(auto)*x7d = &i; / error: declared type is not plain decltype(auto) auto f1(int x) -> decltype(x)) { return (x); } / return type is int& auto f2(int x) -> decltype(auto) { return (x); } / return type is int&& — end example]

For a placeholder-type-specifier with a type-constraint, the immediately-declared constraint ([temp.param]) of the type-constraint for the type deduced for the placeholder shall be satisfied.