TypeHelper.h

Go to the documentation of this file.

//===-- TypeHelper.h --------------------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
 
#pragma once
 
#include "llzk/Util/ErrorHelper.h"
 
#include <mlir/IR/OpImplementation.h>
#include <mlir/IR/Operation.h>
#include <mlir/IR/SymbolTable.h>
 
#include <llvm/ADT/ArrayRef.h>
#include <llvm/ADT/DenseMap.h>
#include <llvm/ADT/StringRef.h>
 
namespace llzk {
 
// Forward declarations
namespace component {
class StructType;
} // namespace component
namespace array {
class ArrayType;
} // namespace array
namespace pod {
class PodType;
} // namespace pod

class BuildShortTypeString {
  std::string ret;
  llvm::raw_string_ostream ss;
 
  BuildShortTypeString() : ret(), ss(ret) {}
  BuildShortTypeString &append(mlir::Type);
  BuildShortTypeString &append(mlir::ArrayRef<mlir::Attribute>);
  BuildShortTypeString &append(mlir::Attribute);
 
  void appendSymRef(mlir::SymbolRefAttr);
  void appendSymName(mlir::StringRef);
 
public:
  static inline std::string from(mlir::Type type) {
    return BuildShortTypeString().append(type).ret;
  }

  static inline std::string from(mlir::Attribute attr) {
    return BuildShortTypeString().append(attr).ret;
  }

  static inline std::string from(mlir::ArrayRef<mlir::Attribute> attrs) {
    return BuildShortTypeString().append(attrs).ret;
  }
};
 
// This function asserts that the given Attribute kind is legal within the LLZK types that can
// contain Attribute parameters (i.e., ArrayType, StructType, and TypeVarType). This should be used
// in any function that examines the attribute parameters within parameterized LLZK types to ensure
// that the function handles all possible cases properly, especially if more legal attributes are
// added in the future. Throw a fatal error if anything illegal is found, indicating that the caller
// of this function should be updated.
void assertValidAttrForParamOfType(mlir::Attribute attr);

bool isValidType(mlir::Type type);

bool isValidColumnType(
    mlir::Type type, mlir::SymbolTableCollection &symbolTable, mlir::Operation *op
);

bool isValidGlobalType(mlir::Type type);

bool isValidEmitEqType(mlir::Type type);

bool isValidConstReadType(mlir::Type type);

bool isValidArrayElemType(mlir::Type type);

bool isValidArrayType(mlir::Type type);

bool isConcreteType(mlir::Type type, bool allowStructParams = true);

bool isTypeVarFreeType(mlir::Type type);

enum class AttrConcreteness : std::uint8_t {
  NonConcrete,
  Concrete,
  Wildcard,
};

AttrConcreteness classifyAttrConcreteness(mlir::Attribute attr, bool allowStructParams = true);

inline bool isConcreteStructParamAttr(mlir::Attribute attr, bool allowStructParams = true) {
  return classifyAttrConcreteness(attr, allowStructParams) == AttrConcreteness::Concrete;
}
 
inline mlir::LogicalResult checkValidType(EmitErrorFn emitError, mlir::Type type) {
  if (!isValidType(type)) {
    return emitError() << "expected a valid LLZK type but found " << type;
  } else {
    return mlir::success();
  }
}

bool hasAffineMapAttr(mlir::Type type);
 
enum class Side : std::uint8_t { LHS, RHS };
static inline mlir::raw_ostream &operator<<(mlir::raw_ostream &os, const Side &val) {
  switch (val) {
  case Side::LHS:
    os << "LHS";
    break;
  case Side::RHS:
    os << "RHS";
    break;
  }
  return os;
}
 
inline Side reverse(Side in) {
  switch (in) {
  case Side::LHS:
    return Side::RHS;
  case Side::RHS:
    return Side::LHS;
  }
  return in;
}
 
} // namespace llzk
 
namespace llvm {
template <> struct DenseMapInfo<llzk::Side> {
  using T = llzk::Side;
  static unsigned getHashValue(const T &val) {
    using UT = std::underlying_type_t<T>;
    return llvm::DenseMapInfo<UT>::getHashValue(static_cast<UT>(val));
  }
  static bool isEqual(const T &lhs, const T &rhs) { return lhs == rhs; }
};
} // namespace llvm
 
namespace llzk {
 
bool isDynamic(mlir::IntegerAttr intAttr);

array::ArrayType flattenArrayElementType(array::ArrayType outerArrTy, mlir::Type elementType);

uint64_t computeEmitEqCardinality(mlir::Type type);

using UnificationMap = mlir::DenseMap<std::pair<mlir::SymbolRefAttr, Side>, mlir::Attribute>;

bool typeParamsUnify(
    const mlir::ArrayRef<mlir::Attribute> &lhsParams,
    const mlir::ArrayRef<mlir::Attribute> &rhsParams, UnificationMap *unifications = nullptr
);

bool typeParamsUnify(
    const mlir::ArrayAttr &lhsParams, const mlir::ArrayAttr &rhsParams,
    UnificationMap *unifications = nullptr
);

bool arrayTypesUnify(
    array::ArrayType lhs, array::ArrayType rhs,
    mlir::ArrayRef<llvm::StringRef> rhsReversePrefix = {}, UnificationMap *unifications = nullptr
);

bool structTypesUnify(
    component::StructType lhs, component::StructType rhs,
    mlir::ArrayRef<llvm::StringRef> rhsReversePrefix = {}, UnificationMap *unifications = nullptr
);

bool podTypesUnify(
    pod::PodType lhs, pod::PodType rhs, mlir::ArrayRef<llvm::StringRef> rhsReversePrefix = {},
    UnificationMap *unifications = nullptr
);

bool functionTypesUnify(
    mlir::FunctionType lhs, mlir::FunctionType rhs,
    mlir::ArrayRef<llvm::StringRef> rhsReversePrefix = {}, UnificationMap *unifications = nullptr
);

bool typesUnify(
    mlir::Type lhs, mlir::Type rhs, mlir::ArrayRef<llvm::StringRef> rhsReversePrefix = {},
    UnificationMap *unifications = nullptr
);

template <typename Iter1, typename Iter2>
inline bool typeListsUnify(
    Iter1 lhs, Iter2 rhs, mlir::ArrayRef<llvm::StringRef> rhsReversePrefix = {},
    UnificationMap *unifications = nullptr
) {
  return (lhs.size() == rhs.size()) &&
         std::equal(lhs.begin(), lhs.end(), rhs.begin(), [&](mlir::Type a, mlir::Type b) {
    return typesUnify(a, b, rhsReversePrefix, unifications);
  });
}
 
template <typename Iter1, typename Iter2>
inline bool singletonTypeListsUnify(
    Iter1 lhs, Iter2 rhs, mlir::ArrayRef<llvm::StringRef> rhsReversePrefix = {},
    UnificationMap *unifications = nullptr
) {
  return lhs.size() == 1 && rhs.size() == 1 &&
         typesUnify(lhs.front(), rhs.front(), rhsReversePrefix, unifications);
}

bool isMoreConcreteUnification(
    mlir::Type oldTy, mlir::Type newTy,
    llvm::function_ref<bool(mlir::Type oldTy, mlir::Type newTy)> knownOldToNew = nullptr
);
 
template <typename TypeClass> inline TypeClass getIfSingleton(mlir::TypeRange types) {
  return (types.size() == 1) ? llvm::dyn_cast<TypeClass>(types.front()) : nullptr;
}
 
template <typename TypeClass> inline TypeClass getAtIndex(mlir::TypeRange types, size_t index) {
  return (types.size() > index) ? llvm::dyn_cast<TypeClass>(types[index]) : nullptr;
}

mlir::FailureOr<mlir::IntegerAttr> forceIntType(mlir::IntegerAttr attr, EmitErrorFn emitError);

mlir::FailureOr<mlir::Attribute> forceIntAttrType(mlir::Attribute attr, EmitErrorFn emitError);

mlir::FailureOr<llvm::SmallVector<mlir::Attribute>>
forceIntAttrTypes(llvm::ArrayRef<mlir::Attribute> attrList, EmitErrorFn emitError);

mlir::LogicalResult verifyIntAttrType(EmitErrorFn emitError, mlir::Attribute in);

mlir::LogicalResult verifyAffineMapAttrType(EmitErrorFn emitError, mlir::Attribute in);

mlir::LogicalResult verifyStructTypeParams(EmitErrorFn emitError, mlir::ArrayAttr params);

mlir::LogicalResult
verifyArrayDimSizes(EmitErrorFn emitError, mlir::ArrayRef<mlir::Attribute> dimensionSizes);

mlir::LogicalResult verifyArrayType(
    EmitErrorFn emitError, mlir::Type elementType, mlir::ArrayRef<mlir::Attribute> dimensionSizes
);

mlir::LogicalResult verifySubArrayType(
    EmitErrorFn emitError, array::ArrayType arrayType, array::ArrayType subArrayType
);

mlir::LogicalResult verifySubArrayOrElementType(
    EmitErrorFn emitError, array::ArrayType arrayType, mlir::Type subArrayOrElemType
);

bool isFeltOrSimpleFeltAggregate(mlir::Type ty);

bool isValidMainSignalType(mlir::Type pType);
 
} // namespace llzk