summaryrefslogtreecommitdiff
path: root/compiler/GHC/Hs
diff options
context:
space:
mode:
authorJohn Ericson <John.Ericson@Obsidian.Systems>2021-01-10 02:01:43 +0000
committerMarge Bot <ben+marge-bot@smart-cactus.org>2021-01-23 21:32:47 -0500
commit81f0665513d65c2d7e544cbe8adeff4b0d6fdfff (patch)
tree9e55698fc5cc041e8623eff2978eb94b72894130 /compiler/GHC/Hs
parente6e1cf743c6de87c376c32d2279e2d684151f3d7 (diff)
downloadhaskell-81f0665513d65c2d7e544cbe8adeff4b0d6fdfff.tar.gz
Separate AST from GhcPass (#18936)
---------------- What: There are two splits. The first spit is: - `Language.Haskell.Syntax.Extension` - `GHC.Hs.Extension` where the former now just contains helpers like `NoExtCon` and all the families, and the latter is everything having to do with `GhcPass`. The second split is: - `Language.Haskell.Syntax.<mod>` - `GHC.Hs.<mod>` Where the former contains all the data definitions, and the few helpers that don't use `GhcPass`, and the latter contains everything else. The second modules also reexport the former. ---------------- Why: See the issue for more details, but in short answer is we're trying to grasp at the modularity TTG is supposed to offer, after a long time of mainly just getting the safety benefits of more complete pattern matching on the AST. Now, we have an AST datatype which, without `GhcPass` is decently stripped of GHC-specific concerns. Whereas before, not was it GHC-specific, it was aware of all the GHC phases despite the parameterization, with the instances and parametric data structure side-by-side. For what it's worth there are also some smaller, imminent benefits: - The latter change also splits a strongly connected component in two, since none of the `Language.Haskell.Syntax.*` modules import the older ones. - A few TTG violations (Using GhcPass directly in the AST) in `Expr` are now more explicitly accounted for with new type families to provide the necessary indirection. ----------------- Future work: - I don't see why all the type families should live in `Language.Haskell.Syntax.Extension`. That seems anti-modular for little benefit. All the ones used just once can be moved next to the AST type they serve as an extension point for. - Decide what to do with the `Outputable` instances. Some of these are no orphans because they referred to `GhcPass`, and had to be moved. I think the types could be generalized so they don't refer to `GhcPass` and therefore can be moved back, but having gotten flak for increasing the size and complexity types when generalizing before, I did *not* want to do this. - We should triage the remaining contents of `GHC.Hs.<mod>`. The renaming helpers are somewhat odd for needing `GhcPass`. We might consider if they are a) in fact only needed by one phase b) can be generalized to be non-GhcPass-specific (e.g. take a callback rather than GADT-match with `IsPass`) and then they can live in `Language.Haskell.Syntax.<mod>`. For more details, see https://gitlab.haskell.org/ghc/ghc/-/wikis/implementing-trees-that-grow Bumps Haddock submodule
Diffstat (limited to 'compiler/GHC/Hs')
-rw-r--r--compiler/GHC/Hs/Binds.hs655
-rw-r--r--compiler/GHC/Hs/Decls.hs1578
-rw-r--r--compiler/GHC/Hs/Expr.hs1655
-rw-r--r--compiler/GHC/Hs/Expr.hs-boot38
-rw-r--r--compiler/GHC/Hs/Extension.hs639
-rw-r--r--compiler/GHC/Hs/ImpExp.hs3
-rw-r--r--compiler/GHC/Hs/Lit.hs178
-rw-r--r--compiler/GHC/Hs/Pat.hs330
-rw-r--r--compiler/GHC/Hs/Pat.hs-boot15
-rw-r--r--compiler/GHC/Hs/Type.hs1186
-rw-r--r--compiler/GHC/Hs/Utils.hs1
11 files changed, 89 insertions, 6189 deletions
diff --git a/compiler/GHC/Hs/Binds.hs b/compiler/GHC/Hs/Binds.hs
index 1f895c20ec..c345cbe5e9 100644
--- a/compiler/GHC/Hs/Binds.hs
+++ b/compiler/GHC/Hs/Binds.hs
@@ -7,9 +7,10 @@
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
+ -- in module Language.Haskell.Syntax.Extension
{-# LANGUAGE ViewPatterns #-}
+{-# OPTIONS_GHC -Wno-orphans #-} -- Outputable
{-
(c) The University of Glasgow 2006
@@ -20,26 +21,26 @@
Datatype for: @BindGroup@, @Bind@, @Sig@, @Bind@.
-}
-module GHC.Hs.Binds where
+module GHC.Hs.Binds
+ ( module Language.Haskell.Syntax.Binds
+ , module GHC.Hs.Binds
+ ) where
import GHC.Prelude
-import {-# SOURCE #-} GHC.Hs.Expr ( pprExpr, LHsExpr,
- MatchGroup, pprFunBind,
- GRHSs, pprPatBind )
-import {-# SOURCE #-} GHC.Hs.Pat ( LPat )
+import Language.Haskell.Syntax.Binds
+import {-# SOURCE #-} GHC.Hs.Expr ( pprExpr, pprFunBind, pprPatBind )
+
+import Language.Haskell.Syntax.Extension
import GHC.Hs.Extension
import GHC.Hs.Type
-import GHC.Core
import GHC.Tc.Types.Evidence
import GHC.Core.Type
import GHC.Types.Name.Set
import GHC.Types.Basic
import GHC.Types.SourceText
import GHC.Types.SrcLoc as SrcLoc
-import GHC.Types.Var
-import GHC.Types.Fixity
import GHC.Data.Bag
import GHC.Data.FastString
import GHC.Data.BooleanFormula (LBooleanFormula)
@@ -47,10 +48,8 @@ import GHC.Data.BooleanFormula (LBooleanFormula)
import GHC.Utils.Outputable
import GHC.Utils.Panic
-import Data.Data hiding ( Fixity )
import Data.List hiding ( foldr )
import Data.Function
-import Data.Void
{-
************************************************************************
@@ -62,76 +61,14 @@ import Data.Void
Global bindings (where clauses)
-}
--- During renaming, we need bindings where the left-hand sides
--- have been renamed but the right-hand sides have not.
-- the ...LR datatypes are parametrized by two id types,
-- one for the left and one for the right.
--- Other than during renaming, these will be the same.
-
--- | Haskell Local Bindings
-type HsLocalBinds id = HsLocalBindsLR id id
-
--- | Located Haskell local bindings
-type LHsLocalBinds id = XRec id (HsLocalBinds id)
-
--- | Haskell Local Bindings with separate Left and Right identifier types
---
--- Bindings in a 'let' expression
--- or a 'where' clause
-data HsLocalBindsLR idL idR
- = HsValBinds
- (XHsValBinds idL idR)
- (HsValBindsLR idL idR)
- -- ^ Haskell Value Bindings
-
- -- There should be no pattern synonyms in the HsValBindsLR
- -- These are *local* (not top level) bindings
- -- The parser accepts them, however, leaving the
- -- renamer to report them
-
- | HsIPBinds
- (XHsIPBinds idL idR)
- (HsIPBinds idR)
- -- ^ Haskell Implicit Parameter Bindings
-
- | EmptyLocalBinds (XEmptyLocalBinds idL idR)
- -- ^ Empty Local Bindings
-
- | XHsLocalBindsLR
- !(XXHsLocalBindsLR idL idR)
type instance XHsValBinds (GhcPass pL) (GhcPass pR) = NoExtField
type instance XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExtField
type instance XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField
type instance XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon
-type LHsLocalBindsLR idL idR = XRec idL (HsLocalBindsLR idL idR)
-
-
--- | Haskell Value Bindings
-type HsValBinds id = HsValBindsLR id id
-
--- | Haskell Value bindings with separate Left and Right identifier types
--- (not implicit parameters)
--- Used for both top level and nested bindings
--- May contain pattern synonym bindings
-data HsValBindsLR idL idR
- = -- | Value Bindings In
- --
- -- Before renaming RHS; idR is always RdrName
- -- Not dependency analysed
- -- Recursive by default
- ValBinds
- (XValBinds idL idR)
- (LHsBindsLR idL idR) [LSig idR]
-
- -- | Value Bindings Out
- --
- -- After renaming RHS; idR can be Name or Id Dependency analysed,
- -- later bindings in the list may depend on earlier ones.
- | XValBindsLR
- !(XXValBindsLR idL idR)
-
-- ---------------------------------------------------------------------
-- Deal with ValBindsOut
@@ -147,177 +84,6 @@ type instance XXValBindsLR (GhcPass pL) (GhcPass pR)
-- ---------------------------------------------------------------------
--- | Located Haskell Binding
-type LHsBind id = LHsBindLR id id
-
--- | Located Haskell Bindings
-type LHsBinds id = LHsBindsLR id id
-
--- | Haskell Binding
-type HsBind id = HsBindLR id id
-
--- | Located Haskell Bindings with separate Left and Right identifier types
-type LHsBindsLR idL idR = Bag (LHsBindLR idL idR)
-
--- | Located Haskell Binding with separate Left and Right identifier types
-type LHsBindLR idL idR = XRec idL (HsBindLR idL idR)
-
-{- Note [FunBind vs PatBind]
- ~~~~~~~~~~~~~~~~~~~~~~~~~
-The distinction between FunBind and PatBind is a bit subtle. FunBind covers
-patterns which resemble function bindings and simple variable bindings.
-
- f x = e
- f !x = e
- f = e
- !x = e -- FunRhs has SrcStrict
- x `f` y = e -- FunRhs has Infix
-
-The actual patterns and RHSs of a FunBind are encoding in fun_matches.
-The m_ctxt field of each Match in fun_matches will be FunRhs and carries
-two bits of information about the match,
-
- * The mc_fixity field on each Match describes the fixity of the
- function binder in that match. E.g. this is legal:
- f True False = e1
- True `f` True = e2
-
- * The mc_strictness field is used /only/ for nullary FunBinds: ones
- with one Match, which has no pats. For these, it describes whether
- the match is decorated with a bang (e.g. `!x = e`).
-
-By contrast, PatBind represents data constructor patterns, as well as a few
-other interesting cases. Namely,
-
- Just x = e
- (x) = e
- x :: Ty = e
--}
-
--- | Haskell Binding with separate Left and Right id's
-data HsBindLR idL idR
- = -- | Function-like Binding
- --
- -- FunBind is used for both functions @f x = e@
- -- and variables @f = \x -> e@
- -- and strict variables @!x = x + 1@
- --
- -- Reason 1: Special case for type inference: see 'GHC.Tc.Gen.Bind.tcMonoBinds'.
- --
- -- Reason 2: Instance decls can only have FunBinds, which is convenient.
- -- If you change this, you'll need to change e.g. rnMethodBinds
- --
- -- But note that the form @f :: a->a = ...@
- -- parses as a pattern binding, just like
- -- @(f :: a -> a) = ... @
- --
- -- Strict bindings have their strictness recorded in the 'SrcStrictness' of their
- -- 'MatchContext'. See Note [FunBind vs PatBind] for
- -- details about the relationship between FunBind and PatBind.
- --
- -- 'GHC.Parser.Annotation.AnnKeywordId's
- --
- -- - 'GHC.Parser.Annotation.AnnFunId', attached to each element of fun_matches
- --
- -- - 'GHC.Parser.Annotation.AnnEqual','GHC.Parser.Annotation.AnnWhere',
- -- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnClose',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- FunBind {
-
- fun_ext :: XFunBind idL idR,
-
- -- ^ After the renamer (but before the type-checker), this contains the
- -- locally-bound free variables of this defn. See Note [Bind free vars]
- --
- -- After the type-checker, this contains a coercion from the type of
- -- the MatchGroup to the type of the Id. Example:
- --
- -- @
- -- f :: Int -> forall a. a -> a
- -- f x y = y
- -- @
- --
- -- Then the MatchGroup will have type (Int -> a' -> a')
- -- (with a free type variable a'). The coercion will take
- -- a CoreExpr of this type and convert it to a CoreExpr of
- -- type Int -> forall a'. a' -> a'
- -- Notice that the coercion captures the free a'.
-
- fun_id :: LIdP idL, -- Note [fun_id in Match] in GHC.Hs.Expr
-
- fun_matches :: MatchGroup idR (LHsExpr idR), -- ^ The payload
-
- fun_tick :: [Tickish Id] -- ^ Ticks to put on the rhs, if any
- }
-
- -- | Pattern Binding
- --
- -- The pattern is never a simple variable;
- -- That case is done by FunBind.
- -- See Note [FunBind vs PatBind] for details about the
- -- relationship between FunBind and PatBind.
-
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnBang',
- -- 'GHC.Parser.Annotation.AnnEqual','GHC.Parser.Annotation.AnnWhere',
- -- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnClose',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | PatBind {
- pat_ext :: XPatBind idL idR, -- ^ See Note [Bind free vars]
- pat_lhs :: LPat idL,
- pat_rhs :: GRHSs idR (LHsExpr idR),
- pat_ticks :: ([Tickish Id], [[Tickish Id]])
- -- ^ Ticks to put on the rhs, if any, and ticks to put on
- -- the bound variables.
- }
-
- -- | Variable Binding
- --
- -- Dictionary binding and suchlike.
- -- All VarBinds are introduced by the type checker
- | VarBind {
- var_ext :: XVarBind idL idR,
- var_id :: IdP idL,
- var_rhs :: LHsExpr idR -- ^ Located only for consistency
- }
-
- -- | Abstraction Bindings
- | AbsBinds { -- Binds abstraction; TRANSLATION
- abs_ext :: XAbsBinds idL idR,
- abs_tvs :: [TyVar],
- abs_ev_vars :: [EvVar], -- ^ Includes equality constraints
-
- -- | AbsBinds only gets used when idL = idR after renaming,
- -- but these need to be idL's for the collect... code in HsUtil
- -- to have the right type
- abs_exports :: [ABExport idL],
-
- -- | Evidence bindings
- -- Why a list? See "GHC.Tc.TyCl.Instance"
- -- Note [Typechecking plan for instance declarations]
- abs_ev_binds :: [TcEvBinds],
-
- -- | Typechecked user bindings
- abs_binds :: LHsBinds idL,
-
- abs_sig :: Bool -- See Note [The abs_sig field of AbsBinds]
- }
-
- -- | Patterns Synonym Binding
- | PatSynBind
- (XPatSynBind idL idR)
- (PatSynBind idL idR)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnPattern',
- -- 'GHC.Parser.Annotation.AnnLarrow','GHC.Parser.Annotation.AnnEqual',
- -- 'GHC.Parser.Annotation.AnnWhere'
- -- 'GHC.Parser.Annotation.AnnOpen' @'{'@,'GHC.Parser.Annotation.AnnClose' @'}'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | XHsBindsLR !(XXHsBindsLR idL idR)
-
type instance XFunBind (GhcPass pL) GhcPs = NoExtField
type instance XFunBind (GhcPass pL) GhcRn = NameSet -- Free variables
type instance XFunBind (GhcPass pL) GhcTc = HsWrapper -- See comments on FunBind.fun_ext
@@ -331,52 +97,9 @@ type instance XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField
type instance XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField
type instance XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon
-
- -- Consider (AbsBinds tvs ds [(ftvs, poly_f, mono_f) binds]
- --
- -- Creates bindings for (polymorphic, overloaded) poly_f
- -- in terms of monomorphic, non-overloaded mono_f
- --
- -- Invariants:
- -- 1. 'binds' binds mono_f
- -- 2. ftvs is a subset of tvs
- -- 3. ftvs includes all tyvars free in ds
- --
- -- See Note [AbsBinds]
-
--- | Abstraction Bindings Export
-data ABExport p
- = ABE { abe_ext :: XABE p
- , abe_poly :: IdP p -- ^ Any INLINE pragma is attached to this Id
- , abe_mono :: IdP p
- , abe_wrap :: HsWrapper -- ^ See Note [ABExport wrapper]
- -- Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_poly
- , abe_prags :: TcSpecPrags -- ^ SPECIALISE pragmas
- }
- | XABExport !(XXABExport p)
-
type instance XABE (GhcPass p) = NoExtField
type instance XXABExport (GhcPass p) = NoExtCon
-
--- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnPattern',
--- 'GHC.Parser.Annotation.AnnEqual','GHC.Parser.Annotation.AnnLarrow',
--- 'GHC.Parser.Annotation.AnnWhere','GHC.Parser.Annotation.AnnOpen' @'{'@,
--- 'GHC.Parser.Annotation.AnnClose' @'}'@,
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- | Pattern Synonym binding
-data PatSynBind idL idR
- = PSB { psb_ext :: XPSB idL idR, -- ^ Post renaming, FVs.
- -- See Note [Bind free vars]
- psb_id :: LIdP idL, -- ^ Name of the pattern synonym
- psb_args :: HsPatSynDetails idR, -- ^ Formal parameter names
- psb_def :: LPat idR, -- ^ Right-hand side
- psb_dir :: HsPatSynDir idR -- ^ Directionality
- }
- | XPatSynBind !(XXPatSynBind idL idR)
-
type instance XPSB (GhcPass idL) GhcPs = NoExtField
type instance XPSB (GhcPass idL) GhcRn = NameSet
type instance XPSB (GhcPass idL) GhcTc = NameSet
@@ -796,15 +519,6 @@ pprTicks pp_no_debug pp_when_debug
************************************************************************
-}
--- | Haskell Implicit Parameter Bindings
-data HsIPBinds id
- = IPBinds
- (XIPBinds id)
- [LIPBind id]
- -- TcEvBinds -- Only in typechecker output; binds
- -- -- uses of the implicit parameters
- | XHsIPBinds !(XXHsIPBinds id)
-
type instance XIPBinds GhcPs = NoExtField
type instance XIPBinds GhcRn = NoExtField
type instance XIPBinds GhcTc = TcEvBinds -- binds uses of the
@@ -819,30 +533,6 @@ isEmptyIPBindsPR (IPBinds _ is) = null is
isEmptyIPBindsTc :: HsIPBinds GhcTc -> Bool
isEmptyIPBindsTc (IPBinds ds is) = null is && isEmptyTcEvBinds ds
--- | Located Implicit Parameter Binding
-type LIPBind id = XRec id (IPBind id)
--- ^ May have 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnSemi' when in a
--- list
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- | Implicit parameter bindings.
---
--- These bindings start off as (Left "x") in the parser and stay
--- that way until after type-checking when they are replaced with
--- (Right d), where "d" is the name of the dictionary holding the
--- evidence for the implicit parameter.
---
--- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnEqual'
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-data IPBind id
- = IPBind
- (XCIPBind id)
- (Either (XRec id HsIPName) (IdP id))
- (LHsExpr id)
- | XIPBind !(XXIPBind id)
-
type instance XCIPBind (GhcPass p) = NoExtField
type instance XXIPBind (GhcPass p) = NoExtCon
@@ -863,167 +553,8 @@ instance OutputableBndrId p => Outputable (IPBind (GhcPass p)) where
\subsection{@Sig@: type signatures and value-modifying user pragmas}
* *
************************************************************************
-
-It is convenient to lump ``value-modifying'' user-pragmas (e.g.,
-``specialise this function to these four types...'') in with type
-signatures. Then all the machinery to move them into place, etc.,
-serves for both.
-}
--- | Located Signature
-type LSig pass = XRec pass (Sig pass)
-
--- | Signatures and pragmas
-data Sig pass
- = -- | An ordinary type signature
- --
- -- > f :: Num a => a -> a
- --
- -- After renaming, this list of Names contains the named
- -- wildcards brought into scope by this signature. For a signature
- -- @_ -> _a -> Bool@, the renamer will leave the unnamed wildcard @_@
- -- untouched, and the named wildcard @_a@ is then replaced with
- -- fresh meta vars in the type. Their names are stored in the type
- -- signature that brought them into scope, in this third field to be
- -- more specific.
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDcolon',
- -- 'GHC.Parser.Annotation.AnnComma'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- TypeSig
- (XTypeSig pass)
- [LIdP pass] -- LHS of the signature; e.g. f,g,h :: blah
- (LHsSigWcType pass) -- RHS of the signature; can have wildcards
-
- -- | A pattern synonym type signature
- --
- -- > pattern Single :: () => (Show a) => a -> [a]
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnPattern',
- -- 'GHC.Parser.Annotation.AnnDcolon','GHC.Parser.Annotation.AnnForall'
- -- 'GHC.Parser.Annotation.AnnDot','GHC.Parser.Annotation.AnnDarrow'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | PatSynSig (XPatSynSig pass) [LIdP pass] (LHsSigType pass)
- -- P :: forall a b. Req => Prov => ty
-
- -- | A signature for a class method
- -- False: ordinary class-method signature
- -- True: generic-default class method signature
- -- e.g. class C a where
- -- op :: a -> a -- Ordinary
- -- default op :: Eq a => a -> a -- Generic default
- -- No wildcards allowed here
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDefault',
- -- 'GHC.Parser.Annotation.AnnDcolon'
- | ClassOpSig (XClassOpSig pass) Bool [LIdP pass] (LHsSigType pass)
-
- -- | A type signature in generated code, notably the code
- -- generated for record selectors. We simply record
- -- the desired Id itself, replete with its name, type
- -- and IdDetails. Otherwise it's just like a type
- -- signature: there should be an accompanying binding
- | IdSig (XIdSig pass) Id
-
- -- | An ordinary fixity declaration
- --
- -- > infixl 8 ***
- --
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnInfix',
- -- 'GHC.Parser.Annotation.AnnVal'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | FixSig (XFixSig pass) (FixitySig pass)
-
- -- | An inline pragma
- --
- -- > {#- INLINE f #-}
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' :
- -- 'GHC.Parser.Annotation.AnnOpen' @'{-\# INLINE'@ and @'['@,
- -- 'GHC.Parser.Annotation.AnnClose','GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnVal','GHC.Parser.Annotation.AnnTilde',
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | InlineSig (XInlineSig pass)
- (LIdP pass) -- Function name
- InlinePragma -- Never defaultInlinePragma
-
- -- | A specialisation pragma
- --
- -- > {-# SPECIALISE f :: Int -> Int #-}
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnOpen' @'{-\# SPECIALISE'@ and @'['@,
- -- 'GHC.Parser.Annotation.AnnTilde',
- -- 'GHC.Parser.Annotation.AnnVal',
- -- 'GHC.Parser.Annotation.AnnClose' @']'@ and @'\#-}'@,
- -- 'GHC.Parser.Annotation.AnnDcolon'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | SpecSig (XSpecSig pass)
- (LIdP pass) -- Specialise a function or datatype ...
- [LHsSigType pass] -- ... to these types
- InlinePragma -- The pragma on SPECIALISE_INLINE form.
- -- If it's just defaultInlinePragma, then we said
- -- SPECIALISE, not SPECIALISE_INLINE
-
- -- | A specialisation pragma for instance declarations only
- --
- -- > {-# SPECIALISE instance Eq [Int] #-}
- --
- -- (Class tys); should be a specialisation of the
- -- current instance declaration
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnInstance','GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | SpecInstSig (XSpecInstSig pass) SourceText (LHsSigType pass)
- -- Note [Pragma source text] in GHC.Types.SourceText
-
- -- | A minimal complete definition pragma
- --
- -- > {-# MINIMAL a | (b, c | (d | e)) #-}
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnVbar','GHC.Parser.Annotation.AnnComma',
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | MinimalSig (XMinimalSig pass)
- SourceText (LBooleanFormula (LIdP pass))
- -- Note [Pragma source text] in GHC.Types.SourceText
-
- -- | A "set cost centre" pragma for declarations
- --
- -- > {-# SCC funName #-}
- --
- -- or
- --
- -- > {-# SCC funName "cost_centre_name" #-}
-
- | SCCFunSig (XSCCFunSig pass)
- SourceText -- Note [Pragma source text] in GHC.Types.SourceText
- (LIdP pass) -- Function name
- (Maybe (XRec pass StringLiteral))
- -- | A complete match pragma
- --
- -- > {-# COMPLETE C, D [:: T] #-}
- --
- -- Used to inform the pattern match checker about additional
- -- complete matchings which, for example, arise from pattern
- -- synonym definitions.
- | CompleteMatchSig (XCompleteMatchSig pass)
- SourceText
- (XRec pass [LIdP pass])
- (Maybe (LIdP pass))
- | XSig !(XXSig pass)
-
type instance XTypeSig (GhcPass p) = NoExtField
type instance XPatSynSig (GhcPass p) = NoExtField
type instance XClassOpSig (GhcPass p) = NoExtField
@@ -1037,116 +568,9 @@ type instance XSCCFunSig (GhcPass p) = NoExtField
type instance XCompleteMatchSig (GhcPass p) = NoExtField
type instance XXSig (GhcPass p) = NoExtCon
--- | Located Fixity Signature
-type LFixitySig pass = XRec pass (FixitySig pass)
-
--- | Fixity Signature
-data FixitySig pass = FixitySig (XFixitySig pass) [LIdP pass] Fixity
- | XFixitySig !(XXFixitySig pass)
-
type instance XFixitySig (GhcPass p) = NoExtField
type instance XXFixitySig (GhcPass p) = NoExtCon
--- | Type checker Specialisation Pragmas
---
--- 'TcSpecPrags' conveys @SPECIALISE@ pragmas from the type checker to the desugarer
-data TcSpecPrags
- = IsDefaultMethod -- ^ Super-specialised: a default method should
- -- be macro-expanded at every call site
- | SpecPrags [LTcSpecPrag]
- deriving Data
-
--- | Located Type checker Specification Pragmas
-type LTcSpecPrag = Located TcSpecPrag
-
--- | Type checker Specification Pragma
-data TcSpecPrag
- = SpecPrag
- Id
- HsWrapper
- InlinePragma
- -- ^ The Id to be specialised, a wrapper that specialises the
- -- polymorphic function, and inlining spec for the specialised function
- deriving Data
-
-noSpecPrags :: TcSpecPrags
-noSpecPrags = SpecPrags []
-
-hasSpecPrags :: TcSpecPrags -> Bool
-hasSpecPrags (SpecPrags ps) = not (null ps)
-hasSpecPrags IsDefaultMethod = False
-
-isDefaultMethod :: TcSpecPrags -> Bool
-isDefaultMethod IsDefaultMethod = True
-isDefaultMethod (SpecPrags {}) = False
-
-isFixityLSig :: forall p. UnXRec p => LSig p -> Bool
-isFixityLSig (unXRec @p -> FixSig {}) = True
-isFixityLSig _ = False
-
-isTypeLSig :: forall p. UnXRec p => LSig p -> Bool -- Type signatures
-isTypeLSig (unXRec @p -> TypeSig {}) = True
-isTypeLSig (unXRec @p -> ClassOpSig {}) = True
-isTypeLSig (unXRec @p -> IdSig {}) = True
-isTypeLSig _ = False
-
-isSpecLSig :: forall p. UnXRec p => LSig p -> Bool
-isSpecLSig (unXRec @p -> SpecSig {}) = True
-isSpecLSig _ = False
-
-isSpecInstLSig :: forall p. UnXRec p => LSig p -> Bool
-isSpecInstLSig (unXRec @p -> SpecInstSig {}) = True
-isSpecInstLSig _ = False
-
-isPragLSig :: forall p. UnXRec p => LSig p -> Bool
--- Identifies pragmas
-isPragLSig (unXRec @p -> SpecSig {}) = True
-isPragLSig (unXRec @p -> InlineSig {}) = True
-isPragLSig (unXRec @p -> SCCFunSig {}) = True
-isPragLSig (unXRec @p -> CompleteMatchSig {}) = True
-isPragLSig _ = False
-
-isInlineLSig :: forall p. UnXRec p => LSig p -> Bool
--- Identifies inline pragmas
-isInlineLSig (unXRec @p -> InlineSig {}) = True
-isInlineLSig _ = False
-
-isMinimalLSig :: forall p. UnXRec p => LSig p -> Bool
-isMinimalLSig (unXRec @p -> MinimalSig {}) = True
-isMinimalLSig _ = False
-
-isSCCFunSig :: forall p. UnXRec p => LSig p -> Bool
-isSCCFunSig (unXRec @p -> SCCFunSig {}) = True
-isSCCFunSig _ = False
-
-isCompleteMatchSig :: forall p. UnXRec p => LSig p -> Bool
-isCompleteMatchSig (unXRec @p -> CompleteMatchSig {} ) = True
-isCompleteMatchSig _ = False
-
-hsSigDoc :: Sig name -> SDoc
-hsSigDoc (TypeSig {}) = text "type signature"
-hsSigDoc (PatSynSig {}) = text "pattern synonym signature"
-hsSigDoc (ClassOpSig _ is_deflt _ _)
- | is_deflt = text "default type signature"
- | otherwise = text "class method signature"
-hsSigDoc (IdSig {}) = text "id signature"
-hsSigDoc (SpecSig _ _ _ inl)
- = ppr inl <+> text "pragma"
-hsSigDoc (InlineSig _ _ prag) = ppr (inlinePragmaSpec prag) <+> text "pragma"
-hsSigDoc (SpecInstSig _ src _)
- = pprWithSourceText src empty <+> text "instance pragma"
-hsSigDoc (FixSig {}) = text "fixity declaration"
-hsSigDoc (MinimalSig {}) = text "MINIMAL pragma"
-hsSigDoc (SCCFunSig {}) = text "SCC pragma"
-hsSigDoc (CompleteMatchSig {}) = text "COMPLETE pragma"
-hsSigDoc (XSig {}) = text "XSIG TTG extension"
-
-{-
-Check if signatures overlap; this is used when checking for duplicate
-signatures. Since some of the signatures contain a list of names, testing for
-equality is not enough -- we have to check if they overlap.
--}
-
instance OutputableBndrId p => Outputable (Sig (GhcPass p)) where
ppr sig = ppr_sig sig
@@ -1219,62 +643,3 @@ instance Outputable TcSpecPrag where
pprMinimalSig :: (OutputableBndr name)
=> LBooleanFormula (Located name) -> SDoc
pprMinimalSig (L _ bf) = ppr (fmap unLoc bf)
-
-{-
-************************************************************************
-* *
-\subsection[PatSynBind]{A pattern synonym definition}
-* *
-************************************************************************
--}
-
--- | Haskell Pattern Synonym Details
-type HsPatSynDetails pass = HsConDetails Void (LIdP pass) [RecordPatSynField pass]
-
--- See Note [Record PatSyn Fields]
--- | Record Pattern Synonym Field
-data RecordPatSynField pass
- = RecordPatSynField
- { recordPatSynField :: FieldOcc pass
- -- ^ Field label visible in rest of the file
- , recordPatSynPatVar :: LIdP pass
- -- ^ Filled in by renamer, the name used internally by the pattern
- }
-
-
-{-
-Note [Record PatSyn Fields]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Consider the following two pattern synonyms.
-
- pattern P x y = ([x,True], [y,'v'])
- pattern Q{ x, y } =([x,True], [y,'v'])
-
-In P, we just have two local binders, x and y.
-
-In Q, we have local binders but also top-level record selectors
- x :: ([Bool], [Char]) -> Bool
- y :: ([Bool], [Char]) -> Char
-
-Both are recorded in the `RecordPatSynField`s for `x` and `y`:
-* recordPatSynField: the top-level record selector
-* recordPatSynPatVar: the local `x`, bound only in the RHS of the pattern synonym.
-
-It would make sense to support record-like syntax
-
- pattern Q{ x=x1, y=y1 } = ([x1,True], [y1,'v'])
-
-when we have a different name for the local and top-level binder,
-making the distinction between the two names clear.
-
--}
-instance Outputable (RecordPatSynField a) where
- ppr (RecordPatSynField { recordPatSynField = v }) = ppr v
-
-
--- | Haskell Pattern Synonym Direction
-data HsPatSynDir id
- = Unidirectional
- | ImplicitBidirectional
- | ExplicitBidirectional (MatchGroup id (LHsExpr id))
diff --git a/compiler/GHC/Hs/Decls.hs b/compiler/GHC/Hs/Decls.hs
index 882303373f..f896d0aeba 100644
--- a/compiler/GHC/Hs/Decls.hs
+++ b/compiler/GHC/Hs/Decls.hs
@@ -9,7 +9,9 @@
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
+ -- in module Language.Haskell.Syntax.Extension
+
+{-# OPTIONS_GHC -Wno-orphans #-}
{-
(c) The University of Glasgow 2006
@@ -99,17 +101,17 @@ module GHC.Hs.Decls (
-- friends:
import GHC.Prelude
-import {-# SOURCE #-} GHC.Hs.Expr( HsExpr, HsSplice, pprExpr,
- pprSpliceDecl )
+import Language.Haskell.Syntax.Decls
+
+import {-# SOURCE #-} GHC.Hs.Expr ( pprExpr, pprSpliceDecl )
-- Because Expr imports Decls via HsBracket
import GHC.Hs.Binds
import GHC.Hs.Type
import GHC.Hs.Doc
-import GHC.Core.TyCon
import GHC.Types.Basic
import GHC.Core.Coercion
-import GHC.Types.ForeignCall
+import Language.Haskell.Syntax.Extension
import GHC.Hs.Extension
import GHC.Types.Name
import GHC.Types.Name.Set
@@ -118,17 +120,13 @@ import GHC.Types.Fixity
-- others:
import GHC.Core.Class
import GHC.Utils.Outputable
-import GHC.Utils.Misc
import GHC.Utils.Panic
import GHC.Types.SrcLoc
import GHC.Types.SourceText
import GHC.Core.Type
-import GHC.Unit.Module.Warnings
import GHC.Data.Bag
import GHC.Data.Maybe
-import Data.Data hiding (TyCon,Fixity, Infix)
-import Data.Void
{-
************************************************************************
@@ -138,33 +136,6 @@ import Data.Void
************************************************************************
-}
-type LHsDecl p = XRec p (HsDecl p)
- -- ^ When in a list this may have
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnSemi'
- --
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- | A Haskell Declaration
-data HsDecl p
- = TyClD (XTyClD p) (TyClDecl p) -- ^ Type or Class Declaration
- | InstD (XInstD p) (InstDecl p) -- ^ Instance declaration
- | DerivD (XDerivD p) (DerivDecl p) -- ^ Deriving declaration
- | ValD (XValD p) (HsBind p) -- ^ Value declaration
- | SigD (XSigD p) (Sig p) -- ^ Signature declaration
- | KindSigD (XKindSigD p) (StandaloneKindSig p) -- ^ Standalone kind signature
- | DefD (XDefD p) (DefaultDecl p) -- ^ 'default' declaration
- | ForD (XForD p) (ForeignDecl p) -- ^ Foreign declaration
- | WarningD (XWarningD p) (WarnDecls p) -- ^ Warning declaration
- | AnnD (XAnnD p) (AnnDecl p) -- ^ Annotation declaration
- | RuleD (XRuleD p) (RuleDecls p) -- ^ Rule declaration
- | SpliceD (XSpliceD p) (SpliceDecl p) -- ^ Splice declaration
- -- (Includes quasi-quotes)
- | DocD (XDocD p) (DocDecl) -- ^ Documentation comment declaration
- | RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p) -- ^Role annotation declaration
- | XHsDecl !(XXHsDecl p)
-
type instance XTyClD (GhcPass _) = NoExtField
type instance XInstD (GhcPass _) = NoExtField
type instance XDerivD (GhcPass _) = NoExtField
@@ -181,50 +152,6 @@ type instance XDocD (GhcPass _) = NoExtField
type instance XRoleAnnotD (GhcPass _) = NoExtField
type instance XXHsDecl (GhcPass _) = NoExtCon
-{-
-Note [Top-level fixity signatures in an HsGroup]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-An `HsGroup p` stores every top-level fixity declarations in one of two places:
-
-1. hs_fixds :: [LFixitySig p]
-
- This stores fixity signatures for top-level declarations (e.g., functions,
- data constructors, classes, type families, etc.) as well as fixity
- signatures for class methods written outside of the class, as in this
- example:
-
- infixl 4 `m1`
- class C1 a where
- m1 :: a -> a -> a
-
-2. hs_tyclds :: [TyClGroup p]
-
- Each type class can be found in a TyClDecl inside a TyClGroup, and that
- TyClDecl stores the fixity signatures for its methods written inside of the
- class, as in this example:
-
- class C2 a where
- infixl 4 `m2`
- m2 :: a -> a -> a
-
-The story for fixity signatures for class methods is made slightly complicated
-by the fact that they can appear both inside and outside of the class itself,
-and both forms of fixity signatures are considered top-level. This matters
-in `GHC.Rename.Module.rnSrcDecls`, which must create a fixity environment out
-of all top-level fixity signatures before doing anything else. Therefore,
-`rnSrcDecls` must be aware of both (1) and (2) above. The
-`hsGroupTopLevelFixitySigs` function is responsible for collecting this
-information from an `HsGroup`.
-
-One might wonder why we even bother separating top-level fixity signatures
-into two places at all. That is, why not just take the fixity signatures
-from `hs_tyclds` and put them into `hs_fixds` so that they are all in one
-location? This ends up causing problems for `GHC.HsToCore.Quote.repTopDs`,
-which translates each fixity signature in `hs_fixds` and `hs_tyclds` into a
-Template Haskell `Dec`. If there are any duplicate signatures between the two
-fields, this will result in an error (#17608).
--}
-
-- | Partition a list of HsDecls into function/pattern bindings, signatures,
-- type family declarations, type family instances, and documentation comments.
--
@@ -257,40 +184,6 @@ partitionBindsAndSigs = go
-> (bs, ss, ts, tfis, dfis, L l d : docs)
_ -> pprPanic "partitionBindsAndSigs" (ppr decl)
--- | Haskell Group
---
--- A 'HsDecl' is categorised into a 'HsGroup' before being
--- fed to the renamer.
-data HsGroup p
- = HsGroup {
- hs_ext :: XCHsGroup p,
- hs_valds :: HsValBinds p,
- hs_splcds :: [LSpliceDecl p],
-
- hs_tyclds :: [TyClGroup p],
- -- A list of mutually-recursive groups;
- -- This includes `InstDecl`s as well;
- -- Parser generates a singleton list;
- -- renamer does dependency analysis
-
- hs_derivds :: [LDerivDecl p],
-
- hs_fixds :: [LFixitySig p],
- -- A list of fixity signatures defined for top-level
- -- declarations and class methods (defined outside of the class
- -- itself).
- -- See Note [Top-level fixity signatures in an HsGroup]
-
- hs_defds :: [LDefaultDecl p],
- hs_fords :: [LForeignDecl p],
- hs_warnds :: [LWarnDecls p],
- hs_annds :: [LAnnDecl p],
- hs_ruleds :: [LRuleDecls p],
-
- hs_docs :: [LDocDecl]
- }
- | XHsGroup !(XXHsGroup p)
-
type instance XCHsGroup (GhcPass _) = NoExtField
type instance XXHsGroup (GhcPass _) = NoExtCon
@@ -299,9 +192,6 @@ emptyGroup, emptyRdrGroup, emptyRnGroup :: HsGroup (GhcPass p)
emptyRdrGroup = emptyGroup { hs_valds = emptyValBindsIn }
emptyRnGroup = emptyGroup { hs_valds = emptyValBindsOut }
-hsGroupInstDecls :: HsGroup id -> [LInstDecl id]
-hsGroupInstDecls = (=<<) group_instds . hs_tyclds
-
emptyGroup = HsGroup { hs_ext = noExtField,
hs_tyclds = [],
hs_derivds = [],
@@ -415,17 +305,6 @@ instance (OutputableBndrId p) => Outputable (HsGroup (GhcPass p)) where
vcat_mb gap (Nothing : ds) = vcat_mb gap ds
vcat_mb gap (Just d : ds) = gap $$ d $$ vcat_mb blankLine ds
--- | Located Splice Declaration
-type LSpliceDecl pass = XRec pass (SpliceDecl pass)
-
--- | Splice Declaration
-data SpliceDecl p
- = SpliceDecl -- Top level splice
- (XSpliceDecl p)
- (XRec p (HsSplice p))
- SpliceExplicitFlag
- | XSpliceDecl !(XXSpliceDecl p)
-
type instance XSpliceDecl (GhcPass _) = NoExtField
type instance XXSpliceDecl (GhcPass _) = NoExtCon
@@ -439,236 +318,6 @@ instance OutputableBndrId p
Type and class declarations
* *
************************************************************************
-
-Note [The Naming story]
-~~~~~~~~~~~~~~~~~~~~~~~
-Here is the story about the implicit names that go with type, class,
-and instance decls. It's a bit tricky, so pay attention!
-
-"Implicit" (or "system") binders
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Each data type decl defines
- a worker name for each constructor
- to-T and from-T convertors
- Each class decl defines
- a tycon for the class
- a data constructor for that tycon
- the worker for that constructor
- a selector for each superclass
-
-All have occurrence names that are derived uniquely from their parent
-declaration.
-
-None of these get separate definitions in an interface file; they are
-fully defined by the data or class decl. But they may *occur* in
-interface files, of course. Any such occurrence must haul in the
-relevant type or class decl.
-
-Plan of attack:
- - Ensure they "point to" the parent data/class decl
- when loading that decl from an interface file
- (See RnHiFiles.getSysBinders)
-
- - When typechecking the decl, we build the implicit TyCons and Ids.
- When doing so we look them up in the name cache (GHC.Rename.Env.lookupSysName),
- to ensure correct module and provenance is set
-
-These are the two places that we have to conjure up the magic derived
-names. (The actual magic is in GHC.Types.Name.Occurrence.mkWorkerOcc, etc.)
-
-Default methods
-~~~~~~~~~~~~~~~
- - Occurrence name is derived uniquely from the method name
- E.g. $dmmax
-
- - If there is a default method name at all, it's recorded in
- the ClassOpSig (in GHC.Hs.Binds), in the DefMethInfo field.
- (DefMethInfo is defined in GHC.Core.Class)
-
-Source-code class decls and interface-code class decls are treated subtly
-differently, which has given me a great deal of confusion over the years.
-Here's the deal. (We distinguish the two cases because source-code decls
-have (Just binds) in the tcdMeths field, whereas interface decls have Nothing.
-
-In *source-code* class declarations:
-
- - When parsing, every ClassOpSig gets a DefMeth with a suitable RdrName
- This is done by GHC.Parser.PostProcess.mkClassOpSigDM
-
- - The renamer renames it to a Name
-
- - During typechecking, we generate a binding for each $dm for
- which there's a programmer-supplied default method:
- class Foo a where
- op1 :: <type>
- op2 :: <type>
- op1 = ...
- We generate a binding for $dmop1 but not for $dmop2.
- The Class for Foo has a Nothing for op2 and
- a Just ($dm_op1, VanillaDM) for op1.
- The Name for $dmop2 is simply discarded.
-
-In *interface-file* class declarations:
- - When parsing, we see if there's an explicit programmer-supplied default method
- because there's an '=' sign to indicate it:
- class Foo a where
- op1 = :: <type> -- NB the '='
- op2 :: <type>
- We use this info to generate a DefMeth with a suitable RdrName for op1,
- and a NoDefMeth for op2
- - The interface file has a separate definition for $dmop1, with unfolding etc.
- - The renamer renames it to a Name.
- - The renamer treats $dmop1 as a free variable of the declaration, so that
- the binding for $dmop1 will be sucked in. (See RnHsSyn.tyClDeclFVs)
- This doesn't happen for source code class decls, because they *bind* the default method.
-
-Dictionary functions
-~~~~~~~~~~~~~~~~~~~~
-Each instance declaration gives rise to one dictionary function binding.
-
-The type checker makes up new source-code instance declarations
-(e.g. from 'deriving' or generic default methods --- see
-GHC.Tc.TyCl.Instance.tcInstDecls1). So we can't generate the names for
-dictionary functions in advance (we don't know how many we need).
-
-On the other hand for interface-file instance declarations, the decl
-specifies the name of the dictionary function, and it has a binding elsewhere
-in the interface file:
- instance {Eq Int} = dEqInt
- dEqInt :: {Eq Int} <pragma info>
-
-So again we treat source code and interface file code slightly differently.
-
-Source code:
- - Source code instance decls have a Nothing in the (Maybe name) field
- (see data InstDecl below)
-
- - The typechecker makes up a Local name for the dict fun for any source-code
- instance decl, whether it comes from a source-code instance decl, or whether
- the instance decl is derived from some other construct (e.g. 'deriving').
-
- - The occurrence name it chooses is derived from the instance decl (just for
- documentation really) --- e.g. dNumInt. Two dict funs may share a common
- occurrence name, but will have different uniques. E.g.
- instance Foo [Int] where ...
- instance Foo [Bool] where ...
- These might both be dFooList
-
- - The CoreTidy phase externalises the name, and ensures the occurrence name is
- unique (this isn't special to dict funs). So we'd get dFooList and dFooList1.
-
- - We can take this relaxed approach (changing the occurrence name later)
- because dict fun Ids are not captured in a TyCon or Class (unlike default
- methods, say). Instead, they are kept separately in the InstEnv. This
- makes it easy to adjust them after compiling a module. (Once we've finished
- compiling that module, they don't change any more.)
-
-
-Interface file code:
- - The instance decl gives the dict fun name, so the InstDecl has a (Just name)
- in the (Maybe name) field.
-
- - RnHsSyn.instDeclFVs treats the dict fun name as free in the decl, so that we
- suck in the dfun binding
--}
-
--- | Located Declaration of a Type or Class
-type LTyClDecl pass = XRec pass (TyClDecl pass)
-
--- | A type or class declaration.
-data TyClDecl pass
- = -- | @type/data family T :: *->*@
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnType',
- -- 'GHC.Parser.Annotation.AnnData',
- -- 'GHC.Parser.Annotation.AnnFamily','GHC.Parser.Annotation.AnnDcolon',
- -- 'GHC.Parser.Annotation.AnnWhere','GHC.Parser.Annotation.AnnOpenP',
- -- 'GHC.Parser.Annotation.AnnDcolon','GHC.Parser.Annotation.AnnCloseP',
- -- 'GHC.Parser.Annotation.AnnEqual','GHC.Parser.Annotation.AnnRarrow',
- -- 'GHC.Parser.Annotation.AnnVbar'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- FamDecl { tcdFExt :: XFamDecl pass, tcdFam :: FamilyDecl pass }
-
- | -- | @type@ declaration
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnType',
- -- 'GHC.Parser.Annotation.AnnEqual',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- SynDecl { tcdSExt :: XSynDecl pass -- ^ Post renameer, FVs
- , tcdLName :: LIdP pass -- ^ Type constructor
- , tcdTyVars :: LHsQTyVars pass -- ^ Type variables; for an
- -- associated type these
- -- include outer binders
- , tcdFixity :: LexicalFixity -- ^ Fixity used in the declaration
- , tcdRhs :: LHsType pass } -- ^ RHS of type declaration
-
- | -- | @data@ declaration
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnData',
- -- 'GHC.Parser.Annotation.AnnFamily',
- -- 'GHC.Parser.Annotation.AnnNewType',
- -- 'GHC.Parser.Annotation.AnnNewType','GHC.Parser.Annotation.AnnDcolon'
- -- 'GHC.Parser.Annotation.AnnWhere',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- DataDecl { tcdDExt :: XDataDecl pass -- ^ Post renamer, CUSK flag, FVs
- , tcdLName :: LIdP pass -- ^ Type constructor
- , tcdTyVars :: LHsQTyVars pass -- ^ Type variables
- -- See Note [TyVar binders for associated declarations]
- , tcdFixity :: LexicalFixity -- ^ Fixity used in the declaration
- , tcdDataDefn :: HsDataDefn pass }
-
- | ClassDecl { tcdCExt :: XClassDecl pass, -- ^ Post renamer, FVs
- tcdCtxt :: LHsContext pass, -- ^ Context...
- tcdLName :: LIdP pass, -- ^ Name of the class
- tcdTyVars :: LHsQTyVars pass, -- ^ Class type variables
- tcdFixity :: LexicalFixity, -- ^ Fixity used in the declaration
- tcdFDs :: [LHsFunDep pass], -- ^ Functional deps
- tcdSigs :: [LSig pass], -- ^ Methods' signatures
- tcdMeths :: LHsBinds pass, -- ^ Default methods
- tcdATs :: [LFamilyDecl pass], -- ^ Associated types;
- tcdATDefs :: [LTyFamDefltDecl pass], -- ^ Associated type defaults
- tcdDocs :: [LDocDecl] -- ^ Haddock docs
- }
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnClass',
- -- 'GHC.Parser.Annotation.AnnWhere','GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnClose'
- -- - The tcdFDs will have 'GHC.Parser.Annotation.AnnVbar',
- -- 'GHC.Parser.Annotation.AnnComma'
- -- 'GHC.Parser.Annotation.AnnRarrow'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | XTyClDecl !(XXTyClDecl pass)
-
-type LHsFunDep pass = XRec pass (FunDep (LIdP pass))
-
-data DataDeclRn = DataDeclRn
- { tcdDataCusk :: Bool -- ^ does this have a CUSK?
- -- See Note [CUSKs: complete user-supplied kind signatures]
- , tcdFVs :: NameSet }
- deriving Data
-
-{- Note [TyVar binders for associated decls]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-For an /associated/ data, newtype, or type-family decl, the LHsQTyVars
-/includes/ outer binders. For example
- class T a where
- data D a c
- type F a b :: *
- type F a b = a -> a
-Here the data decl for 'D', and type-family decl for 'F', both include 'a'
-in their LHsQTyVars (tcdTyVars and fdTyVars resp).
-
-Ditto any implicit binders in the hsq_implicit field of the LHSQTyVars.
-
-The idea is that the associated type is really a top-level decl in its
-own right. However we are careful to use the same name 'a', so that
-we can match things up.
-
-c.f. Note [Associated type tyvar names] in GHC.Core.Class
- Note [Family instance declaration binders]
-}
type instance XFamDecl (GhcPass _) = NoExtField
@@ -685,74 +334,8 @@ type instance XClassDecl GhcPs = LayoutInfo -- See Note [Class LayoutInfo]
type instance XClassDecl GhcRn = NameSet -- FVs
type instance XClassDecl GhcTc = NameSet -- FVs
-{- Note [Class LayoutInfo]
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-The LayoutInfo is used to associate Haddock comments with parts of the declaration.
-Compare the following examples:
-
- class C a where
- f :: a -> Int
- -- ^ comment on f
-
- class C a where
- f :: a -> Int
- -- ^ comment on C
-
-Notice how "comment on f" and "comment on C" differ only by indentation level.
-Thus we have to record the indentation level of the class declarations.
-
-See also Note [Adding Haddock comments to the syntax tree] in GHC.Parser.PostProcess.Haddock
--}
-
type instance XXTyClDecl (GhcPass _) = NoExtCon
--- Simple classifiers for TyClDecl
--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
--- | @True@ <=> argument is a @data@\/@newtype@
--- declaration.
-isDataDecl :: TyClDecl pass -> Bool
-isDataDecl (DataDecl {}) = True
-isDataDecl _other = False
-
--- | type or type instance declaration
-isSynDecl :: TyClDecl pass -> Bool
-isSynDecl (SynDecl {}) = True
-isSynDecl _other = False
-
--- | type class
-isClassDecl :: TyClDecl pass -> Bool
-isClassDecl (ClassDecl {}) = True
-isClassDecl _ = False
-
--- | type/data family declaration
-isFamilyDecl :: TyClDecl pass -> Bool
-isFamilyDecl (FamDecl {}) = True
-isFamilyDecl _other = False
-
--- | type family declaration
-isTypeFamilyDecl :: TyClDecl pass -> Bool
-isTypeFamilyDecl (FamDecl _ (FamilyDecl { fdInfo = info })) = case info of
- OpenTypeFamily -> True
- ClosedTypeFamily {} -> True
- _ -> False
-isTypeFamilyDecl _ = False
-
--- | open type family info
-isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool
-isOpenTypeFamilyInfo OpenTypeFamily = True
-isOpenTypeFamilyInfo _ = False
-
--- | closed type family info
-isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool
-isClosedTypeFamilyInfo (ClosedTypeFamily {}) = True
-isClosedTypeFamilyInfo _ = False
-
--- | data family declaration
-isDataFamilyDecl :: TyClDecl pass -> Bool
-isDataFamilyDecl (FamDecl _ (FamilyDecl { fdInfo = DataFamily })) = True
-isDataFamilyDecl _other = False
-
-- Dealing with names
tyFamInstDeclName :: TyFamInstDecl (GhcPass p) -> IdP (GhcPass p)
@@ -773,25 +356,6 @@ tyClDeclLName (ClassDecl { tcdLName = ln }) = ln
tcdName :: TyClDecl (GhcPass p) -> IdP (GhcPass p)
tcdName = unLoc . tyClDeclLName
-tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass
-tyClDeclTyVars (FamDecl { tcdFam = FamilyDecl { fdTyVars = tvs } }) = tvs
-tyClDeclTyVars d = tcdTyVars d
-
-countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int)
- -- class, synonym decls, data, newtype, family decls
-countTyClDecls decls
- = (count isClassDecl decls,
- count isSynDecl decls, -- excluding...
- count isDataTy decls, -- ...family...
- count isNewTy decls, -- ...instances
- count isFamilyDecl decls)
- where
- isDataTy DataDecl{ tcdDataDefn = HsDataDefn { dd_ND = DataType } } = True
- isDataTy _ = False
-
- isNewTy DataDecl{ tcdDataDefn = HsDataDefn { dd_ND = NewType } } = True
- isNewTy _ = False
-
-- | Does this declaration have a complete, user-supplied kind signature?
-- See Note [CUSKs: complete user-supplied kind signatures]
hsDeclHasCusk :: TyClDecl GhcRn -> Bool
@@ -885,95 +449,6 @@ pprTyClDeclFlavour (FamDecl { tcdFam = FamilyDecl { fdInfo = info }})
pprTyClDeclFlavour (DataDecl { tcdDataDefn = HsDataDefn { dd_ND = nd } })
= ppr nd
-
-{- Note [CUSKs: complete user-supplied kind signatures]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-We kind-check declarations differently if they have a complete, user-supplied
-kind signature (CUSK). This is because we can safely generalise a CUSKed
-declaration before checking all of the others, supporting polymorphic recursion.
-See https://gitlab.haskell.org/ghc/ghc/wikis/ghc-kinds/kind-inference#proposed-new-strategy
-and #9200 for lots of discussion of how we got here.
-
-The detection of CUSKs is enabled by the -XCUSKs extension, switched on by default.
-Under -XNoCUSKs, all declarations are treated as if they have no CUSK.
-See https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0036-kind-signatures.rst
-
-PRINCIPLE:
- a type declaration has a CUSK iff we could produce a separate kind signature
- for it, just like a type signature for a function,
- looking only at the header of the declaration.
-
-Examples:
- * data T1 (a :: *->*) (b :: *) = ....
- -- Has CUSK; equivalant to T1 :: (*->*) -> * -> *
-
- * data T2 a b = ...
- -- No CUSK; we do not want to guess T2 :: * -> * -> *
- -- because the full decl might be data T a b = MkT (a b)
-
- * data T3 (a :: k -> *) (b :: *) = ...
- -- CUSK; equivalent to T3 :: (k -> *) -> * -> *
- -- We lexically generalise over k to get
- -- T3 :: forall k. (k -> *) -> * -> *
- -- The generalisation is here is purely lexical, just like
- -- f3 :: a -> a
- -- means
- -- f3 :: forall a. a -> a
-
- * data T4 (a :: j k) = ...
- -- CUSK; equivalent to T4 :: j k -> *
- -- which we lexically generalise to T4 :: forall j k. j k -> *
- -- and then, if PolyKinds is on, we further generalise to
- -- T4 :: forall kk (j :: kk -> *) (k :: kk). j k -> *
- -- Again this is exactly like what happens as the term level
- -- when you write
- -- f4 :: forall a b. a b -> Int
-
-NOTE THAT
- * A CUSK does /not/ mean that everything about the kind signature is
- fully specified by the user. Look at T4 and f4: we had to do kind
- inference to figure out the kind-quantification. But in both cases
- (T4 and f4) that inference is done looking /only/ at the header of T4
- (or signature for f4), not at the definition thereof.
-
- * The CUSK completely fixes the kind of the type constructor, forever.
-
- * The precise rules, for each declaration form, for whether a declaration
- has a CUSK are given in the user manual section "Complete user-supplied
- kind signatures and polymorphic recursion". But they simply implement
- PRINCIPLE above.
-
- * Open type families are interesting:
- type family T5 a b :: *
- There simply /is/ no accompanying declaration, so that info is all
- we'll ever get. So we it has a CUSK by definition, and we default
- any un-fixed kind variables to *.
-
- * Associated types are a bit tricker:
- class C6 a where
- type family T6 a b :: *
- op :: a Int -> Int
- Here C6 does not have a CUSK (in fact we ultimately discover that
- a :: * -> *). And hence neither does T6, the associated family,
- because we can't fix its kind until we have settled C6. Another
- way to say it: unlike a top-level, we /may/ discover more about
- a's kind from C6's definition.
-
- * A data definition with a top-level :: must explicitly bind all
- kind variables to the right of the ::. See test
- dependent/should_compile/KindLevels, which requires this
- case. (Naturally, any kind variable mentioned before the :: should
- not be bound after it.)
-
- This last point is much more debatable than the others; see
- #15142 comment:22
-
- Because this is fiddly to check, there is a field in the DataDeclRn
- structure (included in a DataDecl after the renamer) that stores whether
- or not the declaration has a CUSK.
--}
-
-
{- *********************************************************************
* *
TyClGroup
@@ -982,210 +457,26 @@ NOTE THAT
* *
********************************************************************* -}
-{- Note [TyClGroups and dependency analysis]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-A TyClGroup represents a strongly connected components of type/class/instance
-decls, together with the role annotations for the type/class declarations.
-
-The hs_tyclds :: [TyClGroup] field of a HsGroup is a dependency-order
-sequence of strongly-connected components.
-
-Invariants
- * The type and class declarations, group_tyclds, may depend on each
- other, or earlier TyClGroups, but not on later ones
-
- * The role annotations, group_roles, are role-annotations for some or
- all of the types and classes in group_tyclds (only).
-
- * The instance declarations, group_instds, may (and usually will)
- depend on group_tyclds, or on earlier TyClGroups, but not on later
- ones.
-
-See Note [Dependency analysis of type, class, and instance decls]
-in GHC.Rename.Module for more info.
--}
-
--- | Type or Class Group
-data TyClGroup pass -- See Note [TyClGroups and dependency analysis]
- = TyClGroup { group_ext :: XCTyClGroup pass
- , group_tyclds :: [LTyClDecl pass]
- , group_roles :: [LRoleAnnotDecl pass]
- , group_kisigs :: [LStandaloneKindSig pass]
- , group_instds :: [LInstDecl pass] }
- | XTyClGroup !(XXTyClGroup pass)
-
type instance XCTyClGroup (GhcPass _) = NoExtField
type instance XXTyClGroup (GhcPass _) = NoExtCon
-tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass]
-tyClGroupTyClDecls = concatMap group_tyclds
-
-tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass]
-tyClGroupInstDecls = concatMap group_instds
-
-tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]
-tyClGroupRoleDecls = concatMap group_roles
-
-tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass]
-tyClGroupKindSigs = concatMap group_kisigs
-
-
{- *********************************************************************
* *
Data and type family declarations
* *
********************************************************************* -}
-{- Note [FamilyResultSig]
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-This data type represents the return signature of a type family. Possible
-values are:
-
- * NoSig - the user supplied no return signature:
- type family Id a where ...
-
- * KindSig - the user supplied the return kind:
- type family Id a :: * where ...
-
- * TyVarSig - user named the result with a type variable and possibly
- provided a kind signature for that variable:
- type family Id a = r where ...
- type family Id a = (r :: *) where ...
-
- Naming result of a type family is required if we want to provide
- injectivity annotation for a type family:
- type family Id a = r | r -> a where ...
-
-See also: Note [Injectivity annotation]
-
-Note [Injectivity annotation]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-A user can declare a type family to be injective:
-
- type family Id a = r | r -> a where ...
-
- * The part after the "|" is called "injectivity annotation".
- * "r -> a" part is called "injectivity condition"; at the moment terms
- "injectivity annotation" and "injectivity condition" are synonymous
- because we only allow a single injectivity condition.
- * "r" is the "LHS of injectivity condition". LHS can only contain the
- variable naming the result of a type family.
-
- * "a" is the "RHS of injectivity condition". RHS contains space-separated
- type and kind variables representing the arguments of a type
- family. Variables can be omitted if a type family is not injective in
- these arguments. Example:
- type family Foo a b c = d | d -> a c where ...
-
-Note that:
- (a) naming of type family result is required to provide injectivity
- annotation
- (b) for associated types if the result was named then injectivity annotation
- is mandatory. Otherwise result type variable is indistinguishable from
- associated type default.
-
-It is possible that in the future this syntax will be extended to support
-more complicated injectivity annotations. For example we could declare that
-if we know the result of Plus and one of its arguments we can determine the
-other argument:
-
- type family Plus a b = (r :: Nat) | r a -> b, r b -> a where ...
-
-Here injectivity annotation would consist of two comma-separated injectivity
-conditions.
-
-See also Note [Injective type families] in GHC.Core.TyCon
--}
-
--- | Located type Family Result Signature
-type LFamilyResultSig pass = XRec pass (FamilyResultSig pass)
-
--- | type Family Result Signature
-data FamilyResultSig pass = -- see Note [FamilyResultSig]
- NoSig (XNoSig pass)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' :
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | KindSig (XCKindSig pass) (LHsKind pass)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' :
- -- 'GHC.Parser.Annotation.AnnOpenP','GHC.Parser.Annotation.AnnDcolon',
- -- 'GHC.Parser.Annotation.AnnCloseP'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' :
- -- 'GHC.Parser.Annotation.AnnOpenP','GHC.Parser.Annotation.AnnDcolon',
- -- 'GHC.Parser.Annotation.AnnCloseP', 'GHC.Parser.Annotation.AnnEqual'
- | XFamilyResultSig !(XXFamilyResultSig pass)
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
type instance XNoSig (GhcPass _) = NoExtField
type instance XCKindSig (GhcPass _) = NoExtField
type instance XTyVarSig (GhcPass _) = NoExtField
type instance XXFamilyResultSig (GhcPass _) = NoExtCon
-
--- | Located type Family Declaration
-type LFamilyDecl pass = XRec pass (FamilyDecl pass)
-
--- | type Family Declaration
-data FamilyDecl pass = FamilyDecl
- { fdExt :: XCFamilyDecl pass
- , fdInfo :: FamilyInfo pass -- type/data, closed/open
- , fdLName :: LIdP pass -- type constructor
- , fdTyVars :: LHsQTyVars pass -- type variables
- -- See Note [TyVar binders for associated declarations]
- , fdFixity :: LexicalFixity -- Fixity used in the declaration
- , fdResultSig :: LFamilyResultSig pass -- result signature
- , fdInjectivityAnn :: Maybe (LInjectivityAnn pass) -- optional injectivity ann
- }
- | XFamilyDecl !(XXFamilyDecl pass)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnType',
- -- 'GHC.Parser.Annotation.AnnData', 'GHC.Parser.Annotation.AnnFamily',
- -- 'GHC.Parser.Annotation.AnnWhere', 'GHC.Parser.Annotation.AnnOpenP',
- -- 'GHC.Parser.Annotation.AnnDcolon', 'GHC.Parser.Annotation.AnnCloseP',
- -- 'GHC.Parser.Annotation.AnnEqual', 'GHC.Parser.Annotation.AnnRarrow',
- -- 'GHC.Parser.Annotation.AnnVbar'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
type instance XCFamilyDecl (GhcPass _) = NoExtField
type instance XXFamilyDecl (GhcPass _) = NoExtCon
--- | Located Injectivity Annotation
-type LInjectivityAnn pass = XRec pass (InjectivityAnn pass)
-
--- | If the user supplied an injectivity annotation it is represented using
--- InjectivityAnn. At the moment this is a single injectivity condition - see
--- Note [Injectivity annotation]. `Located name` stores the LHS of injectivity
--- condition. `[Located name]` stores the RHS of injectivity condition. Example:
---
--- type family Foo a b c = r | r -> a c where ...
---
--- This will be represented as "InjectivityAnn `r` [`a`, `c`]"
-data InjectivityAnn pass
- = InjectivityAnn (LIdP pass) [LIdP pass]
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' :
- -- 'GHC.Parser.Annotation.AnnRarrow', 'GHC.Parser.Annotation.AnnVbar'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
-data FamilyInfo pass
- = DataFamily
- | OpenTypeFamily
- -- | 'Nothing' if we're in an hs-boot file and the user
- -- said "type family Foo x where .."
- | ClosedTypeFamily (Maybe [LTyFamInstEqn pass])
-
-
------------- Functions over FamilyDecls -----------
familyDeclLName :: FamilyDecl (GhcPass p) -> Located (IdP (GhcPass p))
@@ -1245,14 +536,6 @@ pprFamilyDecl top_level (FamilyDecl { fdInfo = info, fdLName = ltycon
Just eqns -> vcat $ map (ppr_fam_inst_eqn . unLoc) eqns )
_ -> (empty, empty)
-pprFlavour :: FamilyInfo pass -> SDoc
-pprFlavour DataFamily = text "data"
-pprFlavour OpenTypeFamily = text "type"
-pprFlavour (ClosedTypeFamily {}) = text "type"
-
-instance Outputable (FamilyInfo pass) where
- ppr info = pprFlavour info <+> text "family"
-
{- *********************************************************************
@@ -1261,75 +544,10 @@ instance Outputable (FamilyInfo pass) where
* *
********************************************************************* -}
--- | Haskell Data type Definition
-data HsDataDefn pass -- The payload of a data type defn
- -- Used *both* for vanilla data declarations,
- -- *and* for data family instances
- = -- | Declares a data type or newtype, giving its constructors
- -- @
- -- data/newtype T a = <constrs>
- -- data/newtype instance T [a] = <constrs>
- -- @
- HsDataDefn { dd_ext :: XCHsDataDefn pass,
- dd_ND :: NewOrData,
- dd_ctxt :: LHsContext pass, -- ^ Context
- dd_cType :: Maybe (XRec pass CType),
- dd_kindSig:: Maybe (LHsKind pass),
- -- ^ Optional kind signature.
- --
- -- @(Just k)@ for a GADT-style @data@,
- -- or @data instance@ decl, with explicit kind sig
- --
- -- Always @Nothing@ for H98-syntax decls
-
- dd_cons :: [LConDecl pass],
- -- ^ Data constructors
- --
- -- For @data T a = T1 | T2 a@
- -- the 'LConDecl's all have 'ConDeclH98'.
- -- For @data T a where { T1 :: T a }@
- -- the 'LConDecls' all have 'ConDeclGADT'.
-
- dd_derivs :: HsDeriving pass -- ^ Optional 'deriving' clause
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- }
- | XHsDataDefn !(XXHsDataDefn pass)
-
type instance XCHsDataDefn (GhcPass _) = NoExtField
type instance XXHsDataDefn (GhcPass _) = NoExtCon
--- | Haskell Deriving clause
-type HsDeriving pass = XRec pass [LHsDerivingClause pass]
- -- ^ The optional @deriving@ clauses of a data declaration. "Clauses" is
- -- plural because one can specify multiple deriving clauses using the
- -- @-XDerivingStrategies@ language extension.
- --
- -- The list of 'LHsDerivingClause's corresponds to exactly what the user
- -- requested to derive, in order. If no deriving clauses were specified,
- -- the list is empty.
-
-type LHsDerivingClause pass = XRec pass (HsDerivingClause pass)
-
--- | A single @deriving@ clause of a data declaration.
---
--- - 'GHC.Parser.Annotation.AnnKeywordId' :
--- 'GHC.Parser.Annotation.AnnDeriving', 'GHC.Parser.Annotation.AnnStock',
--- 'GHC.Parser.Annotation.AnnAnyClass', 'Api.AnnNewtype',
--- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnClose'
-data HsDerivingClause pass
- -- See Note [Deriving strategies] in GHC.Tc.Deriv
- = HsDerivingClause
- { deriv_clause_ext :: XCHsDerivingClause pass
- , deriv_clause_strategy :: Maybe (LDerivStrategy pass)
- -- ^ The user-specified strategy (if any) to use when deriving
- -- 'deriv_clause_tys'.
- , deriv_clause_tys :: LDerivClauseTys pass
- -- ^ The types to derive.
- }
- | XHsDerivingClause !(XXHsDerivingClause pass)
-
type instance XCHsDerivingClause (GhcPass _) = NoExtField
type instance XXHsDerivingClause (GhcPass _) = NoExtCon
@@ -1349,35 +567,6 @@ instance OutputableBndrId p
Just (L _ via@ViaStrategy{}) -> (empty, ppr via)
_ -> (ppDerivStrategy dcs, empty)
-type LDerivClauseTys pass = XRec pass (DerivClauseTys pass)
-
--- | The types mentioned in a single @deriving@ clause. This can come in two
--- forms, 'DctSingle' or 'DctMulti', depending on whether the types are
--- surrounded by enclosing parentheses or not. These parentheses are
--- semantically differnt than 'HsParTy'. For example, @deriving ()@ means
--- \"derive zero classes\" rather than \"derive an instance of the 0-tuple\".
---
--- 'DerivClauseTys' use 'LHsSigType' because @deriving@ clauses can mention
--- type variables that aren't bound by the datatype, e.g.
---
--- > data T b = ... deriving (C [a])
---
--- should produce a derived instance for @C [a] (T b)@.
-data DerivClauseTys pass
- = -- | A @deriving@ clause with a single type. Moreover, that type can only
- -- be a type constructor without any arguments.
- --
- -- Example: @deriving Eq@
- DctSingle (XDctSingle pass) (LHsSigType pass)
-
- -- | A @deriving@ clause with a comma-separated list of types, surrounded
- -- by enclosing parentheses.
- --
- -- Example: @deriving (Eq, C a)@
- | DctMulti (XDctMulti pass) [LHsSigType pass]
-
- | XDerivClauseTys !(XXDerivClauseTys pass)
-
type instance XDctSingle (GhcPass _) = NoExtField
type instance XDctMulti (GhcPass _) = NoExtField
type instance XXDerivClauseTys (GhcPass _) = NoExtCon
@@ -1386,252 +575,17 @@ instance OutputableBndrId p => Outputable (DerivClauseTys (GhcPass p)) where
ppr (DctSingle _ ty) = ppr ty
ppr (DctMulti _ tys) = parens (interpp'SP tys)
--- | Located Standalone Kind Signature
-type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass)
-
-data StandaloneKindSig pass
- = StandaloneKindSig (XStandaloneKindSig pass)
- (LIdP pass) -- Why a single binder? See #16754
- (LHsSigType pass) -- Why not LHsSigWcType? See Note [Wildcards in standalone kind signatures]
- | XStandaloneKindSig !(XXStandaloneKindSig pass)
-
type instance XStandaloneKindSig (GhcPass p) = NoExtField
type instance XXStandaloneKindSig (GhcPass p) = NoExtCon
standaloneKindSigName :: StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
standaloneKindSigName (StandaloneKindSig _ lname _) = unLoc lname
-{- Note [Wildcards in standalone kind signatures]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Standalone kind signatures enable polymorphic recursion, and it is unclear how
-to reconcile this with partial type signatures, so we disallow wildcards in
-them.
-
-We reject wildcards in 'rnStandaloneKindSignature' by returning False for
-'StandaloneKindSigCtx' in 'wildCardsAllowed'.
-
-The alternative design is to have special treatment for partial standalone kind
-signatures, much like we have special treatment for partial type signatures in
-terms. However, partial standalone kind signatures are not a proper replacement
-for CUSKs, so this would be a separate feature.
--}
-
-data NewOrData
- = NewType -- ^ @newtype Blah ...@
- | DataType -- ^ @data Blah ...@
- deriving( Eq, Data ) -- Needed because Demand derives Eq
-
--- | Convert a 'NewOrData' to a 'TyConFlavour'
-newOrDataToFlavour :: NewOrData -> TyConFlavour
-newOrDataToFlavour NewType = NewtypeFlavour
-newOrDataToFlavour DataType = DataTypeFlavour
-
-
--- | Located data Constructor Declaration
-type LConDecl pass = XRec pass (ConDecl pass)
- -- ^ May have 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnSemi' when
- -- in a GADT constructor list
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- |
---
--- @
--- data T b = forall a. Eq a => MkT a b
--- MkT :: forall b a. Eq a => MkT a b
---
--- data T b where
--- MkT1 :: Int -> T Int
---
--- data T = Int `MkT` Int
--- | MkT2
---
--- data T a where
--- Int `MkT` Int :: T Int
--- @
---
--- - 'GHC.Parser.Annotation.AnnKeywordId's : 'GHC.Parser.Annotation.AnnOpen',
--- 'GHC.Parser.Annotation.AnnDotdot','GHC.Parser.Annotation.AnnCLose',
--- 'GHC.Parser.Annotation.AnnEqual','GHC.Parser.Annotation.AnnVbar',
--- 'GHC.Parser.Annotation.AnnDarrow','GHC.Parser.Annotation.AnnDarrow',
--- 'GHC.Parser.Annotation.AnnForall','GHC.Parser.Annotation.AnnDot'
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- | data Constructor Declaration
-data ConDecl pass
- = ConDeclGADT
- { con_g_ext :: XConDeclGADT pass
- , con_names :: [LIdP pass]
-
- -- The following fields describe the type after the '::'
- -- See Note [GADT abstract syntax]
- , con_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass)
- -- ^ The outermost type variable binders, be they explicit or implicit.
- -- The 'XRec' is used to anchor API annotations, AnnForall and AnnDot.
- , con_mb_cxt :: Maybe (LHsContext pass) -- ^ User-written context (if any)
- , con_g_args :: HsConDeclGADTDetails pass -- ^ Arguments; never infix
- , con_res_ty :: LHsType pass -- ^ Result type
-
- , con_doc :: Maybe LHsDocString
- -- ^ A possible Haddock comment.
- }
-
- | ConDeclH98
- { con_ext :: XConDeclH98 pass
- , con_name :: LIdP pass
-
- , con_forall :: XRec pass Bool
- -- ^ True <=> explicit user-written forall
- -- e.g. data T a = forall b. MkT b (b->a)
- -- con_ex_tvs = {b}
- -- False => con_ex_tvs is empty
- , con_ex_tvs :: [LHsTyVarBndr Specificity pass] -- ^ Existentials only
- , con_mb_cxt :: Maybe (LHsContext pass) -- ^ User-written context (if any)
- , con_args :: HsConDeclH98Details pass -- ^ Arguments; can be infix
-
- , con_doc :: Maybe LHsDocString
- -- ^ A possible Haddock comment.
- }
- | XConDecl !(XXConDecl pass)
-
type instance XConDeclGADT (GhcPass _) = NoExtField
type instance XConDeclH98 (GhcPass _) = NoExtField
type instance XXConDecl (GhcPass _) = NoExtCon
-{- Note [GADT abstract syntax]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The types of both forms of GADT constructors are very structured, as they
-must consist of the quantified type variables (if provided), followed by the
-context (if provided), followed by the argument types (if provided), followed
-by the result type. (See "Wrinkle: No nested foralls or contexts" below for
-more discussion on the restrictions imposed here.) As a result, instead of
-storing the type of a GADT constructor as a single LHsType, we split it up
-into its constituent components for easier access.
-
-There are two broad ways to classify GADT constructors:
-
-* Record-syntax constructors. For example:
-
- data T a where
- K :: forall a. Ord a => { x :: [a], ... } -> T a
-
-* Prefix constructors, which do not use record syntax. For example:
-
- data T a where
- K :: forall a. Ord a => [a] -> ... -> T a
-
-This distinction is recorded in the `con_args :: HsConDetails pass`, which
-tracks if we're dealing with a RecCon or PrefixCon. It is easy to distinguish
-the two in the AST since record GADT constructors use HsRecTy. This distinction
-is made in GHC.Parser.PostProcess.mkGadtDecl.
-
-It is worth elaborating a bit more on the process of splitting the argument
-types of a GADT constructor, since there are some non-obvious details involved.
-While splitting the argument types of a record GADT constructor is easy (they
-are stored in an HsRecTy), splitting the arguments of a prefix GADT constructor
-is trickier. The basic idea is that we must split along the outermost function
-arrows ((->) and (%1 ->)) in the type, which GHC.Hs.Type.splitHsFunType
-accomplishes. But what about type operators? Consider:
-
- C :: a :*: b -> a :*: b -> a :+: b
-
-This could parse in many different ways depending on the precedences of each
-type operator. In particular, if (:*:) were to have lower precedence than (->),
-then it could very well parse like this:
-
- a :*: ((b -> a) :*: ((b -> a) :+: b)))
-
-This would give the false impression that the whole type is part of one large
-return type, with no arguments. Note that we do not fully resolve the exact
-precedences of each user-defined type operator until the renamer, so this a
-more difficult task for the parser.
-
-Fortunately, there is no risk of the above happening. GHC's parser gives
-special treatment to function arrows, and as a result, they are always parsed
-with a lower precedence than any other type operator. As a result, the type
-above is actually parsed like this:
-
- (a :*: b) -> ((a :*: b) -> (a :+: b))
-
-While we won't know the exact precedences of (:*:) and (:+:) until the renamer,
-all we are concerned about in the parser is identifying the overall shape of
-the argument and result types, which we can accomplish by piggybacking on the
-special treatment given to function arrows. In a future where function arrows
-aren't given special status in the parser, we will likely have to modify
-GHC.Parser.PostProcess.mkHsOpTyPV to preserve this trick.
-
------
--- Wrinkle: No nested foralls or contexts
------
-
-GADT constructors provide some freedom to change the order of foralls in their
-types (see Note [DataCon user type variable binders] in GHC.Core.DataCon), but
-this freedom is still limited. GADTs still require that all quantification
-occurs "prenex". That is, any explicitly quantified type variables must occur
-at the front of the GADT type, followed by any contexts, followed by the body of
-the GADT type, in precisely that order. For instance:
-
- data T where
- MkT1 :: forall a b. (Eq a, Eq b) => a -> b -> T
- -- OK
- MkT2 :: forall a. Eq a => forall b. a -> b -> T
- -- Rejected, `forall b` is nested
- MkT3 :: forall a b. Eq a => Eq b => a -> b -> T
- -- Rejected, `Eq b` is nested
- MkT4 :: Int -> forall a. a -> T
- -- Rejected, `forall a` is nested
- MkT5 :: forall a. Int -> Eq a => a -> T
- -- Rejected, `Eq a` is nested
- MkT6 :: (forall a. a -> T)
- -- Rejected, `forall a` is nested due to the surrounding parentheses
- MkT7 :: (Eq a => a -> t)
- -- Rejected, `Eq a` is nested due to the surrounding parentheses
-
-For the full details, see the "Formal syntax for GADTs" section of the GHC
-User's Guide. GHC enforces that GADT constructors do not have nested `forall`s
-or contexts in two parts:
-
-1. GHC, in the process of splitting apart a GADT's type,
- extracts out the leading `forall` and context (if they are provided). To
- accomplish this splitting, the renamer uses the
- GHC.Hs.Type.splitLHsGADTPrefixTy function, which is careful not to remove
- parentheses surrounding the leading `forall` or context (as these
- parentheses can be syntactically significant). If the third result returned
- by splitLHsGADTPrefixTy contains any `forall`s or contexts, then they must
- be nested, so they will be rejected.
-
- Note that this step applies to both prefix and record GADTs alike, as they
- both have syntax which permits `forall`s and contexts. The difference is
- where this step happens:
-
- * For prefix GADTs, this happens in the renamer (in rnConDecl), as we cannot
- split until after the type operator fixities have been resolved.
- * For record GADTs, this happens in the parser (in mkGadtDecl).
-2. If the GADT type is prefix, the renamer (in the ConDeclGADTPrefixPs case of
- rnConDecl) will then check for nested `forall`s/contexts in the body of a
- prefix GADT type, after it has determined what all of the argument types are.
- This step is necessary to catch examples like MkT4 above, where the nested
- quantification occurs after a visible argument type.
--}
-
--- | The arguments in a Haskell98-style data constructor.
-type HsConDeclH98Details pass
- = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass])
--- The Void argument to HsConDetails here is a reflection of the fact that
--- type applications are not allowed in data constructor declarations.
-
--- | The arguments in a GADT constructor. Unlike Haskell98-style constructors,
--- GADT constructors cannot be declared with infix syntax. As a result, we do
--- not use 'HsConDetails' here, as 'InfixCon' would be an unrepresentable
--- state. (There is a notion of infix GADT constructors for the purposes of
--- derived Show instances—see Note [Infix GADT constructors] in
--- GHC.Tc.TyCl—but that is an orthogonal concern.)
-data HsConDeclGADTDetails pass
- = PrefixConGADT [HsScaled pass (LBangType pass)]
- | RecConGADT (XRec pass [LConDeclField pass])
-
getConNames :: ConDecl GhcRn -> [Located Name]
getConNames ConDeclH98 {con_name = name} = [name]
getConNames ConDeclGADT {con_names = names} = names
@@ -1685,10 +639,6 @@ instance OutputableBndrId p
ppr (StandaloneKindSig _ v ki)
= text "type" <+> pprPrefixOcc (unLoc v) <+> text "::" <+> ppr ki
-instance Outputable NewOrData where
- ppr NewType = text "newtype"
- ppr DataType = text "data"
-
pp_condecls :: forall p. OutputableBndrId p => [LConDecl (GhcPass p)] -> SDoc
pp_condecls cs
| gadt_syntax -- In GADT syntax
@@ -1749,190 +699,18 @@ ppr_con_names = pprWithCommas (pprPrefixOcc . unLoc)
Instance declarations
* *
************************************************************************
-
-Note [Type family instance declarations in HsSyn]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The data type FamEqn represents one equation of a type family instance.
-Aside from the pass, it is also parameterised over another field, feqn_rhs.
-feqn_rhs is either an HsDataDefn (for data family instances) or an LHsType
-(for type family instances).
-
-Type family instances also include associated type family default equations.
-That is because a default for a type family looks like this:
-
- class C a where
- type family F a b :: Type
- type F c d = (c,d) -- Default instance
-
-The default declaration is really just a `type instance` declaration, but one
-with particularly simple patterns: they must all be distinct type variables.
-That's because we will instantiate it (in an instance declaration for `C`) if
-we don't give an explicit instance for `F`. Note that the names of the
-variables don't need to match those of the class: it really is like a
-free-standing `type instance` declaration.
--}
-
------------------ Type synonym family instances -------------
-
--- | Located Type Family Instance Equation
-type LTyFamInstEqn pass = XRec pass (TyFamInstEqn pass)
- -- ^ May have 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnSemi'
- -- when in a list
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- | Haskell Type Patterns
-type HsTyPats pass = [LHsTypeArg pass]
-
-{- Note [Family instance declaration binders]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The feqn_pats field of FamEqn (family instance equation) stores the LHS type
-(and kind) patterns. Any type (and kind) variables contained
-in these type patterns are bound in the feqn_bndrs field.
-Note that in particular:
-
-* The feqn_bndrs *include* any anonymous wildcards. For example
- type instance F a _ = a
- The feqn_bndrs will be HsOuterImplicit {a, _}. Remember that each separate
- wildcard '_' gets its own unique. In this context wildcards behave just like
- an ordinary type variable, only anonymous.
-
-* The feqn_bndrs *include* type variables that are already in scope
-
- Eg class C s t where
- type F t p :: *
- instance C w (a,b) where
- type F (a,b) x = x->a
- The feqn_bndrs of the F decl is HsOuterImplicit {a,b,x}, even though the
- F decl is nested inside the 'instance' decl.
-
- However after the renamer, the uniques will match up:
- instance C w7 (a8,b9) where
- type F (a8,b9) x10 = x10->a8
- so that we can compare the type pattern in the 'instance' decl and
- in the associated 'type' decl
-
-c.f. Note [TyVar binders for associated decls]
-}
--- | Type Family Instance Equation
-type TyFamInstEqn pass = FamEqn pass (LHsType pass)
- -- Here, the @pats@ are type patterns (with kind and type bndrs).
- -- See Note [Family instance declaration binders]
-
--- | Type family default declarations.
--- A convenient synonym for 'TyFamInstDecl'.
--- See @Note [Type family instance declarations in HsSyn]@.
-type TyFamDefltDecl = TyFamInstDecl
-
--- | Located type family default declarations.
-type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass)
-
--- | Located Type Family Instance Declaration
-type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass)
-
--- | Type Family Instance Declaration
-newtype TyFamInstDecl pass = TyFamInstDecl { tfid_eqn :: TyFamInstEqn pass }
- -- ^
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnType',
- -- 'GHC.Parser.Annotation.AnnInstance',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
------------------ Data family instances -------------
-
--- | Located Data Family Instance Declaration
-type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass)
-
--- | Data Family Instance Declaration
-newtype DataFamInstDecl pass
- = DataFamInstDecl { dfid_eqn :: FamEqn pass (HsDataDefn pass) }
- -- ^
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnData',
- -- 'GHC.Parser.Annotation.AnnNewType','GHC.Parser.Annotation.AnnInstance',
- -- 'GHC.Parser.Annotation.AnnDcolon'
- -- 'GHC.Parser.Annotation.AnnWhere','GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
------------------ Family instances (common types) -------------
-
--- | Family Equation
---
--- One equation in a type family instance declaration, data family instance
--- declaration, or type family default.
--- See Note [Type family instance declarations in HsSyn]
--- See Note [Family instance declaration binders]
-data FamEqn pass rhs
- = FamEqn
- { feqn_ext :: XCFamEqn pass rhs
- , feqn_tycon :: LIdP pass
- , feqn_bndrs :: HsOuterFamEqnTyVarBndrs pass -- ^ Optional quantified type vars
- , feqn_pats :: HsTyPats pass
- , feqn_fixity :: LexicalFixity -- ^ Fixity used in the declaration
- , feqn_rhs :: rhs
- }
- -- ^
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnEqual'
- | XFamEqn !(XXFamEqn pass rhs)
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
type instance XCFamEqn (GhcPass _) r = NoExtField
type instance XXFamEqn (GhcPass _) r = NoExtCon
----------------- Class instances -------------
--- | Located Class Instance Declaration
-type LClsInstDecl pass = XRec pass (ClsInstDecl pass)
-
--- | Class Instance Declaration
-data ClsInstDecl pass
- = ClsInstDecl
- { cid_ext :: XCClsInstDecl pass
- , cid_poly_ty :: LHsSigType pass -- Context => Class Instance-type
- -- Using a polytype means that the renamer conveniently
- -- figures out the quantified type variables for us.
- , cid_binds :: LHsBinds pass -- Class methods
- , cid_sigs :: [LSig pass] -- User-supplied pragmatic info
- , cid_tyfam_insts :: [LTyFamInstDecl pass] -- Type family instances
- , cid_datafam_insts :: [LDataFamInstDecl pass] -- Data family instances
- , cid_overlap_mode :: Maybe (XRec pass OverlapMode)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnClose',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- }
- -- ^
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnInstance',
- -- 'GHC.Parser.Annotation.AnnWhere',
- -- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnClose',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | XClsInstDecl !(XXClsInstDecl pass)
-
type instance XCClsInstDecl (GhcPass _) = NoExtField
type instance XXClsInstDecl (GhcPass _) = NoExtCon
----------------- Instances of all kinds -------------
--- | Located Instance Declaration
-type LInstDecl pass = XRec pass (InstDecl pass)
-
--- | Instance Declaration
-data InstDecl pass -- Both class and family instances
- = ClsInstD
- { cid_d_ext :: XClsInstD pass
- , cid_inst :: ClsInstDecl pass }
- | DataFamInstD -- data family instance
- { dfid_ext :: XDataFamInstD pass
- , dfid_inst :: DataFamInstDecl pass }
- | TyFamInstD -- type family instance
- { tfid_ext :: XTyFamInstD pass
- , tfid_inst :: TyFamInstDecl pass }
- | XInstDecl !(XXInstDecl pass)
-
type instance XClsInstD (GhcPass _) = NoExtField
type instance XDataFamInstD (GhcPass _) = NoExtField
type instance XTyFamInstD (GhcPass _) = NoExtField
@@ -2074,35 +852,6 @@ instDeclDataFamInsts inst_decls
************************************************************************
-}
--- | Located stand-alone 'deriving instance' declaration
-type LDerivDecl pass = XRec pass (DerivDecl pass)
-
--- | Stand-alone 'deriving instance' declaration
-data DerivDecl pass = DerivDecl
- { deriv_ext :: XCDerivDecl pass
- , deriv_type :: LHsSigWcType pass
- -- ^ The instance type to derive.
- --
- -- It uses an 'LHsSigWcType' because the context is allowed to be a
- -- single wildcard:
- --
- -- > deriving instance _ => Eq (Foo a)
- --
- -- Which signifies that the context should be inferred.
-
- -- See Note [Inferring the instance context] in GHC.Tc.Deriv.Infer.
-
- , deriv_strategy :: Maybe (LDerivStrategy pass)
- , deriv_overlap_mode :: Maybe (XRec pass OverlapMode)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDeriving',
- -- 'GHC.Parser.Annotation.AnnInstance', 'GHC.Parser.Annotation.AnnStock',
- -- 'GHC.Parser.Annotation.AnnAnyClass', 'Api.AnnNewtype',
- -- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- }
- | XDerivDecl !(XXDerivDecl pass)
-
type instance XCDerivDecl (GhcPass _) = NoExtField
type instance XXDerivDecl (GhcPass _) = NoExtCon
@@ -2125,22 +874,6 @@ instance OutputableBndrId p
************************************************************************
-}
--- | A 'Located' 'DerivStrategy'.
-type LDerivStrategy pass = XRec pass (DerivStrategy pass)
-
--- | Which technique the user explicitly requested when deriving an instance.
-data DerivStrategy pass
- -- See Note [Deriving strategies] in GHC.Tc.Deriv
- = StockStrategy -- ^ GHC's \"standard\" strategy, which is to implement a
- -- custom instance for the data type. This only works
- -- for certain types that GHC knows about (e.g., 'Eq',
- -- 'Show', 'Functor' when @-XDeriveFunctor@ is enabled,
- -- etc.)
- | AnyclassStrategy -- ^ @-XDeriveAnyClass@
- | NewtypeStrategy -- ^ @-XGeneralizedNewtypeDeriving@
- | ViaStrategy (XViaStrategy pass)
- -- ^ @-XDerivingVia@
-
type instance XViaStrategy GhcPs = LHsSigType GhcPs
type instance XViaStrategy GhcRn = LHsSigType GhcRn
type instance XViaStrategy GhcTc = Type
@@ -2155,15 +888,6 @@ instance OutputableBndrId p
GhcRn -> ppr ty
GhcTc -> ppr ty
--- | A short description of a @DerivStrategy'@.
-derivStrategyName :: DerivStrategy a -> SDoc
-derivStrategyName = text . go
- where
- go StockStrategy = "stock"
- go AnyclassStrategy = "anyclass"
- go NewtypeStrategy = "newtype"
- go (ViaStrategy {}) = "via"
-
-- | Eliminate a 'DerivStrategy'.
foldDerivStrategy :: (p ~ GhcPass pass)
=> r -> (XViaStrategy p -> r) -> DerivStrategy p -> r
@@ -2185,24 +909,8 @@ mapDerivStrategy f ds = foldDerivStrategy ds (ViaStrategy . f) ds
\subsection[DefaultDecl]{A @default@ declaration}
* *
************************************************************************
-
-There can only be one default declaration per module, but it is hard
-for the parser to check that; we pass them all through in the abstract
-syntax, and that restriction must be checked in the front end.
-}
--- | Located Default Declaration
-type LDefaultDecl pass = XRec pass (DefaultDecl pass)
-
--- | Default Declaration
-data DefaultDecl pass
- = DefaultDecl (XCDefaultDecl pass) [LHsType pass]
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId's : 'GHC.Parser.Annotation.AnnDefault',
- -- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | XDefaultDecl !(XXDefaultDecl pass)
-
type instance XCDefaultDecl (GhcPass _) = NoExtField
type instance XXDefaultDecl (GhcPass _) = NoExtCon
@@ -2219,45 +927,6 @@ instance OutputableBndrId p
************************************************************************
-}
--- foreign declarations are distinguished as to whether they define or use a
--- Haskell name
---
--- * the Boolean value indicates whether the pre-standard deprecated syntax
--- has been used
-
--- | Located Foreign Declaration
-type LForeignDecl pass = XRec pass (ForeignDecl pass)
-
--- | Foreign Declaration
-data ForeignDecl pass
- = ForeignImport
- { fd_i_ext :: XForeignImport pass -- Post typechecker, rep_ty ~ sig_ty
- , fd_name :: LIdP pass -- defines this name
- , fd_sig_ty :: LHsSigType pass -- sig_ty
- , fd_fi :: ForeignImport }
-
- | ForeignExport
- { fd_e_ext :: XForeignExport pass -- Post typechecker, rep_ty ~ sig_ty
- , fd_name :: LIdP pass -- uses this name
- , fd_sig_ty :: LHsSigType pass -- sig_ty
- , fd_fe :: ForeignExport }
- -- ^
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnForeign',
- -- 'GHC.Parser.Annotation.AnnImport','GHC.Parser.Annotation.AnnExport',
- -- 'GHC.Parser.Annotation.AnnDcolon'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | XForeignDecl !(XXForeignDecl pass)
-
-{-
- In both ForeignImport and ForeignExport:
- sig_ty is the type given in the Haskell code
- rep_ty is the representation for this type, i.e. with newtypes
- coerced away and type functions evaluated.
- Thus if the declaration is valid, then rep_ty will only use types
- such as Int and IO that we know how to make foreign calls with.
--}
-
type instance XForeignImport GhcPs = NoExtField
type instance XForeignImport GhcRn = NoExtField
type instance XForeignImport GhcTc = Coercion
@@ -2268,51 +937,6 @@ type instance XForeignExport GhcTc = Coercion
type instance XXForeignDecl (GhcPass _) = NoExtCon
--- Specification Of an imported external entity in dependence on the calling
--- convention
---
-data ForeignImport = -- import of a C entity
- --
- -- * the two strings specifying a header file or library
- -- may be empty, which indicates the absence of a
- -- header or object specification (both are not used
- -- in the case of `CWrapper' and when `CFunction'
- -- has a dynamic target)
- --
- -- * the calling convention is irrelevant for code
- -- generation in the case of `CLabel', but is needed
- -- for pretty printing
- --
- -- * `Safety' is irrelevant for `CLabel' and `CWrapper'
- --
- CImport (Located CCallConv) -- ccall or stdcall
- (Located Safety) -- interruptible, safe or unsafe
- (Maybe Header) -- name of C header
- CImportSpec -- details of the C entity
- (Located SourceText) -- original source text for
- -- the C entity
- deriving Data
-
--- details of an external C entity
---
-data CImportSpec = CLabel CLabelString -- import address of a C label
- | CFunction CCallTarget -- static or dynamic function
- | CWrapper -- wrapper to expose closures
- -- (former f.e.d.)
- deriving Data
-
--- specification of an externally exported entity in dependence on the calling
--- convention
---
-data ForeignExport = CExport (Located CExportSpec) -- contains the calling
- -- convention
- (Located SourceText) -- original source text for
- -- the C entity
- deriving Data
-
--- pretty printing of foreign declarations
---
-
instance OutputableBndrId p
=> Outputable (ForeignDecl (GhcPass p)) where
ppr (ForeignImport { fd_name = n, fd_sig_ty = ty, fd_fi = fimport })
@@ -2322,38 +946,6 @@ instance OutputableBndrId p
hang (text "foreign export" <+> ppr fexport <+> ppr n)
2 (dcolon <+> ppr ty)
-instance Outputable ForeignImport where
- ppr (CImport cconv safety mHeader spec (L _ srcText)) =
- ppr cconv <+> ppr safety
- <+> pprWithSourceText srcText (pprCEntity spec "")
- where
- pp_hdr = case mHeader of
- Nothing -> empty
- Just (Header _ header) -> ftext header
-
- pprCEntity (CLabel lbl) _ =
- doubleQuotes $ text "static" <+> pp_hdr <+> char '&' <> ppr lbl
- pprCEntity (CFunction (StaticTarget st _lbl _ isFun)) src =
- if dqNeeded then doubleQuotes ce else empty
- where
- dqNeeded = (take 6 src == "static")
- || isJust mHeader
- || not isFun
- || st /= NoSourceText
- ce =
- -- We may need to drop leading spaces first
- (if take 6 src == "static" then text "static" else empty)
- <+> pp_hdr
- <+> (if isFun then empty else text "value")
- <+> (pprWithSourceText st empty)
- pprCEntity (CFunction DynamicTarget) _ =
- doubleQuotes $ text "dynamic"
- pprCEntity CWrapper _ = doubleQuotes $ text "wrapper"
-
-instance Outputable ForeignExport where
- ppr (CExport (L _ (CExportStatic _ lbl cconv)) _) =
- ppr cconv <+> char '"' <> ppr lbl <> char '"'
-
{-
************************************************************************
* *
@@ -2362,50 +954,9 @@ instance Outputable ForeignExport where
************************************************************************
-}
--- | Located Rule Declarations
-type LRuleDecls pass = XRec pass (RuleDecls pass)
-
- -- Note [Pragma source text] in GHC.Types.SourceText
--- | Rule Declarations
-data RuleDecls pass = HsRules { rds_ext :: XCRuleDecls pass
- , rds_src :: SourceText
- , rds_rules :: [LRuleDecl pass] }
- | XRuleDecls !(XXRuleDecls pass)
-
type instance XCRuleDecls (GhcPass _) = NoExtField
type instance XXRuleDecls (GhcPass _) = NoExtCon
--- | Located Rule Declaration
-type LRuleDecl pass = XRec pass (RuleDecl pass)
-
--- | Rule Declaration
-data RuleDecl pass
- = HsRule -- Source rule
- { rd_ext :: XHsRule pass
- -- ^ After renamer, free-vars from the LHS and RHS
- , rd_name :: XRec pass (SourceText,RuleName)
- -- ^ Note [Pragma source text] in "GHC.Types.Basic"
- , rd_act :: Activation
- , rd_tyvs :: Maybe [LHsTyVarBndr () (NoGhcTc pass)]
- -- ^ Forall'd type vars
- , rd_tmvs :: [LRuleBndr pass]
- -- ^ Forall'd term vars, before typechecking; after typechecking
- -- this includes all forall'd vars
- , rd_lhs :: XRec pass (HsExpr pass)
- , rd_rhs :: XRec pass (HsExpr pass)
- }
- -- ^
- -- - 'GHC.Parser.Annotation.AnnKeywordId' :
- -- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnTilde',
- -- 'GHC.Parser.Annotation.AnnVal',
- -- 'GHC.Parser.Annotation.AnnClose',
- -- 'GHC.Parser.Annotation.AnnForall','GHC.Parser.Annotation.AnnDot',
- -- 'GHC.Parser.Annotation.AnnEqual',
- | XRuleDecl !(XXRuleDecl pass)
-
-data HsRuleRn = HsRuleRn NameSet NameSet -- Free-vars from the LHS and RHS
- deriving Data
-
type instance XHsRule GhcPs = NoExtField
type instance XHsRule GhcRn = HsRuleRn
type instance XHsRule GhcTc = HsRuleRn
@@ -2415,30 +966,10 @@ type instance XXRuleDecl (GhcPass _) = NoExtCon
flattenRuleDecls :: [LRuleDecls (GhcPass p)] -> [LRuleDecl (GhcPass p)]
flattenRuleDecls decls = concatMap (rds_rules . unLoc) decls
--- | Located Rule Binder
-type LRuleBndr pass = XRec pass (RuleBndr pass)
-
--- | Rule Binder
-data RuleBndr pass
- = RuleBndr (XCRuleBndr pass) (LIdP pass)
- | RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass)
- | XRuleBndr !(XXRuleBndr pass)
- -- ^
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnDcolon','GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
type instance XCRuleBndr (GhcPass _) = NoExtField
type instance XRuleBndrSig (GhcPass _) = NoExtField
type instance XXRuleBndr (GhcPass _) = NoExtCon
-collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass]
-collectRuleBndrSigTys bndrs = [ty | RuleBndrSig _ _ ty <- bndrs]
-
-pprFullRuleName :: Located (SourceText, RuleName) -> SDoc
-pprFullRuleName (L _ (st, n)) = pprWithSourceText st (doubleQuotes $ ftext n)
-
instance (OutputableBndrId p) => Outputable (RuleDecls (GhcPass p)) where
ppr (HsRules { rds_src = st
, rds_rules = rules })
@@ -2469,63 +1000,14 @@ instance (OutputableBndrId p) => Outputable (RuleBndr (GhcPass p)) where
{-
************************************************************************
* *
-\subsection[DocDecl]{Document comments}
-* *
-************************************************************************
--}
-
--- | Located Documentation comment Declaration
-type LDocDecl = Located (DocDecl)
-
--- | Documentation comment Declaration
-data DocDecl
- = DocCommentNext HsDocString
- | DocCommentPrev HsDocString
- | DocCommentNamed String HsDocString
- | DocGroup Int HsDocString
- deriving Data
-
--- Okay, I need to reconstruct the document comments, but for now:
-instance Outputable DocDecl where
- ppr _ = text "<document comment>"
-
-docDeclDoc :: DocDecl -> HsDocString
-docDeclDoc (DocCommentNext d) = d
-docDeclDoc (DocCommentPrev d) = d
-docDeclDoc (DocCommentNamed _ d) = d
-docDeclDoc (DocGroup _ d) = d
-
-{-
-************************************************************************
-* *
\subsection[DeprecDecl]{Deprecations}
* *
************************************************************************
-
-We use exported entities for things to deprecate.
-}
--- | Located Warning Declarations
-type LWarnDecls pass = XRec pass (WarnDecls pass)
-
- -- Note [Pragma source text] in GHC.Types.SourceText
--- | Warning pragma Declarations
-data WarnDecls pass = Warnings { wd_ext :: XWarnings pass
- , wd_src :: SourceText
- , wd_warnings :: [LWarnDecl pass]
- }
- | XWarnDecls !(XXWarnDecls pass)
-
type instance XWarnings (GhcPass _) = NoExtField
type instance XXWarnDecls (GhcPass _) = NoExtCon
--- | Located Warning pragma Declaration
-type LWarnDecl pass = XRec pass (WarnDecl pass)
-
--- | Warning pragma Declaration
-data WarnDecl pass = Warning (XWarning pass) [LIdP pass] WarningTxt
- | XWarnDecl !(XXWarnDecl pass)
-
type instance XWarning (GhcPass _) = NoExtField
type instance XXWarnDecl (GhcPass _) = NoExtCon
@@ -2550,22 +1032,6 @@ instance OutputableBndr (IdP (GhcPass p))
************************************************************************
-}
--- | Located Annotation Declaration
-type LAnnDecl pass = XRec pass (AnnDecl pass)
-
--- | Annotation Declaration
-data AnnDecl pass = HsAnnotation
- (XHsAnnotation pass)
- SourceText -- Note [Pragma source text] in GHC.Types.SourceText
- (AnnProvenance (IdP pass)) (XRec pass (HsExpr pass))
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnType'
- -- 'GHC.Parser.Annotation.AnnModule'
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | XAnnDecl !(XXAnnDecl pass)
-
type instance XHsAnnotation (GhcPass _) = NoExtField
type instance XXAnnDecl (GhcPass _) = NoExtCon
@@ -2573,20 +1039,6 @@ instance (OutputableBndrId p) => Outputable (AnnDecl (GhcPass p)) where
ppr (HsAnnotation _ _ provenance expr)
= hsep [text "{-#", pprAnnProvenance provenance, pprExpr (unLoc expr), text "#-}"]
--- | Annotation Provenance
-data AnnProvenance name = ValueAnnProvenance (Located name)
- | TypeAnnProvenance (Located name)
- | ModuleAnnProvenance
-deriving instance Functor AnnProvenance
-deriving instance Foldable AnnProvenance
-deriving instance Traversable AnnProvenance
-deriving instance (Data pass) => Data (AnnProvenance pass)
-
-annProvenanceName_maybe :: AnnProvenance name -> Maybe name
-annProvenanceName_maybe (ValueAnnProvenance (L _ name)) = Just name
-annProvenanceName_maybe (TypeAnnProvenance (L _ name)) = Just name
-annProvenanceName_maybe ModuleAnnProvenance = Nothing
-
pprAnnProvenance :: OutputableBndr name => AnnProvenance name -> SDoc
pprAnnProvenance ModuleAnnProvenance = text "ANN module"
pprAnnProvenance (ValueAnnProvenance (L _ name))
@@ -2602,22 +1054,6 @@ pprAnnProvenance (TypeAnnProvenance (L _ name))
************************************************************************
-}
--- | Located Role Annotation Declaration
-type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass)
-
--- See #8185 for more info about why role annotations are
--- top-level declarations
--- | Role Annotation Declaration
-data RoleAnnotDecl pass
- = RoleAnnotDecl (XCRoleAnnotDecl pass)
- (LIdP pass) -- type constructor
- [XRec pass (Maybe Role)] -- optional annotations
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnType',
- -- 'GHC.Parser.Annotation.AnnRole'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | XRoleAnnotDecl !(XXRoleAnnotDecl pass)
-
type instance XCRoleAnnotDecl (GhcPass _) = NoExtField
type instance XXRoleAnnotDecl (GhcPass _) = NoExtCon
diff --git a/compiler/GHC/Hs/Expr.hs b/compiler/GHC/Hs/Expr.hs
index 78b07e54a3..ac3a58a592 100644
--- a/compiler/GHC/Hs/Expr.hs
+++ b/compiler/GHC/Hs/Expr.hs
@@ -11,9 +11,10 @@
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilyDependencies #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
+ -- in module Language.Haskell.Syntax.Extension
{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}
+{-# OPTIONS_GHC -Wno-orphans #-} -- Outputable
{-
(c) The University of Glasgow 2006
@@ -21,23 +22,28 @@
-}
-- | Abstract Haskell syntax for expressions.
-module GHC.Hs.Expr where
+module GHC.Hs.Expr
+ ( module Language.Haskell.Syntax.Expr
+ , module GHC.Hs.Expr
+ ) where
#include "HsVersions.h"
+import Language.Haskell.Syntax.Expr
+
-- friends:
import GHC.Prelude
import GHC.Hs.Decls
import GHC.Hs.Pat
import GHC.Hs.Lit
+import Language.Haskell.Syntax.Extension
import GHC.Hs.Extension
import GHC.Hs.Type
import GHC.Hs.Binds
-- others:
import GHC.Tc.Types.Evidence
-import GHC.Core
import GHC.Types.Name
import GHC.Types.Name.Set
import GHC.Types.Basic
@@ -61,9 +67,6 @@ import qualified Data.Data as Data (Fixity(..))
import qualified Data.Kind
import Data.Maybe (isJust)
-import GHCi.RemoteTypes ( ForeignRef )
-import qualified Language.Haskell.TH as TH (Q)
-
{-
************************************************************************
* *
@@ -72,16 +75,6 @@ import qualified Language.Haskell.TH as TH (Q)
************************************************************************
-}
--- * Expressions proper
-
--- | Located Haskell Expression
-type LHsExpr p = XRec p (HsExpr p)
- -- ^ May have 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnComma' when
- -- in a list
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--------------------------
-- | Post-Type checking Expression
--
-- PostTcExpr is an evidence expression attached to the syntax tree by the
@@ -95,39 +88,6 @@ type PostTcExpr = HsExpr GhcTc
type PostTcTable = [(Name, PostTcExpr)]
-------------------------
-{- Note [NoSyntaxExpr]
-~~~~~~~~~~~~~~~~~~~~~~
-Syntax expressions can be missing (NoSyntaxExprRn or NoSyntaxExprTc)
-for several reasons:
-
- 1. As described in Note [Rebindable if]
-
- 2. In order to suppress "not in scope: xyz" messages when a bit of
- rebindable syntax does not apply. For example, when using an irrefutable
- pattern in a BindStmt, we don't need a `fail` operator.
-
- 3. Rebindable syntax might just not make sense. For example, a BodyStmt
- contains the syntax for `guard`, but that's used only in monad comprehensions.
- If we had more of a whiz-bang type system, we might be able to rule this
- case out statically.
--}
-
--- | Syntax Expression
---
--- SyntaxExpr is represents the function used in interpreting rebindable
--- syntax. In the parser, we have no information to supply; in the renamer,
--- we have the name of the function (but see
--- Note [Monad fail : Rebindable syntax, overloaded strings] for a wrinkle)
--- and in the type-checker we have a more elaborate structure 'SyntaxExprTc'.
---
--- In some contexts, rebindable syntax is not implemented, and so we have
--- constructors to represent that possibility in both the renamer and
--- typechecker instantiations.
---
--- E.g. @(>>=)@ is filled in before the renamer by the appropriate 'Name' for
--- @(>>=)@, and then instantiated by the type checker with its type args
--- etc
-type family SyntaxExpr p
-- Defining SyntaxExpr in two stages allows for better type inference, because
-- we can declare SyntaxExprGhc to be injective (and closed). Without injectivity,
@@ -199,370 +159,6 @@ instance Outputable SyntaxExprTc where
ppr NoSyntaxExprTc = text "<no syntax expr>"
--- | Command Syntax Table (for Arrow syntax)
-type CmdSyntaxTable p = [(Name, HsExpr p)]
--- See Note [CmdSyntaxTable]
-
-{-
-Note [CmdSyntaxTable]
-~~~~~~~~~~~~~~~~~~~~~
-Used only for arrow-syntax stuff (HsCmdTop), the CmdSyntaxTable keeps
-track of the methods needed for a Cmd.
-
-* Before the renamer, this list is an empty list
-
-* After the renamer, it takes the form @[(std_name, HsVar actual_name)]@
- For example, for the 'arr' method
- * normal case: (GHC.Control.Arrow.arr, HsVar GHC.Control.Arrow.arr)
- * with rebindable syntax: (GHC.Control.Arrow.arr, arr_22)
- where @arr_22@ is whatever 'arr' is in scope
-
-* After the type checker, it takes the form [(std_name, <expression>)]
- where <expression> is the evidence for the method. This evidence is
- instantiated with the class, but is still polymorphic in everything
- else. For example, in the case of 'arr', the evidence has type
- forall b c. (b->c) -> a b c
- where 'a' is the ambient type of the arrow. This polymorphism is
- important because the desugarer uses the same evidence at multiple
- different types.
-
-This is Less Cool than what we normally do for rebindable syntax, which is to
-make fully-instantiated piece of evidence at every use site. The Cmd way
-is Less Cool because
- * The renamer has to predict which methods are needed.
- See the tedious GHC.Rename.Expr.methodNamesCmd.
-
- * The desugarer has to know the polymorphic type of the instantiated
- method. This is checked by Inst.tcSyntaxName, but is less flexible
- than the rest of rebindable syntax, where the type is less
- pre-ordained. (And this flexibility is useful; for example we can
- typecheck do-notation with (>>=) :: m1 a -> (a -> m2 b) -> m2 b.)
--}
-
--- | A Haskell expression.
-data HsExpr p
- = HsVar (XVar p)
- (LIdP p) -- ^ Variable
- -- See Note [Located RdrNames]
-
- | HsUnboundVar (XUnboundVar p)
- OccName -- ^ Unbound variable; also used for "holes"
- -- (_ or _x).
- -- Turned from HsVar to HsUnboundVar by the
- -- renamer, when it finds an out-of-scope
- -- variable or hole.
- -- The (XUnboundVar p) field becomes an HoleExprRef
- -- after typechecking; this is where the
- -- erroring expression will be written after
- -- solving. See Note [Holes] in GHC.Tc.Types.Constraint.
-
- | HsConLikeOut (XConLikeOut p)
- ConLike -- ^ After typechecker only; must be different
- -- HsVar for pretty printing
-
- | HsRecFld (XRecFld p)
- (AmbiguousFieldOcc p) -- ^ Variable pointing to record selector
- -- The parser produces HsVars
- -- The renamer renames record-field selectors to HsRecFld
- -- The typechecker preserves HsRecFld
-
- | HsOverLabel (XOverLabel p)
- (Maybe (IdP p)) FastString
- -- ^ Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels)
- -- @Just id@ means @RebindableSyntax@ is in use, and gives the id of the
- -- in-scope 'fromLabel'.
- -- NB: Not in use after typechecking
-
- | HsIPVar (XIPVar p)
- HsIPName -- ^ Implicit parameter (not in use after typechecking)
- | HsOverLit (XOverLitE p)
- (HsOverLit p) -- ^ Overloaded literals
-
- | HsLit (XLitE p)
- (HsLit p) -- ^ Simple (non-overloaded) literals
-
- | HsLam (XLam p)
- (MatchGroup p (LHsExpr p))
- -- ^ Lambda abstraction. Currently always a single match
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnLam',
- -- 'GHC.Parser.Annotation.AnnRarrow',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p)) -- ^ Lambda-case
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnLam',
- -- 'GHC.Parser.Annotation.AnnCase','GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsApp (XApp p) (LHsExpr p) (LHsExpr p) -- ^ Application
-
- | HsAppType (XAppTypeE p) -- After typechecking: the type argument
- (LHsExpr p)
- (LHsWcType (NoGhcTc p)) -- ^ Visible type application
- --
- -- Explicit type argument; e.g f @Int x y
- -- NB: Has wildcards, but no implicit quantification
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnAt',
-
- -- | Operator applications:
- -- NB Bracketed ops such as (+) come out as Vars.
-
- -- NB We need an expr for the operator in an OpApp/Section since
- -- the typechecker may need to apply the operator to a few types.
-
- | OpApp (XOpApp p)
- (LHsExpr p) -- left operand
- (LHsExpr p) -- operator
- (LHsExpr p) -- right operand
-
- -- | Negation operator. Contains the negated expression and the name
- -- of 'negate'
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnMinus'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | NegApp (XNegApp p)
- (LHsExpr p)
- (SyntaxExpr p)
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'('@,
- -- 'GHC.Parser.Annotation.AnnClose' @')'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsPar (XPar p)
- (LHsExpr p) -- ^ Parenthesised expr; see Note [Parens in HsSyn]
-
- | SectionL (XSectionL p)
- (LHsExpr p) -- operand; see Note [Sections in HsSyn]
- (LHsExpr p) -- operator
- | SectionR (XSectionR p)
- (LHsExpr p) -- operator; see Note [Sections in HsSyn]
- (LHsExpr p) -- operand
-
- -- | Used for explicit tuples and sections thereof
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- -- Note [ExplicitTuple]
- | ExplicitTuple
- (XExplicitTuple p)
- [LHsTupArg p]
- Boxity
-
- -- | Used for unboxed sum types
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'(#'@,
- -- 'GHC.Parser.Annotation.AnnVbar', 'GHC.Parser.Annotation.AnnClose' @'#)'@,
- --
- -- There will be multiple 'GHC.Parser.Annotation.AnnVbar', (1 - alternative) before
- -- the expression, (arity - alternative) after it
- | ExplicitSum
- (XExplicitSum p)
- ConTag -- Alternative (one-based)
- Arity -- Sum arity
- (LHsExpr p)
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnCase',
- -- 'GHC.Parser.Annotation.AnnOf','GHC.Parser.Annotation.AnnOpen' @'{'@,
- -- 'GHC.Parser.Annotation.AnnClose' @'}'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsCase (XCase p)
- (LHsExpr p)
- (MatchGroup p (LHsExpr p))
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnIf',
- -- 'GHC.Parser.Annotation.AnnSemi',
- -- 'GHC.Parser.Annotation.AnnThen','GHC.Parser.Annotation.AnnSemi',
- -- 'GHC.Parser.Annotation.AnnElse',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsIf (XIf p) -- GhcPs: this is a Bool; False <=> do not use
- -- rebindable syntax
- (LHsExpr p) -- predicate
- (LHsExpr p) -- then part
- (LHsExpr p) -- else part
-
- -- | Multi-way if
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnIf'
- -- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnClose',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]
-
- -- | let(rec)
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnLet',
- -- 'GHC.Parser.Annotation.AnnOpen' @'{'@,
- -- 'GHC.Parser.Annotation.AnnClose' @'}'@,'GHC.Parser.Annotation.AnnIn'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsLet (XLet p)
- (LHsLocalBinds p)
- (LHsExpr p)
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDo',
- -- 'GHC.Parser.Annotation.AnnOpen', 'GHC.Parser.Annotation.AnnSemi',
- -- 'GHC.Parser.Annotation.AnnVbar',
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsDo (XDo p) -- Type of the whole expression
- (HsStmtContext GhcRn) -- The parameterisation is unimportant
- -- because in this context we never use
- -- the PatGuard or ParStmt variant
- (XRec p [ExprLStmt p]) -- "do":one or more stmts
-
- -- | Syntactic list: [a,b,c,...]
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'['@,
- -- 'GHC.Parser.Annotation.AnnClose' @']'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- -- See Note [Empty lists]
- | ExplicitList
- (XExplicitList p) -- Gives type of components of list
- (Maybe (SyntaxExpr p))
- -- For OverloadedLists, the fromListN witness
- [LHsExpr p]
-
- -- | Record construction
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'{'@,
- -- 'GHC.Parser.Annotation.AnnDotdot','GHC.Parser.Annotation.AnnClose' @'}'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | RecordCon
- { rcon_ext :: XRecordCon p
- , rcon_con_name :: LIdP p -- The constructor name;
- -- not used after type checking
- , rcon_flds :: HsRecordBinds p } -- The fields
-
- -- | Record update
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'{'@,
- -- 'GHC.Parser.Annotation.AnnDotdot','GHC.Parser.Annotation.AnnClose' @'}'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | RecordUpd
- { rupd_ext :: XRecordUpd p
- , rupd_expr :: LHsExpr p
- , rupd_flds :: [LHsRecUpdField p]
- }
- -- For a type family, the arg types are of the *instance* tycon,
- -- not the family tycon
-
- -- | Expression with an explicit type signature. @e :: type@
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDcolon'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | ExprWithTySig
- (XExprWithTySig p)
-
- (LHsExpr p)
- (LHsSigWcType (NoGhcTc p))
-
- -- | Arithmetic sequence
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'['@,
- -- 'GHC.Parser.Annotation.AnnComma','GHC.Parser.Annotation.AnnDotdot',
- -- 'GHC.Parser.Annotation.AnnClose' @']'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | ArithSeq
- (XArithSeq p)
- (Maybe (SyntaxExpr p))
- -- For OverloadedLists, the fromList witness
- (ArithSeqInfo p)
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- -----------------------------------------------------------
- -- MetaHaskell Extensions
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnOpenE','GHC.Parser.Annotation.AnnOpenEQ',
- -- 'GHC.Parser.Annotation.AnnClose','GHC.Parser.Annotation.AnnCloseQ'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsBracket (XBracket p) (HsBracket p)
-
- -- See Note [Pending Splices]
- | HsRnBracketOut
- (XRnBracketOut p)
- (HsBracket GhcRn) -- Output of the renamer is the *original* renamed
- -- expression, plus
- [PendingRnSplice] -- _renamed_ splices to be type checked
-
- | HsTcBracketOut
- (XTcBracketOut p)
- (Maybe QuoteWrapper) -- The wrapper to apply type and dictionary argument
- -- to the quote.
- (HsBracket GhcRn) -- Output of the type checker is the *original*
- -- renamed expression, plus
- [PendingTcSplice] -- _typechecked_ splices to be
- -- pasted back in by the desugarer
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsSpliceE (XSpliceE p) (HsSplice p)
-
- -----------------------------------------------------------
- -- Arrow notation extension
-
- -- | @proc@ notation for Arrows
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnProc',
- -- 'GHC.Parser.Annotation.AnnRarrow'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsProc (XProc p)
- (LPat p) -- arrow abstraction, proc
- (LHsCmdTop p) -- body of the abstraction
- -- always has an empty stack
-
- ---------------------------------------
- -- static pointers extension
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnStatic',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsStatic (XStatic p) -- Free variables of the body
- (LHsExpr p) -- Body
-
- ---------------------------------------
- -- Haskell program coverage (Hpc) Support
-
- | HsTick
- (XTick p)
- (Tickish (IdP p))
- (LHsExpr p) -- sub-expression
-
- | HsBinTick
- (XBinTick p)
- Int -- module-local tick number for True
- Int -- module-local tick number for False
- (LHsExpr p) -- sub-expression
-
- ---------------------------------------
- -- Expressions annotated with pragmas, written as {-# ... #-}
- | HsPragE (XPragE p) (HsPragE p) (LHsExpr p)
-
- | XExpr !(XXExpr p)
- -- Note [Trees that Grow] extension constructor for the
- -- general idea, and Note [Rebindable syntax and HsExpansion]
- -- for an example of how we use it.
-
-- | Extra data fields for a 'RecordCon', added by the type checker
data RecordConTc = RecordConTc
{ rcon_con_like :: ConLike -- The data constructor or pattern synonym
@@ -594,6 +190,11 @@ data HsWrap hs_syn = HsWrap HsWrapper -- the wrapper
deriving instance (Data (hs_syn GhcTc), Typeable hs_syn) => Data (HsWrap hs_syn)
+type instance HsDoRn (GhcPass _) = GhcRn
+type instance HsBracketRn (GhcPass _) = GhcRn
+type instance PendingRnSplice' (GhcPass _) = PendingRnSplice
+type instance PendingTcSplice' (GhcPass _) = PendingTcSplice
+
-- ---------------------------------------------------------------------
type instance XVar (GhcPass _) = NoExtField
@@ -694,184 +295,12 @@ data XXExprGhcTc
| ExpansionExpr {-# UNPACK #-} !(HsExpansion (HsExpr GhcRn) (HsExpr GhcTc))
-{-
-Note [Rebindable syntax and HsExpansion]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-We implement rebindable syntax (RS) support by performing a desugaring
-in the renamer. We transform GhcPs expressions affected by RS into the
-appropriate desugared form, but **annotated with the original expression**.
-
-Let us consider a piece of code like:
-
- {-# LANGUAGE RebindableSyntax #-}
- ifThenElse :: Char -> () -> () -> ()
- ifThenElse _ _ _ = ()
- x = if 'a' then () else True
-
-The parsed AST for the RHS of x would look something like (slightly simplified):
-
- L locif (HsIf (L loca 'a') (L loctrue ()) (L locfalse True))
-
-Upon seeing such an AST with RS on, we could transform it into a
-mere function call, as per the RS rules, equivalent to the
-following function application:
-
- ifThenElse 'a' () True
-
-which doesn't typecheck. But GHC would report an error about
-not being able to match the third argument's type (Bool) with the
-expected type: (), in the expression _as desugared_, i.e in
-the aforementioned function application. But the user never
-wrote a function application! This would be pretty bad.
-
-To remedy this, instead of transforming the original HsIf
-node into mere applications of 'ifThenElse', we keep the
-original 'if' expression around too, using the TTG
-XExpr extension point to allow GHC to construct an
-'HsExpansion' value that will keep track of the original
-expression in its first field, and the desugared one in the
-second field. The resulting renamed AST would look like:
-
- L locif (XExpr
- (HsExpanded
- (HsIf (L loca 'a')
- (L loctrue ())
- (L locfalse True)
- )
- (App (L generatedSrcSpan
- (App (L generatedSrcSpan
- (App (L generatedSrcSpan (Var ifThenElse))
- (L loca 'a')
- )
- )
- (L loctrue ())
- )
- )
- (L locfalse True)
- )
- )
- )
-
-When comes the time to typecheck the program, we end up calling
-tcMonoExpr on the AST above. If this expression gives rise to
-a type error, then it will appear in a context line and GHC
-will pretty-print it using the 'Outputable (HsExpansion a b)'
-instance defined below, which *only prints the original
-expression*. This is the gist of the idea, but is not quite
-enough to recover the error messages that we had with the
-SyntaxExpr-based, typechecking/desugaring-to-core time
-implementation of rebindable syntax. The key idea is to decorate
-some elements of the desugared expression so as to be able to
-give them a special treatment when typechecking the desugared
-expression, to print a different context line or skip one
-altogether.
-
-Whenever we 'setSrcSpan' a 'generatedSrcSpan', we update a field in
-TcLclEnv called 'tcl_in_gen_code', setting it to True, which indicates that we
-entered generated code, i.e code fabricated by the compiler when rebinding some
-syntax. If someone tries to push some error context line while that field is set
-to True, the pushing won't actually happen and the context line is just dropped.
-Once we 'setSrcSpan' a real span (for an expression that was in the original
-source code), we set 'tcl_in_gen_code' back to False, indicating that we
-"emerged from the generated code tunnel", and that the expressions we will be
-processing are relevant to report in context lines again.
-
-You might wonder why we store a RealSrcSpan in addition to a Bool in
-the TcLclEnv: could we not store a Maybe RealSrcSpan? The problem is
-that we still generate constraints when processing generated code,
-and a CtLoc must contain a RealSrcSpan -- otherwise, error messages
-might appear without source locations. So we keep the RealSrcSpan of
-the last location spotted that wasn't generated; it's as good as
-we're going to get in generated code. Once we get to sub-trees that
-are not generated, then we update the RealSrcSpan appropriately, and
-set the tcl_in_gen_code Bool to False.
-
----
-
-A general recipe to follow this approach for new constructs could go as follows:
-
-- Remove any GhcRn-time SyntaxExpr extensions to the relevant constructor for your
- construct, in HsExpr or related syntax data types.
-- At renaming-time:
- - take your original node of interest (HsIf above)
- - rename its subexpressions (condition, true branch, false branch above)
- - construct the suitable "rebound"-and-renamed result (ifThenElse call
- above), where the 'SrcSpan' attached to any _fabricated node_ (the
- HsVar/HsApp nodes, above) is set to 'generatedSrcSpan'
- - take both the original node and that rebound-and-renamed result and wrap
- them in an XExpr: XExpr (HsExpanded <original node> <desugared>)
- - At typechecking-time:
- - remove any logic that was previously dealing with your rebindable
- construct, typically involving [tc]SyntaxOp, SyntaxExpr and friends.
- - the XExpr (HsExpanded ... ...) case in tcExpr already makes sure that we
- typecheck the desugared expression while reporting the original one in
- errors
-
--}
-
--- See Note [Rebindable syntax and HsExpansion] just above.
-data HsExpansion a b
- = HsExpanded a b
- deriving Data
-
--- | Build a "wrapped" 'HsExpansion' out of an extension constructor,
--- and the two components of the expansion: original and desugared
--- expressions.
---
--- See Note [Rebindable Syntax and HsExpansion] above for more details.
-mkExpanded
- :: (HsExpansion a b -> b) -- ^ XExpr, XCmd, ...
- -> a -- ^ source expression ('GhcPs')
- -> b -- ^ "desugared" expression
- -- ('GhcRn')
- -> b -- ^ suitably wrapped
- -- 'HsExpansion'
-mkExpanded xwrap a b = xwrap (HsExpanded a b)
-
--- | Just print the original expression (the @a@).
-instance (Outputable a, Outputable b) => Outputable (HsExpansion a b) where
- ppr (HsExpanded a b) = ifPprDebug (vcat [ppr a, ppr b]) (ppr a)
-- ---------------------------------------------------------------------
--- | A pragma, written as {-# ... #-}, that may appear within an expression.
-data HsPragE p
- = HsPragSCC (XSCC p)
- SourceText -- Note [Pragma source text] in GHC.Types.SourceText
- StringLiteral -- "set cost centre" SCC pragma
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnOpen' @'{-\# GENERATED'@,
- -- 'GHC.Parser.Annotation.AnnVal','GHC.Parser.Annotation.AnnVal',
- -- 'GHC.Parser.Annotation.AnnColon','GHC.Parser.Annotation.AnnVal',
- -- 'GHC.Parser.Annotation.AnnMinus',
- -- 'GHC.Parser.Annotation.AnnVal','GHC.Parser.Annotation.AnnColon',
- -- 'GHC.Parser.Annotation.AnnVal',
- -- 'GHC.Parser.Annotation.AnnClose' @'\#-}'@
-
- | XHsPragE !(XXPragE p)
-
type instance XSCC (GhcPass _) = NoExtField
type instance XXPragE (GhcPass _) = NoExtCon
--- | Located Haskell Tuple Argument
---
--- 'HsTupArg' is used for tuple sections
--- @(,a,)@ is represented by
--- @ExplicitTuple [Missing ty1, Present a, Missing ty3]@
--- Which in turn stands for @(\x:ty1 \y:ty2. (x,a,y))@
-type LHsTupArg id = XRec id (HsTupArg id)
--- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnComma'
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- | Haskell Tuple Argument
-data HsTupArg id
- = Present (XPresent id) (LHsExpr id) -- ^ The argument
- | Missing (XMissing id) -- ^ The argument is missing, but this is its type
- | XTupArg !(XXTupArg id) -- ^ Note [Trees that Grow] extension point
-
type instance XPresent (GhcPass _) = NoExtField
type instance XMissing GhcPs = NoExtField
@@ -884,148 +313,6 @@ tupArgPresent :: LHsTupArg (GhcPass p) -> Bool
tupArgPresent (L _ (Present {})) = True
tupArgPresent (L _ (Missing {})) = False
-{-
-Note [Parens in HsSyn]
-~~~~~~~~~~~~~~~~~~~~~~
-HsPar (and ParPat in patterns, HsParTy in types) is used as follows
-
- * HsPar is required; the pretty printer does not add parens.
-
- * HsPars are respected when rearranging operator fixities.
- So a * (b + c) means what it says (where the parens are an HsPar)
-
- * For ParPat and HsParTy the pretty printer does add parens but this should be
- a no-op for ParsedSource, based on the pretty printer round trip feature
- introduced in
- https://phabricator.haskell.org/rGHC499e43824bda967546ebf95ee33ec1f84a114a7c
-
- * ParPat and HsParTy are pretty printed as '( .. )' regardless of whether or
- not they are strictly necessary. This should be addressed when #13238 is
- completed, to be treated the same as HsPar.
-
-
-Note [Sections in HsSyn]
-~~~~~~~~~~~~~~~~~~~~~~~~
-Sections should always appear wrapped in an HsPar, thus
- HsPar (SectionR ...)
-The parser parses sections in a wider variety of situations
-(See Note [Parsing sections]), but the renamer checks for those
-parens. This invariant makes pretty-printing easier; we don't need
-a special case for adding the parens round sections.
-
-Note [Rebindable if]
-~~~~~~~~~~~~~~~~~~~~
-The rebindable syntax for 'if' is a bit special, because when
-rebindable syntax is *off* we do not want to treat
- (if c then t else e)
-as if it was an application (ifThenElse c t e). Why not?
-Because we allow an 'if' to return *unboxed* results, thus
- if blah then 3# else 4#
-whereas that would not be possible using a all to a polymorphic function
-(because you can't call a polymorphic function at an unboxed type).
-
-So we use NoSyntaxExpr to mean "use the old built-in typing rule".
-
-A further complication is that, in the `deriving` code, we never want
-to use rebindable syntax. So, even in GhcPs, we want to denote whether
-to use rebindable syntax or not. This is done via the type instance
-for XIf GhcPs.
-
-Note [Record Update HsWrapper]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-There is a wrapper in RecordUpd which is used for the *required*
-constraints for pattern synonyms. This wrapper is created in the
-typechecking and is then directly used in the desugaring without
-modification.
-
-For example, if we have the record pattern synonym P,
- pattern P :: (Show a) => a -> Maybe a
- pattern P{x} = Just x
-
- foo = (Just True) { x = False }
-then `foo` desugars to something like
- foo = case Just True of
- P x -> P False
-hence we need to provide the correct dictionaries to P's matcher on
-the RHS so that we can build the expression.
-
-Note [Located RdrNames]
-~~~~~~~~~~~~~~~~~~~~~~~
-A number of syntax elements have seemingly redundant locations attached to them.
-This is deliberate, to allow transformations making use of the API Annotations
-to easily correlate a Located Name in the RenamedSource with a Located RdrName
-in the ParsedSource.
-
-There are unfortunately enough differences between the ParsedSource and the
-RenamedSource that the API Annotations cannot be used directly with
-RenamedSource, so this allows a simple mapping to be used based on the location.
-
-Note [ExplicitTuple]
-~~~~~~~~~~~~~~~~~~~~
-An ExplicitTuple is never just a data constructor like (,,,).
-That is, the `[LHsTupArg p]` argument of `ExplicitTuple` has at least
-one `Present` member (and is thus never empty).
-
-A tuple data constructor like () or (,,,) is parsed as an `HsVar`, not an
-`ExplicitTuple`, and stays that way. This is important for two reasons:
-
- 1. We don't need -XTupleSections for (,,,)
- 2. The type variables in (,,,) can be instantiated with visible type application.
- That is,
-
- (,,) :: forall a b c. a -> b -> c -> (a,b,c)
- (True,,) :: forall {b} {c}. b -> c -> (Bool,b,c)
-
- Note that the tuple section has *inferred* arguments, while the data
- constructor has *specified* ones.
- (See Note [Required, Specified, and Inferred for types] in GHC.Tc.TyCl
- for background.)
-
-Sadly, the grammar for this is actually ambiguous, and it's only thanks to the
-preference of a shift in a shift/reduce conflict that the parser works as this
-Note details. Search for a reference to this Note in GHC.Parser for further
-explanation.
-
-Note [Empty lists]
-~~~~~~~~~~~~~~~~~~
-An empty list could be considered either a data constructor (stored with
-HsVar) or an ExplicitList. This Note describes how empty lists flow through the
-various phases and why.
-
-Parsing
--------
-An empty list is parsed by the sysdcon nonterminal. It thus comes to life via
-HsVar nilDataCon (defined in GHC.Builtin.Types). A freshly-parsed (HsExpr GhcPs) empty list
-is never a ExplicitList.
-
-Renaming
---------
-If -XOverloadedLists is enabled, we must type-check the empty list as if it
-were a call to fromListN. (This is true regardless of the setting of
--XRebindableSyntax.) This is very easy if the empty list is an ExplicitList,
-but an annoying special case if it's an HsVar. So the renamer changes a
-HsVar nilDataCon to an ExplicitList [], but only if -XOverloadedLists is on.
-(Why not always? Read on, dear friend.) This happens in the HsVar case of rnExpr.
-
-Type-checking
--------------
-We want to accept an expression like [] @Int. To do this, we must infer that
-[] :: forall a. [a]. This is easy if [] is a HsVar with the right DataCon inside.
-However, the type-checking for explicit lists works differently: [x,y,z] is never
-polymorphic. Instead, we unify the types of x, y, and z together, and use the
-unified type as the argument to the cons and nil constructors. Thus, treating
-[] as an empty ExplicitList in the type-checker would prevent [] @Int from working.
-
-However, if -XOverloadedLists is on, then [] @Int really shouldn't be allowed:
-it's just like fromListN 0 [] @Int. Since
- fromListN :: forall list. IsList list => Int -> [Item list] -> list
-that expression really should be rejected. Thus, the renamer's behaviour is
-exactly what we want: treat [] as a datacon when -XNoOverloadedLists, and as
-an empty ExplicitList when -XOverloadedLists.
-
-See also #13680, which requested [] @Int to work.
--}
-
instance (OutputableBndrId p) => Outputable (HsExpr (GhcPass p)) where
ppr expr = pprExpr expr
@@ -1266,21 +553,6 @@ ppr_apps fun args = hang (ppr_expr fun) 2 (fsep (map pp args))
pp (Right arg)
= text "@" <> ppr arg
-pprExternalSrcLoc :: (StringLiteral,(Int,Int),(Int,Int)) -> SDoc
-pprExternalSrcLoc (StringLiteral _ src,(n1,n2),(n3,n4))
- = ppr (src,(n1,n2),(n3,n4))
-
-{-
-HsSyn records exactly where the user put parens, with HsPar.
-So generally speaking we print without adding any parens.
-However, some code is internally generated, and in some places
-parens are absolutely required; so for these places we use
-pprParendLExpr (but don't print double parens of course).
-
-For operator applications we don't add parens, because the operator
-fixities should do the job, except in debug mode (-dppr-debug) so we
-can see the structure of the parse tree.
--}
pprDebugParendExpr :: (OutputableBndrId p)
=> PprPrec -> LHsExpr (GhcPass p) -> SDoc
@@ -1410,111 +682,8 @@ instance Outputable (HsPragE (GhcPass p)) where
\subsection{Commands (in arrow abstractions)}
* *
************************************************************************
-
-We re-use HsExpr to represent these.
-}
--- | Located Haskell Command (for arrow syntax)
-type LHsCmd id = XRec id (HsCmd id)
-
--- | Haskell Command (e.g. a "statement" in an Arrow proc block)
-data HsCmd id
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.Annlarrowtail',
- -- 'GHC.Parser.Annotation.Annrarrowtail','GHC.Parser.Annotation.AnnLarrowtail',
- -- 'GHC.Parser.Annotation.AnnRarrowtail'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- = HsCmdArrApp -- Arrow tail, or arrow application (f -< arg)
- (XCmdArrApp id) -- type of the arrow expressions f,
- -- of the form a t t', where arg :: t
- (LHsExpr id) -- arrow expression, f
- (LHsExpr id) -- input expression, arg
- HsArrAppType -- higher-order (-<<) or first-order (-<)
- Bool -- True => right-to-left (f -< arg)
- -- False => left-to-right (arg >- f)
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpenB' @'(|'@,
- -- 'GHC.Parser.Annotation.AnnCloseB' @'|)'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | HsCmdArrForm -- Command formation, (| e cmd1 .. cmdn |)
- (XCmdArrForm id)
- (LHsExpr id) -- The operator.
- -- After type-checking, a type abstraction to be
- -- applied to the type of the local environment tuple
- LexicalFixity -- Whether the operator appeared prefix or infix when
- -- parsed.
- (Maybe Fixity) -- fixity (filled in by the renamer), for forms that
- -- were converted from OpApp's by the renamer
- [LHsCmdTop id] -- argument commands
-
- | HsCmdApp (XCmdApp id)
- (LHsCmd id)
- (LHsExpr id)
-
- | HsCmdLam (XCmdLam id)
- (MatchGroup id (LHsCmd id)) -- kappa
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnLam',
- -- 'GHC.Parser.Annotation.AnnRarrow',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsCmdPar (XCmdPar id)
- (LHsCmd id) -- parenthesised command
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'('@,
- -- 'GHC.Parser.Annotation.AnnClose' @')'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsCmdCase (XCmdCase id)
- (LHsExpr id)
- (MatchGroup id (LHsCmd id)) -- bodies are HsCmd's
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnCase',
- -- 'GHC.Parser.Annotation.AnnOf','GHC.Parser.Annotation.AnnOpen' @'{'@,
- -- 'GHC.Parser.Annotation.AnnClose' @'}'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsCmdLamCase (XCmdLamCase id)
- (MatchGroup id (LHsCmd id)) -- bodies are HsCmd's
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnLam',
- -- 'GHC.Parser.Annotation.AnnCase','GHC.Parser.Annotation.AnnOpen' @'{'@,
- -- 'GHC.Parser.Annotation.AnnClose' @'}'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsCmdIf (XCmdIf id)
- (SyntaxExpr id) -- cond function
- (LHsExpr id) -- predicate
- (LHsCmd id) -- then part
- (LHsCmd id) -- else part
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnIf',
- -- 'GHC.Parser.Annotation.AnnSemi',
- -- 'GHC.Parser.Annotation.AnnThen','GHC.Parser.Annotation.AnnSemi',
- -- 'GHC.Parser.Annotation.AnnElse',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsCmdLet (XCmdLet id)
- (LHsLocalBinds id) -- let(rec)
- (LHsCmd id)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnLet',
- -- 'GHC.Parser.Annotation.AnnOpen' @'{'@,
- -- 'GHC.Parser.Annotation.AnnClose' @'}'@,'GHC.Parser.Annotation.AnnIn'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsCmdDo (XCmdDo id) -- Type of the whole expression
- (XRec id [CmdLStmt id])
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDo',
- -- 'GHC.Parser.Annotation.AnnOpen', 'GHC.Parser.Annotation.AnnSemi',
- -- 'GHC.Parser.Annotation.AnnVbar',
- -- 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | XCmd !(XXCmd id) -- Note [Trees that Grow] extension point
-
type instance XCmdArrApp GhcPs = NoExtField
type instance XCmdArrApp GhcRn = NoExtField
type instance XCmdArrApp GhcTc = Type
@@ -1541,25 +710,6 @@ type instance XXCmd GhcTc = HsWrap HsCmd
-- wrap :: arg1 "->" arg2
-- Then (XCmd (HsWrap wrap cmd)) :: arg2 --> res
--- | Haskell Array Application Type
-data HsArrAppType = HsHigherOrderApp | HsFirstOrderApp
- deriving Data
-
-
-{- | Top-level command, introducing a new arrow.
-This may occur inside a proc (where the stack is empty) or as an
-argument of a command-forming operator.
--}
-
--- | Located Haskell Top-level Command
-type LHsCmdTop p = XRec p (HsCmdTop p)
-
--- | Haskell Top-level Command
-data HsCmdTop p
- = HsCmdTop (XCmdTop p)
- (LHsCmd p)
- | XCmdTop !(XXCmdTop p) -- Note [Trees that Grow] extension point
-
data CmdTopTc
= CmdTopTc Type -- Nested tuple of inputs on the command's stack
Type -- return type of the command
@@ -1676,73 +826,17 @@ instance (OutputableBndrId p) => Outputable (HsCmdTop (GhcPass p)) where
{-
************************************************************************
* *
-\subsection{Record binds}
-* *
-************************************************************************
--}
-
--- | Haskell Record Bindings
-type HsRecordBinds p = HsRecFields p (LHsExpr p)
-
-{-
-************************************************************************
-* *
\subsection{@Match@, @GRHSs@, and @GRHS@ datatypes}
* *
************************************************************************
-
-@Match@es are sets of pattern bindings and right hand sides for
-functions, patterns or case branches. For example, if a function @g@
-is defined as:
-\begin{verbatim}
-g (x,y) = y
-g ((x:ys),y) = y+1,
-\end{verbatim}
-then \tr{g} has two @Match@es: @(x,y) = y@ and @((x:ys),y) = y+1@.
-
-It is always the case that each element of an @[Match]@ list has the
-same number of @pats@s inside it. This corresponds to saying that
-a function defined by pattern matching must have the same number of
-patterns in each equation.
-}
-data MatchGroup p body
- = MG { mg_ext :: XMG p body -- Post-typechecker, types of args and result
- , mg_alts :: XRec p [LMatch p body] -- The alternatives
- , mg_origin :: Origin }
- -- The type is the type of the entire group
- -- t1 -> ... -> tn -> tr
- -- where there are n patterns
- | XMatchGroup !(XXMatchGroup p body)
-
-data MatchGroupTc
- = MatchGroupTc
- { mg_arg_tys :: [Scaled Type] -- Types of the arguments, t1..tn
- , mg_res_ty :: Type -- Type of the result, tr
- } deriving Data
-
type instance XMG GhcPs b = NoExtField
type instance XMG GhcRn b = NoExtField
type instance XMG GhcTc b = MatchGroupTc
type instance XXMatchGroup (GhcPass _) b = NoExtCon
--- | Located Match
-type LMatch id body = XRec id (Match id body)
--- ^ May have 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnSemi' when in a
--- list
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-data Match p body
- = Match {
- m_ext :: XCMatch p body,
- m_ctxt :: HsMatchContext (NoGhcTc p),
- -- See note [m_ctxt in Match]
- m_pats :: [LPat p], -- The patterns
- m_grhss :: (GRHSs p body)
- }
- | XMatch !(XXMatch p body)
-
type instance XCMatch (GhcPass _) b = NoExtField
type instance XXMatch (GhcPass _) b = NoExtCon
@@ -1750,48 +844,6 @@ instance (OutputableBndrId pr, Outputable body)
=> Outputable (Match (GhcPass pr) body) where
ppr = pprMatch
-{-
-Note [m_ctxt in Match]
-~~~~~~~~~~~~~~~~~~~~~~
-
-A Match can occur in a number of contexts, such as a FunBind, HsCase, HsLam and
-so on.
-
-In order to simplify tooling processing and pretty print output, the provenance
-is captured in an HsMatchContext.
-
-This is particularly important for the API Annotations for a multi-equation
-FunBind.
-
-The parser initially creates a FunBind with a single Match in it for
-every function definition it sees.
-
-These are then grouped together by getMonoBind into a single FunBind,
-where all the Matches are combined.
-
-In the process, all the original FunBind fun_id's bar one are
-discarded, including the locations.
-
-This causes a problem for source to source conversions via API
-Annotations, so the original fun_ids and infix flags are preserved in
-the Match, when it originates from a FunBind.
-
-Example infix function definition requiring individual API Annotations
-
- (&&& ) [] [] = []
- xs &&& [] = xs
- ( &&& ) [] ys = ys
-
-
-
--}
-
-
-isInfixMatch :: Match id body -> Bool
-isInfixMatch match = case m_ctxt match of
- FunRhs {mc_fixity = Infix} -> True
- _ -> False
-
isEmptyMatchGroup :: MatchGroup (GhcPass p) body -> Bool
isEmptyMatchGroup (MG { mg_alts = ms }) = null $ unLoc ms
@@ -1814,41 +866,12 @@ matchGroupArity (MG { mg_alts = alts })
hsLMatchPats :: LMatch (GhcPass id) body -> [LPat (GhcPass id)]
hsLMatchPats (L _ (Match { m_pats = pats })) = pats
--- | Guarded Right-Hand Sides
---
--- GRHSs are used both for pattern bindings and for Matches
---
--- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnVbar',
--- 'GHC.Parser.Annotation.AnnEqual','GHC.Parser.Annotation.AnnWhere',
--- 'GHC.Parser.Annotation.AnnOpen','GHC.Parser.Annotation.AnnClose'
--- 'GHC.Parser.Annotation.AnnRarrow','GHC.Parser.Annotation.AnnSemi'
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-data GRHSs p body
- = GRHSs {
- grhssExt :: XCGRHSs p body,
- grhssGRHSs :: [LGRHS p body], -- ^ Guarded RHSs
- grhssLocalBinds :: LHsLocalBinds p -- ^ The where clause
- }
- | XGRHSs !(XXGRHSs p body)
-
type instance XCGRHSs (GhcPass _) b = NoExtField
type instance XXGRHSs (GhcPass _) b = NoExtCon
--- | Located Guarded Right-Hand Side
-type LGRHS id body = XRec id (GRHS id body)
-
--- | Guarded Right Hand Side.
-data GRHS p body = GRHS (XCGRHS p body)
- [GuardLStmt p] -- Guards
- body -- Right hand side
- | XGRHS !(XXGRHS p body)
-
type instance XCGRHS (GhcPass _) b = NoExtField
type instance XXGRHS (GhcPass _) b = NoExtCon
--- We know the list must have at least one @Match@ in it.
-
pprMatches :: (OutputableBndrId idR, Outputable body)
=> MatchGroup (GhcPass idR) body -> SDoc
pprMatches MG { mg_alts = matches }
@@ -1932,162 +955,6 @@ pp_rhs ctxt rhs = matchSeparator ctxt <+> pprDeeper (ppr rhs)
************************************************************************
-}
--- | Located @do@ block Statement
-type LStmt id body = XRec id (StmtLR id id body)
-
--- | Located Statement with separate Left and Right id's
-type LStmtLR idL idR body = XRec idL (StmtLR idL idR body)
-
--- | @do@ block Statement
-type Stmt id body = StmtLR id id body
-
--- | Command Located Statement
-type CmdLStmt id = LStmt id (LHsCmd id)
-
--- | Command Statement
-type CmdStmt id = Stmt id (LHsCmd id)
-
--- | Expression Located Statement
-type ExprLStmt id = LStmt id (LHsExpr id)
-
--- | Expression Statement
-type ExprStmt id = Stmt id (LHsExpr id)
-
--- | Guard Located Statement
-type GuardLStmt id = LStmt id (LHsExpr id)
-
--- | Guard Statement
-type GuardStmt id = Stmt id (LHsExpr id)
-
--- | Ghci Located Statement
-type GhciLStmt id = LStmt id (LHsExpr id)
-
--- | Ghci Statement
-type GhciStmt id = Stmt id (LHsExpr id)
-
--- The SyntaxExprs in here are used *only* for do-notation and monad
--- comprehensions, which have rebindable syntax. Otherwise they are unused.
--- | API Annotations when in qualifier lists or guards
--- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnVbar',
--- 'GHC.Parser.Annotation.AnnComma','GHC.Parser.Annotation.AnnThen',
--- 'GHC.Parser.Annotation.AnnBy','GHC.Parser.Annotation.AnnBy',
--- 'GHC.Parser.Annotation.AnnGroup','GHC.Parser.Annotation.AnnUsing'
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-data StmtLR idL idR body -- body should always be (LHs**** idR)
- = LastStmt -- Always the last Stmt in ListComp, MonadComp,
- -- and (after the renamer, see GHC.Rename.Expr.checkLastStmt) DoExpr, MDoExpr
- -- Not used for GhciStmtCtxt, PatGuard, which scope over other stuff
- (XLastStmt idL idR body)
- body
- (Maybe Bool) -- Whether return was stripped
- -- Just True <=> return with a dollar was stripped by ApplicativeDo
- -- Just False <=> return without a dollar was stripped by ApplicativeDo
- -- Nothing <=> Nothing was stripped
- (SyntaxExpr idR) -- The return operator
- -- The return operator is used only for MonadComp
- -- For ListComp we use the baked-in 'return'
- -- For DoExpr, MDoExpr, we don't apply a 'return' at all
- -- See Note [Monad Comprehensions]
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnLarrow'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | BindStmt (XBindStmt idL idR body)
- -- ^ Post renaming has optional fail and bind / (>>=) operator.
- -- Post typechecking, also has multiplicity of the argument
- -- and the result type of the function passed to bind;
- -- that is, (P, S) in (>>=) :: Q -> (R # P -> S) -> T
- -- See Note [The type of bind in Stmts]
- (LPat idL)
- body
-
- -- | 'ApplicativeStmt' represents an applicative expression built with
- -- '<$>' and '<*>'. It is generated by the renamer, and is desugared into the
- -- appropriate applicative expression by the desugarer, but it is intended
- -- to be invisible in error messages.
- --
- -- For full details, see Note [ApplicativeDo] in "GHC.Rename.Expr"
- --
- | ApplicativeStmt
- (XApplicativeStmt idL idR body) -- Post typecheck, Type of the body
- [ ( SyntaxExpr idR
- , ApplicativeArg idL) ]
- -- [(<$>, e1), (<*>, e2), ..., (<*>, en)]
- (Maybe (SyntaxExpr idR)) -- 'join', if necessary
-
- | BodyStmt (XBodyStmt idL idR body) -- Post typecheck, element type
- -- of the RHS (used for arrows)
- body -- See Note [BodyStmt]
- (SyntaxExpr idR) -- The (>>) operator
- (SyntaxExpr idR) -- The `guard` operator; used only in MonadComp
- -- See notes [Monad Comprehensions]
-
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnLet'
- -- 'GHC.Parser.Annotation.AnnOpen' @'{'@,'GHC.Parser.Annotation.AnnClose' @'}'@,
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | LetStmt (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)
-
- -- ParStmts only occur in a list/monad comprehension
- | ParStmt (XParStmt idL idR body) -- Post typecheck,
- -- S in (>>=) :: Q -> (R -> S) -> T
- [ParStmtBlock idL idR]
- (HsExpr idR) -- Polymorphic `mzip` for monad comprehensions
- (SyntaxExpr idR) -- The `>>=` operator
- -- See notes [Monad Comprehensions]
- -- After renaming, the ids are the binders
- -- bound by the stmts and used after themp
-
- | TransStmt {
- trS_ext :: XTransStmt idL idR body, -- Post typecheck,
- -- R in (>>=) :: Q -> (R -> S) -> T
- trS_form :: TransForm,
- trS_stmts :: [ExprLStmt idL], -- Stmts to the *left* of the 'group'
- -- which generates the tuples to be grouped
-
- trS_bndrs :: [(IdP idR, IdP idR)], -- See Note [TransStmt binder map]
-
- trS_using :: LHsExpr idR,
- trS_by :: Maybe (LHsExpr idR), -- "by e" (optional)
- -- Invariant: if trS_form = GroupBy, then grp_by = Just e
-
- trS_ret :: SyntaxExpr idR, -- The monomorphic 'return' function for
- -- the inner monad comprehensions
- trS_bind :: SyntaxExpr idR, -- The '(>>=)' operator
- trS_fmap :: HsExpr idR -- The polymorphic 'fmap' function for desugaring
- -- Only for 'group' forms
- -- Just a simple HsExpr, because it's
- -- too polymorphic for tcSyntaxOp
- } -- See Note [Monad Comprehensions]
-
- -- Recursive statement (see Note [How RecStmt works] below)
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnRec'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | RecStmt
- { recS_ext :: XRecStmt idL idR body
- , recS_stmts :: [LStmtLR idL idR body]
-
- -- The next two fields are only valid after renaming
- , recS_later_ids :: [IdP idR]
- -- The ids are a subset of the variables bound by the
- -- stmts that are used in stmts that follow the RecStmt
-
- , recS_rec_ids :: [IdP idR]
- -- Ditto, but these variables are the "recursive" ones,
- -- that are used before they are bound in the stmts of
- -- the RecStmt.
- -- An Id can be in both groups
- -- Both sets of Ids are (now) treated monomorphically
- -- See Note [How RecStmt works] for why they are separate
-
- -- Rebindable syntax
- , recS_bind_fn :: SyntaxExpr idR -- The bind function
- , recS_ret_fn :: SyntaxExpr idR -- The return function
- , recS_mfix_fn :: SyntaxExpr idR -- The mfix function
- }
- | XStmtLR !(XXStmtLR idL idR body)
-
-- Extra fields available post typechecking for RecStmt.
data RecStmtTc =
RecStmtTc
@@ -2151,70 +1018,9 @@ type instance XRecStmt (GhcPass _) GhcTc b = RecStmtTc
type instance XXStmtLR (GhcPass _) (GhcPass _) b = NoExtCon
-data TransForm -- The 'f' below is the 'using' function, 'e' is the by function
- = ThenForm -- then f or then f by e (depending on trS_by)
- | GroupForm -- then group using f or then group by e using f (depending on trS_by)
- deriving Data
-
--- | Parenthesised Statement Block
-data ParStmtBlock idL idR
- = ParStmtBlock
- (XParStmtBlock idL idR)
- [ExprLStmt idL]
- [IdP idR] -- The variables to be returned
- (SyntaxExpr idR) -- The return operator
- | XParStmtBlock !(XXParStmtBlock idL idR)
-
type instance XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField
type instance XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon
--- | The fail operator
---
--- This is used for `.. <-` "bind statments" in do notation, including
--- non-monadic "binds" in applicative.
---
--- The fail operator is 'Just expr' if it potentially fail monadically. if the
--- pattern match cannot fail, or shouldn't fail monadically (regular incomplete
--- pattern exception), it is 'Nothing'.
---
--- See Note [Monad fail : Rebindable syntax, overloaded strings] for the type of
--- expression in the 'Just' case, and why it is so.
---
--- See Note [Failing pattern matches in Stmts] for which contexts for
--- '@BindStmt@'s should use the monadic fail and which shouldn't.
-type FailOperator id = Maybe (SyntaxExpr id)
-
--- | Applicative Argument
-data ApplicativeArg idL
- = ApplicativeArgOne -- A single statement (BindStmt or BodyStmt)
- { xarg_app_arg_one :: XApplicativeArgOne idL
- -- ^ The fail operator, after renaming
- --
- -- The fail operator is needed if this is a BindStmt
- -- where the pattern can fail. E.g.:
- -- (Just a) <- stmt
- -- The fail operator will be invoked if the pattern
- -- match fails.
- -- It is also used for guards in MonadComprehensions.
- -- The fail operator is Nothing
- -- if the pattern match can't fail
- , app_arg_pattern :: LPat idL -- WildPat if it was a BodyStmt (see below)
- , arg_expr :: LHsExpr idL
- , is_body_stmt :: Bool
- -- ^ True <=> was a BodyStmt,
- -- False <=> was a BindStmt.
- -- See Note [Applicative BodyStmt]
- }
- | ApplicativeArgMany -- do { stmts; return vars }
- { xarg_app_arg_many :: XApplicativeArgMany idL
- , app_stmts :: [ExprLStmt idL] -- stmts
- , final_expr :: HsExpr idL -- return (v1,..,vn), or just (v1,..,vn)
- , bv_pattern :: LPat idL -- (v1,...,vn)
- , stmt_context :: HsStmtContext GhcRn -- context of the do expression
- -- used in pprArg
- }
- | XApplicativeArg !(XXApplicativeArg idL)
-
type instance XApplicativeArgOne GhcPs = NoExtField
type instance XApplicativeArgOne GhcRn = FailOperator GhcRn
type instance XApplicativeArgOne GhcTc = FailOperator GhcTc
@@ -2222,170 +1028,7 @@ type instance XApplicativeArgOne GhcTc = FailOperator GhcTc
type instance XApplicativeArgMany (GhcPass _) = NoExtField
type instance XXApplicativeArg (GhcPass _) = NoExtCon
-{-
-Note [The type of bind in Stmts]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Some Stmts, notably BindStmt, keep the (>>=) bind operator.
-We do NOT assume that it has type
- (>>=) :: m a -> (a -> m b) -> m b
-In some cases (see #303, #1537) it might have a more
-exotic type, such as
- (>>=) :: m i j a -> (a -> m j k b) -> m i k b
-So we must be careful not to make assumptions about the type.
-In particular, the monad may not be uniform throughout.
-
-Note [TransStmt binder map]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The [(idR,idR)] in a TransStmt behaves as follows:
-
- * Before renaming: []
-
- * After renaming:
- [ (x27,x27), ..., (z35,z35) ]
- These are the variables
- bound by the stmts to the left of the 'group'
- and used either in the 'by' clause,
- or in the stmts following the 'group'
- Each item is a pair of identical variables.
-
- * After typechecking:
- [ (x27:Int, x27:[Int]), ..., (z35:Bool, z35:[Bool]) ]
- Each pair has the same unique, but different *types*.
-
-Note [BodyStmt]
-~~~~~~~~~~~~~~~
-BodyStmts are a bit tricky, because what they mean
-depends on the context. Consider the following contexts:
-
- A do expression of type (m res_ty)
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * BodyStmt E any_ty: do { ....; E; ... }
- E :: m any_ty
- Translation: E >> ...
-
- A list comprehensions of type [elt_ty]
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * BodyStmt E Bool: [ .. | .... E ]
- [ .. | ..., E, ... ]
- [ .. | .... | ..., E | ... ]
- E :: Bool
- Translation: if E then fail else ...
-
- A guard list, guarding a RHS of type rhs_ty
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * BodyStmt E BooParStmtBlockl: f x | ..., E, ... = ...rhs...
- E :: Bool
- Translation: if E then fail else ...
-
- A monad comprehension of type (m res_ty)
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * BodyStmt E Bool: [ .. | .... E ]
- E :: Bool
- Translation: guard E >> ...
-
-Array comprehensions are handled like list comprehensions.
-
-Note [How RecStmt works]
-~~~~~~~~~~~~~~~~~~~~~~~~
-Example:
- HsDo [ BindStmt x ex
-
- , RecStmt { recS_rec_ids = [a, c]
- , recS_stmts = [ BindStmt b (return (a,c))
- , LetStmt a = ...b...
- , BindStmt c ec ]
- , recS_later_ids = [a, b]
-
- , return (a b) ]
-
-Here, the RecStmt binds a,b,c; but
- - Only a,b are used in the stmts *following* the RecStmt,
- - Only a,c are used in the stmts *inside* the RecStmt
- *before* their bindings
-
-Why do we need *both* rec_ids and later_ids? For monads they could be
-combined into a single set of variables, but not for arrows. That
-follows from the types of the respective feedback operators:
-
- mfix :: MonadFix m => (a -> m a) -> m a
- loop :: ArrowLoop a => a (b,d) (c,d) -> a b c
-
-* For mfix, the 'a' covers the union of the later_ids and the rec_ids
-* For 'loop', 'c' is the later_ids and 'd' is the rec_ids
-
-Note [Typing a RecStmt]
-~~~~~~~~~~~~~~~~~~~~~~~
-A (RecStmt stmts) types as if you had written
-
- (v1,..,vn, _, ..., _) <- mfix (\~(_, ..., _, r1, ..., rm) ->
- do { stmts
- ; return (v1,..vn, r1, ..., rm) })
-
-where v1..vn are the later_ids
- r1..rm are the rec_ids
-
-Note [Monad Comprehensions]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Monad comprehensions require separate functions like 'return' and
-'>>=' for desugaring. These functions are stored in the statements
-used in monad comprehensions. For example, the 'return' of the 'LastStmt'
-expression is used to lift the body of the monad comprehension:
-
- [ body | stmts ]
- =>
- stmts >>= \bndrs -> return body
-
-In transform and grouping statements ('then ..' and 'then group ..') the
-'return' function is required for nested monad comprehensions, for example:
-
- [ body | stmts, then f, rest ]
- =>
- f [ env | stmts ] >>= \bndrs -> [ body | rest ]
-
-BodyStmts require the 'Control.Monad.guard' function for boolean
-expressions:
-
- [ body | exp, stmts ]
- =>
- guard exp >> [ body | stmts ]
-
-Parallel statements require the 'Control.Monad.Zip.mzip' function:
-
- [ body | stmts1 | stmts2 | .. ]
- =>
- mzip stmts1 (mzip stmts2 (..)) >>= \(bndrs1, (bndrs2, ..)) -> return body
-
-In any other context than 'MonadComp', the fields for most of these
-'SyntaxExpr's stay bottom.
-
-
-Note [Applicative BodyStmt]
-
-(#12143) For the purposes of ApplicativeDo, we treat any BodyStmt
-as if it was a BindStmt with a wildcard pattern. For example,
-
- do
- x <- A
- B
- return x
-
-is transformed as if it were
-
- do
- x <- A
- _ <- B
- return x
-
-so it transforms to
-
- (\(x,_) -> x) <$> A <*> B
-
-But we have to remember when we treat a BodyStmt like a BindStmt,
-because in error messages we want to emit the original syntax the user
-wrote, not our internal representation. So ApplicativeArgOne has a
-Bool flag that is True when the original statement was a BodyStmt, so
-that we can pretty-print it correctly.
--}
+type instance ApplicativeArgStmCtxPass _ = GhcRn
instance (Outputable (StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))),
Outputable (XXParStmtBlock (GhcPass idL) (GhcPass idR)))
@@ -2545,38 +1188,6 @@ pprQuals quals = interpp'SP quals
************************************************************************
-}
--- | Haskell Splice
-data HsSplice id
- = HsTypedSplice -- $$z or $$(f 4)
- (XTypedSplice id)
- SpliceDecoration -- Whether $$( ) variant found, for pretty printing
- (IdP id) -- A unique name to identify this splice point
- (LHsExpr id) -- See Note [Pending Splices]
-
- | HsUntypedSplice -- $z or $(f 4)
- (XUntypedSplice id)
- SpliceDecoration -- Whether $( ) variant found, for pretty printing
- (IdP id) -- A unique name to identify this splice point
- (LHsExpr id) -- See Note [Pending Splices]
-
- | HsQuasiQuote -- See Note [Quasi-quote overview] in GHC.Tc.Gen.Splice
- (XQuasiQuote id)
- (IdP id) -- Splice point
- (IdP id) -- Quoter
- SrcSpan -- The span of the enclosed string
- FastString -- The enclosed string
-
- -- AZ:TODO: use XSplice instead of HsSpliced
- | HsSpliced -- See Note [Delaying modFinalizers in untyped splices] in
- -- GHC.Rename.Splice.
- -- This is the result of splicing a splice. It is produced by
- -- the renamer and consumed by the typechecker. It lives only
- -- between the two.
- (XSpliced id)
- ThModFinalizers -- TH finalizers produced by the splice.
- (HsSplicedThing id) -- The result of splicing
- | XSplice !(XXSplice id) -- Note [Trees that Grow] extension point
-
newtype HsSplicedT = HsSplicedT DelayedSplice deriving (Data)
type instance XTypedSplice (GhcPass _) = NoExtField
@@ -2587,36 +1198,6 @@ type instance XXSplice GhcPs = NoExtCon
type instance XXSplice GhcRn = NoExtCon
type instance XXSplice GhcTc = HsSplicedT
--- | A splice can appear with various decorations wrapped around it. This data
--- type captures explicitly how it was originally written, for use in the pretty
--- printer.
-data SpliceDecoration
- = DollarSplice -- ^ $splice or $$splice
- | BareSplice -- ^ bare splice
- deriving (Data, Eq, Show)
-
-instance Outputable SpliceDecoration where
- ppr x = text $ show x
-
-
-isTypedSplice :: HsSplice id -> Bool
-isTypedSplice (HsTypedSplice {}) = True
-isTypedSplice _ = False -- Quasi-quotes are untyped splices
-
--- | Finalizers produced by a splice with
--- 'Language.Haskell.TH.Syntax.addModFinalizer'
---
--- See Note [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice. For how
--- this is used.
---
-newtype ThModFinalizers = ThModFinalizers [ForeignRef (TH.Q ())]
-
--- A Data instance which ignores the argument of 'ThModFinalizers'.
-instance Data ThModFinalizers where
- gunfold _ z _ = z $ ThModFinalizers []
- toConstr a = mkConstr (dataTypeOf a) "ThModFinalizers" [] Data.Prefix
- dataTypeOf a = mkDataType "HsExpr.ThModFinalizers" [toConstr a]
-
-- See Note [Running typed splices in the zonker]
-- These are the arguments that are passed to `GHC.Tc.Gen.Splice.runTopSplice`
data DelayedSplice =
@@ -2632,29 +1213,10 @@ instance Data DelayedSplice where
toConstr a = mkConstr (dataTypeOf a) "DelayedSplice" [] Data.Prefix
dataTypeOf a = mkDataType "HsExpr.DelayedSplice" [toConstr a]
--- | Haskell Spliced Thing
---
--- Values that can result from running a splice.
-data HsSplicedThing id
- = HsSplicedExpr (HsExpr id) -- ^ Haskell Spliced Expression
- | HsSplicedTy (HsType id) -- ^ Haskell Spliced Type
- | HsSplicedPat (Pat id) -- ^ Haskell Spliced Pattern
-
-
--- See Note [Pending Splices]
-type SplicePointName = Name
-
-- | Pending Renamer Splice
data PendingRnSplice
= PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)
-data UntypedSpliceFlavour
- = UntypedExpSplice
- | UntypedPatSplice
- | UntypedTypeSplice
- | UntypedDeclSplice
- deriving Data
-
-- | Pending Type-checker Splice
data PendingTcSplice
= PendingTcSplice SplicePointName (LHsExpr GhcTc)
@@ -2776,18 +1338,6 @@ ppr_splice :: (OutputableBndrId p)
ppr_splice herald n e trail
= herald <> whenPprDebug (brackets (ppr n)) <> ppr e <> trail
--- | Haskell Bracket
-data HsBracket p
- = ExpBr (XExpBr p) (LHsExpr p) -- [| expr |]
- | PatBr (XPatBr p) (LPat p) -- [p| pat |]
- | DecBrL (XDecBrL p) [LHsDecl p] -- [d| decls |]; result of parser
- | DecBrG (XDecBrG p) (HsGroup p) -- [d| decls |]; result of renamer
- | TypBr (XTypBr p) (LHsType p) -- [t| type |]
- | VarBr (XVarBr p) Bool (IdP p) -- True: 'x, False: ''T
- -- (The Bool flag is used only in pprHsBracket)
- | TExpBr (XTExpBr p) (LHsExpr p) -- [|| expr ||]
- | XBracket !(XXBracket p) -- Note [Trees that Grow] extension point
-
type instance XExpBr (GhcPass _) = NoExtField
type instance XPatBr (GhcPass _) = NoExtField
type instance XDecBrL (GhcPass _) = NoExtField
@@ -2797,10 +1347,6 @@ type instance XVarBr (GhcPass _) = NoExtField
type instance XTExpBr (GhcPass _) = NoExtField
type instance XXBracket (GhcPass _) = NoExtCon
-isTypedBracket :: HsBracket id -> Bool
-isTypedBracket (TExpBr {}) = True
-isTypedBracket _ = False
-
instance OutputableBndrId p
=> Outputable (HsBracket (GhcPass p)) where
ppr = pprHsBracket
@@ -2839,18 +1385,6 @@ instance Outputable PendingTcSplice where
************************************************************************
-}
--- | Arithmetic Sequence Information
-data ArithSeqInfo id
- = From (LHsExpr id)
- | FromThen (LHsExpr id)
- (LHsExpr id)
- | FromTo (LHsExpr id)
- (LHsExpr id)
- | FromThenTo (LHsExpr id)
- (LHsExpr id)
- (LHsExpr id)
--- AZ: Should ArithSeqInfo have a TTG extension?
-
instance OutputableBndrId p
=> Outputable (ArithSeqInfo (GhcPass p)) where
ppr (From e1) = hcat [ppr e1, pp_dotdot]
@@ -2870,38 +1404,6 @@ pp_dotdot = text " .. "
************************************************************************
-}
--- | Haskell Match Context
---
--- Context of a pattern match. This is more subtle than it would seem. See Note
--- [Varieties of pattern matches].
-data HsMatchContext p
- = FunRhs { mc_fun :: LIdP p -- ^ function binder of @f@
- , mc_fixity :: LexicalFixity -- ^ fixing of @f@
- , mc_strictness :: SrcStrictness -- ^ was @f@ banged?
- -- See Note [FunBind vs PatBind]
- }
- -- ^A pattern matching on an argument of a
- -- function binding
- | LambdaExpr -- ^Patterns of a lambda
- | CaseAlt -- ^Patterns and guards on a case alternative
- | IfAlt -- ^Guards of a multi-way if alternative
- | ProcExpr -- ^Patterns of a proc
- | PatBindRhs -- ^A pattern binding eg [y] <- e = e
- | PatBindGuards -- ^Guards of pattern bindings, e.g.,
- -- (Just b) | Just _ <- x = e
- -- | otherwise = e'
-
- | RecUpd -- ^Record update [used only in GHC.HsToCore.Expr to
- -- tell matchWrapper what sort of
- -- runtime error message to generate]
-
- | StmtCtxt (HsStmtContext p) -- ^Pattern of a do-stmt, list comprehension,
- -- pattern guard, etc
-
- | ThPatSplice -- ^A Template Haskell pattern splice
- | ThPatQuote -- ^A Template Haskell pattern quotation [p| (a,b) |]
- | PatSyn -- ^A pattern synonym declaration
-
instance OutputableBndrId p => Outputable (HsMatchContext (GhcPass p)) where
ppr m@(FunRhs{}) = text "FunRhs" <+> ppr (mc_fun m) <+> ppr (mc_fixity m)
ppr LambdaExpr = text "LambdaExpr"
@@ -2916,134 +1418,7 @@ instance OutputableBndrId p => Outputable (HsMatchContext (GhcPass p)) where
ppr ThPatQuote = text "ThPatQuote"
ppr PatSyn = text "PatSyn"
-isPatSynCtxt :: HsMatchContext p -> Bool
-isPatSynCtxt ctxt =
- case ctxt of
- PatSyn -> True
- _ -> False
-
--- | Haskell Statement Context.
-data HsStmtContext p
- = ListComp
- | MonadComp
-
- | DoExpr (Maybe ModuleName) -- ^[ModuleName.]do { ... }
- | MDoExpr (Maybe ModuleName) -- ^[ModuleName.]mdo { ... } ie recursive do-expression
- | ArrowExpr -- ^do-notation in an arrow-command context
-
- | GhciStmtCtxt -- ^A command-line Stmt in GHCi pat <- rhs
- | PatGuard (HsMatchContext p) -- ^Pattern guard for specified thing
- | ParStmtCtxt (HsStmtContext p) -- ^A branch of a parallel stmt
- | TransStmtCtxt (HsStmtContext p) -- ^A branch of a transform stmt
-
-qualifiedDoModuleName_maybe :: HsStmtContext p -> Maybe ModuleName
-qualifiedDoModuleName_maybe ctxt = case ctxt of
- DoExpr m -> m
- MDoExpr m -> m
- _ -> Nothing
-
-isComprehensionContext :: HsStmtContext id -> Bool
--- Uses comprehension syntax [ e | quals ]
-isComprehensionContext ListComp = True
-isComprehensionContext MonadComp = True
-isComprehensionContext (ParStmtCtxt c) = isComprehensionContext c
-isComprehensionContext (TransStmtCtxt c) = isComprehensionContext c
-isComprehensionContext _ = False
-
--- | Is this a monadic context?
-isMonadStmtContext :: HsStmtContext id -> Bool
-isMonadStmtContext MonadComp = True
-isMonadStmtContext DoExpr{} = True
-isMonadStmtContext MDoExpr{} = True
-isMonadStmtContext GhciStmtCtxt = True
-isMonadStmtContext (ParStmtCtxt ctxt) = isMonadStmtContext ctxt
-isMonadStmtContext (TransStmtCtxt ctxt) = isMonadStmtContext ctxt
-isMonadStmtContext _ = False -- ListComp, PatGuard, ArrowExpr
-
-isMonadCompContext :: HsStmtContext id -> Bool
-isMonadCompContext MonadComp = True
-isMonadCompContext _ = False
-
-matchSeparator :: HsMatchContext p -> SDoc
-matchSeparator (FunRhs {}) = text "="
-matchSeparator CaseAlt = text "->"
-matchSeparator IfAlt = text "->"
-matchSeparator LambdaExpr = text "->"
-matchSeparator ProcExpr = text "->"
-matchSeparator PatBindRhs = text "="
-matchSeparator PatBindGuards = text "="
-matchSeparator (StmtCtxt _) = text "<-"
-matchSeparator RecUpd = text "=" -- This can be printed by the pattern
- -- match checker trace
-matchSeparator ThPatSplice = panic "unused"
-matchSeparator ThPatQuote = panic "unused"
-matchSeparator PatSyn = panic "unused"
-
-pprMatchContext :: (Outputable (IdP p), UnXRec p)
- => HsMatchContext p -> SDoc
-pprMatchContext ctxt
- | want_an ctxt = text "an" <+> pprMatchContextNoun ctxt
- | otherwise = text "a" <+> pprMatchContextNoun ctxt
- where
- want_an (FunRhs {}) = True -- Use "an" in front
- want_an ProcExpr = True
- want_an _ = False
-
-pprMatchContextNoun :: forall p. (Outputable (IdP p), UnXRec p)
- => HsMatchContext p -> SDoc
-pprMatchContextNoun (FunRhs {mc_fun=fun})
- = text "equation for"
- <+> quotes (ppr (unXRec @p fun))
-pprMatchContextNoun CaseAlt = text "case alternative"
-pprMatchContextNoun IfAlt = text "multi-way if alternative"
-pprMatchContextNoun RecUpd = text "record-update construct"
-pprMatchContextNoun ThPatSplice = text "Template Haskell pattern splice"
-pprMatchContextNoun ThPatQuote = text "Template Haskell pattern quotation"
-pprMatchContextNoun PatBindRhs = text "pattern binding"
-pprMatchContextNoun PatBindGuards = text "pattern binding guards"
-pprMatchContextNoun LambdaExpr = text "lambda abstraction"
-pprMatchContextNoun ProcExpr = text "arrow abstraction"
-pprMatchContextNoun (StmtCtxt ctxt) = text "pattern binding in"
- $$ pprAStmtContext ctxt
-pprMatchContextNoun PatSyn = text "pattern synonym declaration"
-
------------------
-pprAStmtContext, pprStmtContext :: (Outputable (IdP p), UnXRec p)
- => HsStmtContext p -> SDoc
-pprAStmtContext ctxt = article <+> pprStmtContext ctxt
- where
- pp_an = text "an"
- pp_a = text "a"
- article = case ctxt of
- MDoExpr Nothing -> pp_an
- GhciStmtCtxt -> pp_an
- _ -> pp_a
-
-
-----------------
-pprStmtContext GhciStmtCtxt = text "interactive GHCi command"
-pprStmtContext (DoExpr m) = prependQualified m (text "'do' block")
-pprStmtContext (MDoExpr m) = prependQualified m (text "'mdo' block")
-pprStmtContext ArrowExpr = text "'do' block in an arrow command"
-pprStmtContext ListComp = text "list comprehension"
-pprStmtContext MonadComp = text "monad comprehension"
-pprStmtContext (PatGuard ctxt) = text "pattern guard for" $$ pprMatchContext ctxt
-
--- Drop the inner contexts when reporting errors, else we get
--- Unexpected transform statement
--- in a transformed branch of
--- transformed branch of
--- transformed branch of monad comprehension
-pprStmtContext (ParStmtCtxt c) =
- ifPprDebug (sep [text "parallel branch of", pprAStmtContext c])
- (pprStmtContext c)
-pprStmtContext (TransStmtCtxt c) =
- ifPprDebug (sep [text "transformed branch of", pprAStmtContext c])
- (pprStmtContext c)
-
-prependQualified :: Maybe ModuleName -> SDoc -> SDoc
-prependQualified Nothing t = t
-prependQualified (Just _) t = text "qualified" <+> t
instance OutputableBndrId p
=> Outputable (HsStmtContext (GhcPass p)) where
diff --git a/compiler/GHC/Hs/Expr.hs-boot b/compiler/GHC/Hs/Expr.hs-boot
index 7bd7753c56..3eb1894e70 100644
--- a/compiler/GHC/Hs/Expr.hs-boot
+++ b/compiler/GHC/Hs/Expr.hs-boot
@@ -1,38 +1,28 @@
-{-# LANGUAGE CPP, KindSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
-{-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE RoleAnnotations #-}
-{-# LANGUAGE ExistentialQuantification #-}
-{-# LANGUAGE TypeFamilies #-}
+ -- in module Language.Haskell.Syntax.Extension
+
+{-# OPTIONS_GHC -Wno-orphans #-}
module GHC.Hs.Expr where
import GHC.Utils.Outputable ( SDoc, Outputable )
-import {-# SOURCE #-} GHC.Hs.Pat ( LPat )
-import GHC.Types.Basic ( SpliceExplicitFlag(..))
-import GHC.Hs.Extension ( OutputableBndrId, GhcPass, XRec )
-import Data.Kind ( Type )
-
-type role HsExpr nominal
-type role HsCmd nominal
-type role MatchGroup nominal nominal
-type role GRHSs nominal nominal
-type role HsSplice nominal
-data HsExpr (i :: Type)
-data HsCmd (i :: Type)
-data HsSplice (i :: Type)
-data MatchGroup (a :: Type) (body :: Type)
-data GRHSs (a :: Type) (body :: Type)
-type family SyntaxExpr (i :: Type)
+import Language.Haskell.Syntax.Pat ( LPat )
+import {-# SOURCE #-} GHC.Hs.Pat () -- for Outputable
+import GHC.Types.Basic ( SpliceExplicitFlag(..))
+import Language.Haskell.Syntax.Expr
+ ( HsExpr, LHsExpr
+ , HsCmd
+ , MatchGroup
+ , GRHSs
+ , HsSplice
+ )
+import GHC.Hs.Extension ( OutputableBndrId, GhcPass )
instance OutputableBndrId p => Outputable (HsExpr (GhcPass p))
instance OutputableBndrId p => Outputable (HsCmd (GhcPass p))
-type LHsExpr a = XRec a (HsExpr a)
-
pprLExpr :: (OutputableBndrId p) => LHsExpr (GhcPass p) -> SDoc
pprExpr :: (OutputableBndrId p) => HsExpr (GhcPass p) -> SDoc
diff --git a/compiler/GHC/Hs/Extension.hs b/compiler/GHC/Hs/Extension.hs
index 3e9bac5442..ac79d83d0b 100644
--- a/compiler/GHC/Hs/Extension.hs
+++ b/compiler/GHC/Hs/Extension.hs
@@ -14,7 +14,7 @@
{-# LANGUAGE TypeFamilyDependencies #-}
{-# LANGUAGE UndecidableSuperClasses #-} -- for IsPass; see Note [NoGhcTc]
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
+ -- in module Language.Haskell.Syntax.Extension
module GHC.Hs.Extension where
@@ -24,6 +24,7 @@ module GHC.Hs.Extension where
import GHC.Prelude
import Data.Data hiding ( Fixity )
+import Language.Haskell.Syntax.Extension
import GHC.Types.Name
import GHC.Types.Name.Reader
import GHC.Types.Var
@@ -31,40 +32,7 @@ import GHC.Utils.Outputable
import GHC.Types.SrcLoc (Located, unLoc, noLoc)
import GHC.Utils.Panic
-import Data.Kind
-
{-
-Note [Trees that grow]
-~~~~~~~~~~~~~~~~~~~~~~
-
-See https://gitlab.haskell.org/ghc/ghc/wikis/implementing-trees-that-grow
-
-The hsSyn AST is reused across multiple compiler passes. We also have the
-Template Haskell AST, and the haskell-src-exts one (outside of GHC)
-
-Supporting multiple passes means the AST has various warts on it to cope with
-the specifics for the phases, such as the 'ValBindsOut', 'ConPatOut',
-'SigPatOut' etc.
-
-The growable AST will allow each of these variants to be captured explicitly,
-such that they only exist in the given compiler pass AST, as selected by the
-type parameter to the AST.
-
-In addition it will allow tool writers to define their own extensions to capture
-additional information for the tool, in a natural way.
-
-A further goal is to provide a means to harmonise the Template Haskell and
-haskell-src-exts ASTs as well.
-
-Wrinkle: In order to print out the AST, we need to know it is Outputable.
-We also sometimes need to branch on the particular pass that we're in
-(e.g. to print out type information once we know it). In order to allow
-both of these actions, we define OutputableBndrId, which gathers the necessary
-OutputableBndr and IsPass constraints. The use of this constraint in instances
-generally requires UndecidableInstances.
-
-See also Note [IsPass] and Note [NoGhcTc].
-
Note [IsPass]
~~~~~~~~~~~~~
One challenge with the Trees That Grow approach
@@ -126,91 +94,8 @@ saying that NoGhcTcPass is idempotent.
-}
--- | A placeholder type for TTG extension points that are not currently
--- unused to represent any particular value.
---
--- This should not be confused with 'NoExtCon', which are found in unused
--- extension /constructors/ and therefore should never be inhabited. In
--- contrast, 'NoExtField' is used in extension /points/ (e.g., as the field of
--- some constructor), so it must have an inhabitant to construct AST passes
--- that manipulate fields with that extension point as their type.
-data NoExtField = NoExtField
- deriving (Data,Eq,Ord)
-
-instance Outputable NoExtField where
- ppr _ = text "NoExtField"
-
--- | Used when constructing a term with an unused extension point.
-noExtField :: NoExtField
-noExtField = NoExtField
-
--- | Used in TTG extension constructors that have yet to be extended with
--- anything. If an extension constructor has 'NoExtCon' as its field, it is
--- not intended to ever be constructed anywhere, and any function that consumes
--- the extension constructor can eliminate it by way of 'noExtCon'.
---
--- This should not be confused with 'NoExtField', which are found in unused
--- extension /points/ (not /constructors/) and therefore can be inhabited.
-
--- See also [NoExtCon and strict fields].
-data NoExtCon
- deriving (Data,Eq,Ord)
-
-instance Outputable NoExtCon where
- ppr = noExtCon
-
--- | Eliminate a 'NoExtCon'. Much like 'Data.Void.absurd'.
-noExtCon :: NoExtCon -> a
-noExtCon x = case x of {}
-
--- | GHC's L prefixed variants wrap their vanilla variant in this type family,
--- to add 'SrcLoc' info via 'Located'. Other passes than 'GhcPass' not
--- interested in location information can define this as
--- @type instance XRec NoLocated a = a@.
--- See Note [XRec and SrcSpans in the AST]
-type family XRec p a = r | r -> a
-
type instance XRec (GhcPass p) a = Located a
-{-
-Note [XRec and SrcSpans in the AST]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-XRec is meant to replace most of the uses of `Located` in the AST. It is another
-extension point meant to make it easier for non-GHC applications to reuse the
-AST for their own purposes, and not have to deal the hassle of (perhaps) useless
-SrcSpans everywhere.
-
-instead of `Located (HsExpr p)` or similar types, we will now have `XRec p
-(HsExpr p)`
-
-XRec allows annotating certain points in the AST with extra information. This
-maybe be source spans (for GHC), nothing (for TH), types (for HIE files), api
-annotations (for exactprint) or anything else.
-
-This should hopefully bring us one step closer to sharing the AST between GHC
-and TH.
-
-We use the `UnXRec`, `MapXRec` and `WrapXRec` type classes to aid us in writing
-pass-polymorphic code that deals with `XRec`s
--}
-
--- | We can strip off the XRec to access the underlying data.
--- See Note [XRec and SrcSpans in the AST]
-class UnXRec p where
- unXRec :: XRec p a -> a
-
--- | We can map over the underlying type contained in an @XRec@ while preserving
--- the annotation as is.
--- See Note [XRec and SrcSpans in the AST]
-class MapXRec p where
- mapXRec :: (a -> b) -> XRec p a -> XRec p b
-
--- | The trivial wrapper that carries no additional information
--- @noLoc@ for @GhcPass p@
--- See Note [XRec and SrcSpans in the AST]
-class WrapXRec p where
- wrapXRec :: a -> XRec p a
-
instance UnXRec (GhcPass p) where
unXRec = unLoc
instance MapXRec (GhcPass p) where
@@ -293,8 +178,6 @@ instance IsPass 'Renamed where
instance IsPass 'Typechecked where
ghcPass = GhcTc
--- | Maps the "normal" id type for a given pass
-type family IdP p
type instance IdP (GhcPass p) = IdGhcP p
-- | Maps the "normal" id type for a given GHC pass
@@ -303,530 +186,18 @@ type family IdGhcP pass where
IdGhcP 'Renamed = Name
IdGhcP 'Typechecked = Id
-type LIdP p = XRec p (IdP p)
-
-- | Marks that a field uses the GhcRn variant even when the pass
-- parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because
-- HsType GhcTc should never occur.
-- See Note [NoGhcTc]
-type family NoGhcTc (p :: Type) where
- -- this way, GHC can figure out that the result is a GhcPass
- NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)
- NoGhcTc other = other
+
+-- Breaking it up this way, GHC can figure out that the result is a GhcPass
+type instance NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)
type family NoGhcTcPass (p :: Pass) :: Pass where
NoGhcTcPass 'Typechecked = 'Renamed
NoGhcTcPass other = other
--- =====================================================================
--- Type families for the HsBinds extension points
-
--- HsLocalBindsLR type families
-type family XHsValBinds x x'
-type family XHsIPBinds x x'
-type family XEmptyLocalBinds x x'
-type family XXHsLocalBindsLR x x'
-
--- HsValBindsLR type families
-type family XValBinds x x'
-type family XXValBindsLR x x'
-
--- HsBindLR type families
-type family XFunBind x x'
-type family XPatBind x x'
-type family XVarBind x x'
-type family XAbsBinds x x'
-type family XPatSynBind x x'
-type family XXHsBindsLR x x'
-
--- ABExport type families
-type family XABE x
-type family XXABExport x
-
--- PatSynBind type families
-type family XPSB x x'
-type family XXPatSynBind x x'
-
--- HsIPBinds type families
-type family XIPBinds x
-type family XXHsIPBinds x
-
--- IPBind type families
-type family XCIPBind x
-type family XXIPBind x
-
--- Sig type families
-type family XTypeSig x
-type family XPatSynSig x
-type family XClassOpSig x
-type family XIdSig x
-type family XFixSig x
-type family XInlineSig x
-type family XSpecSig x
-type family XSpecInstSig x
-type family XMinimalSig x
-type family XSCCFunSig x
-type family XCompleteMatchSig x
-type family XXSig x
-
--- FixitySig type families
-type family XFixitySig x
-type family XXFixitySig x
-
--- StandaloneKindSig type families
-type family XStandaloneKindSig x
-type family XXStandaloneKindSig x
-
--- =====================================================================
--- Type families for the HsDecls extension points
-
--- HsDecl type families
-type family XTyClD x
-type family XInstD x
-type family XDerivD x
-type family XValD x
-type family XSigD x
-type family XKindSigD x
-type family XDefD x
-type family XForD x
-type family XWarningD x
-type family XAnnD x
-type family XRuleD x
-type family XSpliceD x
-type family XDocD x
-type family XRoleAnnotD x
-type family XXHsDecl x
-
--- -------------------------------------
--- HsGroup type families
-type family XCHsGroup x
-type family XXHsGroup x
-
--- -------------------------------------
--- SpliceDecl type families
-type family XSpliceDecl x
-type family XXSpliceDecl x
-
--- -------------------------------------
--- TyClDecl type families
-type family XFamDecl x
-type family XSynDecl x
-type family XDataDecl x
-type family XClassDecl x
-type family XXTyClDecl x
-
--- -------------------------------------
--- TyClGroup type families
-type family XCTyClGroup x
-type family XXTyClGroup x
-
--- -------------------------------------
--- FamilyResultSig type families
-type family XNoSig x
-type family XCKindSig x -- Clashes with XKindSig above
-type family XTyVarSig x
-type family XXFamilyResultSig x
-
--- -------------------------------------
--- FamilyDecl type families
-type family XCFamilyDecl x
-type family XXFamilyDecl x
-
--- -------------------------------------
--- HsDataDefn type families
-type family XCHsDataDefn x
-type family XXHsDataDefn x
-
--- -------------------------------------
--- HsDerivingClause type families
-type family XCHsDerivingClause x
-type family XXHsDerivingClause x
-
--- -------------------------------------
--- DerivClauseTys type families
-type family XDctSingle x
-type family XDctMulti x
-type family XXDerivClauseTys x
-
--- -------------------------------------
--- ConDecl type families
-type family XConDeclGADT x
-type family XConDeclH98 x
-type family XXConDecl x
-
--- -------------------------------------
--- FamEqn type families
-type family XCFamEqn x r
-type family XXFamEqn x r
-
--- -------------------------------------
--- ClsInstDecl type families
-type family XCClsInstDecl x
-type family XXClsInstDecl x
-
--- -------------------------------------
--- InstDecl type families
-type family XClsInstD x
-type family XDataFamInstD x
-type family XTyFamInstD x
-type family XXInstDecl x
-
--- -------------------------------------
--- DerivDecl type families
-type family XCDerivDecl x
-type family XXDerivDecl x
-
--- -------------------------------------
--- DerivStrategy type family
-type family XViaStrategy x
-
--- -------------------------------------
--- DefaultDecl type families
-type family XCDefaultDecl x
-type family XXDefaultDecl x
-
--- -------------------------------------
--- ForeignDecl type families
-type family XForeignImport x
-type family XForeignExport x
-type family XXForeignDecl x
-
--- -------------------------------------
--- RuleDecls type families
-type family XCRuleDecls x
-type family XXRuleDecls x
-
--- -------------------------------------
--- RuleDecl type families
-type family XHsRule x
-type family XXRuleDecl x
-
--- -------------------------------------
--- RuleBndr type families
-type family XCRuleBndr x
-type family XRuleBndrSig x
-type family XXRuleBndr x
-
--- -------------------------------------
--- WarnDecls type families
-type family XWarnings x
-type family XXWarnDecls x
-
--- -------------------------------------
--- WarnDecl type families
-type family XWarning x
-type family XXWarnDecl x
-
--- -------------------------------------
--- AnnDecl type families
-type family XHsAnnotation x
-type family XXAnnDecl x
-
--- -------------------------------------
--- RoleAnnotDecl type families
-type family XCRoleAnnotDecl x
-type family XXRoleAnnotDecl x
-
--- =====================================================================
--- Type families for the HsExpr extension points
-
-type family XVar x
-type family XUnboundVar x
-type family XConLikeOut x
-type family XRecFld x
-type family XOverLabel x
-type family XIPVar x
-type family XOverLitE x
-type family XLitE x
-type family XLam x
-type family XLamCase x
-type family XApp x
-type family XAppTypeE x
-type family XOpApp x
-type family XNegApp x
-type family XPar x
-type family XSectionL x
-type family XSectionR x
-type family XExplicitTuple x
-type family XExplicitSum x
-type family XCase x
-type family XIf x
-type family XMultiIf x
-type family XLet x
-type family XDo x
-type family XExplicitList x
-type family XRecordCon x
-type family XRecordUpd x
-type family XExprWithTySig x
-type family XArithSeq x
-type family XBracket x
-type family XRnBracketOut x
-type family XTcBracketOut x
-type family XSpliceE x
-type family XProc x
-type family XStatic x
-type family XTick x
-type family XBinTick x
-type family XPragE x
-type family XXExpr x
-
--- -------------------------------------
--- HsPragE type families
-type family XSCC x
-type family XXPragE x
-
-
--- -------------------------------------
--- AmbiguousFieldOcc type families
-type family XUnambiguous x
-type family XAmbiguous x
-type family XXAmbiguousFieldOcc x
-
--- -------------------------------------
--- HsTupArg type families
-type family XPresent x
-type family XMissing x
-type family XXTupArg x
-
--- -------------------------------------
--- HsSplice type families
-type family XTypedSplice x
-type family XUntypedSplice x
-type family XQuasiQuote x
-type family XSpliced x
-type family XXSplice x
-
--- -------------------------------------
--- HsBracket type families
-type family XExpBr x
-type family XPatBr x
-type family XDecBrL x
-type family XDecBrG x
-type family XTypBr x
-type family XVarBr x
-type family XTExpBr x
-type family XXBracket x
-
--- -------------------------------------
--- HsCmdTop type families
-type family XCmdTop x
-type family XXCmdTop x
-
--- -------------------------------------
--- MatchGroup type families
-type family XMG x b
-type family XXMatchGroup x b
-
--- -------------------------------------
--- Match type families
-type family XCMatch x b
-type family XXMatch x b
-
--- -------------------------------------
--- GRHSs type families
-type family XCGRHSs x b
-type family XXGRHSs x b
-
--- -------------------------------------
--- GRHS type families
-type family XCGRHS x b
-type family XXGRHS x b
-
--- -------------------------------------
--- StmtLR type families
-type family XLastStmt x x' b
-type family XBindStmt x x' b
-type family XApplicativeStmt x x' b
-type family XBodyStmt x x' b
-type family XLetStmt x x' b
-type family XParStmt x x' b
-type family XTransStmt x x' b
-type family XRecStmt x x' b
-type family XXStmtLR x x' b
-
--- -------------------------------------
--- HsCmd type families
-type family XCmdArrApp x
-type family XCmdArrForm x
-type family XCmdApp x
-type family XCmdLam x
-type family XCmdPar x
-type family XCmdCase x
-type family XCmdLamCase x
-type family XCmdIf x
-type family XCmdLet x
-type family XCmdDo x
-type family XCmdWrap x
-type family XXCmd x
-
--- -------------------------------------
--- ParStmtBlock type families
-type family XParStmtBlock x x'
-type family XXParStmtBlock x x'
-
--- -------------------------------------
--- ApplicativeArg type families
-type family XApplicativeArgOne x
-type family XApplicativeArgMany x
-type family XXApplicativeArg x
-
--- =====================================================================
--- Type families for the HsImpExp extension points
-
--- TODO
-
--- =====================================================================
--- Type families for the HsLit extension points
-
--- We define a type family for each extension point. This is based on prepending
--- 'X' to the constructor name, for ease of reference.
-type family XHsChar x
-type family XHsCharPrim x
-type family XHsString x
-type family XHsStringPrim x
-type family XHsInt x
-type family XHsIntPrim x
-type family XHsWordPrim x
-type family XHsInt64Prim x
-type family XHsWord64Prim x
-type family XHsInteger x
-type family XHsRat x
-type family XHsFloatPrim x
-type family XHsDoublePrim x
-type family XXLit x
-
--- -------------------------------------
--- HsOverLit type families
-type family XOverLit x
-type family XXOverLit x
-
--- =====================================================================
--- Type families for the HsPat extension points
-
-type family XWildPat x
-type family XVarPat x
-type family XLazyPat x
-type family XAsPat x
-type family XParPat x
-type family XBangPat x
-type family XListPat x
-type family XTuplePat x
-type family XSumPat x
-type family XConPat x
-type family XViewPat x
-type family XSplicePat x
-type family XLitPat x
-type family XNPat x
-type family XNPlusKPat x
-type family XSigPat x
-type family XCoPat x
-type family XXPat x
-
--- =====================================================================
--- Type families for the HsTypes type families
-
-
--- -------------------------------------
--- LHsQTyVars type families
-type family XHsQTvs x
-type family XXLHsQTyVars x
-
--- -------------------------------------
--- HsOuterTyVarBndrs type families
-type family XHsOuterImplicit x
-type family XHsOuterExplicit x flag
-type family XXHsOuterTyVarBndrs x
-
--- -------------------------------------
--- HsSigType type families
-type family XHsSig x
-type family XXHsSigType x
-
--- -------------------------------------
--- HsWildCardBndrs type families
-type family XHsWC x b
-type family XXHsWildCardBndrs x b
-
--- -------------------------------------
--- HsPatSigType type families
-type family XHsPS x
-type family XXHsPatSigType x
-
--- -------------------------------------
--- HsType type families
-type family XForAllTy x
-type family XQualTy x
-type family XTyVar x
-type family XAppTy x
-type family XAppKindTy x
-type family XFunTy x
-type family XListTy x
-type family XTupleTy x
-type family XSumTy x
-type family XOpTy x
-type family XParTy x
-type family XIParamTy x
-type family XStarTy x
-type family XKindSig x
-type family XSpliceTy x
-type family XDocTy x
-type family XBangTy x
-type family XRecTy x
-type family XExplicitListTy x
-type family XExplicitTupleTy x
-type family XTyLit x
-type family XWildCardTy x
-type family XXType x
-
--- ---------------------------------------------------------------------
--- HsForAllTelescope type families
-type family XHsForAllVis x
-type family XHsForAllInvis x
-type family XXHsForAllTelescope x
-
--- ---------------------------------------------------------------------
--- HsTyVarBndr type families
-type family XUserTyVar x
-type family XKindedTyVar x
-type family XXTyVarBndr x
-
--- ---------------------------------------------------------------------
--- ConDeclField type families
-type family XConDeclField x
-type family XXConDeclField x
-
--- ---------------------------------------------------------------------
--- FieldOcc type families
-type family XCFieldOcc x
-type family XXFieldOcc x
-
--- =====================================================================
--- Type families for the HsImpExp type families
-
--- -------------------------------------
--- ImportDecl type families
-type family XCImportDecl x
-type family XXImportDecl x
-
--- -------------------------------------
--- IE type families
-type family XIEVar x
-type family XIEThingAbs x
-type family XIEThingAll x
-type family XIEThingWith x
-type family XIEModuleContents x
-type family XIEGroup x
-type family XIEDoc x
-type family XIEDocNamed x
-type family XXIE x
-
--- -------------------------------------
-
-
--- =====================================================================
--- End of Type family definitions
--- =====================================================================
-
-- |Constraint type to bundle up the requirement for 'OutputableBndr' on both
-- the @id@ and the 'NoGhcTc' of it. See Note [NoGhcTc].
type OutputableBndrId pass =
diff --git a/compiler/GHC/Hs/ImpExp.hs b/compiler/GHC/Hs/ImpExp.hs
index 33c32aa7f7..f290c458b2 100644
--- a/compiler/GHC/Hs/ImpExp.hs
+++ b/compiler/GHC/Hs/ImpExp.hs
@@ -5,7 +5,7 @@
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
+ -- in module Language.Haskell.Syntax.Extension
{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
@@ -28,6 +28,7 @@ import GHC.Utils.Outputable
import GHC.Utils.Panic
import GHC.Data.FastString
import GHC.Types.SrcLoc
+import Language.Haskell.Syntax.Extension
import GHC.Hs.Extension
import Data.Data
diff --git a/compiler/GHC/Hs/Lit.hs b/compiler/GHC/Hs/Lit.hs
index 75ea3ef469..9aaadba24f 100644
--- a/compiler/GHC/Hs/Lit.hs
+++ b/compiler/GHC/Hs/Lit.hs
@@ -5,7 +5,9 @@
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
+ -- in module Language.Haskell.Syntax.Extension
+
+{-# OPTIONS_GHC -Wno-orphans #-} -- Outputable, OutputableBndrId
{-
(c) The University of Glasgow 2006
@@ -14,22 +16,25 @@
-}
-- | Source-language literals
-module GHC.Hs.Lit where
+module GHC.Hs.Lit
+ ( module Language.Haskell.Syntax.Lit
+ , module GHC.Hs.Lit
+ ) where
#include "HsVersions.h"
import GHC.Prelude
-import {-# SOURCE #-} GHC.Hs.Expr( HsExpr, pprExpr )
-import GHC.Types.Basic (PprPrec(..), topPrec )
+import {-# SOURCE #-} GHC.Hs.Expr( pprExpr )
+
+import Language.Haskell.Syntax.Lit
+
import GHC.Types.SourceText
import GHC.Core.Type
import GHC.Utils.Outputable
-import GHC.Utils.Panic
-import GHC.Data.FastString
+import Language.Haskell.Syntax.Extension
import GHC.Hs.Extension
-import Data.ByteString (ByteString)
import Data.Data hiding ( Fixity )
{-
@@ -40,45 +45,6 @@ import Data.Data hiding ( Fixity )
************************************************************************
-}
--- Note [Literal source text] in GHC.Types.Basic for SourceText fields in
--- the following
--- Note [Trees that grow] in GHC.Hs.Extension for the Xxxxx fields in the following
--- | Haskell Literal
-data HsLit x
- = HsChar (XHsChar x) {- SourceText -} Char
- -- ^ Character
- | HsCharPrim (XHsCharPrim x) {- SourceText -} Char
- -- ^ Unboxed character
- | HsString (XHsString x) {- SourceText -} FastString
- -- ^ String
- | HsStringPrim (XHsStringPrim x) {- SourceText -} !ByteString
- -- ^ Packed bytes
- | HsInt (XHsInt x) IntegralLit
- -- ^ Genuinely an Int; arises from
- -- "GHC.Tc.Deriv.Generate", and from TRANSLATION
- | HsIntPrim (XHsIntPrim x) {- SourceText -} Integer
- -- ^ literal @Int#@
- | HsWordPrim (XHsWordPrim x) {- SourceText -} Integer
- -- ^ literal @Word#@
- | HsInt64Prim (XHsInt64Prim x) {- SourceText -} Integer
- -- ^ literal @Int64#@
- | HsWord64Prim (XHsWord64Prim x) {- SourceText -} Integer
- -- ^ literal @Word64#@
- | HsInteger (XHsInteger x) {- SourceText -} Integer Type
- -- ^ Genuinely an integer; arises only
- -- from TRANSLATION (overloaded
- -- literals are done with HsOverLit)
- | HsRat (XHsRat x) FractionalLit Type
- -- ^ Genuinely a rational; arises only from
- -- TRANSLATION (overloaded literals are
- -- done with HsOverLit)
- | HsFloatPrim (XHsFloatPrim x) FractionalLit
- -- ^ Unboxed Float
- | HsDoublePrim (XHsDoublePrim x) FractionalLit
- -- ^ Unboxed Double
-
- | XLit !(XXLit x)
-
type instance XHsChar (GhcPass _) = SourceText
type instance XHsCharPrim (GhcPass _) = SourceText
type instance XHsString (GhcPass _) = SourceText
@@ -94,32 +60,6 @@ type instance XHsFloatPrim (GhcPass _) = NoExtField
type instance XHsDoublePrim (GhcPass _) = NoExtField
type instance XXLit (GhcPass _) = NoExtCon
-instance Eq (HsLit x) where
- (HsChar _ x1) == (HsChar _ x2) = x1==x2
- (HsCharPrim _ x1) == (HsCharPrim _ x2) = x1==x2
- (HsString _ x1) == (HsString _ x2) = x1==x2
- (HsStringPrim _ x1) == (HsStringPrim _ x2) = x1==x2
- (HsInt _ x1) == (HsInt _ x2) = x1==x2
- (HsIntPrim _ x1) == (HsIntPrim _ x2) = x1==x2
- (HsWordPrim _ x1) == (HsWordPrim _ x2) = x1==x2
- (HsInt64Prim _ x1) == (HsInt64Prim _ x2) = x1==x2
- (HsWord64Prim _ x1) == (HsWord64Prim _ x2) = x1==x2
- (HsInteger _ x1 _) == (HsInteger _ x2 _) = x1==x2
- (HsRat _ x1 _) == (HsRat _ x2 _) = x1==x2
- (HsFloatPrim _ x1) == (HsFloatPrim _ x2) = x1==x2
- (HsDoublePrim _ x1) == (HsDoublePrim _ x2) = x1==x2
- _ == _ = False
-
--- | Haskell Overloaded Literal
-data HsOverLit p
- = OverLit {
- ol_ext :: (XOverLit p),
- ol_val :: OverLitVal,
- ol_witness :: HsExpr p} -- Note [Overloaded literal witnesses]
-
- | XOverLit
- !(XXOverLit p)
-
data OverLitTc
= OverLitTc {
ol_rebindable :: Bool, -- Note [ol_rebindable]
@@ -132,20 +72,6 @@ type instance XOverLit GhcTc = OverLitTc
type instance XXOverLit (GhcPass _) = NoExtCon
--- Note [Literal source text] in GHC.Types.Basic for SourceText fields in
--- the following
--- | Overloaded Literal Value
-data OverLitVal
- = HsIntegral !IntegralLit -- ^ Integer-looking literals;
- | HsFractional !FractionalLit -- ^ Frac-looking literals
- | HsIsString !SourceText !FastString -- ^ String-looking literals
- deriving Data
-
-negateOverLitVal :: OverLitVal -> OverLitVal
-negateOverLitVal (HsIntegral i) = HsIntegral (negateIntegralLit i)
-negateOverLitVal (HsFractional f) = HsFractional (negateFractionalLit f)
-negateOverLitVal _ = panic "negateOverLitVal: argument is not a number"
-
overLitType :: HsOverLit GhcTc -> Type
overLitType (OverLit (OverLitTc _ ty) _ _) = ty
@@ -178,52 +104,8 @@ Equivalently it's True if
a) RebindableSyntax is on
b) the witness for fromInteger/fromRational/fromString
that happens to be in scope isn't the standard one
-
-Note [Overloaded literal witnesses]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-*Before* type checking, the HsExpr in an HsOverLit is the
-name of the coercion function, 'fromInteger' or 'fromRational'.
-*After* type checking, it is a witness for the literal, such as
- (fromInteger 3) or lit_78
-This witness should replace the literal.
-
-This dual role is unusual, because we're replacing 'fromInteger' with
-a call to fromInteger. Reason: it allows commoning up of the fromInteger
-calls, which wouldn't be possible if the desugarer made the application.
-
-The PostTcType in each branch records the type the overload literal is
-found to have.
-}
--- Comparison operations are needed when grouping literals
--- for compiling pattern-matching (module GHC.HsToCore.Match.Literal)
-instance (Eq (XXOverLit p)) => Eq (HsOverLit p) where
- (OverLit _ val1 _) == (OverLit _ val2 _) = val1 == val2
- (XOverLit val1) == (XOverLit val2) = val1 == val2
- _ == _ = panic "Eq HsOverLit"
-
-instance Eq OverLitVal where
- (HsIntegral i1) == (HsIntegral i2) = i1 == i2
- (HsFractional f1) == (HsFractional f2) = f1 == f2
- (HsIsString _ s1) == (HsIsString _ s2) = s1 == s2
- _ == _ = False
-
-instance (Ord (XXOverLit p)) => Ord (HsOverLit p) where
- compare (OverLit _ val1 _) (OverLit _ val2 _) = val1 `compare` val2
- compare (XOverLit val1) (XOverLit val2) = val1 `compare` val2
- compare _ _ = panic "Ord HsOverLit"
-
-instance Ord OverLitVal where
- compare (HsIntegral i1) (HsIntegral i2) = i1 `compare` i2
- compare (HsIntegral _) (HsFractional _) = LT
- compare (HsIntegral _) (HsIsString _ _) = LT
- compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2
- compare (HsFractional _) (HsIntegral _) = GT
- compare (HsFractional _) (HsIsString _ _) = LT
- compare (HsIsString _ s1) (HsIsString _ s2) = s1 `uniqCompareFS` s2
- compare (HsIsString _ _) (HsIntegral _) = GT
- compare (HsIsString _ _) (HsFractional _) = GT
-
-- Instance specific to GhcPs, need the SourceText
instance Outputable (HsLit (GhcPass p)) where
ppr (HsChar st c) = pprWithSourceText st (pprHsChar c)
@@ -251,11 +133,6 @@ instance OutputableBndrId p
ppr (OverLit {ol_val=val, ol_witness=witness})
= ppr val <+> (whenPprDebug (parens (pprExpr witness)))
-instance Outputable OverLitVal where
- ppr (HsIntegral i) = pprWithSourceText (il_text i) (integer (il_value i))
- ppr (HsFractional f) = ppr f
- ppr (HsIsString st s) = pprWithSourceText st (pprHsString s)
-
-- | pmPprHsLit pretty prints literals and is used when pretty printing pattern
-- match warnings. All are printed the same (i.e., without hashes if they are
-- primitive and not wrapped in constructors if they are boxed). This happens
@@ -276,34 +153,3 @@ pmPprHsLit (HsInteger _ i _) = integer i
pmPprHsLit (HsRat _ f _) = ppr f
pmPprHsLit (HsFloatPrim _ f) = ppr f
pmPprHsLit (HsDoublePrim _ d) = ppr d
-
--- | @'hsLitNeedsParens' p l@ returns 'True' if a literal @l@ needs
--- to be parenthesized under precedence @p@.
-hsLitNeedsParens :: PprPrec -> HsLit x -> Bool
-hsLitNeedsParens p = go
- where
- go (HsChar {}) = False
- go (HsCharPrim {}) = False
- go (HsString {}) = False
- go (HsStringPrim {}) = False
- go (HsInt _ x) = p > topPrec && il_neg x
- go (HsIntPrim _ x) = p > topPrec && x < 0
- go (HsWordPrim {}) = False
- go (HsInt64Prim _ x) = p > topPrec && x < 0
- go (HsWord64Prim {}) = False
- go (HsInteger _ x _) = p > topPrec && x < 0
- go (HsRat _ x _) = p > topPrec && fl_neg x
- go (HsFloatPrim _ x) = p > topPrec && fl_neg x
- go (HsDoublePrim _ x) = p > topPrec && fl_neg x
- go (XLit _) = False
-
--- | @'hsOverLitNeedsParens' p ol@ returns 'True' if an overloaded literal
--- @ol@ needs to be parenthesized under precedence @p@.
-hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool
-hsOverLitNeedsParens p (OverLit { ol_val = olv }) = go olv
- where
- go :: OverLitVal -> Bool
- go (HsIntegral x) = p > topPrec && il_neg x
- go (HsFractional x) = p > topPrec && fl_neg x
- go (HsIsString {}) = False
-hsOverLitNeedsParens _ (XOverLit { }) = False
diff --git a/compiler/GHC/Hs/Pat.hs b/compiler/GHC/Hs/Pat.hs
index cf23cb4a1c..7f9cecda1b 100644
--- a/compiler/GHC/Hs/Pat.hs
+++ b/compiler/GHC/Hs/Pat.hs
@@ -10,8 +10,11 @@
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
+ -- in module Language.Haskell.Syntax.Extension
{-# LANGUAGE ViewPatterns #-}
+
+{-# OPTIONS_GHC -Wno-orphans #-} -- Outputable
+
{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
@@ -48,11 +51,15 @@ module GHC.Hs.Pat (
import GHC.Prelude
-import {-# SOURCE #-} GHC.Hs.Expr (SyntaxExpr, LHsExpr, HsSplice, pprLExpr, pprSplice)
+import Language.Haskell.Syntax.Pat
+import Language.Haskell.Syntax.Expr (SyntaxExpr)
+
+import {-# SOURCE #-} GHC.Hs.Expr (pprLExpr, pprSplice)
-- friends:
import GHC.Hs.Binds
import GHC.Hs.Lit
+import Language.Haskell.Syntax.Extension
import GHC.Hs.Extension
import GHC.Hs.Type
import GHC.Tc.Types.Evidence
@@ -72,182 +79,7 @@ import GHC.Types.SrcLoc
import GHC.Data.Bag -- collect ev vars from pats
import GHC.Data.Maybe
import GHC.Types.Name (Name)
--- libraries:
-import Data.Data hiding (TyCon,Fixity)
-
-type LPat p = XRec p (Pat p)
-
--- | Pattern
---
--- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnBang'
-
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-data Pat p
- = ------------ Simple patterns ---------------
- WildPat (XWildPat p) -- ^ Wildcard Pattern
- -- The sole reason for a type on a WildPat is to
- -- support hsPatType :: Pat Id -> Type
-
- -- AZ:TODO above comment needs to be updated
- | VarPat (XVarPat p)
- (LIdP p) -- ^ Variable Pattern
-
- -- See Note [Located RdrNames] in GHC.Hs.Expr
- | LazyPat (XLazyPat p)
- (LPat p) -- ^ Lazy Pattern
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnTilde'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | AsPat (XAsPat p)
- (LIdP p) (LPat p) -- ^ As pattern
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnAt'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | ParPat (XParPat p)
- (LPat p) -- ^ Parenthesised pattern
- -- See Note [Parens in HsSyn] in GHC.Hs.Expr
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'('@,
- -- 'GHC.Parser.Annotation.AnnClose' @')'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | BangPat (XBangPat p)
- (LPat p) -- ^ Bang pattern
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnBang'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- ------------ Lists, tuples, arrays ---------------
- | ListPat (XListPat p)
- [LPat p]
- -- For OverloadedLists a Just (ty,fn) gives
- -- overall type of the pattern, and the toList
--- function to convert the scrutinee to a list value
-
- -- ^ Syntactic List
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'['@,
- -- 'GHC.Parser.Annotation.AnnClose' @']'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | TuplePat (XTuplePat p)
- -- after typechecking, holds the types of the tuple components
- [LPat p] -- Tuple sub-patterns
- Boxity -- UnitPat is TuplePat []
- -- You might think that the post typechecking Type was redundant,
- -- because we can get the pattern type by getting the types of the
- -- sub-patterns.
- -- But it's essential
- -- data T a where
- -- T1 :: Int -> T Int
- -- f :: (T a, a) -> Int
- -- f (T1 x, z) = z
- -- When desugaring, we must generate
- -- f = /\a. \v::a. case v of (t::T a, w::a) ->
- -- case t of (T1 (x::Int)) ->
- -- Note the (w::a), NOT (w::Int), because we have not yet
- -- refined 'a' to Int. So we must know that the second component
- -- of the tuple is of type 'a' not Int. See selectMatchVar
- -- (June 14: I'm not sure this comment is right; the sub-patterns
- -- will be wrapped in CoPats, no?)
- -- ^ Tuple sub-patterns
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' :
- -- 'GHC.Parser.Annotation.AnnOpen' @'('@ or @'(#'@,
- -- 'GHC.Parser.Annotation.AnnClose' @')'@ or @'#)'@
-
- | SumPat (XSumPat p) -- after typechecker, types of the alternative
- (LPat p) -- Sum sub-pattern
- ConTag -- Alternative (one-based)
- Arity -- Arity (INVARIANT: ≥ 2)
- -- ^ Anonymous sum pattern
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' :
- -- 'GHC.Parser.Annotation.AnnOpen' @'(#'@,
- -- 'GHC.Parser.Annotation.AnnClose' @'#)'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- ------------ Constructor patterns ---------------
- | ConPat {
- pat_con_ext :: XConPat p,
- pat_con :: XRec p (ConLikeP p),
- pat_args :: HsConPatDetails p
- }
- -- ^ Constructor Pattern
-
- ------------ View patterns ---------------
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnRarrow'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | ViewPat (XViewPat p) -- The overall type of the pattern
- -- (= the argument type of the view function)
- -- for hsPatType.
- (LHsExpr p)
- (LPat p)
- -- ^ View Pattern
-
- ------------ Pattern splices ---------------
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'$('@
- -- 'GHC.Parser.Annotation.AnnClose' @')'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | SplicePat (XSplicePat p)
- (HsSplice p) -- ^ Splice Pattern (Includes quasi-quotes)
-
- ------------ Literal and n+k patterns ---------------
- | LitPat (XLitPat p)
- (HsLit p) -- ^ Literal Pattern
- -- Used for *non-overloaded* literal patterns:
- -- Int#, Char#, Int, Char, String, etc.
-
- | NPat -- Natural Pattern
- -- Used for all overloaded literals,
- -- including overloaded strings with -XOverloadedStrings
- (XNPat p) -- Overall type of pattern. Might be
- -- different than the literal's type
- -- if (==) or negate changes the type
- (XRec p (HsOverLit p)) -- ALWAYS positive
- (Maybe (SyntaxExpr p)) -- Just (Name of 'negate') for
- -- negative patterns, Nothing
- -- otherwise
- (SyntaxExpr p) -- Equality checker, of type t->t->Bool
-
- -- ^ Natural Pattern
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnVal' @'+'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | NPlusKPat (XNPlusKPat p) -- Type of overall pattern
- (LIdP p) -- n+k pattern
- (XRec p (HsOverLit p)) -- It'll always be an HsIntegral
- (HsOverLit p) -- See Note [NPlusK patterns] in GHC.Tc.Gen.Pat
- -- NB: This could be (PostTc ...), but that induced a
- -- a new hs-boot file. Not worth it.
-
- (SyntaxExpr p) -- (>=) function, of type t1->t2->Bool
- (SyntaxExpr p) -- Name of '-' (see GHC.Rename.Env.lookupSyntax)
- -- ^ n+k pattern
-
- ------------ Pattern type signatures ---------------
- -- | - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDcolon'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | SigPat (XSigPat p) -- After typechecker: Type
- (LPat p) -- Pattern with a type signature
- (HsPatSigType (NoGhcTc p)) -- Signature can bind both
- -- kind and type vars
-
- -- ^ Pattern with a type signature
-
- -- | Trees that Grow extension point for new constructors
- | XPat
- !(XXPat p)
-
--- ---------------------------------------------------------------------
data ListPatTc
= ListPatTc
@@ -307,23 +139,12 @@ type instance XXPat GhcRn = NoExtCon
type instance XXPat GhcTc = CoPat
-- After typechecking, we add one extra constructor: CoPat
-type family ConLikeP x
-
type instance ConLikeP GhcPs = RdrName -- IdP GhcPs
type instance ConLikeP GhcRn = Name -- IdP GhcRn
type instance ConLikeP GhcTc = ConLike
-- ---------------------------------------------------------------------
-
--- | Haskell Constructor Pattern Details
-type HsConPatDetails p = HsConDetails (HsPatSigType (NoGhcTc p)) (LPat p) (HsRecFields p (LPat p))
-
-hsConPatArgs :: HsConPatDetails p -> [LPat p]
-hsConPatArgs (PrefixCon _ ps) = ps
-hsConPatArgs (RecCon fs) = map (hsRecFieldArg . unLoc) (rec_flds fs)
-hsConPatArgs (InfixCon p1 p2) = [p1,p2]
-
-- | This is the extension field for ConPat, added after typechecking
-- It adds quite a few extra fields, to support elaboration of pattern matching.
data ConPatTc
@@ -370,123 +191,6 @@ data CoPat
co_pat_ty :: Type
}
--- | Haskell Record Fields
---
--- HsRecFields is used only for patterns and expressions (not data type
--- declarations)
-data HsRecFields p arg -- A bunch of record fields
- -- { x = 3, y = True }
- -- Used for both expressions and patterns
- = HsRecFields { rec_flds :: [LHsRecField p arg],
- rec_dotdot :: Maybe (Located Int) } -- Note [DotDot fields]
- deriving (Functor, Foldable, Traversable)
-
-
--- Note [DotDot fields]
--- ~~~~~~~~~~~~~~~~~~~~
--- The rec_dotdot field means this:
--- Nothing => the normal case
--- Just n => the group uses ".." notation,
---
--- In the latter case:
---
--- *before* renamer: rec_flds are exactly the n user-written fields
---
--- *after* renamer: rec_flds includes *all* fields, with
--- the first 'n' being the user-written ones
--- and the remainder being 'filled in' implicitly
-
--- | Located Haskell Record Field
-type LHsRecField' p arg = Located (HsRecField' p arg)
-
--- | Located Haskell Record Field
-type LHsRecField p arg = Located (HsRecField p arg)
-
--- | Located Haskell Record Update Field
-type LHsRecUpdField p = Located (HsRecUpdField p)
-
--- | Haskell Record Field
-type HsRecField p arg = HsRecField' (FieldOcc p) arg
-
--- | Haskell Record Update Field
-type HsRecUpdField p = HsRecField' (AmbiguousFieldOcc p) (LHsExpr p)
-
--- | Haskell Record Field
---
--- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnEqual',
---
--- For details on above see note [Api annotations] in GHC.Parser.Annotation
-data HsRecField' id arg = HsRecField {
- hsRecFieldLbl :: Located id,
- hsRecFieldArg :: arg, -- ^ Filled in by renamer when punning
- hsRecPun :: Bool -- ^ Note [Punning]
- } deriving (Data, Functor, Foldable, Traversable)
-
-
--- Note [Punning]
--- ~~~~~~~~~~~~~~
--- If you write T { x, y = v+1 }, the HsRecFields will be
--- HsRecField x x True ...
--- HsRecField y (v+1) False ...
--- That is, for "punned" field x is expanded (in the renamer)
--- to x=x; but with a punning flag so we can detect it later
--- (e.g. when pretty printing)
---
--- If the original field was qualified, we un-qualify it, thus
--- T { A.x } means T { A.x = x }
-
-
--- Note [HsRecField and HsRecUpdField]
--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
--- A HsRecField (used for record construction and pattern matching)
--- contains an unambiguous occurrence of a field (i.e. a FieldOcc).
--- We can't just store the Name, because thanks to
--- DuplicateRecordFields this may not correspond to the label the user
--- wrote.
---
--- A HsRecUpdField (used for record update) contains a potentially
--- ambiguous occurrence of a field (an AmbiguousFieldOcc). The
--- renamer will fill in the selector function if it can, but if the
--- selector is ambiguous the renamer will defer to the typechecker.
--- After the typechecker, a unique selector will have been determined.
---
--- The renamer produces an Unambiguous result if it can, rather than
--- just doing the lookup in the typechecker, so that completely
--- unambiguous updates can be represented by 'GHC.HsToCore.Quote.repUpdFields'.
---
--- For example, suppose we have:
---
--- data S = MkS { x :: Int }
--- data T = MkT { x :: Int }
---
--- f z = (z { x = 3 }) :: S
---
--- The parsed HsRecUpdField corresponding to the record update will have:
---
--- hsRecFieldLbl = Unambiguous "x" noExtField :: AmbiguousFieldOcc RdrName
---
--- After the renamer, this will become:
---
--- hsRecFieldLbl = Ambiguous "x" noExtField :: AmbiguousFieldOcc Name
---
--- (note that the Unambiguous constructor is not type-correct here).
--- The typechecker will determine the particular selector:
---
--- hsRecFieldLbl = Unambiguous "x" $sel:x:MkS :: AmbiguousFieldOcc Id
---
--- See also Note [Disambiguating record fields] in GHC.Tc.Gen.Head.
-
-hsRecFields :: HsRecFields p arg -> [XCFieldOcc p]
-hsRecFields rbinds = map (unLoc . hsRecFieldSel . unLoc) (rec_flds rbinds)
-
--- Probably won't typecheck at once, things have changed :/
-hsRecFieldsArgs :: HsRecFields p arg -> [arg]
-hsRecFieldsArgs rbinds = map (hsRecFieldArg . unLoc) (rec_flds rbinds)
-
-hsRecFieldSel :: HsRecField pass arg -> Located (XCFieldOcc pass)
-hsRecFieldSel = fmap extFieldOcc . hsRecFieldLbl
-
hsRecFieldId :: HsRecField GhcTc arg -> Located Id
hsRecFieldId = hsRecFieldSel
@@ -623,22 +327,6 @@ pprConArgs (InfixCon p1 p2) = sep [ pprParendLPat appPrec p1
, pprParendLPat appPrec p2 ]
pprConArgs (RecCon rpats) = ppr rpats
-instance (Outputable arg)
- => Outputable (HsRecFields p arg) where
- ppr (HsRecFields { rec_flds = flds, rec_dotdot = Nothing })
- = braces (fsep (punctuate comma (map ppr flds)))
- ppr (HsRecFields { rec_flds = flds, rec_dotdot = Just (unLoc -> n) })
- = braces (fsep (punctuate comma (map ppr (take n flds) ++ [dotdot])))
- where
- dotdot = text ".." <+> whenPprDebug (ppr (drop n flds))
-
-instance (Outputable p, Outputable arg)
- => Outputable (HsRecField' p arg) where
- ppr (HsRecField { hsRecFieldLbl = f, hsRecFieldArg = arg,
- hsRecPun = pun })
- = ppr f <+> (ppUnless pun $ equals <+> ppr arg)
-
-
{-
************************************************************************
* *
diff --git a/compiler/GHC/Hs/Pat.hs-boot b/compiler/GHC/Hs/Pat.hs-boot
index e0849375b9..be8bcdf72f 100644
--- a/compiler/GHC/Hs/Pat.hs-boot
+++ b/compiler/GHC/Hs/Pat.hs-boot
@@ -1,20 +1,15 @@
-{-# LANGUAGE CPP, KindSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
-{-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE RoleAnnotations #-}
-{-# LANGUAGE TypeFamilies #-}
+ -- in module Language.Haskell.Syntax.Extension
+
+{-# OPTIONS_GHC -Wno-orphans #-} -- Outputable
module GHC.Hs.Pat where
import GHC.Utils.Outputable
-import GHC.Hs.Extension ( OutputableBndrId, GhcPass, XRec )
-import Data.Kind
+import GHC.Hs.Extension ( OutputableBndrId, GhcPass )
-type role Pat nominal
-data Pat (i :: Type)
-type LPat i = XRec i (Pat i)
+import Language.Haskell.Syntax.Pat
instance OutputableBndrId p => Outputable (Pat (GhcPass p))
diff --git a/compiler/GHC/Hs/Type.hs b/compiler/GHC/Hs/Type.hs
index eafe4daa70..d5560411e4 100644
--- a/compiler/GHC/Hs/Type.hs
+++ b/compiler/GHC/Hs/Type.hs
@@ -9,7 +9,10 @@
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
- -- in module GHC.Hs.Extension
+ -- in module Language.Haskell.Syntax.Extension
+
+{-# OPTIONS_GHC -Wno-orphans #-} -- NamedThing, Outputable, OutputableBndrId
+
{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
@@ -87,8 +90,11 @@ module GHC.Hs.Type (
import GHC.Prelude
-import {-# SOURCE #-} GHC.Hs.Expr ( HsSplice, pprSplice )
+import Language.Haskell.Syntax.Type
+import {-# SOURCE #-} GHC.Hs.Expr ( pprSplice )
+
+import Language.Haskell.Syntax.Extension
import GHC.Hs.Extension
import GHC.Types.Id ( Id )
@@ -96,8 +102,6 @@ import GHC.Types.SourceText
import GHC.Types.Name( Name, NamedThing(getName) )
import GHC.Types.Name.Reader ( RdrName )
import GHC.Types.Var ( VarBndr )
-import GHC.Core.DataCon( HsSrcBang(..), HsImplBang(..),
- SrcStrictness(..), SrcUnpackedness(..) )
import GHC.Core.TyCo.Rep ( Type(..) )
import GHC.Builtin.Types( manyDataConName, oneDataConName, mkTupleStr )
import GHC.Core.Type
@@ -105,13 +109,9 @@ import GHC.Hs.Doc
import GHC.Types.Basic
import GHC.Types.SrcLoc
import GHC.Utils.Outputable
-import GHC.Data.FastString
-import GHC.Utils.Misc ( count )
import GHC.Parser.Annotation
-import Data.Data hiding ( Fixity, Prefix, Infix )
import Data.Maybe
-import Data.Void
{-
************************************************************************
@@ -121,17 +121,6 @@ import Data.Void
************************************************************************
-}
--- | Located Bang Type
-type LBangType pass = XRec pass (BangType pass)
-
--- | Bang Type
---
--- In the parser, strictness and packedness annotations bind more tightly
--- than docstrings. This means that when consuming a 'BangType' (and looking
--- for 'HsBangTy') we must be ready to peer behind a potential layer of
--- 'HsDocTy'. See #15206 for motivation and 'getBangType' for an example.
-type BangType pass = HsType pass -- Bangs are in the HsType data type
-
getBangType :: LHsType (GhcPass p) -> LHsType (GhcPass p)
getBangType (L _ (HsBangTy _ _ lty)) = lty
getBangType (L _ (HsDocTy x (L _ (HsBangTy _ _ lty)) lds)) =
@@ -149,181 +138,8 @@ getBangStrictness _ = (HsSrcBang NoSourceText NoSrcUnpack NoSrcStrict)
\subsection{Data types}
* *
************************************************************************
-
-This is the syntax for types as seen in type signatures.
-
-Note [HsBSig binder lists]
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider a binder (or pattern) decorated with a type or kind,
- \ (x :: a -> a). blah
- forall (a :: k -> *) (b :: k). blah
-Then we use a LHsBndrSig on the binder, so that the
-renamer can decorate it with the variables bound
-by the pattern ('a' in the first example, 'k' in the second),
-assuming that neither of them is in scope already
-See also Note [Kind and type-variable binders] in GHC.Rename.HsType
-
-Note [HsType binders]
-~~~~~~~~~~~~~~~~~~~~~
-The system for recording type and kind-variable binders in HsTypes
-is a bit complicated. Here's how it works.
-
-* In a HsType,
- HsForAllTy represents an /explicit, user-written/ 'forall' that
- is nested within another HsType
- e.g. forall a b. {...} or
- forall a b -> {...}
-
- Note that top-level 'forall's are represented with a
- different AST form. See the description of HsOuterTyVarBndrs
- below.
- HsQualTy represents an /explicit, user-written/ context
- e.g. (Eq a, Show a) => ...
- The context can be empty if that's what the user wrote
- These constructors represent what the user wrote, no more
- and no less.
-
-* The ForAllTelescope field of HsForAllTy represents whether a forall is
- invisible (e.g., forall a b. {...}, with a dot) or visible
- (e.g., forall a b -> {...}, with an arrow).
-
-* HsTyVarBndr describes a quantified type variable written by the
- user. For example
- f :: forall a (b :: *). blah
- here 'a' and '(b::*)' are each a HsTyVarBndr. A HsForAllTy has
- a list of LHsTyVarBndrs.
-
-* HsOuterTyVarBndrs is used to represent the outermost quantified type
- variables in a type that obeys the forall-or-nothing rule. An
- HsOuterTyVarBndrs can be one of the following:
-
- HsOuterImplicit (implicit quantification, added by renamer)
- f :: a -> a -- Desugars to f :: forall {a}. a -> a
- HsOuterExplicit (explicit user quantifiation):
- f :: forall a. a -> a
-
- See Note [forall-or-nothing rule].
-
-* An HsSigType is an LHsType with an accompanying HsOuterTyVarBndrs that
- represents the presence (or absence) of its outermost 'forall'.
- See Note [Representing type signatures].
-
-* HsWildCardBndrs is a wrapper that binds the wildcard variables
- of the wrapped thing. It is filled in by the renamer
- f :: _a -> _
- The enclosing HsWildCardBndrs binds the wildcards _a and _.
-
-* HsSigPatType describes types that appear in pattern signatures and
- the signatures of term-level binders in RULES. Like
- HsWildCardBndrs/HsOuterTyVarBndrs, they track the names of wildcard
- variables and implicitly bound type variables. Unlike
- HsOuterTyVarBndrs, however, HsSigPatTypes do not obey the
- forall-or-nothing rule. See Note [Pattern signature binders and scoping].
-
-* The explicit presence of these wrappers specifies, in the HsSyn,
- exactly where implicit quantification is allowed, and where
- wildcards are allowed.
-
-* LHsQTyVars is used in data/class declarations, where the user gives
- explicit *type* variable bindings, but we need to implicitly bind
- *kind* variables. For example
- class C (a :: k -> *) where ...
- The 'k' is implicitly bound in the hsq_tvs field of LHsQTyVars
-
-Note [The wildcard story for types]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Types can have wildcards in them, to support partial type signatures,
-like f :: Int -> (_ , _a) -> _a
-
-A wildcard in a type can be
-
- * An anonymous wildcard,
- written '_'
- In HsType this is represented by HsWildCardTy.
- The renamer leaves it untouched, and it is later given a fresh
- meta tyvar in the typechecker.
-
- * A named wildcard,
- written '_a', '_foo', etc
- In HsType this is represented by (HsTyVar "_a")
- i.e. a perfectly ordinary type variable that happens
- to start with an underscore
-
-Note carefully:
-
-* When NamedWildCards is off, type variables that start with an
- underscore really /are/ ordinary type variables. And indeed, even
- when NamedWildCards is on you can bind _a explicitly as an ordinary
- type variable:
- data T _a _b = MkT _b _a
- Or even:
- f :: forall _a. _a -> _b
- Here _a is an ordinary forall'd binder, but (With NamedWildCards)
- _b is a named wildcard. (See the comments in #10982)
-
-* Named wildcards are bound by the HsWildCardBndrs (for types that obey the
- forall-or-nothing rule) and HsPatSigType (for type signatures in patterns
- and term-level binders in RULES), which wrap types that are allowed to have
- wildcards. Unnamed wildcards, however are left unchanged until typechecking,
- where we give them fresh wild tyvars and determine whether or not to emit
- hole constraints on each wildcard (we don't if it's a visible type/kind
- argument or a type family pattern). See related notes
- Note [Wildcards in visible kind application] and
- Note [Wildcards in visible type application] in GHC.Tc.Gen.HsType.
-
-* After type checking is done, we report what types the wildcards
- got unified with.
-
-Note [Ordering of implicit variables]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Since the advent of -XTypeApplications, GHC makes promises about the ordering
-of implicit variable quantification. Specifically, we offer that implicitly
-quantified variables (such as those in const :: a -> b -> a, without a `forall`)
-will occur in left-to-right order of first occurrence. Here are a few examples:
-
- const :: a -> b -> a -- forall a b. ...
- f :: Eq a => b -> a -> a -- forall a b. ... contexts are included
-
- type a <-< b = b -> a
- g :: a <-< b -- forall a b. ... type synonyms matter
-
- class Functor f where
- fmap :: (a -> b) -> f a -> f b -- forall f a b. ...
- -- The f is quantified by the class, so only a and b are considered in fmap
-
-This simple story is complicated by the possibility of dependency: all variables
-must come after any variables mentioned in their kinds.
-
- typeRep :: Typeable a => TypeRep (a :: k) -- forall k a. ...
-
-The k comes first because a depends on k, even though the k appears later than
-the a in the code. Thus, GHC does a *stable topological sort* on the variables.
-By "stable", we mean that any two variables who do not depend on each other
-preserve their existing left-to-right ordering.
-
-Implicitly bound variables are collected by the extract- family of functions
-(extractHsTysRdrTyVars, extractHsTyVarBndrsKVs, etc.) in GHC.Rename.HsType.
-These functions thus promise to keep left-to-right ordering.
-Look for pointers to this note to see the places where the action happens.
-
-Note that we also maintain this ordering in kind signatures. Even though
-there's no visible kind application (yet), having implicit variables be
-quantified in left-to-right order in kind signatures is nice since:
-
-* It's consistent with the treatment for type signatures.
-* It can affect how types are displayed with -fprint-explicit-kinds (see
- #15568 for an example), which is a situation where knowing the order in
- which implicit variables are quantified can be useful.
-* In the event that visible kind application is implemented, the order in
- which we would expect implicit variables to be ordered in kinds will have
- already been established.
-}
--- | Located Haskell Context
-type LHsContext pass = XRec pass (HsContext pass)
- -- ^ 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnUnit'
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
noLHsContext :: LHsContext (GhcPass p)
-- Use this when there is no context in the original program
-- It would really be more kosher to use a Maybe, to distinguish
@@ -332,64 +148,11 @@ noLHsContext :: LHsContext (GhcPass p)
-- class C a where ...
noLHsContext = noLoc []
--- | Haskell Context
-type HsContext pass = [LHsType pass]
-
--- | Located Haskell Type
-type LHsType pass = XRec pass (HsType pass)
- -- ^ May have 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnComma' when
- -- in a list
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- | Haskell Kind
-type HsKind pass = HsType pass
-
--- | Located Haskell Kind
-type LHsKind pass = XRec pass (HsKind pass)
- -- ^ 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDcolon'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
---------------------------------------------------
--- LHsQTyVars
--- The explicitly-quantified binders in a data/type declaration
-
--- | The type variable binders in an 'HsForAllTy'.
--- See also @Note [Variable Specificity and Forall Visibility]@ in
--- "GHC.Tc.Gen.HsType".
-data HsForAllTelescope pass
- = HsForAllVis -- ^ A visible @forall@ (e.g., @forall a -> {...}@).
- -- These do not have any notion of specificity, so we use
- -- '()' as a placeholder value.
- { hsf_xvis :: XHsForAllVis pass
- , hsf_vis_bndrs :: [LHsTyVarBndr () pass]
- }
- | HsForAllInvis -- ^ An invisible @forall@ (e.g., @forall a {b} c. {...}@),
- -- where each binder has a 'Specificity'.
- { hsf_xinvis :: XHsForAllInvis pass
- , hsf_invis_bndrs :: [LHsTyVarBndr Specificity pass]
- }
- | XHsForAllTelescope !(XXHsForAllTelescope pass)
-
type instance XHsForAllVis (GhcPass _) = NoExtField
type instance XHsForAllInvis (GhcPass _) = NoExtField
type instance XXHsForAllTelescope (GhcPass _) = NoExtCon
--- | Located Haskell Type Variable Binder
-type LHsTyVarBndr flag pass = XRec pass (HsTyVarBndr flag pass)
- -- See Note [HsType binders]
-
--- | Located Haskell Quantified Type Variables
-data LHsQTyVars pass -- See Note [HsType binders]
- = HsQTvs { hsq_ext :: XHsQTvs pass
-
- , hsq_explicit :: [LHsTyVarBndr () pass]
- -- Explicit variables, written by the user
- }
- | XLHsQTyVars !(XXLHsQTyVars pass)
-
type HsQTvsRn = [Name] -- Implicit variables
-- For example, in data T (a :: k1 -> k2) = ...
-- the 'a' is explicit while 'k1', 'k2' are implicit
@@ -413,68 +176,11 @@ mkHsForAllInvisTele invis_bndrs =
mkHsQTvs :: [LHsTyVarBndr () GhcPs] -> LHsQTyVars GhcPs
mkHsQTvs tvs = HsQTvs { hsq_ext = noExtField, hsq_explicit = tvs }
-hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr () pass]
-hsQTvExplicit = hsq_explicit
-
emptyLHsQTvs :: LHsQTyVars GhcRn
emptyLHsQTvs = HsQTvs { hsq_ext = [], hsq_explicit = [] }
------------------------------------------------
-- HsOuterTyVarBndrs
--- Used to quantify the outermost type variable binders of a type that obeys
--- the forall-or-nothing rule. These are used to represent the outermost
--- quantification in:
--- * Type signatures (LHsSigType/LHsSigWcType)
--- * Patterns in a type/data family instance (HsTyPats)
---
--- We support two forms:
--- HsOuterImplicit (implicit quantification, added by renamer)
--- f :: a -> a -- Desugars to f :: forall {a}. a -> a
--- type instance F (a,b) = a->b
--- HsOuterExplicit (explicit user quantifiation):
--- f :: forall a. a -> a
--- type instance forall a b. F (a,b) = a->b
---
--- In constrast, when the user writes /visible/ quanitification
--- T :: forall k -> k -> Type
--- we use use HsOuterImplicit, wrapped around a HsForAllTy
--- for the visible quantification
---
--- See Note [forall-or-nothing rule]
-
--- | The outermost type variables in a type that obeys the @forall@-or-nothing
--- rule. See @Note [forall-or-nothing rule]@.
-data HsOuterTyVarBndrs flag pass
- = HsOuterImplicit -- ^ Implicit forall, e.g.,
- -- @f :: a -> b -> b@
- { hso_ximplicit :: XHsOuterImplicit pass
- }
- | HsOuterExplicit -- ^ Explicit forall, e.g.,
- -- @f :: forall a b. a -> b -> b@
- { hso_xexplicit :: XHsOuterExplicit pass flag
- , hso_bndrs :: [LHsTyVarBndr flag (NoGhcTc pass)]
- }
- | XHsOuterTyVarBndrs !(XXHsOuterTyVarBndrs pass)
-
--- | Used for signatures, e.g.,
---
--- @
--- f :: forall a {b}. blah
--- @
---
--- We use 'Specificity' for the 'HsOuterTyVarBndrs' @flag@ to allow
--- distinguishing between specified and inferred type variables.
-type HsOuterSigTyVarBndrs = HsOuterTyVarBndrs Specificity
-
--- | Used for type-family instance equations, e.g.,
---
--- @
--- type instance forall a. F [a] = Tree a
--- @
---
--- The notion of specificity is irrelevant in type family equations, so we use
--- @()@ for the 'HsOuterTyVarBndrs' @flag@.
-type HsOuterFamEqnTyVarBndrs = HsOuterTyVarBndrs ()
type instance XHsOuterImplicit GhcPs = NoExtField
type instance XHsOuterImplicit GhcRn = [Name]
@@ -486,297 +192,28 @@ type instance XHsOuterExplicit GhcTc flag = [VarBndr TyVar flag]
type instance XXHsOuterTyVarBndrs (GhcPass _) = NoExtCon
--- | Haskell Wildcard Binders
-data HsWildCardBndrs pass thing
- -- See Note [HsType binders]
- -- See Note [The wildcard story for types]
- = HsWC { hswc_ext :: XHsWC pass thing
- -- after the renamer
- -- Wild cards, only named
- -- See Note [Wildcards in visible kind application]
-
- , hswc_body :: thing
- -- Main payload (type or list of types)
- -- If there is an extra-constraints wildcard,
- -- it's still there in the hsc_body.
- }
- | XHsWildCardBndrs !(XXHsWildCardBndrs pass thing)
-
type instance XHsWC GhcPs b = NoExtField
type instance XHsWC GhcRn b = [Name]
type instance XHsWC GhcTc b = [Name]
type instance XXHsWildCardBndrs (GhcPass _) _ = NoExtCon
--- | Types that can appear in pattern signatures, as well as the signatures for
--- term-level binders in RULES.
--- See @Note [Pattern signature binders and scoping]@.
---
--- This is very similar to 'HsSigWcType', but with
--- slightly different semantics: see @Note [HsType binders]@.
--- See also @Note [The wildcard story for types]@.
-data HsPatSigType pass
- = HsPS { hsps_ext :: XHsPS pass -- ^ After renamer: 'HsPSRn'
- , hsps_body :: LHsType pass -- ^ Main payload (the type itself)
- }
- | XHsPatSigType !(XXHsPatSigType pass)
-
--- | The extension field for 'HsPatSigType', which is only used in the
--- renamer onwards. See @Note [Pattern signature binders and scoping]@.
-data HsPSRn = HsPSRn
- { hsps_nwcs :: [Name] -- ^ Wildcard names
- , hsps_imp_tvs :: [Name] -- ^ Implicitly bound variable names
- }
- deriving Data
-
type instance XHsPS GhcPs = NoExtField
type instance XHsPS GhcRn = HsPSRn
type instance XHsPS GhcTc = HsPSRn
type instance XXHsPatSigType (GhcPass _) = NoExtCon
--- | Located Haskell Signature Type
-type LHsSigType pass = Located (HsSigType pass) -- Implicit only
-
--- | Located Haskell Wildcard Type
-type LHsWcType pass = HsWildCardBndrs pass (LHsType pass) -- Wildcard only
-
--- | Located Haskell Signature Wildcard Type
-type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass) -- Both
-
--- | A type signature that obeys the @forall@-or-nothing rule. In other
--- words, an 'LHsType' that uses an 'HsOuterSigTyVarBndrs' to represent its
--- outermost type variable quantification.
--- See @Note [Representing type signatures]@.
-data HsSigType pass
- = HsSig { sig_ext :: XHsSig pass
- , sig_bndrs :: HsOuterSigTyVarBndrs pass
- , sig_body :: LHsType pass
- }
- | XHsSigType !(XXHsSigType pass)
-
type instance XHsSig (GhcPass _) = NoExtField
type instance XXHsSigType (GhcPass _) = NoExtCon
hsSigWcType :: LHsSigWcType pass -> LHsType pass
hsSigWcType = sig_body . unLoc . hswc_body
-hsPatSigType :: HsPatSigType pass -> LHsType pass
-hsPatSigType = hsps_body
-
dropWildCards :: LHsSigWcType pass -> LHsSigType pass
-- Drop the wildcard part of a LHsSigWcType
dropWildCards sig_ty = hswc_body sig_ty
-{-
-Note [forall-or-nothing rule]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Free variables in signatures are usually bound in an implicit 'forall' at the
-beginning of user-written signatures. However, if the signature has an
-explicit, invisible forall at the beginning, this is disabled. This is referred
-to as the forall-or-nothing rule.
-
-The idea is nested foralls express something which is only expressible
-explicitly, while a top level forall could (usually) be replaced with an
-implicit binding. Top-level foralls alone ("forall.") are therefore an
-indication that the user is trying to be fastidious, so we don't implicitly
-bind any variables.
-
-Note that this rule only applies to outermost /in/visible 'forall's, and not
-outermost visible 'forall's. See #18660 for more on this point.
-
-Here are some concrete examples to demonstrate the forall-or-nothing rule in
-action:
-
- type F1 :: a -> b -> b -- Legal; a,b are implicitly quantified.
- -- Equivalently: forall a b. a -> b -> b
-
- type F2 :: forall a b. a -> b -> b -- Legal; explicitly quantified
-
- type F3 :: forall a. a -> b -> b -- Illegal; the forall-or-nothing rule says that
- -- if you quantify a, you must also quantify b
-
- type F4 :: forall a -> b -> b -- Legal; the top quantifier (forall a) is a /visible/
- -- quantifer, so the "nothing" part of the forall-or-nothing
- -- rule applies, and b is therefore implicitly quantified.
- -- Equivalently: forall b. forall a -> b -> b
-
- type F5 :: forall b. forall a -> b -> c -- Illegal; the forall-or-nothing rule says that
- -- if you quantify b, you must also quantify c
-
- type F6 :: forall a -> forall b. b -> c -- Legal: just like F4.
-
-For a complete list of all places where the forall-or-nothing rule applies, see
-"The `forall`-or-nothing rule" section of the GHC User's Guide.
-
-Any type that obeys the forall-or-nothing rule is represented in the AST with
-an HsOuterTyVarBndrs:
-
-* If the type has an outermost, invisible 'forall', it uses HsOuterExplicit,
- which contains a list of the explicitly quantified type variable binders in
- `hso_bndrs`. After typechecking, HsOuterExplicit also stores a list of the
- explicitly quantified `InvisTVBinder`s in
- `hso_xexplicit :: XHsOuterExplicit GhcTc`.
-
-* Otherwise, it uses HsOuterImplicit. HsOuterImplicit is used for different
- things depending on the phase:
-
- * After parsing, it does not store anything in particular.
- * After renaming, it stores the implicitly bound type variable `Name`s in
- `hso_ximplicit :: XHsOuterImplicit GhcRn`.
- * After typechecking, it stores the implicitly bound `TyVar`s in
- `hso_ximplicit :: XHsOuterImplicit GhcTc`.
-
- NB: this implicit quantification is purely lexical: we bind any
- type or kind variables that are not in scope. The type checker
- may subsequently quantify over further kind variables.
- See Note [Binding scoped type variables] in GHC.Tc.Gen.Sig.
-
-HsOuterTyVarBndrs GhcTc is used in the typechecker as an intermediate data type
-for storing the outermost TyVars/InvisTVBinders in a type.
-See GHC.Tc.Gen.HsType.bindOuterTKBndrsX for an example of this.
-
-Note [Representing type signatures]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-HsSigType is used to represent an explicit user type signature. These are
-used in a variety of places. Some examples include:
-
-* Type signatures (e.g., f :: a -> a)
-* Standalone kind signatures (e.g., type G :: a -> a)
-* GADT constructor types (e.g., data T where MkT :: a -> T)
-
-A HsSigType is the combination of an HsOuterSigTyVarBndrs and an LHsType:
-
-* The HsOuterSigTyVarBndrs binds the /explicitly/ quantified type variables
- when the type signature has an outermost, user-written 'forall' (i.e,
- the HsOuterExplicit constructor is used). If there is no outermost 'forall',
- then it binds the /implicitly/ quantified type variables instead (i.e.,
- the HsOuterImplicit constructor is used).
-* The LHsType represents the rest of the type.
-
-E.g. For a signature like
- f :: forall k (a::k). blah
-we get
- HsSig { sig_bndrs = HsOuterExplicit { hso_bndrs = [k, (a :: k)] }
- , sig_body = blah }
-
-Note [Pattern signature binders and scoping]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider the pattern signatures like those on `t` and `g` in:
-
- f = let h = \(t :: (b, b) ->
- \(g :: forall a. a -> b) ->
- ...(t :: (Int,Int))...
- in woggle
-
-* The `b` in t's pattern signature is implicitly bound and scopes over
- the signature and the body of the lambda. It stands for a type (any type);
- indeed we subsequently discover that b=Int.
- (See Note [TyVarTv] in GHC.Tc.Utils.TcMType for more on this point.)
-* The `b` in g's pattern signature is an /occurrence/ of the `b` bound by
- t's pattern signature.
-* The `a` in `forall a` scopes only over the type `a -> b`, not over the body
- of the lambda.
-* There is no forall-or-nothing rule for pattern signatures, which is why the
- type `forall a. a -> b` is permitted in `g`'s pattern signature, even though
- `b` is not explicitly bound. See Note [forall-or-nothing rule].
-
-Similar scoping rules apply to term variable binders in RULES, like in the
-following example:
-
- {-# RULES "h" forall (t :: (b, b)) (g :: forall a. a -> b). h t g = ... #-}
-
-Just like in pattern signatures, the `b` in t's signature is implicitly bound
-and scopes over the remainder of the RULE. As a result, the `b` in g's
-signature is an occurrence. Moreover, the `a` in `forall a` scopes only over
-the type `a -> b`, and the forall-or-nothing rule does not apply.
-
-While quite similar, RULE term binder signatures behave slightly differently
-from pattern signatures in two ways:
-
-1. Unlike in pattern signatures, where type variables can stand for any type,
- type variables in RULE term binder signatures are skolems.
- See Note [Typechecking pattern signature binders] in GHC.Tc.Gen.HsType for
- more on this point.
-
- In this sense, type variables in pattern signatures are quite similar to
- named wildcards, as both can refer to arbitrary types. The main difference
- lies in error reporting: if a named wildcard `_a` in a pattern signature
- stands for Int, then by default GHC will emit a warning stating as much.
- Changing `_a` to `a`, on the other hand, will cause it not to be reported.
-2. In the `h` RULE above, only term variables are explicitly bound, so any free
- type variables in the term variables' signatures are implicitly bound.
- This is just like how the free type variables in pattern signatures are
- implicitly bound. If a RULE explicitly binds both term and type variables,
- however, then free type variables in term signatures are /not/ implicitly
- bound. For example, this RULE would be ill scoped:
-
- {-# RULES "h2" forall b. forall (t :: (b, c)) (g :: forall a. a -> b).
- h2 t g = ... #-}
-
- This is because `b` and `c` occur free in the signature for `t`, but only
- `b` was explicitly bound, leaving `c` out of scope. If the RULE had started
- with `forall b c.`, then it would have been accepted.
-
-The types in pattern signatures and RULE term binder signatures are represented
-in the AST by HsSigPatType. From the renamer onward, the hsps_ext field (of
-type HsPSRn) tracks the names of named wildcards and implicitly bound type
-variables so that they can be brought into scope during renaming and
-typechecking.
-
-Note [Lexically scoped type variables]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The ScopedTypeVariables extension does two things:
-
-* It allows the use of type signatures in patterns
- (e.g., `f (x :: a -> a) = ...`). See
- Note [Pattern signature binders and scoping] for more on this point.
-* It brings lexically scoped type variables into scope for certain type
- signatures with outermost invisible 'forall's.
-
-This Note concerns the latter bullet point. Per the
-"Lexically scoped type variables" section of the GHC User's Guide, the
-following forms of type signatures can have lexically scoped type variables:
-
-* In declarations with type signatures, e.g.,
-
- f :: forall a. a -> a
- f x = e @a
-
- Here, the 'forall a' brings 'a' into scope over the body of 'f'.
-
- Note that ScopedTypeVariables does /not/ interact with standalone kind
- signatures, only type signatures.
-
-* In explicit type annotations in expressions, e.g.,
-
- id @a :: forall a. a -> a
-
-* In instance declarations, e.g.,
-
- instance forall a. C [a] where
- m = e @a
-
- Note that unlike the examples above, the use of an outermost 'forall' isn't
- required to bring 'a' into scope. That is, the following would also work:
-
- instance forall a. C [a] where
- m = e @a
-
-Note that all of the types above obey the forall-or-nothing rule. As a result,
-the places in the AST that can have lexically scoped type variables are a
-subset of the places that use HsOuterTyVarBndrs
-(See Note [forall-or-nothing rule].)
-
-Some other observations about lexically scoped type variables:
-
-* Only type variables bound by an /invisible/ forall can be lexically scoped.
- See Note [hsScopedTvs and visible foralls].
-* The lexically scoped type variables may be a strict subset of the type
- variables brought into scope by a type signature.
- See Note [Binding scoped type variables] in GHC.Tc.Gen.Sig.
--}
-
hsOuterTyVarNames :: HsOuterTyVarBndrs flag GhcRn -> [Name]
hsOuterTyVarNames (HsOuterImplicit{hso_ximplicit = imp_tvs}) = imp_tvs
hsOuterTyVarNames (HsOuterExplicit{hso_bndrs = bndrs}) = hsLTyVarNames bndrs
@@ -786,14 +223,6 @@ hsOuterExplicitBndrs :: HsOuterTyVarBndrs flag (GhcPass p)
hsOuterExplicitBndrs (HsOuterExplicit{hso_bndrs = bndrs}) = bndrs
hsOuterExplicitBndrs (HsOuterImplicit{}) = []
-mapHsOuterImplicit :: (XHsOuterImplicit pass -> XHsOuterImplicit pass)
- -> HsOuterTyVarBndrs flag pass
- -> HsOuterTyVarBndrs flag pass
-mapHsOuterImplicit f (HsOuterImplicit{hso_ximplicit = imp}) =
- HsOuterImplicit{hso_ximplicit = f imp}
-mapHsOuterImplicit _ hso@(HsOuterExplicit{}) = hso
-mapHsOuterImplicit _ hso@(XHsOuterTyVarBndrs{}) = hso
-
mkHsOuterImplicit :: HsOuterTyVarBndrs flag GhcPs
mkHsOuterImplicit = HsOuterImplicit{hso_ximplicit = noExtField}
@@ -824,51 +253,8 @@ mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing
mkEmptyWildCardBndrs x = HsWC { hswc_body = x
, hswc_ext = [] }
-
---------------------------------------------------
--- | These names are used early on to store the names of implicit
--- parameters. They completely disappear after type-checking.
-newtype HsIPName = HsIPName FastString
- deriving( Eq, Data )
-
-hsIPNameFS :: HsIPName -> FastString
-hsIPNameFS (HsIPName n) = n
-
-instance Outputable HsIPName where
- ppr (HsIPName n) = char '?' <> ftext n -- Ordinary implicit parameters
-
-instance OutputableBndr HsIPName where
- pprBndr _ n = ppr n -- Simple for now
- pprInfixOcc n = ppr n
- pprPrefixOcc n = ppr n
-
--------------------------------------------------
--- | Haskell Type Variable Binder
--- The flag annotates the binder. It is 'Specificity' in places where
--- explicit specificity is allowed (e.g. x :: forall {a} b. ...) or
--- '()' in other places.
-data HsTyVarBndr flag pass
- = UserTyVar -- no explicit kinding
- (XUserTyVar pass)
- flag
- (LIdP pass)
- -- See Note [Located RdrNames] in GHC.Hs.Expr
-
- | KindedTyVar
- (XKindedTyVar pass)
- flag
- (LIdP pass)
- (LHsKind pass) -- The user-supplied kind signature
- -- ^
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen',
- -- 'GHC.Parser.Annotation.AnnDcolon', 'GHC.Parser.Annotation.AnnClose'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | XTyVarBndr
- !(XXTyVarBndr pass)
-
type instance XUserTyVar (GhcPass _) = NoExtField
type instance XKindedTyVar (GhcPass _) = NoExtField
@@ -885,12 +271,6 @@ setHsTyVarBndrFlag :: flag -> HsTyVarBndr flag' (GhcPass pass)
setHsTyVarBndrFlag f (UserTyVar x _ l) = UserTyVar x f l
setHsTyVarBndrFlag f (KindedTyVar x _ l k) = KindedTyVar x f l k
--- | Does this 'HsTyVarBndr' come with an explicit kind annotation?
-isHsKindedTyVar :: HsTyVarBndr flag pass -> Bool
-isHsKindedTyVar (UserTyVar {}) = False
-isHsKindedTyVar (KindedTyVar {}) = True
-isHsKindedTyVar (XTyVarBndr {}) = False
-
-- | Do all type variables in this 'LHsQTyVars' come with kind annotations?
hsTvbAllKinded :: LHsQTyVars (GhcPass p) -> Bool
hsTvbAllKinded = all (isHsKindedTyVar . unLoc) . hsQTvExplicit
@@ -899,187 +279,6 @@ instance NamedThing (HsTyVarBndr flag GhcRn) where
getName (UserTyVar _ _ v) = unLoc v
getName (KindedTyVar _ _ v _) = unLoc v
--- | Haskell Type
-data HsType pass
- = HsForAllTy -- See Note [HsType binders]
- { hst_xforall :: XForAllTy pass
- , hst_tele :: HsForAllTelescope pass
- -- Explicit, user-supplied 'forall a {b} c'
- , hst_body :: LHsType pass -- body type
- }
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnForall',
- -- 'GHC.Parser.Annotation.AnnDot','GHC.Parser.Annotation.AnnDarrow'
- -- For details on above see note [Api annotations] in "GHC.Parser.Annotation"
-
- | HsQualTy -- See Note [HsType binders]
- { hst_xqual :: XQualTy pass
- , hst_ctxt :: LHsContext pass -- Context C => blah
- , hst_body :: LHsType pass }
-
- | HsTyVar (XTyVar pass)
- PromotionFlag -- Whether explicitly promoted,
- -- for the pretty printer
- (LIdP pass)
- -- Type variable, type constructor, or data constructor
- -- see Note [Promotions (HsTyVar)]
- -- See Note [Located RdrNames] in GHC.Hs.Expr
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : None
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsAppTy (XAppTy pass)
- (LHsType pass)
- (LHsType pass)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : None
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsAppKindTy (XAppKindTy pass) -- type level type app
- (LHsType pass)
- (LHsKind pass)
-
- | HsFunTy (XFunTy pass)
- (HsArrow pass)
- (LHsType pass) -- function type
- (LHsType pass)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnRarrow',
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsListTy (XListTy pass)
- (LHsType pass) -- Element type
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'['@,
- -- 'GHC.Parser.Annotation.AnnClose' @']'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsTupleTy (XTupleTy pass)
- HsTupleSort
- [LHsType pass] -- Element types (length gives arity)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'(' or '(#'@,
- -- 'GHC.Parser.Annotation.AnnClose' @')' or '#)'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsSumTy (XSumTy pass)
- [LHsType pass] -- Element types (length gives arity)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'(#'@,
- -- 'GHC.Parser.Annotation.AnnClose' '#)'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsOpTy (XOpTy pass)
- (LHsType pass) (LIdP pass) (LHsType pass)
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : None
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsParTy (XParTy pass)
- (LHsType pass) -- See Note [Parens in HsSyn] in GHC.Hs.Expr
- -- Parenthesis preserved for the precedence re-arrangement in
- -- GHC.Rename.HsType
- -- It's important that a * (b + c) doesn't get rearranged to (a*b) + c!
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'('@,
- -- 'GHC.Parser.Annotation.AnnClose' @')'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsIParamTy (XIParamTy pass)
- (XRec pass HsIPName) -- (?x :: ty)
- (LHsType pass) -- Implicit parameters as they occur in
- -- contexts
- -- ^
- -- > (?x :: ty)
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDcolon'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsStarTy (XStarTy pass)
- Bool -- Is this the Unicode variant?
- -- Note [HsStarTy]
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : None
-
- | HsKindSig (XKindSig pass)
- (LHsType pass) -- (ty :: kind)
- (LHsKind pass) -- A type with a kind signature
- -- ^
- -- > (ty :: kind)
- --
- -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'('@,
- -- 'GHC.Parser.Annotation.AnnDcolon','GHC.Parser.Annotation.AnnClose' @')'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsSpliceTy (XSpliceTy pass)
- (HsSplice pass) -- Includes quasi-quotes
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'$('@,
- -- 'GHC.Parser.Annotation.AnnClose' @')'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsDocTy (XDocTy pass)
- (LHsType pass) LHsDocString -- A documented type
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : None
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsBangTy (XBangTy pass)
- HsSrcBang (LHsType pass) -- Bang-style type annotations
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' :
- -- 'GHC.Parser.Annotation.AnnOpen' @'{-\# UNPACK' or '{-\# NOUNPACK'@,
- -- 'GHC.Parser.Annotation.AnnClose' @'#-}'@
- -- 'GHC.Parser.Annotation.AnnBang' @\'!\'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsRecTy (XRecTy pass)
- [LConDeclField pass] -- Only in data type declarations
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @'{'@,
- -- 'GHC.Parser.Annotation.AnnClose' @'}'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsExplicitListTy -- A promoted explicit list
- (XExplicitListTy pass)
- PromotionFlag -- whether explicitly promoted, for pretty printer
- [LHsType pass]
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @"'["@,
- -- 'GHC.Parser.Annotation.AnnClose' @']'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsExplicitTupleTy -- A promoted explicit tuple
- (XExplicitTupleTy pass)
- [LHsType pass]
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpen' @"'("@,
- -- 'GHC.Parser.Annotation.AnnClose' @')'@
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsTyLit (XTyLit pass) HsTyLit -- A promoted numeric literal.
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : None
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- | HsWildCardTy (XWildCardTy pass) -- A type wildcard
- -- See Note [The wildcard story for types]
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : None
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
- -- For adding new constructors via Trees that Grow
- | XHsType
- (XXType pass)
-
--- An escape hatch for tunnelling a Core 'Type' through 'HsType'.
--- For more details on how this works, see:
---
--- * @Note [Renaming HsCoreTys]@ in "GHC.Rename.HsType"
---
--- * @Note [Typechecking HsCoreTys]@ in "GHC.Tc.Gen.HsType"
-type HsCoreTy = Type
-
type instance XForAllTy (GhcPass _) = NoExtField
type instance XQualTy (GhcPass _) = NoExtField
type instance XTyVar (GhcPass _) = NoExtField
@@ -1119,14 +318,6 @@ type instance XWildCardTy (GhcPass _) = NoExtField
type instance XXType (GhcPass _) = HsCoreTy
--- Note [Literal source text] in GHC.Types.Basic for SourceText fields in
--- the following
--- | Haskell Type Literal
-data HsTyLit
- = HsNumTy SourceText Integer
- | HsStrTy SourceText FastString
- deriving Data
-
oneDataConHsTy :: HsType GhcRn
oneDataConHsTy = HsTyVar noExtField NotPromoted (noLoc oneDataConName)
@@ -1137,18 +328,6 @@ isUnrestricted :: HsArrow GhcRn -> Bool
isUnrestricted (arrowToHsType -> L _ (HsTyVar _ _ (L _ n))) = n == manyDataConName
isUnrestricted _ = False
--- | Denotes the type of arrows in the surface language
-data HsArrow pass
- = HsUnrestrictedArrow IsUnicodeSyntax
- -- ^ a -> b or a → b
- | HsLinearArrow IsUnicodeSyntax
- -- ^ a %1 -> b or a %1 → b, or a ⊸ b
- | HsExplicitMult IsUnicodeSyntax (LHsType pass)
- -- ^ a %m -> b or a %m → b (very much including `a %Many -> b`!
- -- This is how the programmer wrote it). It is stored as an
- -- `HsType` so as to preserve the syntax as written in the
- -- program.
-
-- | Convert an arrow into its corresponding multiplicity. In essence this
-- erases the information of whether the programmer wrote an explicit
-- multiplicity or a shorthand.
@@ -1157,26 +336,6 @@ arrowToHsType (HsUnrestrictedArrow _) = noLoc manyDataConHsTy
arrowToHsType (HsLinearArrow _) = noLoc oneDataConHsTy
arrowToHsType (HsExplicitMult _ p) = p
--- | This is used in the syntax. In constructor declaration. It must keep the
--- arrow representation.
-data HsScaled pass a = HsScaled (HsArrow pass) a
-
-hsMult :: HsScaled pass a -> HsArrow pass
-hsMult (HsScaled m _) = m
-
-hsScaledThing :: HsScaled pass a -> a
-hsScaledThing (HsScaled _ t) = t
-
--- | When creating syntax we use the shorthands. It's better for printing, also,
--- the shorthands work trivially at each pass.
-hsUnrestricted, hsLinear :: a -> HsScaled pass a
-hsUnrestricted = HsScaled (HsUnrestrictedArrow NormalSyntax)
-hsLinear = HsScaled (HsLinearArrow NormalSyntax)
-
-instance Outputable a => Outputable (HsScaled pass a) where
- ppr (HsScaled _cnt t) = -- ppr cnt <> ppr t
- ppr t
-
instance
(OutputableBndrId pass) =>
Outputable (HsArrow (GhcPass pass)) where
@@ -1188,120 +347,6 @@ pprHsArrow (HsUnrestrictedArrow _) = arrow
pprHsArrow (HsLinearArrow _) = lollipop
pprHsArrow (HsExplicitMult _ p) = (mulArrow (ppr p))
-{-
-Note [Unit tuples]
-~~~~~~~~~~~~~~~~~~
-Consider the type
- type instance F Int = ()
-We want to parse that "()"
- as HsTupleTy HsBoxedOrConstraintTuple [],
-NOT as HsTyVar unitTyCon
-
-Why? Because F might have kind (* -> Constraint), so we when parsing we
-don't know if that tuple is going to be a constraint tuple or an ordinary
-unit tuple. The HsTupleSort flag is specifically designed to deal with
-that, but it has to work for unit tuples too.
-
-Note [Promotions (HsTyVar)]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-HsTyVar: A name in a type or kind.
- Here are the allowed namespaces for the name.
- In a type:
- Var: not allowed
- Data: promoted data constructor
- Tv: type variable
- TcCls before renamer: type constructor, class constructor, or promoted data constructor
- TcCls after renamer: type constructor or class constructor
- In a kind:
- Var, Data: not allowed
- Tv: kind variable
- TcCls: kind constructor or promoted type constructor
-
- The 'Promoted' field in an HsTyVar captures whether the type was promoted in
- the source code by prefixing an apostrophe.
-
-Note [HsStarTy]
-~~~~~~~~~~~~~~~
-When the StarIsType extension is enabled, we want to treat '*' and its Unicode
-variant identically to 'Data.Kind.Type'. Unfortunately, doing so in the parser
-would mean that when we pretty-print it back, we don't know whether the user
-wrote '*' or 'Type', and lose the parse/ppr roundtrip property.
-
-As a workaround, we parse '*' as HsStarTy (if it stands for 'Data.Kind.Type')
-and then desugar it to 'Data.Kind.Type' in the typechecker (see tc_hs_type).
-When '*' is a regular type operator (StarIsType is disabled), HsStarTy is not
-involved.
-
-
-Note [Promoted lists and tuples]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Notice the difference between
- HsListTy HsExplicitListTy
- HsTupleTy HsExplicitListTupleTy
-
-E.g. f :: [Int] HsListTy
-
- g3 :: T '[] All these use
- g2 :: T '[True] HsExplicitListTy
- g1 :: T '[True,False]
- g1a :: T [True,False] (can omit ' where unambiguous)
-
- kind of T :: [Bool] -> * This kind uses HsListTy!
-
-E.g. h :: (Int,Bool) HsTupleTy; f is a pair
- k :: S '(True,False) HsExplicitTypleTy; S is indexed by
- a type-level pair of booleans
- kind of S :: (Bool,Bool) -> * This kind uses HsExplicitTupleTy
-
-Note [Distinguishing tuple kinds]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Apart from promotion, tuples can have one of three different kinds:
-
- x :: (Int, Bool) -- Regular boxed tuples
- f :: Int# -> (# Int#, Int# #) -- Unboxed tuples
- g :: (Eq a, Ord a) => a -- Constraint tuples
-
-For convenience, internally we use a single constructor for all of these,
-namely HsTupleTy, but keep track of the tuple kind (in the first argument to
-HsTupleTy, a HsTupleSort). We can tell if a tuple is unboxed while parsing,
-because of the #. However, with -XConstraintKinds we can only distinguish
-between constraint and boxed tuples during type checking, in general. Hence the
-two constructors of HsTupleSort:
-
- HsUnboxedTuple -> Produced by the parser
- HsBoxedOrConstraintTuple -> Could be a boxed or a constraint
- tuple. Produced by the parser only,
- disappears after type checking
-
-After typechecking, we use TupleSort (which clearly distinguishes between
-constraint tuples and boxed tuples) rather than HsTupleSort.
--}
-
--- | Haskell Tuple Sort
-data HsTupleSort = HsUnboxedTuple
- | HsBoxedOrConstraintTuple
- deriving Data
-
--- | Located Constructor Declaration Field
-type LConDeclField pass = XRec pass (ConDeclField pass)
- -- ^ May have 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnComma' when
- -- in a list
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
-
--- | Constructor Declaration Field
-data ConDeclField pass -- Record fields have Haddock docs on them
- = ConDeclField { cd_fld_ext :: XConDeclField pass,
- cd_fld_names :: [LFieldOcc pass],
- -- ^ See Note [ConDeclField passs]
- cd_fld_type :: LBangType pass,
- cd_fld_doc :: Maybe LHsDocString }
- -- ^ - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnDcolon'
-
- -- For details on above see note [Api annotations] in GHC.Parser.Annotation
- | XConDeclField !(XXConDeclField pass)
-
type instance XConDeclField (GhcPass _) = NoExtField
type instance XXConDeclField (GhcPass _) = NoExtCon
@@ -1309,63 +354,6 @@ instance OutputableBndrId p
=> Outputable (ConDeclField (GhcPass p)) where
ppr (ConDeclField _ fld_n fld_ty _) = ppr fld_n <+> dcolon <+> ppr fld_ty
--- | Describes the arguments to a data constructor. This is a common
--- representation for several constructor-related concepts, including:
---
--- * The arguments in a Haskell98-style constructor declaration
--- (see 'HsConDeclH98Details' in "GHC.Hs.Decls").
---
--- * The arguments in constructor patterns in @case@/function definitions
--- (see 'HsConPatDetails' in "GHC.Hs.Pat").
---
--- * The left-hand side arguments in a pattern synonym binding
--- (see 'HsPatSynDetails' in "GHC.Hs.Binds").
---
--- One notable exception is the arguments in a GADT constructor, which uses
--- a separate data type entirely (see 'HsConDeclGADTDetails' in
--- "GHC.Hs.Decls"). This is because GADT constructors cannot be declared with
--- infix syntax, unlike the concepts above (#18844).
-data HsConDetails tyarg arg rec
- = PrefixCon [tyarg] [arg] -- C @t1 @t2 p1 p2 p3
- | RecCon rec -- C { x = p1, y = p2 }
- | InfixCon arg arg -- p1 `C` p2
- deriving Data
-
--- | An empty list that can be used to indicate that there are no
--- type arguments allowed in cases where HsConDetails is applied to Void.
-noTypeArgs :: [Void]
-noTypeArgs = []
-
-instance (Outputable tyarg, Outputable arg, Outputable rec)
- => Outputable (HsConDetails tyarg arg rec) where
- ppr (PrefixCon tyargs args) = text "PrefixCon:" <+> hsep (map (\t -> text "@" <> ppr t) tyargs) <+> ppr args
- ppr (RecCon rec) = text "RecCon:" <+> ppr rec
- ppr (InfixCon l r) = text "InfixCon:" <+> ppr [l, r]
-
-{-
-Note [ConDeclField passs]
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-A ConDeclField contains a list of field occurrences: these always
-include the field label as the user wrote it. After the renamer, it
-will additionally contain the identity of the selector function in the
-second component.
-
-Due to DuplicateRecordFields, the OccName of the selector function
-may have been mangled, which is why we keep the original field label
-separately. For example, when DuplicateRecordFields is enabled
-
- data T = MkT { x :: Int }
-
-gives
-
- ConDeclField { cd_fld_names = [L _ (FieldOcc "x" $sel:x:MkT)], ... }.
--}
-
------------------------
--- A valid type must have a for-all at the top of the type, or of the fn arg
--- types
-
---------------------
hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name]
-- Get the lexically-scoped type variables of an LHsSigWcType:
@@ -1385,81 +373,6 @@ hsScopedTvs (L _ (HsSig{sig_bndrs = outer_bndrs}))
= hsLTyVarNames (hsOuterExplicitBndrs outer_bndrs)
-- See Note [hsScopedTvs and visible foralls]
-{- Note [Scoping of named wildcards]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider
- f :: _a -> _a
- f x = let g :: _a -> _a
- g = ...
- in ...
-
-Currently, for better or worse, the "_a" variables are all the same. So
-although there is no explicit forall, the "_a" scopes over the definition.
-I don't know if this is a good idea, but there it is.
--}
-
-{- Note [hsScopedTvs and visible foralls]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--XScopedTypeVariables can be defined in terms of a desugaring to
--XTypeAbstractions (GHC Proposal #50):
-
- fn :: forall a b c. tau(a,b,c) fn :: forall a b c. tau(a,b,c)
- fn = defn(a,b,c) ==> fn @x @y @z = defn(x,y,z)
-
-That is, for every type variable of the leading 'forall' in the type signature,
-we add an invisible binder at term level.
-
-This model does not extend to visible forall, as discussed here:
-
-* https://gitlab.haskell.org/ghc/ghc/issues/16734#note_203412
-* https://github.com/ghc-proposals/ghc-proposals/pull/238
-
-The conclusion of these discussions can be summarized as follows:
-
- > Assuming support for visible 'forall' in terms, consider this example:
- >
- > vfn :: forall x y -> tau(x,y)
- > vfn = \a b -> ...
- >
- > The user has written their own binders 'a' and 'b' to stand for 'x' and
- > 'y', and we definitely should not desugar this into:
- >
- > vfn :: forall x y -> tau(x,y)
- > vfn x y = \a b -> ... -- bad!
-
-This design choice is reflected in the design of HsOuterSigTyVarBndrs, which are
-used in every place that ScopedTypeVariables takes effect:
-
- data HsOuterTyVarBndrs flag pass
- = HsOuterImplicit { ... }
- | HsOuterExplicit { ..., hso_bndrs :: [LHsTyVarBndr flag pass] }
- | ...
- type HsOuterSigTyVarBndrs = HsOuterTyVarBndrs Specificity
-
-The HsOuterExplicit constructor is only used in type signatures with outermost,
-/invisible/ 'forall's. Any other type—including those with outermost,
-/visible/ 'forall's—will use HsOuterImplicit. Therefore, when we determine
-which type variables to bring into scope over the body of a function
-(in hsScopedTvs), we /only/ bring the type variables bound by the hso_bndrs in
-an HsOuterExplicit into scope. If we have an HsOuterImplicit instead, then we
-do not bring any type variables into scope over the body of a function at all.
-
-At the moment, GHC does not support visible 'forall' in terms. Nevertheless,
-it is still possible to write erroneous programs that use visible 'forall's in
-terms, such as this example:
-
- x :: forall a -> a -> a
- x = x
-
-Previous versions of GHC would bring `a` into scope over the body of `x` in the
-hopes that the typechecker would error out later
-(see `GHC.Tc.Validity.vdqAllowed`). However, this can wreak havoc in the
-renamer before GHC gets to that point (see #17687 for an example of this).
-Bottom line: nip problems in the bud by refraining from bringing any type
-variables in an HsOuterImplicit into scope over the body of a function, even
-if they correspond to a visible 'forall'.
--}
-
---------------------
hsTyVarName :: HsTyVarBndr flag (GhcPass p) -> IdP (GhcPass p)
hsTyVarName (UserTyVar _ _ (L _ n)) = n
@@ -1582,20 +495,6 @@ hsTyGetAppHead_maybe = go
go _ = Nothing
------------------------------------------------------------
--- Arguments in an expression/type after splitting
-data HsArg tm ty
- = HsValArg tm -- Argument is an ordinary expression (f arg)
- | HsTypeArg SrcSpan ty -- Argument is a visible type application (f @ty)
- -- SrcSpan is location of the `@`
- | HsArgPar SrcSpan -- See Note [HsArgPar]
-
-numVisibleArgs :: [HsArg tm ty] -> Arity
-numVisibleArgs = count is_vis
- where is_vis (HsValArg _) = True
- is_vis _ = False
-
--- type level equivalent
-type LHsTypeArg p = HsArg (LHsType p) (LHsKind p)
-- | Compute the 'SrcSpan' associated with an 'LHsTypeArg'.
lhsTypeArgSrcSpan :: LHsTypeArg (GhcPass pass) -> SrcSpan
@@ -1604,24 +503,6 @@ lhsTypeArgSrcSpan arg = case arg of
HsTypeArg at ty -> at `combineSrcSpans` getLoc ty
HsArgPar sp -> sp
-instance (Outputable tm, Outputable ty) => Outputable (HsArg tm ty) where
- ppr (HsValArg tm) = ppr tm
- ppr (HsTypeArg _ ty) = char '@' <> ppr ty
- ppr (HsArgPar sp) = text "HsArgPar" <+> ppr sp
-{-
-Note [HsArgPar]
-A HsArgPar indicates that everything to the left of this in the argument list is
-enclosed in parentheses together with the function itself. It is necessary so
-that we can recreate the parenthesis structure in the original source after
-typechecking the arguments.
-
-The SrcSpan is the span of the original HsPar
-
-((f arg1) arg2 arg3) results in an input argument list of
-[HsValArg arg1, HsArgPar span1, HsValArg arg2, HsValArg arg3, HsArgPar span2]
-
--}
-
--------------------------------
-- | Decompose a pattern synonym type signature into its constituent parts.
@@ -1893,57 +774,16 @@ also forbids them in types involved with `deriving`:
************************************************************************
-}
--- | Located Field Occurrence
-type LFieldOcc pass = XRec pass (FieldOcc pass)
-
--- | Field Occurrence
---
--- Represents an *occurrence* of an unambiguous field. This may or may not be a
--- binding occurrence (e.g. this type is used in 'ConDeclField' and
--- 'RecordPatSynField' which bind their fields, but also in 'HsRecField' for
--- record construction and patterns, which do not).
---
--- We store both the 'RdrName' the user originally wrote, and after the renamer,
--- the selector function.
-data FieldOcc pass = FieldOcc { extFieldOcc :: XCFieldOcc pass
- , rdrNameFieldOcc :: Located RdrName
- -- ^ See Note [Located RdrNames] in "GHC.Hs.Expr"
- }
-
- | XFieldOcc
- !(XXFieldOcc pass)
-deriving instance Eq (XCFieldOcc (GhcPass p)) => Eq (FieldOcc (GhcPass p))
-
type instance XCFieldOcc GhcPs = NoExtField
type instance XCFieldOcc GhcRn = Name
type instance XCFieldOcc GhcTc = Id
type instance XXFieldOcc (GhcPass _) = NoExtCon
-instance Outputable (FieldOcc pass) where
- ppr = ppr . rdrNameFieldOcc
-
mkFieldOcc :: Located RdrName -> FieldOcc GhcPs
mkFieldOcc rdr = FieldOcc noExtField rdr
--- | Ambiguous Field Occurrence
---
--- Represents an *occurrence* of a field that is potentially
--- ambiguous after the renamer, with the ambiguity resolved by the
--- typechecker. We always store the 'RdrName' that the user
--- originally wrote, and store the selector function after the renamer
--- (for unambiguous occurrences) or the typechecker (for ambiguous
--- occurrences).
---
--- See Note [HsRecField and HsRecUpdField] in "GHC.Hs.Pat" and
--- Note [Disambiguating record fields] in "GHC.Tc.Gen.Head".
--- See Note [Located RdrNames] in "GHC.Hs.Expr"
-data AmbiguousFieldOcc pass
- = Unambiguous (XUnambiguous pass) (Located RdrName)
- | Ambiguous (XAmbiguous pass) (Located RdrName)
- | XAmbiguousFieldOcc !(XXAmbiguousFieldOcc pass)
-
type instance XUnambiguous GhcPs = NoExtField
type instance XUnambiguous GhcRn = Name
type instance XUnambiguous GhcTc = Id
@@ -2007,9 +847,6 @@ instance OutputableBndrId p => Outputable (HsSigType (GhcPass p)) where
instance OutputableBndrId p => Outputable (HsType (GhcPass p)) where
ppr ty = pprHsType ty
-instance Outputable HsTyLit where
- ppr = ppr_tylit
-
instance OutputableBndrId p
=> Outputable (LHsQTyVars (GhcPass p)) where
ppr (HsQTvs { hsq_explicit = tvs }) = interppSP tvs
@@ -2169,7 +1006,7 @@ ppr_mono_ty (HsExplicitTupleTy _ tys)
= quote $ sep [text (mkTupleStr Boxed 1), ppr_mono_lty ty]
| otherwise
= quote $ parens (maybeAddSpace tys $ interpp'SP tys)
-ppr_mono_ty (HsTyLit _ t) = ppr_tylit t
+ppr_mono_ty (HsTyLit _ t) = ppr t
ppr_mono_ty (HsWildCardTy {}) = char '_'
ppr_mono_ty (HsStarTy _ isUni) = char (if isUni then '★' else '*')
@@ -2207,11 +1044,6 @@ ppr_fun_ty mult ty1 ty2
sep [p1, arr <+> p2]
--------------------------
-ppr_tylit :: HsTyLit -> SDoc
-ppr_tylit (HsNumTy source i) = pprWithSourceText source (integer i)
-ppr_tylit (HsStrTy source s) = pprWithSourceText source (text (show s))
-
-
-- | @'hsTypeNeedsParens' p t@ returns 'True' if the type @t@ needs parentheses
-- under precedence @p@.
hsTypeNeedsParens :: PprPrec -> HsType (GhcPass p) -> Bool
diff --git a/compiler/GHC/Hs/Utils.hs b/compiler/GHC/Hs/Utils.hs
index e538549265..39ce2c19bd 100644
--- a/compiler/GHC/Hs/Utils.hs
+++ b/compiler/GHC/Hs/Utils.hs
@@ -116,6 +116,7 @@ import GHC.Hs.Expr
import GHC.Hs.Pat
import GHC.Hs.Type
import GHC.Hs.Lit
+import Language.Haskell.Syntax.Extension
import GHC.Hs.Extension
import GHC.Tc.Types.Evidence
View Lorry Controller Status