1pub mod wit;
2
3use crate::ExtensionManifest;
4use anyhow::{Context as _, Result, anyhow, bail};
5use async_trait::async_trait;
6use dap::{DebugRequest, StartDebuggingRequestArgumentsRequest};
7use extension::{
8 CodeLabel, Command, Completion, ContextServerConfiguration, DebugAdapterBinary,
9 DebugTaskDefinition, ExtensionHostProxy, KeyValueStoreDelegate, ProjectDelegate, SlashCommand,
10 SlashCommandArgumentCompletion, SlashCommandOutput, Symbol, WorktreeDelegate,
11};
12use fs::{Fs, normalize_path};
13use futures::future::LocalBoxFuture;
14use futures::{
15 Future, FutureExt, StreamExt as _,
16 channel::{
17 mpsc::{self, UnboundedSender},
18 oneshot,
19 },
20 future::BoxFuture,
21};
22use gpui::{App, AsyncApp, BackgroundExecutor, Task, Timer};
23use http_client::HttpClient;
24use language::LanguageName;
25use lsp::LanguageServerName;
26use moka::sync::Cache;
27use node_runtime::NodeRuntime;
28use release_channel::ReleaseChannel;
29use semantic_version::SemanticVersion;
30use std::borrow::Cow;
31use std::sync::{LazyLock, OnceLock};
32use std::time::Duration;
33use std::{
34 path::{Path, PathBuf},
35 sync::Arc,
36};
37use task::{DebugScenario, SpawnInTerminal, TaskTemplate, ZedDebugConfig};
38use wasmtime::{
39 CacheStore, Engine, Store,
40 component::{Component, ResourceTable},
41};
42use wasmtime_wasi::{self as wasi, WasiView};
43use wit::Extension;
44
45pub struct WasmHost {
46 engine: Engine,
47 release_channel: ReleaseChannel,
48 http_client: Arc<dyn HttpClient>,
49 node_runtime: NodeRuntime,
50 pub(crate) proxy: Arc<ExtensionHostProxy>,
51 fs: Arc<dyn Fs>,
52 pub work_dir: PathBuf,
53 _main_thread_message_task: Task<()>,
54 main_thread_message_tx: mpsc::UnboundedSender<MainThreadCall>,
55}
56
57#[derive(Clone)]
58pub struct WasmExtension {
59 tx: UnboundedSender<ExtensionCall>,
60 pub manifest: Arc<ExtensionManifest>,
61 pub work_dir: Arc<Path>,
62 #[allow(unused)]
63 pub zed_api_version: SemanticVersion,
64}
65
66#[async_trait]
67impl extension::Extension for WasmExtension {
68 fn manifest(&self) -> Arc<ExtensionManifest> {
69 self.manifest.clone()
70 }
71
72 fn work_dir(&self) -> Arc<Path> {
73 self.work_dir.clone()
74 }
75
76 async fn language_server_command(
77 &self,
78 language_server_id: LanguageServerName,
79 language_name: LanguageName,
80 worktree: Arc<dyn WorktreeDelegate>,
81 ) -> Result<Command> {
82 self.call(|extension, store| {
83 async move {
84 let resource = store.data_mut().table().push(worktree)?;
85 let command = extension
86 .call_language_server_command(
87 store,
88 &language_server_id,
89 &language_name,
90 resource,
91 )
92 .await?
93 .map_err(|err| store.data().extension_error(err))?;
94
95 Ok(command.into())
96 }
97 .boxed()
98 })
99 .await
100 }
101
102 async fn language_server_initialization_options(
103 &self,
104 language_server_id: LanguageServerName,
105 language_name: LanguageName,
106 worktree: Arc<dyn WorktreeDelegate>,
107 ) -> Result<Option<String>> {
108 self.call(|extension, store| {
109 async move {
110 let resource = store.data_mut().table().push(worktree)?;
111 let options = extension
112 .call_language_server_initialization_options(
113 store,
114 &language_server_id,
115 &language_name,
116 resource,
117 )
118 .await?
119 .map_err(|err| store.data().extension_error(err))?;
120 anyhow::Ok(options)
121 }
122 .boxed()
123 })
124 .await
125 }
126
127 async fn language_server_workspace_configuration(
128 &self,
129 language_server_id: LanguageServerName,
130 worktree: Arc<dyn WorktreeDelegate>,
131 ) -> Result<Option<String>> {
132 self.call(|extension, store| {
133 async move {
134 let resource = store.data_mut().table().push(worktree)?;
135 let options = extension
136 .call_language_server_workspace_configuration(
137 store,
138 &language_server_id,
139 resource,
140 )
141 .await?
142 .map_err(|err| store.data().extension_error(err))?;
143 anyhow::Ok(options)
144 }
145 .boxed()
146 })
147 .await
148 }
149
150 async fn language_server_additional_initialization_options(
151 &self,
152 language_server_id: LanguageServerName,
153 target_language_server_id: LanguageServerName,
154 worktree: Arc<dyn WorktreeDelegate>,
155 ) -> Result<Option<String>> {
156 self.call(|extension, store| {
157 async move {
158 let resource = store.data_mut().table().push(worktree)?;
159 let options = extension
160 .call_language_server_additional_initialization_options(
161 store,
162 &language_server_id,
163 &target_language_server_id,
164 resource,
165 )
166 .await?
167 .map_err(|err| store.data().extension_error(err))?;
168 anyhow::Ok(options)
169 }
170 .boxed()
171 })
172 .await
173 }
174
175 async fn language_server_additional_workspace_configuration(
176 &self,
177 language_server_id: LanguageServerName,
178 target_language_server_id: LanguageServerName,
179 worktree: Arc<dyn WorktreeDelegate>,
180 ) -> Result<Option<String>> {
181 self.call(|extension, store| {
182 async move {
183 let resource = store.data_mut().table().push(worktree)?;
184 let options = extension
185 .call_language_server_additional_workspace_configuration(
186 store,
187 &language_server_id,
188 &target_language_server_id,
189 resource,
190 )
191 .await?
192 .map_err(|err| store.data().extension_error(err))?;
193 anyhow::Ok(options)
194 }
195 .boxed()
196 })
197 .await
198 }
199
200 async fn labels_for_completions(
201 &self,
202 language_server_id: LanguageServerName,
203 completions: Vec<Completion>,
204 ) -> Result<Vec<Option<CodeLabel>>> {
205 self.call(|extension, store| {
206 async move {
207 let labels = extension
208 .call_labels_for_completions(
209 store,
210 &language_server_id,
211 completions.into_iter().map(Into::into).collect(),
212 )
213 .await?
214 .map_err(|err| store.data().extension_error(err))?;
215
216 Ok(labels
217 .into_iter()
218 .map(|label| label.map(Into::into))
219 .collect())
220 }
221 .boxed()
222 })
223 .await
224 }
225
226 async fn labels_for_symbols(
227 &self,
228 language_server_id: LanguageServerName,
229 symbols: Vec<Symbol>,
230 ) -> Result<Vec<Option<CodeLabel>>> {
231 self.call(|extension, store| {
232 async move {
233 let labels = extension
234 .call_labels_for_symbols(
235 store,
236 &language_server_id,
237 symbols.into_iter().map(Into::into).collect(),
238 )
239 .await?
240 .map_err(|err| store.data().extension_error(err))?;
241
242 Ok(labels
243 .into_iter()
244 .map(|label| label.map(Into::into))
245 .collect())
246 }
247 .boxed()
248 })
249 .await
250 }
251
252 async fn complete_slash_command_argument(
253 &self,
254 command: SlashCommand,
255 arguments: Vec<String>,
256 ) -> Result<Vec<SlashCommandArgumentCompletion>> {
257 self.call(|extension, store| {
258 async move {
259 let completions = extension
260 .call_complete_slash_command_argument(store, &command.into(), &arguments)
261 .await?
262 .map_err(|err| store.data().extension_error(err))?;
263
264 Ok(completions.into_iter().map(Into::into).collect())
265 }
266 .boxed()
267 })
268 .await
269 }
270
271 async fn run_slash_command(
272 &self,
273 command: SlashCommand,
274 arguments: Vec<String>,
275 delegate: Option<Arc<dyn WorktreeDelegate>>,
276 ) -> Result<SlashCommandOutput> {
277 self.call(|extension, store| {
278 async move {
279 let resource = if let Some(delegate) = delegate {
280 Some(store.data_mut().table().push(delegate)?)
281 } else {
282 None
283 };
284
285 let output = extension
286 .call_run_slash_command(store, &command.into(), &arguments, resource)
287 .await?
288 .map_err(|err| store.data().extension_error(err))?;
289
290 Ok(output.into())
291 }
292 .boxed()
293 })
294 .await
295 }
296
297 async fn context_server_command(
298 &self,
299 context_server_id: Arc<str>,
300 project: Arc<dyn ProjectDelegate>,
301 ) -> Result<Command> {
302 self.call(|extension, store| {
303 async move {
304 let project_resource = store.data_mut().table().push(project)?;
305 let command = extension
306 .call_context_server_command(store, context_server_id.clone(), project_resource)
307 .await?
308 .map_err(|err| store.data().extension_error(err))?;
309 anyhow::Ok(command.into())
310 }
311 .boxed()
312 })
313 .await
314 }
315
316 async fn context_server_configuration(
317 &self,
318 context_server_id: Arc<str>,
319 project: Arc<dyn ProjectDelegate>,
320 ) -> Result<Option<ContextServerConfiguration>> {
321 self.call(|extension, store| {
322 async move {
323 let project_resource = store.data_mut().table().push(project)?;
324 let Some(configuration) = extension
325 .call_context_server_configuration(
326 store,
327 context_server_id.clone(),
328 project_resource,
329 )
330 .await?
331 .map_err(|err| store.data().extension_error(err))?
332 else {
333 return Ok(None);
334 };
335
336 Ok(Some(configuration.try_into()?))
337 }
338 .boxed()
339 })
340 .await
341 }
342
343 async fn suggest_docs_packages(&self, provider: Arc<str>) -> Result<Vec<String>> {
344 self.call(|extension, store| {
345 async move {
346 let packages = extension
347 .call_suggest_docs_packages(store, provider.as_ref())
348 .await?
349 .map_err(|err| store.data().extension_error(err))?;
350
351 Ok(packages)
352 }
353 .boxed()
354 })
355 .await
356 }
357
358 async fn index_docs(
359 &self,
360 provider: Arc<str>,
361 package_name: Arc<str>,
362 kv_store: Arc<dyn KeyValueStoreDelegate>,
363 ) -> Result<()> {
364 self.call(|extension, store| {
365 async move {
366 let kv_store_resource = store.data_mut().table().push(kv_store)?;
367 extension
368 .call_index_docs(
369 store,
370 provider.as_ref(),
371 package_name.as_ref(),
372 kv_store_resource,
373 )
374 .await?
375 .map_err(|err| store.data().extension_error(err))?;
376
377 anyhow::Ok(())
378 }
379 .boxed()
380 })
381 .await
382 }
383
384 async fn get_dap_binary(
385 &self,
386 dap_name: Arc<str>,
387 config: DebugTaskDefinition,
388 user_installed_path: Option<PathBuf>,
389 worktree: Arc<dyn WorktreeDelegate>,
390 ) -> Result<DebugAdapterBinary> {
391 self.call(|extension, store| {
392 async move {
393 let resource = store.data_mut().table().push(worktree)?;
394 let dap_binary = extension
395 .call_get_dap_binary(store, dap_name, config, user_installed_path, resource)
396 .await?
397 .map_err(|err| store.data().extension_error(err))?;
398 let dap_binary = dap_binary.try_into()?;
399 Ok(dap_binary)
400 }
401 .boxed()
402 })
403 .await
404 }
405 async fn dap_request_kind(
406 &self,
407 dap_name: Arc<str>,
408 config: serde_json::Value,
409 ) -> Result<StartDebuggingRequestArgumentsRequest> {
410 self.call(|extension, store| {
411 async move {
412 let kind = extension
413 .call_dap_request_kind(store, dap_name, config)
414 .await?
415 .map_err(|err| store.data().extension_error(err))?;
416 Ok(kind.into())
417 }
418 .boxed()
419 })
420 .await
421 }
422
423 async fn dap_config_to_scenario(&self, config: ZedDebugConfig) -> Result<DebugScenario> {
424 self.call(|extension, store| {
425 async move {
426 let kind = extension
427 .call_dap_config_to_scenario(store, config)
428 .await?
429 .map_err(|err| store.data().extension_error(err))?;
430 Ok(kind)
431 }
432 .boxed()
433 })
434 .await
435 }
436
437 async fn dap_locator_create_scenario(
438 &self,
439 locator_name: String,
440 build_config_template: TaskTemplate,
441 resolved_label: String,
442 debug_adapter_name: String,
443 ) -> Result<Option<DebugScenario>> {
444 self.call(|extension, store| {
445 async move {
446 extension
447 .call_dap_locator_create_scenario(
448 store,
449 locator_name,
450 build_config_template,
451 resolved_label,
452 debug_adapter_name,
453 )
454 .await
455 }
456 .boxed()
457 })
458 .await
459 }
460 async fn run_dap_locator(
461 &self,
462 locator_name: String,
463 config: SpawnInTerminal,
464 ) -> Result<DebugRequest> {
465 self.call(|extension, store| {
466 async move {
467 extension
468 .call_run_dap_locator(store, locator_name, config)
469 .await?
470 .map_err(|err| store.data().extension_error(err))
471 }
472 .boxed()
473 })
474 .await
475 }
476}
477
478pub struct WasmState {
479 manifest: Arc<ExtensionManifest>,
480 pub table: ResourceTable,
481 ctx: wasi::WasiCtx,
482 pub host: Arc<WasmHost>,
483}
484
485type MainThreadCall = Box<dyn Send + for<'a> FnOnce(&'a mut AsyncApp) -> LocalBoxFuture<'a, ()>>;
486
487type ExtensionCall = Box<
488 dyn Send + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, ()>,
489>;
490
491fn wasm_engine(executor: &BackgroundExecutor) -> wasmtime::Engine {
492 static WASM_ENGINE: OnceLock<wasmtime::Engine> = OnceLock::new();
493 WASM_ENGINE
494 .get_or_init(|| {
495 let mut config = wasmtime::Config::new();
496 config.wasm_component_model(true);
497 config.async_support(true);
498 config
499 .enable_incremental_compilation(cache_store())
500 .unwrap();
501 // Async support introduces the issue that extension execution happens during `Future::poll`,
502 // which could block an async thread.
503 // https://docs.rs/wasmtime/latest/wasmtime/struct.Config.html#execution-in-poll
504 //
505 // Epoch interruption is a lightweight mechanism to allow the extensions to yield control
506 // back to the executor at regular intervals.
507 config.epoch_interruption(true);
508
509 let engine = wasmtime::Engine::new(&config).unwrap();
510
511 // It might be safer to do this on a non-async thread to make sure it makes progress
512 // regardless of if extensions are blocking.
513 // However, due to our current setup, this isn't a likely occurrence and we'd rather
514 // not have a dedicated thread just for this. If it becomes an issue, we can consider
515 // creating a separate thread for epoch interruption.
516 let engine_ref = engine.weak();
517 executor
518 .spawn(async move {
519 // Somewhat arbitrary interval, as it isn't a guaranteed interval.
520 // But this is a rough upper bound for how long the extension execution can block on
521 // `Future::poll`.
522 const EPOCH_INTERVAL: Duration = Duration::from_millis(100);
523 let mut timer = Timer::interval(EPOCH_INTERVAL);
524 while let Some(_) = timer.next().await {
525 // Exit the loop and thread once the engine is dropped.
526 let Some(engine) = engine_ref.upgrade() else {
527 break;
528 };
529 engine.increment_epoch();
530 }
531 })
532 .detach();
533
534 engine
535 })
536 .clone()
537}
538
539fn cache_store() -> Arc<IncrementalCompilationCache> {
540 static CACHE_STORE: LazyLock<Arc<IncrementalCompilationCache>> =
541 LazyLock::new(|| Arc::new(IncrementalCompilationCache::new()));
542 CACHE_STORE.clone()
543}
544
545impl WasmHost {
546 pub fn new(
547 fs: Arc<dyn Fs>,
548 http_client: Arc<dyn HttpClient>,
549 node_runtime: NodeRuntime,
550 proxy: Arc<ExtensionHostProxy>,
551 work_dir: PathBuf,
552 cx: &mut App,
553 ) -> Arc<Self> {
554 let (tx, mut rx) = mpsc::unbounded::<MainThreadCall>();
555 let task = cx.spawn(async move |cx| {
556 while let Some(message) = rx.next().await {
557 message(cx).await;
558 }
559 });
560 Arc::new(Self {
561 engine: wasm_engine(cx.background_executor()),
562 fs,
563 work_dir,
564 http_client,
565 node_runtime,
566 proxy,
567 release_channel: ReleaseChannel::global(cx),
568 _main_thread_message_task: task,
569 main_thread_message_tx: tx,
570 })
571 }
572
573 pub fn load_extension(
574 self: &Arc<Self>,
575 wasm_bytes: Vec<u8>,
576 manifest: &Arc<ExtensionManifest>,
577 executor: BackgroundExecutor,
578 ) -> Task<Result<WasmExtension>> {
579 let this = self.clone();
580 let manifest = manifest.clone();
581 executor.clone().spawn(async move {
582 let zed_api_version = parse_wasm_extension_version(&manifest.id, &wasm_bytes)?;
583
584 let component = Component::from_binary(&this.engine, &wasm_bytes)
585 .context("failed to compile wasm component")?;
586
587 let mut store = wasmtime::Store::new(
588 &this.engine,
589 WasmState {
590 ctx: this.build_wasi_ctx(&manifest).await?,
591 manifest: manifest.clone(),
592 table: ResourceTable::new(),
593 host: this.clone(),
594 },
595 );
596 // Store will yield after 1 tick, and get a new deadline of 1 tick after each yield.
597 store.set_epoch_deadline(1);
598 store.epoch_deadline_async_yield_and_update(1);
599
600 let mut extension = Extension::instantiate_async(
601 &executor,
602 &mut store,
603 this.release_channel,
604 zed_api_version,
605 &component,
606 )
607 .await?;
608
609 extension
610 .call_init_extension(&mut store)
611 .await
612 .context("failed to initialize wasm extension")?;
613
614 let (tx, mut rx) = mpsc::unbounded::<ExtensionCall>();
615 executor
616 .spawn(async move {
617 while let Some(call) = rx.next().await {
618 (call)(&mut extension, &mut store).await;
619 }
620 })
621 .detach();
622
623 Ok(WasmExtension {
624 manifest: manifest.clone(),
625 work_dir: this.work_dir.join(manifest.id.as_ref()).into(),
626 tx,
627 zed_api_version,
628 })
629 })
630 }
631
632 async fn build_wasi_ctx(&self, manifest: &Arc<ExtensionManifest>) -> Result<wasi::WasiCtx> {
633 let extension_work_dir = self.work_dir.join(manifest.id.as_ref());
634 self.fs
635 .create_dir(&extension_work_dir)
636 .await
637 .context("failed to create extension work dir")?;
638
639 let file_perms = wasi::FilePerms::all();
640 let dir_perms = wasi::DirPerms::all();
641
642 Ok(wasi::WasiCtxBuilder::new()
643 .inherit_stdio()
644 .preopened_dir(&extension_work_dir, ".", dir_perms, file_perms)?
645 .preopened_dir(
646 &extension_work_dir,
647 extension_work_dir.to_string_lossy(),
648 dir_perms,
649 file_perms,
650 )?
651 .env("PWD", extension_work_dir.to_string_lossy())
652 .env("RUST_BACKTRACE", "full")
653 .build())
654 }
655
656 pub fn writeable_path_from_extension(&self, id: &Arc<str>, path: &Path) -> Result<PathBuf> {
657 let extension_work_dir = self.work_dir.join(id.as_ref());
658 let path = normalize_path(&extension_work_dir.join(path));
659 anyhow::ensure!(
660 path.starts_with(&extension_work_dir),
661 "cannot write to path {path:?}",
662 );
663 Ok(path)
664 }
665}
666
667pub fn parse_wasm_extension_version(
668 extension_id: &str,
669 wasm_bytes: &[u8],
670) -> Result<SemanticVersion> {
671 let mut version = None;
672
673 for part in wasmparser::Parser::new(0).parse_all(wasm_bytes) {
674 if let wasmparser::Payload::CustomSection(s) =
675 part.context("error parsing wasm extension")?
676 {
677 if s.name() == "zed:api-version" {
678 version = parse_wasm_extension_version_custom_section(s.data());
679 if version.is_none() {
680 bail!(
681 "extension {} has invalid zed:api-version section: {:?}",
682 extension_id,
683 s.data()
684 );
685 }
686 }
687 }
688 }
689
690 // The reason we wait until we're done parsing all of the Wasm bytes to return the version
691 // is to work around a panic that can happen inside of Wasmtime when the bytes are invalid.
692 //
693 // By parsing the entirety of the Wasm bytes before we return, we're able to detect this problem
694 // earlier as an `Err` rather than as a panic.
695 version.with_context(|| format!("extension {extension_id} has no zed:api-version section"))
696}
697
698fn parse_wasm_extension_version_custom_section(data: &[u8]) -> Option<SemanticVersion> {
699 if data.len() == 6 {
700 Some(SemanticVersion::new(
701 u16::from_be_bytes([data[0], data[1]]) as _,
702 u16::from_be_bytes([data[2], data[3]]) as _,
703 u16::from_be_bytes([data[4], data[5]]) as _,
704 ))
705 } else {
706 None
707 }
708}
709
710impl WasmExtension {
711 pub async fn load(
712 extension_dir: PathBuf,
713 manifest: &Arc<ExtensionManifest>,
714 wasm_host: Arc<WasmHost>,
715 cx: &AsyncApp,
716 ) -> Result<Self> {
717 let path = extension_dir.join("extension.wasm");
718
719 let mut wasm_file = wasm_host
720 .fs
721 .open_sync(&path)
722 .await
723 .context("failed to open wasm file")?;
724
725 let mut wasm_bytes = Vec::new();
726 wasm_file
727 .read_to_end(&mut wasm_bytes)
728 .context("failed to read wasm")?;
729
730 wasm_host
731 .load_extension(wasm_bytes, manifest, cx.background_executor().clone())
732 .await
733 .with_context(|| format!("failed to load wasm extension {}", manifest.id))
734 }
735
736 pub async fn call<T, Fn>(&self, f: Fn) -> T
737 where
738 T: 'static + Send,
739 Fn: 'static
740 + Send
741 + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, T>,
742 {
743 let (return_tx, return_rx) = oneshot::channel();
744 self.tx
745 .clone()
746 .unbounded_send(Box::new(move |extension, store| {
747 async {
748 let result = f(extension, store).await;
749 return_tx.send(result).ok();
750 }
751 .boxed()
752 }))
753 .expect("wasm extension channel should not be closed yet");
754 return_rx.await.expect("wasm extension channel")
755 }
756}
757
758impl WasmState {
759 fn on_main_thread<T, Fn>(&self, f: Fn) -> impl 'static + Future<Output = T>
760 where
761 T: 'static + Send,
762 Fn: 'static + Send + for<'a> FnOnce(&'a mut AsyncApp) -> LocalBoxFuture<'a, T>,
763 {
764 let (return_tx, return_rx) = oneshot::channel();
765 self.host
766 .main_thread_message_tx
767 .clone()
768 .unbounded_send(Box::new(move |cx| {
769 async {
770 let result = f(cx).await;
771 return_tx.send(result).ok();
772 }
773 .boxed_local()
774 }))
775 .expect("main thread message channel should not be closed yet");
776 async move { return_rx.await.expect("main thread message channel") }
777 }
778
779 fn work_dir(&self) -> PathBuf {
780 self.host.work_dir.join(self.manifest.id.as_ref())
781 }
782
783 fn extension_error(&self, message: String) -> anyhow::Error {
784 anyhow!(
785 "from extension \"{}\" version {}: {}",
786 self.manifest.name,
787 self.manifest.version,
788 message
789 )
790 }
791}
792
793impl wasi::WasiView for WasmState {
794 fn table(&mut self) -> &mut ResourceTable {
795 &mut self.table
796 }
797
798 fn ctx(&mut self) -> &mut wasi::WasiCtx {
799 &mut self.ctx
800 }
801}
802
803/// Wrapper around a mini-moka bounded cache for storing incremental compilation artifacts.
804/// Since wasm modules have many similar elements, this can save us a lot of work at the
805/// cost of a small memory footprint. However, we don't want this to be unbounded, so we use
806/// a LFU/LRU cache to evict less used cache entries.
807#[derive(Debug)]
808struct IncrementalCompilationCache {
809 cache: Cache<Vec<u8>, Vec<u8>>,
810}
811
812impl IncrementalCompilationCache {
813 fn new() -> Self {
814 let cache = Cache::builder()
815 // Cap this at 32 MB for now. Our extensions turn into roughly 512kb in the cache,
816 // which means we could store 64 completely novel extensions in the cache, but in
817 // practice we will more than that, which is more than enough for our use case.
818 .max_capacity(32 * 1024 * 1024)
819 .weigher(|k: &Vec<u8>, v: &Vec<u8>| (k.len() + v.len()).try_into().unwrap_or(u32::MAX))
820 .build();
821 Self { cache }
822 }
823}
824
825impl CacheStore for IncrementalCompilationCache {
826 fn get(&self, key: &[u8]) -> Option<Cow<'_, [u8]>> {
827 self.cache.get(key).map(|v| v.into())
828 }
829
830 fn insert(&self, key: &[u8], value: Vec<u8>) -> bool {
831 self.cache.insert(key.to_vec(), value);
832 true
833 }
834}