#15330: Error message prints invisible kind arguments in a visible matter -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.8.1 Component: Compiler (Type | Version: 8.4.3 checker) | Resolution: | Keywords: TypeInType Operating System: Unknown/Multiple | Architecture: Type of failure: Poor/confusing | Unknown/Multiple error message | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by RyanGlScott): Unlike its cousin #15308, this ticket looks quite tricky to fix. The difference between pretty-printing the types of `f1` and `f2` is essentially the difference between pretty-printing `TyConApp` and `AppTy`. With `TyConApp`, we have convenient access to the kind of the underlying type constructor, which makes it simple to tell which of its arguments are visible or not. As an example, when we convert a `Type` to an `IfaceType` in `toIfaceTypeX`, we use this tycon kind information to convert the arguments of the tycon to `IfaceTcArgs`. Then, when pretty-printing a `Type`, we first convert to an `IfaceType`, and then determining which arguments of an `IfaceTyConApp` to print is a simple matter of checking for `ITC_Vis` or `ITC_Invis`. Things are tricker with `AppTy`. The type being applied in `AppTy` does not have its kind cached //a priori//, so in order to pretty-print `AppTy` analogously to how we pretty-print `TyConApp`, it seems like we'd have to: 1. Use `typeKind` to get the kind of the type being applied 2. Gather all of the arguments to the type (à la `collectArgs` for `Expr`s) 3. Tag which arguments are invisible (à la `IfaceTcArgs`) This sounds mighty gruesome, but I can't think of a simpler solution at the moment. Thoughts? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/15330#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#15330: Error message prints invisible kind arguments in a visible matter -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.8.1 Component: Compiler (Type | Version: 8.4.3 checker) | Resolution: | Keywords: TypeInType Operating System: Unknown/Multiple | Architecture: Type of failure: Poor/confusing | Unknown/Multiple error message | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by RyanGlScott): That sounds good to me. Two remaining questions: * How should we print `InvisATM`-tagged types when `-fprint-explicit- kinds` is enabled? Using the above example, should it be `f Bool 'True` or `f @Bool 'True`? Should `-dsuppress-type-applications` enter the picture somewhere? * Would we need to pretty-print `VisDepATM`-tagged types differently from `VanillaATM`-tagged ones? That is, why should we distinguish `VisDepATM` at all? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/15330#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#15330: Error message prints invisible kind arguments in a visible matter -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.8.1 Component: Compiler (Type | Version: 8.4.3 checker) | Resolution: | Keywords: TypeInType Operating System: Unknown/Multiple | Architecture: Type of failure: Poor/confusing | Unknown/Multiple error message | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj): Let's ''not'' do this in `Type`, but rather in `IfaceType`. For `Type` it is simply redundant info that we'll have to carry around and maintain. We only need it for pretty-printing. `IfaceType` (now a slight misnomer) is intended for serialisation, either to the user or to a binary file, so adding extra info makes sense. In practice, we are going to gather up all the args of a chain of `AppTy`s before pretty-printing, so we can lay them out nicely. So maybe we should use {{{ | IfaceAppTy IfaceType IfaceTcArgs }}} and then rename `IfaceTcArgs` to `IfaceAppArgs`. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/15330#comment:5 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#15330: Error message prints invisible kind arguments in a visible matter -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: patch Priority: normal | Milestone: 8.8.1 Component: Compiler (Type | Version: 8.4.3 checker) | Resolution: | Keywords: TypeInType Operating System: Unknown/Multiple | Architecture: Type of failure: Poor/confusing | Unknown/Multiple error message | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D4938 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Ryan Scott ): In [changeset:"1c3536239cb5e83ff1427ac410d8fa2549e7d9c0/ghc" 1c353623/ghc]: {{{ #!CommitTicketReference repository="ghc" revision="1c3536239cb5e83ff1427ac410d8fa2549e7d9c0" Use IfaceAppArgs to store an IfaceAppTy's arguments Summary: Currently, an `IfaceAppTy` has no way to tell whether its argument is visible or not, so it simply treats all arguments as visible, leading to #15330. We already have a solution for this problem in the form of the `IfaceTcArgs` data structure, used by `IfaceTyConApp` to represent the arguments to a type constructor. Therefore, it makes sense to reuse this machinery for `IfaceAppTy`, so this patch does just that. This patch: 1. Renames `IfaceTcArgs` to `IfaceAppArgs` to reflect its more general purpose. 2. Changes the second field of `IfaceAppTy` from `IfaceType` to `IfaceAppArgs`, and propagates the necessary changes through. In particular, pretty-printing an `IfaceAppTy` now goes through the `IfaceAppArgs` pretty-printer, which correctly displays arguments as visible or not for free, fixing #15330. 3. Changes `toIfaceTypeX` and related functions so that when converting an `AppTy` to an `IfaceAppTy`, it flattens as many argument `AppTy`s as possible, and then converts those arguments into an `IfaceAppArgs` list, using the kind of the function `Type` as a guide. (Doing so minimizes the number of times we need to call `typeKind`, which is more expensive that finding the kind of a `TyCon`.) Test Plan: make test TEST=T15330 Reviewers: goldfire, simonpj, bgamari Reviewed By: simonpj Subscribers: rwbarton, thomie, carter GHC Trac Issues: #15330 Differential Revision: https://phabricator.haskell.org/D4938 }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/15330#comment:7 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler