[mlir][sparse] Fixes C++98 warning

[wrengr]

Summary

The semicolons were introduced in D126105 in order to correct clang-format, but I forgot this file must be compiled as C++98 rather than C++11.

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

void *_mlir_ciface_addElt##VNAME(void *coo, V value,                         \
     for (uint64_t r = 0; r < isize; r++)                                       \
       indices[perm[r]] = indx[r];                                              \
     static_cast<SparseTensorCOO<V> *>(coo)->add(indices, value);               \
     return coo;                                                                \
   }
 FOREVERY_SIMPLEX_V(IMPL_ADDELT)
 IMPL_ADDELT(C64, complex64)
 // Marked static because it's not part of the public API.
-// (The `static` keyword confuses clang-format, so the extraneous trailing
-// semicolon is required to teach clang-format not to indent the prototype
-// of `_mlir_ciface_addEltC32` below.)
-static IMPL_ADDELT(C32ABI, complex32);
+// NOTE: the `static` keyword confuses clang-format here, causing
+// the strange indentation of the `_mlir_ciface_addEltC32` prototype.
+// In C++11 we can add a semicolon after the call to `IMPL_ADDELT`
+// and that will correct clang-format.  Alas, this file is compiled
+// in C++98 mode where that semicolon is illegal (and there's no portable
+// macro magic to license a no-op semicolon at the top level).
+static IMPL_ADDELT(C32ABI, complex32)
 #undef IMPL_ADDELT
     void *_mlir_ciface_addEltC32(void *coo, float r, float i,
                                  StridedMemRefType<index_type, 1> *iref,
                                  StridedMemRefType<index_type, 1> *pref) {
   return _mlir_ciface_addEltC32ABI(coo, complex32(r, i), iref, pref);
 }
 
 #define IMPL_GETNEXT(VNAME, V)                                                 \
   bool _mlir_ciface_getNext##VNAME(void *coo,                                  \
                                    StridedMemRefType<index_type, 1> *iref,     \
                                    StridedMemRefType<V, 0> *vref) {            \
     assert(coo &&iref &&vref);                                                 \
void _mlir_ciface_lexInsert##VNAME(                                          \
     assert(cref->strides[0] == 1);                                             \
     index_type *cursor = cref->data + cref->offset;                            \
     assert(cursor);                                                            \
     static_cast<SparseTensorStorageBase *>(tensor)->lexInsert(cursor, val);    \
   }
 FOREVERY_SIMPLEX_V(IMPL_LEXINSERT)
 IMPL_LEXINSERT(C64, complex64)
 // Marked static because it's not part of the public API.
-// (The `static` keyword confuses clang-format, so the extraneous trailing
-// semicolon is required to teach clang-format not to indent the prototype
-// of `_mlir_ciface_lexInsertC32` below.)
-static IMPL_LEXINSERT(C32ABI, complex32);
+// NOTE: see the note for `_mlir_ciface_addEltC32ABI`
+static IMPL_LEXINSERT(C32ABI, complex32)
 #undef IMPL_LEXINSERT
     void _mlir_ciface_lexInsertC32(void *tensor,
-                               StridedMemRefType<index_type, 1> *cref, float r,
-                               float i) {
+                                   StridedMemRefType<index_type, 1> *cref,
+                                   float r, float i) {
   _mlir_ciface_lexInsertC32ABI(tensor, cref, complex32(r, i));
 }
 
 #define IMPL_EXPINSERT(VNAME, V)                                               \
   void _mlir_ciface_expInsert##VNAME(                                          \
       void *tensor, StridedMemRefType<index_type, 1> *cref,                    \
       StridedMemRefType<V, 1> *vref, StridedMemRefType<bool, 1> *fref,         \
       StridedMemRefType<index_type, 1> *aref, index_type count) {              \