Describe the interaction of lexical ordering, pack expansion, and if

constexpr.

Fixes #40

Author: zygoloid

abi.html

@@ -4881,7 +4881,8 @@ <h5><a href="#mangling.named">5.1.5.5 Class, union, and enum types</a></h5>
 </pre></font></code>
 
 The number is omitted for the first unnamed type in the class; it is
-n-2 for the nth unnamed type (in lexical order) otherwise.
+n-2 for the nth unnamed type (in <a href="#lexical-ordering">lexical order</a>)
+otherwise.
 <p>
 (The mangling of such unnamed types defined in namespace scope is
 generally unspecified because they do not have to match across
@@ -5358,7 +5359,8 @@ <h4><a href="#mangling-scope">5.1.7 Scope Encoding</a></h4>
 within a function if they are declared in different scopes.  In this
 case, a discriminator must be added to the
 &lt;<a href="#mangle.local-name">local-name</a>&gt;.  Entities with
-the same "top-level" name are numbered in lexical order within
+the same "top-level" name are numbered in
+<a href="#lexical-ordering">lexical order</a> within
 the function definition.  A discriminator is added only for the second
 and later occurrences of the same name, and so the
 &lt;<a href="#mangle.number">number</a>&gt; in the discriminator
@@ -5379,8 +5381,8 @@ <h4><a href="#mangling-scope">5.1.7 Scope Encoding</a></h4>
 </pre></font></code>
 
 where the number is is omitted for the first unnamed type in the
-function, and <i>n</i>-2 for the <i>n</i>th unnamed type (in lexical
-order) otherwise.
+function, and <i>n</i>-2 for the <i>n</i>th unnamed type
+(in <a href="#lexical-ordering">lexical order</a>) otherwise.
 
 <p>
 For example:
@@ -5412,25 +5414,14 @@ <h4><a href="#mangling-scope">5.1.7 Scope Encoding</a></h4>
 is used for string literals.  The discriminator is used only if there
 is more than one, for the second and subsequent ones.  In this case
 again &lt;<a href="#mangle.number">number</a>&gt; is <i>n</i>-2 for
-the <i>n</i>th distinct string literal, in lexical order, appearing in
+the <i>n</i>th distinct string literal, in
+<a href="#lexical-ordering">lexical order</a>, appearing in
 the function.  Multiple references to the same string literal produce
 one string object with one name in the sequence.  <i>Note that this
 assumes that the same string literal occurring twice in a given
 function in fact represents a single entity, i.e. has a unique
 address.</i>
 
-<p>
-In all cases, the numbering order is strictly lexical order based on
-the original token sequence.  All entities occurring in that sequence
-are to be numbered, even if subsequent optimization makes some of them
-unnecessary.  The ordering of literals appearing in a
-mem-initializer-list shall be the order that the literals appear in
-the source, which may be different from the order in which the
-initializers will be executed when the program runs.  It is expected
-that this will be the 'natural' order in most compilers.  In any case,
-conflicts would arise only if different compilation units including
-the same code were compiled by different compilers.
-
 <p>
 For entities in constructors and destructors, the mangling of the
 complete object constructor or destructor is used as the base function
@@ -5503,7 +5494,8 @@ <h4><a href="#closure-types">5.1.8 Closure Types (Lambdas)</a></h4>
 </pre></font></code>
 The number is omitted for the first closure type with a given
 &lt;<a href="#mangle.lambda-sig">lambda-sig</a>&gt; in a given context; it is n-2 for the nth closure
-type (in lexical order) with that same &lt;<a href="#mangle.lambda-sig">lambda-sig</a>&gt; and context.
+type (in <a href="#lexical-ordering">lexical order</a>)
+with that same &lt;<a href="#mangle.lambda-sig">lambda-sig</a>&gt; and context.
 <p>
 
 <p>
@@ -5587,9 +5579,67 @@ <h4><a href="#closure-types">5.1.8 Closure Types (Lambdas)</a></h4>
 href="#mangle.lambda-sig">lambda-sig</a>&gt; can only ever refer to a
 template parameter of a generic lambda.
 
+<p>
+<a name="lexical-ordering">
+<h4><a href="#lexical-ordering">5.1.9 Lexical ordering</a></h4>
+
+<p>
+Lexical ordering is used for numbering local entities
+(unnamed classes and enumerations,
+closure types, and static local variables)
+when there is no other way of distinguishing them.
+Except as described below, all local entities are to be numbered,
+even if subsequent optimization makes some of them unnecessary,
+or no mangled name is actually required for some of them.
+The ordering of entities appearing in a
+mem-initializer-list shall be the order that the entities appear in
+the source, which may be different from the order in which the
+initializers will be executed when the program runs.
+It is expected that this will be the 'natural' order in most compilers.
+
+<p>
+Within a non-template, the numbering
+is in strictly lexical order based on the original token sequence.
+Within a template instantiation, the numbering
+is established after packs are expanded and discarded statements in
+constexpr ifs are removed.
+All entities from one expansion of a pack are considered to occur
+lexically before any entities from the next expansion of the same pack,
+but the ordering is otherwise based on the original token sequence.
+This is expected to match the numbering that would be established for
+the corresponding non-template generated by substitution into the template.
+As a consequence of these rules, the entity instantiated for a particular
+source construct can have a different mangling number in different
+instantiations of the same template.
+For example:
+
+<code><pre>
+void g(...);
+template&lt;bool b, typename ...T> void f() {
+  if constexpr(b) { []{}; }
+  g(([]{}, []{ static T n; return &amp;n; }())...);
+}
+
+// The first lambda is discarded and does not receive a number.
+// The variables passed to g are therefore mangled as
+// _ZZZ1fILb0EJiiEEvvENKUlvE0_clEvE1n and
+// _ZZZ1fILb0EJiiEEvvENKUlvE2_clEvE1n.
+template void f&lt;false, int, int>();
+
+// The variable passed to g is mangled as
+// _ZZZ1fILb1EJiEEvvENKUlvE1_clEvE1n and
+template void f&lt;true, int>();
+
+// Both lambdas are numbered; returns _ZZZ1hvENKUlvE0_clEvE1n.
+inline int *h() {
+  if constexpr(false) { []{}; }
+  return []{ static int n; return &amp;n; }();
+}
+</pre></code>
+
 <p>
 <a name="mangling-compression">
-<h4><a href="#mangling-compression">5.1.9 Compression</a></h4>
+<h4><a href="#mangling-compression">5.1.10 Compression</a></h4>
 
 <p>
 To minimize the length of external names,