Make array pointers in the CAPI const

[GeorgeLyon]

Summary

These pointers do not need to be mutable. This has an affect that generated function signatures in the Swift bindings now use UnsafePointer instead of UnsafeMutablePointer.

mlir/include/mlir-c/IR.h

 
 /// Constructs an operation state from a name and a location.
 MLIR_CAPI_EXPORTED MlirOperationState mlirOperationStateGet(const char *name,
                                                             MlirLocation loc);
 
 /// Adds a list of components to the operation state.
 MLIR_CAPI_EXPORTED void mlirOperationStateAddResults(MlirOperationState *state,
                                                      intptr_t n,
-                                                     MlirType *results);
+                                                     MlirType const *results);
 MLIR_CAPI_EXPORTED void mlirOperationStateAddOperands(MlirOperationState *state,
                                                       intptr_t n,
-                                                      MlirValue *operands);
+                                                      MlirValue const *operands);
 MLIR_CAPI_EXPORTED void
 mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
-                                  MlirRegion *regions);
+                                  MlirRegion const *regions);
 MLIR_CAPI_EXPORTED void
 mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
-                                MlirBlock *successors);
+                                MlirBlock const *successors);
 MLIR_CAPI_EXPORTED void
 mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
-                                MlirNamedAttribute *attributes);
+                                MlirNamedAttribute const *attributes);
 
 //===----------------------------------------------------------------------===//
 // Op Printing flags API.
 // While many of these are simple settings that could be represented in a
 // struct, they are wrapped in a heap allocated object and accessed via
 // functions to maximize the possibility of compatibility over time.
 //===----------------------------------------------------------------------===//
 
MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockBefore(MlirRegion region,
                                                          MlirBlock block);
 
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
 /** Creates a new empty block with the given argument types and transfers
  * ownership to the caller. */
-MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType *args);
+MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args);
 
 /// Takes a block owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block);
 
 /// Checks whether a block is null.
 static inline int mlirBlockIsNull(MlirBlock block) { return !block.ptr; }
 
 /** Checks whether two blocks handles point to the same block. This does not

mlir/include/mlir-c/StandardAttributes.h

 
 /// Checks whether the given attribute is an array attribute.
 MLIR_CAPI_EXPORTED int mlirAttributeIsAArray(MlirAttribute attr);
 
 /** Creates an array element containing the given list of elements in the given
  * context. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirArrayAttrGet(MlirContext ctx,
                                                   intptr_t numElements,
-                                                  MlirAttribute *elements);
+                                                  MlirAttribute const *elements);
 
 /// Returns the number of elements stored in the given array attribute.
 MLIR_CAPI_EXPORTED intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr);
 
 /// Returns pos-th element stored in the given array attribute.
 MLIR_CAPI_EXPORTED MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr,
                                                          intptr_t pos);
 
 //===----------------------------------------------------------------------===//
 // Dictionary attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a dictionary attribute.
 MLIR_CAPI_EXPORTED int mlirAttributeIsADictionary(MlirAttribute attr);
 
 /** Creates a dictionary attribute containing the given list of elements in the
  * provided context. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirDictionaryAttrGet(
-    MlirContext ctx, intptr_t numElements, MlirNamedAttribute *elements);
+    MlirContext ctx, intptr_t numElements, MlirNamedAttribute const *elements);
 
 /// Returns the number of attributes contained in a dictionary attribute.
 MLIR_CAPI_EXPORTED intptr_t
 mlirDictionaryAttrGetNumElements(MlirAttribute attr);
 
 /// Returns pos-th element of the given dictionary attribute.
 MLIR_CAPI_EXPORTED MlirNamedAttribute
 mlirDictionaryAttrGetElement(MlirAttribute attr, intptr_t pos);

 MLIR_CAPI_EXPORTED int mlirAttributeIsASymbolRef(MlirAttribute attr);
 
 /** Creates a symbol reference attribute in the given context referencing a
  * symbol identified by the given string inside a list of nested references.
  * Each of the references in the list must not be nested. The string need not be
  * null-terminated and its length must be specified. */
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length, const char *symbol,
-                     intptr_t numReferences, MlirAttribute *references);
+                     intptr_t numReferences, MlirAttribute const *references);
 
 /** Returns the string reference to the root referenced symbol. The data remains
  * live as long as the context in which the attribute lives. */
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirSymbolRefAttrGetRootReference(MlirAttribute attr);
 
 /** Returns the string reference to the leaf referenced symbol. The data remains
  * live as long as the context in which the attribute lives. */

mlir/include/mlir-c/StandardTypes.h

 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 *affineMaps,
+                                              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,

 
 /// Checks whether the given type is a tuple type.
 MLIR_CAPI_EXPORTED int mlirTypeIsATuple(MlirType type);
 
 /** Creates a tuple type that consists of the given list of elemental types. The
  * type is owned by the context. */
 MLIR_CAPI_EXPORTED MlirType mlirTupleTypeGet(MlirContext ctx,
                                              intptr_t numElements,
-                                             MlirType *elements);
+                                             MlirType const *elements);
 
 /// Returns the number of types contained in a tuple.
 MLIR_CAPI_EXPORTED intptr_t mlirTupleTypeGetNumTypes(MlirType type);
 
 /// Returns the pos-th type in the tuple type.
 MLIR_CAPI_EXPORTED MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos);
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a function type.
 MLIR_CAPI_EXPORTED int mlirTypeIsAFunction(MlirType type);
 
 /// Creates a function type, mapping a list of input types to result types.
 MLIR_CAPI_EXPORTED MlirType mlirFunctionTypeGet(MlirContext ctx,
                                                 intptr_t numInputs,
-                                                MlirType *inputs,
+                                                MlirType const *inputs,
                                                 intptr_t numResults,
-                                                MlirType *results);
+                                                MlirType const *results);
 
 /// Returns the number of input types.
 MLIR_CAPI_EXPORTED intptr_t mlirFunctionTypeGetNumInputs(MlirType type);
 
 /// Returns the number of result types.
 MLIR_CAPI_EXPORTED intptr_t mlirFunctionTypeGetNumResults(MlirType type);
 
 /// Returns the pos-th input type.

mlir/lib/CAPI/IR/IR.cpp

 
 #define APPEND_ELEMS(type, sizeName, elemName)                                 \
   state->elemName =                                                            \
       (type *)realloc(state->elemName, (state->sizeName + n) * sizeof(type));  \
   memcpy(state->elemName + state->sizeName, elemName, n * sizeof(type));       \
   state->sizeName += n;
 
 void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n,
-                                  MlirType *results) {
+                                  MlirType const *results) {
   APPEND_ELEMS(MlirType, nResults, results);
 }
 
 void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n,
-                                   MlirValue *operands) {
+                                   MlirValue const *operands) {
   APPEND_ELEMS(MlirValue, nOperands, operands);
 }
 void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
-                                       MlirRegion *regions) {
+                                       MlirRegion const *regions) {
   APPEND_ELEMS(MlirRegion, nRegions, regions);
 }
 void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
-                                     MlirBlock *successors) {
+                                     MlirBlock const *successors) {
   APPEND_ELEMS(MlirBlock, nSuccessors, successors);
 }
 void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
-                                     MlirNamedAttribute *attributes) {
+                                     MlirNamedAttribute const *attributes) {
   APPEND_ELEMS(MlirNamedAttribute, nAttributes, attributes);
 }
 
 //===----------------------------------------------------------------------===//
 // Operation API.
 //===----------------------------------------------------------------------===//
 
 MlirOperation mlirOperationCreate(const MlirOperationState *state) {

 void mlirRegionDestroy(MlirRegion region) {
   delete static_cast<Region *>(region.ptr);
 }
 
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
-MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType *args) {
+MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args) {
   Block *b = new Block;
   for (intptr_t i = 0; i < nArgs; ++i)
     b->addArgument(unwrap(args[i]));
   return wrap(b);
 }
 
 int mlirBlockEqual(MlirBlock block, MlirBlock other) {
   return unwrap(block) == unwrap(other);

mlir/lib/CAPI/IR/StandardAttributes.cpp

 // Array attribute.
 //===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAArray(MlirAttribute attr) {
   return unwrap(attr).isa<ArrayAttr>();
 }
 
 MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
-                               MlirAttribute *elements) {
+                               MlirAttribute const *elements) {
   SmallVector<Attribute, 8> attrs;
   return wrap(ArrayAttr::get(
       unwrapList(static_cast<size_t>(numElements), elements, attrs),
       unwrap(ctx)));
 }
 
 intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr) {
   return static_cast<intptr_t>(unwrap(attr).cast<ArrayAttr>().size());
 }
 
 MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos) {
   return wrap(unwrap(attr).cast<ArrayAttr>().getValue()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Dictionary attribute.
 //===----------------------------------------------------------------------===//
 
 int mlirAttributeIsADictionary(MlirAttribute attr) {
   return unwrap(attr).isa<DictionaryAttr>();
 }
 
 MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
-                                    MlirNamedAttribute *elements) {
+                                    MlirNamedAttribute const *elements) {
   SmallVector<NamedAttribute, 8> attributes;
   attributes.reserve(numElements);
   for (intptr_t i = 0; i < numElements; ++i)
     attributes.emplace_back(Identifier::get(elements[i].name, unwrap(ctx)),
                             unwrap(elements[i].attribute));
   return wrap(DictionaryAttr::get(attributes, unwrap(ctx)));
 }
 

 //===----------------------------------------------------------------------===//
 
 int mlirAttributeIsASymbolRef(MlirAttribute attr) {
   return unwrap(attr).isa<SymbolRefAttr>();
 }
 
 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length,
                                    const char *symbol, intptr_t numReferences,
-                                   MlirAttribute *references) {
+                                   MlirAttribute const *references) {
   SmallVector<FlatSymbolRefAttr, 4> refs;
   refs.reserve(numReferences);
   for (intptr_t i = 0; i < numReferences; ++i)
     refs.push_back(unwrap(references[i]).cast<FlatSymbolRefAttr>());
   return wrap(SymbolRefAttr::get(StringRef(symbol, length), refs, unwrap(ctx)));
 }
 
 MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr) {
int mlirAttributeIsADenseFPElements(MlirAttribute attr) {
   return unwrap(attr).isa<DenseFPElementsAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // Constructors.
 
 MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
                                        intptr_t numElements,
-                                       MlirAttribute *elements) {
+                                       MlirAttribute const *elements) {
   SmallVector<Attribute, 8> attributes;
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                              unwrapList(numElements, elements, attributes)));
 }
 
 MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
                                             MlirAttribute element) {

 MlirAttribute mlirDenseElementsAttrDoubleGet(MlirType shapedType,
                                              intptr_t numElements,
                                              const double *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 
 MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
                                              intptr_t numElements,
-                                             intptr_t *strLengths,
+                                             intptr_t const *strLengths,
                                              const char **strs) {
   SmallVector<StringRef, 8> values;
   values.reserve(numElements);
   for (intptr_t i = 0; i < numElements; ++i)
     values.push_back(StringRef(strs[i], strLengths[i]));
 
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));

mlir/lib/CAPI/IR/StandardTypes.cpp

 
 //===----------------------------------------------------------------------===//
 // 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 *affineMaps,
+                           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));
 }
 

 
 //===----------------------------------------------------------------------===//
 // Tuple type.
 //===----------------------------------------------------------------------===//
 
 int mlirTypeIsATuple(MlirType type) { return unwrap(type).isa<TupleType>(); }
 
 MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
-                          MlirType *elements) {
+                          MlirType const *elements) {
   SmallVector<Type, 4> types;
   ArrayRef<Type> typeRef = unwrapList(numElements, elements, types);
   return wrap(TupleType::get(typeRef, unwrap(ctx)));
 }
 
 intptr_t mlirTupleTypeGetNumTypes(MlirType type) {
   return unwrap(type).cast<TupleType>().size();
 }
 
 MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos) {
   return wrap(unwrap(type).cast<TupleType>().getType(static_cast<size_t>(pos)));
 }
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 int mlirTypeIsAFunction(MlirType type) {
   return unwrap(type).isa<FunctionType>();
 }
 
 MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
-                             MlirType *inputs, intptr_t numResults,
-                             MlirType *results) {
+                             MlirType const *inputs, intptr_t numResults,
+                             MlirType const *results) {
   SmallVector<Type, 4> inputsList;
   SmallVector<Type, 4> resultsList;
   (void)unwrapList(numInputs, inputs, inputsList);
   (void)unwrapList(numResults, results, resultsList);
   return wrap(FunctionType::get(inputsList, resultsList, unwrap(ctx)));
 }
 
 intptr_t mlirFunctionTypeGetNumInputs(MlirType type) {