Assert that both C++ and Rust rules use the same generics

Author: lucic71

cpp2rust/converter/translation_rule.cpp

@@ -7,6 +7,7 @@
 #include <llvm/Support/MemoryBuffer.h>
 
 #include <algorithm>
+#include <format>
 #include <string>
 #include <vector>
 
@@ -299,6 +300,26 @@ void ExprRule::dump() const {
   }
 }
 
+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");
+  }
+
+  // Check that both source and target use the same generics.
+  for (unsigned i = 0; i < generics.size(); ++i) {
+    auto placeholder = std::format("T{}", i + 1);
+    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 {
@@ -335,11 +356,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

@@ -69,6 +69,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

@@ -1210,19 +1210,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 {