comments, as requested by PR

Author: hhkit

mlir/lib/Target/IRDLToCpp/IRDLToCpp.cpp

@@ -30,6 +30,7 @@ constexpr char definitionMacroFlag[] = "GEN_DIALECT_DEF";
 
 namespace {
 
+/// The set of strings that can be generated from a Dialect declaraiton
 struct DialectStrings {
   std::string dialectName;
   std::string dialectCppName;
@@ -41,11 +42,13 @@ struct DialectStrings {
   std::string namespacePath;
 };
 
+/// The set of strings that can be generated from a Type declaraiton
 struct TypeStrings {
   StringRef typeName;
   std::string typeCppName;
 };
 
+/// The set of strings that can be generated from an Operation declaraiton
 struct OpStrings {
   StringRef opName;
   std::string opCppName;
@@ -61,23 +64,27 @@ static std::string joinNameList(llvm::ArrayRef<std::string> names) {
   return nameArray;
 }
 
+/// Generates the C++ type name for a TypeOp
 static std::string typeToCppName(irdl::TypeOp type) {
   return llvm::formatv("{0}Type",
                        convertToCamelFromSnakeCase(type.getSymName(), true));
 }
 
+/// Generates the C++ class name for an OperationOp
 static std::string opToCppName(irdl::OperationOp op) {
   return llvm::formatv("{0}Op",
                        convertToCamelFromSnakeCase(op.getSymName(), true));
 }
 
+/// Generates TypeStrings from a TypeOp
 static TypeStrings getStrings(irdl::TypeOp type) {
   TypeStrings strings;
   strings.typeName = type.getSymName();
   strings.typeCppName = typeToCppName(type);
   return strings;
 }
 
+/// Generates OpStrings from an OperatioOp
 static OpStrings getStrings(irdl::OperationOp op) {
   auto operandOp = op.getOp<irdl::OperandsOp>();
 
@@ -104,12 +111,14 @@ static OpStrings getStrings(irdl::OperationOp op) {
   return strings;
 }
 
+/// Fills a dictionary with values from TypeStrings
 static void fillDict(irdl::detail::dictionary &dict,
                      const TypeStrings &strings) {
   dict["TYPE_NAME"] = strings.typeName;
   dict["TYPE_CPP_NAME"] = strings.typeCppName;
 }
 
+/// Fills a dictionary with values from OpStrings
 static void fillDict(irdl::detail::dictionary &dict, const OpStrings &strings) {
   const auto operandCount = strings.opOperandNames.size();
   const auto resultCount = strings.opResultNames.size();
@@ -124,6 +133,7 @@ static void fillDict(irdl::detail::dictionary &dict, const OpStrings &strings) {
       resultCount ? joinNameList(strings.opResultNames) : "{\"\"}";
 }
 
+/// Fills a dictionary with values from DialectStrings
 static void fillDict(irdl::detail::dictionary &dict,
                      const DialectStrings &strings) {
   dict["DIALECT_NAME"] = strings.dialectName;

mlir/lib/Target/IRDLToCpp/TemplatingUtils.h

@@ -18,8 +18,15 @@
 
 namespace mlir::irdl::detail {
 
+/// A dictionary stores a mapping of template variables to their assigned
+/// variables
 using dictionary = llvm::StringMap<llvm::SmallString<8>>;
 
+/// Template Code as used by IRDL-to-Cpp.
+///
+/// For efficiency, produces a bytecode representation of an input string
+///   - LiteralToken: A contiguous stream of characters to be printed
+///   - ReplacementToken: A template variable that will be replaced
 class Template {
 public:
   Template(llvm::StringRef str) {
@@ -40,6 +47,8 @@ class Template {
     }
   }
 
+  // Render will apply a dictionary to the Template
+  // and send it to the specified output stream
   void render(llvm::raw_ostream &out, const dictionary &replacements) const {
     for (auto instruction : bytecode) {
       std::visit(