mlir/lib/Dialect/IRDL/IR/IRDL.cpp - llvm-project - Git at Google

 //===- IRDL.cpp - IRDL dialect ----------------------------------*- C++ -*-===//
 //
 // This file is licensed under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "mlir/Dialect/IRDL/IR/IRDL.h"
 #include "mlir/Dialect/IRDL/IRDLSymbols.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Casting.h"

 using namespace mlir;
 using namespace mlir::irdl;

 //===----------------------------------------------------------------------===//
 // IRDL dialect.
 //===----------------------------------------------------------------------===//

 #include "mlir/Dialect/IRDL/IR/IRDL.cpp.inc"

 #include "mlir/Dialect/IRDL/IR/IRDLDialect.cpp.inc"

 void IRDLDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/IRDL/IR/IRDLOps.cpp.inc"
       >();
   addTypes<
 #define GET_TYPEDEF_LIST
 #include "mlir/Dialect/IRDL/IR/IRDLTypesGen.cpp.inc"
       >();
   addAttributes<
 #define GET_ATTRDEF_LIST
 #include "mlir/Dialect/IRDL/IR/IRDLAttributes.cpp.inc"
       >();
 }

 //===----------------------------------------------------------------------===//
 // Parsing/Printing/Verifying
 //===----------------------------------------------------------------------===//

 /// Parse a region, and add a single block if the region is empty.
 /// If no region is parsed, create a new region with a single empty block.
 static ParseResult parseSingleBlockRegion(OpAsmParser &p, Region &region) {
   auto regionParseRes = p.parseOptionalRegion(region);
   if (regionParseRes.has_value() && failed(regionParseRes.value()))
     return failure();

   // If the region is empty, add a single empty block.
   if (region.empty())
     region.push_back(new Block());

   return success();
 }

 static void printSingleBlockRegion(OpAsmPrinter &p, Operation *op,
                                    Region &region) {
   if (!region.getBlocks().front().empty())
     p.printRegion(region);
 }

 LogicalResult DialectOp::verify() {
   if (!Dialect::isValidNamespace(getName()))
     return emitOpError("invalid dialect name");
   return success();
 }

 LogicalResult OperationOp::verifyRegions() {
   // Stores pairs of value kinds and the list of names of values of this kind in
   // the operation.
   SmallVector<std::tuple<StringRef, llvm::SmallDenseSet<StringRef>>> valueNames;

   auto insertNames = [&](StringRef kind, ArrayAttr names) {
     llvm::SmallDenseSet<StringRef> nameSet;
     nameSet.reserve(names.size());
     for (auto name : names)
       nameSet.insert(llvm::cast<StringAttr>(name).getValue());
     valueNames.emplace_back(kind, std::move(nameSet));
   };

   for (Operation &op : getBody().getOps()) {
     TypeSwitch<Operation *>(&op)
         .Case<OperandsOp>(
             [&](OperandsOp op) { insertNames("operands", op.getNames()); })
         .Case<ResultsOp>(
             [&](ResultsOp op) { insertNames("results", op.getNames()); })
         .Case<RegionsOp>(
             [&](RegionsOp op) { insertNames("regions", op.getNames()); });
   }

   // Verify that no two operand, result or region share the same name.
   // The absence of duplicates within each value kind is checked by the
   // associated operation's verifier.
   for (size_t i : llvm::seq(valueNames.size())) {
     for (size_t j : llvm::seq(i + 1, valueNames.size())) {
       auto [lhs, lhsSet] = valueNames[i];
       auto &[rhs, rhsSet] = valueNames[j];
       llvm::set_intersect(lhsSet, rhsSet);
       if (!lhsSet.empty())
         return emitOpError("contains a value named '")
                << *lhsSet.begin() << "' for both its " << lhs << " and " << rhs;
     }
   }

   return success();
 }

 static LogicalResult verifyNames(Operation *op, StringRef kindName,
                                  ArrayAttr names, size_t numOperands) {
   if (numOperands != names.size())
     return op->emitOpError()
            << "the number of " << kindName
            << "s and their names must be "
               "the same, but got "
            << numOperands << " and " << names.size() << " respectively";

   DenseMap<StringRef, size_t> nameMap;
   for (auto [i, name] : llvm::enumerate(names)) {
     StringRef nameRef = llvm::cast<StringAttr>(name).getValue();
     if (nameRef.empty())
       return op->emitOpError()
              << "name of " << kindName << " #" << i << " is empty";
     if (!llvm::isAlpha(nameRef[0]) && nameRef[0] != '_')
       return op->emitOpError()
              << "name of " << kindName << " #" << i
              << " must start with either a letter or an underscore";
     if (llvm::any_of(nameRef,
                      [](char c) { return !llvm::isAlnum(c) && c != '_'; }))
       return op->emitOpError()
              << "name of " << kindName << " #" << i
              << " must contain only letters, digits and underscores";
     if (nameMap.contains(nameRef))
       return op->emitOpError() << "name of " << kindName << " #" << i
                                << " is a duplicate of the name of " << kindName
                                << " #" << nameMap[nameRef];
     nameMap.insert({nameRef, i});
   }

   return success();
 }

 LogicalResult ParametersOp::verify() {
   return verifyNames(*this, "parameter", getNames(), getNumOperands());
 }

 template <typename ValueListOp>
 static LogicalResult verifyOperandsResultsCommon(ValueListOp op,
                                                  StringRef kindName) {
   size_t numVariadicities = op.getVariadicity().size();
   size_t numOperands = op.getNumOperands();

   if (numOperands != numVariadicities)
     return op.emitOpError()
            << "the number of " << kindName
            << "s and their variadicities must be "
               "the same, but got "
            << numOperands << " and " << numVariadicities << " respectively";

   return verifyNames(op, kindName, op.getNames(), numOperands);
 }

 LogicalResult OperandsOp::verify() {
   return verifyOperandsResultsCommon(*this, "operand");
 }

 LogicalResult ResultsOp::verify() {
   return verifyOperandsResultsCommon(*this, "result");
 }

 LogicalResult AttributesOp::verify() {
   size_t namesSize = getAttributeValueNames().size();
   size_t valuesSize = getAttributeValues().size();

   if (namesSize != valuesSize)
     return emitOpError()
            << "the number of attribute names and their constraints must be "
               "the same but got "
            << namesSize << " and " << valuesSize << " respectively";

   return success();
 }

 LogicalResult BaseOp::verify() {
   std::optional<StringRef> baseName = getBaseName();
   std::optional<SymbolRefAttr> baseRef = getBaseRef();
   if (baseName.has_value() == baseRef.has_value())
     return emitOpError() << "the base type or attribute should be specified by "
                             "either a name or a reference";

   if (baseName &&
       (baseName->empty() || ((*baseName)[0] != '!' && (*baseName)[0] != '#')))
     return emitOpError() << "the base type or attribute name should start with "
                             "'!' or '#'";

   return success();
 }

 /// Finds whether the provided symbol is an IRDL type or attribute definition.
 /// The source operation must be within a DialectOp.
 static LogicalResult
 checkSymbolIsTypeOrAttribute(SymbolTableCollection &symbolTable,
                              Operation *source, SymbolRefAttr symbol) {
   Operation *targetOp =
       irdl::lookupSymbolNearDialect(symbolTable, source, symbol);

   if (!targetOp)
     return source->emitOpError() << "symbol '" << symbol << "' not found";

   if (!isa<TypeOp, AttributeOp>(targetOp))
     return source->emitOpError() << "symbol '" << symbol
                                  << "' does not refer to a type or attribute "
                                     "definition (refers to '"
                                  << targetOp->getName() << "')";

   return success();
 }

 LogicalResult BaseOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   std::optional<SymbolRefAttr> baseRef = getBaseRef();
   if (!baseRef)
     return success();

   return checkSymbolIsTypeOrAttribute(symbolTable, *this, *baseRef);
 }

 LogicalResult
 ParametricOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   std::optional<SymbolRefAttr> baseRef = getBaseType();
   if (!baseRef)
     return success();

   return checkSymbolIsTypeOrAttribute(symbolTable, *this, *baseRef);
 }

 /// Parse a value with its variadicity first. By default, the variadicity is
 /// single.
 ///
 /// value-with-variadicity ::= ("single" | "optional" | "variadic")? ssa-value
 static ParseResult
 parseValueWithVariadicity(OpAsmParser &p,
                           OpAsmParser::UnresolvedOperand &operand,
                           VariadicityAttr &variadicityAttr) {
   MLIRContext *ctx = p.getBuilder().getContext();

   // Parse the variadicity, if present
   if (p.parseOptionalKeyword("single").succeeded()) {
     variadicityAttr = VariadicityAttr::get(ctx, Variadicity::single);
   } else if (p.parseOptionalKeyword("optional").succeeded()) {
     variadicityAttr = VariadicityAttr::get(ctx, Variadicity::optional);
   } else if (p.parseOptionalKeyword("variadic").succeeded()) {
     variadicityAttr = VariadicityAttr::get(ctx, Variadicity::variadic);
   } else {
     variadicityAttr = VariadicityAttr::get(ctx, Variadicity::single);
   }

   // Parse the value
   if (p.parseOperand(operand))
     return failure();
   return success();
 }

 static ParseResult parseNamedValueListImpl(
     OpAsmParser &p, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
     ArrayAttr &valueNamesAttr, VariadicityArrayAttr *variadicityAttr) {
   Builder &builder = p.getBuilder();
   MLIRContext *ctx = builder.getContext();
   SmallVector<Attribute> valueNames;
   SmallVector<VariadicityAttr> variadicities;

   // Parse a single value with its variadicity
   auto parseOne = [&] {
     StringRef name;
     OpAsmParser::UnresolvedOperand operand;
     VariadicityAttr variadicity;
     if (p.parseKeyword(&name) || p.parseColon())
       return failure();

     if (variadicityAttr) {
       if (parseValueWithVariadicity(p, operand, variadicity))
         return failure();
       variadicities.push_back(variadicity);
     } else {
       if (p.parseOperand(operand))
         return failure();
     }

     valueNames.push_back(StringAttr::get(ctx, name));
     operands.push_back(operand);
     return success();
   };

   if (p.parseCommaSeparatedList(OpAsmParser::Delimiter::Paren, parseOne))
     return failure();
   valueNamesAttr = ArrayAttr::get(ctx, valueNames);
   if (variadicityAttr)
     *variadicityAttr = VariadicityArrayAttr::get(ctx, variadicities);
   return success();
 }

 /// Parse a list of named values.
 ///
 /// values ::=
 ///   `(` (named-value (`,` named-value)*)? `)`
 /// named-value := bare-id `:` ssa-value
 static ParseResult
 parseNamedValueList(OpAsmParser &p,
                     SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
                     ArrayAttr &valueNamesAttr) {
   return parseNamedValueListImpl(p, operands, valueNamesAttr, nullptr);
 }

 /// Parse a list of named values with their variadicities first. By default, the
 /// variadicity is single.
 ///
 /// values-with-variadicity ::=
 ///   `(` (value-with-variadicity (`,` value-with-variadicity)*)? `)`
 /// value-with-variadicity
 ///   ::= bare-id `:` ("single" | "optional" | "variadic")? ssa-value
 static ParseResult parseNamedValueListWithVariadicity(
     OpAsmParser &p, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
     ArrayAttr &valueNamesAttr, VariadicityArrayAttr &variadicityAttr) {
   return parseNamedValueListImpl(p, operands, valueNamesAttr, &variadicityAttr);
 }

 static void printNamedValueListImpl(OpAsmPrinter &p, Operation *op,
                                     OperandRange operands,
                                     ArrayAttr valueNamesAttr,
                                     VariadicityArrayAttr variadicityAttr) {
   p << "(";
   interleaveComma(llvm::seq<int>(0, operands.size()), p, [&](int i) {
     p << llvm::cast<StringAttr>(valueNamesAttr[i]).getValue() << ": ";
     if (variadicityAttr) {
       Variadicity variadicity = variadicityAttr[i].getValue();
       if (variadicity != Variadicity::single) {
         p << stringifyVariadicity(variadicity) << " ";
       }
     }
     p << operands[i];
   });
   p << ")";
 }

 /// Print a list of named values.
 ///
 /// values ::=
 ///   `(` (named-value (`,` named-value)*)? `)`
 /// named-value := bare-id `:` ssa-value
 static void printNamedValueList(OpAsmPrinter &p, Operation *op,
                                 OperandRange operands,
                                 ArrayAttr valueNamesAttr) {
   printNamedValueListImpl(p, op, operands, valueNamesAttr, nullptr);
 }

 /// Print a list of named values with their variadicities first. By default, the
 /// variadicity is single.
 ///
 /// values-with-variadicity ::=
 ///   `(` (value-with-variadicity (`,` value-with-variadicity)*)? `)`
 /// value-with-variadicity ::=
 ///   bare-id `:` ("single" | "optional" | "variadic")? ssa-value
 static void printNamedValueListWithVariadicity(
     OpAsmPrinter &p, Operation *op, OperandRange operands,
     ArrayAttr valueNamesAttr, VariadicityArrayAttr variadicityAttr) {
   printNamedValueListImpl(p, op, operands, valueNamesAttr, variadicityAttr);
 }

 static ParseResult
 parseAttributesOp(OpAsmParser &p,
                   SmallVectorImpl<OpAsmParser::UnresolvedOperand> &attrOperands,
                   ArrayAttr &attrNamesAttr) {
   Builder &builder = p.getBuilder();
   SmallVector<Attribute> attrNames;
   if (succeeded(p.parseOptionalLBrace())) {
     auto parseOperands = [&]() {
       if (p.parseAttribute(attrNames.emplace_back()) || p.parseEqual() ||
           p.parseOperand(attrOperands.emplace_back()))
         return failure();
       return success();
     };
     if (p.parseCommaSeparatedList(parseOperands) || p.parseRBrace())
       return failure();
   }
   attrNamesAttr = builder.getArrayAttr(attrNames);
   return success();
 }

 static void printAttributesOp(OpAsmPrinter &p, AttributesOp op,
                               OperandRange attrArgs, ArrayAttr attrNames) {
   if (attrNames.empty())
     return;
   p << "{";
   interleaveComma(llvm::seq<int>(0, attrNames.size()), p,
                   [&](int i) { p << attrNames[i] << " = " << attrArgs[i]; });
   p << '}';
 }

 LogicalResult RegionOp::verify() {
   if (IntegerAttr numberOfBlocks = getNumberOfBlocksAttr())
     if (int64_t number = numberOfBlocks.getInt(); number <= 0) {
       return emitOpError("the number of blocks is expected to be >= 1 but got ")
              << number;
     }
   return success();
 }

 LogicalResult RegionsOp::verify() {
   return verifyNames(*this, "region", getNames(), getNumOperands());
 }

 #include "mlir/Dialect/IRDL/IR/IRDLInterfaces.cpp.inc"

 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/IRDL/IR/IRDLTypesGen.cpp.inc"

 #include "mlir/Dialect/IRDL/IR/IRDLEnums.cpp.inc"

 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/IRDL/IR/IRDLAttributes.cpp.inc"

 #define GET_OP_CLASSES
 #include "mlir/Dialect/IRDL/IR/IRDLOps.cpp.inc"
	//===- IRDL.cpp - IRDL dialect ----------------------------------- C++ --===//
	//
	// This file is licensed under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "mlir/Dialect/IRDL/IR/IRDL.h"
	#include "mlir/Dialect/IRDL/IRDLSymbols.h"
	#include "mlir/IR/Builders.h"
	#include "mlir/IR/BuiltinAttributes.h"
	#include "mlir/IR/Diagnostics.h"
	#include "mlir/IR/DialectImplementation.h"
	#include "mlir/IR/ExtensibleDialect.h"
	#include "mlir/IR/OpDefinition.h"
	#include "mlir/IR/OpImplementation.h"
	#include "mlir/IR/Operation.h"
	#include "mlir/Support/LLVM.h"
	#include "llvm/ADT/STLExtras.h"
	#include "llvm/ADT/SetOperations.h"
	#include "llvm/ADT/SmallString.h"
	#include "llvm/ADT/StringExtras.h"
	#include "llvm/ADT/TypeSwitch.h"
	#include "llvm/IR/Metadata.h"
	#include "llvm/Support/Casting.h"

	using namespace mlir;
	using namespace mlir::irdl;

	//===----------------------------------------------------------------------===//
	// IRDL dialect.
	//===----------------------------------------------------------------------===//

	#include "mlir/Dialect/IRDL/IR/IRDL.cpp.inc"

	#include "mlir/Dialect/IRDL/IR/IRDLDialect.cpp.inc"

	void IRDLDialect::initialize() {
	addOperations<
	#define GET_OP_LIST
	#include "mlir/Dialect/IRDL/IR/IRDLOps.cpp.inc"
	>();
	addTypes<
	#define GET_TYPEDEF_LIST
	#include "mlir/Dialect/IRDL/IR/IRDLTypesGen.cpp.inc"
	>();
	addAttributes<
	#define GET_ATTRDEF_LIST
	#include "mlir/Dialect/IRDL/IR/IRDLAttributes.cpp.inc"
	>();
	}

	//===----------------------------------------------------------------------===//
	// Parsing/Printing/Verifying
	//===----------------------------------------------------------------------===//

	/// Parse a region, and add a single block if the region is empty.
	/// If no region is parsed, create a new region with a single empty block.
	static ParseResult parseSingleBlockRegion(OpAsmParser &p, Region &region) {
	auto regionParseRes = p.parseOptionalRegion(region);
	if (regionParseRes.has_value() && failed(regionParseRes.value()))
	return failure();

	// If the region is empty, add a single empty block.
	if (region.empty())
	region.push_back(new Block());

	return success();
	}

	static void printSingleBlockRegion(OpAsmPrinter &p, Operation *op,
	Region &region) {
	if (!region.getBlocks().front().empty())
	p.printRegion(region);
	}

	LogicalResult DialectOp::verify() {
	if (!Dialect::isValidNamespace(getName()))
	return emitOpError("invalid dialect name");
	return success();
	}

	LogicalResult OperationOp::verifyRegions() {
	// Stores pairs of value kinds and the list of names of values of this kind in
	// the operation.
	SmallVector<std::tuple<StringRef, llvm::SmallDenseSet<StringRef>>> valueNames;

	auto insertNames = [&](StringRef kind, ArrayAttr names) {
	llvm::SmallDenseSet<StringRef> nameSet;
	nameSet.reserve(names.size());
	for (auto name : names)
	nameSet.insert(llvm::cast<StringAttr>(name).getValue());
	valueNames.emplace_back(kind, std::move(nameSet));
	};

	for (Operation &op : getBody().getOps()) {
	TypeSwitch<Operation *>(&op)
	.Case<OperandsOp>(
	[&](OperandsOp op) { insertNames("operands", op.getNames()); })
	.Case<ResultsOp>(
	[&](ResultsOp op) { insertNames("results", op.getNames()); })
	.Case<RegionsOp>(
	[&](RegionsOp op) { insertNames("regions", op.getNames()); });
	}

	// Verify that no two operand, result or region share the same name.
	// The absence of duplicates within each value kind is checked by the
	// associated operation's verifier.
	for (size_t i : llvm::seq(valueNames.size())) {
	for (size_t j : llvm::seq(i + 1, valueNames.size())) {
	auto [lhs, lhsSet] = valueNames[i];
	auto &[rhs, rhsSet] = valueNames[j];
	llvm::set_intersect(lhsSet, rhsSet);
	if (!lhsSet.empty())
	return emitOpError("contains a value named '")
	<< *lhsSet.begin() << "' for both its " << lhs << " and " << rhs;
	}
	}

	return success();
	}

	static LogicalResult verifyNames(Operation *op, StringRef kindName,
	ArrayAttr names, size_t numOperands) {
	if (numOperands != names.size())
	return op->emitOpError()
	<< "the number of " << kindName
	<< "s and their names must be "
	"the same, but got "
	<< numOperands << " and " << names.size() << " respectively";

	DenseMap<StringRef, size_t> nameMap;
	for (auto [i, name] : llvm::enumerate(names)) {
	StringRef nameRef = llvm::cast<StringAttr>(name).getValue();
	if (nameRef.empty())
	return op->emitOpError()
	<< "name of " << kindName << " #" << i << " is empty";
	if (!llvm::isAlpha(nameRef[0]) && nameRef[0] != '_')
	return op->emitOpError()
	<< "name of " << kindName << " #" << i
	<< " must start with either a letter or an underscore";
	if (llvm::any_of(nameRef,
	[](char c) { return !llvm::isAlnum(c) && c != '_'; }))
	return op->emitOpError()
	<< "name of " << kindName << " #" << i
	<< " must contain only letters, digits and underscores";
	if (nameMap.contains(nameRef))
	return op->emitOpError() << "name of " << kindName << " #" << i
	<< " is a duplicate of the name of " << kindName
	<< " #" << nameMap[nameRef];
	nameMap.insert({nameRef, i});
	}

	return success();
	}

	LogicalResult ParametersOp::verify() {
	return verifyNames(*this, "parameter", getNames(), getNumOperands());
	}

	template <typename ValueListOp>
	static LogicalResult verifyOperandsResultsCommon(ValueListOp op,
	StringRef kindName) {
	size_t numVariadicities = op.getVariadicity().size();
	size_t numOperands = op.getNumOperands();

	if (numOperands != numVariadicities)
	return op.emitOpError()
	<< "the number of " << kindName
	<< "s and their variadicities must be "
	"the same, but got "
	<< numOperands << " and " << numVariadicities << " respectively";

	return verifyNames(op, kindName, op.getNames(), numOperands);
	}

	LogicalResult OperandsOp::verify() {
	return verifyOperandsResultsCommon(*this, "operand");
	}

	LogicalResult ResultsOp::verify() {
	return verifyOperandsResultsCommon(*this, "result");
	}

	LogicalResult AttributesOp::verify() {
	size_t namesSize = getAttributeValueNames().size();
	size_t valuesSize = getAttributeValues().size();

	if (namesSize != valuesSize)
	return emitOpError()
	<< "the number of attribute names and their constraints must be "
	"the same but got "
	<< namesSize << " and " << valuesSize << " respectively";

	return success();
	}

	LogicalResult BaseOp::verify() {
	std::optional<StringRef> baseName = getBaseName();
	std::optional<SymbolRefAttr> baseRef = getBaseRef();
	if (baseName.has_value() == baseRef.has_value())
	return emitOpError() << "the base type or attribute should be specified by "
	"either a name or a reference";

	if (baseName &&
	(baseName->empty() \|\| ((baseName)[0] != '!' && (baseName)[0] != '#')))
	return emitOpError() << "the base type or attribute name should start with "
	"'!' or '#'";

	return success();
	}

	/// Finds whether the provided symbol is an IRDL type or attribute definition.
	/// The source operation must be within a DialectOp.
	static LogicalResult
	checkSymbolIsTypeOrAttribute(SymbolTableCollection &symbolTable,
	Operation *source, SymbolRefAttr symbol) {
	Operation *targetOp =
	irdl::lookupSymbolNearDialect(symbolTable, source, symbol);

	if (!targetOp)
	return source->emitOpError() << "symbol '" << symbol << "' not found";

	if (!isa<TypeOp, AttributeOp>(targetOp))
	return source->emitOpError() << "symbol '" << symbol
	<< "' does not refer to a type or attribute "
	"definition (refers to '"
	<< targetOp->getName() << "')";

	return success();
	}

	LogicalResult BaseOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
	std::optional<SymbolRefAttr> baseRef = getBaseRef();
	if (!baseRef)
	return success();

	return checkSymbolIsTypeOrAttribute(symbolTable, this, baseRef);
	}

	LogicalResult
	ParametricOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
	std::optional<SymbolRefAttr> baseRef = getBaseType();
	if (!baseRef)
	return success();

	return checkSymbolIsTypeOrAttribute(symbolTable, this, baseRef);
	}

	/// Parse a value with its variadicity first. By default, the variadicity is
	/// single.
	///
	/// value-with-variadicity ::= ("single" \| "optional" \| "variadic")? ssa-value
	static ParseResult
	parseValueWithVariadicity(OpAsmParser &p,
	OpAsmParser::UnresolvedOperand &operand,
	VariadicityAttr &variadicityAttr) {
	MLIRContext *ctx = p.getBuilder().getContext();

	// Parse the variadicity, if present
	if (p.parseOptionalKeyword("single").succeeded()) {
	variadicityAttr = VariadicityAttr::get(ctx, Variadicity::single);
	} else if (p.parseOptionalKeyword("optional").succeeded()) {
	variadicityAttr = VariadicityAttr::get(ctx, Variadicity::optional);
	} else if (p.parseOptionalKeyword("variadic").succeeded()) {
	variadicityAttr = VariadicityAttr::get(ctx, Variadicity::variadic);
	} else {
	variadicityAttr = VariadicityAttr::get(ctx, Variadicity::single);
	}

	// Parse the value
	if (p.parseOperand(operand))
	return failure();
	return success();
	}

	static ParseResult parseNamedValueListImpl(
	OpAsmParser &p, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
	ArrayAttr &valueNamesAttr, VariadicityArrayAttr *variadicityAttr) {
	Builder &builder = p.getBuilder();
	MLIRContext *ctx = builder.getContext();
	SmallVector<Attribute> valueNames;
	SmallVector<VariadicityAttr> variadicities;

	// Parse a single value with its variadicity
	auto parseOne = [&] {
	StringRef name;
	OpAsmParser::UnresolvedOperand operand;
	VariadicityAttr variadicity;
	if (p.parseKeyword(&name) \|\| p.parseColon())
	return failure();

	if (variadicityAttr) {
	if (parseValueWithVariadicity(p, operand, variadicity))
	return failure();
	variadicities.push_back(variadicity);
	} else {
	if (p.parseOperand(operand))
	return failure();
	}

	valueNames.push_back(StringAttr::get(ctx, name));
	operands.push_back(operand);
	return success();
	};

	if (p.parseCommaSeparatedList(OpAsmParser::Delimiter::Paren, parseOne))
	return failure();
	valueNamesAttr = ArrayAttr::get(ctx, valueNames);
	if (variadicityAttr)
	*variadicityAttr = VariadicityArrayAttr::get(ctx, variadicities);
	return success();
	}

	/// Parse a list of named values.
	///
	/// values ::=
	/// `(` (named-value (`,` named-value)*)? `)`
	/// named-value := bare-id `:` ssa-value
	static ParseResult
	parseNamedValueList(OpAsmParser &p,
	SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
	ArrayAttr &valueNamesAttr) {
	return parseNamedValueListImpl(p, operands, valueNamesAttr, nullptr);
	}

	/// Parse a list of named values with their variadicities first. By default, the
	/// variadicity is single.
	///
	/// values-with-variadicity ::=
	/// `(` (value-with-variadicity (`,` value-with-variadicity)*)? `)`
	/// value-with-variadicity
	/// ::= bare-id `:` ("single" \| "optional" \| "variadic")? ssa-value
	static ParseResult parseNamedValueListWithVariadicity(
	OpAsmParser &p, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
	ArrayAttr &valueNamesAttr, VariadicityArrayAttr &variadicityAttr) {
	return parseNamedValueListImpl(p, operands, valueNamesAttr, &variadicityAttr);
	}

	static void printNamedValueListImpl(OpAsmPrinter &p, Operation *op,
	OperandRange operands,
	ArrayAttr valueNamesAttr,
	VariadicityArrayAttr variadicityAttr) {
	p << "(";
	interleaveComma(llvm::seq<int>(0, operands.size()), p, [&](int i) {
	p << llvm::cast<StringAttr>(valueNamesAttr[i]).getValue() << ": ";
	if (variadicityAttr) {
	Variadicity variadicity = variadicityAttr[i].getValue();
	if (variadicity != Variadicity::single) {
	p << stringifyVariadicity(variadicity) << " ";
	}
	}
	p << operands[i];
	});
	p << ")";
	}

	/// Print a list of named values.
	///
	/// values ::=
	/// `(` (named-value (`,` named-value)*)? `)`
	/// named-value := bare-id `:` ssa-value
	static void printNamedValueList(OpAsmPrinter &p, Operation *op,
	OperandRange operands,
	ArrayAttr valueNamesAttr) {
	printNamedValueListImpl(p, op, operands, valueNamesAttr, nullptr);
	}

	/// Print a list of named values with their variadicities first. By default, the
	/// variadicity is single.
	///
	/// values-with-variadicity ::=
	/// `(` (value-with-variadicity (`,` value-with-variadicity)*)? `)`
	/// value-with-variadicity ::=
	/// bare-id `:` ("single" \| "optional" \| "variadic")? ssa-value
	static void printNamedValueListWithVariadicity(
	OpAsmPrinter &p, Operation *op, OperandRange operands,
	ArrayAttr valueNamesAttr, VariadicityArrayAttr variadicityAttr) {
	printNamedValueListImpl(p, op, operands, valueNamesAttr, variadicityAttr);
	}

	static ParseResult
	parseAttributesOp(OpAsmParser &p,
	SmallVectorImpl<OpAsmParser::UnresolvedOperand> &attrOperands,
	ArrayAttr &attrNamesAttr) {
	Builder &builder = p.getBuilder();
	SmallVector<Attribute> attrNames;
	if (succeeded(p.parseOptionalLBrace())) {
	auto parseOperands = [&]() {
	if (p.parseAttribute(attrNames.emplace_back()) \|\| p.parseEqual() \|\|
	p.parseOperand(attrOperands.emplace_back()))
	return failure();
	return success();
	};
	if (p.parseCommaSeparatedList(parseOperands) \|\| p.parseRBrace())
	return failure();
	}
	attrNamesAttr = builder.getArrayAttr(attrNames);
	return success();
	}

	static void printAttributesOp(OpAsmPrinter &p, AttributesOp op,
	OperandRange attrArgs, ArrayAttr attrNames) {
	if (attrNames.empty())
	return;
	p << "{";
	interleaveComma(llvm::seq<int>(0, attrNames.size()), p,
	[&](int i) { p << attrNames[i] << " = " << attrArgs[i]; });
	p << '}';
	}

	LogicalResult RegionOp::verify() {
	if (IntegerAttr numberOfBlocks = getNumberOfBlocksAttr())
	if (int64_t number = numberOfBlocks.getInt(); number <= 0) {
	return emitOpError("the number of blocks is expected to be >= 1 but got ")
	<< number;
	}
	return success();
	}

	LogicalResult RegionsOp::verify() {
	return verifyNames(*this, "region", getNames(), getNumOperands());
	}

	#include "mlir/Dialect/IRDL/IR/IRDLInterfaces.cpp.inc"

	#define GET_TYPEDEF_CLASSES
	#include "mlir/Dialect/IRDL/IR/IRDLTypesGen.cpp.inc"

	#include "mlir/Dialect/IRDL/IR/IRDLEnums.cpp.inc"

	#define GET_ATTRDEF_CLASSES
	#include "mlir/Dialect/IRDL/IR/IRDLAttributes.cpp.inc"

	#define GET_OP_CLASSES
	#include "mlir/Dialect/IRDL/IR/IRDLOps.cpp.inc"