IRDL-to-C++

[hhkit]

Scaffolding work for IRDL-to-C++. Draft PR because it's still WIP, but put this up for my own tracking.

When the following minimal code snippet compiles, this draft will be ready for review.

module {
  irdl.dialect @testd {
    irdl.type @singleton
  
    irdl.operation @any {
      %0 = irdl.any
      irdl.results(%0)
    }
  }
}

[hhkit]

/*===- IRDL to C++ Generated file -------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Dialect Declarations                                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GEN_DIALECT_DECL_HEADER
#undef GEN_DIALECT_DECL_HEADER

namespace mlir {
namespace testd {

class TestdDialect : public ::mlir::Dialect {
  explicit TestdDialect(::mlir::MLIRContext *context);

  void initialize();
  friend class ::mlir::MLIRContext;

public:
  ~TestdDialect() override;
  static constexpr ::llvm::StringLiteral getDialectNamespace() {
    return ::llvm::StringLiteral("testd");
  }

  /// Parse an attribute registered to this dialect.
  ::mlir::Attribute parseAttribute(::mlir::DialectAsmParser &parser,
                                   ::mlir::Type type) const override;

  /// Print an attribute registered to this dialect.
  void printAttribute(::mlir::Attribute attr,
                      ::mlir::DialectAsmPrinter &os) const override;

  /// Parse a type registered to this dialect.
  ::mlir::Type parseType(::mlir::DialectAsmParser &parser) const override;

  /// Print a type registered to this dialect.
  void printType(::mlir::Type type,
                 ::mlir::DialectAsmPrinter &os) const override;
};

} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::TestdDialect)

namespace mlir {
namespace testd {

class TestdType : public ::mlir::Type {
public:
  using Type::Type;

  static bool classof(Type type);
};

class SingletonType : public ::mlir::Type::TypeBase<SingletonType, TestdType, ::mlir::TypeStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "testd.singleton";
  static constexpr ::llvm::StringLiteral dialectName = "testd";
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"singleton"};
  }
};
} // namespace mlir
} // namespace testd
#endif // GEN_DIALECT_DECL_HEADER
#ifdef GEN_DIALECT_DEF
#undef GEN_DIALECT_DEF

MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::testd::TestdDialect)
namespace mlir {
namespace testd {

TestdDialect::TestdDialect(::mlir::MLIRContext *context)
    : ::mlir::Dialect(getDialectNamespace(), context, ::mlir::TypeID::get<TestdDialect>())
{
  initialize();
}

TestdDialect::~TestdDialect() = default;
} // namespace mlir
} // namespace testd

namespace mlir {
namespace testd {

bool TestdType::classof(Type type) {
  return llvm::isa<TestdDialect>(type.getDialect());
}
} // namespace mlir
} // namespace testd
#endif // GEN_DIALECT_DEF

[hhkit]

/*===- IRDL to C++ Generated file -------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Dialect Declarations                                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GEN_DIALECT_DECL_HEADER
#undef GEN_DIALECT_DECL_HEADER

namespace mlir {
namespace testd {

class TestdDialect : public ::mlir::Dialect {
  explicit TestdDialect(::mlir::MLIRContext *context);

  void initialize();
  friend class ::mlir::MLIRContext;

public:
  ~TestdDialect() override;
  static constexpr ::llvm::StringLiteral getDialectNamespace() {
    return ::llvm::StringLiteral("testd");
  }

  /// Parse an attribute registered to this dialect.
  ::mlir::Attribute parseAttribute(::mlir::DialectAsmParser &parser,
                                   ::mlir::Type type) const override;

  /// Print an attribute registered to this dialect.
  void printAttribute(::mlir::Attribute attr,
                      ::mlir::DialectAsmPrinter &os) const override;

  /// Parse a type registered to this dialect.
  ::mlir::Type parseType(::mlir::DialectAsmParser &parser) const override;

  /// Print a type registered to this dialect.
  void printType(::mlir::Type type,
                 ::mlir::DialectAsmPrinter &os) const override;
};

} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::TestdDialect)


namespace mlir {
namespace testd {


class TestdType : public ::mlir::Type {
public:
  using Type::Type;

  static bool classof(Type type);
};

} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::TestdType)


namespace mlir {
namespace testd {


class SingletonType : public ::mlir::Type::TypeBase<SingletonType, TestdType, ::mlir::TypeStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "testd.singleton";
  static constexpr ::llvm::StringLiteral dialectName = "testd";
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"singleton"};
  }
};

} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::SingletonType)

namespace mlir {
namespace testd {


namespace detail {
class AnyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AnyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = {}, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
      odsOpName.emplace("testd.any", odsAttrs.getContext());
  }

  AnyOpGenericAdaptorBase(::mlir::Operation *op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), odsRegions(op->getRegions()) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes() {
    return odsAttrs;
  }

};
} // namespace detail

template <typename RangeT>
class AnyOpGenericAdaptor : public detail::AnyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AnyOpGenericAdaptorBase;
public:
  AnyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = {}, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AnyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AnyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  AnyOpGenericAdaptor(RangeT values, const AnyOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}

  template <typename LateInst = AnyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AnyOp>>>
  AnyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  RangeT getArgs() {
    return getODSOperands(0);
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};

class AnyOpAdaptor : public AnyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AnyOpGenericAdaptor::AnyOpGenericAdaptor;
  AnyOpAdaptor(AnyOp op);

  ::llvm::LogicalResult verify(::mlir::Location loc);
};

class AnyOp : public ::mlir::Op<AnyOp> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AnyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AnyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("testd.any");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return {index, 0};
  }
  ::mlir::Operation::operand_range getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(getOperation()->operand_begin(), valueRange.first),
             std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
  }

  ::mlir::Operation::operand_range getArgs() {
    return getODSOperands(0);
  }

  ::mlir::MutableOperandRange getArgsMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
    return {index, 1};
  }

  ::mlir::Operation::result_range getODSResults(unsigned index) {
    auto valueRange = getODSResultIndexAndLength(index);
    return {std::next(getOperation()->result_begin(), valueRange.first),
             std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
  }

  ::mlir::TypedValue<::mlir::irdl::AttributeType> getOutput() {
    return ::llvm::cast<::mlir::TypedValue<::mlir::irdl::AttributeType>>(*getODSResults(0).begin());
  }

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::ValueRange args);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  ::llvm::LogicalResult verifyInvariantsImpl();
  ::llvm::LogicalResult verifyInvariants();
  std::unique_ptr<::mlir::irdl::Constraint> getVerifier(::mlir::ArrayRef<Value> valueToConstr, ::mlir::DenseMap<::mlir::irdl::TypeOp,
          std::unique_ptr<::mlir::DynamicTypeDefinition>> const&types, ::mlir::DenseMap<::mlir::irdl::AttributeOp,
          std::unique_ptr<::mlir::DynamicAttrDefinition>> const&attrs);
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &_odsPrinter);
public:
};


} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::AnyOp)

#endif // GEN_DIALECT_DECL_HEADER
#ifdef GEN_DIALECT_DEF
#undef GEN_DIALECT_DEF

MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::testd::TestdDialect)
namespace mlir {
namespace testd {

TestdDialect::TestdDialect(::mlir::MLIRContext *context)
    : ::mlir::Dialect(getDialectNamespace(), context, ::mlir::TypeID::get<TestdDialect>())
{
  initialize();
}

TestdDialect::~TestdDialect() = default;
} // namespace mlir
} // namespace testd

namespace mlir {
namespace testd {

bool TestdType::classof(Type type) {
  return llvm::isa<TestdDialect>(type.getDialect());
}
} // namespace mlir
} // namespace testd
#endif // GEN_DIALECT_DEF

[hhkit]

current output, will work on ops tonight!

/*===- IRDL to C++ Generated file -------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Dialect Declarations                                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GEN_DIALECT_DECL_HEADER
#undef GEN_DIALECT_DECL_HEADER

namespace mlir {
namespace testd {

class TestdDialect : public ::mlir::Dialect {
  explicit TestdDialect(::mlir::MLIRContext *context);

  void initialize();
  friend class ::mlir::MLIRContext;

public:
  ~TestdDialect() override;
  static constexpr ::llvm::StringLiteral getDialectNamespace() {
    return ::llvm::StringLiteral("testd");
  }

  /// Parse an attribute registered to this dialect.
  ::mlir::Attribute parseAttribute(::mlir::DialectAsmParser &parser,
                                   ::mlir::Type type) const override;

  /// Print an attribute registered to this dialect.
  void printAttribute(::mlir::Attribute attr,
                      ::mlir::DialectAsmPrinter &os) const override;

  /// Parse a type registered to this dialect.
  ::mlir::Type parseType(::mlir::DialectAsmParser &parser) const override;

  /// Print a type registered to this dialect.
  void printType(::mlir::Type type,
                 ::mlir::DialectAsmPrinter &os) const override;
};

} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::TestdDialect)


namespace mlir {
namespace testd {


class TestdType : public ::mlir::Type {
public:
  using Type::Type;

  static bool classof(Type type);
};

} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::TestdType)


namespace mlir {
namespace testd {


class SingletonType : public ::mlir::Type::TypeBase<SingletonType, TestdType, ::mlir::TypeStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "testd.singleton";
  static constexpr ::llvm::StringLiteral dialectName = "testd";
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"singleton"};
  }
};

} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::SingletonType)

namespace mlir {
namespace testd {


namespace detail {
class AnyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AnyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = {}, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
      odsOpName.emplace("testd.any", odsAttrs.getContext());
  }

  AnyOpGenericAdaptorBase(::mlir::Operation *op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), odsRegions(op->getRegions()) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes() {
    return odsAttrs;
  }

};
} // namespace detail

template <typename RangeT>
class AnyOpGenericAdaptor : public detail::AnyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AnyOpGenericAdaptorBase;
public:
  AnyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = {}, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AnyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AnyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  AnyOpGenericAdaptor(RangeT values, const AnyOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}

  template <typename LateInst = AnyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AnyOp>>>
  AnyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  RangeT getArgs() {
    return getODSOperands(0);
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};

class AnyOpAdaptor : public AnyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AnyOpGenericAdaptor::AnyOpGenericAdaptor;
  AnyOpAdaptor(AnyOp op);

  ::llvm::LogicalResult verify(::mlir::Location loc);
};

class AnyOp : public ::mlir::Op<AnyOp> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AnyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AnyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("testd.any");
  }

  static ::llvm::ArrayRef<::llvm::StringRef> getOperandNames() {
    static ::llvm::StringRef operandNames[] = {"in1", "in2"};
    return operandNames;
  }

  static ::llvm::StringRef getOperandName(unsigned index) {
    assert(index < 2 && "invalid attribute index");
    return getOperandNames()[index];
  }

  static ::llvm::ArrayRef<::llvm::StringRef> getResultNames() {
    static ::llvm::StringRef resultNames[] = {"out1"};
    return resultNames;
  }

  static ::llvm::StringRef getResultName(unsigned index) {
    assert(index < 1 && "invalid attribute index");
    return getResultNames()[index];
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return {index, 2};
  }
  ::mlir::Operation::operand_range getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(getOperation()->operand_begin(), valueRange.first),
             std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
  }

  ::mlir::Operation::operand_range getArgs() {
    return getODSOperands(0);
  }

  ::mlir::MutableOperandRange getArgsMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
    return {index, 1};
  }

  ::mlir::Operation::result_range getODSResults(unsigned index) {
    auto valueRange = getODSResultIndexAndLength(index);
    return {std::next(getOperation()->result_begin(), valueRange.first),
             std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
  }

  ::mlir::TypedValue<::mlir::irdl::AttributeType> getOutput() {
    return ::llvm::cast<::mlir::TypedValue<::mlir::irdl::AttributeType>>(*getODSResults(0).begin());
  }

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::ValueRange args);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  ::llvm::LogicalResult verifyInvariantsImpl();
  ::llvm::LogicalResult verifyInvariants();
  std::unique_ptr<::mlir::irdl::Constraint> getVerifier(::mlir::ArrayRef<Value> valueToConstr, ::mlir::DenseMap<::mlir::irdl::TypeOp,
          std::unique_ptr<::mlir::DynamicTypeDefinition>> const&types, ::mlir::DenseMap<::mlir::irdl::AttributeOp,
          std::unique_ptr<::mlir::DynamicAttrDefinition>> const&attrs);
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &_odsPrinter);
public:
};


} // namespace mlir
} // namespace testd


MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::testd::AnyOp)

#endif // GEN_DIALECT_DECL_HEADER
#ifdef GEN_DIALECT_DEF
#undef GEN_DIALECT_DEF

MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::testd::TestdDialect)
namespace mlir {
namespace testd {

TestdDialect::TestdDialect(::mlir::MLIRContext *context)
    : ::mlir::Dialect(getDialectNamespace(), context, ::mlir::TypeID::get<TestdDialect>())
{
  initialize();
}

TestdDialect::~TestdDialect() = default;
} // namespace mlir
} // namespace testd


namespace mlir {
namespace testd {


bool TestdType::classof(Type type) {
  return llvm::isa<TestdDialect>(type.getDialect());
}

} // namespace mlir
} // namespace testd


#ifdef GET_TYPEDEF_LIST
#undef GET_TYPEDEF_LIST

SingletonType

#endif  // GET_TYPEDEF_LIST


#ifdef GET_TYPEDEF_CLASSES
#undef GET_TYPEDEF_CLASSES

namespace mlir {
namespace testd {

static ::mlir::OptionalParseResult generatedTypeParser(::mlir::AsmParser &parser, ::llvm::StringRef *mnemonic, ::mlir::Type &value) {
  return ::mlir::AsmParser::KeywordSwitch<::mlir::OptionalParseResult>(parser)
    .Case(::mlir::testd::SingletonType::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::testd::SingletonType::get(parser.getContext());
      return ::mlir::success(!!value);
    })
    
    .Default([&](llvm::StringRef keyword, llvm::SMLoc) {
      *mnemonic = keyword;
      return std::nullopt;
    });
}

static ::llvm::LogicalResult generatedTypePrinter(::mlir::Type def, ::mlir::AsmPrinter &printer) {
  return ::llvm::TypeSwitch<::mlir::Type, ::llvm::LogicalResult>(def)
    .Case<::mlir::testd::SingletonType>([&](auto t) {
      printer << ::mlir::testd::SingletonType::getMnemonic();
      return ::mlir::success();
    })
    .Default([](auto) { return ::mlir::failure(); });
}

/// Parse a type registered to this dialect.
::mlir::Type TestdDialect::parseType(::mlir::DialectAsmParser &parser) const {
  ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
  ::llvm::StringRef mnemonic;
  ::mlir::Type genType;
  auto parseResult = generatedTypeParser(parser, &mnemonic, genType);
  if (parseResult.has_value())
    return genType;
  
  parser.emitError(typeLoc) << "unknown  type `"
      << mnemonic << "` in dialect `" << getNamespace() << "`";
  return {};
}
/// Print a type registered to this dialect.
void TestdDialect::printType(::mlir::Type type,
                    ::mlir::DialectAsmPrinter &printer) const {
  if (::mlir::succeeded(generatedTypePrinter(type, printer)))
    return;
  
}

} // namespace mlir
} // namespace testd

#endif // GET_TYPEDEF_CLASSES
#endif // GEN_DIALECT_DEF

[Moxinilian]

I was not notified for this and I wish I was. Excellent stuff!

[Moxinilian]

It's great to see this converging towards upstream quality!

[Moxinilian]

Conversion looks good!

[Moxinilian]

Don't forget to clear this TODO! There should be no more TODOs before this gets merged.

[hhkit]

I folded this into verifySupported. Probably will need a cleanup pass on isSnakeCase?

[Moxinilian]

Is that all the macro guards that are available?

[Moxinilian]

Do it the other way around, success if the operation is explicitly supported (and then check that the operands are constraints that you support, which you are not doing right now I believe).

[Moxinilian]

The reason I say this is because at some point I expect irdl.dialect will not be isolated from above anymore so SSA values could come from outside of it. This would hijack your checks.

[Moxinilian]

This is no bueno but we have to due to symbols. Once this PR is merged upstream I'll fix it myself.

[Moxinilian]

LGTM once comments are addressed

[Moxinilian]

Spacing is inconsistent 👉 👈

[Moxinilian]

I can't easily format on GitHub but I hope you get the gist.

Suggested change

	for (auto &elem : in) {
	if (elem == '_') {
	if (!allowUnderscore)
	return loc->emitError("name of ")
	<< label << " should not contain leading or double underscores";
	} else {
	if (!isalnum(elem))
	return loc->emitError("name of ")
	<< label
	<< " must contain only lowercase letters, digits and "
	"underscores";
	if (llvm::isUpper(elem))
	return loc->emitError("name of ")
	<< label << " should not contain uppercase letters";
	}
	allowUnderscore = elem != '_';
	}
	for (auto &elem : in) {
	if (elem == '_') {
	if (!allowUnderscore)
	return loc->emitError("name of ")
	<< label << " should not contain leading or double underscores";
	allowUnderscore = false;
	continue;
	}
	if (!isalnum(elem))
	return loc->emitError("name of ")
	<< label
	<< " must contain only lowercase letters, digits and "
	"underscores";
	if (llvm::isUpper(elem))
	return loc->emitError("name of ")
	<< label << " should not contain uppercase letters";
	allowUnderscore = true:
	}

[Moxinilian]

Can you add a newline between the two functions?

[Moxinilian]

SmallVec should be in the namespace already, it's so common that people don't use the llvm prefix typically.

[Moxinilian]

Same here for SmallVec.

[Moxinilian]

Rename getODSResults.

[Moxinilian]

Factor out in two functions.

[hhkit]

we are upstream