[Matrix] Replace some err kinds with err_builtin_invalid_arg_type. (NFC)

[fhahn]

Summary

Replace some custom matrix diagnostic kinds with the more generic
err_builtin_invalid_arg_type introduced in D111985.

[erichkeane]

I'm fine with this change in general... but did this not manage to break any tests?

clang/lib/Sema/SemaChecking.cpp

16654

Can you make these be a "select" instead? It makes it really difficult to localize if we do this.

[aaron.ballman]

In general, I like the direction of this cleanup. Thanks!

In D112532#3087293, @erichkeane wrote:

I'm fine with this change in general... but did this not manage to break any tests?

Precommit CI says things are broken: https://buildkite.com/llvm-project/premerge-checks/builds/62247#63e5ea73-b0b3-4df4-898a-dd05d1f4bf81

[fhahn]

Reabsed after landing D111985. Also turned the custom message parts into a select as suggested.

In D112532#3087371, @aaron.ballman wrote:

In general, I like the direction of this cleanup. Thanks!

In D112532#3087293, @erichkeane wrote:

I'm fine with this change in general... but did this not manage to break any tests?

Precommit CI says things are broken: https://buildkite.com/llvm-project/premerge-checks/builds/62247#63e5ea73-b0b3-4df4-898a-dd05d1f4bf81

I think that is a build failure due the me not linking the dependency in Phab. Now that D111985 has landed it should be come back green.

clang/lib/Sema/SemaChecking.cpp

16654

done, thanks!

[erichkeane]

clang/lib/Sema/SemaChecking.cpp

16582

1 nit: On the 'select' lines, please put a /**/ comment next to the integer to explain what it is. If they were all closer to eachother, I'd suggest doing an enum for them, but the comment should be good enough.

[fhahn]

Add comment to int selecting message as suggested.

[fhahn]

clang/lib/Sema/SemaChecking.cpp

16582

done, thanks!

[aaron.ballman]

LGTM

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def warn_noderef_to_dereferenceable_pointer : Warning<
   "casting to dereferenceable pointer removes 'noderef' attribute">, InGroup<NoDeref>;
 
 def err_builtin_launder_invalid_arg : Error<
   "%select{non-pointer|function pointer|void pointer}0 argument to "
   "'__builtin_launder' is not allowed">;
 
 def err_builtin_invalid_arg_type: Error <
-  "%ordinal0 argument must be a %1 (was %2)">;
+  "%ordinal0 argument must be a "
+  "%select{vector, integer or floating point type|matrix|"
+   "pointer to a valid matrix element type}1 (was %2)">;
 
 def err_builtin_matrix_disabled: Error<
   "matrix types extension is disabled. Pass -fenable-matrix to enable it">;
 def err_matrix_index_not_integer: Error<
   "matrix %select{row|column}0 index is not an integer">;
 def err_matrix_index_outside_range: Error<
   "matrix %select{row|column}0 index is outside the allowed range [0, %1)">;
 def err_matrix_incomplete_index: Error<
   "single subscript expressions are not allowed for matrix values">;
 def err_matrix_separate_incomplete_index: Error<
   "matrix row and column subscripts cannot be separated by any expression">;
 def err_matrix_subscript_comma: Error<
   "comma expressions are not allowed as indices in matrix subscript expressions">;
-def err_builtin_matrix_arg: Error<"1st argument must be a matrix">;
 def err_builtin_matrix_scalar_unsigned_arg: Error<
   "%0 argument must be a constant unsigned integer expression">;
-def err_builtin_matrix_pointer_arg: Error<
-  "%ordinal0 argument must be a pointer to a valid matrix element type">;
 def err_builtin_matrix_pointer_arg_mismatch: Error<
   "the pointee of the 2nd argument must match the element type of the 1st argument (%0 != %1)">;
 def err_builtin_matrix_store_to_const: Error<
   "cannot store matrix to read-only pointer">;
 def err_builtin_matrix_stride_too_small: Error<
   "stride must be greater or equal to the number of rows">;
 def err_builtin_matrix_invalid_dimension: Error<
   "%0 dimension is outside the allowed range [1, %1]">;

clang/lib/Sema/SemaChecking.cpp

 
 // Check if \p Ty is a valid type for the elementwise math builtins. If it is
 // not a valid type, emit an error message and return true. Otherwise return
 // false.
 static bool checkMathBuiltinElementType(Sema &S, SourceLocation Loc,
                                         QualType Ty) {
   if (!Ty->getAs<VectorType>() && !ConstantMatrixType::isValidElementType(Ty)) {
     S.Diag(Loc, diag::err_builtin_invalid_arg_type)
-        << 1 << "vector, integer or floating point type" << Ty;
+        << 1 << /* vector, integer or float ty*/ 0 << Ty;
     return true;
   }
   return false;
 }
 
 bool Sema::SemaBuiltinElementwiseMath(CallExpr *TheCall) {
   if (checkArgCount(*this, TheCall, 2))
     return true;
ExprResult Sema::SemaBuiltinMatrixTranspose(CallExpr *TheCall,
 
   ExprResult MatrixArg = DefaultLvalueConversion(TheCall->getArg(0));
   if (MatrixArg.isInvalid())
     return MatrixArg;
   Expr *Matrix = MatrixArg.get();
 
   auto *MType = Matrix->getType()->getAs<ConstantMatrixType>();
   if (!MType) {
-    Diag(Matrix->getBeginLoc(), diag::err_builtin_matrix_arg);
+    Diag(Matrix->getBeginLoc(), diag::err_builtin_invalid_arg_type)
+        << 1 << /* matrix ty*/ 1 << Matrix->getType();
     return ExprError();
   }
 
   // Create returned matrix type by swapping rows and columns of the argument
   // matrix type.
   QualType ResultType = Context.getConstantMatrixType(
       MType->getElementType(), MType->getNumColumns(), MType->getNumRows());
 
if (PtrExpr->isTypeDependent()) {
       TheCall->setType(Context.DependentTy);
       return TheCall;
     }
   }
 
   auto *PtrTy = PtrExpr->getType()->getAs<PointerType>();
   QualType ElementTy;
   if (!PtrTy) {
-    Diag(PtrExpr->getBeginLoc(), diag::err_builtin_matrix_pointer_arg)
-        << PtrArgIdx + 1;
+    Diag(PtrExpr->getBeginLoc(), diag::err_builtin_invalid_arg_type)
+        << PtrArgIdx + 1 << /*pointer to element ty*/ 2 << PtrExpr->getType();
     ArgError = true;
   } else {
     ElementTy = PtrTy->getPointeeType().getUnqualifiedType();
 
     if (!ConstantMatrixType::isValidElementType(ElementTy)) {
-      Diag(PtrExpr->getBeginLoc(), diag::err_builtin_matrix_pointer_arg)
-          << PtrArgIdx + 1;
+      Diag(PtrExpr->getBeginLoc(), diag::err_builtin_invalid_arg_type)
+          << PtrArgIdx + 1 << /* pointer to element ty*/ 2
+          << PtrExpr->getType();
       ArgError = true;
     }
   }
 
   // Apply default Lvalue conversions and convert the expression to size_t.
   auto ApplyArgumentConversions = [this](Expr *E) {
     ExprResult Conv = DefaultLvalueConversion(E);
     if (Conv.isInvalid())
ExprResult Sema::SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
   }
   if (MatrixExpr->isTypeDependent()) {
     TheCall->setType(Context.DependentTy);
     return TheCall;
   }
 
   auto *MatrixTy = MatrixExpr->getType()->getAs<ConstantMatrixType>();
   if (!MatrixTy) {
-    Diag(MatrixExpr->getBeginLoc(), diag::err_builtin_matrix_arg) << 0;
+    Diag(MatrixExpr->getBeginLoc(), diag::err_builtin_invalid_arg_type)
+        << 1 << /*matrix ty */ 1 << MatrixExpr->getType();
     ArgError = true;
   }
 
   {
     ExprResult PtrConv = DefaultFunctionArrayLvalueConversion(PtrExpr);
     if (PtrConv.isInvalid())
       return PtrConv;
     PtrExpr = PtrConv.get();
     TheCall->setArg(1, PtrExpr);
     if (PtrExpr->isTypeDependent()) {
       TheCall->setType(Context.DependentTy);
       return TheCall;
     }
   }
 
   // Check pointer argument.
   auto *PtrTy = PtrExpr->getType()->getAs<PointerType>();
   if (!PtrTy) {
-    Diag(PtrExpr->getBeginLoc(), diag::err_builtin_matrix_pointer_arg)
-        << PtrArgIdx + 1;
+    Diag(PtrExpr->getBeginLoc(), diag::err_builtin_invalid_arg_type)
+        << PtrArgIdx + 1 << /*pointer to element ty*/ 2 << PtrExpr->getType();
     ArgError = true;
   } else {
     QualType ElementTy = PtrTy->getPointeeType();
     if (ElementTy.isConstQualified()) {
       Diag(PtrExpr->getBeginLoc(), diag::err_builtin_matrix_store_to_const);
       ArgError = true;
     }
     ElementTy = ElementTy.getUnqualifiedType().getCanonicalType();