March 2019 - ghc-tickets

[GHC] #15863: Splcing a type class method selects the wrong instance
by GHC 04 Mar '19

04 Mar '19

#15863: Splcing a type class method selects the wrong instance -------------------------------------+------------------------------------- Reporter: mpickering | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Consider these 4 modules as concocted by Csongor. The wrong instance is selected when you splice in `B.me` into `D`. https://gist.github.com/mpickering/959a95525647802414ab50e8e6ed490c {{{ module A where class C a where foo :: a -> String instance C Int where foo _ = "int" }}} {{{ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE NoMonomorphismRestriction #-} module B where import A import Language.Haskell.TH instance C a => C [a] where foo _ = "list" me :: Q (TExp ([Int] -> String)) me = [|| foo ||] }}} {{{ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE NoMonomorphismRestriction #-} module C where import A import Language.Haskell.TH instance {-# OVERLAPPING #-} C [Int] where foo _ = "list2" }}} {{{ {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE NoMonomorphismRestriction #-} module D where import A import B import C main2 = $$(me) [1 :: Int] }}} {{{ >>> main2 "list2" }}} In `B`, `B.me` is created by quoting `foo`. `B.me :: Q (TExp ([Int] -> String))` so in order to type check this quote we need to solve the instance `C [Int]` which we should do by using the instance defined in `B` (and `A`). In module `C` we define a different overlapping instance (note that this could be in a completely different library not under our control). When we then splice `B.me` into `D`, the instance from `C` is used and can be witnessed by printing `main2` which shows `"list2"` rather than `"list"` as expected. This is a symptom of the fact that the renamed rather than the typechecked AST is serialised I think. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15863> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #16293: Inconsistencies and oddities of Proxy#
by GHC 04 Mar '19

04 Mar '19

#16293: Inconsistencies and oddities of Proxy# -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The `Proxy#` type has some downright strange properties that border on being bugs. Here are some of examples that I've discovered: 1. `Proxy#`, when reified with TH, gives a different arity that most other primitive type constructors: {{{ λ> putStrLn $(reify ''Proxy# >>= stringE . show) PrimTyConI GHC.Prim.Proxy# 2 True }}} If this is to be believed, `Proxy#` has 2 arguments. But shouldn't that be 1? Compare this to the results of reifying `(->)`: {{{ λ> putStrLn $(reify ''(->) >>= stringE . show) PrimTyConI GHC.Prim.-> 2 False }}} This correctly claims that it has 2 arguments. Moreover, since `(->)` actually has two invisible `RuntimeRep` arguments, this shows that `(->)` is deliberately not counting them as arguments for `PrimTyConI`'s purposes. It's just `Proxy#` that seems to count its kind argument towards its total. 2. `Proxy#` is nominally roled in its argument! That is to say, the following program typechecks: {{{#!hs {-# LANGUAGE GeneralizedNewtypeDeriving #-} import Data.Proxy class C a where metaData :: Proxy a -> Int instance C Int where metaData _ = 432432 newtype Age = MkAge Int deriving C }}} But the this one does not! {{{#!hs {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE MagicHash #-} import GHC.Exts class C a where metaData :: Proxy# a -> Int instance C Int where metaData _ = 432432 newtype Age = MkAge Int deriving C }}} {{{ $ /opt/ghc/8.6.3/bin/ghc Bug.hs [1 of 1] Compiling Main ( Bug.hs, Bug.o ) Bug.hs:10:34: error: • Couldn't match type ‘Int’ with ‘Age’ arising from the coercion of the method ‘metaData’ from type ‘Proxy# Int -> Int’ to type ‘Proxy# Age -> Int’ • When deriving the instance for (C Age) | 10 | newtype Age = MkAge Int deriving C | ^ }}} If `Proxy` is phantom-roled in its argument, then it feels like `Proxy#` out to be as well. 3. The types of `proxy#` and `Proxy` (the constructor) are subtly different. Compare: {{{ λ> :type +v proxy# proxy# :: forall k0 (a :: k0). Proxy# a λ> :type +v Proxy Proxy :: forall {k} (t :: k). Proxy t }}} Notice that `proxy#` accepts //two// visible type arguments, whereas `Proxy` only accepts one! This means that you'd have to write `proxy# @_ @Int`, as opposed to the shorter `Proxy @Int`. I feel like `proxy#` and `Proxy`'s types ought to mirror each other in this respect. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16293> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #16204: GHC HEAD-only Core Lint error (Argument value doesn't match argument type)
by GHC 04 Mar '19

04 Mar '19

#16204: GHC HEAD-only Core Lint error (Argument value doesn't match argument type) -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: highest | Milestone: 8.8.1 Component: Compiler | Version: 8.7 (Type checker) | Keywords: TypeInType | Operating System: Unknown/Multiple Architecture: | Type of failure: Compile-time Unknown/Multiple | crash or panic Test Case: | Blocked By: Blocking: | Related Tickets: #16188 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The following program passes Core Lint on GHC 8.6.3: {{{#!hs {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} module Bug where import Data.Kind ----- -- singletons machinery ----- data family Sing :: forall k. k -> Type data SomeSing :: Type -> Type where SomeSing :: Sing (a :: k) -> SomeSing k ----- -- (Simplified) GHC.Generics ----- class Generic (a :: Type) where type Rep a :: Type from :: a -> Rep a to :: Rep a -> a class PGeneric (a :: Type) where -- type PFrom ... type PTo (x :: Rep a) :: a class SGeneric k where -- sFrom :: ... sTo :: forall (a :: Rep k). Sing a -> Sing (PTo a :: k) ----- class SingKind k where type Demote k :: Type -- fromSing :: ... toSing :: Demote k -> SomeSing k genericToSing :: forall k. ( SingKind k, SGeneric k, SingKind (Rep k) , Generic (Demote k), Rep (Demote k) ~ Demote (Rep k) ) => Demote k -> SomeSing k genericToSing d = withSomeSing @(Rep k) (from d) $ SomeSing . sTo withSomeSing :: forall k r . SingKind k => Demote k -> (forall (a :: k). Sing a -> r) -> r withSomeSing x f = case toSing x of SomeSing x' -> f x' }}} But not on GHC HEAD: {{{ $ ~/Software/ghc4/inplace/bin/ghc-stage2 Bug.hs -dcore-lint [1 of 1] Compiling Bug ( Bug.hs, Bug.o ) *** Core Lint errors : in result of Desugar (before optimization) *** <no location info>: warning: In the expression: $ @ 'LiftedRep @ (forall (a :: Rep k_a1cV). Sing a -> SomeSing k_a1cV) @ (SomeSing k_a1cV) (withSomeSing @ (Rep k_a1cV) @ (SomeSing k_a1cV) $dSingKind_a1d5 ((from @ (Demote k_a1cV) $dGeneric_a1d7 (d_aX7 `cast` (Sub co_a1dK :: Demote k_a1cV[sk:1] ~R# Demote k_a1cV[sk:1]))) `cast` (Sub (Sym (Sym co_a1dR ; Sym co_a1dM) ; (Sym co_a1dQ ; (Demote (Sym co_a1dO))_N)) :: Rep (Demote k_a1cV[sk:1]) ~R# Demote (Rep k_a1cV[sk:1])))) (\ (@ (a_a1dc :: Rep k_a1cV)) -> let { $dSGeneric_a1dm :: SGeneric k_a1cV [LclId] $dSGeneric_a1dm = $dSGeneric_a1cY } in . @ (Sing (PTo Any)) @ (SomeSing k_a1cV) @ (Sing Any) (SomeSing @ k_a1cV @ (PTo Any)) ((sTo @ k_a1cV $dSGeneric_a1dm @ Any) `cast` (Sym (Sing (Sym co_a1dO) (Sym (GRefl nominal Any co_a1dO)))_R ->_R <Sing (PTo Any)>_R :: (Sing Any -> Sing (PTo Any)) ~R# (Sing Any -> Sing (PTo Any))))) Argument value doesn't match argument type: Fun type: (forall (a :: Rep k_a1cV). Sing a -> SomeSing k_a1cV) -> SomeSing k_a1cV Arg type: forall (a :: Rep k_a1cV). Sing Any -> SomeSing k_a1cV Arg: \ (@ (a_a1dc :: Rep k_a1cV)) -> let { $dSGeneric_a1dm :: SGeneric k_a1cV [LclId] $dSGeneric_a1dm = $dSGeneric_a1cY } in . @ (Sing (PTo Any)) @ (SomeSing k_a1cV) @ (Sing Any) (SomeSing @ k_a1cV @ (PTo Any)) ((sTo @ k_a1cV $dSGeneric_a1dm @ Any) `cast` (Sym (Sing (Sym co_a1dO) (Sym (GRefl nominal Any co_a1dO)))_R ->_R <Sing (PTo Any)>_R :: (Sing Any -> Sing (PTo Any)) ~R# (Sing Any -> Sing (PTo Any)))) *** Offending Program *** <elided> genericToSing :: forall k. (SingKind k, SGeneric k, SingKind (Rep k), Generic (Demote k), Rep (Demote k) ~ Demote (Rep k)) => Demote k -> SomeSing k [LclIdX] genericToSing = \ (@ k_a1cV) ($dSingKind_a1cX :: SingKind k_a1cV) ($dSGeneric_a1cY :: SGeneric k_a1cV) ($dSingKind_a1cZ :: SingKind (Rep k_a1cV)) ($dGeneric_a1d0 :: Generic (Demote k_a1cV)) ($d~_a1d1 :: Rep (Demote k_a1cV) ~ Demote (Rep k_a1cV)) -> let { co_a1dQ :: Demote (Rep k_a1cV) ~# Demote (Rep k_a1cV) [LclId[CoVarId]] co_a1dQ = CO: <Demote (Rep k_a1cV)>_N } in let { co_a1dO :: Rep k_a1cV ~# Rep k_a1cV [LclId[CoVarId]] co_a1dO = CO: <Rep k_a1cV>_N } in let { $dSingKind_a1dT :: SingKind (Rep k_a1cV) [LclId] $dSingKind_a1dT = $dSingKind_a1cZ `cast` (Sub (Sym (SingKind (Sym co_a1dO))_N) :: SingKind (Rep k_a1cV[sk:1]) ~R# SingKind (Rep k_a1cV[sk:1])) } in let { $dSingKind_a1d5 :: SingKind (Rep k_a1cV) [LclId] $dSingKind_a1d5 = $dSingKind_a1dT `cast` ((SingKind (Sym co_a1dO))_R :: SingKind (Rep k_a1cV[sk:1]) ~R# SingKind (Rep k_a1cV[sk:1])) } in let { co_a1dM :: Rep (Demote k_a1cV) ~# Rep (Demote k_a1cV) [LclId[CoVarId]] co_a1dM = CO: <Rep (Demote k_a1cV)>_N } in let { co_a1dK :: Demote k_a1cV ~# Demote k_a1cV [LclId[CoVarId]] co_a1dK = CO: <Demote k_a1cV>_N } in let { $dGeneric_a1dU :: Generic (Demote k_a1cV) [LclId] $dGeneric_a1dU = $dGeneric_a1d0 `cast` (Sub (Sym (Generic (Sym co_a1dK))_N) :: Generic (Demote k_a1cV[sk:1]) ~R# Generic (Demote k_a1cV[sk:1])) } in let { $dGeneric_a1d7 :: Generic (Demote k_a1cV) [LclId] $dGeneric_a1d7 = $dGeneric_a1dU } in case eq_sel @ * @ (Rep (Demote k_a1cV)) @ (Demote (Rep k_a1cV)) $d~_a1d1 of co_a1dI { __DEFAULT -> let { co_a1dR :: Rep (Demote k_a1cV) ~# Demote (Rep k_a1cV) [LclId[CoVarId]] co_a1dR = CO: ((Sym co_a1dM ; (Rep (Sym co_a1dK))_N) ; co_a1dI) ; Sym (Sym co_a1dQ ; (Demote (Sym co_a1dO))_N) } in \ (d_aX7 :: Demote k_a1cV) -> $ @ 'LiftedRep @ (forall (a :: Rep k_a1cV). Sing a -> SomeSing k_a1cV) @ (SomeSing k_a1cV) (withSomeSing @ (Rep k_a1cV) @ (SomeSing k_a1cV) $dSingKind_a1d5 ((from @ (Demote k_a1cV) $dGeneric_a1d7 (d_aX7 `cast` (Sub co_a1dK :: Demote k_a1cV[sk:1] ~R# Demote k_a1cV[sk:1]))) `cast` (Sub (Sym (Sym co_a1dR ; Sym co_a1dM) ; (Sym co_a1dQ ; (Demote (Sym co_a1dO))_N)) :: Rep (Demote k_a1cV[sk:1]) ~R# Demote (Rep k_a1cV[sk:1])))) (\ (@ (a_a1dc :: Rep k_a1cV)) -> let { $dSGeneric_a1dm :: SGeneric k_a1cV [LclId] $dSGeneric_a1dm = $dSGeneric_a1cY } in . @ (Sing (PTo Any)) @ (SomeSing k_a1cV) @ (Sing Any) (SomeSing @ k_a1cV @ (PTo Any)) ((sTo @ k_a1cV $dSGeneric_a1dm @ Any) `cast` (Sym (Sing (Sym co_a1dO) (Sym (GRefl nominal Any co_a1dO)))_R ->_R <Sing (PTo Any)>_R :: (Sing Any -> Sing (PTo Any)) ~R# (Sing Any -> Sing (PTo Any))))) } }}} I'm not sure if this is related to #16188 (see https://ghc.haskell.org/trac/ghc/ticket/16188#comment:1) but this Core Lint error is technically different from the one in that ticket, so I decided to open a new issue for this. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16204> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #16188: GHC HEAD-only panic (buildKindCoercion)
by GHC 04 Mar '19

04 Mar '19

#16188: GHC HEAD-only panic (buildKindCoercion) -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: highest | Milestone: 8.8.1 Component: Compiler | Version: 8.7 (Type checker) | Keywords: TypeInType | Operating System: Unknown/Multiple Architecture: | Type of failure: Compile-time Unknown/Multiple | crash or panic Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The following program compiles without issue on GHC 8.6.3: {{{#!hs {-# LANGUAGE DataKinds #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} module Bug where import Data.Kind (Type) import Data.Type.Bool (type (&&)) data TyFun :: Type -> Type -> Type type a ~> b = TyFun a b -> Type infixr 0 ~> type family Apply (f :: a ~> b) (x :: a) :: b data family Sing :: forall k. k -> Type data instance Sing :: Bool -> Type where SFalse :: Sing False STrue :: Sing True (%&&) :: forall (x :: Bool) (y :: Bool). Sing x -> Sing y -> Sing (x && y) SFalse %&& _ = SFalse STrue %&& a = a data RegExp :: Type -> Type where App :: RegExp t -> RegExp t -> RegExp t data instance Sing :: forall t. RegExp t -> Type where SApp :: Sing re1 -> Sing re2 -> Sing (App re1 re2) data ReNotEmptySym0 :: forall t. RegExp t ~> Bool type instance Apply ReNotEmptySym0 r = ReNotEmpty r type family ReNotEmpty (r :: RegExp t) :: Bool where ReNotEmpty (App re1 re2) = ReNotEmpty re1 && ReNotEmpty re2 sReNotEmpty :: forall t (r :: RegExp t). Sing r -> Sing (Apply ReNotEmptySym0 r :: Bool) sReNotEmpty (SApp sre1 sre2) = sReNotEmpty sre1 %&& sReNotEmpty sre2 blah :: forall (t :: Type) (re :: RegExp t). Sing re -> () blah (SApp sre1 sre2) = case (sReNotEmpty sre1, sReNotEmpty sre2) of (STrue, STrue) -> () }}} However, it panics on GHC HEAD: {{{ $ ~/Software/ghc4/inplace/bin/ghc-stage2 Bug.hs [1 of 1] Compiling Bug ( Bug.hs, Bug.o ) ghc-stage2: panic! (the 'impossible' happened) (GHC version 8.7.20190114 for x86_64-unknown-linux): buildKindCoercion Any ReNotEmpty re2_a1hm Bool t_a1hg Call stack: CallStack (from HasCallStack): callStackDoc, called at compiler/utils/Outputable.hs:1159:37 in ghc:Outputable pprPanic, called at compiler/types/Coercion.hs:2427:9 in ghc:Coercion }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16188> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #16225: GHC HEAD-only Core Lint error (Trans coercion mis-match)
by GHC 04 Mar '19

04 Mar '19

#16225: GHC HEAD-only Core Lint error (Trans coercion mis-match) -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: highest | Milestone: 8.8.1 Component: Compiler | Version: 8.7 (Type checker) | Keywords: TypeInType | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: #16188, #16204 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The following code compiles on GHC 8.0.2 through GHC 8.6.3 with `-dcore- lint`: {{{#!hs {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeInType #-} {-# LANGUAGE TypeOperators #-} module Bug where import Data.Kind data family Sing :: k -> Type data TyFun :: Type -> Type -> Type type a ~> b = TyFun a b -> Type infixr 0 ~> type family Apply (f :: a ~> b) (x :: a) :: b data TyCon1 :: (k1 -> k2) -> (k1 ~> k2) type instance Apply (TyCon1 f) x = f x data SomeApply :: (k ~> Type) -> Type where SomeApply :: Apply f a -> SomeApply f f :: SomeApply (TyCon1 Sing :: k ~> Type) -> SomeApply (TyCon1 Sing :: k ~> Type) f (SomeApply s) = SomeApply s }}} However, it chokes on GHC HEAD: {{{ $ ~/Software/ghc4/inplace/bin/ghc-stage2 --interactive Bug.hs -dcore-lint GHCi, version 8.7.20190120: https://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Bug ( Bug.hs, interpreted ) *** Core Lint errors : in result of Desugar (before optimization) *** <no location info>: warning: In the expression: SomeApply @ k_a1Dz @ (TyCon1 Sing) @ Any (s_a1Bq `cast` (Sub (D:R:ApplyabTyCon1x[0] <k_a1Dz>_N <*>_N <Sing>_N <a_a1DB>_N ; Sym (D:R:ApplyabTyCon1x[0] <k_a1Dz>_N <*>_N <Sing>_N <Any>_N)) :: Apply (TyCon1 Sing) a_a1DB ~R# Apply (TyCon1 Sing) Any)) Trans coercion mis-match: D:R:ApplyabTyCon1x[0] <k_a1Dz>_N <*>_N <Sing>_N <a_a1DB>_N ; Sym (D:R:ApplyabTyCon1x[0] <k_a1Dz>_N <*>_N <Sing>_N <Any>_N) Apply (TyCon1 Sing) a_a1DB Sing a_a1DB Sing Any Apply (TyCon1 Sing) Any *** Offending Program *** <elided> f :: forall k. SomeApply (TyCon1 Sing) -> SomeApply (TyCon1 Sing) [LclIdX] f = \ (@ k_a1Dz) (ds_d1EV :: SomeApply (TyCon1 Sing)) -> case ds_d1EV of wild_00 { SomeApply @ a_a1DB s_a1Bq -> break<0>(s_a1Bq) SomeApply @ k_a1Dz @ (TyCon1 Sing) @ Any (s_a1Bq `cast` (Sub (D:R:ApplyabTyCon1x[0] <k_a1Dz>_N <*>_N <Sing>_N <a_a1DB>_N ; Sym (D:R:ApplyabTyCon1x[0] <k_a1Dz>_N <*>_N <Sing>_N <Any>_N)) :: Apply (TyCon1 Sing) a_a1DB ~R# Apply (TyCon1 Sing) Any)) } }}} Note that if I change the definition of `Sing` to this: {{{#!hs data family Sing (a :: k) }}} Then the error goes away. Also, if I extend `SomeProxy` with an additional `proxy` field: {{{#!hs data SomeApply :: (k ~> Type) -> Type where SomeApply :: proxy a -> Apply f a -> SomeApply f f :: SomeApply (TyCon1 Sing :: k ~> Type) -> SomeApply (TyCon1 Sing :: k ~> Type) f (SomeApply p s) = SomeApply p s }}} Then the error also goes away. Perhaps `a` being ambiguous plays an important role here? Possibly related to #16188 or #16204. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16225> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #15849: Error message: "Perhaps you need a let in a do block", when there is no do block.
by GHC 04 Mar '19

04 Mar '19

#15849: Error message: "Perhaps you need a let in a do block", when there is no do block. -------------------------------------+------------------------------------- Reporter: cdsmith | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.4.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- This code: {{{#!haskell main = return () foo = return () }}} Gives the error message: {{{ parse error on input ‘=’ Perhaps you need a 'let' in a 'do' block? e.g. 'let x = 5' instead of 'x = 5' }}} But this isn't in a do block. It would be awesome if GHC checked whether there's a do block before giving a suggestion that depends on there being a do block. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15849> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #16299: :info pretty-prints data types with non-Type return kinds oddly
by GHC 04 Mar '19

04 Mar '19

#16299: :info pretty-prints data types with non-Type return kinds oddly -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Consider this GHCi session: {{{ $ ghci -XUnboxedTuples GHCi, version 8.6.3: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/ryanglscott/.ghci λ> :i (##) data (##) :: TYPE ('GHC.Types.TupleRep '[]) = (##) -- Defined in ‘GHC.Prim’ }}} Notice that we're printing `data (##) :: TYPE ('GHC.Types.TupleRep '[]) = (##)`. Yuck! Granted, you can't define an unboxed tuple like this anyway, but the presence of that kind signature (which definitely doesn't belong in a Haskell98-style data declaration) makes things worse. In case if you're wondering if this is an unboxed tuple–specific problem, it's not. This issue also creeps up in the [https://phabricator.haskell.org/D4777 WIP implementation] of unlifted newtypes: {{{ λ> newtype T = MkT Int# λ> :i T newtype T :: TYPE 'IntRep = MkT Int# -- Defined at <interactive>:5:1 }}} However, as this ticket demonstrates, this problem has existed well before the unlifted newtypes patch, and more importantly, this can be fixed independently of that patch. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16299> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #15467: unregisterised validation failures
by GHC 04 Mar '19

04 Mar '19

#15467: unregisterised validation failures --------------------------------------+--------------------------------- Reporter: alpmestan | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.5 Keywords: | Operating System: Linux Architecture: x86_64 (amd64) | Type of failure: None/Unknown Test Case: T7040_ghci | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: --------------------------------------+--------------------------------- The most recent completed run of `validate-x86_64-linux-unreg` on Circle CI (https://circleci.com/gh/ghc/ghc/7733) shows 13 unexpected failures and 1 unexpected pass. **Summary** {{{ Unexpected passes: concurrent/T13615/T13615.run T13615 [unexpected] (ghci) Unexpected failures: codeGen/should_compile/T9329.run T9329 [exit code non-0] (normal) codeGen/should_run/cgrun018.run cgrun018 [exit code non-0] (normal) codeGen/should_run/cgrun018.run cgrun018 [exit code non-0] (g1) codeGen/should_run/cgrun069.run cgrun069 [exit code non-0] (normal) codeGen/should_run/cgrun069.run cgrun069 [exit code non-0] (g1) codeGen/should_run/T9577.run T9577 [bad stdout] (normal) concurrent/should_run/T3429.run T3429 [bad exit code] (debug_numa) driver/T14075/T14075.run T14075 [bad stderr] (normal) rts/T7040_ghci.run T7040_ghci [bad stderr] (ghci) rts/T14702.run T14702 [bad exit code] (threaded1) rts/nursery-chunks1.run nursery-chunks1 [bad stderr] (threaded1) rts/numa001.run numa001 [bad exit code] (debug_numa) ../../libraries/base/tests/T11760.run T11760 [bad exit code] (normal) }}} All failures but `T7040_ghci` happen in the debug validation job too (see #15466). `recomp007` doesn't fail here and `T7040_ghci` "replaces" it. I'm therefore only including the details for `T7040_ghci` here, as you can find out everything about the other faiilures in #15466. --- **T7040_ghci** {{{ Actual stderr output differs from expected: --- /dev/null 2018-08-01 14:20:42.758797000 +0000 +++ ./rts/T7040_ghci.run/T7040_ghci.run.stderr.normalised 2018-08-02 04:15:35.594990695 +0000 @@ -0,0 +1,4 @@ + +T7040_ghci:6:30: + Not in scope: ‘Main.main’ + No module named ‘Main’ is imported. *** unexpected failure for T7040_ghci(ghci) }}} I suspect this is one of those cases where ghci can't load the module because of unboxed sums and what not, I havent' checked yet, but we were seeing that type of error. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15467> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #11982: Typechecking fails for parallel monad comprehensions with polymorphic let
by GHC 04 Mar '19

04 Mar '19

#11982: Typechecking fails for parallel monad comprehensions with polymorphic let -------------------------------------+------------------------------------- Reporter: simonpj | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- {{{ {-# LANGUAGE MonadComprehensions, ParallelListComp #-} module Foo where foo xs ys = [ (f y True, f x 'c') | let f _ z = z, x <- xs | y <- ys ] }}} This fails with {{{ Foo.hs:5:52: error: * Cannot instantiate unification variable `t0' with a type involving foralls: forall t2 t3. t3 -> t2 -> t2 GHC doesn't yet support impredicative polymorphism * In a stmt of a monad comprehension: let f _ z = z, x <- xs | y <- ys In the expression: [(f y True, f x 'c') | let f _ z = z, x <- xs | y <- ys] In an equation for `foo': foo xs ys = [(f y True, f x 'c') | let f _ z = z, x <- xs | y <- ys] }}} NB: `ApplicativeDo` has a related problem: the implementation is quite different and has the effect of monomorphising the let-bound variable. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11982> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 21

[GHC] #14579: GeneralizedNewtypeDeriving produces ambiguously-kinded code
by GHC 04 Mar '19

04 Mar '19

#14579: GeneralizedNewtypeDeriving produces ambiguously-kinded code -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.2 (Type checker) | Keywords: deriving | Operating System: Unknown/Multiple Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- This program //should// compile: {{{#!hs {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE TypeInType #-} module Bug where import Data.Kind import Data.Proxy newtype Wat (x :: Proxy (a :: Type)) = MkWat (Maybe a) deriving Eq newtype Glurp a = MkGlurp (Wat ('Proxy :: Proxy a)) deriving Eq }}} After all, it //should// produce this `Eq (Glurp a)` instance, which compiles without issue: {{{#!hs instance Eq a => Eq (Glurp a) where (==) = coerce @(Wat ('Proxy :: Proxy a) -> Wat ('Proxy :: Proxy a) -> Bool) @(Glurp a -> Glurp a -> Bool) (==) }}} But despite my wishful thinking, GHC does not actually do this. In fact, the code that GHC tries to generate for an `Eq (Glurp a)` instance is completely wrong: {{{ $ /opt/ghc/8.2.2/bin/ghci -ddump-deriv Bug.hs GHCi, version 8.2.2: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Bug ( Bug.hs, interpreted ) ==================== Derived instances ==================== Derived class instances: instance forall a (x :: Data.Proxy.Proxy a). GHC.Classes.Eq a => GHC.Classes.Eq (Bug.Wat x) where (GHC.Classes.==) = GHC.Prim.coerce @(GHC.Base.Maybe a_a2wE -> GHC.Base.Maybe a_a2wE -> GHC.Types.Bool) @(Bug.Wat x_a2wF -> Bug.Wat x_a2wF -> GHC.Types.Bool) (GHC.Classes.==) (GHC.Classes./=) = GHC.Prim.coerce @(GHC.Base.Maybe a_a2wE -> GHC.Base.Maybe a_a2wE -> GHC.Types.Bool) @(Bug.Wat x_a2wF -> Bug.Wat x_a2wF -> GHC.Types.Bool) (GHC.Classes./=) instance GHC.Classes.Eq a => GHC.Classes.Eq (Bug.Glurp a) where (GHC.Classes.==) = GHC.Prim.coerce @(Bug.Wat Data.Proxy.Proxy -> Bug.Wat Data.Proxy.Proxy -> GHC.Types.Bool) @(Bug.Glurp a_a1vT -> Bug.Glurp a_a1vT -> GHC.Types.Bool) (GHC.Classes.==) (GHC.Classes./=) = GHC.Prim.coerce @(Bug.Wat Data.Proxy.Proxy -> Bug.Wat Data.Proxy.Proxy -> GHC.Types.Bool) @(Bug.Glurp a_a1vT -> Bug.Glurp a_a1vT -> GHC.Types.Bool) (GHC.Classes./=) Derived type family instances: Bug.hs:12:12: error: • Couldn't match representation of type ‘a0’ with that of ‘a’ arising from a use of ‘GHC.Prim.coerce’ ‘a’ is a rigid type variable bound by the instance declaration at Bug.hs:12:12-13 • In the expression: GHC.Prim.coerce @(Wat Proxy -> Wat Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (==) In an equation for ‘==’: (==) = GHC.Prim.coerce @(Wat Proxy -> Wat Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (==) When typechecking the code for ‘==’ in a derived instance for ‘Eq (Glurp a)’: To see the code I am typechecking, use -ddump-deriv In the instance declaration for ‘Eq (Glurp a)’ • Relevant bindings include (==) :: Glurp a -> Glurp a -> Bool (bound at Bug.hs:12:12) | 12 | deriving Eq | ^^ Bug.hs:12:12: error: • Could not deduce (Eq a0) arising from a use of ‘==’ from the context: Eq a bound by the instance declaration at Bug.hs:12:12-13 The type variable ‘a0’ is ambiguous These potential instances exist: instance forall k (s :: k). Eq (Proxy s) -- Defined in ‘Data.Proxy’ instance Eq Ordering -- Defined in ‘GHC.Classes’ instance Eq Integer -- Defined in ‘integer-gmp-1.0.1.0:GHC.Integer.Type’ ...plus 25 others ...plus 9 instances involving out-of-scope types (use -fprint-potential-instances to see them all) • In the third argument of ‘GHC.Prim.coerce’, namely ‘(==)’ In the expression: GHC.Prim.coerce @(Wat Proxy -> Wat Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (==) In an equation for ‘==’: (==) = GHC.Prim.coerce @(Wat Proxy -> Wat Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (==) When typechecking the code for ‘==’ in a derived instance for ‘Eq (Glurp a)’: To see the code I am typechecking, use -ddump-deriv | 12 | deriving Eq | ^^ Bug.hs:12:12: error: • Couldn't match representation of type ‘a1’ with that of ‘a’ arising from a use of ‘GHC.Prim.coerce’ ‘a’ is a rigid type variable bound by the instance declaration at Bug.hs:12:12-13 • In the expression: GHC.Prim.coerce @(Wat Proxy -> Wat Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (/=) In an equation for ‘/=’: (/=) = GHC.Prim.coerce @(Wat Proxy -> Wat Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (/=) When typechecking the code for ‘/=’ in a derived instance for ‘Eq (Glurp a)’: To see the code I am typechecking, use -ddump-deriv In the instance declaration for ‘Eq (Glurp a)’ • Relevant bindings include (/=) :: Glurp a -> Glurp a -> Bool (bound at Bug.hs:12:12) | 12 | deriving Eq | ^^ Bug.hs:12:12: error: • Could not deduce (Eq a1) arising from a use of ‘/=’ from the context: Eq a bound by the instance declaration at Bug.hs:12:12-13 The type variable ‘a1’ is ambiguous These potential instances exist: instance forall k (s :: k). Eq (Proxy s) -- Defined in ‘Data.Proxy’ instance Eq Ordering -- Defined in ‘GHC.Classes’ instance Eq Integer -- Defined in ‘integer-gmp-1.0.1.0:GHC.Integer.Type’ ...plus 25 others ...plus 9 instances involving out-of-scope types (use -fprint-potential-instances to see them all) • In the third argument of ‘GHC.Prim.coerce’, namely ‘(/=)’ In the expression: GHC.Prim.coerce @(Wat Proxy -> Wat Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (/=) In an equation for ‘/=’: (/=) = GHC.Prim.coerce @(Wat Proxy -> Wat Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (/=) When typechecking the code for ‘/=’ in a derived instance for ‘Eq (Glurp a)’: To see the code I am typechecking, use -ddump-deriv | 12 | deriving Eq | ^^ }}} Yikes. To see what went wrong, let's zoom in a particular part of the `-ddump-deriv` output (cleaned up a bit for presentation purposes): {{{#!hs instance Eq a => Eq (Glurp a) where (==) = coerce @(Wat 'Proxy -> Wat 'Proxy -> Bool) @(Glurp a -> Glurp a -> Bool) (==) }}} Notice that it's `Wat 'Proxy`, and not `Wat ('Proxy :: Proxy a)`! And no, that's not just a result of GHC omitting the kind information—you will see the exact same thing if you compile with `-fprint-explicit-kinds`. What's going on here? As it turns out, the types inside of those visible type applications aren't `Type`s, but rather `HsType GhcRn`s (i.e., source syntax). So what is happening is that GHC is literally producing `@(Wat 'Proxy -> Wat 'Proxy -> Bool)` //as source syntax//, not as a `Type`. This means that `'Proxy` has an underspecified kind, resulting in the numerous `The type variable ‘a0’ is ambiguous` errors you see above. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14579> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 27