llvm/mlir/include/mlir/Dialect/IRDL/IRDLVerifiers.h

//===- IRDLVerifiers.h - IRDL verifiers --------------------------- 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
//
//===----------------------------------------------------------------------===//
//
// Verifiers for objects declared by IRDL.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_DIALECT_IRDL_IRDLVERIFIERS_H
#define MLIR_DIALECT_IRDL_IRDLVERIFIERS_H

#include "mlir/IR/Attributes.h"
#include "mlir/IR/Region.h"
#include "mlir/Support/LLVM.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include <optional>

namespace mlir {
class InFlightDiagnostic;
class DynamicAttrDefinition;
class DynamicTypeDefinition;
} // namespace mlir

namespace mlir {
namespace irdl {

class AttributeOp;
class Constraint;
class OperationOp;
class TypeOp;

/// Provides context to the verification of constraints.
/// It contains the assignment of variables to attributes, and the assignment
/// of variables to constraints.
class ConstraintVerifier { … };

/// Once turned into IRDL verifiers, all constraints are
/// attribute constraints. Type constraints are represented
/// as `TypeAttr` attribute constraints to simplify verification.
/// Verification that a type constraint must yield a
/// `TypeAttr` attribute happens before conversion, at the MLIR level.
class Constraint { … };

/// A constraint that checks that an attribute is equal to a given attribute.
class IsConstraint : public Constraint { … };

/// A constraint that checks that an attribute is of a given attribute base
/// (e.g. IntegerAttr).
class BaseAttrConstraint : public Constraint { … };

/// A constraint that checks that a type is of a given type base (e.g.
/// IntegerType).
class BaseTypeConstraint : public Constraint { … };

/// A constraint that checks that an attribute is of a
/// specific dynamic attribute definition, and that all of its parameters
/// satisfy the given constraints.
class DynParametricAttrConstraint : public Constraint { … };

/// A constraint that checks that a type is of a specific dynamic type
/// definition, and that all of its parameters satisfy the given constraints.
class DynParametricTypeConstraint : public Constraint { … };

/// A constraint checking that one of the given constraints is satisfied.
class AnyOfConstraint : public Constraint { … };

/// A constraint checking that all of the given constraints are satisfied.
class AllOfConstraint : public Constraint { … };

/// A constraint that is always satisfied.
class AnyAttributeConstraint : public Constraint { … };

/// A constraint checking that a region satisfies `irdl.region` requirements
struct RegionConstraint { … };

/// Generate an op verifier function from the given IRDL operation definition.
llvm::unique_function<LogicalResult(Operation *) const> createVerifier(
    OperationOp operation,
    const DenseMap<irdl::TypeOp, std::unique_ptr<DynamicTypeDefinition>>
        &typeDefs,
    const DenseMap<irdl::AttributeOp, std::unique_ptr<DynamicAttrDefinition>>
        &attrDefs);
} // namespace irdl
} // namespace mlir

#endif // MLIR_DIALECT_IRDL_IRDLVERIFIERS_H