Normal Guards are internally spliced as Pattern Guards causing compiler warnings

Here is an example

Foo.hs

{-# OPTIONS_GHC -XTemplateHaskell -ddump-splices #-}

module Foo where

import Language.Haskell.TH

$(do e <- [d| f a b 
                | a == b = a
                | otherwise = b |]
     runIO (putStrLn $ show e)
     return e) 

The example shows that even if the quasiquotes lift the declarations as normal guards, they are, for some reson, internally spliced as equivalent pattern guards. That shouldn't be a big problem as long as the compiler didn't cause warnings for it.

See the compilation result:

$ ghci Foo.hs 
GHCi, version 6.8.2: http://www.haskell.org/ghc/  :? for help
Loading package base ... linking ... done.
[1 of 1] Compiling Foo              ( Foo.hs, interpreted )
Loading package array-0.1.0.0 ... linking ... done.
Loading package packedstring-0.1.0.0 ... linking ... done.
Loading package pretty-1.0.0.0 ... linking ... done.
Loading package containers-0.1.0.1 ... linking ... done.
Loading package template-haskell ... linking ... done.
[FunD f [Clause [VarP a_1627394778,VarP b_1627394779] (GuardedB [(NormalG (InfixE (Just (VarE a_1627394778)) (VarE GHC.Base.==) (Just (VarE b_1627394779))),VarE a_1627394778),(NormalG (VarE GHC.Base.otherwise),VarE b_1627394779)]) []]]
Foo.hs:1:0:
    Foo.hs:1:0: Splicing declarations
        let
          >>= = (>>=) @ Q $dMonad
          $dMonad = $dMonad
          >> = (>>) @ Q $dMonad
          $dMonad = Language.Haskell.TH.Syntax.$f22
          show = show @ [Dec] $dShow
          $dShow = GHC.Show.$f21 @ Dec $dShow
          $dShow = Language.Haskell.TH.Syntax.$f52
          return = return @ Q $dMonad
          $dMonad = $dMonad
        in
          do e <- [d| :THFake.f a b
                                  | a == b = a
                                  | otherwise = b |]
             runIO @ () (($) @ String @ (IO ()) putStrLn show e)
             return @ [Dec] e
      ======>
        Foo.hs:(7,2)-(11,12)
        f a[a1fQ] b[a1fR]
            | True <- (a[a1fQ] `GHC.Base.==` b[a1fR]) = a[a1fQ]
            | True <- GHC.Base.otherwise = b[a1fR]

Foo.hs:7:2:
    Warning: accepting non-standard pattern guards (use -XPatternGuards to suppress this message)
                 True <- (a[a1fQ] == b[a1fR])

Foo.hs:7:2:
    Warning: accepting non-standard pattern guards (use -XPatternGuards to suppress this message)
                 True <- otherwise
Ok, modules loaded: Foo.
*Foo> 

The logical thing a user would expect is to see the guards spliced as:

   | (a[a1fQ] `GHC.Base.==` b[a1fR]) = a[a1fQ]

and not

   | True <- (a[a1fQ] `GHC.Base.==` b[a1fR]) = a[a1fQ]

As expected and suggested by the compiler the warnings are silenced with the -XPatternGuards.

Trac metadata

Trac field	Value
Version	6.8.2
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Template Haskell
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system	Unknown
Architecture	Unknown