refactor: Remove the global table from the vm

Author: Marwes

Cargo.lock

@@ -1,27 +1,24 @@
-extern crate gluon_base;
-extern crate itertools;
-extern crate walkdir;
+use std::{
+    env,
+    fs::File,
+    io::{Read, Write},
+    path::Path,
+};
 
-use std::env;
-use std::fs::File;
-use std::io::{Read, Write};
-use std::path::Path;
-
-use itertools::Itertools;
-
-use walkdir::WalkDir;
+use {itertools::Itertools, walkdir::WalkDir};
 
 use gluon_base::filename_to_module;
 
 #[cfg(feature = "test")]
 mod gen_skeptic {
-    extern crate little_skeptic as skeptic;
-    extern crate walkdir;
+    use little_skeptic as skeptic;
 
-    use std::env;
-    use std::fs::{self, File};
-    use std::io::prelude::*;
-    use std::path::{Path, PathBuf};
+    use std::{
+        env,
+        fs::{self, File},
+        io::Read,
+        path::{Path, PathBuf},
+    };
 
     /// skeptic templates look for `rust` after the opening code fences so writing
     /// ```f#,rust
@@ -64,14 +61,12 @@ return;
         File::open(file)
             .and_then(|mut raw_file| raw_file.read_to_end(&mut contents))
             .unwrap();
-        File::create(&out_file_name)
-            .and_then(|mut out_file| out_file.write_all(&contents))
-            .unwrap();
+        fs::write(&out_file_name, contents).unwrap();
         out_file_name.to_str().expect("UTF-8 string").into()
     }
 
     pub fn generate() {
-        let test_locations: Vec<_> = self::walkdir::WalkDir::new("book/src")
+        let test_locations: Vec<_> = walkdir::WalkDir::new("book/src")
             .into_iter()
             .filter_map(|e| {
                 let e = e.unwrap();

build.rs

@@ -549,7 +549,7 @@ impl DocCollector<'_> {
         );
 
         let (expr, typ) = thread.typecheck_str(&name, &content, None)?;
-        let (meta, _) = metadata(&thread.get_database(), &expr.expr());
+        let (meta, _) = metadata(&thread.get_database().as_env(), &expr.expr());
 
         create_dir_all(out_path.join(module_path.parent().unwrap_or(Path::new(""))))?;
 

doc/src/lib.rs

@@ -20,13 +20,14 @@ use crate::vm::{
         IO,
     },
     internal::ValuePrinter,
-    thread::{ActiveThread, RootedValue, Thread, ThreadInternal},
+    thread::{ActiveThread, RootedValue, Thread},
     {self, Error as VMError, Result as VMResult},
 };
 
 use gluon::{
     compiler_pipeline::{Executable, ExecuteValue},
     import::add_extern_module,
+    query::CompilerDatabase,
     Error as GluonError, Result as GluonResult, RootedThread, ThreadExt,
 };
 
@@ -436,6 +437,9 @@ async fn eval_line_(vm: RootedThread, line: &str) -> gluon::Result<()> {
     let ExecuteValue { value, typ, .. } = (&mut eval_expr)
         .run_expr(&mut module_compiler, vm.clone(), "line", line, None)
         .await?;
+
+    drop(db);
+
     if is_let_binding {
         let mut expr = eval_expr.expr();
         let mut last_bind = None;
@@ -448,7 +452,13 @@ async fn eval_line_(vm: RootedThread, line: &str) -> gluon::Result<()> {
                 _ => break,
             }
         }
-        set_globals(&vm, &last_bind.unwrap().name, &typ, &value.as_ref())?;
+        set_globals(
+            &vm,
+            &mut vm.get_database_mut(),
+            &last_bind.unwrap().name,
+            &typ,
+            &value.as_ref(),
+        )?;
     }
     let vm = value.vm();
     let env = vm.get_env();
@@ -464,33 +474,34 @@ async fn eval_line_(vm: RootedThread, line: &str) -> gluon::Result<()> {
 
 fn set_globals(
     vm: &Thread,
+    db: &mut CompilerDatabase,
     pattern: &SpannedPattern<Symbol>,
     typ: &ArcType,
     value: &RootedValue<&Thread>,
 ) -> GluonResult<()> {
     match pattern.value {
         Pattern::Ident(ref id) => {
-            vm.set_global(
-                Symbol::from(format!("@{}", id.name.declared_name())),
+            db.set_global(
+                id.name.declared_name(),
                 typ.clone(),
                 Default::default(),
                 value.get_value(),
-            )?;
+            );
             Ok(())
         }
         Pattern::Tuple { ref elems, .. } => {
             let iter = elems
                 .iter()
                 .zip(crate::vm::dynamic::field_iter(&value, typ, vm));
             for (elem_pattern, (elem_value, elem_type)) in iter {
-                set_globals(vm, elem_pattern, &elem_type, &elem_value)?;
+                set_globals(vm, db, elem_pattern, &elem_type, &elem_value)?;
             }
             Ok(())
         }
         Pattern::Record { ref fields, .. } => {
             let resolved_type = {
                 let mut type_cache = vm.global_env().type_cache();
-                let env = vm.get_env();
+                let env = db.as_env();
                 resolve::remove_aliases_cow(&env, &mut type_cache, typ)
             };
 
@@ -517,26 +528,26 @@ fn set_globals(
                     .clone();
                 match pattern_value {
                     Some(ref sub_pattern) => {
-                        set_globals(vm, sub_pattern, &field_type, &field_value)?
+                        set_globals(vm, db, sub_pattern, &field_type, &field_value)?
                     }
-                    None => vm.set_global(
-                        Symbol::from(format!("@{}", name.value.declared_name())),
+                    None => db.set_global(
+                        name.value.declared_name(),
                         field_type.to_owned(),
                         Default::default(),
                         field_value.get_value(),
-                    )?,
+                    ),
                 }
             }
             Ok(())
         }
         Pattern::As(ref id, ref pattern) => {
-            vm.set_global(
-                Symbol::from(format!("@{}", id.value.declared_name())),
+            db.set_global(
+                id.value.declared_name(),
                 typ.clone(),
                 Default::default(),
                 value.get_value(),
-            )?;
-            set_globals(vm, pattern, typ, value)
+            );
+            set_globals(vm, db, pattern, typ, value)
         }
         Pattern::Constructor(..) | Pattern::Literal(_) | Pattern::Error => {
             Err(VMError::Message("The repl cannot bind variables from this pattern".into()).into())

repl/src/repl.rs

@@ -28,14 +28,14 @@ use crate::{
         types::{ArcType, NullInterner, Type, TypeCache},
     },
     check::{metadata, rename},
-    query::{Compilation, CompilerDatabase},
+    query::{env, Compilation, CompilerDatabase},
     vm::{
         compiler::CompiledModule,
         core::{self, interpreter, CoreExpr},
         macros::MacroExpander,
         thread::{RootedThread, RootedValue, Thread, ThreadInternal, VmRoot},
     },
-    Error, ModuleCompiler, Result,
+    Error, ModuleCompiler, Result, ThreadExt,
 };
 
 pub type BoxFuture<'vm, T, E> =
@@ -394,8 +394,8 @@ where
         _file: &str,
         _expr_str: &str,
     ) -> SalvageResult<WithMetadata<Self::Expr>> {
-        let env = &*compiler.database;
-        let (metadata, metadata_map) = metadata::metadata(env, self.expr.borrow_mut().expr_mut());
+        let env = env(compiler.database);
+        let (metadata, metadata_map) = metadata::metadata(&env, self.expr.borrow_mut().expr_mut());
         Ok(WithMetadata {
             expr: self.expr,
             metadata,
@@ -605,12 +605,12 @@ fn typecheck_expr(
     metadata_map: &mut FnvMap<Symbol, Arc<Metadata>>,
 ) -> Result<ArcType> {
     use crate::check::typecheck::Typecheck;
-    let env = &*compiler.database;
+    let env = env(compiler.database);
     let (arena, expr) = expr.arena_expr();
     let mut tc = Typecheck::new(
         file.into(),
         &mut compiler.symbols,
-        &*env,
+        &env,
         &thread.global_env().type_cache(),
         metadata_map,
         arena.borrow(),
@@ -658,7 +658,7 @@ where
                         typ: expr
                             .borrow_mut()
                             .expr()
-                            .try_type_of(&*compiler.database)
+                            .try_type_of(&env(compiler.database))
                             .unwrap_or_else(|_| thread.global_env().type_cache().error()),
                         expr,
                         metadata_map,
@@ -671,8 +671,8 @@ where
 
         // Some metadata requires typechecking so recompute it if full metadata is required
         let (metadata, metadata_map) = if compiler.compiler_settings().full_metadata {
-            let env = &*compiler.database;
-            metadata::metadata(&*env, expr.borrow_mut().expr_mut())
+            let env = env(compiler.database);
+            metadata::metadata(&env, expr.borrow_mut().expr_mut())
         } else {
             (metadata, metadata_map)
         };
@@ -824,22 +824,23 @@ where
         let core_expr;
 
         let mut module = {
-            let env = &*compiler.database;
-
-            core_expr = core::with_translator(&*env, |translator| {
-                let expr = translator.translate_expr(self.expr.borrow().expr());
-
-                debug!("Translation returned: {}", expr);
-
-                if settings.optimize {
-                    core::optimize::optimize(&translator.allocator, env, expr)
-                } else {
-                    interpreter::Global {
-                        value: core::freeze_expr(&translator.allocator, expr),
-                        info: Default::default(),
+            core_expr = {
+                let env = env(compiler.database);
+                core::with_translator(&env, |translator| {
+                    let expr = translator.translate_expr(self.expr.borrow().expr());
+
+                    debug!("Translation returned: {}", expr);
+
+                    if settings.optimize {
+                        core::optimize::optimize(&translator.allocator, &env, expr)
+                    } else {
+                        interpreter::Global {
+                            value: core::freeze_expr(&translator.allocator, expr),
+                            info: Default::default(),
+                        }
                     }
-                }
-            });
+                })
+            };
 
             debug!("Optimization returned: {}", core_expr);
 
@@ -854,8 +855,9 @@ where
                 &mut compiler.symbols,
             );
 
+            let env = env(compiler.database);
             let mut compiler = Compiler::new(
-                &*env,
+                &env,
                 thread.global_env(),
                 symbols,
                 &source,
@@ -1114,7 +1116,7 @@ where
 
     async fn load_script<T>(
         self,
-        compiler: &mut ModuleCompiler<'_>,
+        _compiler: &mut ModuleCompiler<'_>,
         vm: T,
         name: &str,
         _expr_str: &str,
@@ -1124,9 +1126,7 @@ where
         T: Send + Sync + VmRoot<'vm>,
         'vm: 'async_trait,
     {
-        use crate::vm::internal::Global;
-        use crate::vm::serialization::DeSeed;
-        use base::symbol::SymbolData;
+        use crate::vm::{internal::Global, serialization::DeSeed};
 
         let Global {
             metadata,
@@ -1136,12 +1136,8 @@ where
         } = DeSeed::new(&vm, &mut vm.current_context())
             .deserialize(self.0)
             .map_err(|err| err.to_string())?;
-        let id = compiler.symbols.symbol(SymbolData {
-            global: true,
-            location: None,
-            name: name,
-        });
-        vm.set_global(id, typ, metadata.clone(), &value)?;
+        vm.get_database_mut()
+            .set_global(name, typ, metadata.clone(), &value);
         info!("Loaded module `{}`", name);
         Ok(())
     }

src/compiler_pipeline.rs

@@ -390,12 +390,8 @@ impl<I> Import<I> {
 /// Adds an extern module to `thread`, letting it be loaded with `import! name` from gluon code.
 ///
 /// ```
-/// extern crate gluon;
-/// #[macro_use]
-/// extern crate gluon_vm;
-///
 /// use gluon::vm::{self, ExternModule};
-/// use gluon::{Thread, ThreadExt};
+/// use gluon::{primitive, record, Thread, ThreadExt};
 /// use gluon::import::add_extern_module;
 ///
 /// fn yell(s: &str) -> String {
@@ -412,22 +408,18 @@ impl<I> Import<I> {
 ///     )
 /// }
 ///
-/// fn main_() -> gluon::Result<()> {
-///     let thread = gluon::new_vm();
+/// #[tokio::main]
+/// async fn main() -> gluon::Result<()> {
+///     let thread = gluon::new_vm_async().await;
 ///     add_extern_module(&thread, "my_module", my_module);
 ///     let script = r#"
 ///         let module = import! "my_module"
 ///         module.yell module.message
 ///     "#;
-///     let (result, _) = thread.run_expr::<String>("example", script)?;
+///     let (result, _) = thread.run_expr_async::<String>("example", script).await?;
 ///     assert_eq!(result, "HELLO WORLD!");
 ///     Ok(())
 /// }
-/// fn main() {
-///     if let Err(err) = main_() {
-///         panic!("{}", err)
-///     }
-/// }
 /// ```
 pub fn add_extern_module<F>(thread: &Thread, name: &str, loader: F)
 where
@@ -506,9 +498,9 @@ where
         id: TypeId,
     ) -> Option<Box<dyn Any>> {
         if id == TypeId::of::<Box<dyn VmEnv>>() {
-            Some(Box::new(
-                Box::new(self.snapshot(thread.root_thread())) as Box<dyn VmEnv>
-            ))
+            Some(Box::new(Box::new(crate::query::snapshot_env(
+                self.snapshot(thread.root_thread()),
+            )) as Box<dyn VmEnv>))
         } else if id == TypeId::of::<Arc<dyn ImportApi>>() {
             Some(Box::new(
                 arc_self.clone().downcast_arc::<Self>().ok().unwrap() as Arc<dyn ImportApi>,