Opened 7 months ago

Last modified 6 months ago

#16183 merge bug

GHC HEAD regression: -ddump-splices incorrectly parenthesizes HsKindSig applications

Reported by: RyanGlScott Owned by:
Priority: normal Milestone: 8.8.1
Component: Template Haskell Version: 8.7
Keywords: Cc:
Operating System: Unknown/Multiple Architecture: Unknown/Multiple
Type of failure: Debugging information is incorrect Test Case: th/T16183
Blocked By: Blocking:
Related Tickets: Differential Rev(s): https://gitlab.haskell.org/ghc/ghc/merge_requests/121
Wiki Page:

Description (last modified by RyanGlScott)

When you compile this file with GHC 8.6.3 and HEAD:

{-# LANGUAGE KindSignatures #-}                                                                    
{-# LANGUAGE TemplateHaskell #-}                                                                   
{-# OPTIONS_GHC -ddump-splices #-}                                                                 
module Bug where                                                                                   
                                                                                                   
import Data.Kind                                                                                   
                                                                                                   
type F = $([t| (Maybe :: Type -> Type) Int |])

You get two different results:

$ /opt/ghc/8.6.3/bin/ghc -fforce-recomp Bug.hs                                                    
[1 of 1] Compiling Bug              ( Bug.hs, Bug.o )                                              
Bug.hs:8:12-45: Splicing type                                                                      
    [t| (Maybe :: Type -> Type) Int |]                                                             
  ======>                                                                                          
    (Maybe :: Type -> Type) Int                                                                    
                                                              
$ ~/Software/ghc4/inplace/bin/ghc-stage2 -fforce-recomp Bug.hs                                     
[1 of 1] Compiling Bug              ( Bug.hs, Bug.o )                                              
Bug.hs:8:12-45: Splicing type
    [t| (Maybe :: Type -> Type) Int |]
  ======>
    Maybe :: Type -> Type Int

Notice how in the GHC HEAD output, GHC forgets to put parentheses around Maybe :: Type -> Type, leading to the utterly nonsensical type Maybe :: Type -> Type Int.

The commit that introduced this regression is bace26aadaafa4064e78f9ed088c1e2217221acc.

Change History (6)

comment:1 Changed 7 months ago by RyanGlScott

Description: modified (diff)

comment:2 Changed 7 months ago by RyanGlScott

Function types are also affected:

{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -ddump-splices #-}
module Bug where

import Data.Kind

type F = $([t| (Int :: Type) -> (Int :: Type) |])
$ ~/Software/ghc4/inplace/bin/ghc-stage2 --interactive Bug.hs
GHCi, version 8.7.20190114: https://www.haskell.org/ghc/  :? for help
Loaded GHCi configuration from /home/rgscott/.ghci
[1 of 1] Compiling Bug              ( Bug.hs, interpreted )
Bug.hs:8:12-48: Splicing type
    [t| (Int :: Type) -> (Int :: Type) |]
  ======>
    Int :: Type -> Int :: Type

comment:3 Changed 7 months ago by RyanGlScott

So are type family equations:

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -ddump-splices #-}
module Bug where

import Data.Kind

$([d| type family F a where
        F (a :: Type) = Int |])
$ ~/Software/ghc4/inplace/bin/ghc-stage2 --interactive Bug.hs
GHCi, version 8.7.20190114: https://www.haskell.org/ghc/  :? for help
Loaded GHCi configuration from /home/rgscott/.ghci
[1 of 1] Compiling Bug              ( Bug.hs, interpreted )
Bug.hs:(8,3)-(9,30): Splicing declarations
    [d| type family F_a1B4 a_a1B5 where
          F_a1B4 (a_a1B6 :: Type) = Int |]
  ======>
    type family F_a4tB a_a4tC where
      F_a4tB a_a4tD :: Type = Int

comment:4 Changed 7 months ago by RyanGlScott

Differential Rev(s): https://gitlab.haskell.org/ghc/ghc/merge_requests/121
Status: newpatch

comment:5 Changed 7 months ago by RyanGlScott

Status: patchmerge
Test Case: th/T16183

comment:6 Changed 6 months ago by Marge Bot <ben+marge-bot@…>

In b1e569a5/ghc:

Use sigPrec in more places in Convert and HsUtils

Trac #16183 was caused by TH conversion (in `Convert`) not properly
inserting parentheses around occurrences of explicit signatures where
appropriate, such as in applications, function types, and type family
equations. Solution: use `parenthesizeHsType sigPrec` in these
places. While I was in town, I also updated `nlHsFunTy` to do the
same thing.
Note: See TracTickets for help on using tickets.