December 2017 - ghc-tickets

[GHC] #9840: Permit empty closed type families
by GHC 18 May '18

18 May '18

#9840: Permit empty closed type families -------------------------------------+------------------------------------- Reporter: adamgundry | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler (Type | Version: 7.8.3 checker) | Operating System: Keywords: | Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: Difficulty: Unknown | None/Unknown Blocked By: | Test Case: Related Tickets: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- At the moment, closed type families without any equations fail with a parse error. In addition, they cannot be created by TH (see #8028). Would it be possible to permit these instead? My use case is in my typechecker plugin for units of measure, where I want to add new type-level operators without any equational theory (because it will be supplied by the plugin) and without users having the ability to introduce their own type family instances. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9840> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 13

[GHC] #12780: Calling "do nothing" type checker plugin affects type checking when it shouldn't
by GHC 18 May '18

18 May '18

#12780: Calling "do nothing" type checker plugin affects type checking when it shouldn't -------------------------------------+------------------------------------- Reporter: clinton | 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 has been compiled against ghc version 8.1.20161022, my apologies if this bug has already been fixed. The following program compiles fine: {{{#!hs {-# LANGUAGE TypeFamilyDependencies #-} {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE ConstraintKinds #-} main :: IO () main = return () type family F p = t | t -> p type IsF p t = (C p, t ~ F p) class C p where f :: (IsF p t) => t f = undefined g :: (IsF p t) => t g = f }}} But if we define a "do nothing" type checker plugin like so: {{{#!hs {-# OPTIONS_GHC -dynamic-too #-} module MyPlugin (plugin) where import Plugins ( Plugin(tcPlugin), defaultPlugin, tcPlugin ) import TcRnTypes ( TcPlugin(TcPlugin), tcPluginInit, tcPluginSolve, tcPluginStop, TcPluginSolver, TcPluginResult(TcPluginContradiction, TcPluginOk) ) plugin :: Plugin plugin = defaultPlugin { tcPlugin = const (Just myPlugin) } myPlugin :: TcPlugin myPlugin = TcPlugin { tcPluginInit = return (), tcPluginSolve = const solver, tcPluginStop = const (return ()) } solver :: TcPluginSolver solver _ _ _ = return $ TcPluginOk [] [] }}} And call it from our original source file by adding: {{{#!hs {-# OPTIONS_GHC -fplugin MyPlugin #-} }}} We get the following error: {{{ pluginbug.hs:18:5: error: • Could not deduce (C p0, t ~ F p0) arising from a use of ‘f’ from the context: IsF p t bound by the type signature for: g :: IsF p t => t at pluginbug.hs:17:1-19 The type variable ‘p0’ is ambiguous Relevant bindings include g :: t (bound at pluginbug.hs:18:1) • In the expression: f In an equation for ‘g’: g = f }}} Note that not just calling my "do nothing" type checking plugin does this, to be sure, instead I called `ghc-typelits-natnormalise` like so: {{{#!hs {-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise #-} }}} And the same error results. One solution is to remove `(C p)` from the `IsF` type declaration, and instead adding it to `g`s definition, like so: {{{#!hs --type IsF p t = (C p, t ~ F p) type IsF p t = (t ~ F p) --g :: (IsF p t) => t g :: (C p, IsF p t) => t }}} But I'm unsure why this should be necessary, and I certainly don't think this should only be necessary if one calls a type checker plugin. Note that the error requires a type checking plugin to be called, if one does not override `defaultPlugin` like so: {{{#!hs plugin = defaultPlugin { tcPlugin = const (Just myPlugin) } }}} and instead just does: {{{#!hs plugin = defaultPlugin }}} then the issue will not occur. So in summary, it seems that calling a type checking plugin somehow affects ordinary type checking. I don't think this should happen. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12780> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #10078: tcPluginStop of a type checker plugin is not called if an error occurs
by GHC 18 May '18

18 May '18

#10078: tcPluginStop of a type checker plugin is not called if an error occurs -------------------------------------+------------------------------------- Reporter: jbracker | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.11 (Type checker) | Operating System: Linux Keywords: | Type of failure: Incorrect result Architecture: x86_64 | at runtime (amd64) | Blocked By: Test Case: | Related Tickets: Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- When a module using a type checker plugin produces a compiler error the clean up function `tcPluginStop` of the plugin is not called. I am not sure if this is intended, but according to the description of the wiki page (Plugins/TypeChecker) this should always be called. === Test plugin `MyPlugin.hs`: {{{#!hs module MyPlugin ( plugin ) where import Plugins import TcRnTypes import TcPluginM plugin :: Plugin plugin = defaultPlugin { tcPlugin = \clos -> Just $ TcPlugin { tcPluginInit = tcPluginIO $ putStrLn ">>> Plugin Init" , tcPluginSolve = \_ _ _ _ -> do tcPluginIO $ putStrLn ">>> Plugin Solve" return $ TcPluginOk [] [] , tcPluginStop = \_ -> tcPluginIO $ putStrLn ">>> Plugin Stop" } } }}} === Minimal example (with type error) `Main.hs`: {{{#!hs {-# OPTIONS_GHC -fplugin MyPlugin #-} module Main where main :: (Monad m) => m () main = do return 1 }}} Compiling this will lead to the following output: {{{ $ ~/ghc/inplace/bin/ghc-stage2 --make -package ghc-7.11.20150209 -dynamic Main.hs [2 of 2] Compiling Main ( Main.hs, Main.o ) >>> Plugin Init >>> Plugin Solve >>> Plugin Solve >>> Plugin Solve Main.hs:6:10: Could not deduce (Num ()) arising from the literal ‘1’ from the context: Monad m bound by the type signature for: main :: Monad m => m () at Main.hs:4:9-25 In the first argument of ‘return’, namely ‘1’ In a stmt of a 'do' block: return 1 In the expression: do { return 1 } }}} Which means `tcPluginStop` was _not_ called. === Minimal example (without type error) `Main.hs`: {{{#!hs {-# OPTIONS_GHC -fplugin MyPlugin #-} module Main where main :: (Monad m) => m () main = do return () }}} Compiling this will lead to the following output: {{{ $ ~/ghc/inplace/bin/ghc-stage2 --make -package ghc-7.11.20150209 -dynamic Main.hs [2 of 2] Compiling Main ( Main.hs, Main.o ) [MyPlugin changed] >>> Plugin Init >>> Plugin Solve >>> Plugin Solve >>> Plugin Stop Linking Main ... }}} Which means `tcPluginStop` _was_ called. === Possible solution As far as I can see, the solution to this should be to change the plugin code at the bottom of `typechecker/TcRnDriver.hs` from {{{#!hs withTcPlugins :: HscEnv -> TcM a -> TcM a withTcPlugins hsc_env m = do plugins <- liftIO (loadTcPlugins hsc_env) case plugins of [] -> m -- Common fast case _ -> do (solvers,stops) <- unzip `fmap` mapM startPlugin plugins res <- updGblEnv (\e -> e { tcg_tc_plugins = solvers }) m mapM_ runTcPluginM stops return res where startPlugin (TcPlugin start solve stop) = do s <- runTcPluginM start return (solve s, stop s) }}} to {{{#!hs withTcPlugins :: HscEnv -> TcM a -> TcM a withTcPlugins hsc_env m = do plugins <- liftIO (loadTcPlugins hsc_env) case plugins of [] -> m -- Common fast case _ -> do (solvers,stops) <- unzip `fmap` mapM startPlugin plugins eitherRes <- tryM $ do updGblEnv (\e -> e { tcg_tc_plugins = solvers }) m mapM_ runTcPluginM stops case eitherRes of Left e -> failM Right res -> return res where startPlugin (TcPlugin start solve stop) = do s <- runTcPluginM start return (solve s, stop s) }}} . I have tried this. It compiles and my minimal example delivers the correct result. Are there any arguments against this change? If not, I would try to commit a patch for this problem sometime this weekend. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10078> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #11462: Use of typechecker plugin erroneously triggers "unbound implicit parameter" error
by GHC 18 May '18

18 May '18

#11462: Use of typechecker plugin erroneously triggers "unbound implicit parameter" error -------------------------------------+------------------------------------- Reporter: kwf | Owner: Type: bug | Status: new Priority: high | Milestone: 8.0.1 Component: Compiler | Version: 7.10.3 (Type checker) | 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: -------------------------------------+------------------------------------- To document this bug, we're going to need a typechecker plugin to test it with. I've built a dummy plugin for this purpose, so we can be sure it is not interference from a particular plugin. {{{dummy-plugin/dummy-plugin.cabal}}} {{{ name: dummy-plugin version: 0.1.0.0 category: Development build-type: Simple cabal-version: >=1.10 library hs-source-dirs: . exposed-modules: DummyPlugin build-depends: base, ghc default-language: Haskell2010 GHC-options: -Wall -O2 }}} {{{dummy-plugin/DummyPlugin.hs}}} {{{#!hs module DummyPlugin(plugin) where import TcRnMonad ( TcPlugin(..), TcPluginResult(..) ) import Plugins ( defaultPlugin, Plugin(..), CommandLineOption ) plugin :: Plugin plugin = defaultPlugin { tcPlugin = Just . thePlugin } thePlugin :: [CommandLineOption] -> TcPlugin thePlugin opts = TcPlugin { tcPluginInit = return () , tcPluginSolve = \_ _ _ _ -> return $ TcPluginOk [] [] , tcPluginStop = \_ -> return () } }}} {{{Bug.hs}}} {{{#!hs {-# OPTIONS_GHC -fplugin=DummyPlugin #-} module Bug where impossible :: a impossible = undefined }}} First, compile the dummy plugin. From its directory, run {{{cabal install}}} to install the plugin. Then, from the main directory, run {{{ghc Bug.hs}}}. Expected result: the file compiles. Actual result: {{{ Bug.hs:6:14: error: • Unbound implicit parameter ?callStack::GHC.Stack.Types.CallStack arising from a use of implicit parameter ‘?callStack’ • In the expression: undefined In an equation for ‘impossible’: impossible = undefined }}} Further, observe that commenting out the line which invokes the type- checker plugin (the pragma on line 1) causes the file to compile correctly. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11462> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #11525: Using a dummy typechecker plugin causes an ambiguity check error
by GHC 18 May '18

18 May '18

#11525: Using a dummy typechecker plugin causes an ambiguity check error -------------------------------------+------------------------------------- Reporter: jme | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1-rc1 (Type checker) | 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 variation on [[GhcFile(testsuite/tests/typecheck/should_compile/T10009.hs)]] compiles cleanly: {{{#!hs {-# LANGUAGE TypeFamilies, ScopedTypeVariables #-} {-# OPTIONS_GHC -fno-warn-redundant-constraints #-} module T10009WithClass where type family F a type family UnF a class (UnF (F b) ~ b) => C b where f :: F b -> () g :: forall a. (C a) => a -> () g _ = f (undefined :: F a) }}} But compiling it with the dummy typechecker plugin [[GhcFile(testsuite/tests/typecheck/should_compile/T11462_Plugin.hs)]] yields {{{ $ ghc -dynamic -c T11462_Plugin.hs $ ghc -fplugin=T11462_Plugin -dynamic -c T10009WithClass.hs T10009WithClass.hs:10:5: error: - Could not deduce: F b0 ~ F b from the context: C b bound by the type signature for: f :: C b => F b -> () at T10009WithClass.hs:10:5-18 NB: 'F' is a type function, and may not be injective The type variable 'b0' is ambiguous Expected type: F b -> () Actual type: F b0 -> () - In the ambiguity check for 'f' To defer the ambiguity check to use sites, enable AllowAmbiguousTypes When checking the class method: f :: forall b. C b => F b -> () In the class declaration for 'C' }}} Superficially, the problem is that the presence of the plugin causes `runTcPluginsWanted` to zonk the pending superclass constraint, changing it to a `CNonCanonical`. This in turn prevents `solveWanteds` from making any further progress (which ultimately leads to the error): {{{ getUnsolvedInerts tv eqs = {[W] hole{aIO} :: s_aIL[fuv:2] GHC.Prim.~# fsk_aIC[fsk] (CTyEqCan)} fun eqs = {[W] hole{aIM} :: F b_aIu[tau:3] GHC.Prim.~# s_aIL[fuv:2] (CFunEqCan)} insols = {} others = {[W] $dC_aIv :: C b_aIu[tau:3] (CDictCan(psc))} <===== BEFORE plugin implics = {} Unflattening {Funeqs = [W] hole{aIM} :: F b_aIu[tau:3] GHC.Prim.~# s_aIL[fuv:2] (CFunEqCan) Tv eqs = [W] hole{aIO} :: s_aIL[fuv:2] GHC.Prim.~# fsk_aIC[fsk] (CTyEqCan)} Filling coercion hole aIM := <F b_aIu[tau:3]>_N unflattenFmv s_aIL[fuv:2] := F b_aIu[tau:3] writeMetaTyVar s_aIL[fuv:2] :: * := F b_aIu[tau:3] Unflattening 1 {} Unflattening 2 {[W] hole{aIO} :: s_aIL[fuv:2] GHC.Prim.~# fsk_aIC[fsk] (CTyEqCan)} Unflattening 3 {} Unflattening done {[W] hole{aIO} :: s_aIL[fuv:2] GHC.Prim.~# fsk_aIC[fsk] (CNonCanonical)} zonkSimples done: {[W] hole{aIO} :: F b_aIu[tau:3] GHC.Prim.~# F b_aIs[sk] (CNonCanonical)} zonkSimples done: {[W] $dC_aIv :: C b_aIu[tau:3] (CNonCanonical), <===== AFTER plugin [W] hole{aIO} :: F b_aIu[tau:3] GHC.Prim.~# F b_aIs[sk] (CNonCanonical)} solveSimples end } iterations = 1 residual = WC {wc_simple = [W] $dC_aIv :: C b_aIu[tau:3] (CNonCanonical) [W] hole{aIO} :: F b_aIu[tau:3] GHC.Prim.~# F b_aIs[sk] (CNonCanonical)} solveWanteds } }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11525> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 15

[GHC] #11457: Run type-checker plugins before GHC's solver
by GHC 18 May '18

18 May '18

#11457: Run type-checker plugins before GHC's solver -------------------------------------+------------------------------------- Reporter: gridaphobe | Owner: Type: feature | Status: new request | Priority: normal | Milestone: 8.0.1 Component: Compiler | Version: 8.0.1-rc1 (Type checker) | Keywords: plugin | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Here's an odd use-case for type-checker plugins: rejecting ''valid'' programs that the user doesn't like, for example, programs that use a class instance with confusing behavior (like the functor/traversable instances on tuples). Unfortunately, we can't write such a plugin at the moment because GHC runs its own solver first, and will (I think) discharge any dictionary constraints before the plugin can run. If instead we run the plugins first, a plugin could mark undesired instances as insoluble. See the discussion at http://mail.haskell.org/pipermail/libraries/2016-January/026602.html for the original motivation. Thoughts? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11457> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #10077: Providing type checker plugin on command line results in false cyclic import error
by GHC 18 May '18

18 May '18

#10077: Providing type checker plugin on command line results in false cyclic import error -------------------------------------+------------------------------------- Reporter: jbracker | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.11 (Type checker) | Operating System: Linux Keywords: | Type of failure: Incorrect typechecker plugin cycle imports | warning at compile-time Architecture: x86_64 | Blocked By: (amd64) | Related Tickets: Test Case: | Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- I am playing around with the new type checker plugins using the current development branch of GHC. When I supply the plugin module to GHC through the command line I get a cyclic import error message, which I think is false. If I supply the same plugin module using a pragma I do not get an error message. === Minimal Example (Command Line) `MyPlugin.hs`: {{{#!hs module MyPlugin ( plugin ) where import Plugins ( Plugin, defaultPlugin ) plugin :: Plugin plugin = defaultPlugin }}} `Test.hs`: {{{#!hs module Test where main :: IO () main = return () }}} Command line call of GHC: {{{ ~/ghc/inplace/bin/ghc-stage2 \ --make -package ghc-7.11.20150209 \ -fplugin=MyPlugin \ Test.hs }}} Results in the following error {{{ Module imports form a cycle: module ‘MyPlugin’ (./MyPlugin.hs) imports itself }}} which does not seem reasonable to me understand. === Minimal example (pragma) On the other hand, if I change `Test.hs` to the following {{{#!hs {-# OPTIONS_GHC -fplugin MyPlugin #-} module Test where main :: IO () main = return () }}} and calling GHC like this {{{ ~/ghc/inplace/bin/ghc-stage2 \ --make \ -package ghc-7.11.20150209 \ -dynamic \ Test.hs }}} it works. I did not change `MyPlugin.hs`. === Note 1. Using `-fplugin=MyPlugin` vs. `-fplugin MyPlugin` does not make a difference. 1. The command line example behaves the same independent of whether I supply the `-dynamic` flag or not. 1. I had to add the `-dynamic` flag, because otherwise GHC will complain that: {{{ <no location info>: cannot find normal object file ‘./MyPlugin.dyn_o’ while linking an interpreted expression }}} This might be a long shot, but maybe using the `-fplugin` option should imply the `-dynamic` flag? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10077> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 11

[GHC] #11435: Evidence from TC Plugin triggers core-lint warning
by GHC 18 May '18

18 May '18

#11435: Evidence from TC Plugin triggers core-lint warning -------------------------------------+------------------------------------- Reporter: jbracker | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 Keywords: core-lint | Operating System: Linux warning evidence type-checker | plugin | Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The attached plugin and program produce a core-lint warning that refers to evidence the plugin did not produce. == High-Level description of what the plugin does and what happens 'flatFilter' produces the following ambiguous wanted constraints: {{{ Polymonad (Reader '["thres" :-> Int]) n (Reader '["thres" :-> Int]) (CNonCanonical) Polymonad (Reader '["thres" :-> Int]) m n (CNonCanonical) Polymonad Identity Identity m }}} To solve these the plugin does the following: 1. It produces two type equality constraints: {{{ n ~ Identity (CNonCanonical) m ~ Reader '["thres" :-> Int] (CNonCanonical) }}} 2. As a result of these equality constraints the GHC constraint solver creates the following wanted constraint: {{{ Polymonad (Reader '["thres" :-> Int]) Identity (Reader '["thres" :-> Int]) (CNonCanonical) }}} GHCs constraint solver can not pick an instance because several instances overlap: {{{ P.Monad f => Polymonad f Identity f ( Effect m, E.Inv m f (Unit m), f ~ Plus m f (Unit m)) => Polymonad (m (f :: [*])) Identity (m (f :: [*])) }}} By trying to produce evidence for either of these instances the plugin determines that only the second instance is actually applicable and therefore selects it and produces evidence. With this the constraints are solved and the type checking/constraint solving stage is done. During core linting we get the following error: {{{ *** Core Lint errors : in result of Simplifier *** <no location info>: Warning: [RHS of ds_a66V :: (Set '["thres" :-> Int], Set (Unit Reader))] Bad getNth: Nth:0 (Nth:2 (Sub (Sym (TFCo:R:Inv[]Readerfg[0] <'["thres" :-> Int]>_N <'[]>_N)) ; (Inv <Reader>_N <'["thres" :-> Int]>_N (Sym TFCo:R:Unit[]Reader[0]))_R ; Sub (TFCo:R:Inv[]Readerfg[0] <'["thres" :-> Int]>_N <Unit Reader>_N))) Split '["thres" :-> Int] '[] (Union '["thres" :-> Int] '[]) Split '["thres" :-> Int] (Unit Reader) (Union '["thres" :-> Int] (Unit Reader)) }}} As can be seen in the plugin [Check for 'Nth' constructor] the evidence produced by the plugin does not contain the 'Nth' constructor for coercions/evidence anywhere. Thus, the produced evidence seems to trigger GHC to produce these 'bad' coercions/evidence somewhere. == Building the Example The example should be self-contained and reproduces the error whenever you try to build it. You can find it here or in the attachment: https://github.com/jbracker/polymonad-plugin/tree/master/examples/core- error You just have to download the three files and run "cabal install" to reproduce the error. There is a high-level explanation of what is going on above and in the 'Main.hs' from line 83. The plugin 'MinimalPlugin.hs' is still around 600 lines long, but I have added a lot of comments to make it comprehensible. I suppose the most interesting part is the production of evidence in 'MinimalPlugin.hs' from line 198. I have added checks to see if the evidence I produce contains the 'Nth' constructors the core-lint warning refers to in line 130 and 556 of the plugin, but the evidence produced does not contain them. So somehow the evidence triggers GHC to produce evidence that the core-linter warns about. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11435> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #14574: Template Haskell Uniq ~ Int leads to external interpreter cross compilation trouble
by GHC 17 May '18

17 May '18

#14574: Template Haskell Uniq ~ Int leads to external interpreter cross compilation trouble -------------------------------------+------------------------------------- Reporter: luite | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.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: -------------------------------------+------------------------------------- 64 bit GHC has 64 bit Unique values, but they don't fit in a `template- haskell` `NameU` when cross-compiling to a 32 bit target. In theory we can support Template Haskell in this situation with `-fexternal-interpreter` (and the earlier GHCJS implementation), but when the target cannot represent GHC's uniques in an `Int`, things go wrong: from `Language.Haskell.TH.Syntax`: {{{#!hs type Uniq = Int }}} I think we can fix this for now by changing the synonym to `type Uniq = Int64` (or even `type Uniq = Integer`), making the `template-haskell` `Uniq` at least as big as the GHC `Unique` in practice. This requires a change in `DsMeta`. the uses of `Int` below should really be changed to `Uniq` {{{#!hs data NameFlavour = NameS -- ^ An unqualified name; dynamically bound | NameQ ModName -- ^ A qualified name; dynamically bound | NameU !Int -- ^ A unique local name | NameL !Int -- ^ Local name bound outside of the TH AST | NameG NameSpace PkgName ModName -- ^ Global name bound outside of the TH AST: -- An original name (occurrences only, not binders) -- Need the namespace too to be sure which -- thing we are naming deriving ( Data, Eq, Ord, Show, Generic ) }}} {{{#!hs -- Global variable to generate unique symbols counter :: IORef Int {-# NOINLINE counter #-} counter = unsafePerformIO (newIORef 0) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14574> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #11774: Regression on GHC 8 branch (vs 7.10.3) when using the GHC API to parse code that uses TH
by GHC 17 May '18

17 May '18

#11774: Regression on GHC 8 branch (vs 7.10.3) when using the GHC API to parse code that uses TH ----------------------------------------+--------------------------------- Reporter: SimonHengel | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1-rc2 Keywords: | Operating System: Linux Architecture: Unknown/Multiple | Type of failure: None/Unknown Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: ----------------------------------------+--------------------------------- If you use the GHC API to parse code that uses TH, the code does not work after a {{{:reload}}} in {{{ghci}}} anymore. = Steps to reproduce Given the following three modules {{{#!hs module Extract where import Prelude hiding (mod) import Data.Generics import DynFlags import FastString import GHC import GHC.Paths import Control.Monad import Digraph (flattenSCCs) extractDocStrings :: IO [String] extractDocStrings = do concatMap (extract . pm_parsed_source . tm_parsed_module) <$> do runGhc (Just libdir) $ do _ <- getSessionDynFlags >>= setSessionDynFlags . setHaddockMode guessTarget "Foo.hs" Nothing >>= setTargets . return mods <- depanal [] False >>= enableCompilation let sortedMods = flattenSCCs (topSortModuleGraph False mods Nothing) mapM (parseModule >=> typecheckModule >=> loadModule) sortedMods where setHaddockMode :: DynFlags -> DynFlags setHaddockMode dynflags = (gopt_set dynflags Opt_Haddock) extract :: ParsedSource -> [String] extract m = [unpackFS s | HsDocString s <- everything (++) ([] `mkQ` return) m] enableCompilation :: ModuleGraph -> Ghc ModuleGraph enableCompilation modGraph = do let enableComp d = let platform = targetPlatform d in d { hscTarget = defaultObjectTarget platform } modifySessionDynFlags enableComp let upd m = m { ms_hspp_opts = enableComp (ms_hspp_opts m) } let modGraph' = map upd modGraph return modGraph' modifySessionDynFlags :: (DynFlags -> DynFlags) -> Ghc () modifySessionDynFlags f = do dflags <- getSessionDynFlags let dflags' = case lookup "GHC Dynamic" (compilerInfo dflags) of Just "YES" -> gopt_set dflags Opt_BuildDynamicToo _ -> dflags _ <- setSessionDynFlags (f dflags') return () }}} {{{#!hs {-# LANGUAGE TemplateHaskell #-} module Foo where import Bar -- | some documentation foo :: Int foo = $(bar) }}} {{{#!hs {-# LANGUAGE TemplateHaskell #-} module Bar where bar = [|23|] }}} == Expected (GHC 7.10.2 behavior) {{{ $ ghci Extract.hs GHCi, version 7.10.2: http://www.haskell.org/ghc/ :? for help *Extract> extractDocStrings [" some documentation"] *Extract> :reload *Extract> extractDocStrings [" some documentation"] }}} == Actual (GHC 8.0.0.20160329 behavior) {{{ $ ghci Extract.hs GHCi, version 8.0.0.20160329: http://www.haskell.org/ghc/ :? for help *Extract> extractDocStrings [" some documentation"] *Extract> :reload *Extract> extractDocStrings /tmp/ghc24970_1/libghc_7.so: file not recognized: File truncated collect2: error: ld returned 1 exit status *** Exception: `gcc' failed in phase `Linker'. (Exit code: 1) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11774> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4