CallLikeOpInterfaces.h.inc

Go to the documentation of this file.

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Interface Declarations                                                     *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
namespace llzk {
 
class LLZKCallLikeOpInterface;
 
} // namespace llzk
namespace llzk {
 
namespace detail {
struct LLZKCallLikeOpInterfaceInterfaceTraits {
  struct Concept {
    ::mlir::Value (*getSelfValue)(const Concept *impl, ::mlir::Operation *);
    ::mlir::FunctionType (*getTypeSignature)(const Concept *impl, ::mlir::Operation *);
    ::mlir::FailureOr<::llzk::UnificationMap> (*unifyTypeSignatureWithNamespace)(const Concept *impl, ::mlir::Operation *, ::mlir::FunctionType, ::mlir::ArrayRef<::llvm::StringRef>);
    ::mlir::FailureOr<::llzk::UnificationMap> (*unifyTypeSignature)(const Concept *impl, ::mlir::Operation *, ::mlir::FunctionType);
    ::llvm::SmallVector<::mlir::ValueRange> (*toVectorOfValueRange)(::mlir::OperandRangeRange);
    ::mlir::LogicalResult (*verifyTemplateParamValueCompatibility)(const Concept *impl, ::mlir::Operation *, ::mlir::Attribute, ::llzk::polymorphic::TemplateParamOp);
    ::mlir::LogicalResult (*verifyTemplateParamValuesCompatibility)(const Concept *impl, ::mlir::Operation *, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>>);
    ::mlir::LogicalResult (*verifyTemplateParamsMatchInferred)(const Concept *impl, ::mlir::Operation *, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>>, const ::llzk::UnificationMap &);
    const ::mlir::ArgAndResultAttrsOpInterface::Concept *implArgAndResultAttrsOpInterface = nullptr;
    const ::mlir::CallOpInterface::Concept *implCallOpInterface = nullptr;
    const ::mlir::SymbolUserOpInterface::Concept *implSymbolUserOpInterface = nullptr;
 
    void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
      implArgAndResultAttrsOpInterface = interfaceMap.lookup<::mlir::ArgAndResultAttrsOpInterface>();
      assert(implArgAndResultAttrsOpInterface && "`::llzk::LLZKCallLikeOpInterface` expected its base interface `::mlir::ArgAndResultAttrsOpInterface` to be registered");
      implCallOpInterface = interfaceMap.lookup<::mlir::CallOpInterface>();
      assert(implCallOpInterface && "`::llzk::LLZKCallLikeOpInterface` expected its base interface `::mlir::CallOpInterface` to be registered");
      implSymbolUserOpInterface = interfaceMap.lookup<::mlir::SymbolUserOpInterface>();
      assert(implSymbolUserOpInterface && "`::llzk::LLZKCallLikeOpInterface` expected its base interface `::mlir::SymbolUserOpInterface` to be registered");
    }
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::LLZKCallLikeOpInterface;
    Model() : Concept{getSelfValue, getTypeSignature, unifyTypeSignatureWithNamespace, unifyTypeSignature, toVectorOfValueRange, verifyTemplateParamValueCompatibility, verifyTemplateParamValuesCompatibility, verifyTemplateParamsMatchInferred} {}
 
    static inline ::mlir::Value getSelfValue(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::FunctionType getTypeSignature(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignatureWithNamespace(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other, ::mlir::ArrayRef<::llvm::StringRef> rhsReversePrefix);
    static inline ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignature(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other);
    static inline ::llvm::SmallVector<::mlir::ValueRange> toVectorOfValueRange(::mlir::OperandRangeRange input);
    static inline ::mlir::LogicalResult verifyTemplateParamValueCompatibility(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::Attribute paramFromCallOp, ::llzk::polymorphic::TemplateParamOp targetParam);
    static inline ::mlir::LogicalResult verifyTemplateParamValuesCompatibility(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs);
    static inline ::mlir::LogicalResult verifyTemplateParamsMatchInferred(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs, const ::llzk::UnificationMap & unifications);
  };
  template<typename ConcreteOp>
  class FallbackModel : public Concept {
  public:
    using Interface = ::llzk::LLZKCallLikeOpInterface;
    FallbackModel() : Concept{getSelfValue, getTypeSignature, unifyTypeSignatureWithNamespace, unifyTypeSignature, toVectorOfValueRange, verifyTemplateParamValueCompatibility, verifyTemplateParamValuesCompatibility, verifyTemplateParamsMatchInferred} {}
 
    static inline ::mlir::Value getSelfValue(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::FunctionType getTypeSignature(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignatureWithNamespace(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other, ::mlir::ArrayRef<::llvm::StringRef> rhsReversePrefix);
    static inline ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignature(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other);
    static inline ::llvm::SmallVector<::mlir::ValueRange> toVectorOfValueRange(::mlir::OperandRangeRange input);
    static inline ::mlir::LogicalResult verifyTemplateParamValueCompatibility(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::Attribute paramFromCallOp, ::llzk::polymorphic::TemplateParamOp targetParam);
    static inline ::mlir::LogicalResult verifyTemplateParamValuesCompatibility(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs);
    static inline ::mlir::LogicalResult verifyTemplateParamsMatchInferred(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs, const ::llzk::UnificationMap & unifications);
  };
  template<typename ConcreteModel, typename ConcreteOp>
  class ExternalModel : public FallbackModel<ConcreteModel> {
  public:
    using ConcreteEntity = ConcreteOp;
    ::mlir::FunctionType getTypeSignature(::mlir::Operation *tablegen_opaque_val) const;
    ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignatureWithNamespace(::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other, ::mlir::ArrayRef<::llvm::StringRef> rhsReversePrefix) const;
    ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignature(::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other) const;
    static ::llvm::SmallVector<::mlir::ValueRange> toVectorOfValueRange(::mlir::OperandRangeRange input);
    ::mlir::LogicalResult verifyTemplateParamValueCompatibility(::mlir::Operation *tablegen_opaque_val, ::mlir::Attribute paramFromCallOp, ::llzk::polymorphic::TemplateParamOp targetParam) const;
    ::mlir::LogicalResult verifyTemplateParamValuesCompatibility(::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs) const;
    ::mlir::LogicalResult verifyTemplateParamsMatchInferred(::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs, const ::llzk::UnificationMap &unifications) const;
  };
};
template <typename ConcreteOp>
struct LLZKCallLikeOpInterfaceTrait;
 
} // namespace detail
class LLZKCallLikeOpInterface : public ::mlir::OpInterface<LLZKCallLikeOpInterface, detail::LLZKCallLikeOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<LLZKCallLikeOpInterface, detail::LLZKCallLikeOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::LLZKCallLikeOpInterfaceTrait<ConcreteOp> {};

  ::mlir::Value getSelfValue();

  ::mlir::FunctionType getTypeSignature();

  ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignatureWithNamespace(::mlir::FunctionType other, ::mlir::ArrayRef<::llvm::StringRef> rhsReversePrefix);

  ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignature(::mlir::FunctionType other);

  ::llvm::SmallVector<::mlir::ValueRange> toVectorOfValueRange(::mlir::OperandRangeRange input);

  ::mlir::LogicalResult verifyTemplateParamValueCompatibility(::mlir::Attribute paramFromCallOp, ::llzk::polymorphic::TemplateParamOp targetParam);

  ::mlir::LogicalResult verifyTemplateParamValuesCompatibility(::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs);

  ::mlir::LogicalResult verifyTemplateParamsMatchInferred(::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs, const ::llzk::UnificationMap & unifications);
  //===----------------------------------------------------------------===//
  // Inherited from ::mlir::ArgAndResultAttrsOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::mlir::ArgAndResultAttrsOpInterface () const {
    if (!*this) return nullptr;
    return ::mlir::ArgAndResultAttrsOpInterface(*this, getImpl()->implArgAndResultAttrsOpInterface);
  }
 

  ::mlir::ArrayAttr getArgAttrsAttr();

  ::mlir::ArrayAttr getResAttrsAttr();

  void setArgAttrsAttr(::mlir::ArrayAttr attrs);

  void setResAttrsAttr(::mlir::ArrayAttr attrs);

  ::mlir::Attribute removeArgAttrsAttr();

  ::mlir::Attribute removeResAttrsAttr();
  //===----------------------------------------------------------------===//
  // Inherited from ::mlir::CallOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::mlir::CallOpInterface () const {
    if (!*this) return nullptr;
    return ::mlir::CallOpInterface(*this, getImpl()->implCallOpInterface);
  }
 

  ::mlir::CallInterfaceCallable getCallableForCallee();

  void setCalleeFromCallable(::mlir::CallInterfaceCallable callee);

  ::mlir::Operation::operand_range getArgOperands();

  ::mlir::MutableOperandRange getArgOperandsMutable();

  ::mlir::Operation *resolveCallableInTable(::mlir::SymbolTableCollection * symbolTable);

  ::mlir::Operation *resolveCallable();
  //===----------------------------------------------------------------===//
  // Inherited from ::mlir::SymbolUserOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::mlir::SymbolUserOpInterface () const {
    if (!*this) return nullptr;
    return ::mlir::SymbolUserOpInterface(*this, getImpl()->implSymbolUserOpInterface);
  }
 

  ::llvm::LogicalResult verifySymbolUses(::mlir::SymbolTableCollection & symbolTable);
};
 
} // namespace llzk
namespace llzk::detail {
 
  template <typename ConcreteOp>
  struct LLZKCallLikeOpInterfaceTrait : public ::mlir::OpInterface<LLZKCallLikeOpInterface, detail::LLZKCallLikeOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {

    ::mlir::FunctionType getTypeSignature() {
      return ::mlir::FunctionType::get(
                                (*static_cast<ConcreteOp *>(this)).getContext(),
                                (*static_cast<ConcreteOp *>(this)).getArgOperands().getTypes(),
                                (*static_cast<ConcreteOp *>(this))->getResultTypes());
    }

    ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignatureWithNamespace(::mlir::FunctionType other, ::mlir::ArrayRef<::llvm::StringRef> rhsReversePrefix) {
      ::llzk::UnificationMap unifications;
                if (::llzk::functionTypesUnify((*static_cast<ConcreteOp *>(this)).getTypeSignature(), other, rhsReversePrefix, &unifications)) {
                    return unifications;
                } else {
                    return ::mlir::failure();
                }
    }

    ::mlir::FailureOr<::llzk::UnificationMap> unifyTypeSignature(::mlir::FunctionType other) {
      return (*static_cast<ConcreteOp *>(this)).unifyTypeSignatureWithNamespace(other, {});
    }

    static ::llvm::SmallVector<::mlir::ValueRange> toVectorOfValueRange(::mlir::OperandRangeRange input) {
      ::llvm::SmallVector<::mlir::ValueRange, 4> output;
                output.reserve(input.size());
                output.insert(output.end(), input.begin(), input.end());
                return output;
    }

    ::mlir::LogicalResult verifyTemplateParamValueCompatibility(::mlir::Attribute paramFromCallOp, ::llzk::polymorphic::TemplateParamOp targetParam) {
      return ::llzk::verifyTemplateParamValueCompatibility(
                    (*static_cast<ConcreteOp *>(this)).getOperation(), paramFromCallOp, targetParam);
    }

    ::mlir::LogicalResult verifyTemplateParamValuesCompatibility(::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs) {
      return ::llzk::verifyTemplateParamValuesCompatibility(
                    (*static_cast<ConcreteOp *>(this)).getOperation(), (*static_cast<ConcreteOp *>(this)).getTemplateParamsAttr(), targetParamDefs);
    }

    ::mlir::LogicalResult verifyTemplateParamsMatchInferred(::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs, const ::llzk::UnificationMap & unifications) {
      return ::llzk::verifyTemplateParamsMatchInferred(
                    (*static_cast<ConcreteOp *>(this)).getOperation(), (*static_cast<ConcreteOp *>(this)).getTemplateParamsAttr(), targetParamDefs, unifications);
    }
  };
 
} // namespace llzk::detail
namespace llzk {
 
template<typename ConcreteOp>
::mlir::Value detail::LLZKCallLikeOpInterfaceInterfaceTraits::Model<ConcreteOp>::getSelfValue(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getSelfValue();
}
template<typename ConcreteOp>
::mlir::FunctionType detail::LLZKCallLikeOpInterfaceInterfaceTraits::Model<ConcreteOp>::getTypeSignature(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getTypeSignature();
}
template<typename ConcreteOp>
::mlir::FailureOr<::llzk::UnificationMap> detail::LLZKCallLikeOpInterfaceInterfaceTraits::Model<ConcreteOp>::unifyTypeSignatureWithNamespace(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other, ::mlir::ArrayRef<::llvm::StringRef> rhsReversePrefix) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).unifyTypeSignatureWithNamespace(other, rhsReversePrefix);
}
template<typename ConcreteOp>
::mlir::FailureOr<::llzk::UnificationMap> detail::LLZKCallLikeOpInterfaceInterfaceTraits::Model<ConcreteOp>::unifyTypeSignature(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).unifyTypeSignature(other);
}
template<typename ConcreteOp>
::llvm::SmallVector<::mlir::ValueRange> detail::LLZKCallLikeOpInterfaceInterfaceTraits::Model<ConcreteOp>::toVectorOfValueRange(::mlir::OperandRangeRange input) {
  return ConcreteOp::toVectorOfValueRange(input);
}
template<typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::Model<ConcreteOp>::verifyTemplateParamValueCompatibility(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::Attribute paramFromCallOp, ::llzk::polymorphic::TemplateParamOp targetParam) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).verifyTemplateParamValueCompatibility(paramFromCallOp, targetParam);
}
template<typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::Model<ConcreteOp>::verifyTemplateParamValuesCompatibility(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).verifyTemplateParamValuesCompatibility(targetParamDefs);
}
template<typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::Model<ConcreteOp>::verifyTemplateParamsMatchInferred(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs, const ::llzk::UnificationMap & unifications) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).verifyTemplateParamsMatchInferred(targetParamDefs, unifications);
}
template<typename ConcreteOp>
::mlir::Value detail::LLZKCallLikeOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getSelfValue(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getSelfValue(tablegen_opaque_val);
}
template<typename ConcreteOp>
::mlir::FunctionType detail::LLZKCallLikeOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getTypeSignature(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getTypeSignature(tablegen_opaque_val);
}
template<typename ConcreteOp>
::mlir::FailureOr<::llzk::UnificationMap> detail::LLZKCallLikeOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::unifyTypeSignatureWithNamespace(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other, ::mlir::ArrayRef<::llvm::StringRef> rhsReversePrefix) {
  return static_cast<const ConcreteOp *>(impl)->unifyTypeSignatureWithNamespace(tablegen_opaque_val, other, rhsReversePrefix);
}
template<typename ConcreteOp>
::mlir::FailureOr<::llzk::UnificationMap> detail::LLZKCallLikeOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::unifyTypeSignature(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other) {
  return static_cast<const ConcreteOp *>(impl)->unifyTypeSignature(tablegen_opaque_val, other);
}
template<typename ConcreteOp>
::llvm::SmallVector<::mlir::ValueRange> detail::LLZKCallLikeOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::toVectorOfValueRange(::mlir::OperandRangeRange input) {
  return ConcreteOp::toVectorOfValueRange(input);
}
template<typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::verifyTemplateParamValueCompatibility(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::Attribute paramFromCallOp, ::llzk::polymorphic::TemplateParamOp targetParam) {
  return static_cast<const ConcreteOp *>(impl)->verifyTemplateParamValueCompatibility(tablegen_opaque_val, paramFromCallOp, targetParam);
}
template<typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::verifyTemplateParamValuesCompatibility(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs) {
  return static_cast<const ConcreteOp *>(impl)->verifyTemplateParamValuesCompatibility(tablegen_opaque_val, targetParamDefs);
}
template<typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::verifyTemplateParamsMatchInferred(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs, const ::llzk::UnificationMap & unifications) {
  return static_cast<const ConcreteOp *>(impl)->verifyTemplateParamsMatchInferred(tablegen_opaque_val, targetParamDefs, unifications);
}
template<typename ConcreteModel, typename ConcreteOp>
::mlir::FunctionType detail::LLZKCallLikeOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::getTypeSignature(::mlir::Operation *tablegen_opaque_val) const {
return ::mlir::FunctionType::get(
                                (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getContext(),
                                (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgOperands().getTypes(),
                                (llvm::cast<ConcreteOp>(tablegen_opaque_val))->getResultTypes());
}
template<typename ConcreteModel, typename ConcreteOp>
::mlir::FailureOr<::llzk::UnificationMap> detail::LLZKCallLikeOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::unifyTypeSignatureWithNamespace(::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other, ::mlir::ArrayRef<::llvm::StringRef> rhsReversePrefix) const {
::llzk::UnificationMap unifications;
                if (::llzk::functionTypesUnify((llvm::cast<ConcreteOp>(tablegen_opaque_val)).getTypeSignature(), other, rhsReversePrefix, &unifications)) {
                    return unifications;
                } else {
                    return ::mlir::failure();
                }
}
template<typename ConcreteModel, typename ConcreteOp>
::mlir::FailureOr<::llzk::UnificationMap> detail::LLZKCallLikeOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::unifyTypeSignature(::mlir::Operation *tablegen_opaque_val, ::mlir::FunctionType other) const {
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).unifyTypeSignatureWithNamespace(other, {});
}
template<typename ConcreteModel, typename ConcreteOp>
::llvm::SmallVector<::mlir::ValueRange> detail::LLZKCallLikeOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::toVectorOfValueRange(::mlir::OperandRangeRange input) {
::llvm::SmallVector<::mlir::ValueRange, 4> output;
                output.reserve(input.size());
                output.insert(output.end(), input.begin(), input.end());
                return output;
}
template<typename ConcreteModel, typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::verifyTemplateParamValueCompatibility(::mlir::Operation *tablegen_opaque_val, ::mlir::Attribute paramFromCallOp, ::llzk::polymorphic::TemplateParamOp targetParam) const {
return ::llzk::verifyTemplateParamValueCompatibility(
                    (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getOperation(), paramFromCallOp, targetParam);
}
template<typename ConcreteModel, typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::verifyTemplateParamValuesCompatibility(::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs) const {
return ::llzk::verifyTemplateParamValuesCompatibility(
                    (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getOperation(), (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getTemplateParamsAttr(), targetParamDefs);
}
template<typename ConcreteModel, typename ConcreteOp>
::mlir::LogicalResult detail::LLZKCallLikeOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::verifyTemplateParamsMatchInferred(::mlir::Operation *tablegen_opaque_val, ::llvm::iterator_range<::mlir::Region::op_iterator<::llzk::polymorphic::TemplateParamOp>> targetParamDefs, const ::llzk::UnificationMap &unifications) const {
return ::llzk::verifyTemplateParamsMatchInferred(
                    (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getOperation(), (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getTemplateParamsAttr(), targetParamDefs, unifications);
}
 
} // namespace llzk