From 6e469b9a311d1bdb7b5e4fc62688fc7d4d08ceea Mon Sep 17 00:00:00 2001 From: Markus Westerlind Date: Sat, 20 Jun 2020 00:02:56 +0200 Subject: [PATCH] fix: Allow find_type etc to work without calling global --- rustfmt.toml | 2 -- src/lib.rs | 13 +++++-- src/query.rs | 85 ++++++++++++++++++++++++--------------------- src/std_lib/http.rs | 5 ++- 4 files changed, 61 insertions(+), 44 deletions(-) delete mode 100644 rustfmt.toml diff --git a/rustfmt.toml b/rustfmt.toml deleted file mode 100644 index 290f301daf..0000000000 --- a/rustfmt.toml +++ /dev/null @@ -1,2 +0,0 @@ -use_try_shorthand = true -error_on_line_overflow = false diff --git a/src/lib.rs b/src/lib.rs index 11286be947..4a3ae9bc6e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -487,9 +487,14 @@ pub trait ThreadExt: Send + Sync { let mut db = vm.get_database(); let TypecheckValue { expr, typ, .. } = db - .typechecked_module(file.into(), expected_type.cloned()) + .typechecked_source_module(file.into(), expected_type.cloned()) .await .map_err(|t| t.1)?; + + // Ensure the type is stored in the database so we can collect typechecked_module later + db.module_type(file.into(), None).await?; + db.module_metadata(file.into(), None).await?; + Ok((expr, typ)) } @@ -587,10 +592,14 @@ pub trait ThreadExt: Send + Sync { metadata, .. } = db - .typechecked_module(module_name, None) + .typechecked_source_module(module_name.clone(), None) .await .map_err(|(_, err)| err)?; + // Ensure the type is stored in the database so we can collect typechecked_module later + db.module_type(module_name.clone(), None).await?; + db.module_metadata(module_name.clone(), None).await?; + if db.compiler_settings().full_metadata { Ok((expr, typ, metadata)) } else { diff --git a/src/query.rs b/src/query.rs index 1bf6d1cf82..edccd7f6f5 100644 --- a/src/query.rs +++ b/src/query.rs @@ -29,7 +29,7 @@ use { macros, thread::{RootedThread, RootedValue, Thread, ThreadInternal}, vm::VmEnv, - ExternLoader, ExternModule, + ExternLoader, }, }; @@ -203,8 +203,11 @@ impl crate::query::CompilationBase for CompilerDatabase { state.add_filemap(&module, &contents[..]); } - fn peek_typechecked_module(&self, key: &str) -> Option>>> { - self.query(TypecheckedModuleQuery) + fn peek_typechecked_source_module( + &self, + key: &str, + ) -> Option>>> { + self.query(TypecheckedSourceModuleQuery) .peek(&(key.into(), None)) .and_then(|r| r.ok()) } @@ -327,7 +330,7 @@ impl CompilerDatabase { .sweep_all_revisions(); self.query(ModuleTextQuery).sweep(strategy); - self.query(TypecheckedModuleQuery).sweep(strategy); + self.query(TypecheckedSourceModuleQuery).sweep(strategy); self.query(CoreExprQuery).sweep(strategy); self.query(CompiledModuleQuery).sweep(strategy); } @@ -338,7 +341,10 @@ pub trait CompilationBase: Send { fn thread(&self) -> &Thread; fn add_module(&mut self, module: String, contents: &str); - fn peek_typechecked_module(&self, key: &str) -> Option>>>; + fn peek_typechecked_source_module( + &self, + key: &str, + ) -> Option>>>; fn peek_module_type(&self, key: &str) -> Option; fn peek_module_metadata(&self, key: &str) -> Option>; fn peek_core_expr(&self, key: &str) -> Option>; @@ -357,9 +363,9 @@ pub trait Compilation: CompilationBase { #[salsa::input] fn extern_global(&self, name: String) -> UnrootedGlobal; + #[doc(hidden)] #[salsa::cycle(recover_cycle)] - #[salsa::dependencies] // FIXME - async fn extern_module(&self, module: String) -> Result>; + async fn extern_module(&self, module: String) -> Result; #[salsa::transparent] fn get_extern_global(&self, name: &str) -> Option; @@ -368,7 +374,7 @@ pub trait Compilation: CompilationBase { fn module_text(&self, module: String) -> StdResult>, Error>; #[salsa::cycle(recover_cycle_typecheck)] - async fn typechecked_module( + async fn typechecked_source_module( &self, module: String, expected_type: Option, @@ -496,7 +502,7 @@ fn module_text( Ok(contents) } -async fn typechecked_module( +async fn typechecked_source_module( db: &mut (impl Compilation + salsa::Database), module: String, expected_type: Option, @@ -530,10 +536,10 @@ async fn module_type( expected_type: Option, ) -> StdResult { if db.compiler().query(ExternLoaderQuery).peek(&name).is_some() { - let (_id, module) = &*db.extern_module(name).await?; - return Ok(module.typ.clone()); + let global = db.extern_module(name).await?; + return Ok(global.typ.clone()); } - db.typechecked_module(name, expected_type) + db.typechecked_source_module(name, expected_type) .await .map(|module| module.typ) .map_err(|(_, err)| err) @@ -545,10 +551,10 @@ async fn module_metadata( expected_type: Option, ) -> StdResult, Error> { if db.compiler().query(ExternLoaderQuery).peek(&name).is_some() { - let (_id, module) = &*db.extern_module(name.clone()).await?; - return Ok(Arc::new(module.metadata.clone())); + let global = db.extern_module(name).await?; + return Ok(global.metadata.clone()); } - db.typechecked_module(name, expected_type) + db.typechecked_source_module(name, expected_type) .await .map(|module| module.metadata) .map_err(|(_, err)| err) @@ -562,11 +568,11 @@ async fn core_expr( db.salsa_runtime_mut().report_untracked_read(); let value = db - .typechecked_module(module.clone(), expected_type.clone()) + .typechecked_source_module(module.clone(), expected_type.clone()) .await .map_err(|(_, err)| err)?; - // Ensure the type is stored in the database so we can collect typechecked_module later + // Ensure the type is stored in the database so we can collect typechecked_source_module later db.module_type(module.clone(), expected_type.clone()) .await?; db.module_metadata(module.clone(), expected_type).await?; @@ -660,23 +666,21 @@ async fn import( async fn global_inner(db: &mut dyn Compilation, name: String) -> Result { if db.compiler().query(ExternLoaderQuery).peek(&name).is_some() { - let (id, module) = &*db.extern_module(name).await?; - let mut value = module.value.clone(); - unsafe { value.vm_mut().unroot() }; // FIXME - return Ok(UnrootedGlobal { - id: id.clone(), - typ: module.typ.clone(), - metadata: Arc::new(module.metadata.clone()), - value: UnrootedValue(value), - }); + let global = db.extern_module(name.clone()).await?; + + // Ensure the type is stored in the database so we can collect typechecked_source_module later + db.module_type(name.clone(), None).await?; + db.module_metadata(name, None).await?; + + return Ok(global); } let TypecheckValue { metadata, typ, .. } = db - .typechecked_module(name.clone(), None) + .typechecked_source_module(name.clone(), None) .await .map_err(|(_, err)| err)?; - // Ensure the type is stored in the database so we can collect typechecked_module later + // Ensure the type is stored in the database so we can collect typechecked_source_module later db.module_type(name.clone(), None).await?; db.module_metadata(name.clone(), None).await?; @@ -725,11 +729,8 @@ async fn global_inner(db: &mut dyn Compilation, name: String) -> Result Result> { - let symbol = Symbol::from(format!("@{}", name)); +async fn extern_module(db: &mut dyn Compilation, name: String) -> Result { + let id = Symbol::from(format!("@{}", name)); let loader = db.extern_loader(name); for dep in &loader.dependencies { @@ -737,10 +738,17 @@ async fn extern_module( } let vm = db.thread(); - Ok(PtrEq(Arc::new(( - symbol, // TODO - (loader.load_fn)(vm)?, - )))) + + let module = (loader.load_fn)(vm)?; + let mut value = module.value.clone(); + unsafe { value.vm_mut().unroot() }; // FIXME + + Ok(UnrootedGlobal { + id, + typ: module.typ.clone(), + metadata: Arc::new(module.metadata), + value: UnrootedValue(value), + }) } async fn global(db: &mut dyn Compilation, name: String) -> Result { @@ -864,8 +872,7 @@ where if id.is_global() { self.0 .borrow_mut() - .peek_typechecked_module(id.definition_name()) - .map(|v| v.metadata.clone()) + .peek_module_metadata(id.definition_name()) } else { None } diff --git a/src/std_lib/http.rs b/src/std_lib/http.rs index 48b13b44d2..7684d9c501 100644 --- a/src/std_lib/http.rs +++ b/src/std_lib/http.rs @@ -90,7 +90,10 @@ impl<'vm, 'value> Getable<'vm, 'value> for Headers { Collect::from_value(vm, value) // TODO Error somehow on invalid headers .filter_map(|(name, value): (&str, &[u8])| { - match (HeaderName::from_bytes(name.as_bytes()), HeaderValue::from_bytes(value)) { + match ( + HeaderName::from_bytes(name.as_bytes()), + HeaderValue::from_bytes(value), + ) { (Ok(name), Ok(value)) => Some((name, value)), _ => None, }