OpInterfaces.h.inc

Go to the documentation of this file.

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Interface Declarations                                                     *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
namespace llzk {
namespace polymorphic {
class TemplateSymbolBindingOpInterface;
namespace detail {
struct TemplateSymbolBindingOpInterfaceInterfaceTraits {
  struct Concept {
    ::std::optional<::mlir::Type> (*getTypeOpt)(const Concept *impl, ::mlir::Operation *);
    const ::mlir::SymbolOpInterface::Concept *implSymbolOpInterface = nullptr;
 
    void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
      implSymbolOpInterface = interfaceMap.lookup<::mlir::SymbolOpInterface>();
      assert(implSymbolOpInterface && "`::llzk::polymorphic::TemplateSymbolBindingOpInterface` expected its base interface `::mlir::SymbolOpInterface` to be registered");
    }
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::polymorphic::TemplateSymbolBindingOpInterface;
    Model() : Concept{getTypeOpt} {}
 
    static inline ::std::optional<::mlir::Type> getTypeOpt(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteOp>
  class FallbackModel : public Concept {
  public:
    using Interface = ::llzk::polymorphic::TemplateSymbolBindingOpInterface;
    FallbackModel() : Concept{getTypeOpt} {}
 
    static inline ::std::optional<::mlir::Type> getTypeOpt(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteModel, typename ConcreteOp>
  class ExternalModel : public FallbackModel<ConcreteModel> {
  public:
    using ConcreteEntity = ConcreteOp;
  };
};
template <typename ConcreteOp>
struct TemplateSymbolBindingOpInterfaceTrait;
 
} // namespace detail
class TemplateSymbolBindingOpInterface : public ::mlir::OpInterface<TemplateSymbolBindingOpInterface, detail::TemplateSymbolBindingOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<TemplateSymbolBindingOpInterface, detail::TemplateSymbolBindingOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::TemplateSymbolBindingOpInterfaceTrait<ConcreteOp> {};
  ::std::optional<::mlir::Type> getTypeOpt();
  //===----------------------------------------------------------------===//
  // Inherited from ::mlir::SymbolOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::mlir::SymbolOpInterface () const {
    if (!*this) return nullptr;
    return ::mlir::SymbolOpInterface(*this, getImpl()->implSymbolOpInterface);
  }

  ::mlir::StringAttr getNameAttr();
  void setName(::mlir::StringAttr name);
  mlir::SymbolTable::Visibility getVisibility();
  bool isNested();
  bool isPrivate();
  bool isPublic();
  void setVisibility(mlir::SymbolTable::Visibility vis);
  void setNested();
  void setPrivate();
  void setPublic();
  ::std::optional<::mlir::SymbolTable::UseRange> getSymbolUses(::mlir::Operation * from);
  bool symbolKnownUseEmpty(::mlir::Operation * from);
  ::llvm::LogicalResult replaceAllSymbolUses(::mlir::StringAttr newSymbol, ::mlir::Operation * from);
  bool isOptionalSymbol();
  bool canDiscardOnUseEmpty();
  bool isDeclaration();
 
    using Visibility = mlir::SymbolTable::Visibility;

    ::mlir::StringRef getName() {
      return getNameAttr().getValue();
    }

    void setName(::mlir::StringRef name) {
      setName(::mlir::StringAttr::get((*this)->getContext(), name));
    }
};
namespace detail {
  template <typename ConcreteOp>
  struct TemplateSymbolBindingOpInterfaceTrait : public ::mlir::OpInterface<TemplateSymbolBindingOpInterface, detail::TemplateSymbolBindingOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
  };
}// namespace detail
} // namespace polymorphic
} // namespace llzk
namespace llzk {
namespace polymorphic {
template<typename ConcreteOp>
::std::optional<::mlir::Type> detail::TemplateSymbolBindingOpInterfaceInterfaceTraits::Model<ConcreteOp>::getTypeOpt(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getTypeOpt();
}
template<typename ConcreteOp>
::std::optional<::mlir::Type> detail::TemplateSymbolBindingOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getTypeOpt(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getTypeOpt(tablegen_opaque_val);
}
} // namespace polymorphic
} // namespace llzk