Skip to content

GitLab

  • Menu
Projects Groups Snippets
  • Help
    • Help
    • Support
    • Community forum
    • Submit feedback
  • Sign in / Register
  • GHC GHC
  • Project information
    • Project information
    • Activity
    • Labels
    • Members
  • Repository
    • Repository
    • Files
    • Commits
    • Branches
    • Tags
    • Contributors
    • Graph
    • Compare
    • Locked Files
  • Issues 4,929
    • Issues 4,929
    • List
    • Boards
    • Service Desk
    • Milestones
    • Iterations
  • Merge requests 461
    • Merge requests 461
  • CI/CD
    • CI/CD
    • Pipelines
    • Jobs
    • Schedules
    • Test Cases
  • Deployments
    • Deployments
    • Releases
  • Analytics
    • Analytics
    • Value stream
    • CI/CD
    • Code review
    • Insights
    • Issue
    • Repository
  • Wiki
    • Wiki
  • Snippets
    • Snippets
  • Activity
  • Graph
  • Create a new issue
  • Jobs
  • Commits
  • Issue Boards
Collapse sidebar
  • Glasgow Haskell Compiler
  • GHCGHC
  • Issues
  • #17722
Closed
Open
Created Jan 21, 2020 by Simon Jakobi@sjakobiDeveloper

Panic "StgCmmEnv: variable not found" when building dhall with -O2

When building dhall's Dhall module with -O2, ghc panics:

Panic message
[34 of 40] Compiling Dhall            ( src/Dhall.hs, /home/simon/src/dhall-haskell/dist-newstyle/build/x86_64-linux/ghc-8.8.2/dhall-1.29.0/opt/build/Dhall.o )

src/Dhall.hs:134:1: warning: [-Wunused-imports]
    The import of ‘Data.Monoid’ is redundant
      except perhaps to import instances from ‘Data.Monoid’
    To import instances alone, use: import Data.Monoid()
    |
134 | import Data.Monoid ((<>))
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
ghc: panic! (the 'impossible' happened)
  (GHC version 8.8.2 for x86_64-unknown-linux):
	StgCmmEnv: variable not found
  lvl_s1ihUy
  local binds for:
  $l$wrealloc_g1ispG
  $lrealloc_g1ispH
  $lrealloc1_g1ispI
  $l$wrealloc_g1ispJ
  $lrealloc_g1ispK
  $lrealloc1_g1ispL
  $l$wrealloc_g1ispM
  $lrealloc_g1ispN
  $lrealloc1_g1ispO
  $l$wrealloc_g1ispP
  $lrealloc_g1ispQ
  $lrealloc1_g1ispR
  $l$wrealloc_g1ispS
  $lrealloc_g1ispT
  $lrealloc1_g1ispU
  $l$wrealloc_g1ispV
  $lrealloc_g1ispW
  $lrealloc1_g1ispX
  $l$wrealloc_g1ispY
  $lrealloc_g1ispZ
  $lrealloc1_g1isq0
  $l$wrealloc_g1isq1
  $lrealloc_g1isq2
  $lrealloc1_g1isq3
  $l$wrealloc_g1isq4
  $lrealloc_g1isq5
  $lrealloc1_g1isq6
  $l$wrealloc_g1isq7
  $lrealloc_g1isq8
  $lrealloc1_g1isq9
  $l$wrealloc_g1isqa
  $lrealloc_g1isqb
  $lrealloc1_g1isqc
  $l$wrealloc_g1isqd
  $lrealloc_g1isqe
  $lrealloc1_g1isqf
  $l$wrealloc_g1isqg
  $lrealloc_g1isqh
  $lrealloc1_g1isqi
  $lgo_g1isqj
  genericToDhallWith
  injectWith
  genericAutoWith
  autoWith
  evaluateSettings
  $fFromDhall(,)_$s$fSelectorMetaMetaSel
  map1
  map_foldrTree
  $w$sgo13
  void_$sgo13
  void3
  $fGenericFromDhallkU5
  $fGenericFromDhallkU6
  $fGenericFromDhallkU7
  $fGenericFromDhallkU8
  $fGenericFromDhallkU1_go
  $fGenericFromDhallkU9
  $s$fExceptionDetailedTypeError_$s$fShowDetailedTypeError
  $s$fShowDetailedTypeError_$cshowsPrec
  $w$sgo3
  $wgo3
  setIgnoringDuplicates1
  $wouter1_r1ioPd
  $wouter2_r1ioPe
  $wouter3_r1ioPf
  $wouter4_r1ioPg
  lvl3_r1ioPh
  lvl4_r1ioPi
  lvl5_r1ioPj
  lvl6_r1ioPk
  lvl9_r1ioPn
  lvl10_r1ioPo
  $wouter5_r1ioPp
  $wouter6_r1ioPq
  $wouter7_r1ioPr
  $wouter8_r1ioPs
  $wouter9_r1ioPt
  $wouter10_r1ioPu
  $wouter11_r1ioPv
  $wouter12_r1ioPw
  lvl11_r1ioPy
  $wouter13_r1ioPz
  $spoly_$wfoldlM_loop_r1ioPA
  $spoly_$wfoldlM_loop1_r1ioPB
  $spoly_$wfoldlM_loop2_r1ioPC
  $spoly_$wfoldlM_loop3_r1ioPD
  lvl12_r1ioPE
  $s$wtraverseTree_r1ioPF
  $wtraverseTree_r1ioPG
  sc_s1ipiB
  sc1_s1ipiC
  sc2_s1ipiD
  sc3_s1ipiE
  wild1_s1ipiF
  dt1_s1ipiI
  pr_s1ipiJ
  m_s1ipiK
  sf_s1ipiL
  sat_s1iplc
  sat_s1ipm2
  Call stack:
      CallStack (from HasCallStack):
        callStackDoc, called at compiler/utils/Outputable.hs:1159:37 in ghc:Outputable
        pprPanic, called at compiler/codeGen/StgCmmEnv.hs:149:9 in ghc:StgCmmEnv

With -dcore-lint, ghc reports

Core lint message
*** Core Lint errors : in result of Simplifier ***
<no location info>: warning:
    In the expression: lvl_sZFi
                         @ (Digit (Node (Elem b_XLt1)))
                         @ (FingerTree (Node (Elem b_XLt1)))
                         (let {
                            b1_aLq2 [OS=OneShot]
                              :: Validation
                                   (ExtractErrors Src Void) (FingerTree (Node (Node (Elem b_XLt1))))
                            [LclId,
                             Unf=Unf{Src=<vanilla>, TopLvl=False, Value=False, ConLike=False,
                                     WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 540 0}]
                            b1_aLq2
                              = $wtraverseTree_sWdp
                                  @ (Validation (ExtractErrors Src Void))
                                  @ (Node (Elem a_XLsZ))
                                  @ (Node (Elem b_XLt1))
                                  sc_s121b
                                  sc_s121c
                                  lvl_sZFi
                                  lvl_sZFj
                                  (\ (t_iLut :: Node (Node (Elem a_XLsZ))) ->
                                     case t_iLut of {
                                       Node2 dt2_iLuH a2_iLuI b2_iLuJ ->
                                         case sc_s121d a2_iLuI of {
                                           Failure e1_aLob ->
                                             Failure
                                               @ (ExtractErrors Src Void)
                                               @ (Node (Node (Elem b_XLt1)))
                                               (case sc_s121d b2_iLuJ of {
                                                  Failure e2_aLq9 ->
                                                    ($fSemigroupNonEmpty_$c<>
                                                       @ (ExtractError Src Void)
                                                       (e1_aLob
                                                        `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                                :: ExtractErrors Src Void
                                                                   ~R# NonEmpty
                                                                         (ExtractError Src Void)))
                                                       (e2_aLq9
                                                        `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                                :: ExtractErrors Src Void
                                                                   ~R# NonEmpty
                                                                         (ExtractError Src Void))))
                                                    `cast` (Sym (N:ExtractErrors[0]
                                                                     <Src>_R <Void>_R)
                                                            :: NonEmpty (ExtractError Src Void)
                                                               ~R# ExtractErrors Src Void);
                                                  Success ds1_aLqc -> e1_aLob
                                                });
                                           Success a1_aLoe ->
                                             case sc_s121d b2_iLuJ of {
                                               Failure e1_aLqj ->
                                                 Failure
                                                   @ (ExtractErrors Src Void)
                                                   @ (Node (Node (Elem b_XLt1)))
                                                   e1_aLqj;
                                               Success x_aLqm ->
                                                 Success
                                                   @ (ExtractErrors Src Void)
                                                   @ (Node (Node (Elem b_XLt1)))
                                                   (Node2
                                                      @ (Node (Elem b_XLt1))
                                                      dt2_iLuH
                                                      a1_aLoe
                                                      x_aLqm)
                                             }
                                         };
                                       Node3 dt2_iLuM a2_iLuN b2_iLuO c_iLuP ->
                                         lvl_sZFi
                                           @ (Node (Elem b_XLt1))
                                           @ (Node (Node (Elem b_XLt1)))
                                           (case sc_s121d a2_iLuN of {
                                              Failure e1_aLob ->
                                                Failure
                                                  @ (ExtractErrors Src Void)
                                                  @ (Node (Elem b_XLt1)
                                                     -> Node (Node (Elem b_XLt1)))
                                                  (case sc_s121d b2_iLuO of {
                                                     Failure e2_aLq9 ->
                                                       ($fSemigroupNonEmpty_$c<>
                                                          @ (ExtractError Src Void)
                                                          (e1_aLob
                                                           `cast` (N:ExtractErrors[0]
                                                                       <Src>_R <Void>_R
                                                                   :: ExtractErrors Src Void
                                                                      ~R# NonEmpty
                                                                            (ExtractError
                                                                               Src Void)))
                                                          (e2_aLq9
                                                           `cast` (N:ExtractErrors[0]
                                                                       <Src>_R <Void>_R
                                                                   :: ExtractErrors Src Void
                                                                      ~R# NonEmpty
                                                                            (ExtractError
                                                                               Src Void))))
                                                       `cast` (Sym (N:ExtractErrors[0]
                                                                        <Src>_R <Void>_R)
                                                               :: NonEmpty (ExtractError Src Void)
                                                                  ~R# ExtractErrors Src Void);
                                                     Success ds1_aLqc -> e1_aLob
                                                   });
                                              Success a1_aLoe ->
                                                case sc_s121d b2_iLuO of {
                                                  Failure e1_aLqj ->
                                                    Failure
                                                      @ (ExtractErrors Src Void)
                                                      @ (Node (Elem b_XLt1)
                                                         -> Node (Node (Elem b_XLt1)))
                                                      e1_aLqj;
                                                  Success x_aLqm ->
                                                    Success
                                                      @ (ExtractErrors Src Void)
                                                      @ (Node (Elem b_XLt1)
                                                         -> Node (Node (Elem b_XLt1)))
                                                      (\ (dt_iLuE :: Node (Elem b_XLt1)) ->
                                                         Node3
                                                           @ (Node (Elem b_XLt1))
                                                           dt2_iLuM
                                                           a1_aLoe
                                                           x_aLqm
                                                           dt_iLuE)
                                                }
                                            })
                                           (sc_s121d c_iLuP)
                                     })
                                  m_iLu7 } in
                          join {
                            $j_s13uy
                              :: ExtractErrors Src Void
                                 -> Validation
                                      (ExtractErrors Src Void)
                                      (Digit (Node (Elem b_XLt1))
                                       -> FingerTree (Node (Elem b_XLt1)))
                            [LclId[JoinId(1)], Arity=1]
                            $j_s13uy (e1_aLob [OS=OneShot] :: ExtractErrors Src Void)
                              = Failure
                                  @ (ExtractErrors Src Void)
                                  @ (Digit (Node (Elem b_XLt1)) -> FingerTree (Node (Elem b_XLt1)))
                                  (case b1_aLq2 of {
                                     Failure e2_aLq9 ->
                                       ($fSemigroupNonEmpty_$c<>
                                          @ (ExtractError Src Void)
                                          (e1_aLob
                                           `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                   :: ExtractErrors Src Void
                                                      ~R# NonEmpty (ExtractError Src Void)))
                                          (e2_aLq9
                                           `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                   :: ExtractErrors Src Void
                                                      ~R# NonEmpty (ExtractError Src Void))))
                                       `cast` (Sym (N:ExtractErrors[0] <Src>_R <Void>_R)
                                               :: NonEmpty (ExtractError Src Void)
                                                  ~R# ExtractErrors Src Void);
                                     Success ds1_aLqc -> e1_aLob
                                   }) } in
                          join {
                            $j_s13uz
                              :: Digit (Node (Elem b_XLt1))
                                 -> Validation
                                      (ExtractErrors Src Void)
                                      (Digit (Node (Elem b_XLt1))
                                       -> FingerTree (Node (Elem b_XLt1)))
                            [LclId[JoinId(1)], Arity=1]
                            $j_s13uz (a1_aLoe [OS=OneShot] :: Digit (Node (Elem b_XLt1)))
                              = case b1_aLq2 of {
                                  Failure e1_aLqj ->
                                    Failure
                                      @ (ExtractErrors Src Void)
                                      @ (Digit (Node (Elem b_XLt1))
                                         -> FingerTree (Node (Elem b_XLt1)))
                                      e1_aLqj;
                                  Success x_aLqm ->
                                    Success
                                      @ (ExtractErrors Src Void)
                                      @ (Digit (Node (Elem b_XLt1))
                                         -> FingerTree (Node (Elem b_XLt1)))
                                      (\ (dt_iL62 :: Digit (Node (Elem b_XLt1))) ->
                                         case a1_aLoe of dt_XL68 { __DEFAULT ->
                                         case dt_iL62 of dt_XL6b { __DEFAULT ->
                                         Deep @ (Node (Elem b_XLt1)) dt1_iLu5 dt_XL68 x_aLqm dt_XL6b
                                         }
                                         })
                                } } in
                          case pr_iLu6 of {
                            One a2_iLuc ->
                              case fmap
                                     @ (Validation (ExtractErrors Src Void))
                                     sc_s121b
                                     @ (Node (Elem b_XLt1))
                                     @ (Digit (Node (Elem b_XLt1)))
                                     (One @ (Node (Elem b_XLt1)))
                                     (sc_s121d a2_iLuc)
                              of {
                                Failure e1_aLob -> jump $j_s13uy e1_aLob;
                                Success a1_aLoe -> jump $j_s13uz a1_aLoe
                              };
                            Two a2_iLuf b2_iLug ->
                              case sc_s121d a2_iLuf of {
                                Failure e1_aLob ->
                                  let {
                                    e1_XLFQ :: ExtractErrors Src Void
                                    [LclId,
                                     Unf=Unf{Src=<vanilla>, TopLvl=False, Value=False,
                                             ConLike=False, WorkFree=False, Expandable=False,
                                             Guidance=IF_ARGS [] 70 0}]
                                    e1_XLFQ
                                      = case sc_s121d b2_iLug of {
                                          Failure e2_aLq9 ->
                                            ($fSemigroupNonEmpty_$c<>
                                               @ (ExtractError Src Void)
                                               (e1_aLob
                                                `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                        :: ExtractErrors Src Void
                                                           ~R# NonEmpty (ExtractError Src Void)))
                                               (e2_aLq9
                                                `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                        :: ExtractErrors Src Void
                                                           ~R# NonEmpty (ExtractError Src Void))))
                                            `cast` (Sym (N:ExtractErrors[0] <Src>_R <Void>_R)
                                                    :: NonEmpty (ExtractError Src Void)
                                                       ~R# ExtractErrors Src Void);
                                          Success ds1_aLqc -> e1_aLob
                                        } } in
                                  jump $j_s13uy e1_XLFQ;
                                Success a1_aLoe ->
                                  case sc_s121d b2_iLug of {
                                    Failure e1_aLqj -> jump $j_s13uy e1_aLqj;
                                    Success x_aLqm ->
                                      let {
                                        a1_XLFX :: Digit (Node (Elem b_XLt1))
                                        [LclId,
                                         Unf=Unf{Src=<vanilla>, TopLvl=False, Value=True,
                                                 ConLike=True, WorkFree=True, Expandable=True,
                                                 Guidance=IF_ARGS [] 10 30}]
                                        a1_XLFX = Two @ (Node (Elem b_XLt1)) a1_aLoe x_aLqm } in
                                      jump $j_s13uz a1_XLFX
                                  }
                              };
                            Three a2_iLuj b2_iLuk c_iLul ->
                              case lvl_sZFi
                                     @ (Node (Elem b_XLt1))
                                     @ (Digit (Node (Elem b_XLt1)))
                                     (case sc_s121d a2_iLuj of {
                                        Failure e1_aLob ->
                                          Failure
                                            @ (ExtractErrors Src Void)
                                            @ (Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                            (case sc_s121d b2_iLuk of {
                                               Failure e2_aLq9 ->
                                                 ($fSemigroupNonEmpty_$c<>
                                                    @ (ExtractError Src Void)
                                                    (e1_aLob
                                                     `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                             :: ExtractErrors Src Void
                                                                ~R# NonEmpty
                                                                      (ExtractError Src Void)))
                                                    (e2_aLq9
                                                     `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                             :: ExtractErrors Src Void
                                                                ~R# NonEmpty
                                                                      (ExtractError Src Void))))
                                                 `cast` (Sym (N:ExtractErrors[0] <Src>_R <Void>_R)
                                                         :: NonEmpty (ExtractError Src Void)
                                                            ~R# ExtractErrors Src Void);
                                               Success ds1_aLqc -> e1_aLob
                                             });
                                        Success a1_aLoe ->
                                          case sc_s121d b2_iLuk of {
                                            Failure e1_aLqj ->
                                              Failure
                                                @ (ExtractErrors Src Void)
                                                @ (Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                                e1_aLqj;
                                            Success x_aLqm ->
                                              Success
                                                @ (ExtractErrors Src Void)
                                                @ (Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                                (Three @ (Node (Elem b_XLt1)) a1_aLoe x_aLqm)
                                          }
                                      })
                                     (sc_s121d c_iLul)
                              of {
                                Failure e1_aLob -> jump $j_s13uy e1_aLob;
                                Success a1_aLoe -> jump $j_s13uz a1_aLoe
                              };
                            Four a2_iLuo b2_iLup c_iLuq d_iLur ->
                              case lvl_sZFi
                                     @ (Node (Elem b_XLt1))
                                     @ (Digit (Node (Elem b_XLt1)))
                                     (lvl_sZFi
                                        @ (Node (Elem b_XLt1))
                                        @ (Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                        (case sc_s121d a2_iLuo of {
                                           Failure e1_aLob ->
                                             Failure
                                               @ (ExtractErrors Src Void)
                                               @ (Node (Elem b_XLt1)
                                                  -> Node (Elem b_XLt1)
                                                  -> Digit (Node (Elem b_XLt1)))
                                               (case sc_s121d b2_iLup of {
                                                  Failure e2_aLq9 ->
                                                    ($fSemigroupNonEmpty_$c<>
                                                       @ (ExtractError Src Void)
                                                       (e1_aLob
                                                        `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                                :: ExtractErrors Src Void
                                                                   ~R# NonEmpty
                                                                         (ExtractError Src Void)))
                                                       (e2_aLq9
                                                        `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                                :: ExtractErrors Src Void
                                                                   ~R# NonEmpty
                                                                         (ExtractError Src Void))))
                                                    `cast` (Sym (N:ExtractErrors[0]
                                                                     <Src>_R <Void>_R)
                                                            :: NonEmpty (ExtractError Src Void)
                                                               ~R# ExtractErrors Src Void);
                                                  Success ds1_aLqc -> e1_aLob
                                                });
                                           Success a1_aLoe ->
                                             case sc_s121d b2_iLup of {
                                               Failure e1_aLqj ->
                                                 Failure
                                                   @ (ExtractErrors Src Void)
                                                   @ (Node (Elem b_XLt1)
                                                      -> Node (Elem b_XLt1)
                                                      -> Digit (Node (Elem b_XLt1)))
                                                   e1_aLqj;
                                               Success x_aLqm ->
                                                 Success
                                                   @ (ExtractErrors Src Void)
                                                   @ (Node (Elem b_XLt1)
                                                      -> Node (Elem b_XLt1)
                                                      -> Digit (Node (Elem b_XLt1)))
                                                   (Four @ (Node (Elem b_XLt1)) a1_aLoe x_aLqm)
                                             }
                                         })
                                        (sc_s121d c_iLuq))
                                     (sc_s121d d_iLur)
                              of {
                                Failure e1_aLob -> jump $j_s13uy e1_aLob;
                                Success a1_aLoe -> jump $j_s13uz a1_aLoe
                              }
                          })
                         (case sf_iLu8 of {
                            One a2_iLuT ->
                              fmap
                                @ (Validation (ExtractErrors Src Void))
                                sc_s121b
                                @ (Node (Elem b_XLt1))
                                @ (Digit (Node (Elem b_XLt1)))
                                (One @ (Node (Elem b_XLt1)))
                                (sc_s121d a2_iLuT);
                            Two a2_iLuW b2_iLuX ->
                              case sc_s121d a2_iLuW of {
                                Failure e1_aLob ->
                                  Failure
                                    @ (ExtractErrors Src Void)
                                    @ (Digit (Node (Elem b_XLt1)))
                                    (case sc_s121d b2_iLuX of {
                                       Failure e2_aLq9 ->
                                         ($fSemigroupNonEmpty_$c<>
                                            @ (ExtractError Src Void)
                                            (e1_aLob
                                             `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                     :: ExtractErrors Src Void
                                                        ~R# NonEmpty (ExtractError Src Void)))
                                            (e2_aLq9
                                             `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                     :: ExtractErrors Src Void
                                                        ~R# NonEmpty (ExtractError Src Void))))
                                         `cast` (Sym (N:ExtractErrors[0] <Src>_R <Void>_R)
                                                 :: NonEmpty (ExtractError Src Void)
                                                    ~R# ExtractErrors Src Void);
                                       Success ds1_aLqc -> e1_aLob
                                     });
                                Success a1_aLoe ->
                                  case sc_s121d b2_iLuX of {
                                    Failure e1_aLqj ->
                                      Failure
                                        @ (ExtractErrors Src Void)
                                        @ (Digit (Node (Elem b_XLt1)))
                                        e1_aLqj;
                                    Success x_aLqm ->
                                      Success
                                        @ (ExtractErrors Src Void)
                                        @ (Digit (Node (Elem b_XLt1)))
                                        (Two @ (Node (Elem b_XLt1)) a1_aLoe x_aLqm)
                                  }
                              };
                            Three a2_iLv0 b2_iLv1 c_iLv2 ->
                              lvl_sZFi
                                @ (Node (Elem b_XLt1))
                                @ (Digit (Node (Elem b_XLt1)))
                                (case sc_s121d a2_iLv0 of {
                                   Failure e1_aLob ->
                                     Failure
                                       @ (ExtractErrors Src Void)
                                       @ (Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                       (case sc_s121d b2_iLv1 of {
                                          Failure e2_aLq9 ->
                                            ($fSemigroupNonEmpty_$c<>
                                               @ (ExtractError Src Void)
                                               (e1_aLob
                                                `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                        :: ExtractErrors Src Void
                                                           ~R# NonEmpty (ExtractError Src Void)))
                                               (e2_aLq9
                                                `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                        :: ExtractErrors Src Void
                                                           ~R# NonEmpty (ExtractError Src Void))))
                                            `cast` (Sym (N:ExtractErrors[0] <Src>_R <Void>_R)
                                                    :: NonEmpty (ExtractError Src Void)
                                                       ~R# ExtractErrors Src Void);
                                          Success ds1_aLqc -> e1_aLob
                                        });
                                   Success a1_aLoe ->
                                     case sc_s121d b2_iLv1 of {
                                       Failure e1_aLqj ->
                                         Failure
                                           @ (ExtractErrors Src Void)
                                           @ (Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                           e1_aLqj;
                                       Success x_aLqm ->
                                         Success
                                           @ (ExtractErrors Src Void)
                                           @ (Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                           (Three @ (Node (Elem b_XLt1)) a1_aLoe x_aLqm)
                                     }
                                 })
                                (sc_s121d c_iLv2);
                            Four a2_iLv5 b2_iLv6 c_iLv7 d_iLv8 ->
                              lvl_sZFi
                                @ (Node (Elem b_XLt1))
                                @ (Digit (Node (Elem b_XLt1)))
                                (lvl_sZFi
                                   @ (Node (Elem b_XLt1))
                                   @ (Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                   (case sc_s121d a2_iLv5 of {
                                      Failure e1_aLob ->
                                        Failure
                                          @ (ExtractErrors Src Void)
                                          @ (Node (Elem b_XLt1)
                                             -> Node (Elem b_XLt1) -> Digit (Node (Elem b_XLt1)))
                                          (case sc_s121d b2_iLv6 of {
                                             Failure e2_aLq9 ->
                                               ($fSemigroupNonEmpty_$c<>
                                                  @ (ExtractError Src Void)
                                                  (e1_aLob
                                                   `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                           :: ExtractErrors Src Void
                                                              ~R# NonEmpty (ExtractError Src Void)))
                                                  (e2_aLq9
                                                   `cast` (N:ExtractErrors[0] <Src>_R <Void>_R
                                                           :: ExtractErrors Src Void
                                                              ~R# NonEmpty
                                                                    (ExtractError Src Void))))
                                               `cast` (Sym (N:ExtractErrors[0] <Src>_R <Void>_R)
                                                       :: NonEmpty (ExtractError Src Void)
                                                          ~R# ExtractErrors Src Void);
                                             Success ds1_aLqc -> e1_aLob
                                           });
                                      Success a1_aLoe ->
                                        case sc_s121d b2_iLv6 of {
                                          Failure e1_aLqj ->
                                            Failure
                                              @ (ExtractErrors Src Void)
                                              @ (Node (Elem b_XLt1)
                                                 -> Node (Elem b_XLt1)
                                                 -> Digit (Node (Elem b_XLt1)))
                                              e1_aLqj;
                                          Success x_aLqm ->
                                            Success
                                              @ (ExtractErrors Src Void)
                                              @ (Node (Elem b_XLt1)
                                                 -> Node (Elem b_XLt1)
                                                 -> Digit (Node (Elem b_XLt1)))
                                              (Four @ (Node (Elem b_XLt1)) a1_aLoe x_aLqm)
                                        }
                                    })
                                   (sc_s121d c_iLv7))
                                (sc_s121d d_iLv8)
                          })
    Out of scope: lvl_sZFi
                    :: forall a b.
                       Validation (ExtractErrors Src Void) (a -> b)
                       -> Validation (ExtractErrors Src Void) a
                       -> Validation (ExtractErrors Src Void) b
                  [LclId, Arity=2]

Full -dcore-lint message (7 MB)

I have reproduced the panic with both 8.8.2 and 8.6.5. GHC 8.4 and earlier don't show the panic. I haven't been able to build dhall with 8.10 due to build failures in its large dependency tree.

The Core seems to point at some Data.Sequence traversal, of which I see two in Dhall: 1, 2. In both cases, es is a Seq.

Reproduction steps

$ cabal get dhall-1.29.0
$ cd dhall-1.29.0
$ cabal build -O2 --ghc-options -dcore-lint
Edited Jan 21, 2020 by Simon Jakobi
To upload designs, you'll need to enable LFS and have an admin enable hashed storage. More information
Assignee
Assign to
Time tracking