Prefer ambiguous: over ambiguous, ; error: ambiguous: over error: ambiguous?

Author: vgvassilev

source/basic.tex

@@ -1950,7 +1950,7 @@
   using namespace A;
   using namespace B;
   int i = C::x;     // OK: \tcode{A::x} (of type \tcode{int} )
-  int j = C::y;     // ambiguous, \tcode{A::y} or \tcode{B::y}
+  int j = C::y;     // ambiguous: \tcode{A::y} or \tcode{B::y}
 }
 \end{codeblock}
 \end{example}

source/declarations.tex

@@ -3202,7 +3202,7 @@
     using namespace B;
     using namespace C;
     void f2() {
-      i = 5;        // ambiguous, \tcode{B::C::i} or \tcode{A::i}?
+      i = 5;        // ambiguous: \tcode{B::C::i} or \tcode{A::i}?
     }
   }
   void f3() {
@@ -3349,7 +3349,7 @@
 }
 
 void f() {
-  d1++;             // error: ambiguous \tcode{::d1} or \tcode{D::d1}?
+  d1++;             // error: ambiguous: \tcode{::d1} or \tcode{D::d1}?
   ::d1++;           // OK
   D::d1++;          // OK
   d2++;             // OK: \tcode{D::d2}

source/derived.tex

@@ -477,7 +477,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}
@@ -544,7 +544,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}

source/expressions.tex

@@ -5210,7 +5210,7 @@
 template<int> struct X { }; 
 constexpr A a = 42; 
 X<a> x;             // OK: unique conversion to \tcode{int}
-int ary[a];         // error: ambiguous conversion 
+int ary[a];         // error: ambiguous: conversion 
 \end{codeblock}
 \end{example}%
 \indextext{expression|)}

source/overloading.tex

@@ -2277,7 +2277,7 @@
 g( {1.0, 1.0} );            // error: narrowing
 
 void f(B);
-f( {'a', 'b'} );            // error: ambiguous \tcode{f(A)} or \tcode{f(B)}
+f( {'a', 'b'} );            // error: ambiguous: \tcode{f(A)} or \tcode{f(B)}
 
 struct C {
   C(std::string);