May 2017 - ghc-tickets

[GHC] #12175: Instance resolution regression
by GHC 26 May '17

26 May '17

#12175: Instance resolution regression -------------------------------------+------------------------------------- Reporter: crockeea | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | 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: -------------------------------------+------------------------------------- The following code works in 7.10, but fails in GHC 8.0.1: {{{ {-# LANGUAGE ConstraintKinds, MultiParamTypeClasses, TypeFamilies, UndecidableInstances #-} import GHC.Exts class Foo a instance (Foo a, Foo b, CTypeOf a ~ CTypeOf b) => Foo (a,b) type family TElt r :: Constraint type instance TElt r = (Foo r, Dispatch (CTypeOf r) r) type family CTypeOf x where CTypeOf (a,b) = CTypeOf a class (repr ~ CTypeOf r) => Dispatch repr r data CT r = CT [r] toCT :: (Foo r) => CT r -> CT r toCT = undefined unzipT :: (TElt a, TElt b, TElt (a,b)) => CT (a,b) -> (CT a, CT b) unzipT = unzipT . toCT main :: IO () main = undefined }}} with the errors {{{ Main.hs:1:1: error: solveWanteds: too many iterations (limit = 4) Unsolved: WC {wc_simple = [D] _ :: Dispatch fsk_a3GC b (CDictCan) [W] hole{a3Hh} :: CTypeOf a ~ CTypeOf b (CNonCanonical) [D] _ :: fsk_a3GC ~ CTypeOf b (CDictCan) [D] _ :: fsk_a3GC ~ CTypeOf b (CDictCan) [D] _ :: fsk_a3GC ~ CTypeOf b (CNonCanonical)} New superclasses found Set limit with -fconstraint-solver-iterations=n; n=0 for no limit Main.hs:22:19: error: • Couldn't match type ‘CTypeOf a’ with ‘CTypeOf b’ arising from a use of ‘toCT’ NB: ‘CTypeOf’ is a type function, and may not be injective • In the second argument of ‘(.)’, namely ‘toCT’ In the expression: unzipT . toCT In an equation for ‘unzipT’: unzipT = unzipT . toCT • Relevant bindings include unzipT :: CT (a, b) -> (CT a, CT b) (bound at Main.hs:22:1) }}} I don't understand the first error at all. The second error seems to be due to calling `toCT` on the type `CT (a,b)`, which requires the constraint `Foo (a,b)`. Rather than using the supplied constraint from `TElt (a,b)`, GHC is trying to resolve the instance provided, which requires `CType a ~ CType b`. Possibly related: #10338, #11948 -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12175> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #13758: Deriving can't find an instance that holds, standalone deriving works
by GHC 26 May '17

26 May '17

#13758: Deriving can't find an instance that holds, standalone deriving works -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.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: -------------------------------------+------------------------------------- Using [https://hackage.haskell.org/package/generic-deriving-1.11.2/docs /Generics-Deriving-Monoid.html generic-deriving] works {{{#!hs {-# Language ScopedTypeVariables, GeneralizedNewtypeDeriving, DeriveGeneric, UndecidableInstances, StandaloneDeriving, FlexibleContexts #-} import GHC.Generics import Generics.Deriving.Monoid hiding (GMonoid) import Data.Coerce import Data.Constraint import Data.Semigroup newtype GenericMonoid a = GenericMonoid a instance (Generic a, Monoid' (Rep a)) => Semigroup (GenericMonoid a) where (<>) = coerce (mappenddefault :: a -> a -> a) instance (Generic a, Monoid' (Rep a)) => Monoid (GenericMonoid a) where mempty = coerce (memptydefault :: a) mappend = coerce (mappenddefault :: a -> a -> a) data Urls = Urls String String String deriving (Show, Generic) newtype UrlsDeriv = UD (GenericMonoid Urls) deriving instance Semigroup UrlsDeriv deriving instance Monoid UrlsDeriv }}} but changing that to {{{#!hs newtype UrlsDeriv = UD (GenericMonoid Urls) deriving (Semigroup, Monoid) }}} fails {{{ $ ghci -ignore-dot-ghci tWqD.hs GHCi, version 8.0.1: http://www.haskell.org/ghc/ :? for help [1 of 1] Compiling Main ( tWqD.hs, interpreted ) Ok, modules loaded: Main. *Main> :r [1 of 1] Compiling Main ( tWqD.hs, interpreted ) tWqD.hs:26:13: error: • No instance for (Monoid' (Rep Urls)) arising from the 'deriving' clause of a data type declaration Possible fix: use a standalone 'deriving instance' declaration, so you can specify the instance context yourself • When deriving the instance for (Semigroup UrlsDeriv) tWqD.hs:26:24: error: • No instance for (Monoid' (Rep Urls)) arising from the 'deriving' clause of a data type declaration Possible fix: use a standalone 'deriving instance' declaration, so you can specify the instance context yourself • When deriving the instance for (Monoid UrlsDeriv) Failed, modules loaded: none. }}} This feels familiar but I couldn't quickly. I can't recall if this behavior is intended so I'm filing a ticket just in case. It even following proof of `Monoid' (Rep Urls)` and a dummy quasiquote `pure []` separating it them, {{{#!hs {-# Language ..., TemplateHaskell #-} ... doo :: Dict (Monoid' (Rep Urls)) doo = Dict pure [] newtype UrlsDeriv = UD (GenericMonoid Urls) deriving Monoid }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13758> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #8905: Function arguments are always spilled/reloaded if scrutinee is already in WHNF
by GHC 26 May '17

26 May '17

#8905: Function arguments are always spilled/reloaded if scrutinee is already in WHNF ------------------------------+-------------------------------------------- Reporter: tibbe | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.9 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime performance bug Unknown/Multiple | Test Case: Difficulty: Unknown | Blocking: Blocked By: | Related Tickets: | ------------------------------+-------------------------------------------- The code generator unnecessarily spills and reloads function arguments if the scrutinee turns out to be already evaluated (i.e. has non-zero tag bits). Here's the beginning of a function body, taken from the `insert` function at https://github.com/tibbe/unordered- containers/blob/master/Data/HashMap/Base.hs#L303: {{{ c2wQ: // stack check if ((Sp + -72) < SpLim) goto c2wR; else goto c2wS; c2wR: // stack check failure R1 = PicBaseReg + $wpoly_go_closure; I64[Sp - 40] = R2; I64[Sp - 32] = R3; P64[Sp - 24] = R4; I64[Sp - 16] = R5; P64[Sp - 8] = R6; Sp = Sp - 40; call (I64[BaseReg - 8])(R1) args: 48, res: 0, upd: 8; c2wS: // stack check success I64[Sp - 40] = PicBaseReg + block_c2my_info; // return addr for eval R1 = R6; // t I64[Sp - 32] = R2; // spill: s I64[Sp - 24] = R3; // spill: x P64[Sp - 16] = R4; // spill: k I64[Sp - 8] = R5; // spill: h Sp = Sp - 40; if (R1 & 7 != 0) goto c2my; else goto c2mz; // eval check of t c2mz: // eval check failed call (I64[R1])(R1) returns to c2my, args: 8, res: 8, upd: 8; // eval c2my: // eval check succeeded _s2b1::I64 = I64[Sp + 8]; // reload: h _s2b2::I64 = I64[Sp + 16]; // reload: k _s2b3::P64 = P64[Sp + 24]; // reload: x _s2b4::I64 = I64[Sp + 32]; // reload: s switch [0 .. 4] (R1 & 7 - 1) { case 0 : goto c2wK; case 1 : goto c2wL; case 2 : goto c2wM; case 3 : goto c2wN; case 4 : goto c2wO; } }}} It seems to me that all the spills/reloads could be pushed into the `c2mz` block. The `c2my` block, in its current form, is reused for a heap check failure case, so the heap check most likely will have to do its own spilling/reloading. However, since the scrutinee not having tags bit or the eval checking failing is not the common case, they should be out of the common path. If it matters the data type is spine strict so GHC should have enough information to know that the common case (e.g. self-recursive calls) already have an evaluated argument (although there might be an indirection in some cases). -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8905> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 17

[GHC] #10421: exponential blowup in inlining (without INLINE pragmas)
by GHC 26 May '17

26 May '17

#10421: exponential blowup in inlining (without INLINE pragmas) -------------------------------------+------------------------------------- Reporter: rwbarton | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Blocked By: Test Case: | Related Tickets: Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- The test case for #10397 also demonstrates an exponential blowup by the inliner, without any INLINE pragmas. I added another four fields to the `Register` type, and I get these final Core program sizes. (The variation in sizes between versions is not really important, the point is just that they are very large for all versions.) {{{ ghc-7.6.3: *** CorePrep: Result size of CorePrep = {terms: 1,702,684, types: 1,950,647, coercions: 103} ghc-7.8.4: *** CorePrep: Result size of CorePrep = {terms: 1,964,183, types: 1,950,620, coercions: 97} ghc-7.10.1: *** CorePrep: Result size of CorePrep = {terms: 1,964,212, types: 1,950,764, coercions: 97} ghc-7.11: *** CorePrep: Result size of CorePrep = {terms: 1,964,212, types: 1,950,764, coercions: 97} }}} Ideally GHC should not produce enormous Core programs on its own like this. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10421> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #13677: Incorrect parenthesization of type in error message
by GHC 26 May '17

26 May '17

#13677: Incorrect parenthesization of type in error message -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 (Type checker) | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Poor/confusing Unknown/Multiple | error message Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- If you compile this program: {{{#!hs {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE GADTs #-} import GHC.Exts (Constraint) data Dict a where Dict :: a => Dict a foo :: Dict (Int ~ Int) => Int foo = undefined }}} In GHC 8.0.1, 8.0.2, 8.2.1, or HEAD, it will give this error message: {{{ GHCi, version 8.3.20170509: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Main ( Bug2.hs, interpreted ) Bug2.hs:9:8: error: • Expected a constraint, but ‘Dict Int ~ Int’ has kind ‘*’ • In the type signature: foo :: Dict (Int ~ Int) => Int | 9 | foo :: Dict (Int ~ Int) => Int | ^^^^^^^^^^^^^^^^ }}} But `Dict Int ~ Int` is not parenthesized correctly! This is a regression, as GHC 7.10.3 and earlier parenthesize it correctly: {{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help [1 of 1] Compiling Main ( Bug2.hs, interpreted ) Bug2.hs:9:8: Expected a constraint, but ‘Dict (Int ~ Int)’ has kind ‘*’ In the type signature for ‘foo’: foo :: Dict (Int ~ Int) => Int }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13677> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #13674: GHC doesn't discharge heterogenous equality constraint when it ought to
by GHC 26 May '17

26 May '17

#13674: GHC doesn't discharge heterogenous equality constraint when it ought to -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 (Type checker) | Keywords: TypeInType | 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: -------------------------------------+------------------------------------- Here's some code, reduced from an example in https://github.com/ekmett/constraints/issues/55: {{{#!hs {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} import Data.Proxy import GHC.Exts (Constraint) import GHC.TypeLits import Unsafe.Coerce (unsafeCoerce) data Dict :: Constraint -> * where Dict :: a => Dict a infixr 9 :- newtype a :- b = Sub (a => Dict b) -- | Given that @a :- b@, derive something that needs a context @b@, using the context @a@ (\\) :: a => (b => r) -> (a :- b) -> r r \\ Sub Dict = r newtype Magic n = Magic (KnownNat n => Dict (KnownNat n)) magic :: forall n m o. (Integer -> Integer -> Integer) -> (KnownNat n, KnownNat m) :- KnownNat o magic f = Sub $ unsafeCoerce (Magic Dict) (natVal (Proxy :: Proxy n) `f` natVal (Proxy :: Proxy m)) type family Lcm :: Nat -> Nat -> Nat where axiom :: forall a b. Dict (a ~ b) axiom = unsafeCoerce (Dict :: Dict (a ~ a)) lcmNat :: forall n m. (KnownNat n, KnownNat m) :- KnownNat (Lcm n m) lcmNat = magic lcm lcmIsIdempotent :: forall n. Dict (n ~ Lcm n n) lcmIsIdempotent = axiom newtype GF (n :: Nat) = GF Integer x :: GF 5 x = GF 3 y :: GF 5 y = GF 4 foo :: (KnownNat m, KnownNat n) => GF m -> GF n -> GF (Lcm m n) foo m@(GF x) n@(GF y) = GF $ (x*y) `mod` (lcm (natVal m) (natVal n)) bar :: (KnownNat m) => GF m -> GF m -> GF m bar (x :: GF m) y = foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) }}} Compiling this (with either GHC 8.0.1, 8.0.2, 8.2.1, or HEAD) gives you a downright puzzling type error: {{{ $ /opt/ghc/head/bin/ghci Bug.hs GHCi, version 8.3.20170509: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Main ( Bug.hs, interpreted ) Bug.hs:54:21: error: • Couldn't match type ‘m’ with ‘Lcm m m’ ‘m’ is a rigid type variable bound by the type signature for: bar :: forall (m :: Nat). KnownNat m => GF m -> GF m -> GF m at Bug.hs:53:1-44 Expected type: GF m Actual type: GF (Lcm m m) • In the first argument of ‘(-)’, namely ‘foo x y’ In the expression: foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) In an equation for ‘bar’: bar (x :: GF m) y = foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) • Relevant bindings include y :: GF m (bound at Bug.hs:54:17) x :: GF m (bound at Bug.hs:54:6) bar :: GF m -> GF m -> GF m (bound at Bug.hs:54:1) | 54 | bar (x :: GF m) y = foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) | ^^^^^^^ Bug.hs:54:31: error: • Could not deduce: m ~ Lcm m m from the context: m ~ Lcm m m bound by a type expected by the context: m ~ Lcm m m => GF m at Bug.hs:54:31-85 ‘m’ is a rigid type variable bound by the type signature for: bar :: forall (m :: Nat). KnownNat m => GF m -> GF m -> GF m at Bug.hs:53:1-44 Expected type: GF m Actual type: GF (Lcm m m) • In the first argument of ‘(\\)’, namely ‘foo y x’ In the first argument of ‘(\\)’, namely ‘foo y x \\ lcmNat @m @m’ In the second argument of ‘(-)’, namely ‘foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m)’ • Relevant bindings include y :: GF m (bound at Bug.hs:54:17) x :: GF m (bound at Bug.hs:54:6) bar :: GF m -> GF m -> GF m (bound at Bug.hs:54:1) | 54 | bar (x :: GF m) y = foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) | ^^^^^^^ }}} In particular, I'd like to emphasize this part: {{{ • Could not deduce: m ~ Lcm m m from the context: m ~ Lcm m m }}} Wat!? Surely, GHC can deduce `m ~ Lcm m m` from `m ~ Lcm m m`? I decided to flip on `-fprint-explicit-kinds` and see if there was some other issue lurking beneath the surface: {{{ $ /opt/ghc/8.2.1/bin/ghci Bug.hs -fprint-explicit-kinds GHCi, version 8.2.0.20170505: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Main ( Bug.hs, interpreted ) Bug.hs:54:21: error: • Couldn't match type ‘m’ with ‘Lcm m m’ ‘m’ is a rigid type variable bound by the type signature for: bar :: forall (m :: Nat). KnownNat m => GF m -> GF m -> GF m at Bug.hs:53:1-44 Expected type: GF m Actual type: GF (Lcm m m) • In the first argument of ‘(-)’, namely ‘foo x y’ In the expression: foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) In an equation for ‘bar’: bar (x :: GF m) y = foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) • Relevant bindings include y :: GF m (bound at Bug.hs:54:17) x :: GF m (bound at Bug.hs:54:6) bar :: GF m -> GF m -> GF m (bound at Bug.hs:54:1) | 54 | bar (x :: GF m) y = foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) | ^^^^^^^ Bug.hs:54:31: error: • Could not deduce: (m :: Nat) ~~ (Lcm m m :: Nat) from the context: m ~ Lcm m m bound by a type expected by the context: m ~ Lcm m m => GF m at Bug.hs:54:31-85 ‘m’ is a rigid type variable bound by the type signature for: bar :: forall (m :: Nat). KnownNat m => GF m -> GF m -> GF m at Bug.hs:53:1-44 Expected type: GF m Actual type: GF (Lcm m m) • In the first argument of ‘(\\)’, namely ‘foo y x’ In the first argument of ‘(\\)’, namely ‘foo y x \\ lcmNat @m @m’ In the second argument of ‘(-)’, namely ‘foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m)’ • Relevant bindings include y :: GF m (bound at Bug.hs:54:17) x :: GF m (bound at Bug.hs:54:6) bar :: GF m -> GF m -> GF m (bound at Bug.hs:54:1) | 54 | bar (x :: GF m) y = foo x y - foo y x \\ lcmNat @m @m \\ Sub @() (lcmIsIdempotent @m) | ^^^^^^^ }}} Well, not a whole lot changed. We now have this, slightly more specific error instead: {{{ • Could not deduce: (m :: Nat) ~~ (Lcm m m :: Nat) from the context: m ~ Lcm m m }}} Huh, this is flummoxing. Surely `(m :: Nat) ~~ (Lcm m m :: Nat)` ought to be the same thing as `m ~ Lcm m m`, right? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13674> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 13

[GHC] #13754: ghc-8.0.2+ rejects more instance declarations
by GHC 26 May '17

26 May '17

#13754: ghc-8.0.2+ rejects more instance declarations -------------------------------------+------------------------------------- Reporter: zilinc | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.2 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: -------------------------------------+------------------------------------- Sorry for the vague title. For a program (sorry again but I failed to shrink it further): {{{ {-# language ExistentialQuantification, KindSignatures, DataKinds, GADTs, UndecidableInstances, AllowAmbiguousTypes #-} class Pretty a where pretty :: a -> String prettyList :: [a] -> String prettyList = concatMap pretty data Def e = forall t. FunDef (Type t) (e t) data Nat = Z | S Nat data F (t :: Nat) where FZ :: F (S Z) FS :: F n -> F (S n) data Type (t :: Nat) = TVar (F t) data Expr (t :: Nat) e = Fun (Type t) | App (e t) (e t) data TE t = TE (Type t) (Expr t TE) -- all methods left undefined, as they're insignificant instance Pretty t => Pretty [t] where pretty = undefined instance (Pretty (e t)) => Pretty (Def e) where pretty (FunDef t e) = undefined instance Pretty (Type t) where pretty (TVar t) = undefined instance Pretty (e t) => Pretty (Expr t e) where pretty (Fun t) = undefined pretty (App e1 e2) = undefined instance Pretty (TE t) where pretty (TE t e) = undefined }}} ghc-8.0.1 is happy with it, whereas later versions (tested with 8.0.2 and 8.2.1-rc2) reject it. The error msg is: {{{ GHCInstance1.hs:27:10: error: • Could not deduce (Pretty (e t0)) arising from a use of ‘Main.$dmprettyList’ from the context: Pretty (e t) bound by the instance declaration at GHCInstance1.hs:27:10-41 The type variable ‘t0’ is ambiguous Relevant bindings include prettyList :: [Def e] -> String (bound at GHCInstance1.hs:27:10) • In the expression: Main.$dmprettyList @Def e In an equation for ‘prettyList’: prettyList = Main.$dmprettyList @Def e In the instance declaration for ‘Pretty (Def e)’ }}} If I comment out the `prettyList` method from the class definition, then all happy. I'm not sure if it's a bug in 8.0.1 or a regression (and hard to reason about the behaviours). If it was the later, how should I migrate from 8.0.1? The `Pretty` class is a library (e.g. ansi-wl-pprint) so no way I can change it. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13754> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #13729: ghc does not pick up TH changes across package boundaries
by GHC 25 May '17

25 May '17

#13729: ghc does not pick up TH changes across package boundaries -------------------------------------+------------------------------------- Reporter: Feuerbach | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.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: -------------------------------------+------------------------------------- I have the following three modules: {{{#!hs module Types where data Foo = Bar }}} {{{#!hs {-# LANGUAGE TemplateHaskell #-} module TH where import Language.Haskell.TH import Language.Haskell.TH.Syntax import Types th_string = lift . show =<< reify ''Foo }}} {{{#!hs {-# LANGUAGE TemplateHaskell #-} module Main where import TH main = putStrLn $(th_string) }}} The goal is to make Main recompile if the definition of Types.Foo changes. If I simply put the three files in the same directory and compile with ghc, it works. However, if I put Types and TH in package A and Main in package B, then ghc doesn't recompile B.Main if I change the definition of A.Types.Foo and reinstall the package A. I tried this with both stack and cabal-install. In both cases I compiled B.Main directly with ghc, so it's not Cabal that's hiding the changes. If I pass -fforce-recomp to ghc, Main recompiles as expected. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13729> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #13718: diagnostic colors: differentiate between message head and message body
by GHC 25 May '17

25 May '17

#13718: diagnostic colors: differentiate between message head and message body -------------------------------------+------------------------------------- Reporter: int-e | Owner: (none) Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 8.2.1-rc2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: #13444 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- When a diagnostic message is printed, currently the whole message is colored by the "message" color (bold by default). I'd find it useful if the message body and the header could be differentiated (I do like the idea that the header stands out). Motivation: Consider the following error message, {{{ GHCi, version 8.2.0.20170508: http://www.haskell.org/ghc/ :? for help Prelude> () () <interactive>:1:1: error: • Couldn't match expected type ‘() -> t’ with actual type ‘()’ • The function ‘()’ is applied to one argument, but its type ‘()’ has none In the expression: () () In an equation for ‘it’: it = () () • Relevant bindings include it :: t (bound at <interactive>:1:1) }}} which by default is all bold, with the {{{error:}}} part in red. I want the message body to use normal text. Thanks to #13444 I can achieve that by setting {{{GHC_COLORS="message=0"}}}. However, that setting also affects the initial {{{<interactive>:1:1}}} part of the headline, which now looks odd because normal and bold text are mixed. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13718> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #13749: Panic (initTc: unresolved constraints) on some bad code
by GHC 23 May '17

23 May '17

#13749: Panic (initTc: unresolved constraints) on some bad code -------------------------------------+------------------------------------- Reporter: uranium | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.2 Keywords: | Operating System: Linux Architecture: | Type of failure: Compile-time Unknown/Multiple | crash or panic Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- I was just refactoring some code, and partway through, before it was all compiling, I hit the below error. The code's probably just terrible in an interestingly new way; I'm pretty inexperienced at Haskell. I'll attach the file. Prelude> :r [1 of 1] Compiling Main ( /home/uranium/projects/server/src/Main.hs, interpreted ) ghc: panic! (the 'impossible' happened) (GHC version 8.0.2 for x86_64-unknown-linux): initTc: unsolved constraints WC {wc_insol = [W] get_aGsK :: t_aGsJ[tau:1] (CHoleCan: get) [W] execState_aGsX :: t_aGsW[tau:1] (CHoleCan: execState) [W] get_aGvL :: t_aGvK[tau:1] (CHoleCan: get) [W] lift_aGvU :: t_aGvT[tau:1] (CHoleCan: lift) [W] put_aGw3 :: t_aGw2[tau:1] (CHoleCan: put) [W] cellType_aGwy :: t_aGwx[tau:1] (CHoleCan: cellType) [W] insts_aGwB :: t_aGwA[tau:1] (CHoleCan: insts) [W] ports_aGwE :: t_aGwD[tau:1] (CHoleCan: ports) [W] conns_aGwH :: t_aGwG[tau:1] (CHoleCan: conns) [W] annos_aGwK :: t_aGwJ[tau:1] (CHoleCan: annos) [W] comms_aGwN :: t_aGwM[tau:1] (CHoleCan: comms)} Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13749> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4