November 2017 - ghc-tickets

[GHC] #14098: Incorrect pattern match warning on nested GADTs
by GHC 02 Mar '18

02 Mar '18

#14098: Incorrect pattern match warning on nested GADTs -------------------------------------+------------------------------------- Reporter: jmgrosen | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 Keywords: | Operating System: Unknown/Multiple PatternMatchWarnings | Architecture: | Type of failure: Incorrect Unknown/Multiple | error/warning at compile-time Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- {{{#!hs {-# Language GADTs #-} data App f a where App :: f a -> App f (Maybe a) data Ty a where TBool :: Ty Bool TInt :: Ty Int data T f a where C :: T Ty (Maybe Bool) -- Warning f :: T f a -> App f a -> () f C (App TBool) = () -- No warning g :: T f a -> App f a -> () g C (App x) = case x of TBool -> () }}} When compiling, with `-Wincomplete-patterns`: {{{ Foo.hs:15:1: warning: [-Wincomplete-patterns] Pattern match(es) are non-exhaustive In an equation for ‘f’: Patterns not matched: C (App TInt) | 15 | f C (App TBool) = () | ^^^^^^^^^^^^^^^^^^^^ }}} I'm sorry for such a complicated example, but I wasn't able to reduce it any further than this. The gist of the problem is that this code gives a pattern matching non- exhaustiveness warning when matching a nested pattern, when pulling out a value then matching on it produces no warning (correctly). It also seems to have to do with using a type constructor (`Maybe`) within the constructor definition of `App`, as changing it to {{{#!hs data App f a where App :: f a -> App f a ... data T f a where C :: T Ty Bool }}} does not give a warning, even when `App` is modified further to force it to be a proper GADT. This might be a known limitation of the checker, but given that it works fine when the nesting is removed, I would think it would be more of a bug. Thanks to Iavor for helping me minimize the test case. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14098> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 10

[GHC] #14544: doCorePass has at least one missing case
by GHC 02 Mar '18

02 Mar '18

#14544: doCorePass has at least one missing case -------------------------------------+------------------------------------- Reporter: mpickering | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 Keywords: newcomer | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- There is a catch all at the end of `doCorePass` which hides the fact that `doCorePass` should be total. In particular `doCorePass` is not implemented for `CoreOccurAnal` and so either `CoreOccurAnal` should be removed from `CoreToDo` or implemented properly in `doCorePass`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14544> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #12706: Collecting type info is slow
by GHC 02 Mar '18

02 Mar '18

#12706: Collecting type info is slow -------------------------------------+------------------------------------- Reporter: vshabanov | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: GHCi | 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: -------------------------------------+------------------------------------- With `:set +c` option in GHCi, I'm waiting for 10-15 seconds for {{{ Collecting type info for 34 module(s) ... }}} after both first load and subsequent reloads, even if only top-level module was modified. And GHCi uses about 1.5-2x more memory than it uses without `:set +c`. My app has about 30k lines of code. Is it expected behavior and some performance improvements are planned or it's a bug? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12706> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #12790: GHC 8.0.1 uses copious amounts of RAM and time when trying to compile lambdabot-haskell-plugins
by GHC 02 Mar '18

02 Mar '18

#12790: GHC 8.0.1 uses copious amounts of RAM and time when trying to compile lambdabot-haskell-plugins -------------------------------------+------------------------------------- Reporter: clint | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Compile-time Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- When building lambdabot-haskell-plugins, Lambdabot.Plugin.Haskell.Pl.Parser compiles without incident on the non- profiling run, but cripples the build machine on the profiling run. An excerpt of -v3 output is below to show the number of terms skyrocketing. *** Common sub-expression [Lambdabot.Plugin.Haskell.Pl.Parser]: Result size of Common sub-expression = {terms: 39,049, types: 30,851, coercions: 990} !!! Common sub-expression [Lambdabot.Plugin.Haskell.Pl.Parser]: finished in 72.00 milliseconds, allocated 44.536 megabytes *** Float inwards [Lambdabot.Plugin.Haskell.Pl.Parser]: Result size of Float inwards = {terms: 39,049, types: 30,851, coercions: 990} !!! Float inwards [Lambdabot.Plugin.Haskell.Pl.Parser]: finished in 68.00 milliseconds, allocated 60.337 megabytes *** Simplifier [Lambdabot.Plugin.Haskell.Pl.Parser]: Result size of Simplifier iteration=1 = {terms: 977,045, types: 299,334, coercions: 1,058} Result size of Simplifier iteration=2 = {terms: 926,036, types: 263,306, coercions: 932} Result size of Simplifier = {terms: 922,724, types: 262,202, coercions: 932} !!! Simplifier [Lambdabot.Plugin.Haskell.Pl.Parser]: finished in 15480.00 milliseconds, allocated 9384.823 megabytes *** CoreTidy [Lambdabot.Plugin.Haskell.Pl.Parser]: Result size of Tidy Core = {terms: 922,623, types: 261,789, coercions: 865} !!! CoreTidy [Lambdabot.Plugin.Haskell.Pl.Parser]: finished in 2060.00 milliseconds, allocated 613.585 megabytes writeBinIface: 95 Names writeBinIface: 259 dict entries *** CorePrep [Lambdabot.Plugin.Haskell.Pl.Parser]: Result size of CorePrep = {terms: 1,128,145, types: 347,063, coercions: 865} !!! CorePrep [Lambdabot.Plugin.Haskell.Pl.Parser]: finished in 3468.00 milliseconds, allocated 1718.453 megabytes *** Stg2Stg: *** CodeGen [Lambdabot.Plugin.Haskell.Pl.Parser]: -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12790> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 20

[GHC] #14196: Replace ArrayArray# with either UnliftedArray# or Array#
by GHC 27 Feb '18

27 Feb '18

#14196: Replace ArrayArray# with either UnliftedArray# or Array# -------------------------------------+------------------------------------- Reporter: andrewthad | Owner: (none) Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 Keywords: | Operating System: Unknown/Multiple LevityPolymorphism | Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Just to be clear, there currently is nothing named `UnliftedArray#`. I would like to propose that such a thing possibly be added, with the long- term goal of deprecating and removing `ArrayArray#`. The interface for it would look like this: {{{#!hs data UnliftedArray# (a :: TYPE 'UnliftedRep) data MutableUnliftedArray# s (a :: TYPE 'UnliftedRep) indexUnliftedArray# :: forall (a :: TYPE 'UnliftedRep). UnliftedArray# a -> Int# -> a writeUnliftedArray# :: forall (a :: TYPE 'UnliftedRep). MutableUnliftedArray# s a -> Int# -> a -> State# s -> State# s readUnliftedArray# :: forall (a :: TYPE 'UnliftedRep). MutableUnliftedArray# s a -> Int# -> State# s -> (# State# s, a #) unsafeFreezeUnliftedArray# :: forall (a :: TYPE 'UnliftedRep). MutableUnliftedArray# s a -> State# s -> (#State# s, UnliftedArray# a#) newUnliftedArray# :: forall (a :: TYPE 'UnliftedRep). Int# -> a -> State# s -> (# State# s, MutableUnliftedArray# s a #) }}} You would also have a few other things like `sameMutableUnliftedArray#`, `sizeofMutableArray#`, `unsafeThawUnliftedArray#`, `copyUnliftedArray#`, etc. The main difficulty that I see in doing this is that I'm not sure if you can tell a primop that it takes a polymorphic argument whose kind is something other than `TYPE LiftedRep`. The bodies of all of the functions I listed above could simply be copied from the `ArrayArray#` functions. There are a few alternatives I've heard discussed. One is to make `Array#` accepted both boxed or unboxed types. There is a brief discussion of this in the UnliftedDataTypes proposal [#point0 (0)]. Indeed, it appears that some have managed to smuggle unlifted data into `Array#` already, with the caveats one would expect [#point1 (1)]. This interface would look like: {{{#!hs data Array# (a :: TYPE k) data MutableArray# s (a :: TYPE k) indexArray# :: Array# a -> Int -> a -- same as before indexUnliftedArray# :: forall (a :: TYPE UnliftedRep). Array# a -> Int -> a }}} So instead of having `Array#` and `UnliftedArray#` as separate data types, we could have `Array#` handle both cases, but we would need to make a duplicate of every function that operates on `Array#`. This follows all of the appropriate rules for when levity polymorphism is allowed, and it should be backwards-compatible with the previous non-levity-polymorphic definition of `Array#`. I'm not sure how many things in the GHC runtime assume that the values inside an array are lifted, so this might cause a bunch of problems. If it is possible, this approach would be kind of neat because then `SmallArray#` could be similarly adapted. Anyway, I just wanted to get this out there. I would be happy to try implementing the first proposal (involving `UnliftedArray#`) at some point in the next six months. Any feedback on the idea would be appreciated. Also, any comments on how appropriate this is for someone new to contributing to GHC would be appreciated as well. Thanks. * [=#point0 (0)] https://ghc.haskell.org/trac/ghc/wiki/UnliftedDataTypes#Parametricity * [=#point0 (1)] https://www.reddit.com/r/haskell/comments/6v9rmg/an_unified_array_interface… -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14196> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #13075: Top-level bang pattern accepted
by GHC 27 Feb '18

27 Feb '18

#13075: Top-level bang pattern accepted -------------------------------------+------------------------------------- Reporter: goldfire | Owner: goldfire 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: -------------------------------------+------------------------------------- When I compile/link {{{#!hs {-# LANGUAGE BangPatterns #-} module Main where !(Just x) = Nothing main = putStrLn "hi there!" }}} I get {{{ rae:09:50:49 ~/temp> ghc Bug.hs [1 of 1] Compiling Main ( Bug.hs, Bug.o ) Linking Bug ... ld: can't open output file for writing: Bug, errno=21 for architecture x86_64 clang: error: linker command failed with exit code 1 (use -v to see invocation) `gcc' failed in phase `Linker'. (Exit code: 1) }}} This bogus code should be rejected more gracefully (and earlier). It actually also loads into GHCi, but shouldn't. Will fix while I'm in the area. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13075> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 15

[GHC] #13596: Try disabling inlining of DynFlags combinators
by GHC 26 Feb '18

26 Feb '18

#13596: Try disabling inlining of DynFlags combinators -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: task | 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: -------------------------------------+------------------------------------- `DynFlags` requires a surprisingly amount of effort to compile. One thing I've been meaning to try is disabling inlining of `make_ord_flag` and such to characterize how much of an impact these inlinings have on simplification effort. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13596> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #11107: Can't use type wildcard infix
by GHC 25 Feb '18

25 Feb '18

#11107: Can't use type wildcard infix -------------------------------------+------------------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.11 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 fails: {{{ foo :: Int `_a` Bool foo = Right True }}} But moving `_a` to be prefix works. I observe the same behavior with an unnamed type wildcard. This was discovered while poking around in the renamer, not in real code! -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11107> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #13088: Type operator holes don't work infix
by GHC 25 Feb '18

25 Feb '18

#13088: Type operator holes don't work infix -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 (Parser) | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: #13050 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Originally noted in https://phabricator.haskell.org/D2910 (which fixed #13050). Currently, you can do this: Does this also work with TypeOperators? That is, you can do this: {{{#!hs {-# LANGUAGE TypeOperators #-} foo :: a `_over` b -> _over a b foo = id }}} But not this: {{{#!hs {-# LANGUAGE TypeOperators #-} foo :: a `_` b -> over a b foo = id }}} osa1 made an attempt at fixing this, and recorded his progress [https://phabricator.haskell.org/D2910#85423 here]: > I played with alternative implementations and attempted at implementing type-level version of this patch as suggested by @RyanGlScott. > > Since `_` needs special treatment by the renamer I think we have to have some kind of special treatment for `_` in the parser too, so this implementation may not be too bad. > > (alternatively I guess we could remove special treatment for `_` in the parser but that'd just move special cases to the renamer, so I'm not sure that's any better than the current approach) > > About the type-level named infix holes: Type renamer is quite different than term renamer (`RnTypes.hs`) and I don't understand type-checker parts of the compiler -- but I was able to made an attempt at implementing this > > {{{#!diff > diff --git a/compiler/hsSyn/HsTypes.hs b/compiler/hsSyn/HsTypes.hs > index 53f200f..877c243 100644 > --- a/compiler/hsSyn/HsTypes.hs > +++ b/compiler/hsSyn/HsTypes.hs > @@ -608,6 +608,7 @@ type LHsAppType name = Located (HsAppType name) > data HsAppType name > = HsAppInfix (Located name) -- either a symbol or an id in backticks > | HsAppPrefix (LHsType name) -- anything else, including things like (+) > + | HsAppWild (Located (HsWildCardInfo name)) > deriving instance (DataId name) => Data (HsAppType name) > > instance (OutputableBndrId name) => Outputable (HsAppType name) where > @@ -987,11 +988,18 @@ getAppsTyHead_maybe tys = case splitHsAppsTy tys of > splitHsAppsTy :: [LHsAppType name] -> ([[LHsType name]], [Located name]) > splitHsAppsTy = go [] [] [] > where > + go :: [LHsType name] > + -> [[LHsType name]] > + -> [Located name] > + -> [LHsAppType name] > + -> ([[LHsType name]], [Located name]) > go acc acc_non acc_sym [] = (reverse (reverse acc : acc_non), reverse acc_sym) > go acc acc_non acc_sym (L _ (HsAppPrefix ty) : rest) > = go (ty : acc) acc_non acc_sym rest > go acc acc_non acc_sym (L _ (HsAppInfix op) : rest) > = go [] (reverse acc : acc_non) (op : acc_sym) rest > + go acc acc_non acc_sym (L l (HsAppWild (L _ wc)) : rest) > + = go (L l (HsWildCardTy wc) : acc) acc_non acc_sym rest > > -- Retrieve the name of the "head" of a nested type application > -- somewhat like splitHsAppTys, but a little more thorough > @@ -1334,14 +1342,18 @@ ppr_fun_ty ctxt_prec ty1 ty2 > > -------------------------- > ppr_app_ty :: (OutputableBndrId name) => TyPrec -> HsAppType name -> SDoc > -ppr_app_ty _ (HsAppInfix (L _ n)) = pprInfixOcc n > +ppr_app_ty _ (HsAppInfix (L _ n)) > + = pprInfixOcc n > ppr_app_ty _ (HsAppPrefix (L _ (HsTyVar NotPromoted (L _ n)))) > = pprPrefixOcc n > ppr_app_ty _ (HsAppPrefix (L _ (HsTyVar Promoted (L _ n)))) > = space <> quote (pprPrefixOcc n) -- We need a space before the ' above, so > -- the parser does not attach it to the > -- previous symbol > -ppr_app_ty ctxt (HsAppPrefix ty) = ppr_mono_lty ctxt ty > +ppr_app_ty ctxt (HsAppPrefix ty) > + = ppr_mono_lty ctxt ty > +ppr_app_ty ctxt (HsAppWild (L _ (AnonWildCard _))) > + = empty -- FIXME > > -------------------------- > ppr_tylit :: HsTyLit -> SDoc > diff --git a/compiler/parser/Parser.y b/compiler/parser/Parser.y > index dfb6755..da4696a 100644 > --- a/compiler/parser/Parser.y > +++ b/compiler/parser/Parser.y > @@ -1833,6 +1833,7 @@ tyapp :: { LHsAppType RdrName } > [mj AnnSimpleQuote $1] } > | SIMPLEQUOTE varop {% ams (sLL $1 $> $ HsAppInfix $2) > [mj AnnSimpleQuote $1] } > + | '`' '_' '`' { sL1 $1 (HsAppWild (sL1 $1 (AnonWildCard PlaceHolder))) } > > atype :: { LHsType RdrName } > : ntgtycon { sL1 $1 (HsTyVar NotPromoted $1) } -- Not including unit tuples > diff --git a/compiler/rename/RnTypes.hs b/compiler/rename/RnTypes.hs > index f3fcf88..9298020 100644 > --- a/compiler/rename/RnTypes.hs > +++ b/compiler/rename/RnTypes.hs > @@ -1050,8 +1050,11 @@ collectAnonWildCards lty = go lty > > gos = mconcat . map go > > + prefix_types_only :: HsAppType Name -> Maybe (LHsType Name) > prefix_types_only (HsAppPrefix ty) = Just ty > prefix_types_only (HsAppInfix _) = Nothing > + prefix_types_only (HsAppWild (L l (AnonWildCard wc_name))) = > + Just (L l (HsWildCardTy (AnonWildCard wc_name))) > > collectAnonWildCardsBndrs :: [LHsTyVarBndr Name] -> [Name] > collectAnonWildCardsBndrs ltvs = concatMap (go . unLoc) ltvs > @@ -1646,8 +1649,9 @@ extract_apps t_or_k tys acc = foldrM (extract_app t_or_k) acc tys > > extract_app :: TypeOrKind -> LHsAppType RdrName -> FreeKiTyVars > -> RnM FreeKiTyVars > -extract_app t_or_k (L _ (HsAppInfix tv)) acc = extract_tv t_or_k tv acc > -extract_app t_or_k (L _ (HsAppPrefix ty)) acc = extract_lty t_or_k ty acc > +extract_app t_or_k (L _ (HsAppInfix tv)) acc = extract_tv t_or_k tv acc > +extract_app t_or_k (L _ (HsAppPrefix ty)) acc = extract_lty t_or_k ty acc > +extract_app t_or_k (L _ (HsAppWild (L l wc))) acc = extract_lty t_or_k (L l (HsWildCardTy wc)) acc > > extract_hs_tv_bndrs :: [LHsTyVarBndr RdrName] -> FreeKiTyVars > -> FreeKiTyVars -> RnM FreeKiTyVars > }}} > > Once I figure out how to do the `FIXME` part this patch may just work. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13088> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #11777: RTS source code issues
by GHC 25 Feb '18

25 Feb '18

#11777: RTS source code issues -------------------------------------+------------------------------------- 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: -------------------------------------+------------------------------------- Tiago Silva <tiagosilva(a)hush.com> writes: Last night I started looking at the C files used in GHC and noticed these issues: {{{ /driver/utils/cwrapper.c : int main(int, char **); }}} `void *p` is apparently unused, even if the compiler optimizes it away.. you should check if something went missing. {{{ /rts/RetainerProfile.c : static nat sanityCheckHeapClosure(StgClosure *) }}} `StgInfoTable *info` has the same issue as above {{{ /rts/RetainerSet.c #elif defined(RETAINER_SCHEME_CC) // Retainer scheme 3: retainer = cost centre void printRetainerSetShort(FILE *f, RetainerSet *rs, nat max_length) { char tmp[max_length + 1]; int size; nat j; } }}} Unlike the other functions around it, this function does nothing. Its variables are also not unused? {{{ /rts/sm/MarkWeak.c : void markWeakPtrList (void); if (w->header.info == &stg_DEAD_WEAK_info) { last_w = &(w->link); } else { last_w = &(w->link); } }}} Not sure what's going on here. Regardless of the test the two branches do the same thing. {{{ /rts/win32/IOManager.c : AddIORequest, AddDelayRequest, AddProcRequest functions }}} If `(!ioMan || !wItem)` the functions either return 0 or FALSE, but they don't free `wItem` before. Is this optimized by the compiler? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11777> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 13