[dcl.meaning.general]

If the declaration is a friend declaration:

(2.1)
The declarator does not bind a name.
(2.2)
If the id-expression E in the declarator-id of the declarator is a qualified-id or a template-id:
- (2.2.1)
  If the friend declaration is not a template declaration, then in the lookup for the terminal name of E:
  (2.2.1.1)
  if the unqualified-id in E is a template-id, all function declarations are discarded;
  (2.2.1.2)
  otherwise, if the declarator corresponds ([basic.scope.scope]) to any declaration found of a non-template function, all function template declarations are discarded;
  (2.2.1.3)
  each remaining function template is replaced with the specialization chosen by deduction from the friend declaration ([temp.deduct.decl]) or discarded if deduction fails.
- (2.2.2)
  The declarator shall correspond to one or more declarations found by the lookup; they shall all have the same target scope, and the target scope of the declarator is that scope.
(2.3)
Otherwise, the terminal name of E is not looked up.

The declaration's target scope is the innermost enclosing namespace scope; if the declaration is contained by a block scope, the declaration shall correspond to a reachable ([module.reach]) declaration that inhabits the innermost block scope.

Otherwise:

(3.1)
If the id-expression in the declarator-id of the declarator is a qualified-id Q, let S be its lookup context ([basic.lookup.qual]); the declaration shall inhabit a namespace scope.
(3.2)
Otherwise, let S be the entity associated with the scope inhabited by the declarator.
(3.3)
If the declarator declares an explicit instantiation or a partial or explicit specialization, the declarator does not bind a name.

If it declares a class member, the terminal name of the declarator-id is not looked up; otherwise, only those lookup results that are nominable in S are considered when identifying any function template specialization being declared ([temp.deduct.decl]).

[Example 1: namespace N { inline namespace O { template<class T> void f(T); / #1 template<class T> void g(T) {} } namespace P { template<class T> void f(T*); / #2, more specialized than #1 template<class> int g; } using P::f,P::g; } template<> void N::f(int*) {} / OK, #2 is not nominable template void N::g(int); / error: lookup is ambiguous — end example]
(3.4)
Otherwise, the terminal name of the declarator-id is not looked up.

If it is a qualified name, the declarator shall correspond to one or more declarations nominable in S; all the declarations shall have the same target scope and the target scope of the declarator is that scope.

[Example 2: namespace Q { namespace V { void f(); } void V::f() { /* ... */ } / OK void V::g() { /* ... */ } / error: g() is not yet a member of V namespace V { void g(); } } namespace R { void Q::V::g() { /* ... */ } / error: R doesn't enclose Q } — end example]
(3.5)
If the declaration inhabits a block scope S and declares a function ([dcl.fct]) or uses the extern specifier, the declaration shall not be attached to a named module ([module.unit]); its target scope is the innermost enclosing namespace scope, but the name is bound in S.

[Example 3: namespace X { void p() { q(); / error: q not yet declared extern void q(); / q is a member of namespace X extern void r(); / r is a member of namespace X } void middle() { q(); / error: q not found } void q() { /* ... */ } / definition of X::q } void q() { /* ... */ } / some other, unrelated q void X::r() { /* ... */ } / error: r cannot be declared by qualified-id — end example]

A static, thread_local, extern, mutable, friend, inline, virtual, constexpr, consteval, constinit, or typedef specifier or an explicit-specifier applies directly to each declarator-id in a declaration; the type specified for each declarator-id depends on both the decl-specifier-seq and its declarator.

Thus, (for each declarator) a declaration has the form T D where T is of the form attribute-specifier-seq

{o p t decl-specifier-seq and D is a declarator .}_{o p t decl-specifier-seq and D is a declarator .}

Following is a recursive procedure for determining the type specified for the contained declarator-id by such a declaration.

First, the decl-specifier-seq determines a type.

In a declaration T D the decl-specifier-seq T determines the type T.

[Example 4:

In the declaration int unsigned i; the type specifiers int unsigned determine the type “unsigned int” ([dcl.type.simple]).

— end example]

In a declaration attribute-specifier-seq

{o p t T D where D is an unadorned declarator-id, the type of the declared entity is “ T ” .}_{o p t T D where D is an unadorned declarator-id, the type of the declared entity is “ T ” .}

In a declaration T D where D has the form

( D1 )

the type of the contained declarator-id is the same as that of the contained declarator-id in the declaration T D1

Parentheses do not alter the type of the embedded declarator-id, but they can alter the binding of complex declarators.