Use `const` for array pointers in `StandardTypes.h`

[GeorgeLyon]

Summary

This mirrors the underlying C++ api.

[GeorgeLyon]

Fix diff

[GeorgeLyon]

Try again after rebase

[GeorgeLyon]

Rebasing to re-run CI

[GeorgeLyon]

Rebasing again

[GeorgeLyon]

Add some missing consts

mlir/include/mlir-c/StandardTypes.h

 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Vector type.
 MLIR_CAPI_EXPORTED int mlirTypeIsAVector(MlirType type);
 
 /** Creates a vector type of the shape identified by its rank and dimensions,
  * with the given element type in the same context as the element type. The type
  * is owned by the context. */
-MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGet(intptr_t rank, int64_t *shape,
+MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGet(intptr_t rank,
+                                              const int64_t *shape,
                                               MlirType elementType);
 
 /** Same as "mlirVectorTypeGet" but returns a nullptr wrapping MlirType on
  * illegal arguments, emitting appropriate diagnostics. */
 MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGetChecked(intptr_t rank,
-                                                     int64_t *shape,
+                                                     const int64_t *shape,
                                                      MlirType elementType,
                                                      MlirLocation loc);
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked Tensor type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Tensor type.
 MLIR_CAPI_EXPORTED int mlirTypeIsATensor(MlirType type);
 
 /// Checks whether the given type is a ranked tensor type.
 MLIR_CAPI_EXPORTED int mlirTypeIsARankedTensor(MlirType type);
 
 /// Checks whether the given type is an unranked tensor type.
 MLIR_CAPI_EXPORTED int mlirTypeIsAUnrankedTensor(MlirType type);
 
 /** Creates a tensor type of a fixed rank with the given shape and element type
  * in the same context as the element type. The type is owned by the context. */
 MLIR_CAPI_EXPORTED MlirType mlirRankedTensorTypeGet(intptr_t rank,
-                                                    int64_t *shape,
+                                                    const int64_t *shape,
                                                     MlirType elementType);
 
 /** Same as "mlirRankedTensorTypeGet" but returns a nullptr wrapping MlirType on
  * illegal arguments, emitting appropriate diagnostics. */
 MLIR_CAPI_EXPORTED MlirType mlirRankedTensorTypeGetChecked(intptr_t rank,
-                                                           int64_t *shape,
+                                                           const int64_t *shape,
                                                            MlirType elementType,
                                                            MlirLocation loc);
 
 /** Creates an unranked tensor type with the given element type in the same
  * context as the element type. The type is owned by the context. */
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedTensorTypeGet(MlirType elementType);
 
 /** Same as "mlirUnrankedTensorTypeGet" but returns a nullptr wrapping MlirType

 MLIR_CAPI_EXPORTED int mlirTypeIsAMemRef(MlirType type);
 
 /// Checks whether the given type is an UnrankedMemRef type.
 MLIR_CAPI_EXPORTED int mlirTypeIsAUnrankedMemRef(MlirType type);
 
 /** Creates a MemRef type with the given rank and shape, a potentially empty
  * list of affine layout maps, the given memory space and element type, in the
  * same context as element type. The type is owned by the context. */
-MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeGet(MlirType elementType,
-                                              intptr_t rank, int64_t *shape,
-                                              intptr_t numMaps,
-                                              MlirAttribute const *affineMaps,
-                                              unsigned memorySpace);
+MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeGet(
+    MlirType elementType, intptr_t rank, const int64_t *shape, intptr_t numMaps,
+    MlirAttribute const *affineMaps, unsigned memorySpace);
 
 /** Creates a MemRef type with the given rank, shape, memory space and element
  * type in the same context as the element type. The type has no affine maps,
  * i.e. represents a default row-major contiguous memref. The type is owned by
  * the context. */
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeContiguousGet(MlirType elementType,
                                                         intptr_t rank,
-                                                        int64_t *shape,
+                                                        const int64_t *shape,
                                                         unsigned memorySpace);
 
 /** Same as "mlirMemRefTypeContiguousGet" but returns a nullptr wrapping
  * MlirType on illegal arguments, emitting appropriate diagnostics. */
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeContiguousGetChecked(
-    MlirType elementType, intptr_t rank, int64_t *shape, unsigned memorySpace,
-    MlirLocation loc);
+    MlirType elementType, intptr_t rank, const int64_t *shape,
+    unsigned memorySpace, MlirLocation loc);
 
 /** Creates an Unranked MemRef type with the given element type and in the given
  * memory space. The type is owned by the context of element type. */
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedMemRefTypeGet(MlirType elementType,
                                                       unsigned memorySpace);
 
 /** Same as "mlirUnrankedMemRefTypeGet" but returns a nullptr wrapping
  * MlirType on illegal arguments, emitting appropriate diagnostics. */

mlir/lib/CAPI/IR/StandardTypes.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Vector type.
 //===----------------------------------------------------------------------===//
 
 int mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
 
-MlirType mlirVectorTypeGet(intptr_t rank, int64_t *shape,
+MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape,
                            MlirType elementType) {
   return wrap(
       VectorType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
                       unwrap(elementType)));
 }
 
-MlirType mlirVectorTypeGetChecked(intptr_t rank, int64_t *shape,
+MlirType mlirVectorTypeGetChecked(intptr_t rank, const int64_t *shape,
                                   MlirType elementType, MlirLocation loc) {
   return wrap(VectorType::getChecked(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       unwrap(loc)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked tensor type.
 //===----------------------------------------------------------------------===//
 
 int mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
 
 int mlirTypeIsARankedTensor(MlirType type) {
   return unwrap(type).isa<RankedTensorType>();
 }
 
 int mlirTypeIsAUnrankedTensor(MlirType type) {
   return unwrap(type).isa<UnrankedTensorType>();
 }
 
-MlirType mlirRankedTensorTypeGet(intptr_t rank, int64_t *shape,
+MlirType mlirRankedTensorTypeGet(intptr_t rank, const int64_t *shape,
                                  MlirType elementType) {
   return wrap(RankedTensorType::get(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType)));
 }
 
-MlirType mlirRankedTensorTypeGetChecked(intptr_t rank, int64_t *shape,
+MlirType mlirRankedTensorTypeGetChecked(intptr_t rank, const int64_t *shape,
                                         MlirType elementType,
                                         MlirLocation loc) {
   return wrap(RankedTensorType::getChecked(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       unwrap(loc)));
 }
 
 MlirType mlirUnrankedTensorTypeGet(MlirType elementType) {
   return wrap(UnrankedTensorType::get(unwrap(elementType)));
 }
 
 MlirType mlirUnrankedTensorTypeGetChecked(MlirType elementType,
                                           MlirLocation loc) {
   return wrap(UnrankedTensorType::getChecked(unwrap(elementType), unwrap(loc)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
 int mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
 
-MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank, int64_t *shape,
-                           intptr_t numMaps, MlirAffineMap const *affineMaps,
+MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank,
+                           const int64_t *shape, intptr_t numMaps,
+                           MlirAffineMap const *affineMaps,
                            unsigned memorySpace) {
   SmallVector<AffineMap, 1> maps;
   (void)unwrapList(numMaps, affineMaps, maps);
   return wrap(
       MemRefType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
                       unwrap(elementType), maps, memorySpace));
 }
 
 MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
-                                     int64_t *shape, unsigned memorySpace) {
+                                     const int64_t *shape,
+                                     unsigned memorySpace) {
   return wrap(
       MemRefType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
                       unwrap(elementType), llvm::None, memorySpace));
 }
 
 MlirType mlirMemRefTypeContiguousGetChecked(MlirType elementType, intptr_t rank,
-                                            int64_t *shape,
+                                            const int64_t *shape,
                                             unsigned memorySpace,
                                             MlirLocation loc) {
   return wrap(MemRefType::getChecked(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       llvm::None, memorySpace, unwrap(loc)));
 }
 
 intptr_t mlirMemRefTypeGetNumAffineMaps(MlirType type) {