GHC.Parser.PostProcess

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

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).

This rather gruesome function is used mainly by the parser.

Case #1. 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.

Case #2. When parsing:

x = fn (forall a. a)   -- RequiredTypeArguments

we use setRdrNameSpace to set the namespace of forall-bound variables.

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

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.

Add the annotation for a where keyword to existing HsLocalBinds

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

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

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.

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

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

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]

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

Check for monad comprehensions

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

Essentially a wrapper for a RuleBndr GhcPs

Deal with both old-form and new-form specialise pragmas, using the new SpecSigE form unless there are multiple comma-separated type signatures, in which case we use the old-form.

See Note [Overview of SPECIALISE pragmas] in GHC.Tc.Gen.Sig.

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

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.

Hint about bang patterns, assuming BangPatterns is off.

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

Disambiguate infix operators. See Note [Ambiguous syntactic categories]

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]

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

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.

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

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.

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.

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.

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.

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

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.