Types.td

Go to the documentation of this file.

//===-- Types.td -------------------------------------------*- tablegen -*-===//
//
// Part of the LLZK Project, under the Apache License v2.0.
// See LICENSE.txt for license information.
// Copyright 2025 Veridise Inc.
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
 
#ifndef LLZK_STRUCT_TYPES
#define LLZK_STRUCT_TYPES
 
include "llzk/Dialect/Shared/Types.td"
include "llzk/Dialect/Struct/IR/Dialect.td"
 
include "mlir/IR/AttrTypeBase.td"
include "mlir/IR/BuiltinTypes.td"
include "mlir/Interfaces/MemorySlotInterfaces.td"
include "mlir/IR/BuiltinTypeInterfaces.td"
 
class StructDialectType<string name, string typeMnemonic,
                        list<Trait> traits = []>
    : TypeDef<StructDialect, name, traits> {
  let mnemonic = typeMnemonic;
}
 
def LLZK_StructType : StructDialectType<"Struct", "type"> {
  let summary = "circuit component";
  let description = [{
    Type of a `struct` op instance. Struct values are identity-bearing, pointer-like
    handles to mutable component instances rather than bags of member values. Copying
    a struct value copies the handle and preserves the identity of the referenced
    component; it does not duplicate the component's members, signals, or tables.
 
    For structs that contain template parameters,
    the type must contain a list of attributes that instantiate the template
    parameters, one per parameter. Each attribute must be one of the following:
      - IntegerAttr (with IndexType), specifying a fixed parameter value; the
        wildcard (`?`) is not allowed
      - SymbolRefAttr, specifying a parameter value defined by a struct parameter
        or global constant
      - AffineMapAttr, for an array of struct elements whose template parameters
        vary based on some fixed pattern.
      - TypeAttr, for specifying a type parameter.
 
    ```llzk
    // Type for struct `A` with no parameters.
    !struct.type<@A>
 
    // Type for struct `B` with IntegerAttr and SymbolRefAttr parameters.
    !struct.type<@B<[5, @C]>>
 
    // Type for struct `C` with TypeAttr and IntegerAttr parameters.
    !struct.type<@C<[!felt.type, 24]>>
    ```
  }];
 
  let parameters =
      (ins TypeParameter<
           "::mlir::SymbolRefAttr",
           "Fully-qualified name of the struct definition.">:$nameRef,
          OptionalParameter<"::mlir::ArrayAttr", "Struct parameters">:$params);
 
  let assemblyFormat =
      [{ `<` $nameRef ( `<` custom<TemplateParams>($params)^ `>` )? `>` }];
 
  let genVerifyDecl = 1;
 
  let skipDefaultBuilders = 1;
  let builders = [TypeBuilderWithInferredContext<
                      (ins "::mlir::SymbolRefAttr":$structName), [{
                    return $_get(structName.getContext(), structName, ::mlir::ArrayAttr());
                  }]>,
                  TypeBuilderWithInferredContext<
                      (ins "::mlir::SymbolRefAttr":$structName,
                          "::mlir::ArrayAttr":$params),
                      [{
                    ::mlir::MLIRContext *ctx = structName.getContext();
                    if (params) {
                      OwningEmitErrorFn emitErrorFn = ::llzk::wrapNullableInFlightDiagnostic(emitError, ctx);
                      auto paramsRes = forceIntAttrTypes(params.getValue(), emitErrorFn);
                      if(::mlir::failed(paramsRes)) { return StructType(); }
                      params = ::mlir::ArrayAttr::get(ctx, *paramsRes);
                    }
                    return $_get(ctx, structName, params);
                  }]>,
                  TypeBuilderWithInferredContext<
                      (ins "::mlir::SymbolRefAttr":$structName,
                          "::llvm::ArrayRef<::mlir::Attribute>":$paramsRef),
                      [{
                    ::mlir::MLIRContext *ctx = structName.getContext();
                    OwningEmitErrorFn emitErrorFn = ::llzk::wrapNullableInFlightDiagnostic(emitError, ctx);
                    auto paramsRes = forceIntAttrTypes(paramsRef, emitErrorFn);
                    if(::mlir::failed(paramsRes)) { return StructType(); }
                    return $_get(ctx, structName, ::mlir::ArrayAttr::get(ctx, *paramsRes));
                  }]>];
 
  let extraClassDeclaration = [{
    /// Gets the `struct` op that defines this struct. Provided `op` is
    /// used as a starting point for the lookup. Should not be assumed to
    /// be non-`null` as we don't verify all types during verification.
    ::mlir::FailureOr<SymbolLookupResult<StructDefOp>> getDefinition
        (::mlir::SymbolTableCollection &symbolTable, ::mlir::Operation *op, bool reportMissing = true) const;
 
    // Verifies that this type references a valid struct, relative to the given `op`.
    ::mlir::LogicalResult verifySymbolRef(::mlir::SymbolTableCollection &symbolTable, ::mlir::Operation *op);
 
    /// Returns wether the struct this type refers to has members marked as columns.
    /// A lookup is necessary first and will forward the failure state if it fails.
    mlir::LogicalResult hasColumns(mlir::SymbolTableCollection &symbolTable, mlir::Operation *op) const;
  }];
 
  let extraClassDefinition = [{
    namespace {
      /// This definition of `emitError` is used by the `get()` functions generated by the
      /// custom builders for this type. The `getChecked()` functions generated by those same
      /// builders have a parameter with this same name that shadows this definition so the
      /// `getChecked()` versions will use the function supplied via the parameter. Regardless,
      /// `wrapNullableInFlightDiagnostic()` checks for `nullptr` and generates a default if
      /// necessary. This approach, although a bit hacky, allows a legitimate error function to
      /// be used whenever available, only reverting to a default in the `get()` function.
      const ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError = nullptr;
    }
  }];
}
 
#endif // LLZK_STRUCT_TYPES