py: Remove mp_obj_str_builder and use vstr instead.

With this patch str/bytes construction is streamlined.  Always use a
vstr to build a str/bytes object.  If the size is known beforehand then
use vstr_init_len to allocate only required memory.  Otherwise use
vstr_init and the vstr will grow as needed.  Then use
mp_obj_new_str_from_vstr to create a str/bytes object using the vstr
memory.

Saves code ROM: 68 bytes on stmhal, 108 bytes on bare-arm, and 336 bytes
on unix x64.

8 files changed, 67 insertions, 62 deletions

diff --git a/stmhal/bufhelper.c b/stmhal/bufhelper.c
index 57aef5a91..ca76e9496 100644
--- a/stmhal/bufhelper.c
+++ b/stmhal/bufhelper.c
@@ -38,15 +38,17 @@ void pyb_buf_get_for_send(mp_obj_t o, mp_buffer_info_t *bufinfo, byte *tmp_data)
     }
 }
 
-mp_obj_t pyb_buf_get_for_recv(mp_obj_t o, mp_buffer_info_t *bufinfo) {
+mp_obj_t pyb_buf_get_for_recv(mp_obj_t o, vstr_t *vstr) {
     if (MP_OBJ_IS_INT(o)) {
         // allocate a new bytearray of given length
-        bufinfo->len = mp_obj_get_int(o);
-        bufinfo->typecode = 'B';
-        return mp_obj_str_builder_start(&mp_type_bytes, bufinfo->len, (byte**)&bufinfo->buf);
+        vstr_init_len(vstr, mp_obj_get_int(o));
+        return MP_OBJ_NULL;
     } else {
         // get the existing buffer
-        mp_get_buffer_raise(o, bufinfo, MP_BUFFER_WRITE);
-        return MP_OBJ_NULL;
+        mp_buffer_info_t bufinfo;
+        mp_get_buffer_raise(o, &bufinfo, MP_BUFFER_WRITE);
+        vstr->buf = bufinfo.buf;
+        vstr->len = bufinfo.len;
+        return o;
     }
 }
diff --git a/stmhal/bufhelper.h b/stmhal/bufhelper.h
index febbe7e4f..abdeea6a8 100644
--- a/stmhal/bufhelper.h
+++ b/stmhal/bufhelper.h
@@ -25,4 +25,4 @@
  */
 
 void pyb_buf_get_for_send(mp_obj_t o, mp_buffer_info_t *bufinfo, byte *tmp_data);
-mp_obj_t pyb_buf_get_for_recv(mp_obj_t o, mp_buffer_info_t *bufinfo);
+mp_obj_t pyb_buf_get_for_recv(mp_obj_t o, vstr_t *vstr);
diff --git a/stmhal/can.c b/stmhal/can.c
index 28f00c994..b10ecd13d 100644
--- a/stmhal/can.c
+++ b/stmhal/can.c
@@ -395,12 +395,12 @@ STATIC mp_obj_t pyb_can_recv(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_
     }
     tuple->items[1] = MP_OBJ_NEW_SMALL_INT(rx_msg.RTR);
     tuple->items[2] = MP_OBJ_NEW_SMALL_INT(rx_msg.FMI);
-    byte *data;
-    tuple->items[3] = mp_obj_str_builder_start(&mp_type_bytes, rx_msg.DLC, &data);
+    vstr_t vstr;
+    vstr_init_len(&vstr, rx_msg.DLC);
     for (mp_uint_t i = 0; i < rx_msg.DLC; i++) {
-        data[i] = rx_msg.Data[i]; // Data is uint32_t but holds only 1 byte
+        vstr.buf[i] = rx_msg.Data[i]; // Data is uint32_t but holds only 1 byte
     }
-    tuple->items[3] = mp_obj_str_builder_end(tuple->items[3]);
+    tuple->items[3] = mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
     return tuple;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_recv_obj, 1, pyb_can_recv);
diff --git a/stmhal/i2c.c b/stmhal/i2c.c
index e4d406b4a..80b40b887 100644
--- a/stmhal/i2c.c
+++ b/stmhal/i2c.c
@@ -418,8 +418,8 @@ STATIC mp_obj_t pyb_i2c_recv(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *k
     mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_I2C_RECV_NUM_ARGS, pyb_i2c_recv_args, vals);
 
     // get the buffer to receive into
-    mp_buffer_info_t bufinfo;
-    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &bufinfo);
+    vstr_t vstr;
+    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &vstr);
 
     // receive the data
     HAL_StatusTypeDef status;
@@ -428,9 +428,9 @@ STATIC mp_obj_t pyb_i2c_recv(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *k
             nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "addr argument required"));
         }
         mp_uint_t i2c_addr = vals[1].u_int << 1;
-        status = HAL_I2C_Master_Receive(self->i2c, i2c_addr, bufinfo.buf, bufinfo.len, vals[2].u_int);
+        status = HAL_I2C_Master_Receive(self->i2c, i2c_addr, (uint8_t*)vstr.buf, vstr.len, vals[2].u_int);
     } else {
-        status = HAL_I2C_Slave_Receive(self->i2c, bufinfo.buf, bufinfo.len, vals[2].u_int);
+        status = HAL_I2C_Slave_Receive(self->i2c, (uint8_t*)vstr.buf, vstr.len, vals[2].u_int);
     }
 
     if (status != HAL_OK) {
@@ -438,10 +438,10 @@ STATIC mp_obj_t pyb_i2c_recv(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *k
     }
 
     // return the received data
-    if (o_ret == MP_OBJ_NULL) {
-        return vals[0].u_obj;
+    if (o_ret != MP_OBJ_NULL) {
+        return o_ret;
     } else {
-        return mp_obj_str_builder_end(o_ret);
+        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_recv_obj, 1, pyb_i2c_recv);
@@ -479,8 +479,8 @@ STATIC mp_obj_t pyb_i2c_mem_read(mp_uint_t n_args, const mp_obj_t *args, mp_map_
     mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_I2C_MEM_READ_NUM_ARGS, pyb_i2c_mem_read_args, vals);
 
     // get the buffer to read into
-    mp_buffer_info_t bufinfo;
-    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &bufinfo);
+    vstr_t vstr;
+    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &vstr);
 
     // get the addresses
     mp_uint_t i2c_addr = vals[1].u_int << 1;
@@ -491,17 +491,17 @@ STATIC mp_obj_t pyb_i2c_mem_read(mp_uint_t n_args, const mp_obj_t *args, mp_map_
         mem_addr_size = I2C_MEMADD_SIZE_16BIT;
     }
 
-    HAL_StatusTypeDef status = HAL_I2C_Mem_Read(self->i2c, i2c_addr, mem_addr, mem_addr_size, bufinfo.buf, bufinfo.len, vals[3].u_int);
+    HAL_StatusTypeDef status = HAL_I2C_Mem_Read(self->i2c, i2c_addr, mem_addr, mem_addr_size, (uint8_t*)vstr.buf, vstr.len, vals[3].u_int);
 
     if (status != HAL_OK) {
         mp_hal_raise(status);
     }
 
     // return the read data
-    if (o_ret == MP_OBJ_NULL) {
-        return vals[0].u_obj;
+    if (o_ret != MP_OBJ_NULL) {
+        return o_ret;
     } else {
-        return mp_obj_str_builder_end(o_ret);
+        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_mem_read_obj, 1, pyb_i2c_mem_read);
diff --git a/stmhal/moduos.c b/stmhal/moduos.c
index 8706f4981..9f8de8046 100644
--- a/stmhal/moduos.c
+++ b/stmhal/moduos.c
@@ -322,12 +322,12 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_sync_obj, os_sync);
 /// random number generator.
 STATIC mp_obj_t os_urandom(mp_obj_t num) {
     mp_int_t n = mp_obj_get_int(num);
-    byte *data;
-    mp_obj_t o = mp_obj_str_builder_start(&mp_type_bytes, n, &data);
+    vstr_t vstr;
+    vstr_init_len(&vstr, n);
     for (int i = 0; i < n; i++) {
-        data[i] = rng_get();
+        vstr.buf[i] = rng_get();
     }
-    return mp_obj_str_builder_end(o);
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_urandom_obj, os_urandom);
 #endif
diff --git a/stmhal/modusocket.c b/stmhal/modusocket.c
index 781720b53..caa8843eb 100644
--- a/stmhal/modusocket.c
+++ b/stmhal/modusocket.c
@@ -201,17 +201,19 @@ STATIC mp_obj_t socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
         nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ENOTCONN)));
     }
     mp_int_t len = mp_obj_get_int(len_in);
-    byte *buf;
-    mp_obj_t ret_obj = mp_obj_str_builder_start(&mp_type_bytes, len, &buf);
+    vstr_t vstr;
+    vstr_init_len(&vstr, len);
     int _errno;
-    mp_uint_t ret = self->nic_type->recv(self, buf, len, &_errno);
+    mp_uint_t ret = self->nic_type->recv(self, (byte*)vstr.buf, len, &_errno);
     if (ret == -1) {
         nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
     }
     if (ret == 0) {
         return mp_const_empty_bytes;
     }
-    return mp_obj_str_builder_end_with_len(ret_obj, ret);
+    vstr.len = ret;
+    vstr.buf[vstr.len] = '\0';
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recv_obj, socket_recv);
 
@@ -248,25 +250,24 @@ STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
         // not connected
         nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ENOTCONN)));
     }
-    mp_int_t len = mp_obj_get_int(len_in);
-    byte *buf;
-    mp_obj_t ret_obj = mp_obj_str_builder_start(&mp_type_bytes, len, &buf);
+    vstr_t vstr;
+    vstr_init_len(&vstr, mp_obj_get_int(len_in));
     byte ip[4];
     mp_uint_t port;
     int _errno;
-    mp_int_t ret = self->nic_type->recvfrom(self, buf, len, ip, &port, &_errno);
+    mp_int_t ret = self->nic_type->recvfrom(self, (byte*)vstr.buf, vstr.len, ip, &port, &_errno);
     if (ret == -1) {
         nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
     }
+    mp_obj_t tuple[2];
     if (ret == 0) {
-        ret_obj = mp_const_empty_bytes;
+        tuple[0] = mp_const_empty_bytes;
     } else {
-        ret_obj = mp_obj_str_builder_end_with_len(ret_obj, ret);
+        vstr.len = ret;
+        vstr.buf[vstr.len] = '\0';
+        tuple[0] = mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
     }
-    mp_obj_t tuple[2] = {
-        ret_obj,
-        mod_network_format_inet_addr(ip, port),
-    };
+    tuple[1] = mod_network_format_inet_addr(ip, port);
     return mp_obj_new_tuple(2, tuple);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recvfrom_obj, socket_recvfrom);
diff --git a/stmhal/spi.c b/stmhal/spi.c
index 109bfe49e..6f8b8f1db 100644
--- a/stmhal/spi.c
+++ b/stmhal/spi.c
@@ -565,15 +565,15 @@ STATIC mp_obj_t pyb_spi_recv(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     // get the buffer to receive into
-    mp_buffer_info_t bufinfo;
-    mp_obj_t o_ret = pyb_buf_get_for_recv(args[0].u_obj, &bufinfo);
+    vstr_t vstr;
+    mp_obj_t o_ret = pyb_buf_get_for_recv(args[0].u_obj, &vstr);
 
     // receive the data
     HAL_StatusTypeDef status;
     if (query_irq() == IRQ_STATE_DISABLED) {
-        status = HAL_SPI_Receive(self->spi, bufinfo.buf, bufinfo.len, args[1].u_int);
+        status = HAL_SPI_Receive(self->spi, (uint8_t*)vstr.buf, vstr.len, args[1].u_int);
     } else {
-        status = HAL_SPI_Receive_DMA(self->spi, bufinfo.buf, bufinfo.len);
+        status = HAL_SPI_Receive_DMA(self->spi, (uint8_t*)vstr.buf, vstr.len);
         if (status == HAL_OK) {
             status = spi_wait_dma_finished(self->spi, args[1].u_int);
         }
@@ -584,10 +584,10 @@ STATIC mp_obj_t pyb_spi_recv(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_
     }
 
     // return the received data
-    if (o_ret == MP_OBJ_NULL) {
-        return args[0].u_obj;
+    if (o_ret != MP_OBJ_NULL) {
+        return o_ret;
     } else {
-        return mp_obj_str_builder_end(o_ret);
+        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_recv_obj, 1, pyb_spi_recv);
@@ -621,13 +621,14 @@ STATIC mp_obj_t pyb_spi_send_recv(mp_uint_t n_args, const mp_obj_t *pos_args, mp
     mp_buffer_info_t bufinfo_send;
     uint8_t data_send[1];
     mp_buffer_info_t bufinfo_recv;
+    vstr_t vstr_recv;
     mp_obj_t o_ret;
 
     if (args[0].u_obj == args[1].u_obj) {
         // same object for send and receive, it must be a r/w buffer
         mp_get_buffer_raise(args[0].u_obj, &bufinfo_send, MP_BUFFER_RW);
         bufinfo_recv = bufinfo_send;
-        o_ret = MP_OBJ_NULL;
+        o_ret = args[0].u_obj;
     } else {
         // get the buffer to send from
         pyb_buf_get_for_send(args[0].u_obj, &bufinfo_send, data_send);
@@ -635,16 +636,17 @@ STATIC mp_obj_t pyb_spi_send_recv(mp_uint_t n_args, const mp_obj_t *pos_args, mp
         // get the buffer to receive into
         if (args[1].u_obj == MP_OBJ_NULL) {
             // only send argument given, so create a fresh buffer of the send length
-            bufinfo_recv.len = bufinfo_send.len;
-            bufinfo_recv.typecode = 'B';
-            o_ret = mp_obj_str_builder_start(&mp_type_bytes, bufinfo_recv.len, (byte**)&bufinfo_recv.buf);
+            vstr_init_len(&vstr_recv, bufinfo_send.len);
+            bufinfo_recv.len = vstr_recv.len;
+            bufinfo_recv.buf = vstr_recv.buf;
+            o_ret = MP_OBJ_NULL;
         } else {
             // recv argument given
             mp_get_buffer_raise(args[1].u_obj, &bufinfo_recv, MP_BUFFER_WRITE);
             if (bufinfo_recv.len != bufinfo_send.len) {
                 nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "recv must be same length as send"));
             }
-            o_ret = MP_OBJ_NULL;
+            o_ret = args[1].u_obj;
         }
     }
 
@@ -664,10 +666,10 @@ STATIC mp_obj_t pyb_spi_send_recv(mp_uint_t n_args, const mp_obj_t *pos_args, mp
     }
 
     // return the received data
-    if (o_ret == MP_OBJ_NULL) {
-        return args[1].u_obj;
+    if (o_ret != MP_OBJ_NULL) {
+        return o_ret;
     } else {
-        return mp_obj_str_builder_end(o_ret);
+        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr_recv);
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_send_recv_obj, 1, pyb_spi_send_recv);
diff --git a/stmhal/usb.c b/stmhal/usb.c
index 0bda0aaeb..8ea5fb561 100644
--- a/stmhal/usb.c
+++ b/stmhal/usb.c
@@ -232,17 +232,17 @@ STATIC mp_obj_t pyb_usb_vcp_recv(mp_uint_t n_args, const mp_obj_t *args, mp_map_
     mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_USB_VCP_SEND_NUM_ARGS, pyb_usb_vcp_send_args, vals);
 
     // get the buffer to receive into
-    mp_buffer_info_t bufinfo;
-    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &bufinfo);
+    vstr_t vstr;
+    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &vstr);
 
     // receive the data
-    int ret = USBD_CDC_Rx(bufinfo.buf, bufinfo.len, vals[1].u_int);
+    int ret = USBD_CDC_Rx((uint8_t*)vstr.buf, vstr.len, vals[1].u_int);
 
     // return the received data
-    if (o_ret == MP_OBJ_NULL) {
+    if (o_ret != MP_OBJ_NULL) {
         return mp_obj_new_int(ret); // number of bytes read into given buffer
     } else {
-        return mp_obj_str_builder_end_with_len(o_ret, ret); // create a new buffer
+        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr); // create a new buffer
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_usb_vcp_recv_obj, 1, pyb_usb_vcp_recv);