swap capacity and len in all string- and vector-like classes

iliabylich · iliabylich · commit 9d50460f64c8 · 2021-11-26T02:10:11.000+03:00
diff --git a/bytes.hpp b/bytes.hpp
@@ -13,8 +13,8 @@ namespace lib_ruby_parser
     {
     public:
         char *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         ByteList() = delete;
         ByteList(char *ptr, size_t len, size_t capacity);
diff --git a/codegen/codegen/message_rs.rs b/codegen/codegen/message_rs.rs
@@ -49,7 +49,9 @@ pub extern \"C\" fn LIB_RUBY_PARSER_drop_message(message: *mut DiagnosticMessage
 #[cfg(feature = \"tests\")]
 #[no_mangle]
 pub extern \"C\" fn lib_ruby_parser__test__make_message_list() -> DiagnosticMessageListBlob {
-    DiagnosticMessageListBlob::from(helpers::make_messages())
+    let mut v = helpers::make_messages();
+    v.reserve(10);
+    DiagnosticMessageListBlob::from(v)
 }
 
 #[no_mangle]
diff --git a/codegen/codegen/messages_hpp.rs b/codegen/codegen/messages_hpp.rs
@@ -81,8 +81,8 @@ namespace lib_ruby_parser
     {
     public:
         DiagnosticMessage *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         DiagnosticMessageList() = delete;
         DiagnosticMessageList(DiagnosticMessage *ptr, size_t len, size_t capacity);
diff --git a/codegen/codegen/node_rs.rs b/codegen/codegen/node_rs.rs
@@ -71,7 +71,9 @@ pub extern \"C\" fn LIB_RUBY_PARSER_drop_node(node: *mut Node) {
 #[cfg(feature = \"tests\")]
 #[no_mangle]
 pub extern \"C\" fn lib_ruby_parser__test__make_node_list() -> NodeListBlob {
-    NodeListBlob::from(helpers::make_nodes())
+    let mut v = helpers::make_nodes();
+    v.reserve(10);
+    NodeListBlob::from(v)
 }
 
 #[no_mangle]
diff --git a/codegen/codegen/nodes_hpp.rs b/codegen/codegen/nodes_hpp.rs
@@ -17,8 +17,8 @@ namespace lib_ruby_parser
     {
     public:
         Node *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         NodeList() = delete;
         NodeList(Node *ptr, size_t len, size_t capacity);
diff --git a/comment.hpp b/comment.hpp
@@ -49,8 +49,8 @@ namespace lib_ruby_parser
     {
     public:
         Comment *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         CommentList() = delete;
         CommentList(Comment *ptr, size_t len, size_t capacity);
diff --git a/diagnostic.hpp b/diagnostic.hpp
@@ -62,8 +62,8 @@ namespace lib_ruby_parser
     {
     public:
         Diagnostic *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         DiagnosticList() = delete;
         DiagnosticList(Diagnostic *ptr, size_t len, size_t capacity);
diff --git a/magic_comment.hpp b/magic_comment.hpp
@@ -44,8 +44,8 @@ namespace lib_ruby_parser
     {
     public:
         MagicComment *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         MagicCommentList() = delete;
         MagicCommentList(MagicComment *ptr, size_t len, size_t capacity);
diff --git a/ruby-parser-cpp/src/bytes.rs b/ruby-parser-cpp/src/bytes.rs
@@ -7,7 +7,9 @@ blob_type!(BytesBlob, Bytes);
 #[cfg(feature = "tests")]
 #[no_mangle]
 pub extern "C" fn lib_ruby_parser__test__make_byte_list(i1: u8, i2: u8, i3: u8) -> ByteListBlob {
-    ByteListBlob::from(vec![i1, i2, i3])
+    let mut v = vec![i1, i2, i3];
+    v.reserve(10);
+    ByteListBlob::from(v)
 }
 
 #[no_mangle]
@@ -18,7 +20,9 @@ pub extern "C" fn LIB_RUBY_PARSER_drop_byte_list(byte_list: *mut Vec<u8>) {
 #[cfg(feature = "tests")]
 #[no_mangle]
 pub extern "C" fn lib_ruby_parser__test__make_bytes(i1: u8, i2: u8, i3: u8) -> BytesBlob {
-    BytesBlob::from(Bytes::new(vec![i1, i2, i3]))
+    let mut v = vec![i1, i2, i3];
+    v.reserve(10);
+    BytesBlob::from(Bytes::new(v))
 }
 
 #[no_mangle]
diff --git a/ruby-parser-cpp/src/comment.rs b/ruby-parser-cpp/src/comment.rs
@@ -34,7 +34,9 @@ pub extern "C" fn lib_ruby_parser__test__make_comment(location: Loc, kind: Comme
 #[cfg(feature = "tests")]
 #[no_mangle]
 pub extern "C" fn lib_ruby_parser__test__make_comment_list(comment: Comment) -> CommentListBlob {
-    CommentListBlob::from(vec![comment])
+    let mut v = vec![comment];
+    v.reserve(10);
+    CommentListBlob::from(v)
 }
 
 #[no_mangle]
diff --git a/ruby-parser-cpp/src/diagnostic.rs b/ruby-parser-cpp/src/diagnostic.rs
@@ -28,9 +28,9 @@ pub extern "C" fn LIB_RUBY_PARSER_drop_diagnostic(diagnostic: *mut Diagnostic) {
 #[cfg(feature = "tests")]
 #[no_mangle]
 pub extern "C" fn lib_ruby_parser__test__make_diagnostic_list() -> DiagnosticListBlob {
-    DiagnosticListBlob::from(vec![Diagnostic::from(
-        lib_ruby_parser__test__make_diagnostic(),
-    )])
+    let mut v = vec![Diagnostic::from(lib_ruby_parser__test__make_diagnostic())];
+    v.reserve(10);
+    DiagnosticListBlob::from(v)
 }
 
 #[no_mangle]
diff --git a/ruby-parser-cpp/src/magic_comment.rs b/ruby-parser-cpp/src/magic_comment.rs
@@ -52,7 +52,9 @@ pub extern "C" fn lib_ruby_parser__test__make_magic_comment(
 pub extern "C" fn lib_ruby_parser__test__make_magic_comment_list(
     magic_comment: MagicComment,
 ) -> MagicCommentListBlob {
-    MagicCommentListBlob::from(vec![magic_comment])
+    let mut v = vec![magic_comment];
+    v.reserve(10);
+    MagicCommentListBlob::from(v)
 }
 
 #[no_mangle]
diff --git a/ruby-parser-cpp/src/source_line.rs b/ruby-parser-cpp/src/source_line.rs
@@ -22,7 +22,9 @@ pub extern "C" fn lib_ruby_parser__test__make_source_line(
 pub extern "C" fn lib_ruby_parser__test__make_source_line_list(
     source_line: SourceLine,
 ) -> SourceLineListBlob {
-    SourceLineListBlob::from(vec![source_line])
+    let mut v = vec![source_line];
+    v.reserve(10);
+    SourceLineListBlob::from(v)
 }
 
 #[no_mangle]
diff --git a/ruby-parser-cpp/src/string.rs b/ruby-parser-cpp/src/string.rs
@@ -18,7 +18,9 @@ pub extern "C" fn LIB_RUBY_PARSER_new_string_from_cstr(ptr: *const i8) -> String
 #[cfg(feature = "tests")]
 #[no_mangle]
 pub extern "C" fn lib_ruby_parser__test__make_string_foo() -> StringBlob {
-    StringBlob::from(String::from("foo"))
+    let mut s = String::from("foo");
+    s.reserve(10);
+    StringBlob::from(s)
 }
 
 #[no_mangle]
diff --git a/ruby-parser-cpp/src/token.rs b/ruby-parser-cpp/src/token.rs
@@ -43,8 +43,9 @@ pub extern "C" fn LIB_RUBY_PARSER_drop_token(token: *mut Token) {
 #[cfg(feature = "tests")]
 #[no_mangle]
 pub extern "C" fn lib_ruby_parser__test__make_token_list(token: TokenBlob) -> TokenListBlob {
-    let token = Token::from(token);
-    TokenListBlob::from(vec![token])
+    let mut v = vec![Token::from(token)];
+    v.reserve(10);
+    TokenListBlob::from(v)
 }
 
 #[no_mangle]
diff --git a/source_line.hpp b/source_line.hpp
@@ -26,8 +26,8 @@ namespace lib_ruby_parser
     {
     public:
         SourceLine *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         SourceLineList() = delete;
         SourceLineList(SourceLine *ptr, size_t len, size_t capacity);
diff --git a/string.hpp b/string.hpp
@@ -16,8 +16,8 @@ namespace lib_ruby_parser
     {
     public:
         char *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         String() = delete;
         String(char *ptr, size_t len, size_t capacity);
diff --git a/token.hpp b/token.hpp
@@ -47,8 +47,8 @@ namespace lib_ruby_parser
     {
     public:
         Token *ptr;
-        size_t len;
         size_t capacity;
+        size_t len;
 
         TokenList() = delete;
         TokenList(Token *ptr, size_t len, size_t capacity);
diff --git a/utils.hpp b/utils.hpp
@@ -53,48 +53,48 @@ T from_blob(B b)
     return std::move(u.t);
 }
 
-#define LIST_IMPL(LIST, ITEM, DROP)                       \
-    LIST::LIST(ITEM *ptr_,                                \
-               size_t len_,                               \
-               size_t capacity_) : ptr(ptr_),             \
-                                   len(len_),             \
-                                   capacity(capacity_) {} \
-                                                          \
-    extern "C"                                            \
-    {                                                     \
-        void DROP(LIST *list);                            \
-    }                                                     \
-    LIST::~LIST()                                         \
-    {                                                     \
-        DROP(this);                                       \
-        this->ptr = nullptr;                              \
-        this->len = 0;                                    \
-        this->capacity = 0;                               \
-    }                                                     \
-    LIST::LIST(LIST &&other)                              \
-    {                                                     \
-        this->ptr = other.ptr;                            \
-        this->len = other.len;                            \
-        this->capacity = other.capacity;                  \
-                                                          \
-        other.ptr = nullptr;                              \
-        other.len = 0;                                    \
-        other.capacity = 0;                               \
-    }                                                     \
-    LIST &LIST::operator=(LIST &&other)                   \
-    {                                                     \
-        this->ptr = other.ptr;                            \
-        this->len = other.len;                            \
-        this->capacity = other.capacity;                  \
-                                                          \
-        other.ptr = nullptr;                              \
-        other.len = 0;                                    \
-        other.capacity = 0;                               \
-                                                          \
-        return *this;                                     \
-    }                                                     \
-    class Ignore##LIST                                    \
-    {                                                     \
+#define LIST_IMPL(LIST, ITEM, DROP)                     \
+    LIST::LIST(ITEM *ptr_,                              \
+               size_t len_,                             \
+               size_t capacity_) : ptr(ptr_),           \
+                                   capacity(capacity_), \
+                                   len(len_) {}         \
+                                                        \
+    extern "C"                                          \
+    {                                                   \
+        void DROP(LIST *list);                          \
+    }                                                   \
+    LIST::~LIST()                                       \
+    {                                                   \
+        DROP(this);                                     \
+        this->ptr = nullptr;                            \
+        this->len = 0;                                  \
+        this->capacity = 0;                             \
+    }                                                   \
+    LIST::LIST(LIST &&other)                            \
+    {                                                   \
+        this->ptr = other.ptr;                          \
+        this->len = other.len;                          \
+        this->capacity = other.capacity;                \
+                                                        \
+        other.ptr = nullptr;                            \
+        other.len = 0;                                  \
+        other.capacity = 0;                             \
+    }                                                   \
+    LIST &LIST::operator=(LIST &&other)                 \
+    {                                                   \
+        this->ptr = other.ptr;                          \
+        this->len = other.len;                          \
+        this->capacity = other.capacity;                \
+                                                        \
+        other.ptr = nullptr;                            \
+        other.len = 0;                                  \
+        other.capacity = 0;                             \
+                                                        \
+        return *this;                                   \
+    }                                                   \
+    class Ignore##LIST                                  \
+    {                                                   \
     }
 
 #endif // LIB_RUBY_PARSER_UTILS_HPP

Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ namespace lib_ruby_parser`
`13`	`13`	`{`
`14`	`14`	`public:`
`15`	`15`	`char *ptr;`
`16`		`- size_t len;`
`17`	`16`	`size_t capacity;`
	`17`	`+ size_t len;`
`18`	`18`
`19`	`19`	`ByteList() = delete;`
`20`	`20`	`ByteList(char *ptr, size_t len, size_t capacity);`
Original file line number	Diff line number	Diff line change
`@@ -81,8 +81,8 @@ namespace lib_ruby_parser`
`81`	`81`	`{`
`82`	`82`	`public:`
`83`	`83`	`DiagnosticMessage *ptr;`
`84`		`- size_t len;`
`85`	`84`	`size_t capacity;`
	`85`	`+ size_t len;`
`86`	`86`
`87`	`87`	`DiagnosticMessageList() = delete;`
`88`	`88`	`DiagnosticMessageList(DiagnosticMessage *ptr, size_t len, size_t capacity);`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ namespace lib_ruby_parser`
`17`	`17`	`{`
`18`	`18`	`public:`
`19`	`19`	`Node *ptr;`
`20`		`- size_t len;`
`21`	`20`	`size_t capacity;`
	`21`	`+ size_t len;`
`22`	`22`
`23`	`23`	`NodeList() = delete;`
`24`	`24`	`NodeList(Node *ptr, size_t len, size_t capacity);`
Original file line number	Diff line number	Diff line change
`@@ -49,8 +49,8 @@ namespace lib_ruby_parser`
`49`	`49`	`{`
`50`	`50`	`public:`
`51`	`51`	`Comment *ptr;`
`52`		`- size_t len;`
`53`	`52`	`size_t capacity;`
	`53`	`+ size_t len;`
`54`	`54`
`55`	`55`	`CommentList() = delete;`
`56`	`56`	`CommentList(Comment *ptr, size_t len, size_t capacity);`
Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,8 @@ namespace lib_ruby_parser`
`62`	`62`	`{`
`63`	`63`	`public:`
`64`	`64`	`Diagnostic *ptr;`
`65`		`- size_t len;`
`66`	`65`	`size_t capacity;`
	`66`	`+ size_t len;`
`67`	`67`
`68`	`68`	`DiagnosticList() = delete;`
`69`	`69`	`DiagnosticList(Diagnostic *ptr, size_t len, size_t capacity);`
Original file line number	Diff line number	Diff line change
`@@ -44,8 +44,8 @@ namespace lib_ruby_parser`
`44`	`44`	`{`
`45`	`45`	`public:`
`46`	`46`	`MagicComment *ptr;`
`47`		`- size_t len;`
`48`	`47`	`size_t capacity;`
	`48`	`+ size_t len;`
`49`	`49`
`50`	`50`	`MagicCommentList() = delete;`
`51`	`51`	`MagicCommentList(MagicComment *ptr, size_t len, size_t capacity);`