[OM] Deprecate the OM Map and Tuple (#8606)

Remove the support for OM Map and Tuple. 
All the dependence on them have been removed.
---------

Co-authored-by: Mike Urbach <mikeurbach@gmail.com>

Author: prithayan

include/circt-c/Dialect/OM.h

@@ -61,12 +61,6 @@ MLIR_CAPI_EXPORTED MlirTypeID omListTypeGetTypeID(void);
 // Return a element type of a ListType.
 MLIR_CAPI_EXPORTED MlirType omListTypeGetElementType(MlirType type);
 
-/// Is the Type a MapType.
-MLIR_CAPI_EXPORTED bool omTypeIsAMapType(MlirType type);
-
-// Return a key type of a MapType.
-MLIR_CAPI_EXPORTED MlirType omMapTypeGetKeyType(MlirType type);
-
 /// Is the Type a StringType.
 MLIR_CAPI_EXPORTED bool omTypeIsAStringType(MlirType type);
 
@@ -187,31 +181,6 @@ omEvaluatorListGetNumElements(OMEvaluatorValue evaluatorValue);
 MLIR_CAPI_EXPORTED OMEvaluatorValue
 omEvaluatorListGetElement(OMEvaluatorValue evaluatorValue, intptr_t pos);
 
-/// Query if the EvaluatorValue is a Tuple.
-MLIR_CAPI_EXPORTED bool
-omEvaluatorValueIsATuple(OMEvaluatorValue evaluatorValue);
-
-/// Get the size of the tuple.
-MLIR_CAPI_EXPORTED intptr_t
-omEvaluatorTupleGetNumElements(OMEvaluatorValue evaluatorValue);
-
-/// Get an element of the tuple.
-MLIR_CAPI_EXPORTED OMEvaluatorValue
-omEvaluatorTupleGetElement(OMEvaluatorValue evaluatorValue, intptr_t pos);
-
-/// Get an element of the map.
-MLIR_CAPI_EXPORTED OMEvaluatorValue
-omEvaluatorMapGetElement(OMEvaluatorValue evaluatorValue, MlirAttribute attr);
-
-MLIR_CAPI_EXPORTED MlirAttribute omEvaluatorMapGetKeys(OMEvaluatorValue object);
-
-/// Query if the EvaluatorValue is a Map.
-MLIR_CAPI_EXPORTED bool omEvaluatorValueIsAMap(OMEvaluatorValue evaluatorValue);
-
-/// Get the Type from a Map, which will be a MapType.
-MLIR_CAPI_EXPORTED MlirType
-omEvaluatorMapGetType(OMEvaluatorValue evaluatorValue);
-
 /// Query if the EvaluatorValue is a BasePath.
 MLIR_CAPI_EXPORTED bool
 omEvaluatorValueIsABasePath(OMEvaluatorValue evaluatorValue);
@@ -275,20 +244,6 @@ MLIR_CAPI_EXPORTED MlirAttribute omListAttrGet(MlirType elementType,
                                                intptr_t numElements,
                                                const MlirAttribute *elements);
 
-//===----------------------------------------------------------------------===//
-// MapAttr API
-//===----------------------------------------------------------------------===//
-
-MLIR_CAPI_EXPORTED bool omAttrIsAMapAttr(MlirAttribute attr);
-
-MLIR_CAPI_EXPORTED intptr_t omMapAttrGetNumElements(MlirAttribute attr);
-
-MLIR_CAPI_EXPORTED MlirIdentifier omMapAttrGetElementKey(MlirAttribute attr,
-                                                         intptr_t pos);
-
-MLIR_CAPI_EXPORTED MlirAttribute omMapAttrGetElementValue(MlirAttribute attr,
-                                                          intptr_t pos);
-
 #ifdef __cplusplus
 }
 #endif

include/circt/Dialect/OM/Evaluator/Evaluator.h

@@ -47,7 +47,7 @@ using ObjectFields = SmallDenseMap<StringAttr, EvaluatorValuePtr>;
 /// the appropriate reference count.
 struct EvaluatorValue : std::enable_shared_from_this<EvaluatorValue> {
   // Implement LLVM RTTI.
-  enum class Kind { Attr, Object, List, Tuple, Map, Reference, BasePath, Path };
+  enum class Kind { Attr, Object, List, Reference, BasePath, Path };
   EvaluatorValue(MLIRContext *ctx, Kind kind, Location loc)
       : kind(kind), ctx(ctx), loc(loc) {}
   Kind getKind() const { return kind; }
@@ -224,44 +224,6 @@ struct ListValue : EvaluatorValue {
   SmallVector<EvaluatorValuePtr> elements;
 };
 
-/// A Map value.
-struct MapValue : EvaluatorValue {
-  MapValue(om::MapType type, DenseMap<Attribute, EvaluatorValuePtr> elements,
-           Location loc)
-      : EvaluatorValue(type.getContext(), Kind::Map, loc), type(type),
-        elements(std::move(elements)) {
-    markFullyEvaluated();
-  }
-
-  // Partially evaluated value.
-  MapValue(om::MapType type, Location loc)
-      : EvaluatorValue(type.getContext(), Kind::Map, loc), type(type) {}
-
-  const auto &getElements() const { return elements; }
-  void setElements(DenseMap<Attribute, EvaluatorValuePtr> newElements) {
-    elements = std::move(newElements);
-    markFullyEvaluated();
-  }
-
-  // Finalize the evaluator value.
-  LogicalResult finalizeImpl();
-
-  /// Return the type of the value, which is a MapType.
-  om::MapType getMapType() const { return type; }
-
-  /// Return an array of keys in the ascending order.
-  ArrayAttr getKeys();
-
-  /// Implement LLVM RTTI.
-  static bool classof(const EvaluatorValue *e) {
-    return e->getKind() == Kind::Map;
-  }
-
-private:
-  om::MapType type;
-  DenseMap<Attribute, EvaluatorValuePtr> elements;
-};
-
 /// A composite Object, which has a type and fields.
 struct ObjectValue : EvaluatorValue {
   ObjectValue(om::ClassOp cls, ObjectFields fields, Location loc)
@@ -313,46 +275,6 @@ struct ObjectValue : EvaluatorValue {
   llvm::SmallDenseMap<StringAttr, EvaluatorValuePtr> fields;
 };
 
-/// Tuple values.
-struct TupleValue : EvaluatorValue {
-  using TupleElements = llvm::SmallVector<EvaluatorValuePtr>;
-  TupleValue(TupleType type, TupleElements tupleElements, Location loc)
-      : EvaluatorValue(type.getContext(), Kind::Tuple, loc), type(type),
-        elements(std::move(tupleElements)) {
-    markFullyEvaluated();
-  }
-
-  // Partially evaluated value.
-  TupleValue(TupleType type, Location loc)
-      : EvaluatorValue(type.getContext(), Kind::Tuple, loc), type(type) {}
-
-  void setElements(TupleElements newElements) {
-    elements = std::move(newElements);
-    markFullyEvaluated();
-  }
-
-  LogicalResult finalizeImpl() {
-    for (auto &&value : elements)
-      if (failed(finalizeEvaluatorValue(value)))
-        return failure();
-
-    return success();
-  }
-  /// Implement LLVM RTTI.
-  static bool classof(const EvaluatorValue *e) {
-    return e->getKind() == Kind::Tuple;
-  }
-
-  /// Return the type of the value, which is a TupleType.
-  TupleType getTupleType() const { return type; }
-
-  const TupleElements &getElements() const { return elements; }
-
-private:
-  TupleType type;
-  TupleElements elements;
-};
-
 /// A Basepath value.
 struct BasePathValue : EvaluatorValue {
   BasePathValue(MLIRContext *context);
@@ -493,14 +415,6 @@ struct Evaluator {
   FailureOr<EvaluatorValuePtr> evaluateListConcat(ListConcatOp op,
                                                   ActualParameters actualParams,
                                                   Location loc);
-  FailureOr<EvaluatorValuePtr>
-  evaluateTupleCreate(TupleCreateOp op, ActualParameters actualParams,
-                      Location loc);
-  FailureOr<EvaluatorValuePtr>
-  evaluateTupleGet(TupleGetOp op, ActualParameters actualParams, Location loc);
-  FailureOr<evaluator::EvaluatorValuePtr>
-  evaluateMapCreate(MapCreateOp op, ActualParameters actualParams,
-                    Location loc);
   FailureOr<evaluator::EvaluatorValuePtr>
   evaluateBasePathCreate(FrozenBasePathCreateOp op,
                          ActualParameters actualParams, Location loc);
@@ -543,8 +457,6 @@ operator<<(mlir::Diagnostic &diag,
     diag << "Object(" << object->getType() << ")";
   else if (auto *list = llvm::dyn_cast<evaluator::ListValue>(&evaluatorValue))
     diag << "List(" << list->getType() << ")";
-  else if (auto *map = llvm::dyn_cast<evaluator::MapValue>(&evaluatorValue))
-    diag << "Map(" << map->getType() << ")";
   else if (llvm::isa<evaluator::BasePathValue>(&evaluatorValue))
     diag << "BasePath()";
   else if (llvm::isa<evaluator::PathValue>(&evaluatorValue))

include/circt/Dialect/OM/OMAttributes.td

@@ -81,28 +81,6 @@ def OMListAttr : AttrDef<OMDialect, "List", [TypedAttrInterface]> {
   }];
 }
 
-def MapAttr : AttrDef<OMDialect, "Map", [TypedAttrInterface]> {
-  let summary = "An attribute that represents a string map";
-
-  let mnemonic = "map";
-
-  let parameters = (ins
-    "mlir::Type": $valueType,
-    "mlir::DictionaryAttr":$elements
-  );
-
-  // TODO: Use custom assembly format to infer a type from elements.
-  let assemblyFormat = [{
-    `<` $valueType `,` $elements `>`
-  }];
-
-  let genVerifyDecl = 1;
-
-  let extraClassDeclaration = [{
-    mlir::Type getType();
-  }];
-}
-
 def OMPathAttr : AttrDef<OMDialect, "Path"> {
   let summary = "An attribute that represents an instance path";
 

include/circt/Dialect/OM/OMOps.td

@@ -280,94 +280,6 @@ def ListConcatOp : OMOp<"list_concat", [Pure, SameOperandsAndResultType]> {
   let assemblyFormat = "$subLists attr-dict `:` type($result)";
 }
 
-def TupleCreateOp : OMOp<"tuple_create", [Pure, InferTypeOpInterface]> {
-  let summary = "Create a tuple of values";
-  let description = [{
-    Create a tuple from a sequence of inputs.
-
-    ```
-    %tuple = om.tuple_create %a, %b, %c : !om.ref, !om.string, !om.list<i32>
-    ```
-  }];
-
-  let arguments = (ins Variadic<AnyType>:$inputs);
-  let results = (outs
-    TupleOf<[AnyType]>:$result
-  );
-
-  let assemblyFormat = [{
-    $inputs attr-dict `:` type($inputs)
-  }];
-
-  let extraClassDeclaration = [{
-    // Implement InferTypeOpInterface.
-    static ::mlir::LogicalResult inferReturnTypes(
-      ::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location,
-      ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
-      ::mlir::OpaqueProperties,
-      ::mlir::RegionRange regions,
-      ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes);
-   }];
-
-}
-
-def TupleGetOp : OMOp<"tuple_get", [Pure, InferTypeOpInterface]> {
-  let summary = "Extract a value from a tuple";
-  let description = [{
-    Extract a value from a tuple.
-
-    ```
-    %value = om.tuple_get %a[0] : tuple<!om.ref, !om.string, !om.list<i32>>
-    ```
-  }];
-
-  let arguments = (ins
-    TupleOf<[AnyType]>:$input,
-    I32Attr:$index
-  );
-
-  let results = (outs
-    AnyType:$result
-  );
-
-  let assemblyFormat = [{
-    $input `[` $index `]` attr-dict `:` type($input)
-  }];
-
-  let extraClassDeclaration = [{
-    // Implement InferTypeOpInterface.
-    static ::mlir::LogicalResult inferReturnTypes(
-      ::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location,
-      ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
-      ::mlir::OpaqueProperties, ::mlir::RegionRange regions,
-      ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes);
-   }];
-}
-
-def MapKeyValuePair: Type<CPred<"::circt::om::isMapKeyValuePairType($_self)">,
-                        "a pair whose first element is an attribute",
-                        "::mlir::TupleType">;
-
-def MapCreateOp : OMOp<"map_create", [Pure, SameTypeOperands]> {
-  let summary = "Create a map";
-  let description = [{
-    Creates a map from a sequence of inputs.
-
-    ```
-    %map = om.map_create %e1, %e2 : !om.string, i8
-    ```
-    where `%e1` and `e2` have !om.tuple<!om.string, i8> and
-    `%map` has `!om.map<!om.string, i8>` type.
-  }];
-
-  let arguments = (ins Variadic<MapKeyValuePair>:$inputs);
-  let results = (outs
-    MapType:$result
-  );
-
-  let hasCustomAssemblyFormat = true;
-}
-
 def BasePathCreateOp : OMOp<"basepath_create", [Pure,
       DeclareOpInterfaceMethods<SymbolUserOpInterface>
     ]> {

include/circt/Dialect/OM/OMTypes.h

@@ -16,12 +16,7 @@
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Types.h"
 
-namespace circt::om {
-// Return true if the type is a pair whose first element is either string or
-// integer.
-bool isMapKeyValuePairType(mlir::Type);
-
-} // namespace circt::om
+namespace circt::om {} // namespace circt::om
 
 #define GET_TYPEDEF_CLASSES
 #include "circt/Dialect/OM/OMTypes.h.inc"

include/circt/Dialect/OM/OMTypes.td

@@ -51,25 +51,6 @@ def ListType : TypeDef<OMDialect, "List", []> {
   ];
 }
 
-def MapType : TypeDef<OMDialect, "Map", []> {
-  let summary = [{A type that represents a map. A key type must be either
-                  an integer or string type}];
-
-  let mnemonic = "map";
-  let parameters = (ins "mlir::Type": $keyType, "mlir::Type":$valueType);
-  let assemblyFormat = [{
-    `<` $keyType `,` $valueType `>`
-  }];
-
-  let builders = [
-    AttrBuilderWithInferredContext<(ins "::mlir::Type":$keyType, "::mlir::Type":$valueType), [{
-      return $_get(keyType.getContext(), keyType, valueType);
-    }]>
-  ];
-
-  let genVerifyDecl = 1;
-}
-
 def SymbolRefType : TypeDef<OMDialect, "SymbolRef", []> {
   let summary = "A type that represents a reference to a flat symbol reference.";