[temp.res] - C++14 → C++17

Files changed (1) hide show

tmp/tmpa9t2iebf/{from.md → to.md} +331 -135

tmp/tmpa9t2iebf/{from.md → to.md} RENAMED Viewed

@@ -10,10 +10,12 @@ Three kinds of names can be used within a template definition:
 A name used in a template declaration or definition and that is
 dependent on a *template-parameter* is assumed not to name a type unless
 the applicable name lookup finds a type name or the name is qualified by
 the keyword `typename`.
 ``` cpp
 // no B declared here
 class X;
@@ -27,36 +29,39 @@ template<class T> class Y {
     Z* a4;                      // declare pointer to Z
     typedef typename T::A TA;
     TA* a5;                     // declare pointer to T's A
     typename T::A* a6;          // declare pointer to T's A
     T::A* a7;                   // T::A is not a type name:
-                                // multiply T::A by a7; ill-formed,
-                                // no visible declaration of a7
     B* a8;                      // B is not a type name:
-                                // multiply B by a8; ill-formed,
-                                // no visible declarations of B and a8
   }
 };
 ```
-When a is intended to refer to a type that is not a member of the
-current instantiation ([[temp.dep.type]]) and its refers to a dependent
-type, it shall be prefixed by the keyword `typename`, forming a . If the
-*qualified-id* in a *typename-specifier* does not denote a type, the
-program is ill-formed.
 ``` bnf
 typename-specifier:
   'typename' nested-name-specifier identifier
   'typename' nested-name-specifier 'template'ₒₚₜ simple-template-id
 ```
 If a specialization of a template is instantiated for a set of
 *template-argument*s such that the *qualified-id* prefixed by `typename`
-does not denote a type, the specialization is ill-formed. The usual
-qualified name lookup ([[basic.lookup.qual]]) is used to find the
-*qualified-id* even in the presence of `typename`.
 ``` cpp
 struct A {
   struct X { };
   int X;
@@ -73,25 +78,31 @@ void foo() {
   f(b);             // OK: T::X refers to B::X
   f(a);             // error: T::X refers to the data member A::X not the struct A::X
 }
 ```
-A qualified name used as the name in a *mem-initializer-id*, a
-*base-specifier*, or an *elaborated-type-specifier* is implicitly
 assumed to name a type, without the use of the `typename` keyword. In a
 *nested-name-specifier* that immediately contains a
 *nested-name-specifier* that depends on a template parameter, the
 *identifier* or *simple-template-id* is implicitly assumed to name a
-type, without the use of the `typename` keyword. The `typename` keyword
-is not permitted by the syntax of these constructs.
 If, for a given set of template arguments, a specialization of a
 template is instantiated that refers to a *qualified-id* that denotes a
-type, and the *qualified-id* refers to a member of an unknown
-specialization, the *qualified-id* shall either be prefixed by
-`typename` or shall be used in a context in which it implicitly names a
-type as described above.
 ``` cpp
 template <class T> void f(int i) {
   T::x * i;         // T::x must not be a type
 }
@@ -108,73 +119,121 @@ int main() {
   f<Bar>(1);        // OK
   f<Foo>(1);        // error: Foo::x is a type
 }
 ```
 Within the definition of a class template or within the definition of a
 member of a class template following the *declarator-id*, the keyword
 `typename` is not required when referring to the name of a previously
-declared member of the class template that declares a type. such names
-can be found using unqualified name lookup ([[basic.lookup.unqual]]),
-class member lookup ([[class.qual]]) into the current instantiation (
-[[temp.dep.type]]), or class member access expression lookup (
-[[basic.lookup.classref]]) when the type of the object expression is the
-current instantiation ([[temp.dep.expr]]).
 ``` cpp
 template<class T> struct A {
   typedef int B;
   B b;              // OK, no typename required
 };
 ```
 Knowing which names are type names allows the syntax of every template
-to be checked. No diagnostic shall be issued for a template for which a
-valid specialization can be generated. If no valid specialization can be
-generated for a template, and that template is not instantiated, the
-template is ill-formed, no diagnostic required. If every valid
-specialization of a variadic template requires an empty template
-parameter pack, the template is ill-formed, no diagnostic required. If a
-type used in a non-dependent name is incomplete at the point at which a
-template is defined but is complete at the point at which an
-instantiation is done, and if the completeness of that type affects
-whether or not the program is well-formed or affects the semantics of
-the program, the program is ill-formed; no diagnostic is required. If a
-template is instantiated, errors will be diagnosed according to the
-other rules in this Standard. Exactly when these errors are diagnosed is
-a quality of implementation issue.
 ``` cpp
 int j;
 template<class T> class X {
   void f(T t, int i, char* p) {
-    t = i;          // diagnosed if X::f is instantiated
- // and the assignment to t is an error
-    p = i;          // may be diagnosed even if X::f is
-                    // not instantiated
-    p = j;          // may be diagnosed even if X::f is
-                    // not instantiated
   }
   void g(T t) {
-    +;              // may be diagnosed even if X::g is
-                    // not instantiated
   }
 };
 template<class... T> struct A {
   void operator++(int, T... t);                     // error: too many parameters
 };
 template<class... T> union X : T... { };            // error: union with base class
 template<class... T> struct A : T...,  T... { };    // error: duplicate base class
 ```
 When looking for the declaration of a name used in a template
 definition, the usual lookup rules ([[basic.lookup.unqual]],
 [[basic.lookup.argdep]]) are used for non-dependent names. The lookup of
 names dependent on the template parameters is postponed until the actual
 template argument is known ([[temp.dep]]).
 ``` cpp
 #include <iostream>
 using namespace std;
 template<class T> class Set {
@@ -198,43 +257,47 @@ the actual *template-argument*s are known. For example, even though the
 name `operator<<` is known within the definition of `printall()` and a
 declaration of it can be found in `<iostream>`, the actual declaration
 of `operator<<` needed to print `p[i]` cannot be known until it is known
 what type `T` is ([[temp.dep]]).
 If a name does not depend on a *template-parameter* (as defined in
 [[temp.dep]]), a declaration (or set of declarations) for that name
 shall be in scope at the point where the name appears in the template
 definition; the name is bound to the declaration (or declarations) found
 at that point and this binding is not affected by declarations that are
 visible at the point of instantiation.
 ``` cpp
 void f(char);
 template<class T> void g(T t) {
   f(1);             // f(char)
   f(T(1));          // dependent
   f(t);             // dependent
-  dd++;             // not dependent
-                    // error: declaration for dd not found
 }
 enum E { e };
 void f(E);
 double dd;
 void h() {
-  g(e);             // will cause one call of f(char) followed
-                    // by two calls of f(E)
   g('a');           // will cause three calls of f(char)
 }
 ```
-For purposes of name lookup, default arguments and
-*exception-specification*s of function templates and default arguments
-and *exception-specification*s of member functions of class templates
-are considered definitions ([[temp.decls]]).
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
 injected-class-name (Clause  [[class]]). The injected-class-name can be
@@ -250,10 +313,12 @@ Within the scope of a class template specialization or partial
 specialization, when the injected-class-name is used as a *type-name*,
 it is equivalent to the *template-name* followed by the
 *template-argument*s of the class template specialization or partial
 specialization enclosed in `<>`.
 ``` cpp
 template<template<class> class T> class A { };
 template<class T> class Y;
 template<> class Y<int> {
   Y* p;                               // meaning Y<int>
@@ -263,14 +328,18 @@ template<> class Y<int> {
     template<class> friend class Y;   // meaning ::Y
   };
 };
 ```
 The injected-class-name of a class template or class template
 specialization can be used either as a *template-name* or a *type-name*
 wherever it is in scope.
 ``` cpp
 template <class T> struct Base {
   Base* p;
 };
@@ -280,43 +349,55 @@ template <class T> struct Derived: public Base<T> {
 template<class T, template<class> class U = T::template Base> struct Third { };
 Third<Base<int> > t;            // OK: default argument uses injected-class-name as a template
 ```
 A lookup that finds an injected-class-name ([[class.member.lookup]])
 can result in an ambiguity in certain cases (for example, if it is found
 in more than one base class). If all of the injected-class-names that
 are found refer to specializations of the same class template, and if
 the name is used as a *template-name*, the reference refers to the class
 template itself and not a specialization thereof, and is not ambiguous.
 ``` cpp
 template <class T> struct Base { };
 template <class T> struct Derived: Base<int>, Base<char> {
   typename Derived::Base b;             // error: ambiguous
   typename Derived::Base<double> d;     // OK
 };
 ```
 When the normal name of the template (i.e., the name from the enclosing
 scope, not the injected-class-name) is used, it always refers to the
 class template itself and not a specialization of the template.
 ``` cpp
 template<class T> class X {
   X* p;             // meaning X<T>
   X<T>* p2;
   X<int>* p3;
   ::X* p4;          // error: missing template argument list
                     // ::X does not refer to the injected-class-name
 };
 ```
 A *template-parameter* shall not be redeclared within its scope
 (including nested scopes). A *template-parameter* shall not have the
 same name as the template name.
 ``` cpp
 template<class T, int i> class Y {
   int T;            // error: template-parameter redeclared
   void f() {
     char T;         // error: template-parameter redeclared
@@ -324,19 +405,23 @@ template<class T, int i> class Y {
 };
 template<class X> class X;      // error: template-parameter redeclared
 ```
 In the definition of a member of a class template that appears outside
 of the class template definition, the name of a member of the class
 template hides the name of a *template-parameter* of any enclosing class
 templates (but not a *template-parameter* of the member if the member is
 a class or function template).
 ``` cpp
 template<class T> struct A {
-  struct B { /* ... */ }
   typedef void C;
   void f();
   template<class U> void g(U);
 };
@@ -348,14 +433,18 @@ template<class B> template<class C> void A<B>::g(C) {
   B b;              // A's B, not the template parameter
   C c;              // the template parameter C, not A's C
 }
 ```
 In the definition of a member of a class template that appears outside
 of the namespace containing the class template definition, the name of a
 *template-parameter* hides the name of a member of this namespace.
 ``` cpp
 namespace N {
   class C { };
   template<class T> class B {
     void f(T);
@@ -364,58 +453,67 @@ namespace N {
 template<class C> void N::B<C>::f(C) {
   C b;              // C is the template parameter, not N::C
 }
 ```
 In the definition of a class template or in the definition of a member
 of such a template that appears outside of the template definition, for
-each base class which does not depend on a *template-parameter* (
-[[temp.dep]]), if the name of the base class or the name of a member of
-the base class is the same as the name of a *template-parameter*, the
-base class name or member name hides the *template-parameter* name (
-[[basic.scope.hiding]]).
 ``` cpp
 struct A {
-  struct B { /* ... */ };
   int a;
   int Y;
 };
 template<class B, class a> struct X : A {
   B b;              // A's B
   a b;              // error: A's a isn't a type name
 };
 ```
 ### Dependent names <a id="temp.dep">[[temp.dep]]</a>
 Inside a template, some constructs have semantics which may differ from
 one instantiation to another. Such a construct *depends* on the template
 parameters. In particular, types and expressions may depend on the type
 and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
-names. Expressions may be *type-dependent* (on the type of a template
-parameter) or *value-dependent* (on the value of a non-type template
-parameter). In an expression of the form:
 where the *postfix-expression* is an *unqualified-id*, the
 *unqualified-id* denotes a *dependent name* if
 - any of the expressions in the *expression-list* is a pack expansion (
   [[temp.variadic]]),
-- any of the expressions in the *expression-list* is a type-dependent
- expression ([[temp.dep.expr]]), or
-- if the *unqualified-id* is a *template-id* in which any of the
- template arguments depends on a template parameter.
 If an operand of an operator is a type-dependent expression, the
 operator also denotes a dependent name. Such names are unbound and are
 looked up at the point of the template instantiation ([[temp.point]])
 in both the context of the template definition and the context of the
 point of instantiation.
 ``` cpp
 template<class T> struct X : B<T> {
   typename T::A* pa;
   void f(B<T>* pb) {
     static int i = B<T>::i;
@@ -425,15 +523,18 @@ template<class T> struct X : B<T> {
 ```
 the base class name `B<T>`, the type name `T::A`, the names `B<T>::i`
 and `pb->j` explicitly depend on the *template-parameter*.
-In the definition of a class or class template, if a base class depends
-on a *template-parameter*, the base class scope is not examined during
-unqualified name lookup either at the point of definition of the class
-template or member or during an instantiation of the class template or
-member.
 ``` cpp
 typedef double A;
 template<class T> class B {
   typedef int A;
@@ -445,21 +546,25 @@ template<class T> struct X : B<T> {
 The type name `A` in the definition of `X<T>` binds to the typedef name
 defined in the global namespace scope, not to the typedef name defined
 in the base class `B<T>`.
 ``` cpp
 struct A {
-  struct B { /* ... */ };
   int a;
   int Y;
 };
 int a;
 template<class T> struct Y : T {
-  struct B { /* ... */ };
   B b;                          // The B defined in Y
   void f(int i) { a = i; }      // ::a
   Y* p;                         // Y<T>
 };
@@ -467,10 +572,12 @@ Y<A> ya;
 ```
 The members `A::B`, `A::a`, and `A::Y` of the template argument `A` do
 not affect the binding of names in `Y<A>`.
 #### Dependent types <a id="temp.dep.type">[[temp.dep.type]]</a>
 A name refers to the *current instantiation* if it is
 - in the definition of a class template, a nested class of a class
@@ -505,21 +612,22 @@ can be used in place of that template parameter in a reference to the
 current instantiation. In the case of a non-type template argument, the
 argument must have been given the value of the template parameter and
 not an expression in which the template parameter appears as a
 subexpression.
 ``` cpp
 template <class T> class A {
   A* p1;                        // A is the current instantiation
   A<T>* p2;                     // A<T> is the current instantiation
   A<T*> p3;                     // A<T*> is not the current instantiation
   ::A<T>* p4;                   // ::A<T> is the current instantiation
   class B {
     B* p1;                      // B is the current instantiation
     A<T>::B* p2;                // A<T>::B is the current instantiation
-    typename A<T*>::B* p3;      // A<T*>::B is not the
-                                // current instantiation
   };
 };
 template <class T> class A<T*> {
   A<T*>* p1;                    // A<T*> is the current instantiation
@@ -537,30 +645,64 @@ template <class T1, class T2, int I> struct B {
   B<my_T1, T2, my_I2>* b4;      // not the current instantiation
   B<my_T1, T2, my_I3>* b5;      // refers to the current instantiation
 };
 ```
 A name is a *member of the current instantiation* if it is
 - An unqualified name that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
-  base class thereof. This can only occur when looking up a name in a
-  scope enclosed by the definition of a class template.
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation and that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
-  base class thereof. if no such member is found, and the current
-  instantiation has any dependent base classes, then the *qualified-id*
-  is a member of an unknown specialization; see below.
 - An *id-expression* denoting the member in a class member access
   expression ([[expr.ref]]) for which the type of the object expression
   is the current instantiation, and the *id-expression*, when looked
   up ([[basic.lookup.classref]]), refers to at least one member of a
   class that is the current instantiation or a non-dependent base class
-  thereof. if no such member is found, and the current instantiation has
-  any dependent base classes, then the *id-expression* is a member of an
-  unknown specialization; see below.
 ``` cpp
 template <class T> class A {
   static const int i = 5;
   int n1[i];                    // i refers to a member of the current instantiation
@@ -572,10 +714,12 @@ template <class T> class A {
 template <class T> int A<T>::f() {
   return i;                     // i refers to a member of the current instantiation
 }
 ```
 A name is a *dependent member of the current instantiation* if it is a
 member of the current instantiation that, when looked up, refers to at
 least one member of a class that is the current instantiation.
 A name is a *member of an unknown specialization* if it is
@@ -606,10 +750,12 @@ access expression for which the type of the object expression is the
 current instantiation does not refer to a member of the current
 instantiation or a member of an unknown specialization, the program is
 ill-formed even if the template containing the member access expression
 is not instantiated; no diagnostic required.
 ``` cpp
 template<class T> class A {
   typedef int type;
   void f() {
     A<T>::type i;               // OK: refers to a member of the current instantiation
@@ -617,42 +763,68 @@ template<class T> class A {
                                 // a member of an unknown specialization
   }
 };
 ```
 If, for a given set of template arguments, a specialization of a
 template is instantiated that refers to a member of the current
 instantiation with a *qualified-id* or class member access expression,
 the name in the *qualified-id* or class member access expression is
 looked up in the template instantiation context. If the result of this
 lookup differs from the result of name lookup in the template definition
-context, name lookup is ambiguous. the result of name lookup differs
-only when the member of the current instantiation was found in a
-non-dependent base class of the current instantiation and a member with
-the same name is also introduced by the substitution for a dependent
-base class of the current instantiation.
 A type is dependent if it is
 - a template parameter,
 - a member of an unknown specialization,
 - a nested class or enumeration that is a dependent member of the
   current instantiation,
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
-- an array type constructed from any dependent type or whose size is
- specified by a constant expression that is value-dependent,
 - a *simple-template-id* in which either the template name is a template
   parameter or any of the template arguments is a dependent type or an
-  expression that is type-dependent or value-dependent, or
 - denoted by `decltype(`*expression*`)`, where *expression* is
   type-dependent ([[temp.dep.expr]]).
-Because typedefs do not introduce new types, but instead simply refer to
-other types, a name that refers to a typedef that is a member of the
-current instantiation is dependent only if the type referred to is
-dependent.
 #### Type-dependent expressions <a id="temp.dep.expr">[[temp.dep.expr]]</a>
 Except as described below, an expression is type-dependent if any
 subexpression is type-dependent.
@@ -664,14 +836,22 @@ dependent ([[temp.dep.type]]).
 An *id-expression* is type-dependent if it contains
 - an *identifier* associated by name lookup with one or more
   declarations declared with a dependent type,
 - an *identifier* associated by name lookup with one or more
   declarations of member functions of the current instantiation declared
-  with a return type that contains a placeholder type (
-  [[dcl.spec.auto]]),
 - a *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
 - a *nested-name-specifier* or a *qualified-id* that names a member of
   an unknown specialization;
@@ -683,34 +863,41 @@ type-dependent only if the type specified by the *type-id*,
 subexpression is type-dependent:
 Expressions of the following forms are never type-dependent (because the
 type of the expression cannot be dependent):
-For the standard library macro `offsetof`, see  [[support.types]].
 A class member access expression ([[expr.ref]]) is type-dependent if
 the expression refers to a member of the current instantiation and the
 type of the referenced member is dependent, or the class member access
-expression refers to a member of an unknown specialization. In an
-expression of the form `x.y` or `xp->y` the type of the expression is
-usually the type of the member `y` of the class of `x` (or the class
-pointed to by `xp`). However, if `x` or `xp` refers to a dependent type
-that is not the current instantiation, the type of `y` is always
-dependent. If `x` or `xp` refers to a non-dependent type or refers to
-the current instantiation, the type of `y` is the type of the class
-member access expression.
 #### Value-dependent expressions <a id="temp.dep.constexpr">[[temp.dep.constexpr]]</a>
-Except as described below, a constant expression is value-dependent if
-any subexpression is value-dependent.
 An *id-expression* is value-dependent if:
-- it is a name declared with a dependent type,
 - it is the name of a non-type template parameter,
-- it names a member of an unknown specialization,
 - it names a static data member that is a dependent member of the
   current instantiation and is not initialized in a *member-declarator*,
 - it names a static member function that is a dependent member of the
   current instantiation, or
 - it is a constant with literal type and is initialized with an
@@ -718,21 +905,26 @@ An *id-expression* is value-dependent if:
 Expressions of the following form are value-dependent if the
 *unary-expression* or *expression* is type-dependent or the *type-id* is
 dependent:
-For the standard library macro `offsetof`, see  [[support.types]].
 Expressions of the following form are value-dependent if either the
 *type-id* or *simple-type-specifier* is dependent or the *expression* or
 *cast-expression* is value-dependent:
 Expressions of the following form are value-dependent:
 An expression of the form `&`*qualified-id* where the *qualified-id*
 names a dependent member of the current instantiation is
-value-dependent.
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 A type *template-argument* is dependent if the type it specifies is
 dependent.
@@ -752,28 +944,30 @@ an unknown specialization.
 ### Non-dependent names <a id="temp.nondep">[[temp.nondep]]</a>
 Non-dependent names used in a template definition are found using the
 usual name lookup and bound at the point they are used.
 ``` cpp
 void g(double);
 void h();
 template<class T> class Z {
 public:
   void f() {
     g(1);           // calls g(double)
-    h++;            // ill-formed: cannot increment function;
-                    // this could be diagnosed either here or
-                    // at the point of instantiation
   }
 };
-void g(int);        // not in scope at the point of the template
-                    // definition, not considered for the call g(1)
 ```
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 In resolving dependent names, names from the following sources are
 considered:
@@ -800,20 +994,19 @@ If a function template or member function of a class template is called
 in a way which uses the definition of a default argument of that
 function template or member function, the point of instantiation of the
 default argument is the point of instantiation of the function template
 or member function specialization.
-For an *exception-specification* of a function template specialization
-or specialization of a member function of a class template, if the
-*exception-specification* is implicitly instantiated because it is
-needed by another template specialization and the context that requires
-it depends on a template parameter, the point of instantiation of the
-*exception-specification* is the point of instantiation of the
-specialization that requires it. Otherwise, the point of instantiation
-for such an *exception-specification* immediately follows the namespace
-scope declaration or definition that requires the
-*exception-specification*.
 For a class template specialization, a class member template
 specialization, or a specialization for a class member of a class
 template, if the specialization is implicitly instantiated because it is
 referenced from within another template specialization, if the context
@@ -846,11 +1039,11 @@ specialization that has a point of instantiation within the translation
 unit, the end of the translation unit is also considered a point of
 instantiation. A specialization for a class template has at most one
 point of instantiation within a translation unit. A specialization for
 any template may have points of instantiation in multiple translation
 units. If two different points of instantiation give a template
-specialization different meanings according to the one definition rule (
 [[basic.def.odr]]), the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
 For a function call where the *postfix-expression* is a dependent name,
@@ -883,20 +1076,23 @@ As with non-template classes, the names of namespace-scope friend
 functions of a class template specialization are not visible during an
 ordinary lookup unless explicitly declared at namespace scope (
 [[class.friend]]). Such names may be found under the rules for
 associated classes ([[basic.lookup.argdep]]).[^6]
 ``` cpp
 template<typename T> struct number {
   number(int);
   friend number gcd(number x, number y) { return 0; };
 };
 void g() {
   number<double> a(3), b(4);
-  a = gcd(a,b);     // finds gcd because number<double> is an
-                    // associated class, making gcd visible
-                    // in its namespace (global scope)
   b = gcd(3,4);     // ill-formed; gcd is not visible
 }
 ```

 A name used in a template declaration or definition and that is
 dependent on a *template-parameter* is assumed not to name a type unless
 the applicable name lookup finds a type name or the name is qualified by
 the keyword `typename`.
+[*Example 1*:
 ``` cpp
 // no B declared here
 class X;
     Z* a4;                      // declare pointer to Z
     typedef typename T::A TA;
     TA* a5;                     // declare pointer to T's A
     typename T::A* a6;          // declare pointer to T's A
     T::A* a7;                   // T::A is not a type name:
+                                // multiplication of T::A by a7; ill-formed, no visible declaration of a7
     B* a8;                      // B is not a type name:
+                                // multiplication of B by a8; ill-formed, no visible declarations of B and a8
   }
 };
 ```
+— *end example*]
+When a *qualified-id* is intended to refer to a type that is not a
+member of the current instantiation ([[temp.dep.type]]) and its
+*nested-name-specifier* refers to a dependent type, it shall be prefixed
+by the keyword `typename`, forming a *typename-specifier*. If the
+*qualified-id* in a *typename-specifier* does not denote a type or a
+class template, the program is ill-formed.
 ``` bnf
 typename-specifier:
   'typename' nested-name-specifier identifier
   'typename' nested-name-specifier 'template'ₒₚₜ simple-template-id
 ```
 If a specialization of a template is instantiated for a set of
 *template-argument*s such that the *qualified-id* prefixed by `typename`
+does not denote a type or a class template, the specialization is
+ill-formed. The usual qualified name lookup ([[basic.lookup.qual]]) is
+used to find the *qualified-id* even in the presence of `typename`.
+[*Example 2*:
 ``` cpp
 struct A {
   struct X { };
   int X;
   f(b);             // OK: T::X refers to B::X
   f(a);             // error: T::X refers to the data member A::X not the struct A::X
 }
 ```
+— *end example*]
+A qualified name used as the name in a *class-or-decltype* (Clause
+[[class.derived]]) or an *elaborated-type-specifier* is implicitly
 assumed to name a type, without the use of the `typename` keyword. In a
 *nested-name-specifier* that immediately contains a
 *nested-name-specifier* that depends on a template parameter, the
 *identifier* or *simple-template-id* is implicitly assumed to name a
+type, without the use of the `typename` keyword.
+[*Note 1*: The `typename` keyword is not permitted by the syntax of
+these constructs. — *end note*]
 If, for a given set of template arguments, a specialization of a
 template is instantiated that refers to a *qualified-id* that denotes a
+type or a class template, and the *qualified-id* refers to a member of
+an unknown specialization, the *qualified-id* shall either be prefixed
+by `typename` or shall be used in a context in which it implicitly names
+a type as described above.
+[*Example 3*:
 ``` cpp
 template <class T> void f(int i) {
   T::x * i;         // T::x must not be a type
 }
   f<Bar>(1);        // OK
   f<Foo>(1);        // error: Foo::x is a type
 }
 ```
+— *end example*]
 Within the definition of a class template or within the definition of a
 member of a class template following the *declarator-id*, the keyword
 `typename` is not required when referring to the name of a previously
+declared member of the class template that declares a type or a class
+template.
+[*Note 2*: Such names can be found using unqualified name lookup (
+[[basic.lookup.unqual]]), class member lookup ([[class.qual]]) into the
+current instantiation ([[temp.dep.type]]), or class member access
+expression lookup ([[basic.lookup.classref]]) when the type of the
+object expression is the current instantiation (
+[[temp.dep.expr]]). — *end note*]
+[*Example 4*:
 ``` cpp
 template<class T> struct A {
   typedef int B;
   B b;              // OK, no typename required
 };
 ```
+— *end example*]
 Knowing which names are type names allows the syntax of every template
+to be checked. The program is ill-formed, no diagnostic required, if:
+- no valid specialization can be generated for a template or a
+  substatement of a constexpr if statement ([[stmt.if]]) within a
+  template and the template is not instantiated, or
+- every valid specialization of a variadic template requires an empty
+  template parameter pack, or
+- a hypothetical instantiation of a template immediately following its
+  definition would be ill-formed due to a construct that does not depend
+  on a template parameter, or
+- the interpretation of such a construct in the hypothetical
+  instantiation is different from the interpretation of the
+  corresponding construct in any actual instantiation of the template.
+  \[*Note 3*:
+  This can happen in situations including the following:
+  - a type used in a non-dependent name is incomplete at the point at
+    which a template is defined but is complete at the point at which an
+    instantiation is performed, or
+  - lookup for a name in the template definition found a
+    *using-declaration*, but the lookup in the corresponding scope in
+    the instantiation does not find any declarations because the
+    *using-declaration* was a pack expansion and the corresponding pack
+    is empty, or
+  - an instantiation uses a default argument or default template
+    argument that had not been defined at the point at which the
+    template was defined, or
+  - constant expression evaluation ([[expr.const]]) within the template
+    instantiation uses
+    - the value of a `const` object of integral or unscoped enumeration
+      type or
+    - the value of a `constexpr` object or
+    - the value of a reference or
+    - the definition of a constexpr function,
+    and that entity was not defined when the template was defined, or
+  - a class template specialization or variable template specialization
+    that is specified by a non-dependent *simple-template-id* is used by
+    the template, and either it is instantiated from a partial
+    specialization that was not defined when the template was defined or
+    it names an explicit specialization that was not declared when the
+    template was defined.
+  — *end note*]
+Otherwise, no diagnostic shall be issued for a template for which a
+valid specialization can be generated.
+[*Note 4*: If a template is instantiated, errors will be diagnosed
+according to the other rules in this International Standard. Exactly
+when these errors are diagnosed is a quality of implementation
+issue. — *end note*]
+[*Example 5*:
 ``` cpp
 int j;
 template<class T> class X {
   void f(T t, int i, char* p) {
+    t = i;          // diagnosed if X::f is instantiated, and the assignment to t is an error
+    p = i;          // may be diagnosed even if X::f is not instantiated
+    p = j;          // may be diagnosed even if X::f is not instantiated
   }
   void g(T t) {
+    +;              // may be diagnosed even if X::g is not instantiated
   }
 };
 template<class... T> struct A {
   void operator++(int, T... t);                     // error: too many parameters
 };
 template<class... T> union X : T... { };            // error: union with base class
 template<class... T> struct A : T...,  T... { };    // error: duplicate base class
 ```
+— *end example*]
 When looking for the declaration of a name used in a template
 definition, the usual lookup rules ([[basic.lookup.unqual]],
 [[basic.lookup.argdep]]) are used for non-dependent names. The lookup of
 names dependent on the template parameters is postponed until the actual
 template argument is known ([[temp.dep]]).
+[*Example 6*:
 ``` cpp
 #include <iostream>
 using namespace std;
 template<class T> class Set {
 name `operator<<` is known within the definition of `printall()` and a
 declaration of it can be found in `<iostream>`, the actual declaration
 of `operator<<` needed to print `p[i]` cannot be known until it is known
 what type `T` is ([[temp.dep]]).
+— *end example*]
 If a name does not depend on a *template-parameter* (as defined in
 [[temp.dep]]), a declaration (or set of declarations) for that name
 shall be in scope at the point where the name appears in the template
 definition; the name is bound to the declaration (or declarations) found
 at that point and this binding is not affected by declarations that are
 visible at the point of instantiation.
+[*Example 7*:
 ``` cpp
 void f(char);
 template<class T> void g(T t) {
   f(1);             // f(char)
   f(T(1));          // dependent
   f(t);             // dependent
+  dd++;             // not dependent; error: declaration for dd not found
 }
 enum E { e };
 void f(E);
 double dd;
 void h() {
+  g(e);             // will cause one call of f(char) followed by two calls of f(E)
   g('a');           // will cause three calls of f(char)
 }
 ```
+— *end example*]
+[*Note 5*: For purposes of name lookup, default arguments and
+*noexcept-specifier*s of function templates and default arguments and
+*noexcept-specifier*s of member functions of class templates are
+considered definitions ([[temp.decls]]). — *end note*]
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
 injected-class-name (Clause  [[class]]). The injected-class-name can be
 specialization, when the injected-class-name is used as a *type-name*,
 it is equivalent to the *template-name* followed by the
 *template-argument*s of the class template specialization or partial
 specialization enclosed in `<>`.
+[*Example 1*:
 ``` cpp
 template<template<class> class T> class A { };
 template<class T> class Y;
 template<> class Y<int> {
   Y* p;                               // meaning Y<int>
     template<class> friend class Y;   // meaning ::Y
   };
 };
 ```
+— *end example*]
 The injected-class-name of a class template or class template
 specialization can be used either as a *template-name* or a *type-name*
 wherever it is in scope.
+[*Example 2*:
 ``` cpp
 template <class T> struct Base {
   Base* p;
 };
 template<class T, template<class> class U = T::template Base> struct Third { };
 Third<Base<int> > t;            // OK: default argument uses injected-class-name as a template
 ```
+— *end example*]
 A lookup that finds an injected-class-name ([[class.member.lookup]])
 can result in an ambiguity in certain cases (for example, if it is found
 in more than one base class). If all of the injected-class-names that
 are found refer to specializations of the same class template, and if
 the name is used as a *template-name*, the reference refers to the class
 template itself and not a specialization thereof, and is not ambiguous.
+[*Example 3*:
 ``` cpp
 template <class T> struct Base { };
 template <class T> struct Derived: Base<int>, Base<char> {
   typename Derived::Base b;             // error: ambiguous
   typename Derived::Base<double> d;     // OK
 };
 ```
+— *end example*]
 When the normal name of the template (i.e., the name from the enclosing
 scope, not the injected-class-name) is used, it always refers to the
 class template itself and not a specialization of the template.
+[*Example 4*:
 ``` cpp
 template<class T> class X {
   X* p;             // meaning X<T>
   X<T>* p2;
   X<int>* p3;
   ::X* p4;          // error: missing template argument list
                     // ::X does not refer to the injected-class-name
 };
 ```
+— *end example*]
 A *template-parameter* shall not be redeclared within its scope
 (including nested scopes). A *template-parameter* shall not have the
 same name as the template name.
+[*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
   int T;            // error: template-parameter redeclared
   void f() {
     char T;         // error: template-parameter redeclared
 };
 template<class X> class X;      // error: template-parameter redeclared
 ```
+— *end example*]
 In the definition of a member of a class template that appears outside
 of the class template definition, the name of a member of the class
 template hides the name of a *template-parameter* of any enclosing class
 templates (but not a *template-parameter* of the member if the member is
 a class or function template).
+[*Example 6*:
 ``` cpp
 template<class T> struct A {
+  struct B { ... };
   typedef void C;
   void f();
   template<class U> void g(U);
 };
   B b;              // A's B, not the template parameter
   C c;              // the template parameter C, not A's C
 }
 ```
+— *end example*]
 In the definition of a member of a class template that appears outside
 of the namespace containing the class template definition, the name of a
 *template-parameter* hides the name of a member of this namespace.
+[*Example 7*:
 ``` cpp
 namespace N {
   class C { };
   template<class T> class B {
     void f(T);
 template<class C> void N::B<C>::f(C) {
   C b;              // C is the template parameter, not N::C
 }
 ```
+— *end example*]
 In the definition of a class template or in the definition of a member
 of such a template that appears outside of the template definition, for
+each non-dependent base class ([[temp.dep.type]]), if the name of the
+base class or the name of a member of the base class is the same as the
+name of a *template-parameter*, the base class name or member name hides
+the *template-parameter* name ([[basic.scope.hiding]]).
+[*Example 8*:
 ``` cpp
 struct A {
+  struct B { ... };
   int a;
   int Y;
 };
 template<class B, class a> struct X : A {
   B b;              // A's B
   a b;              // error: A's a isn't a type name
 };
 ```
+— *end example*]
 ### Dependent names <a id="temp.dep">[[temp.dep]]</a>
 Inside a template, some constructs have semantics which may differ from
 one instantiation to another. Such a construct *depends* on the template
 parameters. In particular, types and expressions may depend on the type
 and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
+names. An expressions may be *type-dependent* (that is, its type may
+depend on a template parameter) or *value-dependent* (that is, its value
+when evaluated as a constant expression ([[expr.const]]) may depend on
+a template parameter) as described in this subclause. In an expression
+of the form:
 where the *postfix-expression* is an *unqualified-id*, the
 *unqualified-id* denotes a *dependent name* if
 - any of the expressions in the *expression-list* is a pack expansion (
   [[temp.variadic]]),
+- any of the expressions or *braced-init-list*s in the *expression-list*
+ is type-dependent ([[temp.dep.expr]]), or
+- the *unqualified-id* is a *template-id* in which any of the template
+  arguments depends on a template parameter.
 If an operand of an operator is a type-dependent expression, the
 operator also denotes a dependent name. Such names are unbound and are
 looked up at the point of the template instantiation ([[temp.point]])
 in both the context of the template definition and the context of the
 point of instantiation.
+[*Example 1*:
 ``` cpp
 template<class T> struct X : B<T> {
   typename T::A* pa;
   void f(B<T>* pb) {
     static int i = B<T>::i;
 ```
 the base class name `B<T>`, the type name `T::A`, the names `B<T>::i`
 and `pb->j` explicitly depend on the *template-parameter*.
+— *end example*]
+In the definition of a class or class template, the scope of a dependent
+base class ([[temp.dep.type]]) is not examined during unqualified name
+lookup either at the point of definition of the class template or member
+or during an instantiation of the class template or member.
+[*Example 2*:
 ``` cpp
 typedef double A;
 template<class T> class B {
   typedef int A;
 The type name `A` in the definition of `X<T>` binds to the typedef name
 defined in the global namespace scope, not to the typedef name defined
 in the base class `B<T>`.
+— *end example*]
+[*Example 3*:
 ``` cpp
 struct A {
+  struct B { ... };
   int a;
   int Y;
 };
 int a;
 template<class T> struct Y : T {
+  struct B { ... };
   B b;                          // The B defined in Y
   void f(int i) { a = i; }      // ::a
   Y* p;                         // Y<T>
 };
 ```
 The members `A::B`, `A::a`, and `A::Y` of the template argument `A` do
 not affect the binding of names in `Y<A>`.
+— *end example*]
 #### Dependent types <a id="temp.dep.type">[[temp.dep.type]]</a>
 A name refers to the *current instantiation* if it is
 - in the definition of a class template, a nested class of a class
 current instantiation. In the case of a non-type template argument, the
 argument must have been given the value of the template parameter and
 not an expression in which the template parameter appears as a
 subexpression.
+[*Example 1*:
 ``` cpp
 template <class T> class A {
   A* p1;                        // A is the current instantiation
   A<T>* p2;                     // A<T> is the current instantiation
   A<T*> p3;                     // A<T*> is not the current instantiation
   ::A<T>* p4;                   // ::A<T> is the current instantiation
   class B {
     B* p1;                      // B is the current instantiation
     A<T>::B* p2;                // A<T>::B is the current instantiation
+    typename A<T*>::B* p3;      // A<T*>::B is not the current instantiation
   };
 };
 template <class T> class A<T*> {
   A<T*>* p1;                    // A<T*> is the current instantiation
   B<my_T1, T2, my_I2>* b4;      // not the current instantiation
   B<my_T1, T2, my_I3>* b5;      // refers to the current instantiation
 };
 ```
+— *end example*]
+A *dependent base class* is a base class that is a dependent type and is
+not the current instantiation.
+[*Note 1*:
+A base class can be the current instantiation in the case of a nested
+class naming an enclosing class as a base.
+[*Example 2*:
+``` cpp
+template<class T> struct A {
+  typedef int M;
+  struct B {
+    typedef void M;
+    struct C;
+  };
+};
+template<class T> struct A<T>::B::C : A<T> {
+  M m;                          // OK, A<T>::M
+};
+```
+— *end example*]
+— *end note*]
 A name is a *member of the current instantiation* if it is
 - An unqualified name that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
+  base class thereof. \[*Note 2*: This can only occur when looking up a
+ name in a scope enclosed by the definition of a class
+  template. — *end note*]
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation and that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
+  base class thereof. \[*Note 3*: If no such member is found, and the
+ current instantiation has any dependent base classes, then the
+ *qualified-id* is a member of an unknown specialization; see
+  below. — *end note*]
 - An *id-expression* denoting the member in a class member access
   expression ([[expr.ref]]) for which the type of the object expression
   is the current instantiation, and the *id-expression*, when looked
   up ([[basic.lookup.classref]]), refers to at least one member of a
   class that is the current instantiation or a non-dependent base class
+  thereof. \[*Note 4*: If no such member is found, and the current
+ instantiation has any dependent base classes, then the *id-expression*
+ is a member of an unknown specialization; see below. — *end note*]
+[*Example 3*:
 ``` cpp
 template <class T> class A {
   static const int i = 5;
   int n1[i];                    // i refers to a member of the current instantiation
 template <class T> int A<T>::f() {
   return i;                     // i refers to a member of the current instantiation
 }
 ```
+— *end example*]
 A name is a *dependent member of the current instantiation* if it is a
 member of the current instantiation that, when looked up, refers to at
 least one member of a class that is the current instantiation.
 A name is a *member of an unknown specialization* if it is
 current instantiation does not refer to a member of the current
 instantiation or a member of an unknown specialization, the program is
 ill-formed even if the template containing the member access expression
 is not instantiated; no diagnostic required.
+[*Example 4*:
 ``` cpp
 template<class T> class A {
   typedef int type;
   void f() {
     A<T>::type i;               // OK: refers to a member of the current instantiation
                                 // a member of an unknown specialization
   }
 };
 ```
+— *end example*]
 If, for a given set of template arguments, a specialization of a
 template is instantiated that refers to a member of the current
 instantiation with a *qualified-id* or class member access expression,
 the name in the *qualified-id* or class member access expression is
 looked up in the template instantiation context. If the result of this
 lookup differs from the result of name lookup in the template definition
+context, name lookup is ambiguous.
+[*Example 5*:
+``` cpp
+struct A {
+  int m;
+};
+struct B {
+  int m;
+};
+template<typename T>
+struct C : A, T {
+  int f() { return this->m; }   // finds A::m in the template definition context
+  int g() { return m; }         // finds A::m in the template definition context
+};
+template int C<B>::f();         // error: finds both A::m and B::m
+template int C<B>::g();         // OK: transformation to class member access syntax
+                                // does not occur in the template definition context; see~[class.mfct.non-static]
+```
+— *end example*]
 A type is dependent if it is
 - a template parameter,
 - a member of an unknown specialization,
 - a nested class or enumeration that is a dependent member of the
   current instantiation,
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
+- an array type whose element type is dependent or whose bound (if any)
+  is value-dependent,
+- a function type whose exception specification is value-dependent,
 - a *simple-template-id* in which either the template name is a template
   parameter or any of the template arguments is a dependent type or an
+  expression that is type-dependent or value-dependent or is a pack
+  expansion \[*Note 5*: This includes an injected-class-name (Clause
+  [[class]]) of a class template used without a
+  *template-argument-list*. — *end note*] , or
 - denoted by `decltype(`*expression*`)`, where *expression* is
   type-dependent ([[temp.dep.expr]]).
+[*Note 6*: Because typedefs do not introduce new types, but instead
+simply refer to other types, a name that refers to a typedef that is a
+member of the current instantiation is dependent only if the type
+referred to is dependent. — *end note*]
 #### Type-dependent expressions <a id="temp.dep.expr">[[temp.dep.expr]]</a>
 Except as described below, an expression is type-dependent if any
 subexpression is type-dependent.
 An *id-expression* is type-dependent if it contains
 - an *identifier* associated by name lookup with one or more
   declarations declared with a dependent type,
+- an *identifier* associated by name lookup with a non-type
+  *template-parameter* declared with a type that contains a placeholder
+  type ([[dcl.spec.auto]]),
 - an *identifier* associated by name lookup with one or more
   declarations of member functions of the current instantiation declared
+  with a return type that contains a placeholder type,
+- an *identifier* associated by name lookup with a structured binding
+  declaration ([[dcl.struct.bind]]) whose *brace-or-equal-initializer*
+  is type-dependent,
+- the *identifier* `__func__` ([[dcl.fct.def.general]]), where any
+  enclosing function is a template, a member of a class template, or a
+  generic lambda,
 - a *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
 - a *nested-name-specifier* or a *qualified-id* that names a member of
   an unknown specialization;
 subexpression is type-dependent:
 Expressions of the following forms are never type-dependent (because the
 type of the expression cannot be dependent):
+[*Note 1*: For the standard library macro `offsetof`, see
+[[support.types]]. — *end note*]
 A class member access expression ([[expr.ref]]) is type-dependent if
 the expression refers to a member of the current instantiation and the
 type of the referenced member is dependent, or the class member access
+expression refers to a member of an unknown specialization.
+[*Note 2*: In an expression of the form `x.y` or `xp->y` the type of
+the expression is usually the type of the member `y` of the class of `x`
+(or the class pointed to by `xp`). However, if `x` or `xp` refers to a
+dependent type that is not the current instantiation, the type of `y` is
+always dependent. If `x` or `xp` refers to a non-dependent type or
+refers to the current instantiation, the type of `y` is the type of the
+class member access expression. — *end note*]
+A *braced-init-list* is type-dependent if any element is type-dependent
+or is a pack expansion.
+A *fold-expression* is type-dependent.
 #### Value-dependent expressions <a id="temp.dep.constexpr">[[temp.dep.constexpr]]</a>
+Except as described below, an expression used in a context where a
+constant expression is required is value-dependent if any subexpression
+is value-dependent.
 An *id-expression* is value-dependent if:
+- it is type-dependent,
 - it is the name of a non-type template parameter,
 - it names a static data member that is a dependent member of the
   current instantiation and is not initialized in a *member-declarator*,
 - it names a static member function that is a dependent member of the
   current instantiation, or
 - it is a constant with literal type and is initialized with an
 Expressions of the following form are value-dependent if the
 *unary-expression* or *expression* is type-dependent or the *type-id* is
 dependent:
+[*Note 1*: For the standard library macro `offsetof`, see
+[[support.types]]. — *end note*]
 Expressions of the following form are value-dependent if either the
 *type-id* or *simple-type-specifier* is dependent or the *expression* or
 *cast-expression* is value-dependent:
 Expressions of the following form are value-dependent:
 An expression of the form `&`*qualified-id* where the *qualified-id*
 names a dependent member of the current instantiation is
+value-dependent. An expression of the form `&`*cast-expression* is also
+value-dependent if evaluating *cast-expression* as a core constant
+expression ([[expr.const]]) succeeds and the result of the evaluation
+refers to a templated entity that is an object with static or thread
+storage duration or a member function.
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 A type *template-argument* is dependent if the type it specifies is
 dependent.
 ### Non-dependent names <a id="temp.nondep">[[temp.nondep]]</a>
 Non-dependent names used in a template definition are found using the
 usual name lookup and bound at the point they are used.
+[*Example 1*:
 ``` cpp
 void g(double);
 void h();
 template<class T> class Z {
 public:
   void f() {
     g(1);           // calls g(double)
+    h++;            // ill-formed: cannot increment function; this could be diagnosed
+                    // either here or at the point of instantiation
   }
 };
+void g(int);        // not in scope at the point of the template definition, not considered for the call g(1)
 ```
+— *end example*]
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 In resolving dependent names, names from the following sources are
 considered:
 in a way which uses the definition of a default argument of that
 function template or member function, the point of instantiation of the
 default argument is the point of instantiation of the function template
 or member function specialization.
+For a *noexcept-specifier* of a function template specialization or
+specialization of a member function of a class template, if the
+*noexcept-specifier* is implicitly instantiated because it is needed by
+another template specialization and the context that requires it depends
+on a template parameter, the point of instantiation of the
+*noexcept-specifier* is the point of instantiation of the specialization
+that requires it. Otherwise, the point of instantiation for such a
+*noexcept-specifier* immediately follows the namespace scope declaration
+or definition that requires the *noexcept-specifier*.
 For a class template specialization, a class member template
 specialization, or a specialization for a class member of a class
 template, if the specialization is implicitly instantiated because it is
 referenced from within another template specialization, if the context
 unit, the end of the translation unit is also considered a point of
 instantiation. A specialization for a class template has at most one
 point of instantiation within a translation unit. A specialization for
 any template may have points of instantiation in multiple translation
 units. If two different points of instantiation give a template
+specialization different meanings according to the one-definition rule (
 [[basic.def.odr]]), the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
 For a function call where the *postfix-expression* is a dependent name,
 functions of a class template specialization are not visible during an
 ordinary lookup unless explicitly declared at namespace scope (
 [[class.friend]]). Such names may be found under the rules for
 associated classes ([[basic.lookup.argdep]]).[^6]
+[*Example 1*:
 ``` cpp
 template<typename T> struct number {
   number(int);
   friend number gcd(number x, number y) { return 0; };
 };
 void g() {
   number<double> a(3), b(4);
+  a = gcd(a,b);     // finds gcd because number<double> is an associated class,
+                    // making gcd visible in its namespace (global scope)
   b = gcd(3,4);     // ill-formed; gcd is not visible
 }
 ```
+— *end example*]

Diff to HTML by rtfpessoa