ghc-lib-parser-9.10.1.20250103: The GHC API, decoupled from GHC versions

Safe Haskell | Ignore
Language | GHC2021

GHC.Parser.PostProcess

Synopsis

- mkRdrGetField :: LHsExpr GhcPs -> LocatedAn NoEpAnns (DotFieldOcc GhcPs) -> HsExpr GhcPs
- mkRdrProjection :: NonEmpty (LocatedAn NoEpAnns (DotFieldOcc GhcPs)) -> AnnProjection -> HsExpr GhcPs
- type Fbind b = Either (LHsRecField GhcPs (LocatedA b)) (LHsRecProj GhcPs (LocatedA b))
- mkHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
- mkHsIntegral :: IntegralLit -> HsOverLit GhcPs
- mkHsFractional :: FractionalLit -> HsOverLit GhcPs
- mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs
- mkHsDo :: HsDoFlavour -> LocatedL [ExprLStmt GhcPs] -> HsExpr GhcPs
- mkSpliceDecl :: LHsExpr GhcPs -> LHsDecl GhcPs
- mkRoleAnnotDecl :: SrcSpan -> LocatedN RdrName -> [Located (Maybe FastString)] -> [AddEpAnn] -> P (LRoleAnnotDecl GhcPs)
- mkClassDecl :: SrcSpan -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs) -> Located (a, [LHsFunDep GhcPs]) -> OrdList (LHsDecl GhcPs) -> EpLayout -> [AddEpAnn] -> P (LTyClDecl GhcPs)
- mkTyData :: SrcSpan -> Bool -> NewOrData -> Maybe (LocatedP CType) -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs) -> Maybe (LHsKind GhcPs) -> [LConDecl GhcPs] -> Located (HsDeriving GhcPs) -> [AddEpAnn] -> P (LTyClDecl GhcPs)
- mkDataFamInst :: SrcSpan -> NewOrData -> Maybe (LocatedP CType) -> (Maybe (LHsContext GhcPs), HsOuterFamEqnTyVarBndrs GhcPs, LHsType GhcPs) -> Maybe (LHsKind GhcPs) -> [LConDecl GhcPs] -> Located (HsDeriving GhcPs) -> [AddEpAnn] -> P (LInstDecl GhcPs)
- mkTySynonym :: SrcSpan -> LHsType GhcPs -> LHsType GhcPs -> [AddEpAnn] -> P (LTyClDecl GhcPs)
- mkTyFamInstEqn :: SrcSpan -> HsOuterFamEqnTyVarBndrs GhcPs -> LHsType GhcPs -> LHsType GhcPs -> [AddEpAnn] -> P (LTyFamInstEqn GhcPs)
- mkStandaloneKindSig :: SrcSpan -> Located [LocatedN RdrName] -> LHsSigType GhcPs -> [AddEpAnn] -> P (LStandaloneKindSig GhcPs)
- mkTyFamInst :: SrcSpan -> TyFamInstEqn GhcPs -> [AddEpAnn] -> P (LInstDecl GhcPs)
- mkFamDecl :: SrcSpan -> FamilyInfo GhcPs -> TopLevelFlag -> LHsType GhcPs -> LFamilyResultSig GhcPs -> Maybe (LInjectivityAnn GhcPs) -> [AddEpAnn] -> P (LTyClDecl GhcPs)
- mkInlinePragma :: SourceText -> (InlineSpec, RuleMatchInfo) -> Maybe Activation -> InlinePragma
- mkOpaquePragma :: SourceText -> InlinePragma
- mkPatSynMatchGroup :: LocatedN RdrName -> LocatedL (OrdList (LHsDecl GhcPs)) -> P (MatchGroup GhcPs (LHsExpr GhcPs))
- mkRecConstrOrUpdate :: Bool -> LHsExpr GhcPs -> SrcSpan -> ([Fbind (HsExpr GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (HsExpr GhcPs)
- mkTyClD :: forall (p :: Pass). LTyClDecl (GhcPass p) -> LHsDecl (GhcPass p)
- mkInstD :: forall (p :: Pass). LInstDecl (GhcPass p) -> LHsDecl (GhcPass p)
- mkRdrRecordCon :: LocatedN RdrName -> HsRecordBinds GhcPs -> [AddEpAnn] -> HsExpr GhcPs
- mkRdrRecordUpd :: Bool -> LHsExpr GhcPs -> [Fbind (HsExpr GhcPs)] -> [AddEpAnn] -> PV (HsExpr GhcPs)
- setRdrNameSpace :: RdrName -> NameSpace -> RdrName
- fromSpecTyVarBndr :: LHsTyVarBndr Specificity GhcPs -> P (LHsTyVarBndr () GhcPs)
- fromSpecTyVarBndrs :: [LHsTyVarBndr Specificity GhcPs] -> P [LHsTyVarBndr () GhcPs]
- annBinds :: AddEpAnn -> EpAnnComments -> HsLocalBinds GhcPs -> (HsLocalBinds GhcPs, Maybe EpAnnComments)
- fixValbindsAnn :: EpAnn AnnList -> EpAnn AnnList
- stmtsAnchor :: Located (OrdList AddEpAnn, a) -> Maybe Anchor
- stmtsLoc :: Located (OrdList AddEpAnn, a) -> SrcSpan
- cvBindGroup :: OrdList (LHsDecl GhcPs) -> P (HsValBinds GhcPs)
- cvBindsAndSigs :: OrdList (LHsDecl GhcPs) -> P (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs], [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl GhcPs])
- cvTopDecls :: OrdList (LHsDecl GhcPs) -> [LHsDecl GhcPs]
- placeHolderPunRhs :: DisambECP b => PV (LocatedA b)
- mkImport :: Located CCallConv -> Located Safety -> (Located StringLiteral, LocatedN RdrName, LHsSigType GhcPs) -> P ([AddEpAnn] -> HsDecl GhcPs)
- parseCImport :: forall (p :: Pass). LocatedE CCallConv -> LocatedE Safety -> FastString -> String -> Located SourceText -> Maybe (ForeignImport (GhcPass p))
- mkExport :: Located CCallConv -> (Located StringLiteral, LocatedN RdrName, LHsSigType GhcPs) -> P ([AddEpAnn] -> HsDecl GhcPs)
- mkExtName :: RdrName -> CLabelString
- mkGadtDecl :: SrcSpan -> NonEmpty (LocatedN RdrName) -> EpUniToken "::" "\8759" -> LHsSigType GhcPs -> P (LConDecl GhcPs)
- mkConDeclH98 :: [AddEpAnn] -> LocatedN RdrName -> Maybe [LHsTyVarBndr Specificity GhcPs] -> Maybe (LHsContext GhcPs) -> HsConDeclH98Details GhcPs -> ConDecl GhcPs
- checkImportDecl :: Maybe EpaLocation -> Maybe EpaLocation -> P ()
- checkExpBlockArguments :: LHsExpr GhcPs -> PV ()
- checkCmdBlockArguments :: LHsCmd GhcPs -> PV ()
- checkPrecP :: Located (SourceText, Int) -> Located (OrdList (LocatedN RdrName)) -> P ()
- checkContext :: LHsType GhcPs -> P (LHsContext GhcPs)
- checkPattern :: LocatedA (PatBuilder GhcPs) -> P (LPat GhcPs)
- checkPattern_details :: ParseContext -> PV (LocatedA (PatBuilder GhcPs)) -> P (LPat GhcPs)
- incompleteDoBlock :: ParseContext
- data ParseContext = ParseContext {
  - is_infix :: !(Maybe RdrName)
  - incomplete_do_block :: !PatIncompleteDoBlock
  }
- checkMonadComp :: PV HsDoFlavour
- checkValDef :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> (HsMultAnn GhcPs, Maybe (AddEpAnn, LHsType GhcPs)) -> Located (GRHSs GhcPs (LHsExpr GhcPs)) -> P (HsBind GhcPs)
- checkValSigLhs :: LHsExpr GhcPs -> P (LocatedN RdrName)
- type LRuleTyTmVar = LocatedAn NoEpAnns RuleTyTmVar
- data RuleTyTmVar = RuleTyTmVar [AddEpAnn] (LocatedN RdrName) (Maybe (LHsType GhcPs))
- mkRuleBndrs :: [LRuleTyTmVar] -> [LRuleBndr GhcPs]
- mkRuleTyVarBndrs :: [LRuleTyTmVar] -> [LHsTyVarBndr () GhcPs]
- checkRuleTyVarBndrNames :: [LHsTyVarBndr flag GhcPs] -> P ()
- checkRecordSyntax :: (MonadP m, Outputable a) => LocatedA a -> m (LocatedA a)
- checkEmptyGADTs :: Located ([AddEpAnn], [LConDecl GhcPs]) -> P (Located ([AddEpAnn], [LConDecl GhcPs]))
- addFatalError :: MonadP m => MsgEnvelope PsMessage -> m a
- hintBangPat :: SrcSpan -> Pat GhcPs -> PV ()
- mkBangTy :: [AddEpAnn] -> SrcStrictness -> LHsType GhcPs -> HsType GhcPs
- data UnpackednessPragma = UnpackednessPragma [AddEpAnn] SourceText SrcUnpackedness
- mkMultTy :: EpToken "%" -> LHsType GhcPs -> EpUniToken "->" "\8594" -> HsArrow GhcPs
- mkMultAnn :: EpToken "%" -> LHsType GhcPs -> HsMultAnn GhcPs
- mkTokenLocation :: SrcSpan -> TokenLocation
- data ImpExpSubSpec
  - = ImpExpAbs
  - | ImpExpAll
  - | ImpExpList [LocatedA ImpExpQcSpec]
  - | ImpExpAllWith [LocatedA ImpExpQcSpec]
- data ImpExpQcSpec
  - = ImpExpQcName (LocatedN RdrName)
  - | ImpExpQcType EpaLocation (LocatedN RdrName)
  - | ImpExpQcWildcard
- mkModuleImpExp :: Maybe (LWarningTxt GhcPs) -> [AddEpAnn] -> LocatedA ImpExpQcSpec -> ImpExpSubSpec -> P (IE GhcPs)
- mkTypeImpExp :: LocatedN RdrName -> P (LocatedN RdrName)
- mkImpExpSubSpec :: [LocatedA ImpExpQcSpec] -> P ([AddEpAnn], ImpExpSubSpec)
- checkImportSpec :: LocatedL [LIE GhcPs] -> P (LocatedL [LIE GhcPs])
- starSym :: Bool -> FastString
- warnStarIsType :: SrcSpan -> P ()
- warnPrepositiveQualifiedModule :: SrcSpan -> P ()
- failOpFewArgs :: MonadP m => LocatedN RdrName -> m a
- failNotEnabledImportQualifiedPost :: SrcSpan -> P ()
- failImportQualifiedTwice :: SrcSpan -> P ()
- requireExplicitNamespaces :: MonadP m => SrcSpan -> m ()
- data SumOrTuple b
  - = Sum ConTag Arity (LocatedA b) [EpaLocation] [EpaLocation]
  - | Tuple [Either (EpAnn Bool) (LocatedA b)]
- data PV a
- runPV :: PV a -> P a
- newtype ECP = ECP {
  - unECP :: forall b. DisambECP b => PV (LocatedA b)
  }
- class DisambInfixOp b where
  - mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN b)
  - mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN b)
  - mkHsInfixHolePV :: LocatedN (HsExpr GhcPs) -> PV (LocatedN b)
- class (b ~ Body b GhcPs, AnnoBody b) => DisambECP b where
  - type Body b :: Type -> Type
  - type InfixOp b
  - type FunArg b
  - ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA b)
  - ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA b)
  - mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA b -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA b))
  - mkHsLetPV :: SrcSpan -> EpToken "let" -> HsLocalBinds GhcPs -> EpToken "in" -> LocatedA b -> PV (LocatedA b)
  - superInfixOp :: (DisambInfixOp (InfixOp b) => PV (LocatedA b)) -> PV (LocatedA b)
  - mkHsOpAppPV :: SrcSpan -> LocatedA b -> LocatedN (InfixOp b) -> LocatedA b -> PV (LocatedA b)
  - mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA b)] -> EpAnnHsCase -> PV (LocatedA b)
  - mkHsLamPV :: SrcSpan -> HsLamVariant -> LocatedL [LMatch GhcPs (LocatedA b)] -> [AddEpAnn] -> PV (LocatedA b)
  - superFunArg :: (DisambECP (FunArg b) => PV (LocatedA b)) -> PV (LocatedA b)
  - mkHsAppPV :: SrcSpanAnnA -> LocatedA b -> LocatedA (FunArg b) -> PV (LocatedA b)
  - mkHsAppTypePV :: SrcSpanAnnA -> LocatedA b -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA b)
  - mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA b -> Bool -> LocatedA b -> AnnsIf -> PV (LocatedA b)
  - mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA b)] -> AnnList -> PV (LocatedA b)
  - mkHsParPV :: SrcSpan -> EpToken "(" -> LocatedA b -> EpToken ")" -> PV (LocatedA b)
  - mkHsVarPV :: LocatedN RdrName -> PV (LocatedA b)
  - mkHsLitPV :: Located (HsLit GhcPs) -> PV (LocatedA b)
  - mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a b)
  - mkHsWildCardPV :: NoAnn a => SrcSpan -> PV (LocatedAn a b)
  - mkHsTySigPV :: SrcSpanAnnA -> LocatedA b -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA b)
  - mkHsExplicitListPV :: SrcSpan -> [LocatedA b] -> AnnList -> PV (LocatedA b)
  - mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (LocatedA b)
  - mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA b -> ([Fbind b], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA b)
  - mkHsNegAppPV :: SrcSpan -> LocatedA b -> [AddEpAnn] -> PV (LocatedA b)
  - mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp b) -> LocatedA b -> PV (LocatedA b)
  - mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA b -> [AddEpAnn] -> PV (LocatedA b)
  - mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> EpToken "@" -> LocatedA b -> PV (LocatedA b)
  - mkHsLazyPatPV :: SrcSpan -> LocatedA b -> [AddEpAnn] -> PV (LocatedA b)
  - mkHsBangPatPV :: SrcSpan -> LocatedA b -> [AddEpAnn] -> PV (LocatedA b)
  - mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple b -> [AddEpAnn] -> PV (LocatedA b)
  - mkHsEmbTyPV :: SrcSpan -> EpToken "type" -> LHsType GhcPs -> PV (LocatedA b)
  - rejectPragmaPV :: LocatedA b -> PV ()
- ecpFromExp :: LHsExpr GhcPs -> ECP
- ecpFromCmd :: LHsCmd GhcPs -> ECP
- data PatBuilder p
- hsHoleExpr :: Maybe EpAnnUnboundVar -> HsExpr GhcPs
- class DisambTD b where
  - mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA b)
  - mkHsAppTyPV :: LocatedA b -> LHsType GhcPs -> PV (LocatedA b)
  - mkHsAppKindTyPV :: LocatedA b -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA b)
  - mkHsOpTyPV :: PromotionFlag -> LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA b)
  - mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA b -> PV (LocatedA b)
- addUnpackednessP :: MonadP m => Located UnpackednessPragma -> LHsType GhcPs -> m (LHsType GhcPs)
- dataConBuilderCon :: LocatedA DataConBuilder -> LocatedN RdrName
- dataConBuilderDetails :: LocatedA DataConBuilder -> HsConDeclH98Details GhcPs
- mkUnboxedSumCon :: LHsType GhcPs -> ConTag -> Arity -> (LocatedN RdrName, HsConDeclH98Details GhcPs)
- mkTupleSyntaxTy :: EpaLocation -> [LocatedA (HsType GhcPs)] -> EpaLocation -> P (HsType GhcPs)
- mkTupleSyntaxTycon :: Boxity -> Int -> P RdrName
- mkListSyntaxTy0 :: EpaLocation -> EpaLocation -> SrcSpan -> P (HsType GhcPs)
- mkListSyntaxTy1 :: EpaLocation -> LocatedA (HsType GhcPs) -> EpaLocation -> P (HsType GhcPs)
- withCombinedComments :: (HasLoc l1, HasLoc l2) => l1 -> l2 -> (SrcSpan -> P a) -> P (LocatedA a)
- requireLTPuns :: PsErrPunDetails -> Located a -> Located b -> P ()

# Documentation

mkRdrGetField :: LHsExpr GhcPs -> LocatedAn NoEpAnns (DotFieldOcc GhcPs) -> HsExpr GhcPs #

mkRdrProjection :: NonEmpty (LocatedAn NoEpAnns (DotFieldOcc GhcPs)) -> AnnProjection -> HsExpr GhcPs #

type Fbind b = Either (LHsRecField GhcPs (LocatedA b)) (LHsRecProj GhcPs (LocatedA b)) #

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 :: HsDoFlavour -> LocatedL [ExprLStmt GhcPs] -> HsExpr GhcPs #

mkSpliceDecl :: LHsExpr GhcPs -> LHsDecl GhcPs #

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

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

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

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

mkTySynonym :: SrcSpan -> LHsType GhcPs -> LHsType GhcPs -> [AddEpAnn] -> P (LTyClDecl GhcPs) #

mkTyFamInstEqn :: SrcSpan -> HsOuterFamEqnTyVarBndrs GhcPs -> LHsType GhcPs -> LHsType GhcPs -> [AddEpAnn] -> P (LTyFamInstEqn GhcPs) #

mkStandaloneKindSig :: SrcSpan -> Located [LocatedN RdrName] -> LHsSigType GhcPs -> [AddEpAnn] -> P (LStandaloneKindSig GhcPs) #

mkTyFamInst :: SrcSpan -> TyFamInstEqn GhcPs -> [AddEpAnn] -> P (LInstDecl GhcPs) #

mkFamDecl :: SrcSpan -> FamilyInfo GhcPs -> TopLevelFlag -> LHsType GhcPs -> LFamilyResultSig GhcPs -> Maybe (LInjectivityAnn GhcPs) -> [AddEpAnn] -> P (LTyClDecl GhcPs) #

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

mkOpaquePragma :: SourceText -> InlinePragma #

mkPatSynMatchGroup :: LocatedN RdrName -> LocatedL (OrdList (LHsDecl GhcPs)) -> P (MatchGroup GhcPs (LHsExpr GhcPs)) #

mkRecConstrOrUpdate :: Bool -> LHsExpr GhcPs -> SrcSpan -> ([Fbind (HsExpr GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (HsExpr GhcPs) #

mkTyClD :: forall (p :: Pass). 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 :: forall (p :: Pass). LInstDecl (GhcPass p) -> LHsDecl (GhcPass p) #

mkRdrRecordCon :: LocatedN RdrName -> HsRecordBinds GhcPs -> [AddEpAnn] -> HsExpr GhcPs #

mkRdrRecordUpd :: Bool -> LHsExpr GhcPs -> [Fbind (HsExpr GhcPs)] -> [AddEpAnn] -> PV (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.

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 `LHsTyVarBndr`s annotated with their `Specificity` to binders without annotations. Only accepts specified variables, and errors if any of the provided binders has an `InferredSpec` annotation.

annBinds :: AddEpAnn -> EpAnnComments -> HsLocalBinds GhcPs -> (HsLocalBinds GhcPs, Maybe EpAnnComments) #

Add the annotation for a 'where' keyword to existing `HsLocalBinds`

fixValbindsAnn :: EpAnn AnnList -> EpAnn AnnList #

stmtsAnchor :: Located (OrdList AddEpAnn, a) -> Maybe Anchor #

The `Anchor` for a stmtlist is based on either the location or the first semicolon annotion.

stmtsLoc :: Located (OrdList AddEpAnn, a) -> SrcSpan #

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

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

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 (LocatedA b) #

mkImport :: Located CCallConv -> Located Safety -> (Located StringLiteral, LocatedN RdrName, LHsSigType GhcPs) -> P ([AddEpAnn] -> HsDecl GhcPs) #

parseCImport :: forall (p :: Pass). LocatedE CCallConv -> LocatedE Safety -> FastString -> String -> Located SourceText -> Maybe (ForeignImport (GhcPass p)) #

mkExport :: Located CCallConv -> (Located StringLiteral, LocatedN RdrName, LHsSigType GhcPs) -> P ([AddEpAnn] -> HsDecl GhcPs) #

mkExtName :: RdrName -> CLabelString #

mkGadtDecl :: SrcSpan -> NonEmpty (LocatedN RdrName) -> EpUniToken "::" "\8759" -> LHsSigType GhcPs -> P (LConDecl GhcPs) #

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 :: [AddEpAnn] -> LocatedN RdrName -> Maybe [LHsTyVarBndr Specificity GhcPs] -> Maybe (LHsContext GhcPs) -> HsConDeclH98Details GhcPs -> ConDecl GhcPs #

checkImportDecl :: Maybe EpaLocation -> Maybe EpaLocation -> 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 (LocatedN RdrName)) | operators
-> P () |

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

checkContext :: LHsType GhcPs -> P (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 :: LocatedA (PatBuilder GhcPs) -> P (LPat GhcPs) #

checkPattern_details :: ParseContext -> PV (LocatedA (PatBuilder GhcPs)) -> P (LPat GhcPs) #

incompleteDoBlock :: ParseContext #

data ParseContext #

Extra information for the expression GHC is currently inspecting/parsing. It can be used to generate more informative parser diagnostics and hints.

Constructors

ParseContext |

Fields

- is_infix :: !(Maybe RdrName)

  If `Just`, this is an infix pattern with the bound operator name

- incomplete_do_block :: !PatIncompleteDoBlock

  Did the parser likely fail due to an incomplete do block?

#### Instances

Instances details

Eq ParseContext # |
Instance details Defined in GHC.Parser.Errors.Types Methods (==) :: ParseContext -> ParseContext -> Bool # (/=) :: ParseContext -> ParseContext -> Bool #

checkMonadComp :: PV HsDoFlavour #

Check for monad comprehensions

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

checkValDef :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> (HsMultAnn GhcPs, Maybe (AddEpAnn, LHsType GhcPs)) -> Located (GRHSs GhcPs (LHsExpr GhcPs)) -> P (HsBind GhcPs) #

checkValSigLhs :: LHsExpr GhcPs -> P (LocatedN RdrName) #

type LRuleTyTmVar = LocatedAn NoEpAnns RuleTyTmVar #

data RuleTyTmVar #

Essentially a wrapper for a `RuleBndr GhcPs`

Constructors

RuleTyTmVar [AddEpAnn] (LocatedN RdrName) (Maybe (LHsType GhcPs)) |

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

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

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

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

checkEmptyGADTs :: Located ([AddEpAnn], [LConDecl GhcPs]) -> P (Located ([AddEpAnn], [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 => MsgEnvelope PsMessage -> 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.

mkBangTy :: [AddEpAnn] -> SrcStrictness -> LHsType GhcPs -> HsType GhcPs #

data UnpackednessPragma #

Result of parsing `{-# UNPACK #-}` or `{-# NOUNPACK #-}`.

Constructors

UnpackednessPragma [AddEpAnn] SourceText SrcUnpackedness |

mkMultTy :: EpToken "%" -> LHsType GhcPs -> EpUniToken "->" "\8594" -> HsArrow GhcPs #

mkMultAnn :: EpToken "%" -> LHsType GhcPs -> HsMultAnn GhcPs #

mkTokenLocation :: SrcSpan -> TokenLocation #

data ImpExpSubSpec #

Constructors

ImpExpAbs |
ImpExpAll |
ImpExpList [LocatedA ImpExpQcSpec] |
ImpExpAllWith [LocatedA ImpExpQcSpec] |

data ImpExpQcSpec #

Constructors

ImpExpQcName (LocatedN RdrName) |
ImpExpQcType EpaLocation (LocatedN RdrName) |
ImpExpQcWildcard |

mkModuleImpExp :: Maybe (LWarningTxt GhcPs) -> [AddEpAnn] -> LocatedA ImpExpQcSpec -> ImpExpSubSpec -> P (IE GhcPs) #

mkTypeImpExp :: LocatedN RdrName -> P (LocatedN RdrName) #

mkImpExpSubSpec :: [LocatedA ImpExpQcSpec] -> P ([AddEpAnn], ImpExpSubSpec) #

checkImportSpec :: LocatedL [LIE GhcPs] -> P (LocatedL [LIE GhcPs]) #

starSym :: Bool -> FastString #

warnStarIsType :: SrcSpan -> P () #

warnPrepositiveQualifiedModule :: SrcSpan -> P () #

failOpFewArgs :: MonadP m => LocatedN RdrName -> m a #

failNotEnabledImportQualifiedPost :: SrcSpan -> P () #

failImportQualifiedTwice :: SrcSpan -> P () #

requireExplicitNamespaces :: MonadP m => SrcSpan -> m () #

data SumOrTuple b #

Constructors

Sum ConTag Arity (LocatedA b) [EpaLocation] [EpaLocation] | Last two are the locations of the '|' before and after the payload
Tuple [Either (EpAnn Bool) (LocatedA b)] |

data PV a #

#### Instances

Instances details

Applicative PV # |
Instance details 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 #
Functor PV # |
Instance details Defined in GHC.Parser.PostProcess Methods fmap :: (a -> b) -> PV a -> PV b # (<$) :: a -> PV b -> PV a #
Monad PV # |
Instance details Defined in GHC.Parser.PostProcess Methods (>>=) :: PV a -> (a -> PV b) -> PV b # (>>) :: PV a -> PV b -> PV b # return :: a -> PV a #
MonadP PV # |

Instance details

Defined in GHC.Parser.PostProcess

Methods

addError :: MsgEnvelope PsMessage -> PV () #

addWarning :: MsgEnvelope PsMessage -> PV () #

addFatalError :: MsgEnvelope PsMessage -> PV a #

getBit :: ExtBits -> PV Bool #

allocateCommentsP :: RealSrcSpan -> PV EpAnnComments #

allocatePriorCommentsP :: RealSrcSpan -> PV EpAnnComments #

allocateFinalCommentsP :: RealSrcSpan -> PV EpAnnComments #

runPV :: PV a -> P a #

newtype ECP #

Constructors

ECP |

Fields

- unECP :: forall b. DisambECP b => PV (LocatedA b)

class DisambInfixOp b where #

Disambiguate infix operators. See Note [Ambiguous syntactic categories]

Methods

mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN b) #

mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN b) #

mkHsInfixHolePV :: LocatedN (HsExpr GhcPs) -> PV (LocatedN b) #

#### Instances

Instances details

DisambInfixOp RdrName # |
Instance details Defined in GHC.Parser.PostProcess Methods mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN RdrName) # mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN RdrName) # mkHsInfixHolePV :: LocatedN (HsExpr GhcPs) -> PV (LocatedN RdrName) #
DisambInfixOp (HsExpr GhcPs) # |
Instance details Defined in GHC.Parser.PostProcess Methods mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs)) # mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs)) # mkHsInfixHolePV :: LocatedN (HsExpr GhcPs) -> PV (LocatedN (HsExpr GhcPs)) #

class (b ~ Body b GhcPs, AnnoBody b) => 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 (LocatedA b) #

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

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA b) #

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

mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA b -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA b)) #

mkHsLetPV :: SrcSpan -> EpToken "let" -> HsLocalBinds GhcPs -> EpToken "in" -> LocatedA b -> PV (LocatedA b) #

Disambiguate "let ... in ..."

superInfixOp :: (DisambInfixOp (InfixOp b) => PV (LocatedA b)) -> PV (LocatedA b) #

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

mkHsOpAppPV :: SrcSpan -> LocatedA b -> LocatedN (InfixOp b) -> LocatedA b -> PV (LocatedA b) #

Disambiguate "f # x" (infix operator)

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA b)] -> EpAnnHsCase -> PV (LocatedA b) #

Disambiguate "case ... of ..."

mkHsLamPV :: SrcSpan -> HsLamVariant -> LocatedL [LMatch GhcPs (LocatedA b)] -> [AddEpAnn] -> PV (LocatedA b) #

Disambiguate "... -> ..." (lambda), "case" and "cases"

superFunArg :: (DisambECP (FunArg b) => PV (LocatedA b)) -> PV (LocatedA b) #

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

mkHsAppPV :: SrcSpanAnnA -> LocatedA b -> LocatedA (FunArg b) -> PV (LocatedA b) #

Disambiguate "f x" (function application)

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA b -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA b) #

Disambiguate "f @t" (visible type application)

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA b -> Bool -> LocatedA b -> AnnsIf -> PV (LocatedA b) #

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

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA b)] -> AnnList -> PV (LocatedA b) #

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

mkHsParPV :: SrcSpan -> EpToken "(" -> LocatedA b -> EpToken ")" -> PV (LocatedA b) #

Disambiguate "( ... )" (parentheses)

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA b) #

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

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

Disambiguate a monomorphic literal

mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a b) #

Disambiguate an overloaded literal

mkHsWildCardPV :: NoAnn a => SrcSpan -> PV (LocatedAn a b) #

Disambiguate a wildcard

mkHsTySigPV :: SrcSpanAnnA -> LocatedA b -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA b) #

Disambiguate "a :: t" (type annotation)

mkHsExplicitListPV :: SrcSpan -> [LocatedA b] -> AnnList -> PV (LocatedA b) #

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

mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (LocatedA b) #

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

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA b -> ([Fbind b], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA b) #

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

mkHsNegAppPV :: SrcSpan -> LocatedA b -> [AddEpAnn] -> PV (LocatedA b) #

Disambiguate "-a" (negation)

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp b) -> LocatedA b -> PV (LocatedA b) #

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

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA b -> [AddEpAnn] -> PV (LocatedA b) #

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

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> EpToken "@" -> LocatedA b -> PV (LocatedA b) #

Disambiguate "a@b" (as-pattern)

mkHsLazyPatPV :: SrcSpan -> LocatedA b -> [AddEpAnn] -> PV (LocatedA b) #

Disambiguate "~a" (lazy pattern)

mkHsBangPatPV :: SrcSpan -> LocatedA b -> [AddEpAnn] -> PV (LocatedA b) #

Disambiguate "!a" (bang pattern)

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple b -> [AddEpAnn] -> PV (LocatedA b) #

Disambiguate tuple sections and unboxed sums

mkHsEmbTyPV :: SrcSpan -> EpToken "type" -> LHsType GhcPs -> PV (LocatedA b) #

Disambiguate "type t" (embedded type)

rejectPragmaPV :: LocatedA b -> PV () #

Validate infixexp LHS to reject unwanted {-# SCC ... #-} pragmas

#### Instances

Instances details

DisambECP (PatBuilder GhcPs) # |

Instance details

Defined in GHC.Parser.PostProcess

Associated Types

type Body (PatBuilder GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type Body (PatBuilder GhcPs) = PatBuilder
type InfixOp (PatBuilder GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type InfixOp (PatBuilder GhcPs) = RdrName
type FunArg (PatBuilder GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (PatBuilder GhcPs)) #

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (PatBuilder GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (PatBuilder GhcPs))) #

mkHsLetPV :: SrcSpan -> EpToken "let" -> HsLocalBinds GhcPs -> EpToken "in" -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

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

mkHsOpAppPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> LocatedN (InfixOp (PatBuilder GhcPs)) -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (PatBuilder GhcPs))] -> EpAnnHsCase -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsLamPV :: SrcSpan -> HsLamVariant -> LocatedL [LMatch GhcPs (LocatedA (PatBuilder GhcPs))] -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

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

mkHsAppPV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LocatedA (FunArg (PatBuilder GhcPs)) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (PatBuilder GhcPs) -> Bool -> LocatedA (PatBuilder GhcPs) -> AnnsIf -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (PatBuilder GhcPs))] -> AnnList -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsParPV :: SrcSpan -> EpToken "(" -> LocatedA (PatBuilder GhcPs) -> EpToken ")" -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (PatBuilder GhcPs)) #

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

mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (PatBuilder GhcPs)) #

mkHsWildCardPV :: NoAnn a => SrcSpan -> PV (LocatedAn a (PatBuilder GhcPs)) #

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsExplicitListPV :: SrcSpan -> [LocatedA (PatBuilder GhcPs)] -> AnnList -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (PatBuilder GhcPs) -> ([Fbind (PatBuilder GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsNegAppPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (PatBuilder GhcPs)) -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> EpToken "@" -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsLazyPatPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsBangPatPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsEmbTyPV :: SrcSpan -> EpToken "type" -> LHsType GhcPs -> PV (LocatedA (PatBuilder GhcPs)) #

rejectPragmaPV :: LocatedA (PatBuilder GhcPs) -> PV () #

DisambECP (HsCmd GhcPs) # |

Instance details

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsCmd GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type Body (HsCmd GhcPs) = HsCmd
type InfixOp (HsCmd GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type InfixOp (HsCmd GhcPs) = HsExpr GhcPs
type FunArg (HsCmd GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type FunArg (HsCmd GhcPs) = HsExpr GhcPs

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsCmd GhcPs)) #

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsCmd GhcPs)) #

mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (HsCmd GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsCmd GhcPs))) #

mkHsLetPV :: SrcSpan -> EpToken "let" -> HsLocalBinds GhcPs -> EpToken "in" -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) #

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

mkHsOpAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> LocatedN (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsCmd GhcPs)) #

mkHsLamPV :: SrcSpan -> HsLamVariant -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) #

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

mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LocatedA (FunArg (HsCmd GhcPs)) -> PV (LocatedA (HsCmd GhcPs)) #

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA (HsCmd GhcPs)) #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsCmd GhcPs) -> Bool -> LocatedA (HsCmd GhcPs) -> AnnsIf -> PV (LocatedA (HsCmd GhcPs)) #

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsCmd GhcPs))] -> AnnList -> PV (LocatedA (HsCmd GhcPs)) #

mkHsParPV :: SrcSpan -> EpToken "(" -> LocatedA (HsCmd GhcPs) -> EpToken ")" -> PV (LocatedA (HsCmd GhcPs)) #

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsCmd GhcPs)) #

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

mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (HsCmd GhcPs)) #

mkHsWildCardPV :: NoAnn a => SrcSpan -> PV (LocatedAn a (HsCmd GhcPs)) #

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) #

mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsCmd GhcPs)] -> AnnList -> PV (LocatedA (HsCmd GhcPs)) #

mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (LocatedA (HsCmd GhcPs)) #

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsCmd GhcPs) -> ([Fbind (HsCmd GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) #

mkHsNegAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) #

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) #

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> EpToken "@" -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) #

mkHsLazyPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) #

mkHsBangPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) #

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) #

mkHsEmbTyPV :: SrcSpan -> EpToken "type" -> LHsType GhcPs -> PV (LocatedA (HsCmd GhcPs)) #

rejectPragmaPV :: LocatedA (HsCmd GhcPs) -> PV () #

DisambECP (HsExpr GhcPs) # |

Instance details

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsExpr GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type Body (HsExpr GhcPs) = HsExpr
type InfixOp (HsExpr GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type InfixOp (HsExpr GhcPs) = HsExpr GhcPs
type FunArg (HsExpr GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type FunArg (HsExpr GhcPs) = HsExpr GhcPs

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsExpr GhcPs)) #

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsExpr GhcPs)) #

mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (HsExpr GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsExpr GhcPs))) #

mkHsLetPV :: SrcSpan -> EpToken "let" -> HsLocalBinds GhcPs -> EpToken "in" -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

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

mkHsOpAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> LocatedN (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsExpr GhcPs)) #

mkHsLamPV :: SrcSpan -> HsLamVariant -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

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

mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LocatedA (FunArg (HsExpr GhcPs)) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA (HsExpr GhcPs)) #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsExpr GhcPs) -> Bool -> LocatedA (HsExpr GhcPs) -> AnnsIf -> PV (LocatedA (HsExpr GhcPs)) #

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsExpr GhcPs))] -> AnnList -> PV (LocatedA (HsExpr GhcPs)) #

mkHsParPV :: SrcSpan -> EpToken "(" -> LocatedA (HsExpr GhcPs) -> EpToken ")" -> PV (LocatedA (HsExpr GhcPs)) #

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsExpr GhcPs)) #

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

mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (HsExpr GhcPs)) #

mkHsWildCardPV :: NoAnn a => SrcSpan -> PV (LocatedAn a (HsExpr GhcPs)) #

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsExpr GhcPs)] -> AnnList -> PV (LocatedA (HsExpr GhcPs)) #

mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsExpr GhcPs) -> ([Fbind (HsExpr GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsNegAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> EpToken "@" -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsLazyPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsBangPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsEmbTyPV :: SrcSpan -> EpToken "type" -> LHsType GhcPs -> PV (LocatedA (HsExpr GhcPs)) #

rejectPragmaPV :: LocatedA (HsExpr GhcPs) -> PV () #

ecpFromExp :: LHsExpr GhcPs -> ECP #

ecpFromCmd :: LHsCmd GhcPs -> ECP #

data PatBuilder p #

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

#### Instances

Instances details

DisambECP (PatBuilder GhcPs) # |

Instance details

Defined in GHC.Parser.PostProcess

Associated Types

type Body (PatBuilder GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type Body (PatBuilder GhcPs) = PatBuilder
type InfixOp (PatBuilder GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type InfixOp (PatBuilder GhcPs) = RdrName
type FunArg (PatBuilder GhcPs) |
Instance details Defined in GHC.Parser.PostProcess type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (PatBuilder GhcPs)) #

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (PatBuilder GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (PatBuilder GhcPs))) #

mkHsLetPV :: SrcSpan -> EpToken "let" -> HsLocalBinds GhcPs -> EpToken "in" -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

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

mkHsOpAppPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> LocatedN (InfixOp (PatBuilder GhcPs)) -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (PatBuilder GhcPs))] -> EpAnnHsCase -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsLamPV :: SrcSpan -> HsLamVariant -> LocatedL [LMatch GhcPs (LocatedA (PatBuilder GhcPs))] -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

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

mkHsAppPV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LocatedA (FunArg (PatBuilder GhcPs)) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (PatBuilder GhcPs) -> Bool -> LocatedA (PatBuilder GhcPs) -> AnnsIf -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (PatBuilder GhcPs))] -> AnnList -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsParPV :: SrcSpan -> EpToken "(" -> LocatedA (PatBuilder GhcPs) -> EpToken ")" -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (PatBuilder GhcPs)) #

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

mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (PatBuilder GhcPs)) #

mkHsWildCardPV :: NoAnn a => SrcSpan -> PV (LocatedAn a (PatBuilder GhcPs)) #

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsExplicitListPV :: SrcSpan -> [LocatedA (PatBuilder GhcPs)] -> AnnList -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (PatBuilder GhcPs) -> ([Fbind (PatBuilder GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsNegAppPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (PatBuilder GhcPs)) -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> EpToken "@" -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsLazyPatPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsBangPatPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) #

mkHsEmbTyPV :: SrcSpan -> EpToken "type" -> LHsType GhcPs -> PV (LocatedA (PatBuilder GhcPs)) #

rejectPragmaPV :: LocatedA (PatBuilder GhcPs) -> PV () #

Outputable (PatBuilder GhcPs) # |
Instance details Defined in GHC.Parser.Types Methods ppr :: PatBuilder GhcPs -> SDoc #
type Body (PatBuilder GhcPs) # |
Instance details Defined in GHC.Parser.PostProcess type Body (PatBuilder GhcPs) = PatBuilder
type FunArg (PatBuilder GhcPs) # |
Instance details Defined in GHC.Parser.PostProcess type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs
type InfixOp (PatBuilder GhcPs) # |
Instance details Defined in GHC.Parser.PostProcess type InfixOp (PatBuilder GhcPs) = RdrName
type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] # |
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] # |
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) # |
Instance details Defined in GHC.Parser.Types type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = EpAnnCO
type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) # |
Instance details Defined in GHC.Parser.Types type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) # |
Instance details Defined in GHC.Parser.Types type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

hsHoleExpr :: Maybe EpAnnUnboundVar -> HsExpr GhcPs #

class DisambTD b where #

Disambiguate constructs that may appear when we do not know ahead of time whether we are parsing a type or a newtype/data constructor.

See Note [Ambiguous syntactic categories] for the general idea.

See Note [Parsing data constructors is hard] for the specific issue this particular class is solving.

Methods

mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA b) #

Process the head of a type-level function/constructor application, i.e. the `H` in `H a b c`.

mkHsAppTyPV :: LocatedA b -> LHsType GhcPs -> PV (LocatedA b) #

Disambiguate `f x` (function application or prefix data constructor).

mkHsAppKindTyPV :: LocatedA b -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA b) #

Disambiguate `f @t` (visible kind application)

mkHsOpTyPV :: PromotionFlag -> LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA b) #

Disambiguate `f # x` (infix operator)

mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA b -> PV (LocatedA b) #

Disambiguate `{-# UNPACK #-} t` (unpack/nounpack pragma)

#### Instances

Instances details

DisambTD DataConBuilder # |

Instance details

Defined in GHC.Parser.PostProcess

Methods

mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA DataConBuilder) #

mkHsAppTyPV :: LocatedA DataConBuilder -> LHsType GhcPs -> PV (LocatedA DataConBuilder) #

mkHsAppKindTyPV :: LocatedA DataConBuilder -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA DataConBuilder) #

mkHsOpTyPV :: PromotionFlag -> LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA DataConBuilder) #

mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA DataConBuilder -> PV (LocatedA DataConBuilder) #

DisambTD (HsType GhcPs) # |

Instance details

Defined in GHC.Parser.PostProcess

Methods

mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) #

mkHsAppTyPV :: LocatedA (HsType GhcPs) -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) #

mkHsAppKindTyPV :: LocatedA (HsType GhcPs) -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) #

mkHsOpTyPV :: PromotionFlag -> LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) #

mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA (HsType GhcPs) -> PV (LocatedA (HsType GhcPs)) #

addUnpackednessP :: MonadP m => Located UnpackednessPragma -> LHsType GhcPs -> m (LHsType GhcPs) #

Annotate a type with either an `{-# UNPACK #-}` or a `{-# NOUNPACK #-}` pragma.

dataConBuilderCon :: LocatedA DataConBuilder -> LocatedN RdrName #

dataConBuilderDetails :: LocatedA DataConBuilder -> HsConDeclH98Details GhcPs #

mkUnboxedSumCon :: LHsType GhcPs -> ConTag -> Arity -> (LocatedN RdrName, HsConDeclH98Details GhcPs) #

mkTupleSyntaxTy :: EpaLocation -> [LocatedA (HsType GhcPs)] -> EpaLocation -> P (HsType GhcPs) #

Decide whether to parse tuple syntax `(Int, Double)` in a type as a type or data constructor, based on the extension `ListTuplePuns`. The case with an explicit promotion quote, `'(Int, Double)`, is handled by `mkExplicitTupleTy`.

mkTupleSyntaxTycon :: Boxity -> Int -> P RdrName #

Decide whether to parse tuple con syntax `(,)` in a type as a type or data constructor, based on the extension `ListTuplePuns`. The case with an explicit promotion quote, `'(,)`, is handled by the rule `SIMPLEQUOTE sysdcon_nolist` in `atype`.

mkListSyntaxTy0 :: EpaLocation -> EpaLocation -> SrcSpan -> P (HsType GhcPs) #

Decide whether to parse list tycon syntax `[]` in a type as a type or data constructor, based on the extension `ListTuplePuns`. The case with an explicit promotion quote, `'[]`, is handled by `mkExplicitListTy`.

mkListSyntaxTy1 :: EpaLocation -> LocatedA (HsType GhcPs) -> EpaLocation -> P (HsType GhcPs) #

Decide whether to parse list type syntax `[Int]` in a type as a type or data constructor, based on the extension `ListTuplePuns`. The case with an explicit promotion quote, `'[Int]`, is handled by `mkExplicitListTy`.

withCombinedComments :: (HasLoc l1, HasLoc l2) => l1 -> l2 -> (SrcSpan -> P a) -> P (LocatedA a) #

Call a parser with a span and its comments given by a start and end token.

requireLTPuns :: PsErrPunDetails -> Located a -> Located b -> P () #

Emit an error of type `PsErrInvalidPun` with a location from `start` to `end` if the extension `ListTuplePuns` is disabled.

This is used in Parser.y to guard rules that require punning.