Restore a couple ORMOLU_DISABLE

These two are still necessary, but overlooked because CI wasn’t actually
running Ormolu.

Author: sellout

unison-runtime/src/Unison/Runtime/Stack.hs

@@ -285,6 +285,8 @@ unboxedTypeTagFromInt = \case
   3 -> NatTag
   _ -> error "intToUnboxedTypeTag: invalid tag"
 
+{- ORMOLU_DISABLE -}
+{- because ormolu-0.7.2.0 can’t handle CPP used within a declaration. -}
 data GClosure comb
   = GPAp
       !CombIx
@@ -306,6 +308,7 @@ data GClosure comb
   | GUnboxedSentinel
 #endif
   deriving stock (Show, Functor, Foldable, Traversable)
+{- ORMOLU_ENABLE -}
 
 -- Singleton black hole value to avoid allocation.
 blackHole :: Closure
@@ -802,69 +805,72 @@ alloc = do
   pure $ Stack {ap = -1, fp = -1, sp = -1, ustk, bstk}
 {-# INLINE alloc #-}
 
-peek :: DebugCallStack => Stack -> IO Val
+{- ORMOLU_DISABLE -}
+{- because ormolu-0.7.2.0 can’t handle CPP used within declarations. -}
+
+peek :: (DebugCallStack) => Stack -> IO Val
 peek stk@(Stack _ _ sp ustk _) = do
   -- Can't use upeek here because in stack-check mode it will assert that the stack slot is unboxed.
   u <- readByteArray ustk sp
   b <- bpeek stk
   pure (Val u b)
 {-# INLINE peek #-}
 
-peekI :: DebugCallStack => Stack -> IO Int
+peekI :: (DebugCallStack) => Stack -> IO Int
 peekI _stk@(Stack _ _ sp ustk _) = do
 #ifdef STACK_CHECK
   assertUnboxed _stk 0
 #endif
   readByteArray ustk sp
 {-# INLINE peekI #-}
 
-peekOffI :: DebugCallStack => Stack -> Off -> IO Int
+peekOffI :: (DebugCallStack) => Stack -> Off -> IO Int
 peekOffI _stk@(Stack _ _ sp ustk _) i = do
 #ifdef STACK_CHECK
   assertUnboxed _stk i
 #endif
   readByteArray ustk (sp - i)
 {-# INLINE peekOffI #-}
 
-bpeek :: DebugCallStack => Stack -> IO BVal
+bpeek :: (DebugCallStack) => Stack -> IO BVal
 bpeek (Stack _ _ sp _ bstk) = readArray bstk sp
 {-# INLINE bpeek #-}
 
-upeek :: DebugCallStack => Stack -> IO UVal
+upeek :: (DebugCallStack) => Stack -> IO UVal
 upeek _stk@(Stack _ _ sp ustk _) = do
 #ifdef STACK_CHECK
   assertUnboxed _stk 0
 #endif
   readByteArray ustk sp
 {-# INLINE upeek #-}
 
-peekOff :: DebugCallStack => Stack -> Off -> IO Val
+peekOff :: (DebugCallStack) => Stack -> Off -> IO Val
 peekOff stk@(Stack _ _ sp ustk _) i = do
   -- Can't use upeekOff here because in stack-check mode it will assert that the stack slot is unboxed.
   u <- readByteArray ustk (sp - i)
   b <- bpeekOff stk i
   pure $ Val u b
 {-# INLINE peekOff #-}
 
-bpeekOff :: DebugCallStack => Stack -> Off -> IO BVal
+bpeekOff :: (DebugCallStack) => Stack -> Off -> IO BVal
 bpeekOff (Stack _ _ sp _ bstk) i = readArray bstk (sp - i)
 {-# INLINE bpeekOff #-}
 
-upeekOff :: DebugCallStack => Stack -> Off -> IO UVal
+upeekOff :: (DebugCallStack) => Stack -> Off -> IO UVal
 upeekOff _stk@(Stack _ _ sp ustk _) i = do
 #ifdef STACK_CHECK
   assertUnboxed _stk i
 #endif
   readByteArray ustk (sp - i)
 {-# INLINE upeekOff #-}
 
-upokeT :: DebugCallStack => Stack -> UVal -> BVal -> IO ()
+upokeT :: (DebugCallStack) => Stack -> UVal -> BVal -> IO ()
 upokeT !stk@(Stack _ _ sp ustk _) !u !t = do
   bpoke stk t
   writeByteArray ustk sp u
 {-# INLINE upokeT #-}
 
-poke :: DebugCallStack => Stack -> Val -> IO ()
+poke :: (DebugCallStack) => Stack -> Val -> IO ()
 poke _stk@(Stack _ _ sp ustk bstk) (Val u b) = do
 #ifdef STACK_CHECK
   assertBumped _stk 0
@@ -876,57 +882,57 @@ poke _stk@(Stack _ _ sp ustk bstk) (Val u b) = do
 -- | Sometimes we get back an int from a foreign call which we want to use as a Nat.
 -- If we know it's positive and smaller than 2^63 then we can safely store the Int directly as a Nat without
 -- checks.
-unsafePokeIasN :: DebugCallStack => Stack -> Int -> IO ()
+unsafePokeIasN :: (DebugCallStack) => Stack -> Int -> IO ()
 unsafePokeIasN stk n = do
   upokeT stk n natTypeTag
 {-# INLINE unsafePokeIasN #-}
 
 -- | Store an unboxed tag to later match on.
 -- Often used to indicate the constructor of a data type that's been unpacked onto the stack,
 -- or some tag we're about to branch on.
-pokeTag :: DebugCallStack => Stack -> Int -> IO ()
+pokeTag :: (DebugCallStack) => Stack -> Int -> IO ()
 pokeTag =
   -- For now we just use ints, but maybe should have a separate type for tags so we can detect if we're leaking them.
   pokeI
 {-# INLINE pokeTag #-}
 
-peekTag :: DebugCallStack => Stack -> IO Int
+peekTag :: (DebugCallStack) => Stack -> IO Int
 peekTag = peekI
 {-# INLINE peekTag #-}
 
-peekTagOff :: DebugCallStack => Stack -> Off -> IO Int
+peekTagOff :: (DebugCallStack) => Stack -> Off -> IO Int
 peekTagOff = peekOffI
 {-# INLINE peekTagOff #-}
 
-pokeBool :: DebugCallStack => Stack -> Bool -> IO ()
+pokeBool :: (DebugCallStack) => Stack -> Bool -> IO ()
 pokeBool stk b =
   poke stk $ if b then trueVal else falseVal
 {-# INLINE pokeBool #-}
 
 -- | Store a boxed value.
 -- We don't bother nulling out the unboxed stack,
 -- it's extra work and there's nothing to garbage collect.
-bpoke :: DebugCallStack => Stack -> BVal -> IO ()
+bpoke :: (DebugCallStack) => Stack -> BVal -> IO ()
 bpoke _stk@(Stack _ _ sp _ bstk) b = do
 #ifdef STACK_CHECK
   assertBumped _stk 0
 #endif
   writeArray bstk sp b
 {-# INLINE bpoke #-}
 
-pokeOff :: DebugCallStack => Stack -> Off -> Val -> IO ()
+pokeOff :: (DebugCallStack) => Stack -> Off -> Val -> IO ()
 pokeOff stk i (Val u t) = do
   bpokeOff stk i t
   writeByteArray (ustk stk) (sp stk - i) u
 {-# INLINE pokeOff #-}
 
-upokeOffT :: DebugCallStack => Stack -> Off -> UVal -> BVal -> IO ()
+upokeOffT :: (DebugCallStack) => Stack -> Off -> UVal -> BVal -> IO ()
 upokeOffT stk i u t = do
   bpokeOff stk i t
   writeByteArray (ustk stk) (sp stk - i) u
 {-# INLINE upokeOffT #-}
 
-bpokeOff :: DebugCallStack => Stack -> Off -> BVal -> IO ()
+bpokeOff :: (DebugCallStack) => Stack -> Off -> BVal -> IO ()
 bpokeOff _stk@(Stack _ _ sp _ bstk) i b = do
 #ifdef STACK_CHECK
   assertBumped _stk i
@@ -1171,6 +1177,8 @@ peekOffC _stk@(Stack _ _ sp ustk _) i = do
   Char.chr <$> readByteArray ustk (sp - i)
 {-# INLINE peekOffC #-}
 
+{- ORMOLU_ENABLE -}
+
 pokeN :: Stack -> Word64 -> IO ()
 pokeN stk@(Stack _ _ sp ustk _) n = do
   bpoke stk natTypeTag