[std] Harmonize comments indicating errors.

Author: jensmaurer

source/basic.tex

@@ -1012,10 +1012,10 @@
 \begin{example}
 \begin{codeblock}
 if (int x = f()) {
-  int x;            // ill-formed, redeclaration of \tcode{x}
+  int x;            // error: redeclaration of \tcode{x}
 }
 else {
-  int x;            // ill-formed, redeclaration of \tcode{x}
+  int x;            // error: redeclaration of \tcode{x}
 }
 \end{codeblock}
 \end{example}
@@ -1958,9 +1958,9 @@
 }
 void test() {
   auto x = make();              // OK, \tcode{decltype(x)} is \tcode{R::X} in module \tcode{M}
-  R::f(x);                      // ill-formed: \tcode{R} and \tcode{R::f} are not visible here
+  R::f(x);                      // error: \tcode{R} and \tcode{R::f} are not visible here
   f(x);                         // OK, calls \tcode{R::f} from interface of \tcode{M}
-  f(x, S::Z());                 // ill-formed: \tcode{S::f} in module \tcode{M} not considered
+  f(x, S::Z());                 // error: \tcode{S::f} in module \tcode{M} not considered
                                 // even though \tcode{S} is an associated namespace
   apply(x, S::Z());             // OK, \tcode{S::f} is visible in instantiation context, and
                                 // \tcode{R::g} is visible even though it has internal linkage
@@ -1996,7 +1996,7 @@
 int main() {
   int A;
   A::n = 42;        // OK
-  A b;              // ill-formed: \tcode{A} does not name a type
+  A b;              // error: \tcode{A} does not name a type
 }
 \end{codeblock}
 \end{example}
@@ -2022,7 +2022,7 @@
   static const int number = 50;
   static X arr[number];
 };
-X C::arr[number];   // ill-formed:
+X C::arr[number];   // error:
                     // equivalent to \tcode{::X} \tcode{C::arr[C::number];}
                     // and not to \tcode{C::X} \tcode{C::arr[C::number];}
 \end{codeblock}
@@ -2149,7 +2149,7 @@
 B::B() { }
 
 B::A ba;            // object of type \tcode{A}
-A::A a;             // error, \tcode{A::A} is not a type name
+A::A a;             // error: \tcode{A::A} is not a type name
 struct A::A a2;     // object of type \tcode{A}
 \end{codeblock}
 \end{example}
@@ -2371,7 +2371,7 @@
   }
   using namespace B;
 }
-void A::f1(int){ }  // ill-formed, \tcode{f1} is not a member of \tcode{A}
+void A::f1(int){ }  // error: \tcode{f1} is not a member of \tcode{A}
 \end{codeblock}
 \end{example}
 However, in such namespace member declarations, the
@@ -3288,7 +3288,7 @@
   pb->mutate();
   *pb;              // OK: \tcode{pb} points to valid memory
   void* q = pb;     // OK: \tcode{pb} points to valid memory
-  pb->f();          // undefined behavior, lifetime of \tcode{*pb} has ended
+  pb->f();          // undefined behavior: lifetime of \tcode{*pb} has ended
 }
 \end{codeblock}
 \end{example}
@@ -4533,8 +4533,8 @@
 UNKA** arrpp;
 
 void foo() {
-  xp++;                         // ill-formed: \tcode{X} is incomplete
-  arrp++;                       // ill-formed: incomplete type
+  xp++;                         // error: \tcode{X} is incomplete
+  arrp++;                       // error: incomplete type
   arrpp++;                      // OK: sizeof \tcode{UNKA*} is known
 }
 
@@ -4544,9 +4544,9 @@
 X x;
 void bar() {
   xp = &x;                      // OK; type is ``pointer to \tcode{X}''
-  arrp = &arr;                  // ill-formed: different types
+  arrp = &arr;                  // error: different types
   xp++;                         // OK:  \tcode{X} is complete
-  arrp++;                       // ill-formed: \tcode{UNKA} can't be completed
+  arrp++;                       // error: \tcode{UNKA} can't be completed
 }
 \end{codeblock}
 \end{example}
@@ -5464,7 +5464,7 @@
   i = 7, i++, i++;              // \tcode{i} becomes \tcode{9}
 
   i = i++ + 1;                  // the value of \tcode{i} is incremented
-  i = i++ + i;                  // the behavior is undefined
+  i = i++ + i;                  // undefined behavior
   i = i + 1;                    // the value of \tcode{i} is incremented
 }
 \end{codeblock}

source/classes.tex

@@ -318,7 +318,7 @@
 simply a single function \tcode{f()} twice. For the same reason,
 \begin{codeblock}
 struct S { int a; };
-struct S { int a; };            // error, double definition
+struct S { int a; };            // error: double definition
 \end{codeblock}
 is ill-formed because it defines \tcode{S} twice.
 \end{example}
@@ -2476,7 +2476,7 @@
 };
 
 Y a;
-int b = a;          // error, \tcode{a.operator X().operator int()} not tried
+int b = a;          // error: no viable conversion (\tcode{a.operator X().operator int()} not considered)
 int c = X(a);       // OK: \tcode{a.operator X().operator int()}
 \end{codeblock}
 \end{example}
@@ -2499,7 +2499,7 @@
 };
 
 void f(Y& a) {
-  if (a) {          // ill-formed: \tcode{X::operator int()} or \tcode{Y::operator char()}
+  if (a) {          // error: ambiguous between \tcode{X::operator int()} and \tcode{Y::operator char()}
   }
 }
 \end{codeblock}
@@ -2642,7 +2642,7 @@
 
 void h(Z z) {
   Y y1(z);          // OK: direct-initialization
-  Y y2 = z;         // ill-formed: copy-initialization
+  Y y2 = z;         // error: no conversion function candidate for copy-initialization
   Y y3 = (Y)z;      // OK: cast notation
 }
 
@@ -3614,7 +3614,7 @@
 \begin{example}
 \begin{codeblock}
 class X { @\commentellip@ };
-class Y : public X, public X { @\commentellip@ };             // ill-formed
+class Y : public X, public X { @\commentellip@ };             // error
 
 \end{codeblock}
 \begin{codeblock}
@@ -3930,7 +3930,7 @@
   Derived*  dp = &d;
   D*  q = dp->vf4();            // calls \tcode{Derived::vf4()} and does not
                                 // convert the result to \tcode{B*}
-  dp->vf2();                    // ill-formed: argument mismatch
+  dp->vf2();                    // error: argument mismatch
 }
 \end{codeblock}
 \end{example}
@@ -3988,7 +3988,7 @@
   A*   ap = b1p;
   D*   dp = &d;
   ap->f();                      // calls \tcode{D::B1::f}
-  dp->f();                      // ill-formed: ambiguous
+  dp->f();                      // error: ambiguous
 }
 \end{codeblock}
 In class \tcode{D} above there are two occurrences of class \tcode{A}
@@ -4014,7 +4014,7 @@
   void f();
 };
 
-struct Error : VB1, VB2 {       // ill-formed
+struct Error : VB1, VB2 {       // error
 };
 
 struct Okay : VB1, VB2 {
@@ -4129,7 +4129,7 @@
 \begin{example}
 \begin{codeblock}
 struct C {
-  virtual void f() = 0 { };     // ill-formed
+  virtual void f() = 0 { };     // error
 };
 \end{codeblock}
 \end{example}
@@ -4348,7 +4348,7 @@
   pd->v++;          // OK: only one \tcode{v} (virtual)
   pd->s++;          // OK: only one \tcode{s} (static)
   int i = pd->e;    // OK: only one \tcode{e} (enumerator)
-  pd->a++;          // error, ambiguous: two \tcode{a}{s} in \tcode{D}
+  pd->a++;          // error: ambiguous: two \tcode{a}{s} in \tcode{D}
 }
 \end{codeblock}
 \end{example}
@@ -4413,7 +4413,7 @@
 void g() {
   D d;
   B* pb = &d;
-  A* pa = &d;       // error, ambiguous: \tcode{C}'s \tcode{A} or \tcode{B}'s \tcode{A}?
+  A* pa = &d;       // error: ambiguous: \tcode{C}'s \tcode{A} or \tcode{B}'s \tcode{A}?
   V* pv = &d;       // OK: only one \tcode{V} subobject
 }
 \end{codeblock}
@@ -5272,7 +5272,7 @@
   friend void c();  // error
   };
   X* px;            // OK, but \tcode{::X} is found
-  Z* pz;            // error, no \tcode{Z} is found
+  Z* pz;            // error: no \tcode{Z} is found
 }
 \end{codeblock}
 \end{example}
@@ -5310,31 +5310,31 @@
 };
 
 void fr(B* pb, D1* p1, D2* p2) {
-  pb->i = 1;                    // ill-formed
-  p1->i = 2;                    // ill-formed
+  pb->i = 1;                    // error
+  p1->i = 2;                    // error
   p2->i = 3;                    // OK (access through a \tcode{D2})
   p2->B::i = 4;                 // OK (access through a \tcode{D2}, even though naming class is \tcode{B})
-  int B::* pmi_B = &B::i;       // ill-formed
+  int B::* pmi_B = &B::i;       // error
   int B::* pmi_B2 = &D2::i;     // OK (type of \tcode{\&D2::i} is \tcode{int B::*})
-  B::j = 5;                     // ill-formed (not a friend of naming class \tcode{B})
+  B::j = 5;                     // error: not a friend of naming class \tcode{B}
   D2::j = 6;                    // OK (because refers to static member)
 }
 
 void D2::mem(B* pb, D1* p1) {
-  pb->i = 1;                    // ill-formed
-  p1->i = 2;                    // ill-formed
+  pb->i = 1;                    // error
+  p1->i = 2;                    // error
   i = 3;                        // OK (access through \tcode{this})
   B::i = 4;                     // OK (access through \tcode{this}, qualification ignored)
-  int B::* pmi_B = &B::i;       // ill-formed
+  int B::* pmi_B = &B::i;       // error
   int B::* pmi_B2 = &D2::i;     // OK
   j = 5;                        // OK (because \tcode{j} refers to static member)
   B::j = 6;                     // OK (because \tcode{B::j} refers to static member)
 }
 
 void g(B* pb, D1* p1, D2* p2) {
-  pb->i = 1;                    // ill-formed
-  p1->i = 2;                    // ill-formed
-  p2->i = 3;                    // ill-formed
+  pb->i = 1;                    // error
+  p1->i = 2;                    // error
+  p2->i = 3;                    // error
 }
 \end{codeblock}
 \end{example}
@@ -5659,7 +5659,7 @@
 struct A { A(); };
 struct B: public virtual A { };
 struct C: public A, public B { C(); };
-C::C(): A() { }                 // ill-formed: which \tcode{A}?
+C::C(): A() { }                 // error: which \tcode{A}?
 \end{codeblock}
 \end{example}
 
@@ -6018,7 +6018,7 @@
   int j;
 public:
   int f();
-  B() : A(f()),     // undefined: calls member function but base \tcode{A} not yet initialized
+  B() : A(f()),     // undefined behavior: calls member function but base \tcode{A} not yet initialized
   j(f()) { }        // well-defined: bases are all initialized
 };
 
@@ -6030,7 +6030,7 @@
 class D : public B, C {
   int i;
 public:
-  D() : C(f()),     // undefined: calls member function but base \tcode{C} not yet initialized
+  D() : C(f()),     // undefined behavior: calls member function but base \tcode{C} not yet initialized
   i(f()) { }        // well-defined: bases are all initialized
 };
 \end{codeblock}
@@ -6152,7 +6152,7 @@
   using V2::V2;
 };
 
-D1 d1(0);           // ill-formed: ambiguous
+D1 d1(0);           // error: ambiguous
 D2 d2(0);           // OK: initializes virtual \tcode{B} base class, which initializes the \tcode{A} base class
                     // then initializes the \tcode{V1} and \tcode{V2} base classes as if by a defaulted default constructor
 
@@ -6192,10 +6192,10 @@
 
 extern B bobj;
 B* pb = &bobj;                          // OK
-int* p1 = &bobj.a;                      // undefined, refers to base class member
-int* p2 = &bobj.y.i;                    // undefined, refers to member's member
+int* p1 = &bobj.a;                      // undefined behavior: refers to base class member
+int* p2 = &bobj.y.i;                    // undefined behavior: refers to member's member
 
-A* pa = &bobj;                          // undefined, upcast to a base class type
+A* pa = &bobj;                          // undefined behavior: upcast to a base class type
 B bobj;                                 // definition of \tcode{bobj}
 
 extern X xobj;
@@ -6284,7 +6284,7 @@
 struct X { X(A*); };
 
 struct E : C, D, X {
-  E() : D(this),    // undefined: upcast from \tcode{E*} to \tcode{A*} might use path \tcode{E*} $\rightarrow$ \tcode{D*} $\rightarrow$ \tcode{A*}
+  E() : D(this),    // undefined behavior: upcast from \tcode{E*} to \tcode{A*} might use path \tcode{E*} $\rightarrow$ \tcode{D*} $\rightarrow$ \tcode{A*}
                     // but \tcode{D} is not constructed
 
                     // ``\tcode{D((C*)this)}\!'' would be defined: \tcode{E*} $\rightarrow$ \tcode{C*} is defined because \tcode{E()} has started,
@@ -6342,7 +6342,7 @@
   f();              // calls \tcode{V::f}, not \tcode{A::f}
   g();              // calls \tcode{B::g}, not \tcode{D::g}
   v->g();           // \tcode{v} is base of \tcode{B}, the call is well-defined, calls \tcode{B::g}
-  a->f();           // undefined behavior, \tcode{a}'s type not a base of \tcode{B}
+  a->f();           // undefined behavior: \tcode{a}'s type not a base of \tcode{B}
 }
 \end{codeblock}
 \end{example}
@@ -6419,7 +6419,7 @@
   typeid(*v);                   // well-defined: \tcode{*v} has type \tcode{V}, a base of \tcode{B} yields \tcode{type_info} for \tcode{B}
   typeid(*a);                   // undefined behavior: type \tcode{A} not a base of \tcode{B}
   dynamic_cast<B*>(v);          // well-defined: \tcode{v} of type \tcode{V*}, \tcode{V} base of \tcode{B} results in \tcode{B*}
-  dynamic_cast<B*>(a);          // undefined behavior, \tcode{a} has type \tcode{A*}, \tcode{A} not a base of \tcode{B}
+  dynamic_cast<B*>(a);          // undefined behavior: \tcode{a} has type \tcode{A*}, \tcode{A} not a base of \tcode{B}
 }
 \end{codeblock}
 \end{example}
@@ -6962,7 +6962,7 @@
 void foo(int i) {
   new (ap) D1;      // calls \tcode{B::operator new(std::size_t, Arena*)}
   new D1[i];        // calls \tcode{::operator new[](std::size_t)}
-  new D1;           // ill-formed: \tcode{::operator new(std::size_t)} hidden
+  new D1;           // error: \tcode{::operator new(std::size_t)} hidden
 }
 \end{codeblock}
 \end{example}

source/compatibility.tex

@@ -2118,7 +2118,7 @@
 int g() { return f(); }
 
 // Translation unit 2
-int f(int a = 76) { return a; }         // ill-formed (no diagnostic required); previously well-formed
+int f(int a = 76) { return a; }         // ill-formed, no diagnostic required; previously well-formed
 int g();
 int main() { return g(); }              // used to return 42
 \end{codeblock}