[clang] Unify and refactor error formatting

Author: frasercrmck

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -12405,17 +12405,13 @@ def err_builtin_is_within_lifetime_invalid_arg : Error<
   "%select{non-|function }0pointer argument to '__builtin_is_within_lifetime' "
   "is not allowed">;
 
-def err_builtin_invalid_arg_type: Error <
-  "%ordinal0 argument must be "
-  "%select{a vector, integer or floating point type|a matrix|"
-  "a pointer to a valid matrix element type|"
-  "a signed integer or floating point type|a vector type|"
-  "a floating point type|"
-  "a vector of integers|"
-  "an unsigned integer|"
-  "an 'int'|"
-  "a vector of floating points|"
-  "an integer or vector of integers}1 (was %2)">;
+def err_builtin_invalid_arg_type: Error<
+  "%ordinal0 argument must be a"
+  "%select{| scalar| vector| vector,| vector of| scalar or vector of}1"
+  "%select{| integer| signed integer| unsigned integer| 'int'|"
+  " matrix| pointer to a valid matrix element}2"
+  "%plural{0:|:%plural{0:|: or}2}3"
+  "%select{| floating-point}3 %plural{[0,3]:type|:types}1 (was %4)">;
 
 def err_builtin_matrix_disabled: Error<
   "matrix types extension is disabled. Pass -fenable-matrix to enable it">;

clang/lib/Sema/SemaChecking.cpp

@@ -1983,25 +1983,29 @@ checkMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy,
     if (!ArgTy->getAs<VectorType>() &&
         !ConstantMatrixType::isValidElementType(ArgTy)) {
       return S.Diag(Loc, diag::err_builtin_invalid_arg_type)
-             << ArgOrdinal << /* vector, integer or float ty*/ 0 << ArgTy;
+             << ArgOrdinal << /* vector, */ 3 << /* integer */ 1 << /* fp */ 1
+             << ArgTy;
     }
     break;
   case Sema::EltwiseBuiltinArgTyRestriction::FloatTy:
     if (!EltTy->isRealFloatingType()) {
       return S.Diag(Loc, diag::err_builtin_invalid_arg_type)
-             << ArgOrdinal << /* vector or float ty*/ 5 << ArgTy;
+             << ArgOrdinal << /* scalar or vector */ 5 << /* no int */ 0
+             << /* floating-point */ 1 << ArgTy;
     }
     break;
   case Sema::EltwiseBuiltinArgTyRestriction::IntegerTy:
     if (!EltTy->isIntegerType()) {
       return S.Diag(Loc, diag::err_builtin_invalid_arg_type)
-             << ArgOrdinal << /* vector or int ty*/ 10 << ArgTy;
+             << ArgOrdinal << /* scalar or vector */ 5 << /* integer */ 1
+             << /* no fp */ 0 << ArgTy;
     }
     break;
   case Sema::EltwiseBuiltinArgTyRestriction::SignedIntOrFloatTy:
     if (EltTy->isUnsignedIntegerType()) {
       return S.Diag(Loc, diag::err_builtin_invalid_arg_type)
-             << 1 << /* signed integer or float ty*/ 3 << ArgTy;
+             << 1 << /* scalar or vector */ 5 << /* signed int */ 2
+             << /* or fp */ 1 << ArgTy;
     }
     break;
   }
@@ -2071,7 +2075,8 @@ static bool BuiltinPopcountg(Sema &S, CallExpr *TheCall) {
 
   if (!ArgTy->isUnsignedIntegerType()) {
     S.Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << 1 << /*unsigned integer ty*/ 7 << ArgTy;
+        << 1 << /* scalar */ 1 << /* unsigned integer ty */ 3 << /* no fp */ 0
+        << ArgTy;
     return true;
   }
   return false;
@@ -2095,7 +2100,8 @@ static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall) {
 
   if (!Arg0Ty->isUnsignedIntegerType()) {
     S.Diag(Arg0->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << 1 << /*unsigned integer ty*/ 7 << Arg0Ty;
+        << 1 << /* scalar */ 1 << /* unsigned integer ty */ 3 << /* no fp */ 0
+        << Arg0Ty;
     return true;
   }
 
@@ -2111,7 +2117,7 @@ static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall) {
 
     if (!Arg1Ty->isSpecificBuiltinType(BuiltinType::Int)) {
       S.Diag(Arg1->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-          << 2 << /*'int' ty*/ 8 << Arg1Ty;
+          << 2 << /* scalar */ 1 << /* 'int' ty */ 4 << /* no fp */ 0 << Arg1Ty;
       return true;
     }
   }
@@ -2826,7 +2832,8 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
 
     if (ElTy.isNull()) {
       Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-          << 1 << /* vector ty*/ 4 << Arg->getType();
+          << 1 << /* vector ty */ 2 << /* no int */ 0 << /* no fp */ 0
+          << Arg->getType();
       return ExprError();
     }
 
@@ -2849,7 +2856,8 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
 
     if (ElTy.isNull() || !ElTy->isFloatingType()) {
       Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-          << 1 << /* vector of floating points */ 9 << Arg->getType();
+          << 1 << /* vector of */ 4 << /* no int */ 0 << /* fp */ 1
+          << Arg->getType();
       return ExprError();
     }
 
@@ -2878,7 +2886,8 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
 
     if (ElTy.isNull() || !ElTy->isIntegerType()) {
       Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-          << 1  << /* vector of integers */ 6 << Arg->getType();
+          << 1 << /* vector of */ 4 << /* int */ 1 << /* no fp */ 0
+          << Arg->getType();
       return ExprError();
     }
 
@@ -14785,8 +14794,9 @@ bool Sema::BuiltinNonDeterministicValue(CallExpr *TheCall) {
   QualType TyArg = Arg.get()->getType();
 
   if (!TyArg->isBuiltinType() && !TyArg->isVectorType())
-    return Diag(TheCall->getArg(0)->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-           << 1 << /*vector, integer or floating point ty*/ 0 << TyArg;
+    return Diag(TheCall->getArg(0)->getBeginLoc(),
+                diag::err_builtin_invalid_arg_type)
+           << 1 << /* vector, */ 3 << /* integer */ 1 << /* fp */ 1 << TyArg;
 
   TheCall->setType(TyArg);
   return false;
@@ -14805,7 +14815,7 @@ ExprResult Sema::BuiltinMatrixTranspose(CallExpr *TheCall,
   auto *MType = Matrix->getType()->getAs<ConstantMatrixType>();
   if (!MType) {
     Diag(Matrix->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << 1 << /* matrix ty*/ 1 << Matrix->getType();
+        << 1 << 0 << /* matrix ty */ 5 << /* no fp */ 0 << Matrix->getType();
     return ExprError();
   }
 
@@ -14877,15 +14887,16 @@ ExprResult Sema::BuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
   QualType ElementTy;
   if (!PtrTy) {
     Diag(PtrExpr->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << PtrArgIdx + 1 << /*pointer to element ty*/ 2 << PtrExpr->getType();
+        << PtrArgIdx + 1 << 0 << /* pointer to element ty */ 6 << /* no fp */ 0
+        << PtrExpr->getType();
     ArgError = true;
   } else {
     ElementTy = PtrTy->getPointeeType().getUnqualifiedType();
 
     if (!ConstantMatrixType::isValidElementType(ElementTy)) {
       Diag(PtrExpr->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-          << PtrArgIdx + 1 << /* pointer to element ty*/ 2
-          << PtrExpr->getType();
+          << PtrArgIdx + 1 << 0 << /* pointer to element ty */ 6
+          << /* no fp */ 0 << PtrExpr->getType();
       ArgError = true;
     }
   }
@@ -14985,7 +14996,7 @@ ExprResult Sema::BuiltinMatrixColumnMajorStore(CallExpr *TheCall,
   auto *MatrixTy = MatrixExpr->getType()->getAs<ConstantMatrixType>();
   if (!MatrixTy) {
     Diag(MatrixExpr->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << 1 << /*matrix ty */ 1 << MatrixExpr->getType();
+        << 1 << 0 << /* matrix ty */ 5 << 0 << MatrixExpr->getType();
     ArgError = true;
   }
 
@@ -15005,7 +15016,8 @@ ExprResult Sema::BuiltinMatrixColumnMajorStore(CallExpr *TheCall,
   auto *PtrTy = PtrExpr->getType()->getAs<PointerType>();
   if (!PtrTy) {
     Diag(PtrExpr->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << PtrArgIdx + 1 << /*pointer to element ty*/ 2 << PtrExpr->getType();
+        << PtrArgIdx + 1 << 0 << /* pointer to element ty */ 6 << 0
+        << PtrExpr->getType();
     ArgError = true;
   } else {
     QualType ElementTy = PtrTy->getPointeeType();

clang/lib/Sema/SemaHLSL.cpp

@@ -2331,7 +2331,8 @@ bool SemaHLSL::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
 
     if (!EltTy->isIntegerType()) {
       Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-          << 1 << /* integer ty */ 6 << ArgTy;
+          << 1 << /* scalar or vector of */ 5 << /* integer ty */ 1
+          << /* no fp */ 0 << ArgTy;
       return true;
     }
 

clang/test/Sema/aarch64-sve-vector-exp-ops.c

@@ -7,11 +7,11 @@
 svfloat32_t test_exp_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_exp(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_exp2_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_exp2(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }

clang/test/Sema/aarch64-sve-vector-log-ops.c

@@ -7,17 +7,17 @@
 svfloat32_t test_log_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_log(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_log10_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_log10(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_log2_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_log2(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }

clang/test/Sema/aarch64-sve-vector-pow-ops.c

@@ -7,5 +7,5 @@
 svfloat32_t test_pow_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_pow(v, v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }

clang/test/Sema/aarch64-sve-vector-trig-ops.c

@@ -7,59 +7,59 @@
 svfloat32_t test_asin_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_asin(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_acos_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_acos(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_atan_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_atan(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_atan2_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_atan2(v, v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_sin_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_sin(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_cos_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_cos(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_tan_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_tan(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_sinh_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_sinh(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_cosh_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_cosh(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }
 
 svfloat32_t test_tanh_vv_i8mf8(svfloat32_t v) {
 
   return __builtin_elementwise_tanh(v);
-  // expected-error@-1 {{1st argument must be a floating point type}}
+  // expected-error@-1 {{1st argument must be a scalar or vector of floating-point types}}
 }