Use typedefs for type rules, cleanup code

joaotgouveia · joaotgouveia · commit 471fc20fb8b7 · 2026-04-21T09:11:32.000Z
diff --git a/cpp2rust/converter/translation_rule.cpp b/cpp2rust/converter/translation_rule.cpp
diff --git a/rules/array/src.cpp b/rules/array/src.cpp
@@ -3,7 +3,8 @@
 
 #include <array>
 
-template <typename T1, std::size_t T2> void t1(std::array<T1, T2>);
+template <typename T1, std::size_t T2>
+using t1 = std::array<T1, T2>;
 
 template <typename T1, std::size_t T2>
 const T1 *f1(const std::array<T1, T2> &o) {
diff --git a/rules/brotli/src.cpp b/rules/brotli/src.cpp
@@ -4,10 +4,10 @@
 #include "brotli/decode.h"
 #include "brotli/encode.h"
 
-void t1(BrotliDecoderResult);
-void t2(BrotliEncoderMode);
-void t3(BrotliDecoderStateStruct *);
-void t4(const BrotliDecoderStateStruct *);
+using t1 = BrotliDecoderResult;
+using t2 = BrotliEncoderMode;
+using t3 = BrotliDecoderStateStruct *;
+using t4 = const BrotliDecoderStateStruct *;
 
 BrotliEncoderMode f1() { return BROTLI_MODE_FONT; }
 
diff --git a/rules/carray/src.cpp b/rules/carray/src.cpp
@@ -3,5 +3,5 @@
 
 #include <cstdlib>
 
-template <typename T1, std::size_t T2> void t1(T1[T2][T2]);
-template <typename T1, std::size_t T2> void t2(T1[T2][T2][T2]);
+template <typename T1, std::size_t T2> using t1 = T1[T2][T2];
+template <typename T1, std::size_t T2> using t2 = T1[T2][T2][T2];
diff --git a/rules/deque/src.cpp b/rules/deque/src.cpp
@@ -4,7 +4,7 @@
 #include <deque>
 #include <vector>
 
-template <typename T1> void t1(std::deque<T1>);
+template <typename T1> using t1 = std::deque<T1>;
 
 template <typename T1> T1 &f1(std::deque<T1> &o) { return o.back(); }
 
diff --git a/rules/fstream/src.cpp b/rules/fstream/src.cpp
@@ -5,9 +5,9 @@
 #include <iostream>
 #include <iterator>
 
-void t1(std::ifstream);
-void t2(std::ofstream);
-void t3(std::ostream_iterator<char>);
+using t1 = std::ifstream;
+using t2 = std::ofstream;
+using t3 = std::ostream_iterator<char>;
 
 std::ofstream f1(const char *filename, std::ios_base::openmode mode) {
   return std::ofstream(filename, mode);
diff --git a/rules/initializer_list/src.cpp b/rules/initializer_list/src.cpp
@@ -3,7 +3,7 @@
 
 #include <initializer_list>
 
-template <typename T1> void t1(std::initializer_list<T1>);
+template <typename T1> using t1 = std::initializer_list<T1>;
 
 template <typename T1>
 typename std::initializer_list<T1>::size_type f1(std::initializer_list<T1> &o) {
diff --git a/rules/iostream/src.cpp b/rules/iostream/src.cpp
@@ -3,9 +3,9 @@
 
 #include <iostream>
 
-void t1(std::ostream);
-void t2(std::ostream &);
-void t3(std::ostream *);
+using t1 = std::ostream;
+using t2 = std::ostream &;
+using t3 = std::ostream *;
 
 std::ostream &f1() { return std::cout; }
 
diff --git a/rules/map/src.cpp b/rules/map/src.cpp
@@ -4,11 +4,13 @@
 #include <map>
 #include <utility>
 
-template <typename T1, typename T2> void t1(std::map<T1, T2>);
+template <typename T1, typename T2> using t1 = std::map<T1, T2>;
+
 template <typename T1, typename T2>
-void t2(typename std::map<T1, T2>::const_iterator);
+using t2 = typename std::map<T1, T2>::const_iterator;
+
 template <typename T1, typename T2>
-void t3(typename std::map<T1, T2>::iterator);
+using t3 = typename std::map<T1, T2>::iterator;
 
 template <typename T1, typename T2> T2 &f1(std::map<T1, T2> &o, const T1 &key) {
   return o.operator[](key);
diff --git a/rules/pair/src.cpp b/rules/pair/src.cpp
@@ -3,7 +3,7 @@
 
 #include <utility>
 
-template <typename T1, typename T2> void t1(std::pair<T1, T2>);
+template <typename T1, typename T2> using t1 = std::pair<T1, T2>;
 
 template <typename T1, typename T2> T2 &f1(std::pair<T1, T2> &o) {
   return o.second;
diff --git a/rules/stdarg/src.cpp b/rules/stdarg/src.cpp
@@ -1,3 +1,3 @@
 #include <stdarg.h>
 
-void t1(va_list);
+using t1 = va_list;
diff --git a/rules/stdio/src.cpp b/rules/stdio/src.cpp
@@ -3,7 +3,7 @@
 
 #include <stdio.h>
 
-void t1(FILE *);
+using t1 = FILE *;
 
 FILE *f1(const char *pathname, const char *mode) {
   return fopen(pathname, mode);
diff --git a/rules/string/src.cpp b/rules/string/src.cpp
@@ -5,8 +5,8 @@
 #include <streambuf>
 #include <string>
 
-void t1(std::string);
-void t2(std::string::iterator);
+using t1 = std::string;
+using t2 = std::string::iterator;
 
 std::string f1(const std::string &s, std::size_t pos, std::size_t count) {
   return s.substr(pos, count);
diff --git a/rules/unique_ptr/src.cpp b/rules/unique_ptr/src.cpp
@@ -4,10 +4,10 @@
 #include <cstddef>
 #include <memory>
 
-template <typename T1> void t1(std::unique_ptr<T1>);
-template <typename T1> void t2(std::unique_ptr<T1[]>);
+template <typename T1> using t1 = std::unique_ptr<T1>;
+template <typename T1> using t2 = std::unique_ptr<T1[]>;
 
-template <typename T1> std::unique_ptr<T1[]> f1(std::size_t n) {
+template <typename T2, typename T1> std::unique_ptr<T1[]> f1(std::size_t n) {
   return std::make_unique<T1[]>(n);
 }
 
diff --git a/rules/vector/src.cpp b/rules/vector/src.cpp
@@ -5,10 +5,10 @@
 #include <initializer_list>
 #include <vector>
 
-template <typename T1> void t1(std::vector<T1>);
-template <typename T1> void t2(typename std::vector<T1>::iterator);
-template <typename T1> void t3(std::vector<std::vector<T1>>);
-template <typename T1> void t4(typename std::vector<T1>::const_iterator);
+template <typename T1> using t1 = std::vector<T1>;
+template <typename T1> using t2 = typename std::vector<T1>::iterator;
+template <typename T1> using t3 = std::vector<std::vector<T1>>;
+template <typename T1> using t4 = typename std::vector<T1>::const_iterator;
 
 template <typename T1>
 typename std::vector<T1>::iterator
