From 8a2de7537986b1d60b9e8ce3bc4c08e9ec6c489a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 1 Nov 2020 14:53:38 +0000
Subject: Untangle ImportEnv::handle_import

---
 dhall/src/semantics/resolve/env.rs | 43 +++++++++++++++++++-------------------
 1 file changed, 21 insertions(+), 22 deletions(-)

(limited to 'dhall/src/semantics/resolve/env.rs')

diff --git a/dhall/src/semantics/resolve/env.rs b/dhall/src/semantics/resolve/env.rs
index 6346a6d..25d2277 100644
--- a/dhall/src/semantics/resolve/env.rs
+++ b/dhall/src/semantics/resolve/env.rs
@@ -69,9 +69,20 @@ impl ImportEnv {
         ImportEnv::default()
     }
 
-    pub fn handle_import(
+    pub fn get_from_cache<'a>(
+        &'a self,
+        location: &ImportLocation,
+    ) -> Option<&'a TypedHir> {
+        self.cache.get(location)
+    }
+
+    pub fn set_cache(&mut self, location: ImportLocation, expr: TypedHir) {
+        self.cache.insert(location, expr);
+    }
+
+    pub fn with_cycle_detection(
         &mut self,
-        mut location: ImportLocation,
+        location: ImportLocation,
         do_resolve: impl FnOnce(&mut Self) -> Result<TypedHir, Error>,
     ) -> Result<TypedHir, Error> {
         if self.stack.contains(&location) {
@@ -79,25 +90,13 @@ impl ImportEnv {
                 ImportError::ImportCycle(self.stack.clone(), location).into()
             );
         }
-        Ok(match self.cache.get(&location) {
-            Some(expr) => expr.clone(),
-            None => {
-                let expr = {
-                    // Push the current location on the stack
-                    self.stack.push(location);
-                    // Resolve the import recursively
-                    // WARNING: do not propagate errors here or the stack will get messed up.
-                    let result = do_resolve(self);
-                    // Remove location from the stack.
-                    location = self.stack.pop().unwrap();
-                    result
-                }?;
-
-                // Add the resolved import to the cache
-                self.cache.insert(location, expr.clone());
-
-                expr
-            }
-        })
+        // Push the current location on the stack
+        self.stack.push(location);
+        // Resolve the import recursively
+        // WARNING: do not propagate errors here or the stack will get messed up.
+        let result = do_resolve(self);
+        // Remove location from the stack.
+        self.stack.pop().unwrap();
+        result
     }
 }
-- 
cgit v1.2.3


From 2c245e7f5ce4019381e0fa47a1e2caf6276106be Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 1 Nov 2020 15:17:42 +0000
Subject: Store file cache in ImportEnv

---
 dhall/src/semantics/resolve/env.rs | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

(limited to 'dhall/src/semantics/resolve/env.rs')

diff --git a/dhall/src/semantics/resolve/env.rs b/dhall/src/semantics/resolve/env.rs
index 25d2277..4d502ce 100644
--- a/dhall/src/semantics/resolve/env.rs
+++ b/dhall/src/semantics/resolve/env.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use crate::error::{Error, ImportError};
-use crate::semantics::{AlphaVar, ImportLocation, TypedHir, VarEnv};
+use crate::semantics::{AlphaVar, Cache, ImportLocation, TypedHir, VarEnv};
 use crate::syntax::{Label, V};
 
 /// Environment for resolving names.
@@ -10,14 +10,15 @@ pub struct NameEnv {
     names: Vec<Label>,
 }
 
-pub type ImportCache = HashMap<ImportLocation, TypedHir>;
-pub type ImportStack = Vec<ImportLocation>;
+pub type MemCache = HashMap<ImportLocation, TypedHir>;
+pub type CyclesStack = Vec<ImportLocation>;
 
 /// Environment for resolving imports
-#[derive(Debug, Clone, Default)]
+#[derive(Debug)]
 pub struct ImportEnv {
-    cache: ImportCache,
-    stack: ImportStack,
+    pub file_cache: Cache,
+    mem_cache: MemCache,
+    stack: CyclesStack,
 }
 
 impl NameEnv {
@@ -66,18 +67,22 @@ impl NameEnv {
 
 impl ImportEnv {
     pub fn new() -> Self {
-        ImportEnv::default()
+        ImportEnv {
+            file_cache: Cache::new(),
+            mem_cache: Default::default(),
+            stack: Default::default(),
+        }
     }
 
     pub fn get_from_cache<'a>(
         &'a self,
         location: &ImportLocation,
     ) -> Option<&'a TypedHir> {
-        self.cache.get(location)
+        self.mem_cache.get(location)
     }
 
     pub fn set_cache(&mut self, location: ImportLocation, expr: TypedHir) {
-        self.cache.insert(location, expr);
+        self.mem_cache.insert(location, expr);
     }
 
     pub fn with_cycle_detection(
-- 
cgit v1.2.3


From 66ea301fc25a07485286560c434a9fdaf460c431 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 1 Nov 2020 16:10:00 +0000
Subject: Untangle caching code

---
 dhall/src/semantics/resolve/env.rs | 32 ++++++++++++++++++++++++--------
 1 file changed, 24 insertions(+), 8 deletions(-)

(limited to 'dhall/src/semantics/resolve/env.rs')

diff --git a/dhall/src/semantics/resolve/env.rs b/dhall/src/semantics/resolve/env.rs
index 4d502ce..06e27a5 100644
--- a/dhall/src/semantics/resolve/env.rs
+++ b/dhall/src/semantics/resolve/env.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use crate::error::{Error, ImportError};
 use crate::semantics::{AlphaVar, Cache, ImportLocation, TypedHir, VarEnv};
-use crate::syntax::{Label, V};
+use crate::syntax::{Hash, Label, V};
 
 /// Environment for resolving names.
 #[derive(Debug, Clone, Default)]
@@ -16,7 +16,7 @@ pub type CyclesStack = Vec<ImportLocation>;
 /// Environment for resolving imports
 #[derive(Debug)]
 pub struct ImportEnv {
-    pub file_cache: Cache,
+    file_cache: Option<Cache>,
     mem_cache: MemCache,
     stack: CyclesStack,
 }
@@ -68,20 +68,36 @@ impl NameEnv {
 impl ImportEnv {
     pub fn new() -> Self {
         ImportEnv {
-            file_cache: Cache::new(),
+            file_cache: Cache::new().ok(),
             mem_cache: Default::default(),
             stack: Default::default(),
         }
     }
 
-    pub fn get_from_cache<'a>(
-        &'a self,
+    pub fn get_from_cache(
+        &mut self,
         location: &ImportLocation,
-    ) -> Option<&'a TypedHir> {
-        self.mem_cache.get(location)
+        hash: Option<&Hash>,
+    ) -> Option<TypedHir> {
+        if let Some(expr) = self.mem_cache.get(location) {
+            return Some(expr.clone());
+        }
+        let hash = hash.as_ref()?;
+        let expr = self.file_cache.as_ref()?.get(hash).ok()?;
+        Some(expr)
     }
 
-    pub fn set_cache(&mut self, location: ImportLocation, expr: TypedHir) {
+    pub fn set_cache(
+        &mut self,
+        location: ImportLocation,
+        hash: Option<&Hash>,
+        expr: TypedHir,
+    ) {
+        if let Some(file_cache) = self.file_cache.as_ref() {
+            if let Some(hash) = hash {
+                let _ = file_cache.insert(hash, &expr);
+            }
+        }
         self.mem_cache.insert(location, expr);
     }
 
-- 
cgit v1.2.3


From a4332cfbd99a5a00563090a080e9bcb0cde9e963 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 1 Nov 2020 17:45:12 +0000
Subject: Typed and TypedHir are the same

---
 dhall/src/semantics/resolve/env.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'dhall/src/semantics/resolve/env.rs')

diff --git a/dhall/src/semantics/resolve/env.rs b/dhall/src/semantics/resolve/env.rs
index 06e27a5..a24c274 100644
--- a/dhall/src/semantics/resolve/env.rs
+++ b/dhall/src/semantics/resolve/env.rs
@@ -1,8 +1,9 @@
 use std::collections::HashMap;
 
 use crate::error::{Error, ImportError};
-use crate::semantics::{AlphaVar, Cache, ImportLocation, TypedHir, VarEnv};
+use crate::semantics::{AlphaVar, Cache, ImportLocation, VarEnv};
 use crate::syntax::{Hash, Label, V};
+use crate::Typed;
 
 /// Environment for resolving names.
 #[derive(Debug, Clone, Default)]
@@ -10,7 +11,7 @@ pub struct NameEnv {
     names: Vec<Label>,
 }
 
-pub type MemCache = HashMap<ImportLocation, TypedHir>;
+pub type MemCache = HashMap<ImportLocation, Typed>;
 pub type CyclesStack = Vec<ImportLocation>;
 
 /// Environment for resolving imports
@@ -78,7 +79,7 @@ impl ImportEnv {
         &mut self,
         location: &ImportLocation,
         hash: Option<&Hash>,
-    ) -> Option<TypedHir> {
+    ) -> Option<Typed> {
         if let Some(expr) = self.mem_cache.get(location) {
             return Some(expr.clone());
         }
@@ -91,7 +92,7 @@ impl ImportEnv {
         &mut self,
         location: ImportLocation,
         hash: Option<&Hash>,
-        expr: TypedHir,
+        expr: Typed,
     ) {
         if let Some(file_cache) = self.file_cache.as_ref() {
             if let Some(hash) = hash {
@@ -104,8 +105,8 @@ impl ImportEnv {
     pub fn with_cycle_detection(
         &mut self,
         location: ImportLocation,
-        do_resolve: impl FnOnce(&mut Self) -> Result<TypedHir, Error>,
-    ) -> Result<TypedHir, Error> {
+        do_resolve: impl FnOnce(&mut Self) -> Result<Typed, Error>,
+    ) -> Result<Typed, Error> {
         if self.stack.contains(&location) {
             return Err(
                 ImportError::ImportCycle(self.stack.clone(), location).into()
-- 
cgit v1.2.3


From e5381c9b76f1d88dedb4a453cd026c8e98be5533 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 1 Nov 2020 18:32:33 +0000
Subject: Ensure that the hash always gets checked

---
 dhall/src/semantics/resolve/env.rs | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

(limited to 'dhall/src/semantics/resolve/env.rs')

diff --git a/dhall/src/semantics/resolve/env.rs b/dhall/src/semantics/resolve/env.rs
index a24c274..29dd16b 100644
--- a/dhall/src/semantics/resolve/env.rs
+++ b/dhall/src/semantics/resolve/env.rs
@@ -17,7 +17,7 @@ pub type CyclesStack = Vec<ImportLocation>;
 /// Environment for resolving imports
 #[derive(Debug)]
 pub struct ImportEnv {
-    file_cache: Option<Cache>,
+    disk_cache: Option<Cache>, // Missing if it failed to initialize
     mem_cache: MemCache,
     stack: CyclesStack,
 }
@@ -69,37 +69,42 @@ impl NameEnv {
 impl ImportEnv {
     pub fn new() -> Self {
         ImportEnv {
-            file_cache: Cache::new().ok(),
+            disk_cache: Cache::new().ok(),
             mem_cache: Default::default(),
             stack: Default::default(),
         }
     }
 
-    pub fn get_from_cache(
+    pub fn get_from_mem_cache(
         &mut self,
         location: &ImportLocation,
-        hash: Option<&Hash>,
     ) -> Option<Typed> {
-        if let Some(expr) = self.mem_cache.get(location) {
-            return Some(expr.clone());
-        }
+        Some(self.mem_cache.get(location)?.clone())
+    }
+
+    pub fn get_from_disk_cache(
+        &mut self,
+        hash: &Option<Hash>,
+    ) -> Option<Typed> {
         let hash = hash.as_ref()?;
-        let expr = self.file_cache.as_ref()?.get(hash).ok()?;
+        let expr = self.disk_cache.as_ref()?.get(hash).ok()?;
         Some(expr)
     }
 
-    pub fn set_cache(
+    pub fn write_to_mem_cache(
         &mut self,
         location: ImportLocation,
-        hash: Option<&Hash>,
         expr: Typed,
     ) {
-        if let Some(file_cache) = self.file_cache.as_ref() {
+        self.mem_cache.insert(location, expr);
+    }
+
+    pub fn write_to_disk_cache(&mut self, hash: &Option<Hash>, expr: &Typed) {
+        if let Some(disk_cache) = self.disk_cache.as_ref() {
             if let Some(hash) = hash {
-                let _ = file_cache.insert(hash, &expr);
+                let _ = disk_cache.insert(hash, &expr);
             }
         }
-        self.mem_cache.insert(location, expr);
     }
 
     pub fn with_cycle_detection(
-- 
cgit v1.2.3