Change ImportSemantics to not necessarily be α-normalized (#1162)

The motivation for this change is to avoid α-normalizing all imported
expressions.

For example, before this change you would get the following behavior
beginning with an empty cache

```
$ cat ./example.dhall
λ(a : Type) → a

$ dhall <<< './example.dhall'
λ(_ : Type) → _
```

The reason why is that the current code α-normalizes all imported
expressions, even when returning them fresh.

To fix this, I changed the `ImportSemantics` type to not require that
expressions are α-normalized.  Instead, the α-normalization only
happens at the last minute when interacting with the semantic cache, but
nowhere else.

I figured that this change would also be fine from the perspective of
the semi-semantic cache because false-negatives for this cache are
fine.  In particular, we probably don't mind if we get a cache miss for
the semi-semantic cache if the user renames a variable.

After this change imports are no longer α-normalized, whether loaded
from a hot or cold cache:

```
$ cat ./example.dhall
λ(a : Type) → a

$ dhall <<< './example.dhall'
λ(a : Type) → a

$ dhall <<< './example.dhall'
λ(a : Type) → a
```

Author: Gabriella439

dhall/src/Dhall/Import.hs

@@ -517,14 +517,14 @@ loadImportWithSemanticCache
         Nothing -> do
             ImportSemantics { importSemantics } <- loadImportWithSemisemanticCache import_
 
-            let variants = map (\version -> encodeExpression version importSemantics)
+            let variants = map (\version -> encodeExpression version (Dhall.Core.alphaNormalize importSemantics))
                                 [ minBound .. maxBound ]
             case Data.Foldable.find ((== semanticHash). Crypto.Hash.hash) variants of
                 Just bytes -> liftIO $ writeToSemanticCache semanticHash bytes
                 Nothing -> do
                     let expectedHash = semanticHash
                     Status { _standardVersion, _stack } <- State.get
-                    let actualHash = hashExpression _standardVersion importSemantics
+                    let actualHash = hashExpression _standardVersion (Dhall.Core.alphaNormalize importSemantics)
                     throwMissingImport (Imported _stack (HashMismatch {..}))
 
             return (ImportSemantics {..})
@@ -608,12 +608,10 @@ loadImportWithSemisemanticCache (Chained (Import (ImportHashed _ importType) Cod
                 Left  err -> throwMissingImport (Imported _stack err)
                 Right _ -> return (Dhall.Core.normalizeWith _normalizer resolvedExpr)
 
-            let alphaBetaNormal = Dhall.Core.alphaNormalize betaNormal
-
-            let bytes = encodeExpression _standardVersion alphaBetaNormal
+            let bytes = encodeExpression _standardVersion betaNormal
             lift $ writeToSemisemanticCache semisemanticHash bytes
 
-            return alphaBetaNormal
+            return betaNormal
 
     return (ImportSemantics {..})
 

dhall/src/Dhall/Import/Types.hs

@@ -48,7 +48,7 @@ instance Pretty Chained where
 
 data ImportSemantics = ImportSemantics
     { importSemantics :: Expr Src X
-    -- ^ The fully resolved import, typechecked and alpha-beta-normal.
+    -- ^ The fully resolved import, typechecked and beta-normal.
     }
 
 -- | `parent` imports (i.e. depends on) `child`