Safe Haskell	None

Language.Haskell.Refact.Utils.TypeUtils

Contents

Program Analysis
Program transformation
Miscellous
Typed AST traversals (added by CMB)
Miscellous
Debug stuff

Description

This module contains a collection of program analysis and transformation functions (the API) that work over the Type Decorated AST. Most of the functions defined in the module are taken directly from the API, but in some cases are modified to work with the type decorated AST.

In particular some new functions have been added to make type decorated AST traversals easier.

In HaRe, in order to preserve the comments and layout of refactored programs, a refactoring modifies not only the AST but also the token stream, and the program source after the refactoring is extracted from the token stream rather than the AST, for the comments and layout information is kept in the token steam instead of the AST. As a consequence, a program transformation function from this API modifies both the AST and the token stream (unless explicitly stated). So when you build your own program transformations, try to use the API to do the transformation, as this can liberate you from caring about the token stream.

This type decorated API is still in development. Any suggestions and comments are very much welcome.

Synopsis

Program Analysis

Imports and exports

inScopeInfo Source

Arguments

:: InScopes	The inscope relation .
-> [(String, NameSpace, ModuleName, Maybe ModuleName)]	The result

Process the inscope relation returned from the parsing and module analysis pass, and return a list of four-element tuples. Each tuple contains an identifier name, the identifier's namespace info, the identifier's defining module name and its qualifier name.

The same identifier may have multiple entries in the result because it may have different qualifiers. This makes it easier to decide whether the identifier can be used unqualifiedly by just checking whether there is an entry for it with the qualifier field being Nothing.

isInScopeAndUnqualified Source

Arguments

:: String	The identifier name.
-> InScopes	The inscope relation
-> Bool	The result.

Return True if the identifier is inscope and can be used without a qualifier.

isInScopeAndUnqualifiedGhc Source

Arguments

:: String	The identifier name.
-> Maybe Name	Existing name, to be excluded from test, if known
-> RefactGhc Bool	The result.

Return True if the identifier is inscope and can be used without a qualifier. The identifier name string may have a qualifier already NOTE: may require qualification based on name clash with an existing identifier.

inScopeNames Source

Arguments

:: String	The identifier name.
-> RefactGhc [Name]	The result.

isExported :: Name -> RefactGhc Bool Source

Return True if an identifier is exported by the module currently being refactored.

isExplicitlyExported Source

Arguments

:: Name	The identifier
-> RenamedSource	The AST of the module
-> Bool	The result

Return True if an identifier is explicitly exported by the module.

modIsExported Source

Arguments

:: ModuleName	The module name
-> RenamedSource	The AST of the module
-> Bool	The result

Return True if the current module is exported either by default or by specifying the module name in the export.

Variable analysis

isFieldName :: Name -> Bool Source

True if the name is a field name

isClassName :: Name -> Bool Source

True if the name is a field name

isInstanceName :: Name -> Bool Source

True if the name is a class instance

hsPNs :: Data t => t -> [PName]Source

Collect the identifiers (in PName format) in a given syntax phrase.

hsBinds :: HsValBinds t => t -> [LHsBind Name]Source

replaceBinds :: HsValBinds t => t -> [LHsBind Name] -> tSource

class Data t => HsValBinds t whereSource

Methods

hsValBinds :: t -> HsValBinds Name Source

Return the binds that are directly enclosed in the given syntax phrase. hsValBinds :: t -> [GHC.LHsBind GHC.Name]

replaceValBinds :: t -> HsValBinds Name -> tSource

Replace the directly enclosed bind list by the given bind list. Note: This function does not modify the token stream. replaceBinds :: t -> [GHC.LHsBind GHC.Name] -> t

hsTyDecls :: t -> [[LTyClDecl Name]]Source

Return True if the specified identifier is declared in the given syntax phrase. isDeclaredIn :: GHC.Name -> t -> Bool

Return the type class definitions that are directly enclosed in the given syntax phrase. Note: only makes sense for GHC.RenamedSource

Instances

HsValBinds RenamedSource
HsValBinds Name
HsValBinds [[LTyClDecl Name]]
HsValBinds [LMatch Name]
HsValBinds [LGRHS Name]
HsValBinds [LStmt Name]
HsValBinds [LTyClDecl Name]
HsValBinds [LFamInstDecl Name]
HsValBinds [LInstDecl Name]
HsValBinds [LHsBind Name]
HsValBinds [LSig Name]
HsValBinds [SyntaxExpr Name]
HsValBinds [LPat Name]
HsValBinds (LMatch Name)
HsValBinds (Match Name)
HsValBinds (LGRHS Name)
HsValBinds (LStmt Name)
HsValBinds (Stmt Name)
HsValBinds (HsGroup Name)
HsValBinds (LTyClDecl Name)
HsValBinds (LFamInstDecl Name)
HsValBinds (LInstDecl Name)
HsValBinds (HsLocalBinds Name)
HsValBinds (HsValBinds Name)
HsValBinds (LHsBind Name)
HsValBinds (LHsBinds Name)
HsValBinds (HsBind Name)
HsValBinds (HsIPBinds Name)
HsValBinds (LSig Name)
HsValBinds (LHsType Name)
HsValBinds (HsExpr Name)
HsValBinds (MatchGroup Name)
HsValBinds (GRHSs Name)
HsValBinds (LHsExpr Name)
HsValBinds (LPat Name)

isDeclaredIn :: HsValBinds t => Name -> t -> Bool Source

hsFreeAndDeclaredPNsOld :: Data t => t -> ([Name], [Name])Source

Collect the free and declared variables (in the GHC.Name format) in a given syntax phrase t. In the result, the first list contains the free variables, and the second list contains the declared variables. Expects RenamedSource

hsFreeAndDeclaredNameStrings :: (Data t, Outputable t) => t -> RefactGhc ([String], [String])Source

The same as hsFreeAndDeclaredPNs except that the returned variables are in the String format.

hsFreeAndDeclaredPNs :: (Data t, Outputable t) => t -> RefactGhc ([Name], [Name])Source

hsFreeAndDeclaredGhc :: (Data t, Outputable t) => t -> RefactGhc (FreeNames, DeclaredNames)Source

Collect the free and declared variables (in the GHC.Name format) in a given syntax phrase t. In the result, the first list contains the free variables, and the second list contains the declared variables. TODO: use GHC.NameSet instead of lists for FreeNames/DeclaredNames NOTE: The GHC fvs fields only carry non-GHC values, as they are used in the renaming process

getDeclaredTypes :: LTyClDecl Name -> [Name]Source

getFvs :: [LHsBind Name] -> [([Name], NameSet)]Source

Experiment with GHC fvs stuff

getFreeVars :: [LHsBind Name] -> [Name]Source

getDeclaredVars :: [LHsBind Name] -> [Name]Source

hsVisiblePNs :: (FindEntity e, Data e, Data t, HsValBinds t, Outputable e) => e -> t -> RefactGhc [Name]Source

Given syntax phrases e and t, if e occurs in t, then return those variables which are declared in t and accessible to e, otherwise return [].

hsVisibleNames :: (FindEntity t1, Data t1, Data t2, HsValBinds t2, Outputable t1) => t1 -> t2 -> RefactGhc [String]Source

Same as hsVisiblePNs except that the returned identifiers are in String format.

hsFDsFromInside :: Data t => t -> RefactGhc ([Name], [Name])Source

hsFDsFromInside is different from hsFreeAndDeclaredPNs in that: given an syntax phrase t, hsFDsFromInside returns not only the declared variables that are visible from outside of t, but also those declared variables that are visible to the main expression inside t. NOTE: Expects to be given RenamedSource

hsFDNamesFromInside :: Data t => t -> RefactGhc ([String], [String])Source

The same as hsFDsFromInside except that the returned variables are in the String format

hsVisibleDs :: (FindEntity e, Data e, Data t, HsValBinds t, Outputable e) => e -> t -> RefactGhc DeclaredNamesSource

Given syntax phrases e and t, if e occurs in t, then return those variables which are declared in t and accessible to e, otherwise return [].

Property checking

isVarId :: String -> Bool Source

Return True if a string is a lexically valid variable name.

isConId :: String -> Bool Source

Return True if a string is a lexically valid constructor name.

isOperator :: String -> Bool Source

Return True if a string is a lexically valid operator name.

isTopLevelPN :: Name -> RefactGhc Bool Source

Return True if a PName is a toplevel PName.

isLocalPN :: Name -> Bool Source

Return True if a PName is a local PName.

isNonLibraryName :: Name -> Bool Source

Return True if the name has a GHC.SrcSpan, i.e. is declared in source we care about

isQualifiedPN :: Name -> RefactGhc Bool Source

Return True if a PName is a qualified PName. AZ:NOTE: this tests the use instance, the underlying name may be qualified. e.g. used name is zip, GHC.List.zip NOTE2: not sure if this gives a meaningful result for a GHC.Name

isFunOrPatName :: Data t => Name -> t -> Bool Source

Return True if a PName is a function/pattern name defined in t.

isTypeSig :: Located (Sig a) -> Bool Source

Return True if a declaration is a type signature declaration. isTypeSig ::HsDeclP->Bool isTypeSig (TiDecorate.Dec (HsTypeSig loc is c tp))=True

isFunBindP :: HsDeclP -> Bool Source

Return True if a declaration is a function definition.

isFunBindR :: LHsBind t -> Bool Source

isPatBindP :: HsDeclP -> Bool Source

Returns True if a declaration is a pattern binding.

isPatBindR :: LHsBind t -> Bool Source

isSimplePatBind :: Data t => LHsBind t -> Bool Source

Return True if a declaration is a pattern binding which only defines a variable value.

isComplexPatBind :: LHsBind Name -> Bool Source

Return True if a declaration is a pattern binding but not a simple one.

isFunOrPatBindP :: HsDeclP -> Bool Source

Return True if a declaration is a function/pattern definition.

isFunOrPatBindR :: LHsBind t -> Bool Source

Return True if a declaration is a function/pattern definition.

usedWithoutQualR :: Data t => Name -> t -> Bool Source

Return True if the identifier is unqualifiedly used in the given syntax phrase. usedWithoutQualR :: GHC.Name -> GHC.ParsedSource -> Bool

isUsedInRhs :: Data t => Located Name -> t -> Bool Source

Return True if the identifier is used in the RHS if a function/pattern binding.

findPNT :: Data t => Located Name -> t -> Bool Source

Return True if the identifier occurs in the given syntax phrase.

findPN :: Data t => Name -> t -> Bool Source

Return True if the identifier occurs in the given syntax phrase.

findAllNameOccurences :: Data t => Name -> t -> [Located Name]Source

Find all occurrences with location of the given name

findPNs :: Data t => [Name] -> t -> Bool Source

Return True if any of the specified PNames ocuur in the given syntax phrase.

findEntity :: (FindEntity a, Data b, Typeable b) => a -> b -> Bool Source

Returns True is a syntax phrase, say a, is part of another syntax phrase, say b. NOTE: very important: only do a shallow check

findEntity' :: (Data a, Data b) => a -> b -> Maybe (SimpPos, SimpPos)Source

sameOccurrence :: Located t -> Located t -> Bool Source

Return True if syntax phrases t1 and t2 refer to the same one.

defines :: Name -> LHsBind Name -> Bool Source

Return True if the function/pattern binding defines the specified identifier.

definesP :: PName -> HsDeclP -> Bool Source

definesTypeSig :: Name -> LSig Name -> Bool Source

Return True if the declaration defines the type signature of the specified identifier.

sameBind :: LHsBind Name -> LHsBind Name -> Bool Source

class Data t => UsedByRhs t whereSource

Methods

usedByRhs :: t -> [Name] -> Bool Source

Return True if any of the GHC.Name's appear in the given syntax element

Instances

Modules and files

isMainModule :: Module -> Bool Source

getModule :: RefactGhc Module Source

Locations

defineLoc :: Located Name -> SrcLoc Source

Return the identifier's defining location. defineLoc::PNT->SrcLoc

useLoc :: Located Name -> SrcLoc Source

Return the identifier's source location. useLoc::PNT->SrcLoc

locToExp Source

Arguments

:: (Data t, Typeable n)
=> SimpPos	The start position.
-> SimpPos	The end position.
-> t	The syntax phrase.
-> Maybe (Located (HsExpr n))	The result.

Given the syntax phrase, find the largest-leftmost expression contained in the region specified by the start and end position, if found.

locToName Source

Arguments

:: Data t
=> SimpPos	The row and column number
-> t	The syntax phrase
-> Maybe (Located Name)	The result

Find the identifier(in GHC.Name format) whose start position is (row,col) in the file specified by the fileName, and returns Nothing if such an identifier does not exist.

locToRdrName Source

Arguments

:: Data t
=> SimpPos	The row and column number
-> t	The syntax phrase
-> Maybe (Located RdrName)	The result

Find the identifier(in GHC.RdrName format) whose start position is (row,col) in the file specified by the fileName, and returns Nothing if such an identifier does not exist.

getName Source

Arguments

:: Data t
=> String	The name to find
-> t	The syntax phrase
-> Maybe Name	The result

Find the identifier with the given name. This looks through the given syntax phrase for the first GHC.Name which matches. Because it is Renamed source, the GHC.Name will include its defining location. Returns Nothing if the name is not found.

Program transformation

Adding

addDecl Source

Arguments

:: (Data t, HsValBinds t)
=> t	The AST to be updated
-> Maybe Name	If this is Just, then the declaration will be added right after this identifier's definition.
-> (LHsBind Name, [LSig Name], Maybe [PosToken])	The declaration with optional signatures to be added, in both AST and Token stream format (optional). If signature and tokens provided, the tokens should include the signature too
-> Bool	True means the declaration is a toplevel declaration.
-> RefactGhc t

Adding a declaration to the declaration list of the given syntax phrase. If the second argument is Nothing, then the declaration will be added to the beginning of the declaration list, but after the data type declarations is there is any.

addItemsToImport Source

Arguments

:: ModuleName	The imported module name
-> RenamedSource	The current module
-> [Name]	The items to be added ->Maybe GHC.Name -- ^ The condition identifier.
-> RefactGhc RenamedSource	The result (with token stream updated)

Add identifiers (given by the third argument) to the explicit entity list in the declaration importing the specified module name. This function does nothing if the import declaration does not have an explicit entity list.

addHiding Source

Arguments

:: ModuleName	The imported module name
-> RenamedSource	The current module
-> [Name]	The items to be added
-> RefactGhc RenamedSource	The result (with token stream updated)

add items to the hiding list of an import declaration which imports the specified module.

addParamsToDecls Source

Arguments

:: [LHsBind Name]	A declaration list where the function is defined and/or used.
-> Name	The function name.
-> [Name]	The parameters to be added.
-> Bool	Modify the token stream or not.
-> RefactGhc [LHsBind Name]	The result.

addActualParamsToRhs :: (Typeable t, Data t) => Bool -> Name -> [Name] -> t -> RefactGhc tSource

addImportDecl Source

Arguments

:: RenamedSource
-> ModuleName
-> Maybe FastString	qualifier
-> Bool
-> Bool
-> Bool
-> Maybe String	alias
-> Bool
-> [Name]
-> RefactGhc RenamedSource

Add identifiers to the export list of a module. If the second argument is like: Just p, then do the adding only if p occurs in the export list, and the new identifiers are added right after p in the export list. Otherwise the new identifiers are add to the beginning of the export list. In the case that the export list is emport, then if the third argument is True, then create an explict export list to contain only the new identifiers, otherwise do nothing.

duplicateDecl Source

Arguments

:: Data t
=> [LHsBind Name]	The declaration list
-> t	Any signatures are in here
-> Name	The identifier whose definition is to be duplicated
-> Name	The new name (possibly qualified)
-> RefactGhc [LHsBind Name]	The result

Remove those specified items from the entity list in the import declaration.

Remove the specified entities from the module's exports. The entities can be specified in either of two formats: i.e. either specify the module names and identifier names to be removed, so just given the exact AST for these entities.

Duplicate a function/pattern binding declaration under a new name right after the original one. Also updates the token stream.

Removing

rmDecl Source

Arguments

:: Data t
=> Name	The identifier whose definition is to be removed.
-> Bool	True means including the type signature.
-> t	The declaration list.
-> RefactGhc (t, LHsBind Name, Maybe (LSig Name))	The result and the removed declaration, with SrcSpans adjusted to reflect the stashed tokens and the possibly removed siganture

Remove the declaration (and the type signature is the second parameter is True) that defines the given identifier from the declaration list.

rmTypeSig Source

Arguments

:: Data t
=> Name	The identifier whose type signature is to be removed.
-> t	The declarations
-> RefactGhc (t, Maybe (LSig Name))	The result and removed signature, if there was one

Remove the type signature that defines the given identifier's type from the declaration list.

rmTypeSigs Source

Arguments

:: Data t
=> [Name]	The identifiers whose type signatures are to be removed.
-> t	The declarations
-> RefactGhc (t, [LSig Name])	The result and removed signatures, if there were any

Remove multiple type signatures

Updating

rmQualifier Source

Arguments

:: Data t
=> [Name]	The identifiers.
-> t	The syntax phrase.
-> RefactGhc t	The result.

Remove the qualifier from the given identifiers in the given syntax phrase.

qualifyToplevelName :: Name -> RefactGhc ()Source

Replace all occurences of a top level GHC.Name with a qualified version.

renamePN Source

Arguments

:: Data t
=> Name	The identifier to be renamed.
-> Name	The new name, including possible qualifier
-> Bool	True means modifying the token stream as well.
-> Bool	True means use the qualified form for the new name.
-> t	The syntax phrase
-> RefactGhc t

Rename each occurrences of the identifier in the given syntax phrase with the new name. If the Bool parameter is True, then modify both the AST and the token stream, otherwise only modify the AST. TODO: the syntax phrase is required to be GHC.Located, not sure how to specify this without breaking the everywhereMStaged call

autoRenameLocalVar Source

Arguments

:: HsValBinds t
=> Bool	True means modfiying the token stream as well.
-> Name	The identifier.
-> t	The syntax phrase.
-> RefactGhc t	The result.

Check whether the specified identifier is declared in the given syntax phrase t, if so, rename the identifier by creating a new name automatically. If the Bool parameter is True, the token stream will be modified, otherwise only the AST is modified.

Miscellous

Parsing, writing and showing

showEntities :: (t -> String) -> [t] -> String Source

Show a list of entities, the parameter f is a function that specifies how to format an entity.

showPNwithLoc :: Located Name -> String Source

Show a PName in a format like: pn(at row:r, col: c).

Locations

Default values

defaultPN :: PName Source

defaultName :: Name Source

defaultExp :: HsExpP Source

Default expression.

Identifiers, expressions, patterns and declarations

ghcToPN :: RdrName -> PName Source

lghcToPN :: Located RdrName -> PName Source

expToName :: Located (HsExpr Name) -> Name Source

If an expression consists of only one identifier then return this identifier in the GHC.Name format, otherwise return the default Name

nameToString :: Name -> String Source

patToPNT :: LPat Name -> Maybe Name Source

If a pattern consists of only one identifier then return this identifier, otherwise return Nothing

pNtoPat :: Name -> Pat Name Source

Compose a pattern from a pName.

definedPNs :: LHsBind Name -> [Name]Source

Return the list of identifiers (in PName format) defined by a function/pattern binding.

definingDeclsNames Source

Arguments

:: [Name]	The specified identifiers.
-> [LHsBind Name]	A collection of declarations.
-> Bool	True means to include the type signature.
-> Bool	True means to look at the local declarations as well.
-> [LHsBind Name]	The result.

Find those declarations(function/pattern binding) which define the specified GHC.Names. incTypeSig indicates whether the corresponding type signature will be included.

definingDeclsNames'Source

Arguments

:: Data t
=> [Name]	The specified identifiers.
-> t	A collection of declarations.
-> [LHsBind Name]	The result.

Find those declarations(function/pattern binding) which define the specified GHC.Names. incTypeSig indicates whether the corresponding type signature will be included.

definingSigsNames Source

Arguments

:: Data t
=> [Name]	The specified identifiers.
-> t	A collection of declarations.
-> [LSig Name]	The result.

Find those type signatures for the specified GHC.Names.

allNames Source

Arguments

:: Data t
=> t	The syntax phrase
-> [Located Name]	The result

Find all Located Names in the given Syntax phrase.

Others

mkRdrName :: String -> RdrName Source

mkNewGhcName :: Maybe Module -> String -> RefactGhc Name Source

Make a new GHC.Name, using the Unique Int sequence stored in the RefactState.

mkNewName Source

Arguments

:: String	The old name
-> [String]	The set of names which the new name cannot take
-> Int	The posfix value
-> String	The result

Create a new name base on the old name. Suppose the old name is f, then the new name would be like f_i where i is an integer.

mkNewToplevelName :: Module -> String -> SrcSpan -> RefactGhc Name Source

causeNameClashInExports Source

Arguments

:: Name	The original name
-> Name	The new name
-> ModuleName	The identity of the module
-> RenamedSource	The AST of the module
-> Bool	The result

Check if the proposed new name will conflict with an existing export

prettyprint :: Outputable a => a -> String Source

prettyprint2 :: Outputable a => a -> String Source

removeOffset :: Int -> [PosToken] -> [PosToken]Source

Remove at most offset whitespaces from each line in the tokens

Typed AST traversals (added by CMB)

Miscellous

Debug stuff

getDeclAndToks :: HsValBinds t => Name -> Bool -> [PosToken] -> t -> ([LHsBind Name], [PosToken])Source

getSigAndToks :: Data t => Name -> t -> [PosToken] -> Maybe (LSig Name, [PosToken])Source

Get the signature and tokens for a declaration

getToksForDecl :: Data t => t -> [PosToken] -> [PosToken]Source

removeToksOffset :: [PosToken] -> [PosToken]Source

Normalise a set of tokens to start at the offset of the first one

getParsedForRenamedLPat :: ParsedSource -> LPat Name -> LPat RdrName Source

Given a RenamedSource LPAT, return the equivalent ParsedSource part. NOTE: returns pristine ParsedSource, since HaRe does not change it

getParsedForRenamedName :: ParsedSource -> Located Name -> Located RdrName Source

Given a RenamedSource Located name, return the equivalent ParsedSource part. NOTE: returns pristine ParsedSource, since HaRe does not change it

getParsedForRenamedLocated :: Typeable b => Located a -> RefactGhc (Located b)Source

Given a RenamedSource Located name, return the equivalent ParsedSource part. NOTE: returns pristine ParsedSource, since HaRe does not change it

newNameTok :: Bool -> SrcSpan -> Name -> PosToken Source

Create a new name token. If useQual then use the qualified name, if it exists. The end position is not changed, so the eventual realignment can know what the difference in length in the token is

stripLeadingSpaces :: [String] -> [String]Source

Take a list of strings and return a list with the longest prefix of spaces removed

UsedByRhs RenamedSource
UsedByRhs [LHsBind Name]
UsedByRhs (Match Name)
UsedByRhs (Stmt Name)
UsedByRhs (HsValBinds Name)
UsedByRhs (LHsBind Name)
UsedByRhs (LHsBinds Name)
UsedByRhs (HsBind Name)
UsedByRhs (HsExpr Name)