- ghc-devs - Haskell.org

How do I add ghc-prim as a dep for ghc?
by Ömer Sinan Ağacan 27 Jun '18

27 Jun '18

I'm trying to add ghc-prim as a dependency to the ghc package. So far I've done these changes: diff --git a/compiler/ghc.cabal.in b/compiler/ghc.cabal.in index 01628dcad1..b9c3b3d02b 100644 --- a/compiler/ghc.cabal.in +++ b/compiler/ghc.cabal.in @@ -65,7 +65,8 @@ Library ghc-boot == @ProjectVersionMunged@, ghc-boot-th == @ProjectVersionMunged@, ghc-heap == @ProjectVersionMunged@, - ghci == @ProjectVersionMunged@ + ghci == @ProjectVersionMunged@, + ghc-prim if os(windows) Build-Depends: Win32 >= 2.3 && < 2.7 diff --git a/ghc.mk b/ghc.mk index c0b99c00f4..26c6e86c02 100644 --- a/ghc.mk +++ b/ghc.mk @@ -420,7 +420,8 @@ else # CLEANING # programs such as GHC and ghc-pkg, that we do not assume the stage0 # compiler already has installed (or up-to-date enough). -PACKAGES_STAGE0 = binary text transformers mtl parsec Cabal/Cabal hpc ghc-boot-th ghc-boot template-haskell ghc-heap ghci +PACKAGES_STAGE0 = binary text transformers mtl parsec Cabal/Cabal hpc \ + ghc-boot-th ghc-boot template-haskell ghc-heap ghci ghc-prim ifeq "$(Windows_Host)" "NO" PACKAGES_STAGE0 += terminfo endif But I'm getting this error: ghc-cabal: Encountered missing dependencies: ghc-prim ==0.5.3 Any ideas what else to edit? Thanks, Ömer

2 3

Update on HIE Files
by Zubin Duggal 27 Jun '18

27 Jun '18

Hello all, I've been working on the HIE File ( https://ghc.haskell.org/trac/ghc/wiki/HIEFiles) GSOC project, The design of the data structure as well as the traversal of GHCs ASTs to collect all the relevant info is mostly complete. We traverse the Renamed and Typechecked AST to collect the following info about each SrcSpan 1) Its type, if it corresponds to a binding, pattern or expression 2) Details about any tokens in the original source corresponding to this span(keywords, symbols, etc.) 3) The set of Constructor/Type pairs that correspond to this span in the GHC AST 4) Details about all the identifiers that occur at this SrcSpan For each occurrence of an identifier(Name or ModuleName), we store its type(if it has one), and classify it as one of the following based on how it occurs: 1) Use 2) Import/Export 3) Pattern Binding, along with the scope of the binding, and the span of the entire binding location(including the RHS) if it occurs as part of a top level declaration, do binding or let/where binding 4) Value Binding, along with whether it is an instance binding or not, its scope, and the span of its entire binding site, including the RHS 5) Type Declaration (class or regular) (foo :: ...) 6) Declaration(class, type, instance, data, type family etc.) 7) Type variable binding, along with its scope(which takes into account ScopedTypeVariables) I have updated the wiki page with more details about the Scopes associated with bindings: https://ghc.haskell.org/trac/ghc/wiki/HIEFiles#Scopeinformationaboutsymbols These annotated SrcSpans are then arranged into a interval/rose tree to aid lookups. We assume that no SrcSpans ever partially overlap, for any two SrcSpans that occur in the Renamed/Typechecked ASTs, either they are equal, disjoint, or strictly contained in each other. This assumption has mostly held out so far while testing on the entire ghc:HEAD tree, other than one case where the typechecker strips out parenthesis in the original source, which has been patched(see https://ghc.haskell.org/trac/ghc/ticket/15242) I have also written functions that lookup the binding site(including RHS) and scope of an identifier from the tree. Testing these functions on the ghc:HEAD tree, it succeeds in looking up scopes for almost all symbol occurrences in all source files, and I've also verified that the calculated scope always contains all the occurrences of the symbol. The few cases where this check fails is where the SrcSpans have been mangled by CPP(see https://ghc.haskell.org/trac/ghc/ticket/15279) The code for this currently lives here: https://github.com/haskell/haddock/compare/ghc-head...wz1000:hiefile-2 Moving forward, the plan for the rest of the summer is 1) Move this into the GHC tree and add a flag that controls generating this 2) Write serializers and deserializers for this info 3) Teach the GHC PackageDb about .hie files 4) Rewrite haddocks --hyperlinked-source to use .hie files.

3 3

Tracking down instances from use-sites
by Christopher Done 26 Jun '18

26 Jun '18

Hi all, Given a TypecheckedModule, what's the most direct way given a Var expression retrieved from the AST, to determine: 1) that it's a class method e.g. `read` 2) that it's a generic call (no instance chosen) e.g. `Read a => a -> String` 3) or if it's a resolved instance, then which instance is it and which package, module and declaration is that defined in? Starting with this file that has a TypecheckedModule in it: https://gist.github.com/chrisdone/6fcb9f1cba6324148d481fcd4eab6af6#file-ghc… I presume at this point that instance resolution has taken place. I'm not sure that dictionaries or chosen instances are inserted into the AST, or whether just the resolved types are inserted e.g. `Int -> String`, where I want e.g. `Read Int`, which might lead me to finding the matching instance from an InstEnv or so. I'd like to do some analyses of Haskell codebases, and the fact that calls to class methods are opaque is a bit of a road-blocker. Any handy tips? Prior work? It'd be neat in tooling to just hit a goto-definition key on `read` and be taken to the instance implementation rather than the class definition. Also, listing all functions that use throw# or functions defined in terms of throw# or FFI calls would be helpful, especially for doing audits. If I could immediately list all partial functions in a project, then list all call-sites, it would be a very convenient way when doing an audit to see whether partial functions (such as head) are used with the proper preconditions or not. Any tips appreciated, Chris

3 5

Literature Review of GHC Core
by Ningning Xie 26 Jun '18

26 Jun '18

Hi all, I was recently doing some GHC Core related stuff, and I found that it might be useful to have a theoretical understanding of the type system for writing better practical code. Therefore I started to read papers about GHC Core, or System FC, following the publication timeline, to try to understand each design choice involved in the type system. I wrote a simple literature review that I think might be useful for people like me. If you're thinking about learning System FC, you might find it helpful: https://github.com/xnning/GHC-Core-Literature-Review/blob/master/doc/doc.pdf Feedbacks are welcome. Best, Ningning

2 1

RE: Strace
by Simon Peyton Jones 26 Jun '18

26 Jun '18

Great. https://ghc.haskell.org/trac/ghc/ticket/15313#ticket is created. I don’t know how to force them to be “cpu multirace on windows”. If you could do that sometime it’d be great. No rush. Thank you! Simon From: Phyx <lonetiger(a)gmail.com> Sent: 26 June 2018 06:01 To: Simon Peyton Jones <simonpj(a)microsoft.com> Subject: Re: Strace Hi Simon, Thanks for the log, that does give a clue. The command fails with setup.exe: 'C:/code/HEAD/inplace/bin/ghc-pkg.exe' exited with an error: ... rule-defining-plugin-0.1: cannot find any of ["libHSrule-defining-plugin-0.1-GxqqrdsQ5NRK9hAhEkvz8Z.a","libHSrule-defining-plugin-0.1-GxqqrdsQ5NRK9hAhEkvz8Z.p_a","libHSrule-defining-plugin-0.1-GxqqrdsQ5NRK9hAhEkvz8Z-ghc8.5.20180616.so<https://na01.safelinks.protection.outlook.com/?url=http%3A%2F%2FlibHSrule-d…>","libHSrule-defining-plugin-0.1-GxqqrdsQ5NRK9hAhEkvz8Z-ghc8.5.20180616.dylib","HSrule-defining-plugin-0.1-GxqqrdsQ5NRK9hAhEkvz8Z-ghc8.5.20180616.dll"] on library path (use --force to override) make[2]: *** [Makefile:18: package.T10420] Error 1 so it's the `setup install` from https://github.com/ghc/ghc/blob/c2783ccf545faabd21a234a4dfc569cd856082b9/te…<https://na01.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.com…> failing. unfortunately, all those tests run with -v0 which is annoying because now the verbosity of the testsuite doesn't control that of these tests. I'm not sure why these commands fail under heavy load though. I'll need to dive into the source of ghc-pkg to figure out what's happening. Notice that all the framework failures are these plugin tests which modify a package database. A wild guess is that ghc-pkg tries to take a lock on all package-databases or something when it's mutating one. But I'm not intimately familiar with the package store and this doesn't explain why it doesn't happen on Linux. for now one solution I can propose is to create a ticket to track these and mark these tests as cpu multirace on Windows, which will force them to run sequentially. I'll try to take a look at ghc-pkg this week and if I don't figure anything out I'll force the tests sequential on the short term. Cheers, Tamar On Mon, Jun 25, 2018 at 4:08 AM, Simon Peyton Jones <simonpj(a)microsoft.com<mailto:simonpj@microsoft.com>> wrote: Tamar I tried this TEST_VERBOSITY="VERBOSE=3" sh validate --fast --no-clean >& log in the root directory. I get the framework failures, but I’m not sure the verbosity-control worked. Log attached SImon

2 1

GHC API question: resolving dependencies for modules
by Dmitriy Kovanikov 26 Jun '18

26 Jun '18

Hello! I’m trying to use GHC as a library. And my goal is to be able to gather information about where each function or data type came from. I’ve started by simply calling `getNamesInScope` function and observing its result. Here is my code: * Main.hs: https://lpaste.net/9026688686753841152 <https://lpaste.net/9026688686753841152> And here is the code for my test modules: * test/X.hs: https://lpaste.net/6844657232357883904 <https://lpaste.net/6844657232357883904> * test/Y.hs: https://lpaste.net/8673289058127970304 <https://lpaste.net/8673289058127970304> Unfortunately, my implementation doesn't work since I’m not very familiar with GHC API. And I see the following errors after executing my `Main.hs` file (I’m using ghc-8.2.2): * error messages: https://lpaste.net/3316737208131518464 <https://lpaste.net/3316737208131518464> Could you please point me to places or parts of GHC API or some documentation about module dependencies and how to make ghc see imports of other modules? I can’t find simple and small enough usage example of this part of the library. Thanks in advance, Dmitrii Kovanikov

4 5

Scavenging SRTs in scavenge_one
by Ben Gamari 26 Jun '18

26 Jun '18

Hi Simon, I'm a bit confused by scavenge_one; namely it doesn't scavenge SRTs. It appears that it is primarily used for remembered set entries but it's not at all clear why this means that we can safely ignore SRTs (e.g. in the FUN and THUNK cases). Can you shed some light on this? Cheers, - Ben

3 10

Can a TC plugin create new skolem vars when simplifying Givens?
by Nicolas Frisby 24 Jun '18

24 Jun '18

I'm still spending the occasional weekend working on a type checker plugin for row types (actually "set" types at first, but I haven't thought of a less ambiguous term for that). One point of complexity in the plugin has to do with creating fresh variables when simplifying Givens. Some constraints are traditionally simplified by introducing a fresh variable. For Wanted constraints, that's easy (newFlexiTyVar). For Givens, though, I haven't figured out how to do it. This email is just to ask these two questions: 1) Is there a function to add a new skolem variable when simplifying Givens? 2) Assuming not, is there a strong reason for there to never be such a function? Here's a small indicative example. In the "simplify Givens" step, the plugin receives [G] (p `Union` Singleton A) ~ (q `Union` Singleton B) and I would ideally simplify that to [G] p ~ (x `Union` Singleton B) [G] q ~ (x `Union` Singleton A) for some fresh skolem variable x. But I don't see how to properly create a fresh skolem variable in the Givens. If these were Wanteds, I would just use newFlexiTyVar. I think this is analogous to a hypothetical type checker plugin that eta expands tuples. If we were to simplify [G] ... (x :: (k1,k2)) ... to [G] ... '(x1 :: k1,x2 :: k2) ... we'd have to generate x1 and x2 somehow. The only method I'm aware of for that is to use Fst x and Snd x instead (ie type families). That might be acceptable for the tuple expansion example, but I'm very reticent to use something like that for the set types plugin. I have a plan to get by without creating these variables when simplifying Givens, but it's not simple. I'd be delighted if it were possible to create them. Hence my two questions listed above. Thank you for your time. -Nick

1 0

atomicWriteIORef
by David Feuer 22 Jun '18

22 Jun '18

Currently, atomicWriteIORef is implemented using atomicModifyIORef. That seems pretty heavy for the job, allocating closures and forcing thunks. Is there a reason not to do it with casMutVar#?

2 1

Plan for GHC 8.6.1
by Ben Gamari 22 Jun '18

22 Jun '18

Hello fellow lazy purists, With GHC 8.4.2 out the door, it is time to begin looking forward to 8.6.1. In keeping with our six-month release schedule, this release will be targetted for early-September, with the stable branch being cut in mid-to-late June. Remarkably, this is only 6 weeks away. If you have patches that you would like to see in 8.6.1, please do put them up on Phabricator and the 8.6.1 status page [1] in the coming weeks to ensure that there is sufficient time for review. If you have a patch which you are concerned won't make the cut-off, do say something. Cheers, - Ben [1] https://ghc.haskell.org/trac/ghc/wiki/Status/GHC-8.6.1

4 4