GHC.Parser.PostProcess

Documentation

mkHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs

A useful function for building OpApps. The operator is always a variable, and we don't know the fixity yet.

mkHsIntegral :: IntegralLit -> HsOverLit GhcPs

mkHsFractional :: FractionalLit -> HsOverLit GhcPs

mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs

mkHsDo :: HsStmtContext GhcRn -> [ExprLStmt GhcPs] -> HsExpr GhcPs

mkSpliceDecl :: LHsExpr GhcPs -> HsDecl GhcPs

mkRoleAnnotDecl :: SrcSpan -> Located RdrName -> [Located (Maybe FastString)] -> P (LRoleAnnotDecl GhcPs)

mkClassDecl :: SrcSpan -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs) -> Located (a, [LHsFunDep GhcPs]) -> OrdList (LHsDecl GhcPs) -> LayoutInfo -> P (LTyClDecl GhcPs)

mkTyData :: SrcSpan -> NewOrData -> Maybe (Located CType) -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs) -> Maybe (LHsKind GhcPs) -> [LConDecl GhcPs] -> HsDeriving GhcPs -> P (LTyClDecl GhcPs)

mkDataFamInst :: SrcSpan -> NewOrData -> Maybe (Located CType) -> (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr () GhcPs], LHsType GhcPs) -> Maybe (LHsKind GhcPs) -> [LConDecl GhcPs] -> HsDeriving GhcPs -> P (LInstDecl GhcPs)

mkTySynonym :: SrcSpan -> LHsType GhcPs -> LHsType GhcPs -> P (LTyClDecl GhcPs)

mkTyFamInstEqn :: Maybe [LHsTyVarBndr () GhcPs] -> LHsType GhcPs -> LHsType GhcPs -> P (TyFamInstEqn GhcPs, [AddAnn])

mkStandaloneKindSig :: SrcSpan -> Located [Located RdrName] -> LHsKind GhcPs -> P (LStandaloneKindSig GhcPs)

mkTyFamInst :: SrcSpan -> TyFamInstEqn GhcPs -> P (LInstDecl GhcPs)

mkFamDecl :: SrcSpan -> FamilyInfo GhcPs -> LHsType GhcPs -> Located (FamilyResultSig GhcPs) -> Maybe (LInjectivityAnn GhcPs) -> P (LTyClDecl GhcPs)

mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs

mkInlinePragma :: SourceText -> (InlineSpec, RuleMatchInfo) -> Maybe Activation -> InlinePragma

mkPatSynMatchGroup :: Located RdrName -> Located (OrdList (LHsDecl GhcPs)) -> P (MatchGroup GhcPs (LHsExpr GhcPs))

mkRecConstrOrUpdate :: LHsExpr GhcPs -> SrcSpan -> ([LHsRecField GhcPs (LHsExpr GhcPs)], Maybe SrcSpan) -> PV (HsExpr GhcPs)

mkTyClD :: LTyClDecl (GhcPass p) -> LHsDecl (GhcPass p)

mkClassDecl builds a RdrClassDecl, filling in the names for tycon and datacon by deriving them from the name of the class. We fill in the names for the tycon and datacon corresponding to the class, by deriving them from the name of the class itself. This saves recording the names in the interface file (which would be equally good).

mkInstD :: LInstDecl (GhcPass p) -> LHsDecl (GhcPass p)

mkRdrRecordCon :: Located RdrName -> HsRecordBinds GhcPs -> HsExpr GhcPs

mkRdrRecordUpd :: LHsExpr GhcPs -> [LHsRecUpdField GhcPs] -> HsExpr GhcPs

setRdrNameSpace :: RdrName -> NameSpace -> RdrName

This rather gruesome function is used mainly by the parser. When parsing:

data T a = T | T1 Int

we parse the data constructors as types because of parser ambiguities, so then we need to change the type constr to a data constr

The exact-name case can occur when parsing:

data [] a = [] | a : [a]

For the exact-name case we return an original name.

filterCTuple :: RdrName -> RdrName

Replaces constraint tuple names with corresponding boxed ones.

fromSpecTyVarBndr :: LHsTyVarBndr Specificity GhcPs -> P (LHsTyVarBndr () GhcPs)

Converts LHsTyVarBndr annotated with its Specificity to one without annotations. Only accepts specified variables, and errors if the provided binder has an InferredSpec annotation.

fromSpecTyVarBndrs :: [LHsTyVarBndr Specificity GhcPs] -> P [LHsTyVarBndr () GhcPs]

Converts a list of LHsTyVarBndrs annotated with their Specificity to binders without annotations. Only accepts specified variables, and errors if any of the provided binders has an InferredSpec annotation.

cvBindGroup :: OrdList (LHsDecl GhcPs) -> P (HsValBinds GhcPs)

cvBindsAndSigs :: OrdList (LHsDecl GhcPs) -> P (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs], [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl])

cvTopDecls :: OrdList (LHsDecl GhcPs) -> [LHsDecl GhcPs]

Function definitions are restructured here. Each is assumed to be recursive initially, and non recursive definitions are discovered by the dependency analyser.

placeHolderPunRhs :: DisambECP b => PV (Located b)

mkImport :: Located CCallConv -> Located Safety -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs) -> P (HsDecl GhcPs)

parseCImport :: Located CCallConv -> Located Safety -> FastString -> String -> Located SourceText -> Maybe ForeignImport

mkExport :: Located CCallConv -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs) -> P (HsDecl GhcPs)

mkExtName :: RdrName -> CLabelString

mkGadtDecl :: [Located RdrName] -> LHsType GhcPs -> P (ConDecl GhcPs, [AddAnn])

Construct a GADT-style data constructor from the constructor names and their type. Some interesting aspects of this function:

• This splits up the constructor type into its quantified type variables (if provided), context (if provided), argument types, and result type, and records whether this is a prefix or record GADT constructor. See Note [GADT abstract syntax] in GHC.Hs.Decls for more details.

mkConDeclH98 :: Located RdrName -> Maybe [LHsTyVarBndr Specificity GhcPs] -> Maybe (LHsContext GhcPs) -> HsConDeclDetails GhcPs -> ConDecl GhcPs

checkImportDecl :: Maybe (Located Token) -> Maybe (Located Token) -> P ()

checkExpBlockArguments :: LHsExpr GhcPs -> PV ()

Yield a parse error if we have a function applied directly to a do block etc. and BlockArguments is not enabled.

checkCmdBlockArguments :: LHsCmd GhcPs -> PV ()

checkPrecP

Arguments

:: Located (SourceText, Int)

precedence

-> Located (OrdList (Located RdrName))

operators

-> P ()

Check if a fixity is valid. We support bypassing the usual bound checks for some special operators.

checkContext :: LHsType GhcPs -> P ([AddAnn], LHsContext GhcPs)

Validate the context constraints and break up a context into a list of predicates.

    (Eq a, Ord b)        -->  [Eq a, Ord b]
    Eq a                 -->  [Eq a]
    (Eq a)               -->  [Eq a]
    (((Eq a)))           -->  [Eq a]

checkPattern :: Located (PatBuilder GhcPs) -> P (LPat GhcPs)

checkPattern_msg :: SDoc -> PV (Located (PatBuilder GhcPs)) -> P (LPat GhcPs)

checkMonadComp :: PV (HsStmtContext GhcRn)

Check for monad comprehensions

If the flag MonadComprehensions is set, return a MonadComp context, otherwise use the usual ListComp context

checkValDef :: Located (PatBuilder GhcPs) -> Maybe (LHsType GhcPs) -> Located (a, GRHSs GhcPs (LHsExpr GhcPs)) -> P ([AddAnn], HsBind GhcPs)

checkValSigLhs :: LHsExpr GhcPs -> P (Located RdrName)

type LRuleTyTmVar = Located RuleTyTmVar

data RuleTyTmVar

Essentially a wrapper for a RuleBndr GhcPs

Constructors

RuleTyTmVar (Located RdrName) (Maybe (LHsType GhcPs))

mkRuleBndrs :: [LRuleTyTmVar] -> [LRuleBndr GhcPs]

mkRuleTyVarBndrs :: [LRuleTyTmVar] -> [LHsTyVarBndr () GhcPs]

checkRuleTyVarBndrNames :: [LHsTyVarBndr flag GhcPs] -> P ()

checkRecordSyntax :: (MonadP m, Outputable a) => Located a -> m (Located a)

checkEmptyGADTs :: Located ([AddAnn], [LConDecl GhcPs]) -> P (Located ([AddAnn], [LConDecl GhcPs]))

Check if the gadt_constrlist is empty. Only raise parse error for `data T where` to avoid affecting existing error message, see #8258.

addFatalError :: MonadP m => SrcSpan -> SDoc -> m a

Add a fatal error. This will be the last error reported by the parser, and the parser will not produce any result, ending in a PFailed state.

hintBangPat :: SrcSpan -> Pat GhcPs -> PV ()

Hint about bang patterns, assuming BangPatterns is off.

data TyEl

Either an operator or an operand.

Constructors

TyElOpr RdrName

TyElOpd (HsType GhcPs)

TyElKindApp SrcSpan (LHsType GhcPs)

TyElUnpackedness ([AddAnn], SourceText, SrcUnpackedness)

Instances

Outputable TyEl

Defined in GHC.Parser.PostProcess

Methods

ppr :: TyEl -> SDoc

pprPrec :: Rational -> TyEl -> SDoc

mergeOps :: [Located TyEl] -> P (LHsType GhcPs)

Merge a reversed and non-empty soup of operators and operands into a type.

User input: F x y + G a b * X Input to mergeOps: [X, *, b, a, G, +, y, x, F] Output corresponds to what the user wrote assuming all operators are of the same fixity and right-associative.

It's a bit silly that we're doing it at all, as the renamer will have to rearrange this, and it'd be easier to keep things separate.

See Note [Parsing data constructors is hard]

mergeDataCon :: [Located TyEl] -> P (Located RdrName, HsConDeclDetails GhcPs)

Merge a reversed and non-empty soup of operators and operands into a data constructor.

User input: C !A B -- ^ doc Input to mergeDataCon: ["doc", B, !A, C] Output: (C, PrefixCon [!A, B], "doc")

See Note [Parsing data constructors is hard]

mkBangTy :: SrcStrictness -> LHsType GhcPs -> HsType GhcPs

mkMultTy :: IsUnicodeSyntax -> Located Token -> LHsType GhcPs -> (HsArrow GhcPs, AddAnn)

data ImpExpSubSpec

Constructors

ImpExpAbs

ImpExpAll

ImpExpList [Located ImpExpQcSpec]

ImpExpAllWith [Located ImpExpQcSpec]

data ImpExpQcSpec

Constructors

ImpExpQcName (Located RdrName)

ImpExpQcType (Located RdrName)

ImpExpQcWildcard

mkModuleImpExp :: Located ImpExpQcSpec -> ImpExpSubSpec -> P (IE GhcPs)

mkTypeImpExp :: Located RdrName -> P (Located RdrName)

mkImpExpSubSpec :: [Located ImpExpQcSpec] -> P ([AddAnn], ImpExpSubSpec)

checkImportSpec :: Located [LIE GhcPs] -> P (Located [LIE GhcPs])

forallSym :: Bool -> String

starSym :: Bool -> String

warnStarIsType :: SrcSpan -> P ()

warnPrepositiveQualifiedModule :: SrcSpan -> P ()

failOpFewArgs :: Located RdrName -> P a

failOpNotEnabledImportQualifiedPost :: SrcSpan -> P ()

failOpImportQualifiedTwice :: SrcSpan -> P ()

data SumOrTuple b

Constructors

Sum ConTag Arity (Located b)

Tuple [Located (Maybe (Located b))]

data PV a

Instances

Monad PV

Defined in GHC.Parser.PostProcess

Methods

(>>=) :: PV a -> (a -> PV b) -> PV b

(>>) :: PV a -> PV b -> PV b

return :: a -> PV a

Functor PV

Defined in GHC.Parser.PostProcess

Methods

fmap :: (a -> b) -> PV a -> PV b

(<$) :: a -> PV b -> PV a

Applicative PV

Defined in GHC.Parser.PostProcess

Methods

pure :: a -> PV a

(<*>) :: PV (a -> b) -> PV a -> PV b

liftA2 :: (a -> b -> c) -> PV a -> PV b -> PV c

(*>) :: PV a -> PV b -> PV b

(<*) :: PV a -> PV b -> PV a

MonadP PV

Defined in GHC.Parser.PostProcess

Methods

addError :: SrcSpan -> SDoc -> PV ()

addWarning :: WarningFlag -> SrcSpan -> SDoc -> PV ()

addFatalError :: SrcSpan -> SDoc -> PV a

getBit :: ExtBits -> PV Bool

addAnnotation :: SrcSpan -> AnnKeywordId -> SrcSpan -> PV ()

runPV :: PV a -> P a

newtype ECP

Constructors

ECP

Fields

• runECP_PV :: forall b. DisambECP b => PV (Located b)

runECP_P :: DisambECP b => ECP -> P (Located b)

class DisambInfixOp b where

Disambiguate infix operators. See Note [Ambiguous syntactic categories]

Methods

mkHsVarOpPV :: Located RdrName -> PV (Located b)

mkHsConOpPV :: Located RdrName -> PV (Located b)

mkHsInfixHolePV :: SrcSpan -> PV (Located b)

Instances

DisambInfixOp RdrName

Defined in GHC.Parser.PostProcess

Methods

mkHsVarOpPV :: Located RdrName -> PV (Located RdrName)

mkHsConOpPV :: Located RdrName -> PV (Located RdrName)

mkHsInfixHolePV :: SrcSpan -> PV (Located RdrName)

DisambInfixOp (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

Methods

mkHsVarOpPV :: Located RdrName -> PV (Located (HsExpr GhcPs))

mkHsConOpPV :: Located RdrName -> PV (Located (HsExpr GhcPs))

mkHsInfixHolePV :: SrcSpan -> PV (Located (HsExpr GhcPs))

class b ~ Body b GhcPs => DisambECP b where

Disambiguate constructs that may appear when we do not know ahead of time whether we are parsing an expression, a command, or a pattern. See Note [Ambiguous syntactic categories]

Associated Types

type Body b :: Type -> Type

See Note [Body in DisambECP]

type InfixOp b

Infix operator representation

type FunArg b

Function argument representation

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located b)

Return a command without ambiguity, or fail in a non-command context.

ecpFromExp' :: LHsExpr GhcPs -> PV (Located b)

Return an expression without ambiguity, or fail in a non-expression context.

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located b) -> PV (Located b)

Disambiguate "... -> ..." (lambda)

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located b -> PV (Located b)

Disambiguate "let ... in ..."

superInfixOp :: (DisambInfixOp (InfixOp b) => PV (Located b)) -> PV (Located b)

Bring superclass constraints on InfixOp into scope. See Note [UndecidableSuperClasses for associated types]

mkHsOpAppPV :: SrcSpan -> Located b -> Located (InfixOp b) -> Located b -> PV (Located b)

Disambiguate "f # x" (infix operator)

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located b) -> PV (Located b)

Disambiguate "case ... of ..."

mkHsLamCasePV :: SrcSpan -> MatchGroup GhcPs (Located b) -> PV (Located b)

Disambiguate \case ... (lambda case)

superFunArg :: (DisambECP (FunArg b) => PV (Located b)) -> PV (Located b)

Bring superclass constraints on FunArg into scope. See Note [UndecidableSuperClasses for associated types]

mkHsAppPV :: SrcSpan -> Located b -> Located (FunArg b) -> PV (Located b)

Disambiguate "f x" (function application)

mkHsAppTypePV :: SrcSpan -> Located b -> LHsType GhcPs -> PV (Located b)

Disambiguate "f @t" (visible type application)

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located b -> Bool -> Located b -> PV (Located b)

Disambiguate "if ... then ... else ..."

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> Located [LStmt GhcPs (Located b)] -> PV (Located b)

Disambiguate "do { ... }" (do notation)

mkHsParPV :: SrcSpan -> Located b -> PV (Located b)

Disambiguate "( ... )" (parentheses)

mkHsVarPV :: Located RdrName -> PV (Located b)

Disambiguate a variable "f" or a data constructor MkF.

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located b)

Disambiguate a monomorphic literal

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located b)

Disambiguate an overloaded literal

mkHsWildCardPV :: SrcSpan -> PV (Located b)

Disambiguate a wildcard

mkHsTySigPV :: SrcSpan -> Located b -> LHsType GhcPs -> PV (Located b)

Disambiguate "a :: t" (type annotation)

mkHsExplicitListPV :: SrcSpan -> [Located b] -> PV (Located b)

Disambiguate "[a,b,c]" (list syntax)

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located b)

Disambiguate "$(...)" and "[quasi|...|]" (TH splices)

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located b -> ([LHsRecField GhcPs (Located b)], Maybe SrcSpan) -> PV (Located b)

Disambiguate "f { a = b, ... }" syntax (record construction and record updates)

mkHsNegAppPV :: SrcSpan -> Located b -> PV (Located b)

Disambiguate "-a" (negation)

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp b) -> Located b -> PV (Located b)

Disambiguate "(# a)" (right operator section)

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located b -> PV (Located b)

Disambiguate "(a -> b)" (view pattern)

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located b -> PV (Located b)

Disambiguate "a@b" (as-pattern)

mkHsLazyPatPV :: SrcSpan -> Located b -> PV (Located b)

Disambiguate "~a" (lazy pattern)

mkHsBangPatPV :: SrcSpan -> Located b -> PV (Located b)

Disambiguate "!a" (bang pattern)

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple b -> PV (Located b)

Disambiguate tuple sections and unboxed sums

rejectPragmaPV :: Located b -> PV ()

Validate infixexp LHS to reject unwanted {--} pragmas

Instances

DisambECP (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsCmd GhcPs) :: Type -> Type

type InfixOp (HsCmd GhcPs)

type FunArg (HsCmd GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsCmd GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsCmd GhcPs))

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsCmd GhcPs)) -> PV (Located (HsCmd GhcPs))

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (HsCmd GhcPs)) => PV (Located (HsCmd GhcPs))) -> PV (Located (HsCmd GhcPs))

mkHsOpAppPV :: SrcSpan -> Located (HsCmd GhcPs) -> Located (InfixOp (HsCmd GhcPs)) -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsCmd GhcPs)) -> PV (Located (HsCmd GhcPs))

mkHsLamCasePV :: SrcSpan -> MatchGroup GhcPs (Located (HsCmd GhcPs)) -> PV (Located (HsCmd GhcPs))

superFunArg :: (DisambECP (FunArg (HsCmd GhcPs)) => PV (Located (HsCmd GhcPs))) -> PV (Located (HsCmd GhcPs))

mkHsAppPV :: SrcSpan -> Located (HsCmd GhcPs) -> Located (FunArg (HsCmd GhcPs)) -> PV (Located (HsCmd GhcPs))

mkHsAppTypePV :: SrcSpan -> Located (HsCmd GhcPs) -> LHsType GhcPs -> PV (Located (HsCmd GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsCmd GhcPs) -> Bool -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> Located [LStmt GhcPs (Located (HsCmd GhcPs))] -> PV (Located (HsCmd GhcPs))

mkHsParPV :: SrcSpan -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsVarPV :: Located RdrName -> PV (Located (HsCmd GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd GhcPs))

mkHsTySigPV :: SrcSpan -> Located (HsCmd GhcPs) -> LHsType GhcPs -> PV (Located (HsCmd GhcPs))

mkHsExplicitListPV :: SrcSpan -> [Located (HsCmd GhcPs)] -> PV (Located (HsCmd GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsCmd GhcPs) -> ([LHsRecField GhcPs (Located (HsCmd GhcPs))], Maybe SrcSpan) -> PV (Located (HsCmd GhcPs))

mkHsNegAppPV :: SrcSpan -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsCmd GhcPs)) -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsLazyPatPV :: SrcSpan -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsBangPatPV :: SrcSpan -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

rejectPragmaPV :: Located (HsCmd GhcPs) -> PV ()

DisambECP (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsExpr GhcPs) :: Type -> Type

type InfixOp (HsExpr GhcPs)

type FunArg (HsExpr GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsExpr GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsExpr GhcPs))

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsExpr GhcPs)) -> PV (Located (HsExpr GhcPs))

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (HsExpr GhcPs)) => PV (Located (HsExpr GhcPs))) -> PV (Located (HsExpr GhcPs))

mkHsOpAppPV :: SrcSpan -> Located (HsExpr GhcPs) -> Located (InfixOp (HsExpr GhcPs)) -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsExpr GhcPs)) -> PV (Located (HsExpr GhcPs))

mkHsLamCasePV :: SrcSpan -> MatchGroup GhcPs (Located (HsExpr GhcPs)) -> PV (Located (HsExpr GhcPs))

superFunArg :: (DisambECP (FunArg (HsExpr GhcPs)) => PV (Located (HsExpr GhcPs))) -> PV (Located (HsExpr GhcPs))

mkHsAppPV :: SrcSpan -> Located (HsExpr GhcPs) -> Located (FunArg (HsExpr GhcPs)) -> PV (Located (HsExpr GhcPs))

mkHsAppTypePV :: SrcSpan -> Located (HsExpr GhcPs) -> LHsType GhcPs -> PV (Located (HsExpr GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsExpr GhcPs) -> Bool -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> Located [LStmt GhcPs (Located (HsExpr GhcPs))] -> PV (Located (HsExpr GhcPs))

mkHsParPV :: SrcSpan -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsVarPV :: Located RdrName -> PV (Located (HsExpr GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr GhcPs))

mkHsTySigPV :: SrcSpan -> Located (HsExpr GhcPs) -> LHsType GhcPs -> PV (Located (HsExpr GhcPs))

mkHsExplicitListPV :: SrcSpan -> [Located (HsExpr GhcPs)] -> PV (Located (HsExpr GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsExpr GhcPs) -> ([LHsRecField GhcPs (Located (HsExpr GhcPs))], Maybe SrcSpan) -> PV (Located (HsExpr GhcPs))

mkHsNegAppPV :: SrcSpan -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsExpr GhcPs)) -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsLazyPatPV :: SrcSpan -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsBangPatPV :: SrcSpan -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

rejectPragmaPV :: Located (HsExpr GhcPs) -> PV ()

DisambECP (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (PatBuilder GhcPs) :: Type -> Type

type InfixOp (PatBuilder GhcPs)

type FunArg (PatBuilder GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (PatBuilder GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (PatBuilder GhcPs))

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs))

mkHsOpAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

mkHsLamCasePV :: SrcSpan -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

superFunArg :: (DisambECP (FunArg (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs))

mkHsAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (FunArg (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

mkHsAppTypePV :: SrcSpan -> Located (PatBuilder GhcPs) -> LHsType GhcPs -> PV (Located (PatBuilder GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (PatBuilder GhcPs) -> Bool -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> Located [LStmt GhcPs (Located (PatBuilder GhcPs))] -> PV (Located (PatBuilder GhcPs))

mkHsParPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsVarPV :: Located RdrName -> PV (Located (PatBuilder GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (PatBuilder GhcPs))

mkHsTySigPV :: SrcSpan -> Located (PatBuilder GhcPs) -> LHsType GhcPs -> PV (Located (PatBuilder GhcPs))

mkHsExplicitListPV :: SrcSpan -> [Located (PatBuilder GhcPs)] -> PV (Located (PatBuilder GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (PatBuilder GhcPs) -> ([LHsRecField GhcPs (Located (PatBuilder GhcPs))], Maybe SrcSpan) -> PV (Located (PatBuilder GhcPs))

mkHsNegAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsLazyPatPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsBangPatPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

rejectPragmaPV :: Located (PatBuilder GhcPs) -> PV ()

ecpFromExp :: LHsExpr GhcPs -> ECP

ecpFromCmd :: LHsCmd GhcPs -> ECP

data PatBuilder p

See Note [Ambiguous syntactic categories] and Note [PatBuilder]

Instances

Outputable (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

Methods

ppr :: PatBuilder GhcPs -> SDoc

pprPrec :: Rational -> PatBuilder GhcPs -> SDoc

DisambECP (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (PatBuilder GhcPs) :: Type -> Type

type InfixOp (PatBuilder GhcPs)

type FunArg (PatBuilder GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (PatBuilder GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (PatBuilder GhcPs))

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs))

mkHsOpAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

mkHsLamCasePV :: SrcSpan -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

superFunArg :: (DisambECP (FunArg (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs))

mkHsAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (FunArg (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

mkHsAppTypePV :: SrcSpan -> Located (PatBuilder GhcPs) -> LHsType GhcPs -> PV (Located (PatBuilder GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (PatBuilder GhcPs) -> Bool -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> Located [LStmt GhcPs (Located (PatBuilder GhcPs))] -> PV (Located (PatBuilder GhcPs))

mkHsParPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsVarPV :: Located RdrName -> PV (Located (PatBuilder GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (PatBuilder GhcPs))

mkHsTySigPV :: SrcSpan -> Located (PatBuilder GhcPs) -> LHsType GhcPs -> PV (Located (PatBuilder GhcPs))

mkHsExplicitListPV :: SrcSpan -> [Located (PatBuilder GhcPs)] -> PV (Located (PatBuilder GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (PatBuilder GhcPs) -> ([LHsRecField GhcPs (Located (PatBuilder GhcPs))], Maybe SrcSpan) -> PV (Located (PatBuilder GhcPs))

mkHsNegAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsLazyPatPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsBangPatPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

rejectPragmaPV :: Located (PatBuilder GhcPs) -> PV ()

type Body (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

type Body (PatBuilder GhcPs) = PatBuilder

type InfixOp (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

type InfixOp (PatBuilder GhcPs) = RdrName

type FunArg (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs