wip: Add vm

Author: Rexagon

Cargo.lock

@@ -20,23 +20,26 @@ anyhow = "1.0"
 base64 = "0.22"
 crc = "3.0"
 dyn-clone = "1.0"
-everscale-crypto = "0.2"
+everscale-crypto = "0.3.0"
 hex = "0.4"
 num-bigint = "0.4"
 num-integer = "0.1"
 num-traits = "0.2"
 rand = "0.8"
 sha2 = "0.10"
-thiserror = "1.0"
+thiserror = "2.0"
 unicode-segmentation = "1.0"
 
 everscale-types = { version = "0.1.2", default-features = false, features = [
     "sync",
     "base64",
     "models",
 ] }
+tycho-vm = { git = "https://github.com/broxus/tycho-vm.git", features = [
+    "dump",
+], rev = "a96840aab2d481019119bcc254dba538d559780a" }
 
 fift-proc = { path = "./proc", version = "=0.1.15" }
 
 [patch.crates-io]
-everscale-types = { git = "https://github.com/broxus/everscale-types.git", rev = "6e3c289f9bbf46337b11b24656a9c87ce409323e" }
+everscale-types = { git = "https://github.com/broxus/everscale-types.git", rev = "3b71c951d876213ad4e03f071182be0b1711d77c" }

Cargo.toml

@@ -19,6 +19,7 @@ bitflags = "2.3"
 console = "0.15"
 rustyline = { version = "15.0", default-features = false }
 unicode-width = "0.2"
+tycho-vm = { git = "https://github.com/broxus/tycho-vm.git", rev = "a96840aab2d481019119bcc254dba538d559780a" }
 
 fift = { path = "..", version = "=0.1.23" }
 fift-libs = { path = "../libs", version = "0.1.23" }

cli/Cargo.toml

@@ -4,10 +4,9 @@ use std::process::ExitCode;
 use anyhow::Result;
 use argh::FromArgs;
 use console::style;
-use unicode_width::UnicodeWidthStr;
-
 use fift::core::lexer::LexerPosition;
 use fift::core::{Environment, SourceBlock};
+use unicode_width::UnicodeWidthStr;
 
 use self::env::SystemEnvironment;
 use self::input::LineReader;

cli/src/main.rs

@@ -1,22 +1,22 @@
 use std::rc::Rc;
 
 use anyhow::Result;
-
 use fift::core::*;
+use tycho_vm::SafeRc;
 
 pub struct CmdArgsUtils {
-    name: Rc<dyn StackValue>,
-    args: Vec<Rc<dyn StackValue>>,
+    name: SafeRc<dyn StackValue>,
+    args: Vec<SafeRc<dyn StackValue>>,
 }
 
 impl CmdArgsUtils {
     pub fn new(args: Vec<String>) -> Self {
         let mut args = args.into_iter();
 
-        let name = Rc::new(args.next().unwrap_or_default()) as Rc<dyn StackValue>;
+        let name = SafeRc::new_dyn_fift_value(args.next().unwrap_or_default());
 
         let args = args
-            .map(|value| Rc::new(value) as Rc<dyn StackValue>)
+            .map(|value| SafeRc::new_dyn_fift_value(value))
             .collect::<Vec<_>>();
 
         Self { name, args }
@@ -27,28 +27,42 @@ impl CmdArgsUtils {
 impl CmdArgsUtils {
     #[init]
     fn init(&self, d: &mut Dictionary) -> Result<()> {
-        d.define_word("$0 ", Rc::new(cont::LitCont(self.name.clone())))?;
+        d.define_word(
+            "$0 ",
+            Cont::new_dyn_fift_cont(cont::LitCont(self.name.clone())),
+        )?;
 
         let mut list = Stack::make_null();
         for (i, arg) in self.args.iter().enumerate().rev() {
             list = cons(arg.clone(), list);
-            d.define_word(format!("${} ", i + 1), Rc::new(cont::LitCont(arg.clone())))?;
+            d.define_word(
+                format!("${} ", i + 1),
+                Cont::new_dyn_fift_cont(cont::LitCont(arg.clone())),
+            )?;
         }
 
-        d.define_word("$# ", Rc::new(cont::IntLitCont::from(self.args.len())))?;
+        d.define_word(
+            "$# ",
+            Cont::new_dyn_fift_cont(cont::IntLitCont::from(self.args.len())),
+        )?;
 
         let mut all_args = Vec::with_capacity(1 + self.args.len());
         all_args.push(self.name.clone());
         all_args.extend_from_slice(&self.args);
-        d.define_word("$() ", Rc::new(CmdArgCont(all_args)))?;
+        d.define_word("$() ", Cont::new_dyn_fift_cont(CmdArgCont(all_args)))?;
 
-        d.define_word("$* ", Rc::new(cont::LitCont(Rc::new(SharedBox::new(list)))))?;
+        d.define_word(
+            "$* ",
+            Cont::new_dyn_fift_cont(cont::LitCont(SafeRc::new_dyn_fift_value(SharedBox::new(
+                list,
+            )))),
+        )?;
 
         Ok(())
     }
 }
 
-struct CmdArgCont(Vec<Rc<dyn StackValue>>);
+struct CmdArgCont(Vec<SafeRc<dyn StackValue>>);
 
 impl ContImpl for CmdArgCont {
     fn run(self: Rc<Self>, ctx: &mut Context) -> Result<Option<Cont>> {
@@ -65,6 +79,6 @@ impl ContImpl for CmdArgCont {
     }
 }
 
-fn cons(head: Rc<dyn StackValue>, tail: Rc<dyn StackValue>) -> Rc<dyn StackValue> {
-    Rc::new(vec![head, tail])
+fn cons(head: SafeRc<dyn StackValue>, tail: SafeRc<dyn StackValue>) -> SafeRc<dyn StackValue> {
+    SafeRc::new_dyn_fift_value(vec![head, tail])
 }

cli/src/modules/args.rs

@@ -3,7 +3,6 @@ use std::process::Stdio;
 
 use anyhow::{Context as _, Result};
 use bitflags::bitflags;
-
 use fift::core::*;
 
 pub struct ShellUtils;

cli/src/modules/shell.rs

@@ -0,0 +1,5 @@
+format_code_in_doc_comments = true
+imports_granularity = "Module"
+normalize_comments = true
+overflow_delimited_expr = true
+group_imports = "StdExternalCrate"

rustfmt.toml

@@ -3,13 +3,46 @@ use std::rc::Rc;
 
 use anyhow::Result;
 use num_bigint::BigInt;
+use tycho_vm::{SafeDelete, SafeRc};
 
 use super::{Context, Dictionary, Stack, StackValue, StackValueType, WordList};
+use crate::core::DynFiftValue;
 use crate::util::*;
 
-pub type Cont = Rc<dyn ContImpl>;
+pub trait DynFiftCont {
+    fn new_dyn_fift_cont<T: ContImpl + 'static>(cont: T) -> Cont;
+}
+
+impl DynFiftCont for Cont {
+    #[inline]
+    fn new_dyn_fift_cont<T: ContImpl + 'static>(cont: T) -> Cont {
+        let cont: Rc<dyn ContImpl> = Rc::new(cont);
+        Cont::from(cont)
+    }
+}
+
+pub trait IntoDynFiftCont {
+    fn into_dyn_fift_cont(self) -> Cont;
+}
+
+impl<T: ContImpl> IntoDynFiftCont for Rc<T> {
+    #[inline]
+    fn into_dyn_fift_cont(self) -> Cont {
+        let this: Rc<dyn ContImpl> = self;
+        Cont::from(this)
+    }
+}
 
-pub trait ContImpl {
+impl<T: ContImpl> IntoDynFiftCont for SafeRc<T> {
+    #[inline]
+    fn into_dyn_fift_cont(self) -> Cont {
+        Rc::<T>::into_dyn_fift_cont(SafeRc::into_inner(self))
+    }
+}
+
+pub type Cont = SafeRc<dyn ContImpl>;
+
+pub trait ContImpl: SafeDelete {
     fn run(self: Rc<Self>, ctx: &mut Context) -> Result<Option<Cont>>;
 
     fn up(&self) -> Option<&Cont> {
@@ -85,10 +118,12 @@ pub struct InterpreterCont;
 impl ContImpl for InterpreterCont {
     fn run(self: Rc<Self>, ctx: &mut Context) -> Result<Option<Cont>> {
         thread_local! {
-            static COMPILE_EXECUTE: Cont = Rc::new(CompileExecuteCont);
+            static COMPILE_EXECUTE: Cont = SafeRc::new_dyn_fift_cont(CompileExecuteCont);
             static WORD: RefCell<String> = RefCell::new(String::with_capacity(128));
         };
 
+        let this = self.into_dyn_fift_cont();
+
         ctx.stdout.flush()?;
 
         let compile_exec = COMPILE_EXECUTE.with(|c| c.clone());
@@ -154,7 +189,7 @@ impl ContImpl for InterpreterCont {
                 if entry.active {
                     ctx.next = SeqCont::make(
                         Some(compile_exec),
-                        SeqCont::make(Some(self), ctx.next.take()),
+                        SeqCont::make(Some(this), ctx.next.take()),
                     );
                     return Ok(Some(entry.definition.clone()));
                 } else {
@@ -164,11 +199,11 @@ impl ContImpl for InterpreterCont {
             };
 
             ctx.exit_interpret.store(match &ctx.next {
-                Some(next) => Rc::new(next.clone()),
+                Some(next) => SafeRc::new_dyn_fift_value(next.clone()),
                 None => NopCont::value_instance(),
             });
 
-            ctx.next = SeqCont::make(Some(self), ctx.next.take());
+            ctx.next = SeqCont::make(Some(this), ctx.next.take());
             break Ok(Some(compile_exec));
         }
     }
@@ -215,20 +250,20 @@ impl ContImpl for ListCont {
                 ctx.next = if is_last {
                     this.after.take()
                 } else {
-                    Some(self)
+                    Some(self.into_dyn_fift_cont())
                 };
             }
             None => {
                 if let Some(next) = ctx.next.take() {
-                    ctx.next = Some(Rc::new(ListCont {
+                    ctx.next = Some(Cont::new_dyn_fift_cont(ListCont {
                         after: SeqCont::make(self.after.clone(), Some(next)),
                         list: self.list.clone(),
                         pos: self.pos + 1,
                     }))
                 } else if is_last {
                     ctx.next = self.after.clone()
                 } else {
-                    ctx.next = Some(Rc::new(ListCont {
+                    ctx.next = Some(Cont::new_dyn_fift_cont(ListCont {
                         after: self.after.clone(),
                         list: self.list.clone(),
                         pos: self.pos + 1,
@@ -287,9 +322,9 @@ pub struct NopCont;
 
 impl NopCont {
     thread_local! {
-        static INSTANCE: (Cont, Rc<dyn StackValue>) = {
-            let cont = Rc::new(NopCont);
-            let value: Rc<dyn StackValue> = Rc::new(cont.clone() as Rc<dyn ContImpl>);
+        static INSTANCE: (Cont, SafeRc<dyn StackValue>) = {
+            let cont = Cont::new_dyn_fift_cont(NopCont);
+            let value: SafeRc<dyn StackValue> = SafeRc::new_dyn_fift_value(cont.clone());
             (cont, value)
         };
     }
@@ -298,12 +333,12 @@ impl NopCont {
         Self::INSTANCE.with(|(c, _)| c.clone())
     }
 
-    pub fn value_instance() -> Rc<dyn StackValue> {
+    pub fn value_instance() -> SafeRc<dyn StackValue> {
         Self::INSTANCE.with(|(_, v)| v.clone())
     }
 
     pub fn is_nop(cont: &dyn ContImpl) -> bool {
-        let left = Self::INSTANCE.with(|(c, _)| Rc::as_ptr(c) as *const ());
+        let left = Self::INSTANCE.with(|(c, _)| SafeRc::as_ptr(c) as *const ());
         let right = cont as *const _ as *const ();
         std::ptr::eq(left, right)
     }
@@ -329,7 +364,7 @@ impl SeqCont {
         if second.is_none() {
             first
         } else if let Some(first) = first {
-            Some(Rc::new(Self {
+            Some(Cont::new_dyn_fift_cont(Self {
                 first: Some(first),
                 second,
             }))
@@ -349,7 +384,7 @@ impl ContImpl for SeqCont {
                 } else {
                     let result = std::mem::replace(&mut this.first, this.second.take());
                     this.second = ctx.next.take();
-                    ctx.next = Some(self);
+                    ctx.next = Some(self.into_dyn_fift_cont());
                     result
                 }
             }
@@ -395,7 +430,7 @@ impl ContImpl for TimesCont {
                 if this.count > 1 {
                     this.count -= 1;
                     let body = this.body.clone();
-                    ctx.next = Some(self);
+                    ctx.next = Some(self.into_dyn_fift_cont());
                     body
                 } else {
                     ctx.next = this.after.take();
@@ -406,7 +441,7 @@ impl ContImpl for TimesCont {
                 let next = SeqCont::make(self.after.clone(), ctx.next.take());
 
                 ctx.next = if self.count > 1 {
-                    Some(Rc::new(Self {
+                    Some(Cont::new_dyn_fift_cont(Self {
                         body: self.body.clone(),
                         after: next,
                         count: self.count - 1,
@@ -468,7 +503,7 @@ impl ContImpl for UntilCont {
                 }
             }
         };
-        ctx.next = Some(next);
+        ctx.next = Some(next.into_dyn_fift_cont());
         Ok(body)
     }
 
@@ -535,7 +570,7 @@ impl ContImpl for WhileCont {
             }),
         };
 
-        ctx.next = Some(next);
+        ctx.next = Some(next.into_dyn_fift_cont());
         Ok(cont)
     }
 
@@ -582,7 +617,7 @@ impl<T> LoopCont<T> {
 impl<T: LoopContImpl + 'static> ContImpl for LoopCont<T> {
     fn run(mut self: Rc<Self>, ctx: &mut Context) -> Result<Option<Cont>> {
         let Some(this) = Rc::get_mut(&mut self) else {
-            return Ok(Some(Rc::new(Self {
+            return Ok(Some(SafeRc::new_dyn_fift_cont(Self {
                 inner: self.inner.clone(),
                 state: self.state,
                 func: self.func.clone(),
@@ -606,7 +641,7 @@ impl<T: LoopContImpl + 'static> ContImpl for LoopCont<T> {
                     }
                     this.state = LoopContState::PostExec;
                     let res = self.func.clone();
-                    ctx.next = Some(self);
+                    ctx.next = Some(self.into_dyn_fift_cont());
                     break Some(res);
                 }
                 LoopContState::PostExec => {
@@ -615,7 +650,7 @@ impl<T: LoopContImpl + 'static> ContImpl for LoopCont<T> {
                         continue;
                     }
                     this.state = LoopContState::PreExec;
-                    break Some(self);
+                    break Some(self.into_dyn_fift_cont());
                 }
                 LoopContState::Finalize => {
                     break if this.inner.finalize(ctx)? {
@@ -686,7 +721,7 @@ impl ContImpl for IntLitCont {
     }
 }
 
-pub struct LitCont(pub Rc<dyn StackValue>);
+pub struct LitCont(pub SafeRc<dyn StackValue>);
 
 impl ContImpl for LitCont {
     fn run(self: Rc<Self>, ctx: &mut Context) -> Result<Option<Cont>> {
@@ -703,7 +738,7 @@ impl ContImpl for LitCont {
     }
 }
 
-pub struct MultiLitCont(pub Vec<Rc<dyn StackValue>>);
+pub struct MultiLitCont(pub Vec<SafeRc<dyn StackValue>>);
 
 impl ContImpl for MultiLitCont {
     fn run(self: Rc<Self>, ctx: &mut Context) -> Result<Option<Cont>> {
@@ -778,7 +813,7 @@ impl Context<'_> {
     fn insert_before_next(&mut self, cont: &mut Option<Cont>) {
         if let Some(next) = self.next.take() {
             *cont = match cont.take() {
-                Some(prev) => Some(Rc::new(SeqCont {
+                Some(prev) => Some(Cont::new_dyn_fift_cont(SeqCont {
                     first: Some(prev),
                     second: Some(next),
                 })),