(void)std::initializer_list<int>{0, (addType<Args>(), 0)...};
}
+ /// Register a type instance with this dialect.
+ /// The use of this method is in general discouraged in favor of
+ /// 'addTypes<CustomType>()'.
+ void addType(TypeID typeID, AbstractType &&typeInfo);
+
/// Register a set of attribute classes with this dialect.
template <typename... Args> void addAttributes() {
(void)std::initializer_list<int>{0, (addAttribute<Args>(), 0)...};
addType(T::getTypeID(), AbstractType::get<T>(*this));
detail::TypeUniquer::registerType<T>(context);
}
- void addType(TypeID typeID, AbstractType &&typeInfo);
/// The namespace of this dialect.
StringRef name;
T::getHasTraitFn());
}
-private:
+ /// Register a new operation in a Dialect object.
+ /// The use of this method is in general discouraged in favor of
+ /// 'insert<CustomOp>(dialect)'.
static void insert(StringRef name, Dialect &dialect, TypeID typeID,
ParseAssemblyFn parseAssembly,
PrintAssemblyFn printAssembly,
GetCanonicalizationPatternsFn getCanonicalizationPatterns,
detail::InterfaceMap &&interfaceMap, HasTraitFn hasTrait);
+private:
AbstractOperation(StringRef name, Dialect &dialect, TypeID typeID,
ParseAssemblyFn parseAssembly,
PrintAssemblyFn printAssembly,
return AbstractType(dialect, T::getInterfaceMap(), T::getTypeID());
}
+ /// This method is used by Dialect objects to register types with
+ /// custom TypeIDs.
+ /// The use of this method is in general discouraged in favor of
+ /// 'get<CustomType>(dialect)';
+ static AbstractType get(Dialect &dialect, detail::InterfaceMap &&interfaceMap,
+ TypeID typeID) {
+ return AbstractType(dialect, std::move(interfaceMap), typeID);
+ }
+
/// Return the dialect this type was registered to.
Dialect &getDialect() const { return const_cast<Dialect &>(dialect); }
/// Returns true if the interface map contains an interface for the given id.
bool contains(TypeID interfaceID) const { return lookup(interfaceID); }
+ /// Create an InterfaceMap given with the implementation of the interfaces.
+ /// The use of this constructor is in general discouraged in favor of
+ /// 'InterfaceMap::get<InterfaceA, ...>()'.
+ InterfaceMap(MutableArrayRef<std::pair<TypeID, void *>> elements)
+ : interfaces(elements.begin(), elements.end()) {
+ llvm::sort(interfaces, [](const auto &lhs, const auto &rhs) {
+ return compare(lhs.first, rhs.first);
+ });
+ }
+
private:
/// Compare two TypeID instances by comparing the underlying pointer.
static bool compare(TypeID lhs, TypeID rhs) {
}
InterfaceMap() = default;
- InterfaceMap(MutableArrayRef<std::pair<TypeID, void *>> elements)
- : interfaces(elements.begin(), elements.end()) {
- llvm::sort(interfaces, [](const auto &lhs, const auto &rhs) {
- return compare(lhs.first, rhs.first);
- });
- }
template <typename... Ts>
static InterfaceMap getImpl(std::tuple<Ts...> *) {