CommonAttrOrTypeCAPITestGen.h

Go to the documentation of this file.

//===- CommonAttrOrTypeCAPITestGen.h - Common test generation utilities ---===//
//
// 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 "CommonCAPIGen.h"
 
#include <mlir/TableGen/AttrOrTypeDef.h>
#include <mlir/TableGen/Dialect.h>
 
#include <llvm/ADT/StringExtras.h>
#include <llvm/Support/FormatVariadic.h>
#include <llvm/Support/raw_ostream.h>

std::string
generateDummyParamsForAttrOrTypeGet(const mlir::tblgen::AttrOrTypeDef &def, bool isType);

std::string generateParamListForAttrOrTypeGet(const mlir::tblgen::AttrOrTypeDef &def);

struct AttrOrTypeTestGenerator : public TestGenerator {
  using TestGenerator::TestGenerator;
 
  ~AttrOrTypeTestGenerator() override = default;

  void setParamName(mlir::StringRef name) {
    this->paramName = name;
    this->paramNameCapitalized = toPascalCase(name);
  }

  virtual void
  genGetBuilderTest(const std::string &dummyParams, const std::string &paramList) const {
    static constexpr char fmt[] = R"(
TEST_F({2}{1}LinkTests, Get_{3}) {{
  auto test{1} = createIndex{1}();
 
  // We only verify the function compiles and links, wrapped in an unreachable condition
  if ({0}{1}IsA_{2}_{3}(test{1})) {{
{4}
    (void){0}{2}_{3}Get(context{5});
  }
}
)";
    assert(!className.empty() && "className must be set");
    os << llvm::formatv(
        fmt,
        getFunctionPrefix(),    // {0}
        kind,                   // {1}
        dialectNameCapitalized, // {2}
        className,              // {3}
        dummyParams,            // {4}
        paramList               // {5}
    );
  }

  virtual void genParamGetterTest(bool isInteger = false) const {
    static constexpr char fmt[] = R"(
TEST_F({2}{1}LinkTests, Get_{3}_{4}) {{
  auto test{1} = createIndex{1}();
 
  if ({0}{1}IsA_{2}_{3}(test{1})) {{
    (void){0}{2}_{3}Get{5}(test{1}{6});
  }
}
)";
    assert(!className.empty() && "className must be set");
    assert(!paramName.empty() && "paramName must be set");
    os << llvm::formatv(
        fmt, getFunctionPrefix(), kind, dialectNameCapitalized, className, paramName,
        paramNameCapitalized, isInteger ? ", [](MlirStringRef, void *) {}, nullptr" : ""
    );
  }

  virtual void genArrayRefParamCountTest() const {
    static constexpr char fmt[] = R"(
TEST_F({2}{1}LinkTests, Get_{3}_{4}Count) {{
  auto test{1} = createIndex{1}();
 
  if ({0}{1}IsA_{2}_{3}(test{1})) {{
    (void){0}{2}_{3}Get{5}Count(test{1});
  }
}
)";
    assert(!className.empty() && "className must be set");
    assert(!paramName.empty() && "paramName must be set");
    os << llvm::formatv(
        fmt, getFunctionPrefix(), kind, dialectNameCapitalized, className, paramName,
        paramNameCapitalized
    );
  }

  virtual void genArrayRefParamAtTest() const {
    static constexpr char fmt[] = R"(
TEST_F({2}{1}LinkTests, Get_{3}_{4}At) {{
  auto test{1} = createIndex{1}();
 
  if ({0}{1}IsA_{2}_{3}(test{1})) {{
    (void){0}{2}_{3}Get{5}At(test{1}, 0);
  }
}
)";
    assert(!className.empty() && "className must be set");
    assert(!paramName.empty() && "paramName must be set");
    os << llvm::formatv(
        fmt, getFunctionPrefix(), kind, dialectNameCapitalized, className, paramName,
        paramNameCapitalized
    );
  }
 
  void genCompleteRecord(const mlir::tblgen::AttrOrTypeDef &def, bool isType) {
    mlir::tblgen::Dialect defDialect = def.getDialect();
 
    // Generate for the selected dialect only
    if (defDialect.getName() != getDialectName()) {
      return;
    }
 
    this->setNamespaceAndClassName(defDialect, def.getCppClassName());
 
    // Generate IsA test
    if (getGenIsA()) {
      this->genIsATest();
    }
 
    // Generate Get builder test
    if (getGenTypeOrAttrGet() && !def.skipDefaultBuilders()) {
      std::string dummyParams = generateDummyParamsForAttrOrTypeGet(def, isType);
      std::string paramList = generateParamListForAttrOrTypeGet(def);
      this->genGetBuilderTest(dummyParams, paramList);
    }
 
    // Generate parameter getter tests
    if (getGenTypeOrAttrParamGetters()) {
      for (const auto &param : def.getParameters()) {
        this->setParamName(param.getName());
        mlir::StringRef cppType = param.getCppType();
        if (isArrayRefType(cppType)) {
          this->genArrayRefParamCountTest();
          this->genArrayRefParamAtTest();
        } else {
          this->genParamGetterTest(isDynamicAPIntType(cppType));
        }
      }
    }
 
    // Generate extra class method tests
    if (getGenExtraClassMethods()) {
      std::optional<mlir::StringRef> extraDecls = def.getExtraDecls();
      if (extraDecls.has_value()) {
        this->genExtraMethods(extraDecls.value());
      }
    }
  }
 
protected:
  mlir::StringRef paramName;
  std::string paramNameCapitalized;
};