Assert that both C++ and Rust rules use the same generics (#101)

Author: lucic71

cpp2rust/converter/mapper.cpp

@@ -227,7 +227,6 @@ matchTemplate(const std::string &template_str,
   size_t si = 0;
 
   while (ti < template_str.size()) {
-    // Match T{N}. TODO: currently only T0..9 are supported
     if (template_str[ti] == 'T' && ti + 1 < template_str.size() &&
         std::isdigit(template_str[ti + 1])) {
       size_t tj = ti + 2;
@@ -236,6 +235,8 @@ matchTemplate(const std::string &template_str,
       }
 
       size_t type_idx = std::stoi(&template_str[ti + 1]) - 1;
+      assert(type_idx < TranslationRule::kMaxGenerics &&
+             "template placeholder exceeds kMaxGenerics");
       ti = tj;
 
       std::string_view nextLit;
@@ -341,7 +342,8 @@ matchTemplate(const std::string &template_str,
 //   result       = "Vec<i32>"
 std::string instantiateTgt(const std::vector<std::optional<std::string>> &types,
                            const std::string &tgt_template) {
-  assert(types.size() <= 9);
+  assert(types.size() <= TranslationRule::kMaxGenerics &&
+         "template placeholder exceeds kMaxGenerics");
   std::string instantiated_template = tgt_template;
   std::string::size_type pos = 0;
   while ((pos = instantiated_template.find('T', pos)) != std::string::npos) {

cpp2rust/converter/translation_rule.cpp

@@ -303,6 +303,28 @@ void ExprRule::dump() const {
   }
 }
 
+std::array<const char *, kMaxGenerics> kGenericPlaceholders = {
+    "T1", "T2", "T3", "T4", "T5", "T6", "T7", "T8", "T9"};
+
+void ExprRule::validate(const std::string &name) const {
+  if (src.empty()) {
+    llvm::errs() << name << '\n';
+    dump();
+    assert(0 && "Expr rule loaded from IR but has no src");
+  }
+
+  for (unsigned i = 0, e = generics.size(); i < e; ++i) {
+    const char *placeholder = kGenericPlaceholders[i];
+    if (src.find(placeholder) == std::string::npos) {
+      llvm::errs() << name << '\n';
+      dump();
+      llvm::errs() << "generic " << placeholder
+                   << " declared but missing from src: " << src << '\n';
+      assert(0 && "Expr rule declares a generic absent from its src");
+    }
+  }
+}
+
 void GenericFragment::dump() const { log() << "  generic: " << n << '\n'; }
 
 void TypeInfo::dump() const {
@@ -339,11 +361,7 @@ std::pair<ExprRules, TypeRules> Load(const std::filesystem::path &path,
   LoadIrSrc(exprs, types, dir / "ir_src.json");
 
   for (auto &[name, rule] : exprs) {
-    if (rule.src.empty()) {
-      llvm::errs() << name << '\n';
-      rule.dump();
-      assert(0 && "Expr rule loaded from IR but has no src");
-    }
+    rule.validate(name);
   }
   for (auto &[name, rule] : types) {
     if (rule.src.empty()) {

cpp2rust/converter/translation_rule.h

@@ -15,6 +15,8 @@
 
 namespace cpp2rust::TranslationRule {
 
+inline constexpr unsigned kMaxGenerics = 9;
+
 struct TextFragment {
   std::string text;
 
@@ -70,6 +72,7 @@ struct ExprRule {
   bool multi_statement = false;
 
   void dump() const;
+  void validate(const std::string &name) const;
 };
 
 struct TypeRule {

rules/algorithm/ir_unsafe.json

@@ -419,9 +419,6 @@
         }
       }
     ],
-    "generics": {
-      "T1": []
-    },
     "multi_statement": true,
     "params": {
       "a0": {

rules/algorithm/tgt_unsafe.rs

@@ -110,7 +110,7 @@ unsafe fn f12<T1: Clone>(a0: *mut T1, a1: *mut T1, a2: T1) {
     }
 }
 
-unsafe fn f13<T1>(a0: *const u8, a1: *const u8, a2: &mut ::std::fs::File) -> ::std::fs::File {
+unsafe fn f13(a0: *const u8, a1: *const u8, a2: &mut ::std::fs::File) -> ::std::fs::File {
     let __start = a0 as *const u8;
     let __end = a1 as *const u8;
     let __len = __end.offset_from(__start) as usize;

rules/string/ir_unsafe.json

@@ -1212,19 +1212,16 @@
         "text": " as usize]\n    }"
       }
     ],
-    "generics": {
-      "T1": []
-    },
     "params": {
       "a0": {
-        "type": "&mut Vec<T1>"
+        "type": "&mut Vec<u8>"
       },
       "a1": {
         "type": "usize"
       }
     },
     "return_type": {
-      "type": "*mut T1",
+      "type": "*mut u8",
       "is_unsafe_pointer": true
     }
   },

rules/string/tgt_unsafe.rs

@@ -146,7 +146,7 @@ unsafe fn f25(a0: &mut Vec<u8>) {
     a0.shrink_to_fit()
 }
 
-unsafe fn f26<T1>(a0: &mut Vec<T1>, a1: usize) -> *mut T1 {
+unsafe fn f26(a0: &mut Vec<u8>, a1: usize) -> *mut u8 {
     if a1 as usize >= a0.len() - 1 {
         panic!("out of bounds access")
     } else {