"atomic specifier" is a bad suggestion, because of the confusion with C's atomic type specifier.

Obviously, defining-type-specifier appears more than once that are not only long.

But they are different specifiers, which is fine, isn't it? It says "each" decl-specifier and that's true. Each of them appears at most once, except long. I don't see the issue.

In the grammar tree of decl-specifier [dcl.spec.general] p1, it lists all components that are decl-specifiers, "each decl-specifier" sounds like it says each component in that tree.

As you said, from the perspective of specifiers, they are different specifiers, but from the perspective of decl-specifiers, they are all defining-type-specifiers and appear more than once.

Analogy, when we say each pm-expression shall appear at most once in ...xxx . What does it mean? Should we consider any direct sub-element categories to pm-expression as a unit or something others? In other words, Does it mean cast-expression shall appear at most once or unary-expression or postfix-expression or each indivisible expression(minimum unit)?

Specifically, given the definition for X as the following

X:

• eggs
• sticks
• balloons
• flowers

We say each X shall appear at most once in my box. Now, there are two different kinds of eggs(e.g., ostrich egg, duck egg) in this box, we cannot say eggs only appear once in my box merely due to the two eggs have different kinds.

So, the issue is whether we need to decompose decl-specifier into its parts, and how far that decomposition goes (e.g. are tokens inside decltype also in view?).

The expression in decltype must be a valid expression, IMO, I think we are not necessary to concern the content contained in decltype at the perspective of [dcl.spec.general] p2, the content of decltype shall obey both the grammar and semantic of an expression. However, decltype-specifier shall only appear once on the top-level of the complete decl-specifier-seq.

I don't figure out a fine way to phrase them except that the wording indivisible decl-specifier, that means the most degree of decomposing the decl-specifier defined in the grammar tree.

That's all fine, but decltype(static_cast<void (*)(int,int)>(nullptr)) does contain (deep inside) the decl-specifiers "void" and "int" (twice). The phrasing needs to be such that those are not considered for the general decl-specifier prohibition.

void (*)(int,int) is a type-id where void is in the type-specifier-seq, which has a more restrictive requirement.
[dcl.type.general] p2

As a general rule, ..., at most one type-specifier is allowed in a type-specifier-seq. The only exceptions to this rule are the following:

the two "int", in my mind, belong to the different complete decl-specifier-seqs of two parameter-declarations. So, it's fine here. And [dcl.dcl.dcl.pre] p2 also has an extra expound.

Certain declarations contain one or more scopes ([basic.scope.scope]). Unless otherwise stated, utterances in [dcl.dcl] about components in, of, or contained by a declaration or subcomponent thereof refer only to those components of the declaration that are not nested within scopes nested within the declaration.

Even though the parameters have abstract-declarators, but they still obey the above rules due to [dcl.dcl#dcl.decl.general-2]

In all contexts, a declarator is interpreted as given below. Where an abstract-declarator can be used (or omitted) in place of a declarator ([dcl.fct], [except.pre]), it is as if a unique identifier were included in the appropriate place ([dcl.name]).

If this is worth addressing at all, how about:

Each distinct decl-specifier shall appear at most once in a complete decl-specifier-seq, except that long may appear twice.

It seems clear to me that int and unsigned are distinct decl-specifiers even though they both use the same immediate production of decl-specifier. (But I also think the wording as-is is clear; if we wanted the other meaning we'd need to say something like "each form of decl-specifier shall appear at most once".)

Actually, this issue claims that what is the degree of classification when we say "each decl-specifier". Does it refer to these components that are directly subsumed to decl-specifier? "distinct decl-specifier" may also have the same problem. "storage-class-specifier" is distinguishable with "defining-type-specifier" but "defining-type-specifier" is not distinguishable with itself when in this perspective.

The "adjective" that can exactly express that we shouldn't consider "each decl-specifier" just on the top-level of the grammar tree is significant.

It is understood that the specification here does not have utmost precision.

• The decl-specifiers of the decl-specifier-seq need to be decomposed several levels before we can apply the "at most once" check.
• "shall appear at most once in" has the usual concerns of giving a lexical ("appear") meaning.

While I think the situation is sufficiently clear for type-specifiers and other single-keyword specifiers appearing there, it is less clear for something like:

struct S {
  explicit(false) explicit(true) S(int);
};

Obviously, explicit(false) and explicit(true) are different decl-specifiers, but we seem to be lacking words to make this declaration ill-formed.