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,869
    • Issues 4,869
    • List
    • Boards
    • Service Desk
    • Milestones
    • Iterations
  • Merge requests 459
    • Merge requests 459
  • 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
  • #16978
Closed
Open
Created Jul 24, 2019 by Ryan Scott@RyanGlScottMaintainer

Minimized `microstache` code fails Core Lint

microstache-1.0.1.1 fails to build with -dcore-lint -O on GHC 8.8, but not with GHC 8.6 or HEAD. Here is a minimized test case that has no dependencies (except for boot libraries):

module Bug where

import Control.Monad.Trans.State.Strict (State, modify')
import Data.Text (Text)
import qualified Data.Text.Lazy.Builder as B

data Value = String !Text | Null

type Render a = State B.Builder a

tellBuilder :: B.Builder -> Render ()
tellBuilder b' = modify' f where
    f b = b <> b'

renderNode :: Value -> Render ()
renderNode v =
  renderValue v >>= outputRaw

outputRaw :: Text -> Render ()
outputRaw = tellBuilder . B.fromText
{-# INLINE outputRaw #-}

renderValue :: Value -> Render Text
renderValue v = case v of
    String str -> return str
    _ -> let x = x in x
{-# INLINE renderValue #-}

Click "Details" to see the Core Lint error (it's pretty long, so I've collapsed it by default):

$ /opt/ghc/8.8.1/bin/ghc -dcore-lint -O Bug.hs
[1 of 1] Compiling Bug              ( Bug.hs, Bug.o )
*** Core Lint errors : in result of Float out(FOS {Lam = Just 0,
                                                   Consts = True,
                                                   OverSatApps = True}) ***
<no location info>: warning:
    In the expression: $wk_s3mo ipv2_a3ds 0# 0# x#_a3dk ipv1_a3dr
    Mismatch in type between binder and occurrence
    Var: $wk_s3mo
    Binder type: MutableByteArray# s_a289
                 -> Int#
                 -> Int#
                 -> Int#
                 -> State# s_a289
                 -> (# State# s_a289, [Text] #)
    Occurrence type: MutableByteArray# s_X28Q
                     -> Int#
                     -> Int#
                     -> Int#
                     -> State# s_X28Q
                     -> (# State# s_X28Q, [Text] #)
      Before subst: MutableByteArray# s_a289
                    -> Int#
                    -> Int#
                    -> Int#
                    -> State# s_a289
                    -> (# State# s_a289, [Text] #)
*** Offending Program ***
$trModule_s1X5 :: Addr#
[LclId]
$trModule_s1X5 = "main"#

$trModule_s1X6 :: TrName
[LclId, Str=m1]
$trModule_s1X6 = TrNameS $trModule_s1X5

$trModule_s1X7 :: Addr#
[LclId]
$trModule_s1X7 = "Bug"#

$trModule_s1X8 :: TrName
[LclId, Str=m1]
$trModule_s1X8 = TrNameS $trModule_s1X7

$trModule :: Module
[LclIdX, Str=m]
$trModule = Module $trModule_s1X6 $trModule_s1X8

$krep_a1Sc [InlPrag=NOUSERINLINE[~]] :: KindRep
[LclId, Str=m1]
$krep_a1Sc = KindRepTyConApp $tcText ([] @ KindRep)

$tcValue_s1X9 :: Addr#
[LclId]
$tcValue_s1X9 = "Value"#

$tcValue_s1Xa :: TrName
[LclId, Str=m1]
$tcValue_s1Xa = TrNameS $tcValue_s1X9

$tcValue :: TyCon
[LclIdX, Str=m]
$tcValue
  = TyCon
      1242433001481263932##
      10437845036473361927##
      $trModule
      $tcValue_s1Xa
      0#
      krep$*

$krep_a1Sd [InlPrag=NOUSERINLINE[~]] :: KindRep
[LclId, Str=m1]
$krep_a1Sd = KindRepTyConApp $tcValue ([] @ KindRep)

$tc'Null_s1Xb :: Addr#
[LclId]
$tc'Null_s1Xb = "'Null"#

$tc'Null_s1Xc :: TrName
[LclId, Str=m1]
$tc'Null_s1Xc = TrNameS $tc'Null_s1Xb

$tc'Null :: TyCon
[LclIdX, Str=m]
$tc'Null
  = TyCon
      8066795106939322414##
      11714487014933546042##
      $trModule
      $tc'Null_s1Xc
      0#
      $krep_a1Sd

$krep_a1Sb [InlPrag=NOUSERINLINE[~]] :: KindRep
[LclId, Str=m4]
$krep_a1Sb = KindRepFun $krep_a1Sc $krep_a1Sd

$tc'String_s1Xd :: Addr#
[LclId]
$tc'String_s1Xd = "'String"#

$tc'String_s1Xe :: TrName
[LclId, Str=m1]
$tc'String_s1Xe = TrNameS $tc'String_s1Xd

$tc'String :: TyCon
[LclIdX, Str=m]
$tc'String
  = TyCon
      9853751225266714820##
      17235034137091912975##
      $trModule
      $tc'String_s1Xe
      0#
      $krep_a1Sb

tellBuilder_s3bE :: Builder -> Builder -> ((), Builder)
[LclId,
 Arity=2,
 Str=<L,C(U)><L,C(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
         Tmpl= \ (b'_aZY [Occ=Once] :: Builder)
                 (s1_a1SW [Occ=Once] :: Builder) ->
                 ((),
                  (\ (@ s_a289) ->
                     . @ (Buffer s_a289 -> ST s_a289 [Text])
                       @ (Buffer s_a289 -> ST s_a289 [Text])
                       @ (Buffer s_a289 -> ST s_a289 [Text])
                       ((s1_a1SW
                         `cast` (N:Builder[0]
                                 :: Builder
                                    ~R# (forall s.
                                         (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])))
                          @ s_a289)
                       ((b'_aZY
                         `cast` (N:Builder[0]
                                 :: Builder
                                    ~R# (forall s.
                                         (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])))
                          @ s_a289))
                  `cast` (Sym (N:Builder[0])
                          :: (forall s. (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])
                             ~R# Builder))}]
tellBuilder_s3bE
  = \ (b'_aZY :: Builder) (s1_a1SW :: Builder) ->
      ((),
       (\ (@ s_a289) ->
          . @ (Buffer s_a289 -> ST s_a289 [Text])
            @ (Buffer s_a289 -> ST s_a289 [Text])
            @ (Buffer s_a289 -> ST s_a289 [Text])
            ((s1_a1SW
              `cast` (N:Builder[0]
                      :: Builder
                         ~R# (forall s.
                              (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])))
               @ s_a289)
            ((b'_aZY
              `cast` (N:Builder[0]
                      :: Builder
                         ~R# (forall s.
                              (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])))
               @ s_a289))
       `cast` (Sym (N:Builder[0])
               :: (forall s. (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])
                  ~R# Builder))

tellBuilder :: Builder -> Render ()
[LclIdX,
 Arity=2,
 Str=<L,C(U)><L,C(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
         Tmpl= tellBuilder_s3bE
               `cast` (<Builder>_R
                       ->_R (<Builder>_R
                             ->_R Sym (N:Identity[0] <((), Builder)>_R)) ; Sym (N:StateT[0]
                                                                                    <Builder>_N
                                                                                    <Identity>_R
                                                                                    <()>_N)
                       :: (Builder -> Builder -> ((), Builder))
                          ~R# (Builder -> StateT Builder Identity ()))}]
tellBuilder
  = tellBuilder_s3bE
    `cast` (<Builder>_R
            ->_R (<Builder>_R
                  ->_R Sym (N:Identity[0] <((), Builder)>_R)) ; Sym (N:StateT[0]
                                                                         <Builder>_N
                                                                         <Identity>_R
                                                                         <()>_N)
            :: (Builder -> Builder -> ((), Builder))
               ~R# (Builder -> StateT Builder Identity ()))

$woutputRaw_s3me [InlPrag=NOUSERINLINE[2]]
  :: Text -> Builder -> (# (), Builder #)
[LclId, Arity=2, Str=<L,U(U,U,U)><L,C(U)>]
$woutputRaw_s3me
  = \ (w_s3m9 :: Text) (w_s3ma :: Builder) ->
      (# (),
         (\ (@ s_a289)
            (x_X1U2 [Dmd=<L,C(U)>] :: Buffer s_a289 -> ST s_a289 [Text]) ->
            (w_s3ma
             `cast` (N:Builder[0]
                     :: Builder
                        ~R# (forall s.
                             (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])))
              @ s_a289
              (case w_s3m9 of wild_a1Te { Text dt_a1Th dt1_a1Ti dt2_a1Tj ->
               case <=# dt2_a1Tj 0# of {
                 __DEFAULT ->
                   case <=# dt2_a1Tj 128# of {
                     __DEFAULT ->
                       (\ (buf_a1Vo :: Buffer s_a289) (eta_X1b :: State# s_a289) ->
                          case buf_a1Vo of wild1_a1Vx
                          { Buffer dt3_a1VN dt4_a1VO dt5_a1VP [Dmd=<S,U>] dt6_a1VQ ->
                          case dt5_a1VP of wild2_a1VS {
                            __DEFAULT ->
                              case unsafeFreezeByteArray# @ s_a289 dt3_a1VN eta_X1b of
                              { (# ipv_a1VW, ipv1_a1VX #) ->
                              (# ipv_a1VW,
                                 : @ Text
                                   (Text ipv1_a1VX dt4_a1VO dt5_a1VP)
                                   (case ((x_X1U2
                                             (Buffer
                                                @ s_a289
                                                dt3_a1VN
                                                (+# dt4_a1VO dt5_a1VP)
                                                0#
                                                dt6_a1VQ))
                                          `cast` (N:ST[0] <s_a289>_N <[Text]>_R
                                                  :: ST s_a289 [Text] ~R# STRep s_a289 [Text]))
                                           ipv_a1VW
                                    of
                                    { (# ipv_a1We [Dmd=<L,A>], ipv1_a1Wf #) ->
                                    : @ Text w_s3m9 ipv1_a1Wf
                                    }) #)
                              };
                            0# ->
                              case ((x_X1U2 buf_a1Vo)
                                    `cast` (N:ST[0] <s_a289>_N <[Text]>_R
                                            :: ST s_a289 [Text] ~R# STRep s_a289 [Text]))
                                     eta_X1b
                              of
                              { (# ipv_a1We, ipv1_a1Wf #) ->
                              (# ipv_a1We, : @ Text w_s3m9 ipv1_a1Wf #)
                              }
                          }
                          })
                       `cast` (<Buffer s_a289>_R ->_R Sym (N:ST[0] <s_a289>_N <[Text]>_R)
                               :: (Buffer s_a289 -> STRep s_a289 [Text])
                                  ~R# (Buffer s_a289 -> ST s_a289 [Text]));
                     1# ->
                       let {
                         $wk_s3m5 [InlPrag=NOUSERINLINE[2]]
                           :: MutableByteArray# s_a289
                              -> Int#
                              -> Int#
                              -> Int#
                              -> State# s_a289
                              -> (# State# s_a289, [Text] #)
                         [LclId, Arity=5, Str=<L,U><L,U><L,U><L,U><L,U>]
                         $wk_s3m5
                           = \ (ww_s3m0 :: MutableByteArray# s_a289)
                               (ww_s3m1 :: Int#)
                               (ww_s3m2 :: Int#)
                               (ww_s3m3 :: Int#)
                               (w_s3lX :: State# s_a289) ->
                               let {
                                 x_a1Wr :: Int#
                                 [LclId]
                                 x_a1Wr = +# ww_s3m1 ww_s3m2 } in
                               let {
                                 y_a1Wq :: Int#
                                 [LclId]
                                 y_a1Wq = +# dt2_a1Tj x_a1Wr } in
                               case >=# x_a1Wr y_a1Wq of {
                                 __DEFAULT ->
                                   case {__pkg_ccall text-1.2.3.1 forall s.
                          MutableByteArray# s
                          -> Word#
                          -> ByteArray#
                          -> Word#
                          -> Word#
                          -> State# RealWorld
                          -> (# State# RealWorld #)}_a1Wx
                                          @ s_a289
                                          ww_s3m0
                                          (int2Word# x_a1Wr)
                                          dt_a1Th
                                          (int2Word# dt1_a1Ti)
                                          (int2Word# (-# y_a1Wq x_a1Wr))
                                          (w_s3lX
                                           `cast` ((State# (UnsafeCo nominal s_a289 RealWorld))_R
                                                   :: State# s_a289 ~R# State# RealWorld))
                                   of
                                   { (# ds2_a1WC #) ->
                                   ((x_X1U2
                                       (Buffer
                                          @ s_a289
                                          ww_s3m0
                                          ww_s3m1
                                          (+# ww_s3m2 dt2_a1Tj)
                                          (-# ww_s3m3 dt2_a1Tj)))
                                    `cast` (N:ST[0] <s_a289>_N <[Text]>_R
                                            :: ST s_a289 [Text] ~R# STRep s_a289 [Text]))
                                     (ds2_a1WC
                                      `cast` ((State# (UnsafeCo nominal RealWorld s_a289))_R
                                              :: State# RealWorld ~R# State# s_a289))
                                   };
                                 1# ->
                                   ((x_X1U2
                                       (Buffer
                                          @ s_a289
                                          ww_s3m0
                                          ww_s3m1
                                          (+# ww_s3m2 dt2_a1Tj)
                                          (-# ww_s3m3 dt2_a1Tj)))
                                    `cast` (N:ST[0] <s_a289>_N <[Text]>_R
                                            :: ST s_a289 [Text] ~R# STRep s_a289 [Text]))
                                     w_s3lX
                               } } in
                       let {
                         $wk1_s3ph [InlPrag=NOUSERINLINE[2]]
                           :: State# s_a289 -> (# State# s_a289, [Text] #)
                         [LclId, Arity=1, Str=<L,U>]
                         $wk1_s3ph
                           = \ (w_s3m7 [OS=OneShot] :: State# s_a289) ->
                               join {
                                 $j_s3na :: Int# -> (# State# s_a289, [Text] #)
                                 [LclId[JoinId(1)], Arity=1]
                                 $j_s3na (x#_a3dk [OS=OneShot] :: Int#)
                                   = case <# x#_a3dk 0# of {
                                       __DEFAULT ->
                                         case andI# x#_a3dk 4611686018427387904# of {
                                           __DEFAULT -> case array_size_error of wild_00 { };
                                           0# ->
                                             case newByteArray#
                                                    @ s_a289 (uncheckedIShiftL# x#_a3dk 1#) w_s3m7
                                             of
                                             { (# ipv1_a3dr, ipv2_a3ds #) ->
                                             $wk_s3m5 ipv2_a3ds 0# 0# x#_a3dk ipv1_a3dr
                                             }
                                         };
                                       1# -> case array_size_error of wild_00 { }
                                     } } in
                               case <=# dt2_a1Tj 112# of {
                                 __DEFAULT -> jump $j_s3na dt2_a1Tj;
                                 1# -> jump $j_s3na 112#
                               } } in
                       (\ (buf_a3d2 :: Buffer s_a289) (eta_X1a :: State# s_a289) ->
                          case buf_a3d2 of { Buffer dt_a3d7 dt1_a3d8 dt2_a3d9 dt3_a3da ->
                          case <=# dt2_a1Tj dt3_a3da of {
                            __DEFAULT ->
                              case dt2_a3d9 of wild1_a3du {
                                __DEFAULT ->
                                  case unsafeFreezeByteArray# @ s_a289 dt_a3d7 eta_X1a of
                                  { (# ipv1_a3dy, ipv2_a3dz #) ->
                                  (# ipv1_a3dy,
                                     : @ Text
                                       (Text ipv2_a3dz dt1_a3d8 dt2_a3d9)
                                       (case $wk1_s3ph ipv1_a3dy of
                                        { (# ipv3_a3dD [Dmd=<L,A>], ipv4_a3dE [Dmd=<S,U>] #) ->
                                        ipv4_a3dE
                                        }) #)
                                  };
                                0# -> $wk1_s3ph eta_X1a
                              };
                            1# -> $wk_s3m5 dt_a3d7 dt1_a3d8 dt2_a3d9 dt3_a3da eta_X1a
                          }
                          })
                       `cast` (<Buffer s_a289>_R ->_R Sym (N:ST[0] <s_a289>_N <[Text]>_R)
                               :: (Buffer s_a289 -> STRep s_a289 [Text])
                                  ~R# (Buffer s_a289 -> ST s_a289 [Text]))
                   };
                 1# -> \ (buf_a1WH :: Buffer s_a289) -> x_X1U2 buf_a1WH
               }
               }))
         `cast` (Sym (N:Builder[0])
                 :: (forall s. (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])
                    ~R# Builder) #)

outputRaw_s3c9 [InlPrag=NOUSERINLINE[2]]
  :: Text -> Builder -> ((), Builder)
[LclId,
 Arity=2,
 Str=<L,U(U,U,U)><L,C(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
         Tmpl= \ (w_s3m9 [Occ=Once] :: Text)
                 (w_s3ma [Occ=Once] :: Builder) ->
                 case $woutputRaw_s3me w_s3m9 w_s3ma of
                 { (# ww_s3mL [Occ=Once], ww_s3mM [Occ=Once] #) ->
                 (ww_s3mL, ww_s3mM)
                 }}]
outputRaw_s3c9
  = \ (w_s3m9 :: Text) (w_s3ma :: Builder) ->
      case $woutputRaw_s3me w_s3m9 w_s3ma of { (# ww_s3mL, ww_s3mM #) ->
      (ww_s3mL, ww_s3mM)
      }

outputRaw [InlPrag=INLINE (sat-args=0)] :: Text -> Render ()
[LclIdX,
 Arity=2,
 Str=<L,U(U,U,U)><L,C(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=0,unsat_ok=False,boring_ok=True)
         Tmpl= \ (x_X1TU [Occ=OnceL] :: Text) ->
                 let {
                   b'_X10y [Occ=OnceL] :: Builder
                   [LclId, Arity=3]
                   b'_X10y = fromText x_X1TU } in
                 (\ (s1_a1SW [Occ=Once] :: Builder) -> ((), append s1_a1SW b'_X10y))
                 `cast` ((<Builder>_R
                          ->_R Sym (N:Identity[0] <((), Builder)>_R)) ; Sym (N:StateT[0]
                                                                                 <Builder>_N
                                                                                 <Identity>_R
                                                                                 <()>_N)
                         :: (Builder -> ((), Builder)) ~R# StateT Builder Identity ())}]
outputRaw
  = outputRaw_s3c9
    `cast` (<Text>_R
            ->_R (<Builder>_R
                  ->_R Sym (N:Identity[0] <((), Builder)>_R)) ; Sym (N:StateT[0]
                                                                         <Builder>_N
                                                                         <Identity>_R
                                                                         <()>_N)
            :: (Text -> Builder -> ((), Builder))
               ~R# (Text -> StateT Builder Identity ()))

Rec {
x_s3cu [Occ=LoopBreaker] :: Render Text
[LclId, Str=b]
x_s3cu = x_s3cu
end Rec }

renderValue_s3o7 :: Value -> Builder -> Identity (Text, Builder)
[LclId, Arity=2, Str=<S,1*U>]
renderValue_s3o7
  = \ (v_a102 :: Value) (eta_B1 :: Builder) ->
      case v_a102 of {
        String str_a103 ->
          (str_a103, eta_B1)
          `cast` (Sym (N:Identity[0] <(Text, Builder)>_R)
                  :: (Text, Builder) ~R# Identity (Text, Builder));
        Null -> case x_s3cu of wild_00 { }
      }

renderValue [InlPrag=INLINE (sat-args=1)] :: Value -> Render Text
[LclIdX,
 Arity=2,
 Str=<S,1*U>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=1,unsat_ok=False,boring_ok=False)
         Tmpl= \ (v_X10U [Occ=Once!] :: Value) ->
                 case v_X10U of {
                   String str_a103 [Occ=OnceL] ->
                     (\ (eta1_a1X1 [Occ=Once] :: Builder) -> (str_a103, eta1_a1X1))
                     `cast` ((<Builder>_R
                              ->_R Sym (N:Identity[0] <(Text, Builder)>_R)) ; Sym (N:StateT[0]
                                                                                       <Builder>_N
                                                                                       <Identity>_R
                                                                                       <Text>_N)
                             :: (Builder -> (Text, Builder)) ~R# StateT Builder Identity Text);
                   Null ->
                     joinrec {
                       x_a1Qg [Occ=LoopBreakerT[0]] :: Render Text
                       [LclId[JoinId(0)]]
                       x_a1Qg = jump x_a1Qg; } in
                     jump x_a1Qg
                 }}]
renderValue
  = renderValue_s3o7
    `cast` (<Value>_R
            ->_R Sym (N:StateT[0] <Builder>_N <Identity>_R <Text>_N)
            :: (Value -> Builder -> Identity (Text, Builder))
               ~R# (Value -> StateT Builder Identity Text))

Rec {
x_s3cv [Occ=LoopBreaker] :: StateT Builder Identity Text
[LclId, Str=b]
x_s3cv = x_s3cv
end Rec }

$wrenderNode_s3mK [InlPrag=NOUSERINLINE[2]]
  :: Value -> Builder -> (# (), Builder #)
[LclId, Arity=2, Str=<S,1*U><L,C(U)>]
$wrenderNode_s3mK
  = \ (w_s3mF :: Value) (w_s3mG :: Builder) ->
      case w_s3mF of {
        String str_a103 [Dmd=<L,U(U,U,U)>] ->
          case str_a103 of wild_s3pj { Text dt_s3pk dt1_s3pl dt2_s3pm ->
          (# (),
             (\ (@ s_a289)
                (x_a1Tc [Dmd=<L,C(U)>] :: Buffer s_a289 -> ST s_a289 [Text]) ->
                (w_s3mG
                 `cast` (N:Builder[0]
                         :: Builder
                            ~R# (forall s.
                                 (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])))
                  @ s_a289
                  (case <=# dt2_s3pm 0# of {
                     __DEFAULT ->
                       case <=# dt2_s3pm 128# of {
                         __DEFAULT ->
                           (\ (buf_X1WP :: Buffer s_a289) (eta_X2H :: State# s_a289) ->
                              case buf_X1WP of wild1_a1Vx
                              { Buffer dt3_a1VN dt4_a1VO dt5_a1VP [Dmd=<S,U>] dt6_a1VQ ->
                              case dt5_a1VP of wild2_a1VS {
                                __DEFAULT ->
                                  case unsafeFreezeByteArray# @ s_a289 dt3_a1VN eta_X2H of
                                  { (# ipv_a1VW, ipv1_a1VX #) ->
                                  (# ipv_a1VW,
                                     : @ Text
                                       (Text ipv1_a1VX dt4_a1VO dt5_a1VP)
                                       (case ((x_a1Tc
                                                 (Buffer
                                                    @ s_a289
                                                    dt3_a1VN
                                                    (+# dt4_a1VO dt5_a1VP)
                                                    0#
                                                    dt6_a1VQ))
                                              `cast` (N:ST[0] <s_a289>_N <[Text]>_R
                                                      :: ST s_a289 [Text] ~R# STRep s_a289 [Text]))
                                               ipv_a1VW
                                        of
                                        { (# ipv_a1We [Dmd=<L,A>], ipv1_a1Wf #) ->
                                        : @ Text str_a103 ipv1_a1Wf
                                        }) #)
                                  };
                                0# ->
                                  case ((x_a1Tc buf_X1WP)
                                        `cast` (N:ST[0] <s_a289>_N <[Text]>_R
                                                :: ST s_a289 [Text] ~R# STRep s_a289 [Text]))
                                         eta_X2H
                                  of
                                  { (# ipv_a1We, ipv1_a1Wf #) ->
                                  (# ipv_a1We, : @ Text str_a103 ipv1_a1Wf #)
                                  }
                              }
                              })
                           `cast` (<Buffer s_a289>_R ->_R Sym (N:ST[0] <s_a289>_N <[Text]>_R)
                                   :: (Buffer s_a289 -> STRep s_a289 [Text])
                                      ~R# (Buffer s_a289 -> ST s_a289 [Text]));
                         1# ->
                           let {
                             $wk_s3mo [InlPrag=NOUSERINLINE[2]]
                               :: MutableByteArray# s_a289
                                  -> Int#
                                  -> Int#
                                  -> Int#
                                  -> State# s_a289
                                  -> (# State# s_a289, [Text] #)
                             [LclId, Arity=5, Str=<L,U><L,U><L,U><L,U><L,U>]
                             $wk_s3mo
                               = \ (ww_s3mj :: MutableByteArray# s_a289)
                                   (ww_s3mk :: Int#)
                                   (ww_s3ml :: Int#)
                                   (ww_s3mm :: Int#)
                                   (w_s3mg :: State# s_a289) ->
                                   let {
                                     x_a1Wr :: Int#
                                     [LclId]
                                     x_a1Wr = +# ww_s3mk ww_s3ml } in
                                   let {
                                     y_a1Wq :: Int#
                                     [LclId]
                                     y_a1Wq = +# dt2_s3pm x_a1Wr } in
                                   case >=# x_a1Wr y_a1Wq of {
                                     __DEFAULT ->
                                       case {__pkg_ccall text-1.2.3.1 forall s.
                          MutableByteArray# s
                          -> Word#
                          -> ByteArray#
                          -> Word#
                          -> Word#
                          -> State# RealWorld
                          -> (# State# RealWorld #)}_a1Wx
                                              @ s_a289
                                              ww_s3mj
                                              (int2Word# x_a1Wr)
                                              dt_s3pk
                                              (int2Word# dt1_s3pl)
                                              (int2Word# (-# y_a1Wq x_a1Wr))
                                              (w_s3mg
                                               `cast` ((State#
                                                          (UnsafeCo nominal s_a289 RealWorld))_R
                                                       :: State# s_a289 ~R# State# RealWorld))
                                       of
                                       { (# ds2_a1WC #) ->
                                       ((x_a1Tc
                                           (Buffer
                                              @ s_a289
                                              ww_s3mj
                                              ww_s3mk
                                              (+# ww_s3ml dt2_s3pm)
                                              (-# ww_s3mm dt2_s3pm)))
                                        `cast` (N:ST[0] <s_a289>_N <[Text]>_R
                                                :: ST s_a289 [Text] ~R# STRep s_a289 [Text]))
                                         (ds2_a1WC
                                          `cast` ((State# (UnsafeCo nominal RealWorld s_a289))_R
                                                  :: State# RealWorld ~R# State# s_a289))
                                       };
                                     1# ->
                                       ((x_a1Tc
                                           (Buffer
                                              @ s_a289
                                              ww_s3mj
                                              ww_s3mk
                                              (+# ww_s3ml dt2_s3pm)
                                              (-# ww_s3mm dt2_s3pm)))
                                        `cast` (N:ST[0] <s_a289>_N <[Text]>_R
                                                :: ST s_a289 [Text] ~R# STRep s_a289 [Text]))
                                         w_s3mg
                                   } } in
                           let {
                             poly_$wk1_s3po [InlPrag=NOUSERINLINE[2]]
                               :: forall s. State# s -> (# State# s, [Text] #)
                             [LclId, Arity=1, Str=<L,U>]
                             poly_$wk1_s3po
                               = \ (@ s_a289) (w_s3mq [OS=OneShot] :: State# s_a289) ->
                                   join {
                                     $j_s3nC :: Int# -> (# State# s_a289, [Text] #)
                                     [LclId[JoinId(1)], Arity=1]
                                     $j_s3nC (x#_a3dk [OS=OneShot] :: Int#)
                                       = case <# x#_a3dk 0# of {
                                           __DEFAULT ->
                                             case andI# x#_a3dk 4611686018427387904# of {
                                               __DEFAULT -> case array_size_error of wild_00 { };
                                               0# ->
                                                 case newByteArray#
                                                        @ s_a289
                                                        (uncheckedIShiftL# x#_a3dk 1#)
                                                        w_s3mq
                                                 of
                                                 { (# ipv1_a3dr, ipv2_a3ds #) ->
                                                 $wk_s3mo ipv2_a3ds 0# 0# x#_a3dk ipv1_a3dr
                                                 }
                                             };
                                           1# -> case array_size_error of wild_00 { }
                                         } } in
                                   case <=# dt2_s3pm 112# of {
                                     __DEFAULT -> jump $j_s3nC dt2_s3pm;
                                     1# -> jump $j_s3nC 112#
                                   } } in
                           (\ (buf_a3d2 :: Buffer s_a289) (eta_X1k :: State# s_a289) ->
                              case buf_a3d2 of { Buffer dt_a3d7 dt1_a3d8 dt2_a3d9 dt3_a3da ->
                              case <=# dt2_s3pm dt3_a3da of {
                                __DEFAULT ->
                                  case dt2_a3d9 of wild1_a3du {
                                    __DEFAULT ->
                                      case unsafeFreezeByteArray# @ s_a289 dt_a3d7 eta_X1k of
                                      { (# ipv1_a3dy, ipv2_a3dz #) ->
                                      (# ipv1_a3dy,
                                         : @ Text
                                           (Text ipv2_a3dz dt1_a3d8 dt2_a3d9)
                                           (case poly_$wk1_s3po @ s_a289 ipv1_a3dy of
                                            { (# ipv3_a3dD [Dmd=<L,A>], ipv4_a3dE [Dmd=<S,U>] #) ->
                                            ipv4_a3dE
                                            }) #)
                                      };
                                    0# -> poly_$wk1_s3po @ s_a289 eta_X1k
                                  };
                                1# -> $wk_s3mo dt_a3d7 dt1_a3d8 dt2_a3d9 dt3_a3da eta_X1k
                              }
                              })
                           `cast` (<Buffer s_a289>_R ->_R Sym (N:ST[0] <s_a289>_N <[Text]>_R)
                                   :: (Buffer s_a289 -> STRep s_a289 [Text])
                                      ~R# (Buffer s_a289 -> ST s_a289 [Text]))
                       };
                     1# -> \ (buf_a1WH :: Buffer s_a289) -> x_a1Tc buf_a1WH
                   }))
             `cast` (Sym (N:Builder[0])
                     :: (forall s. (Buffer s -> ST s [Text]) -> Buffer s -> ST s [Text])
                        ~R# Builder) #)
          };
        Null -> case x_s3cv of wild_00 { }
      }

renderNode_s3ce [InlPrag=NOUSERINLINE[2]]
  :: Value -> Builder -> Identity ((), Builder)
[LclId,
 Arity=2,
 Str=<S,U><L,C(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
         Tmpl= \ (w_s3mF [Occ=Once] :: Value)
                 (w_s3mG [Occ=Once] :: Builder) ->
                 case $wrenderNode_s3mK w_s3mF w_s3mG of
                 { (# ww_s3mO [Occ=Once], ww_s3mP [Occ=Once] #) ->
                 (ww_s3mO, ww_s3mP)
                 `cast` (Sym (N:Identity[0] <((), Builder)>_R)
                         :: ((), Builder) ~R# Identity ((), Builder))
                 }}]
renderNode_s3ce
  = \ (w_s3mF :: Value) (w_s3mG :: Builder) ->
      case $wrenderNode_s3mK w_s3mF w_s3mG of { (# ww_s3mO, ww_s3mP #) ->
      (ww_s3mO, ww_s3mP)
      `cast` (Sym (N:Identity[0] <((), Builder)>_R)
              :: ((), Builder) ~R# Identity ((), Builder))
      }

renderNode :: Value -> Render ()
[LclIdX,
 Arity=2,
 Str=<S,1*U><L,C(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
         Tmpl= renderNode_s3ce
               `cast` (<Value>_R
                       ->_R Sym (N:StateT[0] <Builder>_N <Identity>_R <()>_N)
                       :: (Value -> Builder -> Identity ((), Builder))
                          ~R# (Value -> StateT Builder Identity ()))}]
renderNode
  = renderNode_s3ce
    `cast` (<Value>_R
            ->_R Sym (N:StateT[0] <Builder>_N <Identity>_R <()>_N)
            :: (Value -> Builder -> Identity ((), Builder))
               ~R# (Value -> StateT Builder Identity ()))

*** End of Offense ***


<no location info>: error: 
Compilation had errors

This regression was introduced in commit b9b1f999 (Honor INLINE on 0-arity bindings). I have not investigated why this Core Lint error does not occur on HEAD.

Edited Jul 26, 2019 by Ryan Scott
To upload designs, you'll need to enable LFS and have an admin enable hashed storage. More information
Assignee
Assign to
Time tracking