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 <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>
 
#include "CommonCAPIGen.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;
 
  virtual ~AttrOrTypeTestGenerator() = 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"(
// This test ensures {0}{2}{3}Get links properly.
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,
        FunctionPrefix,         // {0}
        kind,                   // {1}
        dialectNameCapitalized, // {2}
        className,              // {3}
        dummyParams,            // {4}
        paramList               // {5}
    );
  }

  virtual void genParamGetterTest() const {
    static constexpr char fmt[] = R"(
// This test ensures {0}{2}{3}Get{5} links properly.
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});
  }
}
)";
    assert(!className.empty() && "className must be set");
    assert(!paramName.empty() && "paramName must be set");
    os << llvm::formatv(
        fmt, FunctionPrefix, kind, dialectNameCapitalized, className, paramName,
        paramNameCapitalized
    );
  }

  virtual void genArrayRefParamCountTest() const {
    static constexpr char fmt[] = R"(
// This test ensures {0}{2}{3}Get{5}Count links properly.
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, FunctionPrefix, kind, dialectNameCapitalized, className, paramName,
        paramNameCapitalized
    );
  }

  virtual void genArrayRefParamAtTest() const {
    static constexpr char fmt[] = R"(
// This test ensures {0}{2}{3}Get{5}At links properly.
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, FunctionPrefix, kind, dialectNameCapitalized, className, paramName,
        paramNameCapitalized
    );
  }
 
  void genCompleteRecord(const mlir::tblgen::AttrOrTypeDef def, bool isType) {
    const mlir::tblgen::Dialect &defDialect = def.getDialect();
 
    // Generate for the selected dialect only
    if (defDialect.getName() != DialectName) {
      return;
    }
 
    this->setDialectAndClassName(&defDialect, def.getCppClassName());
 
    // Generate IsA test
    if (GenIsA) {
      this->genIsATest();
    }
 
    // Generate Get builder test
    if (GenTypeOrAttrGet && !def.skipDefaultBuilders()) {
      std::string dummyParams = generateDummyParamsForAttrOrTypeGet(def, isType);
      std::string paramList = generateParamListForAttrOrTypeGet(def);
      this->genGetBuilderTest(dummyParams, paramList);
    }
 
    // Generate parameter getter tests
    if (GenTypeOrAttrParamGetters) {
      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();
        }
      }
    }
 
    // Generate extra class method tests
    if (GenExtraClassMethods) {
      std::optional<mlir::StringRef> extraDecls = def.getExtraDecls();
      if (extraDecls.has_value()) {
        this->genExtraMethods(extraDecls.value());
      }
    }
  }
 
protected:
  mlir::StringRef paramName;
  std::string paramNameCapitalized;
};