#11078: Access to module renaming with reifyModule, in TemplateHaskell -------------------------------------+------------------------------------- Reporter: cipher1024 | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Template Haskell | Version: 7.10.2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by jstolarek: Old description:

I am writing a bit of TemplateHaskell for stringing together QuickCheck style specifications. I require every module containing properties to export a symbol called ''axiom_set''. Then, my checkAxioms function finds all the ''axiom_set'' symbols from modules imported where I call checkAxioms.

checkAxioms :: DecsQ checkAxioms = do ModuleInfo ms <- reifyModule =<< thisModule forM_ ms $ \mi@(Module _ m) -> do runIO . print =<< lookupValueName (modString m ++ ".axiom_set")

The above code should find all the imported "axiom_set" symbols. However, if Module.Axioms defines axiom_set but that I imported as follows

import Module.Axioms as MA

my code can't find MA.axiom_set.

I think either modString should return MA in the case of Module.Axioms or there should be a function that takes a symbol and a module and constructs a Name referring to the symbol in the module and considering possible renamings of modules.

New description: I am writing a bit of TemplateHaskell for stringing together QuickCheck style specifications. I require every module containing properties to export a symbol called `axiom_set`. Then, my `checkAxioms` function finds all the `axiom_set` symbols from modules imported where I call `checkAxioms`. {{{#!hs checkAxioms :: DecsQ checkAxioms = do ModuleInfo ms <- reifyModule =<< thisModule forM_ ms $ \mi@(Module _ m) -> do runIO . print =<< lookupValueName (modString m ++ ".axiom_set") }}} The above code should find all the imported `axiom_set` symbols. However, if `Module.Axioms` defines `axiom_set` but that I imported as follows {{{#!hs import Module.Axioms as MA }}} my code can't find `MA.axiom_set`. I think either `modString` should return `MA` in the case of `Module.Axioms` or there should be a function that takes a symbol and a module and constructs a `Name` referring to the symbol in the module and considering possible renamings of modules. -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11078#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11078: Access to module renaming with reifyModule, in TemplateHaskell -------------------------------------+------------------------------------- Reporter: cipher1024 | Owner: Type: feature request | Status: new Priority: normal | Milestone: 8.0.1 Component: Template Haskell | Version: 7.10.2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by goldfire): * milestone: => 8.0.1 Comment: Good point. What about this design: {{{ data ModuleInfo = ModuleInfo [ModuleImport] data ModuleImport = ModuleImport Module -- ^ imported module Bool -- ^ qualified? (Maybe String) -- ^ synonym [Name] -- ^ imported names data Module = Module PkgName ModName -- as it is today }}} I'm not sure that GHC can fully populate `ModuleImport` given the information that it has to hand. But if we could build `ModuleImport`s, would this solve your problem? One further refinement is to enable querying of whether or not the user specified an import list or if simply all names were imported. But I'm less convinced of the need for that at this point. It would be lovely if someone were to do this for 8.0! -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11078#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11078: Access to module renaming with reifyModule, in TemplateHaskell -------------------------------------+------------------------------------- Reporter: cipher1024 | Owner: Type: feature request | Status: new Priority: normal | Milestone: 8.0.1 Component: Template Haskell | Version: 7.10.2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by osa1): * cc: osa1 (added) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11078#comment:5 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11078: Access to module renaming with reifyModule, in TemplateHaskell -------------------------------------+------------------------------------- Reporter: cipher1024 | Owner: Type: feature request | Status: new Priority: normal | Milestone: 8.0.1 Component: Template Haskell | Version: 7.10.2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by osa1): I think I can implement this. When's the deadline for 8.0 patches? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11078#comment:7 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11078: Access to module renaming with reifyModule, in TemplateHaskell -------------------------------------+------------------------------------- Reporter: cipher1024 | Owner: Type: feature request | Status: new Priority: normal | Milestone: 8.0.1 Component: Template Haskell | Version: 7.10.2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by goldfire): I'm afraid I don't have any ideas until my "type=kind" branch is merged, which is of highest priority. What's the specific piece of info that's missing? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11078#comment:9 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11078: Access to module renaming with reifyModule, in TemplateHaskell -------------------------------------+------------------------------------- Reporter: cipher1024 | Owner: Type: feature request | Status: new Priority: normal | Milestone: 8.0.1 Component: Template Haskell | Version: 7.10.2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by osa1): Jan, I worked on this until I got stuck because of the missing information in `TcM`. I don't really have any code in any branch, it was only a couple of lines until I realized something's missing. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11078#comment:11 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11078: Access to module renaming with reifyModule, in TemplateHaskell -------------------------------------+------------------------------------- Reporter: cipher1024 | Owner: Type: feature request | Status: new Priority: normal | Milestone: 8.0.1 Component: Template Haskell | Version: 7.10.2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by goldfire): I'm concerned about `all the things the module could provide`. That sounds like it contains all the exports of the module in question, which is larger than the list of all definitions that are imported here. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11078#comment:13 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11078: Access to module renaming with reifyModule, in TemplateHaskell
-------------------------------------+-------------------------------------
        Reporter:  cipher1024        |                Owner:
            Type:  feature request   |               Status:  new
        Priority:  normal            |            Milestone:  8.0.1
       Component:  Template Haskell  |              Version:  7.10.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by jstolarek):

 Replying to [comment:13 goldfire]:
 > I'm concerned about `all the things the module could provide`. That
 sounds like it contains all the exports of the module in question.
 Yes, that is exactly the case.

 After some more hacking I believe that `Maybe String` for representing a
 synonym is not a good idea.  We should have a `[String]` instead to store
 all names used to import a module. For example, if I say:

 {{{
 import Foo
 import Foo as Bar
 }}}
 then the list would contain `[Foo, Bar]`.

 Replying to [comment:14 osa1]:
 > You may want to have a look at `HsModule` and `HsParsedModule` types. We
 can easily pass them(or some information taken from them) to the type
 checker and they have everything we need.
 Two questions:
 1. Which field of these data types stores the list of *imported*
 functions?
 2. How can we pass data from these to the type checker? Won't this be a
 gross hack?

--
Ticket URL: 
GHC 
The Glasgow Haskell Compiler

#11078: Access to module renaming with reifyModule, in TemplateHaskell -------------------------------------+------------------------------------- Reporter: cipher1024 | Owner: Type: feature request | Status: new Priority: normal | Milestone: 8.0.1 Component: Template Haskell | Version: 7.10.2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by jstolarek): Replying to [comment:16 osa1]:

`LImportDecl` has this field: `iDeclHiding :: Maybe (Bool, LIE)`. As far as I understand from the documentation if the `Bool` is `False` it's an explicit import. Otherwise it's an explicit `hiding (...)`. Good point. So it looks like we have all the necessary information at hand. When `fst . ideclHiding` is `False` then the second component of the tuple stores the names of imported things. If `fst . ideclHiding` is `True`, then we must compute imported names based on `imv_all_exports` (all things provided by the module) and the second component of `ideclHiding` (hidden things, that need to be excluded from the list). Probably a bit tedious, but doable. We'd need to figure out how to sensibly extract names from `LIE name`.

-- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11078#comment:17 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler