June 2018 - ghc-tickets

[GHC] #15063: T3001-2 fails on i386 Linux
by GHC 31 Jul '18

31 Jul '18

#15063: T3001-2 fails on i386 Linux -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.1 Component: Profiling | Version: 8.2.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: -------------------------------------+------------------------------------- The `T3001-2` testcase fails on i386/Linux: {{{ Wrong exit code for T3001-2(prof_hb)(expected 0 , actual 134 ) Stderr ( T3001-2 ): T3001-2: internal error: Invalid object in processHeapClosureForDead(): 7 (GHC version 8.5.20180419 for i386_unknown_linux) Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug Aborted *** unexpected failure for T3001-2(prof_hb) }}} Closure type 7 is `CONSTR_NOCAF`, which is indeed invalid. Tracking this down will take some debugging. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15063> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 11

[GHC] #14346: 8.2.1 regression: heap corruption after safe foreign calls
by GHC 31 Jul '18

31 Jul '18

#14346: 8.2.1 regression: heap corruption after safe foreign calls -------------------------------------+------------------------------------- Reporter: andrewchen | Owner: (none) Type: bug | Status: new Priority: highest | Milestone: Component: Runtime | Version: 8.2.1 System | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime crash Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Test case: (compile with ghc 8.2.1 and -threaded option) {{{#!haskell module Main where import Control.Concurrent import Control.Monad import Data.Word import Foreign.Marshal.Alloc import Foreign.Ptr import Foreign.Storable foreign import ccall safe "test" c_test :: Ptr Word32 -> IO () main :: IO () main = do replicateM_ 1000 $ threadDelay 1000 _ <- forkIO $ forever $ threadDelay 100 allocaBytes 4 $ \p -> forever $ do c_test p x <- peek p unless (x == 0xDEADBEEF) $ putStrLn "value mismatch" }}} {{{#!c void test(unsigned int *buf) { *buf = 0xDEADBEEF; } }}} On my machine, it detects a few value mismatches before crashing with sigsegv. {{{ $ time ./.stack-work/install/x86_64-linux- nopie/nightly-2017-10-10/8.2.1/bin/bug value mismatch value mismatch value mismatch value mismatch zsh: segmentation fault (core dumped) ./.stack-work/install/x86_64-linux- nopie/nightly-2017-10-10/8.2.1/bin/bug ./.stack-work/install/x86_64-linux-nopie/nightly-2017-10-10/8.2.1/bin/bug 2.11s user 0.25s system 66% cpu 3.543 total }}} I believe this is what is causing crashes in xmobar. See discussion: https://github.com/jaor/xmobar/issues/310. Note that the crash in xmobar still happens without -threaded option, while this example only breaks when compiled with -threaded. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14346> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 41

[GHC] #12030: GHCi Proposal: Display (Data.Kind.)Type instead of *
by GHC 31 Jul '18

31 Jul '18

#12030: GHCi Proposal: Display (Data.Kind.)Type instead of * -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: GHCi | Version: 8.1 Keywords: TypeInType | 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 is premature but what the darn, {{{ >>> :kind Maybe Maybe :: Type -> Type >>> :kind StateT StateT :: Type -> (Type -> Type) -> Type -> Type >>> :kind Eq Eq :: Type -> Constraint >>> :info Functor class Functor (f :: Type -> Type) where ... }}} `*` throws students off and makes it seem scarier than it is. Symbols are harder to search for in general and to understand without documentation, `Type` on the other hand is descriptive. There are valid arguments against displaying `Type`: 1. It's a recent feature subject to change. 2. Although symbols are more difficult to search for, `*` is established in educational materials, logs, blogs and questions. 3. By default `Type` is not in scope so a user cannot ask for information in GHCi. `*` is established and searching for “Haskell asterisk” yields a lot resources but [https://support.google.com/websearch/answer/2466433?hl=en ‘*’ is also a wildcard] in Google and ignored by GitHub. With time `Type` would be a good search term but currently it's chicken-and-the-egg. Previous versions of GHCi error on `:kind *` and `:info *` only shows multiplication so that wouldn't be a huge difference but we can qualify by default: {{{ >>> :kind Maybe Maybe :: Data.Kind.Type -> Data.Kind.Type >>> :kind StateT StateT :: Data.Kind.Type -> (Data.Kind.Type -> Data.Kind.Type) -> Data.Kind.Type -> Data.Kind.Type >>> :kind Eq Eq :: Data.Kind.Type -> Constraint >>> :info Functor class Functor (f :: Data.Kind.Type -> Data.Kind.Type) where ... }}} or display `*` normally and only when `TypeInType` is set do we display `Type`. I don't love it (and love `GHC.Types.Type` slightly less) but there is a precedent for unqualified names, browsing the Prelude for example: {{{#!hs ($) :: forall (r :: GHC.Types.RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b undefined :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Stack.Types.HasCallStack => a }}} __If__ the consensus is that this will happen sometime down the line consider that each passing release means many more books and blog posts get written using `*`. I wasn't planning on resulting to scare tactics but [https://www.peoria.com/spaw/spawimages/members/member60763/shoot_this_dog.j… here we are]... ---- If needed a migration plan can be drafted like the Semigroup/FTP/AMP/BBP/MonadFail/expanding Float/... proposals, possibly culminating in `Type` fully replacing `*` and being imported by default. I'm sure there are some further reaching consequences to this and better arguments against. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12030> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #10056: Inconsistent precedence of ~
by GHC 30 Jul '18

30 Jul '18

#10056: Inconsistent precedence of ~ -------------------------------------+------------------------------------- Reporter: crockeea | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.4 (Parser) | Operating System: Unknown/Multiple Keywords: | Type of failure: GHC rejects Architecture: | valid program Unknown/Multiple | Blocked By: Test Case: | Related Tickets: Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- The following compiles as expected: {{{#!hs {-# LANGUAGE TypeFamilies #-} type family Foo a b f :: (Foo a b ~ Int) => a -> b -> b f = error "" }}} but this fails: {{{#!hs {-# LANGUAGE TypeFamilies #-} type family a \\ b f :: (a \\ b ~ Int) => a -> b -> b f = error "" }}} with the error > "The second argument of `(\\)` should have kind `*`, but `b ~ Int` has kind `Constraint`." Thus the first example is being parsed as `(Foo a b) ~ Int`, while the second is parsed as `a \\ (b ~ Int)`. I believe the second example should compile, i.e. `(\\)` and `Foo` should have the same precedence, both of which are higher than `(~)`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10056> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 42

[GHC] #14873: GHC HEAD regression (piResultTy)
by GHC 30 Jul '18

30 Jul '18

#14873: GHC HEAD regression (piResultTy) -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: highest | Milestone: Component: Compiler | Version: 8.5 (Type checker) | Keywords: | 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: -------------------------------------+------------------------------------- (Originally noticed [https://travis- ci.org/goldfirere/singletons/jobs/347945148#L1179 here].) The following program typechecks on GHC 8.2.2 on GHC 8.4.1, but panics on GHC HEAD: {{{#!hs {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeInType #-} {-# LANGUAGE TypeOperators #-} module Bug where import Data.Kind (Type) data family Sing (a :: k) newtype instance Sing (f :: k1 ~> k2) = SLambda { applySing :: forall t. Sing t -> Sing (Apply f t) } data TyFun :: Type -> Type -> Type type a ~> b = TyFun a b -> Type infixr 0 ~> type family Apply (f :: k1 ~> k2) (x :: k1) :: k2 class SingI (a :: k) where sing :: Sing a data ColSym1 :: f a -> a ~> Bool type instance Apply (ColSym1 x) y = Col x y class PColumn (f :: Type -> Type) where type Col (x :: f a) (y :: a) :: Bool class SColumn (f :: Type -> Type) where sCol :: forall (x :: f a) (y :: a). Sing x -> Sing y -> Sing (Col x y :: Bool) instance (SColumn f, SingI x) => SingI (ColSym1 (x :: f a) :: a ~> Bool) where sing = SLambda (sCol (sing @_ @x)) }}} {{{ $ /opt/ghc/head/bin/ghc Bug.hs [1 of 1] Compiling Bug ( Bug.hs, Bug.o ) ghc: panic! (the 'impossible' happened) (GHC version 8.5.20180201 for x86_64-unknown-linux): piResultTy k_aZU[tau:1] (a_aW8[sk:1] |> <*>_N) Call stack: CallStack (from HasCallStack): callStackDoc, called at compiler/utils/Outputable.hs:1150:37 in ghc:Outputable pprPanic, called at compiler/types/Type.hs:947:35 in ghc:Type }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14873> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 16

[GHC] #13451: Bind implicit parameter in patterns
by GHC 30 Jul '18

30 Jul '18

#13451: Bind implicit parameter in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: task | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | Operating System: Unknown/Multiple ImplicitParams | Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Is there any reason why variables for `ImplicitParams` can't be bound in patterns, so you can write {{{#!hs data Exp = Val Int | Op Op Exp Exp data Op = Add | Mul data Protect where Protect :: (?op :: Op) => Protect protectOp :: Exp -> Maybe Protect protectOp (Op ?op _ _) = Just Protect protectOp _ = Nothing }}} instead of {{{#!hs protectOp :: Exp -> Maybe Protect protectOp (Op op _ _) = Just Protect where ?op = op protectOp _ = Nothing }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13451> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #11549: Add -fshow-runtime-rep
by GHC 29 Jul '18

29 Jul '18

#11549: Add -fshow-runtime-rep -------------------------------------+------------------------------------- Reporter: goldfire | Owner: goldfire Type: bug | Status: new Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 8.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: -------------------------------------+------------------------------------- As discussed in several interwoven threads ([https://mail.haskell.org/pipermail/ghc-devs/2016-February/011268.html original], [https://mail.haskell.org/pipermail/haskell- cafe/2016-February/122914.html café]), it has been suggested to add a flag `-fshow-runtime-rep`. Without this flag enabled, the pretty printer will instantiate any `RuntimeRep` type parameters to `PtrRep Lifted`. This has the effect of changing {{{ ($) :: forall (r :: RuntimeRep) (a :: *) (b :: TYPE r). (a -> b) -> a -> b }}} to {{{ ($) :: (a -> b) -> a -> b }}} under the default GHCi settings. Note that `Levity` becomes `RuntimeRep` after #11471 is complete. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11549> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 20

[GHC] #15273: Datatypes with CUSKs should quantify over unknown kinds
by GHC 29 Jul '18

29 Jul '18

#15273: Datatypes with CUSKs should quantify over unknown kinds -------------------------------------+------------------------------------- Reporter: goldfire | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.1 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): Phab:D4845 | Wiki Page: -------------------------------------+------------------------------------- In [https://github.com/ghc-proposals/ghc-proposals/pull/54 the future], we will be able to give full kind signatures to datatype declarations. But in the present, we use CUSKs to write kind signatures. However, consider {{{#!hs data T (a :: Proxy k) }}} That has a CUSK, according to the CUSK rules. Yet we don't know the kind of `k`. Currently, this definition is rejected, accusing the user of lying about having a complete kind. However, let's instead pretend the user had written {{{#!hs type T :: Proxy k -> Type data T a }}} After all, that's what the CUSK is shorthand for. In this case, it's clear that we should infer `T :: forall k1 (k :: k1). Proxy k -> Type`, just the way we would do with a term-level type signature. This turns out to be quite easy. See Phab:D4845. This change allows strictly more programs to be accepted, and I think it falls under the threshold for requiring a proposal. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15273> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #10184: Coercible solver incomplete with recursive newtypes
by GHC 29 Jul '18

29 Jul '18

#10184: Coercible solver incomplete with recursive newtypes -------------------------------------+------------------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: low | Milestone: ⊥ Component: Compiler | Version: 7.10.1-rc3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Blocked By: Test Case: | Related Tickets: Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- The following module fails to compile due to infinite recursion: {{{ import Data.Coerce newtype Bar a = Bar (Either a (Bar a)) newtype Age = MkAge Int x :: Bar Age x = coerce (Bar (Left (5 :: Int))) }}} It tries to coerce `Bar Int` to `Bar Age`. This is clearly doable, via tyconapp decomposition. But we don't find it. Before worrying too much about it, though, we'll wait for a real example. Do speak up if this problem is ruining your day! -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10184> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #14247: Fails to coerce between newtypes directly
by GHC 29 Jul '18

29 Jul '18

#14247: Fails to coerce between newtypes directly -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.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: -------------------------------------+------------------------------------- {{{#!hs import Data.Coerce import Data.Type.Coercion newtype W a = W a newtype A = MkA (W A) a :: Coercion A A a = Coercion b :: Coercion a a' -> Coercion a (W a') b Coercion = Coercion c :: Coercion A (W A) c = b a }}} works just fine but the following fail: {{{#!hs -- • Couldn't match representation of type ‘A’ with that of ‘W A’ -- arising from a use of ‘Coercion’ -- • In the expression: Coercion -- In an equation for ‘d’: d = Coercion d :: Coercion A (W A) d = Coercion -- • Couldn't match representation of type ‘A’ with that of ‘W A’ -- arising from a use of ‘coerce’ -- • In the expression: coerce -- In an equation for ‘e’: e = coerce e :: A -> W A e = coerce }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14247> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5