February 2014 - ghc-tickets

[GHC] #8749: Pattern synonyms crash GHCi
by GHC 18 Dec '14

18 Dec '14

#8749: Pattern synonyms crash GHCi ------------------------------------+------------------------------------- Reporter: monoidal | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.7 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- {{{ ghci -XPatternSynonyms > let pattern P x = x }}} causes a panic. I understand pattern synonyms are currently unsupported in GHCi, but we should give an error message, not a panic. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8749> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #8525: lib/integer/integerConstantFolding fails with -DDEBUG
by GHC 17 Dec '14

17 Dec '14

#8525: lib/integer/integerConstantFolding fails with -DDEBUG -------------------------------+------------------------------------------- Reporter: nomeata | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Test Suite | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: integerConstantFolding Difficulty: Unknown | Blocking: Blocked By: | Related Tickets: | -------------------------------+------------------------------------------- Hi, with `-DDEBUG` in `GhcStage2HcOpts`, the test integerConstantFolding fails: {{{ =====> integerConstantFolding(normal) 1103 of 3814 [0, 1, 0] cd ./lib/integer && $MAKE -s --no-print-directory integerConstantFolding </dev/null >integerConstantFolding.run.stdout 2>integerConstantFolding.run.stderr Actual stderr output differs from expected: --- /dev/null 2013-11-12 10:54:14.804286745 +0100 +++ ./lib/integer/integerConstantFolding.run.stderr 2013-11-12 15:33:12.384669953 +0100 @@ -0,0 +1,62 @@ +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl{v r3Ok} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl4{v r3Oo} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl8{v r3Os} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl12{v r3Ow} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + ww1{v r3OO} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl48{v r3P7} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl52{v r3Pb} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl56{v r3Pf} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl60{v r3Pj} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl64{v r3Pn} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl68{v r3Pr} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + ww2{v r3Pv} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + ww3{v r3Pw} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + ww4{v r3PG} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + ww5{v r3PH} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl90{v r3PR} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl94{v r3PV} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl98{v r3PZ} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl102{v r3Q3} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl106{v r3Q7} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl110{v r3Qb} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl134{v r3Qz} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl138{v r3QD} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl142{v r3QH} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl146{v r3QL} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl153{v r3QS} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl161{v r3R0} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl165{v r3R4} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl169{v r3R8} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl173{v r3Rc} [gid] True False +WARNING: file compiler/stgSyn/CoreToStg.lhs, line 269 + lvl177{v r3Rg} [gid] True False *** unexpected failure for integerConstantFolding(normal) }}} The warning is in `consistentCafInfo` source:compiler/stgSyn/CoreToStg.lhs and was was last touched by SPJ in [fdf86568], and originally introduced by simmonmar in 2e6d322e130a8c37807a14699bbcbf9eb08fc970. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8525> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #8584: Pattern synonym type signatures
by GHC 17 Dec '14

17 Dec '14

#8584: Pattern synonym type signatures ------------------------------------+------------------------------------- Reporter: cactus | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: 5144 | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Currently, the only way to specify a type signature for a pattern synonym is by adding type annotations to the right-hand side, like this: {{{ {-# LANGUAGE PatternSynonyms, ScopedTypeVariables #-} pattern Single x = ([x] :: [Int]) }}} Bespoke syntax for adding type signatures for pattern synonyms would probably be useful. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8584> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #8778: Typeable TypeNats
by GHC 15 Dec '14

15 Dec '14

#8778: Typeable TypeNats -------------------------------------------+------------------------------- Reporter: dmcclean | Owner: Type: feature request | Status: new Priority: normal | Milestone: ⊥ Component: Compiler (Type checker) | Version: 7.8.1-rc1 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Unknown | Type of failure: Blocked By: | None/Unknown Related Tickets: 4385 | Test Case: | Blocking: -------------------------------------------+------------------------------- It would be useful (the case I have at hand is for some scenarios involving checking of physical dimensions) to be able to combine the Data.Dynamic story with the GHC.TypeLits story. A Typeable instance for every Nat is the sticking point. (I do not know if this is even theoretically possible.) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8778> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 28

[GHC] #8240: Better error messages for type family constraints
by GHC 11 Dec '14

11 Dec '14

#8240: Better error messages for type family constraints ------------------------------------+------------------------------------- Reporter: simonpj | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Consider this constraint {{{ F Int ~ Bool -- Arising (say) on line 5 F Int ~ Char -- Arising (say) on line 10 }}} At the moment we'll combine the two to {{{ F Int ~ Bool -- Arising on line 5 Bool ~ Char -- Arising on line 10 }}} The second of these errors is "insoluble" and is reported first. But it's totally misleading: nowhere in the program did we directly need `Int~Char`. Another variant of this came up in Trac #8227. There we get the constraint {{{ Scalar (V a) ~ t0 Scalar (V a) ~ t0 -> t0 }}} which leads to {{{ Scalar (V a) ~ t0 -> t0 t0 ~ t0 -> t0 -- Occurs check }}} which gives the confusing error {{{ T8227.hs:16:44: Occurs check: cannot construct the infinite type: t0 ~ t0 -> t0 Expected type: Scalar (V (t0 -> t0)) Actual type: Scalar (V a) }}} I think the solution is * Do not combine two Wanteds {{{ [W] F tys ~ t1 [W] F tys ~ t2 }}} unless t1 and t2 are both touchable unification variables. * Instead (perhaps) generate a Derived constraint {{{ [D] t1 ~ t2 }}} to express the fact that t1 and t2 had better end up equal. * To do this the inert set would need to contain many `CTyFunEq` constraints with the same LHS. I'm not very sure about this, and no time now, so I'm just making this ticket to record the issue. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8240> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #8548: Coercible does not resolve type family application
by GHC 02 Dec '14

02 Dec '14

#8548: Coercible does not resolve type family application -------------------------------------------+------------------------------- Reporter: nomeata | Owner: nomeata Type: bug | Status: new Priority: normal | Milestone: Component: Compiler (Type checker) | Version: 7.6.3 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Unknown | Type of failure: Blocked By: | None/Unknown Related Tickets: #8503 | Test Case: | Blocking: -------------------------------------------+------------------------------- With GND implemented using `Coercible` (See #8503) the test for #4185 fails. A minimal example is: {{{ {-# LANGUAGE TypeFamilies #-} module CoerceNewtypeFamily where import GHC.Exts data family Foo k newtype instance Foo Int = FooInt Int x :: Foo Int -> Int x = coerce }}} yielding {{{ [1 of 1] Compiling CoerceNewtypeFamily ( CoerceNewtypeFamily.hs, CoerceNewtypeFamily.o ) CoerceNewtypeFamily.hs:11:5: No instance for (Coercible (Foo Int) Int) because ‛Foo Int’ and ‛Int’ are different types. arising from a use of ‛coerce’ In the expression: coerce In an equation for ‛x’: x = coerce }}} I guess the `Coercible` finding code needs to simply type family equations if possible. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8548> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #8304: more lenient operator sections (RelaxedSections extension)
by GHC 01 Dec '14

01 Dec '14

#8304: more lenient operator sections (RelaxedSections extension) -------------------------------------+------------------------------------- Reporter: aavogt | Owner: Type: feature request | Status: new Priority: lowest | Milestone: Component: Compiler (Parser) | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | -------------------------------------+------------------------------------- Some operator sections are rejected which could have some meaning. {{{ (a ++ b ++ ) could mean \x -> a ++ b ++ c (++ a ++) could mean \x y -> x ++ a ++ y }}} The attached quasiquoter implements this, but for various reasons it would be better if ghc supported this directly. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8304> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #8100: Standalone deriving using template haskell
by GHC 01 Dec '14

01 Dec '14

#8100: Standalone deriving using template haskell ------------------------------------+------------------------------------- Reporter: acube | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Template Haskell | Version: Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Currently, there seems to be no support for standalone deriving in TemplateHaskell: {{{ Prelude Data.Typeable Language.Haskell.TH> :set -XStandaloneDeriving Prelude Data.Typeable Language.Haskell.TH> data Weird a (b :: * -> * -> *) c = Weird Prelude Data.Typeable Language.Haskell.TH> runQ $ [d| deriving instance Typeable Weird |] [] }}} ''Use case'': The library [http://hackage.haskell.org/package/typeable-th typeable-th] can already generate Typeable instances using TH for GHC 7.4 and 7.6. To add support for GHC 7.8 in a way that the user doesn't have to care about the version, there has to be a way to make Typeable instances via TH in GHC 7.8. This is currently impossible, but with StandaloneDeriving support for TH, it would be possible. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8100> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 14

[GHC] #8815: confusing language in error message
by GHC 30 Nov '14

30 Nov '14

#8815: confusing language in error message ------------------------------------+------------------------------------- Reporter: carter | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.1-rc1 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Late last night I was finding myself very confused by the following (in retrospect obvious error message) {{{ src/Numerical/OpenBLAS/BLAS.hs:41:44: A pattern match on a GADT requires GADTs or TypeFamilies In the pattern: SRow In the pattern: DenseMatrix SRow _ _ _ _ In an equation for ‛encodeNiceOrderHelper’: encodeNiceOrderHelper (DenseMatrix SRow _ _ _ _) = encodeOrder BLASRowMajor }}} the error is correct per se, but reading (at least late at night) made me think "wait, how is my type not a GADT or TypeFamily?!!?!" I'm thinking (perhaps ) that ``` A pattern match on a GADT requires GADTs or TypeFamilies `` ` could perhaps be more clearly communicated as ```A pattern match on a GADT requires that GADTs or TypeFamilies Language extensions be enabled in the use site module``` (or something similar) relatedly: whats the current reasoning for why GADT related matching logic isn't enabled in client modules that use GADTs? (i'm not questioning it, just wondering why) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8815> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 10

[GHC] #8323: explore ways to possibly use more tag bits in x86_64 pointers
by GHC 28 Nov '14

28 Nov '14

#8323: explore ways to possibly use more tag bits in x86_64 pointers ------------------------------------+------------------------------------- Reporter: carter | Owner: Type: task | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- on x86_64, pointers only use 48 bits! currently we use 3bits for tagging / arity etc info on x86_64, we should explore more uses! -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8323> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3