Language.Haskell.Liquid.GHC.Misc

This module contains a wrappers and utility functions for accessing GHC module information. It should NEVER depend on ANY module inside the Language.Haskell.Liquid.* tree.

Documentation

isAnonBinder :: TyConBinder -> Bool

mkAlive :: Var -> Id

tickSrcSpan :: CoreTickish -> SrcSpan

Encoding and Decoding Location --------------------------------------------

stringTyVar :: String -> TyVar

Generic Helpers for Accessing GHC Innards ---------------------------------

stringVar :: String -> Type -> Var

maybeAuxVar :: Symbol -> Maybe Var

stringTyCon :: Char -> Int -> String -> TyCon

stringTyConWithKind :: Kind -> Char -> Int -> String -> TyCon

hasBaseTypeVar :: Var -> Bool

isBaseType :: Type -> Bool

isTmpVar :: Var -> Bool

isTmpSymbol :: Symbol -> Bool

validTyVar :: String -> Bool

tvId :: TyVar -> String

tidyCBs :: [CoreBind] -> [CoreBind]

unTick :: CoreBind -> CoreBind

unTickExpr :: CoreExpr -> CoreExpr

isFractionalClass :: Class -> Bool

isOrdClass :: Class -> Bool

notracePpr :: Outputable a => String -> a -> a

Pretty Printers -----------------------------------------------------------

tracePpr :: Outputable a => String -> a -> a

pprShow :: Show a => a -> SDoc

toFixSDoc :: Fixpoint a => a -> Doc

sDocDoc :: SDoc -> Doc

pprDoc :: Outputable a => a -> Doc

showPpr :: Outputable a => a -> String

showSDoc :: SDoc -> String

myQualify :: PrintUnqualified

showSDocDump :: SDoc -> String

typeUniqueString :: Outputable a => a -> String

newtype Loc

Manipulating Source Spans -------------------------------------------------

Constructors

L (Int, Int)

Instances

ToJSON Loc

Defined in Language.Haskell.Liquid.UX.Annotate

Methods

toJSON :: Loc -> Value

toEncoding :: Loc -> Encoding

toJSONList :: [Loc] -> Value

toEncodingList :: [Loc] -> Encoding

Show Loc

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

showsPrec :: Int -> Loc -> ShowS

show :: Loc -> String

showList :: [Loc] -> ShowS

Eq Loc

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

(==) :: Loc -> Loc -> Bool

(/=) :: Loc -> Loc -> Bool

Ord Loc

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

compare :: Loc -> Loc -> Ordering

(<) :: Loc -> Loc -> Bool

(<=) :: Loc -> Loc -> Bool

(>) :: Loc -> Loc -> Bool

(>=) :: Loc -> Loc -> Bool

max :: Loc -> Loc -> Loc

min :: Loc -> Loc -> Loc

Hashable Loc

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

hashWithSalt :: Int -> Loc -> Int

hash :: Loc -> Int

fSrcSpan :: Loc a => a -> SrcSpan

fSourcePos :: Loc a => a -> SourcePos

fSrcSpanSrcSpan :: SrcSpan -> SrcSpan

srcSpanFSrcSpan :: SrcSpan -> SrcSpan

sourcePos2SrcSpan :: SourcePos -> SourcePos -> SrcSpan

sourcePosSrcSpan :: SourcePos -> SrcSpan

sourcePosSrcLoc :: SourcePos -> SrcLoc

srcSpanSourcePos :: SrcSpan -> SourcePos

srcSpanSourcePosE :: SrcSpan -> SourcePos

srcSpanFilename :: SrcSpan -> String

srcSpanStartLoc :: RealSrcSpan -> Loc

srcSpanEndLoc :: RealSrcSpan -> Loc

oneLine :: RealSrcSpan -> Bool

lineCol :: RealSrcSpan -> (Int, Int)

realSrcSpanSourcePos :: RealSrcSpan -> SourcePos

realSrcLocSourcePos :: RealSrcLoc -> SourcePos

realSrcSpanSourcePosE :: RealSrcSpan -> SourcePos

getSourcePos :: NamedThing a => a -> SourcePos

getSourcePosE :: NamedThing a => a -> SourcePos

locNamedThing :: NamedThing a => a -> Located a

namedLocSymbol :: (Symbolic a, NamedThing a) => a -> Located Symbol

varLocInfo :: (Type -> a) -> Var -> Located a

namedPanic :: NamedThing a => a -> String -> b

collectArguments :: Int -> CoreExpr -> [Var]

Manipulating CoreExpr -----------------------------------------------------

collectValBinders' :: Expr Var -> ([Var], Expr Var)

ignoreLetBinds :: Expr t -> Expr t

isExternalId :: Id -> Bool

Predicates on CoreExpr and DataCons ---------------------------------------

isTupleId :: Id -> Bool

idDataConM :: Id -> Maybe DataCon

isDataConId :: Id -> Bool

getDataConVarUnique :: Var -> Unique

isDictionaryExpression :: Expr Id -> Maybe Id

realTcArity :: TyCon -> Arity

kindTCArity :: TyCon -> Arity

kindArity :: Kind -> Arity

uniqueHash :: Uniquable a => Int -> a -> Int

lookupRdrName :: HscEnv -> ModuleName -> RdrName -> IO (Maybe Name)

ignoreInline :: ParsedModule -> ParsedModule

symbolTyConWithKind :: Kind -> Char -> Int -> Symbol -> TyCon

Symbol Conversions --------------------------------------------------------

symbolTyCon :: Char -> Int -> Symbol -> TyCon

symbolTyVar :: Symbol -> TyVar

localVarSymbol :: Var -> Symbol

exportedVarSymbol :: Var -> Symbol

qualifiedNameSymbol :: Name -> Symbol

fastStringText :: FastString -> Text

tyConTyVarsDef :: TyCon -> [TyVar]

noTyVars :: TyCon -> Bool

takeModuleUnique :: Symbol -> Symbol

Manipulating Symbols ------------------------------------------------------

splitModuleUnique :: Symbol -> (Symbol, Int)

base62ToI :: Symbol -> Int

splitModuleName :: Symbol -> (Symbol, Symbol)

dropModuleNamesAndUnique :: Symbol -> Symbol

dropModuleNames :: Symbol -> Symbol

dropModuleNamesCorrect :: Symbol -> Symbol

takeModuleNames :: Symbol -> Symbol

dropModuleUnique :: Symbol -> Symbol

cmpSymbol :: Symbol -> Symbol -> Bool

sepModNames :: Text

sepUnique :: Text

mungeNames :: (String -> [Text] -> Symbol) -> Text -> String -> Symbol -> Symbol

qualifySymbol :: Symbol -> Symbol -> Symbol

isQualifiedSym :: Symbol -> Bool

isQualified :: Text -> Bool

wrapParens :: (IsString a, Monoid a) => a -> a

isParened :: Text -> Bool

isDictionary :: Symbolic a => a -> Bool

isMethod :: Symbolic a => a -> Bool

isInternal :: Symbolic a => a -> Bool

isWorker :: Symbolic a => a -> Bool

isSCSel :: Symbolic a => a -> Bool

stripParens :: Text -> Text

stripParensSym :: Symbol -> Symbol

desugarModule :: TypecheckedModule -> Ghc DesugaredModule

gHC_VERSION :: String

GHC Compatibility Layer ---------------------------------------------------

symbolFastString :: Symbol -> FastString

synTyConRhs_maybe :: TyCon -> Maybe Type

tcRnLookupRdrName :: HscEnv -> LocatedN RdrName -> IO (Messages DecoratedSDoc, Maybe [Name])

showCBs :: Bool -> [CoreBind] -> String

ignoreCoreBinds :: HashSet Var -> [CoreBind] -> [CoreBind]

findVarDef :: Symbol -> [CoreBind] -> Maybe (Var, CoreExpr)

findVarDefMethod :: Symbol -> [CoreBind] -> Maybe (Var, CoreExpr)

dictionarySymbols :: CoreBind -> [Symbol]

methodSymbols :: CoreBind -> [Symbol]

coreBindSymbols :: CoreBind -> [Symbol]

simplesymbol :: NamedThing t => t -> Symbol

binders :: Bind a -> [a]

expandVarType :: Var -> Type

isEmbeddedDictExpr :: CoreExpr -> Bool

The following functions test if a CoreExpr or CoreVar can be embedded in logic. With type-class support, we can no longer erase such expressions arbitrarily.

isEmbeddedDictVar :: Var -> Bool

isEmbeddedDictType :: Type -> Bool

isPrelEqPred :: Type -> Bool

isPrelEqTyCon :: TyCon -> Bool

isOrdPred :: Type -> Bool

isNumericPred :: Type -> Bool

isPredExpr :: CoreExpr -> Bool

The following functions test if a CoreExpr or CoreVar are just types in disguise, e.g. have PredType (in the GHC sense of the word), and so shouldn't appear in refinements.

isPredVar :: Var -> Bool

isPredType :: Type -> Bool

anyF :: [a -> Bool] -> a -> Bool

defaultDataCons :: Type -> [AltCon] -> Maybe [(DataCon, [TyVar], [Type])]

'defaultDataCons t ds' returns the list of '(dc, types)' pairs, corresponding to the _missing_ cases, i.e. _other_ than those in ds, that are being handled by DEFAULT.

isEvVar :: Id -> Bool

elabRnExpr :: LHsExpr GhcPs -> TcRn CoreExpr

Elaboration

newtype HashableType

Constructors

HashableType

Fields

• getHType :: Type

Instances

Outputable HashableType

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

ppr :: HashableType -> SDoc

Eq HashableType

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

(==) :: HashableType -> HashableType -> Bool

(/=) :: HashableType -> HashableType -> Bool

Ord HashableType

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

compare :: HashableType -> HashableType -> Ordering

(<) :: HashableType -> HashableType -> Bool

(<=) :: HashableType -> HashableType -> Bool

(>) :: HashableType -> HashableType -> Bool

(>=) :: HashableType -> HashableType -> Bool

max :: HashableType -> HashableType -> HashableType

min :: HashableType -> HashableType -> HashableType

canonSelectorChains :: PredType -> Map HashableType [Id]

Superclass coherence

buildCoherenceOblig :: Class -> [[([Id], [Id])]]

coherenceObligToRef :: Symbolic s => s -> [Id] -> [Id] -> Reft

coherenceObligToRefE :: Expr -> [Id] -> [Id] -> Reft

data TcWiredIn

Constructors

TcWiredIn

Fields

• tcWiredInName :: Name
• tcWiredInFixity :: Maybe (Int, FixityDirection)
• tcWiredInType :: LHsType GhcRn

withWiredIn :: TcM a -> TcM a

Run a computation in GHC's typechecking monad with wired in values locally bound in the typechecking environment.

prependGHCRealQual :: FastString -> RdrName

isFromGHCReal :: NamedThing a => a -> Bool

Orphan instances

Show Class

Methods

showsPrec :: Int -> Class -> ShowS

show :: Class -> String

showList :: [Class] -> ShowS

Show TyCon

Methods

showsPrec :: Int -> TyCon -> ShowS

show :: TyCon -> String

showList :: [TyCon] -> ShowS

Show Name

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

Show Var

Methods

showsPrec :: Int -> Var -> ShowS

show :: Var -> String

showList :: [Var] -> ShowS

NFData Class

Methods

rnf :: Class -> ()

NFData Type

Methods

rnf :: Type -> ()

NFData TyCon

Methods

rnf :: TyCon -> ()

NFData Var

Methods

rnf :: Var -> ()

Hashable Class

Methods

hashWithSalt :: Int -> Class -> Int

hash :: Class -> Int

Hashable DataCon

Methods

hashWithSalt :: Int -> DataCon -> Int

hash :: DataCon -> Int

Hashable TyCon

Methods

hashWithSalt :: Int -> TyCon -> Int

hash :: TyCon -> Int

Hashable SrcSpan

Methods

hashWithSalt :: Int -> SrcSpan -> Int

hash :: SrcSpan -> Int

Hashable Var

Methods

hashWithSalt :: Int -> Var -> Int

hash :: Var -> Int

Symbolic Class

Methods

symbol :: Class -> Symbol

Symbolic TyCon

Symbol Instances

Methods

symbol :: TyCon -> Symbol

Symbolic FastString

Methods

symbol :: FastString -> Symbol

Symbolic Name

Methods

symbol :: Name -> Symbol

Symbolic Var

NOTE:REFLECT-IMPORTS

we **eschew** the unique suffix for exported vars, to make it possible to lookup names from symbols _across_ modules; anyways exported names are top-level and you shouldn't have local binders that shadow them. However, we **keep** the unique suffix for local variables, as otherwise there are spurious, but extremely problematic, name collisions in the fixpoint environment.

Methods

symbol :: Var -> Symbol

Fixpoint Type

Methods

toFix :: Type -> Doc

simplify :: Type -> Type

Fixpoint Name

Methods

toFix :: Name -> Doc

simplify :: Name -> Name

Fixpoint Var

Methods

toFix :: Var -> Doc

simplify :: Var -> Var

Loc Var

Methods

srcSpan :: Var -> SrcSpan

Outputable a => Outputable (HashSet a)

Methods

ppr :: HashSet a -> SDoc