Update dependencies

Author: Rexagon

Cargo.lock

@@ -17,7 +17,7 @@ members = ["proc", "cli", "libs"]
 [dependencies]
 ahash = "0.8"
 anyhow = "1.0"
-base64 = "0.21"
+base64 = "0.22"
 crc = "3.0"
 dyn-clone = "1.0"
 everscale-crypto = "0.2"
@@ -30,10 +30,13 @@ sha2 = "0.10"
 thiserror = "1.0"
 unicode-segmentation = "1.0"
 
-everscale-types = { version = "0.1.0-rc.6", default-features = false, features = [
+everscale-types = { version = "0.1.2", default-features = false, features = [
     "sync",
     "base64",
     "models",
 ] }
 
 fift-proc = { path = "./proc", version = "=0.1.15" }
+
+[patch.crates-io]
+everscale-types = { git = "https://github.com/broxus/everscale-types.git", rev = "6e3c289f9bbf46337b11b24656a9c87ce409323e" }

Cargo.toml

@@ -17,8 +17,8 @@ anyhow = "1.0"
 argh = "0.1"
 bitflags = "2.3"
 console = "0.15"
-rustyline = { version = "12.0", default-features = false }
-unicode-width = "0.1"
+rustyline = { version = "15.0", default-features = false }
+unicode-width = "0.2"
 
 fift = { path = "..", version = "=0.1.23" }
 fift-libs = { path = "../libs", version = "0.1.23" }

cli/Cargo.toml

@@ -47,6 +47,7 @@ struct App {
     source_files: Vec<String>,
 }
 
+#[allow(unused)]
 #[derive(Default)]
 struct ScriptModeDelim;
 

cli/src/main.rs

@@ -13,4 +13,4 @@ proc-macro = true
 [dependencies]
 quote = "1.0"
 syn = "2.0"
-darling = "0.20"
+darling = "0.20.10"

proc/Cargo.toml

@@ -772,7 +772,7 @@ impl ContImpl for StackWordFunc {
     }
 }
 
-/// === impl Context ===
+// === impl Context ===
 
 impl Context<'_> {
     fn insert_before_next(&mut self, cont: &mut Option<Cont>) {

src/core/cont.rs

@@ -426,8 +426,8 @@ define_stack_value! {
         Builder(CellBuilder) = {
             eq(a, b) = a == b,
             fmt_dump(v, f) = {
-                let bytes = (v.bit_len() + 7) / 8;
-                write!(f, "BC{{{}, bits={}}}", hex::encode(&v.raw_data()[..bytes as usize]), v.bit_len())
+                let bytes = (v.size_bits() + 7) / 8;
+                write!(f, "BC{{{}, bits={}}}", hex::encode(&v.raw_data()[..bytes as usize]), v.size_bits())
             },
             as_builder(v): &CellBuilder = Ok(v),
             into_builder,
@@ -642,7 +642,7 @@ impl From<CellSliceParts> for OwnedCellSlice {
 impl PartialEq<CellSlice<'_>> for OwnedCellSlice {
     fn eq(&self, right: &CellSlice<'_>) -> bool {
         if let Ok(left) = self.apply() {
-            if let Ok(std::cmp::Ordering::Equal) = left.cmp_by_content(right) {
+            if let Ok(std::cmp::Ordering::Equal) = left.lex_cmp(right) {
                 return true;
             }
         }

src/core/stack.rs

@@ -132,7 +132,7 @@ impl CellUtils {
         let mut cb1 = stack.pop_builder()?;
         {
             let cb1 = Rc::make_mut(&mut cb1);
-            cb1.store_raw(cb2.raw_data(), cb2.bit_len())?;
+            cb1.store_raw(cb2.raw_data(), cb2.size_bits())?;
             for cell in cb2.references() {
                 cb1.store_reference(cell.clone())?;
             }
@@ -146,7 +146,7 @@ impl CellUtils {
     fn interpret_builder_bitrefs(stack: &mut Stack, bits: bool, refs: bool) -> Result<()> {
         let cb = stack.pop_builder()?;
         if bits {
-            stack.push_int(cb.bit_len())?;
+            stack.push_int(cb.size_bits())?;
         }
         if refs {
             stack.push_int(cb.references().len())?;
@@ -160,7 +160,7 @@ impl CellUtils {
     fn interpret_builder_rem_bitrefs(stack: &mut Stack, bits: bool, refs: bool) -> Result<()> {
         let cb = stack.pop_builder()?;
         if bits {
-            stack.push_int(MAX_BIT_LEN - cb.bit_len())?;
+            stack.push_int(MAX_BIT_LEN - cb.size_bits())?;
         }
         if refs {
             stack.push_int(MAX_REF_COUNT - cb.references().len())?;
@@ -207,9 +207,9 @@ impl CellUtils {
         let mut cs_raw = stack.pop_slice()?;
 
         let mut range = cs_raw.range();
-        if !range.try_advance(bits, refs) {
+        if let Err(e) = range.skip_first(bits, refs) {
             if !quiet {
-                anyhow::bail!(everscale_types::error::Error::CellUnderflow);
+                anyhow::bail!(e);
             }
             if adv {
                 stack.push_raw(cs_raw)?;
@@ -385,10 +385,10 @@ impl CellUtils {
     fn interpret_slice_bitrefs(stack: &mut Stack, bits: bool, refs: bool) -> Result<()> {
         let cs = stack.pop_slice()?;
         if bits {
-            stack.push_int(cs.range().remaining_bits())?;
+            stack.push_int(cs.range().size_bits())?;
         }
         if refs {
-            stack.push_int(cs.range().remaining_refs())?;
+            stack.push_int(cs.range().size_refs())?;
         }
         Ok(())
     }
@@ -461,7 +461,7 @@ impl CellUtils {
         let cell = stack.pop_cell()?;
 
         let mut result = Vec::new();
-        BocHeader::<ahash::RandomState>::new(&**cell)
+        BocHeader::<ahash::RandomState>::with_root(&**cell)
             .with_crc(mode & MODE_WITH_CRC != 0)
             .encode(&mut result);
 
@@ -532,8 +532,8 @@ impl<'a> StorageStat<'a> {
     }
 
     fn add_slice<'b: 'a>(&mut self, slice: &'a CellSlice<'b>) -> bool {
-        self.bits = self.bits.saturating_add(slice.remaining_bits() as u64);
-        self.refs = self.refs.saturating_add(slice.remaining_refs() as u64);
+        self.bits = self.bits.saturating_add(slice.size_bits() as u64);
+        self.refs = self.refs.saturating_add(slice.size_refs() as u64);
 
         for cell in slice.references() {
             if !self.add_cell(cell) {

src/modules/cell_utils.rs

@@ -69,7 +69,7 @@ impl DictUtils {
         let mut cell = pop_maybe_cell(stack)?;
         let key = pop_dict_key(stack, key, bits)?;
         anyhow::ensure!(
-            key.range().remaining_bits() >= bits,
+            key.range().size_bits() >= bits,
             "Not enough bits for a dictionary key"
         );
 
@@ -106,7 +106,7 @@ impl DictUtils {
         let cell = pop_maybe_cell(stack)?;
         let key = pop_dict_key(stack, key, bits)?;
         anyhow::ensure!(
-            key.range().remaining_bits() >= bits,
+            key.range().size_bits() >= bits,
             "Not enough bits for a dictionary key"
         );
 
@@ -136,7 +136,7 @@ impl DictUtils {
         let mut dict = pop_maybe_cell(stack)?;
         let key = pop_dict_key(stack, key, bits)?;
         anyhow::ensure!(
-            key.range().remaining_bits() >= bits,
+            key.range().size_bits() >= bits,
             "Not enough bits for a dictionary key"
         );
 
@@ -266,7 +266,7 @@ impl LoopContImpl for DictMapCont {
             dict_insert(
                 &mut self.result,
                 &mut key.as_data_slice(),
-                key.bit_len(),
+                key.size_bits(),
                 &value.as_full_slice(),
                 SetMode::Set,
                 &mut Cell::empty_context(),
@@ -305,7 +305,7 @@ impl LoopContImpl for DictDiffCont {
                         let (key, left_value) = self.left.next().unwrap()?;
                         let (_, right_value) = self.right.next().unwrap()?;
 
-                        if left_value.apply()?.cmp_by_content(&right_value.apply()?)?
+                        if left_value.apply()?.lex_cmp(&right_value.apply()?)?
                             == std::cmp::Ordering::Equal
                         {
                             continue;
@@ -379,7 +379,7 @@ impl LoopContImpl for DictMergeCont {
             dict_insert(
                 &mut self.result,
                 &mut key.as_data_slice(),
-                key.bit_len(),
+                key.size_bits(),
                 &value.apply()?,
                 SetMode::Set,
                 &mut Cell::empty_context(),
@@ -407,7 +407,7 @@ impl LoopContImpl for DictMergeCont {
             dict_insert(
                 &mut self.result,
                 &mut key.as_data_slice(),
-                key.bit_len(),
+                key.size_bits(),
                 &value.as_full_slice(),
                 SetMode::Set,
                 &mut Cell::empty_context(),
@@ -465,7 +465,8 @@ impl OwnedDictIter {
 
         // SAFETY: iter lifetime is bounded to the `DynCell` which lives as long
         // as `Cell` lives. By storing root we guarantee that it will live enough.
-        let inner = unsafe { std::mem::transmute::<_, dict::RawIter<'static>>(inner) };
+        let inner =
+            unsafe { std::mem::transmute::<dict::RawIter<'_>, dict::RawIter<'static>>(inner) };
 
         Self { root, inner }
     }
@@ -518,7 +519,7 @@ fn pop_dict_key(stack: &mut Stack, key_mode: KeyMode, bits: u16) -> Result<Owned
 }
 
 fn builder_to_int(builder: &CellBuilder, signed: bool) -> Result<BigInt> {
-    let bits = builder.bit_len();
+    let bits = builder.size_bits();
     anyhow::ensure!(
         bits <= (256 + signed as u16),
         "Key does not fit into integer"

src/modules/dict_utils.rs

@@ -744,7 +744,7 @@ struct DispatchTable {
 
 impl DispatchTable {
     fn get_opcode_from_slice(slice: &CellSlice<'_>) -> (u32, u16) {
-        let bits = std::cmp::min(MAX_OPCODE_BITS, slice.remaining_bits());
+        let bits = std::cmp::min(MAX_OPCODE_BITS, slice.size_bits());
         let opcode = (slice.get_uint(0, bits).unwrap() as u32) << (MAX_OPCODE_BITS - bits);
         (opcode, bits)
     }
@@ -992,7 +992,7 @@ impl Opcode for SimpleOpcode {
         f: &mut dyn std::fmt::Write,
     ) -> Result<()> {
         if bits >= self.bits {
-            slice.try_advance(self.bits, 0);
+            slice.skip_first(self.bits, 0)?;
             f.write_str(self.name)?;
         }
         Ok(())
@@ -1023,7 +1023,7 @@ impl Opcode for FixedOpcode {
         f: &mut dyn std::fmt::Write,
     ) -> Result<()> {
         if bits >= self.total_bits {
-            slice.try_advance(self.total_bits, 0);
+            slice.skip_first(self.total_bits, 0)?;
             (self.dump)(slice, opcode >> (MAX_OPCODE_BITS - self.total_bits), f)?;
         }
         Ok(())
@@ -1253,7 +1253,7 @@ fn dump_push_int(
         return Ok(());
     }
 
-    cs.try_advance(bits, 0);
+    cs.skip_first(bits, 0)?;
 
     let mut bytes = [0u8; 33];
     let rem = value_len % 8;
@@ -1276,7 +1276,7 @@ fn dump_push_ref(name: &'static str) -> Box<FnDumpInstr> {
         if !cs.has_remaining(0, 1) {
             return Ok(());
         }
-        cs.try_advance(bits, 0);
+        cs.skip_first(bits, 0)?;
         let cell = cs.load_reference()?;
         write!(f, "{name} ({})", cell.repr_hash())?;
         Ok(())
@@ -1296,7 +1296,7 @@ fn dump_push_ref2(name: &'static str) -> Box<FnDumpInstr> {
         if !cs.has_remaining(0, 2) {
             return Ok(());
         }
-        cs.try_advance(bits, 0);
+        cs.skip_first(bits, 0)?;
         let cell1 = cs.load_reference()?;
         let cell2 = cs.load_reference()?;
         write!(f, "{name} ({}) ({})", cell1.repr_hash(), cell2.repr_hash())?;
@@ -1327,7 +1327,7 @@ fn dump_if_bit_jmpref(
     if cs.is_refs_empty() {
         return Ok(());
     }
-    cs.try_advance(bits, 1);
+    cs.skip_first(bits, 1)?;
     let neg = if args & 0x20 != 0 { "N" } else { "" };
     write!(f, "IF{neg}BITJMPREF {}", args & 0x1f)?;
     Ok(())
@@ -1422,9 +1422,9 @@ fn dump_push_const_dict(name: &'static str) -> Box<FnDumpInstr> {
         if !cs.has_remaining(bits, 1) {
             return Ok(());
         }
-        cs.try_advance(bits - 11, 0);
+        cs.skip_first(bits - 11, 0)?;
         let slice = cs.get_prefix(1, 1);
-        cs.try_advance(1, 1);
+        cs.skip_first(1, 1)?;
         let n = cs.load_uint(10)?;
 
         write!(f, "{name} {n} (x{})", slice.display_data())?;
@@ -1549,14 +1549,14 @@ fn dump_push_slice_ext(
     if !cs.has_remaining(bits + slice_bits, slice_refs) {
         return Ok(());
     }
-    cs.try_advance(bits, 0);
+    cs.skip_first(bits, 0)?;
     let mut slice = cs.get_prefix(slice_bits, slice_refs);
-    cs.try_advance(slice_bits, slice_refs);
+    cs.skip_first(slice_bits, slice_refs)?;
     slice_trim_end(&mut slice)?;
 
     write!(f, "{name} x{}", slice.display_data())?;
     if !slice.is_refs_empty() {
-        write!(f, ",{}", slice.remaining_refs())?;
+        write!(f, ",{}", slice.size_refs())?;
     }
     Ok(())
 }
@@ -1581,14 +1581,14 @@ fn dump_dummy_debug_str(
     if !cs.has_remaining(bits + slice_bits, 0) {
         return Ok(());
     }
-    cs.try_advance(bits, 0);
+    cs.skip_first(bits, 0)?;
     let mut slice = cs.get_prefix(slice_bits, 0);
-    cs.try_advance(slice_bits, 0);
+    cs.skip_first(slice_bits, 0)?;
     slice_trim_end(&mut slice)?;
 
     write!(f, "DEBUGSTR x{}", slice.display_data())?;
     if !slice.is_refs_empty() {
-        write!(f, ",{}", slice.remaining_refs())?;
+        write!(f, ",{}", slice.size_refs())?;
     }
     Ok(())
 }
@@ -1638,7 +1638,7 @@ fn dump_store_cont_ref(
     if !cs.has_remaining(0, refs) {
         return Ok(());
     }
-    cs.try_advance(bits, refs);
+    cs.skip_first(bits, refs)?;
     if refs > 1 {
         write!(f, "STREF{refs}CONST")?;
     } else {
@@ -1861,20 +1861,20 @@ fn dump_shldivmod(has_y: bool, quiet: bool) -> Box<FnDumpArgInstr> {
 }
 
 fn slice_trim_end(slice: &mut CellSlice<'_>) -> Result<()> {
-    let bits = slice.remaining_bits();
+    let bits = slice.size_bits();
     if bits == 0 {
         return Ok(());
     }
     let mut trailing = slice_trailing_zeros(slice)?;
     if bits != trailing {
         trailing = trailing.saturating_add(1);
     }
-    *slice = slice.get_prefix(bits - trailing, slice.remaining_refs());
+    *slice = slice.get_prefix(bits - trailing, slice.size_refs());
     Ok(())
 }
 
 fn slice_trailing_zeros(slice: &CellSlice<'_>) -> Result<u16> {
-    let mut bits = slice.remaining_bits();
+    let mut bits = slice.size_bits();
     if bits == 0 {
         return Ok(0);
     }