Skip to content

GitLab

GHC
GHC
Closed
Opened by Ryan Scott@RyanGlScottMaintainer
Report abuse New issue

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

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.

Edited by Ryan Scott