Implement new fall-back behavior for ? (#2203)

… and also track other standard changes, like parsing
multiple shebang lines

Author: Gabriella439

dhall/dhall-lang

@@ -159,6 +159,7 @@ Extra-Source-Files:
     dhall-lang/Prelude/Natural/toDouble
     dhall-lang/Prelude/Natural/toInteger
     dhall-lang/Prelude/Natural/*.dhall
+    dhall-lang/Prelude/NonEmpty/*.dhall
     dhall-lang/Prelude/Operator/package.dhall
     dhall-lang/Prelude/Optional/all
     dhall-lang/Prelude/Optional/any

dhall/dhall.cabal

@@ -1,3 +1,4 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
 {-# LANGUAGE CPP                 #-}
 {-# LANGUAGE DeriveAnyClass      #-}
 {-# LANGUAGE DeriveDataTypeable  #-}
@@ -7,6 +8,7 @@
 {-# LANGUAGE RankNTypes          #-}
 {-# LANGUAGE RecordWildCards     #-}
 {-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications    #-}
 {-# LANGUAGE ViewPatterns        #-}
 
 {-# OPTIONS_GHC -Wall #-}
@@ -167,6 +169,7 @@ import Data.List.NonEmpty               (NonEmpty (..))
 import Data.Text                        (Text)
 import Data.Typeable                    (Typeable)
 import Data.Void                        (Void, absurd)
+import Dhall.TypeCheck                  (TypeError)
 
 import Dhall.Syntax
     ( Chunks (..)
@@ -201,13 +204,15 @@ import Lens.Family.State.Strict (zoom)
 
 import qualified Codec.CBOR.Write                            as Write
 import qualified Codec.Serialise
+import qualified Control.Exception                           as Exception
 import qualified Control.Monad.State.Strict                  as State
 import qualified Control.Monad.Trans.Maybe                   as Maybe
 import qualified Data.ByteString
 import qualified Data.ByteString.Lazy
 import qualified Data.CaseInsensitive
 import qualified Data.Foldable
 import qualified Data.List.NonEmpty                          as NonEmpty
+import qualified Data.Maybe                                  as Maybe
 import qualified Data.Text                                   as Text
 import qualified Data.Text.Encoding
 import qualified Data.Text.IO
@@ -1157,11 +1162,29 @@ loadWith expr₀ = case expr₀ of
 
   ImportAlt a b -> loadWith a `catch` handler₀
     where
-      handler₀ (SourcedException (Src begin _ text₀) (MissingImports es₀)) =
-          loadWith b `catch` handler₁
+      is :: forall e . Exception e => SomeException -> Bool
+      is exception = Maybe.isJust (Exception.fromException @e exception)
+
+      isNotResolutionError exception =
+              is @(Imported (TypeError Src Void)) exception
+          ||  is @(Imported  Cycle              ) exception
+          ||  is @(Imported  HashMismatch       ) exception
+          ||  is @(Imported  ParseError         ) exception
+
+      handler₀ exception₀@(SourcedException (Src begin _ text₀) (MissingImports es₀))
+          | any isNotResolutionError es₀ =
+              throwM exception₀
+          | otherwise = do
+              loadWith b `catch` handler₁
         where
-          handler₁ (SourcedException (Src _ end text₁) (MissingImports es₁)) =
-              throwM (SourcedException (Src begin end text₂) (MissingImports (es₀ ++ es₁)))
+          handler₁ exception₁@(SourcedException (Src _ end text₁) (MissingImports es₁))
+              | any isNotResolutionError es₁ =
+                  throwM exception₁
+              | otherwise =
+                  -- Fix the source span for the error message to encompass both
+                  -- alternatives, since both are equally to blame for the
+                  -- failure if neither succeeds.
+                  throwM (SourcedException (Src begin end text₂) (MissingImports (es₀ ++ es₁)))
             where
               text₂ = text₀ <> " ? " <> text₁
 

dhall/src/Dhall/Import.hs

@@ -156,9 +156,8 @@ failureTest path = do
     let pathString = Text.unpack path
 
     Tasty.HUnit.testCase pathString (do
-        text <- Text.IO.readFile pathString
-
-        actualExpr <- Core.throws (Parser.exprFromText mempty text)
+        actualExpr <- do
+          Core.throws (Parser.exprFromText mempty (Test.Util.toDhallPath path))
 
         succeeded <- Exception.catch @SomeException
           (do _ <- Test.Util.load actualExpr